# Llama 3.3 70B

{% hint style="info" %}
**¡Nueva versión disponible!** Meta lanzó [**Llama 4**](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) 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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Despliegue en producción
* [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración local fácil
* [Configuración multi-GPU](/guides/guides_v2-es/avanzado/multi-gpu-setup.md) - Escalar a modelos más grandes
* [Integración de API](/guides/guides_v2-es/avanzado/api-integration.md) - Construir aplicaciones


---

# 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/modelos-de-lenguaje/llama33.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.