Buckets:
#
# Licenciado sob a Apache License, Versão 2.0 (a "Licença");
# você não pode usar este arquivo, exceto em conformidade com a Licença.
# Você pode obter uma cópia da Licença em
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que exigido pela lei aplicável ou acordado por escrito, o software
# distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",
# SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.
# Consulte a Licença para o idioma específico que rege as permissões e
# limitações sob a Licença. -->
# Cosmos
[Plataforma do Modelo de Fundação Cosmos para IA Física](https://huggingface.co/papers/2501.03575) da NVIDIA.
*A IA física precisa primeiro ser treinada digitalmente. Ela requer um gêmeo digital de si mesma, o modelo de política, e um gêmeo digital do mundo, o modelo de mundo. Neste artigo, apresentamos a Plataforma de Modelos Fundamentais de Mundo Cosmos para ajudar desenvolvedores a construir modelos de mundo personalizados para seus setups de IA física. Posicionamos um modelo fundamental de mundo como um modelo de mundo de uso geral que pode ser ajustado finamente para se tornar modelos de mundo personalizados para aplicações de nível inferior. Nossa plataforma abrange um pipeline de curadoria de vídeo, modelos fundamentais de mundo pré-treinados, exemplos de pós-treinamento de modelos fundamentais de mundo pré-treinados e tokenizadores de vídeo. Para ajudar construtores de IA física a resolver os problemas mais críticos da nossa sociedade, tornamos nossa plataforma open-source e nossos modelos open-weight com licenças permissivas disponíveis via https://github.com/NVIDIA/Cosmos.*
> [!TIP]
> Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines.
## Uso básico
```python
import torch
from diffusers import Cosmos2_5_PredictBasePipeline
from diffusers.utils import export_to_video
model_id = "nvidia/Cosmos-Predict2.5-2B"
pipe = Cosmos2_5_PredictBasePipeline.from_pretrained(
model_id, revision="diffusers/base/post-trained", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
prompt = "As the red light shifts to green, the red bus at the intersection begins to move forward, its headlights cutting through the falling snow. The snowy tire tracks deepen as the vehicle inches ahead, casting fresh lines onto the slushy road. Around it, streetlights glow warmer, illuminating the drifting flakes and wet reflections on the asphalt. Other cars behind start to edge forward, their beams joining the scene. The stillness of the urban street transitions into motion as the quiet snowfall is punctuated by the slow advance of traffic through the frosty city corridor."
negative_prompt = "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality."
output = pipe(
image=None,
video=None,
prompt=prompt,
negative_prompt=negative_prompt,
num_frames=93,
generator=torch.Generator().manual_seed(1),
).frames[0]
export_to_video(output, "text2world.mp4", fps=16)
```
## Cosmos2_5_TransferPipeline[[diffusers.Cosmos2_5_TransferPipeline]]
#### diffusers.Cosmos2_5_TransferPipeline[[diffusers.Cosmos2_5_TransferPipeline]]
```python
diffusers.Cosmos2_5_TransferPipeline(text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: AutoTokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler, controlnet: CosmosControlNetModel, safety_checker: typing.Optional[diffusers.pipelines.cosmos.pipeline_cosmos2_5_transfer.CosmosSafetyChecker] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_transfer.py#L152)
**Parâmetros:**
text_encoder (`Qwen2_5_VLForConditionalGeneration`) : Codificador de texto congelado. O Cosmos Transfer2.5 usa o codificador [Qwen2.5 VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`AutoTokenizer`) : Tokenizer associado ao codificador do Qwen2.5 VL.
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
controlnet (`CosmosControlNetModel`) : ControlNet usado para condicionar a geração em entradas de controle.
Pipeline para Cosmos Transfer2.5, com suporte a inferência auto-regressiva.
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Cosmos2_5_TransferPipeline.__call__]]
```python
__call__(controls: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], typing.List[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]]], controls_conditioning_scale: typing.Union[float, typing.List[float]] = 1.0, prompt: typing.Union[str, typing.List[str], NoneType] = None, negative_prompt: typing.Union[str, typing.List[str]] = 'The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality.', height: int = 704, width: typing.Optional[int] = None, num_frames: typing.Optional[int] = None, num_frames_per_chunk: int = 93, num_inference_steps: int = 36, guidance_scale: float = 3.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, typing.List[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: typing.Optional[str] = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int, typing.Dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 512, conditional_frame_timestep: float = 0.1, num_ar_conditional_frames: typing.Optional[int] = 1, num_ar_latent_conditional_frames: typing.Optional[int] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_transfer.py#L569)
**Parâmetros:**
controls (`PipelineImageInput`, `List[PipelineImageInput]`) : Imagem ou vídeo de controle usado pelo ControlNet.
controls_conditioning_scale (`float` ou `List[float]`, *opcional*, padrão `1.0`) : O(s) fator(es) de escala para as saídas do ControlNet. Um único float é transmitido para todos os blocos de controle.
prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts para orientar a geração. Obrigatório, a menos que `prompt_embeds` seja fornecido.
negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `704`) : A altura em pixels da imagem gerada.
width (`int`, *opcional*) : A largura em pixels da imagem gerada. Se não for fornecida, será determinada com base na proporção de aspecto da entrada e na altura fornecida.
num_frames (`int`, *opcional*) : Número de quadros de saída. O padrão é `None` para produzir o mesmo número de quadros que a entrada `controls`.
num_frames_per_chunk (`int`, *opcional*, padrão `93`) : Número de quadros gerados por chunk auto-regressivo. Quando o número total de quadros excede esse valor, a geração é dividida em múltiplos chunks usando uma abordagem de janela deslizante.
num_inference_steps (`int`, padrão `36`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `3.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `List[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosPipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
conditional_frame_timestep (`float`, *opcional*, padrão 0.1) : Valor do timestep usado para os frames condicionais durante o desruido. Deve estar no intervalo `[0, 1]`.
num_ar_conditional_frames (`int`, *opcional*, padrão `1`) : Número de quadros para condicionar os loops de inferência subsequentes na inferência auto-regressiva, ou seja, para o segundo chunk e os seguintes. Usado apenas se `num_ar_latent_conditional_frames` for `None`. Isso é usado apenas quando a inferência auto-regressiva é executada, ou seja, quando o número de quadros nos controles é > num_frames_per_chunk
num_ar_latent_conditional_frames (`int`, *opcional*) : Número de quadros latentes para condicionar os loops de inferência subsequentes na inferência auto-regressiva, ou seja, para o segundo chunk e os seguintes. Usado apenas se `num_ar_conditional_frames` for `None`. Isso é usado apenas quando a inferência auto-regressiva é executada, ou seja, quando o número de quadros nos controles é > num_frames_per_chunk
**Retorna:** `~CosmosPipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
`controls` controlam o condicionamento por meio do ControlNet. Os controles são considerados pré-processados, por exemplo, mapas de bordas são pré-calculados.
Definir `num_frames` restringirá o número total de quadros de saída; caso não seja fornecido ou seja atribuído a None (padrão), o número de quadros de saída corresponderá à entrada `controls`.
A inferência auto-regressiva é suportada e, portanto, uma janela deslizante de `num_frames_per_chunk` quadros é usada por laço de desruido. Além disso, quando a inferência auto-regressiva é executada, os `num_ar_latent_conditional_frames` ou `num_ar_conditional_frames` anteriores são usados para condicionar os laços de inferência de desruido subsequentes.
Exemplos:
```python
>>> import cv2
>>> import numpy as np
>>> from PIL import Image
>>> import torch
>>> from diffusers import Cosmos2_5_TransferPipeline, AutoModel
>>> from diffusers.utils import export_to_video, load_video
>>> model_id = "nvidia/Cosmos-Transfer2.5-2B"
>>> # Load a Transfer2.5 controlnet variant (edge, depth, seg, or blur)
>>> controlnet = AutoModel.from_pretrained(
... model_id, revision="diffusers/controlnet/general/edge", torch_dtype=torch.bfloat16
... )
>>> pipe = Cosmos2_5_TransferPipeline.from_pretrained(
... model_id, controlnet=controlnet, revision="diffusers/general", torch_dtype=torch.bfloat16
... )
>>> pipe = pipe.to("cuda")
>>> # Video2World with edge control: Generate video guided by edge maps extracted from input video.
>>> prompt = (
... "The video is a demonstration of robotic manipulation, likely in a laboratory or testing environment. It"
... "features two robotic arms interacting with a piece of blue fabric. The setting is a room with a beige"
... "couch in the background, providing a neutral backdrop for the robotic activity. The robotic arms are"
... "positioned on either side of the fabric, which is placed on a yellow cushion. The left robotic arm is"
... "white with a black gripper, while the right arm is black with a more complex, articulated gripper. At the"
... "beginning, the fabric is laid out on the cushion. The left robotic arm approaches the fabric, its gripper"
... "opening and closing as it positions itself. The right arm remains stationary initially, poised to assist."
... "As the video progresses, the left arm grips the fabric, lifting it slightly off the cushion. The right arm"
... "then moves in, its gripper adjusting to grasp the opposite side of the fabric. Both arms work in"
... "coordination, lifting and holding the fabric between them. The fabric is manipulated with precision,"
... "showcasing the dexterity and control of the robotic arms. The camera remains static throughout, focusing"
... "on the interaction between the robotic arms and the fabric, allowing viewers to observe the detailed"
... "movements and coordination involved in the task."
... )
>>> negative_prompt = (
... "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, "
... "over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, "
... "underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky "
... "movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, "
... "fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. "
... "Overall, the video is of poor quality."
... )
>>> input_video = load_video(
... "https://github.com/nvidia-cosmos/cosmos-transfer2.5/raw/refs/heads/main/assets/robot_example/robot_input.mp4"
... )
>>> num_frames = 93
>>> # Extract edge maps from the input video using Canny edge detection
>>> edge_maps = [
... cv2.Canny(cv2.cvtColor(np.array(frame.convert("RGB")), cv2.COLOR_RGB2BGR), 100, 200)
... for frame in input_video[:num_frames]
... ]
>>> edge_maps = np.stack(edge_maps)[None] # (T, H, W) -> (1, T, H, W)
>>> controls = torch.from_numpy(edge_maps).expand(3, -1, -1, -1) # (1, T, H, W) -> (3, T, H, W)
>>> controls = [Image.fromarray(x.numpy()) for x in controls.permute(1, 2, 3, 0)]
>>> export_to_video(controls, "edge_controlled_video_edge.mp4", fps=30)
>>> # Transfer inference with controls.
>>> video = pipe(
... controls=controls,
... controls_conditioning_scale=1.0,
... prompt=prompt,
... negative_prompt=negative_prompt,
... num_frames=num_frames,
... ).frames[0]
>>> export_to_video(video, "edge_controlled_video.mp4", fps=30)
```
#### encode_prompt[[diffusers.Cosmos2_5_TransferPipeline.encode_prompt]]
```python
encode_prompt(prompt: typing.Union[str, typing.List[str]], negative_prompt: typing.Union[str, typing.List[str], NoneType] = 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, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_transfer.py#L296)
**Parâmetros:**
prompt (`str` ou `List[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## Cosmos2_5_PredictBasePipeline[[diffusers.Cosmos2_5_PredictBasePipeline]]
#### diffusers.Cosmos2_5_PredictBasePipeline[[diffusers.Cosmos2_5_PredictBasePipeline]]
```python
diffusers.Cosmos2_5_PredictBasePipeline(text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: AutoTokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler, safety_checker: CosmosSafetyChecker = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_predict.py#L185)
**Parâmetros:**
text_encoder (`Qwen2_5_VLForConditionalGeneration`) : Codificador de texto congelado. O Cosmos Predict2.5 usa o codificador [Qwen2.5 VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`AutoTokenizer`) : Tokenizer associado ao codificador do Qwen2.5 VL.
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
Pipeline para o modelo base [Cosmos Predict2.5](https://github.com/nvidia-cosmos/cosmos-predict2.5).
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Cosmos2_5_PredictBasePipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, prompt: str | list[str] | None = None, negative_prompt: str | list[str] | None = None, height: int = 704, width: int = 1280, num_frames: int = 93, num_inference_steps: int = 36, guidance_scale: float = 7.0, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, conditional_frame_timestep: float = 0.0001, num_latent_conditional_frames: int = 2)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_predict.py#L544)
**Parâmetros:**
image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, *opcional*) : Imagem única opcional para condicionamento de Image2World. Deve ser `None` quando `video` for fornecido.
video (`list[PIL.Image.Image]`, `np.ndarray`, `torch.Tensor`, *opcional*) : Vídeo de entrada opcional para condicionamento do Video2World. Deve ser `None` quando `image` for fornecido.
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração. Obrigatório, a menos que `prompt_embeds` seja fornecido.
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `704`) : A altura em pixels da imagem gerada.
width (`int`, padrão `1280`) : A largura em pixels da imagem gerada.
num_frames (`int`, padrão `93`) : Número de quadros de saída. Use `93` para geração de mundo (vídeo); defina como `1` para retornar um único quadro.
num_inference_steps (`int`, padrão `35`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `7.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosPipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
num_latent_conditional_frames (`int`, padrão `2`) : Número de quadros latentes condicionais a serem usados para o condicionamento do Video2World. O número de quadros de pixels extraídos do vídeo de entrada é calculado como `4 * (num_latent_conditional_frames - 1) + 1`. Defina como 1 para um comportamento semelhante ao Image2World (condicionamento de quadro único).
conditional_frame_timestep (`float`, *opcional*, padrão 0.0001) : Valor do timestep usado para os frames condicionais durante o desruido.
**Retorna:** `~CosmosPipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
A função de chamada do pipeline para geração. Suporta três modos:
- **Text2World**: `image=None`, `video=None`, `prompt` fornecido. Gera um clipe de mundo.
- **Image2World**: `image` fornecido, `video=None`, `prompt` fornecido. Condições em um único quadro.
- **Video2World**: `video` fornecido, `image=None`, `prompt` fornecido. Condições sobre um clipe de entrada.
Defina `num_frames=93` (padrão) para gerar um vídeo de mundo, ou `num_frames=1` para gerar um único quadro de imagem (o acima no "*2Image mode").
As saídas seguem `output_type` (por exemplo, `"pil"` retorna uma lista de `num_frames` imagens PIL por prompt).
Exemplos:
```python
>>> import torch
>>> from diffusers import Cosmos2_5_PredictBasePipeline
>>> from diffusers.utils import export_to_video, load_image, load_video
>>> model_id = "nvidia/Cosmos-Predict2.5-2B"
>>> pipe = Cosmos2_5_PredictBasePipeline.from_pretrained(
... model_id, revision="diffusers/base/post-trained", torch_dtype=torch.bfloat16
... )
>>> pipe = pipe.to("cuda")
>>> # Common negative prompt reused across modes.
>>> negative_prompt = (
... "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, "
... "over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, "
... "underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky "
... "movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, "
... "fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. "
... "Overall, the video is of poor quality."
... )
>>> # Text2World: generate a 93-frame world video from text only.
>>> prompt = (
... "As the red light shifts to green, the red bus at the intersection begins to move forward, its headlights "
... "cutting through the falling snow. The snowy tire tracks deepen as the vehicle inches ahead, casting fresh "
... "lines onto the slushy road. Around it, streetlights glow warmer, illuminating the drifting flakes and wet "
... "reflections on the asphalt. Other cars behind start to edge forward, their beams joining the scene. "
... "The stillness of the urban street transitions into motion as the quiet snowfall is punctuated by the slow "
... "advance of traffic through the frosty city corridor."
... )
>>> video = pipe(
... image=None,
... video=None,
... prompt=prompt,
... negative_prompt=negative_prompt,
... num_frames=93,
... generator=torch.Generator().manual_seed(1),
... ).frames[0]
>>> export_to_video(video, "text2world.mp4", fps=16)
>>> # Image2World: condition on a single image and generate a 93-frame world video.
>>> prompt = (
... "A high-definition video captures the precision of robotic welding in an industrial setting. "
... "The first frame showcases a robotic arm, equipped with a welding torch, positioned over a large metal structure. "
... "The welding process is in full swing, with bright sparks and intense light illuminating the scene, creating a vivid "
... "display of blue and white hues. A significant amount of smoke billows around the welding area, partially obscuring "
... "the view but emphasizing the heat and activity. The background reveals parts of the workshop environment, including a "
... "ventilation system and various pieces of machinery, indicating a busy and functional industrial workspace. As the video "
... "progresses, the robotic arm maintains its steady position, continuing the welding process and moving to its left. "
... "The welding torch consistently emits sparks and light, and the smoke continues to rise, diffusing slightly as it moves upward. "
... "The metal surface beneath the torch shows ongoing signs of heating and melting. The scene retains its industrial ambiance, with "
... "the welding sparks and smoke dominating the visual field, underscoring the ongoing nature of the welding operation."
... )
>>> image = load_image(
... "https://media.githubusercontent.com/media/nvidia-cosmos/cosmos-predict2.5/refs/heads/main/assets/base/robot_welding.jpg"
... )
>>> video = pipe(
... image=image,
... video=None,
... prompt=prompt,
... negative_prompt=negative_prompt,
... num_frames=93,
... generator=torch.Generator().manual_seed(1),
... ).frames[0]
>>> export_to_video(video, "image2world.mp4", fps=16)
>>> # Video2World: condition on an input clip and predict a 93-frame world video.
>>> prompt = (
... "The video opens with an aerial view of a large-scale sand mining construction operation, showcasing extensive piles "
... "of brown sand meticulously arranged in parallel rows. A central water channel, fed by a water pipe, flows through the "
... "middle of these sand heaps, creating ripples and movement as it cascades down. The surrounding area features dense green "
... "vegetation on the left, contrasting with the sandy terrain, while a body of water is visible in the background on the right. "
... "As the video progresses, a piece of heavy machinery, likely a bulldozer, enters the frame from the right, moving slowly along "
... "the edge of the sand piles. This machinery's presence indicates ongoing construction work in the operation. The final frame "
... "captures the same scene, with the water continuing its flow and the bulldozer still in motion, maintaining the dynamic yet "
... "steady pace of the construction activity."
... )
>>> input_video = load_video(
... "https://github.com/nvidia-cosmos/cosmos-predict2.5/raw/refs/heads/main/assets/base/sand_mining.mp4"
... )
>>> video = pipe(
... image=None,
... video=input_video,
... prompt=prompt,
... negative_prompt=negative_prompt,
... num_frames=93,
... generator=torch.Generator().manual_seed(1),
... ).frames[0]
>>> export_to_video(video, "video2world.mp4", fps=16)
>>> # To produce an image instead of a world (video) clip, set num_frames=1 and
>>> # save the first frame: pipe(..., num_frames=1).frames[0][0].
```
#### encode_prompt[[diffusers.Cosmos2_5_PredictBasePipeline.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, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_predict.py#L324)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## CosmosTextToWorldPipeline[[diffusers.CosmosTextToWorldPipeline]]
#### diffusers.CosmosTextToWorldPipeline[[diffusers.CosmosTextToWorldPipeline]]
```python
diffusers.CosmosTextToWorldPipeline(text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLCosmos, scheduler: EDMEulerScheduler, safety_checker: CosmosSafetyChecker = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_text2world.py#L140)
**Parâmetros:**
text_encoder (`T5EncoderModel`) : Codificador de texto congelado. O Cosmos usa [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel); especificamente a variante [t5-11b](https://huggingface.co/google-t5/t5-11b).
tokenizer (`T5TokenizerFast`) : Tokenizer da classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLCosmos](/docs/diffusers/main/pt/api/models/autoencoderkl_cosmos#diffusers.AutoencoderKLCosmos)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
Pipeline para geração de texto para mundo usando [Cosmos Predict1](https://github.com/nvidia-cosmos/cosmos-predict1).
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.CosmosTextToWorldPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 704, width: int = 1280, num_frames: int = 121, num_inference_steps: int = 36, guidance_scale: float = 7.0, fps: int = 30, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_text2world.py#L401)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `720`) : A altura em pixels da imagem gerada.
width (`int`, padrão `1280`) : A largura em pixels da imagem gerada.
num_frames (`int`, padrão `121`) : O número de quadros no vídeo gerado.
num_inference_steps (`int`, padrão `36`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `7.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
fps (`int`, padrão `30`) : Os quadros por segundo do vídeo gerado.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosPipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
**Retorna:** `~CosmosPipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
```python
>>> import torch
>>> from diffusers import CosmosTextToWorldPipeline
>>> from diffusers.utils import export_to_video
>>> model_id = "nvidia/Cosmos-1.0-Diffusion-7B-Text2World"
>>> pipe = CosmosTextToWorldPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A sleek, humanoid robot stands in a vast warehouse filled with neatly stacked cardboard boxes on industrial shelves. The robot's metallic body gleams under the bright, even lighting, highlighting its futuristic design and intricate joints. A glowing blue light emanates from its chest, adding a touch of advanced technology. The background is dominated by rows of boxes, suggesting a highly organized storage system. The floor is lined with wooden pallets, enhancing the industrial setting. The camera remains static, capturing the robot's poised stance amidst the orderly environment, with a shallow depth of field that keeps the focus on the robot while subtly blurring the background for a cinematic effect."
>>> output = pipe(prompt=prompt).frames[0]
>>> export_to_video(output, "output.mp4", fps=30)
```
#### encode_prompt[[diffusers.CosmosTextToWorldPipeline.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, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_text2world.py#L239)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## CosmosVideoToWorldPipeline[[diffusers.CosmosVideoToWorldPipeline]]
#### diffusers.CosmosVideoToWorldPipeline[[diffusers.CosmosVideoToWorldPipeline]]
```python
diffusers.CosmosVideoToWorldPipeline(text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLCosmos, scheduler: EDMEulerScheduler, safety_checker: CosmosSafetyChecker = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_video2world.py#L181)
**Parâmetros:**
text_encoder (`T5EncoderModel`) : Codificador de texto congelado. O Cosmos usa [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel); especificamente a variante [t5-11b](https://huggingface.co/google-t5/t5-11b).
tokenizer (`T5TokenizerFast`) : Tokenizer da classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLCosmos](/docs/diffusers/main/pt/api/models/autoencoderkl_cosmos#diffusers.AutoencoderKLCosmos)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
Pipeline para geração de imagem-para-mundo e vídeo-para-mundo usando [Cosmos Predict-1](https://github.com/nvidia-cosmos/cosmos-predict1).
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.CosmosVideoToWorldPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 704, width: int = 1280, num_frames: int = 121, num_inference_steps: int = 36, guidance_scale: float = 7.0, input_frames_guidance: bool = False, augment_sigma: float = 0.001, fps: int = 30, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_video2world.py#L511)
**Parâmetros:**
image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, *opcional*) : A imagem a ser usada como entrada de condicionamento para a geração de vídeo.
video (`list[PIL.Image.Image]`, `np.ndarray`, `torch.Tensor`, *opcional*) : O vídeo a ser usado como entrada de condicionamento para a geração de vídeo.
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `720`) : A altura em pixels da imagem gerada.
width (`int`, padrão `1280`) : A largura em pixels da imagem gerada.
num_frames (`int`, padrão `121`) : O número de quadros no vídeo gerado.
num_inference_steps (`int`, padrão `36`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `7.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
input_frames_guidance (`bool`, *opcional*, padrão `False`) : Se deve aplicar orientação nos quadros de entrada condicional.
augment_sigma (`float`, *opcional*, padrão 0.001) : Valor de sigma usado para aumentar os latentes condicionais durante o desruido.
fps (`int`, padrão `30`) : Os quadros por segundo do vídeo gerado.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosPipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
**Retorna:** `~CosmosPipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
Condição de imagem:
```python
>>> import torch
>>> from diffusers import CosmosVideoToWorldPipeline
>>> from diffusers.utils import export_to_video, load_image
>>> model_id = "nvidia/Cosmos-1.0-Diffusion-7B-Video2World"
>>> pipe = CosmosVideoToWorldPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "The video depicts a long, straight highway stretching into the distance, flanked by metal guardrails. The road is divided into multiple lanes, with a few vehicles visible in the far distance. The surrounding landscape features dry, grassy fields on one side and rolling hills on the other. The sky is mostly clear with a few scattered clouds, suggesting a bright, sunny day."
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input.jpg"
... )
>>> video = pipe(image=image, prompt=prompt).frames[0]
>>> export_to_video(video, "output.mp4", fps=30)
```
Condição de vídeo:
```python
>>> import torch
>>> from diffusers import CosmosVideoToWorldPipeline
>>> from diffusers.utils import export_to_video, load_video
>>> model_id = "nvidia/Cosmos-1.0-Diffusion-7B-Video2World"
>>> pipe = CosmosVideoToWorldPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe.transformer = torch.compile(pipe.transformer)
>>> pipe.to("cuda")
>>> prompt = "The video depicts a winding mountain road covered in snow, with a single vehicle traveling along it. The road is flanked by steep, rocky cliffs and sparse vegetation. The landscape is characterized by rugged terrain and a river visible in the distance. The scene captures the solitude and beauty of a winter drive through a mountainous region."
>>> video = load_video(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
... )[:21] # This example uses only the first 21 frames
>>> video = pipe(video=video, prompt=prompt).frames[0]
>>> export_to_video(video, "output.mp4", fps=30)
```
#### encode_prompt[[diffusers.CosmosVideoToWorldPipeline.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, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos_video2world.py#L283)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## Cosmos2TextToImagePipeline[[diffusers.Cosmos2TextToImagePipeline]]
#### diffusers.Cosmos2TextToImagePipeline[[diffusers.Cosmos2TextToImagePipeline]]
```python
diffusers.Cosmos2TextToImagePipeline(text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler, safety_checker: CosmosSafetyChecker = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_text2image.py#L143)
**Parâmetros:**
text_encoder (`T5EncoderModel`) : Codificador de texto congelado. O Cosmos usa [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel); especificamente a variante [t5-11b](https://huggingface.co/google-t5/t5-11b).
tokenizer (`T5TokenizerFast`) : Tokenizer da classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
Pipeline para geração de texto para imagem usando [Cosmos Predict2](https://github.com/nvidia-cosmos/cosmos-predict2).
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Cosmos2TextToImagePipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 768, width: int = 1360, num_inference_steps: int = 35, guidance_scale: float = 7.0, num_images_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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_text2image.py#L417)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `768`) : A altura em pixels da imagem gerada.
width (`int`, padrão `1360`) : A largura em pixels da imagem gerada.
num_inference_steps (`int`, padrão `35`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `7.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosImagePipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
**Retorna:** `~CosmosImagePipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosImagePipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
```python
>>> import torch
>>> from diffusers import Cosmos2TextToImagePipeline
>>> # Available checkpoints: nvidia/Cosmos-Predict2-2B-Text2Image, nvidia/Cosmos-Predict2-14B-Text2Image
>>> model_id = "nvidia/Cosmos-Predict2-2B-Text2Image"
>>> pipe = Cosmos2TextToImagePipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A close-up shot captures a vibrant yellow scrubber vigorously working on a grimy plate, its bristles moving in circular motions to lift stubborn grease and food residue. The dish, once covered in remnants of a hearty meal, gradually reveals its original glossy surface. Suds form and bubble around the scrubber, creating a satisfying visual of cleanliness in progress. The sound of scrubbing fills the air, accompanied by the gentle clinking of the dish against the sink. As the scrubber continues its task, the dish transforms, gleaming under the bright kitchen lights, symbolizing the triumph of cleanliness over mess."
>>> negative_prompt = "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality."
>>> output = pipe(
... prompt=prompt, negative_prompt=negative_prompt, generator=torch.Generator().manual_seed(1)
... ).images[0]
>>> output.save("output.png")
```
#### encode_prompt[[diffusers.Cosmos2TextToImagePipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_text2image.py#L254)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_images_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## Cosmos2VideoToWorldPipeline[[diffusers.Cosmos2VideoToWorldPipeline]]
#### diffusers.Cosmos2VideoToWorldPipeline[[diffusers.Cosmos2VideoToWorldPipeline]]
```python
diffusers.Cosmos2VideoToWorldPipeline(text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler, safety_checker: CosmosSafetyChecker = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_video2world.py#L162)
**Parâmetros:**
text_encoder (`T5EncoderModel`) : Codificador de texto congelado. O Cosmos usa [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel); especificamente a variante [t5-11b](https://huggingface.co/google-t5/t5-11b).
tokenizer (`T5TokenizerFast`) : Tokenizer da classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
Pipeline para geração de mundo a partir de vídeo usando [Cosmos Predict2](https://github.com/nvidia-cosmos/cosmos-predict2).
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Cosmos2VideoToWorldPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 704, width: int = 1280, num_frames: int = 93, num_inference_steps: int = 35, guidance_scale: float = 7.0, fps: int = 16, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, sigma_conditioning: float = 0.0001)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_video2world.py#L485)
**Parâmetros:**
image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, *opcional*) : A imagem a ser usada como entrada de condicionamento para a geração de vídeo.
video (`list[PIL.Image.Image]`, `np.ndarray`, `torch.Tensor`, *opcional*) : O vídeo a ser usado como entrada de condicionamento para a geração de vídeo.
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `704`) : A altura em pixels da imagem gerada.
width (`int`, padrão `1280`) : A largura em pixels da imagem gerada.
num_frames (`int`, padrão `93`) : O número de quadros no vídeo gerado.
num_inference_steps (`int`, padrão `35`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.
guidance_scale (`float`, padrão `7.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`.
fps (`int`, padrão `16`) : Os quadros por segundo do vídeo gerado.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `CosmosPipelineOutput` em vez de uma tupla simples.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.
max_sequence_length (`int`, padrão `512`) : O número máximo de tokens no prompt. Se o prompt exceder esse comprimento, ele será truncado. Se o prompt for mais curto que esse comprimento, ele será preenchido.
sigma_conditioning (`float`, padrão `0.0001`) : O valor de sigma usado para escalar os latentes de condicionamento. Idealmente, não deve ser alterado ou deve ser definido como um valor pequeno próximo de zero.
**Retorna:** `~CosmosPipelineOutput` ou `tuple`
Se `return_dict` for `True`, `CosmosPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).
A função de chamada do pipeline para geração.
Exemplos:
```python
>>> import torch
>>> from diffusers import Cosmos2VideoToWorldPipeline
>>> from diffusers.utils import export_to_video, load_image
>>> # Available checkpoints: nvidia/Cosmos-Predict2-2B-Video2World, nvidia/Cosmos-Predict2-14B-Video2World
>>> model_id = "nvidia/Cosmos-Predict2-2B-Video2World"
>>> pipe = Cosmos2VideoToWorldPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A close-up shot captures a vibrant yellow scrubber vigorously working on a grimy plate, its bristles moving in circular motions to lift stubborn grease and food residue. The dish, once covered in remnants of a hearty meal, gradually reveals its original glossy surface. Suds form and bubble around the scrubber, creating a satisfying visual of cleanliness in progress. The sound of scrubbing fills the air, accompanied by the gentle clinking of the dish against the sink. As the scrubber continues its task, the dish transforms, gleaming under the bright kitchen lights, symbolizing the triumph of cleanliness over mess."
>>> negative_prompt = "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality."
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yellow-scrubber.png"
... )
>>> video = pipe(
... image=image, prompt=prompt, negative_prompt=negative_prompt, generator=torch.Generator().manual_seed(1)
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=16)
```
#### encode_prompt[[diffusers.Cosmos2VideoToWorldPipeline.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, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_video2world.py#L273)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance.
num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
device : (`torch.device`, *opcional*): dispositivo torch
dtype : (`torch.dtype`, *opcional*): dtype do torch
Codifica o prompt em estados ocultos do codificador de texto.
## CosmosPipelineOutput[[diffusers.pipelines.cosmos.pipeline_output.CosmosPipelineOutput]]
#### diffusers.pipelines.cosmos.pipeline_output.CosmosPipelineOutput[[diffusers.pipelines.cosmos.pipeline_output.CosmosPipelineOutput]]
```python
diffusers.pipelines.cosmos.pipeline_output.CosmosPipelineOutput(frames: Tensor)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_output.py#L14)
**Parâmetros:**
frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : lista de saídas de vídeo - Pode ser uma lista aninhada de comprimento `batch_size,` em que cada sublista contém sequências de imagens PIL desruidas de comprimento `num_frames.` Também pode ser um array NumPy ou um tensor Torch de forma `(batch_size, num_frames, channels, height, width)`.
Classe de saída para os pipelines any-to-world/vídeo do Cosmos.
## CosmosImagePipelineOutput[[diffusers.pipelines.cosmos.pipeline_output.CosmosImagePipelineOutput]]
#### diffusers.pipelines.cosmos.pipeline_output.CosmosImagePipelineOutput[[diffusers.pipelines.cosmos.pipeline_output.CosmosImagePipelineOutput]]
```python
diffusers.pipelines.cosmos.pipeline_output.CosmosImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_output.py#L29)
**Parâmetros:**
images (`list[PIL.Image.Image]` ou `np.ndarray`) : lista de imagens PIL desruidas de comprimento `batch_size` ou array numpy de forma `(batch_size, height, width, num_channels)`. As imagens PIL ou o array numpy apresentam as imagens desruidas do pipeline de difusão.
Classe de saída para pipelines any-to-image do Cosmos.
#
# Licenciado sob a Apache License, Versão 2.0 (a "Licença");
# você não pode usar este arquivo, exceto em conformidade com a Licença.
# Você pode obter uma cópia da Licença em
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que exigido pela lei aplicável ou acordado por escrito, o software
# distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",
# SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.
# Consulte a Licença para o idioma específico que rege as permissões e
# limitações sob a Licença. -->
# Cosmos
[Plataforma do Modelo de Fundação Cosmos para IA Física](https://huggingface.co/papers/2501.03575) da NVIDIA.
*A IA física precisa primeiro ser treinada digitalmente. Ela requer um gêmeo digital de si mesma, o modelo de política, e um gêmeo digital do mundo, o modelo de mundo. Neste artigo, apresentamos a Plataforma de Modelos Fundamentais de Mundo Cosmos para ajudar desenvolvedores a construir modelos de mundo personalizados para seus setups de IA física. Posicionamos um modelo fundamental de mundo como um modelo de mundo de uso geral que pode ser ajustado finamente para se tornar modelos de mundo personalizados para aplicações de nível inferior. Nossa plataforma abrange um pipeline de curadoria de vídeo, modelos fundamentais de mundo pré-treinados, exemplos de pós-treinamento de modelos fundamentais de mundo pré-treinados e tokenizadores de vídeo. Para ajudar construtores de IA física a resolver os problemas mais críticos da nossa sociedade, tornamos nossa plataforma open-source e nossos modelos open-weight com licenças permissivas disponíveis via https://github.com/NVIDIA/Cosmos.*
> [!TIP]
> Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines.
## Uso básico
```python
import torch
from diffusers import Cosmos2_5_PredictBasePipeline
from diffusers.utils import export_to_video
model_id = "nvidia/Cosmos-Predict2.5-2B"
pipe = Cosmos2_5_PredictBasePipeline.from_pretrained(
model_id, revision="diffusers/base/post-trained", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
prompt = "As the red light shifts to green, the red bus at the intersection begins to move forward, its headlights cutting through the falling snow. The snowy tire tracks deepen as the vehicle inches ahead, casting fresh lines onto the slushy road. Around it, streetlights glow warmer, illuminating the drifting flakes and wet reflections on the asphalt. Other cars behind start to edge forward, their beams joining the scene. The stillness of the urban street transitions into motion as the quiet snowfall is punctuated by the slow advance of traffic through the frosty city corridor."
negative_prompt = "The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality."
output = pipe(
image=None,
video=None,
prompt=prompt,
negative_prompt=negative_prompt,
num_frames=93,
generator=torch.Generator().manual_seed(1),
).frames[0]
export_to_video(output, "text2world.mp4", fps=16)
```
## Cosmos2_5_TransferPipeline[[diffusers.Cosmos2_5_TransferPipeline]]
#### diffusers.Cosmos2_5_TransferPipeline[[diffusers.Cosmos2_5_TransferPipeline]]
```python
diffusers.Cosmos2_5_TransferPipeline(text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: AutoTokenizer, transformer: CosmosTransformer3DModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler, controlnet: CosmosControlNetModel, safety_checker: typing.Optional[diffusers.pipelines.cosmos.pipeline_cosmos2_5_transfer.CosmosSafetyChecker] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_transfer.py#L152)
**Parâmetros:**
text_encoder (`Qwen2_5_VLForConditionalGeneration`) : Codificador de texto congelado. O Cosmos Transfer2.5 usa o codificador [Qwen2.5 VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`AutoTokenizer`) : Tokenizer associado ao codificador do Qwen2.5 VL.
transformer ([CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel)) : Transformer condicional para desruidar os latentes de imagem codificados.
scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae ([AutoencoderKLWan](/docs/diffusers/main/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.
controlnet (`CosmosControlNetModel`) : ControlNet usado para condicionar a geração em entradas de controle.
Pipeline para Cosmos Transfer2.5, com suporte a inferência auto-regressiva.
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Cosmos2_5_TransferPipeline.__call__]]
```python
__call__(controls: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], typing.List[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]]], controls_conditioning_scale: typing.Union[float, typing.List[float]] = 1.0, prompt: typing.Union[str, typing.List[str], NoneType] = None, negative_prompt: typing.Union[str, typing.List[str]] = 'The video captures a series of frames showing ugly scenes, static with no motion, motion blur, over-saturation, shaky footage, low resolution, grainy texture, pixelated images, poorly lit areas, underexposed and overexposed scenes, poor color balance, washed out colors, choppy sequences, jerky movements, low frame rate, artifacting, color banding, unnatural transitions, outdated special effects, fake elements, unconvincing visuals, poorly edited content, jump cuts, visual noise, and flickering. Overall, the video is of poor quality.', height: int = 704, width: typing.Optional[int] = None, num_frames: typing.Optional[int] = None, num_frames_per_chunk: int = 93, num_inference_steps: int = 36, guidance_scale: float = 3.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, typing.List[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: typing.Optional[str] = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int, typing.Dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 512, conditional_frame_timestep: float = 0.1, num_ar_conditional_frames: typing.Optional[int] = 1, num_ar_latent_conditional_frames: typing.Optional[int] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/cosmos/pipeline_cosmos2_5_transfer.py#L569)
**Parâmetros:**
controls (`PipelineImageInput`, `List[PipelineImageInput]`) : Imagem ou vídeo de controle usado pelo ControlNet.
controls_conditioning_scale (`float` ou `List[float]`, *opcional*, padrão `1.0`) : O(s) fator(es) de escala para as saídas do ControlNet. Um único float é transmitido para todos os blocos de controle.
prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts para orientar a geração. Obrigatório, a menos que `prompt_embeds` seja fornecido.
negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).
height (`int`, padrão `704`) : A altura em pixels da imagem gerada.
width (`int`, *opcional*) : A largura em pixels da imagem gerada. Se não for fornecida, será determinada com base na proporção de aspecto da entrada e na altura fornecida.
num_frames (`int`, *opcional*) : Número de quadros de saída. O padrão é `None` para produzir o mesmo número de quadros que a entrada `controls`.
Xet Storage Details
- Size:
- 85.5 kB
- Xet hash:
- 667099888117fd2a1ce61422dc230399c5829933c4e9998850eae8106581bec1
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.