# SANA-WM

SANA-WM は、SANA を基盤として構築された、カメラ制御による画像から動画への変換を行うワールドモデルです。最初のフレームの画像、テキストプロンプト、カメラ軌道（明示的な `c2w` ポーズまたは WASD/IJKL のアクション文字列）を指定すると、要求されたカメラパスに沿った動きを持つ動画を生成します。

推論は2つの段階で実行されます:

1. **ステージ 1 — SANA-WM DiT。** 1.6Bパラメータの双方向 DiT で、GDN-Triton 線形アテンションと UCPE カメラ制御ブランチを備えています。サンプリングには、トークンごとのタイムステップを持つ LTX スタイルのフローマッチング・オイラースケジューラを使用します。最初の潜在フレームが条件付けアンカーとなります。
2. **ステージ 2 — LTX-2 リファイナ（オプション）。** [SanaWMLTX2RefinerTransformer3DModel](/docs/diffusers/v0.43.0/ja/api/models/sana_wm_refiner_transformer3d#diffusers.SanaWMLTX2RefinerTransformer3DModel) + `LTX2TextConnectors` および Gemma-3 テキストエンコーダーをラップする、独立した sink-bidirectional Euler リファイナパイプライン（[SanaWMLTX2Refiner](/docs/diffusers/v0.43.0/ja/api/pipelines/sana_wm#diffusers.SanaWMLTX2Refiner)）で、蒸留済みシグマステップ 3 ステップ分を実行します。

両方のステージは、[AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ja/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video) VAE を通じてデコードされます。

利用可能なモデル:

| モデル | 推奨されるdtype |
|:-----:|:-----------------:|
| [`Efficient-Large-Model/SANA-WM_bidirectional-diffusers`](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional-diffusers) | `torch.bfloat16` |
| [`Efficient-Large-Model/SANA-WM_bidirectional-diffusers-refiner`](https://huggingface.co/Efficient-Large-Model/SANA-WM_bidirectional-diffusers-refiner) | `torch.bfloat16` |

> [!TIP]
> SANA-WM は固定解像度 704×1280 で学習されています。transformer の重みには推奨 dtype を使用し、数値精度を最適化するために、テキストエンコーダーは `torch.bfloat16`、VAE は `torch.float32` に設定してください。パイプラインは、*元画像*のピクセル座標系におけるカメラ内パラメータ `[fx, fy, cx, cy]` を入力として期待します。リサイズと中央クロップの変換は内部で適用されます。

## 推論

```python
import torch
from PIL import Image

from diffusers import SanaWMPipeline
from diffusers.utils import export_to_video

pipe = SanaWMPipeline.from_pretrained(
    "Efficient-Large-Model/SANA-WM_bidirectional-diffusers",
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()  # ~45 GB of weights — offload between stages

# SANA-WM was trained on the LTX-2 VAE in framewise mode with tiling enabled. Without these
# settings the VAE encodes the whole (B, C, T, H, W) clip in one shot, which gives subtly
# different numerics from the released checkpoint.
pipe.vae.enable_tiling()
pipe.vae.use_framewise_encoding = True
pipe.vae.use_framewise_decoding = True
pipe.vae.tile_sample_stride_num_frames = 64
pipe.vae.tile_sample_min_num_frames = 96

prompt = "A car driving across a vast desert plain at golden hour."
output = pipe(
    image=Image.open("input.png").convert("RGB"),
    prompt=prompt,
    action="w-80,jw-40,w-40",        # WASD-style action DSL: forward 80f, jump+forward 40f, forward 40f
    intrinsics=[800.0, 800.0, 845.0, 464.0],  # fx, fy, cx, cy in original-image pixels
    num_frames=161,
    num_inference_steps=60,
    guidance_scale=5.0,
    generator=torch.Generator(device="cuda").manual_seed(42),
    output_type="latent",            # hand the latents to the refiner below
)
```

`action=None` を渡し、独自の `c2w` ポーズ（`(F, 4, 4)` の numpy 配列）を指定して、カメラの軌道を明示的に制御します。`output_type="latent"` を省略すると、ステージ 1 から直接動画を出力でき、リファイナーをスキップできます。

### ステージ 2 — LTX-2 リファイナー

[SanaWMLTX2Refiner](/docs/diffusers/v0.43.0/ja/api/pipelines/sana_wm#diffusers.SanaWMLTX2Refiner) は、SDXL がベースモデルとリファイナーを分離しているのと同様に、独立したリポジトリとして提供されています。重みを2回読み込むのではなく共有するため、ベースパイプラインの VAE を渡してください:

```python
from diffusers import SanaWMLTX2Refiner

refiner = SanaWMLTX2Refiner.from_pretrained(
    "Efficient-Large-Model/SANA-WM_bidirectional-diffusers-refiner",
    vae=pipe.vae,
    torch_dtype=torch.bfloat16,
)
refiner.enable_model_cpu_offload()

frames = refiner(output.latent, prompt, fps=16)
export_to_video(list(frames), "sana_wm.mp4", fps=16)
```

`vae` を指定しない場合、refiner は動画ではなく精錬された latents を返します。これは、自分でデコードを行いたい場合に便利です。

> [!TIP]
> **両方の**パイプラインでオフローディングを有効にするか、ステージ 2 の前にステージ 1 を解放します（`pipe.transformer.to("cpu")`）。2 つのステージを合計すると `torch.bfloat16` で約 45 GB となり、両方を 1 枚の 80 GB カード上に常駐させると、アクティベーションに割り当てるメモリが不足します。また、ステージ 2 は `torch_dtype` を尊重します。`torch.float32` でリファイナを読み込むと、メモリ使用量が約 2 倍になり、出力がわずかに変化します。

カメラの内部パラメータがない場合、ホストされた[モジュラーブロック](../../modular_diffusers/overview)を使用して、単一のフレームからそれらを推定できます。このブロックは、Pi3Xという追加の依存関係と2番目のチェックポイントを必要とするため、`diffusers`の外に配置されています。そのため、明示的に要求するまで何もダウンロードされません。

```python
from diffusers import ModularPipeline

# One-time per image. Requires `pip install pi3-vision`.
estimator = ModularPipeline.from_pretrained(
    "Efficient-Large-Model/pi3x-intrinsics-estimator", trust_remote_code=True
)
estimator.load_components(dtype=torch.bfloat16)
intrinsics = estimator(image=Image.open("input.png").convert("RGB"), output="intrinsics")
```

## 公開されたチェックポイントの変換

ソースのSANA-WMリリース（事前変換済みのdiffusersスナップショットではない場合）をお持ちの場合は、変換スクリプトを一度実行してください：

```bash
python scripts/convert_sana_wm_to_diffusers.py \
    --src Efficient-Large-Model/SANA-WM_bidirectional \
    --dst ./SANA-WM_bidirectional-diffusers
```

これにより2つのディレクトリが書き出されます。ベースのパイプラインは`--dst`に、ステージ2のリファイナーは`./SANA-WM_bidirectional-diffusers-refiner`に書き出されます（`--dst-refiner`で上書き可能）。その後、それぞれをローカルパスから通常どおり読み込みます。

## コンポーネント

- `tokenizer` — `GemmaTokenizerFast`
- `text_encoder` — Gemma-2（デコーダーの隠れ状態を返します）
- `vae` — [AutoencoderKLLTX2Video](/docs/diffusers/v0.43.0/ja/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video)（LTX-2、空間 ×32 / 時間 ×8）
- `transformer` — [SanaWMTransformer3DModel](/docs/diffusers/v0.43.0/ja/api/models/sana_wm_transformer3d#diffusers.SanaWMTransformer3DModel)、1.6Bパラメータの双方向DiT
- `scheduler` — [FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/ja/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)

ステージ2のリファイナーは、独自の`transformer`（[SanaWMLTX2RefinerTransformer3DModel](/docs/diffusers/v0.43.0/ja/api/models/sana_wm_refiner_transformer3d#diffusers.SanaWMLTX2RefinerTransformer3DModel)）、`connectors`（`LTX2TextConnectors`）、`tokenizer`、Gemma-3の`text_encoder`および`scheduler`を備えた、独立したリポジトリです。独自の`vae`は持たないため、ベースのパイプラインのものを渡してください。

## SanaWMPipeline[[diffusers.SanaWMPipeline]]

#### diffusers.SanaWMPipeline[[diffusers.SanaWMPipeline]]

```python
diffusers.SanaWMPipeline(tokenizer: GemmaTokenizer | GemmaTokenizerFast, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderKLLTX2Video, transformer: SanaWMTransformer3DModel, scheduler: FlowMatchEulerDiscreteScheduler)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L143)

**パラメータ:**

tokenizer ([*GemmaTokenizer*] または [*GemmaTokenizerFast*]) : Gemma-2 のトークナイザー。

text_encoder ([*Gemma2PreTrainedModel*]) : Gemma-2のテキストエンコーダーです。

vae ([*AutoencoderKLLTX2Video*]) : LTX-2 VAEです。

transformer ([*SanaWMTransformer3DModel*]) : 1600Mの双方向SANA-WM DiTです。

scheduler ([*FlowMatchEulerDiscreteScheduler*]) : フローマッチングEulerスケジューラ（LTXスタイルのトークンごとのタイムステップ）。latentsを直接

SANA-WMのカメラ制御による画像から動画へのパイプライン。

`c2w` ポーズまたは WASD/IJKL アクション文字列で指定されたカメラ軌跡、テキストプロンプト、および最初のフレーム画像から動画を生成します。ステージ1のサンプリングには1600Mの双方向 SANA DiT を、ステージ2の仕上げには LTX-2 sink-bidirectional Euler refiner を使用し、どちらも LTX-2 VAE を通じてデコードされます。

#### __call__[[diffusers.SanaWMPipeline.__call__]]

```python
__call__(image: PIL.Image.Image | str | Path, prompt: str, c2w: np.ndarray | None = None, action: str | None = None, intrinsics: np.ndarray | list[float] | None = None, height: int = 704, width: int = 1280, num_frames: int = 161, fps: int = 16, num_inference_steps: int = 60, guidance_scale: float = 5.0, negative_prompt: str = '', generator: torch.Generator | list[torch.Generator] | None = None, prompt_embeds: torch.Tensor | None = None, prompt_attention_mask: torch.Tensor | None = None, negative_prompt_embeds: torch.Tensor | None = None, negative_prompt_attention_mask: torch.Tensor | None = None, max_sequence_length: int = 300, chi_prompt: list[str] | None = None, output_type: Literal['np', 'pil', 'pt', 'latent'] = 'np', callback_on_step_end: Callable[[DiffusionPipeline, int, int, dict], dict] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], return_dict: bool = True)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L457)

**パラメータ:**

image (*PIL.Image.Image* または *str*) : 最初のフレームの画像（PIL またはパス）。

prompt (*str*) : テキストプロンプト。

c2w (*np.ndarray*、*optional*) : `(F, 4, 4)` のカメラからワールドへのポーズ。*action* とは排他的です。

action (*str*、*optional*) : Action-DSL 文字列。例: `"w-80,jw-40,w-40"`。*c2w* とは排他的です。

intrinsics (*np.ndarray* または *list[float]*) : **元の画像**のピクセル座標における `[fx, fy, cx, cy]`。パイプラインは内部でリサイズとクロップの変換を適用します。

height (*int*、デフォルトは 704) : 出力フレームの高さ（公開モデルでは固定されています）。

width (*int*、デフォルトは 1280) : 出力フレームの幅（公開モデルでは固定されています）。

num_frames (*int*、デフォルトは 161) : 対象のフレーム数。LTX-2 VAE の制約により、`8k+1` にスナップされます。

fps (*int*、デフォルトは 16) : 出力フレームレート（リファイナーにも渡されます）。

num_inference_steps (*int*、デフォルトは 60) : ステージ 1 の DiT サンプリングステップ数。

guidance_scale (*float*、デフォルト値は 5.0) : Classifier-free guidance のスケール。

negative_prompt (*str*、デフォルトは "") : 任意のネガティブプロンプト。

generator (*torch.Generator* または *list[torch.Generator]*、*optional*) : ノイズサンプリングを決定論的にするための1つ以上のtorchジェネレーター。*None* の場合、サンプリングは非決定論的になります。

prompt_embeds (*torch.Tensor*、*optional*) : テキストエンコーダーをスキップするために事前計算されたテキスト埋め込み。*prompt_attention_mask* と一緒に渡す必要があります。

prompt_attention_mask (*torch.Tensor*, *optional*) : *prompt_embeds* 用のアテンションマスク。

negative_prompt_embeds (*torch.Tensor*、*optional*) : 事前計算されたネガティブテキスト埋め込み。必ず *negative_prompt_attention_mask* と一緒に渡す必要があります。

negative_prompt_attention_mask (*torch.Tensor*、*optional*) : *negative_prompt_embeds*用のアテンションマスク。

max_sequence_length (*int*、デフォルトは 300) : プロンプトの最大トークン数。

chi_prompt (*list[str]*、*optional*) : chi-prompt のプレフィックスを上書きします（デフォルトはパブリックリリースと同一です）。

output_type (*"np"*、*"pil"*、*"pt"*、または *"latent"*、デフォルトは *"np"*) : 出力形式。

callback_on_step_end (*Callable*、*任意*) : 各デノイジングステップの終了時に *callback_on_step_end(self, step, timestep, callback_kwargs)* として呼び出されます。ここで *callback_kwargs* は、*callback_on_step_end_tensor_inputs* で指定された名前のテンソルを保持します。返された dict 内のテンソルは、パイプライン側のテンソルを置き換えます。

callback_on_step_end_tensor_inputs (*list[str]*、デフォルトは *["latents"]*) : *callback_on_step_end* に渡すテンソルを指定します。*._callback_tensor_inputs* の部分集合である必要があります。

return_dict (*bool*、デフォルトは True) : [*SanaWMPipelineOutput*] を返すか、タプルを返すかを指定します。

**戻り値:**

`(T, H, W, 3)` の形状を持つ *.frames* を持つ [*SanaWMPipelineOutput*]。*output_type="np"* の場合は `[0, 1]` の範囲の float 型 `np.ndarray`、*"pil"* の場合は長さ `T` の `PIL.Image.Image` のリスト、*"pt"* の場合は `(T, 3, H, W)` のテンソル、*"latent"* の場合は生の潜在テンソルです。

SANA-WMのカメラ制御動画を生成します。

例:
```py
>>> import torch
>>> from PIL import Image
>>> from diffusers import SanaWMPipeline

>>> pipe = SanaWMPipeline.from_pretrained(
...     "Efficient-Large-Model/SANA-WM_bidirectional-diffusers", torch_dtype=torch.bfloat16
... ).to("cuda")

>>> output = pipe(
...     image=Image.open("input.png").convert("RGB"),
...     prompt="A car driving across a vast desert plain at golden hour.",
...     action="w-80,jw-40,w-40",
...     intrinsics=[800.0, 800.0, 845.0, 464.0],  # fx, fy, cx, cy in original-image pixels
...     num_inference_steps=60,
... )
>>> # output.frames is (T, H, W, 3) float np.ndarray in [0, 1] (diffusers convention).
```

#### check_inputs[[diffusers.SanaWMPipeline.check_inputs]]

```python
check_inputs(c2w: np.ndarray | None, action: str | None, intrinsics: np.ndarray | list[float] | None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L335)

`__call__` の入力を検証します。無効な入力の場合は例外を発生させ、何も返しません。

#### encode_prompt[[diffusers.SanaWMPipeline.encode_prompt]]

```python
encode_prompt(prompt: str, negative_prompt: str = '', device: torch.device | None = None, max_sequence_length: int = 300, chi_prompt: list[str] | None = None, prompt_embeds: torch.Tensor | None = None, prompt_attention_mask: torch.Tensor | None = None, negative_prompt_embeds: torch.Tensor | None = None, negative_prompt_attention_mask: torch.Tensor | None = None)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L204)

**戻り値:**

`(cond, cond_mask, neg, neg_mask)` ただし、`cond` と `neg` は `(1, 1, L, D)` 形状の Gemma 隠れ状態であり、マスクは `(1, L)` です。

Gemma-2でプロンプトとネガティブプロンプトをエンコードします。

SANAのchi-prompt-prefixトリックを模倣しています。chiプロンプトをユーザープロンプトの先頭に付加し、その後、`select_index = [0, -L+1, ..., -1]`のスライスによってBOSトークンと最後の`max_sequence_length - 1`トークンを取得します。

#### prepare_camera_trajectory[[diffusers.SanaWMPipeline.prepare_camera_trajectory]]

```python
prepare_camera_trajectory(c2w: np.ndarray | None, action: str | None, intrinsics: np.ndarray | list[float], num_frames: int)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L365)

カメラ入力を`(c2w_(F, 4, 4), intrinsics_(F, 4))`に正規化します。

また、`num_frames`をVAEに適合する`8k+1`に丸め、両方の配列をそれに合わせて切り詰めます。トリミングされた画像とリスケールされたイントリニクスは、ターゲット解像度が判明した後に取得されます。

#### prepare_latents[[diffusers.SanaWMPipeline.prepare_latents]]

```python
prepare_latents(first_latent: torch.Tensor, num_frames: int, height: int, width: int, dtype: torch.dtype, device: torch.device, generator: torch.Generator)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L403)

初期の潜在変数をサンプリングし、最初のフレームを条件付けアンカーとして固定します。

`(latents, condition_mask)` を返します。`condition_mask` は、最初のフレームのトークンに 1（サンプリング全体を通じてクリーンに保たれます）、それ以外の位置に 0 を持ちます。

## SanaWMLTX2Refiner[[diffusers.SanaWMLTX2Refiner]]

LTX-2 のステージ2リファイナーは、ステージ1の潜在変数を受け取る独立した [DiffusionPipeline](/docs/diffusers/v0.43.0/ja/api/pipelines/overview#diffusers.DiffusionPipeline) です。`vae`（ベースのパイプラインのものを指定して重みを共有する）を渡すと、動画にデコードされます。指定しない場合は、リファインされた潜在変数が返されます。

#### diffusers.SanaWMLTX2Refiner[[diffusers.SanaWMLTX2Refiner]]

```python
diffusers.SanaWMLTX2Refiner(transformer: SanaWMLTX2RefinerTransformer3DModel, connectors: LTX2TextConnectors, tokenizer: GemmaTokenizer | GemmaTokenizerFast, text_encoder: Gemma3ForConditionalGeneration, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTX2Video | None = None, text_max_sequence_length: int = 1024)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/refiner.py#L47)

**パラメータ:**

transformer ([*SanaWMLTX2RefinerTransformer3DModel*]) : チャンク因果スライディングウィンドウKVキャッシュを備えたLTX-2ビデオDiTです。

connectors ([*LTX2TextConnectors*]) : LTX-2 テキストコネクタ。

tokenizer : Gemma-3 トークナイザー。

text_encoder : Gemma-3 テキストエンコーダー。

scheduler ([*FlowMatchEulerDiscreteScheduler*]) : Flow-matching Euler スケジューラ。`shift=1.0` で構築されるため、蒸留されたシグマは変更なしでそのまま渡されます。

vae ([*AutoencoderKLLTX2Video*], *任意*) : [*SanaWMPipeline*]で使用されているのと同じVAEです。重みを共有するには、*vae=pipe.vae*を渡してください。指定された場合、リファイナは動画をデコードし、指定されなかった場合はリファインされた潜在変数を返します。

text_max_sequence_length (*int*、デフォルト値は 1024) : Gemma-3 トークナイザーに渡す最大トークン数。

LTX-2 sink-bidirectional Euler refiner — SANA-WM ステージ 2、スタンドアロンパイプラインとして。

LTX-2のコンポーネント（refiner transformer、テキストコネクタ、Gemma-3テキストエンコーダー、トークナイザー）と、蒸留されたシグマスケジュールを保持しEulerステップを実行する[*FlowMatchEulerDiscreteScheduler*]をラップします。[*SanaWMPipeline*]の任意のコンポーネントとして登録されており、単独で使用してステージ1の潜在変数をリファインすることもできます。

#### __call__[[diffusers.SanaWMLTX2Refiner.__call__]]

```python
__call__(sana_latent: torch.Tensor, prompt: str, fps: float, sink_size: int = 1, generator: torch.Generator | None = None, block_size: int = 3, kv_max_frames: int = 11, sigmas: tuple[float, ...] = (0.909375, 0.725, 0.421875, 0.0), output_type: str = 'np')
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/refiner.py#L107)

**パラメータ:**

sana_latent : `(B, C, F, H, W)` ステージ1の潜在変数。

prompt : テキストプロンプト。

fps : 動画のフレームレート（LTX-2 RoPE の時間方向スケーリングを制御します）。

sink_size : 注意のアンカーとして固定する先頭の生`z_sana`フレームの数（標準: 1）。

generator : FM エンドポイントノイズ用の torch.Generator。デフォルトではシード 42 で初期化されたジェネレーターが使用され、そのまま再現可能な結果が得られます。

block_size : ARブロックあたりの潜在フレーム数（標準: 3）。

kv_max_frames : スライディングウィンドウ内で保持される最大コンテキスト+アクティブフレーム数（標準: 11 = 1つのシンク + 直近10フレーム）。

sigmas : 0.0 で終了する降下型 Euler スケジュール（正規の 3 ステップ蒸留: `(0.909375, 0.725, 0.421875, 0.0)`）。`self.scheduler` に渡されます（末尾の 0.0 は除外。スケジューラが自動的に追加するため）。

output_type : *"latent"* を指定すると、精錬された潜在変数が返されます。それ以外の値を指定すると、*self.vae* を通じてデコードし、*"np"*、*"pt"*、*"pil"* のいずれかの型に後処理して返します。*vae* が存在しない場合は、いずれの指定でも潜在変数が返されます。

**戻り値:** `*torch.Tensor*`

`(B, C, F, H, W)` の形状を持つ洗練された VAE の潜在変数 — 最初の `sink_size` フレームは、ステージ 1 のシンク潜在変数がそのまま保持され、残りは洗練された出力が保持されます。

LTX-2 リファイナーを実行し、リファインされたVAE潜在変数を返します。

モデルの学習で使用されたチャンク因果 AR レシピ（`block_size=3`、`kv_max_frames=11`）を使用します。`[source_sink + recent_history + active_block]` の K/V スライディングウィンドウを 1 ブロックずつ Transformer に供給するため、ブロックごとの計算量は上限が設定され、全体のリファインメントコストは動画の長さに比例して線形に増加します。

## SanaWMPipelineOutput[[diffusers.SanaWMPipelineOutput]]

#### diffusers.SanaWMPipelineOutput[[diffusers.SanaWMPipelineOutput]]

```python
diffusers.SanaWMPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]], c2w: numpy.ndarray | None = None, latent: typing.Optional[torch.Tensor] = None)
```

[ソース](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana_wm/pipeline_output.py#L25)

**パラメータ:**

frames (*torch.Tensor*、*np.ndarray*、または *list[PIL.Image.Image]*) : 生成された動画: `output_type="np"` の場合は `[0, 1]` の範囲の `(T, H, W, 3)` 形状の float `np.ndarray`、`"pt"` の場合は `(T, 3, H, W)` のテンソル、`"pil"` の場合は `T` 個の `PIL.Image` のリスト、`"latent"` の場合は潜在テンソル `(B, C, T_lat, H_lat, W_lat)`。

c2w (*np.ndarray*) : `frames` と整合したカメラからワールドへのポーズ `(T, 4, 4)`（リファイナが sink アンカーフレームを削除します。リファイナが実行された場合、この配列はそれに合わせて再整合されます）。

latent (*torch.Tensor*, 任意) : LTX-2 VAE 空間における潜在テンソル。形状は `(B, C, T_lat, H_lat, W_lat)` です。`output_type="latent"` の場合に返されます。

SANA-WMの画像から動画へのパイプライン用の出力クラスです。