Adding Inference Compatibility

README.md

@@ -80,37 +80,6 @@ print(f"Transcription: {transcription}")
 
 -----
 
-### Hosted inference endpoint: selecting a language
-
-For an endpoint deployed with `handler.py`, send a JSON request with the
-language in `parameters.language`:
-
-```json
-{
-  "inputs": "<base64-encoded audio file>",
-  "parameters": {"language": "en"}
-}
-```
-
-Whisper accepts language codes, names, or language tokens, for example `"en"`,
-`"english"`, or `"<|en|>"` for English and `"zh"` for Mandarin Chinese.
-The endpoint passes the selected language to Whisper with `task="transcribe"`
-so the output stays in the source language rather than translating it.
-The same `parameters` object works with `{"inputs": {"audio": "..."}}`
-and `{"audio": "..."}` requests. Use JSON to select a language; raw binary
-requests do not carry parameters.
-
-Omitting `language` or setting it to `null` preserves the model's default
-generation behavior. The checked-in generation configuration leaves the
-language unspecified, allowing Whisper to detect it automatically; the handler
-does not force Mandarin. A language override applies only to its own request.
-Unsupported language strings are rejected by Whisper using the handler's
-existing error response format.
-
-Language selection enables cross-language benchmarking, but this model was
-fine-tuned on Mandarin and improvements in other languages have not been
-established. Redeploy the endpoint after merging handler changes to use this option.
-
 ## Training Data
 
 The model was fine-tuned on the **[AImpower/MandarinStutteredSpeech](https://huggingface.co/datasets/AImpower/MandarinStutteredSpeech)** dataset.  
@@ -165,4 +134,4 @@ If you use this model, please cite the original paper:
   location = {Athens, Greece},
   series = {FAccT '25}
 }
-```
+```

handler.py

@@ -9,7 +9,6 @@ import numpy as np
 import base64
 import io
 import logging
-from copy import deepcopy
 from typing import Dict, Any
 from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
 
@@ -102,9 +101,6 @@ class EndpointHandler:
         1. {"inputs": "base64_encoded_audio_string"}
         2. {"inputs": {"audio": "base64_encoded_audio_string"}}
         3. Binary audio data in request body
-
-        Dictionary requests may include {"parameters": {"language": "en"}}.
-        Omit language (or use null) to keep the model's default behavior.
         
         Args:
             data: Input data dictionary
@@ -114,23 +110,6 @@ class EndpointHandler:
         """
         try:
             logger.info("Processing inference request...")
-
-            generate_kwargs = {}
-            if isinstance(data, dict):
-                parameters = data.get("parameters", {})
-                if not isinstance(parameters, dict):
-                    raise ValueError("'parameters' must be a dictionary")
-                language = parameters.get("language")
-                if language is not None:
-                    if not isinstance(language, str) or not language.strip():
-                        raise ValueError("'language' must be a non-empty string or null")
-                    # Keep language overrides local to this request, including on
-                    # Transformers versions that modify the generation config.
-                    generate_kwargs = {
-                        "generation_config": deepcopy(self.model.generation_config),
-                        "language": language.strip(),
-                        "task": "transcribe",
-                    }
             
             # Extract audio data from various input formats
             waveform = None
@@ -191,9 +170,9 @@ class EndpointHandler:
             # Move to device
             input_features = input_features.to(self.device, dtype=self.torch_dtype)
             
-            # Use the requested language, or the model's defaults when omitted.
+            # Run inference with forced Mandarin Chinese language
             with torch.no_grad():
-                predicted_ids = self.model.generate(input_features, **generate_kwargs)
+                predicted_ids = self.model.generate(input_features)
             
             # Decode transcription
             transcription = self.processor.batch_decode(

tests/test_handler.py

@@ -1,83 +0,0 @@
-"""Handler regression tests; no model weights or endpoint required."""
-
-import unittest
-from types import SimpleNamespace
-from unittest.mock import Mock
-
-from handler import EndpointHandler
-
-
-class LanguageTests(unittest.TestCase):
-    def setUp(self):
-        self.handler = EndpointHandler.__new__(EndpointHandler)
-        self.handler.device = "cpu"
-        self.handler.torch_dtype = None
-        self.handler.model = Mock()
-        self.handler.model.generation_config = SimpleNamespace(language=None)
-        self.features = Mock()
-        self.features.to.return_value = self.features
-        self.handler.processor = Mock(return_value=SimpleNamespace(input_features=self.features))
-        self.handler.processor.batch_decode.return_value = [" test transcription "]
-        self.handler._load_audio_from_base64 = Mock(return_value=[0.0] * 16000)
-        self.handler._load_audio_from_bytes = Mock(return_value=[0.0] * 16000)
-
-    def assert_success(self, request):
-        self.assertEqual(self.handler(request), {
-            "transcription": "test transcription",
-            "audio_duration_seconds": 1.0,
-            "model": "AImpower/StutteredSpeechASR",
-        })
-
-    def test_languages_and_json_audio_formats(self):
-        for language in ("en", "english", "<|en|>", "zh", " en "):
-            for audio in ({"inputs": "audio"}, {"inputs": {"audio": "audio"}},
-                          {"audio": "audio"}, {"inputs": b"audio"}):
-                with self.subTest(language=language, audio=audio):
-                    self.assert_success({**audio, "parameters": {"language": language}})
-                    args, kwargs = self.handler.model.generate.call_args
-                    self.assertEqual(args, (self.features,))
-                    self.assertEqual(kwargs["language"], language.strip())
-                    self.assertEqual(kwargs["task"], "transcribe")
-                    self.assertIsNot(kwargs["generation_config"], self.handler.model.generation_config)
-
-    def test_default_requests_keep_existing_generation_call(self):
-        for request in ({"inputs": "audio"}, {"inputs": "audio", "parameters": {}},
-                        {"inputs": "audio", "parameters": {"language": None}},
-                        b"audio", bytearray(b"audio")):
-            with self.subTest(request=request):
-                self.assert_success(request)
-                self.handler.model.generate.assert_called_with(self.features)
-
-    def test_language_does_not_leak_between_requests(self):
-        def generate(features, **kwargs):
-            if "generation_config" in kwargs:
-                kwargs["generation_config"].language = kwargs["language"]
-            return [[1]]
-        self.handler.model.generate.side_effect = generate
-        for language in ("en", "zh"):
-            self.assert_success({"inputs": "audio", "parameters": {"language": language}})
-            self.assertIsNone(self.handler.model.generation_config.language)
-        self.assert_success({"inputs": "audio"})
-        self.handler.model.generate.assert_called_with(self.features)
-
-    def test_invalid_parameter_shapes_return_existing_error_format(self):
-        for parameters in (None, [], "en", {"language": ""}, {"language": " "},
-                           {"language": 123}, {"language": ["en"]}):
-            with self.subTest(parameters=parameters):
-                result = self.handler({"inputs": "audio", "parameters": parameters})
-                self.assertIsNone(result["transcription"])
-                self.assertIn("error", result)
-        self.handler.model.generate.assert_not_called()
-
-    def test_unsupported_language_error_is_returned(self):
-        self.handler.model.generate.side_effect = ValueError("Unsupported language: invalid")
-        result = self.handler({"inputs": "audio", "parameters": {"language": "invalid"}})
-        self.assertEqual(result, {"error": "Unsupported language: invalid", "transcription": None})
-
-    def test_unrelated_parameters_are_not_forwarded(self):
-        self.assert_success({"inputs": "audio", "parameters": {"max_new_tokens": 1}})
-        self.handler.model.generate.assert_called_with(self.features)
-
-
-if __name__ == "__main__":
-    unittest.main()