Unsloth 2x तेज़ Fine-tuning

Clore.ai पर Unsloth का उपयोग करके 70% कम VRAM के साथ LLMs को 2x तेज़ fine-tune करें

Unsloth HuggingFace Transformers के प्रदर्शन-नजरिए हिस्सों को हाथ से अनुकूलित Triton कर्नेल्स के साथ पुनर्लेखन करता है, प्रदान करते हुए 2x प्रशिक्षण गति और 70% VRAM कमी बिना किसी सटीकता हानि के। यह एक drop-in रिप्लेसमेंट है — आयात बदलने के बाद आपके मौजूदा TRL/PEFT स्क्रिप्ट बिना बदलाव के काम करेंगे।

सभी उदाहरण GPU सर्वरों पर चलते हैं जो कि के माध्यम से किराये पर लिए गए हैं CLORE.AI मार्केटप्लेस.

प्रमुख विशेषताएँ

• 2x तेज़ प्रशिक्षण — attention, RoPE, cross-entropy, और RMS norm के लिए कस्टम Triton कर्नेल्स

• 70% कम VRAM — बुद्धिमान gradient checkpointing और memory-mapped weights

• Drop-in HuggingFace रिप्लेसमेंट — केवल एक import परिवर्तन, और कुछ भी नहीं

• QLoRA / LoRA / पूर्ण फाइन-ट्यून — सभी मोड बॉक्स से बाहर समर्थित

• मूल (नेटिव) एक्सपोर्ट — सीधे GGUF (सभी क्वांट प्रकार), LoRA एडाप्टर्स, या मर्ज्ड 16-बिट में सहेजें

• विस्तृत मॉडल कवरेज — Llama 3.x, Mistral, Qwen 2.5, Gemma 2, DeepSeek-R1, Phi-4, और भी बहुत कुछ

• मुफ्त और ओपन सोर्स (Apache 2.0)

आवश्यकताएँ

घटक	न्यूनतम	अनुशंसित
GPU	RTX 3060 12 GB	RTX 4090 24 GB
VRAM	10 GB	24 GB
RAM	16 GB	32 GB
डिस्क	40 GB	80 GB
CUDA	11.8	12.1+
Python	3.10	3.11

Clore.ai मूल्य निर्धारण: RTX 4090 ≈ $0.5–2/दिन · RTX 3090 ≈ $0.3–1/दिन · RTX 3060 ≈ $0.15–0.3/दिन

एक 7B मॉडल 4-bit QLoRA के साथ फिट हो जाता है ~10 GB VRAM, जिससे यहां तक कि एक RTX 3060 भी सक्षम बन जाता है।

त्वरित प्रारम्भ

1. Unsloth इंस्टॉल करें

# एक venv बनाएं (अनुशंसित)
python -m venv /workspace/unsloth-env
source /workspace/unsloth-env/bin/activate

pip install --upgrade pip
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes xformers

2. 4-bit क्वांटाइज़ेशन के साथ एक मॉडल लोड करें

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=2048,
    dtype=None,            # ऑटो-डिटेक्ट (Ampere पर float16, Ada पर bfloat16)
    load_in_4bit=True,
)

3. LoRA एडाप्टर्स लागू करें

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",   # 70% VRAM कमी
    random_state=42,
    use_rslora=False,
    loftq_config=None,
)

4. डेटा तैयार करें और प्रशिक्षण करें

from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

dataset = load_dataset("yahma/alpaca-cleaned", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    dataset_num_proc=2,
    packing=True,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=42,
        output_dir="/workspace/outputs",
    ),
)

stats = trainer.train()
print(f"Training loss: {stats.training_loss:.4f}")

मॉडल का एक्सपोर्ट करना

केवल LoRA एडाप्टर सहेजें

model.save_pretrained("/workspace/lora-adapter")
tokenizer.save_pretrained("/workspace/lora-adapter")

मर्ज करके पूर्ण मॉडल सहेजें (float16)

model.save_pretrained_merged(
    "/workspace/merged-model",
    tokenizer,
    save_method="merged_16bit",
)

Ollama / llama.cpp के लिए GGUF में एक्सपोर्ट करें

# Q4_K_M में क्वांटाइज़ करें (आकार और गुणवत्ता का अच्छा संतुलन)
model.save_pretrained_gguf(
    "/workspace/gguf-output",
    tokenizer,
    quantization_method="q4_k_m",
)

# अन्य विकल्प: q5_k_m, q8_0, f16

एक्सपोर्ट के बाद, Ollama के साथ सर्व करें:

# एक Ollama modelfile बनाएं
cat > Modelfile <<EOF
FROM /workspace/gguf-output/unsloth.Q4_K_M.gguf
TEMPLATE "{{ .System }}\n{{ .Prompt }}"
PARAMETER temperature 0.7
EOF

ollama create my-finetuned -f Modelfile
ollama run my-finetuned "Summarize the key points of transformers architecture"

उपयोग के उदाहरण

कस्टम चैट डेटासेट पर फाइन-ट्यून करें

from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(tokenizer, chat_template="llama-3.1")

def format_chat(example):
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["output"]},
    ]
    return {"text": tokenizer.apply_chat_template(messages, tokenize=False)}

dataset = dataset.map(format_chat)

DPO / ORPO एलाइनमेंट प्रशिक्षण

from trl import DPOTrainer, DPOConfig

dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,          # Unsloth संदर्भ मॉडल आंतरिक रूप से संभालता है
    args=DPOConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=5e-6,
        num_train_epochs=1,
        beta=0.1,
        output_dir="/workspace/dpo-output",
    ),
    train_dataset=dpo_dataset,
    tokenizer=tokenizer,
)
dpo_trainer.train()

VRAM उपयोग संदर्भ

मॉडल	क्वांट	विधि	VRAM	GPU
Llama 3.1 8B	4-bit	QLoRA	~10 GB	RTX 3060
Llama 3.1 8B	16-bit	LoRA	~18 GB	RTX 3090
Qwen 2.5 14B	4-bit	QLoRA	~14 GB	RTX 3090
Mistral 7B	4-bit	QLoRA	~9 GB	RTX 3060
DeepSeek-R1 7B	4-bit	QLoRA	~10 GB	RTX 3060
Llama 3.3 70B	4-bit	QLoRA	~44 GB	2× RTX 3090

टिप्स

• हमेशा उपयोग करें use_gradient_checkpointing="unsloth" — यह एकल सबसे बड़ा VRAM बचाने वाला है, जो Unsloth के लिए विशिष्ट है

• सेट करें lora_dropout=0 — Unsloth के Triton कर्नेल्स शून्य dropout के लिए अनुकूलित हैं और तेज़ चलते हैं

• उपयोग करें packing=True SFTTrainer में ताकि छोटे उदाहरणों पर padding की बर्बादी से बचा जा सके

• के साथ शुरू करें r=16 LoRA रैंक के लिए — केवल तभी 32 या 64 बढ़ाएँ जब validation loss प्लेट्यू हो जाए

• wandb के साथ मॉनिटर करें — जोड़ें report_to="wandb" loss ट्रैकिंग के लिए TrainingArguments में

• बैच साइज ट्यूनिंग — बढ़ाएँ per_device_train_batch_size जब तक आप VRAM सीमा के पास न पहुँचें, फिर क्षतिपूर्ति करें gradient_accumulation_steps

समस्याओं का निवारण

समस्या	समाधान
OutOfMemoryError प्रशिक्षण के दौरान	बैच साइज को 1 तक घटाएं, कम करें max_seq_length, या 4-bit क्वांट का उपयोग करें
Triton कर्नेल कंपाइलेशन त्रुटियाँ	चलाएँ pip install triton --upgrade और सुनिश्चित करें कि CUDA टूलकिट मेल खाता है
पहला कदम धीमा (कम्पाइलिंग)	सामान्य — Triton पहले रन पर कर्नेल्स कम्पाइल करता है, बाद में कैश हो जाते हैं
bitsandbytes CUDA संस्करण त्रुटि	मेल खाता हुआ वर्शन इंस्टॉल करें: pip install bitsandbytes --upgrade
प्रशिक्षण के दौरान loss spike होना	learning rate को 1e-4 तक घटाएँ, warmup steps जोड़ें
GGUF एक्सपोर्ट क्रैश होना	कन्वर्ज़न के लिए पर्याप्त RAM (मॉडल साइज़ का 2×) और डिस्क स्पेस सुनिश्चित करें

संसाधन

• Unsloth GitHub

• Unsloth Wiki — सभी नोटबुक्स

• CLORE.AI मार्केटप्लेस