Add Bangla model API

app.py

@@ -2,8 +2,9 @@ from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 import joblib
 import os
-import pickle
 import logging
+import numpy as np
+import traceback
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -24,46 +25,32 @@ def load_model_safe(filename):
     if not os.path.exists(filename):
         raise FileNotFoundError(f"{filename} not found")
     
-    # Try joblib first
     try:
         return joblib.load(filename)
     except Exception as e1:
         logger.warning(f"Joblib failed for {filename}: {e1}")
         
-        # Try pickle as fallback
         try:
             with open(filename, 'rb') as f:
                 return pickle.load(f)
         except Exception as e2:
             logger.error(f"Pickle also failed for {filename}: {e2}")
-            raise e1  # Raise original joblib error
+            raise e1
 
 @app.on_event("startup")
 async def startup_event():
     global model, vectorizer, label_encoder, models_loaded
     
     try:
-        logger.info("Starting model loading...")
-        
-        # Load each model individually with error handling
-        logger.info("Loading bangla_model.pkl...")
+        logger.info("Loading models...")
         model = load_model_safe("bangla_model.pkl")
-        logger.info(f"Model type: {type(model)}")
-        
-        logger.info("Loading bangla_vectorizer.pkl...")
         vectorizer = load_model_safe("bangla_vectorizer.pkl")
-        logger.info(f"Vectorizer type: {type(vectorizer)}")
-        
-        logger.info("Loading bangla_label_encoder.pkl...")
         label_encoder = load_model_safe("bangla_label_encoder.pkl")
-        logger.info(f"Label encoder type: {type(label_encoder)}")
         
-        # Test pipeline with dummy data
-        logger.info("Testing pipeline...")
+        # Test pipeline
         test_vect = vectorizer.transform(["test"])
         test_pred = model.predict(test_vect)
         test_label = label_encoder.inverse_transform(test_pred)
-        logger.info(f"Pipeline test successful: {test_label[0]}")
         
         models_loaded = True
         logger.info("All models loaded successfully!")
@@ -71,7 +58,6 @@ async def startup_event():
     except Exception as e:
         logger.error(f"Failed to load models: {str(e)}")
         models_loaded = False
-        # Don't raise here - let the app start and handle errors in endpoints
 
 @app.get("/")
 def root():
@@ -83,7 +69,6 @@ def root():
 
 @app.get("/status")
 def status():
-    """Detailed status endpoint"""
     return {
         "models_loaded": models_loaded,
         "model_available": model is not None,
@@ -93,45 +78,133 @@ def status():
         "available_files": [f for f in os.listdir('.') if f.endswith('.pkl')]
     }
 
+@app.post("/debug-predict")
+def debug_predict(request: PredictRequest):
+    """Debug version of predict with detailed logging"""
+    if not models_loaded:
+        raise HTTPException(status_code=503, detail="Models not loaded")
+    
+    debug_info = {"steps": []}
+    
+    try:
+        # Step 1: Input validation
+        debug_info["steps"].append("1. Input validation")
+        if not request.text or not request.text.strip():
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        debug_info["input_text"] = request.text
+        debug_info["input_length"] = len(request.text)
+        
+        # Step 2: Text preprocessing
+        debug_info["steps"].append("2. Text preprocessing")
+        text_to_process = request.text.strip()
+        debug_info["processed_text_length"] = len(text_to_process)
+        
+        # Step 3: Vectorization
+        debug_info["steps"].append("3. Vectorization")
+        try:
+            vect = vectorizer.transform([text_to_process])
+            debug_info["vectorized_shape"] = vect.shape
+            debug_info["vectorized_nnz"] = vect.nnz
+            debug_info["vectorized_dtype"] = str(vect.dtype)
+        except Exception as e:
+            debug_info["vectorization_error"] = str(e)
+            raise HTTPException(status_code=500, detail=f"Vectorization failed: {str(e)}")
+        
+        # Step 4: Model prediction
+        debug_info["steps"].append("4. Model prediction")
+        try:
+            pred = model.predict(vect)
+            debug_info["raw_prediction"] = pred.tolist() if hasattr(pred, 'tolist') else str(pred)
+            debug_info["prediction_type"] = str(type(pred))
+            debug_info["prediction_shape"] = pred.shape if hasattr(pred, 'shape') else "no shape"
+        except Exception as e:
+            debug_info["prediction_error"] = str(e)
+            raise HTTPException(status_code=500, detail=f"Model prediction failed: {str(e)}")
+        
+        # Step 5: Label transformation
+        debug_info["steps"].append("5. Label transformation")
+        try:
+            # Check if prediction is in valid range
+            if hasattr(label_encoder, 'classes_'):
+                debug_info["available_classes"] = label_encoder.classes_.tolist()
+                debug_info["num_classes"] = len(label_encoder.classes_)
+            
+            label = label_encoder.inverse_transform(pred)
+            debug_info["final_label"] = label[0] if len(label) > 0 else "no label"
+            debug_info["label_type"] = str(type(label[0])) if len(label) > 0 else "no label"
+        except Exception as e:
+            debug_info["label_transform_error"] = str(e)
+            raise HTTPException(status_code=500, detail=f"Label transformation failed: {str(e)}")
+        
+        debug_info["steps"].append("6. Success!")
+        debug_info["final_prediction"] = label[0]
+        
+        return debug_info
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        debug_info["unexpected_error"] = str(e)
+        debug_info["traceback"] = traceback.format_exc()
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
 @app.post("/predict")
 def predict(request: PredictRequest):
+    """Production predict endpoint with better error handling"""
     if not models_loaded:
-        raise HTTPException(
-            status_code=503, 
-            detail="Models not loaded. Check /status endpoint for details."
-        )
-    
-    if not request.text or not request.text.strip():
-        raise HTTPException(status_code=400, detail="Text cannot be empty")
+        raise HTTPException(status_code=503, detail="Models not loaded")
     
     try:
-        logger.info(f"Processing text: {request.text[:50]}...")
+        # Input validation
+        if not request.text or not request.text.strip():
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        text_to_process = request.text.strip()
+        logger.info(f"Processing text of length: {len(text_to_process)}")
         
-        # Transform text
-        vect = vectorizer.transform([request.text])
-        logger.info(f"Vectorization successful, shape: {vect.shape}")
+        # Vectorization with error handling
+        try:
+            vect = vectorizer.transform([text_to_process])
+            logger.info(f"Vectorization successful: shape={vect.shape}, nnz={vect.nnz}")
+        except Exception as e:
+            logger.error(f"Vectorization error: {str(e)}")
+            raise HTTPException(status_code=500, detail="Text vectorization failed")
         
-        # Make prediction
-        pred = model.predict(vect)
-        logger.info(f"Prediction successful: {pred}")
+        # Prediction with error handling
+        try:
+            pred = model.predict(vect)
+            logger.info(f"Prediction successful: {pred}")
+        except Exception as e:
+            logger.error(f"Model prediction error: {str(e)}")
+            raise HTTPException(status_code=500, detail="Model prediction failed")
         
-        # Transform label
-        label = label_encoder.inverse_transform(pred)
-        logger.info(f"Label transformation successful: {label[0]}")
+        # Label transformation with error handling
+        try:
+            # Validate prediction is in expected range
+            if hasattr(label_encoder, 'classes_'):
+                max_class = len(label_encoder.classes_) - 1
+                if np.any(pred < 0) or np.any(pred > max_class):
+                    logger.error(f"Prediction {pred} out of range [0, {max_class}]")
+                    raise ValueError(f"Prediction out of range")
+            
+            label = label_encoder.inverse_transform(pred)
+            logger.info(f"Label transformation successful: {label[0]}")
+        except Exception as e:
+            logger.error(f"Label transformation error: {str(e)}")
+            raise HTTPException(status_code=500, detail="Label transformation failed")
         
         return {"prediction": label[0]}
         
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Prediction error: {str(e)}")
-        raise HTTPException(
-            status_code=500, 
-            detail=f"Prediction failed: {str(e)}"
-        )
+        logger.error(f"Unexpected error in predict: {str(e)}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail="Internal server error")
 
-# Add a manual model reload endpoint for debugging
 @app.post("/reload-models")
 def reload_models():
-    """Manually reload models - useful for debugging"""
     global model, vectorizer, label_encoder, models_loaded
     
     try: