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

QwQ और Qwen2.5 की सफलता पर आगे बढ़ते हुए, Qwen3 तर्क, रचनात्मकता और संवादात्मक क्षमताओं में एक बड़ा कदम है। डेंस और Mixture-of-Experts (MoE) मॉडलों तक खुले एक्सेस के साथ, जो 0.6B से 235B-A22B पैरामीटर्स तक फैले हैं, Qwen3 को विविध कार्यों में उत्कृष्टता के लिए डिज़ाइन किया गया है।

इस ट्यूटोरियल में, हम एक मेडिकल रीजनिंग डेटासेट पर Qwen3-32B मॉडल को फाइन-ट्यून करेंगे। लक्ष्य है कि मॉडल की रोगी प्रश्नों पर तर्क करने और सटीक उत्तर देने की क्षमता का अनुकूलन हो, ताकि वह मेडिकल प्रश्नोत्तर में सटीक और कुशल दृष्टिकोण अपनाए। 

हम अपने पाठकों को AI की नवीनतम खबरों से अपडेट रखते हैं The Median के माध्यम से—यह हमारा निःशुल्क शुक्रवार न्यूज़लेटर है जो हफ्ते की प्रमुख कहानियों को सरलता से समझाता है। सदस्यता लें और हर हफ्ते कुछ ही मिनटों में अप-टु-डेट रहें:

यदि आप Qwen 3 के बारे में और यह प्रतिस्पर्धियों के मुकाबले कैसा है, जानना चाहते हैं, तो हमारे मॉडल के परिचयात्मक गाइड पर नज़र डालें, Qwen 3: फीचर्स, DeepSeek-R1 तुलना, एक्सेस, और अधिक. 

चित्र: लेखक द्वारा

1. सेटअप

अपने RunPod डैशबोर्ड पर जाएँ और सुनिश्चित करें कि आपके खाते में कम से कम $5 हों। इसके बाद A100 SXM मॉडल चुनें और PyTorch का नवीनतम संस्करण सेलेक्ट करें। अंत में, अपना Pod लॉन्च करने के लिए “Deploy On-Demand” बटन पर क्लिक करें।

स्रोत: My Pods

अपने Pod सेटिंग्स में जाकर कंटेनर डिस्क साइज को 100 GB पर समायोजित करें। साथ ही, अपने Hugging Face एक्सेस टोकन को एक environment variable के रूप में शामिल करें।

स्रोत: My Pods

सेटिंग्स लागू होने के बाद, Jupyter Lab लॉन्च करने के लिए “Connect” पर क्लिक करें। 

स्रोत: My Pods

Jupyter Lab आवश्यक पैकेजों और एक्सटेंशंस के साथ प्री-इंस्टॉल आता है, जिससे आप बिना अतिरिक्त सेटअप के सीधे ट्रेनिंग शुरू कर सकते हैं।

स्रोत: My Pods

आगे बढ़ने से पहले, सुनिश्चित करें कि सभी आवश्यक Python पैकेज इंस्टॉल हैं और अप टू डेट हैं। 

Jupyter Notebook की एक सेल में निम्न कमांड चलाएँ:

%%capture
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes
%pip install -U transformersसंचालित द्वारा

पहले सेव किए गए Hugging Face एक्सेस टोकन का उपयोग करके Hugging Face Hub में लॉग इन करें। 

from huggingface_hub import login
import os

hf_token = os.environ.get("HF_TOKEN")
login(hf_token)संचालित द्वारा

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

भले ही हमारे पास 80GB VRAM हो, हम Qwen3 मॉडल को 4-बिट क्वांटाइज़ेशन के साथ लोड करेंगे। इससे मॉडल को GPU पर आसानी से फिट करना और बिना किसी झंझट के फाइन-ट्यून करना संभव होगा। 

Hugging Face Hub से Qwen3-32B मॉडल और टोकनाइज़र डाउनलोड और लोड करें।

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=False,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model_dir = "Qwen/Qwen3-32B"
tokenizer = AutoTokenizer.from_pretrained(model_dir, use_fast=True)
model = AutoModelForCausalLM.from_pretrained(
    model_dir,
    quantization_config=bnb_config,   
    device_map="auto",  
    torch_dtype=torch.bfloat16,
    trust_remote_code=True             
)

model.config.use_cache = False
model.config.pretraining_tp = 1संचालित द्वारा

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

इस अनुभाग में, हम ऐसा प्रॉम्प्ट स्टाइल विकसित करेंगे जो मॉडल को समालोचनात्मक सोच के लिए प्रेरित करे। हम एक प्रॉम्प्ट संरचना बनाएँगे जिसमें सिस्टम प्रॉम्प्ट होगा, और प्रश्न, chain of thought, तथा अंतिम उत्तर के लिए placeholders होंगे। 

train_prompt_style = """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.

### Instruction:
You are a medical expert with advanced knowledge in clinical reasoning, diagnostics, and treatment planning. 
Please answer the following medical question. 

### Question:
{}

### Response:
<think>
{}
</think>
{}"""संचालित द्वारा

अब हम वह Python फ़ंक्शन बनाएँगे जो ट्रेन प्रॉम्प्ट स्टाइल का उपयोग कर संबंधित मान भरकर “text” कॉलम बनाएगा।

EOS_TOKEN = tokenizer.eos_token  # Must add EOS_TOKEN

def formatting_prompts_func(examples):
    inputs = examples["Question"]
    complex_cots = examples["Complex_CoT"]
    outputs = examples["Response"]
    texts = []
    for question, cot, response in zip(inputs, complex_cots, outputs):
        # Append the EOS token to the response if it's not already there
        if not response.endswith(tokenizer.eos_token):
            response += tokenizer.eos_token
        text = train_prompt_style.format(question, cot, response)
        texts.append(text)
    return {"text": texts}संचालित द्वारा

इसके बाद, हम FreedomIntelligence/medical-o1-reasoning-SFT डेटासेट से पहले 2000 सैंपल लोड करेंगे और फिर formatting_prompts_func फ़ंक्शन अप्लाई करके “text” कॉलम बनाएँगे।

from datasets import load_dataset

dataset = load_dataset(
    "FreedomIntelligence/medical-o1-reasoning-SFT",
    "en",
    split="train[0:2000]",
    trust_remote_code=True,
)
dataset = dataset.map(
    formatting_prompts_func,
    batched=True,
)
dataset["text"][10]संचालित द्वारा

जैसा कि हम देख सकते हैं, text कॉलम में सिस्टम प्रॉम्प्ट, निर्देश, प्रश्न, chain of thought, और प्रश्नों के उत्तर शामिल हैं।

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

from transformers import DataCollatorForLanguageModeling

data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False
)संचालित द्वारा

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

इंफरेंस के लिए प्रॉम्प्ट स्टाइल ट्रेन प्रॉम्प्ट से अलग है। इसमें ट्रेनिंग प्रॉम्प्ट स्टाइल की सभी चीजें होती हैं, सिवाय chain of thought और response के।

inference_prompt_style = """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.

### Instruction:
You are a medical expert with advanced knowledge in clinical reasoning, diagnostics, and treatment planning. 
Please answer the following medical question. 

### Question:
{}

### Response:
<think>

"""
संचालित द्वारा

फाइन-ट्यूनिंग से पहले मॉडल के प्रदर्शन का परीक्षण करने के लिए, हम डेटासेट से 11वाँ सैंपल लेंगे और उसे फॉर्मेट करके टोकन्स में बदलने के बाद मॉडल को देंगे।

question = dataset[10]['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, skip_special_tokens=True)
print(response[0].split("### Response:")[1])संचालित द्वारा

नतीजे में, हमें बहुत लंबा thinking भाग मिला और 1200 नए टोकन के बाद भी कोई उत्तर नहीं मिला। यह डेटासेट से काफी अलग है, जो छोटा और संक्षिप्त है।

5. मॉडल सेटअप करना

अब हम LoRA (Low-Rank Adaptation) लागू करेंगे। LoRA ज्यादातर मॉडल पैरामीटर्स को फ्रीज़ करके काम करता है और थोड़े से trainable पैरामीटर्स जोड़ता है, जिन्हें low-rank decomposition फॉर्मेट में जोड़ा जाता है। इससे मॉडल को पूरे वेट्स को अपडेट या स्टोर किए बिना नए कार्यों के लिए अनुकूलित करना संभव होता है।

यह तरीका मेमोरी-कुशल, तेज़ और किफायती है, जबकि सटीकता पूरी फाइन-ट्यूनिंग के बराबर रहती है।

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 (Supervised Fine-Tuning Trainer) को कॉन्फ़िगर और इनिशियलाइज़ करेंगे, जो Hugging Face के transformers और trl लाइब्रेरीज़ द्वारा प्रदान की गई एक हाई-लेवल abstraction है। SFTTrainer डेटासेट, मॉडल, data collator, training arguments और 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. मॉडल ट्रेनिंग

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

import gc, torch
gc.collect()
torch.cuda.empty_cache()
model.config.use_cache = False
trainer.train()संचालित द्वारा

ट्रेनिंग शुरू होने पर आप देखेंगे कि आपका pod GPU का 100% और GPU VRAM का 85% उपयोग कर रहा है। यह दर्शाता है कि हम आदर्श उपयोग बिंदु पर हैं।

ट्रेनिंग समय 42 मिनट लगा, और जैसा कि आप देख सकते हैं, ट्रेनिंग लॉस धीरे-धीरे कम हुआ।

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

अब हम पहले जैसे ही सैंपल पर फाइन-ट्यून किए गए मॉडल का परीक्षण करेंगे और परिणामों की तुलना करेंगे।

question = dataset[10]['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, skip_special_tokens=True)
print(response[0].split("### Response:")[1])संचालित द्वारा

हमने thinking सेक्शन को छोटा किया और सटीक उत्तर प्राप्त किया, जो डेटासेट के अनुरूप है। यह एक उत्कृष्ट परिणाम है।

आइए डेटासेट के एक और सैंपल पर फाइन-ट्यून किए गए Qwen3 के प्रदर्शन का परीक्षण करें।

question = dataset[100]['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, skip_special_tokens=True)
print(response[0].split("### Response:")[1])संचालित द्वारा

एक बार फिर, सोचने की प्रक्रिया सटीक और छोटी रही, और उत्तर डेटासेट की तरह ही सही था।

यदि आपको अपने Qwen3 मॉडल को फाइन-ट्यून करने में समस्या हो रही है, तो कृपया साथी नोटबुक देखें: fine-tuning-qwen-3.

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

अंतिम चरण है मॉडल और टोकनाइज़र को सेव करना और उन्हें Hugging Face hub पर अपलोड करना, ताकि हम कोई एप्लीकेशन बना सकें या मॉडल को ओपन-सोर्स समुदाय के साथ साझा कर सकें। 

new_model_name = "Qwen-3-32B-Medical-Reasoning"
model.push_to_hub(new_model_name)
tokenizer.push_to_hub(new_model_name)संचालित द्वारा

मॉडल और टोकनाइज़र अपलोड होने के बाद, रिपॉज़िटरी का लिंक जेनरेट होगा। उदाहरण के लिए: kingabzpro/Qwen-3-32B-Medical-Reasoning · Hugging Face

स्रोत: kingabzpro/Qwen-3-32B-Medical-Reasoning

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

निष्कर्ष

Qwen-3 AI के लोकतंत्रीकरण की दिशा में एक और महत्वपूर्ण कदम है। आप आसानी से Qwen-3 डाउनलोड कर सकते हैं, उसे अपने PC पर (बिना इंटरनेट एक्सेस के) चला सकते हैं, फाइन-ट्यून कर सकते हैं या अपने लोकल सर्वर पर होस्ट कर सकते हैं। सचमुच, Qwen-3 ओपन AI के सिद्धांतों को साकार करता है।

इस ट्यूटोरियल में, हमने Runpod प्लेटफ़ॉर्म का उपयोग करके मेडिकल रीजनिंग डेटासेट पर Qwen-3 मॉडल को फाइन-ट्यून करना सीखा। उल्लेखनीय रूप से, पूरी प्रक्रिया की लागत $3 से कम रही। अपने फाइन-ट्यूनिंग के प्रदर्शन को और बेहतर करने के लिए, आप मॉडल को पूरे डेटासेट पर कम से कम 3 epochs तक ट्रेन कर सकते हैं।

Qwen 3 मॉडल के बारे में अधिक जानने के लिए हमारा गाइड देखें, Qwen 3: फीचर्स, DeepSeek-R1 तुलना, एक्सेस, और अधिक। आप हमारे ये गाइड भी देख सकते हैं: How to Use Qwen 2.4-VL Locally और Fine-Tuning DeepSeek R1 (Reasoning Model)।