Simplification

app.py

@@ -8,98 +8,64 @@ sys.path.append("rd2l_pred")
 from training_data_prep import list_format, modification, league_money, df_gen
 from feature_engineering import heroes, hero_information
 
-# Global variables for model and feature columns
-MODEL = None
+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)
 
-def load_model():
-    """Load the ONNX model"""
-    global MODEL
-    try:
-        model_path = Path("model/rd2l_forest.onnx")
-        if not model_path.exists():
-            return "Model file not found at: " + str(model_path)
-        
-        MODEL = ort.InferenceSession(str(model_path))
-        return "Model loaded successfully"
-    except Exception as e:
-        return f"Error loading model: {str(e)}"
+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 process_player_data(player_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
-    """Process player data with correct feature structure"""
+def predict_cost(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
+    """Main prediction function for Gradio interface"""
     try:
-        # Clean player ID from URL if needed
-        if "/" in player_id:
-            player_id = player_id.split("/")[-1]
-            
-        # 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
-        }
+        # 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')
         
-        # 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
+        # Load and use the model
+        model_path = Path("model/rd2l_forest.onnx")
+        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)
-            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
+            # 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)}")
         
-        # Convert to DataFrame
-        df = pd.DataFrame([data])
-        
-        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
-    except Exception as e:
-        return f"Error processing player data: {str(e)}"
-
-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
-        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}"
+        input_name = session.get_inputs()[0].name
+        prediction = session.run(None, {input_name: prepped_data.values.astype(np.float32)})[0]
+        predicted_cost = round(float(prediction[0]), 2)
         
         return f"""Predicted Cost: {predicted_cost}
 
@@ -115,7 +81,7 @@ Player Details:
 Note: This prediction is based on historical data and player statistics from OpenDota."""
         
     except Exception as e:
-        return f"Error in prediction pipeline: {str(e)}"
+        return f"Error in prediction pipeline: {str(e)}\n\nDebug info:\n{type(e).__name__}: {str(e)}"
 
 # Create Gradio interface
 demo = gr.Interface(
@@ -143,10 +109,13 @@ 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"""
+                - 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"""
 )
 
 if __name__ == "__main__":
-    print("===== Application Startup =====")
-    print(load_model())
-    demo.launch(server_name="0.0.0.0")
+    demo.launch()