updated main.py

Dockerfile

@@ -1,12 +1,36 @@
+# Use official Python image
 FROM python:3.10-slim
 
+# Set working directory
 WORKDIR /app
 
+# Copy requirements and install dependencies
 COPY requirements.txt .
-RUN pip install --no-cache-dir --upgrade pip
-RUN pip install --no-cache-dir -r requirements.txt
 
+# Upgrade pip and install pinned dependencies
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# Copy all code and model files
 COPY . .
 
+# Set Transformers cache to a writable folder
+ENV TRANSFORMERS_CACHE=/tmp/hf_cache
+
+# Expose FastAPI port
 EXPOSE 7860
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# Precompute embeddings at build time (optional: adjust if dataset is large)
+RUN python -c "\
+import os, torch, pandas as pd;\
+from sentence_transformers import SentenceTransformer;\
+model = SentenceTransformer('./muril_combined_multilingual_model');\
+df = pd.read_csv('./muril_multilingual_dataset.csv').dropna(subset=['question','answer']);\
+answers = df['answer'].tolist();\
+embeddings = model.encode(answers, convert_to_tensor=True);\
+torch.save(embeddings, './answer_embeddings.pt');\
+print('✅ Precomputed embeddings saved');\
+"
+
+# Run FastAPI with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "]()

main.py

@@ -1,33 +1,37 @@
 import os
-os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache"
+os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache"  # MUST be before importing SentenceTransformer
+
 import torch
-from fastapi import FastAPI, Query
+import pandas as pd
+from fastapi import FastAPI
 from pydantic import BaseModel
 from sentence_transformers import SentenceTransformer, util
-import pandas as pd
-from langdetect import detect, DetectorFactory
-
-# Fix langdetect randomness
-DetectorFactory.seed = 0
+from langdetect import detect
 
 # --- Configuration ---
 MODEL_PATH = './muril_combined_multilingual_model'
 CSV_PATH = './muril_multilingual_dataset.csv'
+EMBEDDINGS_PATH = './answer_embeddings.pt'
 
 # --- Load MuRIL Model and Dataset ---
 def load_resources():
     try:
         model = SentenceTransformer(MODEL_PATH)
-        df = pd.read_csv(CSV_PATH).dropna(subset=['question', 'answer'])
-        # Precompute embeddings for all answers
-        df['embedding'] = list(model.encode(df['answer'].tolist(), convert_to_tensor=True))
-        print("✅ Resources loaded successfully!")
-        return model, df
+        df = pd.read_csv(CSV_PATH).dropna(subset=['question','answer'])
+        if os.path.exists(EMBEDDINGS_PATH):
+            answer_embeddings = torch.load(EMBEDDINGS_PATH)
+            print("✅ Loaded precomputed embeddings")
+        else:
+            answers = df['answer'].tolist()
+            answer_embeddings = model.encode(answers, convert_to_tensor=True)
+            torch.save(answer_embeddings, EMBEDDINGS_PATH)
+            print("✅ Computed and saved embeddings")
+        return model, df, answer_embeddings
     except Exception as e:
         print(f"❌ Error loading resources: {e}")
-        return None, None
+        return None, None, None
 
-model, df = load_resources()
+model, df, answer_embeddings = load_resources()
 
 # --- Initialize FastAPI ---
 app = FastAPI(title="MuRIL Multilingual QA API")
@@ -35,7 +39,7 @@ app = FastAPI(title="MuRIL Multilingual QA API")
 # --- API Data Models ---
 class QueryRequest(BaseModel):
     question: str
-    lang: str = None  # Optional language filter (en/hi/mr/...)
+    lang: str = None  # optional language filter, e.g., "en", "hi", "mr"
 
 class QAResponse(BaseModel):
     answer: str
@@ -47,28 +51,28 @@ def get_answer_endpoint(request: QueryRequest):
         return {"answer": "Model not loaded."}
 
     question_text = request.question
-    question_lang = None
-    try:
-        question_lang = detect(question_text)
-    except:
-        question_lang = None
+    lang_filter = request.lang
 
-    question_emb = model.encode(question_text, convert_to_tensor=True)
+    # Detect language if no filter provided
+    if not lang_filter:
+        try:
+            lang_filter = detect(question_text)
+        except:
+            lang_filter = None
 
-    # Filter dataframe by requested language if provided
+    # Filter dataset by language if specified
     filtered_df = df
-    if request.lang:
-        filtered_df = df[df['answer'].apply(lambda x: detect(x) == request.lang)]
-
-    if filtered_df.empty:
-        filtered_df = df  # fallback to all answers
-
-    # Compute cosine similarity
-    answer_embeddings = torch.stack(filtered_df['embedding'].to_list())
-    cosine_scores = util.pytorch_cos_sim(question_emb, answer_embeddings)
+    filtered_embeddings = answer_embeddings
+    if lang_filter:
+        if 'lang' in df.columns:
+            mask = df['lang'] == lang_filter
+            filtered_df = df[mask]
+            filtered_embeddings = torch.tensor([answer_embeddings[i] for i, m in enumerate(mask) if m])
+    
+    question_emb = model.encode(question_text, convert_to_tensor=True)
+    cosine_scores = util.pytorch_cos_sim(question_emb, filtered_embeddings)
     best_idx = torch.argmax(cosine_scores).item()
     answer = filtered_df.iloc[best_idx]['answer']
-
     return {"answer": answer}
 
 @app.get("/")