# Lượng tử hóa mô hình

## Tích hợp `bitsandbytes`

Accelerate mang tính năng lượng tử hóa `bitsandbytes` đến mô hình của bạn. Bạn giờ có thể nạp bất kỳ mô hình pytorch nào ở 8-bit hoặc 4-bit chỉ với vài dòng mã.

Nếu bạn muốn sử dụng các mô hình Transformers với `bitsandbytes`, bạn nên làm theo [tài liệu](https://huggingface.co/docs/transformers/main_classes/quantization) này.

Để tìm hiểu thêm về cách lượng tử hóa `bitsandbytes` hoạt động, hãy xem các bài viết trên blog về [lượng tử hóa 8-bit](https://huggingface.co/blog/hf-bitsandbytes-integration) và [lượng tử hóa 4-bit](https://huggingface.co/blog/4bit-transformers-bitsandbytes).

### Yêu cầu tiên quyết
Bạn sẽ cần cài đặt các yêu cầu sau:

- Cài đặt thư viện `bitsandbytes`
```bash
pip install bitsandbytes
```
Đối với các thiết bị không phải cuda, bạn có thể tham khảo hướng dẫn cài đặt bitsandbytes [tại đây](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend).

- Cài đặt `accelerate` mới nhất từ mã nguồn
```bash
pip install git+https://github.com/huggingface/accelerate.git
```
- Cài đặt `minGPT` và `huggingface_hub` để chạy các ví dụ
```bash
git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
pip install huggingface_hub
```

### Cách hoạt động

Đầu tiên, chúng ta cần khởi tạo mô hình. Để tiết kiệm bộ nhớ, chúng ta có thể khởi tạo một mô hình rỗng bằng trình quản lý ngữ cảnh [init_empty_weights()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.init_empty_weights).

Hãy lấy mô hình GPT2 từ thư viện minGPT.
```py
from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    empty_model = GPT(model_config)
```

Sau đó, chúng ta cần lấy đường dẫn đến trọng số của mô hình của bạn. Đường dẫn có thể là tệp state_dict (ví dụ: "pytorch_model.bin") hoặc một thư mục chứa các checkpoint đã chia nhỏ.

```py
from huggingface_hub import snapshot_download
weights_location = snapshot_download(repo_id="marcsun13/gpt2-xl-linear-sharded")
```

Cuối cùng, bạn cần thiết lập cấu hình lượng tử hóa của mình bằng [BnbQuantizationConfig](/docs/accelerate/main/vi/package_reference/utilities#accelerate.utils.BnbQuantizationConfig).

Dưới đây là một ví dụ về lượng tử hóa 8-bit:
```py
from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_8bit=True, llm_int8_threshold = 6)
```

Dưới đây là một ví dụ về lượng tử hóa 4-bit:
```py
from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4")
```

Để lượng tử hóa mô hình trống của bạn với cấu hình đã chọn, bạn cần sử dụng [load_and_quantize_model()](/docs/accelerate/main/vi/package_reference/utilities#accelerate.utils.load_and_quantize_model).

```py
from accelerate.utils import load_and_quantize_model
quantized_model = load_and_quantize_model(empty_model, weights_location=weights_location, bnb_quantization_config=bnb_quantization_config)
```

### Lưu và nạp mô hình 8-bit

Bạn có thể lưu mô hình 8-bit của mình bằng accelerate bằng cách sử dụng [save_model()](/docs/accelerate/main/vi/package_reference/accelerator#accelerate.Accelerator.save_model).

```py
from accelerate import Accelerator
accelerate = Accelerator()
new_weights_location = "path/to/save_directory"
accelerate.save_model(quantized_model, new_weights_location)

quantized_model_from_saved = load_and_quantize_model(empty_model, weights_location=new_weights_location, bnb_quantization_config=bnb_quantization_config, device_map = "auto")
```

Lưu ý rằng việc xuất mô hình 4-bit hiện chưa được hỗ trợ.

### Tải các module xuống cpu và disk 

Bạn có thể offload một số module sang cpu/disk nếu không có đủ dung lượng trên GPU để lưu trữ toàn bộ model trên GPU của bạn. Tính năng này sử dụng big model inference bên dưới. Xem [tài liệu](https://huggingface.co/docs/accelerate/usage_guides/big_modeling) này để biết thêm chi tiết.

Đối với lượng tử hóa 8-bit, các module được chọn sẽ được chuyển đổi sang độ chính xác 8-bit.

Đối với lượng tử hóa 4-bit, các module được chọn sẽ được giữ ở `torch_dtype` mà người dùng đã truyền vào `BnbQuantizationConfig`. Chúng tôi sẽ thêm hỗ trợ để chuyển đổi các module bị offload này sang 4-bit khi việc phân loại chuỗi 4-bit trở nên khả thi.

 Bạn chỉ cần truyền một `device_map` tùy chỉnh để offload các module sang cpu/disk. Các module được offload sẽ được dispatch lên GPU khi cần. Dưới đây là một ví dụ:

```py
device_map = {
    "transformer.wte": 0,
    "transformer.wpe": 0,
    "transformer.drop": 0,
    "transformer.h": "cpu",
    "transformer.ln_f": "disk",
    "lm_head": "disk",
}
```
### Tinh chỉnh một mô hình đã lượng tử hóa

Không thể thực hiện huấn luyện thuần 8bit hoặc 4bit trên các mô hình này. Tuy nhiên, bạn có thể huấn luyện các mô hình này bằng cách tận dụng các phương pháp tinh chỉnh hiệu quả tham số (PEFT) và ví dụ huấn luyện các adapter trên chúng. Hãy xem thư viện [peft](https://github.com/huggingface/peft) để biết thêm chi tiết.

Hiện tại, bạn không thể thêm adapter lên trên bất kỳ model nào đã được lượng tử hóa. Tuy nhiên, với sự hỗ trợ chính thức của adapter cho các model Transformers, bạn có thể fine-tune các model đã được lượng tử hóa. Nếu bạn muốn fine-tune một model Transformers, hãy làm theo [tài liệu](https://huggingface.co/docs/transformers/main_classes/quantization) này. Xem [demo](https://colab.research.google.com/drive/1VoYNfYDKcKRQRor98Zbf2-9VQTtGJ24k?usp=sharing) này để tìm hiểu cách fine-tune một model Transformers 4-bit.

Lưu ý rằng bạn không cần truyền `device_map` khi tải mô hình để huấn luyện. Nó sẽ tự động tải mô hình của bạn lên GPU. Vui lòng lưu ý rằng `device_map=auto` chỉ nên được sử dụng cho suy luận.

### Ví dụ demo - chạy GPT2 1.5b trên Google Colab

Xem [demo](https://colab.research.google.com/drive/1T1pOgewAWVpR9gKpaEWw4orOrzPFb3yM?usp=sharing) trên Google Colab để chạy các mô hình đã lượng tử hóa trên mô hình GPT2. Checkpoint của mô hình GPT2-1.5B ở định dạng FP32, sử dụng 6GB bộ nhớ. Sau khi lượng tử hóa, nó chỉ dùng 1.6GB với các module 8-bit và 1.2GB với các module 4-bit.