# Quantification

Les techniques de quantification réduisent les coûts mémoire et de calcul en représentant les poids et les activations avec des types de données de précision inférieure, tels que les entiers sur 8 bits (int8). Cela permet de charger des modèles plus volumineux qui ne pourraient normalement pas tenir en mémoire, et d'accélérer l'inférence. Transformers prend en charge les algorithmes de quantification AWQ et GPTQ, ainsi que la quantification sur 8 bits et 4 bits avec bitsandbytes.

Les techniques de quantification non prises en charge par Transformers peuvent être ajoutées à l'aide de la classe `HfQuantizer`.

Apprenez à quantiser des modèles dans le guide [Quantization](../quantization/overview).

## QuantoConfig[[transformers.QuantoConfig]]

#### transformers.QuantoConfig[[transformers.QuantoConfig]]

```python
transformers.QuantoConfig(weights = 'int8', activations = None, modules_to_not_convert: list | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1021)

**Paramètres :**

weights (`str`, *facultatif*, par défaut `"int8"`) : Le type de données cible pour les poids après quantification. Les valeurs prises en charge sont ("float8","int8","int4","int2")

activations (`str`, *facultatif*) : Le type de données cible pour les activations après quantification. Les valeurs prises en charge sont (None,"int8","float8")

modules_to_not_convert (`list`, *facultatif*, par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine (par ex. l'encodeur Whisper, l'encodeur Llava, les couches de porte de Mixtral).

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités avec lesquels vous pouvez manipuler un modèle chargé à l'aide de `quanto`.

#### post_init[[transformers.QuantoConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1049)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

## AqlmConfig[[transformers.AqlmConfig]]

#### transformers.AqlmConfig[[transformers.AqlmConfig]]

```python
transformers.AqlmConfig(in_group_size: int = 8, out_group_size: int = 1, num_codebooks: int = 1, nbits_per_codebook: int = 16, linear_weights_not_to_quantize: list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L865)

**Paramètres :**

in_group_size (`int`, *facultatif*, valeur par défaut : 8) : La taille du groupe le long de la dimension d'entrée.

out_group_size (`int`, *facultatif*, valeur par défaut : 1) : La taille du groupe le long de la dimension de sortie. Il est recommandé d'utiliser toujours 1.

num_codebooks (`int`, *facultatif*, valeur par défaut : 1) : Nombre de codebooks pour la procédure de quantification additive.

nbits_per_codebook (`int`, *facultatif*, valeur par défaut 16) : Nombre de bits codant un vecteur de codebook. La taille des codebooks est 2**nbits_per_codebook.

linear_weights_not_to_quantize (`Optional[list[str]]`, *facultatif*) : Liste des chemins complets des paramètres de poids de `nn.Linear` qui ne doivent pas être quantifiés.

kwargs (`dict[str, Any]`, *facultatif*) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

Ceci est une classe enveloppe pour les paramètres de `aqlm`.

#### post_init[[transformers.AqlmConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L902)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

## VptqConfig[[transformers.VptqConfig]]

#### transformers.VptqConfig[[transformers.VptqConfig]]

```python
transformers.VptqConfig(enable_proxy_error: bool = False, config_for_layers: dict = {}, shared_layer_config: dict = {}, modules_to_not_convert: list | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L980)

**Paramètres :**

enable_proxy_error (`bool`, *facultatif*, valeur par défaut `False`) : calculer l'erreur de proxy pour chaque couche

config_for_layers (`Dict`, *facultatif*, valeur par défaut `{}`) : paramètres de quantification pour chaque couche

shared_layer_config (`Dict`, *facultatif*, valeur par défaut `{}`) : paramètres de quantification partagés entre les couches

modules_to_not_convert (`list`, *facultatif*, par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine (par ex. l'encodeur Whisper, l'encodeur Llava, les couches de porte de Mixtral).

kwargs (`dict[str, Any]`, *facultatif*) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

Ceci est une classe enveloppe concernant les paramètres `vptq`.

#### post_init[[transformers.VptqConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1010)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

## AwqConfig[[transformers.AwqConfig]]

#### transformers.AwqConfig[[transformers.AwqConfig]]

```python
transformers.AwqConfig(bits: int = 4, group_size: int = 128, zero_point: bool = True, backend: AwqBackend = <AwqBackend.AUTO: 'auto'>, modules_to_not_convert: list | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L799)

**Paramètres :**

bits (`int`, *facultatif*, valeur par défaut : 4) : Le nombre de bits pour la quantification.

group_size (`int`, *facultatif*, valeur par défaut : 128) : La taille de groupe à utiliser pour la quantification. La valeur recommandée est 128 et -1 utilise la quantification par colonne.

zero_point (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser la quantification à point zéro.

backend (`AwqBackend`, *facultatif*, valeur par défaut `AwqBackend.AUTO`) : le backend de quantification.

modules_to_not_convert (`list`, *facultatif*, valeur par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine (par ex. l'encodeur Whisper, l'encodeur Llava, les couches de porte de Mixtral). Notez que vous ne pouvez pas quantiser directement avec transformers, veuillez vous reporter à la documentation de `AutoAWQ` pour quantiser les modèles HF.

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités que vous pouvez exploiter sur un modèle chargé à l'aide de la quantification awq de la bibliothèque `auto-awq`, qui s'appuie sur le backend auto_awq.

## EetqConfig[[transformers.EetqConfig]]

#### transformers.EetqConfig[[transformers.EetqConfig]]

```python
transformers.EetqConfig(weights: str = 'int8', modules_to_not_convert: list | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1062)

**Paramètres :**

weights (`str`, *facultatif*, par défaut `"int8"`) : Le type de données cible pour les poids. La seule valeur prise en charge est "int8"

modules_to_not_convert (`list`, *facultatif*, valeur par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine.

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités que vous pouvez exploiter sur un modèle chargé à l'aide de `eetq`.

#### post_init[[transformers.EetqConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1086)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

## GPTQConfig[[transformers.GPTQConfig]]

#### transformers.GPTQConfig[[transformers.GPTQConfig]]

```python
transformers.GPTQConfig(bits: int, tokenizer: Any = None, dataset: list[str] | str | None = None, group_size: int = 128, damp_percent: float = 0.1, desc_act: bool = False, act_group_aware: bool = True, sym: bool = True, true_sequential: bool = True, format: str = 'gptq', meta: dict[str, typing.Any] | None = None, backend: str | None = None, model_seqlen: int | None = None, block_name_to_quantize: str | None = None, module_name_preceding_first_block: list[str] | None = None, batch_size: int = 1, pad_token_id: int | None = None, max_input_length: int | None = None, cache_block_outputs: bool = True, modules_in_block_to_quantize: list[list[str]] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L617)

**Paramètres :**

bits (`int`) : Le nombre de bits de quantisation, les valeurs prises en charge sont (2, 3, 4, 8).

tokenizer (`str` ou `PreTrainedTokenizerBase`, *facultatif*) : Le tokenizer utilisé pour traiter le jeu de données. Vous pouvez transmettre : - un objet tokenizer personnalisé. - une chaîne de caractères, l'*identifiant du modèle* d'un tokenizer prédéfini hébergé dans un dépôt de modèles sur huggingface.co. - un chemin vers un *répertoire* contenant les fichiers de vocabulaire requis par le tokenizer, par exemple sauvegardés à l'aide de la méthode [save_pretrained()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), par ex. `./my_model_directory/`.

dataset (`Union[list[str]]`, *facultatif*) : Le jeu de données utilisé pour la quantification. Vous pouvez fournir votre propre jeu de données sous forme de liste de chaînes de caractères, ou simplement utiliser les jeux de données d'origine employés dans l'article GPTQ ['wikitext2','c4','c4-new']

group_size (`int`, *facultatif*, valeur par défaut : 128) : La taille de groupe à utiliser pour la quantification. La valeur recommandée est 128 et -1 utilise la quantification par colonne.

damp_percent (`float`, *facultatif*, valeur par défaut 0.1) : Le pourcentage de la diagonale moyenne de la matrice hessienne à utiliser pour l'amortissement. La valeur recommandée est 0.1.

desc_act (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut quantiser les colonnes dans l'ordre de taille d'activation décroissante. La définir sur False peut accélérer considérablement l'inférence, mais la perplexité peut se dégrader légèrement. Également connu sous le nom de act-order.

act_group_aware (`bool`, *facultatif*, valeur par défaut `True`) : Utilise GAR (group aware activation order) lors de la quantification. A un impact positif mesurable sur la qualité de la quantification. N'est applicable que lorsque `desc_act = False`. Sera forcé à `False` lorsque `desc_act = True`.

sym (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser une quantification symétrique.

true_sequential (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer une quantification séquentielle, y compris au sein d'un seul bloc Transformer. Plutôt que de quantifier l'ensemble du bloc d'un coup, nous effectuons une quantification couche par couche. En conséquence, chaque couche subit une quantification à l'aide d'entrées ayant traversé les couches précédemment quantifiées.

format (`str`, *facultatif*, par défaut `"gptq"`) : format de poids GPTQ. `gptq` (v1) est pris en charge par gptqmodel. `gptq_v2` est exclusif à gptqmodel.

meta (`dict[str, any]`, *facultatif*) : Les propriétés qui ne contribuent pas directement à la quantification ou à l'inférence quantifiée, telles que tooling:version, sont stockées dans meta. Par exemple, `meta.quantizer` : ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *facultatif*) : Permet de contrôler le noyau à utiliser. Les valeurs valides pour gptqmodel sont `auto`, `auto_trainable` et d'autres. Voir les backends de gptqmodel : https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py

model_seqlen (`int`, *facultatif*) : La longueur de séquence maximale que le modèle peut accepter.

block_name_to_quantize (`str`, *facultatif*) : Nom du bloc Transformers à quantiser. Si la valeur est None, le nom du bloc est déduit à l'aide de motifs courants (par exemple model.layers).

module_name_preceding_first_block (`list[str]`, *facultatif*) : Les couches qui précèdent le premier bloc Transformer.

batch_size (`int`, *facultatif*, valeur par défaut : 1) : La taille du lot utilisée lors du traitement du jeu de données

pad_token_id (`int`, *facultatif*) : L'identifiant du jeton de bourrage. Nécessaire pour préparer le jeu de données lorsque `batch_size` > 1.

max_input_length (`int`, *facultatif*) : La longueur maximale de l'entrée. Cette valeur est nécessaire pour initialiser un tampon qui dépend de la longueur d'entrée maximale attendue. Elle est spécifique au backend exllama avec act-order.

cache_block_outputs (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre en cache les sorties des blocs pour les réutiliser en tant qu'entrées du bloc suivant.

modules_in_block_to_quantize (`list[list[str]]`, *facultatif*) : Liste de listes de noms de modules à quantifier dans le bloc spécifié. Cet argument est utile pour exclure certains modules linéaires de la quantification. Le bloc à quantifier peut être spécifié en définissant `block_name_to_quantize`. Nous quantifierons chaque liste séquentiellement. Si non défini, nous quantifierons toutes les couches linéaires. Exemple : `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`. Dans cet exemple, nous quantifierons d'abord les couches q, k, v simultanément, car elles sont indépendantes. Ensuite, nous quantifierons la couche `self_attn.o_proj` avec les couches q, k, v déjà quantifiées. De cette manière, nous obtiendrons de meilleurs résultats, car cela reflète les entrées réelles que `self_attn.o_proj` recevra lorsque le modèle sera quantifié.

Il s’agit d’une classe enveloppe regroupant l’ensemble des attributs et des fonctionnalités possibles avec un modèle chargé via l’API `optimum` pour la quantification GPTQ, en s’appuyant sur le backend gptqmodel.

#### from_dict_optimum[[transformers.GPTQConfig.from_dict_optimum]]

```python
from_dict_optimum(config_dict)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L788)

Obtenir la classe compatible avec le dictionnaire de configuration gptq de optimum

#### post_init[[transformers.GPTQConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L738)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

#### to_dict_optimum[[transformers.GPTQConfig.to_dict_optimum]]

```python
to_dict_optimum()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L782)

Obtenir un dictionnaire compatible pour la configuration gptq d’optimum

## BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

#### transformers.BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

```python
transformers.BitsAndBytesConfig(load_in_8bit = False, load_in_4bit = False, llm_int8_threshold = 6.0, llm_int8_skip_modules = None, llm_int8_enable_fp32_cpu_offload = False, llm_int8_has_fp16_weight = False, bnb_4bit_compute_dtype = None, bnb_4bit_quant_type = 'fp4', bnb_4bit_use_double_quant = False, bnb_4bit_quant_storage = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L390)

**Paramètres :**

load_in_8bit (`bool`, *facultatif*, valeur par défaut `False`) : Ce drapeau est utilisé pour activer la quantification 8 bits avec LLM.int8().

load_in_4bit (`bool`, *facultatif*, valeur par défaut `False`) : Ce drapeau permet d'activer la quantification 4 bits en remplaçant les couches Linear par des couches FP4/NF4 de `bitsandbytes`.

llm_int8_threshold (`float`, *facultatif*, valeur par défaut 6.0) : Cette valeur correspond au seuil de détection des valeurs aberrantes tel que décrit dans l'article `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale` : https://huggingface.co/papers/2208.07339 Toute valeur d'état caché supérieure à ce seuil est considérée comme une valeur aberrante et les opérations sur ces valeurs sont effectuées en fp16. Les valeurs suivent généralement une distribution normale, c'est-à-dire que la plupart des valeurs se situent dans l'intervalle [-3.5, 3.5], mais il existe des valeurs aberrantes systématiques exceptionnelles, très différemment distribuées pour les grands modèles. Ces valeurs aberrantes se trouvent souvent dans l'intervalle [-60, -6] ou [6, 60]. La quantification Int8 fonctionne bien pour des valeurs d'amplitude d'environ 5, mais au-delà, la pénalité de performance est significative. Un seuil par défaut approprié est 6, mais un seuil plus bas peut être nécessaire pour les modèles plus instables (petits modèles, fine-tuning).

llm_int8_skip_modules (`list[str]`, *facultatif*) : Une liste explicite des modules que nous ne souhaitons pas convertir en 8 bits. Cela est utile pour des modèles tels que Jukebox, qui possède plusieurs têtes situées à différents endroits et pas nécessairement à la dernière position. Par exemple, pour les modèles `CausalLM`, le dernier `lm_head` est conservé dans son `dtype` d'origine.

llm_int8_enable_fp32_cpu_offload (`bool`, *facultatif*, valeur par défaut `False`) : Ce drapeau est destiné aux cas d'utilisation avancés et aux utilisateurs connaissant cette fonctionnalité. Si vous souhaitez diviser votre modèle en différentes parties et exécuter certaines en int8 sur GPU et d'autres en fp32 sur CPU, vous pouvez utiliser ce drapeau. C'est utile pour décharger de grands modèles tels que `google/flan-t5-xxl`. Notez que les opérations int8 ne seront pas exécutées sur CPU.

llm_int8_has_fp16_weight (`bool`, *facultatif*, valeur par défaut `False`) : Ce drapeau exécute LLM.int8() avec des poids principaux en 16 bits. C'est utile pour le fine-tuning, car les poids n'ont pas à être convertis à l'aller-retour pour la rétropropagation.

bnb_4bit_compute_dtype (`torch.dtype` ou str, *facultatif*, par défaut `torch.float32`) : Définit le type de calcul, qui peut différer du type d'entrée. Par exemple, les entrées peuvent être en fp32, mais le calcul peut être configuré en bf16 pour gagner en vitesse.

bnb_4bit_quant_type (`str`,  *facultatif*, valeur par défaut `"fp4"`) : Définit le type de données de quantification dans les couches bnb.nn.Linear4Bit. Les options sont les types de données FP4 et NF4, spécifiés par `fp4` ou `nf4`.

bnb_4bit_use_double_quant (`bool`, *facultatif*, valeur par défaut `False`) : Ce drapeau est utilisé pour la quantification imbriquée, où les constantes de quantification issues de la première quantification sont à nouveau quantifiées.

bnb_4bit_quant_storage (`torch.dtype` ou str, *facultatif*, par défaut `torch.uint8`) : Définit le type de stockage pour l'empaquetage des paramètres quantifiés sur 4 bits.

kwargs (`dict[str, Any]`, *facultatif*) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités que vous pouvez exploiter sur un modèle chargé à l'aide de `bitsandbytes`.

Prend actuellement en charge uniquement la quantification `LLM.int8()`, `FP4` et `NF4`. Si d'autres méthodes sont ajoutées à `bitsandbytes`, de nouveaux arguments seront ajoutés à cette classe.

#### is_quantizable[[transformers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L551)

Retourne `True` si le modèle est quantifiable, `False` sinon.

#### post_init[[transformers.BitsAndBytesConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L521)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

#### quantization_method[[transformers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L557)

Cette méthode renvoie la méthode de quantification utilisée pour le modèle. Si le modèle n'est pas quantifiable, elle renvoie `None`.

#### to_diff_dict[[transformers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L588)

**Retourne :** `dict[str, Any]`

Dictionnaire de tous les attributs qui composent cette instance de configuration,

Supprime tous les attributs de la configuration qui correspondent aux attributs de la configuration par défaut, afin d'améliorer la lisibilité, puis sérialise le résultat en dictionnaire Python.

## HfQuantizer[[transformers.quantizers.HfQuantizer]]

#### transformers.quantizers.HfQuantizer[[transformers.quantizers.HfQuantizer]]

```python
transformers.quantizers.HfQuantizer(quantization_config: QuantizationConfigMixin, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L74)

Classe abstraite du quantiseur HuggingFace. Prend actuellement en charge la quantification des modèles transformers HF pour l'inférence et/ou la quantification. Cette classe n'est utilisée que par transformers.PreTrainedModel.from_pretrained et ne peut pas encore être facilement utilisée en dehors du périmètre de cette méthode.

Attributes quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`) : la configuration de quantification qui définit les paramètres de quantification de votre modèle que vous souhaitez quantifier. requires_calibration (`bool`) : indique si la méthode de quantification nécessite de calibrer le modèle avant de l'utiliser.

#### adjust_max_memory[[transformers.quantizers.HfQuantizer.adjust_max_memory]]

```python
adjust_max_memory(max_memory: dict)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L148)

Ajustez l'argument max_memory de infer_auto_device_map() si une mémoire supplémentaire est nécessaire pour la quantification

#### dequantize[[transformers.quantizers.HfQuantizer.dequantize]]

```python
dequantize(model, dtype = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L239)

Désquantifier éventuellement le modèle pour récupérer le modèle d'origine, avec une certaine perte en précision / performance. Notez que tous les schémas de quantification ne prennent pas en charge cette opération.

#### get_load_operations[[transformers.quantizers.HfQuantizer.get_load_operations]]

```python
get_load_operations()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L323)

Classes d'opérations chargant les tenseurs sérialisés, par exemple `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. La désérialisation construit les paramètres d'un module, elle ne s'exécute donc que sur les convertisseurs généraux. La déquantisation s'exécute également avant les opérations des convertisseurs du modèle, par exemple avant une fusion par expert.

#### get_new_dtype[[transformers.quantizers.HfQuantizer.get_new_dtype]]

```python
get_new_dtype(converter, param, dtype: torch.dtype | None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L134)

Cela se produit au moment de la matérialisation, lorsque le tenseur est transféré du disque vers l’appareil. `dtype` pour convertir le tenseur du point de contrôle pré-quantifié `param`. Si ce paramètre n’est pas quantifié (type flottant), nous utilisons le `dtype` d’entrée provenant du `nn.Module` initialisé.

Si la méthode de quantification possède un `Deserializer` ou un `Dequantizer` (fonction de chargement), nous retournons None afin que ce soit géré par eux.

#### get_state_dict_and_metadata[[transformers.quantizers.HfQuantizer.get_state_dict_and_metadata]]

```python
get_state_dict_and_metadata(model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L290)

Obtenir le dictionnaire d'état et les métadonnées. Utile lorsque nous devons modifier légèrement le dictionnaire d'état en raison de la quantification

#### get_weight_conversions[[transformers.quantizers.HfQuantizer.get_weight_conversions]]

```python
get_weight_conversions()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L331)

Retourner le chargement à effectuer sur tout paramètre qui ne correspond pas aux convertisseurs du modèle

#### param_needs_quantization[[transformers.quantizers.HfQuantizer.param_needs_quantization]]

```python
param_needs_quantization(model: PreTrainedModel, param_name: str, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L152)

Vérifie si un paramètre donné doit être quantifié.

#### postprocess_model[[transformers.quantizers.HfQuantizer.postprocess_model]]

```python
postprocess_model(model: PreTrainedModel, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L207)

**Paramètres :**

model (`~transformers.PreTrainedModel`) : Le modèle à quantiser

kwargs (`dict`, *facultatif*) : Les arguments par mot-clé transmis à `_process_model_after_weight_loading`.

Post-traitez le modèle après le chargement des poids. Assurez-vous de redéfinir la méthode abstraite `_process_model_after_weight_loading`.

#### preprocess_model[[transformers.quantizers.HfQuantizer.preprocess_model]]

```python
preprocess_model(model: PreTrainedModel, dtype = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L184)

**Paramètres :**

model (`~transformers.PreTrainedModel`) : Le modèle à quantiser

kwargs (`dict`, *facultatif*) : Les arguments par mot-clé transmis à `_process_model_before_weight_loading`.

Définition des attributs du modèle et/ou conversion du modèle avant le chargement des poids. À ce stade, le modèle doit être initialisé sur l'appareil meta, ce qui vous permet de manipuler librement la structure du modèle afin de remplacer les modules en place. Assurez-vous de redéfinir la méthode abstraite `_process_model_before_weight_loading`.

#### remove_quantization_config[[transformers.quantizers.HfQuantizer.remove_quantization_config]]

```python
remove_quantization_config(model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L227)

Supprimez la configuration de quantification du modèle.

#### update_attn_implementation[[transformers.quantizers.HfQuantizer.update_attn_implementation]]

```python
update_attn_implementation(config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L177)

Consulte le `attn_implementation` demandé avant que le modèle ne soit construit, afin qu'un quantiseur puisse définir une valeur par défaut.

#### update_device_map[[transformers.quantizers.HfQuantizer.update_device_map]]

```python
update_device_map(device_map: dict[str, typing.Any] | None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L112)

**Paramètres :**

device_map (`Union[dict, str]`, *facultatif*) : La device_map transmise par la méthode `from_pretrained`.

Écrasez cette méthode si vous souhaitez remplacer la carte de dispositifs existante par une nouvelle. Par exemple, pour bitsandbytes, comme `accelerate` est une exigence stricte, si aucune device_map n'est transmise, la device_map est définie sur `"auto"``

#### update_dtype[[transformers.quantizers.HfQuantizer.update_dtype]]

```python
update_dtype(dtype: torch.dtype)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L100)

**Paramètres :**

dtype (`torch.dtype`) : le type de données d'entrée transmis à `from_pretrained`

Certaines méthodes de quantification exigent de définir explicitement le dtype du modèle sur un dtype cible. Vous devez redéfinir cette méthode si vous souhaitez vous assurer que ce comportement est conservé

#### update_parallel_plan[[transformers.quantizers.HfQuantizer.update_parallel_plan]]

```python
update_parallel_plan(model, plan: dict)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L166)

Mise à jour sur place de `model.tp_plan` ou `model.ep_plan` (les plans complets, fusionnés à partir de la configuration et de toutes les sous-configurations) afin de prendre en compte les clés personnalisées du quantificateur, telles que 'inv_scale'

#### update_weight_conversions[[transformers.quantizers.HfQuantizer.update_weight_conversions]]

```python
update_weight_conversions(weight_conversions, model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L341)

Permet aux convertisseurs du modèle (issus de la correspondance de conversion) de charger les noms sérialisés. Les paramètres du modèle décident, par exemple, de la fusion de `experts.*.gate_proj.weight` dans `experts.gate_up_proj` :
- `experts.gate_up_proj_scale_inv` est un paramètre : une copie fusionne `experts.*.gate_proj.weight_scale_inv` dedans
- sinon le convertisseur collecte également `experts.*.gate_proj.weight_scale_inv`, l’op de déquantisation s’exécute en premier

#### validate_environment[[transformers.quantizers.HfQuantizer.validate_environment]]

```python
validate_environment(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L158)

Cette méthode est utilisée pour vérifier d’éventuels conflits avec les arguments passés à `from_pretrained`. Vous devez la définir pour tous les quantificateurs futurs qui seront intégrés à transformers. Si aucune vérification explicite n’est nécessaire, il suffit de ne rien retourner.

## HiggsConfig[[transformers.HiggsConfig]]

#### transformers.HiggsConfig[[transformers.HiggsConfig]]

```python
transformers.HiggsConfig(bits: int = 4, p: int = 2, modules_to_not_convert: list[str] | None = None, hadamard_size: int = 512, group_size: int = 256, tune_metadata: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1315)

**Paramètres :**

bits (int, *facultatif*, valeur par défaut 4) : Nombre de bits à utiliser pour la quantification. Peut être 2, 3 ou 4. La valeur par défaut est 4.

p (int, *facultatif*, valeur par défaut 2) : Dimension de la grille de quantification. Les valeurs 1 et 2 sont prises en charge. En pratique, 2 est toujours préférable. La valeur par défaut est 2.

modules_to_not_convert (`list`, *facultatif*, par défaut ["lm_head"]) : Liste des couches linéaires qui ne doivent pas être quantifiées.

hadamard_size (int, *facultatif*, valeur par défaut 512) : taille de Hadamard pour la méthode HIGGS. La valeur par défaut est 512. La dimension d'entrée des matrices est complétée (padding) jusqu'à cette valeur. Réduire cette valeur en dessous de 512 diminuera la qualité de la quantification.

group_size (int, *facultatif*, valeur par défaut 256) : Taille du groupe pour la méthode HIGGS. Peut être 64, 128 ou 256. La diminuer n'a que très peu d'impact sur les performances. La valeur par défaut est 256. Doit être un diviseur de hadamard_size.

tune_metadata ('dict', *facultatif*, valeur par défaut {}) : métadonnées par module (formes de blocs gemm, métadonnées GPU, etc.) pour enregistrer les résultats de l'ajustement du noyau. La valeur par défaut est un dictionnaire vide. Elle est définie automatiquement pendant l'ajustement.

HiggsConfig est une classe de configuration pour la quantification à l'aide de la méthode HIGGS.

#### post_init[[transformers.HiggsConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1356)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

## HqqConfig[[transformers.HqqConfig]]

#### transformers.HqqConfig[[transformers.HqqConfig]]

```python
transformers.HqqConfig(nbits: int = 4, group_size: int = 64, view_as_float: bool = False, axis: int | None = None, dynamic_config: dict | None = None, skip_modules: list = ['lm_head'], **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L277)

**Paramètres :**

nbits (`int`, *facultatif*, valeur par défaut : 4) : Nombre de bits. Les valeurs prises en charge sont (8, 4, 3, 2, 1).

group_size (`int`, *facultatif*, valeur par défaut : 64) : Valeur de la taille du groupe. Les valeurs prises en charge sont toutes les valeurs divisibles par weight.shape[axis]).

view_as_float (`bool`, *facultatif*, valeur par défaut `False`) : Affiche le poids quantifié en tant que flottant (utilisé dans l'entraînement distribué) si la valeur est `True`.

axis (`Optional[int]`, *facultatif*) : Axe le long duquel le regroupement est effectué. Les valeurs prises en charge sont 0 ou 1.

dynamic_config (dict, *facultatif*) : Paramètres pour la configuration dynamique. La clé est le nom de la couche et la valeur est une configuration de quantification. Si défini, chaque couche spécifiée par son identifiant utilisera sa configuration de quantification dédiée.

skip_modules (`list[str]`, *facultatif*, par défaut `['lm_head']`) : Liste des couches `nn.Linear` à ignorer.

kwargs (`dict[str, Any]`, *facultatif*) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

Il s’agit d’un wrapper autour de BaseQuantizeConfig de hqq.

#### from_dict[[transformers.HqqConfig.from_dict]]

```python
from_dict(config: dict)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L342)

Redéfinition de from_dict, utilisé dans AutoQuantizationConfig.from_dict dans quantizers/auto.py

#### post_init[[transformers.HqqConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L337)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

#### to_diff_dict[[transformers.HqqConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L367)

**Retourne :** `dict[str, Any]`

Dictionnaire de tous les attributs qui composent cette instance de configuration,

Supprime tous les attributs de la configuration qui correspondent aux attributs de la configuration par défaut, afin d'améliorer la lisibilité, puis sérialise le résultat en dictionnaire Python.

## MetalConfig[[transformers.MetalConfig]]

#### transformers.MetalConfig[[transformers.MetalConfig]]

```python
transformers.MetalConfig(bits: int = 4, group_size: int = 64, modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1825)

Classe de configuration pour la quantification affine Metal ciblant les appareils Apple Silicon (MPS).

Cette méthode de quantisation utilise les noyaux Metal `mlx-quantization-metal-kernels` du Hugging Face Hub pour effectuer une quantisation affine (échelles + qbiases) avec une largeur de bits et une taille de groupe configurables. Les poids quantisés sont regroupés dans des tenseurs `uint32` et le passage avant utilise des noyaux Metal fusionnés de déquantisation + matmul.

## Mxfp4Config[[transformers.Mxfp4Config]]

#### transformers.Mxfp4Config[[transformers.Mxfp4Config]]

```python
transformers.Mxfp4Config(modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1791)

**Paramètres :**

modules_to_not_convert (`list`, *facultatif*, valeur par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine.

dequantize (`bool`, *facultatif*, par défaut `False`) : Indique si le modèle doit être déquantisé en précision bf16 ou non

Il s’agit d’une classe enveloppe regroupant l’ensemble des attributs et des fonctionnalités possibles avec lesquels vous pouvez manipuler un modèle chargé en utilisant la quantification mxfp4.

## NVFP4Config[[transformers.NVFP4Config]]

#### transformers.NVFP4Config[[transformers.NVFP4Config]]

```python
transformers.NVFP4Config(modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2067)

**Paramètres :**

modules_to_not_convert (`list[str]`, *facultatif*) : Motifs de noms de modules qui doivent conserver leur précision d'origine.

kwargs (`dict[str, Any]`, *facultatif*) : Les valeurs supplémentaires sont ignorées et signalées via le journaliseur Transformers.

Configuration pour la quantification des poids NVFP4 à la volée.

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

#### transformers.FbgemmFp8Config[[transformers.FbgemmFp8Config]]

```python
transformers.FbgemmFp8Config(activation_scale_ub: float = 1200.0, modules_to_not_convert: list | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1284)

**Paramètres :**

activation_scale_ub (`float`, *facultatif*, valeur par défaut 1200.0) : La borne supérieure de l'échelle d'activation. Elle est utilisée lors de la quantification de l'activation d'entrée.

modules_to_not_convert (`list`, *facultatif*, valeur par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine.

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités possibles avec lesquels vous pouvez manipuler un modèle chargé en utilisant la quantification fp8 de fbgemm.

## CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

#### transformers.CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

```python
transformers.CompressedTensorsConfig(config_groups: dict[str, typing.Union[ForwardRef('QuantizationScheme'), list[str]]] | None = None, format: str = 'dense', quantization_status: QuantizationStatus = 'initialized', kv_cache_scheme: typing.Optional[ForwardRef('QuantizationArgs')] = None, global_compression_ratio: float | None = None, ignore: list[str] | None = None, quant_method: str = 'compressed-tensors', run_compressed: bool | None = None, dequantize: bool = False, use_optimized_inference: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1095)

**Paramètres :**

config_groups (`typing.dict[str, typing.Union[ForwardRef('QuantizationScheme'), typing.list[str]]]`, *facultatif*) : dictionnaire associant un nom de groupe à une définition de schéma de quantification

format (`str`, *facultatif*, valeur par défaut `"dense"`) : format dans lequel les poids sont stockés, par exemple `dense`, `float-quantized` ou `pack-quantized`

quantization_status (`QuantizationStatus`, *facultatif*, valeur par défaut `"initialized"`) : état du modèle dans le cycle de vie de la quantification, par exemple 'initialized', 'calibration', 'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`, *facultatif*) : spécifie la quantification du cache kv. Si la valeur est None, le cache kv n'est pas quantifié.

global_compression_ratio (`typing.Union[float, NoneType]`, *facultatif*) : pourcentage de compression du modèle, flottant compris entre 0 et 1

ignore (`typing.Union[typing.list[str], NoneType]`, *facultatif*) : noms ou types de couches à ne pas quantiser, prend en charge les expressions régulières préfixées par 're:'

quant_method (`str`, *facultatif*, par défaut `"compressed-tensors"`) : ne pas remplacer, doit être compressed-tensors

run_compressed (`bool`, *facultatif*) : obsolète, utilisez `dequantize` à la place. Son seul effet est de définir `dequantize` à sa valeur opposée, `run_compressed=False` signifiant `dequantize=True`.

dequantize (`bool`, *facultatif*, valeur par défaut `False`) : lorsque `True`, les poids quantifiés sont déquantifiés pour revenir au type de données du modèle (par ex. BF16) au moment du chargement, ce qui est nécessaire pour l'ajustement fin ou l'enregistrement du modèle dans son type de données d'origine. Lorsque `False`, les poids sont conservés sous leur forme compressée et compressed-tensors les décompresse lors du premier passage avant.

use_optimized_inference (`bool`, *facultatif*, valeur par défaut `False`) : lorsque `True`, les couches pour lesquelles nous disposons de noyaux conservent leurs poids quantifiés et sont exécutées via ces noyaux (actuellement W8A8 FP8, sur CUDA SM89+, XPU, ou MPS avec torch >= 2.15). Réservé à l'inférence et activé explicitement : sans cela, le modèle passe par le chemin standard compressed-tensors. Ignoré lorsque `dequantize=True`.

Ceci est une classe enveloppe qui gère les options de configuration de quantification de compressed-tensors. Il s'agit d'un wrapper autour de `compressed_tensors.QuantizationConfig`

#### from_dict[[transformers.CompressedTensorsConfig.from_dict]]

```python
from_dict(config_dict, return_unused_kwargs = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1192)

**Paramètres :**

config_dict (`dict[str, Any]`) : Dictionnaire qui sera utilisé pour instancier l'objet de configuration.

return_unused_kwargs (`bool`,*facultatif*, par défaut `False`) : Indique s'il faut ou non retourner une liste d'arguments de mots-clés non utilisés. Utilisé par la méthode `from_pretrained` de `PreTrainedModel`.

kwargs (`dict[str, Any]`) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

**Retourne :** `QuantizationConfigMixin`

L'objet de configuration instancié à partir de ces paramètres.

Instancie un [CompressedTensorsConfig](/docs/transformers/main/fr/main_classes/quantization#transformers.CompressedTensorsConfig) à partir d'un dictionnaire Python de paramètres. Développe éventuellement les arguments de la quantization_config imbriquée.

#### to_dict[[transformers.CompressedTensorsConfig.to_dict]]

```python
to_dict()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1217)

Configuration de quantification à ajouter à config.json

Sérialise cette instance en dictionnaire Python. Retourne : `dict[str, Any]` : Dictionnaire de tous les attributs qui composent cette instance de configuration.

#### to_diff_dict[[transformers.CompressedTensorsConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1232)

**Retourne :** `dict[str, Any]`

Dictionnaire de tous les attributs qui composent cette instance de configuration,

Supprime tous les attributs de la configuration qui correspondent aux attributs de la configuration par défaut, afin d'améliorer la lisibilité, puis sérialise le résultat en dictionnaire Python.

## TorchAoConfig[[transformers.TorchAoConfig]]

#### transformers.TorchAoConfig[[transformers.TorchAoConfig]]

```python
transformers.TorchAoConfig(quant_type: AOBaseConfig, modules_to_not_convert: list | None = None, include_input_output_embeddings: bool = False, untie_embedding_weights: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1460)

**Paramètres :**

quant_type (`AOBaseConfig`) : une instance de `AOBaseConfig` de torchao spécifiant le type de quantification, par exemple `Int4WeightOnlyConfig(group_size=32)`, `Int8WeightOnlyConfig()`, `Int8DynamicActivationInt8WeightConfig()`, `Float8WeightOnlyConfig()`, etc.

modules_to_not_convert (`list`, *facultatif*, valeur par défaut `None`) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine.

include_input_output_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut inclure l'embedding dans la quantification ou non. Si ce drapeau est défini, l'embedding d'entrée sera également retiré de la liste module_not_to_convert.

untie_embedding_weights (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut délier les poids lors de la quantification des poids d'embedding d'entrée liés à d'autres poids.

Classe de configuration pour les techniques de quantification/rareté de torchao.

Exemple :

```python
from torchao.quantization import Int4WeightOnlyConfig

quantization_config = TorchAoConfig(Int4WeightOnlyConfig(group_size=32))
model = AutoModelForCausalLM.from_pretrained(
    model_id, device_map="cuda", torch_dtype=torch.bfloat16, quantization_config=quantization_config
)
```

#### from_dict[[transformers.TorchAoConfig.from_dict]]

```python
from_dict(config_dict, return_unused_kwargs = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1543)

Créer une configuration à partir d'un dictionnaire.

#### get_apply_tensor_subclass[[transformers.TorchAoConfig.get_apply_tensor_subclass]]

```python
get_apply_tensor_subclass()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1529)

Retourner la configuration de quantification à appliquer.

#### post_init[[transformers.TorchAoConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1511)

Valider la configuration et définir les valeurs par défaut.

#### to_dict[[transformers.TorchAoConfig.to_dict]]

```python
to_dict()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1533)

Convertit la configuration en dictionnaire.

## BitNetQuantConfig[[transformers.BitNetQuantConfig]]

#### transformers.BitNetQuantConfig[[transformers.BitNetQuantConfig]]

```python
transformers.BitNetQuantConfig(modules_to_not_convert: list | None = None, linear_class: str = 'bitlinear', quantization_mode: str = 'offline', use_rms_norm: bool = False, rms_norm_eps: float | None = 1e-06, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1563)

**Paramètres :**

modules_to_not_convert (`Optional[List]`, *facultatif*) : Fournit éventuellement une liste de chemins complets des paramètres de poids de `nn.Linear` qui ne doivent pas être quantifiés. La valeur par défaut est None.

linear_class (`str`, *facultatif*, par défaut `"bitlinear"`) : Le type de classe linéaire à utiliser. Peut être soit `bitlinear` soit `autobitlinear`.

quantization_mode (`str`, *facultatif*, valeur par défaut `"offline"`) : Le mode de quantisation à utiliser. Peut être `online` ou `offline`. En mode `online`, les paramètres de quantisation des poids sont calculés dynamiquement lors de chaque passe avant (par exemple, en fonction des valeurs actuelles des poids). Cela permet de s'adapter aux modifications des poids pendant l'entraînement (Quantization-Aware Training - QAT). En mode `offline`, les paramètres de quantisation sont précalculés *avant* l'inférence. Ces paramètres sont ensuite figés et chargés dans le modèle quantisé. Cela entraîne généralement une surcharge d'exécution plus faible par rapport à la quantisation en ligne.

use_rms_norm (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut appliquer RMSNorm aux activations avant la quantification. Cela correspond à l'approche du papier original de BitNet, qui normalise les activations avant la quantification/le regroupement.

rms_norm_eps (`float`, *facultatif*, valeur par défaut 1e-06) : La valeur epsilon utilisée dans la couche RMSNorm pour la stabilité numérique.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires qui peuvent être utilisés par des backends de quantification spécifiques ou par des versions futures.

Classe de configuration pour appliquer la quantification BitNet.

#### post_init[[transformers.BitNetQuantConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1612)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

## SpQRConfig[[transformers.SpQRConfig]]

#### transformers.SpQRConfig[[transformers.SpQRConfig]]

```python
transformers.SpQRConfig(bits: int = 3, beta1: int = 16, beta2: int = 16, shapes: dict[str, int] | None = None, modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1619)

**Paramètres :**

bits (`int`, *facultatif*, valeur par défaut 3) : spécifie le nombre de bits pour les poids et les points zéro et les échelles du premier ordre. Actuellement, seul bits = 3 est pris en charge.

beta1 (`int`, *facultatif*, valeur par défaut : 16) : largeur de tuile SpQR. Actuellement, seule la valeur beta1 = 16 est prise en charge.

beta2 (`int`, *facultatif*, valeur par défaut 16) : hauteur de tuile SpQR. Actuellement, seule la valeur beta2 = 16 est prise en charge.

shapes (`Optional`, *optionnel*) : Un dictionnaire contenant la forme de chaque objet. Nous en avons besoin car il est impossible de déduire la taille exacte des paramètres à partir des bits, beta1 et beta2 uniquement.

modules_to_not_convert (`Optional[list[str]]`, *facultatif*) : Fournit éventuellement une liste de chemins complets des paramètres de poids `nn.Linear` qui ne doivent pas être quantifiés. La valeur par défaut est None.

kwargs (`dict[str, Any]`, *facultatif*) : Paramètres supplémentaires à partir desquels initialiser l'objet de configuration.

Ceci est une classe enveloppe pour les paramètres de `spqr`. Reportez-vous à la publication originale pour plus de détails.

#### post_init[[transformers.SpQRConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1660)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

## FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

#### transformers.FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

```python
transformers.FineGrainedFP8Config(activation_scheme: str = 'dynamic', weight_block_size: tuple = (128, 128), dequantize: bool = False, modules_to_not_convert: list | None = None, modules_to_convert: list | None = None, scale_fmt: str = 'float', expert_dtype: str = 'fp8', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1682)

**Paramètres :**

activation_scheme (`str`, *facultatif*, valeur par défaut `"dynamic"`) : Le schéma utilisé pour l’activation. Le schéma par défaut et le seul actuellement pris en charge est "dynamic".

weight_block_size (`typing.tuple[int, int]`, *facultatif*, valeur par défaut `(128, 128)`) : La taille des blocs de poids pour la quantification, la valeur par défaut est (128, 128).

dequantize (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut déquantifier le modèle lors du chargement.

modules_to_not_convert (`list`, *facultatif*) : une liste de noms de modules qui ne doivent pas être convertis lors de la quantification.

modules_to_convert (`list`, *facultatif*) : une liste de noms de modules supplémentaires, tels que les tables d'incorporation, qui doivent être convertis lors de la quantification.

scale_fmt (`str`, *facultatif*, valeur par défaut `"float"`) : Type de stockage des échelles de poids par bloc : `"float"` (fp32, style V3) ou `"ue8m0"` (1 octet `torch.float8_e8m0fnu`, style V4).

expert_dtype (`str`, *facultatif*, valeur par défaut `"fp8"`) : Format des poids des experts MoE : `"fp8"`, ou `"fp4"` pour les experts FP4-packed de DeepSeek-V4.

FineGrainedFP8Config est une classe de configuration pour la quantification FP8 fine, utilisée principalement pour les modèles deepseek.

#### post_init[[transformers.FineGrainedFP8Config.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1729)

Vérificateur de sécurité qui vérifie que les arguments sont corrects

## QuarkConfig[[transformers.QuarkConfig]]

#### transformers.QuarkConfig[[transformers.QuarkConfig]]

```python
transformers.QuarkConfig(**kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1749)

## FourOverSixConfig[[transformers.FourOverSixConfig]]

#### transformers.FourOverSixConfig[[transformers.FourOverSixConfig]]

```python
transformers.FourOverSixConfig(activation_dtype: str | None = None, activation_scale_rule: str | None = None, dtype: str = 'nvfp4', gradient_dtype: str | None = None, gradient_scale_rule: str | None = None, keep_master_weights: bool = False, matmul_backend: str | None = None, output_dtype: str | None = 'bfloat16', quantize_backend: str | None = None, scale_rule: str = 'mse', weight_dtype: str | None = None, weight_scale_2d: bool = False, weight_scale_rule: str | None = None, module_config_overrides: dict[str, dict[str, typing.Any]] | None = None, modules_to_not_convert: list[str] | None = ['lm_head'], **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1869)

**Paramètres :**

activation_dtype (`str`, *facultatif*) : Type de données à utiliser lors de la quantification des tenseurs d'activation. S'il n'est pas fourni, `dtype` est utilisé.

activation_scale_rule (`str`, *facultatif*) : Règle de mise à l'échelle à utiliser lors du choix d'une échelle pour les blocs des tenseurs d'activation. Si elle n'est pas fournie, `scale_rule` est utilisée.

dtype (`str`, par défaut "nvfp4", *facultatif*, par défaut `"nvfp4"`) : Le type de données à utiliser pour les poids, les activations et les tenseurs de la couche. Peut être `"nvfp4"` ou `"mxfp4"`.

gradient_dtype (`str`, *facultatif*) : Type de données à utiliser lors de la quantification des tenseurs de gradient. S'il n'est pas fourni, `dtype` est utilisé.

gradient_scale_rule (`str`, *facultatif*) : Règle de mise à l'échelle à utiliser lors du choix d'une échelle pour les blocs dans les tenseurs de gradient. Si elle n'est pas fournie, `scale_rule` est utilisée.

keep_master_weights (`bool`, défaut False, *facultatif*, défaut `False`) : Indique s'il faut conserver les poids maîtres. Si `True`, les poids haute précision sont conservés en permanence et les poids sont quantifiés en ligne à chaque passe avant. Cela est utile pour l'entraînement quantifié.

matmul_backend (`str`, *facultatif*) : Le backend à utiliser pour les multiplications de matrices. Peut être `"cutlass"` ou `"pytorch"`. S'il n'est pas fourni, CUTLASS sera utilisé s'il est disponible, sinon PyTorch sera utilisé.

output_dtype (`str`, *facultatif*, valeur par défaut `"bfloat16"`) : Le type de données à utiliser pour la sortie de la couche. Peut être `"bfloat16"` ou `"float16"`.

quantize_backend (`str`, *facultatif*) : Le backend à utiliser pour la quantification. Peut être `"cuda"`, `"triton"` ou `"pytorch"`. S'il n'est pas fourni, le backend le plus rapide sera sélectionné en fonction de votre environnement et des options prises en charge par chaque backend. Généralement, `"cuda"` est utilisé pour l'inférence, `"triton"` pour l'entraînement, et `"pytorch"` sur les appareils non-CUDA.

scale_rule (`str`, par défaut "mse", *facultatif*, par défaut `"mse"`) : Règle à utiliser lors de la sélection des échelles de blocs. Peut être `"mse"`, `"mae"` ou `"abs_max"` pour Four Over Six, `"static_6"` pour la quantification NVFP4 par défaut, ou `"static_4"` pour mettre à l'échelle tous les blocs à une valeur maximale de 4.

weight_dtype (`str`, *facultatif*) : Type de données à utiliser lors de la quantification des tenseurs de poids. S'il n'est pas fourni, `dtype` est utilisé.

weight_scale_2d (`bool`, défaut False, *facultatif*, valeur par défaut `False`) : Indique s'il faut calculer les facteurs d'échelle sur les tenseurs de poids dans des blocs 2D. Cette opération doit être effectuée pendant l'entraînement.

weight_scale_rule (`str`, *facultatif*) : Règle de mise à l'échelle à utiliser lors du choix d'une échelle pour les blocs des tenseurs de poids. Si elle n'est pas fournie, `scale_rule` est utilisée.

module_config_overrides (`dict[str, dict[str, Any]]`, *facultatif*) : Un dictionnaire de configurations spécifiques aux modules. Les clés doivent être des noms de modules, et les valeurs doivent être des dictionnaires contenant la configuration de quantification pour ce module. Cela permet de remplacer la configuration par défaut pour des modules spécifiques.

modules_to_not_convert (`list[str]`, *facultatif*, par défaut `['lm_head']`) : La liste des modules à exclure de la quantification. Par défaut, le `lm_head` est exclu.

Il s’agit d’une classe enveloppe regroupant toutes les options de quantification avec `fouroversix`. En résumé, Four Over Six est une modification de la quantification NVFP4 qui met à l’échelle de manière adaptative la valeur maximale de chaque bloc de 16 valeurs FP4, soit à 4, soit à 6. Le choix d’une échelle de 6 exploite la plage complète des valeurs FP4, tandis que le choix d’une échelle de 4 permet une distribution plus uniforme de l’erreur de quantification. Reportez-vous à la publication originale pour plus de détails : https://arxiv.org/abs/2512.02010.

## FPQuantConfig[[transformers.FPQuantConfig]]

#### transformers.FPQuantConfig[[transformers.FPQuantConfig]]

```python
transformers.FPQuantConfig(forward_dtype: str = 'nvfp4', forward_method: str = 'abs_max', backward_dtype: str = 'bf16', store_master_weights: bool = False, hadamard_group_size: int | None = None, pseudoquantization: bool = False, transform_init: str = 'hadamard', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1371)

**Paramètres :**

forward_dtype (`str`, *facultatif*, valeur par défaut `"nvfp4"`) : Le dtype à utiliser pour le passage avant.

forward_method (`str`, *facultatif*, valeur par défaut `"abs_max"`) : Le type de mise à l'échelle à utiliser pour le passage avant. Peut être `"abs_max"` ou `"quest"`. `"abs_max"` est plus adapté au PTQ, `"quest"` est plus adapté au QAT.

backward_dtype (`str`, *facultatif*, par défaut `"bf16"`) : Le dtype à utiliser pour la passe arrière.

store_master_weights (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut stocker les poids maîtres. Nécessaire pour le QAT sur les poids des couches.

hadamard_group_size (`int`, *facultatif*) : La taille de groupe pour la transformation de Hadamard avant la quantification pour `"quest"`, qui correspond à la taille de groupe de MXFP4 (32). Si `None`, elle sera définie à 16 pour `"nvfp4"` et à 32 pour `"mxfp4"`.

pseudoquantization (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser la pseudo-quantification basée sur Triton. Obligatoire pour les GPU non-Blackwell. N'offre aucune accélération. À des fins de débogage.

transform_init (`str`, *facultatif*, par défaut `"hadamard"`) : une méthode pour initialiser la matrice de prétraitement. Peut être `"hadamard"`, `"identity"` ou `"gsr"`.

modules_to_not_convert (`list`, *facultatif*) : La liste des modules à ne pas quantiser, utile pour quantiser des modèles qui nécessitent explicitement de conserver certains modules dans leur précision d'origine.

FPQuantConfig est une classe de configuration pour la quantification à l'aide de la méthode FPQuant.

#### post_init[[transformers.FPQuantConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1418)

Vérificateur de sécurité qui s'assure que les arguments sont corrects - remplace également certains arguments de type NoneType par leurs valeurs par défaut.

## AutoRoundConfig[[transformers.AutoRoundConfig]]

#### transformers.AutoRoundConfig[[transformers.AutoRoundConfig]]

```python
transformers.AutoRoundConfig(bits: int = 4, group_size: int = 128, sym: bool = True, backend: str = 'auto', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L208)

**Paramètres :**

bits (`int`, *facultatif*, valeur par défaut : 4) : Le nombre de bits pour la quantification, les valeurs prises en charge sont (2, 3, 4, 5, 6, 7, 8).

group_size (`int`, *facultatif*, valeur par défaut 128) : valeur de la taille de groupe

sym (`bool`, *facultatif*, valeur par défaut `True`) : quantification symétrique ou non

backend (`str`, *facultatif*, valeur par défaut `"auto"`) : Le backend d'inférence. Par défaut, AutoRound sélectionne un backend compatible en fonction de l'appareil, des paramètres de quantification et des bibliothèques installées. Consultez [Spécifier le backend d'inférence](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend) pour toutes les options de backend.

Il s'agit d'une classe enveloppe regroupant l'ensemble des attributs et des fonctionnalités possibles avec lesquels vous pouvez manipuler un modèle chargé via la quantification AutoRound.

#### post_init[[transformers.AutoRoundConfig.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L239)

Vérificateur de sécurité qui s'assure que les arguments sont corrects.

## SinqConfig[[transformers.SinqConfig]]

#### transformers.SinqConfig[[transformers.SinqConfig]]

```python
transformers.SinqConfig(nbits: int = 4, group_size: int = 64, tiling_mode: str = '1D', method: str = 'sinq', modules_to_not_convert: list[str] | None = None, **kwargs: Any)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1964)

**Paramètres :**

nbits (`int`, par défaut 4) : Nombre de bits de quantification pour les poids.

group_size (`int`, défaut 64) : Taille de groupe utilisée dans la quantification des poids SINQ (doit être un multiple de 8).

tiling_mode (`str`, par défaut "1D") : Mode de tuilage pour SINQ (généralement "1D" ; "2D" si pris en charge par votre backend).

method (`str`, par défaut "sinq") : "sinq" – quantification SINQ sans calibration, poids uniquement ; "asinq" – A-SINQ (prise en compte des activations), non pris en charge par Hugging Face. Veuillez consulter le dépôt officiel de SINQ.

modules_to_not_convert (`list[str]`, *facultatif*) : Liste des noms/préfixes de modules à conserver en pleine précision.

- ****kwargs** : Arguments utilisateur supplémentaires (conservés dans `_extra_kwargs` pour la réutilisation).

Configuration de quantification pour SINQ / A-SINQ.

À passer à :

AutoModel.from_pretrained(..., quantization_config=SinqConfig(...))

## GgufConfig[[transformers.GgufConfig]]

#### transformers.GgufConfig[[transformers.GgufConfig]]

```python
transformers.GgufConfig(gguf_file: str | None = None, dequantize: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2087)

**Paramètres :**

gguf_file (`str`, *facultatif*) : chemin vers le fichier `.gguf` contenant les poids. Peut être omis s'il est spécifié via `from_pretrained(..., gguf_file=...)`, qui le remplit automatiquement.

dequantize (`bool`, *facultatif*, valeur par défaut `False`) : Dépaqueter chaque poids au chargement dans un modèle dense standard plutôt que de les conserver quantifiés. Toujours correct, mais renonce aux gains de mémoire ; c'est aussi le repli automatique lorsqu'aucun noyau de multiplication matricielle n'est disponible pour les types de quantisation du fichier.

Charger un point de contrôle GGUF quantifié avec ses poids laissés dans des blocs GGUF.