# Pipelines

Pipelines cung cấp một cách đơn giản để chạy các mô hình diffusion tiên tiến trong suy luận bằng cách đóng gói tất cả các thành phần cần thiết (nhiều mô hình được huấn luyện độc lập, các trình lập lịch và bộ xử lý) vào một lớp end-to-end duy nhất. Pipelines linh hoạt và có thể được điều chỉnh để sử dụng các trình lập lịch khác nhau hoặc thậm chí các thành phần mô hình khác nhau.

Tất cả các pipeline được xây dựng từ lớp cơ sở [DiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline), cung cấp các chức năng cơ bản để tải, tải xuống và lưu trữ tất cả các thành phần. Các loại pipeline cụ thể (ví dụ [StableDiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)) được tải bằng [from_pretrained()](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) sẽ được tự động phát hiện, và các thành phần của pipeline sẽ được tải và truyền vào hàm `__init__` của pipeline.

> [!WARNING]
> Bạn không nên sử dụng lớp [DiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline) để huấn luyện. Các thành phần riêng lẻ (ví dụ, [UNet2DModel](/docs/diffusers/v0.43.0/vi/api/models/unet2d#diffusers.UNet2DModel) và [UNet2DConditionModel](/docs/diffusers/v0.43.0/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) của các pipeline khuếch tán thường được huấn luyện riêng biệt, vì vậy chúng tôi đề xuất làm việc trực tiếp với chúng.
>
> 
>
> Pipelines không cung cấp bất kỳ chức năng huấn luyện nào. Bạn sẽ nhận thấy autograd của PyTorch bị vô hiệu hóa bằng cách trang trí phương thức `__call__()` với bộ trang trí [`torch.no_grad`](https://pytorch.org/docs/stable/generated/torch.no_grad.html) vì pipelines không nên được sử dụng để huấn luyện. Nếu bạn quan tâm đến huấn luyện, hãy xem các hướng dẫn về [Training](../../training/overview) thay thế!

Sử dụng **API > Pipelines** ở thanh bên để xem tất cả các tham chiếu pipeline theo modality. Đối với các quy trình làm việc theo hướng tác vụ, hãy bắt đầu với [Quickstart](../../quicktour) hoặc một hướng dẫn như [text-to-image](../../using-diffusers/conditional_image_generation), [image-to-image](../../using-diffusers/img2img), [inpainting](../../using-diffusers/inpaint) hoặc [video generation](../../using-diffusers/text-img2vid).

## DiffusionPipeline[[diffusers.DiffusionPipeline]]

#### diffusers.DiffusionPipeline[[diffusers.DiffusionPipeline]]

```python
diffusers.DiffusionPipeline()
```

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

Lớp cơ sở cho tất cả các pipeline.

[DiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline) lưu trữ tất cả các thành phần (mô hình, trình lập lịch và bộ xử lý) cho các pipeline khuếch tán và cung cấp các phương thức để tải, tải xuống và lưu trữ mô hình. Nó cũng bao gồm các phương thức để:

- di chuyển tất cả các module PyTorch sang thiết bị bạn chọn
- bật/tắt thanh tiến trình cho lần lặp khử nhiễu

Thuộc tính lớp:

- **config_name** (`str`) -- Tên tệp cấu hình lưu trữ tên lớp và tên module của tất cả các thành phần trong pipeline khuếch tán.
- **_optional_components** (`List[str]`) -- Danh sách tất cả các thành phần tùy chọn không bắt buộc phải truyền vào pipeline để hoạt động (nên được ghi đè bởi các lớp con).

#### __call__[[diffusers.DiffusionPipeline.__call__]]

```python
__call__(*args, **kwargs)
```

Gọi self như một hàm.

#### device[[diffusers.DiffusionPipeline.device]]

```python
device()
```

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

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

Thiết bị torch mà pipeline được đặt trên đó. Khi các thành phần được chia tách giữa các thiết bị (ví dụ: text encoder trên CPU trong khi denoising backbone chạy trên accelerator), thiết bị accelerator sẽ được trả về.

#### đến[[diffusers.DiffusionPipeline.to]]

```python
to(*args, **kwargs)
```

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

**Tham số:**

dtype (`torch.dtype`, *tùy chọn*) : Trả về một pipeline với [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) được chỉ định

device (`torch.Device`, *tùy chọn*) : Trả về một pipeline với [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) được chỉ định

silence_dtype_warnings (`str`, *tùy chọn*, mặc định là `False`) : Có nên bỏ qua các cảnh báo nếu `dtype` đích không tương thích với `device` đích hay không.

**Trả về:** [DiffusionPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline)

Pipeline đã được chuyển đổi sang `dtype` và/hoặc `dtype` được chỉ định.

Thực hiện chuyển đổi dtype và/hoặc device của Pipeline. Một torch.dtype và torch.device được suy ra từ các đối số của `self.to(*args, **kwargs).`

> [!TIP] > Nếu pipeline đã có torch.dtype và torch.device đúng, thì nó sẽ được trả về nguyên vẹn.
Ngược lại, > pipeline được trả về là bản sao của self với torch.dtype và torch.device mong muốn.

Dưới đây là các cách để gọi `to`:

- `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` để trả về một pipeline với [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) được chỉ định
- `to(device, silence_dtype_warnings=False) → DiffusionPipeline` để trả về một pipeline với [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) được chỉ định
- `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` để trả về một pipeline với [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) và [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) được chỉ định

#### components[[diffusers.DiffusionPipeline.components]]

```python
components()
```

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

Thuộc tính `self.components` có thể hữu ích để chạy các pipeline khác nhau với cùng các trọng số và cấu hình mà không cần cấp phát thêm bộ nhớ.

Returns (`dict`): Một từ điển chứa tất cả các module cần thiết để khởi tạo pipeline.

Ví dụ:

```py
>>> from diffusers import (
...     StableDiffusionPipeline,
...     StableDiffusionImg2ImgPipeline,
...     StableDiffusionInpaintPipeline,
... )

>>> text2img = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> img2img = StableDiffusionImg2ImgPipeline(**text2img.components)
>>> inpaint = StableDiffusionInpaintPipeline(**text2img.components)
```

#### disable_attention_slicing[[diffusers.DiffusionPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

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

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.

#### disable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

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

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

#### tải xuống[[diffusers.DiffusionPipeline.download]]

```python
download(pretrained_model_name, **kwargs)
```

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

**Tham số:**

pretrained_model_name (`str` hoặc `os.PathLike`, *tùy chọn*) : Một chuỗi, *repository id* (ví dụ `CompVis/ldm-text2im-large-256`) của một pipeline được huấn luyện trước có trên Hub.

custom_pipeline (`str`, *optional*) : Có thể là một trong các trường hợp sau:  - Một chuỗi, *repository id* (ví dụ `CompVis/ldm-text2im-large-256`) của một pipeline được huấn luyện trước có trên Hub. Repository phải chứa một tệp có tên `pipeline.py` định nghĩa pipeline tùy chỉnh.  - Một chuỗi, *tên tệp* của một pipeline cộng đồng có trên GitHub dưới [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Tên tệp hợp lệ phải khớp với tên tệp chứ không phải script của pipeline (`clip_guided_stable_diffusion` thay vì `clip_guided_stable_diffusion.py`). Các pipeline cộng đồng luôn được tải từ nhánh `main` hiện tại của GitHub.  - Đường dẫn đến một *thư mục* (`./my_pipeline_directory/`) chứa một pipeline tùy chỉnh. Thư mục phải chứa một tệp có tên `pipeline.py` định nghĩa pipeline tùy chỉnh.  > [!WARNING] > 🧪 Đây là một tính năng thử nghiệm và có thể thay đổi trong tương lai.  Để biết thêm thông tin về cách tải và tạo các pipeline tùy chỉnh, hãy xem [Cách đóng góp một pipeline cộng đồng](https://huggingface.co/docs/diffusers/main/en/using-diffusers/contribute_pipeline).

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.

output_loading_info(`bool`, *tuỳ chọn*, mặc định là `False`) : Có trả về một từ điển chứa các khóa bị thiếu, các khóa không mong đợi và thông báo lỗi hay không.

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.

custom_revision (`str`, *tuỳ 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ẻ, hoặc id commit tương tự như `revision` khi tải một pipeline tùy chỉnh từ Hub. Nó có thể là phiên bản 🤗 Diffusers khi tải một pipeline tùy chỉnh từ GitHub, nếu không, mặc định là `"main"` khi tải từ Hub.

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.

variant (`str`, *tùy chọn*) : Nạp trọng số từ tên tệp biến thể được chỉ định, chẳng hạn như `"fp16"` hoặc `"ema"`.

use_safetensors (`bool`, *tuỳ chọn*, mặc định là `None`) : Nếu được đặt thành `None`, các trọng số safetensors sẽ được tải xuống nếu chúng có sẵn **và** nếu thư viện safetensors đã được cài đặt. Nếu được đặt thành `True`, mô hình sẽ được tải bắt buộc từ các trọng số safetensors. Nếu được đặt thành `False`, các trọng số safetensors sẽ không được tải.

use_onnx (`bool`, *tuỳ chọn*, mặc định là `False`) : Nếu đặt thành `True`, trọng số ONNX sẽ luôn được tải xuống nếu có. Nếu đặt thành `False`, trọng số ONNX sẽ không bao giờ được tải xuống. Mặc định, `use_onnx` có giá trị mặc định là thuộc tính lớp `_is_onnx`, vốn là `False` đối với các pipeline không phải ONNX và `True` đối với các pipeline ONNX. Trọng số ONNX bao gồm cả các tệp kết thúc bằng `.onnx` và `.pb`.

trust_remote_code (`bool`, *tuỳ chọn*, mặc định là `False`) : Cho phép hay không cho phép các pipeline và thành phần tùy chỉnh được định nghĩa trên Hub trong các tệp riêng của chúng. Chỉ nên đặt tùy chọn này thành `True` cho các kho bạn tin tưởng và đã đọc mã nguồn, vì nó sẽ thực thi mã có trên Hub trên máy cục bộ của bạn.

use_flashpack (`bool`, *tuỳ chọn*, mặc định là `False`) : Nếu đặt thành `True`, trọng số FlashPack sẽ luôn được tải xuống nếu có. Nếu đặt thành `False`, trọng số FlashPack sẽ không bao giờ được tải xuống.

**Trả về:** `os.PathLike`

Đường dẫn đến pipeline đã tải xuống.

Tải xuống và lưu vào bộ nhớ đệm một pipeline khuếch tán PyTorch từ trọng số pipeline được huấn luyện trước.

> [!TIP] > Để sử dụng các mô hình riêng tư hoặc [gated models](https://huggingface.co/docs/hub/models-gated#gated-models), hãy đăng nhập
với `hf > auth login

#### enable_attention_slicing[[diffusers.DiffusionPipeline.enable_attention_slicing]]

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

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

**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]
```

#### enable_group_offload[[diffusers.DiffusionPipeline.enable_group_offload]]

```python
enable_group_offload(onload_device: device, offload_device: device = torch.device(), offload_type: str = 'block_level', num_blocks_per_group: int | None = None, non_blocking: bool = False, use_stream: bool = False, record_stream: bool = False, low_cpu_mem_usage = False, offload_to_disk_path: str | None = None, exclude_modules: str | list[str] | None = None)
```

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

**Tham số:**

onload_device (`torch.device`) : Thiết bị mà nhóm các module được nạp lên.

offload_device (`torch.device`, mặc định là `torch.device("cpu")`) : Thiết bị mà nhóm các module được offload đến. Thông thường, đây nên là CPU. Mặc định là CPU.

offload_type (`str` hoặc `GroupOffloadingType`, mặc định là "block_level") : Kiểu offloading sẽ được áp dụng. Có thể là "block_level" hoặc "leaf_level". Mặc định là "block_level".

offload_to_disk_path (`str`, *tùy chọn*, mặc định là `None`) : Đường dẫn đến thư mục nơi các tham số sẽ được offload. Việc thiết lập tùy chọn này có thể hữu ích trong các môi trường có RAM hạn chế, nơi cần một sự đánh đổi hợp lý giữa tốc độ và bộ nhớ.

num_blocks_per_group (`int`, *optional*) : Số lượng khối trên mỗi nhóm khi sử dụng offload_type="block_level". Tham số này là bắt buộc khi sử dụng offload_type="block_level".

non_blocking (`bool`, mặc định là `False`) : Nếu là True, việc offloading và onloading sẽ được thực hiện với chuyển dữ liệu không chặn (non-blocking).

use_stream (`bool`, mặc định là `False`) : Nếu là True, việc offloading và onloading sẽ được thực hiện bất đồng bộ bằng cách sử dụng một CUDA stream. Điều này có thể hữu ích để chồng chéo giữa tính toán và truyền dữ liệu.

record_stream (`bool`, mặc định là `False`) : Khi được bật cùng với `use_stream`, nó đánh dấu tensor hiện tại là đã được sử dụng bởi stream này. Cách này nhanh hơn nhưng đổi lại tiêu tốn thêm một chút bộ nhớ. Xem [tài liệu chính thức của PyTorch](https://pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html) để biết thêm chi tiết.

low_cpu_mem_usage (`bool`, mặc định là `False`) : Nếu là True, việc sử dụng bộ nhớ CPU được tối thiểu hóa bằng cách ghim các tensor theo thời gian thực thay vì ghim trước. Tùy chọn này chỉ có ý nghĩa khi sử dụng offloading CPU dạng luồng (tức là `use_stream=True`). Điều này có thể hữu ích khi bộ nhớ CPU là điểm nghẽn, nhưng có thể làm giảm lợi ích của việc sử dụng luồng.

exclude_modules (`Union[str, List[str]]`, mặc định là `None`) : Danh sách các module cần loại trừ khỏi việc offloading.

Áp dụng group offloading cho các lớp bên trong của một torch.nn.Module. Để hiểu group offloading là gì và khi nào nó mang lại lợi ích, trước tiên chúng ta cần cung cấp một số ngữ cảnh về cách các phương pháp offloading khác được hỗ trợ hoạt động.

Thông thường, việc offload được thực hiện ở hai cấp độ:
- Cấp độ module: Trong Diffusers, tính năng này có thể được bật bằng phương thức `ModelMixin::enable_model_cpu_offload()`. Nó
hoạt động bằng cách offload từng thành phần của pipeline sang CPU để lưu trữ, và onload lên thiết bị accelerator khi cần cho tính toán. Phương pháp này tiết kiệm bộ nhớ hơn so với việc giữ tất cả các thành phần trên accelerator, nhưng yêu cầu về bộ nhớ vẫn khá cao. Để phương pháp này hoạt động, cần có bộ nhớ tương đương với kích thước của model trong runtime dtype + kích thước của các tensor kích hoạt trung gian lớn nhất để có thể hoàn thành forward pass.
- Mức độ lá: Trong Diffusers, tính năng này có thể được bật bằng phương thức `ModelMixin::enable_sequential_cpu_offload()`. Nó
hoạt động bằng cách chuyển các tham số ở mức lá thấp nhất của đồ thị tính toán xuống CPU để lưu trữ, và chỉ nạp các lá đó lên thiết bị tăng tốc để tính toán. Cách này sử dụng lượng bộ nhớ tăng tốc thấp nhất, nhưng có thể chậm hơn do số lượng đồng bộ hóa thiết bị quá lớn.

Group offloading là giải pháp trung gian giữa hai phương pháp. Phương pháp này hoạt động bằng cách offload các nhóm lớp bên trong (dạng `torch.nn.ModuleList` hoặc `torch.nn.Sequential`). Cách này sử dụng bộ nhớ thấp hơn so với offloading ở cấp module. Nó cũng nhanh hơn so với offloading ở cấp leaf/sequential, vì số lần đồng bộ hóa thiết bị được giảm đi.

Một tính năng khác được hỗ trợ (cho các thiết bị CUDA có hỗ trợ các luồng chuyển dữ liệu bất đồng bộ) là khả năng chồng chéo giữa việc chuyển dữ liệu và tính toán để giảm thời gian thực thi tổng thể so với việc offload tuần tự. Tính năng này được kích hoạt bằng cách sử dụng layer prefetching với streams, tức là layer sẽ được thực thi tiếp theo bắt đầu onloading lên thiết bị tăng tốc trong khi layer hiện tại đang được thực thi - điều này làm tăng nhẹ yêu cầu về bộ nhớ. Lưu ý rằng cài đặt này cũng hỗ trợ offload ở cấp độ lá (leaf-level) nhưng có thể nhanh hơn đáng kể khi sử dụng streams.

Ví dụ:
```python
>>> from diffusers import DiffusionPipeline
>>> import torch

>>> pipe = DiffusionPipeline.from_pretrained("Qwen/Qwen-Image", dtype=torch.bfloat16)

>>> pipe.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
>>> image = pipe("a beautiful sunset").images[0]
```

#### enable_model_cpu_offload[[diffusers.DiffusionPipeline.enable_model_cpu_offload]]

```python
enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

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

**Tham số:**

gpu_id (`int`, *optional*) : ID của bộ tăng tốc sẽ được sử dụng trong suy luận. Nếu không được chỉ định, giá trị mặc định sẽ là 0.

device (`torch.Device` hoặc `str`, *tuỳ chọn*, mặc định là None) : Loại thiết bị PyTorch của bộ tăng tốc sẽ được sử dụng trong suy luận. Nếu không được chỉ định, hệ thống sẽ tự động phát hiện và sử dụng bộ tăng tốc khả dụng.

Tải tất cả các mô hình xuống CPU bằng accelerate, giảm mức sử dụng bộ nhớ với tác động thấp đến hiệu suất. So với `enable_sequential_cpu_offload`, phương pháp này di chuyển toàn bộ một mô hình tại một thời điểm lên bộ tăng tốc khi phương thức `forward` của nó được gọi, và mô hình sẽ ở lại trên bộ tăng tốc cho đến khi mô hình tiếp theo chạy. Mức tiết kiệm bộ nhớ thấp hơn so với `enable_sequential_cpu_offload`, nhưng hiệu suất tốt hơn nhiều nhờ việc thực hiện lặp lại của `unet`.

#### enable_sequential_cpu_offload[[diffusers.DiffusionPipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

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

**Tham số:**

gpu_id (`int`, *optional*) : ID của bộ tăng tốc sẽ được sử dụng trong suy luận. Nếu không được chỉ định, giá trị mặc định sẽ là 0.

device (`torch.Device` hoặc `str`, *tuỳ chọn*, mặc định là None) : Loại thiết bị PyTorch của bộ tăng tốc sẽ được sử dụng trong suy luận. Nếu không được chỉ định, hệ thống sẽ tự động phát hiện và sử dụng bộ tăng tốc khả dụng.

Tải xuống tất cả các mô hình xuống CPU bằng 🤗 Accelerate, giảm đáng kể lượng bộ nhớ sử dụng. Khi được gọi, các state dict của tất cả các thành phần `torch.nn.Module` (ngoại trừ những thành phần trong `self._exclude_from_cpu_offload`) sẽ được lưu xuống CPU, sau đó được chuyển đến `torch.device('meta')` và chỉ được tải lên accelerator khi phương thức `forward` của submodule cụ thể đó được gọi. Việc offload diễn ra ở cấp độ submodule. Tiết kiệm bộ nhớ cao hơn so với `enable_model_cpu_offload`, nhưng hiệu suất thấp hơn.

#### enable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.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/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**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)
```

#### from_pipe[[diffusers.DiffusionPipeline.from_pipe]]

```python
from_pipe(pipeline, **kwargs)
```

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

**Tham số:**

pipeline (`DiffusionPipeline`) : Pipeline gốc để tạo một pipeline mới.

**Trả về:** `DiffusionPipeline`

Một pipeline mới với cùng các trọng số và cấu hình như `pipeline`.

Tạo một pipeline mới từ một pipeline đã cho. Phương thức này hữu ích để tạo một pipeline mới từ các thành phần của pipeline hiện có mà không cần cấp phát thêm bộ nhớ.

Ví dụ:

```py
>>> from diffusers import StableDiffusionPipeline, StableDiffusionSAGPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> new_pipe = StableDiffusionSAGPipeline.from_pipe(pipe)
```

#### from_pretrained[[diffusers.DiffusionPipeline.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

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

**Tham số:**

pretrained_model_name_or_path (`str` hoặc `os.PathLike`, *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 trọng số pipeline đã được lưu bằng [save_pretrained()](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline.save_pretrained).

dtype (`torch.dtype` hoặc `dict[str, Union[str, torch.dtype]]`, *tùy chọn*) : Ghi đè `torch.dtype` mặc định và tải mô hình với một dtype khác. Để tải các mô hình con với các dtype khác nhau, hãy truyền một `dict` (ví dụ `{'transformer': torch.bfloat16, 'vae': torch.float16}`). Đặt dtype mặc định cho các thành phần không được chỉ định bằng `default` (ví dụ `{'transformer': torch.bfloat16, 'default': torch.float16}`). Nếu một thành phần không được chỉ định và không có default được đặt, `torch.float32` sẽ được sử dụng.

custom_pipeline (`str`, *optional*) : > [!WARNING] > 🧪 Đây là tính năng thử nghiệm và có thể thay đổi trong tương lai.  Có thể là:  - Một chuỗi, *repo id* (ví dụ `hf-internal-testing/diffusers-dummy-pipeline`) của một pipeline tùy chỉnh được lưu trữ trên Hub. Kho phải chứa một tệp có tên pipeline.py định nghĩa pipeline tùy chỉnh. - Một chuỗi, *tên tệp* của một pipeline cộng đồng được lưu trữ trên GitHub dưới [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Tên tệp hợp lệ phải khớp với tên tệp chứ không phải script pipeline (`clip_guided_stable_diffusion` thay vì `clip_guided_stable_diffusion.py`). Các pipeline cộng đồng luôn được tải từ nhánh main hiện tại của GitHub. - Đường dẫn đến một thư mục (`./my_pipeline_directory/`) chứa pipeline tùy chỉnh. Thư mục phải chứa một tệp có tên `pipeline.py` định nghĩa pipeline tùy chỉnh.  Để biết thêm thông tin về cách tải và tạo các pipeline tùy chỉnh, hãy xem [Tải và Thêm Pipeline Tùy Chỉnh](https://huggingface.co/docs/diffusers/using-diffusers/custom_pipeline_overview)

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 (`Union[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.

output_loading_info(`bool`, *tuỳ chọn*, mặc định là `False`) : Có trả về một từ điển chứa các khóa bị thiếu, các khóa không mong đợi và thông báo lỗi hay không.

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.

custom_revision (`str`, *tuỳ chọn*) : 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ẻ, hoặc id commit tương tự như `revision` khi tải một pipeline tùy chỉnh từ Hub. Mặc định là phiên bản 🤗 Diffusers ổn định mới nhất.

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.

device_map (`str`, *tùy chọn*) : Chiến lược quy định cách các thành phần khác nhau của pipeline nên được đặt trên các thiết bị khả dụng. Hiện tại, chỉ hỗ trợ `device_map` "balanced". Xem [đây](https://huggingface.co/docs/diffusers/main/en/tutorials/inference_with_big_models#device-placement) để biết thêm.

max_memory (`Dict`, *tùy chọn*) : Một từ điển định danh thiết bị cho bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng cho mỗi GPU và RAM CPU khả dụng.

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Đường dẫn để offload trọng số nếu device_map chứa giá trị `"disk"`.

offload_state_dict (`bool`, *tùy chọn*) : Nếu `True`, sẽ tạm thời offload state dict trên CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict trên CPU + shard lớn nhất của checkpoint không vừa. Mặc định là `True` khi có offload xuống đĩa.

low_cpu_mem_usage (`bool`, *tuỳ chọn*, mặc định là `True` nếu phiên bản torch >= 1.9.0, ngược lại là `False`) : Tăng tốc quá trình tải mô hình bằng cách chỉ tải các trọng số được huấn luyện trước và không khởi tạo các trọng số. Đồng thời, tham số này cũng cố gắng không sử dụng quá 1 lần kích thước mô hình trong bộ nhớ CPU (bao gồm cả bộ nhớ đỉnh) trong khi tải mô hình. Chỉ hỗ trợ cho PyTorch >= 1.9.0. Nếu bạn đang sử dụng phiên bản PyTorch cũ hơn, việc đặt tham số này thành `True` sẽ gây ra lỗi.

use_safetensors (`bool`, *tuỳ chọn*, mặc định là `None`) : Nếu được đặt thành `None`, các trọng số safetensors sẽ được tải xuống nếu chúng có sẵn **và** nếu thư viện safetensors đã được cài đặt. Nếu được đặt thành `True`, mô hình sẽ được tải bắt buộc từ các trọng số safetensors. Nếu được đặt thành `False`, các trọng số safetensors sẽ không được tải.

use_onnx (`bool`, *tùy chọn*, mặc định là `None`) : Nếu đặt thành `True`, trọng số ONNX sẽ luôn được tải xuống nếu có. Nếu đặt thành `False`, trọng số ONNX sẽ không bao giờ được tải xuống. Mặc định, `use_onnx` có giá trị mặc định là thuộc tính lớp `_is_onnx`, vốn là `False` đối với các pipeline không phải ONNX và `True` đối với các pipeline ONNX. Trọng số ONNX bao gồm cả các tệp kết thúc bằng `.onnx` và `.pb`.

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.

variant (`str`, *tùy chọn*) : Nạp trọng số từ tên tệp biến thể được chỉ định, chẳng hạn như `"fp16"` hoặc `"ema"`.

disable_mmap ('bool', *optional*, mặc định là 'False') : Có vô hiệu hóa mmap khi tải một 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, những nơi có thể không xử lý tốt tính chất truy cập ngẫu nhiên (seeky) của mmap.

Tạo một pipeline khuếch tán PyTorch từ trọng số pipeline được huấn luyện trước.

Pipeline được đặt ở chế độ đánh giá (`model.eval()`) theo mặc định.

Nếu bạn nhận được thông báo lỗi bên dưới, bạn cần tinh chỉnh trọng số cho tác vụ hạ nguồn của mình:

```
Some weights of UNet2DConditionModel were not initialized from the model checkpoint at stable-diffusion-v1-5/stable-diffusion-v1-5 and are newly initialized because the shapes did not match:
- conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
```

> [!TIP] > Để sử dụng các mô hình riêng tư hoặc [gated](https://huggingface.co/docs/hub/models-gated#gated-models), hãy đăng nhập
với `hf > auth login`.

Ví dụ:

```py
>>> from diffusers import DiffusionPipeline

>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = DiffusionPipeline.from_pretrained("CompVis/ldm-text2im-large-256")

>>> # Download pipeline that requires an authorization token
>>> # For more information on access tokens, please refer to this section
>>> # of the documentation](https://huggingface.co/docs/hub/security-tokens)
>>> pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")

>>> # Use a different scheduler
>>> from diffusers import LMSDiscreteScheduler

>>> scheduler = LMSDiscreteScheduler.from_config(pipeline.scheduler.config)
>>> pipeline.scheduler = scheduler
```

#### maybe_free_model_hooks[[diffusers.DiffusionPipeline.maybe_free_model_hooks]]

```python
maybe_free_model_hooks()
```

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

Phương thức thực hiện các bước sau:
- Tải xuống tất cả các thành phần.
- Xóa tất cả các model hook đã được thêm vào khi sử dụng `enable_model_cpu_offload`, sau đó áp dụng chúng lại. Trong trường hợp model chưa được offload, hàm này không thực hiện thao tác nào.
- Đặt lại các hook có trạng thái của các thành phần denoiser trong diffusers nếu chúng được thêm bằng `register_hook()`.

Hãy đảm bảo thêm hàm này vào cuối hàm `__call__` của pipeline của bạn để nó hoạt động chính xác khi áp dụng `enable_model_cpu_offload`.

#### numpy_to_pil[[diffusers.DiffusionPipeline.numpy_to_pil]]

```python
numpy_to_pil(images)
```

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

Chuyển đổi một ảnh NumPy hoặc một lô ảnh thành ảnh PIL.

#### remove_all_hooks[[diffusers.DiffusionPipeline.remove_all_hooks]]

```python
remove_all_hooks()
```

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

Xóa tất cả các hook đã được thêm vào khi sử dụng `enable_sequential_cpu_offload` hoặc `enable_model_cpu_offload`.

#### reset_device_map[[diffusers.DiffusionPipeline.reset_device_map]]

```python
reset_device_map()
```

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

Đặt lại các bản đồ thiết bị (nếu có) thành None.

#### save_pretrained[[diffusers.DiffusionPipeline.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str | None = None, push_to_hub: bool = False, use_flashpack: bool = False, **kwargs)
```

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

**Tham số:**

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

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.

variant (`str`, *tùy chọn*) : Nếu được chỉ định, trọng số sẽ được lưu ở định dạng `pytorch_model.<variant>.bin`.

max_shard_size (`int` hoặc `str`, mặc định là `None`) : Kích thước tối đa của một checkpoint trước khi được chia nhỏ. Các checkpoint sau khi chia nhỏ sẽ có kích thước nhỏ hơn mức này. Nếu biểu diễn dưới dạng chuỗi, cần là các chữ số theo sau bởi một đơn vị (ví dụ `"5GB"`). Nếu biểu diễn dưới dạng số nguyên, đơn vị là byte. Lưu ý rằng giới hạn này sẽ được giảm sau một khoảng thời gian nhất định (bắt đầu từ tháng 10 năm 2024) để cho phép người dùng nâng cấp lên phiên bản mới nhất của `diffusers`. Điều này nhằm thiết lập một kích thước mặc định chung cho tham số này giữa các thư viện khác nhau trong hệ sinh thái Hugging Face (ví dụ như `transformers` và `accelerate`).

push_to_hub (`bool`, *tùy chọn*, mặc định là `False`) : Có đẩy mô hình của bạn lên Hugging Face model hub sau khi lưu hay không. Bạn có thể chỉ định kho lưu trữ muốn đẩy đến bằng `repo_id` (mặc định sẽ là tên của `save_directory` trong namespace của bạn).

kwargs (`Dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung được truyền đến phương thức [push_to_hub()](/docs/diffusers/v0.43.0/vi/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Lưu tất cả các biến có thể lưu của pipeline vào một thư mục. Một biến của pipeline có thể được lưu và nạp lại nếu lớp của nó triển khai cả phương thức lưu và nạp. Pipeline có thể được nạp lại một cách dễ dàng bằng cách sử dụng phương thức lớp [from_pretrained()](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

#### diffusers.StableDiffusionMixin.enable_freeu[[diffusers.StableDiffusionMixin.enable_freeu]]

```python
diffusers.StableDiffusionMixin.enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

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

**Tham số:**

s1 (`float`) : Hệ số tỷ lệ cho giai đoạn 1 để làm suy giảm đóng góp của các đặc trưng skip. Việc này được thực hiện để giảm thiểu "hiệu ứng làm mịn quá mức" trong quá trình khử nhiễu được tăng cường.

s2 (`float`) : Hệ số tỷ lệ cho giai đoạn 2 để làm suy giảm đóng góp của các đặc trưng skip. Việc này được thực hiện để giảm thiểu "hiệu ứng làm mịn quá mức" trong quá trình khử nhiễu được tăng cường.

b1 (`float`) : Hệ số tỷ lệ cho giai đoạn 1 để khuếch đại đóng góp của các đặc trưng backbone.

b2 (`float`) : Hệ số tỷ lệ cho giai đoạn 2 để khuếch đại đóng góp của các đặc trưng backbone.

Bật cơ chế FreeU như trong https://huggingface.co/papers/2309.11497.

Các hậu tố sau các hệ số tỷ lệ đại diện cho các giai đoạn mà chúng được áp dụng.

Vui lòng tham khảo [kho mã nguồn chính thức](https://github.com/ChenyangSi/FreeU) để biết các tổ hợp giá trị được biết là hoạt động tốt cho các pipeline khác nhau như Stable Diffusion v1, v2 và Stable Diffusion XL.

#### diffusers.StableDiffusionMixin.disable_freeu[[diffusers.StableDiffusionMixin.disable_freeu]]

```python
diffusers.StableDiffusionMixin.disable_freeu()
```

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

Tắt cơ chế FreeU nếu đang được bật.

## PushToHubMixin[[diffusers.utils.PushToHubMixin]]

#### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]]

```python
diffusers.utils.PushToHubMixin()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491)

Một Mixin để đẩy mô hình, bộ lập lịch hoặc pipeline lên Hugging Face Hub.

#### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526)

**Tham số:**

repo_id (`str`) : Tên của kho mà bạn muốn đẩy các tệp mô hình, trình lập lịch hoặc pipeline của mình đến. Nó phải chứa tên tổ chức của bạn khi đẩy đến một tổ chức. `repo_id` cũng có thể là đường dẫn đến một thư mục cục bộ.

commit_message (`str`, *tùy chọn*) : Thông điệp để commit khi đẩy. Mặc định là `"Upload {object}"`.

private (`bool`, *tuỳ chọn*) : Có nên đặt kho thành riêng tư hay không. Nếu là `None` (mặc định), kho sẽ là công khai trừ khi mặc định của tổ chức là riêng tư. Giá trị này bị bỏ qua nếu kho đã tồn tại.

token (`str`, *tùy chọn*) : Token được sử dụng làm HTTP bearer authorization cho các tệp từ xa. Token được tạo ra khi chạy `hf auth login` (được lưu trong `~/.huggingface`).

create_pr (`bool`, *tùy chọn*, mặc định là `False`) : Có tạo PR với các tệp đã tải lên hoặc commit trực tiếp hay không.

safe_serialization (`bool`, *tùy chọn*, mặc định là `True`) : Có chuyển đổi trọng số mô hình sang định dạng `safetensors` hay không.

variant (`str`, *tùy chọn*) : Nếu được chỉ định, trọng số sẽ được lưu ở định dạng `pytorch_model.<variant>.bin`.

Tải tệp mô hình, trình lập lịch hoặc pipeline lên 🤗 Hugging Face Hub.

Ví dụ:

```python
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet")

# Push the `unet` to your namespace with the name "my-finetuned-unet".
unet.push_to_hub("my-finetuned-unet")

# Push the `unet` to an organization with the name "my-finetuned-unet".
unet.push_to_hub("your-org/my-finetuned-unet")
```

## Callbacks[[diffusers.callbacks.PipelineCallback]]

#### diffusers.callbacks.PipelineCallback[[diffusers.callbacks.PipelineCallback]]

```python
diffusers.callbacks.PipelineCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L7)

Lớp cơ sở cho tất cả các callback chính thức được sử dụng trong một pipeline. Lớp này cung cấp cấu trúc để triển khai các callback tùy chỉnh và đảm bảo rằng tất cả các callback đều có một giao diện nhất quán.

Hãy triển khai các phần sau: `tensor_inputs`: Phần này phải trả về một danh sách các đầu vào tensor cụ thể cho callback của bạn. 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. `callback_fn`: Phương thức này định nghĩa chức năng cốt lõi của callback của bạn.

#### diffusers.callbacks.SDCFGCutoffCallback[[diffusers.callbacks.SDCFGCutoffCallback]]

```python
diffusers.callbacks.SDCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L69)

Hàm callback cho các Pipeline Stable Diffusion. Sau một số bước nhất định (được đặt bởi `cutoff_step_ratio` hoặc `cutoff_step_index`), callback này sẽ tắt CFG.

Lưu ý: Callback này thay đổi pipeline bằng cách đặt thuộc tính `_guidance_scale` thành 0.0 sau bước cắt.

#### diffusers.callbacks.SDXLCFGCutoffCallback[[diffusers.callbacks.SDXLCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L98)

Hàm callback cho các Pipeline Stable Diffusion XL cơ bản. Sau một số bước nhất định (được đặt bởi `cutoff_step_ratio` hoặc `cutoff_step_index`), hàm callback này sẽ tắt CFG.

Lưu ý: Callback này thay đổi pipeline bằng cách đặt thuộc tính `_guidance_scale` thành 0.0 sau bước cắt.

#### diffusers.callbacks.SDXLControlnetCFGCutoffCallback[[diffusers.callbacks.SDXLControlnetCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLControlnetCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L140)

Hàm callback cho các Pipeline Controlnet Stable Diffusion XL. Sau một số bước nhất định (được đặt bởi `cutoff_step_ratio` hoặc `cutoff_step_index`), hàm callback này sẽ tắt CFG.

Lưu ý: Callback này thay đổi pipeline bằng cách đặt thuộc tính `_guidance_scale` thành 0.0 sau bước cắt.

#### diffusers.callbacks.IPAdapterScaleCutoffCallback[[diffusers.callbacks.IPAdapterScaleCutoffCallback]]

```python
diffusers.callbacks.IPAdapterScaleCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L188)

Hàm callback cho bất kỳ pipeline nào kế thừa `IPAdapterMixin`. Sau một số bước nhất định (được đặt bởi `cutoff_step_ratio` hoặc `cutoff_step_index`), callback này sẽ đặt thang đo IP Adapter thành `0.0`.

Lưu ý: Callback này thay đổi các bộ xử lý chú ý của IP Adapter bằng cách đặt scale thành 0.0 sau bước cutoff.

#### diffusers.callbacks.SD3CFGCutoffCallback[[diffusers.callbacks.SD3CFGCutoffCallback]]

```python
diffusers.callbacks.SD3CFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L212)

Hàm callback cho các Pipeline của Stable Diffusion 3. Sau một số bước nhất định (được đặt bởi `cutoff_step_ratio` hoặc `cutoff_step_index`), callback này sẽ tắt CFG.

Lưu ý: Callback này thay đổi pipeline bằng cách đặt thuộc tính `_guidance_scale` thành 0.0 sau bước cắt.