Update documentation

1.3B/README.md

@@ -1,183 +1,94 @@
-# Anonymous Video Generation — 1.3B
+# Elastic Forcing — 1.3B
 
-[Project overview](../README.md) · [14B release](../14B/README.md)
+[Overview](../README.md) · [14B guide](../14B/README.md) · [Checkpoints](https://huggingface.co/Elastic-forcing/Elastic-forcing-checkpoint/tree/main/checkpoints/1.3B)
 
----
+The 1.3B model uses Wan2.1-T2V-1.3B with DINOv3, V-JEPA 2, and VideoMAEv2 for distribution matching. It generates 81-frame videos at 832 × 480 resolution and 16 FPS, with four causal denoising steps per chunk.
 
-For a guided implementation walkthrough, see [Reading the code](../docs/paper-to-code.md).
-The YAML uses the paper's distribution batch, differentiation batch, and reference minibatch terminology; `code/utils/config.py` keeps legacy configurations compatible.
+## Environment
 
-Anonymous Video Generation post-trains few-step autoregressive video generators by matching generated and reference videos in frozen representation spaces. It combines a hybrid Nyström–Monte Carlo distribution estimator with gradient replay, allowing distribution estimation to use more samples than backpropagation. Only the generator is optimized; diffusion score models are not needed during post-training.
-
-This repository provides the **Wan2.1-T2V-1.3B three-encoder configuration**, using **DINOv3, V-JEPA 2, and VideoMAEv2**. This configuration achieves **84.25 VBench Total** in the paper.
-
-## Supported Configuration
-
-| Backbone | Feature encoders | Sampling | Training GPUs | Updates |
-|---|---|---|---|---:|
-| Wan2.1-T2V-1.3B | DINOv3 + V-JEPA 2 + VideoMAEv2 | Causal, 4 steps per chunk | 4 | 150 |
-
-Training uses a distribution batch of **256 generated videos**, a differentiation batch of **128 generated videos**, and a reference minibatch of **128 videos**. Inference produces **81-frame, 832 × 480 videos at 16 FPS**.
-
-## 1. Environment
-
-Use Linux, Python 3.10, and NVIDIA GPUs with BF16 support. Run the commands below from the `1.3B/` directory.
+Use Linux, Python 3.10, and NVIDIA GPUs with BF16 support. Run these commands from `1.3B/`:
 
 ```bash
-conda create -n video-generation python=3.10 -y
-conda activate video-generation
-
+conda create -n elastic-forcing python=3.10 -y
+conda activate elastic-forcing
 python -m pip install torch==2.5.1 torchvision==0.20.1 \
   --index-url https://download.pytorch.org/whl/cu121
 python -m pip install -r requirements.txt
 python -m pip install flash-attn==2.7.4.post1 --no-build-isolation
-
 export PYTHON_BIN="$(command -v python)"
 ```
 
-## 2. Models and Data
+## Models and assets
 
-### Inference assets
+Inference requires the Wan2.1-T2V-1.3B base model, T5 text encoder, tokenizer, VAE, and the Elastic Forcing generator checkpoint. Place the base-model bundle under `$ASSET_ROOT/models/Wan2.1-T2V-1.3B/`. Training also requires the Self-Forcing ODE initialization, local DINOv3, V-JEPA 2, and VideoMAEv2 models, and precomputed reference features.
 
-Inference needs the Wan2.1 base model, text encoder, tokenizer, VAE, and a trained Anonymous Video Generation checkpoint. Place the matching Wan2.1 assets in the local model directory:
+Download the generator checkpoint:
 
-```bash
-export ASSET_ROOT=/path/to/video-generation-assets
+```python
+from pathlib import Path
+from huggingface_hub import snapshot_download
 
-# Place the matching model files at the local paths described below.
+folder = Path(snapshot_download(
+    "Elastic-forcing/Elastic-forcing-checkpoint",
+    allow_patterns=["checkpoints/1.3B/*"],
+))
+print(folder / "checkpoints/1.3B/model.pt")
 ```
 
-The base model is stored under `$ASSET_ROOT/models/Wan2.1-T2V-1.3B/`. The trained generator checkpoint can be stored separately and selected with `CHECKPOINT` when running inference.
-
-### Training assets
-
-Training starts from the Self-Forcing ODE initialization, stored locally at `$ASSET_ROOT/checkpoints/ode_init.pt`.
-
-It additionally requires:
-
-- **Frozen feature encoders:** DINOv3 ViT-L/16, V-JEPA 2 ViT-L, and VideoMAEv2-Large.
-- **Reference features:** precomputed features for the 8,682-video reference collection, with the aligned prompt/video manifest.
-- **Nyström references:** one fixed summary per encoder, built from the same collection.
-
-Reference preparation consists of extracting the three representations and building their Nyström summaries. During training, reference features are read directly from disk. See [Asset Preparation](docs/assets.md) for model sources, the directory layout, and preprocessing tools.
-
-**The trained Anonymous Video Generation weights and reference collection are not distributed with this source release.** Reproducing the reported training run requires the corresponding reference assets in addition to the public model downloads.
-
-### Configure asset paths
-
-Generate the local configuration once the asset root is set:
+Set the local asset root and generate the configuration:
 
 ```bash
-"$PYTHON_BIN" scripts/prepare_config.py --asset-root "$ASSET_ROOT"
+export ASSET_ROOT=/path/to/assets
+python scripts/prepare_config.py --asset-root "$ASSET_ROOT"
 ```
 
-This creates `configs/local.yaml` from [the three-encoder configuration](configs/three_encoder.yaml). Local asset paths are excluded from version control. Download dependencies before launching a run; the training and inference scripts use local models in offline mode.
-
-## 3. Quick Inference
+## Inference
 
-Create a text file with one prompt per line, then select a trained checkpoint:
+Use the downloaded checkpoint and a text file containing one prompt per line:
 
 ```bash
-export CHECKPOINT=/path/to/video-generation/model.pt
-
+CHECKPOINT=/path/to/model.pt \
 GPUS=0 \
-  PROMPTS=/path/to/prompts.txt \
-  OUTPUT_DIR=outputs/demo \
-  bash scripts/infer.sh
+PROMPTS=code/prompts/test_8.txt \
+OUTPUT_DIR=outputs/demo \
+bash scripts/infer.sh
 ```
 
-The launcher generates one video per prompt with seed 0, using the generator weights without EMA. The four-step inference path has no additional classifier-free guidance branch. Example prompts are provided in [test_8.txt](code/prompts/test_8.txt).
+The launcher produces one video per prompt with seed 0 and non-EMA generator weights. Prepare base-model assets before launching; model loading uses local files.
 
-## 4. Training
+## Training
 
-Prepare the environment and training assets above, then start the three-encoder run on four GPUs:
+Training requires an ODE initialization, all three frozen encoders, a matched prompt/video manifest, a reference feature bank, and one Nyström summary per encoder. Prepare the model and reference assets at the locations specified in [configs/three_encoder.yaml](configs/three_encoder.yaml), generate the local configuration, and start training:
 
 ```bash
-export LOGDIR=runs/video-generation
-GPUS=0,1,2,3 bash scripts/train.sh
-```
-
-The launcher uses FSDP and gradient checkpointing. Each worker generates 64 videos for distribution estimation and replays 32 with gradients. The feature encoders remain frozen, but gradients pass through them to the generated videos. W&B logging is disabled by the launcher.
-
-Use a separate `LOGDIR` for each run. Training starts from the ODE initialization and runs for **150 updates**, saving model weights, optimizer state, and per-worker random states every five updates. All checkpoints are retained. The final generator checkpoint is:
-
-```text
-runs/video-generation/checkpoint_model_000150/model.pt
+GPUS=0,1,2,3 LOGDIR=runs/train bash scripts/train.sh
 ```
 
-Monitor progress with `tail -f "$LOGDIR/train.log"`. To generate videos from the trained model:
-
-```bash
-export CHECKPOINT="$LOGDIR/checkpoint_model_000150/model.pt"
-GPUS=0 PROMPTS=/path/to/prompts.txt \
-  OUTPUT_DIR=outputs/video-generation bash scripts/infer.sh
-```
-
-<details>
-<summary><b>Training configuration</b></summary>
-
 | Setting | Value |
 |---|---|
-| Initialization | Self-Forcing ODE checkpoint |
-| Distribution batch | 256 generated videos |
-| Differentiation batch | 128 generated videos |
-| Reference minibatch | 128 videos, sampled with replacement |
+| Training updates | 150 |
+| Distribution / differentiation / reference batch | 256 / 128 / 128 |
+| Per-GPU generated / differentiated videos | 64 / 32 |
+| Reference videos | 8,682 |
 | Encoder weights | DINOv3 : V-JEPA 2 : VideoMAEv2 = 10 : 1 : 1 |
-| Loss aggregation | Sum of weighted, normalized branch losses divided by 3 |
-| Reference estimator | Nyström + Monte Carlo, weights 2 : 1 |
+| Loss divisor | 3 |
+| Nyström / Monte Carlo weights | 2 : 1 |
 | Optimizer | AdamW, betas (0, 0.999), weight decay 0 |
+| Learning rate | Cosine from 2.5e-6 to 5e-7 over 125 updates, then constant |
 | Gradient clipping | Maximum norm 10 |
-| Learning rate | Cosine decay from 2.5e-6 to 5e-7 over 125 updates, then constant |
-| Training length | 150 updates |
-| Checkpoint interval | Every 5 updates |
-
-The full configuration is in [configs/three_encoder.yaml](configs/three_encoder.yaml).
-
-</details>
+| Checkpoint interval | Every five updates |
 
-### Short training run
+The launcher uses FSDP and gradient checkpointing. Training settings are in [configs/three_encoder.yaml](configs/three_encoder.yaml). Use a distinct `LOGDIR` for each run; checkpoints include optimizer and random-state files for resuming training.
 
-To check the complete training and checkpoint path before a full run:
+## Evaluation
 
-```bash
-export LOGDIR=runs/video-generation-smoke
-GPUS=0,1,2,3 bash scripts/train.sh --smoke
-```
-
-This runs **one optimizer update with the same batch sizes and all three encoders**. The resulting checkpoint is `$LOGDIR/checkpoint_model_000001/model.pt` and can be loaded with the inference command above.
+| VBench Total ↑ | Quality ↑ | Semantic ↑ |
+|---:|---:|---:|
+| 84.25 | 85.06 | 80.99 |
 
-<details>
-<summary><b>Running in tmux and CPU tests</b></summary>
-
-On a machine with four allocated GPUs, start a persistent session:
+Use [VBench](https://github.com/Vchitect/VBench) to evaluate generated videos. Per-dimension scores are in the [reference results](results/reference/three-encoder-summary.json). Run the CPU numerical tests from `1.3B/`:
 
 ```bash
-tmux new -s video-generation
+python -m pip install pytest
+python scripts/test_cpu.py
 ```
-
-Inside the session, activate the environment, set `PYTHON_BIN` and `LOGDIR`, and run the training command. Detach with `Ctrl-b`, then `d`; reconnect with `tmux attach -t video-generation`.
-
-Run the CPU numerical tests separately:
-
-```bash
-"$PYTHON_BIN" -m pip install pytest
-"$PYTHON_BIN" scripts/test_cpu.py
-```
-
-See the [validation record](docs/validation.md) for revision-specific test results and the GPU environment used.
-
-</details>
-
-## 5. Evaluation
-
-The paper reports the following result for the three-encoder generator after 150 updates:
-
-| Model | VBench Total ↑ | Quality ↑ | Semantic ↑ |
-|---|---:|---:|---:|
-| Anonymous Video Generation, 1.3B, three encoders | **84.25** | **85.06** | **80.99** |
-
-The per-dimension scores are available in the [reference summary](results/reference/three-encoder-summary.json). Use the upstream [VBench](https://github.com/Vchitect/VBench) evaluator to evaluate generated videos; VBench and its evaluation models are maintained separately from this training and inference release. A short training run verifies execution and does not reproduce the reported benchmark score.
-
-## Acknowledgments
-
-This implementation builds on [Self-Forcing](https://github.com/guandeh17/Self-Forcing) and [Wan2.1](https://github.com/Wan-Video/Wan2.1). We also thank the authors of [DINOv3](https://github.com/facebookresearch/dinov3), [V-JEPA 2](https://github.com/facebookresearch/vjepa2), [VideoMAEv2](https://github.com/OpenGVLab/VideoMAEv2), and [VBench](https://github.com/Vchitect/VBench) for making their work available. Bundled source retains its upstream license notices; model weights and datasets follow their respective upstream terms.

14B/README.md

@@ -1,22 +1,16 @@
-# Anonymous Video Generation — 14B
+# Elastic Forcing — 14B
 
-[Project overview](../README.md) · [1.3B release](../1.3B/README.md)
+[Overview](../README.md) · [1.3B guide](../1.3B/README.md) · [Checkpoints](https://huggingface.co/Elastic-forcing/Elastic-forcing-checkpoint/tree/main/checkpoints/14B)
 
-This directory provides the Wan2.1-T2V-14B implementation for **80 updates** of Anonymous Video Generation with **DINOv3, V-JEPA 2, and VideoMAEv2**. It includes the causal generator, frozen feature encoders, distribution-matching objective, gradient replay, CPU offload, checkpoint saving/resume, and inference code.
+The 14B model uses Wan2.1-T2V-14B with DINOv3, V-JEPA 2, and VideoMAEv2 for distribution matching. It generates 81-frame videos at 832 × 480 resolution and 16 FPS. Inference uses four causal denoising steps followed by terminal cleanup.
 
-This is the non-EMA checkpoint used for the human study and VLM evaluations. See [evaluated settings](docs/evaluated-settings.md) for the model identity and distinct sampling protocols.
+## Environment
 
-The step-80 recipe starts from the **causal ODE initialization**. It uses the first 80 updates of a 200-step cosine learning-rate schedule; shortening the learning-rate schedule to 80 steps changes the recipe.
-
-For an implementation walkthrough, see [Reading the code](../docs/paper-to-code.md). The configuration uses the paper's distribution and differentiation terminology; `code/utils/config.py` preserves legacy configuration compatibility.
-
-## 1. Environment
-
-Run the following commands from `14B/`. Use Linux, Python 3.10, and CUDA-capable GPUs with BF16 support. The original training used **8 H200 GPUs** with CPU offload and approximately **1 TB of host RAM** allocated. Inference uses one GPU; this release does not establish a minimum VRAM requirement.
+Use Linux, Python 3.10, and NVIDIA GPUs with BF16 support. Run these commands from `14B/`:
 
 ```bash
-conda create -n video-generation-14b python=3.10 -y
-conda activate video-generation-14b
+conda create -n elastic-forcing-14b python=3.10 -y
+conda activate elastic-forcing-14b
 python -m pip install torch==2.5.1 torchvision==0.20.1 \
   --index-url https://download.pytorch.org/whl/cu121
 python -m pip install -r requirements.txt
@@ -24,106 +18,92 @@ python -m pip install flash-attn==2.7.4.post1 --no-build-isolation
 export PYTHON_BIN="$(command -v python)"
 ```
 
-## 2. Models and Data
+## Models and assets
 
-See [Asset preparation](docs/assets.md) for the directory layout, frozen encoder revisions, and reference-preparation tools.
+Inference requires the Wan2.1-T2V-14B base model, T5 text encoder, tokenizer, VAE, and the Elastic Forcing generator checkpoint. Place the base-model bundle under `$ASSET_ROOT/models/Wan2.1-T2V-14B/`.
 
-Inference requires the Wan2.1-T2V-14B base model, shared T5/tokenizer/VAE, and a trained Anonymous Video Generation `model.pt`. Training additionally requires the original causal ODE initialization and the **8,000-video three-encoder reference collection**. These experiment-specific weights and reference assets are not bundled in this source repository; downloading the public Wan model alone does not reproduce the trained checkpoint.
+The generator checkpoint is stored as eight FP32 safetensors shards. Download them and create the `.pt` file expected by the inference launcher:
 
-```bash
-export ASSET_ROOT=/path/to/video-generation-assets
-# Place the matching model files at the local paths described below.
-
-# After placing all training assets according to docs/assets.md:
-python scripts/prepare_config.py --asset-root "$ASSET_ROOT"
+```python
+import json
+from pathlib import Path
+import torch
+from huggingface_hub import snapshot_download
+from safetensors.torch import load_file
 
-# For inference alone, omit the training-bank requirement:
-# python scripts/prepare_config.py --asset-root "$ASSET_ROOT" --inference-only
+folder = Path(snapshot_download(
+    "Elastic-forcing/Elastic-forcing-checkpoint",
+    allow_patterns=["checkpoints/14B/*"],
+)) / "checkpoints/14B"
+index = json.loads((folder / "model.safetensors.index.json").read_text())
+state = {}
+for shard in sorted(set(index["weight_map"].values())):
+    state.update(load_file(str(folder / shard), device="cpu"))
+torch.save({"generator": state}, "/path/to/local/model.pt")
 ```
 
-The setup script writes `configs/local.yaml` and `configs/local.env`, which are excluded from Git. It preserves the frozen feature-bank identity while separating the VideoMAEv2 load location from the identity stored in its reference metadata.
+Conversion preserves tensor values and precision. Allow enough host memory and disk space for the approximately 57 GB FP32 generator and the output file.
 
-## 3. Inference
+For inference, prepare the base-model assets and generate the local configuration:
 
 ```bash
+export ASSET_ROOT=/path/to/assets
+python scripts/prepare_config.py --asset-root "$ASSET_ROOT" --inference-only
+```
+
+## Inference
+
+```bash
+CHECKPOINT=/path/to/local/model.pt \
 GPUS=0 \
-CHECKPOINT=/path/to/checkpoint_model_000080/model.pt \
 PROMPTS=code/prompts/test_8.txt \
-OUTPUT_DIR=outputs/step80 \
+OUTPUT_DIR=outputs/demo \
 bash scripts/infer.sh
 ```
 
-The default matches the previous inference run: seed `0`, **five samples per prompt**, regular generator weights, and **no classifier-free guidance**. All five samples' initial and transition noises are drawn together; the generator then executes one video at a time to limit memory. Set `NUM_SAMPLES=1` for a single-video demo; this changes the random-number sequence. The seed advances continuously across prompts. Exact output reproduction also requires the same prompt order and shard split. The supplied pipeline performs four causal denoising steps followed by a terminal `t=0` cleanup, and uses the training-matched context-cache lifetime. The auxiliary noise seed is separately fixed in `configs/inference.yaml`.
-
-The `21` latent frames requested by the launcher decode to **81 frames at 832 × 480 and 16 FPS**.
+The defaults are seed 0 and five samples per prompt with non-EMA generator weights. Set `NUM_SAMPLES=1` for a single sample. The generator executes one video at a time while retaining the sampling order across prompts. Model loading uses local base-model assets.
 
-## 4. Training
+## Training
 
-After preparing the training assets and local configuration:
+Training requires the causal ODE initialization, frozen encoders, matched prompt/video manifest, reference feature bank, and Nyström summaries. Prepare the model and reference assets at the locations specified in [configs/train.yaml](configs/train.yaml), then run:
 
 ```bash
-GPUS=0,1,2,3,4,5,6,7 \
-LOGDIR=runs/three-encoder \
-bash scripts/train.sh
+python scripts/prepare_config.py --asset-root "$ASSET_ROOT"
+GPUS=0,1,2,3,4,5,6,7 LOGDIR=runs/train bash scripts/train.sh
 ```
 
-Training stops after update 80. Full model, optimizer, and per-rank random-state checkpoints are saved every 10 updates. Use `runs/three-encoder/checkpoint_model_000080/model.pt` for inference. Keep all companion files for resuming training. Use a fresh `LOGDIR` for each new experiment; eight full 14B checkpoints require substantial disk space.
-
 | Setting | Value |
 |---|---|
-| Generator | Wan2.1-T2V-14B, causal softmax attention |
-| Initialization | Causal ODE checkpoint |
-| GPUs | 8 |
+| Training updates | 80 |
 | Distribution / differentiation / reference batch | 256 / 128 / 128 |
-| Per-rank generated / differentiated videos | 32 / 16 |
-| Physical generation / logical feature / physical replay batch | 2 / 16 / 1 |
-| Reference collection | 8,000 videos |
-| Frozen feature encoders | DINOv3 final block; V-JEPA 2 and VideoMAEv2 block index 15 |
-| Loss aggregation | `(10 × DINOv3 + V-JEPA 2 + VideoMAEv2) / 3`, after per-branch normalization |
-| Fixed / sampled reference attraction weights | 2 / 1 |
-| Optimizer | AdamW, betas `(0, 0.999)`, weight decay `0` |
-| Learning rate | Cosine `2.5e-6 → 5e-7` over **200** updates; stop at **80** |
-| Generator gradient clipping | 10 |
-| EMA | Disabled |
-| Memory management | FSDP full sharding, activation checkpointing, optimizer/activation/frozen-encoder CPU offload |
-
-All three encoders are frozen, but their input gradients are retained for generator training. The original configuration uses `seed: 0`, which selects an effective seed at launch; set an explicit positive training seed for a repeatable new run. Matching the recipe alone does not recover the historical RNG state.
-
-For a one-update smoke test with the full batch geometry:
+| Per-GPU generated / differentiated videos | 32 / 16 |
+| Reference videos | 8,000 |
+| Encoder weights | DINOv3 : V-JEPA 2 : VideoMAEv2 = 10 : 1 : 1 |
+| Loss divisor | 3 |
+| Nyström / Monte Carlo weights | 2 : 1 |
+| Optimizer | AdamW, betas (0, 0.999), weight decay 0 |
+| Learning rate | Cosine from 2.5e-6 to 5e-7 over 200 updates |
+| Gradient clipping | Maximum norm 10 |
+| Checkpoint interval | Every ten updates |
+| Memory management | FSDP, activation checkpointing, optimizer and encoder CPU offload |
 
-```bash
-LOGDIR=runs/smoke bash scripts/train.sh --smoke
-```
+The learning-rate schedule spans 200 updates while training stops at update 80. Use a separate `LOGDIR` for each run. Keep checkpoint companion files for resuming training with the same distributed topology and asset configuration.
 
-Resume a checkpoint produced by this release using the same eight-rank topology and asset identities:
+To resume:
 
 ```bash
 python scripts/prepare_config.py --asset-root "$ASSET_ROOT" \
-  --resume-checkpoint "$PWD/runs/three-encoder/checkpoint_model_000070/model.pt"
-LOGDIR=runs/resumed bash scripts/train.sh
+  --resume-checkpoint /path/to/checkpoint/model.pt
+GPUS=0,1,2,3,4,5,6,7 LOGDIR=runs/resume bash scripts/train.sh
 ```
 
-This continues through update 80. Historical checkpoints may contain deployment-specific resume identities; the inference loader accepts their generator weights, but exact training resume across repackaged identities is not guaranteed.
+## Evaluation and tests
 
-To run in tmux after activating the environment:
+Generate benchmark videos with consistent prompt ordering and sampling settings, then evaluate them with the official [VBench](https://github.com/Vchitect/VBench) implementation.
 
-```bash
-tmux new-session -s video-generation-14b
-bash scripts/train.sh
-# Detach: Ctrl-b, then d. Reattach: tmux attach -t video-generation-14b
-```
-
-## 5. Validation and Evaluation
+Run the CPU numerical tests from `14B/`:
 
 ```bash
 python -m pip install pytest
 python scripts/test_cpu.py
 ```
-
-The CPU suite covers three-encoder configuration and feature-bank loading, partial-gradient geometry, MMD gradients, replay, offload state restoration, terminal cleanup/context-cache inference, sample-batch noise ordering, and the 200-step cosine curve. See [validation notes](docs/validation.md) for the distinction between the original GPU run and checks of this source package.
-
-For VBench, supply the benchmark prompt list to `scripts/infer.sh` and evaluate the resulting videos with the official [VBench](https://github.com/Vchitect/VBench) implementation. A sample-video smoke test is not a benchmark reproduction.
-
-## Acknowledgments
-
-This implementation builds on [Self-Forcing](https://github.com/guandeh17/Self-Forcing), [Wan2.1](https://github.com/Wan-Video/Wan2.1), [DINOv3](https://github.com/facebookresearch/dinov3), [V-JEPA 2](https://github.com/facebookresearch/vjepa2), and [VideoMAEv2](https://github.com/OpenGVLab/VideoMAEv2). Upstream source notices are preserved in `code/LICENSE`; model weights and datasets retain their respective terms.

README.md

@@ -5,69 +5,61 @@ tags:
 - video-generation
 - pytorch
 ---
-<div align="center">
+# Elastic Forcing
 
-# Elastic-forcing-code
+Elastic Forcing post-trains autoregressive video generators by matching generated and reference videos in frozen representation spaces. It combines hybrid Nyström–Monte Carlo distribution estimation with gradient replay.
 
-Anonymous source-code repository.
+[Model checkpoints](https://huggingface.co/Elastic-forcing/Elastic-forcing-checkpoint) · [1.3B guide](1.3B/README.md) · [14B guide](14B/README.md)
 
-[Model checkpoints](https://huggingface.co/Elastic-forcing/Elastic-forcing-checkpoint)
-
-[1.3B Training & Inference](1.3B/README.md) · [14B Training & Inference](14B/README.md)
-
-</div>
-
----
-
-
-Anonymous Video Generation post-trains few-step autoregressive video generators by matching generated and reference videos in frozen representation spaces. It combines a hybrid Nyström–Monte Carlo distribution estimator with gradient replay. Only the generator is optimized; diffusion score models are not needed during post-training.
-Both released recipes use the same three-encoder MMD objective; no auxiliary frame-level distribution objective is enabled or included.
+## Models
 
-Read the implementation through the [paper-to-code guide](docs/paper-to-code.md), which maps the paper's notation to configuration fields, the training loop, the hybrid MMD objective, and gradient replay.
+| Backbone | Frozen feature encoders | Training GPUs | Training updates | Inference |
+|---|---|---:|---:|---|
+| Wan2.1-T2V-1.3B | DINOv3 + V-JEPA 2 + VideoMAEv2 | 4 | 150 | Four causal denoising steps per chunk |
+| Wan2.1-T2V-14B | DINOv3 + V-JEPA 2 + VideoMAEv2 | 8 | 80 | Four causal denoising steps and terminal cleanup |
 
-## Models
+Both models generate 81-frame videos at 832 × 480 resolution and 16 FPS. Training uses a distribution batch of 256 generated videos, a differentiation batch of 128 generated videos, and a reference minibatch of 128 videos.
 
-Each model directory contains its own implementation, configuration, dependency list, asset guide, and training/inference scripts. Run its commands from that directory.
+## Getting started
 
-| Release | Frozen feature encoders | Training | Inference | Guide |
-|---|---|---|---|---|
-| **1.3B** | DINOv3 + V-JEPA 2 + VideoMAEv2 | 4 GPUs, 150 updates | 4 causal steps per chunk | [Training and inference](1.3B/README.md) |
-| **14B** | DINOv3 + V-JEPA 2 + VideoMAEv2 | 8 GPUs, 80 updates | 4 trained steps + terminal zero-step cleanup | [Training and inference](14B/README.md) |
+```bash
+git clone https://huggingface.co/Elastic-forcing/Elastic-forcing-code
+cd Elastic-forcing-code
 
-Both configurations use a distribution batch of 256 generated videos, a differentiation batch of 128 videos, and a reference minibatch of 128 videos. They generate 81-frame, 832 × 480 videos at 16 FPS.
+# Select the model size and follow its guide.
+cd 1.3B
+# Or: cd 14B
+```
 
-The 1.3B three-encoder configuration achieves **84.25 VBench Total** in the paper. The 14B release targets the **step-80 checkpoint**, retaining the first 80 updates of the original **200-step cosine learning-rate schedule**. This is the **three-encoder, 8,000-reference-video model used in the human and VLM evaluations**; see [evaluated settings](14B/docs/evaluated-settings.md).
+Each model directory includes its dependencies, configuration, asset guide, training launcher, and inference launcher. Download the matching generator checkpoint from the checkpoint repository and prepare the Wan2.1 base-model assets locally. Training additionally requires an ODE initialization, frozen feature encoders, and reference features.
 
 ```text
 Elastic-forcing-code/
-├── 1.3B/                # Three-encoder training and inference
+├── 1.3B/
 │   ├── code/
 │   ├── configs/
 │   ├── scripts/
 │   └── README.md
-├── 14B/                 # Three-encoder training and step-80 inference
+├── 14B/
 │   ├── code/
 │   ├── configs/
 │   ├── scripts/
 │   └── README.md
-└── docs/                # Implementation and validation guides
+└── docs/
 ```
 
-## Getting Started
-
-```bash
-git clone https://huggingface.co/Elastic-forcing/Elastic-forcing-code
-cd Elastic-forcing-code
+The model guides describe dependencies, required assets, training settings, and inference commands.
 
-# Choose one model, then follow its README.
-cd 14B
-# Or: cd 1.3B
-```
+## Evaluation
 
-See the [1.3B asset guide](1.3B/docs/assets.md) or [14B asset guide](14B/docs/assets.md) for model and reference-data requirements. This release contains source code; trained generator weights, the 14B ODE initialization, and frozen reference assets are stored separately and are not bundled here.
+| Model | VBench Total ↑ | Quality ↑ | Semantic ↑ |
+|---|---:|---:|---:|
+| Elastic Forcing 1.3B | 84.25 | 85.06 | 80.99 |
 
+Per-dimension scores are provided in the [reference results](1.3B/results/reference/three-encoder-summary.json). Evaluate generated videos using the official [VBench](https://github.com/Vchitect/VBench) implementation.
 
+## Acknowledgments and license
 
-## Acknowledgments
+This implementation builds on [Self-Forcing](https://github.com/guandeh17/Self-Forcing), [Wan2.1](https://github.com/Wan-Video/Wan2.1), [DINOv3](https://github.com/facebookresearch/dinov3), [V-JEPA 2](https://github.com/facebookresearch/vjepa2), and [VideoMAEv2](https://github.com/OpenGVLab/VideoMAEv2).
 
-This implementation builds on [Self-Forcing](https://github.com/guandeh17/Self-Forcing) and [Wan2.1](https://github.com/Wan-Video/Wan2.1). We also thank the authors of [DINOv3](https://github.com/facebookresearch/dinov3), [V-JEPA 2](https://github.com/facebookresearch/vjepa2), [VideoMAEv2](https://github.com/OpenGVLab/VideoMAEv2), and [VBench](https://github.com/Vchitect/VBench) for making their work available. Bundled source retains its upstream license notices; model weights and datasets follow their respective upstream terms.
+Source-code terms are provided in [LICENSE](LICENSE). Upstream source notices are retained; model assets and datasets follow their respective upstream terms.