kermitting soon

util/app.py

@@ -3,6 +3,17 @@ import gradio as gr
 import xgboost as xgb
 from huggingface_hub import hf_hub_download
 from app_training_df_getter import create_app_user_training_df
+import pandas as pd
+import numpy as np
+from collections import Counter
+import os
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import classification_report, precision_score, recall_score, f1_score
+from xgboost import XGBClassifier, plot_importance
+import xgboost as xgb
+from helper import * 
+import helper as helpfun
 
 
 # Define champion list for dropdowns
@@ -60,6 +71,101 @@ def get_user_training_df(player_opgg_url):
 
         #return f"Error getting training data: {e}"
 
+def prepare_training_df(df, target_column='champion', stratify_columns=['champion', 'region'], 
+                         min_samples_per_class=6, train_size=0, val_size=1, random_state=42):
+    df = df.copy()
+    original_dtypes = df.dtypes.to_dict()
+
+    # Create composite stratification label
+    df['stratify_label'] = df[stratify_columns[0]].astype(str)
+    for col in stratify_columns[1:]:
+        df['stratify_label'] += '_' + df[col].astype(str)
+    
+    # Handle categorical columns - store category mappings
+    categorical_columns = df.select_dtypes(include=['category']).columns.tolist()
+    if target_column in categorical_columns:
+        categorical_columns.remove(target_column)
+    
+    category_mappings = {}
+    temp_encoded_df = df.copy()
+    
+    # Convert categorical columns to codes but keep original data
+    for col in categorical_columns:
+        if col in df.columns:
+            category_mappings[col] = {
+                'categories': df[col].cat.categories,
+                'ordered': df[col].cat.ordered
+            }
+            temp_encoded_df[col] = df[col].cat.codes
+    
+    # Remove combinations with too few samples
+    combo_counts = df['stratify_label'].value_counts()
+    valid_combos = combo_counts[combo_counts >= min_samples_per_class].index
+    print(type(valid_combos))
+    
+    # Filter data
+    mask = df['stratify_label'].isin(valid_combos)
+    df_filtered = df[mask].copy()
+    temp_encoded_filtered = temp_encoded_df[mask].copy()
+
+    # Prepare features and target
+    feature_columns = [col for col in df_filtered.columns if col not in stratify_columns + ['stratify_label']]
+    X = temp_encoded_filtered[feature_columns]  # Use encoded version for splitting
+    y = df_filtered[target_column]
+
+    # Encode target values
+    label_encoder = LabelEncoder()
+    y_encoded = label_encoder.fit_transform(y)
+    
+    # Calculate test_size based on train and validation sizes
+    test_size = 1 - train_size - val_size
+    temp_size = val_size + test_size
+    
+    # First split: training and temporary sets
+    X_train, X_temp, y_train, y_temp = train_test_split(
+        X, y_encoded,
+        test_size=temp_size,
+        random_state=random_state,
+        stratify=df_filtered['stratify_label']
+    )
+    
+    # Get corresponding stratify labels for temp set
+    temp_indices = X_temp.index
+    temp_stratify = df_filtered.loc[temp_indices, 'stratify_label']
+    
+    # Second split: validation and test sets
+    val_ratio = val_size / (val_size + test_size)
+    X_val, X_test, y_val, y_test = train_test_split(
+        X_temp, y_temp,
+        test_size=(1 - val_ratio),
+        random_state=random_state,
+        stratify=temp_stratify
+    )
+
+    print("X_val: ", X_val, "\n X_val type: ", type(X_val), "\n y_val: ", y_val, "\n y_val type: ", type(y_val))
+    
+    # Restore categorical dtypes
+    for col in categorical_columns:
+        if col in X_train.columns:
+            X_train[col] = pd.Categorical.from_codes(
+                X_train[col], 
+                categories=category_mappings[col]['categories'],
+                ordered=category_mappings[col]['ordered']
+            )
+            X_val[col] = pd.Categorical.from_codes(
+                X_val[col], 
+                categories=category_mappings[col]['categories'],
+                ordered=category_mappings[col]['ordered']
+            )
+            X_test[col] = pd.Categorical.from_codes(
+                X_test[col], 
+                categories=category_mappings[col]['categories'],
+                ordered=category_mappings[col]['ordered']
+            )
+    
+    
+    return X_train, X_val, X_test, y_train, y_val, y_test, label_encoder
+
 def show_stats(player_opgg_url):
     """Display player statistics and recent matches"""
     if not player_opgg_url:
@@ -85,7 +191,7 @@ def show_stats(player_opgg_url):
 
         stats_html = f"""
         <div style='padding: 20px; background: #f5f5f5; border-radius: 10px;'>
-            <h3>Player Stats</h3>
+            <h3>Player's Recent Stats</h3>
             <p>Wins: {wins} | Losses: {losses}</p>
             <p>Winrate: {winrate}</p>
             <p>Favorite Champions: {', '.join(favorite_champions)}</p>
@@ -110,14 +216,32 @@ def predict_champion(player_opgg_url, *champions):
         
         print("============= Inside predict_champion(): Model loaded properly=================\n")
 
-        features = get_user_training_df(player_opgg_url)
+        training_df = get_user_training_df(player_opgg_url)
 
         print("============= Inside predict_champion(): =================\n")
         print("features type: ", type(features), "\n features: \n", features, "\n")
         
+        print("=============== Inside predict_champion =================== \n")
+
+        training_df = convert_df(training_df)
+        features = apply_feature_engineering(training_df)
+        check_datatypes(training_df)
+
+        X_train, X_val, X_test, y_train, y_val, y_test, label_encoder = prepare_training_df(
+            training_df,
+            target_column='champion',
+            stratify_columns=['champion', 'region'],
+            min_samples_per_class=5,
+            train_size=0.6,
+            val_size=0.2,
+            random_state=42
+        )
+        print("type(X_test): ", type(X_test), "\n")
+
         print("Starting model prediction... \n")
         prediction = model.predict(features)
         predicted_champion = CHAMPIONS[prediction[0]]
+
         return f"Predicted champion: {predicted_champion}"
     except Exception as e:
         return f"Error making prediction: {e}"