Diffusers documentation

Texto para imagem

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Texto para imagem

LoRA

O modelo Stable Diffusion foi criado por pesquisadores e engenheiros do CompVis, Stability AI, Runway e LAION. O 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 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 caixas delimitadoras, e a síntese de alta resolução torna-se possível de maneira convolucional. Nossos modelos de difusão latente (LDMs) alcançam um novo state of the art para inpainting de imagens e desempenho altamente competitivo em várias tarefas, incluindo geração de imagens incondicional, síntese de cenas semânticas 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.

Certifique-se de conferir a seção Dicas 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ê estiver interessado em usar um dos checkpoints oficiais para uma tarefa, explore as organizações CompVis e Stability AI no Hub!

StableDiffusionPipeline

classe diffusers.StableDiffusionPipeline

< >

( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: KarrasDiffusionSchedulerssafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: CLIPVisionModelWithProjection = Nonerequires_safety_checker: bool = True )

Parâmetros

  • vae (AutoencoderKL) — Modelo Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.
  • text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
  • tokenizer (CLIPTokenizer) — Um CLIPTokenizer para tokenizar texto.
  • unet (UNet2DConditionModel) — Um UNet2DConditionModel para desruidar os latentes da imagem codificada.
  • scheduler (SchedulerMixin) — Um scheduler a ser usado em combinação com unet para desruidar os latentes da imagem codificada. Pode ser um de DDIMScheduler, LMSDiscreteScheduler ou 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 para mais detalhes sobre os potenciais danos de um modelo.
  • feature_extractor (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. 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:

__call__

< >

( prompt: str | list[str] = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 50timesteps: list[int] = Nonesigmas: list[float] = Noneguidance_scale: float = 7.5negative_prompt: str | list[str] | None = Nonenum_images_per_prompt: int | None = 1eta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecross_attention_kwargs: dict[str, typing.Any] | None = Noneguidance_rescale: float = 0.0clip_skip: int | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents']**kwargs ) → StableDiffusionPipelineOutput or tuple

Parâmetros

  • prompt (str ou list[str], opcional) — O prompt ou os prompts para orientar a geração de imagens. Se não for 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, à custa de uma inferência mais lenta.
  • timesteps (list[int], opcional) — Timesteps 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 texto prompt, em detrimento da qualidade da 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, é necessário 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. Aplica-se apenas ao DDIMScheduler e é ignorado em outros schedulers.
  • generator (torch.Generator ou list[torch.Generator], opcional) — Um torch.Generator 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 negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto (ponderação do prompt). Se não for fornecido, os 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) — Incorporações de imagem pré-geradas 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 a incorporação de imagem negativa se do_classifier_free_guidance estiver definido como True. Se não for fornecido, as incorporações são calculadas 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 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.
  • guidance_rescale (float, opcional, padrão 0.0) — Fator de rescale de guidance de Common Diffusion Noise Schedules and Sample Steps are Flawed. O fator de rescale de guidance deve corrigir a sobreexposição ao usar zero terminal SNR.
  • 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.

Se return_dict for True, 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 bools 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:

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

< >

( slice_size: str | int = 'auto' )

Parâmetros

  • slice_size (str ou int, opcional, padrão "auto") — Quando "auto", divide a entrada dos cabeçalhos de atenção ao meio, 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 é realizado sequencialmente em cada cabeça. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.

> ⚠️ 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, então você não precisa ativar > essa função. Se você ativar o fatiamento de atenção com SDPA ou xFormers, isso pode levar a desempenhos significativamente mais lentos!

Exemplos:

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

< >

( )

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

< >

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

Parâmetros

  • attention_op (Callable, opcional) — Substitui o operador padrão None para uso como argumento op da função memory_efficient_attention() do xFormers.

Ative a atenção eficiente em memória do 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.

> ⚠️ Quando a memória eficiente de atenção e a atenção fatiada estão ambas habilitadas, a memória eficiente de atenção tem > precedência.

Exemplos:

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

< >

( )

Desative a atenção eficiente em memória do xFormers.

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 = Nonetokenizer: 'PreTrainedTokenizer' | None = Nonetext_encoder: 'PreTrainedModel' | None = None**kwargs )

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 id do modelo (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.
  • 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, opcional) — Codificador de texto congelado (clip-vit-large-patch14). Se não for especificado, a função utilizará self.tokenizer.
  • tokenizer (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 sob um nome de peso 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 arquivos de configuração do modelo localmente. 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 de bearer HTTP para arquivos remotos. Se True, o token gerado a partir de 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 atualidade 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 (os formatos 🤗 Diffusers e Automatic1111 são suportados).

Exemplo:

Para carregar um vetor de incorporação de Inversão Textual no formato 🤗 Diffusers:

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) e, em seguida, carregar o vetor

localmente:

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

< >

( pretrained_model_link_or_path**kwargs )

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 arquivos de configuração do modelo localmente. 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 de bearer HTTP 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 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:

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

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Parâmetros

  • pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) — Veja 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) — 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 deve ser o nome de um adaptador já carregado.

    Se o novo adaptador e o antigo tiverem ranks e/ou alphas LoRA diferentes (ou seja, escalonamento), você precisa chamar um método adicional antes de carregar o adaptador:

    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 a troca dinâmica (hotswap) de adaptadores do codificador de texto ainda não é suportada. 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().

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() para mais detalhes sobre como o state dict é carregado.

Veja load_lora_into_unet() para mais detalhes sobre como o state dict é carregado em self.unet.

Veja load_lora_into_text_encoder() para mais detalhes sobre como o state dict é carregado em self.text_encoder.

save_lora_weights

< >

( save_directory: str | os.PathLikeunet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )

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]) — Dicionário de estado 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 das 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 você precisa 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

< >

( promptdevicenum_images_per_promptdo_classifier_free_guidancenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonelora_scale: float | None = Noneclip_skip: int | None = None )

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 usar classifier free guidance ou não
  • 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 for 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto negativas pré-geradas. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, 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

< >

( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor

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

classe diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput

< >

( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )

Parâmetros

  • images (list[PIL.Image.Image] ou np.ndarray) — lista de imagens PIL desruidas 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.

Update on GitHub