LitGPT

LitGPT es una biblioteca de alto rendimiento para preentrenamiento, ajuste fino y despliegue de más de 20 modelos de lenguaje grandes construidos sobre PyTorch Lightning. Con más de 12K estrellas en GitHub, es un conjunto de herramientas preferido por ingenieros que necesitan código de entrenamiento de LLM limpio y modificable sin la sobrecarga de abstracción de HuggingFace Transformers.

Cada modelo en LitGPT son ~1.000 líneas de PyTorch limpio: no hay cadenas de herencia de 10 niveles, no hay magia. Puedes leer la implementación de Llama 3 de principio a fin en una tarde y modificarla con confianza.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

---

¿Qué es LitGPT?

LitGPT proporciona implementaciones listas para producción de LLMs de vanguardia con una interfaz de entrenamiento unificada:

• Más de 20 modelos compatibles — Llama 3, Gemma 2, Mistral, Phi-3, Falcon, StableLM y más

• Preentrenamiento desde cero — preentrenamiento completo con Flash Attention, FSDP y checkpointing de gradiente

• Ajuste fino eficiente — ajuste fino completo, LoRA, QLoRA y métodos Adapter

• Servir con confianza — servidor de inferencia incorporado con cuantización

• Soporte Multi-GPU — DDP, FSDP, paralelismo de tensores listo para usar

• Eficiente en memoria — cuantización a 4 bits, checkpointing de gradiente, checkpointing de activaciones

---

Requisitos del servidor

Componente	Mínimo	Recomendado
GPU	RTX 3090 (24 GB)	A100 80 GB / H100
VRAM	16 GB (LoRA 7B)	80 GB+ (70B completo)
RAM	32 GB	64 GB+
CPU	8 núcleos	16+ núcleos
Almacenamiento	100 GB	500 GB+
SO	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11
CUDA	11.8+	12.1+

Requisitos de VRAM por tarea

Tarea	Modelo	VRAM
Inferencia (4 bits)	Llama-3 8B	~6 GB
Ajuste LoRA	Llama-3 8B	~16 GB
Ajuste completo	Llama-3 8B	~80 GB
Ajuste LoRA	Llama-3 70B	~48 GB (2×A100)
Ajuste completo	Llama-3 70B	~640 GB (8×A100)
Ajuste QLoRA	Llama-3 8B	~8 GB

---

Puertos

Puerto	Servicio	Notas
22	SSH	Acceso al terminal y transferencia de archivos
8000	Servidor de inferencia LitGPT	API REST para servir modelos

---

Inicio rápido con Docker

# Extrae la imagen oficial de LitGPT
docker pull pytorchlightning/litgpt:latest

# Ejecuta un contenedor interactivo con GPU
docker run -it --gpus all \
  -p 8000:8000 \
  -v $(pwd)/checkpoints:/checkpoints \
  -v $(pwd)/data:/data \
  pytorchlightning/litgpt:latest \
  bash

# O ejecuta un comando específico directamente
docker run --gpus all \
  -v $(pwd)/checkpoints:/checkpoints \
  pytorchlightning/litgpt:latest \
  litgpt download --repo_id meta-llama/Llama-3.2-3B-Instruct

---

Instalación en Clore.ai

Paso 1 — Alquila un servidor

1. Ve a Mercado de Clore.ai

2. Filtra por VRAM ≥ 24 GB (RTX 3090 o mejor)

3. Selecciona una Imagen base PyTorch o CUDA 12.1 imagen base

4. Abre puertos 22 y 8000 en la configuración de tu pedido

5. Selecciona almacenamiento ≥ 200 GB para los pesos del modelo

Paso 2 — Conéctate vía SSH

ssh root@<ip-del-servidor> -p <puerto-ssh>

Paso 3 — Instala LitGPT

# Instala vía pip (recomendado)
pip install litgpt

# Con todas las extras (cuantización, servidor, etc.)
pip install 'litgpt[all]'

# O instala desde la fuente para las últimas funciones
git clone https://github.com/Lightning-AI/litgpt.git
cd litgpt
pip install -e '.[all]'

Paso 4 — Verifica la instalación

litgpt --help

Salida esperada:

Uso: litgpt [OPTIONS] COMMAND [ARGS]...
  
Comandos:
  chat       Chatear con un modelo
  convert    Convertir pesos de modelo
  download   Descargar pesos de modelo
  evaluate   Evaluar un modelo
  finetune   Ajustar finamente un modelo
  generate   Generar texto
  pretrain   Preentrenar un modelo
  serve      Servir un modelo para inferencia

---

Descargando modelos

LitGPT descarga modelos desde Hugging Face:

# Lista los modelos disponibles
litgpt download --list

# Descarga Llama 3.2 3B (requiere token HF para modelos restringidos)
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --checkpoint_dir checkpoints/

# Descarga Mistral 7B (acceso abierto)
litgpt download \
  --repo_id mistralai/Mistral-7B-Instruct-v0.3

# Descarga Gemma 2 2B
litgpt download \
  --repo_id google/gemma-2-2b-it \
  --access_token tu-token-hf

# Descarga Phi-3 (pequeño pero potente)
litgpt download \
  --repo_id microsoft/Phi-3-mini-4k-instruct

Establecer token de HuggingFace

# Para modelos restringidos (Llama, Gemma)
export HF_TOKEN=hf_tu-token-aqui

# O autenticar vía CLI
pip install huggingface_hub
huggingface-cli login

---

Inferencia (Chat y Generar)

# Chat interactivo
litgpt chat \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct

# Generación única
litgpt generate \
  --prompt "Explica la computación en GPU en términos simples" \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --max_new_tokens 200

# Con temperatura y muestreo
litgpt generate \
  --prompt "Escribe una función en Python para ordenar una lista" \
  --checkpoint_dir checkpoints/mistralai/Mistral-7B-Instruct-v0.3 \
  --temperature 0.7 \
  --top_p 0.9 \
  --max_new_tokens 500

---

Ajuste fino

Ajuste LoRA (recomendado)

LoRA entrena un pequeño conjunto de parámetros adaptadores (típicamente 0.1–1% del total de pesos) mientras el modelo base permanece congelado. Llama 3 8B con LoRA en 10K ejemplos toma ~2 horas en una RTX 3090 con r=16.

# Prepara tu conjunto de datos
# Formato: JSON Lines con {"instruction": "...", "input": "...", "output": "..."}
cat > data/train.json << 'EOF'
{"instruction": "¿Qué es la computación en la nube con GPU?", "input": "", "output": "La computación en la nube con GPU proporciona acceso bajo demanda a hardware GPU a través de internet, permitiendo entrenamiento e inferencia de IA sin poseer hardware físico."}
{"instruction": "¿Cómo alquilo una GPU en Clore.ai?", "input": "", "output": "Visita clore.ai/marketplace, filtra por las especificaciones de GPU, selecciona un servidor, configura los puertos y haz clic en alquilar. El acceso SSH se proporciona de inmediato."}
EOF

# Ajustar con LoRA
litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 3 \
  --train.micro_batch_size 4 \
  --lora_r 8 \
  --lora_alpha 16 \
  --out_dir out/llama-lora-finetuned

# Monitorea el entrenamiento
# LitGPT muestra logs con pérdida, tasa de aprendizaje y ETA

QLoRA (4 bits + LoRA)

Usa QLoRA para ajustar modelos grandes con VRAM limitada. Llama 3 8B cabe en una sola RTX 3090 de 24 GB:

litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --quantize bnb.nf4 \
  --train.epochs 3 \
  --train.micro_batch_size 2 \
  --lora_r 16 \
  --lora_alpha 32 \
  --out_dir out/llama-qlora

Ajuste fino completo

litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 2 \
  --train.micro_batch_size 2 \
  --train.accumulate_gradients 8 \
  --out_dir out/llama-full-finetuned

Entrenamiento Multi-GPU

# Usa FSDP en múltiples GPUs
litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --devices 4 \
  --strategy fsdp \
  --train.epochs 3 \
  --out_dir out/llama-multigpu

---

Servir modelos (API REST)

# Inicia el servidor de inferencia
litgpt serve \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --host 0.0.0.0 \
  --port 8000

# Prueba la API
curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "¿Cuál es la capital de Francia?",
    "max_new_tokens": 100,
    "temperature": 0.7
  }'

Cliente Python

import requests

response = requests.post(
    "http://<ip-del-servidor>:8000/predict",
    json={
        "prompt": "Explica el aprendizaje por refuerzo",
        "max_new_tokens": 500,
        "temperature": 0.8,
        "top_p": 0.9,
    }
)
print(response.json()["output"])

---

Preentrenamiento desde cero

Para entrenar un LLM personalizado desde cero con tus propios datos:

# Prepara datos de preentrenamiento (tokenizados y segmentados)
python scripts/prepare_redpajama.py \
  --source_path /data/raw_text \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --destination_path /data/tokenized

# Inicia el preentrenamiento
litgpt pretrain \
  --model_name Llama-3.2 \
  --data /data/tokenized \
  --train.micro_batch_size 4 \
  --train.max_tokens 10_000_000_000 \
  --devices 8 \
  --strategy fsdp \
  --out_dir out/my-pretrained-llm

---

Conversión y exportación de modelos

# Fusiona pesos LoRA en el modelo base
litgpt merge_lora \
  --checkpoint_dir out/llama-lora-finetuned

# Convierte al formato HuggingFace para distribución
litgpt convert to_hf \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --output_dir hf_model/

# Exporta al formato GGUF (para Ollama/LlamaCpp)
# Usa el script de conversión de llama.cpp después de la exportación HF
python llama.cpp/convert.py hf_model/ --outfile model.gguf

---

Evaluando modelos

# Ejecuta el benchmark MMLU
litgpt evaluate \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --tasks mmlu \
  --num_fewshot 5

# Ejecuta múltiples benchmarks
litgpt evaluate \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --tasks "mmlu,hellaswag,truthfulqa_mc"

---

Recomendaciones de GPU de Clore.ai

LitGPT cubre tres cargas de trabajo distintas — inferencia, ajuste LoRA y preentrenamiento completo — cada una con diferentes requisitos de GPU.

Carga de trabajo	GPU	VRAM	Notas
Inferencia / chat (modelos 7–8B)	RTX 3090	24 GB	Ajusta Llama 3 8B en bf16; ~95 tok/s de generación
Ajuste LoRA (modelos 7–8B)	RTX 3090	24 GB	Opción económica; QLoRA mantiene la VRAM por debajo de 10 GB
Ajuste LoRA (7–8B), iteración rápida	RTX 4090	24 GB	~35% más rápido que la 3090; reduce un trabajo de 2 horas a ~1.4 horas
Ajuste completo (7B) o QLoRA (70B)	A100 40 GB	40 GB	40 GB aloja 7B en precisión completa o 70B en 4 bits
Ajuste completo (13B+) o ejecuciones de preentrenamiento	A100 80 GB	80 GB	Máxima tasa de procesamiento; ~2.800 tok/seg de entrenamiento en 8B

Recomendado para la mayoría de los usuarios: Par de RTX 3090 (2×24 GB = 48 GB efectivo con FSDP). Maneja QLoRA en modelos de 70B, o ajuste completo en modelos de 7B con paralelismo de tensores. Costo en Clore.ai: ~$0.25/h por dos 3090.

Para preentrenamiento o ajuste de >70B: Usa 4×A100 80GB con FSDP. La integración FSDP de LitGPT maneja el sharding de forma transparente — solo pasa --devices 4 --strategy fsdp.

---

Solución de problemas

CUDA Fuera de memoria

# Reduce el tamaño del batch
--train.micro_batch_size 1

# Habilita checkpointing de gradiente
--train.gradient_checkpointing true

# Usa QLoRA en lugar de LoRA
--quantize bnb.nf4

# Revisa la memoria GPU
nvidia-smi

La descarga falla / HuggingFace 401

# Establece el token HF
export HF_TOKEN=hf_tu-token-aqui
huggingface-cli login

# O pásalo directamente
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --access_token hf_tu-token

La pérdida de entrenamiento no disminuye

# Verifica el formato de tus datos — debe ser JSON Lines válido
python -c "
import json
with open('data/train.json') as f:
    for i, line in enumerate(f):
        json.loads(line)
        if i < 3: print(f'Line {i}: OK')
print('All lines valid')
"

# Reduce la tasa de aprendizaje
--train.lr 1e-5  # El valor por defecto suele ser demasiado alto para conjuntos de datos pequeños

# Verifica el tamaño de los datos — LoRA necesita al menos 100-1000 ejemplos
wc -l data/train.json

Puerto del servidor 8000 no accesible

# Verifica que el servidor esté escuchando
ss -tlnp | grep 8000

# Abre el firewall
ufw allow 8000/tcp

# Reinicia el servidor con host explícito
litgpt serve \
  --checkpoint_dir checkpoints/... \
  --host 0.0.0.0 \
  --port 8000

El entrenamiento Multi-GPU se queda colgado

# Verifica la conectividad NCCL
python -c "import torch; print(torch.cuda.device_count())"

# Prueba DDP en lugar de FSDP para modelos más pequeños
--strategy ddp

# Establece variables de entorno NCCL
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1  # Si InfiniBand no está disponible

---

Enlaces útiles

• GitHub: https://github.com/Lightning-AI/litgpt ⭐ 12K+

• Documentación: https://lightning.ai/docs/litgpt

• PyTorch Lightning: https://lightning.ai

• Modelos HuggingFace: https://huggingface.co/models

• Discord: https://discord.gg/lightning-ai

• Mercado de Clore.ai: https://clore.ai/marketplace