# Processeur d'attention

Un processeur d'attention est une classe destinée à appliquer différents types de mécanismes d'attention.

## AttnProcessor[[diffusers.models.attention_processor.AttnProcessor]]

#### diffusers.models.attention_processor.AttnProcessor[[diffusers.models.attention_processor.AttnProcessor]]

```python
diffusers.models.attention_processor.AttnProcessor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1103)

Processeur par défaut pour effectuer les calculs liés à l'attention.

#### diffusers.models.attention_processor.AttnProcessor2_0[[diffusers.models.attention_processor.AttnProcessor2_0]]

```python
diffusers.models.attention_processor.AttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2696)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0).

#### diffusers.models.attention_processor.AttnAddedKVProcessor[[diffusers.models.attention_processor.AttnAddedKVProcessor]]

```python
diffusers.models.attention_processor.AttnAddedKVProcessor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1279)

Processeur pour effectuer des calculs liés à l'attention avec des matrices de clé et de valeur supplémentaires apprenables pour l'encodeur de texte.

#### diffusers.models.attention_processor.AttnAddedKVProcessor2_0[[diffusers.models.attention_processor.AttnAddedKVProcessor2_0]]

```python
diffusers.models.attention_processor.AttnAddedKVProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1346)

Processeur pour effectuer une attention à produit scalaire mis à l'échelle (activée par défaut si vous utilisez PyTorch 2.0), avec des matrices de clé et de valeur supplémentaires apprenables pour l'encodeur de texte.

#### diffusers.models.attention_processor.AttnProcessorNPU[[diffusers.models.attention_processor.AttnProcessorNPU]]

```python
diffusers.models.attention_processor.AttnProcessorNPU()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2582)

Processeur pour implémenter l'attention flash à l'aide de torch_npu. Torch_npu ne prend en charge que les types de données fp16 et bf16. Si fp32 est utilisé, F.scaled_dot_product_attention sera utilisé pour le calcul, mais l'effet d'accélération sur la NPU n'est pas significatif.

#### diffusers.models.attention_processor.FusedAttnProcessor2_0[[diffusers.models.attention_processor.FusedAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3668)

Processeur pour implémenter l'attention à point produit mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il utilise des couches de projection 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 actuellement 🧪 expérimentale et peut évoluer à l'avenir.

## Allegro[[diffusers.models.attention_processor.AllegroAttnProcessor2_0]]

#### diffusers.models.attention_processor.AllegroAttnProcessor2_0[[diffusers.models.attention_processor.AllegroAttnProcessor2_0]]

```python
diffusers.models.attention_processor.AllegroAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1993)

Processeur pour implémenter l'attention à point produit mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle Allegro. Il applique une couche de normalisation et un encodage rotatif sur les vecteurs de requête et de clé.

## AuraFlow[[diffusers.models.attention_processor.AuraFlowAttnProcessor2_0]]

#### diffusers.models.attention_processor.AuraFlowAttnProcessor2_0[[diffusers.models.attention_processor.AuraFlowAttnProcessor2_0]]

```python
diffusers.models.attention_processor.AuraFlowAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2087)

Processeur d'attention utilisé typiquement dans le traitement d'Aura Flow.

#### diffusers.models.attention_processor.FusedAuraFlowAttnProcessor2_0[[diffusers.models.attention_processor.FusedAuraFlowAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedAuraFlowAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2180)

Processeur d'attention utilisé généralement dans le traitement d'Aura Flow avec des projections fusionnées.

## CogVideoX[[diffusers.models.attention_processor.CogVideoXAttnProcessor2_0]]

#### diffusers.models.attention_processor.CogVideoXAttnProcessor2_0[[diffusers.models.attention_processor.CogVideoXAttnProcessor2_0]]

```python
diffusers.models.attention_processor.CogVideoXAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2277)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle pour le modèle CogVideoX. Il applique un encodage rotatif sur les vecteurs de requête et de clé, mais n'inclut pas de normalisation spatiale.

#### diffusers.models.attention_processor.FusedCogVideoXAttnProcessor2_0[[diffusers.models.attention_processor.FusedCogVideoXAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedCogVideoXAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2346)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle pour le modèle CogVideoX. Il applique un encodage rotatif sur les vecteurs de requête et de clé, mais n'inclut pas de normalisation spatiale.

## DreamLite[[diffusers.models.unets.unet_dreamlite.DreamLiteAttnProcessor2_0]]

#### diffusers.models.unets.unet_dreamlite.DreamLiteAttnProcessor2_0[[diffusers.models.unets.unet_dreamlite.DreamLiteAttnProcessor2_0]]

```python
diffusers.models.unets.unet_dreamlite.DreamLiteAttnProcessor2_0()
```

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

Processeur pour implémenter l'attention à point produit mis à l'échelle avec prise en charge de l'attention à requêtes groupées (GQA / MQA).

Identique à `AttnProcessor2_0` à l’exception de la branche de redimensionnement des clés/valeurs, qui gère correctement `attn.kv_heads != attn.heads` en redimensionnant K/V vers `kv_heads` puis en les répétant via `repeat_interleave` jusqu’à `attn.heads`. C’est une exigence du UNet DreamLite, qui combine GQA avec `qk_norm` — une combinaison que le `AttnProcessor2_0` par défaut ne gère pas. Le SDPA est délégué à `dispatch_attention_fn` afin que n’importe quel backend d’attention de diffusers (SDPA natif PyTorch, FlashAttention, etc.) puisse être utilisé.

## Custom Diffusion[[diffusers.models.attention_processor.CustomDiffusionAttnProcessor]]

#### diffusers.models.attention_processor.CustomDiffusionAttnProcessor[[diffusers.models.attention_processor.CustomDiffusionAttnProcessor]]

```python
diffusers.models.attention_processor.CustomDiffusionAttnProcessor(train_kv: bool = True, train_q_out: bool = True, hidden_size: int | None = None, cross_attention_dim: int | None = None, out_bias: bool = True, dropout: float = 0.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1175)

**Paramètres :**

train_kv (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de clés et de valeurs correspondant aux caractéristiques textuelles.

train_q_out (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de requête correspondant aux caractéristiques latentes de l'image.

hidden_size (`int`, *facultatif*, valeur par défaut `None`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`, *facultatif*, par défaut `None`) : Le nombre de canaux dans `encoder_hidden_states`.

out_bias (`bool`, par défaut `True`) : Indique si le paramètre de biais doit être inclus dans `train_q_out`.

dropout (`float`, *facultatif*, par défaut 0.0) : La probabilité de dropout à utiliser.

Processeur pour implémenter l'attention pour la méthode Custom Diffusion.

#### diffusers.models.attention_processor.CustomDiffusionAttnProcessor2_0[[diffusers.models.attention_processor.CustomDiffusionAttnProcessor2_0]]

```python
diffusers.models.attention_processor.CustomDiffusionAttnProcessor2_0(train_kv: bool = True, train_q_out: bool = True, hidden_size: int | None = None, cross_attention_dim: int | None = None, out_bias: bool = True, dropout: float = 0.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3886)

**Paramètres :**

train_kv (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de clés et de valeurs correspondant aux caractéristiques textuelles.

train_q_out (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de requête correspondant aux caractéristiques latentes de l'image.

hidden_size (`int`, *facultatif*, valeur par défaut `None`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`, *facultatif*, par défaut `None`) : Le nombre de canaux dans `encoder_hidden_states`.

out_bias (`bool`, par défaut `True`) : Indique si le paramètre de biais doit être inclus dans `train_q_out`.

dropout (`float`, *facultatif*, par défaut 0.0) : La probabilité de dropout à utiliser.

Processeur pour implémenter l'attention de la méthode Custom Diffusion en utilisant l'attention à produit scalaire pondéré efficace en mémoire de PyTorch 2.0.

#### diffusers.models.attention_processor.CustomDiffusionXFormersAttnProcessor[[diffusers.models.attention_processor.CustomDiffusionXFormersAttnProcessor]]

```python
diffusers.models.attention_processor.CustomDiffusionXFormersAttnProcessor(train_kv: bool = True, train_q_out: bool = False, hidden_size: int | None = None, cross_attention_dim: int | None = None, out_bias: bool = True, dropout: float = 0.0, attention_op: Callable | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3770)

**Paramètres :**

train_kv (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de clés et de valeurs correspondant aux caractéristiques textuelles.

train_q_out (`bool`, par défaut `True`) : Indique s'il faut entraîner de nouvelles matrices de requête correspondant aux caractéristiques latentes de l'image.

hidden_size (`int`, *facultatif*, valeur par défaut `None`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`, *facultatif*, par défaut `None`) : Le nombre de canaux dans `encoder_hidden_states`.

out_bias (`bool`, par défaut `True`) : Indique si le paramètre de biais doit être inclus dans `train_q_out`.

dropout (`float`, *facultatif*, par défaut 0.0) : La probabilité de dropout à utiliser.

attention_op (`Callable`, *facultatif*, valeur par défaut `None`) : l'[opérateur](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.AttentionOpBase) de base à utiliser comme opérateur d'attention. Il est recommandé de le définir sur `None` et de laisser xFormers choisir le meilleur opérateur.

Processeur pour implémenter une attention efficace en mémoire à l'aide de xFormers pour la méthode Custom Diffusion.

## Flux[[diffusers.models.attention_processor.FluxAttnProcessor2_0]]

#### diffusers.models.attention_processor.FluxAttnProcessor2_0[[diffusers.models.attention_processor.FluxAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FluxAttnProcessor2_0(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5505)

#### diffusers.models.attention_processor.FusedFluxAttnProcessor2_0[[diffusers.models.attention_processor.FusedFluxAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedFluxAttnProcessor2_0(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5529)

#### diffusers.models.attention_processor.FluxSingleAttnProcessor2_0[[diffusers.models.attention_processor.FluxSingleAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FluxSingleAttnProcessor2_0(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5515)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0).

## Hunyuan[[diffusers.models.attention_processor.HunyuanAttnProcessor2_0]]

#### diffusers.models.attention_processor.HunyuanAttnProcessor2_0[[diffusers.models.attention_processor.HunyuanAttnProcessor2_0]]

```python
diffusers.models.attention_processor.HunyuanAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3124)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle HunyuanDiT. Il applique une couche de normalisation s et un encodage rotatif sur les vecteurs de requête et de clé.

#### diffusers.models.attention_processor.FusedHunyuanAttnProcessor2_0[[diffusers.models.attention_processor.FusedHunyuanAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedHunyuanAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3222)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activée par défaut si vous utilisez PyTorch 2.0) avec des couches de projection fusionnées. Elle est utilisée dans le modèle HunyuanDiT. Elle applique une couche de normalisation s et un encodage rotatif sur les vecteurs de requête et de clé.

#### diffusers.models.attention_processor.PAGHunyuanAttnProcessor2_0[[diffusers.models.attention_processor.PAGHunyuanAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGHunyuanAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3325)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle HunyuanDiT. Il applique une couche de normalisation et un encodage rotatif sur les vecteurs de requête et de clé. Cette variante du processeur emploie [Pertubed Attention Guidance](https://huggingface.co/papers/2403.17377).

#### diffusers.models.attention_processor.PAGCFGHunyuanAttnProcessor2_0[[diffusers.models.attention_processor.PAGCFGHunyuanAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGCFGHunyuanAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3448)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle HunyuanDiT. Il applique une couche de normalisation et un encodage rotatif sur les vecteurs de requête et de clé. Cette variante du processeur emploie [Pertubed Attention Guidance](https://huggingface.co/papers/2403.17377).

## IdentitySelfAttnProcessor2_0[[diffusers.models.attention_processor.PAGIdentitySelfAttnProcessor2_0]]

#### diffusers.models.attention_processor.PAGIdentitySelfAttnProcessor2_0[[diffusers.models.attention_processor.PAGIdentitySelfAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGIdentitySelfAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5043)

Processeur pour implémenter PAG en utilisant l'attention à produit scalaire pondéré (activé par défaut si vous utilisez PyTorch 2.0). Référence PAG : https://huggingface.co/papers/2403.17377

#### diffusers.models.attention_processor.PAGCFGIdentitySelfAttnProcessor2_0[[diffusers.models.attention_processor.PAGCFGIdentitySelfAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGCFGIdentitySelfAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5142)

Processeur pour implémenter PAG en utilisant l'attention à produit scalaire pondéré (activé par défaut si vous utilisez PyTorch 2.0). Référence PAG : https://huggingface.co/papers/2403.17377

## IP-Adapter[[diffusers.models.attention_processor.IPAdapterAttnProcessor]]

#### diffusers.models.attention_processor.IPAdapterAttnProcessor[[diffusers.models.attention_processor.IPAdapterAttnProcessor]]

```python
diffusers.models.attention_processor.IPAdapterAttnProcessor(hidden_size, cross_attention_dim = None, num_tokens = (4,), scale = 1.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4208)

**Paramètres :**

hidden_size (`int`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`) : Le nombre de canaux dans `encoder_hidden_states`.

num_tokens (`int`, `tuple[int]` ou `list[int]`, par défaut `(4,)`) : La longueur de contexte des fonctionnalités d'image.

scale (`float` ou liste`float`, par défaut 1.0) : l'échelle de poids du prompt d'image.

Processeur d'attention pour plusieurs IP-Adapters.

#### diffusers.models.attention_processor.IPAdapterAttnProcessor2_0[[diffusers.models.attention_processor.IPAdapterAttnProcessor2_0]]

```python
diffusers.models.attention_processor.IPAdapterAttnProcessor2_0(hidden_size, cross_attention_dim = None, num_tokens = (4,), scale = 1.0)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4408)

**Paramètres :**

hidden_size (`int`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`) : Le nombre de canaux dans `encoder_hidden_states`.

num_tokens (`int`, `tuple[int]` ou `list[int]`, par défaut `(4,)`) : La longueur de contexte des fonctionnalités d'image.

scale (`float` ou `list[float]`, par défaut 1.0) : l'échelle de poids du prompt d'image.

Processeur d'attention pour IP-Adapter pour PyTorch 2.0.

#### diffusers.models.attention_processor.SD3IPAdapterJointAttnProcessor2_0[[diffusers.models.attention_processor.SD3IPAdapterJointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.SD3IPAdapterJointAttnProcessor2_0(hidden_size: int, ip_hidden_states_dim: int, head_dim: int, timesteps_emb_dim: int = 1280, scale: float = 0.5)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4872)

**Paramètres :**

hidden_size (`int`) : Le nombre de canaux cachés.

ip_hidden_states_dim (`int`) : La dimension des caractéristiques de l'image.

head_dim (`int`) : Le nombre de canaux de tête.

timesteps_emb_dim (`int`, par défaut 1280) : Le nombre de canaux d'entrée pour l'incorporation du pas de temps.

scale (`float`, par défaut 0.5) : échelle de l'IP-Adapter.

Processeur d'attention pour IP-Adapter, utilisé typiquement dans le traitement des projections d'auto-attention de type SD3, avec des informations supplémentaires basées sur l'image et des embeddings de pas de temps.

## JointAttnProcessor2_0[[diffusers.models.attention_processor.JointAttnProcessor2_0]]

#### diffusers.models.attention_processor.JointAttnProcessor2_0[[diffusers.models.attention_processor.JointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.JointAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1422)

Processeur d'attention utilisé typiquement dans le traitement des projections d'auto-attention de type SD3.

#### diffusers.models.attention_processor.PAGJointAttnProcessor2_0[[diffusers.models.attention_processor.PAGJointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGJointAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1508)

Processeur d'attention utilisé typiquement dans le traitement des projections d'auto-attention de type SD3.

#### diffusers.models.attention_processor.PAGCFGJointAttnProcessor2_0[[diffusers.models.attention_processor.PAGCFGJointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGCFGJointAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1664)

Processeur d'attention utilisé typiquement dans le traitement des projections d'auto-attention de type SD3.

#### diffusers.models.attention_processor.FusedJointAttnProcessor2_0[[diffusers.models.attention_processor.FusedJointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FusedJointAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1829)

Processeur d'attention utilisé typiquement dans le traitement des projections d'auto-attention de type SD3.

## LoRA[[diffusers.models.attention_processor.LoRAAttnProcessor]]

#### diffusers.models.attention_processor.LoRAAttnProcessor[[diffusers.models.attention_processor.LoRAAttnProcessor]]

```python
diffusers.models.attention_processor.LoRAAttnProcessor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5305)

Processeur pour implémenter l'attention avec LoRA.

#### diffusers.models.attention_processor.LoRAAttnProcessor2_0[[diffusers.models.attention_processor.LoRAAttnProcessor2_0]]

```python
diffusers.models.attention_processor.LoRAAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5314)

Processeur pour implémenter l'attention avec LoRA (activé par défaut si vous utilisez PyTorch 2.0).

#### diffusers.models.attention_processor.LoRAAttnAddedKVProcessor[[diffusers.models.attention_processor.LoRAAttnAddedKVProcessor]]

```python
diffusers.models.attention_processor.LoRAAttnAddedKVProcessor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5332)

Processeur pour implémenter l'attention avec LoRA, avec des matrices de clés et de valeurs supplémentaires apprenables pour l'encodeur de texte.

#### diffusers.models.attention_processor.LoRAXFormersAttnProcessor[[diffusers.models.attention_processor.LoRAXFormersAttnProcessor]]

```python
diffusers.models.attention_processor.LoRAXFormersAttnProcessor()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5323)

Processeur pour implémenter l'attention avec LoRA en utilisant xFormers.

## Lumina-T2X[[diffusers.models.attention_processor.LuminaAttnProcessor2_0]]

#### diffusers.models.attention_processor.LuminaAttnProcessor2_0[[diffusers.models.attention_processor.LuminaAttnProcessor2_0]]

```python
diffusers.models.attention_processor.LuminaAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L3572)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle LuminaNextDiT. Il applique une couche de normalisation s et un encodage rotatif sur les vecteurs de requête et de clé.

## Mochi[[diffusers.models.attention_processor.MochiAttnProcessor2_0]]

#### diffusers.models.attention_processor.MochiAttnProcessor2_0[[diffusers.models.attention_processor.MochiAttnProcessor2_0]]

```python
diffusers.models.attention_processor.MochiAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L998)

Processeur d'attention utilisé dans Mochi.

#### diffusers.models.attention_processor.MochiVaeAttnProcessor2_0[[diffusers.models.attention_processor.MochiVaeAttnProcessor2_0]]

```python
diffusers.models.attention_processor.MochiVaeAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2906)

Processeur d'attention utilisé dans le VAE de Mochi.

## Sana[[diffusers.models.attention_processor.SanaLinearAttnProcessor2_0]]

#### diffusers.models.attention_processor.SanaLinearAttnProcessor2_0[[diffusers.models.attention_processor.SanaLinearAttnProcessor2_0]]

```python
diffusers.models.attention_processor.SanaLinearAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5341)

Processeur pour implémenter une attention linéaire à point produit mis à l'échelle.

#### diffusers.models.attention_processor.SanaMultiscaleAttnProcessor2_0[[diffusers.models.attention_processor.SanaMultiscaleAttnProcessor2_0]]

```python
diffusers.models.attention_processor.SanaMultiscaleAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5245)

Processeur pour implémenter l'attention quadratique multi-échelle.

#### diffusers.models.attention_processor.PAGCFGSanaLinearAttnProcessor2_0[[diffusers.models.attention_processor.PAGCFGSanaLinearAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGCFGSanaLinearAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5393)

Processeur pour implémenter une attention linéaire à point produit mis à l'échelle.

#### diffusers.models.attention_processor.PAGIdentitySanaLinearAttnProcessor2_0[[diffusers.models.attention_processor.PAGIdentitySanaLinearAttnProcessor2_0]]

```python
diffusers.models.attention_processor.PAGIdentitySanaLinearAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5448)

Processeur pour implémenter une attention linéaire à point produit mis à l'échelle.

## Stable Audio[[diffusers.models.attention_processor.StableAudioAttnProcessor2_0]]

#### diffusers.models.attention_processor.StableAudioAttnProcessor2_0[[diffusers.models.attention_processor.StableAudioAttnProcessor2_0]]

```python
diffusers.models.attention_processor.StableAudioAttnProcessor2_0()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2991)

Processeur pour implémenter l'attention à produit scalaire mis à l'échelle (activé par défaut si vous utilisez PyTorch 2.0). Il est utilisé dans le modèle Stable Audio. Il applique l'incorporation rotative sur les vecteurs de requête et de clé, et permet MHA, GQA ou MQA.

## SlicedAttnProcessor[[diffusers.models.attention_processor.SlicedAttnProcessor]]

#### diffusers.models.attention_processor.SlicedAttnProcessor[[diffusers.models.attention_processor.SlicedAttnProcessor]]

```python
diffusers.models.attention_processor.SlicedAttnProcessor(slice_size: int)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4000)

**Paramètres :**

slice_size (`int`, *facultatif*) : Le nombre d'étapes pour calculer l'attention. Utilise autant de tranches que `attention_head_dim // slice_size`, et `attention_head_dim` doit être un multiple de `slice_size`.

Processeur pour implémenter l'attention par tranches.

#### diffusers.models.attention_processor.SlicedAttnAddedKVProcessor[[diffusers.models.attention_processor.SlicedAttnAddedKVProcessor]]

```python
diffusers.models.attention_processor.SlicedAttnAddedKVProcessor(slice_size)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4087)

**Paramètres :**

slice_size (`int`, *facultatif*) : Le nombre d'étapes pour calculer l'attention. Utilise autant de tranches que `attention_head_dim // slice_size`, et `attention_head_dim` doit être un multiple de `slice_size`.

Processeur pour implémenter l'attention segmentée avec des matrices de clés et de valeurs supplémentaires apprenables pour l'encodeur de texte.

## XFormersAttnProcessor[[diffusers.models.attention_processor.XFormersAttnProcessor]]

#### diffusers.models.attention_processor.XFormersAttnProcessor[[diffusers.models.attention_processor.XFormersAttnProcessor]]

```python
diffusers.models.attention_processor.XFormersAttnProcessor(attention_op: Callable | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2488)

**Paramètres :**

attention_op (`Callable`, *facultatif*, valeur par défaut `None`) : l'[opérateur](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.AttentionOpBase) de base à utiliser comme opérateur d'attention. Il est recommandé de le définir sur `None` et de laisser xFormers choisir le meilleur opérateur.

Processeur pour implémenter une attention efficace en mémoire à l'aide de xFormers.

#### diffusers.models.attention_processor.XFormersAttnAddedKVProcessor[[diffusers.models.attention_processor.XFormersAttnAddedKVProcessor]]

```python
diffusers.models.attention_processor.XFormersAttnAddedKVProcessor(attention_op: Callable | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2417)

**Paramètres :**

attention_op (`Callable`, *facultatif*, valeur par défaut `None`) : l'[opérateur](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.AttentionOpBase) de base à utiliser comme opérateur d'attention. Il est recommandé de le définir sur `None` et de laisser xFormers choisir le meilleur opérateur.

Processeur pour implémenter une attention efficace en mémoire à l'aide de xFormers.

## XLAFlashAttnProcessor2_0[[diffusers.models.attention_processor.XLAFlashAttnProcessor2_0]]

#### diffusers.models.attention_processor.XLAFlashAttnProcessor2_0[[diffusers.models.attention_processor.XLAFlashAttnProcessor2_0]]

```python
diffusers.models.attention_processor.XLAFlashAttnProcessor2_0(partition_spec: tuple[str | None, ...] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L2790)

Processeur pour implémenter l'attention à point produit mis à l'échelle avec le noyau pallas flash attention si `torch_xla` est utilisé.

## XFormersJointAttnProcessor[[diffusers.models.attention_processor.XFormersJointAttnProcessor]]

#### diffusers.models.attention_processor.XFormersJointAttnProcessor[[diffusers.models.attention_processor.XFormersJointAttnProcessor]]

```python
diffusers.models.attention_processor.XFormersJointAttnProcessor(attention_op: Callable | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L1908)

**Paramètres :**

attention_op (`Callable`, *facultatif*, valeur par défaut `None`) : l'[opérateur](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.AttentionOpBase) de base à utiliser comme opérateur d'attention. Il est recommandé de le définir sur `None` et de laisser xFormers choisir le meilleur opérateur.

Processeur pour implémenter une attention efficace en mémoire à l'aide de xFormers.

## IPAdapterXFormersAttnProcessor[[diffusers.models.attention_processor.IPAdapterXFormersAttnProcessor]]

#### diffusers.models.attention_processor.IPAdapterXFormersAttnProcessor[[diffusers.models.attention_processor.IPAdapterXFormersAttnProcessor]]

```python
diffusers.models.attention_processor.IPAdapterXFormersAttnProcessor(hidden_size, cross_attention_dim = None, num_tokens = (4,), scale = 1.0, attention_op: Callable | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L4640)

**Paramètres :**

hidden_size (`int`) : La taille cachée de la couche d'attention.

cross_attention_dim (`int`) : Le nombre de canaux dans `encoder_hidden_states`.

num_tokens (`int`, `tuple[int]` ou `list[int]`, par défaut `(4,)`) : La longueur de contexte des fonctionnalités d'image.

scale (`float` ou `list[float]`, par défaut 1.0) : l'échelle de poids du prompt d'image.

attention_op (`Callable`, *facultatif*, valeur par défaut `None`) : l'[opérateur](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.AttentionOpBase) de base à utiliser comme opérateur d'attention. Il est recommandé de le définir sur `None` et de laisser xFormers choisir le meilleur opérateur.

Processeur d'attention pour IP-Adapter utilisant xFormers.

## FluxIPAdapterJointAttnProcessor2_0[[diffusers.models.attention_processor.FluxIPAdapterJointAttnProcessor2_0]]

#### diffusers.models.attention_processor.FluxIPAdapterJointAttnProcessor2_0[[diffusers.models.attention_processor.FluxIPAdapterJointAttnProcessor2_0]]

```python
diffusers.models.attention_processor.FluxIPAdapterJointAttnProcessor2_0(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5539)

## XLAFluxFlashAttnProcessor2_0[[diffusers.models.attention_processor.XLAFluxFlashAttnProcessor2_0]]

#### diffusers.models.attention_processor.XLAFluxFlashAttnProcessor2_0[[diffusers.models.attention_processor.XLAFluxFlashAttnProcessor2_0]]

```python
diffusers.models.attention_processor.XLAFluxFlashAttnProcessor2_0(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py#L5579)

Processeur pour implémenter l'attention à point produit mis à l'échelle avec le noyau pallas flash attention si `torch_xla` est utilisé.