Phi-4 Reasoning का फाइन-ट्यूनिंग: चरण-दर-चरण मार्गदर्शिका

फाइनेंस Q&A डेटासेट पर अत्याधुनिक Phi-4 Reasoning मॉडल को 10 मिनट से कम में फाइन-ट्यून करने की चरण-दर-चरण गाइड।

Abid Ali Awan

अपडेट किया गया 25 सित॰ 2026 · 9 मि॰ पढ़ें

AI के साथ खोजें

ChatGPT Claude Perplexity

अपना निःशुल्क खाता बनाएँ

अभ्यास और ट्रैक अपनी प्रगति को।

Google के साथ जारी रखें

जारी रखने पर, आप हमारी उपयोग की शर्तें, हमारी गोपनीयता नीति को स्वीकार करते हैं और यह भी कि आपका डेटा संयुक्त राज्य अमेरिका में संग्रहीत किया जाता है।

Phi-4-reasoning एक 14-बिलियन पैरामीटर ओपन-वेट मॉडल है, जिसे जटिल तर्क-संबंधी कार्यों के लिए डिज़ाइन किया गया है। क्यूरेटेड डेटासेट्स पर सावधानीपूर्वक फाइन-ट्यूनिंग के माध्यम से यह आकार में बड़े मॉडलों की टक्कर देता है। यह विस्तृत तर्क-शृंखलाएँ उत्पन्न करता है और इंफरेंस-टाइम कंप्यूट का लाभ लेकर उत्कृष्ट प्रदर्शन हासिल करता है।

इसका उन्नत संस्करण, Phi-4-reasoning-plus, रिइनफोर्समेंट लर्निंग और 1.5x अधिक टोकन का उपयोग करता है, जिससे सटीकता और बढ़ जाती है। छोटे आकार के बावजूद, दोनों मॉडल DeepSeek-R1-Distill-70B जैसे बड़े मॉडलों से बेहतर प्रदर्शन करते हैं और यहां तक कि 671-बिलियन पैरामीटर वाले DeepSeek-R1 को भी बेंचमार्क्स पर पीछे छोड़ देते हैं।

इस ट्यूटोरियल में, हम Phi-4-reasoning-plus मॉडल का उपयोग करेंगे और इसे Financial Q&A reasoning डेटासेट पर फाइन-ट्यून करेंगे। इस गाइड में Runpod वातावरण सेटअप, मॉडल, टोकनाइज़र और डेटासेट लोड करना, डेटा को प्रशिक्षण के लिए तैयार करना, मॉडल को ट्रेनिंग के लिए कॉन्फ़िगर करना, मॉडल इवैल्यूएशन चलाना, और फाइन-ट्यून किए गए मॉडल एडॉप्टर को सेव करना शामिल है।

आप Phi 4 के बारे में सीख सकते हैं और निम्न ट्यूटोरियल का अनुसरण करके एक मल्टीमोडल लैंग्वेज ट्यूटर बना सकते हैं, Phi-4-Multimodal: A Guide With Demo Project।

चित्र: लेखक

1. सेटअप

इस ट्यूटोरियल में, हम अपने कम्प्यूटेशनल वातावरण के रूप में RunPod का उपयोग करेंगे। अपना वातावरण सेट करने के लिए निम्न चरणों का पालन करें:

1. RunPod डैशबोर्ड पर जाएँ और “Deploy On-Demand” पर क्लिक करके एक नया pod बनाएँ।

2. A100 GPU चुनें, जो मॉडल को लोड और फाइन-ट्यून करने के लिए पर्याप्त है।

3. अपनी डिप्लॉयमेंट को कस्टमाइज़ करें:

स्टोरेज को 150GB तक बढ़ाएँ।
Hugging Face Token को एक environment variable के रूप में जोड़ें। गेटेड मॉडल्स लोड करने और मॉडल्स को Hugging Face Hub पर पुश करने के लिए यह टोकन आवश्यक है।

4. Pod डिप्लॉय होने के बाद, Connect बटन पर क्लिक करके JupyterLab इंस्टेंस लॉन्च करें।

5. JupyterLab के अंदर, एक नया नोटबुक बनाएँ और आवश्यक सभी Python पैकेजेस इंस्टॉल करें।

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

6. अगला, पहले सेव किए गए टोकन का उपयोग करते हुए Hugging Face CLI में लॉग इन करें।

from huggingface_hub import login
import os

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

2. मॉडल और टोकनाइज़र लोड करना

इस गाइड में, हम Hugging Face से पूर्ण microsoft/Phi-4-reasoning-plus मॉडल और इसका टोकनाइज़र लोड करेंगे।

यहाँ हम 4-बिट क्वांटाइज़ेशन का उपयोग नहीं कर रहे हैं क्योंकि हार्डवेयर फुल-प्रिसीजन वेट्स को आराम से संभाल सकता है। 80 GB VRAM वाला A100 पर्याप्त हेडरूम छोड़ता है, क्योंकि पूरा Phi-4-Reasoning मॉडल केवल लगभग 28 GB घेरता है, इसलिए एक्टिवेशन्स, ऑप्टिमाइज़र स्टेट्स और अन्य ट्रेनिंग ओवरहेड के लिए अब भी 50 GB से अधिक उपलब्ध रहता है।

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 = 1

मॉडल लोड करने के बाद, आप निम्न कमांड चलाकर यह जाँच सकते हैं कि यह कितनी GPU मेमोरी उपयोग करता है:

!nvidia-smi

पूरा मॉडल लगभग 28GB VRAM उपयोग करता है। A100 GPU में 80GB VRAM होती है, इसलिए फाइन-ट्यूनिंग कार्यों के लिए आपके पास अब भी 55GB मेमोरी उपलब्ध है।

3. डेटासेट लोड करना और प्रोसेस करना

डेटासेट लोड करने से पहले, हम एक ट्रेनिंग प्रॉम्प्ट शैली परिभाषित करेंगे। इस प्रॉम्प्ट में शामिल हैं:

सिस्टम निर्देश: मॉडल को कैसे जवाब देना है, इस पर मार्गदर्शन।
ओपन-एंडेड वित्तीय प्रश्न: उपयोगकर्ता द्वारा दिए गए प्रश्न जिन्हें तर्क की आवश्यकता होती है।
असिस्टेंट का उत्तर, जिसमें सोचने का भाग शामिल हो: चरण-दर-चरण तर्क-श्रृंखला और उसके बाद उत्तर।

यह प्रॉम्प्ट शैली मॉडल को आलोचनात्मक रूप से सोचने और अंतिम उत्तर के साथ तर्क-प्रक्रिया प्रस्तुत करने के लिए प्रोत्साहित करती है।

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>
{}
"""

हम एक Python फ़ंक्शन बनाएँगे जो डेटासेट के कॉलम्स (प्रश्न, तर्क, और उत्तर) को प्रॉम्प्ट टेम्पलेट पर लागू करेगा। यह फ़ंक्शन “text” नाम का नया कॉलम बनाएगा, जिसमें प्रॉम्प्ट के सभी घटक शामिल होंगे।

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

अब, हम डेटासेट (TheFinAI/Fino1_Reasoning_Path_FinQA) डाउनलोड करेंगे, 1000 सैंपल्स लोड करेंगे, फॉर्मेटिंग फ़ंक्शन लागू करेंगे, और नया “text” कॉलम बनाएँगे।

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]

डेटासेट का "text" कॉलम सिस्टम निर्देश, उपयोगकर्ता का प्रश्न, चरण-दर-चरण तर्क-शृंखला, और अंतिम उत्तर शामिल करता है। यह संरचित प्रारूप सुनिश्चित करता है कि मॉडल कार्य को समझे और उच्च-गुणवत्ता के उत्तर उत्पन्न करे।

नया STF ट्रेनर फ़ंक्शन सीधे तौर पर टोकनाइज़र स्वीकार नहीं करता। इसलिए, हमें Transformers के DataCollatorForLanguageModeling का उपयोग करके टोकनाइज़र को डेटा कोलेटर में बदलना होगा।

from transformers import DataCollatorForLanguageModeling

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

4. फाइन-ट्यूनिंग से पहले मॉडल इंफरेंस

फाइन-ट्यूनिंग से पहले, हम डेटासेट से एक प्रश्न पर इंफरेंस चलाएँगे ताकि फाइन-ट्यूनिंग के बाद मॉडल के प्रदर्शन की तुलना की जा सके। इंफरेंस प्रॉम्प्ट शैली ट्रेनिंग प्रॉम्प्ट के समान है, लेकिन इसमें तर्क भाग और उत्तर शामिल नहीं है।

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>
{}
"""

हम डेटासेट से 21वाँ प्रश्न चुनेंगे, उसे फ़ॉर्मेट करेंगे और इंफरेंस के लिए टोकनाइज़ करेंगे:

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

मॉडल एक लंबा तर्क-भाग उत्पन्न करता है लेकिन स्पष्ट उत्तर देने में असफल रहता है। max_new_tokens को 2000 तक बढ़ाने से उत्तर मिल सकता है, लेकिन यह तरीका अक्षम और अविश्वसनीय है। तर्क बिखरा हुआ है, और निष्कर्ष गलत है।

5. मॉडल सेटअप

इस खंड में, हम LoRA (Low-Rank Adaptation) को लागू करेंगे, जो बड़े भाषा मॉडलों (LLMs) को नए कार्यों के अनुरूप ढालने के लिए पैरामीटर-प्रभावी फाइन-ट्यूनिंग तकनीक है। LoRA ज्यादातर पैरामीटर्स को फ्रीज़ करके और लो-रैंक मैट्रिसेज़ के रूप में ट्रेन करने योग्य पैरामीटर्स का एक छोटा सेट जोड़कर काम करता है। ये मैट्रिसेज़ लो-रैंक डीकंपोज़िशन प्रारूप में मॉडल में जोड़े जाते हैं, जिससे मॉडल को पूरे वेट्स को संशोधित या स्टोर किए बिना नए कार्यों के अनुरूप ढाला जा सकता है।

LoRA का उपयोग करके हम VRAM खपत और ट्रेनिंग समय को काफी कम कर सकते हैं, जबकि फुल फाइन-ट्यूनिंग के समकक्ष सटीकता बनाए रखते हैं।

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)

अब हम SFTTrainer सेट करेंगे, जो डेटासेट, मॉडल, डेटा कोलेटर, ट्रेनिंग आर्ग्युमेंट्स और LoRA कॉन्फ़िगरेशन जैसे आवश्यक घटकों को एक सुव्यवस्थित कार्यप्रवाह में समाहित करके फाइन-ट्यूनिंग प्रक्रिया को सरल बनाता है। यह तरीका फाइन-ट्यूनिंग को प्रभावी, उपयोगकर्ता-अनुकूल और अत्यधिक अनुकूलन योग्य बनाता है।

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

6. मॉडल ट्रेनिंग

ट्रेनिंग प्रक्रिया शुरू करने से पहले, हम RAM और GPU VRAM खाली करेंगे ताकि out-of-memory (OOM) समस्याओं से बचा जा सके। इससे ट्रेनिंग के दौरान सुचारू निष्पादन सुनिश्चित होता है।

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

ट्रेनिंग के दौरान, प्रक्रिया लगभग 54% मेमोरी का उपयोग करती है और 99% GPU उपयोग तक पहुँचती है, जिससे संसाधनों का कुशल उपयोग होता है।

आप देख सकते हैं कि ट्रेनिंग लॉस प्रत्येक स्टेप के साथ कम होता है, जो दर्शाता है कि मॉडल सीख रहा है और प्रभावी ढंग से फाइन-ट्यून हो रहा है।

7. फाइन-ट्यूनिंग के बाद मॉडल इंफरेंस

अब हम फाइन-ट्यून किए गए मॉडल को डेटासेट से उसकी प्रतिक्रियाओं की तुलना करके परखेंगे। पिछले सेक्शन वाले उसी प्रश्न का उपयोग करते हुए, हम प्रतिक्रिया जनरेट करेंगे:

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

तर्क-भाग विस्तृत और सटीक है, और उत्तर डेटासेट से काफ़ी मेल खाता है।

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

आइए एक और उदाहरण जाँचते हैं:

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

परिणाम प्रभावशाली है—मॉडल डेटासेट की शैली में सटीक तर्क और उत्तर सफलतापूर्वक जनरेट करता है:

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

8. मॉडल सेव करना

भविष्य में उपयोग और अन्य लोगों द्वारा डाउनलोड के लिए फाइन-ट्यून किए गए मॉडल को उपलब्ध कराने हेतु, हम मॉडल एडॉप्टर और टोकनाइज़र को सेव करेंगे और उन्हें 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)

अब मॉडल सार्वजनिक रूप से यहाँ उपलब्ध है: kingabzpro/Phi-4-Reasoning-Plus-FinQA-COT.

स्रोत: kingabzpro/Phi-4-Reasoning-Plus-FinQA-COT · Hugging Face

यदि आपको फाइन-ट्यूनिंग स्क्रिप्ट चलाने में कोई समस्या आती है, तो सहायक नोटबुक देखें: fine-tuning-phi-4-reasoning.ipynb।

अंतिम विचार

Phi-4 Reasoning मॉडल ओपन-सोर्स समुदाय के लिए एक महत्वपूर्ण प्रगति का प्रतिनिधित्व करता है। 685B-पैरामीटर जैसे विशाल मॉडलों पर निर्भर होने के बजाय, Phi-4 Reasoning एक छोटे, अधिक दक्ष आर्किटेक्चर के साथ बेहतर परिणाम हासिल करता है। यह दर्शाता है कि उच्च-गुणवत्ता वाले डेटासेट और रिइनफोर्समेंट लर्निंग पर ध्यान केंद्रित करने से छोटे मॉडलों में भी बेहतर प्रदर्शन संभव है।

Phi-4 Reasoning मॉडल को फाइन-ट्यून करने के सर्वोत्तम पहलुओं में से एक इसकी किफायती और कुशलता है। 20K या अधिक सैंपल्स पर इस मॉडल को फाइन-ट्यून करना $10 से कम लागत में और केवल कुछ घंटों में संभव है, इसके छोटे आकार और अनुकूलित आर्किटेक्चर के कारण।

Phi-4 Reasoning जैसे छोटे मॉडल न केवल फाइन-ट्यूनिंग लागत को कम करते हैं, बल्कि मॉडल इंफरेंस के लिए क्लाउड इंफ्रास्ट्रक्चर खर्च भी बचाते हैं। यह उन प्रोजेक्ट्स के लिए उत्कृष्ट विकल्प है जिन्हें विशाल मॉडलों के ओवरहेड के बिना उच्च प्रदर्शन की आवश्यकता होती है।

अधिक जानकारी के लिए, विभिन्न बड़े भाषा मॉडलों को फाइन-ट्यून करने पर हमारे गाइड देखें:

Author

Abid Ali Awan

एक प्रमाणित डेटा साइंटिस्ट के रूप में, मैं अत्याधुनिक तकनीक का उपयोग करके नवाचारी मशीन लर्निंग अनुप्रयोग बनाने के लिए उत्साहित रहता/रहती हूँ। स्पीच रिकॉग्निशन, डेटा विश्लेषण और रिपोर्टिंग, MLOps, संवादात्मक AI और NLP में मजबूत पृष्ठभूमि के साथ, मैंने ऐसे बुद्धिमान सिस्टम विकसित करने में अपनी विशेषज्ञता निखारी है जो वास्तविक प्रभाव डाल सकें। तकनीकी दक्षता के अलावा, मैं जटिल अवधारणाओं को स्पष्ट और संक्षिप्त भाषा में प्रस्तुत करने में भी निपुण हूँ। परिणामस्वरूप, मैं डेटा साइंस पर एक मांग में रहने वाला/वाली ब्लॉगर बन गया/गई हूँ, और डेटा प्रोफेशनलों के बढ़ते समुदाय के साथ अपने अनुभव और विचार साझा करता/करती हूँ। वर्तमान में, मैं कंटेंट निर्माण और संपादन पर केंद्रित हूँ, बड़े भाषा मॉडलों के साथ काम करते हुए ऐसा प्रभावशाली और आकर्षक कंटेंट विकसित कर रहा/रही हूँ जो व्यवसायों और व्यक्तियों दोनों को अपने डेटा का अधिकतम लाभ उठाने में मदद कर सके।

विषय

कृत्रिम बुद्धिमत्ता

बड़े भाषा मॉडल