Hugging Face's logo

Transformers documentation

Quantification

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

and get access to the augmented documentation experience

to get started

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 8 bits (int8). Cela permet de charger des modèles plus volumineux que vous ne pourriez normalement pas faire 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 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.

QuantoConfig

classe transformers.QuantoConfig

< >

( weights = 'int8'activations = Nonemodules_to_not_convert: list | None = None**kwargs )

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 fonctionnalités possibles avec lesquels vous pouvez manipuler un modèle chargé à l’aide de quanto.

post_init

< >

( )

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

AqlmConfig

classe transformers.AqlmConfig

< >

( in_group_size: int = 8out_group_size: int = 1num_codebooks: int = 1nbits_per_codebook: int = 16linear_weights_not_to_quantize: list[str] | None = None**kwargs )

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, par défaut 1) — Nombre de codebooks pour la procédure de quantification additive.
  • nbits_per_codebook (int, facultatif, par défaut 16) — Nombre de bits encodant 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

< >

( )

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

classe transformers.VptqConfig

< >

( enable_proxy_error: bool = Falseconfig_for_layers: dict = {}shared_layer_config: dict = {}modules_to_not_convert: list | None = None**kwargs )

Paramètres

  • enable_proxy_error (bool, facultatif, par défaut False) — calcule l'erreur de proxy pour chaque couche
  • config_for_layers (Dict, facultatif, par défaut {}) — paramètres de quantisation pour chaque couche
  • shared_layer_config (Dict, facultatif, 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

< >

( )

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

AwqConfig

classe transformers.AwqConfig

< >

( bits: int = 4group_size: int = 128zero_point: bool = Truebackend: AwqBackend = <AwqBackend.AUTO: 'auto'>modules_to_not_convert: list | None = None**kwargs )

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) — 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 avec point zéro.
  • backend (AwqBackend, facultatif, par défaut AwqBackend.AUTO) — Le backend de quantification.
  • 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 exemple, l’encodeur Whisper, l’encodeur Llava, les couches de porte de Mixtral). Notez que vous ne pouvez pas quantiser directement avec transformers, veuillez vous référer à la documentation de AutoAWQ pour quantiser les modèles HF.

Il s’agit d’une classe enveloppe regroupant l’ensemble des attributs et fonctionnalités possibles avec lesquels vous pouvez interagir avec un modèle chargé en utilisant la quantification awq de la bibliothèque auto-awq, qui s’appuie sur le backend auto_awq.

EetqConfig

classe transformers.EetqConfig

< >

( weights: str = 'int8'modules_to_not_convert: list | None = None**kwargs )

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, 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 fonctionnalités possibles avec lesquels vous pouvez manipuler un modèle chargé à l’aide de eetq.

post_init

< >

( )

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

GPTQConfig

classe transformers.GPTQConfig

< >

( bits: inttokenizer: Any = Nonedataset: list[str] | str | None = Nonegroup_size: int = 128damp_percent: float = 0.1desc_act: bool = Falseact_group_aware: bool = Truesym: bool = Truetrue_sequential: bool = Trueformat: str = 'gptq'meta: dict[str, typing.Any] | None = Nonebackend: str | None = Nonemodel_seqlen: int | None = Noneblock_name_to_quantize: str | None = Nonemodule_name_preceding_first_block: list[str] | None = Nonebatch_size: int = 1pad_token_id: int | None = Nonemax_input_length: int | None = Nonecache_block_outputs: bool = Truemodules_in_block_to_quantize: list[list[str]] | None = None**kwargs )

Paramètres

  • bits (int) — Le nombre de bits pour la quantification, 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 passer soit :
    • Un objet de tokenizer personnalisé.
    • Une chaîne de caractères, l'identifiant du modèle d'un tokeniseur prédéfini hébergé dans un dépôt de modèles sur huggingface.co.
    • Chemin vers un dossier contenant les fichiers de vocabulaire requis par le tokenizer, par exemple enregistrés à l’aide de la méthode save_pretrained(), par exemple ./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, ou simplement utiliser les jeux de données originaux utilisés dans l’article GPTQ [‘wikitext2’,‘c4’,‘c4-new’]
  • group_size (int, facultatif, valeur par défaut 128) — 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, par défaut False) — Indique s'il faut quantiser les colonnes dans l'ordre de taille d'activation décroissante. Le définir à 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 même au sein d'un seul bloc Transformer. Au lieu de quantifier l'ensemble du bloc d'un coup, nous effectuons une quantification couche par couche. En conséquence, chaque couche subit la quantification en utilisant des entrées qui ont traversé les couches précédemment quantifiées.
  • format (str, facultatif, par défaut "gptq") — Format des 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) — Contrôle le noyau à utiliser. Les valeurs valides pour gptqmodel sont auto, auto_trainable et d’autres. Référence sur 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) — Le 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 à l’arrière-plan exllama avec act-order.
  • cache_block_outputs (bool, facultatif, 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 l'entrée réelle 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 fonctionnalités possibles avec lesquels vous pouvez interagir avec un modèle chargé via l’API optimum pour la quantification GPTQ, en s’appuyant sur le backend gptqmodel.

from_dict_optimum

< >

( config_dict )

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

post_init

< >

( )

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

to_dict_optimum

< >

( )

Obtenir un dictionnaire compatible pour la configuration gptq d’optimum

BitsAndBytesConfig

classe transformers.BitsAndBytesConfig

< >

( load_in_8bit = Falseload_in_4bit = Falsellm_int8_threshold = 6.0llm_int8_skip_modules = Nonellm_int8_enable_fp32_cpu_offload = Falsellm_int8_has_fp16_weight = Falsebnb_4bit_compute_dtype = Nonebnb_4bit_quant_type = 'fp4'bnb_4bit_use_double_quant = Falsebnb_4bit_quant_storage = None**kwargs )

Paramètres

  • load_in_8bit (bool, facultatif, 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 est utilisé pour activer la quantification en 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) — 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 ~5, mais au-delà, il y a une pénalité de performance significative. Un bon seuil par défaut 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 à 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 parties en int8 sur GPU et d’autres en fp32 sur CPU, vous pouvez utiliser ce drapeau. Cela 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 le passage arrière.
  • 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 défini 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 empaqueter les 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 fonctionnalités possibles avec lesquels vous pouvez manipuler 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, d'autres arguments seront ajoutés à cette classe.

is_quantizable

< >

( )

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

post_init

< >

( )

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

< >

( )

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

< >

( ) → dict[str, Any]

Retourne

dict[str, Any]

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

Supprime tous les attributs de config qui correspondent aux attributs de la config par défaut, pour une meilleure lisibilité, et sérialise en dictionnaire Python.

HfQuantizer

classe transformers.quantizers.HfQuantizer

< >

( quantization_config: QuantizationConfigMixin**kwargs )

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.

Attributs 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 son utilisation.

adjust_max_memory

< >

( max_memory: dict )

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

déquantiser

< >

( modeldtype = None )

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

get_load_operations

< >

( )

Classes d’opérations chargeant 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

< >

( converterparamdtype: torch.dtype | None )

Cela se produit au moment de la matérialisation, lorsque le tenseur est envoyé 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 renvoyons None afin que ce soit géré par eux.

get_state_dict_and_metadata

< >

( model )

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

< >

( )

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

param_needs_quantization

< >

( model: PreTrainedModelparam_name: str**kwargs )

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

postprocess_model

< >

( model: PreTrainedModel**kwargs )

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 surcharger la méthode abstraite _process_model_after_weight_loading.

preprocess_model

< >

( model: PreTrainedModeldtype = None**kwargs )

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 le périphérique meta afin de pouvoir manipuler librement le squelette du modèle pour remplacer les modules en place. Assurez-vous de surcharger la méthode abstraite _process_model_before_weight_loading.

remove_quantization_config

< >

( model )

Supprimez la configuration de quantification du modèle.

update_attn_implementation

< >

( config )

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

< >

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

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, étant donné que accelerate est une exigence stricte, si aucune device_map n'est transmise, la device_map est définie sur `“auto”“

update_dtype

< >

( dtype: torch.dtype )

Paramètres

  • dtype (torch.dtype) — Le dtype d’entrée transmis à from_pretrained

Certaines méthodes de quantification nécessitent de définir explicitement le dtype du modèle sur un dtype cible. Vous devez surcharger cette méthode si vous souhaitez vous assurer que ce comportement est préservé

update_parallel_plan

< >

( modelplan: dict )

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

< >

( weight_conversionsmodel )

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, pour une 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

< >

( *args**kwargs )

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 intégrés à transformers. Si aucune vérification explicite n’est nécessaire, il suffit de ne rien retourner.

HiggsConfig

classe transformers.HiggsConfig

< >

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

Paramètres

  • bits (int, facultatif, 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, par défaut 2) — Dimension de la grille de quantification. 1 et 2 sont pris en charge. 2 est toujours meilleur en pratique. 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, 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. La réduire en dessous de 512 diminuera la qualité de la quantification.
  • group_size (int, facultatif, 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, par défaut {}) — Métadonnées par module (formes des blocs gemm, métadonnées GPU, etc.) pour enregistrer les résultats de l’ajustement des noyaux. 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

< >

( )

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

classe transformers.HqqConfig

< >

( nbits: int = 4group_size: int = 64view_as_float: bool = Falseaxis: int | None = Nonedynamic_config: dict | None = Noneskip_modules: list = ['lm_head']**kwargs )

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, par défaut False) — Affiche le poids quantifié en float (utilisé dans l’entraînement distribué) si défini sur 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

< >

( config: dict )

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

post_init

< >

( )

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

< >

( ) → dict[str, Any]

Retourne

dict[str, Any]

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

Supprime tous les attributs de config qui correspondent aux attributs de la config par défaut, pour une meilleure lisibilité, et sérialise en dictionnaire Python.

MetalConfig

classe transformers.MetalConfig

< >

( bits: int = 4group_size: int = 64modules_to_not_convert: list | None = Nonedequantize: bool = False**kwargs )

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 quantification affine (échelles + qbiases) avec une largeur de bits et une taille de groupe configurables. Les poids quantifiés sont regroupés dans des tenseurs uint32 et le passage avant utilise des noyaux Metal fusionnés de déquantisation + matmul.

Mxfp4Config

classe transformers.Mxfp4Config

< >

( modules_to_not_convert: list | None = Nonedequantize: bool = False**kwargs )

Paramètres

  • 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.
  • 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 fonctionnalités possibles avec lesquels vous pouvez interagir avec un modèle chargé en utilisant la quantification mxfp4.

NVFP4Config

classe transformers.NVFP4Config

< >

( modules_to_not_convert: list[str] | None = None**kwargs )

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

classe transformers.FbgemmFp8Config

< >

( activation_scale_ub: float = 1200.0modules_to_not_convert: list | None = None**kwargs )

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, 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 fonctionnalités possibles avec lesquels vous pouvez interagir avec un modèle chargé en utilisant la quantification fp8 de fbgemm.

CompressedTensorsConfig

classe transformers.CompressedTensorsConfig

< >

( config_groups: dict[str, typing.Union[ForwardRef('QuantizationScheme'), list[str]]] | None = Noneformat: str = 'dense'quantization_status: QuantizationStatus = 'initialized'kv_cache_scheme: typing.Optional[ForwardRef('QuantizationArgs')] = Noneglobal_compression_ratio: float | None = Noneignore: list[str] | None = Nonequant_method: str = 'compressed-tensors'run_compressed: bool | None = Nonedequantize: bool = Falseuse_optimized_inference: bool = False**kwargs )

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, par défaut "dense") — format dans lequel les poids sont stockés, par exemple dense, float-quantized ou pack-quantized
  • quantization_status (QuantizationStatus, facultatif, 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 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, par défaut False) — lorsque la valeur est True, les poids quantifiés sont déquantifiés pour revenir au type de données du modèle (par exemple 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 la valeur est 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). Inférence uniquement, et activation optionnelle : sans cela, le modèle passe par la voie régulière compressed-tensors. Ignoré lorsque dequantize=True.

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

from_dict

< >

( config_dictreturn_unused_kwargs = False**kwargs ) → QuantizationConfigMixin

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 par mot-clé non utilisés. Utilisé pour 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 à partir d'un dictionnaire Python de paramètres. Développe éventuellement les arguments de la quantization_config imbriquée

to_dict

< >

( )

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

< >

( ) → dict[str, Any]

Retourne

dict[str, Any]

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

Supprime tous les attributs de config qui correspondent aux attributs de la config par défaut, pour une meilleure lisibilité, et sérialise en dictionnaire Python.

TorchAoConfig

classe transformers.TorchAoConfig

< >

( quant_type: AOBaseConfigmodules_to_not_convert: list | None = Noneinclude_input_output_embeddings: bool = Falseuntie_embedding_weights: bool = False**kwargs )

Paramètres

  • quant_type (AOBaseConfig) — Une instance 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, 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 les embeddings 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, par défaut False) — Indique s'il faut délier les poids lors de la quantification des poids d'embedding d'entrée qui sont liés à d'autres poids.

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

Exemple :

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

< >

( config_dictreturn_unused_kwargs = False**kwargs )

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

get_apply_tensor_subclass

< >

( )

Retourner la configuration de quantification à appliquer.

post_init

< >

( )

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

to_dict

< >

( )

Convertit la configuration en dictionnaire.

BitNetQuantConfig

classe transformers.BitNetQuantConfig

< >

( modules_to_not_convert: list | None = Nonelinear_class: str = 'bitlinear'quantization_mode: str = 'offline'use_rms_norm: bool = Falserms_norm_eps: float | None = 1e-06**kwargs )

Paramètres

  • modules_to_not_convert (Optional[List], 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.
  • 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, par défaut "offline") — Le mode de quantisation à utiliser. Peut être soit online soit 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 résulte généralement en un surcoût d'exécution plus faible par rapport à la quantisation en ligne.
  • use_rms_norm (bool, facultatif, par défaut False) — Indique s'il faut appliquer RMSNorm aux activations avant la quantification. Cela correspond à l'approche du papier original 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 par mot-clé qui peuvent être utilisés par des backends de quantification spécifiques ou des versions futures.

Classe de configuration pour appliquer la quantification BitNet.

post_init

< >

( )

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

SpQRConfig

classe transformers.SpQRConfig

< >

( bits: int = 3beta1: int = 16beta2: int = 16shapes: dict[str, int] | None = Nonemodules_to_not_convert: list[str] | None = None**kwargs )

Paramètres

  • bits (int, facultatif, par défaut 3) — Spécifie le nombre de bits pour les poids et les points zéro et échelles du premier ordre. Actuellement, seule la valeur 3 est prise en charge.
  • beta1 (int, facultatif, par défaut 16) — Largeur de tuile SpQR. Actuellement, seule la valeur beta1 = 16 est prise en charge.
  • beta2 (int, facultatif, par défaut 16) — Hauteur de tuile SpQR. Actuellement, seule la valeur beta2 = 16 est prise en charge.
  • shapes (Optional, facultatif) — 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

< >

( )

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

classe transformers.FineGrainedFP8Config

< >

( activation_scheme: str = 'dynamic'weight_block_size: tuple = (128, 128)dequantize: bool = Falsemodules_to_not_convert: list | None = Nonemodules_to_convert: list | None = Nonescale_fmt: str = 'float'expert_dtype: str = 'fp8'**kwargs )

Paramètres

  • activation_scheme (str, facultatif, 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, 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’embeddings, qui doivent être convertis lors de la quantification.
  • scale_fmt (str, facultatif, 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, 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

< >

( )

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

QuarkConfig

classe transformers.QuarkConfig

< >

( **kwargs )

FourOverSixConfig

classe transformers.FourOverSixConfig

< >

( activation_dtype: str | None = Noneactivation_scale_rule: str | None = Nonedtype: str = 'nvfp4'gradient_dtype: str | None = Nonegradient_scale_rule: str | None = Nonekeep_master_weights: bool = Falsematmul_backend: str | None = Noneoutput_dtype: str | None = 'bfloat16'quantize_backend: str | None = Nonescale_rule: str = 'mse'weight_dtype: str | None = Noneweight_scale_2d: bool = Falseweight_scale_rule: str | None = Nonemodule_config_overrides: dict[str, dict[str, typing.Any]] | None = Nonemodules_to_not_convert: list[str] | None = ['lm_head']**kwargs )

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 dans les 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". Si non fourni, CUTLASS sera utilisé s'il est disponible, sinon PyTorch sera utilisé.
  • output_dtype (str, facultatif, 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. En général, "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, défaut False) — Indique s'il faut calculer les facteurs d'échelle sur les tenseurs de poids par blocs 2D. Cela doit être fait lors de 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 remplacements de configuration 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 peut être utilisé pour remplacer la configuration par défaut de 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

classe transformers.FPQuantConfig

< >

( forward_dtype: str = 'nvfp4'forward_method: str = 'abs_max'backward_dtype: str = 'bf16'store_master_weights: bool = Falsehadamard_group_size: int | None = Nonepseudoquantization: bool = Falsetransform_init: str = 'hadamard'modules_to_not_convert: list[str] | None = None**kwargs )

Paramètres

  • forward_dtype (str, facultatif, par défaut "nvfp4") — Le dtype à utiliser pour le passage avant.
  • forward_method (str, facultatif, par défaut "abs_max") — L'échelle à utiliser pour le passage avant. Peut être "abs_max" ou "quest". "abs_max" est préférable pour le PTQ, "quest" est préférable pour le 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 du groupe pour la transformation de Hadamard avant la quantification pour "quest" ; elle correspond à la taille du groupe MXFP4 (32). Si None, elle est définie à 16 pour "nvfp4" et à 32 pour "mxfp4".
  • pseudoquantization (bool, facultatif, 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

< >

( )

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

classe transformers.AutoRoundConfig

< >

( bits: int = 4group_size: int = 128sym: bool = Truebackend: str = 'auto'**kwargs )

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 du groupe
  • sym (bool, facultatif, valeur par défaut True) — Quantification symétrique ou non
  • backend (str, facultatif, 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 pour toutes les options de backend.

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

post_init

< >

( )

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

SinqConfig

classe transformers.SinqConfig

< >

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

Paramètres

  • nbits (int, par défaut 4) — Nombre de bits de quantisation pour les poids.
  • group_size (int, par 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 des poids uniquement SINQ sans calibration “asinq” – A-SINQ (prenant en compte les activations), non pris en charge par Hugging Face. Veuillez consulter le dépôt officiel 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 le trajet aller-retour).

Configuration de quantification pour SINQ / A-SINQ.

À passer à :

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

GgufConfig

classe transformers.GgufConfig

< >

( gguf_file: str | None = Nonedequantize: bool = False**kwargs )

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, par défaut False) — Dépaquetage de chaque poids au chargement pour obtenir un modèle dense standard. Toujours correct, mais renonce à l’économie de mémoire ; c’est aussi le repli automatique lorsqu’aucun noyau de multiplication matricielle n’est disponible pour les types de quantification du fichier.

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

Update on GitHub

←Exportateurs Tokenizer→