फाइन-ट्यूनिंग टूल्स तुलना

Clore.ai GPU सर्वरों पर LLMs का प्रशिक्षण करने के लिए सही फाइन-ट्यूनिंग फ्रेमवर्क चुनें।

फाइन-ट्यूनिंग पूर्व-प्रशिक्षित LLM को आपके विशिष्ट कार्य या डोमेन के अनुकूल बनाता है। यह मार्गदर्शिका चार प्रमुख ओपन-सोर्स टूल — Unsloth, Axolotl, LLaMA-Factory, और TRL — की तुलना करती है — गति, मेमोरी दक्षता, समर्थित मॉडलों और उपयोग में आसानी को कवर करते हुए।

त्वरित निर्णय मैट्रिक्स

एक मॉडल को फाइन-ट्यून करें

Axolotl

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

TRL

उत्तम हेतु

गति + मेमोरी

कॉन्फ़िग-आधारित प्रशिक्षण

शुरुआती-अनुकूल

अनुसंधान + RLHF

बेसलाइन के खिलाफ गति

2-5× तेज़

~1× (मानक)

मेमोरी में कमी

70-80% कम

QLoRA मानक

मानक

RLHF/DPO/PPO

बुनियादी

✅

✅ (मूल)

वेबUI

❌

✅

❌

GitHub स्टार्स

23K+

9K+

37K+

10K+

लाइसेंस

LGPL (गैर-व्यावसायिक उपयोग के लिए मुफ़्त)

Apache 2.0

समीक्षा

एक मॉडल को फाइन-ट्यून करें

Unsloth एक चीज़ पर तीक्ष्ण रूप से केंद्रित है: फाइन-ट्यूनिंग को यथासंभव तेज़ और मेमोरी-कुशल बनाना। यह Triton में प्रमुख ऑपरेशनों को पुनर्लिखता है और CUDA कर्नेल को अनुकूलित करता है।

दर्शन: अधिकतम गति, न्यूनतम VRAM — कोई समझौता नहीं।

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-8B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,  # 4-बिट क्वांटाइज़ेशन
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # LoRA रैंक
    target_modules=["q_proj", "k_proj", "v_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # ~30% अधिक बैच साइज
    random_state=42,
)

Axolotl

Axolotl HuggingFace Transformers को YAML-आधारित कॉन्फ़िगरेशन सिस्टम के साथ रैप करता है। यह प्रशिक्षण सेटअप की जटिलताओं को संभालता है ताकि आप डेटा और हाइपरपैरामीटर्स पर ध्यान केंद्रित कर सकें।

दर्शन: सब कुछ YAML में, नीचे पूरी लचीलापन।

# config.yml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

datasets:
  - path: mhenrichsen/alpaca_data_cleaned
    type: alpaca

load_in_4bit: true
adapter: qlora

lora_r: 32
lora_alpha: 16
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj

num_epochs: 3
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 2e-4

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

LLaMA-Factory 100+ मॉडलों और प्रशिक्षण विधियों की सबसे व्यापक श्रृंखला का समर्थन करता है, और कॉन्फ़िगरेशन के लिए एक वेब UI भी प्रदान करता है। यह गैर-अनुसंधानकर्ताओं के लिए सबसे सुलभ विकल्प है।

दर्शन: सब कुछ काम करता है, सभी के लिए।

# कमांड लाइन के माध्यम से ट्रेन करें
llamafactory-cli train \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --stage sft \
  --do_train \
  --dataset alpaca_gpt4_en \
  --template llama3 \
  --finetuning_type lora \
  --lora_rank 8 \
  --output_dir saves/llama3-8b-lora \
  --num_train_epochs 3.0 \
  --per_device_train_batch_size 2

# या WebUI का उपयोग करें
llamafactory-cli webui

TRL (Transformer Reinforcement Learning)

TRL HuggingFace की आधिकारिक RLHF लाइब्रेरी है। यह PPO, DPO, ORPO और अन्य एलाइन्मेंट प्रशिक्षण विधियों के लिए मानक है।

दर्शन: अनुसंधान-प्रथम, एलाइन्मेंट प्रशिक्षण मूल रूप से मौजूद।

from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

training_args = SFTConfig(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=load_dataset("tatsu-lab/alpaca", split="train"),
)

trainer.train()

स्पीड बेंचमार्क

प्रशिक्षण गति तुलना (टोकन/सेकेंड)

परीक्षण सेटअप: LLaMA 3.1 8B, LoRA r=16, 4-बिट क्वांटाइज़ेशन, बैच साइज 4, A100 80GB

टूल

टोकन/सेकंड

बेसलाइन के खिलाफ

मेमोरी (VRAM)

Unsloth (4-बिट)

~4,200

2.8×

~8GB

Axolotl (QLoRA)

~1,500

1.0×

~16GB

LLaMA-Factory (QLoRA)

~1,480

~1.0×

~16GB

TRL (QLoRA)

~1,450

~0.97×

~18GB

Unsloth (पूर्ण 16-बिट)

~2,800

1.9×

~22GB

Unsloth का फ़ायदा वास्तविक है: 2-5× गति ध्यान, क्रॉस-एंट्रॉपी, RoPE, और LoRA के लिए कस्टम Triton कर्नेल से आती है। सिर्फ़ मार्केटिंग नहीं।

VRAM उपयोग तुलना

LLaMA 3.1 8B का प्रशिक्षण, अनुक्रम लंबाई 2048:

विधि

एक मॉडल को फाइन-ट्यून करें

Axolotl

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

TRL

पूर्ण फाइन-ट्यून (bf16)

60GB

70GB

72GB

74GB

LoRA (bf16)

18GB

24GB

25GB

26GB

QLoRA (4-बिट)

8GB

16GB

18GB

QLoRA (4-बिट, लंबी संदर्भ)

12GB

24GB

26GB

8B मॉडल के लिए न्यूनतम GPU:

Unsloth: RTX 3080 (10GB) ✅
अन्य: RTX 3090 (24GB) आवश्यक

समर्थित मॉडल

मॉडल समर्थन मैट्रिक्स

मॉडल परिवार

एक मॉडल को फाइन-ट्यून करें

Axolotl

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

TRL

LLaMA 3.x

✅

LLaMA 2

✅

Mistral

✅

Mixtral MoE

✅

Gemma 2

✅

Phi-3/3.5

✅

Qwen 2.5

✅

DeepSeek

✅

Falcon

✅

GPT-NeoX

आंशिक

✅

T5/FLAN

❌

✅

BERT/RoBERTa

❌

✅

विज़न LLMs

आंशिक

✅

प्रशिक्षण विधि समर्थन

विधि

एक मॉडल को फाइन-ट्यून करें

Axolotl

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

TRL

पूर्ण फाइन-ट्यून

✅

LoRA

✅

QLoRA

✅

DoRA

✅

❌

PEFT

✅

SFT

✅

✅ (मूल)

DPO

✅

✅ (मूल)

PPO

❌

✅

✅ (मूल)

ORPO

✅

KTO

❌

✅

✅ (मूल)

GRPO

✅

❌

✅

CPT (जारी पूर्व-प्रशिक्षण)

✅

Unsloth: गहन परिचय

क्यों यह तेज़ है

Triton कर्नेल: Flash Attention, क्रॉस-एंट्रॉपी लॉस, और LoRA को Triton में पुनर्लिखता है
फ्यूज़्ड ऑपरेशन्स: कई CUDA ऑप्स को एक कर्नेल में संयोजित करता है
स्मार्ट ग्रेडिएंट चेकपॉइंटिंग: "unsloth" मोड ~30% अधिक मेमोरी बचाता है
कुशल बैकप्रोप: बड़े मध्यवर्ती टेन्सरों को मटेरियलाइज़ करने से बचता है

Clore.ai पर इंस्टॉलेशन

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

# या conda के साथ
conda create --name unsloth_env python=3.11
conda activate unsloth_env
conda install pytorch-cuda=12.1 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

पूर्ण प्रशिक्षण स्क्रिप्ट

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. Unsloth अनुकूलन के साथ मॉडल लोड करें
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # ऑटो-डिटेक्ट
    load_in_4bit=True,
)

# 2. 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",
    random_state=3407,
)

# 3. डेटासेट लोड और फ़ॉर्मेट करें
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. ट्रेन करें
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)
trainer.train()

# 5. सेव करें
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

कमज़ोरियाँ: कोई PPO नहीं, समर्थित मॉडल सूची तक सीमित, LGPL लाइसेंस (व्यावसायिक उपयोग के लिए जाँच करें)

Axolotl: गहन परिचय

कॉन्फ़िगरेशन-प्रथम दृष्टिकोण

Axolotl तब उजागर होता है जब आप पुनरुत्पादनशील, संस्करण-नियंत्रित प्रशिक्षण कॉन्फ़िगरेशन चाहते हैं:

# axolotl_config.yml — पूरा उदाहरण
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# डेटा
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

# क्वांटाइज़ेशन
load_in_4bit: true
adapter: qlora
bf16: true
tf32: true

# LoRA
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
  - k_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# प्रशिक्षण
sequence_len: 4096
sample_packing: true  # छोटे अनुक्रमों को दक्षता के लिए पैक करता है
pad_to_sequence_len: true
micro_batch_size: 2
gradient_accumulation_steps: 4
num_epochs: 3
learning_rate: 0.0002
optimizer: adamw_bnb_8bit
lr_scheduler: cosine

# लॉगिंग
logging_steps: 10
eval_steps: 100
save_steps: 100
output_dir: ./outputs/my-model

# wandb
wandb_project: my-fine-tune
wandb_run_id: run-001

# इंस्टॉल और चलाएँ
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml

उत्तम हेतु: टीमों के लिए जो पुनरुत्पादनशील, कॉन्फ़िग-संस्करणीकृत प्रशिक्षण रन चाहती हैं

LLaMA-Factory: गहन परिचय

WebUI वॉकथ्रू

# इंस्टॉल करें
pip install llamafactory

# WebUI लॉन्च करें
llamafactory-cli webui
# खोलें http://localhost:7860

WebUI टैब:

Train — बेस मॉडल, डेटासेट, विधि कॉन्फ़िगर करें
मूल्यांकन — MMLU, CMMLU बेंचमार्क चलाएँ
चैट — इंटरैक्टिव इनफ़रेंस
निर्यात — LoRA मर्ज करें, GGUF में क्वांटाइज़ करें

CLI प्रशिक्षण उदाहरण

# सुपरवाइज्ड फाइन-ट्यूनिंग
llamafactory-cli train \
  --stage sft \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset alpaca_gpt4_en,glaive_toolcall_en \
  --template llama3 \
  --finetuning_type lora \
  --lora_rank 8 \
  --lora_alpha 16 \
  --lora_target all \
  --output_dir saves/llama3-lora \
  --num_train_epochs 3 \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-4 \
  --quantization_bit 4 \
  --flash_attn fa2

# DPO प्रशिक्षण
llamafactory-cli train \
  --stage dpo \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset dpo_mix_en \
  --template llama3 \
  --finetuning_type lora \
  --output_dir saves/llama3-dpo

उत्तम हेतु: शुरुआती, वे टीमें जो WebUI चाहती हैं, DPO/RLHF बिना गहन अनुसंधान ज्ञान के

TRL: गहन परिचय

RLHF पाइपलाइन उदाहरण

TRL एलाइन्मेंट प्रशिक्षण के लिए जाने-माने विकल्प है:

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO (डायरेक्ट प्रेफरेंस ऑप्टिमाइज़ेशन) — सबसे सामान्य एलाइन्मेंट विधि
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"

dpo_config = DPOConfig(
    model_name_or_path=model_name,
    output_dir="dpo_outputs",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    beta=0.1,             # KL दंड गुणांक
    loss_type="sigmoid",  # या "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# प्रेफरेंस डेटासेट लोड करें (प्रॉम्प्ट + चयनित + अस्वीकृत)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()

उत्तम हेतु: एलाइन्मेंट अनुसंधान, RLHF, DPO, PPO, ORPO कार्यान्वयन

सही टूल चुनना

निर्णय प्रवाह

अधिकतम गति/न्यूनतम VRAM चाहिए?
  → हाँ → Unsloth (2-5× तेज़, छोटे GPUs पर फिट होता है)

क्या आपको एलाइन्मेंट प्रशिक्षण (DPO/PPO/RLHF) की आवश्यकता है?
  → हाँ → TRL या LLaMA-Factory
  → अनुसंधान/कस्टम → TRL
  → उत्पादन/आसान → LLaMA-Factory

क्या आपको कॉन्फ़िगरेशन-प्रथम पुनरुत्पादनशीलता चाहिए?
  → हाँ → Axolotl

गैर-तकनीकी टीम या WebUI चाहते हैं?
  → हाँ → LLaMA-Factory

क्या आप बस जल्दी शुरू करना चाहते हैं?
  → LLaMA-Factory या Unsloth

टीम प्रकार के अनुसार

टीम

सिफारिश

कारण

व्यक्तिगत शोधकर्ता

एक मॉडल को फाइन-ट्यून करें

गति + Jupyter नोटबुक

ML इंजीनियर

Axolotl

कॉन्फ़िग-आधारित, पुनरुत्पादनशील

प्रोडक्ट टीम

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

WebUI, विस्तृत मॉडल समर्थन

एलाइन्मेंट टीम

TRL

मूल RLHF प्रिमिटिव्स

स्टार्टअप

Unsloth + TRL

जरूरत पड़ने पर गति + एलाइन्मेंट

Clore.ai GPU सिफारिशें

कार्य

न्यूनतम GPU

अनुशंसित

टूल

7-8B LoRA (QLoRA)

RTX 3080 (10GB)

RTX 3090

एक मॉडल को फाइन-ट्यून करें

13B LoRA

RTX 3090 (24GB)

A6000 (48GB)

Unsloth/Axolotl

70B LoRA

A100 (80GB)

2×A100

Axolotl/TRL

8B पूर्ण FT

A100 (40GB)

A100 (80GB)

कोई भी

DPO/PPO 7B

RTX 4090 (24GB)

A6000 (48GB)

TRL

उपयोगी लिंक

Unsloth GitHub — 23K+ सितारे
Axolotl GitHub — 9K+ सितारे
LLaMA-Factory GitHub — 37K+ सितारे
TRL GitHub — 10K+ सितारे
HuggingFace PEFT दस्तावेज़

सारांश

टूल

उत्तम हेतु

मुख्य लाभ

एक मॉडल को फाइन-ट्यून करें

गति-क्रिटिकल प्रशिक्षण, छोटे GPUs

2-5× तेज़, 70% कम VRAM

Axolotl

कॉन्फ़िग-आधारित, पुनरुत्पादनशील रन

YAML-प्रथम, कई डेटा फ़ॉर्मेट्स

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

100+ मॉडल, WebUI, शुरुआती

अधिकतर मॉडल समर्थन, GUI

TRL

RLHF, DPO, एलाइन्मेंट अनुसंधान

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

अधिकांश Clore.ai उपयोग मामलों के लिए: शुरुआत करें एक मॉडल को फाइन-ट्यून करें (गति + मेमोरी दक्षता), जोड़ें TRL यदि आपको DPO या PPO एलाइन्मेंट प्रशिक्षण की आवश्यकता है।

Previousवेक्टर डेटाबेस तुलना Nextवीडियो जनरेशन तुलना

Last updated 2 days ago

Was this helpful?

hashtagत्वरित निर्णय मैट्रिक्स

hashtagसमीक्षा

hashtagएक मॉडल को फाइन-ट्यून करें

hashtagAxolotl

hashtag🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

hashtagTRL (Transformer Reinforcement Learning)

hashtagस्पीड बेंचमार्क

hashtagप्रशिक्षण गति तुलना (टोकन/सेकेंड)

hashtagVRAM उपयोग तुलना

hashtagसमर्थित मॉडल

hashtagमॉडल समर्थन मैट्रिक्स

hashtagप्रशिक्षण विधि समर्थन

hashtagUnsloth: गहन परिचय

hashtagक्यों यह तेज़ है

hashtagClore.ai पर इंस्टॉलेशन

hashtagपूर्ण प्रशिक्षण स्क्रिप्ट

hashtagAxolotl: गहन परिचय

hashtagकॉन्फ़िगरेशन-प्रथम दृष्टिकोण

hashtagLLaMA-Factory: गहन परिचय

hashtagWebUI वॉकथ्रू

hashtagCLI प्रशिक्षण उदाहरण

hashtagTRL: गहन परिचय

hashtagRLHF पाइपलाइन उदाहरण

hashtagसही टूल चुनना

hashtagनिर्णय प्रवाह

hashtagटीम प्रकार के अनुसार

hashtagClore.ai GPU सिफारिशें

hashtagउपयोगी लिंक

hashtagसारांश

त्वरित निर्णय मैट्रिक्स

समीक्षा

एक मॉडल को फाइन-ट्यून करें

Axolotl

🆕 — HuggingFace का प्रोडक्शन LLM सर्विंग Flash Attention 2 + PagedAttention के साथ —

TRL (Transformer Reinforcement Learning)

स्पीड बेंचमार्क

प्रशिक्षण गति तुलना (टोकन/सेकेंड)

VRAM उपयोग तुलना

समर्थित मॉडल

मॉडल समर्थन मैट्रिक्स

प्रशिक्षण विधि समर्थन

Unsloth: गहन परिचय

क्यों यह तेज़ है

Clore.ai पर इंस्टॉलेशन

पूर्ण प्रशिक्षण स्क्रिप्ट

Axolotl: गहन परिचय

कॉन्फ़िगरेशन-प्रथम दृष्टिकोण

LLaMA-Factory: गहन परिचय

WebUI वॉकथ्रू

CLI प्रशिक्षण उदाहरण

TRL: गहन परिचय

RLHF पाइपलाइन उदाहरण

सही टूल चुनना

निर्णय प्रवाह

टीम प्रकार के अनुसार

Clore.ai GPU सिफारिशें

उपयोगी लिंक

सारांश