# Изображение в изображение

  

Модель Stable Diffusion также может использоваться для генерации изображений по изображению: для этого передаются текстовый промпт и исходное изображение, которые задают условия для создания новых изображений.

[StableDiffusionImg2ImgPipeline](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/img2img#diffusers.StableDiffusionImg2ImgPipeline) использует механизм диффузионного шумоподавления, предложенный в статье [SDEdit: Guided Image Synthesis and Editing with Stochastic Differential Equations](https://huggingface.co/papers/2108.01073) авторов Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, Stefano Ermon.

Аннотация из статьи:

*Направляемый синтез изображений позволяет обычным пользователям создавать и редактировать фотореалистичные изображения с минимальными усилиями. Ключевая задача заключается в балансе между верностью вводу пользователя (например, нарисованным от руки цветным штрихам) и реализмом синтезированного изображения. Существующие методы на основе GAN пытаются достичь такого баланса с помощью условных GAN или инверсий GAN, что является сложной задачей и часто требует дополнительных обучающих данных или функций потерь для отдельных приложений. Для решения этих проблем мы предлагаем новый метод синтеза и редактирования изображений, Stochastic Differential Editing (SDEdit), основанный на генеративном априорном распределении диффузионной модели, который синтезирует реалистичные изображения путем итеративного удаления шума через стохастическое дифференциальное уравнение (SDE). Получив входное изображение с направляющим элементом пользователя любого типа, SDEdit сначала добавляет шум к входу, а затем последовательно удаляет шум из полученного изображения через SDE-априорное распределение, чтобы повысить его реализм. SDEdit не требует обучения под конкретную задачу или инверсий и может естественным образом достичь баланса между реализмом и верностью. Согласно исследованию человеческого восприятия, SDEdit значительно превосходит передовые методы на основе GAN на 98,09% по показателю реализма и на 91,72% по общему уровню удовлетворенности на нескольких задачах, включая синтез и редактирование изображений на основе штрихов, а также композицию изображений.*

> [!TIP]
> Обязательно ознакомьтесь с разделом [Советы](overview#tips) по Stable Diffusion, чтобы узнать, как исследовать баланс между скоростью и качеством планировщика, а также как эффективно переиспользовать компоненты конвейера!

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L182)

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

vae ([AutoencoderKL](/docs/diffusers/main/ru/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Модель вариационного автоэнкодера (VAE) для кодирования изображений в латентные представления и декодирования из них.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : замороженный текстовый энкодер ([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)) : `CLIPTokenizer` для токенизации текста.

unet ([UNet2DConditionModel](/docs/diffusers/main/ru/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : `UNet2DConditionModel` для удаления шума из закодированных латентов изображения.

scheduler ([SchedulerMixin](/docs/diffusers/main/ru/api/schedulers/overview#diffusers.SchedulerMixin)) : планировщик, используемый в сочетании с `unet` для удаления шума из закодированных латентов изображения. Может быть одним из [DDIMScheduler](/docs/diffusers/main/ru/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/ru/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) или [PNDMScheduler](/docs/diffusers/main/ru/api/schedulers/pndm#diffusers.PNDMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : модуль классификации, оценивающий, могут ли сгенерированные изображения считаться оскорбительными или вредными. Подробности о потенциальных рисках модели см. в [карточке модели](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5).

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : экземпляр `CLIPImageProcessor` для извлечения признаков из сгенерированных изображений; используется в качестве входных данных для `safety_checker`.

Pipeline для генерации изображений по текстовому описанию с использованием Stable Diffusion.

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

Пайплайн также наследует следующие методы загрузки:
- [load_textual_inversion()](/docs/diffusers/main/ru/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) для загрузки эмбеддингов текстовой инверсии
- [load_lora_weights()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) для загрузки весов LoRA
- [save_lora_weights()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) для сохранения весов LoRA
- [from_single_file()](/docs/diffusers/main/ru/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) для загрузки файлов `.ckpt`
- [load_ip_adapter()](/docs/diffusers/main/ru/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) для загрузки IP-адаптеров

#### __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[int] = None, sigmas: list[float] = 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[str] = ['latents'], **kwargs)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L858)

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

prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты для управления генерацией изображения. Если не задан, необходимо передать `prompt_embeds`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` или `list[np.ndarray]`) : `Image`, массив numpy или тензор, представляющие пакет изображений, который будет использоваться в качестве начальной точки. Для массивов numpy и тензоров pytorch ожидаемый диапазон значений составляет `[0, 1]`. Если передается тензор или список тензоров, ожидаемая форма должна быть `(B, C, H, W)` или `(C, H, W)`. Если передается массив numpy или список массивов, ожидаемая форма должна быть `(B, H, W, C)` или `(H, W, C)`. Также можно передавать латенты изображений в качестве `image`, но при прямой передаче латентов они не кодируются повторно.

strength (`float`, *optional*, по умолчанию 0.8) : Определяет степень трансформации исходного `image`. Значение должно быть в диапазоне от 0 до 1. `image` используется как отправная точка, и чем выше `strength`, тем больше шума добавляется. Количество шагов денойзинга зависит от количества шума, добавленного изначально. Когда `strength` равно 1, добавляется максимальное количество шума, и процесс денойзинга выполняется в течение полного числа итераций, указанного в `num_inference_steps`. Значение 1 фактически игнорирует `image`.

num_inference_steps (`int`, *optional*, по умолчанию 50) : Количество шагов денойзинга. Как правило, большее число шагов денойзинга приводит к изображению более высокого качества, но за счёт более медленного вывода. Этот параметр модулируется `strength`.

timesteps (`list[int]`, *optional*) : Пользовательские шаги для процесса денойзинга с планировщиками, поддерживающими аргумент `timesteps` в их методе `set_timesteps`. Если не определено, будет использоваться поведение по умолчанию при передаче `num_inference_steps`. Должны быть в порядке убывания.

sigmas (`list[float]`, *optional*) : Пользовательские сигмы для процесса денойзинга в планировщиках, поддерживающих аргумент `sigmas` в методе `set_timesteps`. Если не задано, будет использовано поведение по умолчанию при передаче `num_inference_steps`.

guidance_scale (`float`, *optional*, по умолчанию 7.5) : Более высокое значение guidance scale побуждает модель генерировать изображения, тесно связанные с текстовым `prompt`, за счёт снижения качества изображения. Guidance scale активируется, когда `guidance_scale > 1`.

negative_prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты, определяющие, что следует исключить из генерируемого изображения. Если не задан, необходимо передать `negative_prompt_embeds`. Игнорируется, если не используется направляющая (`guidance_scale < 1`).

num_images_per_prompt (`int`, *необязательный*, по умолчанию 1) : Количество изображений, генерируемых на один запрос.

eta (`float`, *необязательный*, по умолчанию 0.0) : Соответствует параметру eta (η) из статьи [DDIM](https://huggingface.co/papers/2010.02502). Применяется только к [DDIMScheduler](/docs/diffusers/main/ru/api/schedulers/ddim#diffusers.DDIMScheduler) и игнорируется другими планировщиками.

generator (`torch.Generator` или `list[torch.Generator]`, *необязательно*) : [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) для обеспечения детерминированности генерации.

prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных (взвешивание промпта). Если не предоставлены, текстовые эмбеддинги генерируются из входного аргумента `prompt`.

negative_prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных (взвешивание промпта). Если не предоставлены, `negative_prompt_embeds` генерируются из входного аргумента `negative_prompt`.

ip_adapter_image : (`PipelineImageInput`, *необязательный*): Необязательное входное изображение для работы с IP-адаптерами.

ip_adapter_image_embeds (`list[torch.Tensor]`, *необязательный*) : Предварительно сгенерированные эмбеддинги изображений для IP-Adapter. Должен представлять собой список, длина которого равна количеству IP-адаптеров. Каждый элемент должен быть тензором формы `(batch_size, num_images, emb_dim)`. Если `do_classifier_free_guidance` установлен в `True`, должен содержать отрицательный эмбеддинг изображения. Если не указан, эмбеддинги вычисляются из входного аргумента `ip_adapter_image`.

output_type (`str`, *необязательный*, по умолчанию `"pil"`) : Формат вывода сгенерированного изображения. Выберите между `PIL.Image` и `np.array`.

return_dict (`bool`, *необязательный*, по умолчанию `True`) : Возвращать ли [StableDiffusionPipelineOutput](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) вместо обычного кортежа.

cross_attention_kwargs (`dict`, *необязательный*) : Словарь kwargs, который при указании передается в `AttentionProcessor`, определенный в [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *optional*) : Количество слоев, которые пропускаются в CLIP при вычислении эмбеддингов промпта. Значение 1 означает, что для вычисления эмбеддингов промпта будет использоваться выход предпоследнего слоя.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *optional*) : функция или подкласс `PipelineCallback` или `MultiPipelineCallbacks`, вызываемая в конце каждого шага денойзинга во время инференса со следующими аргументами: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` будет содержать список всех тензоров, как указано в `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *optional*) : Список тензорных входных данных для функции `callback_on_step_end`. Тензоры, указанные в списке, будут переданы в качестве аргумента `callback_kwargs`. Вы сможете включать только переменные, перечисленные в атрибуте `._callback_tensor_inputs` вашего класса pipeline.

**Возвращает:** [StableDiffusionPipelineOutput](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) или `tuple`

Если `return_dict` равно `True`, возвращается [StableDiffusionPipelineOutput](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput), иначе возвращается `tuple`, где первый элемент — это список сгенерированных изображений, а второй — список значений `bool`, указывающих, содержит ли соответствующее сгенерированное изображение контент, нежелательный для просмотра на рабочем месте (nsfw).

Функция вызова конвейера для генерации.

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

[Источник](https://github.com/huggingface/diffusers/blob/main/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]
```

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

```python
disable_attention_slicing()
```

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

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/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)
```

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

```python
disable_xformers_memory_efficient_attention()
```

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

Отключить энергоэффективное внимание из [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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)

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

pretrained_model_name_or_path (`str` или `os.PathLike` или `list[str or os.PathLike]` или `Dict` или `list[Dict]`) : Может быть одним из следующих вариантов или списком таких вариантов:  - Строка, *model id* (например, `sd-concepts-library/low-poly-hd-logos-icons`) предобученной модели, размещенной на Hub. - Путь к *каталогу* (например, `./my_text_inversion_directory/`), содержащему веса textual inversion. - Путь к *файлу* (например, `./my_text_inversions.pt`), содержащему веса textual inversion. - [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` или `list[str]`, *необязательный*) : Переопределяет токен, используемый для весов текстовой инверсии. Если `pretrained_model_name_or_path` является списком, то `token` также должен быть списком той же длины.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *необязательный*) : Замороженный текстовый энкодер ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Если не указан, функция использует self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *необязательный*) : `CLIPTokenizer` для токенизации текста. Если не указан, функция использует self.tokenizer.

weight_name (`str`, *необязательный*) : Имя файла с кастомными весами. Это следует использовать, когда:  - Сохранённый файл текстовой инверсии в формате 🤗 Diffusers был сохранён под конкретным именем весов, например `text_inv.bin`. - Сохранённый файл текстовой инверсии в формате Automatic1111.

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

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

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

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

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

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

subfolder (`str`, *необязательный*, по умолчанию `""`) : Путь к подпапке, в которой находится файл модели в составе более крупного репозитория моделей на Hub или локально.

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

Загрузите эмбеддинги Textual Inversion в текстовый энкодер [StableDiffusionPipeline](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (поддерживаются форматы 🤗 Diffusers и Automatic1111).

Пример:

Для загрузки вектора встраивания Textual Inversion в формате 🤗 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")
```

Чтобы загрузить вектор встраивания Textual Inversion в формате Automatic1111, сначала скачайте вектор (например, с [civitAI](https://civitai.com/models/3036?modelVersionId=9857)), а затем загрузите его

локально:

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/single_file.py#L248)

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

pretrained_model_link_or_path (`str` или `os.PathLike`, *необязательный*) : Может быть одним из: - ссылкой на файл `.ckpt` (например, `"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt"`) на Hub. - путём к *файлу*, содержащему все веса пайплайна.

dtype (`str` или `torch.dtype`, *необязательный*) : Переопределяет стандартный `torch.dtype` и загружает модель с другим dtype.

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

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

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

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

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

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

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

config (`str`, *необязательный*) : Может быть одним из: - строка, *repo id* (например, `CompVis/ldm-text2im-large-256`) предобученного пайплайна, размещённого на Hub. - путь к *каталогу* (например, `./my_pipeline_directory/`), содержащему конфигурации компонентов пайплайна в формате Diffusers.

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

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

Создайте экземпляр [DiffusionPipeline](/docs/diffusers/main/ru/api/pipelines/overview#diffusers.DiffusionPipeline) из предобученных весов пайплайна, сохранённых в формате `.ckpt` или `.safetensors`. По умолчанию пайплайн устанавливается в режим оценки (`model.eval()`).

Примеры:

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L148)

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

pretrained_model_name_or_path_or_dict (`str` или `os.PathLike` или `dict`) : см. [lora_state_dict()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

adapter_name (`str`, *необязательный*) : Имя адаптера, используемое для ссылки на загруженную модель адаптера. Если не указано, будет использовано `default_{i}`, где i — общее количество загружаемых адаптеров.

low_cpu_mem_usage (`bool`, *необязательный*) : Ускоряет загрузку модели, загружая только предобученные веса LoRA и не инициализируя случайные веса.

hotswap (`bool`, *необязательный*) : По умолчанию `False`. Определяет, следует ли заменить существующий адаптер (LoRA) на вновь загруженный адаптер на месте. Это означает, что вместо загрузки дополнительного адаптера будут взяты веса существующего адаптера и заменены весами нового адаптера. Это может быть быстрее и экономнее по памяти. Однако главное преимущество hotswapping заключается в том, что при компиляции модели с помощью torch.compile загрузка нового адаптера не требует повторной компиляции модели. При использовании hotswapping переданный `adapter_name` должен быть именем уже загруженного адаптера. Если у нового и старого адаптеров разные ранги и/или значения LoRA alpha (т.е. масштабирование), перед загрузкой адаптера необходимо вызвать дополнительный метод: ```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 ``` Обратите внимание, что hotswapping адаптеров текстового кодировщика пока не поддерживается. У этой техники есть некоторые дополнительные ограничения, которые описаны здесь: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (`dict`, *необязательный*) : см. [lora_state_dict()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

Загрузите веса LoRA, указанные в `pretrained_model_name_or_path_or_dict`, в `self.unet` и `self.text_encoder`.

Все kwargs передаются в `self.lora_state_dict`.

См. [lora_state_dict()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) для получения подробной информации о том, как загружается state dict.

See [load_lora_into_unet()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) for more details on how the state dict is loaded into `self.unet`.

См. [load_lora_into_text_encoder()](/docs/diffusers/main/ru/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) для подробностей о том, как state dict загружается в `self.text_encoder`.

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

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = 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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L466)

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

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

unet_lora_layers (`dict[str, torch.nn.Module]` или `dict[str, torch.Tensor]`) : Словарь состояний слоёв LoRA, соответствующих `unet`.

text_encoder_lora_layers (`dict[str, torch.nn.Module]` или `dict[str, torch.Tensor]`) : Словарь состояний (state dict) слоёв LoRA, соответствующих `text_encoder`. Необходимо явно передать словарь состояний LoRA для текстового энкодера, так как он поступает из 🤗 Transformers.

is_main_process (`bool`, *необязательный*, по умолчанию `True`) : Указывает, является ли процесс, вызывающий данный метод, основным. Полезно при распределённом обучении, когда необходимо вызвать эту функцию во всех процессах. В этом случае установите `is_main_process=True` только в основном процессе, чтобы избежать гонок.

save_function (`Callable`) : функция, используемая для сохранения словаря состояния. Полезно при распределённом обучении, когда необходимо заменить `torch.save` на другой метод. Может быть настроено с помощью переменной окружения `DIFFUSERS_SAVE_MODE`.

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

unet_lora_adapter_metadata : метаданные адаптера LoRA, связанные с unet, которые будут сериализованы вместе со state dict.

text_encoder_lora_adapter_metadata : метаданные адаптера LoRA, связанные с текстовым энкодером, которые будут сериализованы вместе со словарем состояний.

Сохраните параметры LoRA, соответствующие UNet и текстовому энкодеру.

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L358)

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

prompt (`str` или `list[str]`, *необязательный*) : промпт для кодирования

device : (`torch.device`): устройство torch

num_images_per_prompt (`int`) : количество изображений, которые должны быть сгенерированы для каждого промпта

do_classifier_free_guidance (`bool`) : использовать ли классификаторное свободное наведение (classifier free guidance)

negative_prompt (`str` или `list[str]`, *необязательный*) : Промпт или промпты, которые не должны направлять генерацию изображения. Если не задан, необходимо передать `negative_prompt_embeds`. Игнорируется, если не используется направляющее влияние (то есть игнорируется, если `guidance_scale` меньше `1`).

prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, *например* для взвешивания промпта. Если не предоставлены, текстовые эмбеддинги будут сгенерированы из входного аргумента `prompt`.

negative_prompt_embeds (`torch.Tensor`, *необязательный*) : Предварительно сгенерированные отрицательные текстовые эмбеддинги. Можно использовать для простой настройки текстовых входных данных, *например* для взвешивания промпта. Если не предоставлены, negative_prompt_embeds будут сгенерированы из входного аргумента `negative_prompt`.

lora_scale (`float`, *необязательный*) : Масштаб LoRA, который будет применён ко всем слоям LoRA текстового энкодера, если слои LoRA загружены.

clip_skip (`int`, *optional*) : Количество слоев, которые пропускаются в CLIP при вычислении эмбеддингов промпта. Значение 1 означает, что для вычисления эмбеддингов промпта будет использоваться выход предпоследнего слоя.

Кодирует промпт в скрытые состояния текстового энкодера.

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py#L801)

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

w (`torch.Tensor`) : Генерирует векторы эмбеддингов с заданным масштабом руководства (guidance scale) для последующего обогащения эмбеддингов временных шагов.

embedding_dim (`int`, *необязательный*, по умолчанию 512) : Размерность генерируемых эмбеддингов.

dtype (`torch.dtype`, *необязательный*, по умолчанию `torch.float32`) : Тип данных для генерируемых эмбеддингов.

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

Векторы встраиваний с формой `(len(w), embedding_dim)`.

См. 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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

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

images (`list[PIL.Image.Image]` или `np.ndarray`) : список денойзированных изображений PIL длиной `batch_size` или массив NumPy формы `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : список, указывающий, содержит ли соответствующее сгенерированное изображение контент, нежелательный для просмотра на рабочем месте (nsfw), или `None`, если проверка безопасности не могла быть выполнена.

Класс вывода для пайплайнов Stable Diffusion.