Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /fr /api /models /unet-motion.md

mishig

3 days ago

preview code

download

raw

12.2 kB

# UNetMotionModel

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 lui-même. Il existe plusieurs variantes du modèle UNet dans 🤗 Diffusers, en fonction de son nombre de dimensions et de savoir s'il s'agit d'un modèle conditionnel ou non. Il s'agit ici d'un modèle UNet 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.*

## UNetMotionModel[[diffusers.UNetMotionModel]]

#### diffusers.UNetMotionModel[[diffusers.UNetMotionModel]]

```python
diffusers.UNetMotionModel(sample_size: int | None = None, in_channels: int = 4, out_channels: int = 4, down_block_types: tuple[str, ...] = ('CrossAttnDownBlockMotion', 'CrossAttnDownBlockMotion', 'CrossAttnDownBlockMotion', 'DownBlockMotion'), up_block_types: tuple[str, ...] = ('UpBlockMotion', 'CrossAttnUpBlockMotion', 'CrossAttnUpBlockMotion', 'CrossAttnUpBlockMotion'), 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, act_fn: str = 'silu', norm_num_groups: int = 32, norm_eps: float = 1e-05, cross_attention_dim: int = 1280, transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1, reverse_transformer_layers_per_block: int | tuple[int] | tuple[tuple] | None = None, temporal_transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1, reverse_temporal_transformer_layers_per_block: int | tuple[int] | tuple[tuple] | None = None, transformer_layers_per_mid_block: int | tuple[int] | None = None, temporal_transformer_layers_per_mid_block: int | tuple[int] | None = 1, use_linear_projection: bool = False, num_attention_heads: int | tuple[int, ...] = 8, motion_max_seq_length: int = 32, motion_num_attention_heads: int | tuple[int, ...] = 8, reverse_motion_num_attention_heads: int | tuple[int, ...] | tuple[tuple[int, ...], ...] | None = None, use_motion_mid_block: bool = True, mid_block_layers: int = 1, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, projection_class_embeddings_input_dim: int | None = None, time_cond_proj_dim: int | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1201)

Un modèle de UNet 2D conditionnel modifié 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.UNetMotionModel.disable_freeu]]

```python
disable_freeu()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1842)

Désactive le mécanisme FreeU.

#### enable_forward_chunking[[diffusers.UNetMotionModel.enable_forward_chunking]]

```python
enable_forward_chunking(chunk_size: int | None = None, dim: int = 0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1760)

**Paramètres :**

chunk_size (`int`, *facultatif*) : La taille des blocs des couches feed-forward. Si non spécifiée, la couche feed-forward est exécutée individuellement sur chaque tenseur de dim=`dim`.
dim (`int`, *facultatif*, par défaut `0`) : La dimension sur laquelle le calcul feed-forward doit être découpé. Choisissez entre dim=0 (batch) ou dim=1 (longueur de séquence).
Définit le processeur d'attention à utiliser [feed forward chunking](https://huggingface.co/blog/reformer#2-chunked-feed-forward-layers).
#### enable_freeu[[diffusers.UNetMotionModel.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_motion_model.py#L1817)
**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.UNetMotionModel.forward]]
```python
forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, 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, return_dict: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1882)
**Paramètres :**
sample (`torch.Tensor`) : le tenseur d'entrée bruité de forme `(batch, num_frames, 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)`.

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 d'embeddings supplémentaires (par exemple, embeddings de texte et de temps) utilisés pour conditionner le modèle.

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.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `UNetMotionOutput` plutôt qu'un simple tuple.
**Retourne :** `UNetMotionOutput` ou `tuple`
Si `return_dict` est True, un `UNetMotionOutput` est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est le tenseur d'échantillon.

La méthode forward du [UNetMotionModel](/docs/diffusers/main/fr/api/models/unet-motion#diffusers.UNetMotionModel).

#### freeze_unet2d_params[[diffusers.UNetMotionModel.freeze_unet2d_params]]

```python
freeze_unet2d_params()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1691)

Gélez les poids du UNet2DConditionModel uniquement, et laissez les modules de mouvement non gelés pour l’affinage.

#### fuse_qkv_projections[[diffusers.UNetMotionModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1851)

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_default_attn_processor[[diffusers.UNetMotionModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1801)

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

#### unfuse_qkv_projections[[diffusers.UNetMotionModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1873)

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

> [!WARNING] > Cette API est 🧪 expérimentale.

## UNet3DConditionOutput[[diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput]]

#### diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput[[diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput]]

```python
diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput(sample: Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_3d_condition.py#L50)

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, num_frames, 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 [UNet3DConditionModel](/docs/diffusers/main/fr/api/models/unet3d-cond#diffusers.UNet3DConditionModel).

Xet Storage Details

Size:: 12.2 kB
Xet hash:: 309dc8054cf9d7bf8c7e2ebc0b6dac992098745c5d1eb88ae4b106ae5d9b87bf

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# UNetMotionModel

	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 lui-même. Il existe plusieurs variantes du modèle UNet dans 🤗 Diffusers, en fonction de son nombre de dimensions et de savoir s'il s'agit d'un modèle conditionnel ou non. Il s'agit ici d'un modèle UNet 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.

	## UNetMotionModel[[diffusers.UNetMotionModel]]

	#### diffusers.UNetMotionModel[[diffusers.UNetMotionModel]]

	```python
	diffusers.UNetMotionModel(sample_size: int \| None = None, in_channels: int = 4, out_channels: int = 4, down_block_types: tuple[str, ...] = ('CrossAttnDownBlockMotion', 'CrossAttnDownBlockMotion', 'CrossAttnDownBlockMotion', 'DownBlockMotion'), up_block_types: tuple[str, ...] = ('UpBlockMotion', 'CrossAttnUpBlockMotion', 'CrossAttnUpBlockMotion', 'CrossAttnUpBlockMotion'), 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, act_fn: str = 'silu', norm_num_groups: int = 32, norm_eps: float = 1e-05, cross_attention_dim: int = 1280, transformer_layers_per_block: int \| tuple[int] \| tuple[tuple] = 1, reverse_transformer_layers_per_block: int \| tuple[int] \| tuple[tuple] \| None = None, temporal_transformer_layers_per_block: int \| tuple[int] \| tuple[tuple] = 1, reverse_temporal_transformer_layers_per_block: int \| tuple[int] \| tuple[tuple] \| None = None, transformer_layers_per_mid_block: int \| tuple[int] \| None = None, temporal_transformer_layers_per_mid_block: int \| tuple[int] \| None = 1, use_linear_projection: bool = False, num_attention_heads: int \| tuple[int, ...] = 8, motion_max_seq_length: int = 32, motion_num_attention_heads: int \| tuple[int, ...] = 8, reverse_motion_num_attention_heads: int \| tuple[int, ...] \| tuple[tuple[int, ...], ...] \| None = None, use_motion_mid_block: bool = True, mid_block_layers: int = 1, encoder_hid_dim: int \| None = None, encoder_hid_dim_type: str \| None = None, addition_embed_type: str \| None = None, addition_time_embed_dim: int \| None = None, projection_class_embeddings_input_dim: int \| None = None, time_cond_proj_dim: int \| None = None)
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1201)

	Un modèle de UNet 2D conditionnel modifié 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.UNetMotionModel.disable_freeu]]

	```python
	disable_freeu()
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1842)

	Désactive le mécanisme FreeU.

	#### enable_forward_chunking[[diffusers.UNetMotionModel.enable_forward_chunking]]

	```python
	enable_forward_chunking(chunk_size: int \| None = None, dim: int = 0)
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1760)

	Paramètres :

	chunk_size (`int`, facultatif) : La taille des blocs des couches feed-forward. Si non spécifiée, la couche feed-forward est exécutée individuellement sur chaque tenseur de dim=`dim`.

	dim (`int`, facultatif, par défaut `0`) : La dimension sur laquelle le calcul feed-forward doit être découpé. Choisissez entre dim=0 (batch) ou dim=1 (longueur de séquence).

	Définit le processeur d'attention à utiliser [feed forward chunking](https://huggingface.co/blog/reformer#2-chunked-feed-forward-layers).

	#### enable_freeu[[diffusers.UNetMotionModel.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_motion_model.py#L1817)

	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.UNetMotionModel.forward]]

	```python
	forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, 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, return_dict: bool = True)
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1882)

	Paramètres :

	sample (`torch.Tensor`) : le tenseur d'entrée bruité de forme `(batch, num_frames, 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)`.

	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 d'embeddings supplémentaires (par exemple, embeddings de texte et de temps) utilisés pour conditionner le modèle.

	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.

	return_dict (`bool`, facultatif, par défaut `True`) : Indique s'il faut retourner un `UNetMotionOutput` plutôt qu'un simple tuple.

	Retourne : `UNetMotionOutput` ou `tuple`

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

	La méthode forward du [UNetMotionModel](/docs/diffusers/main/fr/api/models/unet-motion#diffusers.UNetMotionModel).

	#### freeze_unet2d_params[[diffusers.UNetMotionModel.freeze_unet2d_params]]

	```python
	freeze_unet2d_params()
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1691)

	Gélez les poids du UNet2DConditionModel uniquement, et laissez les modules de mouvement non gelés pour l’affinage.

	#### fuse_qkv_projections[[diffusers.UNetMotionModel.fuse_qkv_projections]]

	```python
	fuse_qkv_projections()
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1851)

	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_default_attn_processor[[diffusers.UNetMotionModel.set_default_attn_processor]]

	```python
	set_default_attn_processor()
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1801)

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

	#### unfuse_qkv_projections[[diffusers.UNetMotionModel.unfuse_qkv_projections]]

	```python
	unfuse_qkv_projections()
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_motion_model.py#L1873)

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

	> [!WARNING] > Cette API est 🧪 expérimentale.

	## UNet3DConditionOutput[[diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput]]

	#### diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput[[diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput]]

	```python
	diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput(sample: Tensor)
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_3d_condition.py#L50)

	Paramètres :

	sample (`torch.Tensor` de forme `(batch_size, num_channels, num_frames, 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 [UNet3DConditionModel](/docs/diffusers/main/fr/api/models/unet3d-cond#diffusers.UNet3DConditionModel).