Buckets:
| # UNet2DConditionModel | |
| Le modèle [UNet](https://huggingface.co/papers/1505.04597) 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[[diffusers.UNet2DConditionModel]] | |
| #### diffusers.UNet2DConditionModel[[diffusers.UNet2DConditionModel]] | |
| ```python | |
| diffusers.UNet2DConditionModel(sample_size: int | tuple[int, int] | None = None, in_channels: int = 4, out_channels: int = 4, center_input_sample: bool = False, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple[str, ...] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str, ...] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int, ...] = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, dropout: float = 0.0, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1, reverse_transformer_layers_per_block: tuple[tuple[int]] | None = None, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, dual_cross_attention: bool = False, use_linear_projection: bool = False, class_embed_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', resnet_skip_time_act: bool = False, resnet_out_scale_factor: float = 1.0, time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, attention_type: str = 'default', class_embeddings_concat: bool = False, mid_block_only_cross_attention: bool | None = None, cross_attention_norm: str | None = None, addition_embed_type_num_heads: int = 64) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L76) | |
| **Paramètres :** | |
| sample_size (`int` ou `tuple[int, int]`, *facultatif*, valeur par défaut `None`) : Hauteur et largeur de l'échantillon d'entrée/sortie. | |
| in_channels (`int`, *facultatif*, valeur 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 downsampling à utiliser. | |
| mid_block_type (`str`, *facultatif*, par défaut `"UNetMidBlock2DCrossAttn"`) : Type de bloc pour le milieu du UNet, il peut être l'un des `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D` ou `UNetMidBlock2DSimpleCrossAttn`. Si `None`, la couche de bloc intermédiaire est ignorée. | |
| up_block_types (`tuple[str]`, *facultatif*, par défaut `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Le tuple de blocs de suréchantillonnage à utiliser. | |
| only_cross_attention(`bool` ou `tuple[bool]`, *facultatif*, par défaut `False`) : Indique s'il faut inclure l'auto-attention 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*, 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*, par défaut 1e-5) : L'épsilon à utiliser pour la normalisation. | |
| cross_attention_dim (`int` ou `tuple[int]`, *facultatif*, valeur 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 transformateur 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 transformeurs de type `BasicTransformerBlock`, dans les blocs de remonte en résolution de l'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` vers `cross_attention_dim`. | |
| encoder_hid_dim_type (`str`, *facultatif*, par défaut `None`) : Si fourni, les `encoder_hidden_states` et d'autres embeddings éventuels 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*, valeur par défaut `"default"`) : configuration du décalage d'échelle temporelle pour les blocs ResNet (voir `ResnetBlock2D`). Choisissez entre `default` et `scale_shift`. | |
| class_embed_type (`str`, *facultatif*, valeur par défaut `None`) : Le type d’embedding de classe à utiliser, qui est finalement additionné aux embeddings temporels. Choisissez parmi `None`, `"timestep"`, `"identity"`, `"projection"` ou `"simple_projection"`. | |
| addition_embed_type (`str`, *facultatif*, valeur par défaut `None`) : Configure un embedding facultatif qui sera additionné aux embeddings temporels. Choisissez entre `None` et "text". "text" utilisera la couche `TextTimeEmbedding`. | |
| addition_time_embed_dim : (`int`, *facultatif*, par défaut `None`) : Dimension des embeddings de timestep. | |
| num_class_embeds (`int`, *facultatif*, valeur par défaut `None`) : Dimension d'entrée de la matrice d'incorporation apprenable à 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` ou `fourier`. | |
| time_embedding_dim (`int`, *facultatif*, valeur par défaut `None`) : Remplacement facultatif pour la dimension de l'embedding temporel projeté. | |
| time_embedding_act_fn (`str`, *facultatif*, valeur par défaut `None`) : Fonction d'activation optionnelle à utiliser une seule fois sur les embeddings temporels avant qu'ils ne soient transmis au reste du UNet. Choisissez parmi `silu`, `mish`, `gelu` et `swish`. | |
| timestep_post_act (`str`, *facultatif*, valeur 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 2D UNet conditionnel qui prend un échantillon bruité, un état conditionnel et un pas de temps en entrée, et renvoie une sortie de la même forme que l'échantillon. | |
| Ce modèle hérite de [ModelMixin](/docs/diffusers/main/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (tels que le téléchargement ou l'enregistrement). | |
| #### disable_freeu[[diffusers.UNet2DConditionModel.disable_freeu]] | |
| ```python | |
| disable_freeu() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L814) | |
| Désactive le mécanisme FreeU. | |
| #### enable_freeu[[diffusers.UNet2DConditionModel.enable_freeu]] | |
| ```python | |
| enable_freeu(s1: float, s2: float, b1: float, b2: float) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L790) | |
| **Paramètres :** | |
| s1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré. | |
| s2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » 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](https://github.com/ChenyangSi/FreeU) pour les combinaisons de valeurs connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL. | |
| #### forward[[diffusers.UNet2DConditionModel.forward]] | |
| ```python | |
| forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, added_cond_kwargs: dict[str, torch.Tensor] | None = None, down_block_additional_residuals: tuple[torch.Tensor] | None = None, mid_block_additional_residual: typing.Optional[torch.Tensor] = None, down_intrablock_additional_residuals: tuple[torch.Tensor] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L978) | |
| **Paramètres :** | |
| sample (`torch.Tensor`) : Le tenseur d'entrée bruité de la forme suivante `(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 avec la forme `(batch, sequence_length, feature_dim)`. | |
| class_labels (`torch.Tensor`, *facultatif*, valeur par défaut `None`) : Étiquettes de classe optionnelles pour le conditionnement. Leurs embeddings seront additionnés aux embeddings du timestep. | |
| timestep_cond : (`torch.Tensor`, *facultatif*, valeur par défaut `None`) : embeddings conditionnels pour le timestep. S'ils sont fournis, les embeddings seront additionnés aux échantillons passés par la couche `self.time_embedding` pour obtenir les embeddings de timestep. | |
| 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` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). | |
| 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 unet central. | |
| down_intrablock_additional_residuals (`tuple` de `torch.Tensor`, *facultatif*) : résidus supplémentaires à ajouter dans les 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 « supprimés ». | |
| return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) plutôt qu'un simple tuple. | |
| **Retourne :** [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) ou `tuple` | |
| Si `return_dict` est True, un [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est le tenseur d'échantillon. | |
| La méthode forward du [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel). | |
| #### fuse_qkv_projections[[diffusers.UNet2DConditionModel.fuse_qkv_projections]] | |
| ```python | |
| fuse_qkv_projections() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L822) | |
| 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. | |
| > [!WARNING] > Cette API est 🧪 expérimentale. | |
| #### set_attention_slice[[diffusers.UNet2DConditionModel.set_attention_slice]] | |
| ```python | |
| set_attention_slice(slice_size: str | int | list[int] = 'auto') | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L725) | |
| **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, autant de tranches sont utilisées que `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[[diffusers.UNet2DConditionModel.set_default_attn_processor]] | |
| ```python | |
| set_default_attn_processor() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L710) | |
| Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut. | |
| #### unfuse_qkv_projections[[diffusers.UNet2DConditionModel.unfuse_qkv_projections]] | |
| ```python | |
| unfuse_qkv_projections() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L843) | |
| Désactive la projection QKV fusionnée si elle est activée. | |
| > [!WARNING] > Cette API est 🧪 expérimentale. | |
| ## UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]] | |
| #### diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]] | |
| ```python | |
| diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput(sample: Tensor = None) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L64) | |
| **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](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel). | |
Xet Storage Details
- Size:
- 21.1 kB
- Xet hash:
- 77b2e89dfd66446eddf05e41cbc1788e4a4d899b75841d9d590a011018a4f363
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.