# Пайплайны

Pipelines предоставляют простой способ запуска передовых диффузионных моделей в режиме инференса, объединяя все необходимые компоненты (несколько независимо обученных моделей, планировщики и процессоры) в единый класс для сквозного выполнения. Pipelines гибки и могут быть адаптированы для использования различных планировщиков или даже компонентов моделей.

Все конвейеры создаются на основе базового класса [DiffusionPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline), который обеспечивает базовые функции загрузки, скачивания и сохранения всех компонентов. Конкретные типы конвейеров (например, [StableDiffusionPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)), загруженные с помощью [from_pretrained()](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained), определяются автоматически, а компоненты конвейера загружаются и передаются в функцию `__init__` конвейера.

> [!WARNING]
> Не следует использовать класс [DiffusionPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline) для обучения. Отдельные компоненты (например, [UNet2DModel](/docs/diffusers/v0.43.0/ru/api/models/unet2d#diffusers.UNet2DModel) и [UNet2DConditionModel](/docs/diffusers/v0.43.0/ru/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) диффузионных пайплайнов обычно обучаются по отдельности, поэтому мы рекомендуем работать с ними напрямую.
>
> 
>
> Pipelines не предоставляют никаких функций для обучения. Вы заметите, что autograd в PyTorch отключён, поскольку метод `__call__()` декорирован декоратором [`torch.no_grad`](https://pytorch.org/docs/stable/generated/torch.no_grad.html), так как pipelines не предназначены для обучения. Если вас интересует обучение, обратитесь к руководствам по [обучению](../../training/overview)!

Use **API > Pipelines** in the sidebar to browse all pipeline references by modality. For task-oriented workflows, start with the [Quickstart](../../quicktour) or a guide such as [text-to-image](../../using-diffusers/conditional_image_generation), [image-to-image](../../using-diffusers/img2img), [inpainting](../../using-diffusers/inpaint), or [video generation](../../using-diffusers/text-img2vid).

## DiffusionPipeline[[diffusers.DiffusionPipeline]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L198)

Базовый класс для всех конвейеров.

[DiffusionPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline) хранит все компоненты (модели, планировщики и процессоры) для диффузионных пайплайнов и предоставляет методы для загрузки, скачивания и сохранения моделей. Он также включает методы для:

- переместить все модули PyTorch на устройство по вашему выбору
- включить/отключить индикатор прогресса для итераций шумоподавления

Атрибуты класса:

- **config_name** (`str`) -- Имя файла конфигурации, в котором хранятся имена классов и модулей всех компонентов диффузионного конвейера.
- **_optional_components** (`List[str]`) -- список всех необязательных компонентов, которые не обязательно передавать в pipeline для его работы (должен быть переопределён в подклассах).

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

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

Вызовите self как функцию.

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

```python
device()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L600)

**Возвращает:** `torch.device`

Устройство torch, на котором размещён конвейер. Если компоненты распределены по разным устройствам (например, текстовые энкодеры работают на CPU, а базовая модель денуайзинга — на ускорителе), возвращается устройство ускорителя.

#### к[[diffusers.DiffusionPipeline.to]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L397)

**Параметры:**

dtype (`torch.dtype`, *необязательный*) : Возвращает конвейер с указанным [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)

device (`torch.Device`, *необязательный*) : Возвращает конвейер с указанным [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device)

silence_dtype_warnings (`str`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать предупреждения, если целевой `dtype` несовместим с целевым `device`.

**Возвращает:** [DiffusionPipeline](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline)

Пайплайн преобразован в указанный `dtype` и/или `dtype`.

Выполняет преобразование dtype и/или device для Pipeline. Значения torch.dtype и torch.device выводятся из аргументов `self.to(*args, **kwargs).`

> [!TIP] > Если у конвейера уже есть правильные torch.dtype и torch.device, он возвращается без изменений.
В противном случае > возвращаемый конвейер является копией self с требуемыми torch.dtype и torch.device.

Способы вызова `to`:

- `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` для возврата пайплайна с указанным [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)
- `to(device, silence_dtype_warnings=False) → DiffusionPipeline` для возврата пайплайна с указанным [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device)
- `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` возвращает пайплайн с указанными [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) и [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)

#### компоненты[[diffusers.DiffusionPipeline.components]]

```python
components()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1907)

Свойство `self.components` может быть полезно для запуска разных конвейеров с одними и теми же весами и конфигурациями без выделения дополнительной памяти.

Returns (`dict`): словарь, содержащий все модули, необходимые для инициализации конвейера.

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)

Отключает вычисление внимания с нарезкой. Если `enable_attention_slicing` был вызван ранее, внимание вычисляется за один шаг.

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

```python
disable_xformers_memory_efficient_attention()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)

Отключить энергоэффективное внимание из [xFormers](https://facebookresearch.github.io/xformers/).

#### загрузить[[diffusers.DiffusionPipeline.download]]

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1483)

**Параметры:**

pretrained_model_name (`str` или `os.PathLike`, *необязательный*) : строка, *идентификатор репозитория* (например, `CompVis/ldm-text2im-large-256`) предобученного пайплайна, размещенного на Hub.

custom_pipeline (`str`, *optional*) : Может принимать одно из следующих значений:  - Строка, *repository id* (например, `CompVis/ldm-text2im-large-256`) предобученного пайплайна, размещенного на Hub. Репозиторий должен содержать файл `pipeline.py`, в котором определяется пользовательский пайплайн.  - Строка, *file name* пайплайна сообщества, размещенного на GitHub в разделе [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Допустимые имена файлов должны соответствовать имени файла, а не имени скрипта пайплайна (`clip_guided_stable_diffusion`, а не `clip_guided_stable_diffusion.py`). Пайплайны сообщества всегда загружаются из текущей ветки `main` на GitHub.  - Путь к *directory* (`./my_pipeline_directory/`), содержащему пользовательский пайплайн. В каталоге должен находиться файл `pipeline.py`, определяющий пользовательский пайплайн.  > [!WARNING] > 🧪 Это экспериментальная функция, которая может измениться в будущем.  Чтобы узнать больше о загрузке и создании пользовательских пайплайнов, ознакомьтесь с разделом [How to contribute a community pipeline](https://huggingface.co/docs/diffusers/main/en/using-diffusers/contribute_pipeline).

force_download (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли принудительно (пере)скачивать веса модели и файлы конфигурации, заменяя кэшированные версии, если они существуют.

proxies (`Dict[str, str]`, *необязательный*) : Словарь прокси-серверов, используемых по протоколу или конечной точке, например, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Прокси используются при каждом запросе.

output_loading_info(`bool`, *необязательный*, по умолчанию `False`) : Нужно ли также возвращать словарь, содержащий отсутствующие ключи, неожиданные ключи и сообщения об ошибках.

local_files_only (`bool`, *необязательный*, по умолчанию `False`) : Загружать только локальные веса модели и файлы конфигурации или нет. Если установлено в `True`, модель не будет скачана с Hub.

token (`str` или *bool*, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если `True`, используется токен, сгенерированный командой `diffusers-cli login` (сохранённый в `~/.huggingface`).

revision (`str`, *необязательный*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Может быть именем ветки, именем тега, идентификатором коммита или любым другим идентификатором, поддерживаемым Git.

custom_revision (`str`, *optional*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, аналогично `revision` при загрузке пользовательского конвейера из Hub. Это может быть версия 🤗 Diffusers при загрузке пользовательского конвейера из GitHub, в противном случае по умолчанию используется `"main"` при загрузке из Hub.

mirror (`str`, *необязательный*) : Зеркальный источник для решения проблем с доступностью при загрузке модели в Китае. Мы не гарантируем актуальность или безопасность источника, поэтому за дополнительной информацией обращайтесь на сайт зеркала.

variant (`str`, *необязательный*) : Загружает веса из файла с указанным вариантом имени, например `"fp16"` или `"ema"`.

use_safetensors (`bool`, *необязательный*, по умолчанию `None`) : Если установлено в `None`, веса safetensors загружаются, если они доступны **и** если библиотека safetensors установлена. Если установлено в `True`, модель принудительно загружается из весов safetensors. Если установлено в `False`, веса safetensors не загружаются.

use_onnx (`bool`, *необязательный*, по умолчанию `False`) : Если установлено в `True`, веса ONNX всегда будут загружаться, если они присутствуют. Если установлено в `False`, веса ONNX никогда не будут загружаться. По умолчанию `use_onnx` принимает значение атрибута класса `_is_onnx`, которое равно `False` для не-ONNX конвейеров и `True` для ONNX конвейеров. К весам ONNX относятся как файлы, заканчивающиеся на `.onnx`, так и на `.pb`.

trust_remote_code (`bool`, *необязательный*, по умолчанию `False`) : Разрешает ли использование пользовательских конвейеров и компонентов, определённых на Hub в отдельных файлах. Этот параметр следует устанавливать в `True` только для репозиториев, которым вы доверяете и код которых вы изучили, поскольку это приведёт к выполнению кода с Hub на вашем локальном компьютере.

use_flashpack (`bool`, *необязательный*, по умолчанию `False`) : Если установлено в `True`, веса FlashPack всегда будут загружаться, если они присутствуют. Если установлено в `False`, веса FlashPack никогда не будут загружаться.

**Возвращает:** `os.PathLike`

Путь к загруженной конвейерной модели.

Загрузите и закэшируйте PyTorch diffusion pipeline из предобученных весов pipeline.

> [!TIP] > Для использования частных или [gated models](https://huggingface.co/docs/hub/models-gated#gated-models) выполните вход
с `hf > auth login

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)

**Параметры:**

slice_size (`str` или `int`, *необязательный*, по умолчанию `"auto"`) : Если указано `"auto"`, вход для головок внимания делится пополам, и внимание вычисляется в два этапа. Если указано `"max"`, для экономии максимального объёма памяти выполняется по одному срезу за раз. Если указано число, используется столько срезов, сколько получается от `attention_head_dim // slice_size`. В этом случае `attention_head_dim` должно быть кратным `slice_size`.

Включает послойный вычисление внимания. При включении этого параметра модуль внимания разбивает входной тензор на фрагменты для вычисления внимания в несколько шагов. Если используется более одной головы внимания, вычисления выполняются последовательно для каждой головы. Это полезно для экономии памяти ценой небольшого снижения скорости.

> [!WARNING] > ⚠️ Не включайте нарезку внимания, если вы уже используете `scaled_dot_product_attention` (SDPA)
из PyTorch > 2.0 или xFormers. Эти вычисления внимания уже очень экономны по памяти, поэтому вам не нужно включать > эту функцию. Если вы включите нарезку внимания (attention slicing) с SDPA или xFormers, это может привести к серьезному замедлению!

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1343)

**Параметры:**

onload_device (`torch.device`) : Устройство, на котором загружена группа модулей.

offload_device (`torch.device`, по умолчанию `torch.device("cpu")`) : Устройство, на которое выгружается группа модулей. Обычно это должно быть CPU. По умолчанию — CPU.

offload_type (`str` или `GroupOffloadingType`, по умолчанию "block_level") : Тип применяемого выгрузки. Может быть "block_level" или "leaf_level". По умолчанию "block_level".

offload_to_disk_path (`str`, *необязательный*, по умолчанию `None`) : Путь к каталогу, в который будут выгружаться параметры. Установка этого параметра может быть полезна в условиях ограниченной оперативной памяти, когда требуется разумный компромисс между скоростью и потреблением памяти.

num_blocks_per_group (`int`, *optional*) : количество блоков в группе при использовании offload_type="block_level". Это значение обязательно при использовании offload_type="block_level".

non_blocking (`bool`, по умолчанию `False`) : Если True, выгрузка и загрузка данных выполняются с неблокирующей передачей.

use_stream (`bool`, по умолчанию `False`) : Если True, выгрузка и загрузка выполняются асинхронно с использованием CUDA-потока. Это может быть полезно для перекрытия вычислений и передачи данных.

record_stream (`bool`, по умолчанию `False`) : При включении вместе с `use_stream` помечает текущий тензор как использованный этим потоком. Работает быстрее за счёт немного большего потребления памяти. Подробности см. в [официальной документации PyTorch](https://pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html).

low_cpu_mem_usage (`bool`, по умолчанию `False`) : Если установлено в True, использование памяти CPU минимизируется за счёт закрепления тензоров на лету, а не их предварительного закрепления. Этот параметр имеет значение только при использовании потоковой разгрузки на CPU (т. е. `use_stream=True`). Это может быть полезно, когда память CPU является узким местом, но может нивелировать преимущества использования потоков.

exclude_modules (`Union[str, List[str]]`, по умолчанию `None`) : Список модулей, которые следует исключить из offloading.

Применяет групповую разгрузку (group offloading) для внутренних слоёв модуля torch.nn.Module. Чтобы понять, что такое групповая разгрузка и в каких случаях она полезна, сначала нужно дать некоторый контекст о том, как работают другие поддерживаемые методы разгрузки.

Как правило, выгрузка выполняется на двух уровнях:
- На уровне модуля: в Diffusers это можно включить с помощью метода `ModelMixin::enable_model_cpu_offload()`. Он
работает за счёт выгрузки каждого компонента конвейера на CPU для хранения и загрузки на устройство ускорителя по мере необходимости для вычислений. Этот метод более эффективен с точки зрения памяти, чем хранение всех компонентов на ускорителе, однако требования к памяти остаются довольно высокими. Для работы этого метода требуется объём памяти, эквивалентный размеру модели в рабочем типе данных (runtime dtype) + размеру крупнейших промежуточных тензоров активаций, чтобы завершить прямой проход (forward pass).
- Уровень отдельных компонентов: в Diffusers это можно включить с помощью метода `ModelMixin::enable_sequential_cpu_offload()`. Он
работает за счёт выгрузки параметров нижнего уровня вычислительного графа на CPU для хранения и загрузки только этих параметров на ускоритель для вычислений. Этот режим использует минимальное количество памяти ускорителя, но может работать медленнее из-за избыточного количества синхронизаций устройств.

Групповое выгружение представляет собой промежуточный вариант между двумя методами. Оно работает путём выгрузки групп внутренних слоёв (либо `torch.nn.ModuleList`, либо `torch.nn.Sequential`). Этот метод потребляет меньше памяти, чем выгружение на уровне модулей. Он также быстрее, чем выгружение на уровне листьев/последовательное выгружение, поскольку уменьшается количество синхронизаций устройств.

Ещё одна поддерживаемая функция (для CUDA-устройств с поддержкой потоков асинхронной передачи данных) — возможность перекрывать передачу данных и вычисления, чтобы сократить общее время выполнения по сравнению с последовательным offloading. Это реализуется с помощью предварительной загрузки слоёв (layer prefetching) с использованием потоков: слой, который будет выполнен следующим, начинает onloading на ускорительное устройство, пока выполняется текущий слой, — это немного увеличивает требования к памяти. Обратите внимание, что данная реализация также поддерживает offloading на уровне листьев (leaf-level), но может стать значительно быстрее при использовании потоков.

Пример:
```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)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1152)

**Параметры:**

gpu_id (`int`, *optional*) : Идентификатор ускорителя, который будет использоваться при выводе. Если не указан, по умолчанию используется 0.

device (`torch.Device` или `str`, *необязательный*, по умолчанию None) : Тип устройства PyTorch для ускорителя, который будет использоваться при выводе. Если не указан, доступный ускоритель будет обнаружен и использован автоматически.

Переносит все модели на CPU с помощью accelerate, снижая потребление памяти с минимальным влиянием на производительность. В отличие от `enable_sequential_cpu_offload`, этот метод перемещает на акселератор целую модель за раз в момент вызова её метода `forward`, и модель остаётся на акселераторе до запуска следующей модели. Экономия памяти меньше, чем при использовании `enable_sequential_cpu_offload`, но производительность значительно выше благодаря итеративному выполнению `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)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1273)

**Параметры:**

gpu_id (`int`, *optional*) : Идентификатор ускорителя, который будет использоваться при выводе. Если не указан, по умолчанию используется 0.

device (`torch.Device` или `str`, *необязательный*, по умолчанию None) : Тип устройства PyTorch для ускорителя, который будет использоваться при выводе. Если не указан, доступный ускоритель будет обнаружен и использован автоматически.

Выгружает все модели на CPU с помощью 🤗 Accelerate, что значительно снижает потребление памяти. При вызове state dicts всех компонентов `torch.nn.Module` (кроме тех, что находятся в `self._exclude_from_cpu_offload`) сохраняются на CPU, затем перемещаются на `torch.device('meta')` и загружаются на accelerator только тогда, когда у конкретного подмодуля вызывается его метод `forward`. Выгрузка происходит на уровне подмодулей. Экономия памяти выше, чем при использовании `enable_model_cpu_offload`, но производительность ниже.

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**Параметры:**

attention_op (`Callable`, *необязательный*) : Переопределяет оператор по умолчанию `None` для использования в качестве аргумента `op` функции [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) xFormers.

Включить энергоэффективное внимание от [xFormers](https://facebookresearch.github.io/xformers/). При включении этого параметра следует ожидать снижение потребления памяти GPU и возможное ускорение во время инференса. Ускорение во время обучения не гарантируется.

> [!WARNING] > ⚠️ Если включены и memory efficient attention, и sliced attention, memory efficient
attention имеет > приоритет.

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2083)

**Параметры:**

pipeline (`DiffusionPipeline`) : конвейер, на основе которого будет создан новый конвейер.

**Возвращает:** `DiffusionPipeline`

Новый конвейер с теми же весами и конфигурациями, что и у `pipeline`.

Создайте новый конвейер на основе заданного конвейера. Этот метод полезен для создания нового конвейера из компонентов существующего конвейера без выделения дополнительной памяти.

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L638)

**Параметры:**

pretrained_model_name_or_path (`str` или `os.PathLike`, *необязательный*) : Может быть одним из:  - строка, *repo id* (например, `CompVis/ldm-text2im-large-256`) предобученного пайплайна, размещенного на Hub. - путь к *каталогу* (например, `./my_pipeline_directory/`), содержащему веса пайплайна, сохраненные с помощью [save_pretrained()](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline.save_pretrained).

dtype (`torch.dtype` или `dict[str, Union[str, torch.dtype]]`, *необязательный*) : Переопределяет стандартный `torch.dtype` и загружает модель с другим dtype. Чтобы загрузить подмодели с разными dtype, передайте `dict` (например, `{'transformer': torch.bfloat16, 'vae': torch.float16}`). Установите стандартный dtype для не указанных компонентов с помощью `default` (например, `{'transformer': torch.bfloat16, 'default': torch.float16}`). Если компонент не указан и стандартный dtype не задан, используется `torch.float32`.

custom_pipeline (`str`, *optional*) : > [!WARNING] > 🧪 Это экспериментальная функция, которая может измениться в будущем.  Может принимать одно из значений:  - Строка, *repo id* (например, `hf-internal-testing/diffusers-dummy-pipeline`) пользовательского пайплайна, размещённого на Hub. Репозиторий должен содержать файл pipeline.py, в котором определяется пользовательский пайплайн. - Строка, *file name* пайплайна сообщества, размещённого на GitHub в разделе [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Допустимые имена файлов должны соответствовать имени файла, а не имени скрипта пайплайна (`clip_guided_stable_diffusion`, а не `clip_guided_stable_diffusion.py`). Пайплайны сообщества всегда загружаются из текущей ветки main на GitHub. - Путь к каталогу (`./my_pipeline_directory/`), содержащему пользовательский пайплайн. В каталоге должен находиться файл `pipeline.py`, определяющий пользовательский пайплайн.  Подробнее о загрузке и создании пользовательских пайплайнов см. в разделе [Loading and Adding Custom Pipelines](https://huggingface.co/docs/diffusers/using-diffusers/custom_pipeline_overview)

force_download (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли принудительно (пере)скачивать веса модели и файлы конфигурации, заменяя кэшированные версии, если они существуют.

cache_dir (`Union[str, os.PathLike]`, *необязательный*) : Путь к каталогу, в котором кэшируется конфигурация загруженной предобученной модели, если стандартный кэш не используется.

proxies (`Dict[str, str]`, *необязательный*) : Словарь прокси-серверов, используемых по протоколу или конечной точке, например, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Прокси используются при каждом запросе.

output_loading_info(`bool`, *необязательный*, по умолчанию `False`) : Нужно ли также возвращать словарь, содержащий отсутствующие ключи, неожиданные ключи и сообщения об ошибках.

local_files_only (`bool`, *необязательный*, по умолчанию `False`) : Загружать только локальные веса модели и файлы конфигурации или нет. Если установлено в `True`, модель не будет скачана с Hub.

token (`str` или *bool*, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если `True`, используется токен, сгенерированный командой `diffusers-cli login` (сохранённый в `~/.huggingface`).

revision (`str`, *необязательный*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Может быть именем ветки, именем тега, идентификатором коммита или любым другим идентификатором, поддерживаемым Git.

custom_revision (`str`, *optional*) : Конкретная версия модели для использования. Может быть именем ветки, именем тега или идентификатором коммита, аналогично `revision` при загрузке пользовательского пайплайна с Hub. По умолчанию используется последняя стабильная версия 🤗 Diffusers.

mirror (`str`, *необязательный*) : Зеркальный источник для решения проблем с доступностью при загрузке модели в Китае. Мы не гарантируем актуальность или безопасность источника, поэтому за дополнительной информацией обращайтесь на сайт зеркала.

device_map (`str`, *необязательный*) : Стратегия, определяющая, как различные компоненты конвейера должны распределяться по доступным устройствам. В настоящее время поддерживается только «сбалансированная» `device_map`. Подробнее см. [здесь](https://huggingface.co/docs/diffusers/main/en/tutorials/inference_with_big_models#device-placement).

max_memory (`Dict`, *необязательный*) : Словарь идентификаторов устройств для максимальной памяти. Если не задано, по умолчанию используется максимальная доступная память для каждого GPU и доступная оперативная память CPU.

offload_folder (`str` или `os.PathLike`, *необязательный*) : Путь для выгрузки весов, если device_map содержит значение `"disk"`.

offload_state_dict (`bool`, *необязательный*) : Если `True`, состояние CPU state dict временно выгружается на диск, чтобы избежать нехватки оперативной памяти CPU, если вес CPU state dict и крупнейший фрагмент контрольной точки не помещаются в неё. По умолчанию `True`, если используется выгрузка на диск.

low_cpu_mem_usage (`bool`, *необязательный*, по умолчанию `True`, если версия torch >= 1.9.0, иначе `False`) : Ускоряет загрузку модели, загружая только предобученные веса и не инициализируя их. Также это позволяет не использовать больше 1x размера модели в оперативной памяти (включая пиковое потребление) при загрузке модели. Поддерживается только для PyTorch >= 1.9.0. Если вы используете более старую версию PyTorch, установка этого аргумента в `True` вызовет ошибку.

use_safetensors (`bool`, *необязательный*, по умолчанию `None`) : Если установлено в `None`, веса safetensors загружаются, если они доступны **и** если библиотека safetensors установлена. Если установлено в `True`, модель принудительно загружается из весов safetensors. Если установлено в `False`, веса safetensors не загружаются.

use_onnx (`bool`, *необязательный*, по умолчанию `None`) : Если установлено в `True`, веса ONNX всегда будут загружаться, если они присутствуют. Если установлено в `False`, веса ONNX никогда не будут загружаться. По умолчанию `use_onnx` принимает значение атрибута класса `_is_onnx`, которое равно `False` для не-ONNX конвейеров и `True` для ONNX конвейеров. К весам ONNX относятся как файлы, заканчивающиеся на `.onnx`, так и на `.pb`.

kwargs (остаточный словарь аргументов с ключами, *необязательный*) : может использоваться для переопределения переменных загрузки и сохранения (компонентов конвейера конкретного класса конвейера). Переопределённые компоненты передаются непосредственно в метод `__init__` конвейера. См. пример ниже для получения дополнительной информации.

variant (`str`, *необязательный*) : Загружает веса из файла с указанным вариантом имени, например `"fp16"` или `"ema"`.

disable_mmap ('bool', *optional*, по умолчанию 'False') : Отключает ли использование mmap при загрузке модели Safetensors. Этот параметр может обеспечить лучшую производительность, если модель находится на сетевом диске или жёстком диске, которые могут плохо справляться с частыми операциями перемотки, характерными для mmap.

Создайте пайплайн диффузии PyTorch из предобученных весов пайплайна.

По умолчанию пайплайн устанавливается в режим оценки (`model.eval()`).

Если вы получаете сообщение об ошибке, приведённое ниже, вам необходимо дообучить веса для вашей целевой задачи:

```
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] > Для использования частных или [gated](https://huggingface.co/docs/hub/models-gated#gated-models) моделей выполните вход
с помощью `hf > auth login`.

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1250)

Метод, выполняющий следующие действия:
- Выгружает все компоненты.
- Удаляет все хуки модели, добавленные при использовании `enable_model_cpu_offload`, и затем применяет их снова. Если модель не была выгружена, эта функция ничего не делает.
- Сбрасывает хуки с состоянием компонентов denoiser в diffusers, если они были добавлены с помощью `register_hook()`.

Убедитесь, что вы добавили эту функцию в конец функции `__call__` вашего конвейера, чтобы он корректно работал при применении `enable_model_cpu_offload`.

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

```python
numpy_to_pil(images)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1945)

Преобразование изображения NumPy или пакета изображений в изображение PIL.

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

```python
remove_all_hooks()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1143)

Удаляет все хуки, добавленные при использовании `enable_sequential_cpu_offload` или `enable_model_cpu_offload`.

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

```python
reset_device_map()
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1470)

Сбрасывает карты устройств (если они есть) в 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)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L254)

**Параметры:**

save_directory (`str` или `os.PathLike`) : Каталог для сохранения конвейера. Будет создан, если не существует.

safe_serialization (`bool`, *необязательный*, по умолчанию `True`) : Сохранять ли модель с помощью `safetensors` или традиционным способом PyTorch с использованием `pickle`.

variant (`str`, *необязательный*) : Если указано, веса сохраняются в формате `pytorch_model.<variant>.bin`.

max_shard_size (`int` или `str`, по умолчанию `None`) : Максимальный размер контрольной точки перед её разбиением на части. Каждая часть контрольной точки будет иметь размер, меньший этого значения. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"5GB"`). Если значение указано в виде целого числа, единицей измерения являются байты. Обратите внимание, что это ограничение будет уменьшено через определённый период времени (начиная с октября 2024 года), чтобы пользователи могли перейти на последнюю версию `diffusers`. Это делается для установления общего значения по умолчанию для этого аргумента в разных библиотеках экосистемы Hugging Face (например, `transformers` и `accelerate`).

push_to_hub (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли после сохранения модели отправить её в репозиторий моделей Hugging Face. Репозиторий, в который нужно отправить модель, можно указать с помощью `repo_id` (по умолчанию используется имя `save_directory` в вашем пространстве имён).

kwargs (`Dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод [push_to_hub()](/docs/diffusers/v0.43.0/ru/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Сохраните все сохраняемые переменные конвейера в каталог. Переменную конвейера можно сохранить и загрузить, если её класс реализует как метод сохранения, так и метод загрузки. Конвейер легко перезагружается с помощью метода класса [from_pretrained()](/docs/diffusers/v0.43.0/ru/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)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Параметры:**

s1 (`float`) : Коэффициент масштабирования для этапа 1, ослабляющий вклад признаков пропуска. Это делается для смягчения «эффекта чрезмерного сглаживания» в процессе улучшенного шумоподавления.

s2 (`float`) : Коэффициент масштабирования для этапа 2, ослабляющий вклад признаков пропуска. Это делается для смягчения «эффекта чрезмерного сглаживания» в процессе улучшенного шумоподавления.

b1 (`float`) : Коэффициент масштабирования для этапа 1, усиливающий вклад признаков базовой модели.

b2 (`float`) : Коэффициент масштабирования для этапа 2, усиливающий вклад признаков базовой модели.

Включает механизм FreeU, как описано в https://huggingface.co/papers/2309.11497.

Суффиксы после коэффициентов масштабирования обозначают этапы, на которых они применяются.

Сочетания значений, которые хорошо работают для различных пайплайнов, таких как Stable Diffusion v1, v2 и Stable Diffusion XL, приведены в [официальном репозитории](https://github.com/ChenyangSi/FreeU).

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2289)

Отключает механизм FreeU, если он включен.

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

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491)

Миксин для загрузки модели, планировщика или конвейера на 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)
```

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526)

**Параметры:**

repo_id (`str`) : Имя репозитория, в который вы хотите загрузить файлы модели, планировщика или конвейера. При загрузке в организацию оно должно содержать имя вашей организации. `repo_id` также может быть путём к локальному каталогу.

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию `"Upload {object}"`.

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`str`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Токен, создаваемый при выполнении `hf auth login` (хранится в `~/.huggingface`).

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

safe_serialization (`bool`, *необязательный*, по умолчанию `True`) : Преобразовывать ли веса модели в формат `safetensors`.

variant (`str`, *необязательный*) : Если указано, веса сохраняются в формате `pytorch_model.<variant>.bin`.

Загрузите файлы модели, планировщика или конвейера в 🤗 Hugging Face Hub.

Примеры:

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

## Обработчики событий[[diffusers.callbacks.PipelineCallback]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L7)

Базовый класс для всех официальных колбэков, используемых в конвейере. Этот класс обеспечивает структуру для реализации пользовательских колбэков и гарантирует, что все колбэки имеют согласованный интерфейс.

Реализуйте следующее: `tensor_inputs`: этот метод должен возвращать список тензорных входных данных, специфичных для вашего обратного вызова. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса конвейера. `callback_fn`: этот метод определяет основную функциональность вашего обратного вызова.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L69)

Функция обратного вызова для конвейеров Stable Diffusion. После определённого количества шагов (заданного параметром `cutoff_step_ratio` или `cutoff_step_index`) эта функция отключает CFG.

Примечание: этот колбэк изменяет пайплайн, устанавливая атрибут `_guidance_scale` в 0.0 после шага отсечения.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L98)

Функция обратного вызова для базовых пайплайнов Stable Diffusion XL. После определённого количества шагов (заданного параметром `cutoff_step_ratio` или `cutoff_step_index`) эта функция отключает CFG.

Примечание: этот колбэк изменяет пайплайн, устанавливая атрибут `_guidance_scale` в 0.0 после шага отсечения.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L140)

Функция обратного вызова для пайплайнов Controlnet Stable Diffusion XL. После определённого количества шагов (заданного параметром `cutoff_step_ratio` или `cutoff_step_index`) эта функция отключает CFG.

Примечание: этот колбэк изменяет пайплайн, устанавливая атрибут `_guidance_scale` в 0.0 после шага отсечения.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L188)

Функция обратного вызова для любого конвейера, наследующего `IPAdapterMixin`. После определённого количества шагов (заданного параметрами `cutoff_step_ratio` или `cutoff_step_index`) эта функция обратного вызова установит масштаб IP Adapter в `0.0`.

Note: Этот callback изменяет процессоры внимания IP Adapter, устанавливая масштаб в 0.0 после шага отсечения.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L212)

Функция обратного вызова для пайплайнов Stable Diffusion 3. После определённого количества шагов (заданного параметром `cutoff_step_ratio` или `cutoff_step_index`) эта функция отключает CFG.

Примечание: этот колбэк изменяет пайплайн, устанавливая атрибут `_guidance_scale` в 0.0 после шага отсечения.