[OpenVINO] Add MedASR (LASR-CTC) model support

Add OpenVINO export, inference, and quantization support for google/medasr
(model_type=lasr_ctc):

Export:
- Add LasrCtcOpenVINOConfig with custom DummyLasrCtcAudioInputGenerator
  (input_features [batch, time, features] + attention_mask)
- Register lasr_ctc in TasksManager custom classes (AutoModelForCTC)

Inference:
- Update OVModelForCTC.forward() to handle input_features naming
  and conditionally pass attention_mask

Quantization:
- Add OVModelForCTC._preprocess_quantization_config() for automatic
  processor resolution (mirrors Whisper/Seq2Seq pattern)
- Add OVModelForCTC branch in build_from_quantization_config() to
  route CTC models to speech-to-text calibration datasets
- Add OVModelForCTC to build_from_dataset() isinstance check
- Add _prepare_ctc_calibration_data() method for collecting audio
  calibration inputs via InferRequestWrapper
- Add CTC model detection in _main_quantize() for weight compression

Tests & Docs:
- Add gated tests (RUN_SLOW_EXPORT_TESTS=1, transformers>=5.0)
- Add MedASR entry to supported models documentation

Verified on Intel Arc iGPU + CPU:
- FP16 and INT8 weight-only: cosine sim >= 0.9999, token match >= 99%
- INT8 full quantization (32 LibriSpeech samples): 2.9x CPU speedup

Author: padatta

docs/source/openvino/models.mdx

@@ -98,6 +98,7 @@ Here is the list of the supported architectures :
 - LongT5
 - M2M-100
 - MAIRA-2
+- MedASR (LASR-CTC)
 - Mamba
 - mBART
 - MPNet

optimum/exporters/openvino/__main__.py

@@ -727,6 +727,15 @@ def _main_quantize(
         except (AttributeError, ImportError, KeyError) as e:
             raise RuntimeError(f"Wasn't able to locate OpenVINO class for task {original_task} ({task}).") from e
 
+
+    # For ASR task, detect CTC models (single openvino_model.xml) vs Seq2Seq (encoder/decoder)
+    if task == "automatic-speech-recognition" and model_cls_name == "OVModelForSpeechSeq2Seq":
+        if (Path(output) / "openvino_model.xml").exists() and not (
+            Path(output) / "openvino_encoder_model.xml"
+        ).exists():
+            model_cls_name = "OVModelForCTC"
+            model_cls = getattr(__import__("optimum.intel", fromlist=[model_cls_name]), model_cls_name)
+
     # Step 2. Load the exported model
     model = model_cls.from_pretrained(
         output,

optimum/exporters/openvino/model_configs.py

@@ -277,6 +277,10 @@ def init_model_configs():
         "transformers",
         "AutoModelForCausalLM",
     )
+    TasksManager._CUSTOM_CLASSES[("pt", "lasr_ctc", "automatic-speech-recognition")] = (
+        "transformers",
+        "AutoModelForCTC",
+    )
 
     # since transformers v4.46, model can be loaded using default AutoModelForImageTextToText
     # https://github.com/huggingface/transformers/blob/v4.46.0/src/transformers/models/auto/modeling_auto.py#L776
@@ -5156,10 +5160,57 @@ class Wav2Vec2OpenVINOConfig(HubertOpenVINOConfig):
         "audio-xvector",
     ],
 )
-class Wav2Vec2ConformerOpenVINOConfig(HubertOpenVINOConfig):
+class Wav2Vec2ConformerOpenVINOConfig(Wav2Vec2ConformerOnnxConfig):
     pass
 
 
+class DummyLasrCtcAudioInputGenerator(DummyAudioInputGenerator):
+    SUPPORTED_INPUT_NAMES = ("input_features", "attention_mask")
+
+    def generate(self, input_name: str, framework: str = "pt", int_dtype: str = "int64", float_dtype: str = "fp32"):
+        if input_name == "attention_mask":
+            return self.random_mask_tensor(
+                shape=[self.batch_size, self.nb_max_frames],
+                framework=framework,
+                dtype=int_dtype,
+            )
+        # MedASR expects input_features shape [batch, time, features] unlike most audio models
+        return self.random_float_tensor(
+            shape=[self.batch_size, self.nb_max_frames, self.feature_size],
+            min_value=-1,
+            max_value=1,
+            framework=framework,
+            dtype=float_dtype,
+        )
+
+
+@register_in_tasks_manager("lasr_ctc", *["feature-extraction", "automatic-speech-recognition", "audio-classification"])
+class LasrCtcOpenVINOConfig(OnnxConfig):
+    NORMALIZED_CONFIG_CLASS = NormalizedConfig.with_args(
+        hidden_size="encoder_config.hidden_size",
+        num_attention_heads="encoder_config.num_attention_heads",
+        num_hidden_layers="encoder_config.num_hidden_layers",
+        allow_new=True,
+        feature_size="encoder_config.num_mel_bins",
+    )
+    DUMMY_INPUT_GENERATOR_CLASSES = (DummyLasrCtcAudioInputGenerator,)
+
+    @property
+    def inputs(self):
+        return {
+            "input_features": {0: "batch_size", 1: "sequence_length", 2: "feature_size"},
+            "attention_mask": {0: "batch_size", 1: "sequence_length"},
+        }
+
+    @property
+    def outputs(self):
+        return {"logits": {0: "batch_size", 1: "sequence_length"}}
+
+
+@register_in_tasks_manager("hubert", *["feature-extraction", "automatic-speech-recognition", "audio-classification"])
+class HubertOpenVINOConfig(HubertOnnxConfig):
+    pass
+
 @register_in_tasks_manager("sew", *["feature-extraction", "automatic-speech-recognition", "audio-classification"])
 class SEWOpenVINOConfig(HubertOpenVINOConfig):
     pass

optimum/intel/openvino/modeling.py

@@ -728,6 +728,16 @@ class OVModelForCTC(OVModel):
     auto_model_class = AutoModelForCTC
     export_feature = "automatic-speech-recognition"
 
+    def _preprocess_quantization_config(
+        self,
+        quantization_config: OVQuantizationConfigBase,
+        model_name_or_path: str,
+    ) -> OVQuantizationConfigBase:
+        if model_name_or_path is not None and quantization_config.processor is None:
+            quantization_config = quantization_config.clone()
+            quantization_config.processor = model_name_or_path
+        return quantization_config
+
     @add_start_docstrings_to_model_forward(
         AUDIO_INPUTS_DOCSTRING.format("batch_size, sequence_length")
         + CTC_EXAMPLE.format(
@@ -742,13 +752,20 @@ def forward(
         attention_mask: Optional[Union[torch.Tensor, np.ndarray]] = None,
         **kwargs,
     ):
+        # Support models using input_features (e.g. MedASR/lasr_ctc) instead of input_values
+        input_features = kwargs.get("input_features", None)
+        if input_values is None and input_features is not None:
+            input_values = input_features
+
         np_inputs = isinstance(input_values, np.ndarray)
 
         input_values = ensure_numpy(input_values)
         attention_mask = ensure_numpy(attention_mask)
 
+        # Use the actual input name expected by the model
+        input_name = "input_features" if "input_features" in self.input_names else "input_values"
         inputs = {
-            "input_values": input_values,
+            input_name: input_values,
         }
 
         # Add the attention_mask when needed

optimum/intel/openvino/quantization.py

@@ -58,7 +58,7 @@
     OVWeightQuantizationConfig,
     _merge_ignored_scopes,
 )
-from .modeling import OVModelForFeatureExtraction, OVModelForMaskedLM, OVModelForZeroShotImageClassification
+from .modeling import OVModelForCTC, OVModelForFeatureExtraction, OVModelForMaskedLM, OVModelForZeroShotImageClassification
 from .modeling_base import OVBaseModel
 from .modeling_decoder import OVBaseDecoderModel, OVModelForCausalLM
 from .modeling_sam import OVSamModel
@@ -281,6 +281,22 @@ def build_from_quantization_config(self, config: OVQuantizationConfigBase) -> OV
 
         if isinstance(self.model, OVModelForCausalLM):
             return self._prepare_causal_lm_calibration_data(config)
+        elif isinstance(self.model, OVModelForCTC):
+            if config.processor is None:
+                raise ValueError(
+                    "`processor` must be specified in order to run data-aware quantization. Please provide it as a"
+                    "model id, or a path to a directory containing all the required configuration files."
+                )
+            dataset_metadata = PREDEFINED_SPEECH_TO_TEXT_DATASETS[config.dataset]
+            return self.build_from_dataset_name(
+                config,
+                dataset_metadata["id"],
+                num_samples=config.num_samples,
+                dataset_split=dataset_metadata["split"],
+                streaming=dataset_metadata["streaming"],
+                data_dir=dataset_metadata.get("data_dir", None),
+                revision=dataset_metadata.get("revision", None),
+            )
         elif isinstance(
             self.model,
             (OVModelForVisualCausalLM, _OVModelForWhisper, OVModelForZeroShotImageClassification, OVSamModel),
@@ -486,6 +502,7 @@ def build_from_dataset(
             isinstance(
                 self.model,
                 (
+                    OVModelForCTC,
                     OVModelForVisualCausalLM,
                     _OVModelForWhisper,
                     OVModelForFeatureExtraction,
@@ -506,7 +523,9 @@ def build_from_dataset(
                     "`batch_size`, `data_collator` and `remove_unused_columns` are not supported for this type of model."
                 )
 
-            if isinstance(self.model, OVModelForVisualCausalLM):
+            if isinstance(self.model, OVModelForCTC):
+                return self._prepare_ctc_calibration_data(quantization_config, dataset)
+            elif isinstance(self.model, OVModelForVisualCausalLM):
                 return self._prepare_visual_causal_lm_calibration_data(quantization_config, dataset)
             elif isinstance(self.model, _OVModelForWhisper):
                 return self._prepare_speech_to_text_calibration_data(quantization_config, dataset)
@@ -955,6 +974,32 @@ def _prepare_speech_to_text_calibration_data(
 
         return OVCalibrationDataset(collected_inputs)
 
+    def _prepare_ctc_calibration_data(
+        self, config: OVQuantizationConfigBase, dataset: "Dataset"
+    ) -> OVCalibrationDataset:
+        """
+        Prepares calibration data for CTC (Connectionist Temporal Classification) models by processing audio samples.
+        """
+        collected_inputs = []
+        self.model.compile()
+        self.model.request = InferRequestWrapper(self.model.request, collected_inputs, apply_caching=True)
+
+        try:
+            processor = AutoProcessor.from_pretrained(config.processor, trust_remote_code=self.trust_remote_code)
+
+            num_samples = config.num_samples or 32
+            dataset = list(tqdm(dataset.take(num_samples), desc="Downloading audio inputs", total=num_samples))
+
+            for item in tqdm(dataset, desc="Collecting calibration data"):
+                audio = item["audio"]["array"]
+                sampling_rate = item["audio"]["sampling_rate"]
+                inputs = processor(audio, sampling_rate=sampling_rate, return_tensors="pt")
+                self.model(**inputs)
+        finally:
+            self.model.request = self.model.request.request
+
+        return OVCalibrationDataset({"model": nncf.Dataset(collected_inputs)})
+
     def _prepare_text_to_text_calibration_data(
         self,
         config: OVQuantizationConfigBase,

tests/openvino/test_export.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 
+import os
 import unittest
 from pathlib import Path
 
@@ -36,6 +37,7 @@
     OVLTXPipeline,
     OVModelForAudioClassification,
     OVModelForCausalLM,
+    OVModelForCTC,
     OVModelForCustomTasks,
     OVModelForFeatureExtraction,
     OVModelForImageClassification,
@@ -134,6 +136,9 @@ class ExportModelTest(unittest.TestCase):
     if is_transformers_version(">=", "5.0"):
         SUPPORTED_ARCHITECTURES.update({"lfm2_moe": OVModelForCausalLM})
 
+    if os.environ.get("RUN_SLOW_EXPORT_TESTS") == "1" and is_transformers_version(">=", "5.0"):
+        SUPPORTED_ARCHITECTURES.update({"lasr_ctc": OVModelForCTC})
+
     EXPECTED_DIFFUSERS_SCALE_FACTORS = {
         "stable-diffusion-xl": {"vae_encoder": "128.0", "vae_decoder": "128.0"},
         "stable-diffusion-3": {"text_encoder_3": "8.0"},

tests/openvino/test_quantization.py

@@ -13,6 +13,7 @@
 #  limitations under the License.
 import dataclasses
 import inspect
+import os
 
 # ruff: noqa
 
@@ -45,6 +46,7 @@
     OVLatentConsistencyModelPipeline,
     OVModelForAudioClassification,
     OVModelForCausalLM,
+    OVModelForCTC,
     OVModelForFeatureExtraction,
     OVModelForImageClassification,
     OVModelForMaskedLM,
@@ -1103,6 +1105,9 @@ class OVWeightCompressionTest(unittest.TestCase):
         SUPPORTED_ARCHITECTURES_WITH_AUTO_COMPRESSION.append((OVModelForVisualCausalLM, "gemma4", False))
         SUPPORTED_ARCHITECTURES_WITH_AUTO_COMPRESSION.append((OVModelForVisualCausalLM, "gemma4_moe", False))
 
+    if os.environ.get("RUN_SLOW_EXPORT_TESTS") == "1" and is_transformers_version(">=", "5.0"):
+        SUPPORTED_ARCHITECTURES_WITH_AUTO_COMPRESSION.append((OVModelForCTC, "lasr_ctc", True))
+
     SUPPORTED_ARCHITECTURES_WITH_HYBRID_QUANTIZATION = [
         (OVStableDiffusionPipeline, "stable-diffusion", 72, 195),
         (OVStableDiffusionXLPipeline, "stable-diffusion-xl", 84, 331),

tests/openvino/utils_tests.py

@@ -356,6 +356,9 @@ def _create_tiny_kokoro_model():
     "videochat_flash_qwen": "optimum-intel-internal-testing/tiny-videochat-flash-qwen",
 }
 
+if os.environ.get("RUN_SLOW_EXPORT_TESTS") == "1" and is_transformers_version(">=", "5.0"):
+    MODEL_NAMES["lasr_ctc"] = "google/medasr"
+
 EAGLE3_MODELS = {"qwen3_eagle3": ("AngelSlim/Qwen3-1.7B_eagle3", "Qwen/Qwen3-1.7B")}
 
 # VLM-based Eagle3 draft models (AngelSlim Eagle3LlamaForCausalLM architecture).
@@ -576,6 +579,7 @@ def _create_tiny_kokoro_model():
     "qwen3_eagle3",
     "qwen3_vl_eagle3",
     "qwen3_asr",
+    "lasr_ctc",
     "videochat_flash_qwen",
 )