kermitting soon

util/app.py

@@ -44,6 +44,13 @@ except Exception as e:
     print(f"Error loading model: {e}")
     model = None 
 
+try:
+    label_encoder = joblib.load('label_encoder.joblib')
+    print("Label encoder loaded successfully")
+except Exception as e:
+    print(f"Error loading label encoder: {e}")
+    label_encoder = None
+
 # Functions
 def get_user_training_df(player_opgg_url):
     try:
@@ -67,7 +74,7 @@ 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.6, val_size=0.2, random_state=42):
+                         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()
 
@@ -200,6 +207,67 @@ def show_stats(player_opgg_url):
 
 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):  # Error message
+            return training_df
+
+        # Apply necessary transformations
+        training_df = convert_df(training_df)
+        training_df = apply_feature_engineering(training_df)
+        
+        # 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]
+        
+        # Handle categorical features
+        categorical_columns = X.select_dtypes(include=['category']).columns
+        X_processed = X.copy()
+        
+        # Convert categorical columns to numeric
+        for col in categorical_columns:
+            X_processed[col] = X_processed[col].cat.codes
+            
+        # Convert to float32
+        X_processed = X_processed.astype('float32')
+        
+        # Create DMatrix with categorical feature support
+        dtest = DMatrix(X_processed, enable_categorical=True)
+        
+        # Make prediction
+        predictions = model.predict(dtest)
+        
+        # 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)
+        
+        # Return the first prediction
+        return f"Predicted champion: {decoded_preds[0]}"
+    
+    except Exception as e:
+        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")