Qwen2.5

Ejecuta los LLMs multilingües Qwen2.5 de Alibaba en GPUs de Clore.ai

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.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

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

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:

Ir a Mis Pedidos página
Haz clic en tu pedido
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

# 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

Si obtiene HTTP 502, espere 5-15 minutos: el modelo todavía se está descargando desde HuggingFace.

Modo de razonamiento Qwen3

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.

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

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

Para usar Qwen3 con razonamiento:

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

8GB

32K

Económico

Qwen2.5-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

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)

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

# 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

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

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

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

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)

# 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

# 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

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

# 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

# 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

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)

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

# 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

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:

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

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:

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

# 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

# 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

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

GGUF con llama.cpp

# 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

# 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

100

130

150

Qwen2.5-7B Q4

110

140

180

200

Qwen2.5-14B

Qwen2.5-32B

Qwen2.5-72B

20 (2x)

40 (2x)

Qwen2.5-72B Q4

55 (2x)

Qwen2.5-Coder-32B

Tiempo hasta el primer token (TTFT)

Modelo

RTX 4090

A100 40GB

A100 80GB

60ms

40ms

35ms

14B

120ms

80ms

60ms

32B

200ms

140ms

72B

400ms (2x)

280ms (2x)

Longitud de contexto vs VRAM (7B)

Contexto

FP16

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

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

# 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

# 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

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

Modelo no encontrado

# 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

Multilingüe

Excelente

Bueno

Excelente

Código

Excelente

Bueno

Excelente

Matemáticas

Excelente

Bueno

Excelente

Chino

Excelente

Pobre

Bueno

Licencia

Apache 2.0

Llama 3.1

Proprietario

Costo

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 - Despliegue en producción
Ollama - Configuración local fácil
DeepSeek-V3 - Modelo de razonamiento más grande
DeepSeek-R1 - Modelo de razonamiento de código abierto
Ajustar LLM - Entrenamiento personalizado

AnteriorModelo de Razonamiento DeepSeek-R1 SiguienteCodeLlama

Última actualización hace 1 día

¿Te fue útil?

hashtag¿Por qué Qwen2.5?

hashtagDespliegue rápido en CLORE.AI

hashtagAccediendo a tu servicio

hashtagVerificar que funciona

hashtagModo de razonamiento Qwen3

hashtagVariantes de modelo

hashtagModelos base

hashtagVariantes especializadas

hashtagRequisitos de hardware

hashtagInstalación

hashtagUsando vLLM (Recomendado)

hashtagUsando Ollama

hashtagUsando Transformers

hashtagUso de la API

hashtagAPI compatible con OpenAI

hashtagStreaming

hashtagcURL

hashtagQwen2.5-72B-Instruct

hashtagEjecución vía vLLM (Multi-GPU)

hashtagEjecución vía Ollama

hashtagEjemplo en Python

hashtagQwen2.5-Coder-32B-Instruct

hashtagEjecución vía vLLM

hashtagEjecución vía Ollama

hashtagEjemplos de generación de código

hashtagQwen2.5-Coder

hashtagQwen2.5-Math

hashtagSoporte multilingüe

hashtagContexto largo (128K)

hashtagCuantización

hashtagGGUF con Ollama

hashtagAWQ con vLLM

hashtagGGUF con llama.cpp

hashtagConfiguración multi-GPU

hashtagParalelismo tensorial

hashtagRendimiento

hashtagRendimiento (tokens/seg)

hashtagTiempo hasta el primer token (TTFT)

hashtagLongitud de contexto vs VRAM (7B)

hashtagBenchmarks

hashtagDocker Compose

hashtagEstimación de costos

hashtagSolución de problemas

hashtagMemoria insuficiente

hashtagGeneración lenta

hashtagVisualización de caracteres chinos

hashtagModelo no encontrado

hashtagQwen2.5 vs Otros

hashtagPróximos pasos

¿Por qué Qwen2.5?

Despliegue rápido en CLORE.AI

Accediendo a tu servicio

Verificar que funciona

Modo de razonamiento Qwen3

Variantes de modelo

Modelos base

Variantes especializadas

Requisitos de hardware

Instalación

Usando vLLM (Recomendado)

Usando Ollama

Usando Transformers

Uso de la API

API compatible con OpenAI

Streaming

cURL

Qwen2.5-72B-Instruct

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

Ejecución vía Ollama

Ejemplo en Python

Qwen2.5-Coder-32B-Instruct

Ejecución vía vLLM

Ejecución vía Ollama

Ejemplos de generación de código

Qwen2.5-Coder

Qwen2.5-Math

Soporte multilingüe

Contexto largo (128K)

Cuantización

GGUF con Ollama

AWQ con vLLM

GGUF con llama.cpp

Configuración multi-GPU

Paralelismo tensorial

Rendimiento

Rendimiento (tokens/seg)

Tiempo hasta el primer token (TTFT)

Longitud de contexto vs VRAM (7B)

Benchmarks

Docker Compose

Estimación de costos

Solución de problemas

Memoria insuficiente

Generación lenta

Visualización de caracteres chinos

Modelo no encontrado

Qwen2.5 vs Otros

Próximos pasos