Integración de Unsloth

Unsloth es un marco de código abierto para el ajuste fino y el aprendizaje por refuerzo que entrena LLM (como Llama, OpenAI gpt-oss, Mistral, Gemma, DeepSeek y más) hasta 2 veces más rápido con hasta un 80% menos de VRAM. Unsloth permite entrenar, evaluar, ejecutar y desplegar con otros motores de inferencia como llama.cpp, Ollama y vLLM.

La biblioteca ofrece un flujo de trabajo simplificado y compatible con Hugging Face para el entrenamiento, la evaluación, la inferencia y la implementación, y es totalmente compatible con SFTTrainer.

Características principales

Soporte de entrenamiento para todos los modelos compatibles con transformers: texto a voz (TTS), multimodal, BERT, RL y más
Admite ajuste fino completo, preentrenamiento, LoRA, QLoRA, entrenamiento de 8 bits y más
Funciona en Linux, Windows, Colab, Kaggle; GPUs de NVIDIA, próximamente configuraciones de AMD e Intel
Admite la mayoría de las funciones que soporta TRL, incluyendo RLHF (GSPO, GRPO, DPO, etc.)
Los kernels de Triton escritos a mano y un motor de retropropagación manual garantizan que no haya degradación de la precisión (0% de error de aproximación)

Instalación

pip install

Instalación local (se recomienda Linux):

pip install unsloth

También puedes instalar unsloth siguiendo la documentación oficial. Una vez instalado, puedes incorporar unsloth en tu flujo de trabajo de una manera muy sencilla; en lugar de cargar AutoModelForCausalLM, solo necesitas cargar un FastLanguageModel de la siguiente manera:

import torch
from trl import SFTConfig, SFTTrainer
from unsloth import FastLanguageModel

max_length = 2048 # Supports automatic RoPE Scaling, so choose any number

# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/mistral-7b",
    max_seq_length=max_length,
    dtype="auto",  # For auto-detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
    load_in_4bit=True,  # Use 4bit quantization to reduce memory usage. Can be False
)

# Do model patching and add fast LoRA weights
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,  # Dropout = 0 is currently optimized
    bias="none",  # Bias = "none" is currently optimized
    use_gradient_checkpointing=True,
    random_state=3407,
)

training_args = SFTConfig(output_dir="./output", max_length=max_length)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

El modelo guardado es totalmente compatible con la biblioteca transformers de Hugging Face. Obtenga más información sobre unsloth en su repositorio oficial.

Instalación de Docker

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Acceda a Jupyter Lab en http://localhost:8888 y comience a hacer fine-tuning.

Entrenamiento

Estas son algunas configuraciones básicas que puedes activar o desactivar antes del entrenamiento:

max_seq_length = 2048 – Controla la longitud del contexto. Aunque Llama-3 admite 8192, recomendamos 2048 para pruebas. Unsloth permite un ajuste fino con un contexto 4 veces más largo.
dtype = "auto" – Para la detección automática; usa torch.float16 o torch.bfloat16 para GPUs más recientes.
load_in_4bit = True – Habilita la cuantización de 4 bits, reduciendo el uso de memoria 4 veces para el ajuste fino. Deshabilitarlo permite habilitar el ajuste fino de LoRA de 16 bits.
Para habilitar el ajuste fino completo (FFT), establezca full_finetuning = True. Para el ajuste fino de 8 bits, establezca load_in_8bit = True. Nota: solo se puede establecer un método de entrenamiento en True a la vez.

Para obtener más información sobre la configuración de los hiperparámetros y las funciones de Unsloth, lea su guía de documentación aquí.

Guardado del modelo

Unsloth te permite guardar directamente el modelo afinado como un archivo pequeño llamado adaptador LoRA. También puedes subirlo al Hugging Face hub si deseas publicar tu modelo. Recuerda obtener un token de Hugging Face y añadir tu token.

Guardar en GGUF

Para guardar en GGUF, Unsloth utiliza llama.cpp. Para guardar localmente:

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

Para publicar en el hub:

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

Guardar en vLLM

Para guardar en 16 bits para vLLM, use:

model.save_pretrained_merged("model", tokenizer, save_method = "merged_16bit",)
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Update on GitHub

TRL