# 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.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

***

## ¿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

```bash
# 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](https://clore.ai/marketplace)
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

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

### Paso 3 — Instala LitGPT

```bash
# 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

```bash
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:

```bash
# 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

```bash
# 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)

```bash
# 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`.

```bash
# 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:

```bash
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

```bash
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

```bash
# 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)

```bash
# 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

```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:

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/entrenamiento/litgpt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.