app.py

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()