OpenVINO y SmolVLM: VLM en CPUs Intel en 3 pasos

Cargando...

OpenVINO y SmolVLM: VLM en CPUs Intel en 3 pasos | Keryc

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)

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)

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

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

Cómo hacerlo en 3 pasos

Resultados que reportan y qué significan para ti

Recomendaciones prácticas antes de empezar

Para terminar

¡Mantente al día!

OpenVINO y SmolVLM: VLM en CPUs Intel en 3 pasos