Hugging Face's logo

Diffusers documentation

UNet2DConditionModel

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

UNet2DConditionModel

Le modèle UNet a été initialement introduit par Ronneberger et al. pour la segmentation d’images biomédicales, mais il est également couramment utilisé dans 🤗 Diffusers car il produit des images de la même taille que l’entrée. C’est l’un des composants les plus importants d’un système de diffusion, car il facilite le processus de diffusion proprement dit. Il existe plusieurs variantes du modèle UNet dans 🤗 Diffusers, en fonction de son nombre de dimensions et de savoir s’il s’agit ou non d’un modèle conditionnel. Il s’agit ici d’un modèle UNet conditionnel 2D.

L'abstract de l'article est :

Il est largement admis que l’entraînement réussi de réseaux profonds nécessite des milliers d’échantillons d’entraînement annotés. Dans cet article, nous présentons un réseau et une stratégie d’entraînement qui reposent sur l’utilisation intensive de l’augmentation de données afin d’exploiter plus efficacement les échantillons annotés disponibles. L’architecture se compose d’un chemin contractant pour capturer le contexte et d’un chemin d’expansion symétrique permettant une localisation précise. Nous montrons qu’un tel réseau peut être entraîné de bout en bout à partir de très peu d’images et qu’il surpasse la meilleure méthode antérieure (un réseau convolutif à fenêtre glissante) lors du défi ISBI de segmentation de structures neuronales dans des piles de microscopie électronique. En utilisant le même réseau entraîné sur des images de microscopie en lumière transmise (contraste de phase et DIC), nous avons remporté le défi ISBI de suivi cellulaire 2015 dans ces catégories avec une large avance. De plus, le réseau est rapide. La segmentation d’une image de 512x512 prend moins d’une seconde sur un GPU récent. L’implémentation complète (basée sur Caffe) et les réseaux entraînés sont disponibles à l’adresse http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.

UNet2DConditionModel

classe diffusers.UNet2DConditionModel

< >

( sample_size: int | tuple[int, int] | None = Nonein_channels: int = 4out_channels: int = 4center_input_sample: bool = Falseflip_sin_to_cos: bool = Truefreq_shift: int = 0down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D')mid_block_type: str | None = 'UNetMidBlock2DCrossAttn'up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D')only_cross_attention: bool | tuple[bool] = Falseblock_out_channels: tuple = (320, 640, 1280, 1280)layers_per_block: int | tuple[int] = 2downsample_padding: int = 1mid_block_scale_factor: float = 1dropout: float = 0.0act_fn: str = 'silu'norm_num_groups: int | None = 32norm_eps: float = 1e-05cross_attention_dim: int | tuple[int] = 1280transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1reverse_transformer_layers_per_block: tuple[tuple[int]] | None = Noneencoder_hid_dim: int | None = Noneencoder_hid_dim_type: str | None = Noneattention_head_dim: int | tuple[int] = 8num_attention_heads: int | tuple[int] | None = Nonedual_cross_attention: bool = Falseuse_linear_projection: bool = Falseclass_embed_type: str | None = Noneaddition_embed_type: str | None = Noneaddition_time_embed_dim: int | None = Nonenum_class_embeds: int | None = Noneupcast_attention: bool = Falseresnet_time_scale_shift: str = 'default'resnet_skip_time_act: bool = Falseresnet_out_scale_factor: float = 1.0time_embedding_type: str = 'positional'time_embedding_dim: int | None = Nonetime_embedding_act_fn: str | None = Nonetimestep_post_act: str | None = Nonetime_cond_proj_dim: int | None = Noneconv_in_kernel: int = 3conv_out_kernel: int = 3projection_class_embeddings_input_dim: int | None = Noneattention_type: str = 'default'class_embeddings_concat: bool = Falsemid_block_only_cross_attention: bool | None = Nonecross_attention_norm: str | None = Noneaddition_embed_type_num_heads: int = 64 )

Paramètres

  • sample_size (int ou tuple[int, int], facultatif, par défaut None) — Hauteur et largeur de l'échantillon d'entrée/sortie.
  • in_channels (int, facultatif, par défaut 4) — Nombre de canaux dans l'échantillon d'entrée.
  • out_channels (int, facultatif, par défaut 4) — Nombre de canaux dans la sortie.
  • center_input_sample (bool, facultatif, par défaut False) — Indique s'il faut centrer l'échantillon d'entrée.
  • flip_sin_to_cos (bool, facultatif, par défaut True) — Indique s'il faut inverser le sin en cos dans l'embedding temporel.
  • freq_shift (int, facultatif, valeur par défaut 0) — Le décalage de fréquence à appliquer à l’incorporation temporelle.
  • down_block_types (tuple[str], facultatif, par défaut ("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")) — Le tuple de blocs de sous-échantillonnage à utiliser.
  • mid_block_type (str, facultatif, par défaut "UNetMidBlock2DCrossAttn") — Type de bloc pour la partie centrale du UNet. Il peut être l'un des suivants : UNetMidBlock2DCrossAttn, UNetMidBlock2D ou UNetMidBlock2DSimpleCrossAttn. Si la valeur est None, la couche de bloc central est ignorée.
  • up_block_types (tuple[str], facultatif, par défaut ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")) — Le tuple de blocs de remonte à utiliser.
  • only_cross_attention(bool ou tuple[bool], facultatif, par défaut False) — Indique si l'auto-attention doit être incluse dans les blocs de base du transformer, voir BasicTransformerBlock.
  • block_out_channels (tuple[int], facultatif, par défaut (320, 640, 1280, 1280)) — Le tuple des canaux de sortie pour chaque bloc.
  • layers_per_block (int, facultatif, valeur par défaut 2) — Le nombre de couches par bloc.
  • downsample_padding (int, facultatif, valeur par défaut 1) — Le padding à utiliser pour la convolution de downsampling.
  • mid_block_scale_factor (float, facultatif, valeur par défaut 1.0) — Le facteur d'échelle à utiliser pour le bloc intermédiaire.
  • dropout (float, facultatif, valeur par défaut 0.0) — La probabilité de dropout à utiliser.
  • act_fn (str, facultatif, par défaut "silu") — La fonction d'activation à utiliser.
  • norm_num_groups (int, facultatif, valeur par défaut 32) — Le nombre de groupes à utiliser pour la normalisation. Si None, les couches de normalisation et d’activation sont ignorées lors du post-traitement.
  • norm_eps (float, facultatif, valeur par défaut 1e-5) — L'épsilon à utiliser pour la normalisation.
  • cross_attention_dim (int ou tuple[int], facultatif, par défaut 1280) — La dimension des fonctionnalités d'attention croisée.
  • transformer_layers_per_block (int, tuple[int] ou tuple[tuple] , facultatif, valeur par défaut 1) — Le nombre de blocs de type BasicTransformerBlock. Ne concerne que CrossAttnDownBlock2D, CrossAttnUpBlock2D, UNetMidBlock2DCrossAttn.
  • reverse_transformer_layers_per_block — (tuple[tuple], facultatif, valeur par défaut None) : Le nombre de blocs de type BasicTransformerBlock dans les blocs de suréchantillonnage du U-Net. Pertinent uniquement si transformer_layers_per_block est de type tuple[tuple] et pour CrossAttnDownBlock2D, CrossAttnUpBlock2D, UNetMidBlock2DCrossAttn.
  • encoder_hid_dim (int, facultatif, valeur par défaut None) — Si encoder_hid_dim_type est défini, encoder_hidden_states sera projeté de la dimension encoder_hid_dim à la dimension cross_attention_dim.
  • encoder_hid_dim_type (str, facultatif, par défaut None) — Si fourni, les encoder_hidden_states et d’éventuels autres embeddings sont projetés vers des embeddings de texte de dimension cross_attention selon encoder_hid_dim_type.
  • attention_head_dim (int, facultatif, valeur par défaut : 8) — La dimension des têtes d'attention.
  • num_attention_heads (int, facultatif) — Le nombre de têtes d'attention. S'il n'est pas défini, la valeur par défaut est attention_head_dim
  • resnet_time_scale_shift (str, facultatif, par défaut "default") — Configuration du décalage de l'échelle temporelle pour les blocs ResNet (voir ResnetBlock2D). Choisissez entre default et scale_shift.
  • class_embed_type (str, facultatif, par défaut None) — Le type d’incorporation de classe à utiliser, qui est finalement additionné aux incorporations temporelles. Choisissez parmi None, "timestep", "identity", "projection" ou "simple_projection".
  • addition_embed_type (str, facultatif, par défaut None) — Configure un embedding facultatif qui sera additionné aux embeddings temporels. Choisissez entre None et “text”. “text” utilise la couche TextTimeEmbedding.
  • addition_time_embed_dim — (int, facultatif, valeur par défaut None) : Dimension des embeddings de pas de temps.
  • num_class_embeds (int, facultatif, par défaut None) — Dimension d’entrée de la matrice d’embeddings apprenables à projeter vers time_embed_dim, lors de l’utilisation d’un conditionnement par classe avec class_embed_type égal à None.
  • time_embedding_type (str, facultatif, par défaut positional) — Le type d’incorporation de position à utiliser pour les pas de temps. Choisissez entre positional et fourier.
  • time_embedding_dim (int, facultatif, par défaut None) — Substitution facultative pour la dimension de l’embedding de temps projeté.
  • time_embedding_act_fn (str, facultatif, par défaut None) — Fonction d’activation optionnelle à utiliser une seule fois sur les embeddings de temps avant qu’ils ne soient transmis au reste du UNet. Choisissez parmi silu, mish, gelu et swish.
  • timestep_post_act (str, facultatif, par défaut None) — La seconde fonction d'activation à utiliser dans l'encodage du pas de temps. Choisissez parmi silu, mish et gelu.
  • time_cond_proj_dim (int, facultatif, par défaut None) — La dimension de la couche cond_proj dans l’encodage du pas de temps.
  • conv_in_kernel (int, facultatif, par défaut 3) — La taille du noyau de la couche conv_in.
  • conv_out_kernel (int, facultatif, par défaut 3) — La taille du noyau de la couche conv_out.
  • projection_class_embeddings_input_dim (int, facultatif) — La dimension de l’entrée class_labels lorsque class_embed_type="projection". Obligatoire lorsque class_embed_type="projection".
  • class_embeddings_concat (bool, facultatif, par défaut False) — Indique s'il faut concaténer les embeddings temporels avec les embeddings de classe.
  • mid_block_only_cross_attention (bool, facultatif, valeur par défaut None) — Indique s'il faut utiliser l'attention croisée avec le bloc intermédiaire lors de l'utilisation de UNetMidBlock2DSimpleCrossAttn. Si only_cross_attention est fourni sous forme d'un booléen unique et que mid_block_only_cross_attention est None, la valeur de only_cross_attention est utilisée comme valeur pour mid_block_only_cross_attention. Sinon, la valeur par défaut est False.

Un modèle UNet 2D conditionné qui prend un échantillon bruité, un état conditionnel et un pas de temps en entrée et renvoie une sortie de forme

Ce modèle hérite de ModelMixin. Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (téléchargement ou sauvegarde, par exemple).

disable_freeu

< >

( )

Désactive le mécanisme FreeU.

enable_freeu

< >

( s1: floats2: floatb1: floatb2: float )

Paramètres

  • s1 (float) — Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de sur-lissage » dans le processus de débruitage amélioré.
  • s2 (float) — Facteur d'échelle de l'étape 2 pour atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de sur-lissage » dans le processus de débruitage amélioré.
  • b1 (float) — Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone.
  • b2 (float) — Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.

Active le mécanisme FreeU de https://huggingface.co/papers/2309.11497.

Les suffixes après les facteurs d'échelle représentent les blocs de stades où ils sont appliqués.

Veuillez consulter le dépôt officiel pour les combinaisons de valeurs qui fonctionnent bien pour différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.

forward

< >

( sample: Tensortimestep: typing.Union[torch.Tensor, float, int]encoder_hidden_states: Tensorclass_labels: typing.Optional[torch.Tensor] = Nonetimestep_cond: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonecross_attention_kwargs: dict[str, typing.Any] | None = Noneadded_cond_kwargs: dict[str, torch.Tensor] | None = Nonedown_block_additional_residuals: tuple[torch.Tensor] | None = Nonemid_block_additional_residual: typing.Optional[torch.Tensor] = Nonedown_intrablock_additional_residuals: tuple[torch.Tensor] | None = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonereturn_dict: bool = True ) → UNet2DConditionOutput or tuple

Paramètres

  • sample (torch.Tensor) — Le tenseur d'entrée bruité de forme (batch, channel, height, width).
  • timestep (torch.Tensor ou float ou int) — Le nombre de pas de temps pour débruitiser une entrée.
  • encoder_hidden_states (torch.Tensor) — Les états cachés de l’encodeur, de forme (batch, sequence_length, feature_dim).
  • class_labels (torch.Tensor, facultatif, par défaut None) — Étiquettes de classes facultatives pour le conditionnement. Leurs embeddings seront additionnés aux embeddings de pas de temps.
  • timestep_cond — (torch.Tensor, facultatif, valeur par défaut None) : Incrustations conditionnelles pour le pas de temps. Si fournies, les incrustations seront additionnées aux échantillons passés à travers la couche self.time_embedding pour obtenir les incrustations de pas de temps.
  • attention_mask (torch.Tensor, facultatif, par défaut None) — Un masque d’attention de forme (batch, key_tokens) est appliqué à encoder_hidden_states. Si la valeur est 1, le masque est conservé ; sinon, si elle est 0, il est ignoré. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d’attention correspondant aux jetons « ignorés ».
  • cross_attention_kwargs (dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessor défini sous self.processor dans diffusers.models.attention_processor.
  • added_cond_kwargs — (dict, facultatif) : Un dictionnaire de kwargs contenant des embeddings supplémentaires qui, s'ils sont spécifiés, sont ajoutés aux embeddings transmis aux blocs du UNet.
  • down_block_additional_residuals — (tuple de torch.Tensor, facultatif) : Un tuple de tenseurs qui, s'il est spécifié, est ajouté aux résidus des blocs down du unet.
  • mid_block_additional_residual — (torch.Tensor, facultatif) : Un tenseur qui, s'il est spécifié, est ajouté au résidu du bloc intermédiaire de l'unet.
  • down_intrablock_additional_residuals (tuple de torch.Tensor, facultatif) — résidus supplémentaires à ajouter au sein des blocs de descente du UNet, par exemple issus de modèle(s) latéral(aux) T2I-Adapter
  • encoder_attention_mask (torch.Tensor) — Un masque d’attention croisée de forme (batch, sequence_length) est appliqué à encoder_hidden_states. Si True, le masque est conservé, sinon, si False, il est supprimé. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d’attention correspondant aux jetons « à supprimer ».
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un UNet2DConditionOutput plutôt qu'un simple tuplet.

Retourne

UNet2DConditionOutput ou tuple

Si return_dict est True, un UNet2DConditionOutput est renvoyé, sinon un tuple est renvoyé dont le premier élément est le tenseur d'échantillon.

La méthode forward du UNet2DConditionModel.

fuse_qkv_projections

< >

( )

Active les projections QKV fusionnées. Pour les modules d'auto-attention, toutes les matrices de projection (c'est-à-dire requête, clé, valeur) sont fusionnées. Pour les modules d'attention croisée, les matrices de projection des clés et des valeurs sont fusionnées.

> Cette API est 🧪 expérimentale.

set_attention_slice

< >

( slice_size: str | int | list[int] = 'auto' )

Paramètres

  • slice_size (str ou int ou list(int), facultatif, par défaut "auto") — Lorsque la valeur est "auto", l’entrée des têtes d’attention est divisée par deux, de sorte que l’attention est calculée en deux étapes. Si la valeur est "max", la quantité maximale de mémoire est économisée en n’exécutant qu’une seule tranche à la fois. Si un nombre est fourni, le nombre de tranches utilisé est attention_head_dim // slice_size. Dans ce cas, attention_head_dim doit être un multiple de slice_size.

Activer le calcul de l'attention par tranches.

Lorsque cette option est activée, le module d'attention divise le tenseur d'entrée en tranches pour calculer l'attention en plusieurs étapes. Cela est utile pour économiser de la mémoire au prix d'une légère diminution de la vitesse.

set_default_attn_processor

< >

( )

Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.

unfuse_qkv_projections

< >

( )

Désactive la projection QKV fusionnée si elle est activée.

> Cette API est 🧪 expérimentale.

UNet2DConditionOutput

classe diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput

< >

( sample: Tensor = None )

Paramètres

  • sample (torch.Tensor de forme (batch_size, num_channels, height, width)) — Les états cachés en sortie, conditionnés par l'entrée encoder_hidden_states. Sortie de la dernière couche du modèle.

La sortie de UNet2DConditionModel.

Update on GitHub

←UNet1DModel UNet2DModel→