pip install git+https://github.com/huggingface/peft.git -q
pip install transformers datasets accelerate wandb trl bitsandbytes  # Optional: QDoRA
wandb login  # For logging

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, BitsAndBytesConfig

# Dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

def preprocess(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=256)

tokenized = dataset.map(preprocess, batched=True)

# Model (Optional: 4-bit for QDoRA)
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=2,
    quantization_config=quant_config if torch.cuda.is_available() else None,
    device_map="auto"
)

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch

# Prepare for quantized training (if QDoRA)
model = prepare_model_for_kbit_training(model)

# DoRA Config (Just flip use_dora=True!)
dora_config = LoraConfig(
    r=16,                          # Rank (8–64)
    lora_alpha=32,                 # Scaling
    target_modules=["q_lin", "v_lin"],  # DistilBERT attention
    lora_dropout=0.05,
    bias="none",
    task_type="SEQ_CLS",
    use_dora=True                  # 🔥 The magic flag!
)

dora_model = get_peft_model(model, dora_config)
dora_model.print_trainable_parameters()
# Output: trainable params: ~2.3M || all params: 67M || trainable%: 3.4% (2x LoRA due to magnitude)

from transformers import TrainingArguments, Trainer
import numpy as np
from trl import SFTTrainer  # For advanced (optional)

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    preds = np.argmax(logits, axis=1)
    return {"accuracy": (preds == labels).mean()}

args = TrainingArguments(
    output_dir="./dora-imdb",
    num_train_epochs=3,
    per_device_train_batch_size=8,  # Adjust for VRAM
    gradient_accumulation_steps=4,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=2e-4,
    fp16=True,  # Or bf16
    logging_steps=10,
    report_to="wandb",
    run_name="dora-distilbert-imdb"
)

trainer = Trainer(
    model=dora_model,
    args=args,
    train_dataset=tokenized["train"].shuffle().select(range(1000)),  # Subset for speed
    eval_dataset=tokenized["test"].select(range(200)),
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)

trainer.train()

# Save adapter (magnitude + direction)
dora_model.save_pretrained("./dora-adapter")

# Merge (combines magnitude scalar + direction vector)
from peft import PeftModel
base = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
merged = PeftModel.from_pretrained(base, "./dora-adapter")
merged = merged.merge_and_unload()  # Full model, no adapter

merged.save_pretrained("./merged-dora-imdb")

# Inference
from transformers import pipeline
classifier = pipeline("text-classification", model="./merged-dora-imdb")
print(classifier("This film was phenomenal!"))  # [{'label': 'POSITIVE', 'score': 0.98}]

from trl import SFTTrainer

# Load quantized Llama
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B",
    quantization_config=quant_config,
    device_map="auto"
)
model = prepare_model_for_kbit_training(model)

# DoRA Config for Llama
dora_config = LoraConfig(
    r=64,
    lora_alpha=16,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    lora_dropout=0.1,
    use_dora=True,
    task_type="CAUSAL_LM",
    modules_to_save=["lm_head"]
)

dora_model = get_peft_model(model, dora_config)

# Dataset (e.g., Alpaca)
dataset = load_dataset("yahma/alpaca-cleaned")

# SFTTrainer
trainer = SFTTrainer(
    model=dora_model,
    args=args,  # From above, adjust batch=1, accum=32 for 24GB VRAM
    train_dataset=dataset["train"],
    dataset_text_field="text",
    max_seq_length=512,
    packing=True
)

trainer.train()

pip install vllm

from vllm import LLM
llm = LLM(model="./merged-dora-llama", quantization="awq")  # Or bitsandbytes
outputs = llm.generate(["Q: What is DoRA?\nA:"], max_tokens=100)

dora_model.push_to_hub("yourname/dora-sentiment")
# Auto-deploys to https://huggingface.co/spaces

pip install git+https://github.com/huggingface/peft.git
python -c "from peft import LoraConfig; print(LoraConfig(use_dora=True))"