Debugging

app.py

@@ -38,84 +38,70 @@ def load_model():
 def process_player_data(player_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
     """Process player data similar to training pipeline"""
     try:
+        # Define expected columns based on the model's requirements
+        expected_columns = ['mmr', 'p1', 'p2', 'p3', 'p4', 'p5', 'count', 'mean', 'std', 'min']
+        # Add hero-specific columns
+        for hero_id in range(1, 139):  # Based on max hero ID 138 from your data
+            if hero_id in [139, 140, 141, 142, 143, 144]:  # Skip any known gaps
+                continue
+            expected_columns.extend([f'games_{hero_id}', f'winrate_{hero_id}'])
+            
+        print(f"\nExpected columns: {len(expected_columns)}")
+        
         # 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)
+            "p5": int(comf_5),
+            "count": 0,
+            "mean": 0,
+            "std": 0,
+            "min": 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")
-            print("\nReference columns from prediction_data_prepped.csv:")
-            print(sorted(pred_data.columns.tolist()))
-            print(f"Number of reference columns: {len(pred_data.columns)}")
-            
-            if not pred_data.empty:
-                # Get column structure from the first row
-                for col in pred_data.columns:
-                    if col not in player_data and col != 'Predicted_Cost':  # Skip the target variable
-                        player_data[col] = 0
-        except Exception as e:
-            print(f"Warning - Error reading prediction data template: {str(e)}")
-        
         # Get hero statistics using OpenDota API
         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)
+            hero_data = hero_stats.to_dict()
             
+            # Add hero-specific stats
+            for col in expected_columns:
+                if col.startswith('games_') or col.startswith('winrate_'):
+                    if col not in hero_data:
+                        player_data[col] = 0
+                    else:
+                        player_data[col] = hero_data[col]
+                        
         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])
-        
-        # Print out the columns we have in our processed data
-        print("\nProcessed data columns:")
-        print(sorted(df.columns.tolist()))
-        print(f"Number of processed columns: {len(df.columns)}")
+            # If hero stats fail, add placeholder values for all hero columns
+            for col in expected_columns:
+                if col.startswith('games_') or col.startswith('winrate_'):
+                    player_data[col] = 0
         
-        # Find missing columns
-        expected_cols = set(pred_data.columns) - {'Predicted_Cost'}  # Remove target variable
-        actual_cols = set(df.columns)
-        
-        missing_cols = expected_cols - actual_cols
-        extra_cols = actual_cols - expected_cols
+        # Convert to DataFrame and ensure column order
+        df = pd.DataFrame([player_data])
         
+        # Verify we have all expected columns
+        missing_cols = set(expected_columns) - set(df.columns)
         if missing_cols:
-            print("\nMissing columns:")
-            print(sorted(list(missing_cols)))
-            
-        if extra_cols:
-            print("\nExtra columns:")
-            print(sorted(list(extra_cols)))
-            
-        # Ensure we have all needed columns and remove any extras
-        for col in missing_cols:
-            df[col] = 0
-        df = df[list(expected_cols)]
+            print("\nMissing columns:", missing_cols)
+            for col in missing_cols:
+                df[col] = 0
+                
+        # Ensure correct column order
+        df = df[expected_columns]
         
         print(f"\nFinal number of columns: {len(df.columns)}")
+        print(f"Column list: {df.columns.tolist()}")
+        
         return df
     except Exception as e:
         return f"Error processing player data: {str(e)}"