Thực chiến Fine-Tuning mô hình ngôn ngữ lớn Bloom-560m

Nội dung

1. Giới thiệu

1. 1 Fine-Tuning là gì

Fine-Tuning là quá trình điều chỉnh và tối ưu hóa một mô hình ngôn ngữ lớn (Large Language Model – LLM) đã được huấn luyện trước (Pre-trained). Quá trình này tập trung vào việc huấn luyện thêm mô hình trên một tập dữ liệu đặc thù hoặc mục tiêu cụ thể nhằm cải thiện hiệu suất trong những ứng dụng cụ thể, đồng thời giảm thiểu chi phí và thời gian so với việc xây dựng mô hình từ đầu.

1.2. Tầm quan trọng của Fine-Tuning

Tăng cường hiệu suất cho mục tiêu cụ thể: LLM sau quá trình Pre-training thường mang tính chất tổng quát. Fine-Tuning giúp tinh chỉnh mô hình để đạt hiệu quả cao hơn trong các nhiệm vụ cụ thể, chẳng hạn như phân tích cảm xúc, trả lời câu hỏi, hoặc xử lý văn bản chuyên ngành.
Tiết kiệm tài nguyên: Thay vì huấn luyện toàn bộ mô hình từ đầu, Fine-Tuning tận dụng mô hình Pre-trained, giúp tiết kiệm tài nguyên tính toán và thời gian.
Tùy chỉnh cho ứng dụng thực tiễn: Fine-Tuning giúp các tổ chức và doanh nghiệp tạo ra mô hình phù hợp với dữ liệu và yêu cầu thực tế của họ, nâng cao giá trị sử dụng.

1.3. Mục tiêu của quá trình Fine-Tuning

Chuyên biệt hóa mô hình: Tối ưu hóa khả năng của mô hình trên các tập dữ liệu cụ thể.
Cải thiện độ chính xác: Tăng khả năng đưa ra các kết quả phù hợp hơn với ngữ cảnh và mục tiêu cụ thể.
Giảm thiểu lỗi sai: Đặc biệt trong các lĩnh vực yêu cầu độ chính xác cao như y tế, pháp luật hoặc tài chính.
Hỗ trợ đa dạng ngôn ngữ hoặc lĩnh vực: Fine-Tuning giúp mở rộng khả năng sử dụng của mô hình trên nhiều ngôn ngữ hoặc các lĩnh vực chuyên ngành.

1.4. Sự khác biệt giữa Pre-training và Fine-Tuning

Mục tiêu:
- Pre-training: Tập trung vào việc học các đặc trưng cơ bản của ngôn ngữ từ tập dữ liệu lớn, không có định hướng cụ thể.
- Fine-Tuning: Điều chỉnh mô hình với mục tiêu cụ thể trên tập dữ liệu đặc thù.
Dữ liệu:
- Pre-training: Sử dụng tập dữ liệu tổng quát và lớn để mô hình học ngữ pháp, cú pháp và ngữ nghĩa.
- Fine-Tuning: Dữ liệu thường nhỏ hơn và chuyên biệt hơn, liên quan trực tiếp đến bài toán cần giải quyết.
Chi phí:
- Pre-training: Đòi hỏi nhiều tài nguyên tính toán và thời gian.
- Fine-Tuning: Chi phí thấp hơn nhờ tận dụng mô hình đã được Pre-trained.
Ứng dụng:
- Pre-training: Tạo nền tảng cho các ứng dụng đa dạng.
- Fine-Tuning: Cụ thể hóa khả năng của mô hình để phù hợp với từng ứng dụng riêng biệt

2. Lựa chọn mô hình gốc

Quá trình lựa chọn mô hình gốc (“base model”) đóng vai trò quan trọng trong việc Fine-Tuning, đặc biệt khi mục tiêu là tối ưu hóa hiệu suất trong các tác vụ cụ thể. Việc lựa chọn đúng mô hình có thể giúm tiết kiệm đáng kể tài nguyên, đạt hiệu quả cao hơn, và đáp ứng tốt nhất nhu cầu thực tiễn.

2.1. Tiêu chí lựa chọn mô hình gốc

Việc chọn mô hình phù hợp phụ thuộc vào nhiều yếu tố, bao gồm:

Mỗi mô hình ngôn ngữ lớn đã Pre-trained thường có những điểm mạnh để thực hiện tốt một số nhóm tác vụ nhất định. Việc đánh giá hiệu quả ban đầu của mô hình trên tập dữ liệu cụ thể có thể cung cấp những thông tin quan trọng.
Quy mô (đọc theo số tham số hoặc đánh giá theo tài nguyên cần thiết) phải phù hợp với khả năng tính toán của doanh nghiệp hoặc người dùng. Các mô hình nhỏ hơn thường yêu cầu ít tài nguyên hơn, nhưng lại có giới hạn trong xử lý những tác vụ phức tạp.
Một số mô hình được thiết kế để Fine-Tuning đơn giản và hiệu quả hơn nhờ các công nghệ như “LoRA” (Low-Rank Adaptation) hoặc Adapter Layers.

2.2. Lựa chọn mô hình trong bài thực hành

Trong bài thực hành này, tôi lựa chọn mô hình Bloom-560m (Mô hình Bloom bản 560 triệu tham số) để phù hợp với bài toán thực hành demo (các phiên bản khác chúng ta làm tương tự).

Mô hình BLOOM (BigScience Large Open-science Open-access Multilingual Language Model) là một mô hình ngôn ngữ lớn (LLM) được phát triển bởi dự án BigScience, một sáng kiến hợp tác quốc tế với mục tiêu tạo ra một mô hình ngôn ngữ mã nguồn mở và minh bạch.

Một số đặc điểm chính của BLOOM:

Đa ngôn ngữ:

Được huấn luyện trên 46 ngôn ngữ khác nhau
Bao gồm cả các ngôn ngữ có ít tài nguyên như tiếng Việt
Hỗ trợ 13 ngôn ngữ lập trình

Quy mô và kiến trúc:

Kích thước từ 560 triệu đến 176 tỷ tham số
Sử dụng kiến trúc Transformer tương tự GPT
Được huấn luyện trên một lượng lớn dữ liệu đa dạng

Mã nguồn mở:

Toàn bộ mã nguồn, trọng số và quá trình huấn luyện được công khai
Nhằm tăng tính minh bạch và khả năng nghiên cứu
Khuyến khích sự hợp tác và phát triển cộng đồng

3. Chuẩn bị dữ liệu cho Fine-Tuning

Tại sao chuẩn bị dữ liệu lại quan trọng?

Hình dung việc chuẩn bị dữ liệu giống như xây dựng nền móng cho một tòa nhà. Một nền móng yếu kém sẽ dẫn đến toàn bộ công trình bị lung lay. Tương tự, dữ liệu kém chất lượng sẽ làm giảm đáng kể hiệu suất của mô hình AI của bạn.

Việc thu thập dữ liệu không phải chỉ đơn giản là tải về hàng loạt. Bạn cần những nguồn dữ liệu:

Chính xác và đáng tin cậy
Phù hợp với mục tiêu cụ thể của dự án
Đại diện cho các tình huống thực tế bạn muốn mô hình giải quyết

Các nguồn tốt nhất thường đến từ:

Tài liệu học thuật từ các trường đại học.
Báo cáo nghiên cứu khoa học
Các nguồn dữ liệu được gán nhãn bởi chuyên gia

Làm sạch dữ liệu: loại bỏ “rác” thông tin

Không phải tất cả dữ liệu đều có giá trị. Quá trình làm sạch là một nghệ thuật:

Loại bỏ các bản ghi trùng lặp
Wipe out dữ liệu nhiễu
Chuẩn hóa định dạng văn bản
Kiểm tra và sửa lỗi chính tả

Hãy nghĩ về việc này như việc chọn lọc những viên ngọc quý từ một đống đá vụn.

Định dạng dữ liệu: ngôn ngữ chung của AI

Mô hình AI cần một “ngôn ngữ” để hiểu. Với fine-tuning, chúng ta thường sử dụng định dạng JSON đơn giản nhưng mạnh mẽ:

# Định dạng dữ liệu cho fine-tuning
data = {
    "input": "Câu hỏi hoặc văn bản đầu vào",
    "output": "Câu trả lời hoặc kết quả mong muốn",
    "context": "Thông tin bổ sung (nếu có)"
}

Trong bài thực hành này, tôi sử dụng bộ dữ liệu aicandy_llm_dataset_msbagtmv.jsonl bao gồm nhiều bộ “question” – “answer” ví dụ như phía dưới:

{"question": "Trí tuệ nhân tạo (AI) là gì?", "answer": "AI là khả năng mô phỏng trí thông minh con người của máy móc."}
{"question": "AI khác gì so với học máy (ML)?", "answer": "AI là khái niệm bao quát, còn ML là một nhánh cụ thể của AI."}
{"question": "Deep Learning (DL) là gì?", "answer": "DL là một phần của ML sử dụng mạng nơ-ron sâu."}
{"question": "Học máy có mấy phương pháp chính?", "answer": "Có 4 phương pháp: giám sát, không giám sát, bán giám sát và tăng cường."}
{"question": "Thuật toán hồi quy tuyến tính dùng để làm gì?", "answer": "Dùng để dự đoán giá trị liên tục."}
{"question": "K-means clustering là gì?", "answer": "Là thuật toán phân cụm dữ liệu thành các nhóm."}

Bộ dataset có thể download miễn phí tại đây

4. Chương trình thực hiện

4.1. Download pretrain model

Bloom-560m được download miễn phí tại huggingface

Sau khi tải về, lưu các tệp model tại “AIcandy_LLM_Finetuning_bloom_560m_iehimqko/models/bloom-560m”

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/models/bloom-560m# tree
.
├── config.json
├── model_bloom-560m.safetensors
├── pytorch_model.bin
├── tokenizer_config.json
└── tokenizer.json

0 directories, 5 files
root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/models/bloom-560m#

4.2. Bộ dữ liệu dataset

Tải bộ dữ liệu và lưu tại “AIcandy_LLM_Finetuning_bloom_560m_iehimqko/datasets”

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/datasets# tree
.
└── aicandy_llm_dataset_msbagtmv.jsonl

0 directories, 1 file
root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/datasets#

4.3. Phân tích chương trình

Bước 1: Lựa chọn device là “CPU/GPU”

computation_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

Bước 2: Tải model và Tokenizer

Tokenizer là một thành phần quan trọng trong xử lý ngôn ngữ tự nhiên (NLP) và là công cụ được sử dụng để chuyển đổi văn bản thành các đơn vị nhỏ hơn gọi là token. Chia nhỏ văn bản: Tokenizer chia một đoạn văn bản thành các phần nhỏ như từ, subword, hoặc ký tự tùy thuộc vào loại tokenizer. Tokenizer có thể thực hiện các bước như loại bỏ khoảng trắng, chuyển thành chữ thường, hoặc xử lý các ký tự đặc biệt.

# Create tokenizer
model_tokenizer = AutoTokenizer.from_pretrained(original_model_path)

# Load model
language_model = AutoModelForCausalLM.from_pretrained(original_model_path, trust_remote_code=True)
language_model = language_model.to(computation_device)

AutoTokenizer là một lớp tự động giúp tải một tokenizer phù hợp với mô hình bạn đang sử dụng.

from_pretrained() Đây là phương thức dùng để tải một tokenizer đã được huấn luyện từ một đường dẫn hoặc tên mô hình có sẵn. Khi gọi hàm này, transformers sẽ kiểm tra và tải tokenizer tương ứng từ thư viện Hugging Face hoặc từ thư mục được chỉ định.

Bước 3: Tùy chỉnh Gradient checkpointing và K-bit training

Gradient checkpointing: là kỹ thuật tối ưu bộ nhớ (RAM/GPU memory), đặc biệt trong quá trình huấn luyện hoặc fine-tuning các mô hình lớn. Thay vì lưu trữ tất cả các gradient (đạo hàm) trong quá trình forward pass, gradient checkpointing chỉ lưu lại một số điểm (checkpoints) nhất định. Khi cần tính gradient cho backward pass, các phần còn lại sẽ được tính toán lại thay vì lưu trữ sẵn.

Khi nào nên sử dụng Gradient checkpointing? Khi bạn huấn luyện mô hình lớn và gặp vấn đề về thiếu RAM/GPU memory. Kỹ thuật này giúp giảm bộ nhớ sử dụng nhưng đổi lại sẽ tăng thời gian huấn luyện vì một phần của forward pass phải được tính lại trong backward pass.

K-bit Training: là kỹ thuật giảm độ chính xác của các tham số mô hình từ 32-bit (FP32) xuống k-bit như 8-bit (INT8) hoặc 4-bit để giảm kích thước mô hình và tối ưu tài nguyên tính toán. hay vì lưu trữ tất cả trọng số mô hình dưới dạng 32-bit, bạn sử dụng 8-bit hoặc 4-bit, tiết kiệm đáng kể bộ nhớ GPU/RAM. Khi trọng số giảm kích thước, tốc độ truyền dữ liệu và tính toán sẽ nhanh hơn.

# Gradient checkpointing (only use if RAM reduction is needed)
language_model.gradient_checkpointing_enable()

# Prepare model for k-bit training
language_model = prepare_model_for_kbit_training(language_model)

Bước 4: tối ưu hóa quá trình fine-tuning mô hình lớn

Sử dụng kỹ thuật LORA. LoRA là kỹ thuật giúp giảm số lượng tham số cần tinh chỉnh trong quá trình fine-tuning mô hình lớn (Large Language Models – LLM) như GPT, LLaMA, … Thay vì tinh chỉnh toàn bộ trọng số của mô hình, LoRA chỉ học một ma trận low-rank bổ sung trong các lớp (layers) trọng số gốc. Điều này giúp Giảm số lượng tham số huấn luyện và tiết kiệm bộ nhớ đồng thời tăng tốc huấn luyện.

# LoRA configuration
lora_config = LoraConfig(
    r=8,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
language_model = get_peft_model(language_model, lora_config)

r=8: Đây là rank của ma trận low-rank. Rank thấp làm giảm độ phức tạp, nhưng nếu rank quá thấp có thể ảnh hưởng tới chất lượng fine-tuning.

lora_alpha=32: Alpha là hệ số scaling cho ma trận low-rank. lora_alpha càng lớn thì mô hình càng “phụ thuộc” nhiều vào trọng số LoRA.

lora_dropout=0.05: Áp dụng dropout lên các trọng số LoRA trong quá trình huấn luyện. Điều này giúp tránh overfitting trên dữ liệu huấn luyện.

task_type=”CAUSAL_LM”: Task type chỉ định loại bài toán fine-tuning. “CAUSAL_LM“: Bài toán mô hình ngôn ngữ nhân quả (Causal Language Modeling) như GPT, trong đó mô hình dự đoán token tiếp theo dựa trên các token trước đó.

get_peft_model: Hàm này thêm các tham số LoRA vào mô hình gốc (language_model). Kết quả là mô hình có thể fine-tune với số lượng tham số rất nhỏ thay vì tinh chỉnh toàn bộ mô hình.

Bước 5: Load dataset

# Load data
training_dataset = load_dataset("json", data_files="datasets/*.json", split='train')
training_dataset = training_dataset.map(
    lambda samples: {
        "input_text": "Human: " + samples["question"] + " Assistant: " + samples["answer"]
    },
    remove_columns=['question', 'answer']
)
training_dataset = training_dataset.map(lambda examples: model_tokenizer(examples["input_text"], padding="max_length", truncation=True, max_length=512), batched=True)

Dựa vào cấu trúc dữ liệu đầu vào trong tệp json, dòng lệnh trên sẽ tải dữ liệu, tạo cột dữ liệu “input_text” chứa các ‘question‘ và ‘answer‘.

Hàm map được sử dụng để áp dụng một hàm xử lý lên từng mẫu dữ liệu trong dataset.

Hàm lambda định nghĩa cách kết hợp các cột dữ liệu.

remove_columns=[‘question’, ‘answer’] thực hiện Xóa các cột “question” và “answer” sau khi đã tạo cột mới “input_text”.

Bước 6: Khởi tạo trainer

Tạo class trainer với các tham số cấu hình phục vụ việc train dữ liệu mới. Trainer là lớp hỗ trợ mạnh mẽ trong Hugging Face, dùng để huấn luyện và đánh giá các mô hình. Nó giúp đơn giản hóa việc quản lý quá trình huấn luyện thông qua tích hợp các thành phần như mô hình, bộ dữ liệu, tham số huấn luyện, và chiến lược lưu trữ/logging.

model_trainer = transformers.Trainer(
    model=language_model,
    train_dataset=training_dataset, 
    args=transformers.TrainingArguments(...)
)

Cấu hình các tham số:
per_device_train_batch_size=2 # Kích thước batch trên mỗi GPU/CPU
gradient_accumulation_steps=8 # Tích lũy gradient 8 bước trước khi cập nhật
warmup_steps=2: Số bước ban đầu tăng dần tốc độ học (learning_rate) từ 0 đến giá trị tối đa.
max_steps=10: Số bước huấn luyện tối đa. Sau bước này, huấn luyện sẽ dừng lại.
learning_rate=2e-4: Tốc độ học ban đầu cho bộ tối ưu hóa (AdamW trong trường hợp này).
logging_steps=1: Tần suất ghi log (mỗi bước). Log giúp theo dõi thông tin trong quá trình huấn luyện.
output_dir=”outputs”: Thư mục lưu trữ kết quả huấn luyện như mô hình checkpoint, log, v.v.
optim=”adamw_hf”: Bộ tối ưu hóa sử dụng thuật toán AdamW được tinh chỉnh từ Hugging Face.

Sau khi cấu hình xong class trainer, để thực hiện train chỉ cần sử dụng lệnh:

training_result = model_trainer.train()

Và sau khi train xong cần lưu lại model đã được train

# Adapter model save path
adapter_model_path = "models/adapter-model"

# Save model after fine-tuning
model_trainer.save_model(adapter_model_path)

Bước 7: Merger model

Việc hợp nhất (merge) mô hình gốc và mô hình fine-tuning là cần thiết để đảm bảo hiệu quả và tính toàn vẹn của mô hình. Quá trình fine-tuning chỉ lưu các thay đổi so với mô hình gốc để tiết kiệm bộ nhớ và tăng hiệu thời gian train. Nói một cách dễ hiểu là model gốc chứa tổng quát đặc trưng của đối tượng đã train còn model fine-tuning chứa các đặc điểm chi tiết riêng theo dữ liệu mới. Vì thế để tạo ra mô hình đầy đủ cần có quá trình merge model gốc và model fine-tuining để đảm bảo tương thích và hiệu năng.

merged_model = PeftModel.from_pretrained(base_language_model, adapter_model_path).to(computation_device)
merged_model = merged_model.merge_and_unload()

# Save merged model
merged_model_path = "models/merged-model"
merged_model.save_pretrained(merged_model_path)
model_tokenizer.save_pretrained(merged_model_path)

Bước 8: Train
Quá trình train sẽ có log như phía dưới:

root@aicandy:/data/new/work/study/AIcandy_LLM_Finetuning_bloom_560m_iehimqko# python AIcandy_LLM_Finetuing_bloom_560m_icsgpvrs.py
{'loss': 13.3404, 'grad_norm': 92.74317932128906, 'learning_rate': 0.0001, 'epoch': 0.07}
{'loss': 13.3606, 'grad_norm': 91.90301513671875, 'learning_rate': 0.0002, 'epoch': 0.15}
{'loss': 13.0523, 'grad_norm': 85.71514129638672, 'learning_rate': 0.000175, 'epoch': 0.22}
{'loss': 12.4526, 'grad_norm': 85.54156494140625, 'learning_rate': 0.00015000000000000001, 'epoch': 0.3}
{'loss': 11.969, 'grad_norm': 87.21179962158203, 'learning_rate': 0.000125, 'epoch': 0.37}
{'loss': 11.5837, 'grad_norm': 90.1021499633789, 'learning_rate': 0.0001, 'epoch': 0.44}
{'loss': 11.1974, 'grad_norm': 96.4682388305664, 'learning_rate': 7.500000000000001e-05, 'epoch': 0.52}
{'loss': 10.9516, 'grad_norm': 105.14913177490234, 'learning_rate': 5e-05, 'epoch': 0.59}
{'loss': 10.7243, 'grad_norm': 112.90843963623047, 'learning_rate': 2.5e-05, 'epoch': 0.67}
{'loss': 10.5917, 'grad_norm': 107.06537628173828, 'learning_rate': 0.0, 'epoch': 0.74}
{'train_runtime': 26.3522, 'train_samples_per_second': 6.072, 'train_steps_per_second': 0.379, 'train_loss': 11.92236270904541, 'epoch': 0.74}
100%|███████████████████████████████████████████████████████████████| 10/10 [00:26<00:00,  2.64s/it]
Training completed successfully!
Final training loss: 11.92236270904541

Qua log trên, loss khá cao nguyên nhân là bộ dữ liệu của chúng ta đang rất ít, số bước train cũng đang nhỏ. Các model thương mại thực tế có bộ dữ liệu train cực lớn và có số lượng tham số lớn (Bloom-1B là 1 tỷ tham số, Bloom-7B là 7 tỷ tham số, GPT-3 là 175 tỷ tham số …).
Sau khi training kết thúc và merge model thành công, chúng ta có được bộ model như sau:

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/models/merged-model# tree
.
├── config.json
├── generation_config.json
├── model.safetensors
├── special_tokens_map.json
├── tokenizer_config.json
└── tokenizer.json

0 directories, 6 files
root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko/models/merged-model#

5. Kết quả

Sau khi fine-tuning và merge model, hãy trải nghiệm kết quả bằng việc “hỏi” lại nó một số câu hỏi để xem mức độ cải thiện.

Bước 1: Tải model

merged_model_path = "models/merged-model"
test_model = AutoModelForCausalLM.from_pretrained(merged_model_path).to(computation_device)
test_tokenizer = AutoTokenizer.from_pretrained(merged_model_path)

Bước 2: Tạo prompt để “hỏi”

test_prompt = "Human: Tăng tốc huấn luyện AI bằng cách nào? Assistant: "
input_sequence = test_tokenizer.encode(test_prompt, return_tensors='pt').to(computation_device)

Bước 3: Cấu hình tham số đầu ra

generated_outputs = test_model.generate(
    input_sequence,
    pad_token_id=50256,
    do_sample=True,
    max_length=100,
    temperature=0.8,
    early_stopping=False,
    no_repeat_ngram_size=2,
    num_return_sequences=1
)

Phương thức .generate() được sử dụng để tạo văn bản từ một chuỗi đầu vào (input_sequence).

input_sequence: Chuỗi đầu vào để bắt đầu quá trình tạo văn bản.

pad_token_id=50256: Token ID được sử dụng để điền vào các vị trí trống trong batch (padding). Việc này giúp mô hình biết cách bỏ qua các vị trí trống trong batch khi sinh văn bản.

do_sample=True: Kích hoạt chế độ sampling để mô hình chọn token tiếp theo dựa trên xác suất phân phối (không phải chọn token có xác suất cao nhất).

max_length=100: Giới hạn chiều dài tối đa của văn bản được sinh ra (tính theo số token). Nếu văn bản vượt quá 100 token, mô hình sẽ dừng quá trình sinh.

num_return_sequences=1: Số lượng văn bản được sinh ra cho mỗi chuỗi đầu vào. Mỗi lần chạy, mô hình chỉ tạo ra một văn bản duy nhất.
Thử nghiệm với câu hỏi “Random Forest là gì?”

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko# python AIcandy_LLM_Finetuing_bloom_560m_icsgpvrs.py
>> Generated text 1

Human: Random Forest là gì? Assistant: là một công cụ hiệu quả giúp bạn thiết lập các mô-đun cho mô hình để thu thập dữ liệu, phân tích và phát triển nó. Trong khi làm việc, nó hoạt động như một hệ thống quản lý thông tin, hỗ trợ quản trị dự án và hỗ

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko#

Thử nghiệm với câu hỏi “Trí tuệ nhân tạo là gì?”

root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko# python AIcandy_LLM_Finetuing_bloom_560m_icsgpvrs.py
>> Generated text 1

Human: Trí tuệ nhân tạo là gì? Assistant: Ơn giời ơi! Bạn đang làm cái gì?
Kích thích sự xuất hiện của tính năng bảo mật thông qua công nghệ bảo vệ thông minh (chẳng hạn như mã hóa dữ liệu khi trao đổi thông tin giữa máy tính và thiết bị lưu trữ trên mạng) trên toàn bộ mạng Internet.
root@aicandy:/aicandy/projects/LLM/AIcandy_LLM_Finetuning_bloom_560m_iehimqko#

6. Kết luận

Trong bài viết này, chúng ta đã đi qua quy trình fine-tuning một mô hình ngôn ngữ lớn, từ việc chuẩn bị dữ liệu, lựa chọn mô hình, đến việc thực hiện quá trình huấn luyện. Mặc dù bộ dữ liệu sử dụng trong bài viết khá nhỏ và mô hình được chọn có số lượng tham số hạn chế để phù hợp với tài nguyên GPU, nhưng các bước được trình bày đã làm rõ cách fine-tuning có thể được thực hiện một cách thực tiễn.

Kết quả cuối cùng chưa đạt mức tối ưu, điều này không nằm ngoài dự đoán do hạn chế về tài nguyên và dữ liệu. Tuy nhiên, bài viết đã cung cấp một nền tảng để bạn đọc có thể áp dụng và mở rộng với các bộ dữ liệu lớn hơn, các mô hình mạnh hơn, hoặc tối ưu hóa thêm quy trình huấn luyện.

Fine-tuning là một công cụ mạnh mẽ giúp cá nhân hóa các mô hình ngôn ngữ lớn cho các tác vụ cụ thể. Với sự đầu tư đúng đắn về dữ liệu và tài nguyên, chúng ta có thể đạt được kết quả vượt trội, phù hợp với nhu cầu ứng dụng thực tế. Hy vọng rằng hướng dẫn trong bài viết này sẽ giúp bạn đọc tự tin hơn khi bắt đầu hành trình fine-tuning của riêng mình.