Chương trình học Bài 204 trên tổng số 250 · Fine-tuning, về mặt khái niệm
Fine-tuning, về mặt khái niệm

Dung lượng bộ nhớ: 4-bit so với 16-bit

Đây là phép tính quyết định một mô hình có vừa phần cứng của bạn hay không, và vì sao các mô hình "đã lượng tử hóa" có mặt khắp nơi. Trọng số của một mô hình chỉ là các con số, và mỗi con số tốn vài byte tùy theo độ chính xác của nó. Dung lượng rất đơn giản:

bytes = params * bits_per_param / 8
# (8 bits per byte)

Huấn luyện và suy luận độ chính xác đầy đủ thường dùng số thực 16-bit (mỗi số 2 byte). Để chạy một mô hình trên laptop hay điện thoại, bạn lượng tử hóa nó: lưu mỗi trọng số bằng ít bit hơn. Lượng tử hóa 4-bit dùng một phần tư số byte, vì 4 bit là một phần tư của 16 bit. Cùng số tham số, một phần tư bộ nhớ.

Tính cho một mô hình 7 tỷ tham số:

16-bit: 7e9 * 16 / 8 = 1.4e10 bytes  ~= 13.04 GiB
 4-bit: 7e9 *  4 / 8 = 3.5e9  bytes  ~=  3.26 GiB   (exactly 1/4)

Đó là khác biệt giữa một mô hình cần một GPU lớn và một mô hình chạy được trên laptop. Đó chính là lý do một trợ lý chạy trên thiết bị (như cái vận hành gia sư AI của khóa học này) đi kèm một mô hình 4-bit: cái giá về chất lượng nhỏ, cái lợi về bộ nhớ và băng thông thì rất lớn. Đây cũng là lý do fine-tuning tiết kiệm tham số (LoRA) hấp dẫn, bạn chỉ phải lưu và gửi đi vài trọng số adapter nhỏ trên một mô hình nền bị đóng băng, có thể đã lượng tử hóa.

Những gì công thức đơn giản bỏ qua. Nó chỉ đếm trọng số, nên hãy coi nó là mức sàn. Các định dạng 4-bit thật còn lưu một hệ số tỷ lệ cho mỗi nhóm trọng số nhỏ, đưa chúng lên khoảng 4.5 tới 5 bit mỗi trọng số (một mô hình 7B gần 4 GiB hơn là 3.26). Chạy mô hình cần chỗ cho KV cache, thứ lớn lên theo độ dài ngữ cảnh. Và việc huấn luyện cần nhiều hơn trọng số rất nhiều: fine-tuning toàn phần với bộ tối ưu Adam giữ gradient và hai trạng thái bộ tối ưu cho mỗi trọng số, khoảng 16 byte mỗi tham số ở độ chính xác hỗn hợp, nên khoảng 100 GiB cho một mô hình 7B trước cả activation. Khoảng cách đó là lý do thật sự để LoRA và fine-tuning lượng tử hóa tồn tại.

Ta báo cáo dung lượng bằng GiB (gibibyte), chia số byte cho 1024 ** 3. Giữ nó là một số thực chính xác, đừng làm tròn, để các quan hệ dưới đây đúng tuyệt đối.

Xây hai hàm.

  • model_memory(params, bits_per_param) -> dung lượng tính bằng GiB dưới dạng float: params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, trong đó before_gb và after_gb là hai dung lượng và ratio là from_bits / to_bits (mô hình lượng tử hóa nhỏ hơn bao nhiêu lần).

Phép toán là thật và chấm được; việc huấn luyện GPU mà nó cho phép thì sandbox này không chạy được. Bấm Chạy để in dung lượng của một mô hình 7B ở vài độ chính xác.

Đến lượt bạn

Viết model_memory(params, bits_per_param) trả về dung lượng tính bằng GiB dưới dạng float (params * bits_per_param / 8 / (1024 ** 3)), và quantization_savings(params, from_bits, to_bits) trả về {"before_gb", "after_gb", "ratio"} trong đó hai dung lượng đến từ model_memory và ratio là from_bits / to_bits. Đừng làm tròn; giữ số thực chính xác để 4-bit ra đúng một phần tư của 16-bit.

Bạn thấy vấn đề gì trong bài học này? Hãy báo cáo nó · Hỏi về bài học này

Bài tập này sẽ sớm mở.

Hoàn thành bài học trước đó để mở khóa bài này. Toàn bộ khóa học là miễn phí, không cần tài khoản, và bạn có thể đọc bài học này ngay bây giờ.