added new structure

util/app.py

@@ -7,7 +7,8 @@ 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 * 
+from helper import *
+from helper import ChampionConverter 
 import joblib
 
 
@@ -127,7 +128,7 @@ def show_stats(player_opgg_url):
     except Exception as e:
         return f"Error processing stats: {e}. ", None
 
-def predict_champion(player_opgg_url, *champions):
+def predict_top_5_champion_w_confidence(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"
@@ -146,56 +147,92 @@ def predict_champion(player_opgg_url, *champions):
             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")
         
+        label_column = training_df['champion']
+        predict_column = training_df.drop(columns=['champion', 'region'])
+
         # 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]
+        # 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()
+        # 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
+        # for col in categorical_columns:
+        #     X_processed[col] = X_processed[col].cat.codes
             
-        X_processed = X_processed.astype('float32')
+        # X_processed = X_processed.astype('float32')
         
         # Create DMatrix and predict
-        dtest = DMatrix(X_processed, enable_categorical=False)
-        predictions = model.predict(dtest)
+        # dtest = DMatrix(X_processed, enable_categorical=False)
+        # predictions = model.predict(dtest)
+        proba = model.predict_proba(training_df)
         
         # Get prediction indices
-        if len(predictions.shape) > 1:
-            pred_indices = predictions.argmax(axis=1)
-        else:
-            pred_indices = predictions.astype(int)
+        # if len(predictions.shape) > 1:
+        #     pred_indices = predictions.argmax(axis=1)
+        # else:
+        #     pred_indices = predictions.astype(int)
+
+        # Get top 5 indices and probabilities
+        top_5_idx = np.argsort(proba, axis=1)[:, -5:][:, ::-1]
+        top_5_proba = np.take_along_axis(proba, top_5_idx, axis=1)
+
+        # Initialize results DataFrame
+        results = pd.DataFrame()
+
+        champion_converter = ChampionConverter()
         
+        # Add true champion - convert numeric label to champion name
+        true_numbers = label_column
+        results['True_Champion'] = [champion_converter.num_to_champion(int(num)) for num in true_numbers]
+        
+        # Process each rank separately
+        for i in range(5):
+            # Convert indices to champion names using the champion converter
+            champions = [champion_converter.num_to_champion(int(label_encoder.classes_[idx])) for idx in top_5_idx[:, i]]
+            probabilities = top_5_proba[:, i]
+            
+            # Add to results
+            results[f'Rank_{i+1}_Champion'] = champions
+            results[f'Rank_{i+1}_Confidence'] = probabilities.round(4)
+
         # First get the numeric ID from the original label encoder
-        decoded_numeric = label_encoder.inverse_transform(pred_indices)
+        # 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 3 prediction
-            champion_id = int(decoded_numeric[0])
+            # champion_id = int(decoded_numeric[0])
             
             # Print debug information
-            print(f"Champion ID from model: {champion_id}")
+            # 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]
+            # champion_index = min(max(champion_id - 1, 0), len(CHAMPIONS) - 1)
+            # predicted_champion = CHAMPIONS[champion_index]
             
-            print(f"Mapped to champion: {predicted_champion}")
+            # print(f"Mapped to champion: {predicted_champion}")
+
+
+            def find_champion_rank(row):
+                true_champ = row['True_Champion']
+                for i in range(1, 6):
+                    if row[f'Rank_{i}_Champion'] == true_champ:
+                        return f'Rank_{i}'
+                return 'Not in Top 5'
+            
+            results['Prediction_Rank'] = results.apply(find_champion_rank, axis=1)
             
-            return f"{predicted_champion}"
+            return results
             
         except Exception as e:
             print(f"Error mapping champion ID: {e}")
@@ -206,111 +243,6 @@ def predict_champion(player_opgg_url, *champions):
         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")