claude save me

app.py

@@ -1,72 +1,121 @@
 import gradio as gr
 import pandas as pd
+import numpy as np
+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 fetch_data(user_id, mmr, comf_1, comf_2, comf_3, comf_4, comf_5):
-    player_id = user_id.split("/")[-1]
-
-    series = {"player_id" : player_id, "mmr" : mmr, "p1" : comf_1, "p2" : comf_2, "p3" : comf_3, "p4" : comf_4, "p5" : comf_5}
-
-    money = pd.read_csv("result_money.csv")    
-
-    print()
-    print(f"Reading player {player_id}.  Starting now")
-
-    print(money)
-    print(money.values)
-
-    for item in money.values:
-        series.update({item[0] : float(item[1])})
-
-    print("Corrected Series")
-    print(series)
-    
-    d = pd.Series(series)
-    print(d)
-
-    # This the original section used to add the money section to the series.
-    # d = d.assign(count=lambda x: money[player_season].loc['count'], mean=lambda x: money[player_season].loc['mean'], std=lambda x: money[player_season].loc['std'], min=lambda x: money[player_season].loc['min'], max=lambda x: money[player_season].loc['max'], sum=lambda x: money[player_season].loc['sum'])
-
-    # We need to generate the inputs for the sheet using hugging face
-    # We also need to load the money values from the generated csv file
-    # df_gen(draft, league_money(captains, data_type), data_type)
-
-    print(f"Done reading player {player_id}")
-    print()
-
-    return player_id
-
-demo = gr.Interface.load("https://huggingface.co/nick-leland/RD2L_Random_Forest")
-
-# demo = gr.Interface(
-#     fn=fetch_data,
-#     inputs=[
-#         gr.Textbox(label="Player ID or Link to OpenDota/Dotabuff"),
-#         gr.Textbox(label="MMR"),
-#         gr.Slider(1, 5, value=1, step=1, label="Comfort (Pos 1)"),
-#         gr.Slider(1, 5, value=1, step=1, label="Comfort (Pos 2)"),
-#         gr.Slider(1, 5, value=1, step=1, label="Comfort (Pos 3)"),
-#         gr.Slider(1, 5, value=1, step=1, label="Comfort (Pos 4)"),
-#         gr.Slider(1, 5, value=1, step=1, label="Comfort (Pos 5)")
-#     ],
-#     # examples=[
-#     #     [np.asarray(Image.open("examples/1500_maze.jpg")), "Bulge", True, 0.25, 0.5, 0.5, 0.5],
-#     #     [np.asarray(Image.open("examples/2048_maze.jpg")), "Bulge", True, 0.25, 0.5, 0.5, 0.5],
-#     #     [np.asarray(Image.open("examples/2300_fresh.jpg")), "Bulge", True, 0.25, 0.5, 0.5, 0.5],
-#     #     [np.asarray(Image.open("examples/50_fresh.jpg")), "Bulge", True, 0.25, 0.5, 0.5, 0.5]
-#     # ],
-#     outputs=[
-#         "text"
-#     ],
-#     title="RD2L Pricing Prediction",
-#     article="Uhhhhh this is the article",
-#     description="Uhhhhh this is the description"
-# )
-demo.launch()
-
+# Load the ONNX model
+model_path = Path("model/rd2l_predictor.onnx")
+session = ort.InferenceSession(model_path)
+
+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:
+        # 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)
+        }
+        
+        # Get hero statistics using OpenDota API
+        try:
+            hero_stats = hero_information(player_id)
+            # 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)}"
+            
+        # 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]
+        
+        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:
+        # 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)
+        
+        return f"""Predicted Cost: {predicted_cost}
+
+Player Details:
+- MMR: {mmr}
+- Position Comfort:
+  * Pos 1: {comf_1}
+  * Pos 2: {comf_2}
+  * Pos 3: {comf_3}
+  * Pos 4: {comf_4}
+  * Pos 5: {comf_5}
+
+Note: This prediction is based on historical data and player statistics from OpenDota."""
+        
+    except Exception as e:
+        return f"Error making prediction: {str(e)}"
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=predict_cost,
+    inputs=[
+        gr.Textbox(label="Player ID or Link to OpenDota/Dotabuff",
+                  placeholder="Enter player ID or full profile URL"),
+        gr.Number(label="MMR", value=3000),
+        gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 1)"),
+        gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 2)"),
+        gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 3)"),
+        gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 4)"),
+        gr.Slider(1, 5, value=3, step=1, label="Comfort (Pos 5)")
+    ],
+    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, 
+                   position comfort levels, and historical performance data from OpenDota. 
+                   Enter a player's OpenDota ID or profile URL along with their current stats 
+                   to get a predicted cost.""",
+    article="""### How it works
+                - 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"""
+)
+
+if __name__ == "__main__":
+    demo.launch()