Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /pt /api /pipelines /stable_diffusion /text2img.md
mishig
2 days ago
preview code
download
raw
39.3 kB
# Texto para imagem

  

O modelo Stable Diffusion foi criado por pesquisadores e engenheiros do [CompVis](https://github.com/CompVis), [Stability AI](https://stability.ai/), [Runway](https://github.com/runwayml) e [LAION](https://laion.ai/). O [StableDiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) é capaz de gerar imagens fotorrealistas a partir de qualquer entrada de texto. Ele foi treinado em imagens de 512x512 de um subconjunto do conjunto de dados LAION-5B. Este modelo usa um codificador de texto CLIP ViT-L/14 congelado para condicionar o modelo em prompts de texto. Com seu UNet de 860M e codificador de texto de 123M, o modelo é relativamente leve e pode ser executado em GPUs de consumo. A difusão latente é a pesquisa sobre a qual o Stable Diffusion foi construído. Foi proposta em [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752) por Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, Björn Ommer.

O resumo do artigo é:

*Ao decompor o processo de formação de imagens em uma aplicação sequencial de autoencoders de remoção de ruído, os modelos de difusão (DMs) alcançam resultados de síntese state-of-the-art em dados de imagem e além. Além disso, sua formulação permite um mecanismo de orientação para controlar o processo de geração de imagens sem re-treinamento. No entanto, como esses modelos geralmente operam diretamente no espaço de pixels, a otimização de DMs poderosos frequentemente consome centenas de dias de GPU e a inferência é cara devido às avaliações sequenciais. Para permitir o treinamento de DMs em recursos computacionais limitados, mantendo sua qualidade e flexibilidade, aplicamos-os no espaço latente de autoencoders pré-treinados poderosos. Em contraste com trabalhos anteriores, o treinamento de modelos de difusão em tal representação permite, pela primeira vez, alcançar um ponto quase ótimo entre a redução de complexidade e a preservação de detalhes, aumentando significativamente a fidelidade visual. Ao introduzir camadas de atenção cruzada na arquitetura do modelo, transformamos os modelos de difusão em geradores poderosos e flexíveis para entradas de condicionamento gerais, como texto ou bounding boxes, e a síntese de alta resolução se torna possível de maneira convolucional. Nossos modelos de difusão latente (LDMs) alcançam um novo state of the art para inpainting de imagem e desempenho altamente competitivo em várias tarefas, incluindo geração de imagem incondicional, síntese de cena semântica e super-resolução, reduzindo significativamente os requisitos computacionais em comparação com DMs baseados em pixels. O código está disponível em https://github.com/CompVis/latent-diffusion.*

> [!TIP]
> Certifique-se de conferir a seção [Dicas](overview#tips) do Stable Diffusion para aprender como explorar o equilíbrio entre a velocidade e a qualidade do agendador, e como reutilizar os componentes do pipeline de forma eficiente!
>
> Se você tem interesse em usar um dos checkpoints oficiais para uma tarefa, explore as organizações [CompVis](https://huggingface.co/CompVis) e [Stability AI](https://huggingface.co/stabilityai) no Hub!

## StableDiffusionPipeline[[diffusers.StableDiffusionPipeline]]

#### diffusers.StableDiffusionPipeline[[diffusers.StableDiffusionPipeline]]

```python
diffusers.StableDiffusionPipeline(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)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L154)

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Um `CLIPTokenizer` para tokenizar texto.
unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Um `UNet2DConditionModel` para desruidar os latentes da imagem codificada.
scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes da imagem codificada. Pode ser um de [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/pndm#diffusers.PNDMScheduler).
safety_checker (`StableDiffusionSafetyChecker`) : Módulo de classificação que estima se as imagens geradas podem ser consideradas ofensivas ou prejudiciais. Consulte o [model card](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para mais detalhes sobre os potenciais danos de um modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPImageProcessor)) : Um `CLIPImageProcessor` para extrair recursos de imagens geradas; usado como entradas para o `safety_checker`.

Pipeline para geração de texto para imagem usando Stable Diffusion.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

O pipeline também herda os seguintes métodos de carregamento:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para salvar os pesos do LoRA
- para carregar arquivos `.ckpt` com [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)
- [load_ip_adapter()](/docs/diffusers/v0.43.0/pt/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para carregar IP Adapters

#### __call__[[diffusers.StableDiffusionPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = 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, guidance_rescale: float = 0.0, clip_skip: int | None = 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)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L778)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração de imagens. Se não definido, você precisa passar `prompt_embeds`.

height (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão `self.unet.config.sample_size * self.vae_scale_factor`) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumento `timesteps` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado. Deve estar em ordem decrescente.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

guidance_scale (`float`, *opcional*, padrão 7.5) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar o que não incluir na geração de imagem. Se não definido, você precisa passar `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale < 1`).

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
eta (`float`, *opcional*, padrão 0.0) : Corresponde ao parâmetro eta (η) do paper [DDIM](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores.
generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido.
prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`.

ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagem opcional para trabalhar com IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Embebimentos de imagem pré-gerados para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma `(batch_size, num_images, emb_dim)`. Deve conter o embebimento de imagem negativo se `do_classifier_free_guidance` estiver definido como `True`. Se não for fornecido, os embebimentos são calculados a partir do argumento de entrada `ip_adapter_image`.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) em vez de uma tupla simples.
cross_attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado ao `AttentionProcessor` conforme definido em [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
guidance_rescale (`float`, *opcional*, padrão 0.0) : Fator de rescalonamento de orientação de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). O fator de rescalonamento de orientação deve corrigir a sobreexposição ao usar SNR terminal zero.

clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

A função de chamada do pipeline para geração.

Exemplos:
```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionPipeline.enable_attention_slicing]]

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

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

**Parâmetros:**

slice_size (`str` ou `int`, *opcional*, padrão `"auto"`) : Quando `"auto"`, divide a entrada dos cabeçalhos de atenção pela metade, de modo que a atenção será calculada em duas etapas. Se `"max"`, a quantidade máxima de memória será economizada executando apenas uma fatia por vez. Se um número for fornecido, usa tantas fatias quanto `attention_head_dim // slice_size`. Nesse caso, `attention_head_dim` deve ser um múltiplo de `slice_size`.
Ativa o cálculo de atenção fatiado. Quando esta opção está ativada, o módulo de atenção divide o tensor de entrada em fatias para calcular a atenção em várias etapas. Para mais de uma cabeça de atenção, o cálculo é executado sequencialmente em cada cabeça. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.
> [!WARNING] > ⚠️ Não ative o fatiamento de atenção se você já estiver usando `scaled_dot_product_attention` (SDPA)
do PyTorch > 2.0 ou xFormers. Esses cálculos de atenção já são muito eficientes em termos de memória, portanto, você não precisará habilitar > esta função. Se você habilitar o fatiamento de atenção com SDPA ou xFormers, isso pode levar a uma desaceleração significativa!

Exemplos:

```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.StableDiffusionPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

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

Desativa o cálculo de atenção fatiado. Se `enable_attention_slicing` foi chamado anteriormente, a atenção é calculada em uma única etapa.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionPipeline.enable_xformers_memory_efficient_attention]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**Parâmetros:**

attention_op (`Callable`, *opcional*) : Substitui o operador padrão `None` para uso como argumento `op` da função [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) do xFormers.
Ative a atenção eficiente em memória do [xFormers](https://facebookresearch.github.io/xformers/). Quando essa opção estiver ativada, você deve observar um menor uso de memória de GPU e uma possível aceleração durante a inferência. A aceleração durante o treinamento não é garantida.
> [!WARNING] > ⚠️ Quando a atenção eficiente em memória e a atenção fatiada estão ambas habilitadas, a atenção eficiente
attention tem > precedência.
Exemplos:
```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.StableDiffusionPipeline.disable_xformers_memory_efficient_attention]]
```python
disable_xformers_memory_efficient_attention()
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)
Desative a atenção eficiente em memória do [xFormers](https://facebookresearch.github.io/xformers/).
#### load_textual_inversion[[diffusers.StableDiffusionPipeline.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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/textual_inversion.py#L271)
**Parâmetros:**
pretrained_model_name_or_path (`str` ou `os.PathLike` ou `list[str or os.PathLike]` ou `Dict` ou `list[Dict]`) : Pode ser um dos seguintes ou uma lista deles:  - Uma string, o *model id* (por exemplo `sd-concepts-library/low-poly-hd-logos-icons`) de um modelo pré-treinado hospedado no Hub. - Um caminho para um *diretório* (por exemplo `./my_text_inversion_directory/`) contendo os pesos de inversão textual. - Um caminho para um *arquivo* (por exemplo `./my_text_inversions.pt`) contendo pesos de inversão textual. - Um [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` ou `list[str]`, *opcional*) : Substitui o token a ser usado para os pesos de inversão textual. Se `pretrained_model_name_or_path` for uma lista, então `token` também deve ser uma lista de comprimento igual.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel), *opcional*) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Se não for especificado, a função usará self.tokenizer.
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer), *opcional*) : Um `CLIPTokenizer` para tokenizar texto. Se não for especificado, a função usará self.tokenizer.
weight_name (`str`, *opcional*) : Nome de um arquivo de pesos personalizado. Isso deve ser usado quando: - O arquivo de inversão textual salvo está no formato 🤗 Diffusers, mas foi salvo com um nome de pesos específico, como `text_inv.bin`. - O arquivo de inversão textual salvo está no formato Automatic1111.

cache_dir (`str | os.PathLike`, *opcional*) : Caminho para um diretório onde a configuração de um modelo pré-treinado baixado é armazenada em cache, caso o cache padrão não seja utilizado.
force_download (`bool`, *opcional*, padrão `False`) : Se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.

proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.

local_files_only (`bool`, *opcional*, padrão `False`) : Se deve carregar apenas os pesos e os arquivos de configuração do modelo localmente ou não. Se definido como `True`, o modelo não será baixado do Hub.

hf_token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, o token gerado por `diffusers-cli login` (armazenado em `~/.huggingface`) é utilizado.
revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag, um id de commit ou qualquer identificador permitido pelo Git.
subfolder (`str`, *opcional*, padrão `""`) : A localização da subpasta de um arquivo de modelo dentro de um repositório de modelo maior no Hub ou localmente.
mirror (`str`, *opcional*) : Espelho de origem para resolver problemas de acessibilidade se você estiver baixando um modelo na China. Não garantimos a pontualidade ou a segurança da origem, e você deve consultar o site do espelho para obter mais informações.
Carregue os embeddings de Textual Inversion no codificador de texto do [StableDiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (ambos os formatos 🤗 Diffusers e Automatic1111 são suportados).
Exemplo:
Para carregar um vetor de incorporação de Inversão Textual no formato 🤗 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")
```
Para carregar um vetor de incorporação de Inversão Textual no formato Automatic1111, certifique-se de baixar o vetor primeiro (por exemplo, do [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) e, em seguida, carregar o vetor
localmente:
```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.StableDiffusionPipeline.from_single_file]]
```python
from_single_file(pretrained_model_link_or_path, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/single_file.py#L248)
**Parâmetros:**
pretrained_model_link_or_path (`str` ou `os.PathLike`, *opcional*) : Pode ser: - Um link para o arquivo `.ckpt` (por exemplo, `"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt"`) no Hub. - Um caminho para um *arquivo* contendo todos os pesos do pipeline.
dtype (`str` ou `torch.dtype`, *opcional*) : Substitui o `torch.dtype` padrão e carrega o modelo com outro dtype.
force_download (`bool`, *opcional*, padrão `False`) : Se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.

cache_dir (`str | os.PathLike`, *opcional*) : Caminho para um diretório onde a configuração de um modelo pré-treinado baixado é armazenada em cache, caso o cache padrão não seja utilizado.
proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.
local_files_only (`bool`, *opcional*, padrão `False`) : Se deve carregar apenas os pesos e os arquivos de configuração do modelo localmente ou não. Se definido como `True`, o modelo não será baixado do Hub.
token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, o token gerado por `diffusers-cli login` (armazenado em `~/.huggingface`) é utilizado.
revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag, um id de commit ou qualquer identificador permitido pelo Git.
original_config_file (`str`, *opcional*) : O caminho para o arquivo de configuração original que foi usado para treinar o modelo. Se não for fornecido, o arquivo de configuração será inferido a partir do arquivo de checkpoint.
config (`str`, *opcional*) : Pode ser: - Uma string, o *repo id* (por exemplo `CompVis/ldm-text2im-large-256`) de um pipeline pré-treinado hospedado no Hub. - Um caminho para um *diretório* (por exemplo `./my_pipeline_directory/`) contendo as configurações dos componentes do pipeline no formato Diffusers.
disable_mmap ('bool', *opcional*, padrão 'False') : Se deve desabilitar o mmap ao carregar um modelo Safetensors. Essa opção pode ter um desempenho melhor quando o modelo está em uma montagem de rede ou em um disco rígido.

kwargs (dicionário restante de argumentos de palavra-chave, *opcional*) : Pode ser usado para sobrescrever variáveis de carregamento e salvamento (os componentes do pipeline da classe de pipeline específica). Os componentes sobrescritos são passados diretamente para o método `__init__` dos pipelines. Veja o exemplo abaixo para mais informações.

Instancie um [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline) a partir de pesos de pipeline pré-treinados salvos no formato `.ckpt` ou `.safetensors`. O pipeline é definido no modo de avaliação (`model.eval()`) por padrão.

Exemplos:

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

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L148)

**Parâmetros:**

pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Veja [lora_state_dict()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.

low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : O padrão é `False`. Se deve substituir um adaptador (LoRA) existente pelo adaptador recém-carregado no local. Isso significa que, em vez de carregar um adaptador adicional, isso pegará os pesos do adaptador existente e os substituirá pelos pesos do novo adaptador. Isso pode ser mais rápido e eficiente em termos de memória. No entanto, a principal vantagem do hotswap é que, quando o modelo é compilado com torch.compile, o carregamento do novo adaptador não requer a recompilação do modelo. Ao usar hotswap, o `adapter_name` passado deve ser o nome de um adaptador já carregado. Se o novo adaptador e o antigo tiverem ranks e/ou alfas LoRA (ou seja, escalonamento) diferentes, você precisa chamar um método adicional antes de carregar o adaptador: ```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 ``` Observe que o hotswap de adaptadores do codificador de texto ainda não é suportado. Existem algumas limitações adicionais a essa técnica, que estão documentadas aqui: https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (`dict`, *opcional*) : Veja [lora_state_dict()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).
Carrega os pesos LoRA especificados em `pretrained_model_name_or_path_or_dict` para `self.unet` e `self.text_encoder`.

Todos os kwargs são encaminhados para `self.lora_state_dict`.

Veja [lora_state_dict()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes sobre como o state dict é carregado.

Veja [load_lora_into_unet()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes sobre como o state dict é carregado em `self.unet`.

Veja [load_lora_into_text_encoder()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) para mais detalhes sobre como o state dict é carregado em `self.text_encoder`.

#### save_lora_weights[[diffusers.StableDiffusionPipeline.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)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L466)

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório para salvar os parâmetros LoRA. Será criado se não existir.
unet_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `unet`.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `text_encoder`. É necessário passar explicitamente o state dict do LoRA do text encoder, pois ele vem do 🤗 Transformers.

is_main_process (`bool`, *opcional*, padrão `True`) : Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído, quando é necessário chamar esta função em todos os processos. Nesse caso, defina `is_main_process=True` apenas no processo principal para evitar condições de corrida.

save_function (`Callable`) : A função a ser usada para salvar o dicionário de estado. Útil durante o treinamento distribuído quando você precisa substituir `torch.save` por outro método. Pode ser configurado com a variável de ambiente `DIFFUSERS_SAVE_MODE`.
safe_serialization (`bool`, *opcional*, padrão `True`) : Se o modelo deve ser salvo usando `safetensors` ou da maneira tradicional do PyTorch com `pickle`.

unet_lora_adapter_metadata : Metadados do adaptador LoRA associados ao unet a serem serializados com o state dict.
text_encoder_lora_adapter_metadata : Metadados do adaptador LoRA associados ao codificador de texto a serem serializados com o state dict.
Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.
#### encode_prompt[[diffusers.StableDiffusionPipeline.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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L332)
**Parâmetros:**
prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado
device : (`torch.device`): dispositivo torch
num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt
do_classifier_free_guidance (`bool`) : se deve ou não usar classifier free guidance
negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).
prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.
lora_scale (`float`, *opcional*) : Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas.
clip_skip (`int`, *opcional*) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.
Codifica o prompt em estados ocultos do codificador de texto.
#### get_guidance_scale_embedding[[diffusers.StableDiffusionPipeline.get_guidance_scale_embedding]]
```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py#L717)
**Parâmetros:**
w (`torch.Tensor`) : Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo.
embedding_dim (`int`, *opcional*, padrão 512) : Dimensão dos embeddings a serem gerados.
dtype (`torch.dtype`, *opcional*, padrão `torch.float32`) : Tipo de dados dos embeddings gerados.
**Retorna:** `torch.Tensor`
Vetores de incorporação com forma `(len(w), embedding_dim)`.
Veja 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)
**Parâmetros:**
images (`list[PIL.Image.Image]` ou `np.ndarray`) : lista de imagens PIL desruídas de comprimento `batch_size` ou array NumPy de forma `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : lista indicando se a imagem gerada correspondente contém conteúdo "não seguro para o trabalho" (nsfw) ou `None` se a verificação de segurança não pôde ser realizada.

Classe de saída para pipelines do Stable Diffusion.
Xet Storage Details

Size:: 39.3 kB
Xet hash:: 8bc693e16d640bd67ff2881995c7e403d1398a537c97229ee5804b708b4a8fbd
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.