# Representation Guidance: a pixel diffusion Transformer that guides itself with its own bottleneck

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/representation-guidance
> date: 2026-10-13
> tags: diffusion, diffusion-transformers, image-generation, flow-matching, representation-learning

The post that brought this paper to me read: "Alibaba dropped Representation Guidance (RG) - end-to-end pixel-space framework that scales plain Transformers via compact internal rep to guide diffusion (way less compute) - keeps standard blocks, no heavy decoders - tops FLUX.1-dev". The only reply under it said there was no proof of concept.

The paper is [arXiv 2610.12978](https://arxiv.org/abs/2610.12978), "Learning Representations to Guide Pixel Diffusion Transformers", by Zihao Pan, Mengting Chen and seven others at Sun Yat-sen University, Alibaba, HKU and SJTU. Its [repository](https://github.com/Pan-Zihao/Representation-Guidance) has no code yet, so I could not run anything. I derived what the method trains the network to do and checked each clause of the post against the paper's own tables.

| Claim in the post | What the paper shows |
|---|---|
| plain Transformer, standard blocks, no heavy decoder | Holds. JiT blocks, split 8/4 into encoder and decoder, a linear bottleneck between. |
| "end-to-end" | Half true. Diffusion runs on raw pixels, but training aligns a layer to a frozen DINOv2, and RG fails without it. |
| "way less compute" | Fewer parameters for a given FID, and 4x fewer **epochs** to match JiT-B. Per training step, RG costs more. |
| "tops FLUX.1-dev" | On GenEval and DPG-Bench, prompt-following benchmarks, at 512x512. The same model without RG already scored higher than FLUX.1-dev there. |

## Pixel diffusion without a VAE

Pixel diffusion skips the VAE and denoises RGB patches directly. [PixelUMM and PixelDense](/articles/pixelumm-pixeldense) covers why that used to be hard, and the [Diffusion Transformer doc](/architectures/diffusion-transformer) the latent baseline. The short version: a 16x16 RGB patch is 768 numbers, and a Transformer can only carry that if it predicts the clean image rather than the noise. That is [JiT](https://arxiv.org/abs/2511.13720)'s result, and RG builds on JiT.

RG writes flow matching with $t = 1$ as clean data, the opposite of the convention in the PixelUMM article:

$$
\mathbf{z}_t = t\,\mathbf{x} + (1-t)\,\boldsymbol{\epsilon}, \qquad \mathbf{v} = \mathbf{x} - \boldsymbol{\epsilon}.
$$

The network outputs a clean-image estimate $\mathbf{x}_\theta(\mathbf{z}_t, t, \mathbf{c})$ for a class label or prompt $\mathbf{c}$. It is converted to a velocity and trained against $\mathbf{v}$:

$$
\mathbf{v}_\theta = \frac{\mathbf{x}_\theta - \mathbf{z}_t}{1-t}, \qquad
\mathcal{L}_{\text{FM}} = \mathbb{E}\,\big\|\mathbf{v}_\theta(\mathbf{z}_t, t, \mathbf{c}) - \mathbf{v}\big\|_2^2 .
$$

The denominator is clipped at 0.05 and $t$ is drawn from a logit-normal with mean -0.8 and standard deviation 0.8 (reported, Table 9). At sampling, classifier-free guidance (CFG) mixes a conditional and an unconditional prediction:

$$
\mathbf{v}^{w}_\theta = \mathbf{v}_\theta(\mathbf{z}_t, t, \varnothing) + w\,\big(\mathbf{v}_\theta(\mathbf{z}_t, t, \mathbf{c}) - \mathbf{v}_\theta(\mathbf{z}_t, t, \varnothing)\big).
$$

Keep that shape in mind. RG's whole trick is the same extrapolation, moved from sampling into the training target, with a learned representation in place of $\mathbf{c}$.

## Why REPA fades in pixel models

[REPA](https://arxiv.org/abs/2410.06940) adds a loss that pulls one intermediate layer of the denoiser toward a frozen DINOv2's features of the clean image. In latent diffusion it is a large win; the PixelUMM article walks through the loss.

The paper's first claim is that in a pixel Transformer this win does not last. They apply REPA to JiT-B/16 at layer 4, 6 or 8 and train for 200 epochs (reported, Section 2):

- At the aligned layer, linear probing jumps. REPA lifts JiT-B's layer-4 accuracy to 60.7%. By layer 12 it is back to 30.8%, and local-structure score LDS falls from 0.662 to 0.025 (reported, Appendix A.5).
- REPA-4 converges faster early, but the baseline overtakes it after about 160 epochs and ends better: FID 4.56 against 4.80. Aligning deeper is worse: 5.38 at layer 6 and 8.33 at layer 8 (reported).

Their reading: per-pixel loss is mostly satisfied by local operations, so the later layers overwrite the imposed semantics. A probe finds a good representation mid-network that the output does not depend on.

The second claim is about the obvious fix: give the network a specialised pixel decoder, so the Transformer above it can stay semantic. Table 1 compares four decoders on a common 8-block encoder, same budget, same REPA at layer 3 (reported):

| Decoder | Params (M) | GFLOPs | FID |
|---|---|---|---|
| Vanilla Transformer blocks | 131.32 | 28.42 | 4.165 |
| PixelDiT (pixel attention and FFN) | 203.37 | 47.38 | 4.256 |
| DiP (convolutional U-Net) | 93.60 | 33.72 | 6.089 |
| DeCo (pixel-wise MLP) | 99.52 | 25.80 | 9.167 |

PixelDiT costs 1.55x the parameters and 1.67x the FLOPs of the vanilla decoder for a slightly worse FID (reasoned, from the table). The probes say why: decoders that model cross-patch structure let the encoder stay semantic but spatially flat; decoders that treat patches independently force it to keep spatial detail and lose semantics. The decoder decides what the encoder keeps; it does not make the representation better. Both experiments are base-size, 200 epochs, one run each: enough to motivate a design, not a scaling law.

## What RG changes

<Figure
  src="https://ai.thesatyajit.com/articles/representation-guidance/fig2.png"
  alt="Five architecture diagrams side by side. Under the heading Standard Patch-Level Transformer: (a) JiT, patch-level input through patch embed into one stack of global attention and FFN blocks to patch-level output; (b) Ours, patch-level input through a patch encoder and a Bottleneck, whose output enters a second stack of global attention and FFN blocks over its own copy of the patch-level input, with a dashed Drop path. Under the heading Pixel-Specialized Decoder: (c) PixelDiT with patch attention and pixel FFN over pixel-level input, (d) DeCo with a pixel-wise MLP, (e) DiP with a convolutional U-Net and skip concatenation."
  caption="RG (b) is JiT (a) cut in two, with a bottleneck between the halves and a decoder that re-reads the noisy patches. The three pixel-specialised decoders (c to e) are what the paper argues against (RG paper, Figure 3; project-page render)."
/>

RG has two parts, one for each claim.

**A bottleneck that forms the representation.** The model is split, following DDT, into an encoder $E_\theta$ and a decoder $D_\theta$, both made of unmodified JiT blocks. The encoder's output tokens $\mathbf{h} \in \mathbb{R}^{N\times D}$ go through two linear maps:

$$
\mathbf{u} = \mathbf{h}\,\mathbf{W}_{\text{down}} \in \mathbb{R}^{N\times d}, \qquad
\mathbf{r} = \mathbf{u}\,\mathbf{W}_{\text{up}} \in \mathbb{R}^{N\times D}, \qquad d \ll D.
$$

$d$ is 128 for every size; $D$ is 768, 1,024 and 1,152 for B, L and XL (reported, Table 9). The decoder has its own patch embedding, reads the noisy image again, and sees the encoder only through $\mathbf{r}$, which enters every decoder block as a per-token adaLN condition. The class label also reaches the decoder only through $\mathbf{r}$. The paper calls the space of $\mathbf{u}$ an "implicit latent space": compact and spatial like a VAE latent, but recomputed from $\mathbf{z}_t$ at every step and never decoded on its own.

**A guided target that forces the decoder to use it.** With probability 0.1, $\mathbf{r}$ is set to zero, so the same decoder also learns a representation-free, and therefore unconditional, prediction. The difference between the two predictions is the representation's contribution:

$$
\Delta\mathbf{v}_{\text{rep}} = \mathbf{v}_\theta(\mathbf{z}_t, t, \mathbf{r}) - \mathbf{v}_\theta(\mathbf{z}_t, t, \varnothing).
$$

RG adds a multiple of it, with the gradient stopped, to the flow-matching target:

$$
\mathbf{v}_{\text{RG}} = \mathbf{v} + (s-1)\,\operatorname{sg}\big(\Delta\mathbf{v}_{\text{rep}}\big), \qquad
\mathcal{L}_{\text{RG}} = \mathbb{E}\,\big\|\mathbf{v}_\theta(\mathbf{z}_t, t, \mathbf{r}) - \mathbf{v}_{\text{RG}}\big\|_2^2 .
$$

$s \geq 1$ is the RG scale, 1.4 by default; $s = 1$ is plain flow matching. The representation-free branch keeps the plain target $\mathbf{v}$. So does any sample with $t \leq 0.3$, because representations of nearly pure noise are unreliable.

<Figure
  src="https://ai.thesatyajit.com/articles/representation-guidance/fig1.png"
  alt="Training pipeline. Top row: noisy corgi image z_t goes through an Encoder and a bottleneck to tokens labelled r, then a Decoder conditioned on z_t, t and r, which outputs a sharp corgi image x-hat; converted by (x-hat minus z_t) over (1 minus t) into v_with_rep. Bottom row: the same z_t through a shared Encoder whose r is dropped, into the shared Decoder conditioned on z_t, t and the empty set, which outputs a blurry corgi; this gives v_without_rep, matched to v by MSE. Red arrows: the difference Delta v_rep runs from v_without_rep up to v_with_rep, and v_RG is v plus (s minus 1) times stop-gradient of Delta v_rep, matched to v_with_rep by MSE, labelled self-distilled target."
  caption="One RG step. The decoder runs with and without the representation; the gap between its two answers is added back to the target the representation-conditioned branch must hit (RG paper, Figure 6; project-page render)."
/>

Every reported result computes the offset with the EMA network, as two gradient-free forward passes, and switches RG on after 20 epochs of plain flow matching; starting at epoch 0, 10 or 30 moved FID by under 0.01 (reported, Appendix A.5).

### What the shifted target converges to

Appendix A.2 solves for the fixed point, and I checked the algebra. Write $\bar{\mathbf{v}}_{\mathbf{r}} = \mathbb{E}[\mathbf{v}\mid\mathbf{z}_t, \mathbf{r}]$ and $\bar{\mathbf{v}}_\varnothing = \mathbb{E}[\mathbf{v}\mid\mathbf{z}_t]$. The dropped branch converges to $\bar{\mathbf{v}}_\varnothing$. If the teacher equals the student at convergence, the minimiser of $\mathcal{L}_{\text{RG}}$ satisfies $f = \bar{\mathbf{v}}_{\mathbf{r}} + (s-1)(f - \bar{\mathbf{v}}_\varnothing)$, which rearranges to

$$
\mathbf{v}_\theta(\mathbf{z}_t, t, \mathbf{r}) = \bar{\mathbf{v}}_\varnothing + \frac{1}{2-s}\big(\bar{\mathbf{v}}_{\mathbf{r}} - \bar{\mathbf{v}}_\varnothing\big), \qquad 1 \le s < 2 .
$$

That is a CFG velocity with the representation as the condition and an effective scale $w_{\text{rep}} = 1/(2-s)$. At the default $s = 1.4$ that is 1/0.6, about 1.67 (reasoned). As $s$ approaches 2 the scale blows up, which is why the slider below stops at 1.9.

So the answer to "is RG a training change or a sampling-time guidance?" is: **training only**. The guidance is baked into the weights. Sampling is a normal 50-step Heun solve with normal class-label CFG on top, and RG adds no inference passes. What changes is how much CFG you still need: the best CFG scale for RG-B falls from 3.95 without guidance to 2.60 with it (reported, Table 10). Why not extrapolate at sampling time instead? Appendix A.2: it "would double the decoder cost and leave the representation unchanged". The second half matters more. The gradient of $\mathcal{L}_{\text{RG}}$ flows through $\mathbf{r}$ into the bottleneck and the encoder. To hit a target that sits further from the unconditional answer, the conditioned branch has to deviate more, so $\mathbf{r}$ has to carry more of what denoising needs. CFG guides with a fixed label. RG guides with a condition it is simultaneously learning.

<RgTargetField />

The toy above is three Gaussian modes in 2D, with $\mathbf{r}$ idealised as "which mode". Both branches are then exact, so the grey field is the fixed point above, not a trained network. The black arrow is one pair's plain target, the orange tip the added offset, and 64 noise draws are integrated with 50 Euler steps. Three things show up (measured, in the toy):

- At $s = 1$ the samples land with close to the data's own spread (Euler's 50 steps lose a little). Raising $s$ tightens them around the chosen mode, the sharpening the paper describes as $p(\mathbf{z}_t)\,p(\mathbf{r}\mid\mathbf{z}_t)^{w_{\text{rep}}}$.
- Push $s$ high and the centre drifts away from the other modes and the spread grows again: the samples overshoot the data, the same failure as too much CFG.
- Untick the $t > 0.3$ interval and the drift starts at much lower $s$, because the offset is largest when the mode is still ambiguous. The paper's version of this: guidance at all noise levels raises RG-B's FID from 3.28 to 5.28 (reported, Figure 9b).

What a toy cannot show is the learned half. Here $\mathbf{r}$ is fixed and perfect; in RG it is a 128-wide vector per token, trained by the same loss.

### How it differs from Internal Guidance

Internal Guidance (IG) has a training variant of the same form: it adds $\omega\,\operatorname{sg}(\mathbf{v}_{\text{final}} - \mathbf{v}_{\text{inter}})$, the gap between the output and an intermediate head. On JiT-B in pixel space it made FID worse, 4.56 to 5.22 (reported, Table 10). The paper's explanation: the shallow head's loss is only 4% above the final one's, so the gap is mostly fine pixel detail. RG's offset removes only $\mathbf{r}$, so it isolates what the representation contributes.

## Checking "keeps standard blocks, no heavy decoders"

This one holds. Every block is a JiT block. The B/16 model is 8 encoder blocks and 4 decoder blocks, the same 12 as JiT-B. Against JiT-B/16 at 131.12M parameters and 25.22 GFLOPs, RG-B/16 is 131.52M and 28.47 GFLOPs (reported, Table 8): 0.4M more parameters and 12.9% more FLOPs per forward pass (reasoned). Table 8 splits it: decoupling into encoder and decoder takes JiT-B to 131.32M and 28.42 GFLOPs, and the bottleneck adds the last 0.2M, which is 768 x 128 twice, 196,608 weights (reasoned). So the extra FLOPs are the decoder's second patch embedding and its conditioning, not the bottleneck. The paper rounds this to "13% FLOPs".

Two qualifiers. The text-to-image model swaps JiT blocks for MiniT2I's MM-JiT blocks, which are also standard but not the same architecture. And the configuration carries 32 in-context class tokens, inserted at block 4, 6 or 8 depending on size (reported, Table 9).

## Checking "end-to-end"

Diffusion runs on raw pixels, and nothing external is needed at sampling time. Training is another matter. RG's full loss is $\mathcal{L}_{\text{RG}} + 0.5\,\mathcal{L}_{\text{REPA}}$, aligned to a frozen DINOv2-B/14 with registers at encoder block 3, 5 or 7 for B, L and XL (reported, Table 9). The component ablation shows this is not optional (reported, Table 8, B/16 at 200 epochs):

| REPA | Bottleneck | Guidance | FID |
|---|---|---|---|
| | | yes | 8.08 |
| | yes | yes | 8.99 |
| yes | | yes | 7.85 |
| yes | | | 4.17 |
| yes | yes | | 3.79 |
| yes | yes | yes | 3.28 |

Guidance without both REPA and the bottleneck makes things much worse. With both, it takes 3.79 to 3.28. RG does not replace pretrained alignment; it is what makes alignment survive to the output. The paper's own phrase for DINOv2 here is "a semantic scaffold". Aligning the encoder's last layer directly, so that $\mathbf{h}$ itself matches DINOv2, gives FID 8.97 (reported, Table 6). The representation the decoder consumes has to be learned for generation, but it starts from someone else's.

## Checking "way less compute"

<FidBoard />

On ImageNet 256x256, RG-XL/16 reaches FID 1.55 with 725M parameters at 600 epochs, the best pixel-space number in Table 2. PixelDiT-XL is next at 1.61 with 797M. RG-L/16 reaches 1.79 at 459M, beside JiT-G/16 at 1.82 with 2B and PixelREPA-H/16 at 1.81 with 953M (reported). That is 4.4x fewer parameters than JiT-G and 2.1x fewer than PixelREPA-H (reasoned). A 0.03 FID gap from one run each is a tie; "matches with a quarter of the parameters" is the honest reading, and still a strong one. At 512x512, RG-XL/16 reaches 1.74 against PixelDiT-XL's 1.81 and JiT-H/32's 1.94 (reported, Table 3). Latent models are still ahead at 256: RAE-XL is at 1.13.

<Figure
  src="https://ai.thesatyajit.com/articles/representation-guidance/fig3.png"
  alt="Left, panel (a): FID on the vertical axis from about 1.5 to 2.7 against parameters on a log axis from 100M to 2B, with circle size showing GFLOPs. A blue dashed line runs down from RG-B/16 at about 2.64 through RG-L/16 at about 1.79 to RG-XL/16 at about 1.55. A pink dashed line for JiT runs from JiT-L/16 near 2.36 through JiT-H/16 near 1.86 to JiT-G/16 near 1.82 at 2B. Squares mark DiP-XL, DeCo-XL and PixelDiT-XL near 1.6 to 1.8; triangles mark DiT-XL/2 and SiT-XL/2. Right, panel (b): for a cat and a dog photo, rows of PCA colour maps and cosine-similarity maps for JiT, JiT plus REPA, PixelDiT and Ours; Ours shows a clean object outline and a sharply localised similarity peak."
  caption="Parameter and FLOP scaling of RG against JiT and pixel-specialised decoders, and PCA and cosine-similarity maps of the last encoder layer. RG-B/16 here is the 600-epoch model (RG paper, Figure 2; project-page render)."
/>

Per **inference** step, then, RG is cheap: the same blocks, about 13% more FLOPs than JiT at the same size, and fewer parameters for a given FID. RG-L/16 is 99.2 GFLOPs and RG-XL/16 155.8 (reported, Table 9). The sampling budget is ordinary: 50 Heun steps, which is about 100 network evaluations, roughly doubled by CFG inside its (0.1, 1] interval (reasoned; the paper does not count NFE). FIDs are only reported with CFG, with the scale swept over 2.0 to 4.0. No CFG-free number is given.

Per **training** step, RG costs more. The headline speed-up is this:

<Figure
  src="https://ai.thesatyajit.com/articles/representation-guidance/fig4.png"
  alt="FID-50K against training epochs from 80 to 200, then a break to 600. JiT-B falls from about 8.2 at 80 epochs to 4.56 at 200 and 3.66 at 600. JiT-B plus REPA starts lower, about 6.1, but flattens near 4.8 and is overtaken by JiT-B around 160 epochs, annotated REPA plateaus, overtaken by baseline. RG-B starts at about 4.45 at 100 epochs, reaches about 3.64 at 150 and 3.28 at 200, and 2.64 at 600, marked minus 28 percent against JiT-B. A dashed arrow from RG-B at 150 epochs to JiT-B at 600 is labelled 4x faster."
  caption="RG-B at 150 epochs matches JiT-B at 600 (3.64 against 3.66). The 4x is a count of epochs (RG paper, Figure 14; project-page render)."
/>

Epochs are not FLOPs. An RG step adds two gradient-free EMA forward passes. Taking a backward pass as about twice a forward, a JiT-B step is about 3 x 25.22 GFLOPs per image and an RG-B step 3 x 28.47 plus 2 x 28.47 (reasoned). If the EMA passes run on every sample, 600 JiT-B epochs cost 2.1x what 150 RG-B epochs do. They are only needed when $t > 0.3$ and $\mathbf{r}$ is kept: 52.4% of logit-normal draws, times 0.9, so 47% (reasoned). Skipping the rest lifts the ratio to 2.7x. Neither counts RG's DINOv2 forward for REPA, which JiT-B does not pay. So the compute-matched speed-up is roughly 2x to 2.7x (reasoned): real, and less than 4x. The paper gives no training FLOPs, wall-clock or GPU-hours to check this against. The figure's "-28%" at 600 epochs checks out: (3.66 - 2.64) / 3.66 is 27.9% (reasoned).

## Checking "tops FLUX.1-dev"

This is the text-to-image result at 512x512 (reported, Table 4):

| Model | Params | GenEval | DPG-Bench |
|---|---|---|---|
| SD3 | 8B | 0.68 | 84.1 |
| FLUX.1-dev | 12B | 0.67 | 83.8 |
| DeCo-XXL/16 | 1.1+1.7B | 0.86 | 81.4 |
| MiniT2I-L/16 | 912+341M | 0.88 | 85.9 |
| RG-T2I-L/16 | 912+341M | 0.89 | 87.1 |

**These are prompt-following benchmarks.** GenEval checks object counts, colours and positions with a detector over 553 prompts; DPG-Bench asks question-answer checks over 1,065 dense prompts. Neither measures image quality, and the paper reports no text-to-image FID or preference study. "Tops FLUX.1-dev" means "follows these prompts more literally", not "makes better images".

**RG's own contribution is small.** RG-T2I-L/16 is MiniT2I-L/16 with RG added, same size, same data, same recipe. MiniT2I-L/16 alone already scores 0.88 and 85.9, above FLUX.1-dev on both. RG adds 0.01 GenEval and 1.2 DPG (reported). At 553 prompts and 4 images each, a binomial standard error on a GenEval-like score near 0.89 is about 0.007 (reasoned; GenEval averages per-category scores, so this is approximate). A 0.01 gain from one run is about 1.5 standard errors. The DPG gain is probably more solid, but the paper gives no seeds. (MiniT2I-L is also the model [BudgetPix](/articles/budgetpix) adapts to run at any token budget; the two papers attack the same baseline from opposite ends, its training signal and its compute.)

**The parameter column mixes conventions.** The caption says counts include the text encoder. RG's 912+341M does: 341M is FLAN-T5-Large. FLUX.1-dev's 12B is its transformer only; it also runs a T5-XXL text encoder that is not in the 12B. The ratio is still about 10x, but the column is not like for like.

**The data differ.** RG-T2I trains on CC12M with LLaVA-NeXT captions, then fine-tunes on 120K images from BLIP3o-60K, DALL-E 3 and ShareGPT-4o-Image (reported). That fine-tuning mixture is curated, largely synthetic data made for prompt alignment, and I would expect it to lift exactly these two benchmarks (reasoned; the paper does not test it). FLUX.1-dev's training data is not public. A small model tuned for prompt alignment beating a general 12B model on prompt alignment is useful to know; it is not evidence that RG out-generates FLUX.

## Representation quality against generative usefulness

The paper measures representations with three probes on B/16 models at 200 epochs, and no CKNNA: **linear probing** for global semantics, **RMSC** (spread of normalised patch tokens) for how distinct positions are, and **LDS** (neighbour minus distant-pair similarity) for local structure (reported, Appendix A.4).

<Figure
  src="https://ai.thesatyajit.com/articles/representation-guidance/fig5.png"
  alt="Three rows of thirteen panels on the same Siamese cat photo. Each panel after the photo is a PCA colour map of one layer, layers 1 to 12. JiT-B: noisy, high-frequency colour patterns in every layer with no clear outline. JiT-B plus REPA4: a clear cat outline around layers 3 to 7 that dissolves back into high-frequency patterns by layers 10 to 12. RG-B: a clean cat silhouette against a flat background from layer 3 to layer 8, then high-frequency patterns in layers 9 to 12, the decoder."
  caption="PCA of every layer at t = 0.5. REPA's structure peaks near the aligned layer 4 and dissolves; RG keeps it through encoder layer 8 and hands pixel detail to decoder layers 9 to 12 (RG paper, Figure 7; project-page render)."
/>

The numbers support the thesis better than the pictures do (reported, Appendix A.5):

- JiT-B's probing peaks at 29.5% at layer 8. RG-B's encoder holds 52.1% to 55.2% from layer 3 to layer 8, then drops to 22.7% to 29.2% in the decoder. 55.2 over 29.5 is 1.87x, the paper's "nearly twice" (reasoned).
- At the last encoder layer, RG-B has RMSC 0.858 and LDS 0.390 against JiT-B's 0.476 and 0.111.
- JiT-B with REPA probes higher than RG at its peak, 60.7% at layer 4, but has the worse FID: 4.80 against 3.28.

That last line is the paper's best evidence: peak alignment predicted generation poorly, survival to the layer that uses it predicted it well. With three or four models and one seed each, it is a consistent pattern, not a measured correlation.

## What is released

As of 2026-10-13 (measured):

- The [repository](https://github.com/Pan-Zihao/Representation-Guidance) at commit `65b573f` (30 September 2026) holds `README.md`, `assets/teaser.jpg` and `assets/pipeline.png`. No code, no config, no licence file. Its arXiv badge still reads "Coming Soon". Its TODO lists ImageNet and text-to-image training code and weights, all unchecked, "in the coming weeks".
- Hugging Face has no models: searching `representation-guidance` and listing author `Pan-Zihao` both return an empty list.

None of it can be reproduced yet. The README's results table matches Tables 2, 3, 4 and 9 to the digit, and adds two numbers the paper's text does not state: RG-B at 100 epochs, 4.45, and RG-L at 200 epochs, 2.00.

## Things that do not line up

- **The EMA assumption.** The fixed-point derivation assumes the EMA teacher matches the online network. The appendix then finds the online teacher better, 3.18 against 3.28 (reported, single runs), and explains it: at decay 0.9999 the EMA averages about 10,000 steps, roughly eight epochs, so its offset describes an older $\mathbf{r}$. That is the assumption failing in practice, and the paper still uses EMA for every headline number.
- **The 512x512 table** gives no parameter counts or epochs, and the text cites "Table 7" for bottleneck width (it is Table 5) and "Algorithm 10" (it is Algorithm 1). Cosmetic, but it is a v1.
- **Bottleneck width** was chosen at 600 epochs, where $d = 128$ beat 512 (2.64 against 2.89), while at 200 epochs 512 was best (3.18). It is one sweep on B/16; whether 128 is right for XL is not shown.

## How it relates to PixelDense

[PixelDense](/articles/pixelumm-pixeldense) starts from the same observation, that per-pixel loss alone does not build a representation, and goes the other way: **more** frozen teachers, four of them, in two orthogonal streams. RG keeps one teacher as a scaffold and makes the network **depend** on what it learns. The two compose; neither paper tries it.

Related reading on this site: [CSFM](/articles/csfm-flow-matching) learns the other end of flow matching, the source. [EVA](/articles/eva-empirical-vae) keeps a latent and learns its prior. [MrFlow](/articles/mrflow-diffusion-acceleration) cuts pixel-space sampling compute, and [LoT Diffusion](/articles/lot-diffusion) changes how many tokens a DiT spends where.

## What I would want next

- **The code.** The method is a few lines on top of JiT. Until it ships, every number above is reported.
- **GPU-hours** for RG against JiT at matched FID, since the 4x is in epochs.
- **Text-to-image quality** beyond GenEval and DPG, and RG-T2I against MiniT2I with seeds.

## Sources

- Paper: [arXiv 2610.12978](https://arxiv.org/abs/2610.12978) (v1, 9 October 2026), read from the arXiv HTML · [project page](https://pan-zihao.github.io/Representation-Guidance/) · repository `Pan-Zihao/Representation-Guidance`, commit `65b573f`, README and assets only
- The post: [@wildmindai on X](https://x.com/wildmindai/status/2109988271275258078)
- JiT: [arXiv 2511.13720](https://arxiv.org/abs/2511.13720) · REPA: [arXiv 2410.06940](https://arxiv.org/abs/2410.06940)