Cách huấn luyện một LLM với PyTorch

Các Mô hình Ngôn ngữ Lớn (LLM) là thành phần chủ chốt trong các ứng dụng trí tuệ nhân tạo hiện đại, đặc biệt là xử lý ngôn ngữ tự nhiên. Chúng có khả năng xử lý và hiểu ngôn ngữ con người một cách hiệu quả, với các ứng dụng từ trợ lý ảo và dịch máy đến tóm tắt văn bản và hỏi đáp.

Những thư viện như LangChain hỗ trợ triển khai các ứng dụng AI đầu-cuối như đã nêu. Bài hướng dẫn Giới thiệu LangChain cho Kỹ thuật Dữ liệu & Ứng dụng Dữ liệu của chúng tôi cung cấp cái nhìn tổng quan về những gì bạn có thể làm với LangChain, bao gồm các vấn đề LangChain giải quyết cùng ví dụ về các trường hợp sử dụng dữ liệu.

Bài viết này sẽ giải thích toàn bộ quy trình huấn luyện một mô hình ngôn ngữ lớn, từ thiết lập không gian làm việc đến triển khai cuối cùng bằng Pytorch 2.0.1, một khung học sâu linh hoạt và động, cho phép triển khai mô hình dễ dàng và rõ ràng.

Yêu cầu tiên quyết

Để tận dụng tối đa nội dung này, bạn cần thoải mái với lập trình Python, hiểu cơ bản về học sâu và transformers, và quen thuộc với khung Pytorch. Toàn bộ mã nguồn sẽ có trên GitHub.

Trước khi đi vào phần triển khai cốt lõi, chúng ta cần cài đặt và import các thư viện liên quan. Cũng cần lưu ý rằng script huấn luyện được lấy cảm hứng từ kho lưu trữ này của Hugging Face.

Cài đặt thư viện

Quy trình cài đặt được nêu chi tiết dưới đây:

Trước hết, chúng ta dùng câu lệnh %%bash để chạy các lệnh cài đặt trong một ô duy nhất như một lệnh bash trong Jupyter Notebook.

• Trl: dùng để huấn luyện các mô hình ngôn ngữ transformer bằng học tăng cường.
• Peft sử dụng các phương pháp tinh chỉnh hiệu quả tham số (PEFT) để cho phép thích nghi hiệu quả với mô hình đã được huấn luyện trước.
• Torch: một thư viện máy học mã nguồn mở được sử dụng rộng rãi.
• Datasets: hỗ trợ tải xuống và nạp nhiều bộ dữ liệu máy học phổ biến.

Transformers: một thư viện do Hugging Face phát triển, đi kèm hàng nghìn mô hình đã huấn luyện trước cho nhiều tác vụ văn bản như phân loại, tóm tắt và dịch.

%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers

Bây giờ, có thể import các mô-đun như sau:

import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments

Tải và chuẩn bị dữ liệu

Bộ dữ liệu alpaca, được cung cấp miễn phí trên Hugging Face, sẽ được dùng để minh họa. Bộ dữ liệu có ba cột chính: instructions, input và output. Các cột này được kết hợp để tạo ra cột văn bản cuối cùng.

Cách tải bộ dữ liệu được nêu dưới đây bằng cách cung cấp tên bộ dữ liệu quan tâm, đó là tatsu-lab/alpaca:

train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)

Chúng ta có thể thấy dữ liệu trả về là một từ điển gồm hai khóa:

• Features: chứa các cột chính của dữ liệu
• Num_rows: tương ứng với tổng số hàng trong dữ liệu

Cấu trúc của train_dataset

Năm hàng đầu tiên có thể được hiển thị với hướng dẫn sau. Trước tiên, chuyển từ điển thành pandas dataframe, sau đó hiển thị các hàng.

pandas_format = train_dataset.to_pandas()
display(pandas_format.head())

Năm hàng đầu tiên của train_dataset

Để trực quan tốt hơn, hãy in thông tin về ba hàng đầu tiên, nhưng trước đó cần cài đặt thư viện textwrap để đặt số từ tối đa mỗi dòng là 50. Lệnh in đầu tiên phân tách mỗi khối bằng 15 dấu gạch ngang.

import textwrap

for index in range(3):
   print("---"*15)
   print("Instruction:        
       {}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],    
       width=50)))
   print("Output:  
       {}".format(textwrap.fill(pandas_format.iloc[index]["output"],  
       width=50)))
   print("Text: 
       {}".format(textwrap.fill(pandas_format.iloc[index]["text"],  
       width=50)))

Chi tiết ba hàng đầu tiên

Huấn luyện mô hình

Trước khi tiến hành huấn luyện mô hình, chúng ta cần thiết lập một số điều kiện tiên quyết:

• Mô hình đã huấn luyện trước: Chúng ta sẽ sử dụng mô hình đã huấn luyện trước Salesforce/xgen-7b-8k-base, có trên Hugging Face. Salesforce đã huấn luyện dòng LLM 7B có tên XGen-7B với attention đặc dày tiêu chuẩn trên chuỗi lên đến 8K cho tối đa 1,5T token.
• Tokenizer: Cần thiết cho nhiệm vụ tokenization trên dữ liệu huấn luyện. Mã để tải mô hình và tokenizer đã huấn luyện trước như sau:

pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)

Cấu hình huấn luyện

Việc huấn luyện yêu cầu một số đối số và cấu hình; hai đối tượng cấu hình quan trọng được định nghĩa dưới đây, một thể hiện của TrainingArguments, một thể hiện của mô hình LoraConfig, và cuối cùng là mô hình SFTTrainer.

TrainingArguments

Dùng để xác định các tham số cho việc huấn luyện mô hình.

Trong kịch bản cụ thể này, chúng ta bắt đầu bằng cách xác định nơi lưu mô hình đã huấn luyện bằng thuộc tính output_dir trước khi thiết lập các siêu tham số bổ sung, như phương pháp tối ưu hóa, learning rate, số epoch, và hơn nữa.

model_training_args = TrainingArguments(
       output_dir="xgen-7b-8k-base-fine-tuned",
       per_device_train_batch_size=4,
       optim="adamw_torch",
       logging_steps=80,
       learning_rate=2e-4,
       warmup_ratio=0.1,
       lr_scheduler_type="linear",
       num_train_epochs=1,
       save_strategy="epoch"
   )

LoRAConfig

Các đối số chính dùng trong kịch bản này gồm hạng của ma trận biến đổi hạng thấp trong LoRA, được đặt là 16. Sau đó, hệ số tỷ lệ cho các tham số bổ sung trong LoRA được đặt là 32.

Ngoài ra, tỷ lệ dropout là 0,05, nghĩa là 5% đơn vị đầu vào sẽ bị bỏ qua trong quá trình huấn luyện. Cuối cùng, vì chúng ta đang xử lý mô hình hóa ngôn ngữ nhân quả, nên tác vụ được khởi tạo với thuộc tính CAUSAL_LM.

SFTTrainer

Mục tiêu là huấn luyện mô hình bằng dữ liệu huấn luyện, tokenizer và thông tin bổ sung như các mô hình ở trên.

Vì chúng ta dùng trường text từ dữ liệu huấn luyện, nên cần xem phân phối để hỗ trợ đặt số lượng token tối đa trong một chuỗi.

import matplotlib.pyplot as plt


pandas_format['text_length'] = pandas_format['text'].apply(len)


plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()

Phân phối độ dài của cột văn bản

Dựa trên quan sát trên, có thể thấy phần lớn văn bản có độ dài trong khoảng 0 đến 1000. Ngoài ra, như dưới đây, chỉ 4,5% tài liệu văn bản có độ dài lớn hơn 1024.

mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100


print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")

Sau đó, chúng ta đặt số token tối đa trong chuỗi là 1024 để mọi văn bản dài hơn sẽ bị cắt bớt.

SFT_trainer = SFTTrainer(
       model=model,
       train_dataset=train_dataset,
       dataset_text_field="text",
       max_seq_length=1024,
       tokenizer=tokenizer,
       args=model_training_args,
       packing=True,
       peft_config=lora_peft_config,
   )

Thực thi huấn luyện

Khi đã có đủ điều kiện tiên quyết, chúng ta có thể chạy quá trình huấn luyện mô hình như sau:

tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()

Cần lưu ý rằng quá trình huấn luyện này được thực hiện trên môi trường đám mây với GPU, giúp toàn bộ quá trình nhanh hơn. Tuy nhiên, huấn luyện trên máy tính cá nhân sẽ cần nhiều thời gian hơn để hoàn thành.

Bài blog của chúng tôi, Ưu và nhược điểm của việc dùng LLM trên đám mây so với chạy LLM cục bộ, cung cấp các cân nhắc then chốt để chọn chiến lược triển khai tối ưu cho LLM.

Hãy cùng hiểu những gì đang xảy ra trong đoạn mã trên:

• tokenizer.pad_token = tokenizer.eos_token: Đặt token đệm giống với token kết thúc câu.
• model.resize_token_embeddings(len(tokenizer)): Thay đổi kích thước lớp embedding token của mô hình để khớp với độ dài từ vựng của tokenizer.
• model = prepare_model_for_int8_training(model): Chuẩn bị mô hình cho huấn luyện với độ chính xác INT8, có thể bao gồm lượng tử hóa.
• model = get_peft_model(model, lora_peft_config): Điều chỉnh mô hình theo cấu hình PEFT.
• training_args = model_training_args: Gán các đối số huấn luyện đã định trước cho training_args.
• trainer = SFT_trainer: Gán thể hiện SFTTrainer cho biến trainer.
• trainer.train(): Kích hoạt quá trình huấn luyện mô hình theo các thông số đã cung cấp.

Kết luận

Bài viết đã cung cấp hướng dẫn rõ ràng về cách huấn luyện một mô hình ngôn ngữ lớn bằng PyTorch. Bắt đầu từ chuẩn bị bộ dữ liệu, bài viết đi qua các bước chuẩn bị điều kiện tiên quyết, thiết lập trainer và cuối cùng là chạy quá trình huấn luyện.

Mặc dù sử dụng một bộ dữ liệu và mô hình đã huấn luyện trước cụ thể, quy trình nhìn chung sẽ tương tự với các lựa chọn tương thích khác. Giờ bạn đã hiểu cách huấn luyện một LLM, bạn có thể tận dụng kiến thức này để huấn luyện các mô hình tinh vi khác cho nhiều tác vụ NLP.

Xem hướng dẫn của chúng tôi về cách xây dựng ứng dụng LLM với LangChain để khám phá sâu hơn sức mạnh của các mô hình ngôn ngữ lớn. Hoặc, nếu bạn vẫn cần tìm hiểu các khái niệm về mô hình ngôn ngữ lớn, hãy xem khóa học của chúng tôi để tiếp tục học tập.