La buena noticia: ahora puedes ejecutar un Vision Language Model (VLM) ligero en una laptop o PC con CPU Intel sin necesitar una gran granja de GPUs. ¿Suena bien? En esta guía te explico, paso a paso y sin jerga inaccesible, cómo convertir, cuantizar y ejecutar un VLM usando Optimum Intel y OpenVINO. (huggingface.co)

Qué es esto y por qué debería importarte

Los VLMs son modelos que combinan visión y lenguaje para describir imágenes, generar subtítulos o responder preguntas sobre contenido visual. Ejecutarlos localmente te da dos ventajas claras: tu información queda en tu máquina y la latencia suele ser mucho menor que depender de un servidor remoto. En este caso la receta usa SmolVLM, un modelo pequeño pensado para recursos limitados, junto con Optimum Intel y OpenVINO para optimizar su despliegue. (huggingface.co)

Cómo hacerlo en 3 pasos

La nota central es simple: convertir, cuantizar y ejecutar. Cada paso tiene comandos concretos que puedes copiar y pegar.

1. Paso 0: instala lo necesario

   Para seguir el tutorial necesitas optimum y openvino. La instalación recomendada es:

   pip install optimum-intel[openvino] transformers==4.52.*
   

   Ejecutar esto te da las herramientas para convertir modelos Hugging Face a OpenVINO y aplicar las optimizaciones. (huggingface.co)

2. Paso 1: convierte tu modelo a OpenVINO

   Tienes dos opciones: usar la CLI o convertir al cargar el modelo desde código. Por ejemplo, con la CLI:

   optimum-cli export openvino -m HuggingFaceTB/SmolVLM2-256M-Video-Instruct smolvlm_ov/
   

   O en Python cuando cargas el modelo:

   from optimum.intel import OVModelForVisualCausalLM
   model_id = "HuggingFaceTB/SmolVLM2-256M-Video-Instruct"
   model = OVModelForVisualCausalLM.from_pretrained(model_id)
   model.save_pretrained("smolvlm_ov")
   

   Convertir a OpenVINO genera el formato IR optimizado para hardware Intel. (huggingface.co)

3. Paso 2: cuantización

   La cuantización reduce la precisión de pesos o activaciones para acelerar la inferencia y reducir memoria. Optimum soporta dos métodos principales:

   • Weight Only Quantization (WOQ): solo los pesos se convierten a baja precisión; es rápido y suele mantener mejor la precisión.
   • Static Quantization: cuantiza pesos y activaciones, requiere calibración con un conjunto de muestras representativas.

   Un ejemplo con WOQ en Python:

   from optimum.intel import OVWeightQuantizationConfig, OVModelForVisualCausalLM
   q_config = OVWeightQuantizationConfig(bits=8)
   q_model = OVModelForVisualCausalLM.from_pretrained(model_id, quantization_config=q_config)
   q_model.save_pretrained("smolvlm_int8")
   

   Y para una configuración mixta donde la parte visual recibe cuantización estática:

   from optimum.intel import OVPipelineQuantizationConfig, OVQuantizationConfig, OVWeightQuantizationConfig
   q_config = OVPipelineQuantizationConfig(
       quantization_configs={
           "lm_model": OVWeightQuantizationConfig(bits=8),
           "text_embeddings_model": OVWeightQuantizationConfig(bits=8),
           "vision_embeddings_model": OVQuantizationConfig(bits=8),
       },
       dataset=dataset,
       num_samples=num_samples,
   )
   

   Es importante probar la precisión después de cuantizar; la ganancia en velocidad puede venir con una pequeña pérdida de exactitud. (huggingface.co)

4. Paso 3: ejecutar la inferencia

   Una vez cuantizado, hacer inferencia es directo:

   generated_ids = q_model.generate(**inputs, max_new_tokens=100)
   generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
   print(generated_texts[0])
   

   Si tienes una laptop Intel reciente o una GPU Intel discreta, puedes cargar el modelo en device="gpu" para aprovecharla. También hay un Space demo para probar las variantes cuantizadas. (huggingface.co)

Resultados que reportan y qué significan para ti

En las pruebas que publicaron, convertir a OpenVINO reduce drásticamente la latencia respecto a la versión PyTorch. Algunos números clave en CPU Intel fueron:

• PyTorch: TTFT ~ 5.15 s, throughput ~ 0.72 tokens/s.
• OpenVINO: TTFT ~ 0.42 s, throughput ~ 47 tokens/s.
• OpenVINO con 8-bit WOQ: TTFT ~ 0.247 s, throughput ~ 63.9 tokens/s.

Es decir, pasar a OpenVINO puede dar un salto de velocidad de varias decenas de veces en tiempo hasta el primer token y multiplicar el throughput. Estos resultados se obtuvieron en una configuración específica con CPUs Intel y OpenVINO 2025.2.0; tu experiencia variará según hardware y ajustes. (huggingface.co)

Convertir y cuantizar puede transformar un modelo pequeño en algo usable en una laptop normal sin GPUs costosas. (huggingface.co)

Recomendaciones prácticas antes de empezar

• Si quieres experimentar rápido, empieza con weight-only quantization; suele ser el menor riesgo para la calidad.

• Si tu caso de uso procesa muchas imágenes o buscas máxima eficiencia en el encoder de visión, prueba la cuantización estática en esa pieza concreta y mide la diferencia.

• Siempre valida resultados y crea un conjunto de pruebas representativas para calibración y evaluación después de cuantizar.

• Revisa la notebook y el Space que acompañan el tutorial para ejemplos listos para probar. (huggingface.co)

Para terminar

No necesitas infraestructura gigante para probar capacidades multimodales hoy. Con modelos pequeños como SmolVLM y herramientas como Optimum Intel y OpenVINO puedes llevar un VLM a una máquina local y obtener latencias útiles para prototipos o aplicaciones privadas. ¿Quieres que te guíe con comandos adaptados a tu equipo o con un ejemplo práctico según tu CPU? Puedo ayudarte a armar los pasos concretos para tu laptop.