plps

app.py

@@ -5,68 +5,103 @@ import onnxruntime as ort
 import sys
 from pathlib import Path
 sys.path.append("rd2l_pred")
-from training_data_prep import list_format, modification, league_money, df_gen
 from feature_engineering import heroes, hero_information
 
-def prepare_single_player_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
-    """Creates a draft sheet format DataFrame for a single player"""
-    # Create player data in the format expected by the original pipeline
-    player_data = {
-        'Discord ID': ['N/A'],  # Placeholder for Discord ID
-        'Dotabuff Link': [user_id],
-        'MMR': [mmr],
-        'Comfort (Pos 1)': [comf_1],
-        'Comfort (Pos 2)': [comf_2],
-        'Comfort (Pos 3)': [comf_3],
-        'Comfort (Pos 4)': [comf_4],
-        'Comfort (Pos 5)': [comf_5],
-        'Player statement': ['N/A']  # Placeholder for player statement
-    }
-    
-    return pd.DataFrame(player_data)
+# Define expected columns
+EXPECTED_COLUMNS = ['mmr', 'p1', 'p2', 'p3', 'p4', 'p5', 'count', 'mean', 'std', 'min', 'max', 'sum',
+                   'total_games_played', 'total_winrate'] + \
+                  [f'games_{i}' for i in range(1, 146) if i != 24 and i != 122 and i != 124 and i != 125 and 
+                   i != 127 and i != 130 and i != 132 and i != 133 and i != 134 and i != 139 and 
+                   i != 140 and i != 141 and i != 142 and i != 143 and i != 144] + \
+                  [f'winrate_{i}' for i in range(1, 146) if i != 24 and i != 122 and i != 124 and i != 125 and 
+                   i != 127 and i != 130 and i != 132 and i != 133 and i != 134 and i != 139 and 
+                   i != 140 and i != 141 and i != 142 and i != 143 and i != 144]
 
-def prepare_mock_captains():
-    """Creates a minimal captains DataFrame for the league money calculation"""
-    captains_data = {
-        'Name': ['Mock Captain'],
-        'Dotabuff': ['N/A'],
-        'MMR': [3000],
-        "Buck's Bucks": [100],
-        'Crub Cents': [100],
-        'Remaining': [100]
-    }
-    return pd.DataFrame(captains_data)
+def prepare_single_player_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
+    """Creates a DataFrame in the expected format for the model"""
+    try:
+        # Extract player_id from URL if needed
+        player_id = user_id.split("/")[-1] if "/" in user_id else user_id
+        
+        # Get hero statistics using OpenDota API
+        hero_stats = hero_information(player_id)
+        
+        # Create initial data dictionary with zeros for all columns
+        data = {col: 0 for col in EXPECTED_COLUMNS}
+        
+        # Fill in the basic features
+        data.update({
+            'mmr': float(mmr),
+            'p1': int(comf_1),
+            'p2': int(comf_2),
+            'p3': int(comf_3),
+            'p4': int(comf_4),
+            'p5': int(comf_5),
+        })
+        
+        # Add hero statistics
+        if hero_stats is not None:
+            data['total_games_played'] = hero_stats.get('total_games_played', 0)
+            data['total_winrate'] = hero_stats.get('total_winrate', 0)
+            
+            # Fill in the games and winrate columns from hero_stats
+            for key, value in hero_stats.items():
+                if key in EXPECTED_COLUMNS:
+                    data[key] = value
+        
+        # Add mock statistics for money-related columns
+        # These would normally come from league_money function
+        stats = {
+            'count': 1,
+            'mean': mmr / 200,  # rough approximation
+            'std': mmr / 400,
+            'min': mmr / 250,
+            'max': mmr / 150,
+            'sum': mmr / 200
+        }
+        data.update(stats)
+        
+        # Convert to DataFrame
+        df = pd.DataFrame([data])
+        
+        # Ensure columns are in correct order
+        df = df[EXPECTED_COLUMNS]
+        
+        print(f"DataFrame shape: {df.shape}")
+        print("Missing columns:", set(EXPECTED_COLUMNS) - set(df.columns))
+        
+        return df
+        
+    except Exception as e:
+        print(f"Error in data preparation: {e}")
+        raise e
 
 def predict_cost(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
     """Main prediction function for Gradio interface"""
     try:
-        # Create a single-player draft sheet
-        draft_df = prepare_single_player_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5)
-        captains_df = prepare_mock_captains()
-        
-        # Use the original pipeline functions
-        money = league_money(captains_df, 'prediction')
-        prepped_data = df_gen(draft_df, money, 'prediction')
+        # Prepare the player data
+        processed_data = prepare_single_player_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5)
         
         # Load and use the model
         model_path = Path("model/rd2l_forest.onnx")
+        if not model_path.exists():
+            return f"Model file not found at: {model_path}"
+            
         session = ort.InferenceSession(str(model_path))
         
-        # Get hero information using the original feature engineering
-        try:
-            player_id = modification(user_id)  # Use the original modification function
-            hero_stats = hero_information(player_id)
-            # Add hero stats to prepped data
-            for col, value in hero_stats.items():
-                prepped_data[col] = value
-        except Exception as e:
-            print(f"Warning - Error fetching hero data: {str(e)}")
+        # Debug information
+        print("Processed data shape:", processed_data.shape)
+        print("Processed data columns:", processed_data.columns.tolist())
         
         # Make prediction
         input_name = session.get_inputs()[0].name
-        prediction = session.run(None, {input_name: prepped_data.values.astype(np.float32)})[0]
+        prediction = session.run(None, {input_name: processed_data.values.astype(np.float32)})[0]
         predicted_cost = round(float(prediction[0]), 2)
         
+        hero_stats = processed_data.iloc[0]
+        total_games = hero_stats.get('total_games_played', 'N/A')
+        total_winrate = hero_stats.get('total_winrate', 'N/A')
+        
         return f"""Predicted Cost: {predicted_cost}
 
 Player Details:
@@ -78,6 +113,10 @@ Player Details:
   * Pos 4: {comf_4}
   * Pos 5: {comf_5}
 
+Player Statistics:
+- Total Games: {total_games}
+- Overall Winrate: {total_winrate:.1%} if isinstance(total_winrate, float) else 'N/A'
+
 Note: This prediction is based on historical data and player statistics from OpenDota."""
         
     except Exception as e: