Buckets:
| # Model Konsistensi | |
| Consistency Models diusulkan dalam [Consistency Models](https://huggingface.co/papers/2303.01469) oleh Yang Song, Prafulla Dhariwal, Mark Chen, dan Ilya Sutskever. | |
| Abstrak dari makalah tersebut adalah: | |
| *Model difusi telah mendorong kemajuan signifikan di bidang generasi gambar, audio, dan video, tetapi mereka bergantung pada proses sampling iteratif yang menyebabkan generasi lambat. Untuk mengatasi keterbatasan ini, kami mengusulkan model konsistensi, sebuah keluarga model baru yang menghasilkan sampel berkualitas tinggi dengan memetakan noise langsung ke data. Mereka mendukung generasi satu langkah yang cepat secara desain, sambil tetap memungkinkan sampling multi-langkah untuk menukar komputasi dengan kualitas sampel. Mereka juga mendukung pengeditan data zero-shot, seperti inpainting gambar, pewarnaan, dan super-resolusi, tanpa memerlukan pelatihan eksplisit pada tugas-tugas tersebut. Model konsistensi dapat dilatih baik dengan mendistilasi model difusi yang sudah terlatih, maupun sebagai model generatif mandiri sepenuhnya. Melalui eksperimen yang luas, kami menunjukkan bahwa mereka melampaui teknik distilasi yang ada untuk model difusi dalam sampling satu langkah dan beberapa langkah, mencapai FID state-of-the-art baru sebesar 3,55 pada CIFAR-10 dan 6,20 pada ImageNet 64x64 untuk generasi satu langkah. Ketika dilatih secara terpisah, model konsistensi menjadi keluarga model generatif baru yang dapat melampaui model generatif satu langkah, non-adversarial yang ada pada benchmark standar seperti CIFAR-10, ImageNet 64x64, dan LSUN 256x256.* | |
| Kodebase asli dapat ditemukan di [openai/consistency_models](https://github.com/openai/consistency_models), dan checkpoint tambahan tersedia di [openai](https://huggingface.co/openai). | |
| Pipeline ini disumbangkan oleh [dg845](https://github.com/dg845) dan [ayushtues](https://huggingface.co/ayushtues). ❤️ | |
| ## Tips | |
| Untuk percepatan tambahan, gunakan `torch.compile` untuk menghasilkan beberapa gambar dalam <1 detik: | |
| ```diff | |
| import torch | |
| from diffusers import ConsistencyModelPipeline | |
| device = "cuda" # or "mps", "xpu", "cpu" | |
| # Load the cd_bedroom256_lpips checkpoint. | |
| model_id_or_path = "openai/diffusers-cd_bedroom256_lpips" | |
| pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, dtype=torch.float16) | |
| pipe.to(device) | |
| + pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True) | |
| # Multistep sampling | |
| # Timesteps can be explicitly specified; the particular timesteps below are from the original GitHub repo: | |
| # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L83 | |
| for _ in range(10): | |
| image = pipe(timesteps=[17, 0]).images[0] | |
| image.show() | |
| ``` | |
| ## ConsistencyModelPipeline[[diffusers.ConsistencyModelPipeline]] | |
| #### diffusers.ConsistencyModelPipeline[[diffusers.ConsistencyModelPipeline]] | |
| ```python | |
| diffusers.ConsistencyModelPipeline(unet: UNet2DModel, scheduler: CMStochasticIterativeScheduler) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/consistency_models/pipeline_consistency_models.py#L67) | |
| **Parameter:** | |
| unet ([UNet2DModel](/docs/diffusers/main/id/api/models/unet2d#diffusers.UNet2DModel)) : Sebuah `UNet2DModel` untuk menghilangkan noise dari latens gambar yang telah dikodekan. | |
| scheduler ([SchedulerMixin](/docs/diffusers/main/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `unet` untuk menghilangkan noise pada latens gambar yang telah dikodekan. Saat ini hanya kompatibel dengan [CMStochasticIterativeScheduler](/docs/diffusers/main/id/api/schedulers/cm_stochastic_iterative#diffusers.CMStochasticIterativeScheduler). | |
| Pipeline untuk generasi gambar tanpa syarat atau bersyarat kelas. | |
| 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.ConsistencyModelPipeline.__call__]] | |
| ```python | |
| __call__(batch_size: int = 1, class_labels: typing.Union[torch.Tensor, list[int], int, NoneType] = None, num_inference_steps: int = 1, timesteps: list[int] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/consistency_models/pipeline_consistency_models.py#L171) | |
| **Parameter:** | |
| batch_size (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan. | |
| class_labels (`torch.Tensor` atau `list[int]` atau `int`, *opsional*) : Label kelas opsional untuk model konsistensi bersyarat kelas. Tidak digunakan jika model tidak bersyarat kelas. | |
| num_inference_steps (`int`, *opsional*, default 1) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. | |
| timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, timesteps `num_inference_steps` yang berjarak sama akan digunakan. Harus dalam urutan menurun. | |
| generator (`torch.Generator`, *opsional*) : Sebuah [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat 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. | |
| output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara `PIL.Image` atau `np.array`. | |
| return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) alih-alih tuple biasa. | |
| callback (`Callable`, *opsional*) : Fungsi yang dipanggil setiap `callback_steps` langkah selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *opsional*, default 1) : Frekuensi pemanggilan fungsi `callback`. Jika tidak ditentukan, callback dipanggil di setiap langkah. | |
| **Mengembalikan:** [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) atau `tuple` | |
| Jika `return_dict` adalah `True`, [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan. | |
| Contoh: | |
| ```py | |
| >>> import torch | |
| >>> from diffusers import ConsistencyModelPipeline | |
| >>> device = "cuda" | |
| >>> # Load the cd_imagenet64_l2 checkpoint. | |
| >>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2" | |
| >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16) | |
| >>> pipe.to(device) | |
| >>> # Onestep Sampling | |
| >>> image = pipe(num_inference_steps=1).images[0] | |
| >>> image.save("cd_imagenet64_l2_onestep_sample.png") | |
| >>> # Onestep sampling, class-conditional image generation | |
| >>> # ImageNet-64 class label 145 corresponds to king penguins | |
| >>> image = pipe(num_inference_steps=1, class_labels=145).images[0] | |
| >>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png") | |
| >>> # Multistep sampling, class-conditional image generation | |
| >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original GitHub repo: | |
| >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77 | |
| >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0] | |
| >>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png") | |
| ``` | |
| ## ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| #### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| ```python | |
| diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L135) | |
| **Parameter:** | |
| images (`List[PIL.Image.Image]` atau `np.ndarray`) : Daftar gambar PIL yang telah didenoise dengan panjang `batch_size` atau array NumPy dengan bentuk `(batch_size, height, width, num_channels)`. | |
| Kelas output untuk pipeline gambar. | |
Xet Storage Details
- Size:
- 8.84 kB
- Xet hash:
- 050e7a91e54653adcdba9a1b57f21e0ec687a7cb165f1ff8cb7a3a2c8fc00772
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.