Update tests

Author: daniil-lyakhov

src/nncf/quantization/quantize_model.py

@@ -201,6 +201,10 @@ def quantize(
     if backend == BackendType.ONNX:
         from nncf.onnx.quantization.quantize_model import quantize_impl
 
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "ONNX backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         return quantize_impl(  # type: ignore[no-any-return]
             model=model,
             calibration_dataset=calibration_dataset,
@@ -217,6 +221,10 @@ def quantize(
     if backend == BackendType.TORCH:
         from nncf.torch.function_hook.quantization.quantize_model import quantize_impl
 
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "Torch backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         return quantize_impl(  # type: ignore[no-any-return]
             model=model,
             calibration_dataset=calibration_dataset,
@@ -233,6 +241,10 @@ def quantize(
     if backend == BackendType.TORCH_FX:
         from nncf.experimental.torch.fx.quantization.quantize_model import quantize_impl
 
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "TorchFX backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         return quantize_impl(  # type: ignore[no-any-return]
             model=model,
             calibration_dataset=calibration_dataset,
@@ -372,6 +384,10 @@ def quantize_with_accuracy_control(
     if backend == BackendType.ONNX:
         from nncf.onnx.quantization.quantize_model import quantize_with_accuracy_control_impl
 
+        if advanced_quantization_parameters and advanced_quantization_parameters.calibration_device:
+            msg = "ONNX backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         return quantize_with_accuracy_control_impl(  # type: ignore[no-any-return]
             model,
             calibration_dataset,
@@ -528,6 +544,10 @@ def compress_weights(
             msg = "Torch backend does not support statistics caching."
             raise nncf.ParameterNotSupportedError(msg)
 
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "Torch backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         if compression_format == CompressionFormat.FQ and group_size != -1:
             msg = "Torch backend does not support FQ compression format for group-wise quantization."
             raise nncf.ParameterNotSupportedError(msg)
@@ -578,6 +598,10 @@ def compress_weights(
             msg = "TorchFX does not supports statistics caching."
             raise nncf.ParameterNotSupportedError(msg)
 
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "TorchFX backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
+
         if compression_format in [CompressionFormat.FQ, CompressionFormat.FQ_LORA, CompressionFormat.FQ_LORA_NLS]:
             msg = "Torch FX backend does not support FQ, FQ_LORA and FQ_LORA_NLS compression formats."
             raise nncf.ParameterNotSupportedError(msg)
@@ -649,6 +673,10 @@ def compress_weights(
         if advanced_parameters and advanced_parameters.statistics_path:
             msg = "ONNX does not supports statistics caching."
             raise nncf.ParameterNotSupportedError(msg)
+
+        if advanced_parameters and advanced_parameters.calibration_device:
+            msg = "ONNX backend does not support the `calibration_device` option."
+            raise nncf.ParameterNotSupportedError(msg)
         compression_weights_impl = onnx_compress_weights_impl
     if compression_weights_impl is None:
         msg = f"Unsupported type of backend: {backend}"

src/nncf/version.py

@@ -9,4 +9,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "3.2.0.dev0+00576e031"
+__version__ = "3.2.0"

tests/cross_fw/test_templates/template_test_quantize_api.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2026 Intel Corporation
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from abc import ABC
+from abc import abstractmethod
+from typing import TypeVar
+
+import pytest
+
+import nncf
+from nncf.data.dataset import Dataset
+from nncf.quantization.advanced_parameters import AdvancedQuantizationParameters
+
+TModel = TypeVar("TModel")
+
+
+class TemplateTestQuantizeApi(ABC):
+    @staticmethod
+    @abstractmethod
+    def get_simple_model() -> TModel:
+        """Returns a minimal model for the backend."""
+
+    def test_quantize_calibration_device(self):
+        model = self.get_simple_model()
+        with pytest.raises(nncf.ParameterNotSupportedError):
+            nncf.quantize(
+                model,
+                Dataset([0]),
+                advanced_parameters=AdvancedQuantizationParameters(calibration_device="SOME_DEVICE"),
+            )

tests/cross_fw/test_templates/template_test_weights_compression.py

@@ -983,3 +983,17 @@ def test_compression_skipped_with_transposed_activations(self, transpose_a_suppo
                 all_layers=True,
                 **kwargs,
             )
+
+    def test_compress_weights_calibration_device(self):
+        model = self.get_awq_model(non_mergable_pattern=False, is_3d_weights=False)
+        dataset = Dataset([self.to_tensor(np.ones([2, 8, 8]))])
+        with pytest.raises(nncf.ParameterNotSupportedError):
+            compress_weights(
+                model,
+                mode=CompressWeightsMode.INT4_SYM,
+                ratio=1.0,
+                group_size=2,
+                dataset=dataset,
+                awq=True,
+                advanced_parameters=CompressionParams(calibration_device="SOME_DEVICE"),
+            )

tests/onnx/quantization/test_quantize_api.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2026 Intel Corporation
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import numpy as np
+import pytest
+
+import nncf
+from nncf import Dataset
+from nncf.quantization.advanced_parameters import AdvancedQuantizationParameters
+from tests.cross_fw.test_templates.template_test_quantize_api import TemplateTestQuantizeApi
+from tests.onnx.models import LinearModel
+
+INPUT_SHAPE = [1, 3, 32, 32]
+
+
+class TestONNXQuantizeApi(TemplateTestQuantizeApi):
+    @staticmethod
+    def get_simple_model():
+        return LinearModel().onnx_model
+
+    def test_quantize_with_accuracy_control_calibration_device(self):
+        model = self.get_simple_model()
+        dataset = Dataset([np.ones(INPUT_SHAPE, dtype=np.float32)])
+        with pytest.raises(nncf.ParameterNotSupportedError):
+            nncf.quantize_with_accuracy_control(
+                model,
+                dataset,
+                dataset,
+                lambda model, dataset: (1.0, None),
+                advanced_quantization_parameters=AdvancedQuantizationParameters(calibration_device="SOME_DEVICE"),
+            )

tests/openvino/native/quantization/test_quantize_api.py

@@ -8,57 +8,67 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import numpy as np
+import openvino as ov
 import pytest
-from openvino import Model
-from openvino import Shape
-from openvino import Type
-from openvino import op
-from openvino import opset13 as opset
 
 import nncf
 from nncf import Dataset
-from tests.cross_fw.shared.datasets import MockDataset
+from nncf.quantization.advanced_parameters import AdvancedQuantizationParameters
+from tests.cross_fw.test_templates.template_test_quantize_api import TemplateTestQuantizeApi
+from tests.openvino.native.models import LinearModel
 
-INPUT_SHAPE = [2, 1, 1, 1]
+LINEAR_MODEL_INPUT_SHAPE = [1, 3, 4, 2]
 
 
-def get_mock_model() -> Model:
-    param_node = op.Parameter(Type.f32, Shape(INPUT_SHAPE))
-    softmax_axis = 1
-    softmax_node = opset.softmax(param_node, softmax_axis)
-    return Model(softmax_node, [param_node], "mock")
+class TestOVQuantizeApi(TemplateTestQuantizeApi):
+    @staticmethod
+    def get_simple_model() -> ov.Model:
+        return LinearModel().ov_model
 
+    def test_quantize_calibration_device(self, monkeypatch):
+        model = self.get_simple_model()
+        dataset = Dataset([np.ones(LINEAR_MODEL_INPUT_SHAPE, dtype=np.float32)])
+        captured_devices = []
 
-def test_non_positive_subset_size():
-    model_to_test = get_mock_model()
+        original_compile = ov.Core.compile_model
 
-    with pytest.raises(nncf.ValidationError) as e:
-        nncf.quantize(model_to_test, Dataset(MockDataset(INPUT_SHAPE)), subset_size=0)
-        assert "Subset size must be positive." in e.info
+        def mock_compile(self, model, device_name="CPU", config=None):
+            captured_devices.append(device_name)
+            return original_compile(self, model, device_name="CPU", config=config)
 
+        monkeypatch.setattr(ov.Core, "compile_model", mock_compile)
+        nncf.quantize(
+            model,
+            dataset,
+            advanced_parameters=AdvancedQuantizationParameters(calibration_device="SOME_DEVICE"),
+        )
+        assert all(d == "SOME_DEVICE" for d in captured_devices)
 
-def test_quantize_calibration_device(monkeypatch):
-    import numpy as np
-    import openvino as ov
+    def test_quantize_with_accuracy_control_calibration_device(self, monkeypatch):
+        model = self.get_simple_model()
+        dataset = Dataset([np.ones(LINEAR_MODEL_INPUT_SHAPE, dtype=np.float32)])
+        captured_devices = []
 
-    from nncf.quantization.advanced_parameters import AdvancedQuantizationParameters
-    from tests.openvino.native.models import LinearModel
+        original_compile = ov.Core.compile_model
 
-    model_to_test = LinearModel().ov_model
-    input_shape = [inp.shape for inp in model_to_test.inputs][0]
-    dataset = Dataset([np.random.rand(*input_shape).astype(np.float32) for _ in range(2)])
-    captured_devices = []
+        def mock_compile(self, model, device_name="CPU", config=None):
+            captured_devices.append(device_name)
+            return original_compile(self, model, device_name="CPU", config=config)
 
-    original_compile = ov.Core.compile_model
+        monkeypatch.setattr(ov.Core, "compile_model", mock_compile)
+        nncf.quantize_with_accuracy_control(
+            model,
+            dataset,
+            dataset,
+            lambda model, dataset: (1.0, None),
+            advanced_quantization_parameters=AdvancedQuantizationParameters(calibration_device="SOME_DEVICE"),
+        )
+        assert "SOME_DEVICE" in captured_devices
 
-    def mock_compile(self, model, device_name="CPU", config=None):
-        captured_devices.append(device_name)
-        return original_compile(self, model, device_name="CPU", config=config)
+    def test_non_positive_subset_size(self):
+        model_to_test = self.get_simple_model()
 
-    monkeypatch.setattr(ov.Core, "compile_model", mock_compile)
-    nncf.quantize(
-        model_to_test,
-        dataset,
-        advanced_parameters=AdvancedQuantizationParameters(calibration_device="GPU"),
-    )
-    assert any(d == "GPU" for d in captured_devices)
+        with pytest.raises(nncf.ValidationError) as e:
+            nncf.quantize(model_to_test, Dataset([np.ones(LINEAR_MODEL_INPUT_SHAPE, dtype=np.float32)]), subset_size=0)
+            assert "Subset size must be positive." in e.info

tests/openvino/native/quantization/test_weights_compression.py

@@ -2768,26 +2768,26 @@ def test_phi_rope_model(self):
         )
         assert self.get_num_int8_nodes(compressed_model) == 0
 
+    def test_compress_weights_calibration_device(self, monkeypatch):
+        model = AWQMatmulModel().ov_model
+        dataset = Dataset([np.ones([2, 8, 8])])
+        captured_devices = []
 
-def test_compress_weights_calibration_device(monkeypatch):
-    model = AWQMatmulModel().ov_model
-    dataset = Dataset([np.ones([2, 8, 8])])
-    captured_devices = []
-
-    original_compile = ov.Core.compile_model
+        original_compile = ov.Core.compile_model
 
-    def mock_compile(self, model, device_name="CPU", config=None):
-        captured_devices.append(device_name)
-        return original_compile(self, model, device_name="CPU", config=config)
+        def mock_compile(self, model, device_name="CPU", config=None):
+            captured_devices.append(device_name)
+            return original_compile(self, model, device_name="CPU", config=config)
 
-    monkeypatch.setattr(ov.Core, "compile_model", mock_compile)
-    compress_weights(
-        model,
-        mode=CompressWeightsMode.INT4_SYM,
-        ratio=1.0,
-        group_size=2,
-        dataset=dataset,
-        awq=True,
-        advanced_parameters=AdvancedCompressionParameters(calibration_device="GPU"),
-    )
-    assert any(d == "GPU" for d in captured_devices)
+        monkeypatch.setattr(ov.Core, "compile_model", mock_compile)
+        monkeypatch.setenv("NNCF_DISABLE_OPTIMIZED_COMPRESSION", "1")
+        compress_weights(
+            model,
+            mode=CompressWeightsMode.INT4_SYM,
+            ratio=1.0,
+            group_size=2,
+            dataset=dataset,
+            awq=True,
+            advanced_parameters=AdvancedCompressionParameters(calibration_device="SOME_DEVICE"),
+        )
+        assert all(d == "SOME_DEVICE" for d in captured_devices)