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 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 và lượng tử hóa 4-bit.

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

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.

• Cài đặt accelerate mới nhất từ mã nguồn

pip install git+https://github.com/huggingface/accelerate.git

• Cài đặt minGPT và huggingface_hub để chạy các ví dụ

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().

Hãy lấy mô hình GPT2 từ thư viện minGPT.

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ỏ.

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.

Dưới đây là một ví dụ về lượng tử hóa 8-bit:

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:

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().

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().

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 các 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 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ụ:

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 để biết thêm chi tiết.

Hiện tại, bạn không thể thêm adapter lê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 này. Xem demo 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 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.