# Llama 3.3 70B

{% hint style="info" %}
**¡Nueva versión disponible!** Meta lanzó [**Llama 4**](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/llama4) en abril de 2025 con arquitectura MoE — Scout (17B activos, cabe en RTX 4090) ofrece calidad similar con una fracción de la VRAM. Considere actualizar.
{% endhint %}

El modelo más reciente y eficiente de 70B de Meta en GPUs CLORE.AI.

{% 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 %}

## ¿Por qué Llama 3.3?

* **Mejor modelo de 70B** - Iguala el rendimiento de Llama 3.1 405B a una fracción del costo
* **Multilingüe** - Soporta 8 idiomas de forma nativa
* **Contexto de 128K** - Procesamiento de documentos largos
* **Pesos abiertos** - Gratis para uso comercial

## Resumen del modelo

| Especificación         | Valor                          |
| ---------------------- | ------------------------------ |
| Parámetros             | 70B                            |
| Longitud de contexto   | 128K tokens                    |
| Datos de entrenamiento | 15T+ tokens                    |
| Idiomas                | EN, DE, FR, IT, PT, HI, ES, TH |
| Licencia               | Licencia comunitaria Llama 3.3 |

### Rendimiento vs otros modelos

| Benchmark   | Llama 3.3 70B | Llama 3.1 405B | GPT-4o |
| ----------- | ------------- | -------------- | ------ |
| MMLU        | 86.0          | 87.3           | 88.7   |
| HumanEval   | 88.4          | 89.0           | 90.2   |
| MATES       | 77.0          | 73.8           | 76.6   |
| Multilingüe | 91.1          | 91.6           | -      |

## Requisitos de GPU

| Configuración | VRAM  | Rendimiento | Costo                    |
| ------------- | ----- | ----------- | ------------------------ |
| Cuantizado Q4 | 40GB  | Bueno       | A100 40GB (\~$0.17/h)    |
| Cuantizado Q8 | 70GB  | Mejor       | A100 80GB (\~$0.25/h)    |
| FP16 completo | 140GB | Mejor       | 2x A100 80GB (\~$0.50/h) |

**Recomendado:** A100 40GB con cuantización Q4 para la mejor relación precio/rendimiento.

## Despliegue rápido en CLORE.AI

### Usando Ollama (lo más fácil)

**Imagen Docker:**

```
ollama/ollama
```

**Puertos:**

```
22/tcp
11434/http
```

**Después del despliegue:**

```bash
ollama pull llama3.3
ollama run llama3.3
```

### Usando vLLM (producción)

**Imagen Docker:**

```
vllm/vllm-openai:latest
```

**Puertos:**

```
22/tcp
8000/http
```

**Comando:**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 1 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

## Métodos de instalación

### Método 1: Ollama (Recomendado para pruebas)

```bash
# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descargar Llama 3.3 (descarga automática la versión Q4)
ollama pull llama3.3

# Ejecutar interactivamente
ollama run llama3.3

# O servir API
ollama serve
```

**Uso de la API:**

```bash
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.3",
  "prompt": "Explica la computación cuántica en términos simples"
}'
```

### Método 2: vLLM (producción)

```bash
pip install vllm

# GPU única (A100 40GB con cuantización AWQ)
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --max-model-len 16384 \
    --host 0.0.0.0

# Multi-GPU (2x A100 para precisión completa)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

**Uso de la API (compatible con OpenAI):**

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

response = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Escribe una función en Python para calcular números de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)
```

### Método 3: Transformers + bitsandbytes

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# Configuración de cuantización a 4 bits
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model_id = "meta-llama/Llama-3.3-70B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

# Generar
messages = [
    {"role": "system", "content": "Eres un asistente de programación servicial."},
    {"role": "user", "content": "Escribe un web scraper en Python usando BeautifulSoup"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Método 4: llama.cpp (híbrido CPU+GPU)

```bash
# Clonar y compilar
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1

# Descargar modelo GGUF
wget https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF/resolve/main/Llama-3.3-70B-Instruct-Q4_K_M.gguf

# Ejecutar servidor
./llama-server \
    -m Llama-3.3-70B-Instruct-Q4_K_M.gguf \
    -c 8192 \
    -ngl 80 \
    --host 0.0.0.0 \
    --port 8080
```

## Benchmarks

### Rendimiento (tokens/segundo)

| GPU          | Q4    | Q8    | FP16  |
| ------------ | ----- | ----- | ----- |
| A100 40GB    | 25-30 | -     | -     |
| A100 80GB    | 35-40 | 25-30 | -     |
| 2x A100 80GB | 50-60 | 40-45 | 30-35 |
| H100 80GB    | 60-70 | 45-50 | 35-40 |

### Tiempo hasta el primer token (TTFT)

| GPU          | Q4       | FP16     |
| ------------ | -------- | -------- |
| A100 40GB    | 0.8-1.2s | -        |
| A100 80GB    | 0.6-0.9s | -        |
| 2x A100 80GB | 0.4-0.6s | 0.8-1.0s |

### Longitud de contexto vs VRAM

| Contexto | VRAM Q4 | VRAM Q8 |
| -------- | ------- | ------- |
| 4K       | 38GB    | 72GB    |
| 8K       | 40GB    | 75GB    |
| 16K      | 44GB    | 80GB    |
| 32K      | 52GB    | 90GB    |
| 64K      | 68GB    | 110GB   |
| 128K     | 100GB   | 150GB   |

## Casos de uso

### Generación de código

```python
messages = [
    {"role": "system", "content": "Eres un programador experto. Escribe código limpio, eficiente y bien documentado."},
    {"role": "user", "content": "Crea una API REST en FastAPI con autenticación de usuario usando tokens JWT"}
]
```

### Análisis de documentos (contexto largo)

```python
# Cargar documento largo
with open("large_document.txt") as f:
    document = f.read()

messages = [
    {"role": "system", "content": "Eres un analista de documentos. Proporciona un análisis detallado y preciso."},
    {"role": "user", "content": f"Analiza este documento y proporciona un resumen con puntos clave:\n\n{document}"}
]
```

### Tareas multilingües

```python
messages = [
    {"role": "system", "content": "Eres un asistente multilingüe."},
    {"role": "user", "content": "Traduce esto a alemán, francés y español: 'The quick brown fox jumps over the lazy dog'"}
]
```

### Razonamiento y análisis

```python
messages = [
    {"role": "system", "content": "Piensa paso a paso. Muestra tu razonamiento."},
    {"role": "user", "content": "Un tren sale de la Estación A a las 9:00 AM viajando a 60 mph. Otro tren sale de la Estación B (a 300 millas) a las 10:00 AM viajando hacia la Estación A a 90 mph. ¿Cuándo y dónde se encuentran?"}
]
```

## Consejos de optimización

### Optimización de memoria

```python
# vLLM con optimización de memoria
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --gpu-memory-utilization 0.95 \
    --max-model-len 8192
```

### Optimización de velocidad

```python
# Habilitar Flash Attention
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --enable-prefix-caching
```

### Procesamiento por lotes

```python
# Procesar múltiples solicitudes de manera eficiente
responses = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=messages,
    n=4,  # Generar 4 respuestas
    temperature=0.8
)
```

## Comparación con otros modelos

| Función      | Llama 3.3 70B | Llama 3.1 70B | Qwen 2.5 72B | Mixtral 8x22B |
| ------------ | ------------- | ------------- | ------------ | ------------- |
| MMLU         | 86.0          | 83.6          | 85.3         | 77.8          |
| Programación | 88.4          | 80.5          | 85.4         | 75.5          |
| Matemáticas  | 77.0          | 68.0          | 80.0         | 60.0          |
| Contexto     | 128K          | 128K          | 128K         | 64K           |
| Idiomas      | 8             | 8             | 29           | 8             |
| Licencia     | Abrir         | Abrir         | Abrir        | Abrir         |

**Veredicto:** Llama 3.3 70B ofrece el mejor rendimiento general en su clase, especialmente para tareas de programación y razonamiento.

## Solución de problemas

### Memoria insuficiente

```bash
# Usar cuantización AWQ (más eficiente en memoria)
--model casperhansen/llama-3.3-70b-instruct-awq --quantization awq

# Reducir la longitud de contexto
--max-model-len 8192

# Usar paralelismo de tensores
--tensor-parallel-size 2
```

### Primera respuesta lenta

* La primera solicitud carga el modelo en la GPU - espere 30-60 segundos
* Usa `--enable-prefix-caching` para solicitudes posteriores más rápidas
* Precalentar con una solicitud falsa

### Acceso a Hugging Face

```bash
# Iniciar sesión en HF (requerido para modelo restringido)
huggingface-cli login

# O establecer una variable de entorno
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

## Estimación de costos

| Configuración | GPU            | $/hora  | tokens/$ |
| ------------- | -------------- | ------- | -------- |
| Económico     | A100 40GB (Q4) | \~$0.17 | \~530K   |
| Equilibrado   | A100 80GB (Q4) | \~$0.25 | \~500K   |
| Rendimiento   | 2x A100 80GB   | \~$0.50 | \~360K   |
| Máximo        | H100 80GB      | \~$0.50 | \~500K   |

## Próximos pasos

* [Guía de vLLM](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) - Despliegue en producción
* [Guía de Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) - Configuración local fácil
* [Configuración multi-GPU](https://docs.clore.ai/guides/guides_v2-es/avanzado/multi-gpu-setup) - Escalar a modelos más grandes
* [Integración de API](https://docs.clore.ai/guides/guides_v2-es/avanzado/api-integration) - Construir aplicaciones