Fine-Tuning Gemma 2 dan Menggunakannya Secara Lokal

Dalam tutorial ini, kita akan mempelajari cara melakukan fine-tuning model Gemma 2 pada dataset percakapan pasien dan dokter. Kita juga akan mengonversi model ke format GGUF agar dapat digunakan secara lokal di laptop secara offline. 

Kita akan mempelajari Gemma 2 dan peningkatannya dibanding generasi sebelumnya sebelum melakukan fine-tuning model Gemma 2 pada dataset percakapan pasien-dokter. Kita kemudian akan menggabungkan adapter yang disimpan dengan model dasar, mendorong model penuh ke Hugging Face Hub, dan menggunakan Hugging Face Space untuk mengonversi dan mengkuantisasi model. Terakhir, kita akan mengunduh model yang telah dikuantisasi dan menggunakannya secara lokal dengan aplikasi Jan. 

Gambar oleh Penulis

Memahami Gemma 2

Gemma 2 adalah rilis terbaru dalam keluarga model bahasa besar (LLM) terbuka Gemma dari Google. Model ini tersedia untuk peneliti dan pengembang dalam dua ukuran, 9 miliar (9B) dan 27 miliar (27B) parameter, dengan lisensi yang ramah komersial. Artinya, Anda dapat melakukan fine-tuning pada dataset privat dan menerapkan model yang telah di-fine-tune ke produksi tanpa batasan. 

Sumber: Google meluncurkan Gemma 2

Gemma 2 menawarkan peningkatan signifikan dalam kinerja dan efisiensi inferensi. Arsitektur yang didesain ulang memastikan inferensi yang sangat cepat di berbagai perangkat keras serta integrasi mulus dengan kerangka AI utama seperti Hugging Face Transformers, JAX, PyTorch, dan TensorFlow. 

Gemma 2 juga menyertakan langkah keselamatan yang kuat dan alat untuk penerapan AI yang etis. Model ini melampaui Llama 3 dan Groq-1 pada berbagai tolok ukur dan hadir dengan integrasi Keras 3 yang lebih baik untuk fine-tuning dan inferensi model yang mulus. 

Jika Anda ingin mempelajari generasi pertama model Gemma, sumber yang bagus adalah tutorial kami, Fine Tuning Google Gemma: Meningkatkan LLM dengan Instruksi yang Disesuaikan. Sumber ini memberikan panduan komprehensif tentang cara melakukan fine-tuning model Gemma, seperti Gemma 7b-it, pada dataset dan tugas tertentu. 

Mengakses Gemma 2

Pada bagian ini, kita akan mengunduh model, memuatnya dalam kuantisasi 4-bit, lalu menjalankan inferensi pada GPU. 

1. Instal semua paket Python yang diperlukan. 

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

2. Kita menggunakan Kaggle sebagai lingkungan pengembangan. Kita perlu membuat variabel lingkungan menggunakan fungsi "Secrets" lalu mengaktifkannya. Variabel lingkungan memiliki token Hugging Face yang dapat Anda buat dengan masuk ke situs web Hugging Face. 

3. Ambil token Hugging Face dari Kaggle Secrets secara aman dan gunakan untuk masuk ke Hugging Face CLI. Masuk akan membantu kita mengunduh model dan dataset yang dibatasi. 

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)

4. Muat tokenizer menggunakan tautan repositori model Gemma 2 di Hugging Face. 
5. Muat model menggunakan nama model, pengaturan kuantisasi 4-bit, dan peta perangkat. Ini akan terlebih dahulu mengunduh berkas model penuh lalu memuat model dalam 4-bit untuk mengoptimalkan komputasi dan memori. 

Catatan: Model Gemma 2 9B-It berukuran besar, dan bahkan dengan memori GPU 16GB, kita tidak dapat memuat model penuh. Karena itu, kita memuat model dalam kuantisasi 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
)

6. Buat prompt menggunakan instruksi sistem dan pertanyaan pengguna.
7. Konversi prompt menjadi token menggunakan tokenizer.
8. Hasilkan respons lalu dekode menjadi teks bahasa Inggris yang dapat dibaca.
9. Tampilkan hasil dengan mengonversi gaya Markdown ke format 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])

Seperti yang bisa kita lihat, model Gemma 2 bekerja dengan sangat baik. 

Jika Anda mengalami kesulitan menjalankan kode di atas, silakan lihat Kaggle Notebook: Gemma 2 Simple Inference on GPU.

Fine-tuning Gemma 2 Menggunakan LoRA

Pada bagian ini, kita akan melakukan fine-tuning model Gemma 2 9B-It pada dataset layanan kesehatan, yang terdiri dari percakapan antara pasien dan dokter. Kita akan memuat model dan tokenizer, memuat dataset, mengonversi dataset, menyiapkan model menggunakan argumen pelatihan, dan melacak kinerja model menggunakan API Weights and Biases.  

Jika Anda tertarik memahami teori fine-tuning, bacalah panduan kami, Panduan Pengantar Fine-Tuning LLM.

1. Penyiapan

Instal paket Python yang diperlukan untuk memuat, melakukan fine-tuning, dan mengevaluasi model pada dataset medis. 

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

Muat paket Python dan fungsi yang diperlukan. 

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

Masuk ke Hugging Face CLI menggunakan kunci API yang telah kita simpan melalui 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)

Muat kunci API Weights and Biases dari Kaggle Secrets untuk memulai proyek pelacakan kinerja model. 

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

Menetapkan ID model dan dataset agar kita dapat memuatnya dari Hugging Face Hub. Selain itu, kita perlu menetapkan nama model yang telah di-fine-tune untuk membuat repositori model di Hugging Face dan mendorong model yang telah di-fine-tune.

base_model = "google/gemma-2-9b-it"
dataset_name = "lavita/ChatDoctor-HealthCareMagic-100k"
new_model = "Gemma-2-9b-it-chat-doctor"

2. Memuat model dan tokenizer

Menetapkan tipe data dan implementasi attention berdasarkan 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"

Kita harus membuat konfigurasi QLoRA agar dapat memuat model dengan presisi 4-bit, mengurangi penggunaan memori, dan mempercepat proses fine-tuning.

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

Menggunakan URL Model, konfigurasi LoRA, dan implementasi attention, muat model Gemma 2 9B-It dan tokenizernya.

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

3. Menambahkan adapter ke layer

Buat fungsi Python yang akan menggunakan model dan mengekstrak nama semua modul linear. 

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)

Fine-tuning model penuh akan memakan banyak waktu, jadi untuk mempercepat proses pelatihan, kita akan membuat dan memasang layer adapter sehingga prosesnya lebih cepat dan lebih efisien memori. 

Layer adopsi dibuat menggunakan modul target dan jenis tugas. Selanjutnya, kita menyiapkan format chat untuk model dan tokenizer. Terakhir, kita menautkan model dasar ke adapter untuk membuat model Parameter Efficient Fine-Tuning (PEFT).

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

4. Memuat dataset

Sekarang kita akan memuat dataset lavita/ChatDoctor-HealthCareMagic-100k dari Hugging Face hub. Dataset terdiri dari tiga kolom:

1. instruction: Berisi instruksi sistem. 
2. input: Pertanyaan pasien yang terperinci.
3. output: Respons dokter terhadap pertanyaan pasien. 

Setelah memuat dataset, kita akan mengacaknya dan memilih 1000 sampel untuk semakin mengurangi waktu pelatihan. Terakhir, kita akan membuat format chat menggunakan templat chat default dan menggunakannya untuk membuat kolom “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

Keluaran: 

Dataset({
    features: ['instruction', 'input', 'output', 'text'],
    num_rows: 1000
})

Mari tinjau kolom “text” pada baris ke-3. 

dataset['text'][3]

Kolom “text” memuat instruksi, pertanyaan pasien, dan respons dokter dalam gaya OpenAI.

Untuk evaluasi model, kita akan membagi dataset menjadi set pelatihan dan pengujian. 

dataset = dataset.train_test_split(test_size=0.1)

5. Mengompilasi dan melatih model

Sekarang kita akan menetapkan argumen pelatihan dan parameter STF lalu memulai proses pelatihan. 

Anda dapat mengubah berbagai hiperparameter berdasarkan lingkungan, komputasi, dan memori Anda. Hiperparameter di bawah ini dioptimalkan untuk Kaggle Notebook. Jadi, jika Anda ingin menjalankan hal yang sama di Google Colab, pertimbangkan untuk bereksperimen dengan algoritme pelatihan. 

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

Diperlukan hampir 25 menit untuk melakukan fine-tuning model, dan seperti yang terlihat, loss pelatihan dan validasi berangsur menurun. Untuk kinerja yang lebih baik, coba lakukan fine-tuning model pada seluruh dataset setidaknya tiga epoch.

Fine-tuning bisa cukup teknis bagi pemula dan non-teknis. Jika Anda mencari solusi yang lebih sederhana, Anda sebaiknya melihat tutorial Fine-Tuning OpenAI's GPT-4: A Step-by-Step Guide. Tutorial ini membahas cara sederhana melakukan fine-tuning model mutakhir menggunakan OpenAI API.

6. Evaluasi model

Kita akan menyelesaikan eksperimen Weights and Biases yang akan menghasilkan laporan evaluasi. 

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

Untuk melihat laporan terperinci, buka akun Weights and Biases Anda dan klik nama proyek "Fine-tune Gemma-2-9b-it on Healthcare Dataset".

Tangkapan layar dari wandb.ai

7. Menyimpan perubahan

Sekarang kita akan menyimpan adapter yang telah di-fine-tune secara lokal dan juga mendorongnya ke Hugging Face hub. 

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

Untuk menggunakan adapter yang disimpan di Kaggle notebook lain, kita harus menyimpan notebook tersebut. Kita dapat melakukannya dengan mengeklik “Save Version” di kanan atas. Setelah itu, pilih “Quick Save” dan “Always save output when creating a Quick Save,” lalu tekan tombol “Save”. 

Jika Anda mengalami masalah saat menjalankan kode, silakan klon Kaggle Notebook dan jalankan. Anda harus menyiapkan kunci API Hugging Face dan Weights & Biases menggunakan Kaggle Secrets.

Untuk menentukan apakah fine-tuning atau Retrieval-Augmented Generation (RAG) lebih cocok untuk kasus penggunaan spesifik Anda, sangat saya rekomendasikan membaca blog RAG vs Fine-Tuning. 

Menggabungkan Model Dasar dengan Adapter

Sekarang, kita akan menggabungkan adapter dengan model dasar dan mendorong model penuh ke Hugging Face hub.

Buat Kaggle notebook baru dengan CPU sebagai akselerator dan instal paket Python yang diperlukan.

Mengapa kita menggunakan CPU sebagai akselerator? Bukankah akan lambat? Ya, tetapi mesin GPU di Kaggle hanya menyediakan 16 GB memori GPU, yang cukup untuk model 7 miliar parameter namun tidak untuk model 9 miliar parameter. Sementara itu, mesin CPU menyediakan 30GB, yang cukup untuk memuat model dasar dan adapter.

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

Ambil kunci API dari Kaggle Secrets dan masuk ke 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)

Untuk mengakses model yang disimpan, Anda harus mengimpor Kaggle notebook yang disimpan. Caranya, klik tombol “Add Input” di kanan atas dan pilih tab “Your Work.” Lalu, klik tombol plus pada notebook yang disimpan untuk mengakses semua berkasnya. 

Siapkan URL model dasar dengan memberikan nama repositori Hugging Face. Selain itu, konfigurasikan URL adapter dengan menentukan direktori lokal tempat adapter disimpan.

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/"

Muat tokenizer dan model penuh menggunakan URL model dasar. Pastikan Anda menetapkan device “cpu” dan 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",
)

Tetapkan format chat ke model dasar yang baru dimuat dan gabungkan dengan adapter. Terakhir, kita akan memuat dan menggabungkan adapter ke model dasar. 

Fungsi merge_and_unload() akan membantu kita menggabungkan bobot adapter dengan model dasar dan menggunakannya sebagai model mandiri.

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

Simpan model penuh dan tokenizer secara lokal.

model.save_pretrained("Gemma-2-9b-it-chat-doctor")
tokenizer.save_pretrained("Gemma-2-9b-it-chat-doctor")

Selain itu, dorong semua berkas model dan tokenizer ke 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)

Anda dapat membuka repositori model Hugging Face Anda dan melihat semua berkasnya. 

Sumber: kingabzpro/Gemma-2-9b-it-chat-doctor · Hugging Face

Jika Anda menghadapi masalah saat menggabungkan model menggunakan CPU, silakan lihat Kaggle Notebook.

Kuantisasi menggunakan Hugging Face Space

Dengan GGUF My Repo di Hugging Face Space, konversi dan kuantisasi model menjadi mudah dan cepat. Yang perlu Anda lakukan hanyalah masuk dan memberikan ID model. 

Sumber: GGUF My Repo - a Hugging Face Space by ggml-org

Ini akan membuat repositori model baru untuk Anda dengan berkas model yang telah dikuantisasi yang dapat Anda unduh nanti untuk digunakan secara lokal. Semudah itu. 

Anda dapat mempelajari teori di balik kuantisasi dengan membaca artikel kami tentang Kuantisasi untuk Large Language Models (LLM): Mengurangi Ukuran Model AI Secara Efisien.

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

Namun jika Anda ingin terjun langsung dan menjalankan skrip llama.cpp sendiri, Anda sebaiknya melihat tutorial Fine-Tuning Llama 3 dan Menggunakannya Secara Lokal.

Menggunakan Model yang Telah Di-fine-tune Secara Lokal

Untuk menggunakan model yang telah dikuantisasi secara lokal:

1. Kita terlebih dahulu harus mengunduh dan memasang aplikasi Jan dari situs resmi. 
2. Luncurkan aplikasi dan buka “Model Hub.” Kita dapat mengakses menu dengan mengeklik tombol Windows “🪟” di kiri atas. 
3. Tempel tautan repositori model yang telah di-fine-tune ke bilah pencarian dan tekan enter: "kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF"

4. Kita akan diarahkan ke menu baru, di mana kita memiliki opsi untuk mengunduh model secara langsung. 

5. Buka menu “Thread” dan pilih model yang telah di-fine-tune dari tab “Model” di kanan atas.  

6. Mulailah mengajukan pertanyaan kepada asisten AI dan dapatkan respons yang disesuaikan. 

7. Seperti yang bisa kita lihat, respons awal masih kurang. Kita perlu memodifikasi beberapa parameter model. Arahkan ke tab “Model” dan mulai sesuaikan argumen berikut:

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

8. Buka tab “Assistant” dan ubah Instructions menjadi “Jika Anda seorang dokter, mohon jawab pertanyaan medis berdasarkan deskripsi pasien.”
9. Uji model dengan beberapa pertanyaan dan rasakan hasil yang berkualitas tinggi dan tepat sasaran.

Kesimpulan

Gemma 2 adalah model yang hebat, dan bisa menjadi lebih baik jika Anda menggunakan kerangka Keras 3 untuk fine-tuning terdistribusi dan inferensi model. Anda akan mendapatkan waktu pelatihan dan inferensi yang lebih cepat dibanding menggunakan kerangka Transformers. 

Anda dapat mempelajari cara melakukan fine-tuning model Gemma dan menjalankan inferensi model menggunakan Keras 3 dengan mengikuti tutorial Fine-Tune and Run Inference on Google's Gemma Model with TPU.

Dalam tutorial ini, kita telah mempelajari model Gemma 2 dan cara mengaksesnya menggunakan pustaka Transformer. Kita juga telah mempelajari cara melakukan fine-tuning model pada percakapan pasien-dokter, menggabungkan adapter dengan model dasar, mendorong model penuh ke Hugging Face hub, mengonversi dan mengkuantisasi model menggunakan Hugging Face Space, mengunduh dan menjalankan model secara lokal di laptop menggunakan aplikasi Jan. 

Ini adalah proyek yang menyenangkan untuk dicoba para penggemar AI. Ini akan meningkatkan kemampuan mereka untuk memecahkan masalah yang muncul selama fine-tuning model bahasa besar. Tantangan utama sering kali terkait dengan keterbatasan memori dan komputasi, serta meminimalkan loss.

Anda juga dapat belajar mengembangkan LLM Anda sendiri dengan PyTorch dan Hugging Face dalam kursus Developing Large Language Models di DataCamp.