Preserve Your Own Correlation: A Noise Prior for Video Diffusion Models

In plain words

Image generators that work by denoising are trained on single pictures. To make video, the usual shortcut is to take such a generator and teach it to produce several frames at once. The catch is that the random starting noise for each frame is drawn independently, while the noise that the image model actually learned from real photos of one video is strongly alike from frame to frame. The model then has to unlearn that similarity during training.

The paper keeps the frames' starting noise correlated. Frames from the same clip begin from noise that looks related, so the pretrained image knowledge carries over more easily. The authors offer two ways to build this noise, one that mixes a shared part with a per-frame part and one that chains each frame to the previous one. Training on a large mix of image and video data then produces video that looks better than the baselines the authors compare against, and it is reported by the authors to need far less training compute than an earlier video diffusion model.

TL;DR

• Starts from a pretrained text-to-image diffusion model (eDiff-I) and finetunes it jointly on images and videos §4.
• Replaces i.i.d. per-frame noise with correlated noise: mixed (eq. 3) or progressive (eq. 4), controlled by one number α.
• Large-scale model: a 16-frame base at 64×64, two upsampling stacks, 1.08B + 1.08B + 313M parameters §5.1.
• Author-reported best zero-shot results on UCF-101 and MSR-VTT. No official code found.

Problem

Large text-to-video diffusion models trained from scratch are costly: the authors cite hundreds of high-end accelerators and several weeks of training for prior work §1. Finetuning from an image model is cheaper, but finetuning with the standard i.i.d. noise prior forces the model to forget the frame-to-frame noise correlation that the image model had learned from real frames §1, §4. The authors measure this correlation: the average cosine similarity of reversed noise is 0.206 ± 0.156 for frames of the same video and 0.001 ± 0.009 across videos tab. 1.

Method

Denoiser and training §3. The paper uses the EDM formulation of Karras et al. Its denoiser D takes a noisy video x, a text embedding e and a noise level σ, and is parameterised with preconditioning (see the pseudocode below). Training minimises a λ(σ)-weighted squared error between the denoised and clean video eq. 1. The noise level is log-normally distributed, with mean −1.2 and standard deviation 1.2 for ln σ, and σ_data = 0.5 §3.

Sampling §3. Sampling integrates the probability-flow ODE from σ_max down to 0, starting from N(0, σ_max² I) eq. 2. The paper uses DEIS and its stochastic variant §3, app. A.3. The value of σ_max is not stated.

Correlated noise §4. The paper's key change is in the noise, not the network. Let α ≥ 0 control the correlation; α = 0 gives i.i.d. noise, and α → ∞ gives the same noise for all frames, which the paper reports produces a frozen video §4.

• Mixed noise eq. 3. Each video has one shared noise map and one independent map per frame. The shared part has variance α²/(1+α²) and the per-frame part has variance 1/(1+α²), so each frame stays at unit variance.
• Progressive noise eq. 4. The first frame is standard normal. Each later frame is α/√(1+α²) times the previous frame's noise plus an independent part with variance 1/(1+α²). The variance again stays at one.

Two properties follow directly from these equations and are our derivation, not statements in the paper: under mixed noise every pair of frames has correlation α²/(1+α²); under progressive noise adjacent frames have correlation α/√(1+α²), and frames k steps apart have that value raised to the power k.

Architecture §4, app. A.1, app. A.4. The large-scale model is a cascade of four networks.

• Base: 16 frames at 64×64 with a frameskip of 5, giving frames {1, 6, …, 76} §4.
• Temporal interpolation: produces 76 frames at 64×64 §4. It has the same architecture as the base and is initialised from a base checkpoint after the base has been finetuned for some time (duration not stated) app. A.1 (6).
• Two spatial super-resolution stacks: 76×256×256 and 76×1024×1024 §4. The super-resolution model is stated to have 313M parameters §5.1; the text does not say whether both stacks have that size.

The base and the spatial super-resolution models are initialised from eDiff-I §4. The U-Net is adapted as follows app. A.1:

1. 2D convolutions become 3D by adding a temporal dimension of size 1.
2. Temporal attention layers are added. Their output projection is zero-initialised, and temporal attention is applied to the feature maps with the spatial axis moved into the batch axis.
3. Spatial attention is also applied to feature maps with the temporal axis moved into the batch axis, including the maps fed into GroupNorm.
4. Each efficient block of the super-resolution model is followed by an extra temporal convolution with kernel 3×1×1 app. A.1 (4).
5. Cross-attention to text is used only in spatial blocks, because adding it to temporal attention caused significant memory overhead.
6. Images and videos are jointly trained by concatenating them on the time axis; temporal modules act only on the video part §4, app. A.1 (7).
7. Two text encoders, T5 and CLIP, are used; each is dropped independently at random during training, as in eDiff-I §4.

The temporal interpolation input is described as 16 frames with 4 real frames infilled with zero frames app. A.1 (3). The text does not state how the other frames are filled in.

Model sizes for the small-scale UCF-101 study are 69M, 112M and 253M parameters §5.1. The large-scale base and temporal interpolation models have 1.08B parameters each §5.1. The VDM baseline has 1.2B parameters §5.1.

Pseudocode. Correlated noise, mixed eq. 3 and progressive eq. 4:

# Mixed correlated noise  [eq. 3]
# alpha >= 0; per-frame shape (C, H, W); returns (T, C, H, W)
def mixed_video_noise(num_frames, frame_shape, alpha):
    # Variance split keeps every frame at unit variance  [eq. 3]
    shared_var = alpha**2 / (1 + alpha**2)
    individual_var = 1 / (1 + alpha**2)
    # One noise map shared by all frames of the video  [eq. 3]
    shared = sqrt(shared_var) * randn(frame_shape)
    # Independent noise for each frame  [eq. 3]
    individual = sqrt(individual_var) * randn(num_frames, *frame_shape)
    # Each frame is the shared part plus its own part  [eq. 3]
    return shared + individual

# Progressive correlated noise  [eq. 4]
# alpha >= 0; per-frame shape (C, H, W); returns (T, C, H, W)
def progressive_video_noise(num_frames, frame_shape, alpha):
    # Weight on the previous frame's noise  [eq. 4]
    decay = alpha / sqrt(1 + alpha**2)
    # Std of the fresh noise added at each step  [eq. 4]
    fresh_std = sqrt(1 / (1 + alpha**2))
    # The first frame is standard normal  [eq. 4]
    frames = [randn(frame_shape)]
    for i in range(1, num_frames):
        # Each frame perturbs the previous frame's noise  [eq. 4]
        fresh = fresh_std * randn(frame_shape)
        frames.append(decay * frames[i - 1] + fresh)
    return stack(frames)

One denoising training step, with the paper's preconditioning §3 and loss eq. 1:

# One training step  [§3] [eq. 1]
# clean_video (T, C, H, W); sigma_data = 0.5
def training_loss(clean_video, text_embedding, alpha):
    # Draw the noise level from a log-normal distribution  [§3]
    sigma = exp(normal(mean=-1.2, std=1.2))
    # Correlated noise: mixed or progressive  [eq. 3] [eq. 4]
    noise = correlated_noise(clean_video, alpha)
    noisy_video = clean_video + sigma * noise
    # Preconditioning of the denoiser  [§3]
    sigma_star = sqrt(sigma**2 + sigma_data**2)
    scaled_input = noisy_video / sigma_star
    raw = network(scaled_input, text_embedding, log(sigma) / 4)
    denoised = (sigma_data / sigma_star)**2 * noisy_video
    denoised += sigma * sigma_data / sigma_star * raw
    # Loss weight lambda(sigma)  [§3] [eq. 1]
    weight = (sigma**2 + sigma_data**2) / (sigma * sigma_data)**2
    # Reduction over elements is not stated
    return weight * mean((denoised - clean_video)**2)

Here correlated_noise means the mixed or progressive function above. The independent dropout of the text embeddings §4 and the sampler are not shown.

Hyperparameters

Large-scale text-to-video app. A.3, tab. hyperparams in app. A.3:

Small-scale UCF-101 app. A.3:

Small-scale architectures app. A.4:

Shared across these: attention resolutions [32, 16, 8] for self, cross and temporal attention; 64 channels per head; scale-shift norm enabled app. A.4.

Large-scale base and temporal interpolation app. A.4: 1.08B parameters, channel multiplier [1, 2, 4, 4], 256 channels, 3 residual blocks, dropout 0, attention resolutions [32, 16, 8], 64 channels per head, scale-shift norm enabled. The super-resolution architecture is in app. A.4 (313M parameters §5.1).

Data §5.1:

• UCF-101: 13,320 videos; frames sampled at random to train the image model.
• Large-scale: roughly 1.2 billion image-caption pairs and 22.5 million video-caption pairs, from public and proprietary sources, filtered by a CLIP score and an aesthetic score. The thresholds and the exact source list are not stated. Most videos are 2K at 16:9.

Results

Author-reported. The zero-shot setting follows Make-A-Video §5.2.

Zero-shot text-to-video on UCF-101 tab. 2. IS higher is better, FVD lower.

Zero-shot text-to-video on MSR-VTT tab. 3. CLIP-FID uses a ViT-B/32 model; FID uses Inception-V3 §5.2. Setup: 2,990 test videos and 59,794 captions, a 76×256×256 video generated per caption §5.2. Lower is better.

The ensemble configs use "level-1 experts" finetuned from each model §5.2.

Unconditional UCF-101 tab. 4. No class labels are used as conditions §5.2. Setup: sample 2,048 videos for FVD §5.2. Higher IS, lower FVD.

Against the diffusion baseline VDM, the paper reports about 10× fewer parameters and about 14× less training time (75 GPU-days against 925) for its unconditional model §5.2. The text does not say which of the three sizes the 75 GPU-day figure refers to.

Training strategies on UCF-101 tab. 5. FID here is the averaged per-frame FID.

Model size §5.3. Mixed and progressive noise outperform training from scratch in FVD at 69M, 112M and 253M, and the two noise models perform similarly. The numbers are in a figure, not a table, so only the direction is reported here.

Paper vs code

No official code.

Searches on 2026-11-01:

• The abstract's project page, research.nvidia.com/labs/dir/pyoco/, now redirects to research.nvidia.com/labs/cosmos-lab/pyoco/. That page links no repository and no code, and states no license.
• GitHub repository search (via WebFetch) for "PYoCo", "preserve your own correlation", "pyoco nvidia", "pyoco org:NVlabs", "video noise prior org:NVlabs" and "PYoCo video" returned no results.

No code was cloned and no discrepancies were checked.

Pitfalls

• Training data is not reproducible from the paper. The large-scale model trains on public and proprietary sources with counts given §5.1, but the exact mix and the CLIP and aesthetic thresholds are not stated. Matching the paper's large-scale numbers would need an equivalent corpus.
• The base model depends on eDiff-I. Both the base and super-resolution models start from eDiff-I §4. An implementer needs an equivalent text-to-image diffusion model, with T5 and CLIP text encoders, to start from. The paper does not describe an autoencoder; the denoiser works on video frames directly §4.
• Sampling guidance is not stated. No classifier-free guidance weight or other guidance scale appears in the text, so the sampling settings in the results may not be reproducible from this card alone.
• σ_max, batch size and warmup for the large-scale run are not stated. Only a 5,000-step linear warmup for UCF-101 is given app. A.3.
• Temporal interpolation input is ambiguous. The text says 16 frames with 4 real frames infilled with zero frames app. A.1 (3). It does not say what fills the other 12. The zero-initialised temporal projection app. A.1 (2) means the temporal branch starts as a no-op, which matters when debugging early training.
• α is a sensitive knob, and the paper does not say how to pick it for new data. The sweep was done only on the 69M UCF-101 model §5.3. The large-scale run uses progressive α = 2 §5.3; mixed-noise α is not tested at large scale. Very small α gave repeated samples and black borders in the authors' qualitative check; very large α gave poor motion §5.3. These are visual observations, not metrics.
• Derived correlation values are not in the paper. The per-pair correlations listed under Method follow from eq. 3 and eq. 4. They are useful for choosing α, but the paper does not report them.
• Text inconsistencies.
  • The α grid in §5.3 lists 1 twice; the intended grid is presumably 0, 0.1, 0.2, 0.5, 1, 2, 5, 10, ∞.
  • The large-scale and UCF-101 runs use different optimizers (AdamW vs Adam) and samplers (order 3 with 60 steps vs order 6 with 25 steps) app. A.3.
  • §3 cites the DEIS sampler as zhang2023fast, while app. A.3 cites zhang2022fast.
• Zero-shot UCF-101 is not the class-label benchmark. The paper writes one sentence per class and then uses it as the prompt app. A.2. Results from baselines that used class labels are not directly comparable §5.2.
• Two FID metrics. MSR-VTT is reported with CLIP-FID (ViT-B/32) and Inception FID. Use the same one when comparing with other numbers.
• Costs. The 75 GPU-day figure is for the unconditional UCF-101 model, of unstated size §5.2. Large-scale compute is not stated in the compiled text.
• Figures. The t-SNE comparison of noise maps §1 and the alpha-sweep visuals §5.3 are the paper's own evidence for the correlation claim. Their numeric content is only partly in tables.

Lineage

• Builds on: eDiff-I (text-to-image initialisation, T5 and CLIP encoders, expert denoisers) §1, §4; the video diffusion model VDM (joint image and video training, temporal attention) §1, §4; Imagen Video (cascaded generation) §1; Make-A-Video (finetuning an image model on video and the zero-shot protocol) §1, §5.2; the EDM training formulation and preconditioning §3; the DEIS sampler §3.
• Changed relative to those: the frame noise prior is correlated (mixed or progressive) instead of i.i.d. §4.
• Compared against: Make-A-Video, NUWA, CogVideo, MagicVideo, Video LDM, VideoFactory, Latent-Shift, TATS, MoCoGAN-HD, DIGAN, CCVS, VideoGPT, StyleGAN-V, TGAN, LDVD-GAN §5.2.
• Superseded by: not stated in the compiled text.