Skip to content

Contrastive Conditional–Unconditional Alignment for Long-tailed Diffusion Model

Conference: ECCV2026
Paper: ECCV Virtual
Area: Image Generation
Keywords: long-tailed generation / diffusion model / contrastive learning / conditional-unconditional alignment / class imbalance

TL;DR

For class-conditional diffusion models trained on long-tailed data, this paper leaves the architecture untouched and adds two complementary regularizers to the training objective only — an unsupervised contrastive loss with negative samples only that pushes apart the intermediate latents of the unconditional branch, plus an alignment loss that matches the conditional and unconditional noise predictions at large timesteps (the initial stage of denoising) — thereby transferring the data advantage of head classes to tail classes without any inference overhead, lowering FID from 19.9 to 15.1 and tail-class FID from 33.9 to 22.5 on ImageNet-LT 256×256.

Background & Motivation

Real training data for class-conditional image synthesis is almost always long-tailed: head classes may have thousands of images while tail classes may have only a few dozen. When diffusion models (DDPM, SiT/DiT, etc.) are trained on such data, tail classes lose both fidelity and diversity — the model collapses its tail-class samples onto the neighbourhood of those few dozen training images, which shows up visually as the same face and the same composition appearing over and over. Prior work has looked for remedies in other generative families: in long-tailed recognition, contrastive learning is a well-established tool, and in long-tailed GANs, methods such as UTLO let low-resolution representations be trained with unconditional objectives so that the data of head classes "carries along" the early generation behaviour of tail classes. Neither lesson transfers directly to conditional diffusion models, however. Supervised contrastive learning applies an attractive force between samples of the same class, which suppresses exactly the intra-class diversity that tail classes lack most; and plugging standard InfoNCE directly onto the conditional branch's latents (the concurrent Dispersive Loss) falls into a trivial solution — see design 3 below.

The core tension is this: tail classes need intra-class diversity, yet the laziest way to optimize contrastive learning on conditional latents is to make same-class latents identical (maximizing the inter-class mutual information term), and the optimizer takes that shortcut first — which is mode collapse itself. At the same time, a tail class has only a few dozen images, so any regularizer that acts solely on the conditional branch and draws its supervision only from tail samples has almost no data to work with; and naively "aligning" tail classes with head classes would directly damage head-class quality. What is needed is a route that borrows head-class data without flattening tail classes into a single mode.

The angle taken here is to move contrastive learning onto the unconditional branch: that branch carries no class label, so applying a negative-samples-only contrastive loss to it necessarily increases the separation between all samples regardless of class, and this diversity is a sample-level one; an alignment loss then pulls the conditional branch towards the unconditional branch at large timesteps, distilling that diversity into conditional generation. The justification for aligning at large timesteps comes from an existing observation: in the initial denoising stage, images are dominated by a shared low-frequency structure, so the class condition has little to say at that step; making it class-agnostic does not weaken later conditional controllability, but instead lets tail classes share the same early denoising behaviour as head classes and thereby profit from their data volume. Core idea: rather than contrasting on the conditional branch directly, a pair of synergistic losses — "push unconditional latents apart, then align the conditional branch to the unconditional branch at large timesteps" — injects sample-level diversity into conditional generation implicitly.

Method

Overall Architecture

This is a pure training-objective improvement; the network architecture is not modified at all. Conceptually split any denoising network (U-Net or Diffusion Transformer, e.g. SiT) into an encoding part \(e(\cdot)\) and a decoding part \(d(\cdot)\): \(e\) encodes the noisy image \(x_t\) into a low-dimensional latent \(h\), and \(d\) decodes \(h\) into the noise prediction \(\epsilon_\theta\). Both new losses hang off this pathway: the unsupervised contrastive loss (UCL) only uses the unconditional latent \(h = e_\theta(x_t, t, \varnothing)\); the alignment loss (AL) needs the same \(x_t\) to take two forward passes, yielding the conditional noise prediction \(\epsilon_\theta(x_t, t, c)\) and the unconditional one \(\epsilon_\theta(x_t, t, \varnothing)\). During training the standard DDPM denoising loss is added to these two terms and optimized end to end; at inference only the conditional branch is used, so the sampling procedure and the inference cost are unchanged.

The two losses have clearly separate roles and neither is dispensable: UCL "pushes unconditional generation apart", and AL "pulls conditional generation towards the pushed-apart unconditional generation". The diversity of conditional generation is never optimized directly — it is obtained indirectly through these two steps, which is the most fundamental difference from concurrent work (Dispersive Loss) that adds a contrastive loss directly on the conditional branch.

Key Designs

1. UCL: a negative-samples-only contrastive loss on the unconditional branch that pushes the latents of different samples apart

The pain point is direct: a tail class has very few training images, so the same handful of images reappears in every mini-batch, the network quickly memorizes them, and the synthesized results collapse onto the neighbourhood of those few training samples. The authors treat the latent of each noisy image in a mini-batch as an anchor; the positive sample of an anchor is the anchor itself (no data augmentation at all, which differs from most unsupervised contrastive learning), and every other sample in the batch is a negative. Plugging this into standard InfoNCE gives:

\[L_{\text{ucl}} = -\frac{1}{|B|}\sum_{i\in B}\log\frac{\exp(h_i^{\top} h_i/\tau)}{\exp(h_i^{\top} h_i/\tau)+\sum_{j\neq i}\exp(h_i^{\top} h_j/\tau)}\]

where \(h_i = e_\theta(x_i^t, t, \varnothing)\) is the normalized unconditional latent and the temperature \(\tau\) defaults to 0.1. Why does this improve diversity? The self-similarity in the numerator is always maximal and does not change under optimization, so minimizing the loss can only be achieved by lowering all the pairwise similarities in the denominator; geometrically, the optimum places the latents uniformly on a hypersphere. Conversely, in the worst case where all latents collapse to a single constant vector, the loss reaches its upper bound \(\log|B|\) and is explicitly penalized. Compared with supervised contrastive learning (which attracts same-class samples), it repels all samples regardless of class, thus enlarging both intra-class and inter-class image differences — exactly what tail classes lack. The authors also note that UCL is implemented together with batch resampling (a standard practice in long-tailed recognition and generation) and ablate the complementarity of this ingredient against the loss itself (see Tab. 4); in the motivation they point out that sampling from the original distribution with replacement makes tail samples repeat within a batch and further aggravates overfitting to the few tail images. ⚠️ The exact resampling scheme (class-balanced or not, with or without replacement) is given in Appendix A.1 and is not expanded in the main text.

2. AL: aligning conditional and unconditional denoising predictions at large timesteps to pass the data advantage of head classes to tail classes

A tail class cannot learn a good early denoising behaviour on its own: the initial stage of denoising is supposed to capture the generic structure of "what images of this kind roughly look like", yet a tail class has only a few dozen images as supervision. The authors' solution is to let the conditional and unconditional branches share the same behaviour at that step. Concretely, they penalize the KL divergence between the two reverse-process distributions, i.e. the conditional \(p_\theta(x_{t-1}|x_i^t, c_i)\) and the unconditional \(p_\theta(x_{t-1}|x_i^t)\). Since both are Gaussians with the same variance \(\sigma_t^2 I\), the KL retains only the squared difference of their means (everything else is a constant independent of the parameters); expanding the means with the DDPM parameterization, the means depend on the input only through the noise prediction \(\epsilon_\theta\), so the whole KL collapses into the squared distance between the two noise predictions. Averaging over the mini-batch and multiplying by the timestep weight \(t/T\) yields:

\[L_{\text{al}} = \frac{1}{|B|}\sum_{i\in B}\mathbb{E}_{t,x_0}\left[\frac{t}{T}\left\|\epsilon_\theta(x_i^t;t,c_i)-\epsilon_\theta(x_i^t;t,\varnothing)\right\|^2\right]\]

The linear weight \(t/T\) is the soul of this loss: the reverse process runs from \(t=T\) down to \(t=0\), so large \(t\) is precisely the initial stage of denoising. The alignment therefore acts only on the noisiest, most structural steps, while the detailed generation at small \(t\) remains fully controlled by the class condition — conditional controllability is not sacrificed. The authors acknowledge that "aligning conditional with unconditional generation" looks as if it would weaken control, and the weighting scheme is precisely their answer to that concern. Why does aligning early steps not harm conditional generation? The supporting evidence is a low/high-frequency decomposition observation (citing FreeU): starting from the same initial noise, the low-frequency components of different classes are nearly identical during the initial timesteps, so that step carries little class information anyway; making it class-agnostic instead lets tail and head classes share one early denoising behaviour. This is the diffusion counterpart of UTLO's idea on GANs — "use an unconditional objective at low resolution": low-resolution GAN representations ≈ large timesteps in diffusion.

3. Synergy of the two losses: writing the diversity of conditional latents as a mutual-information lower bound to bypass the trivial solution of direct conditional contrast

This is the paper's central argument against the concurrent Dispersive Loss and the key to understanding why the contrastive loss belongs on the unconditional branch. Denote the conditional latent by \(h_t^c = e_\theta(x_t, t, c)\). Information-theoretically, InfoNCE is a lower bound on the mutual information between data and representation, so minimizing InfoNCE amounts to maximizing mutual information. If InfoNCE were applied to \(h_t^c\) directly, the chain rule decomposes the objective into two terms (Eq. 2 of the paper): \(I(h_t^c; x, c) = I(h_t^c; c) + I(h_t^c; x|c)\). The first term measures how much the class condition reveals about the latent and corresponds to inter-class difference; only the second corresponds to intra-class difference — and it is the second that must be raised to cure tail-class mode collapse. The problem is that the first term \(I(h_t^c; c)\) admits a trivial solution: making the latents of all samples of a class identical drives it to the maximum, and the optimizer takes that shortcut first — producing exactly mode collapse.

Reversing the order of decomposition sidesteps the trap (Eq. 3 of the paper): \(I(h_t^c; x, c) = I(h_t^c; x) + I(h_t^c; c|x)\), where \(I(h_t^c; c|x)\) varies little during optimization and the dominant term is \(I(h_t^c; x)\), which is controlled by a lower bound expressed through the unconditional latent \(h_t^u = e_\theta(x_t, t, \varnothing)\) in a form like \(I(h_t^c; x) \ge I(h_t^u; x) + I(h_t^c; h_t^u) - H(h_t^u)\) (⚠️ this expression is incomplete after OCR of the original; it is reconstructed from the paper's prose, refer to the original paper for the exact symbols and form). Each loss then handles one side of the bound: UCL repels different samples in the unconditional latent space, raising \(I(h_t^u; x)\); AL pulls the conditional latent towards the unconditional latent, raising \(I(h_t^c; h_t^u)\). Together they raise the lower bound on the conditional latent's ability to preserve sample-level variation — the diversity of conditional generation is implicitly distilled in rather than explicitly demanded, as Dispersive Loss does; the ablation (loss breakdown in Tab. 5) confirms the empirical benefit of this indirect route.

Loss & Training

The total loss sums the standard DDPM denoising loss and the two proposed regularizers:

\[L = L_{\text{ddpm}} + \lambda_{\text{ucl}}\,L_{\text{ucl}} + \lambda_{\text{al}}\,L_{\text{al}}\]

During training, each sample randomly sends the DDPM term through either the conditional or the unconditional branch (classifier-free-guidance-style branch training), while AL requires one forward pass per branch. Key hyper-parameters: contrastive temperature \(\tau = 0.1\); the two weights \(\lambda_{\text{ucl}}\) and \(\lambda_{\text{al}}\) are swept on ImageNet-LT with 0.05/0.05 selected as optimal (⚠️ the notation of these two symbols differs across the paper's prose, algorithm box and tables after OCR; they are written uniformly as \(\lambda_{\text{ucl}}\) and \(\lambda_{\text{al}}\) here — refer to the original paper). The latent used by UCL comes from the \(N/4\)-th or the \(N\)-th block of SiT (\(N\) = total number of blocks). As for cost: AL requires two forward passes (conditional and unconditional), and with an optimized implementation training takes about 1.3× that of SiT, but there is zero extra inference cost.

Key Experimental Results

Main Results

With SiT (Diffusion Transformer) as the backbone on ImageNet-LT 256→256, higher is better for IS/Precision/Recall and lower is better for FID/sFID/FID_tail; parenthesized values are absolute improvements over the SiT baseline. FID_tail is the FID computed only over the tail classes of the dataset, the most important metric in the long-tailed setting.

Steps Method IS↑ FID↓ sFID↓ Prec.%↑ Recall%↑ FID_tail↓
250k SiT 53.9 33.8 22.6 54.5 19.1 52.8
250k CBDM 54.8 34.1 23.3 53.9 18.7 53.1
250k REPA 74.1 28.4 20.0 58.3 16.1 48.5
250k Dispersive Loss 53.8 34.0 22.6 54.8 19.8 54.5
250k CCUA (ours) 70.7 27.0 (−6.8) 20.5 60.2 20.1 37.0 (−15.8)
450k SiT 78.8 25.7 21.9 64.3 18.5 41.6
450k CBDM 84.0 24.7 21.8 64.6 18.7 40.7
450k REPA 105.9 21.9 19.5 65.7 15.2 39.7
450k Dispersive Loss 83.8 25.2 21.7 65.5 17.3 43.0
450k CCUA (ours) 111.9 19.4 (−6.3) 18.3 69.4 18.9 28.8 (−12.8)
700k SiT 103.1 21.2 20.1 69.3 18.2 35.4
700k CBDM 105.7 20.9 20.7 70.3 17.8 35.5
700k REPA 126.8 19.7 20.3 68.0 15.8 36.9
700k Dispersive Loss 104.0 21.3 20.4 68.0 18.5 35.9
700k CCUA (ours) 140.5 16.3 (−4.9) 17.2 73.9 18.4 24.5 (−10.9)
900k SiT 111.7 19.9 20.1 70.3 18.6 33.9
900k CBDM 117.2 19.4 20.2 72.5 17.7 32.7
900k REPA 137.8 18.1 19.3 69.8 16.2 33.8
900k Dispersive Loss 115.6 19.7 20.1 69.9 18.9 34.1
900k CCUA (ours) 153.1 15.1 (−4.8) 16.5 75.7 17.3 22.5 (−11.4)

With the U-Net backbone (DDPM), the authors report the same conclusion on TinyImageNet-LT 64→64 and Places-LT 64→64. DDPM†bal is a DDPM trained on the class-balanced version, given as a reference upper bound (green values indicate the gain of balanced over long-tailed training):

Dataset Method FID↓ FID_tail↓ KID×1k↓
TinyImageNet-LT DDPM†bal 15.7 (−3.0) 25.6 (−14.5) 3.2 (−3.1)
TinyImageNet-LT DDPM 18.7 40.1 6.3
TinyImageNet-LT CBDM 20.9 48.1 6.6
TinyImageNet-LT OCLT 17.7 39.7 5.6
TinyImageNet-LT CCUA (ours) 15.2 (−3.5) 30.4 (−9.7) 3.8 (−2.5)
Places-LT DDPM 13.9 23.7 5.3
Places-LT CBDM 15.2 26.1 5.6
Places-LT OCLT 13.0 22.8 4.2
Places-LT CCUA (ours) 12.0 (−1.9) 20.8 (−2.9) 3.6 (−1.7)

To locate where the gains land along the class distribution, the authors sort classes by the number of training images and split them into three super-categories: the top 33% as Head, the next 34% as Body, and the rest as Tail (on TinyImageNet-LT these hold 80%/17%/3% of the training images), reporting FID for each:

Dataset Method Head Body Tail All
TinyImageNet-LT DDPM 21.3 33.3 40.1 18.7
TinyImageNet-LT CBDM 24.1 35.0 48.1 20.9
TinyImageNet-LT OCLT 20.6 30.6 39.7 17.7
TinyImageNet-LT CCUA (ours) 21.3 28.0 30.4 15.2
Places-LT DDPM 19.3 20.3 23.7 13.9
Places-LT CBDM 21.3 21.7 26.1 15.2
Places-LT OCLT 19.2 19.4 22.8 13.0
Places-LT CCUA (ours) 18.2 19.3 20.8 12.0

Ablation Study

First, the complementarity of batch resampling and the CCUA loss (TinyImageNet-LT):

Config FID↓ FID_tail↓ KID×1k↓
DDPM (baseline) 18.7 40.1 6.3
+ Batch Resample 17.2 (−1.5) 33.6 (−6.5) 4.7 (−1.6)
\(L_{\text{ccua}}\) (loss only) 17.2 (−1.5) 37.9 (−2.2) 4.9 (−1.4)
\(L_{\text{ccua}}\) + Batch Resample 15.2 (−3.5) 30.4 (−9.7) 3.8 (−2.5)

Second, the breakdown of the two loss terms and the key hyper-parameters (ImageNet-LT 256→256, DiT-family backbone, all trained from scratch to 250k steps; "Latent block" is the block whose \(h\) feeds UCL, \(N/4\)-th or \(N\)-th):

Method \(\lambda_{\text{ucl}}\) \(\lambda_{\text{al}}\) Latent block IS↑ FID↓ sFID↓ Prec.%↑ Recall%↑
SiT (baseline) 0 0 — 53.9 33.8 22.6 54.5 19.1
CCUA 1.0 1.0 N/4 58.2 30.5 16.2 51.1 29.4
CCUA 0.1 0.1 N/4 70.3 27.3 18.8 59.2 21.3
CCUA 0.05 0.05 N/4 70.7 27.0 20.5 60.2 20.1
CCUA 0.01 0.01 N/4 69.7 27.6 19.3 60.7 19.9
CCUA (UCL only) 0.1 0 N/4 67.4 28.8 25.5 58.5 19.3
CCUA (AL only) 0 0.1 N/4 64.5 29.6 24.8 56.4 20.6
CCUA (UCL only) 0.05 0 N/4 69.2 27.7 19.9 59.4 20.6
CCUA (AL only) 0 0.05 N/4 68.4 28.2 19.5 58.8 21.6
CCUA 0.05 0.05 N 73.6 25.9 16.5 58.6 23.1

Key Findings

  • The gains land almost entirely on tail classes. At 900k steps FID drops from 19.9 to 15.1 (about 24% relative) while FID_tail drops from 33.9 to 22.5 (about 34% relative); for the 250k setting the paper summarizes this as "about 20% improvement on overall FID and 30% on IS and FID_tail", which matches the table exactly (−6.8/33.8≈20% and −15.8/52.8≈30%). The three-way class breakdown makes the point even clearer: on TinyImageNet-LT, Tail falls from 40.1 to 30.4 and Body from 33.3 to 28.0 while Head stays at 21.3; on Places-LT, Head actually improves from 19.3 to 18.2. The improvement is therefore not bought by sacrificing head classes.
  • Neither loss is dispensable. At the 0.05 setting, keeping only UCL gives FID 27.7 and keeping only AL gives 28.2, while enabling both gives 27.0; the gap is larger at the 0.1 setting (28.8 / 29.6 vs 27.3). Using AL alone means pulling the conditional branch towards an unconditional branch that has not been pushed apart, which limits its benefit and confirms that the order "disperse first, then align" is what matters.
  • The weights show a clear fidelity-diversity trade-off. Raising the weights from 0.05 to 1.0 sends Recall from 19.1 up to 29.4 (much more diversity) but degrades FID from 27.0 to 30.5 and Precision from 60.2 to 51.1; conversely, lowering them to 0.01 gives the highest Precision (60.7) while Recall falls back to 19.9. 0.05 is the authors' compromise on FID and IS.
  • Batch resampling and the proposed loss are complementary rather than substitutable. Each alone lowers FID from 18.7 to 17.2, and combining them lowers it further to 15.2 with FID_tail going from 40.1 to 30.4 — class-balanced sampling addresses how often tail samples appear in a batch, whereas CCUA addresses how far apart tail samples are pushed in latent space; they act at different points of the pipeline.
  • The method still wins at comparable training time. The paper notes that CCUA trains more slowly (see Limitations), so it compares 700k-step CCUA (FID 16.3) against 900k-step SiT (FID 19.9) at equal training time, and the baseline is still clearly behind.
  • ⚠️ Two caveats. First, in Tab. 5 taking the latent from the \(N\)-th block is actually better on FID/IS (25.9/73.6 vs 27.0/70.7 for \(N/4\)), yet the main experiments use the \(N/4\) setting and the paper does not explain the choice. Second, at 900k steps CCUA's Recall is slightly below SiT's (17.3 vs 18.6); the diversity advantage mainly holds between 250k and 700k, while Precision improves substantially over the same range (70.3→75.7). The authors do not discuss this single regression.

Highlights & Insights

  • Treating the unconditional branch as a diversity anchor rather than as a discarded conditional branch. The common view is that the unconditional branch is a by-product of CFG; this paper inverts its role: create diversity in the unconditional space first, then distill it into conditional generation via alignment. Because that space is class-agnostic, the diversity is inherently sample-level — exactly the missing ingredient for tail classes.
  • Using a mutual-information decomposition to decide which branch a contrastive loss belongs on is the most methodologically valuable step of the paper: the decomposition \(I(h_t^c;x,c) = I(h_t^c;c)+I(h_t^c;x|c)\) exposes the trivial solution on the conditional branch, and only the reordered form \(I(h_t^c;x)+I(h_t^c;c|x)\) yields an optimizable lower bound. This analytical framework transfers to any setting that wants a diversity regularizer on conditional generation, by indicating which pathway the regularizer should attach to.
  • The linear \(t/T\) timestep weight is a "good enough" trade-off. A single monotone weight confines alignment to the initial stage, preserving later conditional controllability while avoiding any new scheduling network or curriculum; the price is that the weight shape itself is not ablated (see Limitations).
  • A pure-loss solution with minimal deployment cost. No change to U-Net/DiT structure, no external teacher model (unlike REPA, which needs a frozen vision encoder), and zero inference overhead — only two extra terms in the training objective. This architecture-agnostic property lets it plug into both the DDPM and the SiT pipelines.

Limitations & Future Work

  • Admitted by the authors: AL requires two forward passes (conditional and unconditional), so training takes about 1.3× that of SiT; the good news is that inference latency is completely unchanged.
  • Not discussed by the authors but visible in the data: although tail-class FID improves greatly, it does not reach the balanced-data reference (30.4 vs DDPM†bal's 25.6 on TinyImageNet-LT), so the absolute tail-class quality gap caused by long-tailed data is not fully closed; the latent block used in the main experiments (\(N/4\)) is not the FID-optimal one in the ablation, leaving an unexplained mismatch between hyper-parameter choice and main results; and Recall at the longest training budget is slightly below the baseline, so the fidelity-diversity trade-off remains conservative.
  • Methodological limitations: the \(t/T\) linear weight is hand-specified and no ablation over the weight shape (constant, exponential, learnable) is provided; UCL is applied at a single layer (the \(N/4\)-th or \(N\)-th block) and multi-layer combinations are not explored; experiments are limited to class-conditional generation and do not cover text conditioning or larger-scale latent diffusion; the comparison with long-tailed diffusion methods such as DiROP is placed in Appendix A.3 without numbers in the main text.
  • Concrete improvement directions: replace \(t/T\) with a learnable or signal-to-noise-adaptive weighting function; extend UCL to several blocks with per-layer weights; combine with class-balanced sampling or loss reweighting (e.g. LDAM, class-balanced softmax) to see whether the balanced-data reference can be approached; and generalize the "unconditional anchor + alignment distillation" mechanism to text-conditioned generation (using the prompt-dropout branch as the unconditional anchor).
  • vs UTLO / Transitional-GAN (long-tailed GANs): they train low-resolution representations with an unconditional objective on GANs so that head and tail classes share knowledge; this paper ports the same idea to diffusion models, replacing "low resolution" with "large timesteps". The difference is that diffusion denoising is recursive, so the low-frequency structure at initial timesteps corresponds to but is not equivalent to a low-resolution representation; the paper supplies that argument with a low/high-frequency decomposition observation.
  • vs Dispersive Loss (concurrent work): it applies negative-only InfoNCE directly on conditional training, designed for class-balanced diffusion models; this paper puts the contrastive loss in the unconditional latent space and passes it implicitly to conditional generation through alignment, arguing via the mutual-information decomposition that the former has a trivial solution. The ablation (Tab. 5) shows enabling both terms is better than either alone.
  • vs CBDM: CBDM trains a second model (with pseudo-labels forming a uniform distribution) and minimizes the distance between the two models' estimated noise; this paper uses only the conditional and unconditional branches of a single model, requiring neither a second network nor a pseudo-labeling pipeline.
  • vs DiROP: DiROP treats image pairs of different classes as negatives and maximizes the distance between class distributions, but does not regularize images of the same class; this paper's UCL repels all samples regardless of class, thus enlarging both intra-class and inter-class differences and covering the half DiROP misses.
  • vs REPA: REPA aligns diffusion features with those of a frozen vision encoder to accelerate training, requiring an external model and targeting the balanced setting; this paper introduces no external model, regularizing the denoising network's own intermediate features and designing for the long-tailed distribution.
  • vs OCLT: OCLT addresses long-tailed diffusion with "oriented calibration"; on TinyImageNet-LT and Places-LT this paper beats it on all three of FID/FID_tail/KID (e.g. on Places-LT, 12.0 vs 13.0 and 20.8 vs 22.8).

Rating

  • Novelty: ⭐⭐⭐⭐ Translating head-tail knowledge sharing in long-tailed GANs from "low resolution" to "large timesteps", and using a mutual-information decomposition to justify why the contrastive loss belongs on the unconditional branch, is a clear perspective; but both losses are recombinations of existing tools.
  • Experimental Thoroughness: ⭐⭐⭐⭐ Covers ImageNet-LT/TinyImageNet-LT/Places-LT with both DDPM and SiT backbones, including hyper-parameters, loss breakdown, resampling and three-way class analysis; weaknesses are the modest model scale (at most 256×256), the DiROP comparison being relegated to the appendix, and the unexplained mismatch between the chosen latent block and the main results.
  • Writing Quality: ⭐⭐⭐⭐ The motivation chain and information-theoretic argument are complete and the tables match the claims, though some formulas and symbols are typeset confusingly in the main text and the notation differs between the algorithm box and the prose.
  • Value: ⭐⭐⭐⭐ Architecture-agnostic, zero inference overhead and cheap to adopt, and the paradigm of "unconditional branch as diversity anchor + alignment distillation" is transferable to other conditional generation tasks beyond long-tailed generation.