Entrena modelos con Unsloth y Hugging Face Jobs gratis

Unsloth y Hugging Face Jobs te permiten afinar modelos pequeños de lenguaje de forma rápida, barata y accesible. ¿Quieres experimentar con LFM2.5-1.2B-Instruct y pagar solo unos pocos dólares (o usar créditos gratis)? Aquí te explico paso a paso cómo hacerlo, qué hace Unsloth y cómo usar agentes de código para automatizar el flujo.

Qué ofrece la noticia y por qué importa

Hugging Face anuncia integración con Unsloth para fine-tuning acelerado de LLMs pequeños, junto con créditos gratis si te unes a la organización Unsloth Jobs Explorers. Unsloth promete aproximadamente 2x más velocidad de entrenamiento y ~60% menos uso de VRAM frente a métodos estándar. El resultado: entrenar modelos chicos como LiquidAI/LFM2.5-1.2B-Instruct puede costar solo unos pocos dólares y funcionar en dispositivos con menos de 1 GB de memoria.

¿Por qué enfocarse en modelos pequeños? Porque son económicos, rápidos para iterar y cada vez más competitivos en tareas concretas. LFM2.5-1.2B-Instruct está optimizado para despliegue on-device: CPUs, teléfonos y laptops pueden servir lo que fine-tunees. Eso cambia la ecuación si tu producto necesita latencia baja o despliegue en el borde.

Requisitos y créditos gratis

• Cuenta en Hugging Face (obligatoria para HF Jobs).
• Configurar billing (verificación; puedes monitorear uso en tu página de facturación).
• Un token de Hugging Face con permisos de escritura.
• Opcional: un agente de código como Open Code, Claude Code o Codex.

También ofrecen créditos gratuitos y un mes de Pro si te unes a la organización Unsloth Jobs Explorers. Si estás probando por primera vez, eso puede cubrir varios experimentos.

Flujo técnico: desde el CLI hasta el push al Hub

1. Instala el hf CLI (mac o linux):

curl -LsSf https://hf.co/cli/install.sh | bash

2. Envía un trabajo a HF Jobs usando el ejemplo listo para LFM2.5:

hf jobs uv run https://huggingface.co/datasets/unsloth/jobs/resolve/main/sft-lfm2.5.py \
--flavor a10g-small \
--secrets HF_TOKEN \
--timeout 4h \
--dataset mlabonne/FineTome-100k \
--num-epochs 1 \
--eval-split 0.2 \
--output-repo your-username/lfm-finetuned

3. Revisa la documentación y el script de entrenamiento para ajustar hiperparámetros:

• Script de entrenamiento: https://huggingface.co/datasets/unsloth/jobs/blob/main/sft-lfm2.5.py
• Docs de Hugging Face Jobs: https://huggingface.co/docs/hub/jobs

Qué hace el script y por qué funciona

El ejemplo usa unsloth.FastLanguageModel con load_in_4bit para reducir memoria y acelerar inferencia. Complementa con PEFT (LoRA) para entrenar solo adaptaciones leves del modelo, lo que baja notablemente el costo computacional.

Fragmento clave del script:

from unsloth import FastLanguageModel
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
  "LiquidAI/LFM2.5-1.2B-Instruct",
  load_in_4bit=True,
  max_seq_length=2048,
)

model = FastLanguageModel.get_peft_model(
  model,
  r=16,
  lora_alpha=32,
  lora_dropout=0,
  target_modules=["q_proj","k_proj","v_proj","out_proj","in_proj","w1","w2","w3"],
)

trainer = SFTTrainer(...)
trainer.train()
trainer.push_to_hub()

Puntos importantes:

• load_in_4bit=True reduce memoria usando cuantización; ideal para GPUs pequeñas y despliegue en edge.
• LoRA con r=16 y lora_alpha=32 permite adaptar el modelo sin reentrenar todos los pesos.
• SFTTrainer y SFTConfig manejan batching, acumulación de gradientes y reportes (por ejemplo a Trackio).

Integración con agentes de código (Claude Code, Codex, Open Code)

Si prefieres que un agente genere y lance el trabajo:

• Claude Code: instala la skill desde su marketplace y agrega la skill de Hugging Face Model Trainer.

  • Docs de plugins de Claude Code: https://code.claude.com/docs/en/discover-plugins

• Codex: usa AGENTS.md y .agents/skills/ o ejecuta el instalador de skills:

$skill-installer install https://github.com/huggingface/skills/tree/main/skills/hugging-face-model-trainer

O clona el repo y copia el skill:

git clone https://github.com/huggingface/skills.git
mkdir -p ~/.agents/skills && cp -R skills/skills/hugging-face-model-trainer ~/.agents/skills/

Una vez instalada la skill, pídele al agente: "Train LiquidAI/LFM2.5-1.2B-Instruct on mlabonne/FineTome-100k using Unsloth on HF Jobs". El agente generará el script UV, lo enviará, reportará el job ID y dará el enlace de monitoreo (Trackio). Muy útil si quieres automatizar desde prompts.

Costos orientativos y selección de GPU

Consejos prácticos:

• Sé específico con IDs de modelo y dataset (por ejemplo LiquidAI/LFM2.5-1.2B-Instruct y trl-lib/Capybara). Los agentes validan combinaciones.
• Si quieres que usen Unsloth explícitamente, menciónalo en el prompt; si no, el agente escogerá según presupuesto.
• Pide estimados de costo antes de lanzar trabajos grandes.
• Solicita monitoreo en Trackio para ver curvas de pérdida en tiempo real.
• Después de enviar, revisa logs y métricas con el agente o vía la consola HF Jobs.

Recomendaciones para empezar rápido

• Usa los créditos gratis si calificas: experimenta con 1 epoch y dataset pequeño para validar pipeline.
• Empieza con per_device_train_batch_size pequeño y usa gradient_accumulation_steps para simular batches grandes sin usar mucha VRAM.
• Haz push a tu propio repo en el Hub para versionar y desplegar fácilmente.

Entrenar modelos ya no es solo para grandes equipos con presupuestos enormes. Con herramientas como Unsloth, PEFT y Hugging Face Jobs puedes iterar rápido, gastar poco y desplegar en dispositivos reales. ¿Listo para probar tu primer fine-tune?

Fuente original

https://huggingface.co/blog/unsloth-jobs