# Metal

Kuantisasi Metal melakukan kuantisasi afine pada perangkat Apple Silicon (MPS) menggunakan kernel Metal yang dihosting di Hugging Face Hub ([kernels-community/mlx-quantization-metal-kernels](https://huggingface.co/kernels-community/mlx-quantization-metal-kernels)). Kernel ini berasal dari framework [MLX](https://github.com/ml-explore/mlx) dan dikompilasi melalui pustaka [`kernels`](https://github.com/huggingface/kernels).

Bobot dikemas ke dalam tensor `uint32` dengan skala dan bias per grup, dan jalur maju menggunakan kernel Metal dequantization + matmul yang terfusi (`affine_qmm_t`). Hal ini menjaga penggunaan memori tetap rendah sambil menjalankan inferensi sepenuhnya di GPU tanpa round-trip ke CPU.

Lebar bit yang didukung adalah **2, 4, dan 8**. Ukuran grup dapat dikonfigurasi (default 64).

## Persyaratan

- Mac Apple Silicon (M1 / M2 / M3 / M4) dengan dukungan MPS
- Paket `kernels`:

```bash
pip install kernels
```

Kernel Metal diunduh secara otomatis dari Hub saat pertama kali digunakan — tidak perlu kompilasi manual.

## Kuantisasi secara langsung

Muat model apa pun dan kuantisasi saat pemuatan dengan meneruskan [MetalConfig](/docs/transformers/main/id/main_classes/quantization#transformers.MetalConfig). Semua lapisan `nn.Linear` yang memenuhi syarat akan diganti dengan versi terkuantisasi.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, MetalConfig

quantization_config = MetalConfig(bits=4, group_size=64)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-1B",
    device_map="mps",
    quantization_config=quantization_config,
)

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B")
inputs = tokenizer("Apple Silicon is", return_tensors="pt").to("mps")
output = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

## Muat model yang sudah dikuantisasi

Jika checkpoint sudah berisi bobot terkuantisasi (`weight` sebagai uint32 yang dikemas, `scales`, `qbiases`), bobot tersebut dimuat secara langsung — tidak diperlukan kuantisasi ulang.

```python
from transformers import AutoModelForCausalLM, MetalConfig

model = AutoModelForCausalLM.from_pretrained(
    "your-org/model-metal-4bit",
    device_map="mps",
)
```

## Dequantisasi

Pada mesin tanpa MPS, checkpoint yang sudah dikuantisasi sebelumnya akan otomatis didekuantisasi kembali ke float agar model tetap dapat digunakan di CPU atau CUDA. Anda juga dapat memaksa perilaku ini secara eksplisit:

```python
from transformers import AutoModelForCausalLM, MetalConfig

config = MetalConfig(dequantize=True)
model = AutoModelForCausalLM.from_pretrained(
    "your-org/model-metal-4bit",
    quantization_config=config,
    device_map="cpu",
)
```

## The input "Exclude layers" is a short phrase, likely a heading or label.
"Exclude" translates to "Kecualikan" or "Hilangkan" or "Lewati". In the context of model architecture or configuration, "Kecualikan" (Exclude) is the most standard and professional term.
"Layers" translates to "Lapisan".
So, "Kecualikan lapisan".

Kecualikan lapisan

Beberapa lapisan (misalnya, `lm_head`) dapat dikecualikan dari kuantisasi melalui `modules_to_not_convert`:

```python
config = MetalConfig(bits=4, group_size=64, modules_to_not_convert=["lm_head"])
```

## Opsi konfigurasi

| Parameter | Default | Deskripsi |
|---|---|---|
| `bits` | `4` | Lebar bit untuk kuantisasi bobot (2, 4, atau 8) |
| `group_size` | `64` | Jumlah elemen per grup kuantisasi |
| `modules_to_not_convert` | `None` | Daftar nama modul yang akan dipertahankan dalam presisi penuh |
| `dequantize` | `False` | Paksa dequantization ke float (untuk perangkat non-MPS) |