Upload folder using huggingface_hub

app.py

@@ -1,19 +1,21 @@
 # Import necessary libraries
 import numpy as np
-import joblib  # For loading the serialized model
-import pandas as pd  # For data manipulation
-from flask import Flask, request, jsonify  # For creating the Flask API
+import joblib
+import pandas as pd
+from flask import Flask, request, jsonify
 
 # Initialize the Flask application
 extraaLearn_predictor_api = Flask("ExtraaLearn paid customers Predictor")
 
 # Load the trained machine learning model
-model = joblib.load("extraaLearn_model_prediction_model_v1_0.joblib")
+model = joblib.load("extraaLearn_model_prediction_model_v1_0
+.joblib")
 
 # -----------------------------
-# Feature mapping (incoming JSON -> model column names)
+# Feature mapping
 # -----------------------------
-feature_mapping = {    
+feature_mapping = {
+    "id": "ID",
     "age": "age",
     "currentOccupation": "current_occupation",
     "firstInteraction": "first_interaction",
@@ -26,97 +28,153 @@ feature_mapping = {
     "printMediaType2": "print_media_type2",
     "digitalMedia": "digital_media",
     "educationalChannels": "educational_channels",
-    "referral": "referral",   
+    "referral": "referral",
+    "status": "status"
 }
 
+# -----------------------------
+# Debug function to check model expectations
+# -----------------------------
+def debug_model_expectations():
+    """Debug what the model expects for features"""
+    print("=== MODEL DEBUG INFORMATION ===")
+    
+    # Check if model has feature names
+    if hasattr(model, 'feature_names_in_'):
+        print(f"Model expects these features: {list(model.feature_names_in_)}")
+    else:
+        print("Model doesn't have explicit feature names")
+    
+    # If it's a pipeline, check preprocessing steps
+    if hasattr(model, 'named_steps'):
+        print("Model is a pipeline with steps:")
+        for step_name, step in model.named_steps.items():
+            print(f"  - {step_name}: {type(step)}")
+            
+            # Check for column transformers or encoders
+            if hasattr(step, 'transformers_'):
+                for name, transformer, columns in step.transformers_:
+                    print(f"    Transformer '{name}' handles columns: {columns}")
+                    if hasattr(transformer, 'categories_'):
+                        print(f"    Categories: {transformer.categories_}")
+    
+    print("=== END MODEL DEBUG ===")
+
+# Run debug on startup
+debug_model_expectations()
 
 # -----------------------------
-# Routes
+# Routes with enhanced debugging
 # -----------------------------
 
-# Health check
 @extraaLearn_predictor_api.get("/ping")
 def ping():
-    """Simple health check endpoint."""
     return jsonify({"status": "ok"})
 
-
-# Home route
 @extraaLearn_predictor_api.get("/")
 def home():
-    """Welcome message for the API."""
     return "Welcome to the ExtraaLearn customers Prediction API!"
 
-
-# Single prediction
 @extraaLearn_predictor_api.post("/v1/customers")
-def predict_customer_converted_to_a_paid():
+def predict_sales_revenue():
     """
     Handles POST requests to predict sales revenue for a single product/store.
-    Expects a JSON payload with features.
-    """
-    # try:
-        # Get the JSON data from the request body
-    property_data = request.get_json()
-
-    # Map input keys to model feature names
-    sample = {}
-    for api_key, model_key in feature_mapping.items():
-        if api_key not in property_data:
-            return jsonify({"error": f"Missing required field: {api_key}"}), 400
-        sample[model_key] = property_data[api_key]
-
-    # Convert the extracted data into a Pandas DataFrame
-    input_data = pd.DataFrame([sample])
-
-    # Make prediction (log-transformed sales total)
-    predicted_customer = model.predict(input_data)[0]
-
-
-
-    return jsonify({"Predicted_customer": predicted_customer})
-
-    # except Exception as e:
-    #     return jsonify({"error": str(e)}), 500
-
-
-# Batch prediction
-@extraaLearn_predictor_api.post("/v1/customersbatch")
-def predict_sales_batch():
-    """
-    Handles POST requests for batch prediction.
-    Expects a CSV file with multiple records.
     """
     try:
-        # Get the uploaded CSV file
-        file = request.files.get("file")
-        if file is None:
-            return jsonify({"error": "CSV file is required"}), 400
-
-        # Read the CSV file into a Pandas DataFrame
-        input_data = pd.read_csv(file)
-
-        # Make predictions
-        predicted_extraaLearn_customers_totals = model.predict(input_data).tolist()
-
-        # Convert predictions back from log scale
-        predicted_customers = [
-            round(float(np.exp(p)), 2) for p in predicted_extraaLearn_customers_totals
-        ]
-
-        # If an "id" column exists, return mapping {id: prediction}
-        if "id" in input_data.columns:
-            property_ids = input_data["id"].tolist()
-            output_dict = dict(zip(property_ids, predicted_customers))
-        else:
-            output_dict = {"predictions": predicted_customers}
-
-        return jsonify(output_dict)
+        # Get the JSON data from the request body
+        property_data = request.get_json()
+        
+        if not property_data:
+            return jsonify({"error": "No JSON data provided"}), 400
+
+        print("=== RECEIVED PAYLOAD ===")
+        for key, value in property_data.items():
+            print(f"  {key}: {value} (type: {type(value)})")
+        
+        # Check for missing fields
+        missing_fields = []
+        for api_key in feature_mapping.keys():
+            if api_key not in property_data:
+                missing_fields.append(api_key)
+        
+        if missing_fields:
+            return jsonify({
+                "error": f"Missing required fields: {missing_fields}",
+                "required_fields": list(feature_mapping.keys())
+            }), 400
+
+        # Map input keys to model feature names
+        sample = {}
+        for api_key, model_key in feature_mapping.items():
+            sample[model_key] = property_data[api_key]
+
+        # Convert to DataFrame
+        input_data = pd.DataFrame([sample])
+        
+        print("=== DATA SENT TO MODEL ===")
+        print("DataFrame dtypes:")
+        for col in input_data.columns:
+            print(f"  {col}: {input_data[col].dtype} - value: {input_data[col].iloc[0]}")
+        
+        # Make prediction
+        print("=== MAKING PREDICTION ===")
+        predicted_customer = model.predict(input_data)[0]
+        
+        # Convert to serializable type
+        if hasattr(predicted_customer, 'item'):
+            predicted_customer = predicted_customer.item()
+        predicted_customer = float(predicted_customer)
+
+        print(f"=== PREDICTION SUCCESS: {predicted_customer} ===")
+        
+        return jsonify({
+            "Predicted_Sales": predicted_customer,
+            "status": "success",
+            "input_received": {
+                "fields_received": list(property_data.keys()),
+                "fields_processed": list(sample.keys())
+            }
+        })
 
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
+        print(f"=== PREDICTION FAILED ===")
+        print(f"Error type: {type(e).__name__}")
+        print(f"Error message: {str(e)}")
+        
+        # Try to identify which feature might be causing the issue
+        error_msg = str(e)
+        if "unknown category" in error_msg.lower():
+            return jsonify({
+                "error": "Unknown category value provided",
+                "details": "One of your categorical values doesn't match what the model was trained on",
+                "debug_info": "Check the server logs for specific category issues"
+            }), 400
+        elif "isnan" in error_msg:
+            return jsonify({
+                "error": "Data type mismatch",
+                "details": "The model encountered unexpected data types",
+                "debug_info": "Check that numeric fields contain numbers and categorical fields contain strings"
+            }), 400
+        else:
+            return jsonify({
+                "error": f"Prediction failed: {str(e)}",
+                "debug_info": "Check server logs for detailed error information"
+            }), 500
+
+# Test endpoint to check model expectations
+@extraaLearn_predictor_api.get("/v1/model-info")
+def get_model_info():
+    """Endpoint to get information about what the model expects"""
+    info = {
+        "required_fields": list(feature_mapping.keys()),
+        "feature_mapping": feature_mapping,
+        "model_type": str(type(model))
+    }
+    
+    if hasattr(model, 'feature_names_in_'):
+        info["model_expected_features"] = list(model.feature_names_in_)
+    
+    return jsonify(info)
 
-# Run the Flask application in debug mode if this script is executed directly
 if __name__ == "__main__":
     extraaLearn_predictor_api.run(host="0.0.0.0", port=7860, debug=True)