Fine-Tuning de Qwen 3.8 27B con Unsloth: guía completa

# Python 3.10+
python --version

# PyTorch con CUDA (para NVIDIA)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Unsloth (instalación completa)
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

# Dependencias adicionales
pip install transformers datasets trl peft accelerate bitsandbytes

from unsloth import FastModel
import torch

# Configuración
max_seq_length = 2048  # Puedes subir a 4096, 8192, etc.
dtype = None           # Auto-detect (Float16 para Tesla T4, BFloat16 para Ampere+)
load_in_4bit = True    # QLoRA: carga en 4-bit

# Cargar modelo y tokenizer
model, tokenizer = FastModel.from_pretrained(
    model_name="unsloth/Qwen3.8-27B-unsloth-bnb-4bit",
    max_seq_length=max_seq_length,
    dtype=dtype,
    load_in_4bit=load_in_4bit,
    # token="hf_...",  # Tu token de Hugging Face si es necesario
)

# Añadir adapters LoRA al modelo
model = FastModel.get_peft_model(
    model,
    r=16,                          # Rank de LoRA (8, 16, 32, 64, 128)
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,                 # Scaling factor (usualmente = r o 2*r)
    lora_dropout=0,                # 0 es óptimo para QLoRA
    bias="none",
    use_gradient_checkpointing="unsloth",  # Ahorra 30% más VRAM
    random_state=3407,
    use_rslora=False,              # Rank-Stabilized LoRA (opcional)
)

{
  "text": "<|im_start|>system\nEres un asistente útil.<|im_end|>\n<|im_start|>user\n¿Cuál es la capital de Francia?<|im_end|>\n<|im_start|>assistant\nLa capital de Francia es París.<|im_end|>"
}

from datasets import load_dataset

# Dataset de ejemplo (reemplaza con el tuyo)
dataset = load_dataset("yahma/alpaca-cleaned", split="train")

# Función para formatear con el chat template de Qwen
def format_prompt(examples):
    texts = []
    for instruction, input_text, output in zip(
        examples["instruction"],
        examples["input"],
        examples["output"]
    ):
        if input_text:
            prompt = f"{instruction}\n\n{input_text}"
        else:
            prompt = instruction

        # Aplicar chat template de Qwen 3.8
        messages = [
            {"role": "user", "content": prompt},
            {"role": "assistant", "content": output}
        ]
        text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
        texts.append(text)

    return {"text": texts}

# Aplicar formateo
dataset = dataset.map(format_prompt, batched=True)

import pandas as pd
from datasets import Dataset

# Cargar CSV
df = pd.read_csv("mi_dataset.csv")  # Columnas: instruction, input, output
dataset = Dataset.from_pandas(df)
dataset = dataset.map(format_prompt, batched=True)

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    packing=False,  # True para secuencias cortas (ahorra VRAM)

    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,     # Efectivo: batch_size * grad_acc = 8
        warmup_steps=5,
        max_steps=60,                      # Total de pasos de entrenamiento
        learning_rate=2e-4,
        logging_steps=1,
        optim="adamw_8bit",                # Optimizador 8-bit (ahorra VRAM)
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
        report_to="none",                  # Cambia a "wandb" o "tensorboard" si quieres
    ),
)

# ¡Entrenar!
trainer.train()

# Ver uso de GPU
!nvidia-smi

# O en código Python
import torch
print(f"VRAM usada: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
print(f"VRAM reservada: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")

from trl import GRPOConfig, GRPOTrainer

# Configuración GRPO
training_args = GRPOConfig(
    learning_rate=5e-6,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=8,
    max_prompt_length=512,
    max_completion_length=1024,
    num_generations=4,        # Tamaño del grupo GRPO
    beta=0.04,                # Coeficiente KL
    logging_steps=1,
    max_steps=100,
    output_dir="outputs_grpo",
    report_to="none",
)

# Función de recompensa (ejemplo: longitud de respuesta)
def reward_len(completions, **kwargs):
    return [-abs(20 - len(completion)) for completion in completions]

trainer = GRPOTrainer(
    model=model,
    processing_class=tokenizer,
    reward_funcs=[reward_len],
    args=training_args,
    train_dataset=dataset,
)

trainer.train()

# Guardar adapters (pequeño, ~100-500 MB)
model.save_pretrained("lora_adapters")
tokenizer.save_pretrained("lora_adapters")

# Fusionar LoRA con el modelo base para un modelo completo
model.save_pretrained_merged(
    "merged_model_16bit",
    tokenizer,
    save_method="merged_16bit",
)

# Exportar a GGUF con diferentes cuantizaciones
model.save_pretrained_gguf(
    "gguf_model",
    tokenizer,
    quantization_method=[
        "q4_k_m",   # ~18 GB, balance calidad/tamaño
        "q5_k_m",   # ~20 GB, alta calidad
        "q8_0",     # ~30 GB, casi sin pérdida
    ],
)

# FP8 (para servidores con soporte Hopper/Ada)
model.save_pretrained_merged(
    "merged_model_fp8",
    tokenizer,
    save_method="merged_8bit",
)

# Cargar modelo fine-tuneado (adapters)
from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name="unsloth/Qwen3.8-27B-unsloth-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

# Cargar adapters entrenados
model = FastModel.get_peft_model(model, r=16)
model.load_adapter("lora_adapters")

# Generar respuesta
messages = [
    {"role": "user", "content": "¿Cuál es la capital de Francia?"}
]
inputs = tokenizer.apply_chat_template(messages, tokenize=True, return_tensors="pt").to("cuda")

outputs = model.generate(
    input_ids=inputs,
    max_new_tokens=256,
    temperature=0.7,
    top_p=0.95,
)

response = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
print(response)

# Instalar Unsloth para Mac
pip install unsloth

# O usar Unsloth Desktop App
# Descarga desde: https://unsloth.ai

# Soluciones:
# 1. Reduce max_seq_length
max_seq_length = 1024  # En lugar de 2048

# 2. Reduce batch_size
per_device_train_batch_size = 1
gradient_accumulation_steps = 8  # Mantiene batch efectivo de 8

# 3. Activa gradient checkpointing
use_gradient_checkpointing = "unsloth"

# 4. Usa QLoRA en lugar de LoRA
load_in_4bit = True

# Autenticación con Hugging Face
huggingface-cli login
# O en Python:
# from huggingface_hub import login
# login(token="tu_token_aqui")

# En Kaggle, asegúrate de tener GPU activada:
# Settings → Accelerator → GPU T4 x2

# Verificar GPU disponible
import torch
print(torch.cuda.device_count())      # Debe mostrar 2
print(torch.cuda.get_device_name(0))  # Tesla T4