app.py

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.linear_model import LinearRegression, Lasso
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
import joblib
import plotly.express as px
import plotly.figure_factory as ff

# Main function
def main():
    st.set_page_config(page_title="Data Automation-Machine Learning")
    st.title("Machine Learning")

    with st.expander("1: Add Your Data Source"):
        uploaded_file = st.file_uploader("Upload your CSV or Excel file- Only numbers", type=["csv", "xlsx", "xls"])

        if uploaded_file is None:
            try:
                data = pd.read_csv('example.csv')  # Load example CSV
                st.info("Loaded example.csv")
            except FileNotFoundError:
                st.error("Example CSV file not found. Please upload your own CSV or Excel file.")
            except pd.errors.EmptyDataError:
                st.error("Example CSV file is empty or invalid.")
        else:
            try:
                if uploaded_file.name.endswith('.csv'):
                    data = pd.read_csv(uploaded_file)
                elif uploaded_file.name.endswith(('.xlsx', '.xls')):
                    data = pd.read_excel(uploaded_file)
                
                # Check if the file has content
                if data.empty:
                    st.error("Uploaded file is empty. Please upload a valid CSV or Excel file.")
                else:
                    st.success("File uploaded successfully!")
            except pd.errors.EmptyDataError:
                st.error("The uploaded file is empty or contains no readable data.")
            except ValueError:
                st.error("Error in file format. Please ensure the file is a valid CSV or Excel.")
            except Exception as e:
                st.error(f"An error occurred: {e}")

    with st.expander("2: DataSet Preview"):

        st.write("Data Overview")
        st.dataframe(data.head())
        st.write("Data Description")
        st.write(data.describe())
        st.write("Missing Values")
        st.write(data.isnull().sum())
        st.write("Data Types")
        st.write(data.dtypes)

    with st.expander("3: Data Cleaning"):           
        st.write("Data Summary Before Cleaning")
        st.write(data.describe())
        st.write("Missing Values Before Cleaning:")
        st.write(data.isnull().sum())

        if st.checkbox("Show Missing Values Heatmap"):
            fig, ax = plt.subplots(figsize=(10, 6))
            sns.heatmap(data.isnull(), cbar=False, cmap='viridis', ax=ax)
            plt.title("Missing Values Heatmap")
            st.pyplot(fig)

        if st.checkbox("Remove Duplicate Rows"):
            initial_shape = data.shape
            data = data.drop_duplicates()
            st.success(f"Removed {initial_shape[0] - data.shape[0]} duplicate rows.")

        missing_strategy = st.selectbox(
            "Choose a strategy for handling missing values",
            options=["Drop Missing Values", "Fill with Mean", "Fill with Median", "Fill with Mode", "Do Nothing"]
        )

        if st.button("Apply Missing Value Strategy"):
            if missing_strategy == "Drop Missing Values":
                data.dropna(inplace=True)
                st.success("Dropped rows with missing values.")
            elif missing_strategy == "Fill with Mean":
                data.fillna(data.mean(), inplace=True)
                st.success("Filled missing values with the mean.")
            elif missing_strategy == "Fill with Median":
                data.fillna(data.median(), inplace=True)
                st.success("Filled missing values with the median.")
            elif missing_strategy == "Fill with Mode":
                for column in data.select_dtypes(include=['object']).columns:
                    data[column].fillna(data[column].mode()[0], inplace=True)
                st.success("Filled missing values with the mode for categorical columns.")
            elif missing_strategy == "Do Nothing":
                st.info("No changes made to missing values.")

        st.write("Data Summary After Cleaning")
        st.write(data.describe())
        st.write("Missing Values After Cleaning:")
        st.write(data.isnull().sum())

    with st.expander('4: EDA'):
        st.write("Correlation Matrix")
        correlation_matrix = data.corr()
        fig = ff.create_annotated_heatmap(
            z=correlation_matrix.values,
            x=list(correlation_matrix.columns),
            y=list(correlation_matrix.index),
        )
        fig.update_layout(
            title="Correlation Matrix",
            xaxis_title="Features",
            yaxis_title="Features",
            width=700,
            height=500,
        )
        st.plotly_chart(fig)

        if st.checkbox("Show Distribution Plots for Numeric Features"):
            for column in data.select_dtypes(include=[int, float]).columns:
                fig, ax = plt.subplots(figsize=(8, 4))
                sns.histplot(data[column], bins=30, kde=True, ax=ax)
                plt.title(f'Distribution of {column}')
                st.pyplot(fig)

        if st.checkbox("Show Boxplots for Numeric Features"):
            for column in data.select_dtypes(include=[int, float]).columns:
                fig, ax = plt.subplots(figsize=(8, 4))
                sns.boxplot(x=data[column], ax=ax)
                plt.title(f'Boxplot of {column}')
                st.pyplot(fig)

    with st.expander("5: Feature Engineering"):
        target_column = st.selectbox("Select the target variable", options=data.columns)
        feature_columns = st.multiselect("Select features", options=data.columns.drop(target_column))

    with st.expander("6: Modelling"):
        if 'model_plot' not in st.session_state:
            st.session_state.model_plot = None
        if 'model_metrics' not in st.session_state:
            st.session_state.model_metrics = None

        model_option = st.selectbox("Select Regression Model", options=["Linear Regression", "Random Forest Regression", "Lasso Regression"])

        if st.button("Train Model (Without Hyperparameter Tuning)"):
            if feature_columns:
                X = data[feature_columns]
                y = data[target_column]
                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

                if model_option == "Linear Regression":
                    model = LinearRegression()
                elif model_option == "Random Forest Regression":
                    model = RandomForestRegressor(random_state=42)
                elif model_option == "Lasso Regression":
                    model = Lasso()

                model.fit(X_train, y_train)

                model_name = st.text_input('Enter model name', 'my_model')
                model_file_path = f'{model_name}.pkl'
                joblib.dump(model, model_file_path)
                st.success("Model saved successfully!")

                with open(model_file_path, "rb") as f:
                    st.download_button(
                        label="Download Model",
                        data=f,
                        file_name=model_file_path,
                        mime="application/octet-stream"
                    )

                y_pred = model.predict(X_test)
                mse = mean_squared_error(y_test, y_pred)
                r2 = r2_score(y_test, y_pred)

                st.session_state.model_plot = (y_test.reset_index(drop=True), y_pred)
                st.session_state.model_metrics = (mse, r2)

                st.success(f"Mean Squared Error: {mse:.2f}")
                st.success(f"R^2 Score: {r2:.2f}")

        if st.session_state.model_plot is not None:
            y_test, y_pred = st.session_state.model_plot
            fig, ax = plt.subplots(figsize=(10, 6))
            ax.plot(y_test, label="True Values", color="blue", linestyle="--")
            ax.plot(y_pred, label="Predicted Values", color="orange")
            ax.set_title(f'{model_option}: True Values vs Predictions')
            ax.set_xlabel('Index')
            ax.set_ylabel('Values')
            ax.legend()
            st.pyplot(fig)

            if st.session_state.model_metrics is not None:
                mse, r2 = st.session_state.model_metrics
                st.success(f"Mean Squared Error: {mse:.2f}")
                st.success(f"R^2 Score: {r2:.2f}")

    with st.expander("7: HyperParameter"):
        if feature_columns:
            hyperparam_model_option = st.selectbox("Select Model for Hyperparameter Tuning", options=["Linear Regression", "Random Forest Regression", "Lasso Regression"])

            if hyperparam_model_option == "Linear Regression":
                param_grid = {'fit_intercept': [True, False]}
            elif hyperparam_model_option == "Random Forest Regression":
                param_grid = {'n_estimators': [50, 100, 200], 'max_depth': [10, 20, None], 'min_samples_split': [2, 5, 10]}
            elif hyperparam_model_option == "Lasso Regression":
                param_grid = {'alpha': [0.01, 0.1, 1, 10], 'max_iter': [1000, 5000, 10000]}

            if st.button("Train Model with Hyperparameter Tuning"):
                X = data[feature_columns]
                y = data[target_column]
                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

                if hyperparam_model_option == "Linear Regression":
                    model = LinearRegression()
                    grid_search = GridSearchCV(model, param_grid, cv=5)
                elif hyperparam_model_option == "Random Forest Regression":
                    model = RandomForestRegressor(random_state=42)
                    grid_search = GridSearchCV(model, param_grid, cv=5)
                elif hyperparam_model_option == "Lasso Regression":
                    model = Lasso()
                    grid_search = GridSearchCV(model, param_grid, cv=5)

                grid_search.fit(X_train, y_train)
                best_params = grid_search.best_params_

                st.success(f"Best Hyperparameters: {best_params}")

# Run the application
if __name__ == '__main__':
    main()