A NVIDIA eliminou o VAE e o encoder de visão: conheça o PixelUMM

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: NVIDIA Just Deleted the VAE and the Vision Encoder (PixelUMM Explained) · Canal: Prompt Engineer 48 · 05:11 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Geração de conteúdo com IA, Modelos de IA, Modelos multimodais

Resumo

O vídeo apresenta o PixelUMM, um modelo da NVIDIA que processa imagens e vídeos diretamente em pixels, sem VAE nem encoder de visão. Ele usa patches de pixels e um transformer com especialistas para compreensão e geração, compartilhando a mesma self-attention. O apresentador destaca resultados experimentais sobre tamanho dos patches, cabeças de saída e escalabilidade, além de comparar o desempenho em benchmarks de compreensão de imagens. O modelo ainda tem limitações de geração e uma licença de pesquisa não comercial, mas aponta para a possibilidade de modelos visuais mais unificados.

Pontos-chave

O PixelUMM recebe e gera pixels diretamente, sem usar VAE ou encoder de visão.
Imagens são divididas em patches de 16 × 16; para vídeos, o modelo usa tubos de quatro frames por 16 × 16 pixels.
O transformer tem especialistas para compreensão e geração que compartilham a self-attention.
Os experimentos indicam que patches menores facilitam o aprendizado da geração.
Uma cabeça convolucional com pixel shuffle reduz artefatos de grade, mas exige mais computação.
O modelo é competitivo em algumas tarefas de compreensão, mas fica atrás de referências em benchmarks mais difíceis.
A geração ainda pode apresentar anatomia incorreta, contagens imprecisas e movimento fisicamente implausível.
O checkpoint tem licença de pesquisa não comercial, e o treinamento requer pelo menos sete GPUs com 48 GB cada, segundo o repo.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do PixelUMM e dos componentes tradicionais	O vídeo introduz o modelo e explica o papel do VAE e do ViT nos sistemas de imagem e vídeo.
01:32	Como o PixelUMM processa pixels diretamente	O apresentador descreve os patches de imagem e os tubos de vídeo, além da arquitetura com especialistas compartilhando self-attention.
02:34	Resultados de geração e escolhas de arquitetura	São mostrados exemplos gerados e discutidos experimentos com tamanho dos patches, cabeças de saída e treinamento em espaço de pixels.
03:35	Benchmarks e limitações	O vídeo compara o desempenho em tarefas de compreensão e aponta problemas na geração e as restrições da licença.
04:40	Requisitos e possíveis implicações	O apresentador comenta os requisitos de hardware e considera como a abordagem poderia simplificar modelos visuais futuros.

Citações

Um modelo, pixels brutos, compreensão e geração de imagens e vídeos. — 00:00

A resposta do PixelUMM é simples: ignorar os dois e inserir os pixels diretamente. — 01:32

Pixels entram, pixels saem. — 02:34

O objetivo não é vencer todos os benchmarks. É chegar perto com um único modelo sem encoder. — 04:09

Sem VAE, sem encoder de visão, apenas pixels. — 05:11

Conceitos e entidades

PixelUMM (modelo): Modelo visual apresentado no vídeo, projetado para compreender e gerar imagens e vídeos diretamente em pixels.
NVIDIA (empresa): Empresa apontada no vídeo como responsável pelo lançamento do PixelUMM.
VAE (conceito): Autoencoder variacional que comprime imagens ou vídeos em latentes e os reconstrói em pixels.
ViT (conceito): Vision transformer que divide imagens em patches e os transforma em características para compreensão.
Qwen3 8B (modelo): Modelo citado como base do transformer decoder-only usado pelo PixelUMM.
GitHub (ferramenta): Plataforma onde, segundo o vídeo, está disponível o código do projeto.
Hugging Face (empresa): Plataforma indicada no vídeo como local de hospedagem do checkpoint.

Tradução completa (pt-BR)

00:00 Certo, a Nvidia acabou de lançar o PixelUmm, que descarta completamente o VAE e o encoder de visão. Um modelo, pixels brutos, compreensão e geração de imagens e vídeos. Vamos entender como funciona. Mas, antes da teoria, veja isto. Tudo o que você vê na tela foi gerado por esse único modelo diretamente a partir de um prompt de texto: 4 segundos, 24 quadros por segundo. E vale lembrar: não há nenhum VAE decodificando nada disso. Então, para entender por que isso é tão importante, precisamos falar de duas coisas das quais quase todo modelo de imagem e vídeo depende:

00:30 um VAE e um ViT. Vamos começar pelo básico. Um VAE, ou autoencoder variacional, é basicamente um compressor. Um vídeo é enorme, com milhões de pixels por quadro, então o modelo primeiro o comprime em uma pequena grade oculta chamada latentes, faz todo o trabalho ali e, no fim, um decodificador expande os latentes de volta em pixels. Então, como você pode ver, o VAE é um modelo separado, treinado separadamente, que fica no início e no fim do processo. O problema é que o gerador nunca pode

01:01 criar texturas finas, textos pequenos ou bordas nítidas além do que o VAE consegue representar. O VAE se torna um limite para a qualidade e é mais uma coisa para treinar, armazenar e manter sincronizada. Agora, o ViT, um transformer de visão, atua no lado da compreensão. Quando você pergunta a um modelo o que há em uma imagem, primeiro a imagem passa por um encoder de visão. Ele divide a imagem em patches e os transforma em características que o modelo de linguagem consegue ler. Mais uma vez, é um modelo pré-treinado separado, com suas próprias limitações. Então, um modelo unificado típico de hoje tem um ViT para compreender, um VAE para

01:32 gerar e um modelo de linguagem no meio, unindo tudo. Três partes, três conjuntos de concessões. A resposta do PixelUmm é simples: ignore os dois e insira diretamente os pixels. Uma imagem é dividida em patches de 16 por 16. Cada patch contém 768 números brutos, e uma única camada linear os transforma em um token. Para vídeo, a unidade é um tubo de quatro quadros por 16 por 16, ou seja, 3.072 valores. Uma camada linear, um token. Esse é todo o frontend. Depois, esses tokens entram em um transformer somente decodificador, baseado no Qwen

02:04 3 8B, com 36 camadas. Agora, vem a parte interessante. Se você olhar o diagrama, há dois especialistas. O especialista em compreensão processa texto e pixels limpos, e o especialista em geração processa pixels ruidosos, mas os dois compartilham a mesma autoatenção. Assim, tudo se comunica com tudo em uma única sequência. O total é de cerca de 15,2 bilhões de parâmetros. Para compreensão, a cabeça de linguagem gera texto, como uma descrição de vídeo; para geração, uma cabeça linear prevê diretamente pixels limpos, removendo o ruído ao longo de 35 etapas. Não há espaço latente em lugar nenhum. Entram pixels,

02:34 saem pixels. E aqui está o resultado: uma raposa ao amanhecer, um golden retriever ao vento, uma lontra surfando e uma rua de Tóquio iluminada por néons. Todos esses vídeos têm 832 por 464 e 96 quadros, e foram gerados apenas com um prompt de texto. Agora, se quiser se aprofundar, o artigo traz resultados bem interessantes. Vamos ver alguns. Primeiro, o tamanho do patch. Eles compararam patches de 16 por 16 com patches de 32 por 32, e os de 16 mantêm a perda de treinamento mais baixa. A conclusão é que comprimir mais a imagem torna a geração mais difícil de aprender. Para vídeo, eles escolheram 16

03:05 no espaço por quatro no tempo. Segundo, a cabeça de saída. Uma cabeça linear simples tem um problema: com guidance alto, é possível ver a grade de 16 pixels em áreas lisas, como o céu ou uma parede. Eles testaram cabeças convolucionais com pixel shuffle, que resolveram isso, e o melhor equilíbrio custa cerca de 9,6 vezes mais computação nessa cabeça. Um detalhe interessante: os checkpoints disponibilizados ainda usam a cabeça linear simples, porque a mudança exige mais treinamento. Terceiro, espaço de pixels em comparação com espaço VAE. Treinar diretamente com pixels funciona, e as normas do gradiente são

03:35 quase iguais às do VAE 1.2 congelado, embora o espaço de pixels apresente alguns picos ocasionais de perda. E o modelo de 8 bilhões atinge a mesma perda em cerca de um terço das etapas de treinamento do modelo de 1,7 bilhão. Agora, vamos ser honestos sobre os números. Em compreensão de imagens, ele é competitivo, mas não é o líder. No DocVQA, 90,4; no ChartQA, 83. No CountBench, marca 94,3, acima dos modelos de referência da tabela deles. Mas, em conjuntos mais difíceis, como o MMU, chega a 41,7, enquanto o Qwen-VL marca 69,6. Então, o objetivo

04:09 não é vencer todos os benchmarks. O importante é que um único modelo sem encoder chega perto disso. Também há limitações. Quando vários animais ou pessoas se sobrepõem, seus corpos podem se fundir ou a contagem pode ficar errada. As mãos podem ter o número incorreto de dedos. O movimento pode ser fisicamente implausível. E o checkpoint está sob uma licença de pesquisa não comercial. Então, por enquanto, é para pesquisa, não para lançar um produto. Se quiser experimentar, o código está no GitHub e o checkpoint está no Hugging Face. A inference é feita com um único comando, com tarefas de texto para imagem, texto para vídeo, compreensão de imagens e

04:40 compreensão de vídeos. Vale lembrar: o repo lista treinamento com sete GPUs ou mais, cada uma com 48 GB. Então, confira os requisitos antes de tentar executá-lo no seu próprio sistema. E o que vem pela frente? Esta é a minha opinião, não a do artigo. Se os pixels brutos funcionam, o VAE deixa de ser um limite para a qualidade e o pipeline fica mais simples. Um modelo, um ciclo de treinamento. Somando a isso o resultado de escalabilidade — o modelo maior aprende mais rápido —, isso sugere que versões maiores devem continuar melhorando. E, como geração de imagem para vídeo e edição de vídeo já estão no mesmo modelo, ele pode se tornar um modelo visual geral. Vamos ver. Então,

05:11 esse é o Pixel UMM: sem VAE, sem encoder de visão, só pixels. Os links estão na descrição. Experimente e me conte como foi. Até a próxima.

Transcrição original

[00:00] All right, Nvidia just released PixelUmm and it throws away the VAE and the vision encoder completely. One model, raw pixels, images and video understanding and generation. Let’s break it down. Now, before the theory, look at this. Everything you see on screen was generated by this one model straight from a text prompt, 4 seconds, 24 frames per second. And mind you, there is no VAE decoding any of this. So, to understand why this is a big deal, we need two things that almost every image and video model depends on,

[00:30] a VAE and a ViT. Let’s start from the basics. A VAE, a variational autoencoder, is basically a compressor. A video is huge, millions of pixels per frame, so the model first squeezes it down into a small hidden grid called latents, does all its work there, and at the end a decoder blows the latents back up into pixels. So, you can see that the VAE is a separate model trained separately sitting at the front and the back. The catch is whatever the VAE can represent, the generator can never

[01:01] create fine textures, small text, sharp edges. The VAE becomes a ceiling for quality, and it’s one more thing to train, store, and keep in sync. Now, the ViT, a vision transformer, this one is on the understanding side. When you ask a model what is in this picture, the image goes through a vision encoder first. It cuts the picture into patches and turns them into features that the language model can read. Again, a separate pretrained model with its own limits. So, a typical unified model today has a ViT to understand, a VAE to

[01:32] generate, and a language model in the middle gluing them together. Three parts, three sets of compromises. PixelUmm’s answer is simple, skip both and just feed the pixels in. An image is cut into 16 by 16 patches. Each patch is 768 raw numbers, and one single linear layer turns it into a token. For video, the unit is a tube, four frames by 16 by 16, which is 3,072 values. One linear layer, one token. That’s the entire front end. Then those tokens go into a decoder-only transformer built on Queen

[02:04] 3 8 B, 36 layers. Now, here’s the nice part. If you look at the diagram, there are two experts. The understanding expert handles text and clean pixels, and the generation expert handles the noisy pixels, but they share the same self-attention. So, everything talks to everything in one sequence. The total is about 15.2 billion parameters. For understanding, the language head writes text like describing a video for generation, a linear head predicts clean pixels directly denoised over 35 steps, no latent space anywhere. Pixels in,

[02:34] pixels out. And here’s what comes out. A fox at dawn, a golden retriever in the wind, an otter surfing, and neon Tokyo street. All of these are 832 by 464 96 frames from just a text prompt. Now, if you want to go deeper, the paper has some really interesting findings. Let’s go through a few. First, patch size. They tested 16 by 16 patches against 32 by 32, and 16 keeps a lower training loss. The takeaway is that squeezing the image harder makes generation harder to learn. For video, they settle on 16

[03:05] spatial by four temporal. Second, the output head. A plain linear head has a problem. At high guidance, you can actually see the 16 pixel grid in smooth areas like a sky or a wall. They tried convolutional heads with pixel shuffle that fixed this, and the best balance costs about 9.6 times more compute in that head. Interesting thing, the released checkpoints still use the simple linear head because switching needs more training. Third, pixel space against VAE space. Training directly on pixels works, and the gradient norms are

[03:35] nearly the same as with the frozen 1 2.2 VAE, though pixel space does show some occasional loss spikes. And the 8 billion model reaches the same loss in roughly a third of the training steps of the 1.7 billion one. Now, let’s be honest about the numbers. On image understanding, it’s competitive, not the leader. DocVQA 90.4, ChartQA 83. On count bench, it scores 94.3, ahead of the baselines in their table. But on harder ones like MMU, it gets 41.7, where Qwen-VL gets 69.6. So, the point

[04:09] isn’t winning every benchmark. The point is that one encoder-free model gets this close. There are limits, too. When several animals or people overlap, their bodies can merge or the count drifts. Hands can have the wrong number of fingers. Motion can be physically implausible. And the checkpoint is under a non-commercial research license. So, this is for research, not for shipping a product yet. If you want to try it, the code is on GitHub and the checkpoint is on Hugging Face. Inference is one command with tasks for text-to-image, text-to-video, image understanding, and

[04:40] video understanding. Mind you, the repo lists training on seven or more GPUs with 48 GB each. So, check the requirements before you try it on your own system. So, what’s the future? This is my take, not the paper’s. If raw pixels work, the VAE stops being a quality ceiling, and the pipeline gets simpler. One model, one training loop. Add the scaling result, the bigger model learning faster, and it suggests larger versions should keep improving. And with image-to-video and video editing already in the same model, this could become one general visual model. We’ll see. So,

[05:11] that’s Pixel UMM, no VAE, no vision encoder, just pixels. Links are in the description. Go ahead and try it out, and let me know how it goes. I’ll see you in another one.