Fine-Tuning Phi-4 Reasoning: Panduan Langkah demi Langkah

Phi-4-reasoning adalah model open-weight dengan 14 miliar parameter yang dirancang untuk tugas penalaran kompleks, menyaingi model yang jauh lebih besar melalui fine-tuning cermat pada kumpulan data terkurasi. Model ini menghasilkan rantai penalaran yang terperinci dan memanfaatkan komputasi saat inferensi untuk mencapai kinerja yang luar biasa. 

Versi yang ditingkatkan, Phi-4-reasoning-plus, menggunakan reinforcement learning dan 1,5x lebih banyak token untuk akurasi yang lebih tinggi. Meski ukurannya lebih kecil, kedua model ini melampaui model yang lebih besar seperti DeepSeek-R1-Distill-70B dan bahkan mengungguli DeepSeek-R1 dengan 671 miliar parameter pada tolok ukur.

Dalam tutorial ini, kita akan menggunakan model Phi-4-reasoning-plus dan melakukan fine-tuning pada dataset penalaran Financial Q&A. Panduan ini mencakup menyiapkan lingkungan Runpod, memuat model, tokenizer, dan dataset, menyiapkan data untuk pelatihan model, mengonfigurasi model untuk pelatihan, menjalankan evaluasi model, serta menyimpan adopter model yang telah di-fine-tune.

Anda dapat mempelajari Phi 4 dan membangun tutor bahasa multimodal dengan mengikuti tutorial Phi-4-Multimodal: Panduan dengan Proyek Demo.

Gambar oleh Penulis

1. Penyiapan 

Dalam tutorial ini, kita akan menggunakan RunPod sebagai lingkungan komputasi. Ikuti langkah-langkah berikut untuk menyiapkan lingkungan Anda:

1. Buka RunPod Dashboard dan klik “Deploy On-Demand” untuk membuat pod baru.

2. Pilih GPU A100, yang cukup untuk memuat dan melakukan fine-tuning model.

3. Kustomisasi deployment Anda:

• Tingkatkan penyimpanan menjadi 150GB.
• Tambahkan Hugging Face Token sebagai variabel lingkungan. Token ini diperlukan untuk memuat model berpagar dan mendorong model ke Hugging Face Hub.

4. Setelah pod ter-deploy, klik tombol Connect untuk meluncurkan instance JupyterLab.

5. Di dalam JupyterLab, buat notebook baru dan instal 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 huggingface_hub[hf_xet]Didukung oleh

6. Selanjutnya, masuk ke Hugging Face CLI menggunakan token yang Anda simpan sebelumnya. 

from huggingface_hub import login
import os

hf_token = os.environ.get("HF_TOKEN")
login(hf_token)Didukung oleh

2. Memuat Model dan Tokenizer

Dalam panduan ini, kita akan memuat model lengkap microsoft/Phi-4-reasoning-plus dari Hugging Face, beserta tokenizer-nya.

Kita tidak menggunakan kuantisasi 4-bit di sini karena perangkat keras dapat dengan nyaman menangani bobot presisi penuh. A100 dengan 80 GB VRAM memiliki ruang yang cukup, karena model Phi-4-Reasoning lengkap hanya memakan sekitar 28 GB, sehingga masih ada lebih dari 50 GB untuk aktivasi, status optimizer, dan overhead pelatihan lainnya.

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Load tokenizer & model
model_dir = "microsoft/Phi-4-reasoning-plus"

tokenizer = AutoTokenizer.from_pretrained(model_dir, use_fast=True)

model = AutoModelForCausalLM.from_pretrained(
    model_dir, 
    device_map="auto",  
    torch_dtype=torch.bfloat16,
    trust_remote_code=True             
)

model.config.use_cache = False
model.config.pretraining_tp = 1Didukung oleh

Setelah memuat model, Anda dapat memeriksa berapa banyak memori GPU yang digunakan dengan menjalankan perintah berikut:

!nvidia-smiDidukung oleh

Model penuh menggunakan sekitar 28GB VRAM. GPU A100 memiliki 80GB VRAM, sehingga Anda masih memiliki 55GB memori bebas untuk tugas fine-tuning.

3. Memuat dan Memroses Dataset

Sebelum memuat dataset, kita akan mendefinisikan gaya prompt pelatihan. Prompt ini mencakup:

• Instruksi sistem: Panduan untuk model tentang cara merespons.
• Pertanyaan keuangan terbuka: Pertanyaan dari pengguna yang memerlukan penalaran.
• Respons asisten dengan bagian berpikir: Rantai penalaran langkah demi langkah diikuti dengan jawabannya.

Gaya prompt ini dirancang untuk mendorong model berpikir kritis dan menghasilkan proses penalaran beserta respons akhir.

train_prompt_style="""
<|im_start|>system<|im_sep|>
Below is an instruction that describes a task, paired with an input that provides further context. 
Write a response that appropriately completes the request. 
Before answering, think carefully about the question and create a step-by-step chain of thoughts to ensure a logical and accurate response.
<|im_end|>
<|im_start|>user<|im_sep|>
{}<|im_end|>
<|im_start|>assistant<|im_sep|>
<think>
{}
</think>
{}
"""Didukung oleh

Kita akan membuat fungsi Python untuk menerapkan kolom dataset (pertanyaan, penalaran, dan respons) ke template prompt. Fungsi ini akan menghasilkan kolom baru bernama “text” yang mencakup semua komponen prompt.

EOS_TOKEN = tokenizer.eos_token  # Must add EOS_TOKEN

def formatting_prompts_func(examples):
    inputs = examples["Open-ended Verifiable Question"]
    complex_cots = examples["Complex_CoT"]
    outputs = examples["Response"]
    texts = []
    for input, cot, output in zip(inputs,complex_cots,outputs):
        text = train_prompt_style.format(input,cot,output) + EOS_TOKEN
        texts.append(text)
    return {
        "text": texts,
    }Didukung oleh

Sekarang, kita akan mengunduh dataset (TheFinAI/Fino1_Reasoning_Path_FinQA), memuat 1000 sampel, menerapkan fungsi pemformatan, dan membuat kolom “text” yang baru.

from datasets import load_dataset

dataset = load_dataset(
    "TheFinAI/Fino1_Reasoning_Path_FinQA", split="train[0:1000]", trust_remote_code=True
)
dataset = dataset.map(
    formatting_prompts_func,
    batched=True,
)
dataset["text"][20]Didukung oleh

Kolom "text" pada dataset mencakup instruksi sistem, pertanyaan pengguna, rantai penalaran langkah demi langkah, dan jawaban akhir. Format terstruktur ini memastikan model memahami tugas dan menghasilkan respons berkualitas tinggi.

Fungsi pelatih STF yang baru tidak menerima tokenizer secara langsung. Oleh karena itu, kita perlu mengonversi tokenizer menjadi data collator menggunakan DataCollatorForLanguageModeling dari Transformers.

from transformers import DataCollatorForLanguageModeling

data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False
)Didukung oleh

4. Inferensi Model Sebelum Fine-Tuning

Sebelum fine-tuning, kita akan menjalankan inferensi pada sebuah pertanyaan dari dataset untuk membandingkan kinerja model setelah fine-tuning. Gaya prompt inferensi mirip dengan gaya prompt pelatihan tetapi tidak menyertakan bagian penalaran dan jawaban.

inference_prompt_style = """
<|im_start|>system<|im_sep|>
Below is an instruction that describes a task, paired with an input that provides further context. 
Write a response that appropriately completes the request. 
Before answering, think carefully about the question and create a step-by-step chain of thoughts to ensure a logical and accurate response.
<|im_end|>
<|im_start|>user<|im_sep|>
{}<|im_end|>
<|im_start|>assistant<|im_sep|>
<think>
{}
"""Didukung oleh

Kita akan memilih pertanyaan ke-21 dari dataset, memformatnya, dan melakukan tokenisasi untuk inferensi:

question = dataset[20]['Open-ended Verifiable Question']
inputs = tokenizer(
    [inference_prompt_style.format(question, "") + tokenizer.eos_token],
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=1200,
    eos_token_id=tokenizer.eos_token_id,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
print(response[0].split("<|im_start|>assistant<|im_sep|>")[1])Didukung oleh

Model menghasilkan bagian penalaran yang panjang tetapi gagal memberikan jawaban yang jelas. Meningkatkan max_new_tokens menjadi 2000 mungkin menghasilkan jawaban, tetapi pendekatan ini tidak efisien dan tidak andal. Penalarannya terpencar, dan kesimpulannya tidak akurat.

5. Menyiapkan Model

Pada bagian ini, kita akan menerapkan LoRA (Low-Rank Adaptation), teknik fine-tuning hemat parameter yang dirancang untuk mengadaptasi large language models (LLM) ke tugas baru. LoRA bekerja dengan membekukan sebagian besar parameter model dan memperkenalkan sejumlah kecil parameter yang dapat dilatih dalam bentuk matriks berderajat rendah. Matriks ini ditambahkan ke model dalam format dekomposisi berderajat rendah, memungkinkan model beradaptasi ke tugas baru tanpa memodifikasi atau menyimpan seluruh bobot model.

Dengan menggunakan LoRA, kita dapat secara signifikan mengurangi konsumsi VRAM dan waktu pelatihan sambil mempertahankan akurasi yang sebanding dengan fine-tuning penuh.

from peft import LoraConfig, get_peft_model

# LoRA config
peft_config = LoraConfig(
    lora_alpha=16,                           # Scaling factor for LoRA
    lora_dropout=0.05,                       # Add slight dropout for regularization
    r=64,                                    # Rank of the LoRA update matrices
    bias="none",                             # No bias reparameterization
    task_type="CAUSAL_LM",                   # Task type: Causal Language Modeling
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],  # Target modules for LoRA
)

model = get_peft_model(model, peft_config)Didukung oleh

Sekarang kita akan menyiapkan SFTTrainer, yang menyederhanakan proses fine-tuning dengan menggabungkan komponen penting seperti dataset, model, data collator, argumen pelatihan, dan konfigurasi LoRA ke dalam satu alur kerja yang ringkas. Pendekatan ini membuat fine-tuning menjadi efisien, mudah digunakan, dan sangat dapat dikustomisasi.

from trl import SFTTrainer
from transformers import TrainingArguments


# Training Arguments
training_arguments = TrainingArguments(
    output_dir="output",
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    logging_steps=0.2,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="none"
)

# Initialize the Trainer
trainer = SFTTrainer(
    model=model,
    args=training_arguments,
    train_dataset=dataset,
    peft_config=peft_config,
    data_collator=data_collator,
)Didukung oleh

6. Pelatihan Model

Sebelum memulai proses pelatihan, kita akan membebaskan RAM dan VRAM GPU untuk menghindari masalah kehabisan memori (OOM). Ini memastikan eksekusi yang lancar selama pelatihan.

import gc, torch
gc.collect()
torch.cuda.empty_cache()
model.config.use_cache = False
trainer.train()Didukung oleh

Selama pelatihan, proses menggunakan sekitar 54% memori dan mencapai utilisasi GPU 99%, memastikan penggunaan sumber daya yang efisien.

Anda dapat mengamati bahwa training loss menurun di setiap langkah, menandakan model belajar dan fine-tuning berjalan efektif. 

7. Inferensi Model Setelah Fine-Tuning

Sekarang kita akan menguji model yang telah di-fine-tune dengan membandingkan responsnya terhadap dataset. Menggunakan pertanyaan yang sama dari bagian sebelumnya, kita menghasilkan sebuah respons:

question = dataset[20]['Open-ended Verifiable Question']
inputs = tokenizer(
    [inference_prompt_style.format(question, "") + tokenizer.eos_token],
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=1200,
    eos_token_id=tokenizer.eos_token_id,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
print(response[0].split("<|im_start|>assistant<|im_sep|>")[1])Didukung oleh

Bagian penalaran terperinci dan akurat, serta jawabannya sangat mendekati dataset. 

<think><|im_end|>First, I need to figure out what the employee contributions were for the years 2002 and 2003. Okay, looking at the numbers, I see that the company contributed $979,000 in 2002 and $825,000 in 2003. So, those are my two key figures. 

Next, I'll calculate the change in the contribution amount. To find this, I subtract the 2003 contribution from the 2002 contribution. Let me do that: $979,000 minus $825,000 equals $154,000. So, there's a decrease of $154,000 from 2002 to 2003.

Now, I need to understand what this decrease means in terms of percentage. Percentage change is usually calculated by taking the change, dividing it by the original number, and then multiplying by 100. So, I'll take that $154,000 change and divide it by the 2002 amount, $979,000. 

Let me do that math: $154,000 divided by $979,000... Hmm, this gives me a value of approximately 0.1573. 

Finally, I multiply that by 100 to convert it to a percentage. That gives me about 15.73%. 

Oh, wait, let me make sure everything makes sense. I calculated the change in contributions correctly by subtracting the 2003 amount from the 2002 amount. Then I used the original amount from 2002 as the base for the percentage calculation. 

Yes, that all seems right. So, the employee contribution decreased by approximately 15.73% from 2002 to 2003.</think>The percentage decrease in the employee contribution from 2002 to 2003 was approximately 15.73%.<|im_end|>Didukung oleh

Mari uji contoh lainnya:

question = dataset[200]['Open-ended Verifiable Question']
inputs = tokenizer(
    [inference_prompt_style.format(question, "") + tokenizer.eos_token],
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids=inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_new_tokens=1200,
    eos_token_id=tokenizer.eos_token_id,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
print(response[0].split("<|im_start|>assistant<|im_sep|>")[1])Didukung oleh

Hasilnya mengesankan, dengan model berhasil menghasilkan penalaran dan jawaban akurat dalam gaya dataset:

<think><|im_end|>Okay, let's figure out how much of the long-term debt should be considered current liabilities. So, the total long-term debt at the end of 2011 was $1859 million. Now, I remember that there's some information about the timing of cash payments related to this debt. In particular, there's a chunk of $29 million that is due in 2012. Hmm, that's the part that's likely to become a current liability. 

Let’s check the table again to make sure. It says total long-term debt is $1859 million, and the breakdown of estimated cash payments includes $29 million for 2012. Yep, that seems to align. So, this $29 million should be classified as a current liability because it's due within the next year. 

But wait, let me double-check. The table is pretty straightforward: long-term debt is $1859 million and the breakdown clearly shows $29 million due in 2012. So, that $29 million is the part that should be on the current liabilities section of the balance sheet. 

Alright, so I'm confident that the portion of the long-term debt that's included in current liabilities as of December 31, 2011, is $29 million. That's it!</think>The portion of the long-term debt included in the current liabilities on the balance sheet as of December 31, 2011, is $29 million. This $29 million represents the amount of debt due within the next year, making it a current liability.<|im_end|>Didukung oleh

8. Menyimpan Model

Agar model yang telah di-fine-tune dapat diakses untuk penggunaan mendatang dan diunduh oleh orang lain, kita akan menyimpan adapter model dan tokenizer lalu mendorongnya ke Hugging Face Hub:

new_model_name = "Phi-4-Reasoning-Plus-FinQA-COT"
model.push_to_hub(new_model_name)
tokenizer.push_to_hub(new_model_name)Didukung oleh

Model kini tersedia untuk umum di: kingabzpro/Phi-4-Reasoning-Plus-FinQA-COT. 

Sumber: kingabzpro/Phi-4-Reasoning-Plus-FinQA-COT · Hugging Face

Jika Anda mengalami masalah saat menjalankan skrip fine-tuning, lihat notebook pendamping: fine-tuning-phi-4-reasoning.ipynb.

Pemikiran Akhir

Model Phi-4 Reasoning merepresentasikan langkah maju yang signifikan bagi komunitas open-source. Alih-alih bergantung pada model dengan 685B parameter yang masif, Phi-4 Reasoning mencapai hasil yang lebih baik dengan arsitektur yang lebih kecil dan efisien. Ini menunjukkan bahwa berfokus pada dataset berkualitas tinggi dan reinforcement learning dapat menghasilkan kinerja yang lebih baik bahkan pada model yang lebih kecil.

Salah satu aspek terbaik dari fine-tuning model Phi-4 Reasoning adalah keterjangkauan dan efisiensinya. Melakukan fine-tuning model ini pada 20K sampel atau lebih akan menelan biaya kurang dari $10 dan hanya memakan waktu beberapa jam, berkat ukurannya yang lebih kecil dan arsitektur yang dioptimalkan.

Model yang lebih kecil seperti Phi-4 Reasoning tidak hanya mengurangi biaya fine-tuning tetapi juga menghemat biaya infrastruktur cloud untuk inferensi model. Ini menjadikannya pilihan yang sangat baik untuk proyek yang membutuhkan kinerja tinggi tanpa beban model yang masif.

Untuk informasi lebih lanjut, silakan lihat panduan kami tentang fine-tuning berbagai large language model:

1. Fine-Tuning Llama 4: Panduan dengan Proyek Demo
2. Fine-Tuning Qwen3: Panduan Langkah demi Langkah
3. Fine-Tune Gemma 3: Panduan Langkah demi Langkah dengan Dataset Tanya Jawab Keuangan 
4. Fine-Tuning DeepSeek R1 (Model Penalaran)