Tinh chỉnh Llama 3 và sử dụng cục bộ: Hướng dẫn từng bước

Tìm hiểu Llama 3

Meta đã phát hành một loạt mô hình ngôn ngữ lớn (LLM) mới có tên Llama 3, tập hợp các mô hình text-to-text được huấn luyện trước và tinh chỉnh theo hướng dẫn.

Llama 3 là một mô hình ngôn ngữ tự hồi quy sử dụng kiến trúc transformer đã được tối ưu. Cả phiên bản huấn luyện trước và tinh chỉnh theo hướng dẫn đều có 8B và 70B tham số với độ dài ngữ cảnh 8K token.

Llama 3 8B là LLM được yêu thích nhất trên Hugging Face. Phiên bản tinh chỉnh theo hướng dẫn của nó vượt trội hơn Gemma 7B-It của Google và Mistral 7B Instruct trên nhiều chỉ số hiệu năng. Phiên bản 70B tinh chỉnh theo hướng dẫn đã vượt qua Gemini Pro 1.5 và Claude Sonnet trên hầu hết các chỉ số hiệu năng:

Nguồn: Meta Llama 3

Meta huấn luyện Llama 3 trên một tập hợp dữ liệu trực tuyến công khai mới, với hơn 15 nghìn tỷ token. Mô hình 8B có mốc kiến thức đến tháng 3/2023, trong khi mô hình 70B có mốc đến tháng 12/2023. Các mô hình sử dụng Grouped-Query Attention (GQA), giúp giảm băng thông bộ nhớ và cải thiện hiệu suất.

Các mô hình Llama 3 được phát hành theo giấy phép thương mại tùy chỉnh. Để truy cập mô hình, bạn cần điền biểu mẫu với tên, đơn vị và email của mình và chấp nhận các điều khoản. Nếu bạn dùng các địa chỉ email khác nhau cho các nền tảng như Kaggle và Hugging Face, bạn có thể phải điền biểu mẫu nhiều lần.

Bạn có thể tìm hiểu thêm về Llama 3 qua bài viết Llama 3 là gì?.

1. Tinh chỉnh Llama 3

Trong hướng dẫn này, chúng ta sẽ tinh chỉnh mô hình Llama 3 8B-Chat bằng bộ dữ liệu ruslanmv/ai-medical-chatbot. Bộ dữ liệu chứa 250 nghìn đoạn đối thoại giữa bệnh nhân và bác sĩ. Chúng ta sẽ sử dụng Kaggle Notebook để truy cập mô hình này và GPU miễn phí.

Thiết lập

Trước khi khởi chạy Kaggle Notebook, hãy điền biểu mẫu tải xuống của Meta bằng địa chỉ email Kaggle của bạn, sau đó vào trang mô hình Llama 3 trên Kaggle và chấp nhận thỏa thuận. Quá trình phê duyệt có thể mất từ một đến hai ngày.

Bây giờ chúng ta thực hiện các bước sau:

1. Khởi chạy Notebook mới trên Kaggle và thêm mô hình Llama 3 bằng cách nhấp nút + Add Input, chọn tùy chọn Models, rồi nhấp vào dấu + cạnh mô hình Llama 3. Sau đó, chọn đúng framework, biến thể và phiên bản, rồi thêm mô hình.

2. Vào Session options và chọn GPU P100 làm bộ tăng tốc.

3. Tạo token cho Hugging Face và Weights & Biases, rồi tạo Kaggle Secrets. Bạn có thể tạo và kích hoạt Kaggle Secrets bằng cách vào Add-ons > Secrets > Add một secret mới.

4. Khởi tạo phiên Kaggle bằng cách cài đặt tất cả các gói Python cần thiết.

%%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

5. Import các thư viện Python cần thiết để tải bộ dữ liệu, mô hình và tokenizer, cũng như tinh chỉnh.

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

6. Chúng ta sẽ theo dõi quá trình huấn luyện bằng Weights & Biases và sau đó lưu mô hình đã tinh chỉnh lên Hugging Face, vì vậy cần đăng nhập vào cả Hugging Face Hub và Weights & Biases bằng API key.

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)

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3 8B on Medical Dataset', 
    job_type="training", 
    anonymous="allow"
)

7. Thiết lập biến mô hình gốc, bộ dữ liệu và mô hình mới. Chúng ta sẽ tải mô hình gốc từ Kaggle và bộ dữ liệu từ HugginFace Hub rồi lưu mô hình mới.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
dataset_name = "ruslanmv/ai-medical-chatbot"
new_model = "llama-3-8b-chat-doctor"

8. Thiết lập kiểu dữ liệu và cách triển khai attention.

torch_dtype = torch.float16
attn_implementation = "eager"

Tải mô hình và tokenizer

Ở phần này, chúng ta sẽ tải mô hình từ Kaggle. Tuy nhiên, do hạn chế bộ nhớ, chúng ta không thể tải toàn bộ mô hình. Vì vậy, chúng ta sẽ tải mô hình với độ chính xác 4-bit.

Mục tiêu của dự án này là 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,
)

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

Tải tokenizer rồi thiết lập mô hình và tokenizer cho tác vụ hội thoại. Mặc định, nó dùng mẫu chatml của OpenAI để chuyển văn bản đầu vào sang định dạng giống trò chuyện.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
model, tokenizer = setup_chat_format(model, tokenizer)

Thêm adapter vào các lớp

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

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)
model = get_peft_model(model, peft_config)

Tải bộ dữ liệu

Để tải và tiền xử lý bộ dữ liệu, chúng ta sẽ:

1. Tải bộ dữ liệu ruslanmv/ai-medical-chatbot, xáo trộn và chỉ chọn 1000 dòng đầu. Điều này sẽ giảm đáng kể thời gian huấn luyện.

2. Định dạng mẫu chat để mang tính hội thoại. Kết hợp câu hỏi của bệnh nhân và phản hồi của bác sĩ vào một cột "text".

3. Hiển thị một mẫu từ cột text (cột “text” có định dạng giống chat với các token đặc biệt).

#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": "user", "content": row["Patient"]},
               {"role": "assistant", "content": row["Doctor"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

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

dataset['text'][3]

4. Chia bộ dữ liệu thành tập huấn luyện và kiểm định.

dataset = dataset.train_test_split(test_size=0.1)

Cấu hình và huấn luyện mô hình

Chúng ta đang thiết lập các siêu tham số của mô hình để có thể chạy trên Kaggle. Bạn có thể tìm hiểu về từng siêu tham số trong hướng dẫn Tinh chỉnh Llama 2.

Chúng ta tinh chỉnh mô hình trong một epoch và ghi log các chỉ số bằng Weights & Biases.

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,
    evaluation_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"
)

Tiếp theo, chúng ta thiết lập một SFT trainer (huấn luyện có giám sát) và cung cấp tập huấn luyện, kiểm định, cấu hình LoRA, tham số huấn luyện, tokenizer và mô hình. Chúng ta đặt max_seq_length là 512 để tránh vượt quá bộ nhớ GPU trong quá trình huấn luyện.

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,
)

Bắt đầu quá trình tinh chỉnh bằng cách chạy đoạn mã sau.

trainer.train()

Cả loss huấn luyện và kiểm định đều giảm. Hãy cân nhắc huấn luyện mô hình trong ba epoch trên toàn bộ dữ liệu để có kết quả tốt hơn.

Đánh giá mô hình

Khi bạn kết thúc phiên Weights & Biases, nó sẽ tạo lịch sử và tóm tắt lần chạy.

wandb.finish()
model.config.use_cache = True

Các chỉ số hiệu năng của mô hình cũng được lưu theo tên dự án cụ thể trên tài khoản Weights & Biases của bạn.

Hãy đánh giá mô hình trên một truy vấn mẫu của bệnh nhân để kiểm tra mô hình đã được tinh chỉnh đúng chưa.

Để tạo phản hồi, chúng ta cần chuyển tin nhắn sang định dạng chat, đưa qua tokenizer, nhập vào mô hình, rồi giải mã token sinh ra để hiển thị văn bản.

messages = [
    {
        "role": "user",
        "content": "Hello doctor, I have bad acne. How do I get rid of it?"
    }
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, 
                                       add_generation_prompt=True)

inputs = tokenizer(prompt, return_tensors='pt', padding=True, 
                   truncation=True).to("cuda")

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

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

print(text.split("assistant")[1])

Hóa ra chúng ta có thể thu được kết quả ở mức khá ngay cả với một epoch.

Lưu tệp mô hình

Bây giờ chúng ta sẽ lưu adapter đã tinh chỉnh và đẩy nó lên Hugging Face Hub. API của Hub sẽ tự động tạo kho lưu trữ và lưu tệp adapter.

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)

Như bạn thấy, tệp adapter đã lưu nhỏ hơn rất nhiều so với mô hình gốc.

Cuối cùng, chúng ta sẽ lưu notebook cùng với tệp adapter để hợp nhất với mô hình gốc trong notebook mới.

Để lưu Kaggle Notebook, nhấp nút Save Version ở góc trên bên phải, chọn loại phiên bản là Quick Save, mở cài đặt nâng cao, chọn Always save output when creating a Quick Save, rồi nhấn Save.

Nếu bạn gặp sự cố khi chạy mã, hãy tham khảo Kaggle Notebook này: Fine-tune Llama 3 8B on Medical Dataset.

Chúng ta đã tinh chỉnh mô hình bằng GPU. Bạn cũng có thể học cách tinh chỉnh LLM bằng TPU theo hướng dẫn Tinh chỉnh và suy luận trên mô hình Gemma của Google bằng TPU.

Nếu bạn muốn học cách tinh chỉnh các mô hình khác, hãy xem Hướng dẫn Mistral 7B: Từng bước sử dụng và tinh chỉnh Mistral 7B.

2. Hợp nhất Llama 3

Để sử dụng mô hình đã tinh chỉnh cục bộ, trước tiên chúng ta phải hợp nhất adapter với mô hình gốc rồi lưu mô hình đầy đủ.

Thiết lập

Thực hiện các bước sau:

1. Tạo Kaggle Notebook mới và cài đặt tất cả các gói Python cần thiết. Hãy đảm bảo bạn đang dùng GPU làm bộ tăng tốc.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trl

2. Đăng nhập vào Hugging Face Hub bằng Kaggle Secrets. Việc này giúp chúng ta dễ dàng tải lên mô hình đã tinh chỉnh đầy đủ.

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)

3. Thêm mô hình Llama 3 8B Chat và Kaggle Notebook đã tinh chỉnh mà chúng ta vừa lưu. Bạn có thể thêm các Notebook vào phiên hiện tại giống như thêm dataset và mô hình.

Thêm Notebook vào phiên Kaggle sẽ cho phép chúng ta truy cập các tệp đầu ra. Trong trường hợp này là tệp adapter của mô hình.

4. Thiết lập biến trỏ đến vị trí mô hình gốc và adapter.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
new_model = "/kaggle/input/fine-tune-llama-3-8b-on-medical-dataset/llama-3-8b-chat-doctor/"

Hợp nhất mô hình gốc với adapter

Đầu tiên, chúng ta sẽ tải tokenizer và mô hình gốc bằng thư viện transformers. Sau đó, thiết lập định dạng chat bằng thư viện trl. Cuối cùng, tải và hợp nhất adapter vào mô hình gốc bằng thư viện PEFT.

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

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model)

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, new_model)

model = model.merge_and_unload()

Suy luận mô hình

Để kiểm tra mô hình đã được hợp nhất đúng chưa, chúng ta sẽ thực hiện suy luận đơn giản bằng pipeline từ thư viện transformers. Chúng ta sẽ chuyển đổi tin nhắn bằng mẫu chat rồi cung cấp prompt cho pipeline. Pipeline được khởi tạo với mô hình, tokenizer và loại tác vụ.

Lưu ý: bạn có thể đặt device_map thành "auto" nếu muốn dùng nhiều GPU.

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Mô hình đã tinh chỉnh hoạt động như mong đợi sau khi hợp nhất.

Lưu và đẩy mô hình đã hợp nhất

Bây giờ chúng ta sẽ lưu tokenizer và mô hình bằng hàm save_pretrained().

model.save_pretrained("llama-3-8b-chat-doctor")
tokenizer.save_pretrained("llama-3-8b-chat-doctor")

Các tệp mô hình được lưu ở định dạng safetensors, và tổng kích thước khoảng 16 GB.

Chúng ta có thể đẩy tất cả tệp lên Hugging Face Hub bằng hàm push_to_hub().

model.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)

Cuối cùng, chúng ta có thể lưu Kaggle Notebook giống như trước đó.

Sử dụng Kaggle Notebook Fine Tuned Adapter to fully model sẽ giúp bạn giải quyết mọi vấn đề liên quan đến việc tự chạy mã.

3. Chuyển đổi mô hình sang Llama.cpp GGUF

Chúng ta không thể dùng các tệp safetensors cục bộ vì hầu hết chatbot AI cục bộ không hỗ trợ định dạng này. Thay vào đó, chúng ta sẽ chuyển đổi sang định dạng tệp GGUF của llama.cpp.

Thiết lập

Khởi chạy phiên Kaggle Notebook mới và thêm Notebook Fine Tuned Adapter to the full model.

Clone kho llama.cpp và cài đặt framework llama.cpp bằng lệnh make như bên dưới.

Lưu ý: lệnh dưới đây chỉ hoạt động với Kaggle Notebook. Bạn có thể cần thay đổi một vài thứ để chạy trên nền tảng khác hoặc cục bộ.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Chuyển đổi Safetensors sang định dạng mô hình GGUF

Chạy lệnh sau trong ô Kaggle Notebook để chuyển mô hình sang định dạng GGUF.

convert-hf-to-gguf.py yêu cầu thư mục mô hình đầu vào, đường dẫn tệp đầu ra và kiểu đầu ra.

!python convert-hf-to-gguf.py /kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/ \
    --outfile /kaggle/working/llama-3-8b-chat-doctor.gguf \
    --outtype f16

Sau vài phút, mô hình được chuyển đổi và lưu cục bộ. Sau đó, chúng ta có thể lưu notebook để lưu tệp.

Nếu bạn gặp vấn đề khi chạy mã trên, hãy tham khảo Kaggle Notebook HF LLM to GGUF.

4. Lượng tử hóa mô hình GGUF

Laptop thông thường không có đủ RAM và bộ nhớ GPU để tải toàn bộ mô hình, vì vậy chúng ta phải lượng tử hóa mô hình GGUF, giảm mô hình 16 GB xuống khoảng 4–5 GB.

Thiết lập

Khởi chạy phiên Kaggle Notebook mới và thêm Notebook HF LLM to GGUF.

Sau đó, cài đặt llama.cpp bằng cách chạy lệnh sau trong ô Kaggle Notebook.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Lượng tử hóa

Script lượng tử hóa yêu cầu thư mục mô hình GGUF, đường dẫn tệp đầu ra và phương pháp lượng tử hóa. Chúng ta đang chuyển đổi mô hình bằng phương pháp Q4_K_M.

%cd /kaggle/working/

!./llama.cpp/llama-quantize /kaggle/input/hf-llm-to-gguf/llama-3-8b-chat-doctor.gguf llama-3-8b-chat-doctor-Q4_K_M.gguf Q4_K_M

Kích thước mô hình đã giảm đáng kể từ 15317,05 MB xuống 4685,32 MB.

Đẩy tệp mô hình lên Hugging Face

Để đẩy tệp đơn lẻ lên Hugging Face Hub, chúng ta sẽ:

1. Đăng nhập vào Hugging Face Hub bằng API key.
2. Tạo đối tượng API.
3. Tải tệp lên bằng cách cung cấp đường dẫn cục bộ, đường dẫn trong repo, repo id và loại repo.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
from huggingface_hub import HfApi
user_secrets = UserSecretsClient()
hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/llama-3-8b-chat-doctor-Q4_K_M.gguf",
    path_in_repo="llama-3-8b-chat-doctor-Q4_K_M.gguf",
    repo_id="kingabzpro/llama-3-8b-chat-doctor",
    repo_type="model",
)

Mô hình của chúng ta đã được đẩy thành công lên máy chủ từ xa như hình dưới đây.

Nếu bạn vẫn gặp vấn đề, vui lòng tham khảo Kaggle Notebook GGUF to Quantize, trong đó có toàn bộ mã và đầu ra.

Nếu bạn muốn cách đơn giản hơn để chuyển đổi và lượng tử hóa mô hình, hãy truy cập Hugging Face Space này và cung cấp Hub Model Id.

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

Để sử dụng mô hình GGUF cục bộ, bạn phải tải xuống và nhập vào ứng dụng Jan.

Tải mô hình từ Hugging Face

Để tải mô hình, chúng ta cần:

1. Vào kho trên Hugging Face của chúng ta.

2. Nhấp tab Files.

3. Nhấp vào tệp mô hình đã lượng tử có phần mở rộng GGUF.

4. Nhấp nút download.

Việc tải tệp về máy cục bộ sẽ mất vài phút.

Cài đặt ứng dụng Jan

Tải và cài đặt ứng dụng Jan từ Jan AI.

Giao diện trông như thế này khi bạn mở ứng dụng Jan trên Windows:

Nạp mô hình đã tinh chỉnh vào Jan

Để thêm mô hình vào ứng dụng Jan, chúng ta phải nhập tệp GGUF đã lượng tử hóa.

Chúng ta cần vào menu Hub và nhấp Import Model như dưới đây. Cung cấp vị trí tệp vừa tải xuống là xong.

Vào menu Thread và chọn mô hình đã tinh chỉnh.

Sử dụng mô hình đã tinh chỉnh trong Jan

Trước khi sử dụng mô hình, chúng ta cần tùy chỉnh để hiển thị phản hồi chính xác. Đầu tiên, sửa mẫu Prompt trong phần Model Parameters.

<|im_start|>system
{system_message}<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistant

Chúng ta thêm token Stop và đổi số token tối đa thành 512 trong tham số suy luận.

<endofstring>, Best, Regards, Thanks,-->

Bắt đầu nhập truy vấn, và bác sĩ sẽ phản hồi tương ứng.

Mô hình đã tinh chỉnh của chúng ta hoạt động hoàn hảo trên máy cục bộ.

Mô hình này hoạt động với GPT4ALL, Llama.cpp, Ollama và nhiều ứng dụng AI cục bộ khác. Để học cách sử dụng từng cái, hãy xem hướng dẫn về cách chạy LLM cục bộ.

Kết luận

Tinh chỉnh mô hình Llama 3 trên bộ dữ liệu tùy chỉnh và sử dụng cục bộ đã mở ra nhiều khả năng để xây dựng các ứng dụng sáng tạo. Các trường hợp sử dụng tiềm năng trải rộng từ giải pháp hội thoại AI riêng tư, tùy biến đến chatbot theo miền, phân loại văn bản, dịch ngôn ngữ, hỏi đáp, hệ thống gợi ý cá nhân hóa, thậm chí cả các ứng dụng trong y tế và tự động hóa marketing.

Với các framework Ollama và Langchain, xây dựng ứng dụng AI của riêng bạn giờ đây dễ tiếp cận hơn bao giờ hết, chỉ cần vài dòng mã. Để làm điều đó, hãy theo dõi hướng dẫn LlamaIndex: Khung dữ liệu cho các ứng dụng dựa trên mô hình ngôn ngữ lớn (LLM).

Trong hướng dẫn này, chúng ta đã học cách tinh chỉnh Llama 3 8B Chat trên bộ dữ liệu y khoa. Chúng ta đã đi qua quy trình hợp nhất adapter với mô hình gốc, chuyển sang định dạng GGUF và lượng tử hóa để sử dụng cục bộ trên ứng dụng chatbot Jan.

Nếu bạn muốn học thêm, hãy xem đường kỹ năng gồm bốn khóa về Phát triển mô hình ngôn ngữ lớn.