please

app.py

@@ -10,10 +10,9 @@ from feature_engineering import heroes, hero_information
 
 # Global variables for model and feature columns
 MODEL = None
-FEATURE_COLUMNS = None
 
 def load_model():
-    """Load the ONNX model and get input features"""
+    """Load the ONNX model"""
     global MODEL
     try:
         model_path = Path("model/rd2l_forest.onnx")
@@ -26,93 +25,53 @@ def load_model():
         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"""
+    """Process player data with correct feature structure"""
     try:
         # Clean player ID from URL if needed
         if "/" in player_id:
             player_id = player_id.split("/")[-1]
             
-        # Create initial player series
-        player_data = {
-            "player_id": player_id,
-            "mmr": float(mmr),
-            "p1": int(comf_1),
-            "p2": int(comf_2),
-            "p3": int(comf_3),
-            "p4": int(comf_4),
-            "p5": int(comf_5)
+        # Create initial data structure with basic features
+        data = {
+            'mmr': float(mmr),
+            'p1': int(comf_1),
+            'p2': int(comf_2),
+            'p3': int(comf_3),
+            'p4': int(comf_4),
+            'p5': int(comf_5),
+            'count': 0,
+            'mean': 0,
+            'std': 0,
+            'min': 0,
+            'max': 0,
+            'sum': 0,
+            'total_games_played': 0,
+            'total_winrate': 0
         }
         
-        # Read the example row from prediction_data_prepped.csv to get the expected structure
-        try:
-            pred_data = pd.read_csv("prediction_data_prepped.csv")
-            if not pred_data.empty:
-                # Get column structure from the first row
-                for col in pred_data.columns:
-                    if col not in player_data:
-                        player_data[col] = 0
-        except Exception as e:
-            print(f"Warning - Error reading prediction data template: {str(e)}")
-        
-        # Get hero statistics using OpenDota API
+        # Add hero-specific features
+        for i in range(1, 139):  # Add all possible hero IDs
+            data[f'games_{i}'] = 0
+            data[f'winrate_{i}'] = 0
+            
+        # Get hero statistics from OpenDota
         try:
             hero_stats = hero_information(player_id)
-            player_data.update(hero_stats.to_dict())
-            
-            # Add season identifier to match training data format
-            player_season = f"{player_id}_S34"  # Assuming current season is 34
-            temp_dict = {}
-            temp_dict[player_season] = 1.0  # Set current season flag to 1.0
-            player_data.update(temp_dict)
+            data['total_games_played'] = hero_stats['total_games_played']
+            data['total_winrate'] = hero_stats['total_winrate']
             
+            # Update hero-specific stats
+            for key, value in hero_stats.items():
+                if key in data:
+                    data[key] = value
         except Exception as 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])
         
-        # Load reference data structure if available
-        try:
-            ref_data = pd.read_csv("result_prediction_data_prepped.csv")
-            if not ref_data.empty:
-                # Get all columns from reference data
-                for col in ref_data.columns:
-                    if col not in df.columns:
-                        df[col] = 0
-                # Reorder columns to match reference data
-                df = df[ref_data.columns]
-        except Exception as e:
-            print(f"Warning - Error matching reference data structure: {str(e)}")
-            
-        # Load the expected columns from your prediction data
-        pred_data = pd.read_csv("prediction_data_prepped.csv")
-        expected_columns = pred_data.columns.tolist()
+        # Convert to DataFrame
+        df = pd.DataFrame([data])
         
-        # Debug print
-        print(f"\nNumber of expected columns: {len(expected_columns)}")
-        print(f"Number of current columns: {len(df.columns)}")
-        
-        # Find missing columns
-        missing_columns = [col for col in expected_columns if col not in df.columns]
-        extra_columns = [col for col in df.columns if col not in expected_columns]
-        
-        print(f"\nMissing columns: {missing_columns}")
-        print(f"Extra columns: {extra_columns}")
-        
-        # Ensure all expected columns exist
-        for col in expected_columns:
-            if col not in df.columns:
-                df[col] = 0
-                
-        # Remove any extra columns
-        df = df[expected_columns]
-        
-        print(f"\nFinal number of columns: {len(df.columns)}")
+        print(f"Processed data shape: {df.shape}")
+        print(f"Number of features: {len(df.columns)}")
         print(f"First few columns: {list(df.columns)[:5]}")
         
         return df
@@ -133,11 +92,7 @@ def predict_cost(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
         
         if isinstance(processed_data, str):  # Error occurred
             return processed_data
-        
-        # 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
@@ -188,16 +143,10 @@ demo = gr.Interface(
                 - The predictor uses machine learning trained on historical RD2L draft data
                 - Player statistics are fetched from OpenDota API
                 - Position comfort levels range from 1 (least comfortable) to 5 (most comfortable)
-                - Predictions are based on both current stats and historical performance
-                
-                ### Notes
-                - MMR should be the player's current solo MMR
-                - Position comfort should reflect actual role experience
-                - Predictions are estimates and may vary from actual draft results"""
+                - Predictions are based on both current stats and historical performance"""
 )
 
-# Load model on startup
-print(load_model())
-
 if __name__ == "__main__":
-    demo.launch()
+    print("===== Application Startup =====")
+    print(load_model())
+    demo.launch(server_name="0.0.0.0")