Image Generation

No VAE Required: AMD Open-Sources Nitro-P, a 679M Pixel-Space Image Model That Hits 90 Images a Second at 512px

November 22, 20261 views阅读中文原文
No VAE Required: AMD Open-Sources Nitro-P, a 679M Pixel-Space Image Model That Hits 90 Images a Second at 512px — But the "Code Released" Claim Doesn't Check Out Yet

No VAE Required: AMD Open-Sources Nitro-P, a 679M Pixel-Space Image Model That Hits 90 Images a Second at 512px — But the "Code Released" Claim Doesn't Check Out Yet

The short version: on November 20, AMD published Nitro-P, a 679-million-parameter text-to-image model built on a "pixel-space" design that deletes the VAE decoder every mainstream image model still depends on, denoising directly in RGB. AMD's numbers: 10.26 images per second at 512×512 with the full model, and 90.02 images per second with a one-step distilled variant. The weights are already downloadable on Hugging Face.

Three things the release leaves unclear, though, and they matter more than the speed figures. The blog says code and weights were both released; the code repository returns a 404. The Hugging Face repo ships no model card and carries no license tag. And AMD's own comparison table admits that once you raise the sampling steps, Nitro-P is slower than the model it replaces.

This article is compiled from AMD's official blog, the official model repository, and multiple media reports.

What actually changed

To understand Nitro-P you first need to understand how text-to-image models normally draw.

The standard pipeline runs in two stages: a diffusion model denoises inside a compressed "latent space," then a separate VAE decoder turns that compressed representation back into the RGB image we can see. The upside is speed — far fewer pixels to process. The cost is that the VAE becomes a ceiling. Detail the encoder did not preserve is detail the denoiser can never recover, and the autoencoder and the diffusion model are trained against different objectives rather than jointly.

Pixel-space diffusion removes the middleman and denoises on raw pixels. The obvious problem: a 1024×1024 image holds more than three million pixels, and treating each one as a Transformer token produces sequences so long that self-attention becomes impractical.

Nitro-P splits the job in two. The upper stage is an E-MMDiT Transformer that chops the image into 16×16 patches and works only at 1/16 resolution, producing a coarse semantic map — what objects exist, where they sit, what color they are. The lower stage is a lightweight U-Net that takes that map and reconstructs RGB at full resolution across the whole image, using multi-scale convolutions and skip connections so no seams appear at patch boundaries.

How the semantic map reaches the U-Net turned out to be the key design question. AMD tried two options: concatenating the features directly, or projecting the map into spatially varying scale and shift parameters that modulate the normalized activations at the U-Net bottleneck. The second won. In AMD's comparison, the concatenation baseline routinely mismatched colors, miscounted objects, and broke the overall layout.

The numbers: what is genuinely fast, and what gets misread

The key rows from AMD's table:

  • 512×512, full 20-step model: 10.26 images/s, GenEval 0.88
  • 512×512, one-step distilled: 90.02 images/s, GenEval 0.85
  • 1024×1024, full model: 2.44 images/s, GenEval 0.87
  • 1024×1024, one-step distilled: 26.00 images/s, GenEval 0.83
  • 0.74 TFLOPs main network, 25M training pairs, 679M parameters total

Against comparable pixel-space models: at 512px, PixelDiT reaches 5.54 images/s (GenEval 0.78), DeCo 6.13 images/s (0.86), MiniT2I-L 2.4 images/s (0.88). At 1024px, PixelDiT manages 2.05 images/s with GenEval 0.74, while Nitro-P does 2.44 images/s at 0.87.

Two readings need correcting.

First, "90 FPS" is not a frame rate. That figure is samples per second at batch size 32 on a single MI300X. Divided down it works out to roughly 11 milliseconds per image, but that is saturated-batch throughput, not the latency of typing a prompt and getting a picture back. Headlines that say 90 FPS are quietly dropping the batch qualifier.

Second, it is only faster at very low step counts. AMD's own comparison is explicit: on the same MI300X at the same batch size, at 512px and one step, Nitro-P runs 90.02 against 44.13 for its predecessor Nitro-E. At two steps it is 64.83 against 41.39. At five steps the two are level at 33.76 and 34.35. At 20 steps Nitro-P falls to 10.26 while Nitro-E holds 18.83 — the ranking inverts. The reason is that with more steps the denoising backbone dominates runtime, and a latent-space step is simply cheaper than a pixel-space one. The 1024px curve behaves identically: 26.00 against 11.00 at one step, 2.44 against 4.66 at 20 steps.

In other words, Nitro-P is not "faster across the board." It is built specifically for one-to-two-step, high-throughput serving. AMD's own summary says as much: it is best suited to low-NFE workloads.

Pitfalls: three things to write down

Pitfall one: the code repository is a 404. The blog's "Additional Resources" section points to github.com/AMD-AGI/Nitro-P. I checked it through the GitHub API and in a browser; both return 404. The predecessor repo in the same organization, AMD-AGI/Nitro-E, resolves normally, so this is not an org-level problem. As of writing, the claim that full training code shipped cannot be verified. Anyone hoping to reproduce the training pipeline has to wait.

Pitfall two: the weights have no documentation and no license. The amd/Nitro-P repository contains four safetensors files and a .gitattributes, nothing else. The README request returns "Entry not found," and the model's tags include only region:us — no license field. The four files are the 512px model, its distilled variant, the 1024px model, and its distilled variant, each 2,717,604,284 bytes. I parsed the safetensors header on the 512px file: 824 tensors totaling 679.4M parameters, all in F32. That means a single checkpoint costs 2.7GB of real disk and memory, with no bf16 or fp16 build available. Before any commercial use, the license question has to be answered in writing.

Pitfall three: the quality scores are not human votes. GenEval measures whether the things named in the prompt actually appear — objects, counts, colors, positions. ImageReward and HPSv2.1 are both trained reward models assigning scores. Nitro-P does lead that table (IR 0.98, HPS 30.04, versus 0.48 and 27.75 for DeCo), but a high reward-model score is not the same as a human finding the image better. These metrics are close to blind to stylistic appeal and fine-detail endurance. Real preference signals will have to wait until the model shows up on a blind human-vote leaderboard.

How to use it: the realistic path

The weights are standard safetensors, but the repo ships no inference script and no diffusers model_index.json, so do not expect a single from_pretrained call to work. The practical route:

  1. Pull the 2.7GB file with huggingface-cli download amd/Nitro-P Nitro-P-512px.safetensors — skip the distilled variants unless you are certain you only want one-step generation.
  2. Write your own loading logic: read the safetensors header, rebuild the E-MMDiT backbone and U-Net decoder from the 824 tensor names, and wire the text side to Qwen3-1.7B encoder features. The names follow standard DiT conventions (adaln_single.*, blocks.*), so you can walk them against the architecture diagram in AMD's post.
  3. The easier path is waiting for the official repo to come back, or for the diffusers and ComfyUI communities to ship adapters. By the usual pattern for releases like this, community support lands anywhere from a few days to a couple of weeks later.

On hardware: every published figure comes from an MI300X with 192GB of HBM3 at batch size 32. Consumer cards are not ruled out — 679M parameters and a 0.74 TFLOPs backbone mean a 24GB card can hold the F32 weights — but AMD published no consumer-GPU data at all, so do not extrapolate MI300X throughput onto a 4090.

Who it is for

  • Teams running high-concurrency image services. If your product generates dozens of candidates per prompt and the user picks one, the one-step distilled model's 90 images/s translates directly into GPU-seconds saved.
  • Researchers working on pixel-space diffusion. The post documents the patch-level-semantic plus full-image-convolutional-decoder route in unusual detail, including the modulation-versus-concatenation ablation and the patch-artifact comparison. It is a reproducible baseline — once the code repo returns.
  • Anyone running image models on AMD hardware. The whole thing was trained and benchmarked on ROCm, making it one of the few open T2I models that treats MI300X as the primary target.
  • People tracking the no-VAE line. vivo BluePixel, Tencent L2P, and HiDream-O1 all sit in the same family. Nitro-P is currently the smallest and highest-throughput member.

When not to use it

  • Commercial output. With no license tag, the copyright status is undefined by default. Get AMD's position in writing first.
  • High-step, high-quality work. At 20 steps it is roughly twice as slow as the previous generation and the quality does not compensate. There is no reason to pick it here.
  • Typography and layout. Pixel-space models are generally weak at rendering long text, and none of AMD's samples are layout tasks. For lettering, stay with Ideogram or Qwen-Image.
  • Drop-in deployment. No model card, no inference script, no diffusers config, no ComfyUI node. Right now the setup cost outweighs the benefit.

Cost: a realistic accounting

AMD published no pricing because the model is open — the cost sits entirely on your side:

  • Storage. All four checkpoints total 10.87GB; keeping just the 512px full model and its distilled variant still costs 5.4GB.
  • VRAM. 2.7GB of F32 weights plus activations and the text encoder means a 24GB card handles 512px comfortably, while 1024px wants 40GB or more.
  • Compute. Renting an MI300X runs roughly two dollars an hour on the open market. At 90 images/s, a fully loaded hour theoretically produces over three hundred thousand images, making per-image cost negligible — but only if your batch actually saturates at 32. In real traffic, prompts vary in length and post-processing takes time, so utilization typically lands between ten and thirty percent of nameplate.
  • The counter-case. If you only generate images occasionally, a per-image API is cheaper. This model's value is throughput density, not unit price.

First step: three things you can do today

First, pull just the safetensors header for the 512px file — a 200KB prefix, not the full 2.7GB — and check that the tensor names line up with AMD's architecture diagram. That tells you how hard a port will be before any official code appears.

Second, take one batch of prompts and run a 20-image side-by-side against any available model, FLUX or Qwen-Image. Score three things specifically: correct colors, correct object counts, and visible patch artifacts. Ignore overall prettiness.

Third, if your workload really is high-concurrency candidate generation, estimate how much of the one-step 512px throughput your daily request volume can absorb before deciding whether to rework your pipeline for it.

Sources

  • AMD ROCm Blogs, official release post (November 20, 2026): https://rocm.blogs.amd.com/artificial-intelligence/nitro-p/README.html
  • Official model weights (created November 21, 2026): https://huggingface.co/amd/Nitro-P
  • Data Phoenix report (November 20, 2026): https://dataphoenix.info/news/amd-nitro-p-framework
  • Emergent report (November 21, 2026): https://emergent.sh/news/amd-nitro-p-vae-free-text-image-diffusion-90
  • Predecessor Nitro-E official post (October 24, 2025, used for the throughput comparison): https://rocm.blogs.amd.com/artificial-intelligence/nitro-e/README.html
  • Predecessor code repository, verified reachable and used as the contrast for the new repo's 404: https://github.com/AMD-AGI/Nitro-E

This article is compiled from multiple media reports alongside AMD's official blog; the repository status and parameter counts were independently verified for this piece.

Comments

0 published
Log inorsign up to leave a comment.

Loading comments...