# FP8 bergranularitas halus

Kuantisasi FP8 bergranularitas halus mengkuantisasi bobot dan aktivasi ke fp8.

- Bobot dikuantisasi menjadi 8-bit untuk setiap blok 2D (`weight_block_size=(128, 128)`).
- Aktivasi dikuantisasi menjadi 8-bit untuk setiap grup per token. Nilai grup sesuai dengan bobot pada kanal input (128 secara default).

Kuantisasi FP8 memungkinkan dukungan untuk [DeepSeek-V3](https://hf.co/papers/2412.19437) dan DeepSeek-R1.

    

> [!TIP]
> Anda memerlukan GPU dengan Compute Capability>=9 (H100), dan menginstal versi PyTorch yang kompatibel dengan versi CUDA dari GPU Anda.

Instal Accelerate dan tingkatkan ke versi terbaru PyTorch.

```bash
pip install --upgrade accelerate torch
```

Buat kelas [FineGrainedFP8Config](/docs/transformers/main/id/main_classes/quantization#transformers.FineGrainedFP8Config) dan teruskan ke [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk melakukan kuantisasi. Secara default, bobot dimuat dalam presisi penuh (`torch.float32`) terlepas dari tipe data aktual tempat bobot disimpan. Atur `dtype="auto"` untuk memuat bobot dalam tipe data yang didefinisikan di file `config.json` model, sehingga tipe data yang paling optimal dari segi memori dimuat secara otomatis.

```py
from transformers import FineGrainedFP8Config, AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Meta-Llama-3-8B"
quantization_config = FineGrainedFP8Config()
quantized_model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto", device_map="auto", quantization_config=quantization_config)

tokenizer = AutoTokenizer.from_pretrained(model_name)
input_text = "What are we having for dinner?"
input_ids = tokenizer(input_text, return_tensors="pt").to(quantized_model.device.type)

output = quantized_model.generate(**input_ids, max_new_tokens=10)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

Gunakan [save_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) untuk menyimpan model terkuantisasi dan memuatnya kembali dengan [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained).

```py
quant_path = "/path/to/save/quantized/model"
quantized_model.save_pretrained(quant_path)
model = AutoModelForCausalLM.from_pretrained(quant_path, device_map="auto")
```

## Jalur cepat DeepGEMM

Pada GPU Hopper (SM90+) dan Blackwell (SM100+), setiap linear FP8 secara otomatis di-dispatch ke kernel [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM) dari [kernels-community/deep-gemm](https://huggingface.co/kernels-community/deep-gemm) ketika `weight_block_size=(128, 128)` dan `activation_scheme="dynamic"`. DeepGEMM 3-6x lebih cepat daripada fallback Triton. Instal atau upgrade paket [kernels](https://github.com/huggingface/kernels) untuk mengaktifkannya.

```bash
pip install -U kernels
```

DeepGEMM mengompilasi kernel-nya secara JIT menggunakan `nvcc` sistem, sehingga toolkit CUDA lengkap harus diinstal. Instalasi hanya runtime (perpustakaan CUDA tanpa `nvcc`) tidak akan berfungsi. Versi minimum toolkit bergantung pada perangkat keras: 12.3 atau lebih baru pada Hopper (SM90), dan 12.9 atau lebih baru pada Blackwell (SM100).

Transformers menemukan toolkit dengan memeriksa `CUDA_HOME`, kemudian `CUDA_PATH`, kemudian `nvcc` di `PATH` Anda, kemudian `/usr/local/cuda`. Atur `CUDA_HOME` ke root toolkit jika `nvcc` tidak ditemukan.

Jika kernel tidak dapat dimuat (karena `kernels` tidak ada, GPU tidak didukung, tidak ada CUDA toolkit, atau `nvcc` lebih lama dari versi yang diperlukan), Transformers mencatat peringatan sekali dan beralih ke kernel Triton finegrained-fp8. Kuantisasi aktivasi statis selalu tetap berada di jalur Triton.

Untuk memaksa penggunaan fallback Triton meskipun DeepGEMM tersedia, atur `TRANSFORMERS_DISABLE_DEEPGEMM_LINEAR=1`. Hal ini hanya memengaruhi dispatch linear FP8 dan tidak mengubah backend experts `"deepgemm"`, yang dapat Anda ubah dengan [set_experts_implementation()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.set_experts_implementation).

Untuk pakar MoE, jalur DeepGEMM bersifat opt-in. Sampaikan `experts_implementation="deepgemm"` (atau `"deepgemm_megamoe"` pada Blackwell) saat pemuatan untuk mengalihkan perkalian matriks pakar melalui DeepGEMM. Lihat panduan [Backends pakar](../experts_interface) untuk kumpulan opsi lengkap.

## Format skala UE8M0

Checkpoint bergaya DeepSeek V4 menyimpan skala bobot FP8 dalam format `float8_e8m0fnu` yang ter-packing, alih-alih `float32`. Checkpoint ini sudah ter-kuantisasi sebelumnya dan mengatur `scale_fmt="ue8m0"` dalam konfigurasi kuantisasinya. Baik kernel DeepGEMM maupun Triton membaca skala UE8M0, sehingga checkpoint ini dapat dijalankan di jalur mana pun.

Pada Blackwell (SM100+), kernel DeepGEMM experts hanya mendukung skala UE8M0. Checkpoint dengan skala `float32` biasa (`scale_fmt="float"`) akan memicu `ValueError`. Gunakan checkpoint `scale_fmt="ue8m0"`, atau jalankan experts dengan `grouped_mm` atau `batched_mm`, yang mendukung skala `float32` secara langsung. Hopper (SM90+) mendukung skala `float32` pada jalur DeepGEMM tanpa konversi. Lihat panduan [Experts backends](../experts_interface) untuk opsi backend experts.