# Ảnh sang ảnh

  

Mô hình Stable Diffusion cũng có thể được áp dụng cho việc tạo ảnh từ ảnh bằng cách truyền vào một prompt văn bản và một ảnh ban đầu để điều kiện hóa quá trình tạo ra các ảnh mới.

[StableDiffusionImg2ImgPipeline](/docs/diffusers/main/vi/api/pipelines/stable_diffusion/img2img#diffusers.StableDiffusionImg2ImgPipeline) sử dụng cơ chế khuếch tán - khử nhiễu được đề xuất trong [SDEdit: Guided Image Synthesis and Editing with Stochastic Differential Equations](https://huggingface.co/papers/2108.01073) của Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, Stefano Ermon.

Tóm tắt từ bài báo là:

*Tổng hợp hình ảnh có hướng dẫn cho phép người dùng thông thường tạo và chỉnh sửa các hình ảnh chân thực như ảnh chụp với nỗ lực tối thiểu. Thách thức chính là cân bằng giữa độ trung thành với đầu vào của người dùng (ví dụ: các nét vẽ màu vẽ tay) và tính chân thực của hình ảnh được tổng hợp. Các phương pháp dựa trên GAN hiện tại cố gắng đạt được sự cân bằng đó bằng cách sử dụng GAN có điều kiện hoặc đảo ngược GAN, những thứ khó khăn và thường đòi hỏi dữ liệu huấn luyện bổ sung hoặc các hàm mất mát cho từng ứng dụng cụ thể. Để giải quyết những vấn đề này, chúng tôi giới thiệu một phương pháp tổng hợp và chỉnh sửa hình ảnh mới, Chỉnh sửa vi phân ngẫu nhiên (SDEdit), dựa trên tiên nghiệm sinh của mô hình khuếch tán, tổng hợp các hình ảnh chân thực bằng cách khử nhiễu lặp đi lặp lại thông qua một phương trình vi phân ngẫu nhiên (SDE). Với một hình ảnh đầu vào có hướng dẫn của người dùng bất kỳ loại nào, SDEdit trước tiên thêm nhiễu vào đầu vào, sau đó khử nhiễu hình ảnh kết quả thông qua tiên nghiệm SDE để tăng tính chân thực. SDEdit không yêu cầu huấn luyện cụ thể cho tác vụ hay đảo ngược và có thể tự nhiên đạt được sự cân bằng giữa tính chân thực và độ trung thành. Theo một nghiên cứu về nhận thức của con người, SDEdit vượt trội đáng kể so với các phương pháp dựa trên GAN tiên tiến nhất, với mức độ lên đến 98,09% về tính chân thực và 91,72% về điểm hài lòng tổng thể, trên nhiều tác vụ, bao gồm tổng hợp và chỉnh sửa hình ảnh dựa trên nét vẽ cũng như ghép hình ảnh.*

> [!TIP]
> Hãy chắc chắn xem qua phần [Mẹo](overview#tips) của Stable Diffusion để tìm hiểu cách khám phá sự đánh đổi giữa tốc độ và chất lượng của scheduler, cũng như cách tái sử dụng các thành phần pipeline một cách hiệu quả!

## StableDiffusionImg2ImgPipeline[[diffusers.StableDiffusionImg2ImgPipeline]]

#### diffusers.StableDiffusionImg2ImgPipeline[[diffusers.StableDiffusionImg2ImgPipeline]]

```python
diffusers.StableDiffusionImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L182)

**Tham số:**

vae ([AutoencoderKL](/docs/diffusers/main/vi/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Mô hình Variational Auto-Encoder (VAE) để mã hóa và giải mã hình ảnh sang và từ các biểu diễn ẩn.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Bộ mã hóa văn bản đóng băng ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Một `CLIPTokenizer` để phân tách văn bản.

unet ([UNet2DConditionModel](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Một `UNet2DConditionModel` để khử nhiễu các latents ảnh đã mã hóa.

scheduler ([SchedulerMixin](/docs/diffusers/main/vi/api/schedulers/overview#diffusers.SchedulerMixin)) : Một scheduler được sử dụng kết hợp với `unet` để khử nhiễu các latents của ảnh đã mã hóa. Có thể là một trong [DDIMScheduler](/docs/diffusers/main/vi/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/vi/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), hoặc [PNDMScheduler](/docs/diffusers/main/vi/api/schedulers/pndm#diffusers.PNDMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Module phân loại ước tính xem hình ảnh được tạo ra có thể bị coi là khiêu khích hoặc gây hại hay không. Vui lòng tham khảo [model card](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) để biết thêm chi tiết về các tác hại tiềm ẩn của model.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Một `CLIPImageProcessor` để trích xuất đặc trưng từ các hình ảnh được tạo ra; được dùng làm đầu vào cho `safety_checker`.

Pipeline cho việc tạo ảnh từ ảnh có hướng dẫn bằng văn bản sử dụng Stable Diffusion.

Mô hình này kế thừa từ [DiffusionPipeline](/docs/diffusers/main/vi/api/pipelines/overview#diffusers.DiffusionPipeline). Xem tài liệu của lớp cha để biết các phương thức chung được triển khai cho tất cả các pipeline (tải xuống, lưu, chạy trên một thiết bị cụ thể, v.v.).

Pipeline cũng kế thừa các phương thức nạp sau:
- [load_textual_inversion()](/docs/diffusers/main/vi/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) để nạp các embedding textual inversion
- [load_lora_weights()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) để nạp trọng số LoRA
- [save_lora_weights()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) để lưu trọng số LoRA
- [from_single_file()](/docs/diffusers/main/vi/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) để tải các tệp `.ckpt`
- [load_ip_adapter()](/docs/diffusers/main/vi/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) để nạp IP Adapters

#### __call__[[diffusers.StableDiffusionImg2ImgPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.8, num_inference_steps: int | None = 50, timesteps: list = None, sigmas: list = None, guidance_scale: float | None = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int = None, 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 = ['latents'], **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L858)

**Tham số:**

prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn tạo ảnh. Nếu không được định nghĩa, bạn cần truyền `prompt_embeds`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, hoặc `list[np.ndarray]`) : `Image`, mảng numpy hoặc tensor đại diện cho một lô ảnh (image batch) được sử dụng làm điểm khởi đầu. Đối với cả mảng numpy và tensor pytorch, khoảng giá trị mong đợi nằm trong `[0, 1]` Nếu là tensor hoặc danh sách các tensor, hình dạng mong đợi nên là `(B, C, H, W)` hoặc `(C, H, W)`. Nếu là mảng numpy hoặc danh sách các mảng, hình dạng mong đợi nên là `(B, H, W, C)` hoặc `(H, W, C)` Nó cũng có thể nhận các image latents dưới dạng `image`, nhưng nếu truyền trực tiếp latents thì chúng sẽ không được mã hóa lại.

strength (`float`, *optional*, mặc định là 0.8) : Chỉ định mức độ biến đổi ảnh tham chiếu `image`. Giá trị phải nằm trong khoảng từ 0 đến 1. `image` được dùng làm điểm khởi đầu và càng thêm nhiều nhiễu khi `strength` càng cao. Số bước khử nhiễu phụ thuộc vào lượng nhiễu ban đầu được thêm vào. Khi `strength` là 1, nhiễu được thêm vào là tối đa và quá trình khử nhiễu chạy đủ số lần lặp được chỉ định trong `num_inference_steps`. Giá trị 1 về cơ bản sẽ bỏ qua `image`.

num_inference_steps (`int`, *optional*, mặc định là 50) : Số bước khử nhiễu. Số bước khử nhiễu nhiều hơn thường dẫn đến hình ảnh có chất lượng cao hơn, đổi lại là suy luận chậm hơn. Tham số này được điều chỉnh bởi `strength`.

timesteps (`list[int]`, *optional*) : Các bước thời gian (timesteps) tùy chỉnh để sử dụng cho quá trình khử nhiễu với các trình lập lịch (scheduler) hỗ trợ tham số `timesteps` trong phương thức `set_timesteps` của chúng. Nếu không được định nghĩa, hành vi mặc định khi `num_inference_steps` được truyền vào sẽ được sử dụng. Phải được sắp xếp theo thứ tự giảm dần.

sigmas (`list[float]`, *optional*) : Các sigma tùy chỉnh để sử dụng cho quá trình khử nhiễu với các trình lập lịch hỗ trợ tham số `sigmas` trong phương thức `set_timesteps` của chúng. Nếu không được định nghĩa, hành vi mặc định khi `num_inference_steps` được truyền vào sẽ được sử dụng.

guidance_scale (`float`, *optional*, mặc định là 7.5) : Giá trị guidance scale cao hơn khuyến khích mô hình tạo ra các hình ảnh gắn kết chặt chẽ với `prompt` văn bản, với cái giá là chất lượng hình ảnh thấp hơn. Guidance scale được kích hoạt khi `guidance_scale > 1`.

negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn những gì không nên bao gồm trong quá trình tạo ảnh. Nếu không được định nghĩa, bạn cần truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (`guidance_scale < 1`).

num_images_per_prompt (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng hình ảnh cần tạo cho mỗi prompt.

eta (`float`, *tuỳ chọn*, mặc định là 0.0) : Tương ứng với tham số eta (η) trong bài báo [DDIM](https://huggingface.co/papers/2010.02502). Chỉ áp dụng cho [DDIMScheduler](/docs/diffusers/main/vi/api/schedulers/ddim#diffusers.DDIMScheduler) và bị bỏ qua ở các trình lập lịch khác.

generator (`torch.Generator` hoặc `list[torch.Generator]`, *tùy chọn*) : Một [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) để đảm bảo quá trình sinh là tất định.

prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản (trọng số prompt). Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`.

negative_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản (trọng số prompt). Nếu không được cung cấp, `negative_prompt_embeds` sẽ được tạo từ đối số đầu vào `negative_prompt`.

ip_adapter_image : (`PipelineImageInput`, *tùy chọn*): Đầu vào hình ảnh tùy chọn để làm việc với IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *tùy chọn*) : Các embedding ảnh đã tạo trước cho IP-Adapter. Nó phải là một danh sách có độ dài bằng với số lượng IP-adapter. Mỗi phần tử phải là một tensor có hình dạng `(batch_size, num_images, emb_dim)`. Nó phải chứa embedding ảnh âm nếu `do_classifier_free_guidance` được đặt thành `True`. Nếu không được cung cấp, các embedding sẽ được tính toán từ đối số đầu vào `ip_adapter_image`.

output_type (`str`, *tùy chọn*, mặc định là `"pil"`) : Định dạng đầu ra của hình ảnh được tạo ra. Chọn giữa `PIL.Image` hoặc `np.array`.

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một [StableDiffusionPipelineOutput](/docs/diffusers/main/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) thay vì một tuple thông thường hay không.

cross_attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttentionProcessor` như đã định nghĩa trong [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *optional*) : Số lượng lớp cần bỏ qua từ CLIP khi tính toán các prompt embeddings. Giá trị 1 có nghĩa là đầu ra của lớp trước lớp cuối cùng sẽ được sử dụng để tính toán các prompt embeddings.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*) : Một hàm hoặc một lớp con của `PipelineCallback` hoặc `MultiPipelineCallbacks` được gọi vào cuối mỗi bước khử nhiễu trong quá trình suy luận, với các đối số sau: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` sẽ bao gồm một danh sách tất cả các tensor như được chỉ định bởi `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *optional*) : Danh sách các đầu vào tensor cho hàm `callback_on_step_end`. Các tensor được chỉ định trong danh sách sẽ được truyền dưới dạng tham số `callback_kwargs`. Bạn chỉ có thể bao gồm các biến được liệt kê trong thuộc tính `._callback_tensor_inputs` của lớp pipeline của bạn.

**Trả về:** [StableDiffusionPipelineOutput](/docs/diffusers/main/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) hoặc `tuple`

Nếu `return_dict` là `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/vi/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) sẽ được trả về, ngược lại một `tuple` sẽ được trả về trong đó phần tử đầu tiên là một danh sách chứa các hình ảnh đã tạo và phần tử thứ hai là một danh sách các `bool` cho biết hình ảnh tương ứng có chứa nội dung "không an toàn" (nsfw) hay không.

Hàm gọi call của pipeline để tạo nội dung.

Ví dụ:
```py
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from diffusers import StableDiffusionImg2ImgPipeline

>>> device = "cuda"
>>> model_id_or_path = "stable-diffusion-v1-5/stable-diffusion-v1-5"
>>> pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
>>> pipe = pipe.to(device)

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))

>>> prompt = "A fantasy landscape, trending on artstation"

>>> images = pipe(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images
>>> images[0].save("fantasy_landscape.png")
```

#### enable_attention_slicing[[diffusers.StableDiffusionImg2ImgPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**Tham số:**

slice_size (`str` hoặc `int`, *tuỳ chọn*, mặc định là `"auto"`) : Khi là `"auto"`, sẽ chia đôi đầu vào của các attention head, do đó attention sẽ được tính trong hai bước. Nếu là `"max"`, lượng bộ nhớ tối đa sẽ được tiết kiệm bằng cách chỉ chạy một lát một lúc. Nếu cung cấp một số, sẽ sử dụng nhiều lát bằng `attention_head_dim // slice_size`. Trong trường hợp này, `attention_head_dim` phải là bội số của `slice_size`.

Bật tính toán chú ý dạng lát cắt. Khi tùy chọn này được bật, module chú ý sẽ chia tensor đầu vào thành các lát cắt để tính toán chú ý qua nhiều bước. Với nhiều hơn một đầu chú ý, phép tính được thực hiện tuần tự trên từng đầu. Điều này hữu ích để tiết kiệm một phần bộ nhớ, đổi lại là sự giảm tốc độ nhỏ.

> [!WARNING] > ⚠️ Không bật attention slicing nếu bạn đã đang sử dụng `scaled_dot_product_attention` (SDPA)
từ PyTorch > 2.0 hoặc xFormers. Các phép tính attention này đã rất tiết kiệm bộ nhớ nên bạn không cần bật > chức năng này. Nếu bạn bật attention slicing với SDPA hoặc xFormers, nó có thể dẫn đến việc chậm đi đáng kể!

Ví dụ:

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableDiffusionImg2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

Tắt tính toán chú ý dạng lát cắt. Nếu `enable_attention_slicing` đã được gọi trước đó, chú ý sẽ được tính toán trong một bước duy nhất.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionImg2ImgPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**Tham số:**

attention_op (`Callable`, *tùy chọn*) : Ghi đè toán tử mặc định `None` để sử dụng làm đối số `op` cho hàm [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) của xFormers.

Bật chú ý tiết kiệm bộ nhớ từ [xFormers](https://facebookresearch.github.io/xformers/). Khi tùy chọn này được bật, bạn nên quan sát thấy mức sử dụng bộ nhớ GPU thấp hơn và có thể tăng tốc trong quá trình suy luận. Việc tăng tốc trong quá trình huấn luyện không được đảm bảo.

> [!WARNING] > ⚠️ Khi cả memory efficient attention và sliced attention đều được bật, memory efficient
attention có > ưu tiên.

Ví dụ:

```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionImg2ImgPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

Tắt chú ý tiết kiệm bộ nhớ từ [xFormers](https://facebookresearch.github.io/xformers/).

#### load_textual_inversion[[diffusers.StableDiffusionImg2ImgPipeline.load_textual_inversion]]

```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)

**Tham số:**

pretrained_model_name_or_path (`str` hoặc `os.PathLike` hoặc `list[str or os.PathLike]` hoặc `Dict` hoặc `list[Dict]`) : Có thể là một trong các loại sau hoặc một danh sách của chúng:  - Một chuỗi, *model id* (ví dụ `sd-concepts-library/low-poly-hd-logos-icons`) của một mô hình được huấn luyện trước có trên Hub. - Đường dẫn đến một *thư mục* (ví dụ `./my_text_inversion_directory/`) chứa trọng số textual inversion. - Đường dẫn đến một *tệp* (ví dụ `./my_text_inversions.pt`) chứa trọng số textual inversion. - Một [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` hoặc `list[str]`, *tùy chọn*) : Ghi đè token được sử dụng cho trọng số đảo ngược văn bản. Nếu `pretrained_model_name_or_path` là một danh sách, thì `token` cũng phải là một danh sách có cùng độ dài.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *tùy chọn*) : Bộ mã hóa văn bản đóng băng ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Nếu không được chỉ định, hàm sẽ lấy self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *tùy chọn*) : Một `CLIPTokenizer` để tách token cho văn bản. Nếu không được chỉ định, hàm sẽ lấy self.tokenizer.

weight_name (`str`, *tùy chọn*) : Tên của tệp trọng số tùy chỉnh. Nên sử dụng khi: - Tệp textual inversion đã lưu ở định dạng 🤗 Diffusers, nhưng được lưu dưới một tên trọng số cụ thể như `text_inv.bin`. - Tệp textual inversion đã lưu ở định dạng Automatic1111.

cache_dir (`str | os.PathLike`, *tùy chọn*) : Đường dẫn đến thư mục nơi cấu hình mô hình được huấn luyện trước đã tải xuống được lưu đệm nếu không sử dụng bộ lưu đệm tiêu chuẩn.

force_download (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.

proxies (`dict[str, str]`, *tùy chọn*) : Một từ điển các máy chủ proxy để sử dụng theo giao thức hoặc điểm cuối, ví dụ, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Các proxy được sử dụng cho mỗi yêu cầu.

local_files_only (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có chỉ tải trọng số và tệp cấu hình của mô hình cục bộ hay không. Nếu đặt thành `True`, mô hình sẽ không được tải xuống từ Hub.

hf_token (`str` hoặc *bool*, *tùy chọn*) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là `True`, token được tạo từ `diffusers-cli login` (được lưu trong `~/.huggingface`) sẽ được sử dụng.

revision (`str`, *tùy chọn*, mặc định là `"main"`) : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ, id commit, hoặc bất kỳ định danh nào được Git cho phép.

subfolder (`str`, *tùy chọn*, mặc định là `""`) : Vị trí của thư mục con chứa tệp mô hình bên trong một kho lưu trữ mô hình lớn hơn trên Hub hoặc cục bộ.

mirror (`str`, *tùy chọn*) : Nguồn mirror để giải quyết các vấn đề về khả năng truy cập nếu bạn đang tải xuống một model ở Trung Quốc. Chúng tôi không đảm bảo tính kịp thời hay an toàn của nguồn, và bạn nên tham khảo trang mirror để biết thêm thông tin.

Nạp các embedding Textual Inversion vào text encoder của [StableDiffusionPipeline](/docs/diffusers/main/vi/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (hỗ trợ cả định dạng 🤗 Diffusers và Automatic1111).

Ví dụ:

Để nạp vector nhúng Textual Inversion ở định dạng 🤗 Diffusers:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```

Để nạp vector nhúng Textual Inversion ở định dạng Automatic1111, hãy đảm bảo tải vector trước (ví dụ từ [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) rồi nạp vector đó

trên máy cục bộ:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```

#### from_single_file[[diffusers.StableDiffusionImg2ImgPipeline.from_single_file]]

```python
from_single_file(pretrained_model_link_or_path, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/single_file.py#L276)

**Tham số:**

pretrained_model_link_or_path (`str` hoặc `os.PathLike`, *tùy chọn*) : Có thể là: - Một liên kết đến tệp `.ckpt` (ví dụ `"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt"`) trên Hub. - Một đường dẫn đến *tệp* chứa tất cả trọng số của pipeline.

dtype (`str` hoặc `torch.dtype`, *tuỳ chọn*) : Ghi đè `torch.dtype` mặc định và tải mô hình với dtype khác.

force_download (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có nên ép buộc tải lại (re-download) trọng số mô hình và các tệp cấu hình hay không, ghi đè lên các phiên bản đã được lưu trong bộ nhớ đệm nếu chúng tồn tại.

cache_dir (`str | os.PathLike`, *tùy chọn*) : Đường dẫn đến thư mục nơi cấu hình mô hình được huấn luyện trước đã tải xuống được lưu đệm nếu không sử dụng bộ lưu đệm tiêu chuẩn.

proxies (`dict[str, str]`, *tùy chọn*) : Một từ điển các máy chủ proxy để sử dụng theo giao thức hoặc điểm cuối, ví dụ, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Các proxy được sử dụng cho mỗi yêu cầu.

local_files_only (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có chỉ tải trọng số và tệp cấu hình của mô hình cục bộ hay không. Nếu đặt thành `True`, mô hình sẽ không được tải xuống từ Hub.

token (`str` hoặc *bool*, *tùy chọn*) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Nếu là `True`, token được tạo từ `diffusers-cli login` (được lưu trong `~/.huggingface`) sẽ được sử dụng.

revision (`str`, *tùy chọn*, mặc định là `"main"`) : Phiên bản mô hình cụ thể cần sử dụng. Nó có thể là tên nhánh, tên thẻ, id commit, hoặc bất kỳ định danh nào được Git cho phép.

original_config_file (`str`, *tùy chọn*) : Đường dẫn đến tệp cấu hình gốc được sử dụng để huấn luyện mô hình. Nếu không được cung cấp, tệp cấu hình sẽ được suy ra từ tệp checkpoint.

config (`str`, *tùy chọn*) : Có thể là: - Một chuỗi, *repo id* (ví dụ `CompVis/ldm-text2im-large-256`) của một pipeline được huấn luyện trước có trên Hub. - Một đường dẫn đến *thư mục* (ví dụ `./my_pipeline_directory/`) chứa các cấu hình thành phần pipeline ở định dạng Diffusers.

disable_mmap ('bool', *tuỳ chọn*, mặc định là 'False') : Có vô hiệu hóa mmap khi tải mô hình Safetensors hay không. Tùy chọn này có thể cho hiệu suất tốt hơn khi mô hình nằm trên ổ đĩa mạng hoặc ổ cứng.

kwargs (đictionary còn lại của các đối số từ khóa, *tùy chọn*) : Có thể được sử dụng để ghi đè lên các biến load và saveable (các thành phần pipeline của lớp pipeline cụ thể). Các thành phần bị ghi đè sẽ được truyền trực tiếp vào phương thức `__init__` của pipeline. Xem ví dụ bên dưới để biết thêm thông tin.

Tạo một [DiffusionPipeline](/docs/diffusers/main/vi/api/pipelines/overview#diffusers.DiffusionPipeline) từ trọng số pipeline được huấn luyện trước, lưu ở định dạng `.ckpt` hoặc `.safetensors`. Pipeline mặc định được đặt ở chế độ đánh giá (`model.eval()`).

Ví dụ:

```py
>>> from diffusers import StableDiffusionPipeline

>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = StableDiffusionPipeline.from_single_file(
...     "https://huggingface.co/WarriorMama777/OrangeMixs/blob/main/Models/AbyssOrangeMix/AbyssOrangeMix.safetensors"
... )

>>> # Download pipeline from local file
>>> # file is downloaded under ./v1-5-pruned-emaonly.ckpt
>>> pipeline = StableDiffusionPipeline.from_single_file("./v1-5-pruned-emaonly.ckpt")

>>> # Enable float16 and move to GPU
>>> pipeline = StableDiffusionPipeline.from_single_file(
...     "https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/blob/main/v1-5-pruned-emaonly.ckpt",
...     torch_dtype=torch.float16,
... )
>>> pipeline.to("cuda")
```

#### load_lora_weights[[diffusers.StableDiffusionImg2ImgPipeline.load_lora_weights]]

```python
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L148)

**Tham số:**

pretrained_model_name_or_path_or_dict (`str` hoặc `os.PathLike` hoặc `dict`) : Xem [lora_state_dict()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

adapter_name (`str`, *tùy chọn*) : Tên adapter sẽ được sử dụng để tham chiếu mô hình adapter đã tải. Nếu không được chỉ định, hệ thống sẽ sử dụng `default_{i}`, trong đó i là tổng số adapter đang được tải.

low_cpu_mem_usage (`bool`, *tùy chọn*) : Tăng tốc độ tải mô hình bằng cách chỉ tải trọng số LoRA được huấn luyện trước và không khởi tạo các trọng số ngẫu nhiên.

hotswap (`bool`, *tuỳ chọn*) : Mặc định là `False`. Xác định có thay thế adapter (LoRA) hiện có bằng adapter mới được nạp tại chỗ hay không. Điều này có nghĩa là, thay vì nạp thêm một adapter, phương thức này sẽ lấy trọng số của adapter hiện có và thay thế chúng bằng trọng số của adapter mới. Cách này có thể nhanh hơn và tiết kiệm bộ nhớ hơn. Tuy nhiên, lợi ích chính của hotswapping là khi mô hình được biên dịch bằng torch.compile, việc nạp adapter mới không yêu cầu biên dịch lại mô hình. Khi sử dụng hotswapping, `adapter_name` được truyền vào phải là tên của một adapter đã được nạp. Nếu adapter mới và adapter cũ có rank và/hoặc LoRA alphas (tức là hệ số scale) khác nhau, bạn cần gọi thêm một phương thức trước khi nạp adapter: ```py pipeline = ...  # load diffusers pipeline max_rank = ...  # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now ``` Lưu ý rằng việc hotswap adapter của text encoder hiện chưa được hỗ trợ. Kỹ thuật này có một số hạn chế khác, được tài liệu hóa tại đây: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (`dict`, *tùy chọn*) : Xem [lora_state_dict()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

Tải trọng số LoRA được chỉ định trong `pretrained_model_name_or_path_or_dict` vào `self.unet` và `self.text_encoder`.

Tất cả các kwargs được chuyển tiếp đến `self.lora_state_dict`.

Xem [lora_state_dict()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) để biết thêm chi tiết về cách nạp state dict.

Xem [load_lora_into_unet()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) để biết thêm chi tiết về cách state dict được nạp vào `self.unet`.

Xem [load_lora_into_text_encoder()](/docs/diffusers/main/vi/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) để biết thêm chi tiết về cách state dict được nạp vào `self.text_encoder`.

#### save_lora_weights[[diffusers.StableDiffusionImg2ImgPipeline.save_lora_weights]]

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict = None, text_encoder_lora_layers: dict = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L466)

**Tham số:**

save_directory (`str` hoặc `os.PathLike`) : Thư mục để lưu các tham số LoRA. Thư mục sẽ được tạo nếu chưa tồn tại.

unet_lora_layers (`dict[str, torch.nn.Module]` hoặc `dict[str, torch.Tensor]`) : State dict của các lớp LoRA tương ứng với `unet`.

text_encoder_lora_layers (`dict[str, torch.nn.Module]` hoặc `dict[str, torch.Tensor]`) : State dict của các lớp LoRA tương ứng với `text_encoder`. Phải truyền rõ state dict LoRA của text encoder vì nó đến từ 🤗 Transformers.

is_main_process (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem tiến trình gọi hàm này có phải là tiến trình chính hay không. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần gọi hàm này trên tất cả các tiến trình. Trong trường hợp này, chỉ đặt `is_main_process=True` trên tiến trình chính để tránh điều kiện đua.

save_function (`Callable`) : Hàm được sử dụng để lưu state dictionary. Hữu ích trong quá trình huấn luyện phân tán khi bạn cần thay thế `torch.save` bằng một phương pháp khác. Có thể được cấu hình bằng biến môi trường `DIFFUSERS_SAVE_MODE`.

safe_serialization (`bool`, *tùy chọn*, mặc định là `True`) : Có lưu mô hình bằng `safetensors` hay theo cách truyền thống của PyTorch với `pickle` hay không.

unet_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến unet sẽ được serialize cùng với state dict.

text_encoder_lora_adapter_metadata : Metadata của adapter LoRA liên quan đến text encoder, sẽ được serialize cùng với state dict.

Lưu các tham số LoRA tương ứng với UNet và text encoder.

#### encode_prompt[[diffusers.StableDiffusionImg2ImgPipeline.encode_prompt]]

```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L358)

**Tham số:**

prompt (`str` hoặc `list[str]`, *tùy chọn*) : prompt cần được mã hóa

device : (`torch.device`): thiết bị torch

num_images_per_prompt (`int`) : số lượng hình ảnh cần được tạo cho mỗi prompt

do_classifier_free_guidance (`bool`) : có sử dụng classifier free guidance hay không

negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt không được dùng để hướng dẫn việc tạo ảnh. Nếu không được định nghĩa, bạn phải truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (tức là bị bỏ qua nếu `guidance_scale` nhỏ hơn `1`).

prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`.

negative_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, negative_prompt_embeds sẽ được tạo từ đối số đầu vào `negative_prompt`.

lora_scale (`float`, *tuỳ chọn*) : Thang LoRA sẽ được áp dụng cho tất cả các lớp LoRA của text encoder nếu các lớp LoRA được nạp.

clip_skip (`int`, *optional*) : Số lượng lớp cần bỏ qua từ CLIP khi tính toán các prompt embeddings. Giá trị 1 có nghĩa là đầu ra của lớp trước lớp cuối cùng sẽ được sử dụng để tính toán các prompt embeddings.

Mã hóa prompt thành các trạng thái ẩn của text encoder.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionImg2ImgPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L801)

**Tham số:**

w (`torch.Tensor`) : Tạo các vector nhúng với thang độ dẫn hướng được chỉ định để sau đó làm phong phú các nhúng bước thời gian.

embedding_dim (`int`, *tuỳ chọn*, mặc định là 512) : Kích thước của các embedding cần tạo.

dtype (`torch.dtype`, *tùy chọn*, mặc định là `torch.float32`) : Kiểu dữ liệu của các embedding được tạo ra.

**Trả về:** `torch.Tensor`

Các vector nhúng có hình dạng `(len(w), embedding_dim)`.

Xem https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

**Tham số:**

images (`list[PIL.Image.Image]` hoặc `np.ndarray`) : danh sách các hình ảnh PIL đã khử nhiễu có độ dài `batch_size` hoặc mảng NumPy có hình dạng `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : danh sách cho biết hình ảnh tương ứng có chứa nội dung "không an toàn cho công việc" (nsfw) hay không, hoặc `None` nếu không thể thực hiện kiểm tra an toàn.

Lớp đầu ra cho các pipeline Stable Diffusion.