kermitting soon

util/app.py

@@ -32,28 +32,41 @@ CHAMPIONS = [
     "Xin Zhao", "Yasuo", "Yone", "Yorick", "Yuumi", "Zac", "Zed", "Zeri", "Ziggs", "Zilean", "Zoe", "Zyra"
 ]
 
+try:
+    label_encoder = joblib.load('util/label_encoder.joblib')
+    n_classes = len(label_encoder.classes_)
+    print("Label encoder loaded successfully")
+except Exception as e:
+    print(f"Error loading label encoder: {e}")
+    label_encoder = None
+
 # Load model
 try:
     model_path = hf_hub_download(
         repo_id="ivwhy/champion-predictor-model",
         filename="champion_predictor.json"
     )
-    model = xgb.Booster()
-    model.load_model(model_path)
+
+    # Initialize the model with proper parameters
+    model = xgb.XGBClassifier(
+        use_label_encoder=False,
+        objective='multi:softprob',
+        num_class=n_classes
+    )
+
+    # Load the model
+    model._Booster = xgb.Booster()
+    model._Booster.load_model(model_path)
+
+    # Set only n_classes_
+    model.n_classes_ = n_classes
 except Exception as e:
     print(f"Error loading model: {e}")
     model = None 
 
-try:
-    label_encoder = joblib.load('util/label_encoder.joblib')
-    print("Label encoder loaded successfully")
-except Exception as e:
-    print(f"Error loading label encoder: {e}")
-    label_encoder = None
-
 # Initialize champion name encoder
-champion_encoder = LabelEncoder()
-champion_encoder.fit(CHAMPIONS)
+# champion_encoder = LabelEncoder()
+# champion_encoder.fit(CHAMPIONS)
 
 
 #==================================== Functions =================================================
@@ -169,7 +182,7 @@ def predict_champion(player_opgg_url, *champions):
         # Map numeric ID to index in CHAMPIONS list
         # Since your label encoder seems to use champion IDs, we need to map these to list indices
         try:
-            # Get the first prediction
+            # Get the first 3 prediction
             champion_id = int(decoded_numeric[0])
             
             # Print debug information
@@ -334,7 +347,7 @@ with gr.Blocks() as demo:
     )
 
 # Optional: Save the champion encoder for future use
-joblib.dump(champion_encoder, 'champion_encoder.joblib')
+#joblib.dump(champion_encoder, 'champion_encoder.joblib')
 # Enable queuing
 demo.launch(debug=True)
 

util/app_working_backup.py

@@ -0,0 +1,343 @@
+# app.py
+import gradio as gr
+import xgboost as xgb
+from xgboost import DMatrix
+from huggingface_hub import hf_hub_download
+from app_training_df_getter import create_app_user_training_df
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from helper import * 
+import joblib
+
+
+# Define champion list for dropdowns
+CHAMPIONS = [
+    "Aatrox", "Ahri", "Akali", "Akshan", "Alistar", "Amumu", "Anivia", "Annie", "Aphelios", "Ashe",
+    "Aurelion Sol", "Azir", "Bard", "Bel'Veth", "Blitzcrank", "Brand", "Braum", "Caitlyn", "Camille",
+    "Cassiopeia", "Cho'Gath", "Corki", "Darius", "Diana", "Dr. Mundo", "Draven", "Ekko", "Elise",
+    "Evelynn", "Ezreal", "Fiddlesticks", "Fiora", "Fizz", "Galio", "Gangplank", "Garen", "Gnar",
+    "Gragas", "Graves", "Gwen", "Hecarim", "Heimerdinger", "Illaoi", "Irelia", "Ivern", "Janna",
+    "Jarvan IV", "Jax", "Jayce", "Jhin", "Jinx", "Kai'Sa", "Kalista", "Karma", "Karthus", "Kassadin",
+    "Katarina", "Kayle", "Kayn", "Kennen", "Kha'Zix", "Kindred", "Kled", "Kog'Maw", "KSante", "LeBlanc",
+    "Lee Sin", "Leona", "Lillia", "Lissandra", "Lucian", "Lulu", "Lux", "Malphite", "Malzahar", "Maokai",
+    "Master Yi", "Milio", "Miss Fortune", "Mordekaiser", "Morgana", "Naafiri", "Nami", "Nasus", "Nautilus",
+    "Neeko", "Nidalee", "Nilah", "Nocturne", "Nunu & Willump", "Olaf", "Orianna", "Ornn", "Pantheon",
+    "Poppy", "Pyke", "Qiyana", "Quinn", "Rakan", "Rammus", "Rek'Sai", "Rell", "Renata Glasc", "Renekton",
+    "Rengar", "Riven", "Rumble", "Ryze", "Samira", "Sejuani", "Senna", "Seraphine", "Sett", "Shaco",
+    "Shen", "Shyvana", "Singed", "Sion", "Sivir", "Skarner", "Sona", "Soraka", "Swain", "Sylas",
+    "Syndra", "Tahm Kench", "Taliyah", "Talon", "Taric", "Teemo", "Thresh", "Tristana", "Trundle",
+    "Tryndamere", "Twisted Fate", "Twitch", "Udyr", "Urgot", "Varus", "Vayne", "Veigar", "Vel'Koz",
+    "Vex", "Vi", "Viego", "Viktor", "Vladimir", "Volibear", "Warwick", "Wukong", "Xayah", "Xerath",
+    "Xin Zhao", "Yasuo", "Yone", "Yorick", "Yuumi", "Zac", "Zed", "Zeri", "Ziggs", "Zilean", "Zoe", "Zyra"
+]
+
+# Load model
+try:
+    model_path = hf_hub_download(
+        repo_id="ivwhy/champion-predictor-model",
+        filename="champion_predictor.json"
+    )
+    model = xgb.Booster()
+    model.load_model(model_path)
+except Exception as e:
+    print(f"Error loading model: {e}")
+    model = None 
+
+try:
+    label_encoder = joblib.load('util/label_encoder.joblib')
+    print("Label encoder loaded successfully")
+except Exception as e:
+    print(f"Error loading label encoder: {e}")
+    label_encoder = None
+
+# Initialize champion name encoder
+champion_encoder = LabelEncoder()
+champion_encoder.fit(CHAMPIONS)
+
+
+#==================================== Functions =================================================
+def get_user_training_df(player_opgg_url):
+    try:
+        print("========= Inside get_user_training_df(player_opgg_url) ============= \n") 
+        #print("player_opgg_url: ", player_opgg_url, "\n type(player_opgg_url): ", type(player_opgg_url), "\n")
+
+        # Add input validation
+        if not player_opgg_url or not isinstance(player_opgg_url, str):
+            return "Invalid URL provided"
+
+        training_df = create_app_user_training_df(player_opgg_url)
+        return training_df
+    except Exception as e:
+
+        # Add more detailed error information
+        import traceback
+        error_trace = traceback.format_exc()
+        print(f"Full error trace:\n{error_trace}")
+        return f"Error getting training data: {str(e)}"
+
+        #return f"Error getting training data: {e}"
+
+def show_stats(player_opgg_url):
+    """Display player statistics and recent matches"""
+    if not player_opgg_url:
+        return "Please enter a player link to OPGG", None
+    
+    try:
+        training_features = get_user_training_df(player_opgg_url)
+
+        print("training_features: ", training_features, "\n")
+        
+        if isinstance(training_features, str):  # Error message
+            return training_features, None
+
+        wins = training_features['result'].sum()
+        losses = len(training_features) - wins
+        winrate = f"{(wins / len(training_features)) * 100:.0f}%"
+        favorite_champions = (
+            training_features['champion']
+            .value_counts()
+            .head(3)
+            .index.tolist()
+        )
+
+        stats_html = f"""
+        <div style='padding: 20px; background: #f5f5f5; border-radius: 10px;'>
+            <h3>Player's Recent Stats</h3>
+            <p>Wins: {wins} | Losses: {losses}</p>
+            <p>Winrate: {winrate}</p>
+            <p>Favorite Champions: {', '.join(favorite_champions)}</p>
+        </div>
+        """
+        
+        return stats_html, None
+    except Exception as e:
+        return f"Error processing stats: {e}. ", None
+
+def predict_champion(player_opgg_url, *champions):
+    """Make prediction based on selected champions"""
+    if not player_opgg_url or None in champions:
+        return "Please fill in all fields"
+    
+    try:
+        if model is None:
+            return "Model not loaded properly"
+        
+        if label_encoder is None:
+            return "Label encoder not loaded properly" 
+            
+        # Get and process the data
+        training_df = get_user_training_df(player_opgg_url)
+        
+        if isinstance(training_df, str):
+            return training_df
+
+        training_df = convert_df(training_df)
+        #print("type(training_df): ", type(training_df), "\n")
+        print("check_datatypes(training_df) BEFORE feature eng:  \n", check_datatypes(training_df), "\n")
+
+        training_df = apply_feature_engineering(training_df)
+        print("check_datatypes(training_df) AFTER feature eng: \n", check_datatypes(training_df), "\n")
+        
+        # Get feature columns
+        feature_columns = [col for col in training_df.columns 
+                         if col not in ['champion', 'region', 'stratify_label']]
+        X = training_df[feature_columns]
+        
+        # Handle categorical features
+        categorical_columns = X.select_dtypes(include=['category']).columns
+        X_processed = X.copy()
+        
+        for col in categorical_columns:
+            X_processed[col] = X_processed[col].cat.codes
+            
+        X_processed = X_processed.astype('float32')
+        
+        # Create DMatrix and predict
+        dtest = DMatrix(X_processed, enable_categorical=True)
+        predictions = model.predict(dtest)
+        
+        # Get prediction indices
+        if len(predictions.shape) > 1:
+            pred_indices = predictions.argmax(axis=1)
+        else:
+            pred_indices = predictions.astype(int)
+        
+        # First get the numeric ID from the original label encoder
+        decoded_numeric = label_encoder.inverse_transform(pred_indices)
+        
+        # Map numeric ID to index in CHAMPIONS list
+        # Since your label encoder seems to use champion IDs, we need to map these to list indices
+        try:
+            # Get the first prediction
+            champion_id = int(decoded_numeric[0])
+            
+            # Print debug information
+            print(f"Champion ID from model: {champion_id}")
+            
+            # Find the closest matching index
+            # Note: This assumes champion IDs roughly correspond to their position in the list
+            champion_index = min(max(champion_id - 1, 0), len(CHAMPIONS) - 1)
+            predicted_champion = CHAMPIONS[champion_index]
+            
+            print(f"Mapped to champion: {predicted_champion}")
+            
+            return f"{predicted_champion}"
+            
+        except Exception as e:
+            print(f"Error mapping champion ID: {e}")
+            return f"Error: Could not map champion ID {decoded_numeric[0]}"
+    
+    except Exception as e:
+        import traceback
+        print(f"Full error trace:\n{traceback.format_exc()}")
+        return f"Error making prediction: {e}"
+
+''' current working function!!!!!!
+def predict_champion(player_opgg_url, *champions):
+    """Make prediction based on selected champions"""
+
+    print("==================== Inside: predict_champion() ===================== \n")
+    if not player_opgg_url or None in champions:
+        return "Please fill in all fields"
+    
+    try:
+        if model is None:
+            return "Model not loaded properly"
+        
+        if label_encoder is None:
+            return "Label encoder not loaded properly"
+        
+        # Print label encoder information
+        print("\nLabel Encoder Information:")
+        print("Classes in encoder:", label_encoder.classes_)
+        print("Number of classes:", len(label_encoder.classes_))
+
+        # Get and process the data
+        training_df = get_user_training_df(player_opgg_url)
+        print("training_df retrieved: ", training_df, "\n")
+        
+        if isinstance(training_df, str):  # Error message
+            return training_df
+
+        # Apply necessary transformations
+        training_df = convert_df(training_df)
+        training_df = apply_feature_engineering(training_df)
+        print("training_df converted and feature engineered: ", training_df, "\n")
+        
+        # Get feature columns (excluding champion and region)
+        feature_columns = [col for col in training_df.columns 
+                         if col not in ['champion', 'region', 'stratify_label']]
+        X = training_df[feature_columns]
+        print("Got feature columns X: ", X, "\n")
+        
+        # Handle categorical features
+        categorical_columns = X.select_dtypes(include=['category']).columns
+        X_processed = X.copy()
+        print("Handled categorical features, X_processed = ", X_processed, "\n")
+        
+        # Convert categorical columns to numeric
+        for col in categorical_columns:
+            X_processed[col] = X_processed[col].cat.codes
+        print("Converted categorical columns to numeric: ", categorical_columns, "\n")
+            
+        # Convert to float32
+        X_processed = X_processed.astype('float32')
+        print("Converted X_processed to float32: ", X_processed, "\n")
+        
+        # Create DMatrix with categorical feature support
+        dtest = DMatrix(X_processed, enable_categorical=True)
+        print("Converted to Dmatrix: ", dtest, "\n")
+        
+        # Make prediction
+        print("Starting model prediction...\n")
+        predictions = model.predict(dtest)
+        print("Model prediction complete\n")
+
+        print("\nPrediction Information:")
+        print("Raw predictions shape:", predictions.shape)
+        print("Raw predictions:", predictions)
+        
+        # Get the highest probability prediction
+        if len(predictions.shape) > 1:
+            pred_indices = predictions.argmax(axis=1)
+        else:
+            pred_indices = predictions.astype(int)
+
+        print("\nPrediction Indices:")
+        print("Indices shape:", pred_indices.shape)
+        print("Indices:", pred_indices)
+
+        # Check if indices are within valid range
+        print("\nValidation:")
+        print("Min index:", pred_indices.min())
+        print("Max index:", pred_indices.max())
+        print("Valid index range:", 0, len(label_encoder.classes_) - 1)
+        # Try to decode predictions
+
+        try:
+            decoded_preds = label_encoder.inverse_transform(pred_indices)
+            print("\nDecoded Predictions:")
+            print("Type:", type(decoded_preds))
+            print("Value:", decoded_preds) 
+            print("==================== Exiting: predict_champion()===================\n")
+            return f"Predicted champion: {decoded_preds[0]}"
+        except Exception as e:
+            print(f"\nError during decoding: {e}")
+            # Fallback: try to directly index into classes
+            try:
+                champion = label_encoder.classes_[int(pred_indices[0])]
+                return f"Predicted champion: {champion}"
+            except Exception as e2:
+                print(f"Fallback error: {e2}")
+                return f"Error decoding prediction: {pred_indices[0]}"
+    
+    except Exception as e:
+        import traceback
+        print(f"Full error trace:\n{traceback.format_exc()}")
+        return f"Error making prediction: {e}"
+'''
+
+# Define your interface
+with gr.Blocks() as demo:
+    gr.Markdown("# League of Legends Champion Prediction")
+    
+    with gr.Row():
+        player_opgg_url = gr.Textbox(label="OPGG Player URL")
+        show_button = gr.Button("Show Player Stats")
+    
+    with gr.Row():
+        stats_output = gr.HTML(label="Player Statistics")
+        recent_matches = gr.HTML(label="Recent Matches")
+    
+    with gr.Row():
+        champion_dropdowns = [
+            gr.Dropdown(choices=CHAMPIONS, label=f"Champion {i+1}")
+            for i in range(9)
+        ]
+    
+    with gr.Row():
+        predict_button = gr.Button("Predict")
+        prediction_output = gr.Text(label="Prediction")
+        
+    # Set up event handlers
+    show_button.click(
+        fn=show_stats,
+        inputs=[player_opgg_url],
+        outputs=[stats_output, recent_matches]
+    )
+    
+    predict_button.click(
+        fn=predict_champion,
+        inputs=[player_opgg_url] + champion_dropdowns,
+        outputs=prediction_output
+    )
+
+# Optional: Save the champion encoder for future use
+joblib.dump(champion_encoder, 'champion_encoder.joblib')
+# Enable queuing
+demo.launch(debug=True)
+
+# For local testing
+if __name__ == "__main__":
+    demo.launch()