Fine-tuning Llama 3.2 dan Menggunakannya Secara Lokal: Panduan Langkah demi Langkah

Belakangan ini, bidang large language model (LLM) berkembang pesat. LLM yang lebih baru dirancang makin kecil dan makin cerdas, sehingga lebih hemat biaya dan mudah digunakan dibanding model yang lebih besar. 

Dengan rilis Llama 3.2, kini kita memiliki akses ke model yang lebih kecil, seperti varian 1B dan 3B. Meski model kecil ini mungkin tidak menyamai akurasi model besar pada tugas umum, model tersebut dapat di-fine-tune agar berkinerja sangat baik pada area spesifik, seperti klasifikasi emosi dalam interaksi dukungan pelanggan. Kemampuan ini memungkinkan mereka berpotensi menggantikan model tradisional di domain tersebut.

Dalam tutorial ini, kita akan mengeksplorasi kemampuan model visi dan model ringan Llama 3.2. Kita akan mempelajari cara mengakses model Llama 3.2 3B, melakukan fine-tune pada dataset dukungan pelanggan, lalu menggabungkan dan mengekspornya ke Hugging Face hub. Terakhir, kita akan mengonversi model ke format GGUF dan menggunakannya secara lokal dengan aplikasi Jan.

Jika Anda baru mengenal AI, sangat disarankan untuk mengikuti AI Fundamentals dan mempelajari dasar-dasar ChatGPT, large language model, generative AI, dan lainnya.

Gambar oleh Penulis

Mengenal Llama 3.2

Keluarga model open-source Llama 3.2 memiliki dua variasi: model ringan dan visi. Model visi unggul dalam penalaran gambar dan menjembatani visi dengan bahasa, sedangkan model ringan unggul dalam generasi teks multibahasa dan pemanggilan alat untuk perangkat edge.

Model ringan

Model ringan memiliki dua varian lebih kecil: 1B dan 3B. Model ini unggul dalam tugas generasi teks multibahasa dan pemanggilan alat. Ukurannya kecil, artinya dapat berjalan di perangkat sehingga data tidak pernah meninggalkan perangkat dan menyediakan generasi teks berkecepatan tinggi dengan biaya komputasi rendah.

Untuk membuat model ringan yang efisien ini, Llama 3.2 menggunakan teknik pruning dan knowledge distillation. Pruning mengurangi ukuran model sambil mempertahankan performa, dan knowledge distillation menggunakan jaringan yang lebih besar untuk berbagi pengetahuan dengan yang lebih kecil, sehingga meningkatkan performa mereka.

Model 3B mengungguli model lain seperti Gemma 2 (2,6B) dan Phi 3.5-mini pada tugas seperti mengikuti instruksi, merangkum, menulis ulang prompt, dan penggunaan alat.

Sumber: Llama 3.2: Revolutionizing edge AI and vision with open, customizable models

Model visi

Model visi hadir dalam dua varian: 11B dan 90B. Model ini dirancang untuk mendukung penalaran gambar. Varian 11B dan 90B dapat memahami dan menafsirkan dokumen, bagan, dan grafik serta melakukan tugas seperti penulisan caption gambar dan visual grounding. Kemampuan visi tingkat lanjut ini dimungkinkan dengan mengintegrasikan encoder gambar pra-latih dengan model bahasa menggunakan bobot adaptor yang terdiri dari lapisan cross-attention.

Dibandingkan dengan Claude 3 Haiku dan GPT-4o mini, model visi Llama 3.2 unggul dalam pengenalan gambar dan berbagai tugas pemahaman visual, menjadikannya alat yang andal untuk aplikasi AI multimodal.

Sumber: Llama 3.2: Revolutionizing edge AI and vision with open, customizable models

Anda dapat mempelajari lebih lanjut tentang use case Llama 3.2, tolok ukur, Llama Guard 3, dan arsitektur model dengan membaca blog terbaru kami, Panduan Llama 3.2: Cara Kerja, Use Case & Lainnya.

Mengakses Model Ringan Llama 3.2 di Kaggle

Meskipun model Llama 3.2 tersedia gratis dan open source, Anda tetap perlu menerima syarat dan ketentuan serta mengisi formulir di situs web. 

Untuk mendapatkan akses ke model Llama 3.2 terbaru di platform Kaggle:

1. Kunjungi situs llama.com dan isi formulir dengan data Anda. Pilih kedua model, ringan dan visi. 

Sumber: Download Llama

2. Buka halaman model Meta | Llama 3.2 dan klik tombol “Submit Form”. 

Sumber: Meta | Llama 3.2 | Kaggle

3. Terima semua syarat dan ketentuan lalu tekan tombol “Submit”. 

Sumber: Meta | Llama 3.2 | Kaggle

4. Tunggu beberapa menit hingga Anda melihat opsi untuk mengunduh atau membuat notebook baru. Pilih tab Transformers dan variasi model, lalu klik tombol “+ New Notebook”.

5. Notebook Kaggle akan diluncurkan dengan model Llama terbaru. Agar berfungsi, kita hanya perlu mengubah akselerator menjadi “GPU T4 x2.”

6. Perbarui paket Python Transformers dan Accelerate. 

%%capture
%pip install -U transformers accelerateDidukung oleh

7. Muat tokenizer dan model menggunakan paket Transformers. Alih-alih memberikan tautan repositori model Hugging Face, kita menentukan direktori lokal tempat model berada.

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, TextStreamer
import torch


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

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

8. Atur pad_token_id untuk menghindari pesan peringatan.

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_idDidukung oleh

9. Buat pipeline generasi teks dengan model dan tokenizer. 

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)Didukung oleh

10. Jalankan pipeline dengan prompt kustom. Dalam contoh ini, kita menanyakannya tentang Vincent van Gogh.

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

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

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])Didukung oleh

Jawabannya cukup akurat. 

11. Mari berikan instruksi sistem untuk melihat apakah model dapat memahami dan mengikuti prompt yang kompleks. Kita akan menampilkan hasil sebagai HTML dengan menggabungkan kode Markdown. 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

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

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )Didukung oleh

Hasilnya sangat akurat. Kinerja model cukup baik meski hanya memiliki 3 miliar parameter.

Jika Anda mengalami kesulitan mengakses model ringan Llama 3.2, silakan lihat notebook Accessing the Llama 3.2 Lightweight Models.

Mengakses Model Visi Llama 3.2 di Kaggle

Mengakses model Visi itu mudah, dan Anda tidak perlu khawatir soal memori GPU, karena kita akan menggunakan beberapa GPU dalam panduan ini. 

1. Kirim formulir pada halaman model Meta | Llama 3.2 Vision. Terima semua persyaratan dan klik tombol “Submit”. 

Sumber: Meta | Llama 3.2 Vision | Kaggle

2. Gulir ke bawah, pilih tab Transformer dan varian model visi, lalu klik “+ New Notebook”.

Sumber: Meta | Llama 3.2 Vision | Kaggle

3. Pastikan Anda menggunakan “GPU T4 x2” sebagai akselerator. 
4. Perbarui paket Python Transformers dan Accelerate.

%%capture
%pip install -U transformers accelerateDidukung oleh

5. Muat image processor dan model visi Llama 3.2. 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)Didukung oleh

Seperti terlihat, model ini menggunakan hampir 25 GB memori GPU. Ini tidak mungkin dijalankan di laptop atau Google Colab versi gratis.

6. Muat gambar. Kita memberinya gambar unggulan dari tutorial: OpenAI o1-preview Tutorial: Building a Machine Learning Project.
7. Tulis pesan dan konversi menjadi prompt menggunakan chat template. Tulis pesan dan konversi menjadi prompt menggunakan chat template. 
8. Proses gambar dan teks lalu berikan ke model untuk menghasilkan respons. 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))Didukung oleh

Hasilnya, kita mendapatkan deskripsi gambar yang detail. Cukup akurat. 

Jika Anda mengalami masalah saat menjalankan kode di atas, silakan lihat notebook Kaggle Accessing the Llama 3.2 Vision Models.

Fine-tuning Llama 3.2 3B Instruct

Pada bagian ini, kita akan mempelajari cara melakukan fine-tune model Llama 3.2 3B Instruct menggunakan pustaka Transformers pada dataset dukungan pelanggan. Kita akan menggunakan Kaggle untuk mengakses GPU gratis dan mendapatkan RAM yang lebih besar daripada Colab. 

1. Menyiapkan lingkungan

Luncurkan notebook baru di Kaggle dan atur variabel lingkungan. Kita akan menggunakan API Hugging Face untuk menyimpan model dan Weights & Biases untuk melacak performanya.

Instal dan perbarui semua paket Python yang diperlukan. 

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

Muat paket dan fungsi Python yang akan kita gunakan sepanjang proses fine-tuning dan evaluasi.

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_formatDidukung oleh

Masuk ke Hugging Face CLI menggunakan kunci API. 

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)Didukung oleh

Masuk ke Weights & Biases menggunakan kunci API dan inisialisasi proyek baru. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)Didukung oleh

Atur variabel untuk model dasar, dataset, dan nama model baru. Kita akan menggunakannya di beberapa tempat dalam proyek ini, jadi lebih baik ditetapkan di awal untuk menghindari kebingungan.

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"Didukung oleh

2. Memuat model dan tokenizer

Atur tipe data dan implementasi attention.

# Set torch dtype and attention implementation
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"Didukung oleh

Muat model dan tokenizer dengan memberikan direktori model lokal. Meskipun model kita kecil, memuat model penuh dan melakukan fine-tune akan memakan waktu. Sebagai gantinya, kita akan memuat model dalam kuantisasi 4-bit.

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

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)Didukung oleh

3. Memuat dan memproses dataset

Kita akan memuat dataset Bitext-customer-support-llm-chatbot dari Hugging Face hub. Ini adalah dataset sintetis hibrida yang akan kita gunakan untuk membuat chatbot dukungan pelanggan yang disesuaikan.

Kita akan memuat, mengacak, dan memilih hanya 1000 sampel. Kita melakukan fine-tune pada subset kecil untuk mengurangi waktu pelatihan, tetapi Anda selalu dapat memilih model penuh.

Selanjutnya, kita akan membuat kolom "text" menggunakan instruksi sistem, pertanyaan pengguna, dan respons asisten. Lalu, kita konversi respons JSON ke format chat.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

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

Seperti terlihat, kita telah menggabungkan pertanyaan pelanggan dan respons asisten dalam format chat. 

dataset['text'][3]Didukung oleh

4. Menyiapkan model

Ekstrak nama linear model dari modelnya. 

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)Didukung oleh

Gunakan nama modul linear untuk membuat adaptor LoRA. Kita hanya akan melakukan fine-tune pada adaptor LoRA dan membiarkan bagian model lainnya agar hemat memori dan mempercepat waktu pelatihan. 

# 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)Didukung oleh

Kita mengonfigurasi hiperparameter model agar berjalan di lingkungan Kaggle. Anda dapat memahami tiap hiperparameter dengan merujuk ke tutorial Fine-Tuning Llama 2 dan menyesuaikannya untuk mengoptimalkan pelatihan di sistem Anda.

#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"
)Didukung oleh

Sekarang kita akan menyiapkan trainer supervised fine-tuning (SFT) dan memberikan dataset pelatihan dan evaluasi, konfigurasi LoRA, argumen pelatihan, tokenizer, dan model. 

# 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,
)Didukung oleh

5. Pelatihan model

Mulai proses pelatihan dan pantau metrik training loss dan validation loss. 

trainer.train()Didukung oleh

Training loss berkurang secara bertahap. Ini pertanda baik. 

Riwayat run yang detail dihasilkan saat kita menyelesaikan run Weights & Biases. 

wandb.finish()Didukung oleh

Anda selalu dapat mengunjungi dasbor Weights & Biases untuk meninjau metrik model secara menyeluruh.

6. Inferensi model

Untuk menguji model yang telah di-fine-tune, kita akan memberinya prompt sampel dari dataset. 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

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_new_tokens=150, num_return_sequences=1)

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

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

Model yang di-fine-tune telah mengadopsi gaya dan memberikan respons yang akurat.

7. Menyimpan tokenizer dan model

Simpan model yang telah di-fine-tune secara lokal dan dorong ke Hugging Face hub. Fungsi push_to_hub akan membuat repositori model baru dan mengunggah berkas model ke repositori Hugging Face Anda. 

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Didukung oleh

Sumber: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Untuk melakukan fine-tune model Llama 3 yang lebih besar, Anda sebaiknya melihat tutorial Fine-Tuning Llama 3.1 untuk Klasifikasi Teks. Tutorial ini cukup populer dan akan membantu Anda menemukan LLM untuk menyelesaikan tugas secara menyeluruh. 

8. Menyimpan notebook

Klik tombol "Save Version" di kanan atas, pilih opsi quick save, dan ubah opsi save output untuk menyimpan berkas model dan seluruh kode.

Lihat notebook Kaggle Fine-tune Llama 3.2 on Customer Support untuk sumber kode, hasil, dan output. 

Ini adalah panduan berbasis kode yang cukup berat. Jika Anda mencari panduan no-code atau low-code untuk fine-tuning LLM, lihat LlaMA-Factory WebUI Beginner's Guide: Fine-Tuning LLMs. 

Menggabungkan dan Mengekspor Llama 3.2 yang Telah di-Fine-tune 

Kita akan membuat notebook baru dan menambahkan notebook yang sebelumnya disimpan untuk mengakses adaptor LoRA yang telah di-fine-tune guna menghindari masalah memori. 

Pastikan Anda juga menambahkan model dasar "Llama 3.2 3B Instruct".

Instal dan perbarui semua paket Python yang diperlukan. 

%%capture
%pip install -U bitsandbytes
%pip install transformers==4.44.2
%pip install -U accelerate
%pip install -U peft
%pip install -U trlDidukung oleh

Masuk ke Hugging Face CLI untuk mendorong model gabungan ke Hugging Face hub. 

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)Didukung oleh

Berikan lokasi model dasar dan LoRA hasil fine-tune. Kita akan menggunakannya untuk memuat model dasar dan menggabungkannya dengan adaptor.

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"Didukung oleh

Muat tokenizer dan model penuh. 

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="auto",
)Didukung oleh

Terapkan format chat pada model dan tokenizer. Lalu gabungkan model dasar dengan adaptor LoRA.

# Merge adapter with base model
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()Didukung oleh

Untuk memeriksa apakah model berhasil digabungkan, berikan prompt sampel dan hasilkan respons. 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

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_new_tokens=150, num_return_sequences=1)

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

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

Seperti terlihat, model yang telah di-fine-tune bekerja dengan sempurna. 

Simpan tokenizer dan model secara lokal. 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)Didukung oleh

Dorong tokenizer dan model gabungan ke repositori model Hugging Face.

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)Didukung oleh

Setelah beberapa menit, Anda dapat melihat semua berkas model beserta berkas metadata di repositori Hugging Face Anda.

Sumber: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Anda juga dapat meninjau kode sumber di notebook Kaggle Merging and Exporting Fine-tuned Llama 3.2 untuk mempelajari lebih lanjut tentang penggabungan dan pengunggahan model ke Hugging Face hub.

Langkah berikutnya dalam proyek ini adalah mengonversi model penuh ke format GGUF lalu melakukan kuantisasi. Setelah itu, Anda dapat menggunakannya secara lokal menggunakan aplikasi chat favorit seperti Jan, Msty, atau GPT4ALL. Ikuti panduan Fine-Tuning Llama 3 dan Menggunakannya Secara Lokal untuk mempelajari cara mengonversi semua LLM ke format GGUF dan menggunakannya secara lokal di laptop Anda.

Mengonversi Model yang Digabung ke Format GGUF

Untuk menggunakan model yang telah di-fine-tune secara lokal, pertama-tama kita harus mengonversinya ke format GGUF. Mengapa? Karena ini adalah format llama.cpp dan diterima oleh semua aplikasi chatbot desktop. 

Mengonversi model gabungan ke format llama.ccp cukup mudah. Yang perlu kita lakukan hanyalah pergi ke GGUF My Repo di Hugging Face Hub. Masuk dengan akun Hugging Face. Ketik tautan repositori model yang telah di-fine-tune “kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot” lalu tekan tombol “Submit”. 

Sumber: GGUF My Repo

Dalam beberapa detik, versi model terkuantisasi akan dibuat di repositori Hugging Face baru. 

Sumber: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

Klik tab “Files” dan unduh hanya berkas GGUF. 

Sumber: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

Menggunakan Model yang Telah di-Fine-tune Secara Lokal

Kita akan menggunakan aplikasi chatbot Jan untuk menggunakan model yang telah di-fine-tune secara lokal. Kunjungi situs resmi jan.ai untuk mengunduh dan memasang aplikasi. 

Sumber: Jan

Klik pengaturan, pilih menu “My Models”, dan tekan tombol “Import Model”. Lalu berikan direktori lokal modelnya. 

Buka menu chat dan pilih model yang telah di-fine-tune seperti di bawah ini.

Klik tab “Assistant” di panel kanan dan ketikkan system prompt.

System prompt: “You are a top-rated customer service agent named John. Be polite to customers and answer all their questions.”

Klik tab “Model”, tepat di samping tab “Assistant”, dan ubah stop token menjadi “<|eot_id|>”

Selesai. Sekarang Anda tinggal menanyakan ke AI dukungan pelanggan tentang masalah yang Anda hadapi. 

Prompt: “How do I order multiple items from the same vendor?”

Responsnya akurat dan sangat cepat—hampir 102 token per detik.

Kesimpulan

Melakukan fine-tune LLM yang lebih kecil memungkinkan kita menghemat biaya dan meningkatkan waktu inferensi. Dengan data yang cukup, Anda dapat meningkatkan performa model pada tugas tertentu mendekati GPT-4-mini. Singkatnya, masa depan AI melibatkan penggunaan banyak LLM kecil dalam suatu grid dengan relasi master-slave. 

Model master akan menerima prompt awal dan memutuskan model spesialis mana yang digunakan untuk menghasilkan jawaban. Ini akan mengurangi waktu komputasi, meningkatkan hasil, dan menurunkan biaya operasional.

Dalam tutorial ini, kita telah mempelajari tentang Llama 3.2 dan cara mengaksesnya di Kaggle. Kita juga telah mempelajari cara melakukan fine-tune model Llama 3.2 yang ringan pada dataset dukungan pelanggan sehingga dapat belajar merespons dengan gaya tertentu dan memberikan informasi spesifik domain yang akurat. Lalu kita menggabungkan adaptor LoRA dengan model dasar dan mendorong model penuh ke Hugging Face Hub. Terakhir, kita mengonversi model gabungan ke format GGUF dan menggunakannya secara lokal di laptop dengan aplikasi chatbot Jan.

Ikuti Working with Hugging Face untuk mempelajari penggunaan alat ini dan fine-tuning model.