Comment fine-tuner un LLM avec LoRA en 2026

#!/bin/bash
set -e

# Mises à jour pip et torch CUDA
pip install --upgrade pip
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Core libs HF + PEFT/TRL
pip install transformers==4.45.1
pip install peft==0.12.0
pip install trl==0.9.6
pip install datasets==2.21.0
pip install accelerate==0.33.0
pip install bitsandbytes==0.43.1
pip install wandb

# Login HF (remplacez par votre token)
huggingface-cli login

# Vérification CUDA
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, Devices: {torch.cuda.device_count()}')"

from datasets import load_dataset, DatasetDict

# Chargement Dolly-15k (train split seulement pour simplicité)
dataset = load_dataset("databricks/databricks-dolly-15k", split="train")
dataset = dataset.train_test_split(test_size=0.1)  # 90/10 split

# Template Llama-3 pour SFTTrainer
llama_prompt = "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n{instruction}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n{output}<|eot_id|>"

def formatting_prompts_func(example):
    return {'text': llama_prompt.format(instruction=example['instruction'], output=example['output'])}

train_dataset = dataset['train'].map(formatting_prompts_func)
eval_dataset = dataset['test'].map(formatting_prompts_func)

# Sauvegarde local pour réutilisation
train_dataset.save_to_disk('dolly_train')
eval_dataset.save_to_disk('dolly_eval')
print(f'Train: {len(train_dataset)}, Eval: {len(eval_dataset)}')

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, TaskType

model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

# Quantization 4-bit pour QLoRA
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation="flash_attention_2"
)

# Tokenizer avec padding EOS
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# Config LoRA experte : cible attention, r=16 pour balance perf/mémoire
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # ~0.3% trainable

from datasets import load_from_disk
from trl import SFTTrainer, SFTConfig
from peft import LoraConfig

# Datasets préparés
train_dataset = load_from_disk('dolly_train')
eval_dataset = load_from_disk('dolly_eval')

# Hyperparams expertes 2026
sft_config = SFTConfig(
    output_dir="./lora-llama3-dolly",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=50,
    eval_steps=50,
    max_seq_length=2048,
    packing=True,  # Pack prompts pour efficacité
    dataset_num_proc=4,
    report_to="wandb",
    push_to_hub=True,
    gradient_checkpointing=True,
    remove_unused_columns=False,
    warmup_steps=100
)

trainer = SFTTrainer(
    model=model,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer,
    args=sft_config,
    max_seq_length=2048,
    packing=True,
    dataset_text_field="text"
)

trainer.train()
trainer.save_model()
trainer.push_to_hub("votre-username/lora-llama3-dolly")

from peft import PeftModel
from transformers import AutoTokenizer, AutoModelForCausalLM

# Chemin LoRA entraîné
peft_model_id = "./lora-llama3-dolly"

# Load base + adapter
model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct", torch_dtype=torch.bfloat16, device_map="auto")
model = PeftModel.from_pretrained(model, peft_model_id)

# Merge et unload
merged_model = model.merge_and_unload()
merged_model.save_pretrained("merged-lora-llama3")

# Tokenizer
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
tokenizer.pad_token = tokenizer.eos_token

# Test inférence
prompt = "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\nExpliquez LoRA en 3 phrases.<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
inputs = tokenizer(prompt, return_tensors="pt").to(merged_model.device)
outputs = merged_model.generate(**inputs, max_new_tokens=128, temperature=0.7, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

from vllm import LLM, SamplingParams

llm = LLM(model="merged-lora-llama3", tensor_parallel_size=1, dtype="bfloat16")

prompts = [
    "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\nQue fait LoRA ?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
]
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=128)

outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(output.outputs[0].text)