Show the Signal, Hide the Noise: Spectral Forcing for Pixel-Space Diffusion
Abstract: Pixel-space diffusion models are trained on full-bandwidth noisy images, yet the useful signal available to the denoiser is strongly frequency dependent. Under rectified-flow diffusion and natural-image power-law spectra, the per-band data-to-noise contour $k{*}(t) = (1-t){-2/α}$ separates a signal-bearing low-frequency region from a noise-dominated high-frequency region at each time $t$. We show that this implicit coarse-to-fine structure is not merely descriptive: it induces a capacity-allocation problem. A standard pixel-space denoiser must discover the moving bandwidth boundary internally and can spend computation on frequency-time regions where the optimal prediction collapses to deterministic baselines rather than data-distribution modeling. To make this boundary explicit, we introduce Spectral Forcing, a parameter-free, time-conditional 2D-DCT low-pass operator applied to the noisy input before the patch embedder. Its cutoff expands monotonically with the diffusion time and becomes the identity at the data endpoint. Through controlled synthetic experiments, we identify the regime in which the operator is beneficial: coarse patch tokenization and data whose high-frequency content is predominantly noise rather than essential signal. On ImageNet-256 with JiT-700M/32, Spectral Forcing consistently improves both FID and Inception Score across different training epochs, demonstrating robust gains throughout training; at finer tokenization, the spectral forcing is still competitive. We further insert the unchanged operator into SenseNova-U1, a unified text-to-image model, where it improves DPG-Bench and GenEval, showing that the input-side spectral prior transfers beyond class-conditional generation. These results suggest a route to capacity-efficient pixel-space diffusion by showing the signal and hiding the noise.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Clear, Simple Summary of “Show the Signal, Hide the Noise: Spectral Forcing for Pixel-Space Diffusion”
Overview of the paper
This paper is about teaching image-generating AI models to pay attention to the useful parts of an image and ignore the noisy parts, at the right times during training. The authors add a simple, no-extra-parameters “filter” to the model’s input that starts by hiding tiny, noisy details and then gradually reveals them as training goes on. This helps the model learn big, important patterns first and fine details later—much like how you’d sketch the outline of a drawing before adding textures.
What questions did the researchers ask?
- Can we make image models learn in a clearer “big-to-small” (coarse-to-fine) order by gently hiding tiny, noisy details early and revealing them later?
- Will this make models use their brainpower (capacity) more efficiently, instead of wasting effort on parts of the image that are mostly noise?
- When does this idea help the most, and when does it not help (or even hurt)?
How did they study it? (Methods explained simply)
Modern image generators (diffusion or flow models) learn by starting from pure noise and stepping toward a clean image. At each step, the model sees a mix: some real image signal plus some noise. Early on, the noise is strong, so only big shapes are visible; later, noise fades, and small details become visible.
- Think of images as made up of “notes” from low (big, smooth shapes) to high (tiny, sharp details). In the early steps, high notes (tiny details) are drowned out by noise—so trying to learn them is a waste.
- The authors measure where the useful signal lives using a simple rule: at each time step, there’s a cutoff line between “signal you can trust” (lower frequencies) and “noise that’s not helpful yet” (higher frequencies). That cutoff grows outward as training progresses.
What they add:
- Spectral Forcing (SF): a tiny input filter that works like an adjustable pair of glasses.
- Early in training: the glasses blur out super-fine details (which are mostly noise anyway).
- As training goes on: the glasses clear up and reveal more and more detail.
- By the end: the glasses are fully clear (no filter), so the model can handle all details.
- How it’s done under the hood:
- They use the 2D-DCT, a standard way to split an image into “low” and “high” frequency parts (like separating slow waves from fast ripples).
- They multiply the high-frequency part by a soft mask that starts strict (blocks tiny details) and gradually relaxes (lets them through).
- Importantly, this adds no new trainable parameters, barely adds any compute, and doesn’t change the model’s training recipe or sampler.
What did they find and why is it important?
Key results from controlled tests and large-scale experiments:
- The “wedge” pattern: Without any filter, models naturally do real learning only in a wedge-shaped region of “time vs. frequency.” Outside that wedge, the best they can do is a simple, almost trivial guess (because the details are just noise there). That means they’re wasting capacity trying to model something that isn’t learnable yet.
- Spectral Forcing helps when:
- The model uses big patches (fewer tokens), which already limits how much detail it can process. In this case, hiding extra noisy detail early frees the model to focus on what matters.
- The dataset’s very fine details are mostly noise (like with many natural images).
- Spectral Forcing does not help (and can hurt) when:
- The model uses very small patches (many tokens), so it needs high-frequency details earlier.
- The task heavily depends on sharp edges or tiny details (where high frequencies carry essential information).
- On ImageNet-256 (a standard test set), with large models that use big patches (64 tokens), Spectral Forcing consistently improved image quality scores (lower FID is better, higher Inception Score is better). It also reached strong results in fewer training epochs, meaning faster training to the same quality.
- Even in text-to-image generation (a different but related task), the same input filter improved benchmark scores without any special tuning.
What does this mean for the future? (Implications)
- Better use of model capacity: By “showing the signal and hiding the noise,” the model spends its effort where it counts, especially early in training.
- Faster and simpler upgrades: The method is drop-in (no new parameters, minimal compute cost), so it’s easy to add to many pixel-based diffusion/flow models.
- Clear guidance on when to use it:
- Best: big patches (few tokens) and image data where the finest details are mostly noise.
- Neutral or risky: very fine patching (many tokens) or tasks where tiny sharp details are essential from the start.
- Broader impact: This approach can help both pure image generators and unified text–image models become more efficient and possibly reduce training time and cost.
In short, the paper shows a simple, practical way to help image models learn like a good artist: focus on big shapes first, then refine the details—at just the right times.
Knowledge Gaps
Below is a single, consolidated list of concrete knowledge gaps, limitations, and open questions that remain unresolved by the paper. Each item is phrased to be directly actionable for future research.
- Theory beyond rectified-flow: establish a formal derivation of the optimal cutoff schedule for diffusion variants other than rectified-flow (e.g., VP/VE SDEs, EDM preconditioning, ε- and x0-prediction), including the corresponding per-band data-to-noise contour and whether the SF rationale still holds.
- Dataset- and class-conditional spectra: develop robust procedures to estimate and per dataset or per class (and ideally online during training), and test whether schedules tailored to these estimates outperform the fixed linear schedule.
- Per-sample adaptivity: investigate learned or adaptive per-sample/per-batch cutoff schedules c(t) (e.g., via a small controller predicting c(t) from z_t and t) to avoid over-masking samples with essential high-frequency content.
- Anisotropic/locally adaptive masks: the current global radial mask ignores orientation and locality; evaluate anisotropic (direction-aware) and spatially varying frequency masks (e.g., steerable filters, wavelets, local DCTs) that can preserve edges and text while suppressing noise-dominated bands.
- Essential high-frequency regimes: rigorously characterize when SF harms performance (e.g., line art, text rendering, medical imaging, remote sensing) and design mitigations such as content-aware relaxation of the mask or late-stage unmasking.
- Diversity vs fidelity trade-offs: Analytical-SF at 256 tokens maintained FID but reduced IS; quantify how different schedules affect class coverage, precision/recall, and calibration, and identify strategies (e.g., schedule annealing, conditional cutoffs) to prevent diversity loss.
- Architectural generality: validate SF across non-JiT architectures (U-Nets, DiTs with different preconditioning, hybrid conv-transformers) to confirm whether the capacity-allocation benefits generalize beyond large-patch transformers.
- Resolution and token-count scaling laws: provide systematic scaling studies (to 512, 1024, 2k+) that factor both resolution and token count to isolate when SF transitions from helpful to neutral/harmful, and whether Analytical-SF becomes preferred at high resolutions.
- Forward-process compatibility at inference: test whether SF trained under rectified-flow transfers to samplers with different discretizations or guidance strategies (e.g., higher CFG, consistency sampling), and whether any schedule adjustments are needed.
- Beyond ImageNet-256: evaluate on additional datasets and tasks (COCO, LAION subsets, OpenImages, FFHQ, LSUN, AFHQ) to establish external validity and quantify class- or domain-specific effects, especially where high-frequency semantics matter.
- Text-to-image breadth: current VLM evidence uses a single model and early training; extend to multiple text-to-image backbones and standard benchmarks (e.g., COCO captions, DrawBench, T2I-CompBench, Pick-a-Pic) at converged budgets to assess generalization and text fidelity.
- Downstream conditioning tasks: study SF for inpainting, super-resolution, editing, and control (e.g., ControlNet-like constraints), including whether the mask interferes with high-frequency constraints (edges, strokes) and how to adapt c(t) in these settings.
- Per-band learning dynamics: directly measure how SF changes gradient norms, learned filters, and per-band error over time; verify that capacity is reallocated from noise-dominated bands to the signal-recovery wedge rather than merely regularizing training.
- Objective mismatch analysis: quantify any bias introduced by masking inputs while keeping the velocity target unchanged, particularly near , and explore target-side or loss reweighting adjustments that could better align with the masked inputs.
- DCT-specific artifacts: assess potential ringing/ Gibbs phenomena, boundary-condition sensitivities, and color-channel coupling in the global 2D-DCT; test alternative transforms (DFT, DWT, steerable pyramids) and color spaces (YCbCr) with channel-specific cutoffs.
- Mask hyperparameters: systematically ablate c_min, c_max, transition sharpness κ, and schedule shapes (beyond linear/analytical) to map robust defaults and dataset-dependent tuning guidelines; explore soft-to-hard mask annealing.
- Interaction with patch embedding: co-design patchify and SF (e.g., anti-aliased patchify, joint mask/patch schedules) to avoid redundant bandlimiting and quantify the net gains under fixed token budgets.
- Learnable vs fixed masks: compare fixed SF with small learnable frequency gates that are time-conditional but parameter-light; investigate regularizers that keep learned masks close to the analytical front while allowing data-driven deviations.
- Precision/recall and perceptual metrics: complement FID/IS with precision/recall, KID, LPIPS/DISTS, CLIPScore, and human preference studies to detect subtle detail loss or artifacts not captured by FID/IS.
- Sampling efficiency: test whether SF enables fewer sampling steps (e.g., via distillation or higher-order solvers) without quality loss, and whether the time-dependent masking suggests coarser early integration grids.
- Robustness to preprocessing and augmentations: evaluate the impact of resizing/antialiasing, JPEG compression, and common data augmentations on P(k), α estimation, and SF efficacy; propose augmentation-aware schedules.
- Latent-space extensions: investigate whether analogous “latent spectral forcing” (pre- or post-autoencoder) can provide similar benefits in latent diffusion, and how the latent spectral statistics affect schedule design.
- Automated regime detection: provide a diagnostic tool (e.g., wedge analysis from a small probe model or early-training per-band MSE) that predicts ex-ante whether SF will help on a new dataset/architecture/tokenization.
- Fairness and category bias: analyze whether SF introduces category-dependent performance shifts (e.g., benefiting low-frequency classes while harming high-frequency ones), and design category- or content-aware schedules to mitigate bias.
- Engineering at scale: profile memory/throughput of the DCT/IDCT at high resolutions and video; optimize CUDA kernels or adopt tiled/local DCTs to keep overhead negligible in large-batch, multi-node training.
Practical Applications
Immediate Applications
Below are actionable use cases that can be deployed now, leveraging the paper’s parameter-free, time-conditional 2D-DCT low-pass “Spectral Forcing” (SF) operator for pixel-space diffusion and unified text–image models.
- Drop-in training adapter to improve pixel-space diffusion quality and time-to-target
- Sectors: software/AI, media/entertainment, gaming, e-commerce (creative assets)
- What it enables: Improved FID and Inception Score with negligible overhead (~0.5% per step), and fewer epochs to reach target quality (e.g., JiT-700M/32: FID 24.19 → 20.68, +14.5%; 17–33% fewer epochs to matched FID).
- Tools/workflows:
- Add a pre-embedder 2D-DCT low-pass module with a monotonic schedule (linear default) to existing pixel-space rectified-flow pipelines.
- No changes to forward process, loss, EMA, sampler, or CFG; integrate as a lightweight input adapter in PyTorch/JAX training code.
- Assumptions/dependencies:
- Pixel-space rectified-flow diffusion; coarse image tokenization (e.g., ~64 tokens at 256×256); data where high-frequency content is mostly noise.
- For edge-rich or fine-token regimes (e.g., 256 tokens), effect is neutral to small.
- Faster, higher-quality pretraining of unified text–image models under small image-token budgets
- Sectors: software/AI (multimodal foundation models), education technology, creator tools
- What it enables: Better early-stage text-to-image quality where image tokens must be kept small; demonstrated improvements on DPG-Bench and GenEval by inserting the unchanged SF operator into a native VLM (SenseNova-U1).
- Tools/workflows:
- Use SF for stage-1 training of unified VLMs that process raw image patches directly (e.g., 64 tokens), improving coarse-to-fine semantics and content fidelity.
- Assumptions/dependencies:
- Coarse tokenization; frequency profile similar to natural images (power-law); schedule choice tuned (linear default works robustly at 256×256).
- Compute and energy savings for training budgets
- Sectors: industry R&D, cloud/compute providers, sustainability/ESG teams
- What it enables: Lower wall-clock and energy to quality targets (e.g., matching a 90/120/145-epoch baseline in 60/90/120 epochs); contributes to “Green AI” goals.
- Tools/workflows:
- Adopt SF as a default for coarse-token pixel-space diffusion; track FID/IS vs. epochs; use built-in scheduling to avoid constant low-pass pitfalls.
- Assumptions/dependencies:
- Benefits are strongest when high-frequency bands are noise-dominated and patch sizes are coarse relative to the signal-bearing bandwidth.
- Spectral diagnostics to guide architecture and tokenization choices
- Sectors: academia, industry R&D (modeling/efficiency teams)
- What it enables: The “wedge” diagnostic (per-band MSE vs. trivial predictors) reveals wasted capacity regions; guides patch size, schedule, and token budget decisions.
- Tools/workflows:
- Add per-band MSE heatmaps during training checkpoints; integrate with experiment dashboards; estimate dataset spectral slope α to inform schedules.
- Assumptions/dependencies:
- Access to validation data and model outputs; sufficient instrumentation for DCT-based diagnostics.
- Quality and stability boosts in early-stage training (“cold start”)
- Sectors: model development teams across creative AI, ads, product design
- What it enables: Consistent quality gains early (e.g., +11.6% FID at 15 epochs for JiT-130M/32), accelerating iteration on prompts, classes, and prompts-to-UI pipelines.
- Tools/workflows:
- Enable SF from day 1 with the linear schedule; gradually evaluate whether to keep it through to convergence.
- Assumptions/dependencies:
- Coarse tokens; natural-image-like data spectra.
- Integration into open-source diffusion toolchains
- Sectors: open-source ecosystems, applied ML groups
- What it enables: Reusable SF components (operator + schedules) packaged for Hugging Face Diffusers or similar, with default linear scheduling and optional analytical schedule.
- Tools/workflows:
- Publish a small library with: (a) DCT/IDCT kernels; (b) schedule registry; (c) config hooks for patch-embedders; (d) monitoring of passband over time.
- Assumptions/dependencies:
- Efficient DCT/IDCT implementations; configuration interfaces for pre-embedder hooks.
- Improved on-device or resource-constrained generative prototypes (training-side gains)
- Sectors: mobile software, XR/AR prototyping, robotics labs (simulation imagery)
- What it enables: Train coarse-token pixel-space generators more efficiently; deploy improved checkpoints with minimal inference overhead (+0.5%).
- Tools/workflows:
- Use SF during training to achieve better quality under tight budgets; ship models without changing runtime architecture.
- Assumptions/dependencies:
- Training is the primary bottleneck; inference budgets can tolerate the minimal DCT cost if SF is kept at sampling time.
- Curriculum-like coarse-to-fine generation without modifying samplers or losses
- Sectors: research/education, rapid prototyping
- What it enables: Enforce an explicit coarse-to-fine curriculum through the input, preserving standard rectified-flow training and sampling.
- Tools/workflows:
- Choose between linear/cosine/analytical schedules; monitor for starvation at very small cutoffs; ensure mask becomes identity at t=1.
- Assumptions/dependencies:
- Correct schedule selection; avoid constant low-pass (harms convergence).
Long-Term Applications
These opportunities require additional research, scaling, or domain adaptation.
- Modality extensions: audio, video, and 3D with spectral gating
- Sectors: media tech (audio synthesis), film/gaming (video), digital twins/3D
- What it enables: Apply SF principles with STFT (audio), 3D-DCT (video), or spectral operators for 3D data; encourage capacity-efficient coarse-to-fine denoising.
- Tools/workflows:
- Derive per-band DNR for each modality’s forward process; design time-conditional masks that saturate to identity at the endpoint.
- Assumptions/dependencies:
- Need to re-derive data-to-noise contours per modality; verify when high-frequency bands are noise-dominated.
- Adaptive or learned spectral gates (data- and content-aware schedules)
- Sectors: software/AI, foundation model research
- What it enables: Per-sample or per-batch schedules that adjust pass-bands based on content (e.g., edge density) or dynamic estimates of α.
- Tools/workflows:
- Add small policy networks to predict cutoff c(t) from z_t; retain zero-parameter baseline as fallback; calibrate to avoid starving gradients.
- Assumptions/dependencies:
- Extra complexity and potential instability; careful regularization and monitoring required.
- Generalization beyond rectified-flow to other noise schedules (DDPM/SDE)
- Sectors: diffusion research, production model teams using legacy samplers
- What it enables: SF-like operators for alternative forward processes by re-deriving DNR contours and corresponding schedules.
- Tools/workflows:
- Analytical mapping from conventional SNR to per-band DNR; implement schedule transforms tailored to the chosen noise schedule.
- Assumptions/dependencies:
- Theoretical derivations and empirical validation across samplers.
- Edge- and structure-aware spectral forcing for edge-rich domains
- Sectors: CAD/BIM, document synthesis, medical/remote-sensing (with caution)
- What it enables: Preserve essential high-frequency edges/lines while still hiding noise-dominated bands.
- Tools/workflows:
- Combine edge detectors or learned importance maps with SF masks; hybrid pass-bands that protect sharp structures.
- Assumptions/dependencies:
- High-frequency content is often essential; naïve SF can degrade quality—requires domain-specific safeguards.
- Joint design of patchification and spectral forcing for smaller, faster models
- Sectors: applied ML engineering, edge AI
- What it enables: Co-optimize patch size, token count, and schedules to minimize tokens/backbone size while maintaining quality.
- Tools/workflows:
- AutoML sweeps over (patch size, token count, schedule); wedge diagnostics as constraints; parameter-efficiency tracking.
- Assumptions/dependencies:
- Trade-offs differ across datasets/resolutions; requires extensive experimentation.
- Hardware acceleration of spectral gating
- Sectors: chip design, systems/compilers
- What it enables: Kernel-level DCT/IDCT and mask ops (or FFT-based) fused into training/inference stacks to reduce overhead below 0.5%.
- Tools/workflows:
- CUDA kernels, Triton/TensorRT plugins, or on-silicon DCT primitives; operator fusion with patch embedding.
- Assumptions/dependencies:
- Engineering investment; benefit scales with model deployment footprint.
- Standards for spectral efficiency metrics and reporting
- Sectors: policy, benchmarking consortia, research conferences
- What it enables: Reporting per-band MSE “wedge” plots, α estimates, and compute-to-quality curves; encourages transparent, energy-aware practices.
- Tools/workflows:
- Add spectral diagnostics to benchmark suites; document schedule choices and tokenization regimes.
- Assumptions/dependencies:
- Community consensus on metrics; reproducibility infrastructure.
- Robustness and safety: mitigating high-frequency artifacts/adversarial noise
- Sectors: safety/robustness research, enterprise AI
- What it enables: Reduce sensitivity to high-frequency noise during generation or editing; potentially fewer ringing/aliasing artifacts.
- Tools/workflows:
- Integrate SF during training for robustness; evaluate against adversarial or sensor-noise tests.
- Assumptions/dependencies:
- Must ensure semantic fidelity isn’t harmed; benefits may vary with domain and tokenization.
- Dataset curation and augmentation informed by spectral analysis
- Sectors: data engineering, applied research
- What it enables: Use DNR and wedge diagnostics to identify noise-dominated bands; tailor augmentations or filtering to reduce sensor noise or aliasing.
- Tools/workflows:
- Compute α per dataset/subset; flag classes with atypical spectra; refine pipelines accordingly.
- Assumptions/dependencies:
- Requires spectral profiling of data sources; risk of over-filtering if domain-specific high-frequency details matter.
- Latent-space analogs and cross-domain forcing
- Sectors: diffusion in latents, multimodal tokenizers
- What it enables: Adapt SF ideas to latent representations (e.g., “latent forcing”) or to tokenizer frequency biases; unify coarse-to-fine priors across spaces.
- Tools/workflows:
- Map latent frequency axes to meaningful bands; design time-conditional gates compatible with latent decoders.
- Assumptions/dependencies:
- Latent spectra differ from pixel spectra; needs careful theoretical and empirical work.
Notes on Feasibility and Regime Boundaries
- Most effective when:
- Image tokens are coarse (e.g., ~64 tokens at 256×256) and high-frequency content is predominantly noise.
- Natural-image-like power-law spectra (α≈2.8 on ImageNet-256) hold reasonably.
- Linear time schedule is used at 256×256; analytical schedule becomes more favorable as resolution increases.
- Potentially neutral or harmful when:
- High-frequency content is essential (technical drawings, sharp edges, some medical or remote-sensing domains).
- Token counts are high (e.g., 256 tokens) such that patchify does not bandlimit input; observed neutral to slight effects on FID/IS.
- Constant low-pass is used (never saturates to identity) or overly aggressive early cutoffs starve gradients.
- Implementation dependencies:
- Efficient 2D-DCT/IDCT kernels; schedule hyperparameters (c_min, c_max, schedule shape) exposed in config.
- Compatible with rectified-flow; for other noise schedules, re-derive per-band DNR and schedules.
Glossary
- 2D-DCT: The two-dimensional Discrete Cosine Transform used to represent images in the frequency domain. "we introduce Spectral Forcing, a parameter-free, time-conditional 2D-DCT low-pass operator applied to the noisy input before the patch embedder."
- Analytical schedule: A time-varying cutoff schedule derived from theory that tracks the data–noise boundary as . "The analytical schedule, with the appropriate normalization, is the bandwidth front itself"
- Bandwidth front: The frequency boundary separating signal-dominated from noise-dominated bands at time . "Its unit level set gives a closed-form bandwidth front, , above which noise dominates the data spectrum."
- Blurring diffusion: A diffusion variant that replaces Gaussian noise with progressive blurring governed by the heat equation. "Blurring diffusion~\citep{rissanen2022ihdm,hoogeboom2023blurring} replaces the Gaussian forward with a heat-equation blur"
- Classifier-free guidance (CFG): A sampling technique that steers generation without an explicit classifier by conditioning on null/real prompts. "Sampling integrates from to $1$ with a Heun integrator and classifier-free guidance."
- Closed-form denoising: A regime where the optimal prediction reduces to a deterministic, analytical mapping rather than learning the data distribution. "closed-form denoising (low , high )"
- Data-to-noise ratio (DNR): The ratio of clean data power to additive noise power at each frequency band and time. "we define the per-band data-to-noise ratio (DNR) as"
- DCT-II radius: The radial index in DCT-II frequency space used to define a circular pass-band. "r(u, v) is the normalized DCT-II radius"
- DCTDiff: A frequency-domain diffusion approach that operates directly in DCT coefficient space. "DCTDiff~\citep{lin2024dctdiff} (model in DCT space)"
- DiT: Diffusion Transformer, a transformer-based architecture for diffusion models. "a 2D DiT (M params)"
- EMA (Exponential Moving Average): A running average of model parameters used for more stable evaluation and sampling. "with logit-normal at training and EMA weights at inference."
- FID (Fréchet Inception Distance): A metric comparing distributions of generated and real images via activations of an Inception network. "SF reduces FID from $24.19$ to $20.68$"
- Focal Frequency Loss: A loss that reweights errors in the frequency domain to emphasize specific frequencies. "Focal Frequency Loss~\citep{jiang2021focal} reweights $(v - v_{\mathrm{pred})$ in frequency"
- Flow matching: A training objective where a model learns the velocity field that transports noise to data. "a flow-matching model is trained"
- Heun integrator: A second-order numerical integrator (improved Euler method) used to solve ODEs during sampling. "Sampling integrates from to $1$ with a Heun integrator and classifier-free guidance."
- IDCT (Inverse Discrete Cosine Transform): The inverse transform that maps DCT coefficients back to the spatial domain. "SF_t(z) = \IDCT!\left( \DCT(z) \odot M(t) \right)"
- Inception Score: A generation metric measuring image quality and diversity via a pretrained Inception classifier. "improves Inception Score from $83.28$ to $93.96$"
- Latent diffusion: Diffusion performed in a compressed latent space produced by an autoencoder rather than directly on pixels. "Latent diffusion compresses images via separately trained autoencoders"
- Logit-normal (time sampling): A distribution for sampling diffusion times where the logits of are normally distributed. "with logit-normal at training"
- Patch tokenization: Representing images as non-overlapping patches (tokens) for transformer processing. "in particular through coarse patch tokenization and large transformer backbones"
- Pixel-space diffusion: Diffusion models that operate directly on pixel values instead of latent codes. "Pixel-space diffusion models are trained on full-bandwidth noisy images"
- Power-law spectrum: A spectral distribution where power decays as a power of frequency, typical of natural images. "natural-image power-law spectra"
- Radial 2D-DCT spectrum: The power spectrum of an image aggregated over circular (radial) frequency bins in DCT space. "We approximate the radial 2D-DCT spectrum of natural images by"
- Rectified-flow: A deterministic interpolation framework for diffusion/flow models where . "Under rectified-flow diffusion"
- Spectral Forcing (SF): An input-side, parameter-free, time-conditioned low-pass mask in DCT space that reveals signal-dominated frequencies. "We introduce Spectral Forcing (SF), a parameter-free time-conditional 2D-DCT low-pass mask applied to the network input before the patch embedder"
- Time-conditional: Conditioned explicitly on the diffusion time step, allowing operations to vary with . "a parameter-free, time-conditional 2D-DCT low-pass operator"
- Velocity target: The ground-truth velocity field used to train flow-matching models. "The per-sample velocity target is"
- Zero-predictor baseline: A trivial predictor that outputs zeros, used to diagnose whether the model learns beyond baseline. "zero-predictor baseline"
Collections
Sign up for free to add this paper to one or more collections.