# Qwen2.5

Ejecute la familia de modelos Qwen2.5 de Alibaba: potentes LLM multilingües con excelentes capacidades de código y matemáticas en GPUs de 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é Qwen2.5?

* **Tamaños versátiles** - 0.5B a 72B parámetros
* **Multilingüe** - 29 idiomas incluyendo chino
* **Contexto largo** - Hasta 128K tokens
* **Variantes especializadas** - Ediciones Coder, Math
* **Código abierto** - Licencia Apache 2.0

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

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

**Puertos:**

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

**Comando:**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

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

### Verificar que funciona

```bash
# Comprobar si el servicio está listo
curl https://your-http-pub.clorecloud.net/health

# Listar modelos disponibles
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Si obtiene HTTP 502, espere 5-15 minutos: el modelo todavía se está descargando desde HuggingFace.
{% endhint %}

## Modo de razonamiento Qwen3

{% hint style="info" %}
**Novedades en Qwen3:** Algunos modelos Qwen3 admiten un modo de razonamiento que muestra el proceso de pensamiento del modelo en `<think>` etiquetas antes de la respuesta final.
{% endhint %}

Al usar modelos Qwen3 a través de vLLM, las respuestas pueden incluir razonamiento:

```json
{
  "content": "<think>\nDéjame pensar en esto paso a paso...\n</think>\n\nLa respuesta es..."
}
```

Para usar Qwen3 con razonamiento:

```bash
vllm serve Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8000
```

## Variantes de modelo

### Modelos base

| Modelo               | Parámetros | VRAM (FP16) | Contexto | Notas                            |
| -------------------- | ---------- | ----------- | -------- | -------------------------------- |
| Qwen2.5-0.5B         | 0.5B       | 2GB         | 32K      | Edge/pruebas                     |
| Qwen2.5-1.5B         | 1.5B       | 4GB         | 32K      | Muy ligero                       |
| Qwen2.5-3B           | 3B         | 8GB         | 32K      | Económico                        |
| Qwen2.5-7B           | 7B         | 16GB        | 128K     | Equilibrado                      |
| Qwen2.5-14B          | 14B        | 32GB        | 128K     | Alta calidad                     |
| Qwen2.5-32B          | 32B        | 70GB        | 128K     | Calidad muy alta                 |
| Qwen2.5-72B          | 72B        | 150GB       | 128K     | **Mejor calidad**                |
| Qwen2.5-72B-Instruct | 72B        | 150GB       | 128K     | Ajustado para chat/instrucciones |

### Variantes especializadas

| Modelo                     | Enfoque     | Mejor para                         | VRAM (FP16) |
| -------------------------- | ----------- | ---------------------------------- | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Código      | Programación, depuración           | 16GB        |
| Qwen2.5-Coder-14B-Instruct | Código      | Tareas de código complejas         | 32GB        |
| Qwen2.5-Coder-32B-Instruct | Código      | **Mejor modelo para código**       | 70GB        |
| Qwen2.5-Math-7B-Instruct   | Matemáticas | Cálculos, demostraciones           | 16GB        |
| Qwen2.5-Math-72B-Instruct  | Matemáticas | Matemáticas de nivel investigativo | 150GB       |
| Qwen2.5-Instruct           | Chat        | Asistente general                  | varía       |

## Requisitos de hardware

| Modelo    | GPU mínima    | Recomendado  | VRAM (Q4) |
| --------- | ------------- | ------------ | --------- |
| 0.5B-3B   | RTX 3060 12GB | RTX 3080     | 2-6GB     |
| 7B        | RTX 3090 24GB | RTX 4090     | 6GB       |
| 14B       | A100 40GB     | A100 80GB    | 12GB      |
| 32B       | A100 80GB     | 2x A100 40GB | 22GB      |
| 72B       | 2x A100 80GB  | 4x A100 80GB | 48GB      |
| Coder-32B | A100 80GB     | 2x A100 40GB | 22GB      |

## Instalación

### Usando vLLM (Recomendado)

```bash
pip install vllm==0.7.3

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

### Usando Ollama

```bash
# Modelos estándar
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Nuevo: el Qwen2.5 más grande

# Especializados
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Nuevo: mejor modelo para código

# Ejecutar chat
ollama run qwen2.5:7b
```

### Usando Transformers

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

model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [{"role": "user", "content": "¡Hola!"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## Uso de la API

### API compatible con OpenAI

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no-necesaria"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Explica el aprendizaje automático en términos simples."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Escribe un poema sobre la IA"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "¿Qué es Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

El modelo insignia Qwen2.5 — el más grande y capaz de la familia. Compite con GPT-4 en muchos benchmarks y es completamente de código abierto bajo Apache 2.0.

### Ejecución vía vLLM (Multi-GPU)

```bash
# Configuración 4x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9

# AWQ cuantizado — se ejecuta en 2x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq \
    --max-model-len 32768
```

### Ejecución vía Ollama

```bash
# Descargar modelo 72B (requiere 48GB+ VRAM para Q4)
ollama pull qwen2.5:72b

# Ejecutar sesión interactiva
ollama run qwen2.5:72b

# Acceso a la API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analiza este escenario complejo..."}],
  "stream": false
}'
```

### Ejemplo en Python

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

# El modelo 72B sobresale en tareas analíticas complejas
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Eres un analista experto. Proporciona respuestas detalladas y matizadas."
        },
        {
            "role": "user",
            "content": """Compara las diferencias arquitectónicas entre transformer y 
            modelos de espacio de estados (SSMs) para el modelado de secuencias. Incluye compensaciones de eficiencia."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

## Qwen2.5-Coder-32B-Instruct

El mejor modelo de código de código abierto disponible. Qwen2.5-Coder-32B-Instruct iguala o supera a GPT-4o en muchos benchmarks de codificación, soportando más de 40 lenguajes de programación.

### Ejecución vía vLLM

```bash
# A100 80GB única
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.9

# Doble RTX 4090 (24GB cada una = 48GB total, usando cuantización Q4)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq
```

### Ejecución vía Ollama

```bash
# Descargar Coder-32B (requiere ~22GB VRAM para Q4)
ollama pull qwen2.5-coder:32b

# Ejecutar
ollama run qwen2.5-coder:32b

# Probar con un prompt de codificación
ollama run qwen2.5-coder:32b "Escribe un scraper web asíncrono en Python usando aiohttp"
```

### Ejemplos de generación de código

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

# Generación de código full-stack
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Eres un ingeniero de software experto. Escribe código limpio, listo para producción, con manejo adecuado de errores y documentación."
        },
        {
            "role": "user",
            "content": """Escribe un servicio Python FastAPI que:
1. Acepte POST /summarize con cuerpo JSON {"text": "...", "max_length": 150}
2. Use una instancia local de Ollama para resumir el texto
3. Devuelva {"summary": "...", "original_length": N, "summary_length": N}
4. Incluya manejo adecuado de errores, validación de entrada con Pydantic y soporte asíncrono"""
        }
    ],
    temperature=0.1,  # Baja temperatura para código
    max_tokens=3000
)

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

````python
# Revisión de código y depuración
code_to_review = """
def find_duplicates(lst):
    seen = []
    duplicates = []
    for item in lst:
        if item in seen:
            duplicates.append(item)
        seen.append(item)
    return duplicates
"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "user",
            "content": f"Revisa este código Python por problemas de rendimiento y sugiere mejoras:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

## Qwen2.5-Coder

Optimizado para generación de código:

```bash
# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Usando Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Escribe una función en Python que:
1. Tome una lista de números
2. Devuelva el valor mediano
3. Maneje listas vacías de forma correcta
Incluye anotaciones de tipo y docstrings."""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2
)

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

## Qwen2.5-Math

Especializado para razonamiento matemático:

```bash
# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0
```

```python
prompt = """Resuelve paso a paso:
Encuentra todos los valores de x donde: x^3 - 6x^2 + 11x - 6 = 0"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Math-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1
)

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

## Soporte multilingüe

Qwen2.5 soporta 29 idiomas:

```python
# Chino
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "用中文解释什么是人工智能"}]
)

# Japonés
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "人工知能について日本語で説明してください"}]
)

# Coreano
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "인공지능에 대해 한국어로 설명해주세요"}]
)
```

## Contexto largo (128K)

```python
# Leer un documento largo
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": f"Resume este documento:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Cuantización

### GGUF con Ollama

```bash
# Cuantizado a 4 bits
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B en 4 bits (~48GB)

# Cuantizado a 8 bits
ollama pull qwen2.5:7b-instruct-q8_0

# Variantes Coder
ollama pull qwen2.5-coder:32b-instruct-q4_K_M
```

### AWQ con vLLM

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct-AWQ \
    --quantization awq \
    --tensor-parallel-size 2
```

### GGUF con llama.cpp

```bash
# Descargar GGUF
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Ejecutar servidor
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 35
```

## Configuración multi-GPU

### Paralelismo tensorial

```bash
# 72B en 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 32768

# 32B en 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-32B-Instruct \
    --tensor-parallel-size 2

# Coder-32B en 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-32B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 16384
```

## Rendimiento

### Rendimiento (tokens/seg)

| Modelo            | RTX 3090 | RTX 4090 | A100 40GB | A100 80GB |
| ----------------- | -------- | -------- | --------- | --------- |
| Qwen2.5-0.5B      | 250      | 320      | 380       | 400       |
| Qwen2.5-3B        | 150      | 200      | 250       | 280       |
| Qwen2.5-7B        | 75       | 100      | 130       | 150       |
| Qwen2.5-7B Q4     | 110      | 140      | 180       | 200       |
| Qwen2.5-14B       | -        | 55       | 70        | 85        |
| Qwen2.5-32B       | -        | -        | 35        | 50        |
| Qwen2.5-72B       | -        | -        | 20 (2x)   | 40 (2x)   |
| Qwen2.5-72B Q4    | -        | -        | -         | 55 (2x)   |
| Qwen2.5-Coder-32B | -        | -        | 32        | 48        |

### Tiempo hasta el primer token (TTFT)

| Modelo | RTX 4090 | A100 40GB  | A100 80GB  |
| ------ | -------- | ---------- | ---------- |
| 7B     | 60ms     | 40ms       | 35ms       |
| 14B    | 120ms    | 80ms       | 60ms       |
| 32B    | -        | 200ms      | 140ms      |
| 72B    | -        | 400ms (2x) | 280ms (2x) |

### Longitud de contexto vs VRAM (7B)

| Contexto | FP16 | Q8   | Q4   |
| -------- | ---- | ---- | ---- |
| 8K       | 16GB | 10GB | 6GB  |
| 32K      | 24GB | 16GB | 10GB |
| 64K      | 40GB | 26GB | 16GB |
| 128K     | 72GB | 48GB | 28GB |

## Benchmarks

| Modelo            | MMLU  | HumanEval | GSM8K | MATES | LiveCodeBench |
| ----------------- | ----- | --------- | ----- | ----- | ------------- |
| Qwen2.5-7B        | 74.2% | 75.6%     | 85.4% | 55.2% | 42.1%         |
| Qwen2.5-14B       | 79.7% | 81.1%     | 89.5% | 65.8% | 51.3%         |
| Qwen2.5-32B       | 83.3% | 84.2%     | 91.2% | 72.1% | 60.7%         |
| Qwen2.5-72B       | 86.1% | 86.2%     | 93.2% | 79.5% | 67.4%         |
| Qwen2.5-Coder-7B  | 72.8% | 88.4%     | 86.1% | 58.4% | 64.2%         |
| Qwen2.5-Coder-32B | 83.1% | **92.7%** | 92.3% | 76.8% | **78.5%**     |

## Docker Compose

```yaml
versión: '3.8'

services:
  qwen:
    imagen: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    comando: >
      --model Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

| GPU           | Tarifa por hora | Mejor para             |
| ------------- | --------------- | ---------------------- |
| RTX 3090 24GB | \~$0.06         | Modelos 7B             |
| RTX 4090 24GB | \~$0.10         | Modelos 7B-14B         |
| A100 40GB     | \~$0.17         | Modelos 14B-32B        |
| A100 80GB     | \~$0.25         | Modelos 32B, Coder-32B |
| 2x A100 80GB  | \~$0.50         | Modelos 72B            |
| 4x A100 80GB  | \~$1.00         | 72B contexto máximo    |

*Los precios varían según el proveedor. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** mercado para cargas de trabajo flexibles
* Paga con **CLORE** tokens
* Comience con modelos más pequeños (7B) para pruebas

## Solución de problemas

### Memoria insuficiente

```bash
# Reducir el contexto
--max-model-len 8192

# Habilitar optimización de memoria
--gpu-memory-utilization 0.85

# Usar modelo cuantizado
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Generación lenta

```bash
# Habilitar flash attention
pip install flash-attn

# Use vLLM para mejor rendimiento
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Visualización de caracteres chinos

```python
# Asegurar codificación UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modelo no encontrado

```bash
# Verificar nombre del modelo
huggingface-cli search Qwen/Qwen2.5

# Nombres comunes:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Nuevo
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Nuevo
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 vs Otros

| Función     | Qwen2.5-7B | Qwen2.5-72B | Llama 3.1 70B | GPT-4o       |
| ----------- | ---------- | ----------- | ------------- | ------------ |
| Contexto    | 128K       | 128K        | 128K          | 128K         |
| Multilingüe | Excelente  | Excelente   | Bueno         | Excelente    |
| Código      | Excelente  | Excelente   | Bueno         | Excelente    |
| Matemáticas | Excelente  | Excelente   | Bueno         | Excelente    |
| Chino       | Excelente  | Excelente   | Pobre         | Bueno        |
| Licencia    | Apache 2.0 | Apache 2.0  | Llama 3.1     | Proprietario |
| Costo       | Gratis     | Gratis      | Gratis        | API de pago  |

**Use Qwen2.5 cuando:**

* Se necesita soporte del idioma chino
* Las tareas de matemáticas/código son prioridad
* Se requiere contexto largo
* Desee la licencia Apache 2.0
* Necesite el mejor modelo de código de código abierto (Coder-32B)

## Próximos pasos

* [vLLM](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) - Despliegue en producción
* [Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) - Configuración local fácil
* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3) - Modelo de razonamiento más grande
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1) - Modelo de razonamiento de código abierto
* [Ajustar LLM](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/finetune-llm) - Entrenamiento personalizado