Datasets:

OpenVINO
/

documentation

@@ -55,7 +55,7 @@ First, you will need to convert your model to the OpenVINO IR. There are multipl
 1. You can use the [Optimum CLI](https://huggingface.co/docs/optimum-intel/en/openvino/export#using-the-cli)
 ```bash
-optimum-cli export openvino -m HuggingFaceTB/SmolVLM-256M-Instruct  smolvlm_ov/
 ```
 2. Or you can convert it [on the fly](https://huggingface.co/docs/optimum-intel/en/openvino/export#when-loading-your-model) when loading your model:
@@ -63,7 +63,8 @@ optimum-cli export openvino -m HuggingFaceTB/SmolVLM-256M-Instruct  smolvlm_ov/
 ```python
 from optimum.intel import OVModelForVisualCausalLM
-model_id = "HuggingFaceTB/SmolVLM-256M-Instruct"
 model = OVModelForVisualCausalLM.from_pretrained(model_id)
 model.save_pretrained("smolvlm_ov")
 ```
@@ -91,7 +92,7 @@ Weight-only quantization means that only the weights are being quantized and lea
 However, the “interactions” during the trip, like drinking water, remain unchanged. This is similar to what happens to activations, which stay in high precision (FP32 or BF16) to preserve accuracy during computation.
-As a result, the model becomes smaller and more memory-efficient, improving loading times. But since activations are not quantized, inference speed gains are limited unless the workload is memory-bound (memory-bound is when its performance is limited mainly by the speed of reading from or writing to memory, rather than by the processor’s computing power).
 Weight-only quantization is a simple first step since it usually doesn’t result in significant accuracy degradation.
 In order to run it, you will need to create a quantization configuration using Optimum \`OVWeightQuantizationConfig\` as follows
@@ -99,23 +100,39 @@ In order to run it, you will need to create a quantization configuration using O
 ```python
 from optimum.intel import OVModelForVisualCausalLM, OVWeightQuantizationConfig
 q_config = OVWeightQuantizationConfig(bits=8)
 # Apply quantization and save the new model
 q_model = OVModelForVisualCausalLM.from_pretrained(model_id, quantization_config=q_config)
 q_model.save_pretrained("smolvlm_int8")
 ```
 ## Option 2: Static Quantization
 When applying static quantization, quantization is applied on both weights and activations. For this a calibration step is needed in which a dataset subset is used in order to estimate the activations ranges. In the following example we are using 50 samples of the [contextual dataset](https://huggingface.co/datasets/ucla-contextual/contextual_test) to perform this calibration step.
 ```python
 from optimum.intel import OVModelForVisualCausalLM, OVQuantizationConfig
 q_config = OVQuantizationConfig(bits=8, dataset="contextual", num_samples=50)
 q_model = OVModelForVisualCausalLM.from_pretrained(model_id, quantization_config=q_config)
 q_model.save_pretrained("smolvlm_static_int8")
 ```
 Quantizing activations adds small errors that can build up and affect accuracy, so careful testing afterward is important. More information and examples can be found in [our documentation](https://huggingface.co/docs/optimum-intel/en/openvino/optimization#pipeline-quantization).
 ### Step 3: Run inference
@@ -123,13 +140,18 @@ Quantizing activations adds small errors that can build up and affect accuracy,
 You can now run inference with your quantized model :
 ```python
-# Generate outputs with quantized model
 generated_ids = q_model.generate(**inputs, max_new_tokens=500)
 generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
 print(generated_texts[0])
 ```
-Try the complete notebook [here](https://github.com/huggingface/optimum-intel/blob/main/notebooks/openvino/vision_language_quantization.ipynb).
 ## Conclusion

 1. You can use the [Optimum CLI](https://huggingface.co/docs/optimum-intel/en/openvino/export#using-the-cli)
 ```bash
+optimum-cli export openvino -m HuggingFaceTB/SmolVLM2-256M-Video-Instruct smolvlm_ov/
 ```
 2. Or you can convert it [on the fly](https://huggingface.co/docs/optimum-intel/en/openvino/export#when-loading-your-model) when loading your model:
 ```python
 from optimum.intel import OVModelForVisualCausalLM
+model_id = "HuggingFaceTB/SmolVLM2-256M-Video-Instruct"
 model = OVModelForVisualCausalLM.from_pretrained(model_id)
 model.save_pretrained("smolvlm_ov")
 ```
 However, the “interactions” during the trip, like drinking water, remain unchanged. This is similar to what happens to activations, which stay in high precision (FP32 or BF16) to preserve accuracy during computation.
+As a result, the model becomes smaller and more memory-efficient, improving loading times. But since activations are not quantized, inference speed gains are limited. Since OpenVINO 2024.3, if the model's weight have been quantized, the corresponding activations will also be quantized at runtime, leading to additional speedup depending on the device.
 Weight-only quantization is a simple first step since it usually doesn’t result in significant accuracy degradation.
 In order to run it, you will need to create a quantization configuration using Optimum \`OVWeightQuantizationConfig\` as follows
 ```python
 from optimum.intel import OVModelForVisualCausalLM, OVWeightQuantizationConfig
 q_config = OVWeightQuantizationConfig(bits=8)
 # Apply quantization and save the new model
 q_model = OVModelForVisualCausalLM.from_pretrained(model_id, quantization_config=q_config)
 q_model.save_pretrained("smolvlm_int8")
 ```
+or quivalently using the CLI:
+```bash
+optimum-cli export openvino -m HuggingFaceTB/SmolVLM2-256M-Video-Instruct --weight-format int8 smolvlm_int8/
+```
 ## Option 2: Static Quantization
 When applying static quantization, quantization is applied on both weights and activations. For this a calibration step is needed in which a dataset subset is used in order to estimate the activations ranges. In the following example we are using 50 samples of the [contextual dataset](https://huggingface.co/datasets/ucla-contextual/contextual_test) to perform this calibration step.
 ```python
 from optimum.intel import OVModelForVisualCausalLM, OVQuantizationConfig
 q_config = OVQuantizationConfig(bits=8, dataset="contextual", num_samples=50)
 q_model = OVModelForVisualCausalLM.from_pretrained(model_id, quantization_config=q_config)
 q_model.save_pretrained("smolvlm_static_int8")
 ```
+or quivalently using the CLI:
+```bash
+optimum-cli export openvino -m HuggingFaceTB/SmolVLM2-256M-Video-Instruct --quant-mode int8 --dataset contextual --num-samples 50 smolvlm_static_int8/
+```
 Quantizing activations adds small errors that can build up and affect accuracy, so careful testing afterward is important. More information and examples can be found in [our documentation](https://huggingface.co/docs/optimum-intel/en/openvino/optimization#pipeline-quantization).
 ### Step 3: Run inference
 You can now run inference with your quantized model :
 ```python
 generated_ids = q_model.generate(**inputs, max_new_tokens=500)
 generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
 print(generated_texts[0])
 ```
+If you have a recent Intel laptop, Intel AI PC, or Intel discrete GPU, you can load the model on GPU by adding `device="gpu"` when loading your model:
+```python
+model = OVModelForVisualCausalLM.from_pretrained(model_id, device="gpu")
+```
+Try the complete notebook [here](https://github.com/huggingface/optimum-intel/blob/main/notebooks/openvino/vision_language_quantization.ipynb).
 ## Conclusion