Hugging Face's logo

Buckets:
hf-doc-build
/
doc

Files
xet
hf-doc-build/doc / diffusers /main /id /api /pipelines /chronoedit.md
mishig's picture
mishig
preview code
|
download
raw
25.9 kB
#
# Berlisensi di bawah Apache License, Versi 2.0 ("Lisensi");
# Anda mungkin tidak dapat menggunakan file ini kecuali sesuai dengan Lisensi.
# Anda dapat memperoleh salinan Lisensi di
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Kecuali diwajibkan oleh hukum yang berlaku atau disepakati secara tertulis, perangkat lunak
# distribusikan di bawah Lisensi berdasarkan basis "SEBAGAIMANA ADANYA",
# TANPA JAMINAN ATAU SYARAT DALAM BENTUK APAPUN, baik yang dinyatakan maupun yang tersirat.
# Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan
# batasan di bawah Lisensi. -->
# ChronoEdit
[ChronoEdit: Towards Temporal Reasoning for Image Editing and World Simulation](https://huggingface.co/papers/2510.04290) dari NVIDIA dan University of Toronto, oleh Jay Zhangjie Wu, Xuanchi Ren, Tianchang Shen, Tianshi Cao, Kai He, Yifan Lu, Ruiyuan Gao, Enze Xie, Shiyi Lan, Jose M. Alvarez, Jun Gao, Sanja Fidler, Zian Wang, Huan Ling.
> **TL;DR:** ChronoEdit membingkai ulang pengeditan gambar sebagai tugas generasi video, menggunakan gambar input dan gambar yang telah diedit sebagai bingkai awal/akhir untuk memanfaatkan model video pralatih dengan konsistensi temporal. Tahap penalaran temporal memperkenalkan token penalaran untuk memastikan edit yang secara fisika masuk akal dan memvisualisasikan lintasan pengeditan.
*Perkembangan terbaru dalam model generatif besar telah sangat meningkatkan kemampuan pengeditan gambar dan pembuatan gambar dalam konteks, namun masih terdapat kesenjangan kritis dalam memastikan konsistensi fisik, di mana objek yang diedit harus tetap koheren. Kemampuan ini sangat penting untuk tugas-tugas yang berkaitan dengan simulasi dunia. Dalam makalah ini, kami memperkenalkan ChronoEdit, sebuah kerangka kerja yang membingkai ulang pengeditan gambar sebagai masalah pembuatan video. Pertama, ChronoEdit memperlakukan gambar input dan gambar yang diedit sebagai bingkai pertama dan terakhir dari sebuah video, sehingga memungkinkan pemanfaatan model generatif video pralatih besar yang menangkap tidak hanya penampilan objek tetapi juga fisika implisit dari gerakan dan interaksi melalui konsistensi temporal yang dipelajari. Kedua, ChronoEdit memperkenalkan tahap penalaran temporal yang secara eksplisit melakukan pengeditan pada saat inferensi. Dalam pengaturan ini, bingkai target didenorkan secara bersama-sama dengan token penalaran untuk membayangkan lintasan pengeditan yang masuk akal, yang membatasi ruang solusi pada transformasi yang layak secara fisik. Token penalaran kemudian dibuang setelah beberapa langkah untuk menghindari biaya komputasi tinggi dari merender video penuh. Untuk memvalidasi ChronoEdit, kami memperkenalkan PBench-Edit, sebuah benchmark baru berupa pasangan gambar-prompt untuk konteks yang memerlukan konsistensi fisik, dan menunjukkan bahwa ChronoEdit melampaui baseline state-of-the-art dalam hal kesetiaan visual dan kelayakan fisik. Halaman proyek untuk kode dan model: [this https URL](https://research.nvidia.com/labs/toronto-ai/chronoedit).*
Pipeline ChronoEdit dikembangkan oleh Tim ChronoEdit. Kode aslinya tersedia di [GitHub](https://github.com/nv-tlabs/ChronoEdit), dan model pretrained dapat ditemukan di koleksi [nvidia/ChronoEdit](https://huggingface.co/collections/nvidia/chronoedit) di Hugging Face.
Model/LoRA yang Tersedia:
- [nvidia/ChronoEdit-14B-Diffusers](https://huggingface.co/nvidia/ChronoEdit-14B-Diffusers)
- [nvidia/ChronoEdit-14B-Diffusers-Upscaler-Lora](https://huggingface.co/nvidia/ChronoEdit-14B-Diffusers-Upscaler-Lora)
- [nvidia/ChronoEdit-14B-Diffusers-Paint-Brush-Lora](https://huggingface.co/nvidia/ChronoEdit-14B-Diffusers-Paint-Brush-Lora)
### Pengeditan Gambar
```py
import torch
import numpy as np
from diffusers import AutoencoderKLWan, ChronoEditTransformer3DModel, ChronoEditPipeline
from diffusers.utils import export_to_video, load_image
from transformers import CLIPVisionModel
from PIL import Image
model_id = "nvidia/ChronoEdit-14B-Diffusers"
image_encoder = CLIPVisionModel.from_pretrained(model_id, subfolder="image_encoder", dtype=torch.float32)
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
transformer = ChronoEditTransformer3DModel.from_pretrained(model_id, subfolder="transformer", dtype=torch.bfloat16)
pipe = ChronoEditPipeline.from_pretrained(model_id, image_encoder=image_encoder, transformer=transformer, vae=vae, dtype=torch.bfloat16)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = load_image(
"https://huggingface.co/spaces/nvidia/ChronoEdit/resolve/main/examples/3.png"
)
max_area = 720 * 1280
aspect_ratio = image.height / image.width
mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
print("width", width, "height", height)
image = image.resize((width, height))
prompt = (
"The user wants to transform the image by adding a small, cute mouse sitting inside the floral teacup, enjoying a spa bath. The mouse should appear relaxed and cheerful, with a tiny white bath towel draped over its head like a turban. It should be positioned comfortably in the cup’s liquid, with gentle steam rising around it to blend with the cozy atmosphere. "
"The mouse’s pose should be natural—perhaps sitting upright with paws resting lightly on the rim or submerged in the tea. The teacup’s floral design, gold trim, and warm lighting must remain unchanged to preserve the original aesthetic. The steam should softly swirl around the mouse, enhancing the spa-like, whimsical mood."
)
output = pipe(
image=image,
prompt=prompt,
height=height,
width=width,
num_frames=5,
num_inference_steps=50,
guidance_scale=5.0,
enable_temporal_reasoning=False,
num_temporal_reasoning_steps=0,
).frames[0]
Image.fromarray((output[-1] * 255).clip(0, 255).astype("uint8")).save("output.png")
```
Secara opsional, aktifkan **penalaran temporal** untuk konsistensi fisik yang lebih baik:
```py
output = pipe(
image=image,
prompt=prompt,
height=height,
width=width,
num_frames=29,
num_inference_steps=50,
guidance_scale=5.0,
enable_temporal_reasoning=True,
num_temporal_reasoning_steps=50,
).frames[0]
export_to_video(output, "output.mp4", fps=16)
Image.fromarray((output[-1] * 255).clip(0, 255).astype("uint8")).save("output.png")
```
### Inferensi dengan Lora Distilasi 8-Langkah
```py
import torch
import numpy as np
from diffusers import AutoencoderKLWan, ChronoEditTransformer3DModel, ChronoEditPipeline
from diffusers.schedulers import UniPCMultistepScheduler
from diffusers.utils import export_to_video, load_image
from transformers import CLIPVisionModel
from PIL import Image
model_id = "nvidia/ChronoEdit-14B-Diffusers"
image_encoder = CLIPVisionModel.from_pretrained(model_id, subfolder="image_encoder", dtype=torch.float32)
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
transformer = ChronoEditTransformer3DModel.from_pretrained(model_id, subfolder="transformer", dtype=torch.bfloat16)
pipe = ChronoEditPipeline.from_pretrained(model_id, image_encoder=image_encoder, transformer=transformer, vae=vae, dtype=torch.bfloat16)
pipe.load_lora_weights("nvidia/ChronoEdit-14B-Diffusers", weight_name="lora/chronoedit_distill_lora.safetensors", adapter_name="distill")
pipe.fuse_lora(adapter_names=["distill"], lora_scale=1.0)
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=2.0)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = load_image(
"https://huggingface.co/spaces/nvidia/ChronoEdit/resolve/main/examples/3.png"
)
max_area = 720 * 1280
aspect_ratio = image.height / image.width
mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
print("width", width, "height", height)
image = image.resize((width, height))
prompt = (
"The user wants to transform the image by adding a small, cute mouse sitting inside the floral teacup, enjoying a spa bath. The mouse should appear relaxed and cheerful, with a tiny white bath towel draped over its head like a turban. It should be positioned comfortably in the cup’s liquid, with gentle steam rising around it to blend with the cozy atmosphere. "
"The mouse’s pose should be natural—perhaps sitting upright with paws resting lightly on the rim or submerged in the tea. The teacup’s floral design, gold trim, and warm lighting must remain unchanged to preserve the original aesthetic. The steam should softly swirl around the mouse, enhancing the spa-like, whimsical mood."
)
output = pipe(
image=image,
prompt=prompt,
height=height,
width=width,
num_frames=5,
num_inference_steps=8,
guidance_scale=1.0,
enable_temporal_reasoning=False,
num_temporal_reasoning_steps=0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)
Image.fromarray((output[-1] * 255).clip(0, 255).astype("uint8")).save("output.png")
```
### Inferensi dengan Beberapa LoRA
```py
import torch
import numpy as np
from diffusers import AutoencoderKLWan, ChronoEditTransformer3DModel, ChronoEditPipeline
from diffusers.schedulers import UniPCMultistepScheduler
from diffusers.utils import export_to_video, load_image
from transformers import CLIPVisionModel
from PIL import Image
model_id = "nvidia/ChronoEdit-14B-Diffusers"
image_encoder = CLIPVisionModel.from_pretrained(model_id, subfolder="image_encoder", dtype=torch.float32)
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
transformer = ChronoEditTransformer3DModel.from_pretrained(model_id, subfolder="transformer", dtype=torch.bfloat16)
pipe = ChronoEditPipeline.from_pretrained(model_id, image_encoder=image_encoder, transformer=transformer, vae=vae, dtype=torch.bfloat16)
pipe.load_lora_weights("nvidia/ChronoEdit-14B-Diffusers-Paint-Brush-Lora", weight_name="paintbrush_lora_diffusers.safetensors", adapter_name="paintbrush")
pipe.load_lora_weights("nvidia/ChronoEdit-14B-Diffusers", weight_name="lora/chronoedit_distill_lora.safetensors", adapter_name="distill")
pipe.fuse_lora(adapter_names=["paintbrush", "distill"], lora_scale=1.0)
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=2.0)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = load_image(
"https://raw.githubusercontent.com/nv-tlabs/ChronoEdit/refs/heads/main/assets/images/input_paintbrush.png"
)
max_area = 720 * 1280
aspect_ratio = image.height / image.width
mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
print("width", width, "height", height)
image = image.resize((width, height))
prompt = (
"Turn the pencil sketch in the image into an actual object that is consistent with the image’s content. The user wants to change the sketch to a crown and a hat."
)
output = pipe(
image=image,
prompt=prompt,
height=height,
width=width,
num_frames=5,
num_inference_steps=8,
guidance_scale=1.0,
enable_temporal_reasoning=False,
num_temporal_reasoning_steps=0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)
Image.fromarray((output[-1] * 255).clip(0, 255).astype("uint8")).save("output_1.png")
```
## ChronoEditPipeline[[diffusers.ChronoEditPipeline]]
#### diffusers.ChronoEditPipeline[[diffusers.ChronoEditPipeline]]
```python
diffusers.ChronoEditPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, image_encoder: CLIPVisionModel, image_processor: CLIPImageProcessorPil, transformer: ChronoEditTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/chronoedit/pipeline_chronoedit.py#L128)
**Parameter:**
tokenizer (`T5Tokenizer`) : Tokenizer dari [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), khususnya varian [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).
text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).
image_encoder (`CLIPVisionModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModel), khususnya varian [clip-vit-huge-patch14](https://github.com/mlfoundations/open_clip/blob/main/docs/PRETRAINED.md#vit-h14-xlm-roberta-large).
transformer ([WanTransformer3DModel](/docs/diffusers/main/id/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer bersyarat untuk menghilangkan noise pada latens input.
scheduler ([UniPCMultistepScheduler](/docs/diffusers/main/id/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKLWan](/docs/diffusers/main/id/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.
Pipeline untuk generasi gambar-ke-video menggunakan Wan.
Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).
#### __call__[[diffusers.ChronoEditPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 480, width: int = 832, num_frames: int = 81, num_inference_steps: int = 50, guidance_scale: float = 5.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, image_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, 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, enable_temporal_reasoning: bool = False, num_temporal_reasoning_steps: int = 0)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/chronoedit/pipeline_chronoedit.py#L470)
**Parameter:**
image (`PipelineImageInput`) : Gambar input untuk mengondisikan generasi. Harus berupa gambar, daftar gambar, atau `torch.Tensor`.
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`).
height (`int`, defaultnya `480`) : Tinggi video yang dihasilkan.
width (`int`, defaultnya `832`) : Lebar video yang dihasilkan.
num_frames (`int`, defaultnya `81`) : Jumlah frame dalam video yang dihasilkan.
num_inference_steps (`int`, defaultnya `50`) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
guidance_scale (`float`, defaultnya `5.0`) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.
num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Sebuah [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (pemberian bobot pada prompt). Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks (pemberian bobot pada prompt). Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `negative_prompt`.
image_embeds (`torch.Tensor`, *opsional*) : Embedding gambar yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input gambar (penimbangan). Jika tidak disediakan, embedding gambar akan dihasilkan dari argumen input `image`.
output_type (`str`, *opsional*, defaultnya `"np"`) : Format output dari gambar yang dihasilkan. Pilih antara `PIL.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `ChronoEditPipelineOutput` alih-alih tuple biasa.
attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi atau subkelas dari `PipelineCallback` atau `MultiPipelineCallbacks` yang dipanggil di akhir setiap langkah denoising selama inferensi, dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`List`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int`, defaultnya `512`) : Panjang maksimum urutan dari text encoder. Jika prompt lebih panjang dari ini, prompt akan dipotong. Jika prompt lebih pendek, prompt akan di-pad hingga panjang ini.
enable_temporal_reasoning (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengaktifkan penalaran temporal.
num_temporal_reasoning_steps (`int`, *opsional*, defaultnya `0`) : Jumlah langkah untuk mengaktifkan penalaran temporal.
**Mengembalikan:** `~ChronoEditPipelineOutput` atau `tuple`
Jika `return_dict` adalah `True`, `ChronoEditPipelineOutput` dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan dan elemen kedua adalah daftar `bool` yang menunjukkan apakah gambar yang dihasilkan yang sesuai mengandung konten "not-safe-for-work" (nsfw).
Fungsi panggilan untuk pipeline pada generasi.
Contoh:
```python
>>> import torch
>>> import numpy as np
>>> from diffusers import AutoencoderKLWan, ChronoEditTransformer3DModel, ChronoEditPipeline
>>> from diffusers.utils import export_to_video, load_image
>>> from transformers import CLIPVisionModel
>>> # Available models: nvidia/ChronoEdit-14B-Diffusers
>>> model_id = "nvidia/ChronoEdit-14B-Diffusers"
>>> image_encoder = CLIPVisionModel.from_pretrained(
... model_id, subfolder="image_encoder", torch_dtype=torch.float32
... )
>>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
>>> transformer = ChronoEditTransformer3DModel.from_pretrained(
... model_id, subfolder="transformer", torch_dtype=torch.bfloat16
... )
>>> pipe = ChronoEditPipeline.from_pretrained(
... model_id, vae=vae, image_encoder=image_encoder, transformer=transformer, torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = load_image("https://huggingface.co/spaces/nvidia/ChronoEdit/resolve/main/examples/3.png")
>>> max_area = 720 * 1280
>>> aspect_ratio = image.height / image.width
>>> mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
>>> height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
>>> width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
>>> image = image.resize((width, height))
>>> prompt = (
... "The user wants to transform the image by adding a small, cute mouse sitting inside the floral teacup, enjoying a spa bath. The mouse should appear relaxed and cheerful, with a tiny white bath towel draped over its head like a turban. It should be positioned comfortably in the cup’s liquid, with gentle steam rising around it to blend with the cozy atmosphere. "
... "The mouse’s pose should be natural—perhaps sitting upright with paws resting lightly on the rim or submerged in the tea. The teacup’s floral design, gold trim, and warm lighting must remain unchanged to preserve the original aesthetic. The steam should softly swirl around the mouse, enhancing the spa-like, whimsical mood."
... )
>>> output = pipe(
... image=image,
... prompt=prompt,
... height=height,
... width=width,
... num_frames=5,
... guidance_scale=5.0,
... enable_temporal_reasoning=False,
... num_temporal_reasoning_steps=0,
... ).frames[0]
>>> export_to_video(output, "output.mp4", fps=16)
```
#### encode_prompt[[diffusers.ChronoEditPipeline.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 = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/chronoedit/pipeline_chronoedit.py#L242)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`).
do_classifier_free_guidance (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan classifier free guidance atau tidak.
num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang harus dihasilkan per prompt. perangkat torch untuk menempatkan embedding yang dihasilkan
prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
device : (`torch.device`, *opsional*): perangkat torch
dtype : (`torch.dtype`, *opsional*): torch dtype
Mengkodekan prompt menjadi hidden states dari text encoder.
## ChronoEditPipelineOutput[[diffusers.pipelines.chronoedit.pipeline_output.ChronoEditPipelineOutput]]
#### diffusers.pipelines.chronoedit.pipeline_output.ChronoEditPipelineOutput[[diffusers.pipelines.chronoedit.pipeline_output.ChronoEditPipelineOutput]]
```python
diffusers.pipelines.chronoedit.pipeline_output.ChronoEditPipelineOutput(frames: Tensor)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/chronoedit/pipeline_output.py#L9)
**Parameter:**
frames (`torch.Tensor`, `np.ndarray`, atau list[list[PIL.Image.Image]]) : Daftar output video - Dapat berupa daftar bersarang dengan panjang `batch_size,` di mana setiap sub-daftar berisi urutan gambar PIL yang telah didenoise dengan panjang `num_frames.` Dapat juga berupa array NumPy atau tensor Torch dengan bentuk `(batch_size, num_frames, channels, height, width)`.
Kelas output untuk pipeline ChronoEdit.

Xet Storage Details

Size:
25.9 kB
·
Xet hash:
92c998a9b6a746bf6c2b4ccdff6d1dada3082b8d58ea8cb9ab75e49477ae952a

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.