ML.py

import streamlit as st
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split,cross_val_score,GridSearchCV
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, roc_curve, auc,classification_report
from sklearn.impute import SimpleImputer
import openpyxl
import optuna
import joblib
import plotly.express as px
import seaborn as sns
import matplotlib.pyplot as plt

st.set_page_config(page_title="ML Model Deployment", layout="wide")

def load_data(file):
    try:
        if file.name.endswith('.csv'):
            data = pd.read_csv(file)
        elif file.name.endswith(('.xls', '.xlsx')):
            data = pd.read_excel(file)
        return data
    except Exception as e:
        st.error(f"Error loading file: {e}")
        return None

def auto_process_data(data):
    processed_data = data.copy()
    label_encoders = {}
    
    if processed_data.isnull().sum().sum() > 0:
        st.info("Automatically handling missing values...")
        
        num_cols = processed_data.select_dtypes(include=['int64', 'float64']).columns
        if len(num_cols) > 0:
            num_imputer = SimpleImputer(strategy='median')
            processed_data[num_cols] = num_imputer.fit_transform(processed_data[num_cols])
        
        cat_cols = processed_data.select_dtypes(include=['object']).columns
        if len(cat_cols) > 0:
            for col in cat_cols:
                if processed_data[col].isnull().any():
                    most_frequent = processed_data[col].mode()[0]
                    processed_data[col].fillna(most_frequent, inplace=True)
    
    for column in processed_data.select_dtypes(include=['object']):
        label_encoders[column] = LabelEncoder()
        processed_data[column] = label_encoders[column].fit_transform(processed_data[column].astype(str))
    
    return processed_data, label_encoders

def get_model_configs():
    models = {
        'Logistic Regression': {
            'pipeline': Pipeline([
                ('scaler', StandardScaler()),
                ('classifier', LogisticRegression())
            ]),
            'params': {
                'classifier__penalty':['l1','l2'],
                'classifier__C':[0.01,0.1,1],
                'classifier__max_iter': [100, 200],
                'classifier__solver':['liblinear','saga']
            }
        },
        'Support Vector Machine': {
            'pipeline': Pipeline([
                ('scaler', StandardScaler()),
                ('classifier', SVC(probability=True))
            ]),
            'params': {
                'classifier__C': [0.001, 0.1, 1],
                'classifier__kernel': ['linear', 'rbf', 'sigmoid'],
                'classifier__gamma': ['scale', 'auto', 0.01, 0.1, 1],
                'classifier__max_iter':[100,200]
            }
        },
        'Random Forest': {
            'pipeline': Pipeline([
                ('scaler', StandardScaler()),
                ('classifier', RandomForestClassifier())
            ]),
            'params': {
                'classifier__n_estimators':[100,200],
                'classifier__max_depth': [None, 10, 20],
                'classifier__min_samples_split': [2,5,10],
                'classifier__min_samples_leaf':[1,2,4],
            }
        },
        'XgBoost':{
            'pipeline':Pipeline([
            ('scaled',StandardScaler()),
            ('classifier',XGBClassifier(use_label_encoder=False,eval_metric='logloss'))
            ]),
            'params':{
                'classifier__n_estimators': [100, 200],
                'classifier__learning_rate': [0.01, 0.05, 0.1],
                'classifier__max_depth': [3, 5, 7],
                'classifier__min_child_weight': [1, 3, 5],
                'classifier__subsample': [0.8, 1.0]               
            }
        }
    }
    return models

def train_model(X_train, y_train, selected_model, progress_bar=None):
    models = get_model_configs()
    model_config = models[selected_model]
    
    with st.spinner(f"Training {selected_model}..."):
        grid_search = GridSearchCV(
            estimator=model_config['pipeline'],
            param_grid=model_config['params'],
            cv=5,
            n_jobs=-1,
            verbose=0,
            scoring="accuracy"
        )
        grid_search.fit(X_train, y_train)
        
        if progress_bar:
            progress_bar.progress(1.0)
        
        return grid_search.best_estimator_, grid_search.best_score_
def objective(trial, X_train, y_train, model_name):
    models = get_model_configs()
    model_config = models[model_name]
    dataset_size = len(X_train)
    cv_folds = 5 if dataset_size > 1000 else (3 if dataset_size > 500 else min(2, dataset_size))
    params = {}

    if model_name == 'Logistic Regression':
        params = {
            'classifier__penalty': trial.suggest_categorical('classifier__penalty', ['l1', 'l2']),
            'classifier__C': trial.suggest_float('classifier__C', 0.01, 1.0, log=True),
            'classifier__solver': trial.suggest_categorical('classifier__solver', ['liblinear', 'saga']),
            'classifier__max_iter': trial.suggest_int('classifier__max_iter', 100, 200)
        }
    
    elif model_name == 'Support Vector Machine':
        params = {
            'classifier__C': trial.suggest_float('classifier__C', 0.001, 1.0, log=True),
            'classifier__kernel': trial.suggest_categorical('classifier__kernel', ['linear', 'rbf', 'sigmoid']),
            'classifier__gamma': trial.suggest_categorical('classifier__gamma', ['scale', 'auto', 0.01, 0.1, 1]),
            'classifier__max_iter': trial.suggest_int('classifier__max_iter', 100, 200)
        }
    
    elif model_name == 'Random Forest':
         params = {
            'classifier__n_estimators': trial.suggest_int('classifier__n_estimators', 100, 200),
            'classifier__max_depth': trial.suggest_categorical('classifier__max_depth', [None, 10, 20]),
            'classifier__min_samples_split': trial.suggest_int('classifier__min_samples_split', 2, 10),
            'classifier__min_samples_leaf': trial.suggest_int('classifier__min_samples_leaf', 1, 4)
        }
    elif model_name == 'XGBoost':
         params = {
            'classifier__n_estimators': trial.suggest_int('classifier__n_estimators', 100, 300),
            'classifier__learning_rate': trial.suggest_float('classifier__learning_rate', 0.01, 0.2, log=True),
            'classifier__max_depth': trial.suggest_int('classifier__max_depth', 3, 10),
            'classifier__min_child_weight': trial.suggest_int('classifier__min_child_weight', 1, 6)
        }
    
    pipeline = model_config['pipeline'].set_params(**params)
    pipeline.fit(X_train, y_train)
    
    score = cross_val_score(pipeline, X_train, y_train, cv=cv_folds, scoring="accuracy").mean()
    return score
def auto_train(X_train, y_train, X_test, y_test):
    models = get_model_configs()
    results = {}
    best_score = 0
    best_model = None
    best_model_name = None

    st.write("🔄 Training models with Optuna hyperparameter tuning...")

    progress_cols = st.columns(len(models))
    progress_bars = {model_name: progress_cols[i].progress(0.0) for i, model_name in enumerate(models)}

    for model_name in models.keys():
        st.write(f"🛠 Training {model_name}...")

        # Run Optuna optimization
        study = optuna.create_study(direction='maximize')
        study.optimize(lambda trial: objective(trial, X_train, y_train, model_name), n_trials=20)

        # Retrieve best parameters and train model
        best_params = study.best_params
        pipeline = models[model_name]['pipeline'].set_params(**best_params)
        pipeline.fit(X_train, y_train)

        # Evaluate model
        y_pred = pipeline.predict(X_test)
        test_accuracy = accuracy_score(y_test, y_pred)

        results[model_name] = {
            'model': pipeline,
            'cv_score': study.best_value,
            'test_accuracy': test_accuracy
        }

        progress_bars[model_name].progress(1.0)

        # Track best model
        if test_accuracy > best_score:
            best_score = test_accuracy
            best_model = pipeline
            best_model_name = model_name

    # Display results
    results_df = pd.DataFrame({
        'Model': list(results.keys()),
        'Cross-Validation Score': [results[model]['cv_score'] for model in results],
        'Test Accuracy': [results[model]['test_accuracy'] for model in results]
    }).sort_values('Test Accuracy', ascending=False)

    st.subheader("📊 Model Performance Comparison")
    st.dataframe(results_df)

    st.success(f"🏆 Best model: **{best_model_name}** with accuracy: **{best_score:.2%}**")

    return best_model, best_model_name

def get_classification_report(y_true, y_pred):
    report_dict = classification_report(y_true, y_pred, output_dict=True)
    df = pd.DataFrame(report_dict).transpose()
    return df
def evaluate_models(X_train, X_test, y_train, y_test):
    models =get_model_configs()
    
    results = {}

    plt.figure(figsize=(10, 6))
    
    for name, model in models.items():
        model.fit(X_train, y_train)
        y_pred = model.predict(X_test)
        y_prob = model.predict_proba(X_test)[:, 1] if hasattr(model, "predict_proba") else None
        
        accuracy = accuracy_score(y_test, y_pred)
        precision = precision_score(y_test, y_pred, average='binary')
        recall = recall_score(y_test, y_pred, average='binary')
        f1 = f1_score(y_test, y_pred, average='binary')
        roc_auc = roc_auc_score(y_test, y_prob) if y_prob is not None else None
        
        results[name] = {
            "Accuracy": accuracy,
            "Precision": precision,
            "Recall": recall,
            "F1-score": f1,
            "ROC-AUC": roc_auc
        }

        if y_prob is not None:
            fpr, tpr, _ = roc_curve(y_test, y_prob)
            plt.plot(fpr, tpr, label=f"{name} (AUC = {roc_auc:.2f})")

    plt.plot([0, 1], [0, 1], linestyle="--", color="gray")
    plt.xlabel("False Positive Rate")
    plt.ylabel("True Positive Rate")
    plt.title("ROC Curves")
    plt.legend()
    plt.show()
    
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    for ax, (name, model) in zip(axes.ravel(), models.items()):
        y_pred = model.predict(X_test)
        cm = confusion_matrix(y_test, y_pred)
        sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax)
        ax.set_title(f"{name} - Confusion Matrix")
        ax.set_xlabel("Predicted Label")
        ax.set_ylabel("True Label")
    
    plt.tight_layout()
    plt.show()

    results_df = pd.DataFrame(results).T
    results_df.plot(kind="bar", figsize=(10, 6))
    plt.title("Model Comparison")
    plt.ylabel("Score")
    plt.xticks(rotation=45)
    plt.legend(title="Metrics")
    plt.show()
    
    return results_df

def main():
    st.title("🤖  Machine Learning Model Deployment")
    
    st.sidebar.header("Navigation")
    page = st.sidebar.radio("Go to", ["Home","Data Upload & Analysis", "Model Training","Visualisation", "Prediction"])
    
    if 'data' not in st.session_state:
        st.session_state.data = None
    if 'processed_data' not in st.session_state:
        st.session_state.processed_data = None
    if 'label_encoders' not in st.session_state:
        st.session_state.label_encoders = None
    if 'model' not in st.session_state:
        st.session_state.model = None
    if 'features' not in st.session_state:
        st.session_state.features = None
    if 'target' not in st.session_state:
        st.session_state.target = None
    if 'model_name' not in st.session_state:
        st.session_state.model_name = None

    if page=="Home":
        st.title("🚀 AutoML: Effortless Machine Learning")
        st.markdown(
        """
        Welcome to **AutoML**, a powerful yet easy-to-use tool that automates the process of building and evaluating 
        machine learning models. Whether you're a beginner exploring data or an expert looking for quick model deployment, 
        AutoML simplifies the entire workflow.
        """
        )

        st.header("🔹 Features")
        st.markdown(
        """
        - **Automated Model Selection** – Let AutoML pick the best algorithm for your data.
        - **Hyperparameter Tuning** – Optimize model performance without manual tweaking.
        - **Data Preprocessing** – Handle missing values, scaling, encoding, and feature engineering.
        - **Performance Evaluation** – Compare models with key metrics and visualizations.
        - **Model Export** – Save trained models for deployment.
        """
        )

        st.header("🚀 Get Started")
        st.markdown(
        """
        1. **Upload your dataset** – Provide a CSV or Excel file with your data.
        2. **Select your target variable** – Choose the column to predict.
        3. **Let AutoML do the magic!** – Sit back and watch the automation work.
        """
        )

        st.header("📊 Visual Insights")
        st.markdown(
        """
        Explore interactive charts and performance metrics to make informed decisions. 
        Use visualizations to compare model accuracy, precision, recall, and other key statistics.
        """
        )

        st.success("Start automating your ML workflows now! 🎯")
        st.write('''Developed By Gourav Singh,Ankit Yadav,Pushpansh''')
  
    if page == "Data Upload & Analysis":
        st.header("📊 Data Upload & Analysis")
        
        uploaded_file = st.file_uploader("Upload your dataset (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
        
        if uploaded_file is not None:
            st.session_state.data = load_data(uploaded_file)
            
            if st.session_state.data is not None:
                st.session_state.processed_data, st.session_state.label_encoders = auto_process_data(st.session_state.data)
                
                st.success("Data loaded and automatically processed!")
                
                st.subheader("Dataset Overview")
                col1, col2, col3 = st.columns(3)
                with col1:
                    st.info(f"Number of rows: {st.session_state.data.shape[0]}")
                with col2:
                    st.info(f"Number of columns: {st.session_state.data.shape[1]}")
                with col3:
                    missing_values = st.session_state.data.isnull().sum().sum()
                    st.info(f"Missing values: {missing_values} (Automatically handled)")
                
                st.subheader("Original Data Preview")
                st.dataframe(st.session_state.data.head())
                
                st.subheader("Processed Data Preview")
                st.dataframe(st.session_state.processed_data.head())
                
                st.subheader("Statistical Description")
                st.dataframe(st.session_state.processed_data.describe())
                
                st.subheader("Correlation Heatmap")
                fig, ax = plt.subplots(figsize=(10, 6))
                sns.heatmap(st.session_state.processed_data.corr(), annot=True, cmap='coolwarm', ax=ax)
                st.pyplot(fig)
    
    elif page == "Model Training":
        st.header("🎯 Auto Model Training")
        
        if st.session_state.processed_data is None:
            st.warning("Please upload and process your data first!")
            return
            
        st.subheader("Select Features and Target")
        columns = st.session_state.processed_data.columns.tolist()
        
        st.session_state.features = st.multiselect("Select features", columns, default=columns[:-1])
        st.session_state.target = st.selectbox("Select target variable", columns)
        
        if st.button("Auto Train Models"):
            if len(st.session_state.features) > 0 and st.session_state.target:
                X = st.session_state.processed_data[st.session_state.features]
                y = st.session_state.processed_data[st.session_state.target]
                
                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
                
                st.session_state.model, st.session_state.model_name = auto_train(X_train, y_train, X_test, y_test)
                
                y_pred = st.session_state.model.predict(X_test)
                
                st.subheader("Best Model Performance")
                
                accuracy = accuracy_score(y_test, y_pred)
                st.metric("Accuracy", f"{accuracy:.2%}")
                
                st.text("Classification Report:")

                df_report = get_classification_report(y_test, y_pred)
                st.dataframe(df_report)
                
                if st.session_state.model_name == "Random Forest":
                    st.subheader("Feature Importance")
                    
                    importance_df = pd.DataFrame({
                        'Feature': st.session_state.features,
                        'Importance': st.session_state.model.named_steps['classifier'].feature_importances_
                    }).sort_values('Importance', ascending=False)
                    
                    fig = px.bar(importance_df, x='Feature', y='Importance',
                                title='Feature Importance Plot')
                    st.plotly_chart(fig)
                
                model_data = {
                    'model': st.session_state.model,
                    'model_name': st.session_state.model_name,
                    'label_encoders': st.session_state.label_encoders,
                    'features': st.session_state.features,
                    'target': st.session_state.target
                }
                joblib.dump(model_data, 'model_data.joblib')
                st.download_button(
                    label="Download trained model",
                    data=open('model_data.joblib', 'rb'),
                    file_name='model_data.joblib',
                    mime='application/octet-stream'
                )
    elif page=="Visualisation":
        st.header("Model Visualisation")
        if st.session_state.model is None:
            st.warning("Please train a model first!")
            return
    
        if st.session_state.processed_data is not None and st.session_state.features and st.session_state.target:
            X = st.session_state.processed_data[st.session_state.features]
            y = st.session_state.processed_data[st.session_state.target]
        
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # Create visualization options
            viz_option = st.selectbox(
                "Select visualization type", 
                ["Model Comparison", "ROC Curves", "Confusion Matrix"]
            )
        
            if viz_option == "Model Comparison":
                st.subheader("Model Performance Metrics")
            
            # Train all models to compare
                models = get_model_configs()
                results = {}
            
                progress_bar = st.progress(0)
                progress_text = st.empty()
            
                for i, (name, model_config) in enumerate(models.items()):
                    progress_text.text(f"Training {name}...")
                    pipeline = model_config['pipeline']
                    pipeline.fit(X_train, y_train)
                
                    y_pred = pipeline.predict(X_test)
                    y_prob = pipeline.predict_proba(X_test)[:, 1] if hasattr(pipeline, "predict_proba") else None
                
                    accuracy = accuracy_score(y_test, y_pred)
                    precision = precision_score(y_test, y_pred, average='binary')
                    recall = recall_score(y_test, y_pred, average='binary')
                    f1 = f1_score(y_test, y_pred, average='binary')
                    roc_auc = roc_auc_score(y_test, y_prob) if y_prob is not None else None
                
                    results[name] = {
                        "Accuracy": accuracy,
                        "Precision": precision,
                        "Recall": recall,
                        "F1-score": f1,
                        "ROC-AUC": roc_auc
                    }
                
                    progress_bar.progress((i + 1) / len(models))
            
                progress_text.empty()
            
                results_df = pd.DataFrame(results).T
                st.dataframe(results_df)

                fig = px.bar(
                    results_df.reset_index().melt(id_vars='index', var_name='Metric', value_name='Score'), 
                    x='index', y='Score', color='Metric', 
                    barmode='group',
                    title='Model Comparison',
                    labels={'index': 'Model'}
                )
                st.plotly_chart(fig)
            
            elif viz_option == "ROC Curves":
                st.subheader("ROC Curves")
            
                models = get_model_configs()
            
                fig = plt.figure(figsize=(10, 6))
            
                for name, model_config in models.items():
                    pipeline = model_config['pipeline']
                    pipeline.fit(X_train, y_train)
                
                    if hasattr(pipeline, "predict_proba"):
                        y_prob = pipeline.predict_proba(X_test)[:, 1]
                        fpr, tpr, _ = roc_curve(y_test, y_prob)
                        roc_auc = auc(fpr, tpr)
                        plt.plot(fpr, tpr, lw=2, label=f'{name} (AUC = {roc_auc:.2f})')
            
                plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')
                plt.xlim([0.0, 1.0])
                plt.ylim([0.0, 1.05])
                plt.xlabel('False Positive Rate')
                plt.ylabel('True Positive Rate')
                plt.title('Receiver Operating Characteristic (ROC) Curves')
                plt.legend(loc="lower right")
            
                st.pyplot(fig)
            
            elif viz_option == "Confusion Matrix":
                st.subheader("Confusion Matrices")
            
                models = get_model_configs()
            
                if len(models) > 4:
                    st.warning("Showing confusion matrices for the first 4 models")
                    model_items = list(models.items())[:4]
                else:
                    model_items = list(models.items())
            
                num_models = len(model_items)
                cols = 2
                rows = (num_models + 1) // 2
            
                fig, axes = plt.subplots(rows, cols, figsize=(12, 10))
                axes = axes.flatten() if num_models > 1 else [axes]
            
                for i, (name, model_config) in enumerate(model_items):
                    pipeline = model_config['pipeline']
                    pipeline.fit(X_train, y_train)
                
                    y_pred = pipeline.predict(X_test)
                    cm = confusion_matrix(y_test, y_pred)
                
                    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=axes[i])
                    axes[i].set_title(f"{name} - Confusion Matrix")
                    axes[i].set_xlabel("Predicted")
                    axes[i].set_ylabel("Actual")
            
                for j in range(num_models, len(axes)):
                    fig.delaxes(axes[j])
                
                plt.tight_layout()
                st.pyplot(fig)
            
            st.subheader("Current Model Performance")
            best_model_pred = st.session_state.model.predict(X_test)
        
            st.metric("Accuracy", f"{accuracy_score(y_test, best_model_pred):.2%}")
        
            col1, col2 = st.columns(2)
            with col1:
                st.metric("Precision", f"{precision_score(y_test, best_model_pred):.2%}")
                st.metric("F1 Score", f"{f1_score(y_test, best_model_pred):.2%}")
            with col2:
                st.metric("Recall", f"{recall_score(y_test, best_model_pred):.2%}")
                if hasattr(st.session_state.model, "predict_proba"):
                    best_proba = st.session_state.model.predict_proba(X_test)[:, 1]
                    st.metric("AUC", f"{roc_auc_score(y_test, best_proba):.2%}")
        
                else:
                    st.warning("Please load and preprocess your dataset before running evaluation.")


    elif page == "Prediction":
        st.header("🎲 Make Predictions")
        
        if st.session_state.model is None:
            st.warning("Please train a model first!")
            return
            
        st.subheader("Enter Feature Values")
        st.info(f"Using best model: {st.session_state.model_name}")
        
        input_data = {}
        for feature in st.session_state.features:
            if feature in st.session_state.label_encoders:
                options = st.session_state.label_encoders[feature].classes_
                value = st.selectbox(f"Select {feature}", options)
                input_data[feature] = st.session_state.label_encoders[feature].transform([value])[0]
            else:
                input_data[feature] = st.number_input(f"Enter value for {feature}", value=0.0)
        if st.button("Predict"):
            input_df = pd.DataFrame([input_data])
            
            prediction = st.session_state.model.predict(input_df)
            
            if st.session_state.target in st.session_state.label_encoders:
                original_prediction = st.session_state.label_encoders[st.session_state.target].inverse_transform(prediction)
                st.success(f"Predicted {st.session_state.target}: {original_prediction[0]}")
            else:
                st.success(f"Predicted {st.session_state.target}: {prediction[0]}")
            
            proba = st.session_state.model.predict_proba(input_df)
            st.subheader("Prediction Probability")
            
            if st.session_state.target in st.session_state.label_encoders:
                classes = st.session_state.label_encoders[st.session_state.target].classes_
            else:
                classes = st.session_state.model.classes_
                
            proba_df = pd.DataFrame(
                proba,
                columns=classes
            )
            st.dataframe(proba_df)

if __name__ == "__main__":
    main()