Transformers documentation
Escritura de pruebas de modelos
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/ -vEl 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 base | Uso | Mixins |
|---|---|---|
CausalLMModelTest | Modelos de lenguaje causales | ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin, TrainingTesterMixin, TensorParallelTesterMixin |
VLMModelTest | Modelos de visión y lenguaje | ModelTesterMixin, GenerationTesterMixin, PipelineTesterMixin |
ALMModelTest | Modelos de audio y lenguaje | ModelTesterMixin, 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 = MyModelTesterEstas 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 = FalsePara 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_rankVLMModelTest
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 = MyVLMTesterSobrescribir 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_classyconditional_generation_classen el tester. VLMModelTestno incluyeTrainingTesterMixinniTensorParallelTesterMixin.- El
__init__del tester acepta parámetros de visión (image_size,patch_size,num_channels,num_image_tokens) desde**kwargsysetdefault(). ConfigTesterutilizahas_text_modality=Falseporque 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 = MyALMTesterSobrescribir 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 comoNonesi 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 marcadoresaudio_token_idinsertar eninput_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 deprepare_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 deBOS. 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.
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.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.
| Mixin | Archivo de origen | Lo que se prueba |
|---|---|---|
ModelTesterMixin | tests/test_modeling_common.py | Guardar/cargar, verificación de gradiente, firma de forward, atributos comunes |
GenerationTesterMixin | tests/generation/test_utils.py | Greed, muestreo, búsqueda por haces, decodificación asistida |
PipelineTesterMixin | tests/test_pipeline_mixin.py | Una prueba por tarea de pipeline |
TrainingTesterMixin | tests/test_training_mixin.py | Sobreajuste en un lote pequeño |
TensorParallelTesterMixin | tests/test_tensor_parallel_mixin.py | Paralelismo 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.
La clase
ModelTestercrea 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 parainput_ids,token_type_idsy tensores de etiquetas.random_attention_mask(shape): Tensor binario (0 y 1) en el que el primer token siempre es 1. Se utiliza paraattention_mask.floats_tensor(shape, scale=1.0): Tensor de números flotantes aleatorio. Úsalo para entradas continuas comopixel_valuesoinputs_embeds.
El tester debe implementar
get_config(),prepare_config_and_inputs()yprepare_config_and_inputs_for_common(). Añada métodoscreate_and_check_*para cada cabeza de tarea (modelo base, clasificación de secuencias, clasificación de tokens, etc.).Hereda de los mixins que necesite tu modelo, define
all_model_classesypipeline_model_mapping, y definesetUp(). Escribe métodostest_*que deleguen en los métodoscreate_and_check_*del tester.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étodotest_*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_headsynum_hidden_layers(yvocab_sizesihas_text_modality=True). - Prueba la serialización JSON con
to_json_string()yto_json_file(). - Realiza viajes de ida y vuelta con
save_pretrained()yfrom_pretrained(). - Confirma la coherencia entre
id2labelylabel2id. - Crea una configuración sin argumentos para validar la inicialización predeterminada.
- Establece argumentos comunes como
output_hidden_statesy 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 = ...ensetUpClass). Pytest mantiene las instancias de prueba activas durante toda la sesión, por lo quegc.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.
MemoryCleanupTestCasecombina el mixin conTestCasePlus, 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| Flag | Predeterminado | Lo que controla |
|---|---|---|
test_resize_embeddings | True | Redimensionamiento de la capa de incrustación |
test_resize_position_embeddings | False | Redimensionamiento de los embeddings de posición |
test_mismatched_shapes | True | Gestión de formas de entrada/salida no coincidentes |
test_missing_keys | True | Advertencias de claves faltantes al cargar |
test_torch_exportable | True | Compatibilidad con torch.export |
test_all_params_have_gradient | True | Todos 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_decoder | False | Pruebas específicas de codificador-decodificador |
has_attentions | True | Pruebas de la salida de atención |
_is_composite | False | Gestió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.