Delete app.py

app.py

@@ -1,227 +0,0 @@
-
-import pandas as pd
-import numpy as np
-from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
-import matplotlib.pyplot as plt
-import seaborn as sns
-import pickle
-import gradio as gr
-import os
-
-# Load the model
-model_path = 'career_prediction_model.pkl'
-with open(model_path, 'rb') as f:
-    saved_data = pickle.load(f)
-
-model = saved_data['model']
-label_encoders = saved_data['label_encoders']
-target_encoder = saved_data['target_encoder']
-features = saved_data['features']
-target = 'What would you like to become when you grow up'
-
-# Function for individual prediction
-def predict_career(work_env, academic_perf, motivation, leadership, tech_savvy):
-    # Prepare input data
-    input_data = pd.DataFrame({
-        'Preferred Work Environment': [work_env],
-        'Academic Performance (CGPA/Percentage)': [float(academic_perf)],
-        'Motivation for Career Choice ': [motivation],  # Note the space at the end
-        'Leadership Experience': [leadership],
-        'Tech-Savviness': [tech_savvy]
-    })
-    
-    # Encode categorical features
-    for feature in features:
-        if feature in label_encoders and input_data[feature].dtype == 'object':
-            try:
-                input_data[feature] = label_encoders[feature].transform(input_data[feature])
-            except ValueError:
-                # Handle unknown categories
-                print(f"Warning: Unknown category in {feature}. Using most frequent category.")
-                input_data[feature] = 0  # Default to first category
-    
-    # Make prediction
-    prediction = model.predict(input_data)[0]
-    predicted_career = target_encoder.inverse_transform([int(prediction)])[0]
-    
-    # Get probabilities for all classes
-    if hasattr(model, 'predict_proba'):
-        probabilities = model.predict_proba(input_data)[0]
-        class_probs = {target_encoder.inverse_transform([i])[0]: prob 
-                      for i, prob in enumerate(probabilities)}
-        sorted_probs = dict(sorted(class_probs.items(), key=lambda x: x[1], reverse=True))
-        
-        result = f"Predicted career: {predicted_career}\n\nProbabilities:\n"
-        for career, prob in sorted_probs.items():
-            result += f"{career}: {prob:.2f}\n"
-        return result
-    else:
-        return f"Predicted career: {predicted_career}"
-
-# Function for batch evaluation
-def evaluate_model_with_csv(csv_file):
-    try:
-        # Try different encodings
-        encodings = ['utf-8', 'latin1', 'ISO-8859-1', 'cp1252', 'utf-8-sig']
-        
-        # Try each encoding until one works
-        for encoding in encodings:
-            try:
-                test_df = pd.read_csv(csv_file.name, encoding=encoding)
-                break
-            except UnicodeDecodeError:
-                if encoding == encodings[-1]:
-                    return ["Error: Could not decode the CSV file with any common encodings.", None]
-                continue
-            except Exception as e:
-                if encoding == encodings[-1]:
-                    return [f"Error reading CSV: {str(e)}", None]
-                continue
-        
-        # Check if required columns exist
-        missing_cols = [col for col in features + [target] if col not in test_df.columns]
-        if missing_cols:
-            return [f"Error: The following required columns are missing in the CSV: {missing_cols}", None]
-        
-        # Preprocess the test data
-        X_eval = test_df[features].copy()
-        
-        # Handle missing values
-        X_eval = X_eval.fillna('Unknown')
-        
-        # Convert Academic Performance to numeric
-        X_eval['Academic Performance (CGPA/Percentage)'] = pd.to_numeric(
-            X_eval['Academic Performance (CGPA/Percentage)'], errors='coerce')
-        X_eval['Academic Performance (CGPA/Percentage)'].fillna(
-            X_eval['Academic Performance (CGPA/Percentage)'].mean(), inplace=True)
-        
-        # Encode categorical features
-        for feature in features:
-            if feature in label_encoders and X_eval[feature].dtype == 'object':
-                # Handle unknown categories by mapping them to 0
-                X_eval[feature] = X_eval[feature].apply(
-                    lambda x: label_encoders[feature].transform([x])[0] 
-                    if x in label_encoders[feature].classes_ else 0
-                )
-        
-        # Get the true labels
-        y_true = test_df[target].copy()
-        y_true = y_true.fillna('Corporate Employee')
-        
-        # Encode the true labels
-        y_true_encoded = y_true.apply(
-            lambda x: target_encoder.transform([x])[0] 
-            if x in target_encoder.classes_ else 0
-        ).values
-        
-        # Make predictions
-        y_pred = model.predict(X_eval)
-        y_pred = np.array(y_pred).astype(int)
-        
-        # Calculate accuracy
-        accuracy = accuracy_score(y_true_encoded, y_pred)
-        
-        # Create a DataFrame with actual vs predicted values
-        results_df = pd.DataFrame({
-            'Actual Career': [target_encoder.classes_[i] for i in y_true_encoded],
-            'Predicted Career': [target_encoder.classes_[i] for i in y_pred]
-        })
-        
-        # Count correct predictions
-        results_df['Correct'] = results_df['Actual Career'] == results_df['Predicted Career']
-        correct_count = results_df['Correct'].sum()
-        total_count = len(results_df)
-        
-        # Create confusion matrix
-        plt.figure(figsize=(12, 10))
-        cm = pd.crosstab(results_df['Actual Career'], results_df['Predicted Career'])
-        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
-        plt.title('Confusion Matrix')
-        plt.ylabel('Actual Career')
-        plt.xlabel('Predicted Career')
-        plt.tight_layout()
-        
-        # Save the confusion matrix
-        cm_path = 'confusion_matrix.png'
-        plt.savefig(cm_path)
-        
-        # Prepare the results
-        result_text = f"Model Evaluation Results:\n\n"
-        result_text += f"Total samples: {total_count}\n"
-        result_text += f"Correct predictions: {correct_count}\n"
-        result_text += f"Accuracy: {accuracy:.4f}\n\n"
-        
-        # Generate classification report
-        report = classification_report(y_true_encoded, y_pred, 
-                                      target_names=target_encoder.classes_, 
-                                      output_dict=True)
-        
-        # Add class-wise metrics
-        result_text += "Class-wise Performance:\n"
-        for class_name in target_encoder.classes_:
-            if class_name in report:
-                result_text += f"\n{class_name}:\n"
-                result_text += f"  Precision: {report[class_name]['precision']:.4f}\n"
-                result_text += f"  Recall: {report[class_name]['recall']:.4f}\n"
-                result_text += f"  F1-score: {report[class_name]['f1-score']:.4f}\n"
-        
-        return [result_text, cm_path]
-    
-    except Exception as e:
-        import traceback
-        error_details = traceback.format_exc()
-        print(f"Error in evaluation: {str(e)}\n{error_details}")
-        
-        # Create a simple error image
-        plt.figure(figsize=(6, 4))
-        plt.text(0.5, 0.5, f"Error: {str(e)}", 
-                 horizontalalignment='center', verticalalignment='center', fontsize=12, color='red')
-        plt.axis('off')
-        error_path = 'error_image.png'
-        plt.savefig(error_path)
-        
-        return [f"Error: {str(e)}", error_path]
-
-# Get unique values for dropdowns
-work_env_options = list(label_encoders['Preferred Work Environment'].classes_)
-motivation_options = list(label_encoders['Motivation for Career Choice '].classes_)
-leadership_options = list(label_encoders['Leadership Experience'].classes_)
-tech_savvy_options = list(label_encoders['Tech-Savviness'].classes_)
-
-# Create the Gradio interface
-iface = gr.Interface(
-    fn=predict_career,
-    inputs=[
-        gr.Dropdown(work_env_options, label="Preferred Work Environment"),
-        gr.Number(label="Academic Performance (CGPA/Percentage)", minimum=0, maximum=10),
-        gr.Dropdown(motivation_options, label="Motivation for Career Choice"),
-        gr.Dropdown(leadership_options, label="Leadership Experience"),
-        gr.Dropdown(tech_savvy_options, label="Tech-Savviness")
-    ],
-    outputs="text",
-    title="Career Prediction Model",
-    description="Enter your details to predict your future career path",
-    theme="huggingface"
-)
-
-# Create a separate interface for model evaluation
-eval_iface = gr.Interface(
-    fn=evaluate_model_with_csv,
-    inputs=gr.File(label="Upload Test CSV File"),
-    outputs=[
-        gr.Textbox(label="Evaluation Results"),
-        gr.Image(label="Confusion Matrix")
-    ],
-    title="Career Prediction Model Evaluation",
-    description="Upload a CSV file with test data to evaluate the model's performance",
-    theme="huggingface"
-)
-
-# Create a tabbed interface
-demo = gr.TabbedInterface(
-    [iface, eval_iface],
-    ["Individual Prediction", "Batch Evaluation"]
-)
-
-# Launch the interface
-demo.launch()