Added example and updated the loading of the onnx model

app.py

@@ -8,9 +8,31 @@ sys.path.append("rd2l_pred")
 from training_data_prep import list_format, modification, league_money, df_gen
 from feature_engineering import heroes, hero_information
 
-# Load the ONNX model
-model_path = Path("model/rd2l_forest.onnx")
-session = ort.InferenceSession(model_path)
+# Global variables for model and feature columns
+MODEL = None
+FEATURE_COLUMNS = None
+
+def load_model():
+    """Load the ONNX model and get input features"""
+    global MODEL, FEATURE_COLUMNS
+    try:
+        model_path = Path("model/rd2l_predictor.onnx")
+        if not model_path.exists():
+            return "Model file not found at: " + str(model_path)
+        
+        MODEL = ort.InferenceSession(str(model_path))
+        
+        # Load feature columns from a saved reference - you'll need to create this
+        try:
+            FEATURE_COLUMNS = pd.read_csv("model/feature_columns.csv")["columns"].tolist()
+        except:
+            # Fallback to basic features if feature columns file not found
+            FEATURE_COLUMNS = ["player_id", "mmr", "p1", "p2", "p3", "p4", "p5", 
+                             "total_games_played", "total_winrate"]
+        
+        return "Model loaded successfully"
+    except Exception as e:
+        return f"Error loading model: {str(e)}"
 
 def process_player_data(player_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
     """Process player data similar to training pipeline"""
@@ -36,19 +58,23 @@ def process_player_data(player_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
             # Merge hero stats with player data
             player_data.update(hero_stats.to_dict())
         except Exception as e:
-            return f"Error fetching hero data: {str(e)}"
+            print(f"Warning - Error fetching hero data: {str(e)}")
+            # If hero stats fail, add placeholder values
+            player_data.update({
+                "total_games_played": 0,
+                "total_winrate": 0.0
+            })
             
         # Convert to DataFrame for consistency with training
         df = pd.DataFrame([player_data])
         
-        # Ensure columns match training data
-        required_columns = [col.name for col in session.get_inputs()[0].type.tensor_type.shape.dim]
-        for col in required_columns:
-            if col not in df.columns:
-                df[col] = 0
-                
-        # Reorder columns to match model input
-        df = df[required_columns]
+        # Ensure all required columns exist
+        if FEATURE_COLUMNS:
+            for col in FEATURE_COLUMNS:
+                if col not in df.columns:
+                    df[col] = 0
+            # Reorder columns to match model input
+            df = df[FEATURE_COLUMNS]
         
         return df
     except Exception as e:
@@ -57,18 +83,29 @@ def process_player_data(player_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
 def predict_cost(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
     """Main prediction function for Gradio interface"""
     try:
+        # Check if model is loaded
+        if MODEL is None:
+            result = load_model()
+            if not result.startswith("Model loaded"):
+                return result
+        
         # Process input data
         processed_data = process_player_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5)
         
         if isinstance(processed_data, str):  # Error occurred
             return processed_data
-            
-        # Make prediction
-        input_name = session.get_inputs()[0].name
-        prediction = session.run(None, {input_name: processed_data.values.astype(np.float32)})[0]
         
-        # Format prediction
-        predicted_cost = round(float(prediction[0]), 2)
+        # Print debug information
+        print("Processed data shape:", processed_data.shape)
+        print("Processed data columns:", processed_data.columns.tolist())
+        
+        # Make prediction
+        try:
+            input_name = MODEL.get_inputs()[0].name
+            prediction = MODEL.run(None, {input_name: processed_data.values.astype(np.float32)})[0]
+            predicted_cost = round(float(prediction[0]), 2)
+        except Exception as e:
+            return f"Error during prediction: {str(e)}\nProcessed data shape: {processed_data.shape}"
         
         return f"""Predicted Cost: {predicted_cost}
 
@@ -84,7 +121,7 @@ Player Details:
 Note: This prediction is based on historical data and player statistics from OpenDota."""
         
     except Exception as e:
-        return f"Error making prediction: {str(e)}"
+        return f"Error in prediction pipeline: {str(e)}"
 
 # Create Gradio interface
 demo = gr.Interface(
@@ -99,6 +136,9 @@ demo = gr.Interface(
         gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 4)"),
         gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 5)")
     ],
+    examples=[
+        ["https://www.dotabuff.com/players/188649776", 6812, 5, 5, 4, 2, 1]
+    ],
     outputs=gr.Textbox(label="Prediction Results"),
     title="RD2L Player Cost Predictor",
     description="""This tool predicts the auction cost for RD2L players based on their MMR, 
@@ -117,5 +157,8 @@ demo = gr.Interface(
                 - Predictions are estimates and may vary from actual draft results"""
 )
 
+# Load model on startup
+print(load_model())
+
 if __name__ == "__main__":
     demo.launch()