# What Are Sigma Schedules and Step Counts per Pipeline in LTX‑2?

> Understand LTX-2 sigma schedules and step counts. Learn how 1D tensors of noise levels guide diffusion and step counts control denoising iterations for optimal results.

- Repository: [Lightricks/LTX-2](https://github.com/Lightricks/LTX-2)
- Tags: deep-dive
- Published: 2026-08-14

---

**Sigma schedules in LTX‑2 are 1‑D tensors of noise levels (σ values) that guide the diffusion process from noisy to clean latent representations, with step counts determining how many denoising iterations each pipeline performs.**

In the **Lightricks/LTX‑2** video generation framework, understanding sigma schedules and step counts is essential for tuning inference quality and speed. The codebase implements multiple schedule types tailored to different pipelines, from the adaptive **LTX2Scheduler** to handcrafted distilled schedules for accelerated generation.

---

## How Sigma Schedules Work in LTX‑2

A **sigma schedule** defines the noise level at each step of the diffusion process. LTX‑2 uses *σ* (sigma) to represent the standard deviation of the noise added to latents. Higher σ means more noise; lower σ approaches a clean sample.

The framework provides three core schedule implementations as defined in [`ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_core/components/schedulers.py):

- **LTX2Scheduler** – Linear-to-exponential schedule that adapts to token count
- **LinearQuadraticScheduler** – Alternative interpolation-based schedule
- **BetaScheduler** – Beta-distributed noise scheduling

---

## Default LTX2 Schedule: Adaptive Noise Injection

The **LTX2Scheduler.execute()** method in [`ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_core/components/schedulers.py) generates the primary schedule used by most pipelines.

Key characteristics:

- Computes a linear-to-exponential decay curve
- Adapts schedule length based on latent tensor token count
- Optionally stretches final σ to match a configurable **terminal value** (default 0.1)

```python
from ltx_core.components.schedulers import LTX2Scheduler

scheduler = LTX2Scheduler()
sigmas = scheduler.execute(
    steps=30,           # num_inference_steps

    terminal_sigma=0.1  # final noise level

)

# Returns: 1-D tensor of 30+1 sigma values (including σ=0)

```

When no custom `sigmas` argument is provided, pipelines automatically invoke `self._scheduler.execute(steps=num_inference_steps)`.

---

## Distilled Sigma Schedules: Fixed 9-Step Acceleration

For **distilled LoRA models**, LTX‑2 provides hand-tuned sigma sequences in [`ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/utils/constants.py). These schedules trade some quality for dramatically faster inference.

### Available distilled schedules

| Schedule | Source constant | Step count | Use case |
|----------|----------------|------------|----------|
| Full distilled schedule | `DISTILLED_SIGMAS` | 9 | Standard distilled inference |
| Stage‑2 distilled schedule | `STAGE_2_DISTILLED_SIGMAS` | Subset of 9 | Two-stage pipeline refinement |
| TDP distilled schedule | `TDP_DISTILLED_SIGMAS` | 3 | Multi-GPU tiled parallel inference |

```python

# From ltx_pipelines/utils/constants.py

DISTILLED_SIGMAS = torch.tensor([
    1.0,      # Step 0: maximum noise

    0.99375,
    0.9875,
    0.98125,
    0.975,
    0.909375,
    0.725,
    0.421875,
    0.0       # Step 8: no noise (clean sample)

])

```

These values were empirically tuned for the distilled model checkpoints and typically override user-supplied step counts.

---

## Step Count Defaults by Pipeline Configuration

The **num_inference_steps** parameter controls schedule length. LTX‑2 defines version-specific defaults in [`ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/utils/constants.py):

| Configuration | Default steps | Applies to |
|-------------|-------------|-----------|
| `PipelineParams` (LTX‑2.0) | 40 | Legacy checkpoints |
| `LTX_2_3_PARAMS` | 30 | LTX‑2.3 generation |
| `LTX_2_3_HQ_PARAMS` | 15 | High-quality preset |
| Distilled pipelines | 9 (fixed schedule) | When `distilled=True` |

```python
from dataclasses import dataclass, replace
from ltx_pipelines.utils.constants import PipelineParams, LTX_2_3_PARAMS

@dataclass(frozen=True)
class PipelineParams:
    num_inference_steps: int = 40
    # ... other params

# LTX-2.3 reduces steps for faster inference

LTX_2_3_PARAMS = replace(LTX_2_PARAMS, num_inference_steps=30)

# HQ preset uses even fewer steps

LTX_2_3_HQ_PARAMS = PipelineParams(num_inference_steps=15, ...)

```

Users override via `--num_inference_steps` CLI argument processed through `resolve_cli_params()`.

---

## Sigma Schedule Selection per Pipeline

Each pipeline in `packages/ltx-pipelines/src/ltx_pipelines/` implements specific schedule selection logic:

### TI2VidOneStagePipeline (single-stage text-to-video)

File: [`ltx_pipelines/ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/ti2vid_one_stage.py)

```python

# Default behavior: LTX2Scheduler with user-specified steps

pipeline = TI2VidOneStagePipeline(model_paths=..., device='cuda')
video = pipeline(
    prompt="A mountain landscape",
    num_inference_steps=30,  # Uses LTX2Scheduler.execute(steps=30)

)

# Override with custom schedule

video = pipeline(
    prompt="A mountain landscape",
    sigmas=torch.linspace(1.0, 0.0, 50),  # Custom 50-step linear schedule

)

```

### TI2VidTwoStagesPipeline (coarse-then-refine)

File: [`ltx_pipelines/ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/ti2vid_two_stages.py)

Two-stage pipelines allow independent schedule control:

| Stage | Default schedule | Override parameter |
|-------|---------------|------------------|
| Stage 1 (coarse generation) | `LTX2Scheduler.execute(steps=num_inference_steps)` | `stage_1_sigmas` |
| Stage 2 (distilled refinement) | `STAGE_2_DISTILLED_SIGMAS` | `stage_2_sigmas` |

```python
from ltx_pipelines.ti2vid_two_stages import TI2VidTwoStagesPipeline
from ltx_pipelines.utils.constants import DISTILLED_SIGMAS

pipeline = TI2VidTwoStagesPipeline(
    model_paths=...,
    distilled_lora=...,  # Enables stage-2 distillation

    device='cuda'
)

video = pipeline(
    prompt="A futuristic robot",
    num_inference_steps=40,           # Stage 1: 40 steps with LTX2Scheduler

    stage_1_sigmas=None,              # Use default scheduler

    stage_2_sigmas=DISTILLED_SIGMAS,  # Stage 2: 9-step distilled schedule

)

```

### Other Pipelines

- **RetakePipeline**, **A2VidTwoStagePipeline**, **KeyframeInterpolationPipeline**, **HDRICLoraPipeline**, **DistilledPipeline** – All follow the same pattern: use `LTX2Scheduler` by default or switch to `DISTILLED_SIGMAS` when `distilled=True` or custom `sigmas` provided.

---

## Complete Usage Examples

### Standard LTX‑2.3 generation with default schedule

```python
from ltx_pipelines.ti2vid_one_stage import TI2VidOneStagePipeline
from ltx_pipelines.utils.constants import LTX_2_3_PARAMS

pipeline = TI2VidOneStagePipeline(
    model_paths="/path/to/ltx-2.3",
    loras=[],
    device="cuda"
)

video, audio, tiling = pipeline(
    prompt="A serene lake at dawn",
    negative_prompt="blur, low quality",
    seed=42,
    height=720,
    width=1280,
    frame_rate=24.0,
    num_inference_steps=LTX_2_3_PARAMS.num_inference_steps,  # 30 steps

    # No sigmas argument: uses LTX2Scheduler.execute(steps=30)

    images=[],
)

```

### Maximum quality with HQ preset (15 steps)

```python
from ltx_pipelines.utils.constants import LTX_2_3_HQ_PARAMS

video = pipeline(
    prompt="Crystal-clear ocean waves",
    num_inference_steps=LTX_2_3_HQ_PARAMS.num_inference_steps,  # 15 steps

    # Optimized sigmas for quality at reduced step count

)

```

### Two-stage with distilled acceleration

```python
from ltx_pipelines.ti2vid_two_stages import TI2VidTwoStagesPipeline
from ltx_pipelines.utils.constants import DISTILLED_SIGMAS

pipeline = TI2VidTwoStagesPipeline(
    model_paths=...,
    distilled_lora="/path/to/distilled_lora.safetensors",
    spatial_upsampler_path=...,
    device="cuda"
)

video, audio, _, tiling = pipeline(
    prompt="A cyberpunk street scene",
    num_inference_steps=40,              # Stage 1 steps

    stage_2_sigmas=DISTILLED_SIGMAS,     # Fixed 9-step stage 2

    height=1080,
    width=1920,
)

```

---

## Key Source Files

| File | Purpose |
|------|---------|
| [`ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_core/components/schedulers.py) | `LTX2Scheduler`, `LinearQuadraticScheduler`, `BetaScheduler` implementations |
| [`ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/utils/constants.py) | `DISTILLED_SIGMAS`, `STAGE_2_DISTILLED_SIGMAS`, `TDP_DISTILLED_SIGMAS`, `PipelineParams` defaults |
| [`ltx_pipelines/ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/ti2vid_one_stage.py) | Single-stage pipeline schedule selection |
| [`ltx_pipelines/ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/ti2vid_two_stages.py) | Two-stage pipeline with independent stage schedules |

---

## Summary

- **Sigma schedules** are 1-D tensors defining noise levels (σ) across diffusion steps, implemented in [`ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_core/components/schedulers.py)
- **LTX2Scheduler** provides adaptive linear-to-exponential schedules; **distilled schedules** in [`ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/utils/constants.py) offer fixed 9-step acceleration
- **Step counts** default to 40 (LTX‑2.0), 30 (LTX‑2.3), or 15 (HQ preset), overridable via `num_inference_steps`
- **Single-stage pipelines** use `LTX2Scheduler` unless custom `sigmas` provided
- **Two-stage pipelines** support independent schedules: adaptive for stage 1, distilled for stage 2

---

## Frequently Asked Questions

### How do I use the 9-step distilled schedule in LTX‑2?

Pass `DISTILLED_SIGMAS` from [`ltx_pipelines/utils/constants.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_pipelines/utils/constants.py) to the `sigmas` or `stage_2_sigmas` parameter. For single-stage pipelines: `pipeline(prompt=..., sigmas=DISTILLED_SIGMAS)`. For two-stage pipelines, this applies to stage 2 via `stage_2_sigmas=DISTILLED_SIGMAS`.

### What happens if I set num_inference_steps=50 with a distilled model?

The distilled schedule (`DISTILLED_SIGMAS`) contains exactly 9 values. If you request 50 steps, LTX‑2 either stretches the 9-step schedule to 50 points or ignores `num_inference_steps` depending on the pipeline implementation. For true 50-step generation, omit distilled flags and use `LTX2Scheduler` with custom `num_inference_steps`.

### Where does the terminal_sigma parameter affect generation?

`terminal_sigma` (default 0.1) controls the final noise level in `LTX2Scheduler.execute()`. It appears in [`ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/ltx_core/components/schedulers.py) and ensures the schedule terminates at the desired cleanliness rather than exactly zero, providing subtle control over generation fidelity.

### Can I mix different schedules across pipeline stages?

Yes. `TI2VidTwoStagesPipeline` explicitly supports this via `stage_1_sigmas` and `stage_2_sigmas` parameters. Common configurations use the full `LTX2Scheduler` for coarse generation (stage 1) and `STAGE_2_DISTILLED_SIGMAS` or `DISTILLED_SIGMAS` for fast refinement (stage 2).