# # Licenciado sob a Apache License, Versão 2.0 (a "Licença"); # você não pode usar este arquivo, exceto em conformidade com a Licença. # Você pode obter uma cópia da Licença em # # http://www.apache.org/licenses/LICENSE-2.0 # # A menos que exigido pela lei aplicável ou acordado por escrito, o software # distribuído sob a Licença é distribuído em uma base "COMO ESTÁ", # SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. # Consulte a Licença para o idioma específico que rege as permissões e # limitações sob a Licença. --> # QwenImage O Qwen-Image, da equipe Qwen, é um modelo de fundação para geração de imagens da série Qwen que alcança avanços significativos na renderização de texto complexo e na edição precisa de imagens. Experimentos demonstram capacidades gerais robustas tanto na geração quanto na edição de imagens, com desempenho excepcional na renderização de texto, especialmente para o chinês. O Qwen-Image está disponível nas seguintes variantes: | tipo de modelo | ID do modelo | |:----------:|:--------:| | Qwen-Image | [`Qwen/Qwen-Image`](https://huggingface.co/Qwen/Qwen-Image) | | Qwen-Image-Edit | [`Qwen/Qwen-Image-Edit`](https://huggingface.co/Qwen/Qwen-Image-Edit) | | Qwen-Image-Edit Plus | [Qwen/Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509) | > [!TIP] > Consulte o guia de [Caching](../../optimization/cache) para acelerar a inferência armazenando e reutilizando saídas intermediárias. ## LoRA para inferência mais rápida Use um LoRA de `lightx2v/Qwen-Image-Lightning` para acelerar a inferência, reduzindo o número de etapas. Consulte o trecho de código abaixo: Código ```py from diffusers import DiffusionPipeline, FlowMatchEulerDiscreteScheduler import torch import math ckpt_id = "Qwen/Qwen-Image" # From # https://github.com/ModelTC/Qwen-Image-Lightning/blob/342260e8f5468d2f24d084ce04f55e101007118b/generate_with_diffusers.py#L82C9-L97C10 scheduler_config = { "base_image_seq_len": 256, "base_shift": math.log(3), # We use shift=3 in distillation "invert_sigmas": False, "max_image_seq_len": 8192, "max_shift": math.log(3), # We use shift=3 in distillation "num_train_timesteps": 1000, "shift": 1.0, "shift_terminal": None, # set shift_terminal to None "stochastic_sampling": False, "time_shift_type": "exponential", "use_beta_sigmas": False, "use_dynamic_shifting": True, "use_exponential_sigmas": False, "use_karras_sigmas": False, } scheduler = FlowMatchEulerDiscreteScheduler.from_config(scheduler_config) pipe = DiffusionPipeline.from_pretrained( ckpt_id, scheduler=scheduler, dtype=torch.bfloat16 ).to("cuda") # or "mps", "xpu", "cpu" pipe.load_lora_weights( "lightx2v/Qwen-Image-Lightning", weight_name="Qwen-Image-Lightning-8steps-V1.0.safetensors" ) prompt = "a tiny astronaut hatching from an egg on the moon, Ultra HD, 4K, cinematic composition." negative_prompt = " " image = pipe( prompt=prompt, negative_prompt=negative_prompt, width=1024, height=1024, num_inference_steps=8, true_cfg_scale=1.0, generator=torch.manual_seed(0), ).images[0] image.save("qwen_fewsteps.png") ``` > [!TIP] > O parâmetro `guidance_scale` no pipeline está presente para suportar futuros modelos destilados por orientação quando surgirem. Observe que passar `guidance_scale` para o pipeline é ineficaz. Para habilitar a orientação sem classificador, passe `true_cfg_scale` e `negative_prompt` (mesmo um prompt negativo vazio, como " ") para habilitar os cálculos de orientação sem classificador. ## Referência de múltiplas imagens com QwenImageEditPlusPipeline Com o [QwenImageEditPlusPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/qwenimage#diffusers.QwenImageEditPlusPipeline), é possível fornecer múltiplas imagens como referência de entrada. ```py import torch from PIL import Image from diffusers import QwenImageEditPlusPipeline from diffusers.utils import load_image pipe = QwenImageEditPlusPipeline.from_pretrained( "Qwen/Qwen-Image-Edit-2509", dtype=torch.bfloat16 ).to("cuda") # or "mps", "xpu", "cpu" image_1 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/grumpy.jpg") image_2 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/peng.png") image = pipe( image=[image_1, image_2], prompt='''put the penguin and the cat at a game show called "Qwen Edit Plus Games"''', num_inference_steps=50 ).images[0] ``` ## Desempenho ### torch.compile Usar `torch.compile` no transformer fornece uma aceleração de ~2,4x (A100 80GB: 4,70s → 1,93s): ```python import torch from diffusers import QwenImagePipeline pipe = QwenImagePipeline.from_pretrained("Qwen/Qwen-Image", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu" pipe.transformer = torch.compile(pipe.transformer) # First call triggers compilation (~7s overhead) # Subsequent calls run at ~2.4x faster image = pipe("a cat", num_inference_steps=50).images[0] ``` ### Inferência em Lote com Prompts de Comprimento Variável Ao usar classifier-free guidance (CFG) com prompts de comprimentos diferentes, o pipeline trata o padding corretamente por meio de mascaramento de atenção. Isso garante que os tokens de padding não influenciem a saída gerada. ```python # CFG with different prompt lengths works correctly image = pipe( prompt="A cat", negative_prompt="blurry, low quality, distorted", true_cfg_scale=3.5, num_inference_steps=50, ).images[0] ``` Para scripts e resultados detalhados de benchmark, consulte [este gist](https://gist.github.com/cdutr/bea337e4680268168550292d7819dc2f). ## QwenImagePipeline[[diffusers.QwenImagePipeline]] #### diffusers.QwenImagePipeline[[diffusers.QwenImagePipeline]] ```python diffusers.QwenImagePipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L132) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline QwenImage para geração de imagens a partir de texto. #### __call__[[diffusers.QwenImagePipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L408) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao texto do `prompt`, geralmente em detrimento de uma menor qualidade de imagem. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. 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. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from diffusers import QwenImagePipeline >>> pipe = QwenImagePipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> prompt = "A cat holding a sign that says hello world" >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> image = pipe(prompt, num_inference_steps=50).images[0] >>> image.save("qwenimage.png") ``` #### encode_prompt[[diffusers.QwenImagePipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L225) **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 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`. ## QwenImageImg2ImgPipeline[[diffusers.QwenImageImg2ImgPipeline]] #### diffusers.QwenImageImg2ImgPipeline[[diffusers.QwenImageImg2ImgPipeline]] ```python diffusers.QwenImageImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L134) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline QwenImage para geração de imagens a partir de texto. #### __call__[[diffusers.QwenImageImg2ImgPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L482) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. true_cfg_scale (`float`, *opcional*, padrão 1.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao texto do `prompt`, geralmente em detrimento de uma menor qualidade de imagem. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. strength (`float`, *opcional*, padrão 1.0) : 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, em detrimento de uma inferência mais lenta. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from diffusers import QwenImageImg2ImgPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageImg2ImgPipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16) >>> pipe = pipe.to("cuda") >>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" >>> init_image = load_image(url).resize((1024, 1024)) >>> prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney" >>> images = pipe(prompt=prompt, negative_prompt=" ", image=init_image, strength=0.95).images[0] >>> images.save("qwenimage_img2img.png") ``` #### encode_prompt[[diffusers.QwenImageImg2ImgPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L268) **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 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`. ## QwenImageInpaintPipeline[[diffusers.QwenImageInpaintPipeline]] #### diffusers.QwenImageInpaintPipeline[[diffusers.QwenImageInpaintPipeline]] ```python diffusers.QwenImageInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L137) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline QwenImage para geração de imagens a partir de texto. #### __call__[[diffusers.QwenImageInpaintPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L592) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. true_cfg_scale (`float`, *opcional*, padrão 1.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao texto do `prompt`, geralmente em detrimento de uma menor qualidade de imagem. mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, array numpy ou tensor representando um lote de imagens para mascarar `image`. Os pixels brancos na máscara são repintados, enquanto os pixels pretos são preservados. Se `mask_image` for uma imagem PIL, ela é convertida para um único canal (luminância) antes do uso. Se for um array numpy ou tensor pytorch, ele 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)` ou `(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`, `list[torch.Tensor]`) : `Tensor` representando um lote de imagens para mascarar a `image` gerada pelo VAE. Se não for fornecido, o tensor de latentes de máscara será gerado por `mask_image`. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. padding_mask_crop (`int`, *opcional*, padrão `None`) : O tamanho da margem no recorte a ser aplicado à imagem e à máscara. Se `None`, nenhum recorte é aplicado à imagem e à mask_image. Se `padding_mask_crop` não for `None`, primeiro será encontrada uma região retangular com a mesma proporção de aspecto da imagem e que contenha toda a área mascarada, e então essa área será expandida com base em `padding_mask_crop`. A imagem e a mask_image serão então recortadas com base na área expandida antes de serem redimensionadas para o tamanho original da imagem para o inpainting. Isso é útil quando a área mascarada é pequena, mas 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 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, em detrimento de uma inferência mais lenta. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from diffusers import QwenImageInpaintPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageInpaintPipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench" >>> 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" >>> source = load_image(img_url) >>> mask = load_image(mask_url) >>> image = pipe(prompt=prompt, negative_prompt=" ", image=source, mask_image=mask, strength=0.85).images[0] >>> image.save("qwenimage_inpainting.png") ``` #### encode_prompt[[diffusers.QwenImageInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L279) **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 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`. ## QwenImageEditPipeline[[diffusers.QwenImageEditPipeline]] #### diffusers.QwenImageEditPipeline[[diffusers.QwenImageEditPipeline]] ```python diffusers.QwenImageEditPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L165) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline Qwen-Image-Edit para edição de imagens. #### __call__[[diffusers.QwenImageEditPipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L504) **Parâmetros:** image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : true_cfg_scale (`float`, *opcional*, padrão 1.0): Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. 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. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from PIL import Image >>> from diffusers import QwenImageEditPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageEditPipeline.from_pretrained("Qwen/Qwen-Image-Edit", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png" ... ).convert("RGB") >>> prompt = ( ... "Make Pikachu hold a sign that says 'Qwen Edit is awesome', yarn art style, detailed, vibrant colors" ... ) >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> image = pipe(image, prompt, num_inference_steps=50).images[0] >>> image.save("qwenimage_edit.png") ``` #### encode_prompt[[diffusers.QwenImageEditPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L272) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado image (`torch.Tensor`, *opcional*) : imagem a ser codificada device : (`torch.device`): dispositivo torch num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt 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`. ## QwenImageEditInpaintPipeline[[diffusers.QwenImageEditInpaintPipeline]] #### diffusers.QwenImageEditInpaintPipeline[[diffusers.QwenImageEditInpaintPipeline]] ```python diffusers.QwenImageEditInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L167) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline Qwen-Image-Edit para edição de imagens. #### __call__[[diffusers.QwenImageEditInpaintPipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L637) **Parâmetros:** image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : true_cfg_scale (`float`, *opcional*, padrão 1.0): Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, array numpy ou tensor representando um lote de imagens para mascarar `image`. Os pixels brancos na máscara são repintados, enquanto os pixels pretos são preservados. Se `mask_image` for uma imagem PIL, ela é convertida para um único canal (luminância) antes do uso. Se for um array numpy ou tensor pytorch, ele 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)` ou `(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`, `list[torch.Tensor]`) : `Tensor` representando um lote de imagens para mascarar a `image` gerada pelo VAE. Se não for fornecido, o tensor de latentes da máscara será gerado por `mask_image`. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. padding_mask_crop (`int`, *opcional*, padrão `None`) : O tamanho da margem no recorte a ser aplicado à imagem e à máscara. Se `None`, nenhum recorte é aplicado à imagem e à mask_image. Se `padding_mask_crop` não for `None`, primeiro será encontrada uma região retangular com a mesma proporção de aspecto da imagem e que contenha toda a área mascarada, e então essa área será expandida com base em `padding_mask_crop`. A imagem e a mask_image serão então recortadas com base na área expandida antes de serem redimensionadas para o tamanho original da imagem para o inpainting. Isso é útil quando a área mascarada é pequena, mas 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 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, em detrimento de uma inferência mais lenta. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from PIL import Image >>> from diffusers import QwenImageEditInpaintPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageEditInpaintPipeline.from_pretrained("Qwen/Qwen-Image-Edit", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench" >>> 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" >>> source = load_image(img_url) >>> mask = load_image(mask_url) >>> image = pipe( ... prompt=prompt, negative_prompt=" ", image=source, mask_image=mask, strength=1.0, num_inference_steps=50 ... ).images[0] >>> image.save("qwenimage_inpainting.png") ``` #### encode_prompt[[diffusers.QwenImageEditInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L284) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado image (`torch.Tensor`, *opcional*) : imagem a ser codificada device : (`torch.device`): dispositivo torch num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt 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`. ## QwenImageControlNetPipeline[[diffusers.QwenImageControlNetPipeline]] #### diffusers.QwenImageControlNetPipeline[[diffusers.QwenImageControlNetPipeline]] ```python diffusers.QwenImageControlNetPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_qwenimage.QwenImageControlNetModel | diffusers.models.controlnets.controlnet_qwenimage.QwenImageMultiControlNetModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L192) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline QwenImage para geração de imagens a partir de texto. #### __call__[[diffusers.QwenImageControlNetPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L511) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao texto do `prompt`, geralmente em detrimento de uma menor qualidade de imagem. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. 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. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). control_guidance_start (`float` ou `list[float]`, *opcional*, padrão 0.0) : A porcentagem do total de etapas em que o ControlNet começa a ser aplicado. control_guidance_end (`float` ou `list[float]`, *opcional*, padrão 1.0) : A porcentagem do total de etapas em que o ControlNet para de ser aplicado. control_image (`PipelineImageInput`, *opcional*) : A condição de entrada do ControlNet para fornecer orientação para a geração. controlnet_conditioning_scale (`float` ou `list[float]`, *opcional*, padrão 1.0) : As saídas do ControlNet são multiplicadas por `controlnet_conditioning_scale` antes de serem adicionadas ao residual no `transformer` original. num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from diffusers.utils import load_image >>> from diffusers import QwenImageControlNetModel, QwenImageMultiControlNetModel, QwenImageControlNetPipeline >>> # QwenImageControlNetModel >>> controlnet = QwenImageControlNetModel.from_pretrained( ... "InstantX/Qwen-Image-ControlNet-Union", torch_dtype=torch.bfloat16 ... ) >>> pipe = QwenImageControlNetPipeline.from_pretrained( ... "Qwen/Qwen-Image", controlnet=controlnet, torch_dtype=torch.bfloat16 ... ) >>> pipe.to("cuda") >>> prompt = "Aesthetics art, traditional asian pagoda, elaborate golden accents, sky blue and white color palette, swirling cloud pattern, digital illustration, east asian architecture, ornamental rooftop, intricate detailing on building, cultural representation." >>> negative_prompt = " " >>> control_image = load_image( ... "https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union/resolve/main/conds/canny.png" ... ) >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> image = pipe( ... prompt, ... negative_prompt=negative_prompt, ... control_image=control_image, ... controlnet_conditioning_scale=1.0, ... num_inference_steps=30, ... true_cfg_scale=4.0, ... ).images[0] >>> image.save("qwenimage_cn_union.png") >>> # QwenImageMultiControlNetModel >>> controlnet = QwenImageControlNetModel.from_pretrained( ... "InstantX/Qwen-Image-ControlNet-Union", torch_dtype=torch.bfloat16 ... ) >>> controlnet = QwenImageMultiControlNetModel([controlnet]) >>> pipe = QwenImageControlNetPipeline.from_pretrained( ... "Qwen/Qwen-Image", controlnet=controlnet, torch_dtype=torch.bfloat16 ... ) >>> pipe.to("cuda") >>> prompt = "Aesthetics art, traditional asian pagoda, elaborate golden accents, sky blue and white color palette, swirling cloud pattern, digital illustration, east asian architecture, ornamental rooftop, intricate detailing on building, cultural representation." >>> negative_prompt = " " >>> control_image = load_image( ... "https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union/resolve/main/conds/canny.png" ... ) >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> image = pipe( ... prompt, ... negative_prompt=negative_prompt, ... control_image=[control_image, control_image], ... controlnet_conditioning_scale=[0.5, 0.5], ... num_inference_steps=30, ... true_cfg_scale=4.0, ... ).images[0] >>> image.save("qwenimage_cn_union_multi.png") ``` #### encode_prompt[[diffusers.QwenImageControlNetPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L290) **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 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`. ## QwenImageEditPlusPipeline[[diffusers.QwenImageEditPlusPipeline]] #### diffusers.QwenImageEditPlusPipeline[[diffusers.QwenImageEditPlusPipeline]] ```python diffusers.QwenImageEditPlusPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L168) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline Qwen-Image-Edit para edição de imagens. #### __call__[[diffusers.QwenImageEditPlusPipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L526) **Parâmetros:** image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : true_cfg_scale (`float`, *opcional*, padrão 1.0): Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. 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. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from PIL import Image >>> from diffusers import QwenImageEditPlusPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageEditPlusPipeline.from_pretrained("Qwen/Qwen-Image-Edit-2509", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png" ... ).convert("RGB") >>> prompt = ( ... "Make Pikachu hold a sign that says 'Qwen Edit is awesome', yarn art style, detailed, vibrant colors" ... ) >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> image = pipe(image, prompt, num_inference_steps=50).images[0] >>> image.save("qwenimage_edit_plus.png") ``` #### encode_prompt[[diffusers.QwenImageEditPlusPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L286) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado image (`torch.Tensor`, *opcional*) : imagem a ser codificada device : (`torch.device`): dispositivo torch num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt 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`. ## QwenImageLayeredPipeline[[diffusers.QwenImageLayeredPipeline]] #### diffusers.QwenImageLayeredPipeline[[diffusers.QwenImageLayeredPipeline]] ```python diffusers.QwenImageLayeredPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L174) **Parâmetros:** transformer ([QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), especificamente a variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer da classe https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer O pipeline Qwen-Image-Layered para decomposição de imagens. #### __call__[[diffusers.QwenImageLayeredPipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, layers: int | None = 4, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, resolution: int = 640, cfg_normalize: bool = False, use_en_prompt: bool = False) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L537) **Parâmetros:** image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[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 como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. 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 `true_cfg_scale` não for maior que `1`). true_cfg_scale (`float`, *opcional*, padrão 1.0) : true_cfg_scale (`float`, *opcional*, padrão 1.0): Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A orientação sem classificador é ativada ao definir `true_cfg_scale > 1` e fornecer um `negative_prompt`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. layers (`int`, *opcional*, padrão 4) : Número de camadas latentes a serem geradas para a saída em camadas. 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. 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 None) : Um valor de escala de orientação para modelos destilados de orientação. Diferentemente da orientação livre de classificador tradicional, onde a escala de orientação é aplicada durante a inferência por meio do reescalonamento da previsão de ruído, os modelos destilados de orientação recebem a escala de orientação diretamente como um parâmetro de entrada durante a passagem para frente. A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação mais alta incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente às custas de uma menor qualidade de imagem. Este parâmetro no pipeline está presente para suportar futuros modelos destilados de orientação quando surgirem. Ele é ignorado quando não se está usando modelos destilados de orientação. Para ativar a orientação livre de classificador tradicional, passe `true_cfg_scale > 1.0` e `negative_prompt` (mesmo um prompt negativo vazio como " " deve ativar os cálculos de orientação livre de classificador). num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `prompt_embeds`. 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`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para `negative_prompt_embeds`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`. resolution (`int`, *opcional*, padrão 640) : usar um bucket diferente em (640, 1024) para determinar a resolução da condição e da saída cfg_normalize (`bool`, *opcional*, padrão `False`) : se a normalização de cfg deve ser habilitada. use_en_prompt (`bool`, *opcional*, padrão `False`) : idioma da legenda automática caso o usuário não forneça uma legenda **Retorna:** `~pipelines.qwenimage.QwenImagePipelineOutput` ou `tuple` `~pipelines.qwenimage.QwenImagePipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas. Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from PIL import Image >>> from diffusers import QwenImageLayeredPipeline >>> from diffusers.utils import load_image >>> pipe = QwenImageLayeredPipeline.from_pretrained("Qwen/Qwen-Image-Layered", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png" ... ).convert("RGBA") >>> prompt = "" >>> # Depending on the variant being used, the pipeline call will slightly vary. >>> # Refer to the pipeline documentation for more details. >>> images = pipe( ... image, ... prompt, ... num_inference_steps=50, ... true_cfg_scale=4.0, ... layers=4, ... resolution=640, ... cfg_normalize=False, ... use_en_prompt=True, ... ).images[0] >>> for i, image in enumerate(images): ... image.save(f"{i}.out.png") ``` #### encode_prompt[[diffusers.QwenImageLayeredPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L291) **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 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`. ## QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]] #### diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]] ```python diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/qwenimage/pipeline_output.py#L10) **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)`. As imagens PIL ou o array numpy apresentam as imagens desruidas do pipeline de difusão. Classe de saída para pipelines do Stable Diffusion.