Puntos clave
Multimodal + Comprensión de videos largos
Admite imágenes, documentos y videos largos
Adecuado para educación, medios, vigilancia
Localización precisa + Salida estructurada
Detecta objetos con precisión
Extrae datos estructurados de facturas, formularios, gráficos
Útil en finanzas, derecho, logística
¡Puedes comenzar una prueba gratuita en la API de Novita AI de manera muy conveniente!
Qwen2.5-VL-72B-Instruct es un potente modelo grande de visión-lenguaje (LVLM) de 72B parámetros ajustado para tareas de seguimiento de instrucciones. Admite entradas textuales y visuales (imágenes y videos), lo que lo hace ideal para razonamiento multimodal, comprensión de documentos, análisis de video e interacción agéntica.
¿Qué es Qwen2.5-VL-72B?
Un ejemplo para mostrar la capacidad de Qwen2.5-VL-72B
Entrada: Proporciona la consulta: “el usuario está experimentando la función de generación de imágenes”, ¿cuándo ocurre el contenido descrito en el video? Usa segundos para el formato de tiempo.
Salida: El contenido descrito ocurre desde los 28 segundos hasta los 50 segundos en el video. Durante este segmento, el usuario interactúa con la función de generación de imágenes, solicitando y recibiendo una pintura artística de doble escena de una montaña durante el día y la noche. Luego, el usuario agrega un pájaro a la imagen generada, demostrando la funcionalidad de la herramienta de generación de imágenes.
Resumen de Qwen2.5-VL-72B
| Categoría | Elemento | Detalles |
|---|---|---|
| Información básica | Fecha de publicación | 28 de enero de 2025 |
| Tamaño del modelo | 73.4B parámetros | |
| Código abierto | Sí (publicado por Qwen) | |
| Arquitectura | Componentes principales | Entrenamiento de resolución dinámica y frecuencia de cuadros\SwiGLU + RMSNorm + Window Attention\Muestreo dinámico de FPS |
| Soporte de idiomas | Idiomas compatibles | Excelente en documentos multilingües y reconocimiento de texto en escenas |
| Multimodal | Capacidad | Entradas visuales (imágenes y videos) y textuales |
| Contexto | Ventana de contexto | Configurable hasta 64K tokens para videos largos |
| Precisión | Tipo de tensor | BF16 |
| Benchmarks | MMMU (Imagen) | 70.2 (Qwen2.5-VL-72B) vs 70.3 (GPT-4o) |
| MVBench (Video) | 70.4 (Qwen2.5-VL-72B) vs 64.6 (GPT-4o) | |
| AITZ_EM (Agente) | 83.2 (Qwen2.5-VL-72B) vs 35.3 (GPT-4o) |
¿Cómo acceder a Qwen2.5-VL-72B de forma local?
Requisitos de hardware para Qwen2.5-VL-72B
| Categoría | Elemento | Detalles |
|---|---|---|
| Hardware | Nvidia A100 (80 GB) | 8 GPUs × 80 GB = 640 GB VRAM total |
| Nvidia H100 (80 GB) | 8 GPUs × 80 GB = 640 GB VRAM total | |
| RTX 4090 (24 GB) | 24 GPUs × 24 GB = 576 GB VRAM total | |
| Nvidia L40S (48 GB) | 8 GPUs × 48 GB = 384 GB VRAM total |
Instalar Qwen2.5-VL-72B localmente
1. Instalar dependencias
bashCopyEdit<code># Instalar la última versión de Hugging Face Transformers desde el código fuente (necesario para Qwen2.5-VL)<br>pip install git+https://github.com/huggingface/transformers accelerate<br><br># Instalar el kit de utilidades de visión (recomendado con decord para carga rápida de video)<br>pip install 'qwen-vl-utils[decord]==0.0.8'</code>
2. Usar Qwen2.5-VL para preguntas y respuestas visuales
import torch
from transformers import AutoTokenizer, AutoModelForVision2Seq
from qwen_vl_utils import load_image, load_video, build_multimodal_inputs
# 🔧 Nombre del modelo (también se puede usar una ruta local)
model_name = "Qwen/Qwen2.5-VL-7B-Instruct"
# Cargar tokenizer y modelo
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForVision2Seq.from_pretrained(model_name, trust_remote_code=True).eval()
#Cargar una imagen (puede ser ruta local, URL o base64)
image = load_image("https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg")
#Definir la consulta
query = "What is happening in the image?"
#Construir entradas para el modelo
inputs = build_multimodal_inputs(tokenizer, query=query, images=[image])
#Inferencia
with torch.no_grad():
outputs = model.generate(**inputs, max_new_tokens=128)
#Decodificar e imprimir respuesta
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Answer:", response)
3. Ejemplo de entrada de video
video = load_video("path_or_url_to_video.mp4")
query = "Summarize the video content."
inputs = build_multimodal_inputs(tokenizer, query=query, videos=[video])
with torch.no_grad():
outputs = model.generate(**inputs, max_new_tokens=128)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Answer:", response)
¿Cómo acceder a Qwen2.5-VL-72B a través de la API de Novita?
Paso 1: Iniciar sesión y acceder a la Biblioteca de Modelos
Inicia sesión en tu cuenta y haz clic en el botón Model Library.
¡Prueba el Demo de Qwen2-VL-72B-Instruct ahora!
Paso 2: Comenzar tu prueba gratuita
Inicia tu prueba gratuita para explorar las capacidades del modelo seleccionado.
Paso 3: Obtener tu clave API
Para autenticarte con la API, te proporcionaremos una nueva clave API. Ingresa a la página “Settings” y copia la clave API como se indica en la imagen.
Paso 4: Instalar la API
Instala la API usando el gestor de paquetes específico para tu lenguaje de programación.
Después de la instalación, importa las bibliotecas necesarias en tu entorno de desarrollo. Inicializa la API con tu clave API para comenzar a interactuar con Novita AI LLM. Este es un ejemplo de uso de la API de completado de chat para usuarios de Python.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
api_key="<YOUR Novita AI API Key>",
)
model = "qwen/qwen2.5-vl-72b-instruct"
stream = True # or False
max_tokens = 2048
system_content = """Be a helpful assistant"""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }
chat_completion_res = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_content,
},
{
"role": "user",
"content": "Hi there!",
}
],
stream=stream,
max_tokens=max_tokens,
temperature=temperature,
top_p=top_p,
presence_penalty=presence_penalty,
frequency_penalty=frequency_penalty,
response_format=response_format,
extra_body={
"top_k": top_k,
"repetition_penalty": repetition_penalty,
"min_p": min_p
}
)
if stream:
for chunk in chat_completion_res:
print(chunk.choices[0].delta.content or "", end="")
else:
print(chat_completion_res.choices[0].message.content)
Usar Qwen2.5-VL-72B mediante GPU en la nube
Paso 1: Registrar una cuenta
Si eres nuevo en Novita AI, comienza creando una cuenta en nuestro sitio web. Una vez registrado, dirígete a la pestaña “GPUs” para explorar los recursos disponibles y comenzar tu viaje.
Paso 2: Explorar plantillas y servidores GPU
Comienza seleccionando una plantilla que coincida con las necesidades de tu proyecto, como PyTorch, TensorFlow o CUDA. Elige la versión que se ajuste a tus requisitos, por ejemplo PyTorch 2.2.1 o CUDA 11.8.0. Luego, selecciona la configuración del servidor GPU A100, que ofrece un rendimiento potente para manejar cargas de trabajo exigentes con amplia VRAM, RAM y capacidad de disco.
Prueba las GPU de alto rendimiento de Novita AI
Paso 3: Personalizar tu implementación
Después de seleccionar una plantilla y GPU, personaliza la configuración de implementación ajustando parámetros como la versión del sistema operativo (por ejemplo, CUDA 11.8). También puedes modificar otras configuraciones para adaptar el entorno a los requisitos específicos de tu proyecto.
Paso 4: Iniciar una instancia
Una vez que hayas finalizado la plantilla y la configuración de implementación, haz clic en “Launch Instance” para configurar tu instancia GPU. Esto iniciará la configuración del entorno, permitiéndote comenzar a usar los recursos GPU para tus tareas de IA.
Qwen2.5-VL-72B-Instruct ofrece un rendimiento de vanguardia en una amplia gama de tareas de visión-lenguaje. Ya sea que estés automatizando flujos de trabajo en finanzas o analizando videos en tiempo real, combina profundidad, escala y flexibilidad. Con acceso de código abierto y múltiples rutas de implementación (GPU local, instancias en la nube o API), Qwen2.5-VL permite a desarrolladores y empresas construir sistemas de IA más inteligentes y capaces.
Preguntas frecuentes
¿Puedo implementar Qwen2.5-VL-72B-Instruct localmente?
Sí. Puedes ejecutarlo en máquinas con suficiente VRAM (por ejemplo, 8×A100 o 24×4090 GPUs).
¿Cómo uso Qwen2.5-VL-72B-Instruct mediante API?
Puedes acceder a Qwen2.5-VL-72B-Instruct a través de la Biblioteca de Modelos de Novita AI, iniciar una prueba gratuita y obtener una clave API para una integración rápida.
¿Cuál es la diferencia entre Qwen2.5-VL-72B y Qwen2.5-VL-72B-Instruct?
El modelo base maneja tareas generales de visión-lenguaje; la versión “Instruct” está ajustada para seguir instrucciones del usuario con mayor precisión.
Novita AI es una plataforma en la nube de IA que ofrece a los desarrolladores una forma sencilla de implementar modelos de IA utilizando nuestra API simple, al mismo tiempo que proporciona una GPU en la nube asequible y confiable para construir y escalar.
Lecturas recomendadas
- Qwen2.5-VL: Modelo de visión-lenguaje potente pero hambriento de RAM
- Qwen 2.5 72b vs Llama 3.3 70b: ¿Qué modelo se adapta mejor a tus necesidades?
- Qwen 2.5 vs Llama 3.2 90B: Un análisis comparativo de las capacidades de codificación y razonamiento de imágenes
APIs simples y GPU escalable
Novita AI es una plataforma en la nube de IA que ofrece a los desarrolladores una forma sencilla de implementar modelos de IA utilizando nuestra API simple, al mismo tiempo que proporciona una GPU en la nube asequible y confiable para construir y escalar.
