Diffusers documentation
Imagem para imagem
Imagem para imagem
O modelo Stable Diffusion também pode ser aplicado à geração de imagem-para-imagem, passando um prompt de texto e uma imagem inicial para condicionar a geração de novas imagens.
O StableDiffusionImg2ImgPipeline utiliza o mecanismo de difusão-desruidamento proposto em SDEdit: Guided Image Synthesis and Editing with Stochastic Differential Equations, por Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, Stefano Ermon.
O resumo do artigo é:
A síntese de imagens guiada permite que usuários comuns criem e editem imagens fotorrealistas com o mínimo de esforço. O principal desafio é equilibrar a fidelidade à entrada do usuário (por exemplo, traços coloridos desenhados à mão) e o realismo da imagem sintetizada. Métodos baseados em GAN existentes tentam alcançar esse equilíbrio usando GANs condicionais ou inversões de GAN, o que é desafiador e frequentemente requer dados de treinamento adicionais ou funções de perda para aplicações individuais. Para resolver esses problemas, introduzimos um novo método de síntese e edição de imagens, Stochastic Differential Editing (SDEdit), baseado em um prior generativo de modelo de difusão, que sintetiza imagens realistas por meio de um desruidamento iterativo através de uma equação diferencial estocástica (SDE). Dada uma imagem de entrada com um guia do usuário de qualquer tipo, o SDEdit primeiro adiciona ruído à entrada e, em seguida, desruída a imagem resultante por meio do prior SDE para aumentar seu realismo. O SDEdit não requer treinamento específico para a tarefa nem inversões e pode alcançar naturalmente o equilíbrio entre realismo e fidelidade. O SDEdit supera significativamente os métodos baseados em GAN do estado da arte em até 98,09% em realismo e 91,72% nas pontuações de satisfação geral, de acordo com um estudo de percepção humana, em várias tarefas, incluindo síntese e edição de imagens baseadas em traços, bem como composição de imagens.
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!
StableDiffusionImg2ImgPipeline
classe diffusers.StableDiffusionImg2ImgPipeline
< source >( 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
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Um
UNet2DConditionModelpara desruidar os latentes da imagem codificada. - scheduler (SchedulerMixin) —
Um scheduler a ser usado em combinação com
unetpara 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
CLIPImageProcessorpara extrair recursos de imagens geradas; usado como entradas para osafety_checker.
Pipeline para geração de imagem a partir de imagem guiada por texto 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:
- load_textual_inversion() para carregar embeddings de inversão textual
- load_lora_weights() para carregar os pesos do LoRA
- save_lora_weights() para salvar os pesos do LoRA
- para carregar arquivos
.ckptcom from_single_file() - load_ip_adapter() para carregar IP Adapters
__call__
< source >( prompt: str | list[str] = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonestrength: float = 0.8num_inference_steps: int | None = 50timesteps: list = Nonesigmas: list = Noneguidance_scale: float | None = 7.5negative_prompt: str | list[str] | None = Nonenum_images_per_prompt: int | None = 1eta: float | None = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = 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 = Noneclip_skip: int = 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 = ['latents']**kwargs ) → StableDiffusionPipelineOutput or tuple
Parâmetros
- prompt (
stroulist[str], opcional) — O prompt ou os prompts para orientar a geração de imagens. Se não for definido, você precisa passarprompt_embeds. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]oulist[np.ndarray]) —Image, array numpy ou tensor representando um lote de imagens a ser usado como ponto de partida. Para arrays numpy e tensors pytorch, o intervalo de valores esperado é entre[0, 1]Se for um tensor ou uma lista de tensors, a forma esperada deve ser(B, C, H, W)ou(C, H, W). Se for um array numpy ou uma lista de arrays, a forma esperada deve ser(B, H, W, C)ou(H, W, C)Também pode aceitar latentes de imagem comoimage, mas, se latentes forem passados diretamente, eles não são codificados novamente. - strength (
float, opcional, padrão 0.8) — Indica o grau de transformação daimagede referência. Deve estar entre 0 e 1. Aimageé usada como ponto de partida e mais ruído é adicionado quanto maior for ostrength. O número de etapas de desruidamento depende da quantidade de ruído inicialmente adicionada. Quandostrengthé 1, o ruído adicionado é máximo e o processo de desruidamento é executado pelo número total de iterações especificado emnum_inference_steps. Um valor de 1 essencialmente ignora aimage. - 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. Este parâmetro é modulado porstrength. - timesteps (
list[int], opcional) — Timesteps personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumentotimestepsem seu métodoset_timesteps. Se não definido, o comportamento padrão quandonum_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 argumentosigmasem seu métodoset_timesteps. Se não definido, o comportamento padrão quandonum_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 textoprompt, em detrimento da qualidade da imagem. O guidance scale é ativado quandoguidance_scale > 1. - negative_prompt (
stroulist[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 passarnegative_prompt_embedsem 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.Generatoroulist[torch.Generator], opcional) — Umtorch.Generatorpara 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 entradaprompt. - 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, osnegative_prompt_embedssão gerados a partir do argumento de entradanegative_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 sedo_classifier_free_guidanceestiver definido comoTrue. Se não for fornecido, as incorporações são calculadas a partir do argumento de entradaip_adapter_image. - output_type (
str, opcional, padrão"pil") — O formato de saída da imagem gerada. Escolha entrePIL.Imageounp.array. - return_dict (
bool, opcional, padrãoTrue) — 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 aoAttentionProcessorconforme definido emself.processor. - 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 dePipelineCallbackouMultiPipelineCallbacksque é 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_kwargsincluirá uma lista de todos os tensores, conforme especificado porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — A lista de entradas de tensor para a funçãocallback_on_step_end. Os tensores especificados na lista serão passados como argumentocallback_kwargs. Você só poderá incluir variáveis listadas no atributo._callback_tensor_inputsda sua classe de pipeline.
Retorna
StableDiffusionPipelineOutput ou tuple
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 requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import StableDiffusionImg2ImgPipeline
>>> device = "cuda"
>>> model_id_or_path = "stable-diffusion-v1-5/stable-diffusion-v1-5"
>>> pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
>>> pipe = pipe.to(device)
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))
>>> prompt = "A fantasy landscape, trending on artstation"
>>> images = pipe(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images
>>> images[0].save("fantasy_landscape.png")enable_attention_slicing
< source >( slice_size: str | int = 'auto' )
Parâmetros
- slice_size (
strouint, 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 quantoattention_head_dim // slice_size. Nesse caso,attention_head_dimdeve ser um múltiplo deslice_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]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
< source >( attention_op: typing.Optional[typing.Callable] = None )
Parâmetros
- attention_op (
Callable, opcional) — Substitui o operador padrãoNonepara uso como argumentoopda funçãomemory_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)Desative a atenção eficiente em memória do xFormers.
load_textual_inversion
< source >( 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 (
strouos.PathLikeoulist[str or os.PathLike]ouDictoulist[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.
- Uma string, o id do modelo (por exemplo,
- token (
stroulist[str], opcional) — Substitui o token a ser usado para os pesos de inversão textual. Sepretrained_model_name_or_pathfor uma lista, entãotokentambé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
CLIPTokenizerpara 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.
- O arquivo de inversão textual salvo está no formato 🤗 Diffusers, mas foi salvo sob um nome de peso específico, como
- 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ãoFalse) — 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ãoFalse) — Se deve carregar apenas os pesos e arquivos de configuração do modelo localmente. Se definido comoTrue, o modelo não será baixado do Hub. - hf_token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, o token gerado a partir dediffusers-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
< source >( pretrained_model_link_or_path**kwargs )
Parâmetros
- pretrained_model_link_or_path (
strouos.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.
- Um link para o arquivo
- dtype (
stroutorch.dtype, opcional) — Substitui otorch.dtypepadrão e carrega o modelo com outro dtype. - force_download (
bool, opcional, padrãoFalse) — 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ãoFalse) — Se deve carregar apenas os pesos e arquivos de configuração do modelo localmente. Se definido comoTrue, o modelo não será baixado do Hub. - token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, o token gerado pordiffusers-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.
- Uma string, o repo id (por exemplo,
- 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
< source >( 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 (
strouos.PathLikeoudict) — 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á usadodefault_{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, oadapter_namedeve 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:
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
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict = Nonetext_encoder_lora_layers: dict = 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 (
strouos.PathLike) — Diretório para salvar os parâmetros LoRA. Será criado se não existir. - unet_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dicionário de estado das camadas LoRA correspondentes aounet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — State dict das camadas LoRA correspondentes aotext_encoder. É necessário passar explicitamente o state dict das LoRA do text encoder, pois ele vem do 🤗 Transformers. - is_main_process (
bool, opcional, padrãoTrue) — 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, definais_main_process=Trueapenas 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 substituirtorch.savepor outro método. Pode ser configurado com a variável de ambienteDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch compickle. - 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
< source >( 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 (
stroulist[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 (
stroulist[str], opcional) — O prompt ou os prompts que não devem orientar a geração da imagem. Se não for definido, é necessário passarnegative_prompt_embedsem vez disso. Ignorado quando não se usa orientação (ou seja, ignorado seguidance_scalefor menor que1). - 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 entradaprompt. - 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 entradanegative_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
< source >( 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ãotorch.float32) — Tipo de dados dos embeddings gerados.
Retorna
torch.Tensor
Vetores de incorporação com forma (len(w), embedding_dim).
StableDiffusionPipelineOutput
classe diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput
< source >( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )
Parâmetros
- images (
list[PIL.Image.Image]ounp.ndarray) — lista de imagens PIL desruidas de comprimentobatch_sizeou 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) ouNonese a verificação de segurança não pôde ser realizada.
Classe de saída para pipelines do Stable Diffusion.