# Menulis pengujian model

Suite pengujian Transformers menggunakan arsitektur berbasis mixin untuk menghasilkan otomatis 100+ tes dari kode minimal. Anda menulis sejumlah kecil kode yang spesifik untuk model, dan mixin menangani save/load, generation, pipelines, training, dan tensor parallelism.

Jalankan pengujian model Anda dengan perintah berikut.

```bash
# 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
```

CI Hugging Face menjalankan pengujian model tanpa `@slow` pada setiap pull request, dan pengujian lambat dijalankan berdasarkan jadwal harian (lihat [Periksa pull request](./pr_checks) untuk apa yang divalidasi oleh CI).

## Jalankan Kontrak Integrasi Model secara lokal

MICs memeriksa jalur penggunaan model yang dipublikasikan terhadap baseline yang telah ditinjau menggunakan fixture kecil. Runner (`transformers-mic`) dan `hf-doc-builder` hadir dengan extra `testing`. Dari checkout Transformers Anda:

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

Lalu jalankan:

```bash
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)
```

Perintah ini menggunakan sumber dari checkout ini dan revisi fleet dalam `tests/contracts.lock`. Secara default, perintah ini menjalankan fleet prototypes; `FLEET=control` memilih fleet control yang lebih kecil. Seperti CI, perintah ini memeriksa fleet prototypes dalam `bfloat16` dan fleet control dalam kedua `default` dan `bfloat16`. Perintah ini mengunduh kontrak, fixture, dan baseline yang di-pin sesuai kebutuhan, mengeksekusinya secara lokal, dan mencetak satu baris per fixture beserta ringkasan; fixture yang gagal akan menyebabkan perintah gagal. Kontrak dibagi ke dalam proses runner paralel (`JOBS`, default hingga 4, `JOBS=1` untuk menjalankannya satu per satu). Setiap runner menggunakan `OMP_NUM_THREADS=4`, jumlah thread yang digunakan saat baseline direkam (atur `OMP_NUM_THREADS` untuk menimpanya), sehingga jumlah thread tidak menambah perbedaan dengan CI. `make run-mic` adalah wrapper di sekitar checker `mic` (`python utils/checkers.py mic`), yang bersifat opt-in dan bukan bagian dari `make check-repo` atau CI karena membutuhkan akses jaringan dan runtime model. Perintah ini tidak membuat atau menerbitkan kontrak. Ketergantungan runtime yang spesifik untuk model dan baseline yang telah ditinjau untuk platform Anda diperlukan; lolosnya fixture tidak memvalidasi checkpoint penuh.

Secara default, file yang berubah adalah diff antara merge base dengan `origin/main` dan working tree Anda, ditambah file yang tidak dilacak. Ini mencakup commit cabang, perubahan yang di-staged dan yang belum di-staged, serta kedua path dari rename. Checkout yang bersih tidak memiliki apa pun untuk dijalankan. Ketika perubahan memilih semua kontrak (misalnya `setup.py`, kode bersama, atau fleet pin di `tests/contracts.lock`), tidak ada yang dijalankan: perintah akan menjelaskan alasannya, dan Anda memilih `MODEL=<name>` atau `ALL=1`.

MIC menurunkan dependensi model dari konfigurasi fixture (termasuk model bersarang), arsitektur, dan kelas tokenizer/processor. Perubahan pada direktori model memilih kontrak yang cocok; perubahan pada kode Transformers bersama, kelas Auto, deklarasi dependensi, atau pin armada memilih semua kontrak. Perubahan pada dokumentasi dan pengujian biasa yang tidak terkait memilih tidak ada. Runner mencetak pilihan dan alasannya; tidak adanya kontrak yang cocok berarti tidak ada cakupan, bukan pemeriksaan model yang berhasil. Pemilihan ini bersifat heuristik, bukan graf dependensi Python yang lengkap; gunakan `ALL=1` jika ragu apakah dependensi tidak langsung tercakup.

`MODEL=bert` lebih sempit: hanya menjalankan kontrak yang fixture `config.json` memiliki `model_type` yang didefinisikan di `models/bert`. Model komposit yang sekadar menyematkan BERT tidak dijalankan; gunakan pilihan file-terubah default (atau `ALL=1`) untuk menyertakannya.

## Pilih kelas pengujian dasar

Tiga kelas dasar mencakup keluarga model yang paling umum. Pilih yang sesuai dengan modalitas model Anda.

| Kelas dasar | Digunakan untuk | Mixins |
|---|---|---|
| `CausalLMModelTest` | Model bahasa kausal | `ModelTesterMixin`, `GenerationTesterMixin`, `PipelineTesterMixin`, `TrainingTesterMixin`, `TensorParallelTesterMixin` |
| `VLMModelTest` | Model bahasa-visi | `ModelTesterMixin`, `GenerationTesterMixin`, `PipelineTesterMixin` |
| `ALMModelTest` | Model bahasa-audio | `ModelTesterMixin`, `GenerationTesterMixin`, `PipelineTesterMixin` |

`VLMModelTest` dan `ALMModelTest` berbagi induk `MultiModalModelTest` yang sama, yang menelusuk sub-config ke dalam config top-level komposit dan menempatkan token placeholder modalitas di `input_ids` berdampingan dengan fitur modalitas mentah (audio atau visi). `CausalLMModelTest` tidak menggunakan induk multimodal. Ia dibangun di atas tiga mixin bersama dan menambahkan `TrainingTesterMixin` serta `TensorParallelTesterMixin` untuk cakupan pelatihan dan tensor-parallel.

Untuk arsitektur yang tidak cocok dengan salah satu dari tiga (hanya encoder, encoder-decoder, dll.), bangun infrastruktur pengujian langsung dari [pola dua kelas](#modeltester-and-modeltest) dan [mixin pengujian](#test-mixins) yang dijelaskan di bawah.

## CausalLMModelTest

`CausalLMModelTest` adalah kelas dasar yang direkomendasikan untuk menguji model bahasa kausal. Kelas ini mewarisi dari lima [test mixin](#test-mixins) dan secara otomatis menghasilkan pengujian untuk save/load, generation, pipelines, training, dan tensor parallelism.

```py
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
```

Kedua kelas ini memberikan cakupan pengujian penuh untuk `MyModel` dan semua kelas head-nya (`MyModelForCausalLM`, `MyModelForSequenceClassification`, dst.). Lihat [tests/models/llama/test_modeling_llama.py](https://github.com/huggingface/transformers/blob/main/tests/models/llama/test_modeling_llama.py) untuk contoh nyata.

`CausalLMModelTester` hanya membutuhkan `base_model_class`. Tester ini menghapus akhiran `Model` untuk mendapatkan nama dasar (`LlamaModel` menjadi `Llama`), lalu menambahkan akhiran seperti `Config` atau `ForCausalLM` untuk menemukan kelas terkait. Jika sebuah kelas tidak ada di modul, atributnya tetap `None` dan tester akan melewati tes yang sesuai.

### Menimpa nilai bawaan di CausalLMTester

Jika model Anda tidak mengikuti penamaan standar, atau Anda perlu menyesuaikan perilaku, timpa atribut pada tester atau kelas pengujian.

```py
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
```

Untuk model yang memerlukan parameter konstruktor khusus pada tester, override `__init__` dan panggil `super().__init__(parent=parent)` sebelum mengatur atribut tambahan. Lihat [tests/models/youtu/test_modeling_youtu.py](https://github.com/huggingface/transformers/blob/main/tests/models/youtu/test_modeling_youtu.py) untuk contoh nyata.

```py
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` adalah kelas dasar untuk model bahasa-visi. Kelas ini mewarisi dari tiga mixin (`ModelTesterMixin`, `GenerationTesterMixin`, `PipelineTesterMixin`) dan mengatur `_is_composite = True` untuk menangani beberapa sub-model.

```py
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
```

### Menimpa nilai bawaan di VLMModelTester

Ketika VLM memerlukan parameter visi khusus atau nilai konfigurasi non-default, override `__init__`. Atur nilai default dengan `setdefault` sebelum memanggil `super().__init__(parent, **kwargs)`. Contoh di bawah ini menampilkan beberapa nilai default pertama dari [tests/models/qianfan_ocr/test_modeling_qianfan_ocr.py](https://github.com/huggingface/transformers/blob/main/tests/models/qianfan_ocr/test_modeling_qianfan_ocr.py).

```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)
```

Uji VLM berbeda dari `CausalLMModelTest` dalam beberapa hal.

- Anda harus mengatur `config_class`, `text_config_class`, `vision_config_class`, dan `conditional_generation_class` pada tester.
- `VLMModelTest` tidak menyertakan `TrainingTesterMixin` atau `TensorParallelTesterMixin`.
- `__init__` pengujian menerima parameter visual (`image_size`, `patch_size`, `num_channels`, `num_image_tokens`) dari `**kwargs` dan `setdefault()`.
- `ConfigTester` menggunakan `has_text_modality=False` karena konfigurasi tingkat atas adalah konfigurasi komposit, bukan konfigurasi model teks.

## ALMModelTest

`ALMModelTest` adalah kelas dasar untuk model audio-bahasa (ALM) seperti Qwen2Audio, AudioFlamingo3, dan GraniteSpeech. Kelas ini mengikuti pola VLM dengan kelas induk `MultiModalModelTest` yang sama serta penemuan otomatis kelas head. Mekanisme sisi visual diganti dengan fitur audio, sub-konfigurasi audio, dan strategi penempatan token audio.

```py
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
```

### Menimpa nilai bawaan di ALMModelTester

`__init__` tester mengatur nilai default yang spesifik untuk ALM (`feat_seq_length=128`, `num_mel_bins=80`, `audio_token_id=0`). Timpa nilai-nilai tersebut dengan `setdefault` sebelum memanggil `super().__init__(parent, **kwargs)`.

Dua atribut kelas memberi tahu tester bagaimana model Anda menamai sesuatu.

- `audio_mask_key`: nama kwarg yang diharapkan model Anda untuk audio mask (`"feature_attention_mask"`, `"input_features_mask"`, dll.). Biarkan `None` jika model Anda tidak mengonsumsi audio mask terpisah.
- `audio_config_key`: nama atribut yang digunakan oleh config tingkat atas Anda untuk menaruh sub-config audio. Nilainya secara default adalah `"audio_config"`, tetapi model seperti GraniteSpeech menggunakan `"encoder_config"`.

```py
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` mengharuskan Anda untuk menimpa satu hook, `get_audio_embeds_mask(audio_mask)`, dan menyediakan beberapa hook opsional lainnya untuk kustomisasi.

- `get_audio_embeds_mask(audio_mask)`: mengembalikan mask posisi embedding audio per batch setelah downsampling encoder. Tester menggunakan jumlah per barisnya untuk menentukan berapa banyak placeholder `audio_token_id` yang akan disisipkan ke dalam `input_ids`, sehingga jumlahnya harus sesuai dengan apa yang dihasilkan encoder Anda.
- `create_audio_features()`: mengembalikan tensor fitur audio. Bentuk default adalah `[batch_size, num_mel_bins, feat_seq_length]`. Override ketika model Anda, seperti GraniteSpeech, mengharapkan fitur dengan urutan waktu di depan (`[batch_size, feat_seq_length, num_mel_bins]`).
- `create_audio_mask()`: mengembalikan attention mask pada level audio. Secara default, fungsi ini membangun region valid yang berurutan secara acak untuk setiap baris dalam batch. Ganti dengan mask penuh yang deterministik jika pengujian Anda membandingkan dua pemanggilan `prepare_config_and_inputs_for_common()` satu sama lain, atau jika audio encoder Anda di-dispatch ke backend yang menolak mask yang tidak null.
- `place_audio_tokens(input_ids, config, num_audio_tokens)`: menempatkan token placeholder audio secara berurutan setelah `BOS`. Override hanya jika model Anda memerlukan tata letak yang berbeda.
- `get_audio_feature_key()`: mengembalikan kunci dict input untuk fitur audio (defaultnya `"input_features"`).

Selain tes multimodal yang diwarisi, `ALMModelTest` menambahkan `test_mismatching_num_audio_tokens`. Tes ini memastikan model melempar `ValueError` yang jelas ketika jumlah fitur audio tidak cocok dengan jumlah token placeholder audio di `input_ids`, dan memverifikasi bahwa prompt dengan beberapa segmen audio tetap berhasil diteruskan.

## Tulis tes untuk arsitektur lain

Untuk arsitektur encoder-only, encoder-decoder, audio, atau arsitektur non-standar lainnya, bangun infrastruktur pengujian langsung dari pola dua kelas dan mixin pengujian yang dijelaskan di bawah ini.

### ModelTester dan ModelTest

Setiap file pengujian model mengikuti struktur yang sama.

1. `ModelTester` (kelas biasa) membuat konfigurasi kecil dan input dummy untuk pengujian, serta dapat juga menyimpan uji regresi kecil yang spesifik untuk model tersebut.
2. `ModelTest` (`unittest.TestCase` + mixins) mewarisi tes yang dibuat secara otomatis dan menjalankannya terhadap setiap varian model.

`ModelTest` memanggil `prepare_config_and_inputs_for_common()` pada tester untuk mendapatkan tuple `(config, inputs_dict)`. Semua mixin bergantung pada `prepare_config_and_inputs_for_common()` untuk data uji.

### Uji mixin

Pilih mixin yang dibutuhkan model Anda.

| Mixin | Berkas sumber | Yang diuji |
|---|---|---|
| `ModelTesterMixin` | `tests/test_modeling_common.py` | Simpan/muat, checkpointing gradien, tanda tangan forward, atribut umum |
| `GenerationTesterMixin` | `tests/generation/test_utils.py` | Greedy, sampling, beam search, assisted decoding |
| `PipelineTesterMixin` | `tests/test_pipeline_mixin.py` | Satu tes per tugas pipeline |
| `TrainingTesterMixin` | `tests/test_training_mixin.py` | Overfitting pada batch kecil |
| `TensorParallelTesterMixin` | `tests/test_tensor_parallel_mixin.py` | Paralelisme tensor terdistribusi |

### Menulis pengujian model

Lihat [tests/models/modernbert/test_modeling_modernbert.py](https://github.com/huggingface/transformers/blob/main/tests/models/modernbert/test_modeling_modernbert.py) untuk contoh lengkap yang berfungsi. Langkah-langkah utama diuraikan di bawah ini.

1. Kelas `ModelTester` membangun konfigurasi kecil dan input dummy. Pertahankan dimensi tetap kecil agar pengujian selesai dalam hitungan detik pada CPU. Gunakan tiga helper tensor di bawah ini untuk membangun input.

    - `ids_tensor(shape, vocab_size)`: Tensor integer acak dalam `[0, vocab_size)`. Gunakan untuk `input_ids`, `token_type_ids`, dan tensor label.
    - `random_attention_mask(shape)`: Tensor biner (0 dan 1) di mana token pertama selalu bernilai 1. Gunakan untuk `attention_mask`.
    - `floats_tensor(shape, scale=1.0)`: Tensor float acak. Gunakan untuk input kontinu seperti `pixel_values` atau `inputs_embeds`.

    Tester harus mengimplementasikan `get_config()`, `prepare_config_and_inputs()`, dan `prepare_config_and_inputs_for_common()`. Tambahkan metode `create_and_check_*` untuk setiap task head (base model, sequence classification, token classification, dll.).

2. Warisi dari mixin yang dibutuhkan model Anda, atur `all_model_classes` dan `pipeline_model_mapping`, serta definisikan `setUp()`. Tulis metode `test_*` yang mendelegasikan ke metode `create_and_check_*` dari tester.

3. Untuk setiap task head, tambahkan metode `create_and_check_*` pada tester yang menginstansiasi model, menjalankan forward pass, dan memvalidasi bentuk output. Kemudian tambahkan metode `test_*` yang sesuai pada kelas test.

### Organisasi file

File uji berada di `tests/models/mymodel/` mengikuti struktur yang ditunjukkan di bawah ini.

```text
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)
```

Uji tokenizer mengikuti pola yang sama. Turunkan `TokenizerTesterMixin` dari `tests/test_tokenization_common.py`, atur beberapa atribut, dan dapatkan uji yang dibuat secara otomatis. Lihat [tests/models/llama/test_tokenization_llama.py](https://github.com/huggingface/transformers/blob/main/tests/models/llama/test_tokenization_llama.py) untuk contoh.

## Uji konfigurasi

`ConfigTester` memverifikasi bahwa kelas config menangani serialisasi, save/load, dan properti standar dengan benar. `CausalLMModelTest` dan `VLMModelTest` menyertakan pengujian config secara otomatis. Untuk jalur umum dengan `ModelTester` dan `ModelTest`, definisikan pengujian config secara manual di `setUp()`.

```py
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()` menjalankan beberapa pemeriksaan.

- Memeriksa bahwa properti umum seperti `hidden_size`, `num_attention_heads`, dan `num_hidden_layers` ada (dan `vocab_size` jika `has_text_modality=True`).
- Menguji serialisasi JSON dengan `to_json_string()` dan `to_json_file()`.
- Melakukan round-trip `save_pretrained()` dan `from_pretrained()`.
- Memastikan konsistensi `id2label` dan `label2id`.
- Membuat config tanpa argumen untuk memvalidasi inisialisasi default.
- Menetapkan kwargs umum seperti `output_hidden_states` dan memastikan bahwa nilai tersebut disimpan dengan benar.

Lewati `has_text_modality=False` untuk model yang hanya visual dan tidak memiliki `vocab_size`, serta lewati `**kwargs` tambahan untuk menimpa nilai default konfigurasi.

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

## Uji integrasi dan model kecil

Mixin tests menggunakan konfigurasi kecil dengan bobot acak untuk memverifikasi perilaku model dengan cepat. Integration tests menjalankan inferensi dengan bobot pretrained asli untuk memvalidasi kebenaran output. Model kecil di Hub cukup kecil untuk CI yang cepat, tetapi terstruktur seperti checkpoint asli.

### Menulis pengujian integrasi

Letakkan pengujian integrasi dalam kelas pengujian terpisah, tandai dengan `@slow`, dan campurkan `MemoryCleanupMixin`. Setiap pengujian mengunduh bobot asli, menjalankan inferensi, dan memeriksa keluaran terhadap nilai yang diharapkan. Mixin ini membebaskan memori yang digunakan oleh setiap pengujian dan menjalankan metode pengujian di bawah `torch.no_grad()` — lihat [Melepaskan memori antar pengujian](#releasing-memory-between-tests) untuk mengetahui apa yang dilakukan dan cara untuk tidak mengikutinya.

```py
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)
```

Tandai setiap test dengan `@slow` jika test tersebut mengunduh weights, memuat dataset besar, atau memakan waktu lebih dari beberapa detik. [pull request CI](./pr_checks) akan melewati test yang lambat, tetapi jadwal nightly akan menjalankannya.

#### Melepaskan memori di antara pengujian

Uji integrasi memuat checkpoint asli, sehingga uji yang mempertahankan referensi ke modelnya dapat menyebabkan OOM pada apa pun yang dijalankan setelahnya. `MemoryCleanupMixin`, di `tests/test_memory_cleanup_mixin.py`, menangani hal tersebut untuk seluruh kelas:

- Menjalankan `cleanup(torch_device, gc_collect=True)` sebelum dan sesudah setiap pengujian agar sisa tidak terbawa.
- Menghapus atribut yang ditambahkan oleh tes pada `self` (termasuk cache `@cached_property`) dan pada kelas (misalnya `cls.model = ...` di `setUpClass`). Pytest mempertahankan instance tes selama sesi, sehingga `gc.collect()` tidak dapat membebaskan objek yang masih dipegang oleh referensi tersebut.
- Menjalankan metode pengujian di bawah `torch.no_grad()` sehingga forward pass tidak menyimpan aktivasi.

Kelas yang melatih atau memanggil `backward()` mengatur `run_under_no_grad = False`. Kelas yang mencampurkan keduanya menempatkan `@with_grad` atau `@with_no_grad` pada metode uji individual.

Atribut yang ditugaskan di dalam badan kelas akan dipertahankan, dan semua yang ditambahkan kemudian akan dibuang. Jika Anda menimpa `setUp`, panggil `super().setUp()`: mixin mengambil snapshot atribut instance di sana dan akan menghasilkan error tanpa pemanggilan tersebut.

> [!TIP]
> `MemoryCleanupTestCase` menggabungkan mixin dengan `TestCasePlus`, untuk tes yang juga ingin direktori sementara dihapus secara otomatis.

Untuk menemukan test yang bocor, atur `TRANSFORMERS_TEST_MEMORY_LEAK_MIB` ke anggaran dalam MiB; setiap test yang meninggalkan alokasi lebih dari itu pada perangkat akan dilaporkan beserta penggunaan puncaknya. Tambahkan `TRANSFORMERS_TEST_MEMORY_LEAK_MODE=error` untuk membuat test gagal alih-alih memperingatkan. Pemeriksaan ini nonaktif secara default dan sebaiknya diaktifkan saat mencari sisa alokasi. Teardown biasa dari mixin sudah menjalankan `gc.collect`, yang dapat menghapus alokasi yang ingin Anda periksa saat mereproduksi kebocoran.

#### Uji integrasi generasi

Gunakan `do_sample=False` dalam pengujian generasi agar output bersifat deterministik di antara berbagai eksekusi dan perangkat keras. Untuk model Mixture-of-Experts, juga panggil `model.set_experts_implementation("eager")` sebelum melakukan generasi untuk memaksa jalur dispatch expert yang stabil. Tanpa ini, perbedaan numerik kecil pada router dapat mengubah expert mana yang menangani sebuah token dan mengubah output.

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

#### Ekspektasi spesifik perangkat keras

Transformers CI menjalankan tes lambat pada NVIDIA A10. Hasil numerik dapat sedikit bervariasi antar generasi GPU, sehingga tes integrasi menggunakan kelas [Expectations](https://github.com/huggingface/transformers/blob/main/src/transformers/testing_utils.py#L3247) untuk mendaftarkan nilai yang diharapkan per perangkat. `Expectations` memilih kecocokan terbaik untuk perangkat keras saat ini berdasarkan kunci SM `(device_type, (major, minor))`, dan kembali ke nilai default jika tidak ada yang cocok.

Jalankan `torch.cuda.get_device_capability()` untuk mencetak versi SM lokal Anda (misalnya `(8, 6)` untuk A10, `(9, 0)` untuk H100).

```py
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)
```

### Membuat model kecil

Model kecil dengan bobot acak tersedia di Hub di bawah organisasi [hf-internal-testing](https://huggingface.co/hf-internal-testing). Uji pipeline mengandalkan model kecil ketika mereka membutuhkan checkpoint yang di-hosting di Hub tetapi tidak peduli dengan kualitas output. Uji smoke yang cepat juga memuat model kecil untuk memverifikasi bentuk jalur maju tanpa mengunduh checkpoint besar.

Model kecil adalah pilihan terakhir untuk uji integrasi. Gunakan model ini hanya jika checkpoint terkecil yang tersedia melebihi ~24 GB VRAM. Gunakan bobot pretrained asli, jika memungkinkan, untuk mendeteksi regresi numerik yang sebenarnya.

Skrip `utils/create_dummy_models.py` menghasilkan model berukuran kecil dari `ModelTester.get_config()`. Skrip ini mengekstrak hiperparameter berukuran kecil dari tester Anda, membangun model dengan bobot acak, dan mengunggah hasilnya ke Hub.

Generate model kecil secara lokal.

```bash
python utils/create_dummy_models.py output_dir -m your_model_type
```

Unggah ke Hub.

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

Setiap model menggunakan nama `hf-internal-testing/tiny-random-{ModelClassName}` dan dicatat dalam `tests/utils/tiny_model_summary.json`. Alur kerja CI (`.github/workflows/check_tiny_models.yml`) membuat ulang model kecil setiap hari.

## Kendalikan apa yang diuji

Flag boolean pada `ModelTesterMixin` mengaktifkan atau menonaktifkan tes yang dibuat secara otomatis. Override flag mana pun pada kelas tes Anda untuk mengaktifkan atau menonaktifkan pemeriksaan tertentu.

```py
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
```

| Bendera | Default | Yang dikendalikannya |
|---|---|---|
| `test_resize_embeddings` | `True` | Penyesuaian ukuran layer embedding |
| `test_resize_position_embeddings` | `False` | Penyesuaian ukuran posisi embedding |
| `test_mismatched_shapes` | `True` | Penanganan bentuk input/output yang tidak cocok |
| `test_missing_keys` | `True` | Peringatan kunci yang hilang saat memuat |
| `test_torch_exportable` | `True` | kompatibilitas `torch.export` |
| `test_all_params_have_gradient` | `True` | Semua parameter menerima gradien (setel `False` ketika tidak semua parameter diaktifkan pada setiap forward pass, seperti pada MoE experts) |
| `is_encoder_decoder` | `False` | Uji khusus encoder-decoder |
| `has_attentions` | `True` | Tes output perhatian |
| `_is_composite` | `False` | Penanganan model komposit/multimodal |
| `model_split_percents` | `[0.5, 0.7, 0.9]` | Persentase pembagian untuk pengujian paralelisme model |

## Langkah selanjutnya

- Jelajahi dokumentasi [pytest](https://docs.pytest.org/en/latest/getting-started.html) untuk informasi lebih lanjut tentang pemilihan tes, fixture, logging, dan lainnya.

