Transformers documentation

Escritura de pruebas de modelos

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Escritura de pruebas de modelos

El conjunto de pruebas de Transformers utiliza una arquitectura basada en mixins para generar automáticamente más de 100 pruebas a partir de un código mínimo. Escribes una pequeña cantidad de código específico del modelo, y los mixins se encargan de guardar/cargar, generación, pipelines, entrenamiento y paralelismo de tensores.

Ejecuta las pruebas de tu modelo con los siguientes comandos.

# 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/ -v

El CI de Hugging Face ejecuta las pruebas de modelos sin @slow en cada pull request, y las pruebas lentas se ejecutan en un horario nocturno (consulte Verificaciones de pull request para ver qué valida el CI).

Ejecutar los contratos de integración de modelos localmente

Los MIC verifican las rutas de uso de los modelos publicados en comparación con las líneas base revisadas, utilizando fixtures pequeños. El ejecutor (transformers-mic) y hf-doc-builder incluyen el extra testing. Desde tu checkout de Transformers:

python -m pip install -e ".[testing]"

Luego, ejecuta:

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)

El comando utiliza el código fuente de este checkout y la revisión de la flota en tests/contracts.lock. Ejecuta la flota de prototipos de forma predeterminada; FLEET=control selecciona la flota de control más pequeña. Al igual que en CI, comprueba la flota de prototipos en bfloat16 y la flota de control tanto en default como en bfloat16. Descarga los contratos, fixtures y líneas base fijados según sea necesario, los ejecuta localmente e imprime una línea por fixture junto con un resumen; cualquier fixture que falle provoca el fallo del comando. Los contratos se distribuyen entre procesos de ejecución en paralelo (JOBS, hasta 4 por defecto, JOBS=1 para ejecutarlos uno a uno). Cada ejecutor utiliza OMP_NUM_THREADS=4, el número de hilos con el que se registran las líneas base (establece OMP_NUM_THREADS para sobrescribirlo), de modo que el número de hilos no añada diferencias con CI. make run-mic es un envoltorio del comprobador mic (python utils/checkers.py mic), que es opcional y no forma parte de make check-repo ni de CI porque requiere acceso a la red y tiempos de ejecución de modelos. No crea ni publica contratos. Se requieren dependencias de tiempo de ejecución específicas del modelo y una línea base revisada para tu plataforma; el paso de un fixture no valida el punto de control completo.

Por defecto, los archivos modificados son la diferencia entre la base de la fusión con origin/main y tu árbol de trabajo, más los archivos no rastreados. Esto incluye los commits de la rama, los cambios con y sin staging, y ambas rutas de los renombrados. Un checkout limpio no tiene nada que ejecutar. Cuando los cambios seleccionan todos los contratos (por ejemplo setup.py, el código compartido o el pin de la flota en tests/contracts.lock), no se ejecuta nada: el comando indica por qué, y tú eliges MODEL=<name> o ALL=1.

MIC deriva las dependencias del modelo a partir de las configuraciones de fixture (incluidos los modelos anidados), las arquitecturas y las clases de tokenizer/processor. Los cambios en el directorio del modelo seleccionan los contratos coincidentes; los cambios en el código compartido de Transformers, las clases Auto, las declaraciones de dependencias o el pin de la flota seleccionan todos los contratos. Los cambios en la documentación y las pruebas ordinarias no seleccionan nada. El ejecutor imprime su selección y las razones; la ausencia de un contrato coincidente significa que no hay cobertura, no que la comprobación del modelo haya sido exitosa. La selección es una heurística, no un grafo completo de dependencias de Python; use ALL=1 si no está seguro de si las dependencias indirectas están cubiertas.

MODEL=bert es más restrictivo: solo ejecuta los contratos cuyo fixture config.json tiene un model_type definido en models/bert. Los modelos compuestos que simplemente incrustan BERT no se ejecutan; usa la selección predeterminada de archivos modificados (o ALL=1) para incluirlos.

Elegir una clase de prueba base

Las tres clases base cubren las familias de modelos más comunes. Elija la que corresponda a la modalidad de su modelo.

Clase baseUsoMixins
CausalLMModelTestModelos de lenguaje causalesModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin, TrainingTesterMixin, TensorParallelTesterMixin
VLMModelTestModelos de visión y lenguajeModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin
ALMModelTestModelos de audio y lenguajeModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin

VLMModelTest y ALMModelTest comparten un padre común, MultiModalModelTest, que anida sub-configuraciones en una configuración de nivel superior compuesta y coloca tokens de marcador de posición de modalidad en input_ids junto a las características crudas de la modalidad (audio o visión). CausalLMModelTest no utiliza el padre multimodal. Se basa en los tres mixins compartidos y añade TrainingTesterMixin y TensorParallelTesterMixin para la cobertura de entrenamiento y paralelismo de tensores.

Para las arquitecturas que no encajan en ninguna de las tres (solo codificador, codificador-decodificador, etc.), construya la infraestructura de pruebas directamente a partir del patrón de dos clases y los mezcladores de pruebas descritos a continuación.

CausalLMModelTest

CausalLMModelTest es la clase base recomendada para probar modelos de lenguaje causales. Hereda de cinco mezclas de pruebas y genera automáticamente pruebas para guardar/cargar, generación, pipelines, entrenamiento y paralelismo de tensores.

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 = MyModelTester

Estas dos clases ofrecen una cobertura de pruebas completa para MyModel y todas sus clases de cabecera (MyModelForCausalLM, MyModelForSequenceClassification, etc.). Consulte tests/models/llama/test_modeling_llama.py para un ejemplo real.

CausalLMModelTester solo requiere base_model_class. El tester elimina el sufijo Model para obtener un nombre base (LlamaModel se convierte en Llama), y luego añade sufijos como Config o ForCausalLM para descubrir las clases relacionadas. Si una clase no existe en el módulo, el atributo se mantiene como None y el tester omite las pruebas correspondientes.

Sobrescribir los valores predeterminados en CausalLMTester

Si tu modelo no sigue la nomenclatura estándar o necesitas personalizar el comportamiento, sobrescribe los atributos en el tester o en la clase de prueba.

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 = False

Para los modelos que requieren parámetros de constructor personalizados en el tester, sobrescribe __init__ y llama a super().__init__(parent=parent) antes de establecer atributos adicionales. Consulta tests/models/youtu/test_modeling_youtu.py para un ejemplo real.

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_rank

VLMModelTest

VLMModelTest es la clase base para los modelos de visión-lenguaje. Hereda de tres mixins (ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin) y establece _is_composite = True para gestionar varios submodelos.

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 = MyVLMTester

Sobrescribir los valores predeterminados en VLMModelTester

Cuando el VLM necesita parámetros de visión personalizados o valores de configuración no predeterminados, sobrescribe __init__. Establece los valores predeterminados con setdefault antes de llamar a super().__init__(parent, **kwargs). El ejemplo siguiente muestra los primeros valores predeterminados 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)

Las pruebas de VLM difieren de CausalLMModelTest en algunos aspectos.

  • Debe establecer config_class, text_config_class, vision_config_class y conditional_generation_class en el tester.
  • VLMModelTest no incluye TrainingTesterMixin ni TensorParallelTesterMixin.
  • El __init__ del tester acepta parámetros de visión (image_size, patch_size, num_channels, num_image_tokens) desde **kwargs y setdefault().
  • ConfigTester utiliza has_text_modality=False porque la configuración de nivel superior es una configuración compuesta y no una configuración de modelo de texto.

ALMModelTest

ALMModelTest es la clase base para los modelos de audio y lenguaje (ALM), como Qwen2Audio, AudioFlamingo3 y GraniteSpeech. Sigue el patrón de los VLM, con la misma clase padre MultiModalModelTest y el descubrimiento automático de clases de cabecera. La infraestructura del lado de la visión se sustituye por características de audio, una subconfiguración de audio y una estrategia de colocación de tokens de 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 = MyALMTester

Sobrescribir los valores predeterminados en ALMModelTester

El __init__ del tester establece valores predeterminados específicos de ALM (feat_seq_length=128, num_mel_bins=80, audio_token_id=0). Sobrescríbelos con setdefault antes de llamar a super().__init__(parent, **kwargs).

Dos atributos de clase le indican al tester cómo nombra tu modelo las cosas.

  • audio_mask_key: el nombre del kwarg que su modelo espera para la máscara de audio ("feature_attention_mask", "input_features_mask", etc.). Déjelo como None si su modelo no consume una máscara de audio separada.
  • audio_config_key: el nombre del atributo que usa tu configuración de nivel superior para anidar la subconfiguración de audio. El valor predeterminado es "audio_config", pero modelos como GraniteSpeech usan "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 requiere que se sobrescriba un hook, get_audio_embeds_mask(audio_mask), y expone algunos hooks opcionales adicionales para personalización.

  • get_audio_embeds_mask(audio_mask): devuelve la máscara de posiciones de incrustaciones de audio por lote tras el muestreo descendente del codificador. El probador utiliza la suma por fila para decidir cuántos marcadores audio_token_id insertar en input_ids, por lo que la cantidad debe coincidir con lo que emite tu codificador.
  • create_audio_features(): devuelve el tensor de características de audio. La forma predeterminada es [batch_size, num_mel_bins, feat_seq_length]. Sobrescríbala cuando su modelo, como GraniteSpeech, espere características con el tiempo primero ([batch_size, feat_seq_length, num_mel_bins]).
  • create_audio_mask(): devuelve la máscara de atención a nivel de audio. El valor predeterminado construye una región válida contigua aleatoria por cada fila del lote. Sustitúyala por una máscara determinista de longitud completa si sus pruebas comparan dos invocaciones de prepare_config_and_inputs_for_common() entre sí, o si su codificador de audio se dirige a un backend que rechaza máscaras no nulas.
  • place_audio_tokens(input_ids, config, num_audio_tokens): coloca los tokens de marcador de posición de audio de forma contigua después de BOS. Solo se debe sobrescribir si el modelo requiere un diseño diferente.
  • get_audio_feature_key(): devuelve la clave del diccionario de entradas para las características de audio (por defecto, "input_features").

Además de las pruebas multimodales heredadas, ALMModelTest añade test_mismatching_num_audio_tokens. La prueba verifica que el modelo lance un ValueError claro cuando el número de características de audio no coincide con el número de tokens de marcador de posición de audio en input_ids, y comprueba que un prompt con múltiples segmentos de audio se procesa correctamente.

Escribe pruebas para otras arquitecturas

Para arquitecturas solo de codificador, codificador-decodificador, de audio u otras no estándar, construya la infraestructura de pruebas directamente a partir del patrón de dos clases y los mixins de pruebas descritos a continuación.

ModelTester y ModelTest

Cada archivo de prueba de modelo sigue la misma estructura.

  1. ModelTester (clase simple) crea configuraciones pequeñas y entradas ficticias para pruebas, y también puede contener pruebas de regresión pequeñas específicas del modelo.
  2. ModelTest (unittest.TestCase + mixins) hereda pruebas autogeneradas y las ejecuta contra cada variante de modelo.

ModelTest llama a prepare_config_and_inputs_for_common() en el tester para obtener una tupla (config, inputs_dict). Todos los mixins se basan en prepare_config_and_inputs_for_common() para los datos de prueba.

Mezclas de pruebas

Elige los mixins que tu modelo necesita.

MixinArchivo de origenLo que se prueba
ModelTesterMixintests/test_modeling_common.pyGuardar/cargar, verificación de gradiente, firma de forward, atributos comunes
GenerationTesterMixintests/generation/test_utils.pyGreed, muestreo, búsqueda por haces, decodificación asistida
PipelineTesterMixintests/test_pipeline_mixin.pyUna prueba por tarea de pipeline
TrainingTesterMixintests/test_training_mixin.pySobreajuste en un lote pequeño
TensorParallelTesterMixintests/test_tensor_parallel_mixin.pyParalelismo de tensores distribuido

Escribir una prueba de modelo

Consulte tests/models/modernbert/test_modeling_modernbert.py para un ejemplo completo y funcional. Los pasos clave se detallan a continuación.

  1. La clase ModelTester crea configuraciones pequeñas y entradas ficticias. Mantenga las dimensiones pequeñas para que las pruebas finalicen en segundos en CPU. Utilice los tres auxiliares de tensores a continuación para construir las entradas.

    • ids_tensor(shape, vocab_size): Tensor de enteros aleatorios en [0, vocab_size). Úsalo para input_ids, token_type_ids y tensores de etiquetas.
    • random_attention_mask(shape): Tensor binario (0 y 1) en el que el primer token siempre es 1. Se utiliza para attention_mask.
    • floats_tensor(shape, scale=1.0): Tensor de números flotantes aleatorio. Úsalo para entradas continuas como pixel_values o inputs_embeds.

    El tester debe implementar get_config(), prepare_config_and_inputs() y prepare_config_and_inputs_for_common(). Añada métodos create_and_check_* para cada cabeza de tarea (modelo base, clasificación de secuencias, clasificación de tokens, etc.).

  2. Hereda de los mixins que necesite tu modelo, define all_model_classes y pipeline_model_mapping, y define setUp(). Escribe métodos test_* que deleguen en los métodos create_and_check_* del tester.

  3. Para cada cabeza de tarea, añade un método create_and_check_* en el tester que instancie el modelo, ejecute una pasada hacia adelante y verifique las formas de la salida. Después, añade un método test_* correspondiente en la clase de prueba.

Organización de archivos

Los archivos de prueba se encuentran en tests/models/mymodel/ siguiendo la estructura mostrada a continuación.

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)

Las pruebas de tokenizadores siguen el mismo patrón. Herede de TokenizerTesterMixin en tests/test_tokenization_common.py, defina algunos atributos y obtenga pruebas generadas automáticamente. Consulte tests/models/llama/test_tokenization_llama.py como ejemplo.

Pruebas de configuración

ConfigTester verifica que una clase de configuración maneje correctamente la serialización, el guardado/carga y las propiedades estándar. CausalLMModelTest y VLMModelTest incluyen pruebas de configuración automáticamente. Para la ruta general con ModelTester y ModelTest, defina el probador de configuración manualmente en 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() ejecuta varias comprobaciones.

  • Comprueba que existen propiedades comunes como hidden_size, num_attention_heads y num_hidden_layers (y vocab_size si has_text_modality=True).
  • Prueba la serialización JSON con to_json_string() y to_json_file().
  • Realiza viajes de ida y vuelta con save_pretrained() y from_pretrained().
  • Confirma la coherencia entre id2label y label2id.
  • Crea una configuración sin argumentos para validar la inicialización predeterminada.
  • Establece argumentos comunes como output_hidden_states y confirma que se almacenan correctamente.

Pasa has_text_modality=False para modelos solo de visión que carecen de vocab_size, y pasa **kwargs adicionales para sobrescribir los valores predeterminados de la configuración.

self.config_tester = ConfigTester(
    self, config_class=MyVisionConfig, has_text_modality=False, hidden_size=64
)

Pruebas de integración y modelos pequeños

Las pruebas de mixin utilizan configuraciones pequeñas con pesos aleatorios para verificar rápidamente el comportamiento del modelo. Las pruebas de integración ejecutan inferencia con pesos preentrenados reales para validar la corrección de la salida. Los modelos pequeños en el Hub son lo suficientemente pequeños para una CI rápida, pero están estructurados como puntos de control reales.

Escritura de pruebas de integración

Coloca las pruebas de integración en una clase de pruebas separada, márcalas con @slow e incluye MemoryCleanupMixin. Cada prueba descarga pesos reales, ejecuta inferencia y verifica las salidas contra los valores esperados. El mixin libera la memoria que ocupa cada prueba y ejecuta los métodos de prueba bajo torch.no_grad(); consulta Liberación de memoria entre pruebas para ver qué hace y cómo desactivarlo.

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)

Marca cualquier prueba con @slow si descarga pesos, carga un conjunto de datos grande o tarda más de unos segundos. El CI de la pull request omite las pruebas lentas, pero el programa nocturno las ejecuta.

Liberar memoria entre pruebas

Las pruebas de integración cargan puntos de control reales, por lo que una prueba que conserve una referencia a su modelo puede agotar la memoria de cualquier prueba que se ejecute después. MemoryCleanupMixin, en tests/test_memory_cleanup_mixin.py, lo gestiona para toda la clase:

  • Ejecuta cleanup(torch_device, gc_collect=True) antes y después de cada prueba para que no queden residuos que se lleven a la siguiente.
  • Elimina los atributos que la prueba añadió en self (incluidas las cachés de @cached_property) y en la clase (por ejemplo, cls.model = ... en setUpClass). Pytest mantiene las instancias de prueba activas durante toda la sesión, por lo que gc.collect() no puede liberar los objetos que esas referencias siguen sosteniendo.
  • Ejecuta los métodos de prueba bajo torch.no_grad() para que una pasada hacia adelante no retenga las activaciones.

Las clases que entrenan o invocan backward() establecen run_under_no_grad = False. Una clase que combina ambas coloca @with_grad o @with_no_grad en los métodos de prueba individuales.

Los atributos asignados en el cuerpo de la clase se conservan, y todo lo que se añada después se descarta. Si sobrescribes setUp, llama a super().setUp(): el mixin toma una instantánea de los atributos de la instancia allí y genera un error si no lo haces.

MemoryCleanupTestCase combina el mixin con TestCasePlus, para pruebas que también desean directorios temporales eliminados automáticamente.

Para encontrar una prueba que cause una fuga de memoria, establezca TRANSFORMERS_TEST_MEMORY_LEAK_MIB en un presupuesto en MiB; cualquier prueba que deje asignada más memoria en el dispositivo se informará junto con su uso máximo. Añada TRANSFORMERS_TEST_MEMORY_LEAK_MODE=error para que falle en lugar de emitir una advertencia. Esta comprobación está desactivada de forma predeterminada y debe activarla cuando busque restos de memoria. El desmontaje habitual del mixin ya ejecuta gc.collect, lo que puede liberar la asignación que desearía inspeccionar al reproducir una fuga.

Pruebas de integración de generación

Use do_sample=False en las pruebas de generación para que la salida sea determinista entre ejecuciones y hardware. En el caso de modelos Mixture-of-Experts, también llame a model.set_experts_implementation("eager") antes de generar para forzar una ruta de despacho de expertos estable. Sin esto, pequeñas diferencias numéricas en el router pueden cambiar qué experto procesa un token y alterar la salida.

@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..."])

Expectativas específicas del hardware

La CI de Transformers ejecuta pruebas lentas en una NVIDIA A10. Los resultados numéricos pueden variar ligeramente entre generaciones de GPU, por lo que las pruebas de integración utilizan la clase Expectations para registrar los valores esperados por dispositivo. Expectations selecciona la mejor coincidencia para el hardware actual en función de las claves SM (device_type, (major, minor)) y recurre a un valor predeterminado cuando no hay coincidencia.

Ejecuta torch.cuda.get_device_capability() para imprimir la versión de SM local (p. ej. (8, 6) para una A10, (9, 0) para una 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)

Creación de modelos pequeños

Los modelos diminutos con pesos aleatorios se encuentran en el Hub bajo la organización hf-internal-testing. Las pruebas de pipeline dependen de los modelos diminutos cuando necesitan un punto de control alojado en el Hub, pero no les importa la calidad de la salida. Las pruebas de humo rápidas también cargan modelos diminutos para verificar las formas de la pasada hacia adelante sin descargar puntos de control grandes.

Los modelos pequeños son un último recurso para las pruebas de integración. Úselos solo cuando el punto de control más pequeño disponible supere los ~24 GB de VRAM. Utilice los pesos preentrenados originales, cuando sea posible, para detectar regresiones numéricas reales.

El script utils/create_dummy_models.py genera modelos diminutos a partir de ModelTester.get_config(). El script extrae hiperparámetros diminutos de su tester, construye un modelo con pesos aleatorios y sube el resultado al Hub.

Genera modelos pequeños localmente.

python utils/create_dummy_models.py output_dir -m your_model_type

Sube al Hub.

python utils/create_dummy_models.py output_dir -m your_model_type --upload --organization hf-internal-testing

Cada modelo utiliza el nombre hf-internal-testing/tiny-random-{ModelClassName} y se registra en tests/utils/tiny_model_summary.json. Un flujo de trabajo de CI (.github/workflows/check_tiny_models.yml) regenera los modelos pequeños a diario.

Controlar lo que se prueba

Las banderas booleanas en ModelTesterMixin activan las pruebas generadas automáticamente. Sobrescribe cualquier bandera en tu clase de prueba para habilitar o deshabilitar comprobaciones específicas.

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
FlagPredeterminadoLo que controla
test_resize_embeddingsTrueRedimensionamiento de la capa de incrustación
test_resize_position_embeddingsFalseRedimensionamiento de los embeddings de posición
test_mismatched_shapesTrueGestión de formas de entrada/salida no coincidentes
test_missing_keysTrueAdvertencias de claves faltantes al cargar
test_torch_exportableTrueCompatibilidad con torch.export
test_all_params_have_gradientTrueTodos los parámetros reciben gradientes (establezca False cuando no todos los parámetros se activan en cada pasada hacia adelante, como en los expertos de MoE)
is_encoder_decoderFalsePruebas específicas de codificador-decodificador
has_attentionsTruePruebas de la salida de atención
_is_compositeFalseGestión de modelos compuestos/multimodales
model_split_percents[0.5, 0.7, 0.9]Porcentajes de división para las pruebas de paralelismo de modelos

Próximos pasos

  • Consulte la documentación de pytest para obtener más información sobre la selección de pruebas, los fixtures, el registro y mucho más.
Update on GitHub