TRELLIS.2 da Microsoft é impressionante: de uma foto a um modelo 3D completo (eu testei)

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Microsoft’s TRELLIS.2 Is INSANE: One Photo to a Full 3D Model (I Ran It) · Canal: Prompt Engineer 48 · 09:23 · Assistir no YouTube

Tópicos: Geração de conteúdo com IA, Infraestrutura e hardware de IA, Modelos locais e open source, Modelos multimodais

Resumo

O vídeo apresenta o TRELLIS.2, um modelo open source da Microsoft que transforma uma imagem em um modelo 3D com materiais PBR. O apresentador explica a representação baseada em voxels, relata tempos de geração e uso de memória em uma GPU L40S e mostra que os resultados podem incluir detalhes e partes traseiras que não aparecem na imagem original. Também descreve os obstáculos de instalação, como requisitos de GPU, modelos com acesso restrito e conflitos entre versões de dependências. A conclusão é que a ferramenta é promissora para protótipos e assets de jogos, mas ainda exige trabalho para uso em produção e para obter topologia pronta para animação.

Pontos-chave

TRELLIS.2 gera modelos 3D a partir de imagens e pode produzir materiais PBR em resoluções de 512 a 1536³.
Em vez de representar o objeto como um campo contínuo, o modelo usa voxels para armazenar geometria e material nas células ocupadas.
O teste em uma GPU L40S de 48 GB levou cerca de 70 segundos em 1024 e 149 segundos em 1536, sem contar todo o tempo de preparação e exportação.
Nos exemplos testados, o modelo produziu detalhes nítidos e partes traseiras coerentes, embora essas partes não estivessem visíveis na imagem de entrada.
A exportação reduz a malha a 1 milhão de faces e gera arquivos GLB de cerca de 42 MB, mas a topologia pode exigir retopologia para animação.
A instalação foi feita em Linux e envolveu dependências com versões específicas, submódulos e modelos com acesso restrito no Hugging Face.
O apresentador não testou casos difíceis, como garrafas transparentes ou pessoas, e não considera comprovada a superioridade em relação a outros modelos.
O vídeo recomenda cautela para uso em produção, pois o repo não tinha releases e a página indicava uso acadêmico.

Capítulos

Início	Capítulo	Resumo
00:00	O que é o TRELLIS.2	O vídeo apresenta o modelo, seus materiais PBR e o contexto do lançamento e do repo.
01:32	Como o modelo representa objetos 3D	O apresentador explica a representação por voxels, a compressão com sparse VAE e os tempos de geração anunciados e medidos.
03:08	Resultados, qualidade e exportação	São comparados tempos e uso de memória, e o vídeo mostra a qualidade dos modelos e o processo de exportação para GLB.
05:16	Como executar o modelo	O vídeo percorre as etapas do exemplo, explica as opções cascade e relata dificuldades com dependências e acesso aos modelos.
08:22	Limitações e conclusão	O apresentador reúne ressalvas sobre a instalação, a topologia e a avaliação comparativa, e recomenda o modelo para protótipos, não para produção imediata.

Citações

Uma foto de um motor steampunk e este é o modelo 3D que o TRELLIS.2 da Microsoft fez a partir dela. — 00:00

Como não há uma regra de dentro versus fora, ele pode lidar com superfícies abertas, geometria não manifold e estruturas internas fechadas. — 02:04

A qualidade é o verdadeiro destaque. — 03:38

Cada problema que encontrei era de versão ou de acesso, não de um modelo quebrado. — 08:22

Para um lançamento de pesquisa, o resultado é realmente impressionante. — 09:23

Conceitos e entidades

TRELLIS.2 (modelo): Modelo da Microsoft que gera assets 3D com materiais PBR a partir de imagens.
Microsoft (empresa): Empresa responsável pelo lançamento do TRELLIS.2.
voxel (conceito): Célula de uma grade tridimensional usada pelo TRELLIS.2 para armazenar a geometria e o material do objeto.
PBR (conceito): Abordagem de materiais que mantém propriedades como cor-base, rugosidade, metalicidade e opacidade em camadas separadas.
sparse VAE (conceito): Componente que comprime a representação voxelizada para reduzir a quantidade de informação processada pelo gerador.
Hugging Face (ferramenta): Plataforma onde o vídeo consulta a página do modelo e obtém os pesos necessários para executá-lo.
GLB (conceito): Formato de arquivo usado para exportar o modelo 3D e suas texturas.
RunPod (empresa): Serviço de aluguel de GPUs mencionado pelo apresentador para executar o modelo na nuvem.

Tradução completa (pt-BR)

00:00 Esta é uma foto de um motor steampunk, e este é o modelo 3D que o TRELLIS.2 da Microsoft fez a partir dela, em uma GPU que aluguei: com metal de verdade, roughness de verdade e uma parte de trás de verdade que ele nunca viu. Então, como ele faz isso? Quanto tempo levou na minha execução? E você consegue rodá-lo por conta própria? Vamos ver. >> [música] >> Primeiro, o que é isso? O TRELLIS.2 é um modelo de imagem para 3D open source da Microsoft. A página o descreve como um modelo de 4 bilhões de parâmetros, que cria assets com

00:31 materiais PBR completos em resoluções de 512 até 1536³. PBR significa apenas que o modelo vem com cor base, roughness, metallic e opacity em camadas separadas. Assim, uma engine de jogo ou um renderizador pode iluminá-lo corretamente, em vez de receber uma imagem já renderizada. Os autores são da Tsinghua, da Microsoft Research, da USTC e da Microsoft AI. E o artigo está no arXiv, número 2512.14692, datado de 16 de dezembro de 2025. Agora, o repo em si, porque hype e realidade são

01:02 coisas diferentes: cerca de 12,3 mil estrelas, 1,5 mil forks, licença MIT para o código e o modelo. Mas veja os detalhes: 11 commits, nenhum lançamento publicado e dois contribuidores listados. Um deles é o Copilot. Então, este é um lançamento de pesquisa, e a página até diz que é apenas para uso acadêmico. Tenha isso em mente ao pensar em colocá-lo em produção. Mas é claro que as pessoas estão usando. No Hugging Face, o modelo mostra cerca de 2,25 milhões de downloads no mês passado e 100 Spaces criados com base nele.

01:32 Essa é a página do Hugging Face capturada hoje, não um número meu. Aqui está a ideia de verdade, explicada em termos simples. A maioria dos geradores 3D descreve uma forma como um campo, uma função suave em que a superfície fica onde o valor cruza zero. Isso funciona muito bem para formas fechadas. Mas tem dificuldade com superfícies abertas, como uma folha ou um tecido com paredes finas, e com interiores ocos, porque um campo precisa decidir em toda parte o que está dentro e o que está fora. O TRELLIS.2 dispensa o campo. Ele armazena apenas as células de uma grade 3D que o objeto

02:04 realmente toca e mantém a geometria e o material juntos em cada célula. Eles chamam isso de voxel. Como não há uma regra para distinguir o que está dentro do que está fora, a página diz que ele pode lidar com superfícies abertas, geometria non-manifold e estruturas internas fechadas. E a conversão entre uma malha texturizada comum e esse formato é rápida: menos de 10 segundos em uma única CPU em uma direção e menos de 100 milissegundos em CUDA na volta. Esse é o número dos autores. Não cronometrei essa parte. Uma grade dessas é enorme. Então, o segundo truque é a compressão. Um VAE esparso a comprime 16

02:37 vezes em cada direção. Em 1024³, isso deixa cerca de 9,6 mil tokens latentes, um número pequeno o bastante para que o gerador possa ser um transformer de difusão comum, sem arquitetura exótica. Em termos simples, eles transformam um objeto esparso gigantesco em uma lista curta de tokens, deixam um transformer comum escrever essa lista com base na sua foto e, depois, decodificam a lista de volta para um modelo completo. Agora, a velocidade. O readme afirma que, em uma H100,

03:08 leva cerca de 3 segundos em 512, 17 segundos em 1024 e cerca de um minuto em 1536. Eu não tenho uma H100. Aluguei uma L40S com 48 gigabytes por cerca de US$ 1,09 por hora. Minha primeira execução em 512 levou 67 segundos, mas isso inclui o aquecimento, então não considere esse número preciso. 1024 levou cerca de 70 segundos. 1536 levou 149 segundos, aproximadamente dois minutos e meio. Então, nesta placa, é mais lento do que os números do readme para a H100, o que

03:38 faz sentido. É uma GPU menor e mais barata, mas só executei cada configuração uma vez, então considere esses números aproximados. Agora, a qualidade é a verdadeira história. Veja o passe de normais: os detalhes da superfície nas engrenagens são nítidos, e a parte de trás do motor, que a foto nunca mostrou, parece consistente com a frente. A memória foi uma surpresa. O readme diz

04:09 que você precisa de 24 GB. Meu pico em 1536 foi de 15,3 GB, e 1024 ficou entre 7 e 12 GB. Uma observação sincera sobre as entradas: estas são as imagens de exemplo incluídas no repo, não fotos que escolhi para favorecê-lo. Não o testei em um caso difícil, como uma garrafa transparente ou uma pessoa, então não posso falar sobre esses casos. Com três dessas imagens em 1024, a geração levou 70, 74 e 85 segundos. O pico de memória foi de 7,5, 7,6 e 12,1 GB. Então, o custo não é um número fixo; ele varia de acordo com

04:41 o objeto. O objeto mais complexo, com a maior quantidade de detalhes finos, levou mais tempo e usou mais memória. As malhas brutas também eram grandes. Em 1024, obtive entre 11 e 16 milhões de faces antes da limpeza. Depois, a etapa de exportação refaz a malha e reduz o número de faces para 1 milhão, com texturas de 4096 pixels, o que me deu arquivos GLB de cerca de 42 MB cada.

05:16 Se você tiver o hardware, o código é curto, e o exemplo do readme tem apenas cinco etapas. Primeiro, carregue o mapa de ambiente. Isso é apenas a iluminação da prévia. Segundo, carregue o pipeline do modelo do Hugging Face trellis.2 4 billion e mova-o para a GPU. Terceiro, abra sua imagem e chame run; você pode escolher o tipo de pipeline: 512, 1024, 1024 cascade ou 1536 cascade. Quarto, renderize um vídeo de prévia. Quinto, exporte um GLB, escolhendo o limite de faces e o tamanho da

05:46 textura. As opções cascade são importantes. Em vez de criar a resolução completa de uma vez, ele cria primeiro uma estrutura grosseira e depois a refina, e é por isso que 1536 foi viável em uma placa como a minha. Também há um modo de texturização em que você fornece uma malha que já tem e ele aplica os materiais PBR nela com base em uma imagem. Não testei esse modo, então considere isso uma afirmação, não um resultado.

06:16 Você consegue rodá-lo em casa? Meu laptop tem uma RTX 4060 com 8 GB e roda Windows, enquanto o readme diz que é só para Linux e exige 24 GB, então não. Por isso aluguei uma máquina. E, mesmo em uma máquina alugada, não bastou um comando. Dois dos arquivos do modelo têm acesso restrito no Hugging Face. Meu token funcionou para o removedor de fundo, mas não para o Dino versão 3, então usei um espelho comunitário desses pesos, algo com que você deve ter cuidado. Depois, houve quatro conflitos de versão: torch audio, transformers 5 e OpenCV 5, que não conseguia ler o arquivo de iluminação. Tudo isso tem solução, mas fixe as versões. O

06:49 primeiro carregamento do modelo, sozinho, levou cerca de 5 minutos, e exportar um GLB pronto para jogos levou mais dois a três minutos por asset, além do tempo de geração. Então, o custo total por modelo é maior do que o tempo de geração. Então, aqui está o caminho que funcionou para mim, na ordem, para você evitar meus erros. Etapa um: consiga uma GPU com pelo menos 24 GB. A minha tinha 48, e eu diria que essa é a opção confortável, porque o carregamento e a exportação precisam de margem além do pico de

07:20 geração. Etapa dois: use uma imagem CUDA 12.4 com as ferramentas de desenvolvimento, porque as extensões são compiladas durante a instalação. Usei uma imagem do PyTorch no Ubuntu 22. Etapa três: clone o repo com a flag recursiva, porque ele baixa submódulos como Eigen para o código de voxels. Etapa quatro: instale torch 2.6 com CUDA 12.4 e, em seguida, execute o script de configuração com as flags para os componentes básicos, flash attention, nvdiffrast, CUMESH, OVoxel e FlexiGAM. Essa é a

07:51 etapa que compila o kernel personalizado, então dê tempo a ela. Etapa cinco: resolva a questão dos modelos com acesso restrito. Solicite acesso no Hugging Face ao Dino versão três e ao removedor de fundo e faça login com um token. Se o acesso ainda estiver pendente, você vai esbarrar na mesma barreira 403 que eu. Etapa seis: fixe as versões. No meu caso, isso significou usar uma versão compatível do torch audio, uma versão mais antiga do transformers que tenha o atributo layer esperado pelo repo e uma versão mais antiga do OpenCV, para que o arquivo de iluminação carregue. E etapa sete: execute o script de exemplo e aguarde o primeiro carregamento do modelo. Tenha paciência.

08:22 Isso só é lento uma vez; depois, é rápido. Se uma etapa falhar, leia o erro de verdade antes de reinstalar tudo. Todos os meus problemas eram de versão ou de acesso, não de um modelo quebrado. Coisas que você deve saber antes de ficar empolgado: as exportações GLB são opacas por padrão, então a transparência precisa ser configurada manualmente. Linux é a plataforma testada. E a página do projeto mostra um gráfico de qualidade, mas não cita nenhum

08:52 modelos concorrentes, então não posso dizer que ele supera qualquer coisa. Só posso dizer o que fez com minhas cinco imagens. Então, para quem é isso? Se você cria jogos ou protótipos e precisa de muitos objetos provisórios, mas bem iluminados, rapidamente, alguns minutos por recurso em uma placa alugada saem barato. A cerca de US$ 1,09 por hora, um recurso levou aproximadamente 4 minutos em 1024 e cerca de 6 minutos em 1536 para gerar e exportar, o que dá aproximadamente de 7 a 10 centavos por modelo depois que o modelo é carregado. Essa é a minha conta com base nesta execução, não uma promessa. Se você precisa de uma topologia limpa,

09:23 pronta para animação, lembre-se de que o que você obtém é uma malha no estilo de uma digitalização com 1 milhão de faces, não algo feito por um artista. Provavelmente, você ainda vai precisar refazer a topologia. Meu veredito sobre um lançamento de pesquisa: o resultado é realmente impressionante e funciona em uma GPU de nuvem intermediária, não apenas em uma monstruosidade de data center. Para um pipeline de produção, eu esperaria por novos lançamentos e por uma instalação mais simples. Se você está procurando GPUs baratas e confiáveis, eu uso RunPod; o link está na descrição. Se tiver uma foto que queira que eu processe, coloque-a nos comentários. Obrigado por assistir.

Transcrição original

[00:00] This is one picture of a steampunk engine and this is the 3D model Microsoft’s trellis.2 made from it on a GPU I rented with real metal, real roughness, and a real backside it never saw. So, how does it actually do that? How long did it take on my run? And can you run it yourself? Let’s go through it. >> [music] >> First, what is it? trellis.2 is an open-source image to 3D model from Microsoft. The page calls it a 4 billion parameter model and it makes assets with

[00:31] full PBR materials at resolutions from 512 up to 1536 cubed. PBR just means the model comes with base color, roughness, metallic, and opacity as separate layers. So, a game engine or a renderer can light it properly instead of getting a baked-in picture. The authors are from Tsinghua Microsoft Research, USTC, and Microsoft AI. And the paper is on archive number 2512.14692 dated December 16th, 2025. Now, the repo itself, because hype and reality are

[01:02] different things about 12.3 thousand stars, 1.5 thousand forks, MIT license for the code and the model. But, look at the details. 11 commits, no releases published, and two contributors listed. One of them is co-pilot. So, this is a research release and the page even says academic use only. Keep that in mind when you think about putting it in production. But, people are clearly using it. On Hugging Face, the model shows about 2.25 million downloads last month and 100 spaces built on top of it.

[01:32] That’s the Hugging Face page captured today, not my number. Here’s the actual idea in normal words. Most 3D generators describe a shape as a field, a smooth function where the surface is wherever the value crosses zero. That works great for closed blobs. It struggles with open surfaces like a leaf or a cloth with thin walls and with hollow insides because a field has to decide inside versus outside everywhere. Trellis.2 skips the field. It stores only the cells of a 3D grid that the object

[02:04] actually touches and in each cell it keeps the geometry and the material together. They call it a voxel. Because there’s no inside versus outside rule, the page says it can handle open surfaces, non-manifold geometry, and enclosed internal structures. And converting between a normal textured mesh and this format is fast under 10 seconds on a single CPU one way and under 100 milliseconds on coda coming back. That’s the author’s number. I did not time that part. A grid like that is huge. So, the second trick is compression. A sparse VAE squeezes it 16

[02:37] times in each direction. At 1024 cubed that leaves about 9.6 thousand latent tokens, which is small enough that the generator can be a plain diffusion transformer, no exotic architecture. Plain English, they turn a giant sparse object into a short list of tokens, let a normal transformer write that list from your photo, then decode the list back into a full model. Now speed. The readme claims on an H100

[03:08] about 3 seconds at 512, 17 seconds at 1024, and about a minute at 1536. I don’t have an H100. I rented an L40S with 48 gigabytes for about a dollar nine an hour. My first run at 512 took 67 seconds, but that includes warm up, so don’t treat it as a clean number. 1024 took about 70 seconds. 1536 took 149 seconds, roughly two and a half minutes. So, on this card it’s slower than the readme’s H100 numbers, which

[03:38] makes sense. It’s a smaller and cheaper GPU, but I only ran each setting once, so call these ballpark. Now the quality is the real story. Look at the normal pass, the surface detail on the gears is sharp and the back of the engine, which the photo never showed, looks consistent with the front. Memory was a surprise. The readme says

[04:09] you need 24 GB. My peak at 1536 was 15.3 and 1024 stayed between 7 and 12. One honest note on inputs, these are the example images that ship inside the repo, not photos I picked to flatter it. I didn’t test it on a hard case like a transparent bottle or a person, so I can’t speak to those. On three of those images and 1024, generation took 70, 74, and 85 seconds. Peak memory was 7 and 1/2, 7.6, and 12.1 GB. So, the cost isn’t one fixed number, it moves with

[04:41] the object. The busiest object, the one with the most fine structure, took the longest and used the most memory. The raw meshes were big, too. At 1024, I got between 11 and 16 million faces before cleanup. The export step then remeshes and decimates down to 1 million faces with 4096 pixel textures, and that gave me GLB files around 42 MB each.

[05:16] If you do have the hardware, the code is short, and the readme example is only five step. One, load the environment map. That’s just the lighting for the preview. Two, load the pipeline from the huggingface model trellis.2 4 billion and move it to the GPU. Three, open your image and call run, and you can pick the pipeline type 512, 1024, 1024 cascade, or 1536 cascade. Four, render a preview video. Five, export a GLB, where you choose the face budget and the texture

[05:46] size. The cascade options matter. Instead of making the full resolution in one go, it makes a coarse structure first and refines it, which is why 1536 was affordable at all on a card like mine. There’s also a texturing mode where you give it a mesh you already have and it paints the PBR materials onto it from a picture. I didn’t test that one, so treat it as a claim, not a result.

[06:16] Can you run it at home? My laptop has an RTX 4060 with 8 GB on Windows and the readme says Linux only and 24 GB, so no. That’s why I rented a pod. And even on a pod, it was not one command. Two of the model files are gated on Hugging Face. My token worked for the background remover, but not for Dino version 3, so I used a community mirror of those weights, which you should be careful with. Then four version clashes, torch audio, transformers, five, OpenCV, five, that could not read the lighting file, all fixable, but pin your versions. The

[06:49] first model load alone took about 5 minutes and exporting a game-ready GLB took two to three minutes per asset on top of generation. So, the full cost per model is more than the generation number. So, here’s the path that worked for me in order, so you can skip my mistakes. Step one, get a GPU with at least 24 GB. Mine was 48 and I’d say that’s the comfortable choice because the load and the export both want headroom beyond the

[07:20] generation peak. Step two, use a Suo Day 12.4 image with the development tools because the extensions compile on install. I used a PyTorch image on Ubuntu 22. Step three, clone the repo with the recursive flag because it pulls in submodules like Eigen for the voxel code. Step four, install torch 2.6 with CUDA 12.4 and then run the setup script with the flags for basics, flash attention, and NVIDIFR NVIDIFRAG, CUMESH, OVoxel, and FlexiGAM. That’s the

[07:51] one that builds the custom kernel, so give it time. Step five, deal with the gated models. Request access on Hugging Face for Dino version three and for the background remover, and login with a token. If access is pending, you’ll hit the same 403 wall I did. Step six, pin your versions. For me, that meant a matching torch audio and older transformers that has the layer attribute the repo expects, and an older OpenCV, so the lighting file loads. And step seven, run the example script and watch the first model load. Be patient.

[08:22] It’s slow once, and after that, it’s fast. If a step fails, read the actual error before you reinstall everything. Every one of mine was a version or an access problem, not a broken model. Things to know before you get excited. GLB exports are opaque by default, so transparency needs manual wiring. Linux is the tested platform. And the project page shows a quality chart, but names no

[08:52] competing models, so I can’t tell you it beats anything. I can only tell you what it did on my five images. So, who is this for? If you make games or prototypes, and you need lots of rough but well-lit props fast, a couple of minutes per asset on a rented card is cheap. At about a dollar nine an hour, one asset took me roughly 4 minutes at 1024, and about six at 1536 generation plus export, which is around 7 to 10 cents per model once the model is loaded. That’s my arithmetic from this run, not a promise. If you need clean,

[09:23] animation-ready topology, remember what you get is a 1 million face scan style mesh, not something an artist built. You will probably still retopologize it. My verdict for a research release, the output is genuinely impressive, and it fits on a mid-range cloud GPU, not just a data center monster. For a production pipeline, I’d wait for releases and a cleaner install. If you’re looking for cheap and reliable GPUs, I use RunPod and the link is in the description. If you have a photo you want me to run through it, drop it in the comments. Thanks for watching.