# How LTX2Scheduler Controls Sigma Schedules in LTX-2

> Discover how LTX2Scheduler controls sigma schedules in LTX-2 by generating adaptive noise-scale sequences with linear shifts and non-linear transformations. Learn the technical details.

- Repository: [Lightricks/LTX-2](https://github.com/Lightricks/LTX-2)
- Tags: internals
- Published: 2026-06-20

---

**LTX2Scheduler generates adaptive noise-scale sequences by applying a token-count-dependent linear shift followed by a non-linear transformation and optional terminal stretching.**

LTX2Scheduler is the default diffusion scheduler in LTX-2, Lightricks’ open-source video generation framework. It dynamically calculates sigma schedules—the noise-scale values that guide the diffusion process—by adapting to latent token counts and applying configurable mathematical transformations. The implementation resides in [`packages/ltx-core/src/ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/components/schedulers.py) and integrates directly into the inference pipelines.

## The Three-Stage Sigma Schedule Algorithm

### Token-Count-Dependent Linear Shift

The scheduler first calculates a dynamic **sigma shift** value based on the input latent dimensions. When a latent tensor is provided, the code computes the total token count as `math.prod(latent.shape[2:])`, falling back to `MAX_SHIFT_ANCHOR` (4096) when no latent is supplied. This token count drives a linear interpolation between `base_shift` (0.95) and `max_shift` (2.05) across the range defined by `BASE_SHIFT_ANCHOR` (1024) and `MAX_SHIFT_ANCHOR` (4096).

The linear mapping follows the formula `σ_shift = m·tokens + b`, where the slope `m` equals `(max_shift - base_shift) / (MAX_SHIFT_ANCHOR - BASE_SHIFT_ANCHOR)`. This ensures smaller latent representations receive lower shift values, while larger contexts approach the maximum shift.

### Non-Linear Sigma Conversion

After determining the shift, the scheduler creates a base linear schedule from 1.0 to 0.0 using `torch.linspace(1.0, 0.0, steps + 1)`. It then applies a closed-form transformation to each non-zero element using the formula:

`σ = e^{σ_shift} / (e^{σ_shift} + (1/s - 1)^{power})`

With `power` defaulting to 1, this transformation converts the linear progression into a curve that decays gently during early denoising steps and sharply near the end. The implementation uses `torch.where` to preserve zero values while applying the exponential mapping to all other positions.

### Optional Schedule Stretching

When `stretch=True`, the scheduler rescales the tail of the distribution so that the final non-zero sigma equals the `terminal` parameter (default 0.1). The code calculates `scale_factor = (1.0 - last_sigma) / (1.0 - terminal)`, then linearly remaps all non-zero values by computing `stretched = 1.0 - (one_minus_z / scale_factor)`. This ensures the schedule terminates at the exact noise level required by the target model.

## Source Implementation Details

The `LTX2Scheduler` class is implemented in [`packages/ltx-core/src/ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/components/schedulers.py). The core logic executes inside the `execute()` method, which accepts parameters including `steps`, `latent`, `base_shift`, `max_shift`, `stretch`, and `terminal`. The method returns a `torch.FloatTensor` of shape `(steps + 1,)` containing the sigma values cast to `float32`.

Key default parameters defined in the source:
- `base_shift`: 0.95
- `max_shift`: 2.05
- `terminal`: 0.1
- `default_number_of_tokens`: 4096

## Integration with LTX-2 Inference Pipelines

In production pipelines such as [`packages/ltx-pipelines/src/ltx_pipelines/ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-pipelines/src/ltx_pipelines/ti2vid_one_stage.py), the scheduler is instantiated once during pipeline initialization:

```python
self._scheduler = LTX2Scheduler()

```

During inference, the pipeline invokes the scheduler to generate the sigma sequence:

```python
sigmas = (sigmas if sigmas is not None else
          self._scheduler.execute(steps=num_inference_steps)).to(
              dtype=torch.float32, device=self.device)

```

This pattern appears across multiple pipeline files including [`ti2vid_two_stages.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_two_stages.py), [`keyframe_interpolation.py`](https://github.com/Lightricks/LTX-2/blob/main/keyframe_interpolation.py), and [`retake.py`](https://github.com/Lightricks/LTX-2/blob/main/retake.py), ensuring consistent schedule generation throughout the LTX-2 ecosystem.

## Practical Usage Examples

Basic execution with fixed steps:

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

scheduler = LTX2Scheduler()
sigmas = scheduler.execute(steps=50)
print(sigmas.shape)  # torch.Size([51])

```

Token-aware execution with custom shift parameters:

```python
latent = torch.randn(1, 4, 16, 16)  # 256 tokens

sigmas = scheduler.execute(
    steps=50,
    latent=latent,
    base_shift=0.9,
    max_shift=2.2
)

```

Disabling terminal stretching:

```python
sigmas = scheduler.execute(steps=30, stretch=False, terminal=0.05)

```

## Summary

- **LTX2Scheduler** adapts sigma schedules based on latent token counts using linear interpolation between `base_shift` (0.95) and `max_shift` (2.05).
- The scheduler applies a non-linear transformation formula to convert linear progressions into diffusion-optimized decay curves.
- Optional stretching rescales the schedule tail to match a specific `terminal` value (default 0.1) for model compatibility.
- The implementation in [`packages/ltx-core/src/ltx_core/components/schedulers.py`](https://github.com/Lightricks/LTX-2/blob/main/packages/ltx-core/src/ltx_core/components/schedulers.py) provides a configurable `execute()` method used across all LTX-2 pipelines including [`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py).

## Frequently Asked Questions

### What is the default terminal value for LTX2Scheduler?

The default `terminal` parameter is **0.1**, representing the final non-zero sigma value when stretching is enabled. This ensures compatibility with models expecting specific noise levels at the end of the diffusion process.

### How does LTX2Scheduler determine the shift value without a latent tensor?

When no latent is provided, the scheduler defaults to `MAX_SHIFT_ANCHOR` (4096 tokens) as the token count, placing the shift value at the upper end of the interpolation range near `max_shift` (2.05).

### Why does the sigma schedule use a non-linear transformation instead of linear interpolation?

The non-linear formula `σ = e^{shift} / (e^{shift} + (1/s - 1)^{power})` creates a schedule that decays more slowly during early denoising steps and more aggressively at the end. This allocation improves generation quality by dedicating more steps to fine detail refinement.

### Where is LTX2Scheduler instantiated in the LTX-2 codebase?

The scheduler is instantiated in pipeline files within `packages/ltx-pipelines/src/ltx_pipelines/`, such as [`ti2vid_one_stage.py`](https://github.com/Lightricks/LTX-2/blob/main/ti2vid_one_stage.py), where it is stored as `self._scheduler` and invoked during the inference preparation phase to generate noise-scale schedules.