Fixes

Dockerfile

@@ -19,7 +19,9 @@ RUN pip install --no-cache-dir sentence-transformers>=2.2.2
 
 # Download model files
 RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
-RUN python -c "from transformers import pipeline; pipeline('automatic-speech-recognition', 'openai/whisper-base', from_tf=True)"
+RUN python -c "from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq; \
+    processor = AutoProcessor.from_pretrained('openai/whisper-base'); \
+    model = AutoModelForSpeechSeq2Seq.from_pretrained('openai/whisper-base', from_tf=True)"
 
 # Run NLTK downloads
 RUN python -m nltk.downloader punkt wordnet

fastapi_app.py

@@ -87,32 +87,60 @@ def get_model(model_name):
                 logging.info(f"Converting Xenova model {model_name} to {hf_model_name}")
             
             try:
+                # First, try loading the model with from_tf=True
+                from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq, pipeline
+                
+                processor = AutoProcessor.from_pretrained(hf_model_name)
+                model = AutoModelForSpeechSeq2Seq.from_pretrained(
+                    hf_model_name, 
+                    from_tf=True,
+                    use_fast=True
+                )
+                
                 models[model_name] = pipeline(
                     "automatic-speech-recognition", 
-                    hf_model_name,
+                    model=model,
+                    tokenizer=processor,
+                    feature_extractor=processor,
                     chunk_length_s=30,
-                    stride_length_s=5,
-                    from_tf=True,  # Added this parameter to handle TensorFlow models
-                    model_kwargs={"use_fast": True},  # Use fast version of tokenizer
-                    tokenizer_kwargs={"use_fast": True}
+                    stride_length_s=5
                 )
-                logging.info(f"Model {model_name} loaded successfully")
+                logging.info(f"Model {model_name} loaded successfully with from_tf=True")
             except Exception as e:
                 logging.error(f"Error loading model with from_tf=True, trying with from_tf=False: {str(e)}")
                 try:
-                    # Fallback to PyTorch version if TensorFlow fails
+                    # Fallback to regular loading method
+                    from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq, pipeline
+                    
+                    processor = AutoProcessor.from_pretrained(hf_model_name)
+                    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+                        hf_model_name, 
+                        use_fast=True
+                    )
+                    
                     models[model_name] = pipeline(
                         "automatic-speech-recognition", 
-                        hf_model_name,
+                        model=model,
+                        tokenizer=processor,
+                        feature_extractor=processor,
                         chunk_length_s=30,
-                        stride_length_s=5,
-                        model_kwargs={"use_fast": True},  # Use fast version of tokenizer
-                        tokenizer_kwargs={"use_fast": True}
+                        stride_length_s=5
                     )
                     logging.info(f"Model {model_name} loaded successfully with from_tf=False")
                 except Exception as e2:
-                    logging.error(f"Failed to load model {model_name}: {str(e2)}")
-                    raise RuntimeError(f"Failed to load model {model_name}: {str(e2)}")
+                    # Last resort: try direct pipeline with no extra args
+                    try:
+                        from transformers import pipeline
+                        models[model_name] = pipeline(
+                            "automatic-speech-recognition", 
+                            hf_model_name,
+                            chunk_length_s=30,
+                            stride_length_s=5
+                        )
+                        logging.info(f"Model {model_name} loaded successfully with direct pipeline")
+                    except Exception as e3:
+                        logging.error(f"Failed to load model {model_name}: {str(e3)}")
+                        raise RuntimeError(f"Failed to load model {model_name}: {str(e3)}")
         return models[model_name]
 
 def process_audio(audio_data, sample_rate=16000, model_name="openai/whisper-base"):