openvinotoolkit
diff --git a/‎.github/actions/compile-models/convert_pytorch_to_onnx.py‎
Lines changed: 34 additions & 8 deletions b/‎.github/actions/compile-models/convert_pytorch_to_onnx.py‎
Lines changed: 34 additions & 8 deletions
diff --git a/‎.github/actions/compile-models/quantize_onnx.py‎
Lines changed: 10 additions & 0 deletions b/‎.github/actions/compile-models/quantize_onnx.py‎
Lines changed: 10 additions & 0 deletions
diff --git a/‎.github/actions/compile-models/requirements.in‎
Lines changed: 11 additions & 10 deletions b/‎.github/actions/compile-models/requirements.in‎
Lines changed: 11 additions & 10 deletions
@@ -45,6 +45,24 @@ def forward(self, input_ids, attention_mask, pixel_values):
         )
 
 
+class ResNetWrapper(torch.nn.Module):
+    """
+    ResNetForImageClassification returns an ImageClassifierOutputWithNoAttention dataclass.
+    In transformers 5.x, ONNX tracing of this dataclass may expose intermediate feature
+    tensors (e.g. the 2048-dim pooler output) alongside the logits, causing onnxruntime
+    shape inference to fail during quantization with (2048) vs (1000) mismatch.
+    This wrapper ensures only the logits tensor is exported.
+    """
+
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def forward(self, pixel_values):
+        """Returns logits only"""
+        return self.model(pixel_values).logits
+
+
 class PromptEncoderWrapper(torch.nn.Module):
     """
     SamPromptEncoder takes extra input_boxes optional input
@@ -72,24 +90,24 @@ class MaskDecoderWrapper(torch.nn.Module):
     that shouldn't be counted in onnx model inputs.
     """
 
-    def __init__(self, decoder):
+    def __init__(self, decoder, multimask_output: bool):
         super().__init__()
         self.decoder = decoder
+        self.multimask_output = multimask_output
 
     def forward(
         self,
         image_embeddings,
         sparse_prompt_embeddings,
         dense_prompt_embeddings,
-        multimask_output,
     ):
         """Adds extra image_positional_embeddings input"""
         low_res_masks, iou_predictions = self.decoder(
             image_embeddings=image_embeddings,
             image_positional_embeddings=torch.randn_like(image_embeddings),
             sparse_prompt_embeddings=sparse_prompt_embeddings,
             dense_prompt_embeddings=dense_prompt_embeddings,
-            multimask_output=multimask_output,
+            multimask_output=self.multimask_output,
         )
         return low_res_masks, iou_predictions
 
@@ -100,6 +118,7 @@ def convert_pytorch_to_onnx(model: dict, torch_model_path: str):
     onnx_model_path = pytorch_model_dir / f"{model.get('name')}.onnx"
     model_type = model.get("model_type", "")
     convert_config = model.get("Convert", {})
+    export_kwargs = {}
 
     input_names = convert_config.get("input_names", [])
     output_names = convert_config.get("output_names", [])
@@ -108,6 +127,10 @@ def convert_pytorch_to_onnx(model: dict, torch_model_path: str):
     for name, shape in convert_config.get("dynamic_axes", {}).items():
         dynamic_axes[name] = {int(axis): type for axis, type in shape.items()}
 
+    if model_type == "sam_mask_decoder":
+        input_names = [name for name in input_names if name != "multimask_output"]
+        dynamic_axes.pop("multimask_output", None)
+
     if model_type == "transformer":
         tokenizer = AutoTokenizer.from_pretrained(pytorch_model_dir, use_fast=True)
         pytorch_model = AutoModel.from_pretrained(pytorch_model_dir)
@@ -145,6 +168,7 @@ def convert_pytorch_to_onnx(model: dict, torch_model_path: str):
         sam_pytorch_model = SamModel.from_pretrained(pytorch_model_dir)
         processor = SamProcessor.from_pretrained(pytorch_model_dir)
         pytorch_model = sam_pytorch_model.vision_encoder.eval()
+        export_kwargs["dynamo"] = False
 
         image = Image.open(
             requests.get(
@@ -171,23 +195,24 @@ def convert_pytorch_to_onnx(model: dict, torch_model_path: str):
         }
     elif model_type == "sam_mask_decoder":
         sam_pytorch_model = SamModel.from_pretrained(pytorch_model_dir)
-        pytorch_model = MaskDecoderWrapper(sam_pytorch_model.mask_decoder.eval())
+        multimask_output = bool(convert_config.get("multimask_output", False))
+        pytorch_model = MaskDecoderWrapper(
+            sam_pytorch_model.mask_decoder.eval(),
+            multimask_output,
+        )
 
         image_embeddings = torch.rand(convert_config.get("image_embeddings_shape", []))
         sparse_embeddings = torch.rand(
             convert_config.get("sparse_embeddings_shape", [])
         )
         dense_embeddings = torch.rand(convert_config.get("dense_embeddings_shape", []))
-        multimask_output = torch.tensor([0], dtype=torch.bool)
         inputs = {
             "image_embeddings": image_embeddings,
             "sparse_embeddings": sparse_embeddings,
             "dense_embeddings": dense_embeddings,
-            "multimask_output": multimask_output,
         }
     elif model_type == "resnet":
-        pytorch_model = ResNetForImageClassification.from_pretrained(pytorch_model_dir)
-        pytorch_model.eval()
+        pytorch_model = ResNetWrapper(ResNetForImageClassification.from_pretrained(pytorch_model_dir)).eval()
         processor = AutoImageProcessor.from_pretrained(pytorch_model_dir, use_fast=True)
 
         image = Image.open(
@@ -205,6 +230,7 @@ def convert_pytorch_to_onnx(model: dict, torch_model_path: str):
         output_names=output_names,
         dynamic_axes=dynamic_axes,
         opset_version=18,
+        **export_kwargs,
     )
 
     return onnx_model_path
@@ -2,13 +2,23 @@
 Dynamically quantizes an ONNX model
 """
 
+import onnx
 from pathlib import Path
 from onnxruntime.quantization import quantize_dynamic, QuantType
 
 
 def quantize_onnx_model(model: dict, input_model_path: Path):
     """Dynamically quantizes an ONNX model"""
     output_model_path = input_model_path.parent / f"{model.get('name')}_quantized.onnx"
+
+    # Strip intermediate value_info that may contain stale shape annotations from
+    # torch.onnx.export. onnxruntime's quantizer uses onnx.shape_inference.infer_shapes_path
+    # in strict mode, which raises InferenceError when existing annotations conflict with
+    # inferred shapes. Removing them lets onnxruntime infer all shapes from scratch.
+    onnx_model = onnx.load(str(input_model_path))
+    del onnx_model.graph.value_info[:]
+    onnx.save(onnx_model, str(input_model_path))
+
     quantize_dynamic(
         model_input=str(input_model_path),
         model_output=str(output_model_path),
 
@@ -1,21 +1,22 @@
 --extra-index-url https://download.pytorch.org/whl/cpu
 
 # Core
-transformers==4.57.3
-torch==2.8.0+cpu
-torchvision==0.23.0+cpu
-protobuf==6.33.5
-onnx==1.20.0
-onnxruntime==1.23.2
+transformers==5.5.4
+torch==2.11.0+cpu
+torchvision==0.26.0+cpu
+protobuf==7.34.1
+onnx==1.21.0
+onnxruntime==1.24.4
 onnxruntime-tools>=1.7.0
+onnxscript==0.6.2
 
 # Hugging Face Hub
-huggingface_hub==0.36.2
-hf-xet==1.4.2
+huggingface_hub==1.10.2
+hf-xet==1.4.3
 
 # Utils
-pillow>=12.1.1
-requests>=2.32.5
+pillow>=12.2.0
+requests>=2.33.1
 tqdm>=4.67.3
 accelerate>=1.13.0
 urllib3>=2.6.3