Buckets:
| # ControlNet com Hunyuan-DiT | |
| HunyuanDiTControlNetPipeline é uma implementação do ControlNet para [Hunyuan-DiT](https://huggingface.co/papers/2405.08748). | |
| ControlNet foi introduzido em [Adding Conditional Control to Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.05543) por Lvmin Zhang, Anyi Rao e Maneesh Agrawala. | |
| Com um modelo ControlNet, você pode fornecer uma imagem de controle adicional para condicionar e controlar a geração do Hunyuan-DiT. Por exemplo, se você fornecer um mapa de profundidade, o modelo ControlNet gera uma imagem que preservará as informações espaciais do mapa de profundidade. É uma maneira mais flexível e precisa de controlar o processo de geração de imagens. | |
| O resumo do artigo é: | |
| *Apresentamos o ControlNet, uma arquitetura de rede neural para adicionar controles de condicionamento espacial a grandes modelos de difusão de texto para imagem pré-treinados. O ControlNet trava os grandes modelos de difusão prontos para produção e reutiliza suas camadas de codificação profundas e robustas, pré-treinadas com bilhões de imagens, como uma base forte para aprender um conjunto diversificado de controles condicionais. A arquitetura neural é conectada com "convoluções zero" (camadas de convolução inicializadas em zero) que crescem progressivamente os parâmetros a partir de zero e garantem que nenhum ruído prejudicial possa afetar o ajuste fino. Testamos vários controles de condicionamento, por exemplo, bordas, profundidade, segmentação, pose humana, etc., com o Stable Diffusion, usando condições únicas ou múltiplas, com ou sem prompts. Mostramos que o treinamento dos ControlNets é robusto com conjuntos de dados pequenos (<50k) e grandes (>1m). Resultados extensos mostram que o ControlNet pode facilitar aplicações mais amplas para controlar modelos de difusão de imagem.* | |
| Este código foi implementado pela equipe Tencent Hunyuan. Você pode encontrar checkpoints pré-treinados para ControlNets do Hunyuan-DiT em [Tencent Hunyuan](https://huggingface.co/Tencent-Hunyuan). | |
| > [!TIP] | |
| > Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines. | |
| ## HunyuanDiTControlNetPipeline[[diffusers.HunyuanDiTControlNetPipeline]] | |
| #### diffusers.HunyuanDiTControlNetPipeline[[diffusers.HunyuanDiTControlNetPipeline]] | |
| ```python | |
| diffusers.HunyuanDiTControlNetPipeline(vae: AutoencoderKL, text_encoder: BertModel, tokenizer: BertTokenizer, transformer: HunyuanDiT2DModel, scheduler: DDPMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, controlnet: diffusers.models.controlnets.controlnet_hunyuan.HunyuanDiT2DControlNetModel | list[diffusers.models.controlnets.controlnet_hunyuan.HunyuanDiT2DControlNetModel] | tuple[diffusers.models.controlnets.controlnet_hunyuan.HunyuanDiT2DControlNetModel] | diffusers.models.controlnets.controlnet_hunyuan.HunyuanDiT2DMultiControlNetModel, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | None = None, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | None = None, requires_safety_checker: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet_hunyuandit/pipeline_hunyuandit_controlnet.py#L165) | |
| **Parâmetros:** | |
| vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. Usamos `sdxl-vae-fp16-fix`. | |
| text_encoder (`~transformers.BertModel`, `~transformers.CLIPTextModel` | None) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). O HunyuanDiT usa um [CLIP bilíngue] ajustado finamente. | |
| tokenizer (`~transformers.BertTokenizer`, `~transformers.CLIPTokenizer` | None) : Um `BertTokenizer` ou `CLIPTokenizer` para tokenizar texto. | |
| transformer ([HunyuanDiT2DModel](/docs/diffusers/main/pt/api/models/hunyuan_transformer2d#diffusers.HunyuanDiT2DModel)) : O modelo HunyuanDiT desenvolvido pelo Tencent Hunyuan. | |
| text_encoder_2 (`T5EncoderModel`) : O incorporador mT5. Especificamente, é o 't5-v1_1-xxl'. | |
| tokenizer_2 (`T5Tokenizer`) : O tokenizador do incorporador mT5. | |
| scheduler ([DDPMScheduler](/docs/diffusers/main/pt/api/schedulers/ddpm#diffusers.DDPMScheduler)) : Um agendador a ser usado em combinação com HunyuanDiT para desruidar os latentes de imagem codificados. | |
| controlnet ([HunyuanDiT2DControlNetModel](/docs/diffusers/main/pt/api/models/controlnet_hunyuandit#diffusers.HunyuanDiT2DControlNetModel) ou `list[HunyuanDiT2DControlNetModel]` ou [HunyuanDiT2DControlNetModel](/docs/diffusers/main/pt/api/models/controlnet_hunyuandit#diffusers.HunyuanDiT2DControlNetModel)) : Fornece condicionamento adicional ao `unet` durante o processo de desruidamento. Se você definir múltiplos ControlNets como uma lista, as saídas de cada ControlNet são somadas para criar um único condicionamento adicional combinado. | |
| Pipeline para geração de imagens a partir de inglês/chinês usando HunyuanDiT. | |
| Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os pipelines (como download ou salvamento, execução em um dispositivo específico, etc.) | |
| HunyuanDiT usa dois codificadores de texto: [mT5](https://huggingface.co/google/mt5-base) e [CLIP bilíngue](ajustado por nós mesmos) | |
| #### __call__[[diffusers.HunyuanDiTControlNetPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int | None = 50, guidance_scale: float | None = 5.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, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, prompt_attention_mask_2: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask_2: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = (1024, 1024), target_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), use_resolution_binning: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet_hunyuandit/pipeline_hunyuandit_controlnet.py#L632) | |
| **Parâmetros:** | |
| prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração de imagens. Se não definido, você precisa passar `prompt_embeds`. | |
| height (`int`) : A altura, em pixels, da imagem gerada. | |
| width (`int`) : A largura, em pixels, da imagem gerada. | |
| num_inference_steps (`int`, *opcional*, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta. Este parâmetro é modulado por `strength`. | |
| guidance_scale (`float`, *opcional*, padrão 7.5) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`. | |
| control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` ou `list[list[PIL.Image.Image]]`): A condição de entrada do ControlNet para fornecer orientação ao `unet` para a geração. Se o tipo for especificado como `torch.Tensor`, ele é passado ao ControlNet como está. `PIL.Image.Image` também pode ser aceito como uma imagem. As dimensões da imagem de saída padrão são as dimensões de `image`. Se altura e/ou largura forem passadas, `image` será redimensionada de acordo. Se múltiplos ControlNets forem especificados em `init`, as imagens devem ser passadas como uma lista, de modo que cada elemento da lista possa ser corretamente agrupado (batched) para entrada em um único ControlNet. | |
| 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 `unet` original. Se múltiplos ControlNets forem especificados em `init`, você pode definir a escala correspondente como uma lista. | |
| negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar o que não incluir na geração de imagem. Se não definido, você precisa passar `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale < 1`). | |
| num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. | |
| eta (`float`, *opcional*, padrão 0.0) : Corresponde ao parâmetro eta (η) do paper [DDIM](https://huggingface.co/papers/2010.02502). Aplica-se apenas ao [DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler) e é ignorado em outros agendadores. | |
| generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. | |
| latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. | |
| prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. | |
| prompt_embeds_2 (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. | |
| negative_prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt. Obrigatória quando `prompt_embeds` é passado diretamente. | |
| prompt_attention_mask_2 (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt. Obrigatória quando `prompt_embeds_2` é passado diretamente. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt negativo. Obrigatória quando `negative_prompt_embeds` é passado diretamente. | |
| negative_prompt_attention_mask_2 (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt negativo. Obrigatória quando `negative_prompt_embeds_2` é passado diretamente. | |
| output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [StableDiffusionPipelineOutput](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) em vez de uma tupla simples. | |
| callback_on_step_end (`Callable[[int, int], None]`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função de callback ou uma lista de funções de callback a serem chamadas no final de cada etapa de remoção de ruído. | |
| callback_on_step_end_tensor_inputs (`list[str]`, *opcional*) : Uma lista de entradas de tensor que devem ser passadas para a função de callback. Se não for definida, todas as entradas de tensor serão passadas. | |
| guidance_rescale (`float`, *opcional*, padrão 0.0) : Reescala o noise_cfg de acordo com `guidance_rescale`. Baseado nas descobertas de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Veja a Seção 3.4 | |
| original_size (`tuple[int, int]`, *opcional*, padrão `(1024, 1024)`) : O tamanho original da imagem. Usado para calcular os ids de tempo. | |
| target_size (`tuple[int, int]`, *opcional*) : O tamanho alvo da imagem. Usado para calcular os ids de tempo. | |
| crops_coords_top_left (`tuple[int, int]`, *opcional*, padrão `(0, 0)`) : As coordenadas do canto superior esquerdo do recorte. Usado para calcular os ids de tempo. | |
| use_resolution_binning (`bool`, *opcional*, padrão `True`) : Se deve usar binning de resolução ou não. Se `True`, a resolução de entrada será mapeada para a resolução padrão mais próxima. As resoluções suportadas são 1024x1024, 1280x1280, 1024x768, 1152x864, 1280x960, 768x1024, 864x1152, 960x1280, 1280x768 e 768x1280. Recomenda-se definir este valor como `True`. | |
| **Retorna:** [StableDiffusionPipelineOutput](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple` | |
| Se `return_dict` for `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). | |
| A função de chamada do pipeline para geração com HunyuanDiT. | |
| Exemplos: | |
| ```py | |
| from diffusers import HunyuanDiT2DControlNetModel, HunyuanDiTControlNetPipeline | |
| import torch | |
| controlnet = HunyuanDiT2DControlNetModel.from_pretrained( | |
| "Tencent-Hunyuan/HunyuanDiT-v1.1-ControlNet-Diffusers-Canny", torch_dtype=torch.float16 | |
| ) | |
| pipe = HunyuanDiTControlNetPipeline.from_pretrained( | |
| "Tencent-Hunyuan/HunyuanDiT-v1.1-Diffusers", controlnet=controlnet, torch_dtype=torch.float16 | |
| ) | |
| pipe.to("cuda") | |
| from diffusers.utils import load_image | |
| cond_image = load_image( | |
| "https://huggingface.co/Tencent-Hunyuan/HunyuanDiT-v1.1-ControlNet-Diffusers-Canny/resolve/main/canny.jpg?download=true" | |
| ) | |
| ## You may also use English prompt as HunyuanDiT supports both English and Chinese | |
| prompt = "在夜晚的酒店门前,一座古老的中国风格的狮子雕像矗立着,它的眼睛闪烁着光芒,仿佛在守护着这座建筑。背景是夜晚的酒店前,构图方式是特写,平视,居中构图。这张照片呈现了真实摄影风格,蕴含了中国雕塑文化,同时展现了神秘氛围" | |
| # prompt="At night, an ancient Chinese-style lion statue stands in front of the hotel, its eyes gleaming as if guarding the building. The background is the hotel entrance at night, with a close-up, eye-level, and centered composition. This photo presents a realistic photographic style, embodies Chinese sculpture culture, and reveals a mysterious atmosphere." | |
| image = pipe( | |
| prompt, | |
| height=1024, | |
| width=1024, | |
| control_image=cond_image, | |
| num_inference_steps=50, | |
| ).images[0] | |
| ``` | |
| #### encode_prompt[[diffusers.HunyuanDiTControlNetPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str, device: device = None, dtype: dtype = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int | None = None, text_encoder_index: int = 0) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet_hunyuandit/pipeline_hunyuandit_controlnet.py#L276) | |
| **Parâmetros:** | |
| prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado | |
| device : (`torch.device`): dispositivo torch | |
| dtype (`torch.dtype`) : dtype do torch | |
| num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt | |
| do_classifier_free_guidance (`bool`) : se deve ou não usar classifier free guidance | |
| negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). | |
| prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt. Obrigatória quando `prompt_embeds` é passado diretamente. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção para o prompt negativo. Obrigatória quando `negative_prompt_embeds` é passado diretamente. | |
| max_sequence_length (`int`, *opcional*) : comprimento máximo da sequência a ser usado para o prompt. | |
| text_encoder_index (`int`, *opcional*) : Índice do codificador de texto a ser usado. `0` para clip e `1` para T5. | |
| Codifica o prompt em estados ocultos do codificador de texto. | |
Xet Storage Details
- Size:
- 19.6 kB
- Xet hash:
- f228ac22f03e686f4a54c33ec2e3965680363a424a99410cda252bb0896278f7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.