Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /api /pipelines /mochi.md
mishig
1 day ago
preview code
download
raw
23.8 kB
#
# Apache Lisansı, 2.0 Sürümü ("Lisans") altında lisanslanmıştır;
# bu dosyayı, Lisansa uygun olarak kullanabilirsiniz.
# Lisansın bir kopyasını şu adresten edinebilirsiniz
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Uygulanabilir yasa gerektirmedikçe veya yazılı olarak anlaşılmadıkça, yazılım
# Lisans kapsamında dağıtılan, "OLDUĞU GİBİ" esasına göre dağıtılır,
# HİÇBİR TÜR AÇIK VEYA ZIMMİ GARANTİ VEYA ŞART İÇERMEZ.
# İzinleri ve
# Lisans kapsamındaki kısıtlamalar.
-->

# Mochi 1 Önizleme

  

> [!TIP]
> Şu anda yalnızca model ağırlıklarının bir araştırma önizlemesi mevcuttur.

[Mochi 1](https://huggingface.co/genmo/mochi-1-preview), Genmo tarafından geliştirilen, prompt uyumu ve hareket kalitesine güçlü bir odaklanma sunan bir video üretim modelidir. Model, 10B parametreli Asmmetric Diffusion Transformer (AsymmDiT) mimarisine sahiptir ve çıkarım bellek gereksinimlerini azaltmak için kare olmayan QKV ve çıktı projeksiyon katmanları kullanır. Prompt'ları kodlamak için tek bir T5-XXL modeli kullanılır.

*Mochi 1 önizleme, ön değerlendirme sonuçlarına göre yüksek sadakatli hareket ve güçlü istem uyumu sunan, açık kaynaklı ve en ileri düzey video üretim modelidir. Bu model, kapalı ve açık video üretim sistemleri arasındaki farkı büyük ölçüde kapatmaktadır. Model, esnek bir Apache 2.0 lisansı altında yayımlanmıştır.*

> [!TIP]
> Scheduler'lar [kılavuzunu](../../using-diffusers/schedulers) inceleyerek scheduler hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi öğrenin ve aynı bileşenleri birden fazla pipeline'a nasıl verimli bir şekilde yükleyebileceğinizi öğrenmek için [pipeline'lar arasında bileşenleri yeniden kullanma](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) bölümüne göz atın.

## Kantizasyon

Kantizasyon, model ağırlıklarını daha düşük hassasiyetli bir veri türünde saklayarak çok büyük modellerin bellek gereksinimlerini azaltmaya yardımcı olur. Ancak kantizasyonun video kalitesi üzerindeki etkisi, video modeline göre değişebilir.

Desteklenen kuantizasyon arka uçları ve kullanım durumunu destekleyen bir kuantizasyon arka ucunu seçme hakkında daha fazla bilgi edinmek için [Quantization](../../quantization/overview) genel bakışına başvurun. Aşağıdaki örnek, bitsandbytes ile çıkarım için kuantize edilmiş bir [MochiPipeline](/docs/diffusers/main/tr/api/pipelines/mochi#diffusers.MochiPipeline) yüklemenin nasıl yapılacağını göstermektedir.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, MochiTransformer3DModel, MochiPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel
quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)
quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = MochiTransformer3DModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)
pipeline = MochiPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)
video = pipeline(
  "Close-up of a cats eye, with the galaxy reflected in the cats eye. Ultra high resolution 4k.",
  num_inference_steps=28,
  guidance_scale=3.5
).frames[0]
export_to_video(video, "cat.mp4")
```

## Mochi-1 Preview ile video oluşturma

Aşağıdaki örnek, tam hassasiyetli `mochi-1-preview` ağırlıklarını indirir ve en yüksek kalitede sonuçları üretir ancak çalıştırılması için en az 42GB VRAM gerektirir.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview")
# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
      frames = pipe(prompt, num_frames=85).frames[0]
export_to_video(frames, "mochi.mp4", fps=30)
```

## Bellek tasarrufu için daha düşük hassasiyetli bir varyant kullanma

Aşağıdaki örnek, modelin `bfloat16` varyantını kullanır ve çalıştırılması için 22 GB VRAM gerektirir. Sonuç olarak üretilen videonun kalitesinde hafif bir düşüş yaşanır.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", variant="bf16", dtype=torch.bfloat16)
# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
frames = pipe(prompt, num_frames=85).frames[0]
export_to_video(frames, "mochi.mp4", fps=30)
```

## Genmo Mochi deposundaki sonuçları yeniden üretme

[Genmo Mochi uygulaması](https://github.com/genmoai/mochi/tree/main), çıkarım sürecindeki her aşama için farklı hassasiyet değerleri kullanır. Metin kodlayıcı ve VAE `torch.float32` kullanırken, DiT, [dikkat çekirdeğinin](https://pytorch.org/docs/stable/generated/torch.nn.attention.sdpa_kernel.html#torch.nn.attention.sdpa_kernel) `EFFICIENT_ATTENTION` olarak ayarlandığı `torch.bfloat16` ile çalışır. Diffusers hatları, şu anda hattın farklı aşamaları için farklı `dtypes` ayarlamayı desteklememektedir. Çıkarımı orijinal uygulama ile aynı şekilde çalıştırmak için lütfen aşağıdaki örneğe bakın.

> [!TIP]
> Orijinal Mochi uygulaması boş istekleri sıfırlar. Ancak bu seçeneği etkinleştirmek ve tüm hattı autocast altına almak, T5 metin kodlayıcısıyla sayısal taşmalara yol açabilir.
>
> `force_zeros_for_empty_prompt` etkinleştirildiğinde, metin kodlama adımının tam hassasiyetle, autocast bağlamının dışında çalıştırılması önerilir.

> [!TIP]
> Tam hassasiyette latentleri çözmek çok fazla bellek gerektirir. Bu örnekteki 163 kareyi üretmek için en az 70GB VRAM'e ihtiyacınız olacaktır. Belleği azaltmak için kare sayısını azaltın veya çözümleme adımını `torch.bfloat16` ile çalıştırın.

```python
import torch
from torch.nn.attention import SDPBackend, sdpa_kernel
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
from diffusers.video_processor import VideoProcessor
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", force_zeros_for_empty_prompt=True)
pipe.vae.enable_tiling()
pipe.enable_model_cpu_offload()
prompt =  "An aerial shot of a parade of elephants walking across the African savannah. The camera showcases the herd and the surrounding landscape."
with torch.no_grad():
    prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
        pipe.encode_prompt(prompt=prompt)
    )
with torch.autocast("cuda", torch.bfloat16):
    with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION):
        frames = pipe(
            prompt_embeds=prompt_embeds,
            prompt_attention_mask=prompt_attention_mask,
            negative_prompt_embeds=negative_prompt_embeds,
            negative_prompt_attention_mask=negative_prompt_attention_mask,
            guidance_scale=4.5,
            num_inference_steps=64,
            height=480,
            width=848,
            num_frames=163,
            generator=torch.Generator("cuda").manual_seed(0),
            output_type="latent",
            return_dict=False,
        )[0]
video_processor = VideoProcessor(vae_scale_factor=8)
has_latents_mean = hasattr(pipe.vae.config, "latents_mean") and pipe.vae.config.latents_mean is not None
has_latents_std = hasattr(pipe.vae.config, "latents_std") and pipe.vae.config.latents_std is not None
if has_latents_mean and has_latents_std:
    latents_mean = (
        torch.tensor(pipe.vae.config.latents_mean).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    latents_std = (
        torch.tensor(pipe.vae.config.latents_std).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    frames = frames * latents_std / pipe.vae.config.scaling_factor + latents_mean
else:
    frames = frames / pipe.vae.config.scaling_factor
with torch.no_grad():
    video = pipe.vae.decode(frames.to(pipe.vae.dtype), return_dict=False)[0]
video = video_processor.postprocess_video(video)[0]
export_to_video(video, "mochi.mp4", fps=30)
```

## Çoklu GPU ile çıkarım çalıştırma

Büyük Mochi transformer'ı, `from_pretrained` içindeki `device_map` ve `max_memory` seçeneklerini kullanarak birden fazla GPU arasında bölmek mümkündür. Aşağıdaki örnekte model, her biri 24GB VRAM'e sahip iki GPU arasında bölünmektedir.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video
model_id = "genmo/mochi-1-preview"
transformer = MochiTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    device_map="auto",
    max_memory={0: "24GB", 1: "24GB"}
)
pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]
export_to_video(frames, "output.mp4", fps=30)
```

## Mochi Transformer ile tek dosya yükleme kullanımı

Mochi dönüştürücüsünü orijinal biçiminde yüklemek için `from_single_file` kullanabilirsiniz.

> [!TIP]
> Diffusers şu anda Mochi tek dosya checkpoint'lerinin FP8 ölçekli sürümlerini kullanmayı desteklemiyor.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video
model_id = "genmo/mochi-1-preview"
ckpt_path = "https://huggingface.co/Comfy-Org/mochi_preview_repackaged/blob/main/split_files/diffusion_models/mochi_preview_bf16.safetensors"
transformer = MochiTransformer3DModel.from_pretrained(ckpt_path, dtype=torch.bfloat16)
pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]
export_to_video(frames, "output.mp4", fps=30)
```

## MochiPipeline[[diffusers.MochiPipeline]]

#### diffusers.MochiPipeline[[diffusers.MochiPipeline]]

```python
diffusers.MochiPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLMochi, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: MochiTransformer3DModel, force_zeros_for_empty_prompt: bool = False)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L138)

**Parametreler:**

transformer ([MochiTransformer3DModel](/docs/diffusers/main/tr/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel)) : Kodlanmış video latentlerini gürültüden arındırmak için kullanılan koşullu Transformer mimarisi.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/tr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için `transformer` ile birlikte kullanılacak bir zamanlayıcı.

vae ([AutoencoderKLMochi](/docs/diffusers/main/tr/api/models/autoencoderkl_mochi#diffusers.AutoencoderKLMochi)) : Video'ları latent temsillere kodlamak ve latent temsillerden video'lara çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli.

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), özellikle [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) varyantı.
tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı.
tokenizer (`T5TokenizerFast`) : [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast) sınıfının ikinci Tokenizer'ı.
Metinden video üretimi için mochi hattı.
Referans: https://github.com/genmoai/models
#### __call__[[diffusers.MochiPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_frames: int = 19, num_inference_steps: int = 64, timesteps: list = None, guidance_scale: float = 4.5, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], max_sequence_length: int = 256)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L444)
**Parametreler:**
prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmek için istem veya istemler. Tanımlanmamışsa, bunun yerine `prompt_embeds` geçirilmelidir.
negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Tanımlanmamışsa bunun yerine `negative_prompt_embeds` parametresinin geçirilmesi gerekir. Yönlendirme kullanılmadığında (`guidance_scale < 1`) yok sayılır.
height (`int`, *isteğe bağlı*, varsayılan `self.default_height`) : Üretilen görüntünün piksel cinsinden yüksekliği. En iyi sonuçlar için varsayılan olarak 480 olarak ayarlanır.
width (`int`, *isteğe bağlı*, varsayılan `self.default_width`) : Üretilen görüntünün piksel cinsinden genişliği. En iyi sonuçlar için varsayılan olarak 848 olarak ayarlanır.
num_frames (`int`, varsayılan `19`) : Üretilecek video kare sayısı
num_inference_steps (`int`, *isteğe bağlı*, varsayılan 50) : Gürültü azaltma adım sayısı. Daha fazla gürültü azaltma adımı genellikle daha yavaş çıkarım pahasına daha yüksek kaliteli bir görüntüye yol açar.
timesteps (`list[int]`, *isteğe bağlı*) : `set_timesteps` metodunda `timesteps` argümanını destekleyen zamanlayıcılarla gürültü azaltma süreci için kullanılacak özel zaman adımları. Tanımlanmamışsa, `num_inference_steps` geçirildiğinde varsayılan davranış kullanılacaktır. Azalan sırada olmalıdır.
guidance_scale (`float`, varsayılan `4.5`) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlanan yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder.
num_videos_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek video sayısı.
generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi.
latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur.
prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur.
prompt_attention_mask (`torch.Tensor`, *isteğe bağlı*) : Metin gömme (embedding) için önceden oluşturulmuş dikkat maskesi (attention mask).
negative_prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Önceden oluşturulmuş negatif metin gömme değerleri. PixArt-Sigma için bu negatif istem "" olmalıdır. Sağlanmazsa, negative_prompt_embeds, `negative_prompt` girdi argümanından oluşturulur.
negative_prompt_attention_mask (`torch.FloatTensor`, *isteğe bağlı*) : Negatif metin gömme vektörleri için önceden oluşturulmuş dikkat maskesi.
output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` veya `np.array` arasında seçim yapın.
return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `~pipelines.mochi.MochiPipelineOutput` döndürülecek mi?
attention_kwargs (`dict`, *isteğe bağlı*) : Belirtilirse, [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py) içinde `self.processor` altında tanımlanan `AttentionProcessor`'a iletilen bir kwargs sözlüğü.
callback_on_step_end (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her gürültü azaltma adımının sonunda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs`, `callback_on_step_end_tensor_inputs` tarafından belirtilen tüm tensörlerin listesini içerir.
callback_on_step_end_tensor_inputs (`list`, *isteğe bağlı*) : `callback_on_step_end` işlevi için girdi tensörlerinin listesi. Listede belirtilen tensörler, `callback_kwargs` argümanı olarak geçirilir. Yalnızca pipeline sınıfınızın `._callback_tensor_inputs` özniteliğinde listelenen değişkenleri dahil edebilirsiniz.
max_sequence_length (`int` varsayılan olarak `256`'dır) : `prompt` ile kullanılacak maksimum dizi uzunluğu.
**Dönüş:** `~pipelines.mochi.MochiPipelineOutput` veya `tuple`
`return_dict` `True` ise `~pipelines.mochi.MochiPipelineOutput` döndürülür, aksi halde ilk öğesi üretilen görüntülerin listesini içeren bir `tuple` döndürülür.
Üretim için pipeline çağrıldığında tetiklenen işlev.
Örnekler:
```py
>>> import torch
>>> from diffusers import MochiPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()
>>> pipe.vae.enable_tiling()
>>> prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
>>> frames = pipe(prompt, num_inference_steps=28, guidance_scale=3.5).frames[0]
>>> export_to_video(frames, "mochi.mp4")
```
#### encode_prompt[[diffusers.MochiPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_mochi.py#L254)
**Parametreler:**
prompt (`str` veya `list[str]`, *isteğe bağlı*) : kodlanacak istem
negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Tanımlanmazsa, bunun yerine `negative_prompt_embeds` parametresinin geçirilmesi gerekir. Yönlendirme kullanılmadığında (yani `guidance_scale` değeri `1`'den küçükse) yok sayılır.

do_classifier_free_guidance (`bool`, *isteğe bağlı*, varsayılan `True`) : Sınıflandırıcı serbest yönlendirmenin (classifier free guidance) kullanılıp kullanılmayacağı.
num_videos_per_prompt (`int`, *opsiyonel*, varsayılan 1) : Her istem için oluşturulması gereken video sayısı. Sonuç gömme vektörlerinin yerleştirileceği torch cihazı

prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur.
negative_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, negative_prompt_embeds, `negative_prompt` girdi argümanından oluşturulur.

device : (`torch.device`, *isteğe bağlı*): torch cihazı

dtype : (`torch.dtype`, *isteğe bağlı*): torch dtype

İsteği metin kodlayıcı gizli durumlarına kodlar.

## MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]
#### diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]
```python
diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput(frames: Tensor)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/mochi/pipeline_output.py#L9)
**Parametreler:**
frames (`torch.Tensor`, `np.ndarray` veya list[list[PIL.Image.Image]]) : video çıktıları listesi - `batch_size,` uzunluğunda iç içe geçmiş bir liste olabilir; her alt liste, `num_frames.` uzunluğunda gürültüsü azaltılmış PIL görüntü dizileri içerir. Ayrıca `(batch_size, num_frames, channels, height, width)` biçiminde bir NumPy dizi veya Torch tensörü de olabilir.
Mochi pipeline'leri için çıktı sınıfı.
Xet Storage Details

Size:: 23.8 kB
Xet hash:: 2a5b13590f1eab9e940ca66d09301c32c90e027e06b0622d6565472a26000c76
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.