# SANA-WM

SANA-WM, SANA üzerine inşa edilmiş, kamera kontrollü görüntüden videoya dünya modelidir. İlk kare görüntüsü, bir metin komutu ve bir kamera yörüngesi (açıkça belirtilmiş `c2w` pozları veya WASD/IJKL eylem dizesi) verildiğinde, hareketi istenen kamera yolunu izleyen bir video üretir.

Çıkarım iki aşamada çalışır:

1. **Aşama 1 — SANA-WM DiT.** GDN-Triton doğrusal dikkat ve UCPE kamera kontrol dalına sahip, 1,6B parametreli çift yönlü bir DiT. Örnekleme, token başına zaman adımları kullanan LTX tarzı bir akış eşleştirme Euler zamanlayıcısı kullanır; ilk gizli çerçeve, koşullandırma çapasıdır.
2. **Aşama 2 — LTX-2 iyileştirici (isteğe bağlı).** [SanaWMLTX2RefinerTransformer3DModel](/docs/diffusers/main/tr/api/models/sana_wm_refiner_transformer3d#diffusers.SanaWMLTX2RefinerTransformer3DModel) + `LTX2TextConnectors` ve bir Gemma-3 metin kodlayıcısını saran, 3 damıtılmış sigma adımı için çalıştırılan ayrı bir sink-bidirectional Euler iyileştirici hattı ([SanaWMLTX2Refiner](/docs/diffusers/main/tr/api/pipelines/sana_wm#diffusers.SanaWMLTX2Refiner)).

Her iki aşama da [AutoencoderKLLTX2Video](/docs/diffusers/main/tr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video) VAE üzerinden çözümlenir.

Mevcut modeller:

| Model | Önerilen 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, sabit 704×1280 çözünürlükte eğitilmiştir. Önerilen dtype, transformer ağırlıkları içindir — en iyi sayısal sonuçlar için metin kodlayıcıyı `torch.bfloat16` ve VAE'yi `torch.float32` olarak tutun. Pipeline, kamera içsel parametrelerini `[fx, fy, cx, cy]` biçiminde *orijinal görüntü* piksel koordinatlarında bekler; yeniden boyutlandırma ve merkezden kırpma dönüşümü dahili olarak uygulanır.

## Çıkarım

```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` parametresini geçirin ve kamera yörüngesini açıkça yönlendirmek için kendi `c2w` pozlarınızı (`(F, 4, 4)` numpy dizisi) sağlayın. Videoyu doğrudan 1. aşamadan almak ve iyileştiriciyi atlamak için `output_type="latent"` değerini kaldırın.

### Aşama 2 — LTX-2 iyileştirici

[SanaWMLTX2Refiner](/docs/diffusers/main/tr/api/pipelines/sana_wm#diffusers.SanaWMLTX2Refiner), SDXL'in taban ve rafineri bileşenlerini ayırma biçiminde, kendi deposu olarak dağıtılır. Ağırlıkların iki kez yüklenmesi yerine paylaşılması için taban hattın VAE'sini iletin:

```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` olmadan refiner, video yerine rafine edilmiş latents döndürür; bu, kendiniz decode etmek istiyorsanız faydalıdır.

> [!TIP]
> Her iki **pipeline** için de offloading'i etkinleştirin veya 2. aşamadan önce 1. aşamayı serbest bırakın (`pipe.transformer.to("cpu")`). İki aşama birlikte `torch.bfloat16` ile yaklaşık 45 GB tutar ve her ikisinin de tek bir 80 GB kartta kalması, aktivasyonlar için yeterince yer bırakmaz. Ayrıca 2. aşamanın `torch_dtype` parametresine uyduğunu da not edelim: refiner'ı `torch.float32` ile yüklemek bellek kullanımını yaklaşık ikiye katlar ve çıktıyı hafifçe değiştirir.

Kamera içsel parametreleriniz yoksa, barındırılan bir [modüler blok](../../modular_diffusers/overview) bunları tek bir kareden tahmin edebilir. Ek bir bağımlılık olan Pi3X ve ikinci bir checkpoint gerektirdiği için `diffusers` dışında tutulur; siz talep edene kadar hiçbir şey indirilmez:

```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")
```

## Yayınlanan kontrol noktasını dönüştürme

SANA-WM kaynak sürümüne (ön dönüştürülmüş diffusers anlık görüntüsüne değil) sahipseniz, dönüştürme betiğini bir kez çalıştırın:

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

Bu işlem iki dizin yazar: temel hattı `--dst` konumuna ve 2. aşama iyileştiricisini yanına `./SANA-WM_bidirectional-diffusers-refiner` konumuna (`--dst-refiner` ile geçersiz kılınabilir). Ardından her birini yerel yolundan normal şekilde yükleyin.

## Bileşenler

- `tokenizer` — `GemmaTokenizerFast`
- `text_encoder` — Gemma-2 (decoder gizli durumlarını döndürür)
- `vae` — [AutoencoderKLLTX2Video](/docs/diffusers/main/tr/api/models/autoencoderkl_ltx_2#diffusers.AutoencoderKLLTX2Video) (LTX-2, uzamsal ×32 / zamansal ×8)
- `transformer` — [SanaWMTransformer3DModel](/docs/diffusers/main/tr/api/models/sana_wm_transformer3d#diffusers.SanaWMTransformer3DModel), 1,6B parametreli çift yönlü DiT
- `scheduler` — [FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/tr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)

Stage-2 refiner, kendi `transformer` ([SanaWMLTX2RefinerTransformer3DModel](/docs/diffusers/main/tr/api/models/sana_wm_refiner_transformer3d#diffusers.SanaWMLTX2RefinerTransformer3DModel)), `connectors` (`LTX2TextConnectors`), `tokenizer`, Gemma-3 `text_encoder` ve `scheduler` bileşenlerine sahip ayrı bir depodur. Kendine ait bir `vae` yoktur — temel pipeline'ınkini iletin.

## SanaWMPipeline[[diffusers.SanaWMPipeline]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L143)

**Parametreler:**

tokenizer ([*GemmaTokenizer*] veya [*GemmaTokenizerFast*]) : Gemma-2 tokenizer'ı.

text_encoder ([*Gemma2PreTrainedModel*]) : Gemma-2 metin kodlayıcısı.

vae ([*AutoencoderKLLTX2Video*]) : LTX-2 VAE'si.

transformer ([*SanaWMTransformer3DModel*]) : 1600M parametreli çift yönlü SANA-WM DiT.

scheduler ([*FlowMatchEulerDiscreteScheduler*]) : Akış eşleştirme Euler zamanlayıcısı (LTX tarzı token başına zaman adımları). latents doğrudan.

SANA-WM kamera kontrollü görüntüden videoya dönüştürme hattı.

İlk kare görüntüsünden, bir metin komutundan ve bir kamera yörüngesinden (açık `c2w` pozları veya bir WASD/IJKL eylem dizesi) video üretir. 1. aşama örneklemesi için 1600M çift yönlü SANA DiT'yi, 2. aşama cilası için LTX-2 sink-bidirectional Euler iyileştiricisini kullanır; her ikisi de LTX-2 VAE üzerinden çözümlenir.

#### __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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L457)

**Parametreler:**

image (*PIL.Image.Image* veya *str*) : İlk kare görüntüsü (PIL veya yol).

prompt (*str*) : Metin komutu.

c2w (*np.ndarray*, *opsiyonel*) : `(F, 4, 4)` kamera-dünya pozları. *action* ile karşılıklı olarak dışlayıcıdır.

action (*str*, *isteğe bağlı*) : Eylem-DSL dizesi, örn. `"w-80,jw-40,w-40"`. *c2w* ile karşılıklı dışlayıcıdır.

intrinsics (*np.ndarray* veya *list[float]*) : **original-image** piksel koordinatlarında `[fx, fy, cx, cy]`. Pipeline, resize+crop dönüşümünü içsel olarak uygular.

height (*int*, varsayılan 704) : Çıktı kare yüksekliği (halka açık model için sabittir).

width (*int*, varsayılan 1280) : Çıktı kare genişliği (halka açık model için sabittir).

num_frames (*int*, varsayılan 161) : Hedef kare sayısı; `8k+1` değerine ayarlanır (LTX-2 VAE kısıtı).

fps (*int*, varsayılan 16) : Çıktı kare hızı (aynı zamanda refiner'a da iletilir).

num_inference_steps (*int*, varsayılan 60) : 1. aşama DiT örneklemesi için adım sayısı.

guidance_scale (*float*, varsayılan 5.0) : Classifier-free guidance ölçeği.

negative_prompt (*str*, varsayılan "") : İsteğe bağlı negatif istem.

generator (*torch.Generator* veya *list[torch.Generator]*, *opsiyonel*) : Gürültü örneklemesini deterministik hale getirmek için bir veya daha fazla torch jeneratörü. *None* ise, örneklemesi deterministik değildir.

prompt_embeds (*torch.Tensor*, *isteğe bağlı*) : Metin kodlayıcısını atlamak için önceden hesaplanmış metin gömme değerleri. *prompt_attention_mask* ile birlikte geçirilmelidir.

prompt_attention_mask (*torch.Tensor*, *opsiyonel*) : *prompt_embeds* için dikkat maskesi.

negative_prompt_embeds (*torch.Tensor*, *opsiyonel*) : Ön hesaplanmış negatif metin gömme değerleri. *negative_prompt_attention_mask* ile birlikte geçirilmelidir.

negative_prompt_attention_mask (*torch.Tensor*, *isteğe bağlı*) : *negative_prompt_embeds* için dikkat maskesi.

max_sequence_length (*int*, varsayılan 300) : Maksimum istem belirteçleri.

chi_prompt (*list[str]*, *opsiyonel*) : chi-prompt önekini geçersiz kılar (varsayılan, herkese açık sürümle aynıdır).

output_type (*"np"*, *"pil"*, *"pt"* veya *"latent"*, varsayılan *"np"*) : Çıktı biçimi.

callback_on_step_end (*Callable*, *isteğe bağlı*) : *callback_on_step_end_tensor_inputs* içinde adları belirtilen tensörleri içeren *callback_kwargs* ile her gürültü azaltma adımının sonunda *callback_on_step_end(self, step, timestep, callback_kwargs)* olarak çağrılır. Dönen sözlükteki tensörler, hattınkileri değiştirir.

callback_on_step_end_tensor_inputs (*list[str]*, varsayılan *["latents"]*) : *callback_on_step_end*'e iletilecek tensörler; *._callback_tensor_inputs*'ün bir alt kümesi olmalıdır.

return_dict (*bool*, varsayılan True) : [*SanaWMPipelineOutput*] döndürür, tuple değil.

**Dönüş:**

`(T, H, W, 3)` biçiminde *.frames* içeren [*SanaWMPipelineOutput*], *output_type="np"* için `[0, 1]` aralığında float `np.ndarray`, *"pil"* için `T` uzunluğunda `PIL.Image.Image` listesi, *"pt"* için `(T, 3, H, W)` tensörü veya *"latent"* için ham latent tensör.

SANA-WM kamera kontrollü video oluşturun.

Örnekler:
```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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L335)

`__call__` girdilerini doğrular. Geçersiz girdide hata fırlatır ve hiçbir şey döndürmez.

#### 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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L204)

**Dönüş:**

`(cond, cond_mask, neg, neg_mask)` burada `cond` ve `neg`, `(1, 1, L, D)` boyutlu Gemma gizli durumlarıdır ve maskeler `(1, L)` boyutundadır.

Gemma-2 üzerinden prompt + negatif prompt'u kodlayın.

SANA chi-prompt-prefix hilesini yansıtır: chi prompt, kullanıcı promptunun başına eklenir, ardından `select_index = [0, -L+1, ..., -1]` dilimi BOS token'ını ve son `max_sequence_length - 1` token'ı alır.

#### 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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L365)

Kamera girdilerini `(c2w_(F, 4, 4), intrinsics_(F, 4))` olarak normalize edin.

Ayrıca `num_frames` değerini VAE uyumlu `8k+1` değerine yuvarlar ve her iki diziyi buna göre kırpıp eşitler. Kırpılmış görüntü ve yeniden ölçeklenmiş içsel parametreler, hedef çözünürlük bilindiğinde daha sonra gelir.

#### 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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_sana_wm.py#L403)

Başlangıç latenslerini örnekleyin ve ilk kareyi koşullama çapası olarak sabitleyin.

`(latents, condition_mask)` döndürür; burada `condition_mask`, ilk karedeki tokenlarda (örnekleme boyunca temiz tutulurlar) bir, diğer yerlerde sıfır içerir.

## SanaWMLTX2Refiner[[diffusers.SanaWMLTX2Refiner]]

LTX-2 stage-2 refiner, stage-1 latents alan bağımsız bir [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline)'dir. Videoya decode etmesi için ona bir `vae` (ağırlıkların paylaşılması için temel pipeline'ınki) verin; yoksa rafine edilmiş latents döndürür.

#### 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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/refiner.py#L47)

**Parametreler:**

transformer ([*SanaWMLTX2RefinerTransformer3DModel*]) : Parça-nedensel kayan pencere KV önbelleğine sahip LTX-2 video DiT'si.

connectors ([*LTX2TextConnectors*]) : LTX-2 metin bağlantıları.

tokenizer : Gemma-3 tokenizer'ı.

text_encoder : Gemma-3 metin kodlayıcısı.

scheduler ([*FlowMatchEulerDiscreteScheduler*]) : Akış eşleştirme Euler zamanlayıcısı. Damıtılmış sigmaların değiştirilmeden geçmesi için `shift=1.0` ile oluşturulur.

vae ([*AutoencoderKLLTX2Video*], *isteğe bağlı*) : [*SanaWMPipeline*] tarafından kullanılan aynı VAE; ağırlıkları paylaşmak için *vae=pipe.vae* parametresini iletin. Verildiğinde, iyileştirici (refiner) videoya çözer, aksi halde iyileştirilmiş latentleri döndürür.

text_max_sequence_length (*int*, varsayılan 1024) : Gemma-3 tokenizer'ına iletilen en fazla token sayısı.

LTX-2 sink-bidirectional Euler refiner — SANA-WM 2. aşama, bağımsız bir pipeline olarak.

LTX-2 bileşenlerini (refiner transformer + metin bağlayıcıları + Gemma-3 metin kodlayıcı + tokenizer) ve damıtılmış sigma zamanlamasını taşıyıp Euler adımlarını gerçekleştiren [*FlowMatchEulerDiscreteScheduler*] bileşenini sarar. [*SanaWMPipeline*] içinde isteğe bağlı bir bileşen olarak kayıtlıdır ve ayrıca 1. aşama latentlerini rafine etmek için tek başına da kullanılabilir.

#### __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')
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/refiner.py#L107)

**Parametreler:**

sana_latent : `(B, C, F, H, W)` 1. aşama gizli değişkeni.

prompt : metin komutu.

fps : video kare hızı (LTX-2 RoPE zaman ölçeklemesini belirler).

sink_size : dikkat çapası olarak sabitlenecek kaç adet başlangıç ham `z_sana` çerçevesi (standart: 1).

generator : FM uç noktası gürültüsü için torch.Generator. Varsayılan olarak, sonuçların kutudan çıktığı gibi tekrarlanabilir olması için 42 ile tohumlanmış bir üreteçtir.

block_size : AR bloğu başına gizli kare sayısı (standart: 3).

kv_max_frames : kayan pencerede tutulan maksimum bağlam + aktif kare sayısı (standart: 11 = 1 çapa + 10 son).

sigmas : 0.0'da sonlanan azalan Euler zamanlaması (kanonik 3 adımlık damıtılmış: `(0.909375, 0.725, 0.421875, 0.0)`). `self.scheduler`'a verilir (sonundaki 0.0 hariçtir, zamanlayıcı bunu kendisi ekler).

output_type : *"latent"* rafine edilmiş latentleri döndürür. Diğer her şey *self.vae* üzerinden çözümlenir ve o tipe (*"np"*, *"pt"*, *"pil"*) göre son işleme tabi tutulur; *vae* yoksa latentler her durumda döndürülür.

**Dönüş:** `*torch.Tensor*`

`(B, C, F, H, W)` biçiminde rafine edilmiş VAE latents — ilk `sink_size` kare, ham 1. aşama sink latents'ini değiştirilmeden taşır, geri kalanı ise rafine edilmiş çıktıyı taşır.

LTX-2 iyileştiricisini çalıştırın ve iyileştirilmiş VAE latentlerini döndürün.

Modelin eğitiminde kullanılan chunk-causal AR tarifini kullanır (`block_size=3`, `kv_max_frames=11`): `[source_sink + recent_history + active_block]` K/V kayan penceresi, transformer'a blok blok beslenir; böylece blok başına hesaplama sınırlı kalır ve toplam iyileştirme maliyeti video uzunluğuyla doğrusal olarak ölçeklenir.

## 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)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_wm/pipeline_output.py#L25)

**Parametreler:**

frames (*torch.Tensor*, *np.ndarray* veya *list[PIL.Image.Image]*) : Üretilen video: `output_type="np"` için `[0, 1]` aralığında `(T, H, W, 3)` biçiminde bir `np.ndarray`, `"pt"` için `(T, 3, H, W)` biçiminde bir tensör, `"pil"` için `T` adet ``PIL.Image`` içeren bir liste veya `"latent"` için `(B, C, T_lat, H_lat, W_lat)` biçiminde latent tensör.

c2w (*np.ndarray*) : `frames` ile hizalı, kamera-dünya pozları `(T, 4, 4)` (refiner, çapa çerçevesini düşürür; refiner çalıştıysa bu dizi buna göre yeniden hizalanır).

latent (*torch.Tensor*, isteğe bağlı) : LTX-2 VAE uzayındaki latent tensör, şekli `(B, C, T_lat, H_lat, W_lat)`. `output_type="latent"` olduğunda döndürülür.

SANA-WM görüntüden videoya hattı için çıktı sınıfı.