kermitting soon

util/app.py

@@ -43,13 +43,18 @@ try:
 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):
@@ -73,102 +78,6 @@ 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=2, train_size=0.6, val_size=0.2, 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:
@@ -205,6 +114,82 @@ def show_stats(player_opgg_url):
     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)
+        training_df = apply_feature_engineering(training_df)
+        
+        # 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: {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"""
 
@@ -307,77 +292,7 @@ def predict_champion(player_opgg_url, *champions):
         import traceback
         print(f"Full error trace:\n{traceback.format_exc()}")
         return f"Error making prediction: {e}"
-
-def predict_champion_NOT_IN_USE(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"
-
-        training_df = get_user_training_df(player_opgg_url)
-
-        print("training_df type: ", type(training_df), "\n training_df: \n", training_df , "\n")
-
-        training_df = convert_df(training_df)
-        training_df = 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")
-
-        # Handle categorical features
-        categorical_columns = X_val.select_dtypes(include=['category']).columns
-        X_val_processed = X_val.copy()
-        
-        # Convert categorical columns to numeric
-        for col in categorical_columns:
-            X_val_processed[col] = X_val_processed[col].cat.codes
-            
-        # Convert to float32
-        X_val_processed = X_val_processed.astype('float32')
-        
-        # Create DMatrix with categorical feature support from pandas dataframe.
-        dtest = DMatrix(X_val_processed, enable_categorical=True)
-
-        print("type(X_test) after converting to DMatrix: ", type(X_test), "\n") 
-
-        print("Starting model prediction... \n")
-
-        predictions = model.predict(dtest)
-        print("Previous line: predictions = model.predict(dtest). \n prediction: ", predictions , "\n")
-
-        '''
-        # Get the highest probability prediction
-        if len(predictions.shape) > 1:
-            pred_indices = predictions.argmax(axis=1)
-        else:
-            pred_indices = predictions.astype(int)
-
-        # Decode predictions using loaded label encoder
-        decoded_preds = label_encoder.inverse_transform(pred_indices)
-        '''
-        
-        # Decode predictions (if using LabelEncoder)
-        decoded_preds = label_encoder.inverse_transform(predictions)
-        print("decoded_preds: ", decoded_preds, "\n")
-
-        return f"Predicted champion: {decoded_preds}"
-    except Exception as e:
-        return f"Error making prediction: {e}"
+'''
 
 # Define your interface
 with gr.Blocks() as demo:
@@ -414,8 +329,9 @@ with gr.Blocks() as demo:
         outputs=prediction_output
     )
 
+# Optional: Save the champion encoder for future use
+joblib.dump(champion_encoder, 'champion_encoder.joblib')
 # Enable queuing
-#demo.queue(debug = True)
 demo.launch(debug=True)
 
 # For local testing