Transformers documentation
Écrire des tests de modèle
Écrire des tests de modèle
La suite de tests de Transformers utilise une architecture basée sur des mixins pour générer automatiquement plus de 100 tests à partir d'un code minimal. Vous rédigez une petite quantité de code spécifique au modèle, et les mixins gèrent la sauvegarde/chargement, la génération, les pipelines, l'entraînement et le parallélisme de tenseurs.
Exécutez les tests de votre modèle avec les commandes suivantes.
# run your model's tests
pytest tests/models/mymodel/test_modeling_mymodel.py -v
# run a specific test
pytest tests/models/mymodel/test_modeling_mymodel.py::MyModelTest::test_model
# run tests matching a keyword pattern (useful to run all integration tests)
pytest tests/models/mymodel/ -k integration -v
# include slow integration tests
RUN_SLOW=1 pytest tests/models/mymodel/ -vLa CI de Hugging Face exécute les tests de modèles sans @slow à chaque pull request, et les tests lents sont exécutés selon un planning nocturne (voir Contrôles de pull request pour savoir ce que la CI valide).
Exécuter les contrats d’intégration de modèles localement
Les MIC vérifient les chemins d'utilisation des modèles publiés par rapport aux lignes de base examinées à l'aide de petits fixtures.
Le runner (transformers-mic) et hf-doc-builder sont fournis avec l'extra testing. Depuis votre checkout de Transformers :
python -m pip install -e ".[testing]"Puis exécutez :
make run-mic MODEL=bert # only the contracts for this model directory under src/transformers/models/
make run-mic MODEL=Wav2Vec2 # a model name works too (case and punctuation are ignored)
make run-mic MODEL=qwen+ # every matching model directory: + stands for any characters
make run-mic # contracts affected by local changes
make run-mic ALL=1 # all fixtures in the fleet
make run-mic BASE=main # use a different Git comparison base
make run-mic FLEET=control # the control fleet instead of the default prototypes fleet
make run-mic ALL=1 JOBS=8 # number of runner processes working in parallel (default: cores / 4, up to 4)La commande utilise le code source de ce checkout et la révision de la flotte dans tests/contracts.lock.
Elle exécute la flotte de prototypes par défaut ; FLEET=control sélectionne la flotte de contrôle plus petite.
Comme dans la CI, elle vérifie la flotte de prototypes en bfloat16 et la flotte de contrôle à la fois en default et en bfloat16.
Elle télécharge les contrats, les fixtures et les baselines épinglés au besoin, les exécute localement,
et affiche une ligne par fixture ainsi qu’un résumé ; toute fixture en échec fait échouer la commande.
Les contrats sont répartis sur des processus de runner parallèles (JOBS, par défaut jusqu’à 4, JOBS=1 pour les exécuter un par un).
Chaque runner utilise OMP_NUM_THREADS=4, le nombre de threads avec lequel les baselines sont enregistrées (définir OMP_NUM_THREADS pour le remplacer), afin que le nombre de threads n’ajoute pas de différences par rapport à la CI. make run-mic est un wrapper autour du vérificateur mic (python utils/checkers.py mic), qui est opt-in
et ne fait pas partie de make check-repo ni de la CI car il nécessite un accès réseau et des temps d’exécution des modèles. Il ne crée ni ne publie de contrats.
Les dépendances d’exécution spécifiques au modèle et une baseline validée pour votre plateforme sont requises ;
le passage d’une fixture ne valide pas le checkpoint complet.
Par défaut, les fichiers modifiés correspondent à la différence entre la base de fusion avec origin/main et votre arborescence de travail, ainsi qu'aux fichiers non suivis. Cela inclut les commits de la branche, les modifications en attente et non en attente, ainsi que les deux chemins des renommages. Un clone propre n'a rien à exécuter.
Lorsque les modifications sélectionnent tous les contrats (par exemple setup.py, le code partagé ou le verrou de la flotte dans tests/contracts.lock), rien ne s'exécute : la commande explique pourquoi, et vous choisissez MODEL=<name> ou ALL=1.
MIC dérive les dépendances des modèles à partir des configurations de fixtures (y compris les modèles imbriqués), des architectures et des classes de tokenizer/processor. Les modifications du répertoire d'un modèle sélectionnent les contrats correspondants ; les modifications du code Transformers partagé, des classes Auto, des déclarations de dépendances ou du pin de la flotte sélectionnent tous les contrats. Les modifications de la documentation et les modifications de tests ordinaires ne sélectionnent rien. L'exécuteur affiche sa sélection et les raisons ; l'absence de contrat correspondant signifie une absence de couverture, et non un contrôle de modèle réussi. La sélection est une heuristique, et non un graphe de dépendances Python complet ; utilisez ALL=1 en cas de doute sur la couverture des dépendances indirectes.
MODEL=bert est plus restreint : il n’exécute que les contrats dont le fichier de référence config.json définit un model_type dans models/bert. Les modèles composites qui intègrent simplement BERT ne sont pas exécutés ;
utilisez la sélection par défaut des fichiers modifiés (ou ALL=1) pour les inclure.
Choisir une classe de test de base
Trois classes de base couvrent les familles de modèles les plus courantes. Choisissez celle qui correspond à la modalité de votre modèle.
| Classe de base | Utilisation | Mixins |
|---|---|---|
CausalLMModelTest | Modèles de langage causaux | ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin, TrainingTesterMixin, TensorParallelTesterMixin |
VLMModelTest | Modèles de vision-langage | ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin |
ALMModelTest | Modèles audio-langage | ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin |
VLMModelTest et ALMModelTest partagent un parent commun, MultiModalModelTest, qui imbrique des sous-configurations dans une configuration de niveau supérieur composite et place les jetons de placeholder de modalité dans input_ids aux côtés des fonctionnalités brutes de la modalité (audio ou vision). CausalLMModelTest n’utilise pas le parent multimodal. Il s’appuie sur les trois mixins partagés et ajoute TrainingTesterMixin et TensorParallelTesterMixin pour la couverture de l’entraînement et du parallélisme de tenseurs.
Pour les architectures qui ne correspondent à aucune des trois catégories (encodeur uniquement, encodeur-décodeur, etc.), construisez l’infrastructure de tests directement à partir du motif à deux classes et des mixins de test décrits ci-dessous.
CausalLMModelTest
CausalLMModelTest est la classe de base recommandée pour tester les modèles de langage causaux. Elle hérite de cinq mixins de test et génère automatiquement des tests pour la sauvegarde/chargement, la génération, les pipelines, l’entraînement et le parallélisme de tenseurs.
import unittest
from transformers.testing_utils import require_torch
from transformers import is_torch_available
from ...causal_lm_tester import CausalLMModelTest, CausalLMModelTester
if is_torch_available():
from transformers import MyModel
class MyModelTester(CausalLMModelTester):
if is_torch_available():
base_model_class = MyModel
@require_torch
class MyModelTest(CausalLMModelTest, unittest.TestCase):
model_tester_class = MyModelTesterCes deux classes assurent une couverture de tests complète pour MyModel et toutes ses classes de tête (MyModelForCausalLM, MyModelForSequenceClassification, etc.). Consultez tests/models/llama/test_modeling_llama.py pour un exemple concret.
CausalLMModelTester ne requiert que base_model_class. Le tester supprime le suffixe Model pour obtenir un nom de base (LlamaModel devient Llama), puis ajoute des suffixes tels que Config ou ForCausalLM pour découvrir les classes associées. Si une classe n’existe pas dans le module, l’attribut reste None et le tester ignore les tests correspondants.
Définition des valeurs par défaut dans le CausalLMTester
Si votre modèle ne respecte pas la convention de nommage standard, ou si vous devez personnaliser le comportement, surchargez les attributs sur le testeur ou la classe de test.
class MyModelTester(CausalLMModelTester):
if is_torch_available():
base_model_class = MyModel
# override if the class name doesn't follow the convention
causal_lm_class = MyCustomCausalLM
@require_torch
class MyModelTest(CausalLMModelTest, unittest.TestCase):
model_tester_class = MyModelTester
# disable embedding resize tests
test_resize_embeddings = FalsePour les modèles qui nécessitent des paramètres de constructeur personnalisés sur le testeur, surchargez __init__ et appelez super().__init__(parent=parent) avant de définir les attributs supplémentaires. Consultez tests/models/youtu/test_modeling_youtu.py pour un exemple concret.
class YoutuModelTester(CausalLMModelTester):
if is_torch_available():
base_model_class = YoutuModel
def __init__(self, parent, kv_lora_rank=16, q_lora_rank=32):
super().__init__(parent=parent)
self.kv_lora_rank = kv_lora_rank
self.q_lora_rank = q_lora_rankVLMModelTest
VLMModelTest est la classe de base pour les modèles vision-langage. Elle hérite de trois mixins (ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin) et définit _is_composite = True afin de gérer plusieurs sous-modèles.
import unittest
from transformers.testing_utils import require_torch
from transformers import is_torch_available
from ...vlm_tester import VLMModelTest, VLMModelTester
if is_torch_available():
from transformers import (
MyVLMConfig,
MyVLMModel,
MyVLMTextConfig,
MyVLMVisionConfig,
MyVLMForConditionalGeneration,
)
class MyVLMTester(VLMModelTester):
if is_torch_available():
base_model_class = MyVLMModel
config_class = MyVLMConfig
text_config_class = MyVLMTextConfig
vision_config_class = MyVLMVisionConfig
conditional_generation_class = MyVLMForConditionalGeneration
@require_torch
class MyVLMTest(VLMModelTest, unittest.TestCase):
model_tester_class = MyVLMTesterDéfinir des valeurs par défaut personnalisées dans VLMModelTester
Lorsque le VLM nécessite des paramètres de vision personnalisés ou des valeurs de configuration non par défaut, surchargez __init__. Définissez les valeurs par défaut à l'aide de setdefault avant d'appeler super().__init__(parent, **kwargs). L'exemple ci-dessous présente les premières valeurs par défaut de tests/models/qianfan_ocr/test_modeling_qianfan_ocr.py.
class QianfanOCRVisionText2TextModelTester(VLMModelTester):
base_model_class = QianfanOCRModel
config_class = QianfanOCRConfig
text_config_class = Qwen3Config
vision_config_class = QianfanOCRVisionConfig
conditional_generation_class = QianfanOCRForConditionalGeneration
def __init__(self, parent, **kwargs):
kwargs.setdefault("image_token_id", 1)
kwargs.setdefault("image_size", 32)
kwargs.setdefault("patch_size", 4)
kwargs.setdefault("num_channels", 3)
# ... more defaults
super().__init__(parent, **kwargs)Les tests VLM diffèrent de CausalLMModelTest à quelques égards.
- Vous devez définir
config_class,text_config_class,vision_config_classetconditional_generation_classsur le testeur. VLMModelTestn’inclut pasTrainingTesterMixinniTensorParallelTesterMixin.- Le
__init__du testeur accepte les paramètres visuels (image_size,patch_size,num_channels,num_image_tokens) à partir de**kwargsetsetdefault(). ConfigTesterutilisehas_text_modality=Falsecar la configuration de niveau supérieur est une configuration composite et non une configuration de modèle de texte.
ALMModelTest
ALMModelTest est la classe de base pour les modèles audio-langage (ALM) tels que Qwen2Audio, AudioFlamingo3 et GraniteSpeech. Elle reproduit le schéma des VLM avec le même parent MultiModalModelTest et la même découverte automatique des classes de tête. Le mécanisme du côté vision est remplacé par des caractéristiques audio, une sous-configuration audio et une stratégie de placement des jetons audio.
class MyALMTester(ALMModelTester):
config_class = MyALMConfig
text_config_class = MyALMTextConfig
audio_config_class = MyALMAudioConfig
conditional_generation_class = MyALMForConditionalGeneration
audio_mask_key = "feature_attention_mask"
class MyALMTest(ALMModelTest, unittest.TestCase):
model_tester_class = MyALMTesterRéécriture des valeurs par défaut dans ALMModelTester
Le __init__ du testeur définit des valeurs par défaut spécifiques à ALM (feat_seq_length=128, num_mel_bins=80, audio_token_id=0). Remplacez-les à l’aide de setdefault avant d’appeler super().__init__(parent, **kwargs).
Deux attributs de classe indiquent au testeur comment votre modèle nomme les éléments.
audio_mask_key: le nom de l'argument que votre modèle attend pour le masque audio ("feature_attention_mask","input_features_mask", etc.). Laissez-le àNonesi votre modèle n'utilise pas de masque audio distinct.audio_config_key: le nom de l’attribut utilisé par votre configuration de plus haut niveau pour imbriquer la sous-configuration audio. La valeur par défaut est"audio_config", mais des modèles comme GraniteSpeech utilisent"encoder_config".
class Qwen2AudioModelTester(ALMModelTester):
def __init__(self, parent, **kwargs):
kwargs.setdefault("feat_seq_length", 60)
kwargs.setdefault("max_source_positions", kwargs["feat_seq_length"] // 2)
super().__init__(parent, **kwargs)ALMModelTester exige de surcharger un hook, get_audio_embeds_mask(audio_mask), et expose quelques hooks optionnels supplémentaires pour la personnalisation.
get_audio_embeds_mask(audio_mask): renvoie le masque des positions des embeddings audio par lot après le sous-échantillonnage de l’encodeur. Le testeur utilise la somme par ligne pour déterminer le nombre de placeholdersaudio_token_idà insérer dansinput_ids; ce nombre doit donc correspondre à ce que votre encodeur émet.create_audio_features(): renvoie le tenseur de caractéristiques audio. La forme par défaut est[batch_size, num_mel_bins, feat_seq_length]. À surcharger si votre modèle, comme GraniteSpeech, attend des caractéristiques avec le temps en premier ([batch_size, feat_seq_length, num_mel_bins]).create_audio_mask(): renvoie le masque d’attention au niveau audio. Par défaut, il construit une région valide aléatoire et contiguë pour chaque ligne du lot. Remplacez-le par un masque de longueur complète déterministe si vos tests comparent deux appels deprepare_config_and_inputs_for_common()entre eux, ou si votre encodeur audio délègue le traitement à un backend qui rejette les masques non nuls.place_audio_tokens(input_ids, config, num_audio_tokens): place les jetons de remplacement audio de manière contiguë aprèsBOS. À n'implémenter que si votre modèle nécessite une disposition différente.get_audio_feature_key(): renvoie la clé du dictionnaire d’entrées pour les caractéristiques audio ("input_features"par défaut).
En plus des tests multimodaux hérités, ALMModelTest ajoute test_mismatching_num_audio_tokens. Ce test vérifie que le modèle lève une ValueError claire lorsque le nombre de caractéristiques audio ne correspond pas au nombre de jetons de remplacement audio dans input_ids, et s’assure qu’un prompt contenant plusieurs segments audio est bien transmis avec succès.
Écrire des tests pour d'autres architectures
Pour les architectures encoder-only, encoder-decoder, audio ou autres architectures non standard, construisez l’infrastructure de tests directement à partir du schéma à deux classes et des mixins de tests décrits ci-dessous.
ModelTester et ModelTest
Chaque fichier de test de modèle suit la même structure.
ModelTester(classe simple) crée de petites configurations et des entrées factices pour les tests, et peut également contenir de petits tests de régression spécifiques au modèle.ModelTest(unittest.TestCase+ mixins) hérite des tests générés automatiquement et les exécute sur chaque variante de modèle.
ModelTest appelle prepare_config_and_inputs_for_common() sur le tester pour obtenir un tuple (config, inputs_dict). Tous les mixins s’appuient sur prepare_config_and_inputs_for_common() pour les données de test.
Test des mixins
Choisissez les mixins dont votre modèle a besoin.
| Mixin | Fichier source | Ce qu'il teste |
|---|---|---|
ModelTesterMixin | tests/test_modeling_common.py | Enregistrement/chargement, point de contrôle des gradients, signature de l'avant, attributs courants |
GenerationTesterMixin | tests/generation/test_utils.py | Glouton, échantillonnage, recherche par faisceau, décodage assisté |
PipelineTesterMixin | tests/test_pipeline_mixin.py | Un test par tâche de pipeline |
TrainingTesterMixin | tests/test_training_mixin.py | Surapprentissage sur un petit lot |
TensorParallelTesterMixin | tests/test_tensor_parallel_mixin.py | Parallélisme de tenseurs distribué |
Écrire un test de modèle
Consultez tests/models/modernbert/test_modeling_modernbert.py pour un exemple complet et fonctionnel. Les étapes clés sont décrites ci-dessous.
La classe
ModelTesterconstruit de petites configurations et des entrées factices. Gardez les dimensions petites afin que les tests s’achèvent en quelques secondes sur CPU. Utilisez les trois utilitaires de tenseurs ci-dessous pour construire les entrées.ids_tensor(shape, vocab_size): Tenseur d'entiers aléatoires dans[0, vocab_size). À utiliser pourinput_ids,token_type_idset les tenseurs d'étiquettes.random_attention_mask(shape): tenseur binaire (0 et 1) où le premier jeton est toujours 1. À utiliser pourattention_mask.floats_tensor(shape, scale=1.0): Tenseur de nombres flottants aléatoires. À utiliser pour des entrées continues telles quepixel_valuesouinputs_embeds.
Le testeur doit implémenter
get_config(),prepare_config_and_inputs()etprepare_config_and_inputs_for_common(). Ajoutez des méthodescreate_and_check_*pour chaque tête de tâche (modèle de base, classification de séquence, classification de jeton, etc.).Héritez des mixins dont votre modèle a besoin, définissez
all_model_classesetpipeline_model_mapping, puis implémentezsetUp(). Rédigez des méthodestest_*qui délèguent aux méthodescreate_and_check_*du testeur.Pour chaque tête de tâche, ajoutez une méthode
create_and_check_*sur le testeur qui instancie le modèle, exécute un passage avant et vérifie les formes des sorties. Ajoutez ensuite une méthodetest_*correspondante sur la classe de test.
Organisation des fichiers
Les fichiers de test se trouvent dans tests/models/mymodel/ selon la structure présentée ci-dessous.
tests/models/mymodel/ ├── __init__.py ├── test_modeling_mymodel.py # model tests (required) ├── test_tokenization_mymodel.py # tokenizer tests (if custom tokenizer) ├── test_image_processing_mymodel.py # image processor tests (if vision model) ├── test_feature_extraction_mymodel.py # feature extractor tests (if audio/speech model) └── test_processing_mymodel.py # processor tests (if multimodal)
Les tests de tokenizers suivent le même schéma. Héritez de TokenizerTesterMixin depuis tests/test_tokenization_common.py, définissez quelques attributs et obtenez des tests générés automatiquement. Consultez tests/models/llama/test_tokenization_llama.py pour un exemple.
Tests de configuration
ConfigTester vérifie qu'une classe de configuration gère correctement la sérialisation, la sauvegarde/chargement et les propriétés standard. CausalLMModelTest et VLMModelTest incluent automatiquement les tests de configuration. Pour le parcours général avec ModelTester et ModelTest, définissez le testeur de configuration manuellement dans setUp().
from tests.test_configuration_common import ConfigTester
def setUp(self):
self.config_tester = ConfigTester(self, config_class=MyModelConfig, hidden_size=32)
def test_config(self):
self.config_tester.run_common_tests()run_common_tests() exécute plusieurs vérifications.
- Vérifie que des propriétés courantes comme
hidden_size,num_attention_headsetnum_hidden_layersexistent (etvocab_sizesihas_text_modality=True). - Tests de la sérialisation JSON avec
to_json_string()etto_json_file(). - Allers-retours entre
save_pretrained()etfrom_pretrained(). - Vérifie la cohérence entre
id2labeletlabel2id. - Crée une configuration sans arguments pour valider l’initialisation par défaut.
- Définit des arguments communs tels que
output_hidden_stateset vérifie qu’ils sont correctement stockés.
Passez has_text_modality=False pour les modèles uniquement visuels qui ne disposent pas de vocab_size, et transmettez des **kwargs supplémentaires pour remplacer les valeurs par défaut de la configuration.
self.config_tester = ConfigTester(
self, config_class=MyVisionConfig, has_text_modality=False, hidden_size=64
)Tests d'intégration et petits modèles
Les tests de mixin utilisent de petites configurations avec des poids aléatoires pour vérifier rapidement le comportement des modèles. Les tests d’intégration exécutent l’inférence avec de vrais poids pré-entraînés pour valider la justesse des sorties. Les petits modèles sur le Hub sont suffisamment compacts pour un CI rapide, mais structurés comme de vrais points de contrôle.
Rédaction de tests d'intégration
Placez les tests d’intégration dans une classe de test distincte, marquez-les avec @slow et incorporez MemoryCleanupMixin. Chaque test télécharge de vrais poids, exécute une inférence et vérifie les sorties par rapport aux valeurs attendues. Le mixin libère la mémoire utilisée par chaque test et exécute les méthodes de test sous torch.no_grad() — voir Libération de la mémoire entre les tests pour en savoir plus sur son fonctionnement et sur la manière de s’en exclure.
import torch
from transformers import AutoTokenizer
from transformers.testing_utils import MemoryCleanupMixin, require_torch, slow, torch_device
class MyModelIntegrationTest(MemoryCleanupMixin, unittest.TestCase):
@slow
@require_torch
def test_inference(self):
model = MyModelForCausalLM.from_pretrained("myorg/mymodel-base").to(torch_device)
tokenizer = AutoTokenizer.from_pretrained("myorg/mymodel-base")
inputs = tokenizer("Hello, world", return_tensors="pt").to(torch_device)
outputs = model(**inputs)
# check against expected values
expected_slice = torch.tensor([[-0.1234, 0.5678, -0.9012]])
torch.testing.assert_close(outputs.logits[0, :1, :3], expected_slice, atol=1e-4, rtol=1e-4)Marquez tout test avec @slow s'il télécharge des poids, charge un jeu de données volumineux ou prend plus de quelques secondes. Le CI de la pull request ignore les tests lents, mais l'agenda nocturne les exécute.
Libération de la mémoire entre les tests
Les tests d’intégration chargent de vrais points de contrôle, de sorte qu’un test qui conserve une référence à son modèle peut provoquer une erreur de mémoire (OOM) pour tout ce qui s’exécute ensuite. MemoryCleanupMixin, dans tests/test_memory_cleanup_mixin.py, gère ce problème pour l’ensemble de la classe :
- Exécute
cleanup(torch_device, gc_collect=True)avant et après chaque test afin que les résidus ne se transmettent pas. - Supprime les attributs ajoutés par le test sur
self(y compris les caches@cached_property) et sur la classe (par exemplecls.model = ...danssetUpClass). Pytest conserve les instances de test en vie pour toute la session, de sorte quegc.collect()ne peut pas libérer les objets que ces références continuent de retenir. - Exécute les méthodes de test sous
torch.no_grad()afin qu'un passage avant ne conserve pas les activations.
Les classes qui entraînent ou appellent backward() définissent run_under_no_grad = False. Une classe qui combine les deux place @with_grad ou @with_no_grad sur les méthodes de test individuelles.
Les attributs définis dans le corps de la classe sont conservés, tandis que tout ce qui est ajouté ultérieurement est ignoré. Si vous redéfinissez setUp, appelez super().setUp() : le mixin capture les attributs de l'instance à cet endroit et lève une erreur en l'absence de cet appel.
MemoryCleanupTestCasecombine le mixin avecTestCasePlus, pour les tests qui souhaitent également la suppression automatique des répertoires temporaires.
Pour détecter un test qui fuit de la mémoire, définissez TRANSFORMERS_TEST_MEMORY_LEAK_MIB sur un budget en Mo ; tout test qui laisse plus que cette quantité allouée sur l’appareil est signalé avec son usage de pic. Ajoutez TRANSFORMERS_TEST_MEMORY_LEAK_MODE=error pour faire échouer le test au lieu d’émettre un avertissement. Cette vérification est désactivée par défaut et vous devez l’activer lorsque vous recherchez des résidus. Le démontage habituel du mixin exécute déjà gc.collect, ce qui peut libérer l’allocation que vous souhaiteriez inspecter lors de la reproduction d’une fuite.
Tests d'intégration de la génération
Utilisez do_sample=False dans les tests de génération afin que la sortie soit déterministe d'une exécution à l'autre et quel que soit le matériel. Pour les modèles Mixture-of-Experts, appelez également model.set_experts_implementation("eager") avant la génération pour forcer un chemin de dispatch des experts stable. Sans cela, de petites différences numériques dans le routeur peuvent modifier l'expert chargé de traiter un jeton et changer la sortie.
@slow
@require_torch
def test_generate(self):
model = MyModelForCausalLM.from_pretrained("myorg/mymodel-base").to(torch_device)
tokenizer = AutoTokenizer.from_pretrained("myorg/mymodel-base")
inputs = tokenizer("Hello, world", return_tensors="pt").to(torch_device)
# model.set_experts_implementation("eager") # uncomment for MoE models
generated_ids = model.generate(**inputs, max_new_tokens=20, do_sample=False)
output = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
self.assertEqual(output, ["Hello, world! This is the expected continuation..."])Attentes spécifiques au matériel
La CI de Transformers exécute les tests lents sur une NVIDIA A10. Les résultats numériques peuvent varier légèrement d'une génération de GPU à l'autre, les tests d'intégration utilisent donc la classe Expectations pour enregistrer les valeurs attendues par appareil. Expectations sélectionne la correspondance optimale pour le matériel actuel en fonction des clés SM (device_type, (major, minor)), et recourt à une valeur par défaut en l'absence de correspondance.
Exécutez torch.cuda.get_device_capability() pour afficher la version SM de votre appareil local (par exemple (8, 6) pour une A10, (9, 0) pour une H100).
from transformers.testing_utils import Expectations
expected_texts = Expectations(
{
("cuda", (8, 6)): ["Hello, world! This is the A10 continuation..."],
("cuda", (9, 0)): ["Hello, world! This is the H100 continuation..."],
}
).get_expectation()
self.assertEqual(output, expected_texts)Créer de minuscules modèles
Les petits modèles aux poids aléatoires sont hébergés sur le Hub sous l’organisation hf-internal-testing. Les tests de pipeline s’appuient sur ces petits modèles lorsqu’ils ont besoin d’un point de contrôle hébergé sur le Hub, sans se soucier de la qualité de la sortie. Les tests de fumée rapides chargent également ces petits modèles pour vérifier les formes du passage avant, sans télécharger de points de contrôle volumineux.
Les modèles de petite taille constituent un dernier recours pour les tests d’intégration. N’utilisez-les que lorsque le point de contrôle le plus petit disponible dépasse environ 24 Go de VRAM. Utilisez, lorsque c’est possible, les poids pré-entraînés d’origine afin de détecter les régressions numériques réelles.
Le script utils/create_dummy_models.py génère de très petits modèles à partir de ModelTester.get_config(). Le script extrait les hyperparamètres réduits de votre tester, construit un modèle avec des poids aléatoires et télécharge le résultat sur le Hub.
Générer de petits modèles localement.
python utils/create_dummy_models.py output_dir -m your_model_type
Téléchargez-les sur le Hub.
python utils/create_dummy_models.py output_dir -m your_model_type --upload --organization hf-internal-testing
Chaque modèle utilise le nom hf-internal-testing/tiny-random-{ModelClassName} et est enregistré dans tests/utils/tiny_model_summary.json. Un workflow CI (.github/workflows/check_tiny_models.yml) régénère les petits modèles quotidiennement.
Contrôler ce qui est testé
Les drapeaux booléens de ModelTesterMixin activent ou désactivent les tests générés automatiquement. Redéfinissez un drapeau sur votre classe de test pour activer ou désactiver des vérifications spécifiques.
class MyModelTest(CausalLMModelTest, unittest.TestCase):
model_tester_class = MyModelTester
test_resize_embeddings = False
test_all_params_have_gradient = False # when not all parameters are activated in every forward pass| Drapeau | Par défaut | Ce qu'il contrôle |
|---|---|---|
test_resize_embeddings | True | Redimensionnement de la couche d'embedding |
test_resize_position_embeddings | False | Redimensionnement des embeddings de position |
test_mismatched_shapes | True | Gestion des formes d'entrée/sortie non correspondantes |
test_missing_keys | True | Avertissements de clés manquantes au chargement |
test_torch_exportable | True | Compatibilité avec torch.export |
test_all_params_have_gradient | True | Tous les paramètres reçoivent des gradients (définissez False si tous les paramètres ne sont pas activés à chaque passe avant, comme pour les experts MoE) |
is_encoder_decoder | False | Tests spécifiques aux encodeurs-décodeurs |
has_attentions | True | Tests de la sortie de l'attention |
_is_composite | False | Gestion des modèles composites/multimodaux |
model_split_percents | [0.5, 0.7, 0.9] | Pourcentages de répartition pour les tests de parallélisme de modèle |
Étapes suivantes
- Consultez la documentation de pytest pour en savoir plus sur la sélection des tests, les fixtures, la journalisation et bien plus encore.