Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /pt /api /pipelines /stable_diffusion /depth2img.md
mishig
2 days ago
preview code
download
raw
29.6 kB
# Profundidade para imagem

  

O modelo Stable Diffusion também pode inferir profundidade com base em uma imagem usando [MiDaS](https://github.com/isl-org/MiDaS). Isso permite passar um prompt de texto e uma imagem inicial para condicionar a geração de novas imagens, bem como um `depth_map` para preservar a estrutura da imagem.

> [!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!

## StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

#### diffusers.StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

```python
diffusers.StableDiffusionDepth2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, depth_estimator: DPTForDepthEstimation, feature_extractor: DPTImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L92)

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/main/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/main/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/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Um `CLIPTokenizer` para tokenizar texto.
unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Um `UNet2DConditionModel` para desruidar os latentes da imagem codificada.
scheduler ([SchedulerMixin](/docs/diffusers/main/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/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/main/pt/api/schedulers/pndm#diffusers.PNDMScheduler).
Pipeline para geração de imagem a partir de imagem baseada em profundidade guiada por texto usando Stable Diffusion.
Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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/main/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para salvar os pesos do LoRA
#### __call__[[diffusers.StableDiffusionDepth2ImgPipeline.__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, depth_map: typing.Optional[torch.Tensor] = None, strength: float = 0.8, num_inference_steps: int | None = 50, 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, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L634)
**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`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tensor representando um lote de imagens a ser usado como ponto de partida. Pode aceitar latentes de imagem como `image` apenas se `depth_map` não for `None`.

depth_map (`torch.Tensor`, *opcional*) : Previsão de profundidade a ser usada como condicionamento adicional para o processo de geração de imagem. Se não for definida, a profundidade é prevista automaticamente com `self.depth_estimator`.

strength (`float`, *opcional*, padrão 0.8) : Indica o grau de transformação da `image` de referência. Deve estar entre 0 e 1. `image` é usado como ponto de partida e mais ruído é adicionado quanto maior for o `strength`. O número de etapas de desruidamento depende da quantidade de ruído inicialmente adicionada. Quando `strength` é 1, o ruído adicionado é máximo e o processo de desruidamento executa pelo número total de iterações especificado em `num_inference_steps`. Um valor de 1 essencialmente ignora `image`.

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, às custas de uma inferência mais lenta. Este parâmetro é modulado por `strength`.

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/main/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.
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`.

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/main/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).

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`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada 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/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/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.

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

Exemplos:

```py
>>> import torch
>>> import requests
>>> from PIL import Image
>>> from diffusers import StableDiffusionDepth2ImgPipeline
>>> pipe = StableDiffusionDepth2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-depth",
...     torch_dtype=torch.float16,
... )
>>> pipe.to("cuda")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> init_image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "two tigers"
>>> n_prompt = "bad, deformed, ugly, bad anotomy"
>>> image = pipe(prompt=prompt, image=init_image, negative_prompt=n_prompt, strength=0.7).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionDepth2ImgPipeline.enable_attention_slicing]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/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.StableDiffusionDepth2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/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.StableDiffusionDepth2ImgPipeline.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/main/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.StableDiffusionDepth2ImgPipeline.disable_xformers_memory_efficient_attention]]
```python
disable_xformers_memory_efficient_attention()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/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.StableDiffusionDepth2ImgPipeline.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/main/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/main/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/main/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/main/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")
```
#### load_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.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/main/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/main/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/main/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/main/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/main/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/main/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.StableDiffusionDepth2ImgPipeline.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/main/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.StableDiffusionDepth2ImgPipeline.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/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L204)
**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.
## 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/main/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:: 29.6 kB
Xet hash:: 1ea694533fb601d6484601e1a4e2a14da4f4d24546ae8fdaea676d0a6eccdbfd
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.