Fixes

Dockerfile

@@ -10,18 +10,22 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
+# Create a non-root user to run the application
+RUN useradd -m appuser
+
 # Set environment variables for controlling cache locations
-ENV TRANSFORMERS_CACHE=/app/.cache/huggingface/transformers
-ENV HF_HOME=/app/.cache/huggingface
-ENV HF_DATASETS_CACHE=/app/.cache/huggingface/datasets
-ENV SENTENCE_TRANSFORMERS_HOME=/app/.cache/torch/sentence_transformers
-ENV TORCH_HOME=/app/.cache/torch
+ENV TRANSFORMERS_CACHE=/tmp/.cache/huggingface/transformers
+ENV HF_HOME=/tmp/.cache/huggingface
+ENV HF_DATASETS_CACHE=/tmp/.cache/huggingface/datasets
+ENV SENTENCE_TRANSFORMERS_HOME=/tmp/.cache/torch/sentence_transformers
+ENV TORCH_HOME=/tmp/.cache/torch
 
 # Create cache directories with proper permissions
-RUN mkdir -p /app/.cache/huggingface/transformers
-RUN mkdir -p /app/.cache/huggingface/datasets
-RUN mkdir -p /app/.cache/torch/sentence_transformers
-RUN mkdir -p /app/.cache/torch/hub
+RUN mkdir -p /tmp/.cache/huggingface/transformers && \
+    mkdir -p /tmp/.cache/huggingface/datasets && \
+    mkdir -p /tmp/.cache/torch/sentence_transformers && \
+    mkdir -p /tmp/.cache/torch/hub && \
+    chmod -R 777 /tmp/.cache
 
 # Copy requirements first for better caching
 COPY requirements.txt .
@@ -42,6 +46,13 @@ RUN python -m nltk.downloader punkt wordnet
 # Copy the rest of the application
 COPY . .
 
+# Make sure the non-root user can access the application files
+RUN chown -R appuser:appuser /app
+RUN chmod -R 755 /app
+
+# Switch to non-root user
+USER appuser
+
 # Expose the port Hugging Face Spaces expects (7860)
 EXPOSE 7860
 

fastapi_app.py

@@ -8,7 +8,7 @@ import base64
 import numpy as np
 import torch
 import time
-from transformers import pipeline, AutoProcessor, AutoModelForSpeechSeq2Seq
+from transformers import pipeline
 import threading
 import json
 import logging
@@ -16,32 +16,11 @@ from pydantic import BaseModel
 from typing import Optional, Dict, Any, List
 from topic_segmenter import TopicSegmenter
 from middleware import HTTPSProxyMiddleware
-import tempfile
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Set environment variables for cache directories to writable locations
-os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
-os.environ["HF_HOME"] = "/tmp/hf_home"
-os.environ["XDG_CACHE_HOME"] = "/tmp/xdg_cache"
-os.environ["NLTK_DATA"] = "/tmp/nltk_data"
-
-# Create directories
-for directory in ["/tmp/transformers_cache", "/tmp/hf_home", "/tmp/xdg_cache", "/tmp/nltk_data"]:
-    os.makedirs(directory, exist_ok=True)
-
-# Try to download NLTK data to the tmp directory
-try:
-    import nltk
-    nltk.data.path.append("/tmp/nltk_data")
-    nltk.download('punkt', download_dir="/tmp/nltk_data", quiet=True)
-    nltk.download('wordnet', download_dir="/tmp/nltk_data", quiet=True)
-    nltk.download('omw-1.4', download_dir="/tmp/nltk_data", quiet=True)
-except Exception as e:
-    logger.warning(f"NLTK download issue: {str(e)}")
-
 app = FastAPI(title="Flowify", description="Audio transcription and topic segmentation API")
 
 # Add custom middleware for HTTPS handling
@@ -95,49 +74,68 @@ def get_model(model_name):
         if model_name not in models:
             logging.info(f"Loading model: {model_name}")
             
-            try:
-                # Direct approach to load the model with correct parameters
-                processor = AutoProcessor.from_pretrained(
-                    model_name,
-                    cache_dir="/tmp/transformers_cache",
-                    local_files_only=False
-                )
+            hf_model_name = model_name
+            if model_name.startswith('Xenova/'):
+                base_name = model_name.split('/')[-1] 
+                if '.en' in base_name:
+                    size = base_name.split('.')[0].replace('whisper-', '')
+                    hf_model_name = f"openai/whisper-{size}"
+                else:
+                    size = base_name.replace('whisper-', '')
+                    hf_model_name = f"openai/whisper-{size}"
                 
-                model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                    model_name, 
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                    cache_dir="/tmp/transformers_cache",
-                    local_files_only=False
-                )
+                logging.info(f"Converting Xenova model {model_name} to {hf_model_name}")
+            
+            try:
+                # Load the model using TensorFlow compatibility mode
+                import tensorflow as tf
+                logging.info(f"TensorFlow version: {tf.__version__}")
                 
+                # Configure pipeline with correct parameters to avoid conflicts
                 models[model_name] = pipeline(
-                    "automatic-speech-recognition",
-                    model=model,
-                    tokenizer=processor.tokenizer,
-                    feature_extractor=processor.feature_extractor,
+                    "automatic-speech-recognition", 
+                    model=hf_model_name,
                     chunk_length_s=30,
-                    stride_length_s=5
+                    stride_length_s=5,
+                    framework="tf",  # Explicitly use TensorFlow
+                    model_kwargs={
+                        "attention_mask": True,  # Explicitly set attention mask
+                        "use_cache": True,
+                    }
                 )
-                logging.info(f"Model {model_name} loaded successfully")
-                
+                logging.info(f"Model {model_name} loaded successfully with TensorFlow")
             except Exception as e:
-                logging.error(f"Error loading model: {str(e)}")
-                
-                # Fallback - try using just the pipeline which sometimes works better
+                logging.error(f"Error loading model with TensorFlow: {str(e)}")
                 try:
-                    logging.info(f"Trying fallback method for {model_name}")
+                    # Fallback to PyTorch with more specific configurations
+                    from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
+                    
+                    # First load processor and model separately to customize configs
+                    processor = AutoProcessor.from_pretrained(hf_model_name)
+                    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+                        hf_model_name,
+                        use_cache=True,
+                        attention_mask=True
+                    )
+                    
+                    # Create the pipeline with the initialized model and processor
                     models[model_name] = pipeline(
-                        "automatic-speech-recognition",
-                        model=model_name,
-                        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                        "automatic-speech-recognition", 
+                        model=model,
+                        tokenizer=processor,
+                        feature_extractor=processor,
                         chunk_length_s=30,
-                        stride_length_s=5
+                        stride_length_s=5,
+                        generate_kwargs={
+                            "task": "transcribe",
+                            "language": "english",
+                            # Don't set forced_decoder_ids here to avoid conflict
+                        }
                     )
-                    logging.info(f"Model {model_name} loaded successfully using fallback")
+                    logging.info(f"Model {model_name} loaded successfully with PyTorch")
                 except Exception as e2:
-                    logging.error(f"Fallback loading also failed: {str(e2)}")
-                    raise RuntimeError(f"Failed to load model {model_name}: {str(e)} | Fallback error: {str(e2)}")
-                
+                    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"):
@@ -158,10 +156,14 @@ def process_audio(audio_data, sample_rate=16000, model_name="openai/whisper-base
             
             logging.info(f"Processing chunk {i+1}/{total_chunks}")
             
+            # Use consistent parameters for model inference
             result = model(
                 chunk,
                 return_timestamps=True,
-                generate_kwargs={"language": "english", "task": "transcribe"}
+                generate_kwargs={
+                    "task": "transcribe",
+                    "language": "english"
+                }
             )
             
             if "chunks" in result and len(result["chunks"]) > 0:
@@ -212,8 +214,7 @@ async def analyze_topics(data: TranscriptData):
             min_segment_size=2,  
             topic_similarity_threshold=0.25,  
             max_topics=6,  
-            hierarchical_threshold=0.6,
-            model_name="all-MiniLM-L6-v2"
+            hierarchical_threshold=0.6  
         )
         
         segments, topic_mappings, topic_history, topic_hierarchies = segmenter.segment_transcript(transcript)