# 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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Despliegue en producción
* [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración local fácil
* [DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) - Modelo de razonamiento más grande
* [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) - Modelo de razonamiento de código abierto
* [Ajustar LLM](/guides/guides_v2-es/entrenamiento/finetune-llm.md) - Entrenamiento personalizado


---

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