Tinh chỉnh Gemma 2 và sử dụng cục bộ

Trong hướng dẫn này, chúng ta sẽ học cách tinh chỉnh mô hình Gemma 2 trên bộ dữ liệu hội thoại giữa bệnh nhân và bác sĩ. Chúng ta cũng sẽ chuyển đổi mô hình sang định dạng GGUF để có thể sử dụng ngoại tuyến trên máy tính xách tay. 

Chúng ta sẽ tìm hiểu về Gemma 2 và những cải tiến so với các thế hệ trước, trước khi tinh chỉnh mô hình Gemma 2 trên bộ dữ liệu hội thoại bệnh nhân - bác sĩ. Sau đó, chúng ta sẽ hợp nhất adapter đã lưu với mô hình nền tảng, đẩy toàn bộ mô hình lên Hugging Face Hub và dùng một Hugging Face Space để chuyển đổi và lượng tử hóa mô hình. Cuối cùng, chúng ta sẽ tải về mô hình đã lượng tử hóa và sử dụng cục bộ với ứng dụng Jan. 

Hình ảnh: Tác giả

Tìm hiểu Gemma 2

Gemma 2 là bản phát hành mới nhất trong họ các mô hình ngôn ngữ lớn (LLM) mở của Google. Mô hình có sẵn cho nhà nghiên cứu và nhà phát triển với hai kích cỡ, 9 tỷ (9B) và 27 tỷ (27B) tham số, theo giấy phép thân thiện với thương mại. Điều này có nghĩa là bạn có thể tinh chỉnh trên bộ dữ liệu riêng tư của mình và triển khai mô hình đã tinh chỉnh vào sản xuất mà không bị hạn chế. 

Nguồn: Google ra mắt Gemma 2

Gemma 2 mang lại những tiến bộ đáng kể về hiệu năng và hiệu quả suy luận. Kiến trúc được thiết kế lại giúp suy luận cực nhanh trên nhiều cấu hình phần cứng và tích hợp mượt mà với các framework AI lớn như Hugging Face Transformers, JAX, PyTorch và TensorFlow. 

Gemma 2 cũng bao gồm các biện pháp an toàn mạnh mẽ và công cụ triển khai AI có đạo đức. Mô hình vượt trội hơn Llama 3 và Groq-1 trên nhiều benchmark và đi kèm tích hợp Keras 3 cải tiến để tinh chỉnh và suy luận mô hình liền mạch. 

Nếu bạn muốn tìm hiểu về thế hệ đầu tiên của các mô hình Gemma, một tài liệu tuyệt vời là hướng dẫn của chúng tôi, Tinh chỉnh Google Gemma: Nâng cao LLM với chỉ dẫn tùy biến. Tài liệu này cung cấp hướng dẫn toàn diện về cách tinh chỉnh các mô hình Gemma, như Gemma 7b-it, trên các bộ dữ liệu và tác vụ cụ thể. 

Truy cập Gemma 2

Trong phần này, chúng ta sẽ tải mô hình, nạp nó ở lượng tử hóa 4-bit và sau đó chạy suy luận trên GPU. 

1. Cài đặt tất cả các gói Python cần thiết. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerateĐược hỗ trợ bởi

2. Chúng tôi sử dụng Kaggle làm môi trường phát triển. Cần tạo biến môi trường bằng chức năng "Secrets" và kích hoạt nó. Biến môi trường chứa token Hugging Face mà bạn có thể tạo sau khi đăng nhập vào website Hugging Face. 

3. Lấy token Hugging Face từ Kaggle Secrets một cách an toàn và dùng nó để đăng nhập CLI của Hugging Face. Đăng nhập sẽ giúp chúng ta tải các mô hình và bộ dữ liệu bị hạn chế. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)Được hỗ trợ bởi

4. Nạp tokenizer bằng liên kết kho mô hình Gemma 2 trên Hugging Face. 
5. Nạp mô hình bằng tên mô hình, thiết lập lượng tử hóa 4-bit và device map. Quá trình sẽ tải toàn bộ tệp mô hình trước rồi nạp mô hình ở 4-bit để tối ưu tính toán và bộ nhớ. 

Lưu ý: Mô hình Gemma 2 9B-It rất lớn và ngay cả với GPU 16GB, chúng ta cũng không thể nạp toàn bộ mô hình. Đó là lý do chúng ta nạp mô hình ở lượng tử hóa 4-bit. 

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig

modelName = "google/gemma-2-9b-it"

bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(modelName)

model = AutoModelForCausalLM.from_pretrained(
    modelName,
    device_map = "auto",
    quantization_config=bnbConfig
)Được hỗ trợ bởi

6. Tạo prompt bằng chỉ dẫn hệ thống và câu hỏi của người dùng.
7. Chuyển prompt thành token bằng tokenizer.
8. Sinh phản hồi và giải mã thành văn bản tiếng Anh có thể đọc được.
9. Hiển thị kết quả bằng cách chuyển đổi kiểu Markdown sang định dạng HTML. 

from IPython.display import Markdown, display

system =  "You are a skilled software architect who consistently creates system designs for various applications."
user = "Design a system with the ASCII diagram for the customer support application."

prompt = f"System: {system} \n User: {user} \n AI: "
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

Markdown(text.split("AI:")[1])Được hỗ trợ bởi

Như chúng ta thấy, mô hình Gemma 2 đã làm rất tốt. 

Nếu bạn gặp khó khăn khi chạy đoạn mã trên, vui lòng tham khảo Kaggle Notebook: Gemma 2 Simple Inference on GPU.

Tinh chỉnh Gemma 2 bằng LoRA

Trong phần này, chúng ta sẽ tinh chỉnh mô hình Gemma 2 9B-It trên bộ dữ liệu y tế, bao gồm các cuộc hội thoại giữa bệnh nhân và bác sĩ. Chúng ta sẽ nạp mô hình và tokenizer, nạp bộ dữ liệu, chuyển đổi bộ dữ liệu, cấu hình mô hình bằng tham số huấn luyện và theo dõi hiệu năng mô hình bằng API Weights and Biases.  

Nếu bạn quan tâm đến lý thuyết phía sau tinh chỉnh, hãy đọc hướng dẫn Hướng dẫn nhập môn tinh chỉnh LLM của chúng tôi.

1. Thiết lập

Cài đặt các gói Python cần thiết để nạp, tinh chỉnh và đánh giá mô hình trên bộ dữ liệu y khoa. 

%%capture
%pip install -U transformers 
%pip install -U datasets 
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes 
%pip install -U wandbĐược hỗ trợ bởi

Nạp các gói Python cần thiết và các hàm. 

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainer, setup_chat_formatĐược hỗ trợ bởi

Đăng nhập Hugging Face CLI bằng khóa API mà chúng ta đã lưu bằng Kaggle Secrets. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)
Được hỗ trợ bởi

Nạp khóa API Weights and Biases từ Kaggle Secrets để khởi tạo dự án theo dõi hiệu năng mô hình. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Gemma-2-9b-it on HealthCare Dataset', 
    job_type="training", 
    anonymous="allow"
)Được hỗ trợ bởi

Thiết lập ID mô hình và bộ dữ liệu để chúng ta có thể nạp từ Hugging Face Hub. Ngoài ra, cần đặt tên mô hình đã tinh chỉnh để tạo kho mô hình trên Hugging Face và đẩy mô hình đã tinh chỉnh lên đó.

base_model = "google/gemma-2-9b-it"
dataset_name = "lavita/ChatDoctor-HealthCareMagic-100k"
new_model = "Gemma-2-9b-it-chat-doctor"Được hỗ trợ bởi

2. Nạp mô hình và tokenizer

Thiết lập kiểu dữ liệu và triển khai attention dựa trên GPU. 

if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"Được hỗ trợ bởi

Chúng ta cần tạo cấu hình QLoRA để nạp mô hình với độ chính xác 4-bit, giảm sử dụng bộ nhớ và tăng tốc quá trình tinh chỉnh.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)
Được hỗ trợ bởi

Sử dụng URL mô hình, cấu hình LoRA và triển khai attention, nạp mô hình Gemma 2 9B-It và tokenizer.

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)Được hỗ trợ bởi

3. Thêm adapter vào lớp

Tạo hàm Python sử dụng mô hình và trích xuất tên của tất cả các module tuyến tính. 

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)Được hỗ trợ bởi

Tinh chỉnh toàn bộ mô hình sẽ tốn rất nhiều thời gian, vì vậy để tăng tốc quá trình huấn luyện, chúng ta sẽ tạo và gắn lớp adapter, giúp quy trình nhanh hơn và tiết kiệm bộ nhớ hơn. 

Lớp thích ứng được tạo bằng các module đích và loại tác vụ. Tiếp theo, chúng ta thiết lập định dạng chat cho mô hình và tokenizer. Cuối cùng, gắn mô hình nền tảng với adapter để tạo mô hình PEFT (Parameter Efficient Fine-Tuning).

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)Được hỗ trợ bởi

4. Nạp bộ dữ liệu

Bây giờ chúng ta sẽ nạp bộ dữ liệu lavita/ChatDoctor-HealthCareMagic-100k từ Hugging Face hub. Bộ dữ liệu gồm ba cột:

1. instruction: Chứa chỉ dẫn hệ thống. 
2. input: Truy vấn chi tiết của bệnh nhân.
3. output: Phản hồi của bác sĩ cho truy vấn của bệnh nhân. 

Sau khi nạp bộ dữ liệu, chúng ta sẽ xáo trộn và chọn 1000 mẫu để rút ngắn thời gian huấn luyện. Cuối cùng, chúng ta tạo định dạng chat bằng template mặc định và dùng nó để tạo cột “text”. 

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "system", "content": row["instruction"]},
               {"role": "user", "content": row["input"]},
               {"role": "assistant", "content": row["output"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)

datasetĐược hỗ trợ bởi

Kết quả: 

Dataset({
    features: ['instruction', 'input', 'output', 'text'],
    num_rows: 1000
})Được hỗ trợ bởi

Hãy xem cột “text” của hàng số 3. 

dataset['text'][3]Được hỗ trợ bởi

Cột “text” có chỉ dẫn, truy vấn của bệnh nhân và phản hồi của bác sĩ theo phong cách OpenAI.

Để đánh giá mô hình, chúng ta sẽ chia bộ dữ liệu thành tập huấn luyện và kiểm tra. 

dataset = dataset.train_test_split(test_size=0.1)Được hỗ trợ bởi

5. Biên dịch và huấn luyện mô hình

Bây giờ chúng ta sẽ đặt tham số huấn luyện và tham số STF rồi bắt đầu quá trình huấn luyện. 

Bạn có thể thay đổi nhiều siêu tham số dựa trên môi trường, tài nguyên tính toán và bộ nhớ của mình. Các siêu tham số dưới đây được tối ưu cho Kaggle Notebook. Vì vậy, nếu muốn chạy trên Google Colab, vui lòng cân nhắc thử nghiệm các thuật toán huấn luyện. 

# Setting Hyperparamter
training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    eval_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)
# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

model.config.use_cache = False
trainer.train()Được hỗ trợ bởi

Mất gần 25 phút để tinh chỉnh mô hình, và như chúng ta thấy, loss huấn luyện và kiểm định giảm dần. Để có hiệu năng tốt hơn, hãy thử tinh chỉnh mô hình trên toàn bộ bộ dữ liệu trong ít nhất ba epoch.

Tinh chỉnh có thể hơi kỹ thuật đối với người mới bắt đầu và người không chuyên. Nếu bạn tìm kiếm giải pháp đơn giản hơn, hãy xem hướng dẫn Tinh chỉnh GPT-4 của OpenAI: Hướng dẫn từng bước. Bài này trình bày cách tinh chỉnh một mô hình tối tân đơn giản bằng OpenAI API.

6. Đánh giá mô hình

Chúng ta sẽ kết thúc thí nghiệm Weights and Biases, từ đó tạo báo cáo đánh giá. 

wandb.finish()
model.config.use_cache = TrueĐược hỗ trợ bởi

Để xem báo cáo chi tiết, vào tài khoản Weights and Biases của bạn và nhấp vào tên dự án "Fine-tune Gemma-2-9b-it on Healthcare Dataset".

Ảnh chụp màn hình từ wandb.ai

7. Lưu các thay đổi

Bây giờ chúng ta sẽ lưu adapter đã tinh chỉnh tại chỗ và đồng thời đẩy nó lên Hugging Face hub. 

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Được hỗ trợ bởi

Để sử dụng adapter đã lưu trong một Kaggle notebook khác, chúng ta phải lưu notebook. Có thể làm điều đó bằng cách nhấp “Save Version” ở góc trên bên phải. Sau đó chọn “Quick Save” và “Always save output when creating a Quick Save”, rồi nhấn nút “Save”. 

Nếu bạn gặp khó khăn khi chạy mã, vui lòng sao chép Kaggle Notebook và chạy. Bạn phải thiết lập khóa API của Hugging Face và Weights & Biases bằng Kaggle Secrets.

Để xác định tinh chỉnh hay Retrieval-Augmented Generation (RAG) phù hợp hơn với bài toán của bạn, tôi khuyến nghị đọc bài blog RAG vs Fine-Tuning. 

Hợp nhất mô hình nền tảng với adapter

Giờ đây, chúng ta sẽ hợp nhất adapter với mô hình nền tảng và đẩy toàn bộ mô hình lên Hugging Face hub.

Tạo một Kaggle notebook mới với CPU làm bộ tăng tốc và cài đặt các gói Python cần thiết.

Tại sao chúng ta dùng CPU làm bộ tăng tốc? Chẳng phải sẽ chậm sao? Đúng vậy, nhưng máy GPU trên Kaggle chỉ cung cấp 16 GB bộ nhớ GPU, đủ cho mô hình 7 tỷ tham số chứ không đủ cho mô hình 9 tỷ. Trong khi đó, máy CPU cung cấp 30GB, đủ để nạp cả mô hình nền tảng và adapter.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trlĐược hỗ trợ bởi

Lấy khóa API từ Kaggle Secrets và đăng nhập Hugging Face CLI. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)Được hỗ trợ bởi

Để truy cập mô hình đã lưu, bạn phải nhập notebook Kaggle đã lưu. Để làm điều đó, nhấp nút “Add Input” ở góc trên bên phải và chọn tab “Your Work”. Sau đó nhấp nút dấu cộng của notebook đã lưu để truy cập tất cả tệp của nó. 

Thiết lập URL mô hình nền tảng bằng cách cung cấp tên kho trên Hugging Face. Đồng thời, cấu hình URL adapter bằng cách chỉ định thư mục cục bộ nơi adapter được lưu.

base_model_url = "google/gemma-2-9b-it"
new_model_url = "/kaggle/input/fine-tune-gemma-2-9b-it-on-healthcare-dataset/Gemma-2-9b-it-chat-doctor/"Được hỗ trợ bởi

Nạp tokenizer và toàn bộ mô hình bằng URL mô hình nền tảng. Hãy đảm bảo đặt thiết bị “cpu” và dtype “float16”.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format


# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

base_model_reload= AutoModelForCausalLM.from_pretrained(
    base_model_url,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map="cpu",
)Được hỗ trợ bởi

Thiết lập định dạng chat cho mô hình nền tảng vừa nạp và kết hợp với adapter. Cuối cùng, chúng ta sẽ nạp và hợp nhất adapter vào mô hình nền tảng. 

Hàm merge_and_unload() sẽ giúp chúng ta hợp nhất trọng số adapter với mô hình nền tảng và sử dụng như một mô hình độc lập.

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()Được hỗ trợ bởi

Lưu toàn bộ mô hình và tokenizer cục bộ.

model.save_pretrained("Gemma-2-9b-it-chat-doctor")
tokenizer.save_pretrained("Gemma-2-9b-it-chat-doctor")Được hỗ trợ bởi

Đồng thời, đẩy tất cả tệp mô hình và tokenizer lên Hugging Face hub. 

model.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)Được hỗ trợ bởi

Bạn có thể vào kho mô hình trên Hugging Face của mình và xem tất cả các tệp. 

Nguồn: kingabzpro/Gemma-2-9b-it-chat-doctor · Hugging Face

Nếu bạn gặp vấn đề khi hợp nhất mô hình bằng CPU, vui lòng tham khảo Kaggle Notebook.

Lượng tử hóa bằng Hugging Face Space

Với Hugging Face Space GGUF My Repo, việc chuyển đổi và lượng tử hóa mô hình trở nên dễ dàng và nhanh chóng. Tất cả những gì bạn cần làm là đăng nhập và cung cấp ID mô hình. 

Nguồn: GGUF My Repo - một Hugging Face Space của ggml-org

Space này sẽ tạo một kho mô hình mới cho bạn với tệp mô hình đã lượng tử hóa để bạn có thể tải về và dùng cục bộ sau đó. Đơn giản như vậy. 

Bạn có thể học lý thuyết đằng sau lượng tử hóa bằng cách đọc bài viết Lượng tử hóa cho mô hình ngôn ngữ lớn (LLM): Giảm kích thước mô hình AI hiệu quả của chúng tôi.

Nguồn: kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF · Hugging Face

Nhưng nếu bạn muốn tự tay thực hiện và chạy các script llama.cpp, hãy xem hướng dẫn Tinh chỉnh Llama 3 và sử dụng cục bộ.

Sử dụng mô hình đã tinh chỉnh cục bộ

Để sử dụng mô hình đã lượng tử hóa cục bộ:

1. Trước tiên tải và cài đặt ứng dụng Jan từ trang web chính thức. 
2. Khởi chạy ứng dụng và vào “Model Hub”. Có thể mở menu bằng cách nhấp nút Windows “🪟” ở góc trên bên trái. 
3. Dán liên kết kho mô hình đã tinh chỉnh vào ô tìm kiếm và nhấn enter: "kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF"

4. Bạn sẽ được chuyển tới menu mới, nơi có tùy chọn tải mô hình trực tiếp. 

5. Vào menu “Thread” và chọn mô hình đã tinh chỉnh từ tab “Model” ở góc trên bên phải.  

6. Bắt đầu đặt câu hỏi cho trợ lý AI và nhận phản hồi tùy biến. 

7. Như chúng ta thấy, phản hồi ban đầu chưa tốt. Chúng ta cần chỉnh một vài tham số mô hình. Điều hướng đến tab “Model” và bắt đầu điều chỉnh các tham số sau:

• Stop: <endofstring>, Best wishes, Chat Doctor.
• Frequency Penalty: 0.5
• Max Tokens:  680

8. Vào tab “Assistant” và đổi phần Instructions thành “Nếu bạn là bác sĩ, vui lòng trả lời các câu hỏi y khoa dựa trên mô tả của bệnh nhân.”
9. Thử nghiệm mô hình với nhiều câu hỏi và trải nghiệm kết quả chất lượng cao, đi thẳng vào trọng tâm.

Kết luận

Gemma 2 là một mô hình tuyệt vời, và còn tốt hơn nữa nếu bạn sử dụng framework Keras 3 cho tinh chỉnh phân tán và suy luận mô hình. Bạn sẽ có thời gian huấn luyện và suy luận nhanh hơn so với dùng Transformers. 

Bạn có thể học cách tinh chỉnh mô hình Gemma và chạy suy luận bằng Keras 3 qua hướng dẫn Tinh chỉnh và chạy suy luận trên mô hình Gemma của Google với TPU.

Trong hướng dẫn này, chúng ta đã tìm hiểu về các mô hình Gemma 2 và cách truy cập chúng bằng thư viện Transformer. Chúng ta cũng đã học cách tinh chỉnh mô hình trên hội thoại bệnh nhân - bác sĩ, hợp nhất adapter với mô hình nền tảng, đẩy toàn bộ mô hình lên Hugging Face hub, chuyển đổi và lượng tử hóa mô hình bằng Hugging Face Space, tải xuống và chạy mô hình cục bộ trên máy tính xách tay bằng ứng dụng Jan. 

Đây là một dự án thú vị mà người đam mê AI nên thử. Điều này sẽ nâng cao khả năng xử lý sự cố phát sinh trong quá trình tinh chỉnh các mô hình ngôn ngữ lớn. Thách thức chính thường liên quan đến giới hạn bộ nhớ và tính toán, cũng như việc giảm thiểu loss.

Bạn cũng có thể học cách phát triển LLM của riêng mình với PyTorch và Hugging Face trong khóa học Developing Large Language Models trên DataCamp.