Diffusers documentation
Inpainting
Inpainting
O modelo Stable Diffusion também pode ser aplicado ao inpainting, que permite editar partes específicas de uma imagem fornecendo uma máscara e um prompt de texto usando o Stable Diffusion.
Dicas
É recomendável usar este pipeline com checkpoints que foram especificamente ajustados para inpainting, como stable-diffusion-v1-5/stable-diffusion-inpainting. Checkpoints padrão de texto para imagem do Stable Diffusion, como stable-diffusion-v1-5/stable-diffusion-v1-5, também são compatíveis, mas podem ter desempenho inferior.
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!
StableDiffusionInpaintPipeline
classe diffusers.StableDiffusionInpaintPipeline
< source >( vae: diffusers.models.autoencoders.autoencoder_kl.AutoencoderKL | diffusers.models.autoencoders.autoencoder_asym_kl.AsymmetricAutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: KarrasDiffusionSchedulerssafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: CLIPVisionModelWithProjection = Nonerequires_safety_checker: bool = True )
Parâmetros
- vae ([
AutoencoderKL,AsymmetricAutoencoderKL]) — 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 inpainting de imagens guiado 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
- load_ip_adapter() para carregar IP Adapters
- para carregar arquivos
.ckptcom from_single_file()
__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]] = Nonemask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonemasked_image_latents: Tensor = Noneheight: int | None = Nonewidth: int | None = Nonepadding_mask_crop: int | None = Nonestrength: float = 1.0num_inference_steps: int = 50timesteps: list = Nonesigmas: list = 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 = 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 inpaintado (quais partes da imagem devem ser mascaradas commask_imagee repintadas de acordo comprompt). 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. - mask_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 para mascararimage. Os pixels brancos na máscara são repintados, enquanto os pixels pretos são preservados. Semask_imagefor uma imagem PIL, ela é convertida para um único canal (luminância) antes do uso. Se for um array numpy ou tensor pytorch, deve conter um único canal de cor (L) em vez de 3, portanto a forma esperada para um tensor pytorch seria(B, 1, H, W),(B, H, W),(1, H, W),(H, W). E para um array numpy seria(B, H, W, 1),(B, H, W),(H, W, 1)ou(H, W). - masked_image_latents (
torch.Tensor, opcional) — Latente pré-codificado da imagem mascarada (para inpainting). - height (
int, opcional, padrãoself.unet.config.sample_size * self.vae_scale_factor) — A altura em pixels da imagem gerada. - width (
int, opcional, padrãoself.unet.config.sample_size * self.vae_scale_factor) — A largura em pixels da imagem gerada. - padding_mask_crop (
int, opcional, padrãoNone) — O tamanho da margem no recorte a ser aplicado à imagem e à máscara. SeNone, nenhum recorte é aplicado à imagem e à mask_image. Sepadding_mask_cropnão forNone, primeiro será encontrada uma região retangular com a mesma proporção da imagem e que contenha toda a área mascarada, e então essa área será expandida com base empadding_mask_crop. A imagem e a mask_image serão então recortadas com base na área expandida antes do redimensionamento para o tamanho original da imagem para o inpainting. Isso é útil quando a área mascarada é pequena, enquanto a imagem é grande e contém informações irrelevantes para o inpainting, como o fundo. - strength (
float, opcional, padrão 1.0) — 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. - 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 ogeneratoraleató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 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 PIL
>>> import requests
>>> import torch
>>> from io import BytesIO
>>> from diffusers import StableDiffusionInpaintPipeline
>>> def download_image(url):
... response = requests.get(url)
... return PIL.Image.open(BytesIO(response.content)).convert("RGB")
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> init_image = download_image(img_url).resize((512, 512))
>>> mask_image = download_image(mask_url).resize((512, 512))
>>> pipe = StableDiffusionInpaintPipeline.from_pretrained(
... "stable-diffusion-v1-5/stable-diffusion-inpainting", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]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")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.