Fixes

Dockerfile

@@ -17,11 +17,11 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Install additional dependencies directly
 RUN pip install --no-cache-dir sentence-transformers>=2.2.2
 
-# Download model files
+# Download model files - only use the sentence transformer
 RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
-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)"
+
+# Skip Whisper model preloading - it will be downloaded on first use
+# We don't need to preload it during build
 
 # Run NLTK downloads
 RUN python -m nltk.downloader punkt wordnet

fastapi_app.py

@@ -87,36 +87,24 @@ 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
-                )
+                # Simple direct approach without from_tf
+                from transformers import pipeline
                 
                 models[model_name] = pipeline(
                     "automatic-speech-recognition", 
-                    model=model,
-                    tokenizer=processor,
-                    feature_extractor=processor,
+                    hf_model_name,
                     chunk_length_s=30,
                     stride_length_s=5
                 )
-                logging.info(f"Model {model_name} loaded successfully with from_tf=True")
+                logging.info(f"Model {model_name} loaded successfully using direct pipeline")
             except Exception as e:
-                logging.error(f"Error loading model with from_tf=True, trying with from_tf=False: {str(e)}")
+                logging.error(f"Error loading model with direct pipeline: {str(e)}")
                 try:
-                    # Fallback to regular loading method
+                    # Try with explicit loading but no from_tf
                     from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq, pipeline
                     
                     processor = AutoProcessor.from_pretrained(hf_model_name)
-                    model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                        hf_model_name, 
-                        use_fast=True
-                    )
+                    model = AutoModelForSpeechSeq2Seq.from_pretrained(hf_model_name)
                     
                     models[model_name] = pipeline(
                         "automatic-speech-recognition", 
@@ -126,21 +114,10 @@ def get_model(model_name):
                         chunk_length_s=30,
                         stride_length_s=5
                     )
-                    logging.info(f"Model {model_name} loaded successfully with from_tf=False")
+                    logging.info(f"Model {model_name} loaded successfully with explicit loading")
                 except Exception as 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)}")
+                    logging.error(f"Failed to load model {model_name}: {str(e2)}")
+                    raise RuntimeError(f"Failed to load model {model_name}: {str(e2)}")
         return models[model_name]
 
 def process_audio(audio_data, sample_rate=16000, model_name="openai/whisper-base"):