Compilation of the Application for Churning

app.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_curve, auc
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+st.title("Customer Churn Prediction")
+
+df = 
+
+# Data Loading and Preprocessing (same as before)
+@st.cache_data
+def load_and_preprocess_data(file_path):
+    df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], errors='coerce')
+    df.dropna(inplace=True)
+
+    for col in ['gender', 'Partner', 'Dependents', 'PhoneService', 'MultipleLines', 'InternetService',
+                'OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV',
+                'StreamingMovies', 'Contract', 'PaperlessBilling', 'PaymentMethod', 'Churn']:
+        le = LabelEncoder()
+        df[col] = le.fit_transform(df[col])
+
+    numerical_cols = ['tenure', 'MonthlyCharges', 'TotalCharges']
+    scaler = StandardScaler()
+    df[numerical_cols] = scaler.fit_transform(df[numerical_cols])
+    return df
+
+# file_path = st.file_uploader("Upload CSV file", type="csv")
+file_path = "./WA_Fn-UseC_-Telco-Customer-Churn.csv"
+
+if file_path is not None:
+    df = load_and_preprocess_data(file_path)
+    X = df.drop('Churn', axis=1)
+    y = df['Churn']
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    # Model Training and Evaluation (using session state - same as before)
+    if 'models' not in st.session_state:
+        st.session_state.models = {}
+
+    def train_and_evaluate(model_name, model, X_train, y_train, X_test, y_test):
+        if model_name not in st.session_state.models:
+            model.fit(X_train, y_train)
+            st.session_state.models[model_name] = model
+        else:
+            model = st.session_state.models[model_name]
+
+        y_pred = model.predict(X_test)
+        accuracy = accuracy_score(y_test, y_pred)
+        report = classification_report(y_test, y_pred, output_dict=True)
+        cm = confusion_matrix(y_test, y_pred)
+
+        # ROC Curve and AUC
+        if hasattr(model, "predict_proba"): #check if model has predict_proba
+            y_prob = model.predict_proba(X_test)[:, 1]
+            fpr, tpr, _ = roc_curve(y_test, y_prob)
+            roc_auc = auc(fpr, tpr)
+            return accuracy, report, cm, model, fpr, tpr, roc_auc
+        else:
+            return accuracy, report, cm, model, None, None, None
+
+    models = {
+        "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
+        "Random Forest": RandomForestClassifier(random_state=42),
+        "Gradient Boosting": GradientBoostingClassifier(random_state=42),
+        "AdaBoost": AdaBoostClassifier(random_state=42),
+        "SVM": SVC(probability=True, random_state=42),  # probability=True for ROC Curve
+        "K-Nearest Neighbors": KNeighborsClassifier(),
+        "Decision Tree": DecisionTreeClassifier(random_state=42),
+        "Naive Bayes": GaussianNB(),
+    }
+
+    # Tabs for Comparison
+    tabs = ["Model Comparison", "Individual Model Performance"]
+    selected_tab = st.sidebar.radio("Select Tab", tabs)
+
+    if selected_tab == "Model Comparison":
+        st.subheader("Model Comparison")
+        results = []
+        for model_name, model in models.items():
+            accuracy, report, cm, trained_model, fpr, tpr, roc_auc = train_and_evaluate(model_name, model, X_train, y_train, X_test, y_test)
+            results.append([model_name, accuracy])
+
+        results_df = pd.DataFrame(results, columns=["Model", "Accuracy"])
+        st.dataframe(results_df.sort_values(by="Accuracy", ascending=False))  # Sort by accuracy
+
+        # Combined ROC Curve Plot
+        fig, ax = plt.subplots()
+        for model_name, model in models.items():
+            _, _, _, _, fpr, tpr, roc_auc = train_and_evaluate(model_name, model, X_train, y_train, X_test, y_test)
+            if fpr is not None and tpr is not None and roc_auc is not None:
+                ax.plot(fpr, tpr, label=f'{model_name} (AUC = {roc_auc:.2f})')
+
+        ax.plot([0, 1], [0, 1], 'k--')  # Dashed diagonal
+        ax.set_xlabel('False Positive Rate')
+        ax.set_ylabel('True Positive Rate')
+        ax.set_title('ROC Curves')
+        ax.legend()
+        st.pyplot(fig)
+
+
+    elif selected_tab == "Individual Model Performance":
+        model_name = st.selectbox("Select Model", list(models.keys()))
+        accuracy, report, cm, trained_model, fpr, tpr, roc_auc = train_and_evaluate(model_name, models[model_name], X_train, y_train, X_test, y_test)
+
+        st.subheader(f"{model_name} Performance")
+        st.write(f"Accuracy: {accuracy:.4f}")
+        report_df = pd.DataFrame(report).transpose()
+        st.dataframe(report_df)
+
+        fig, ax = plt.subplots()
+        sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax)
+        plt.xlabel("Predicted Label")
+        plt.ylabel("True Label")
+        st.pyplot(fig)
+
+        if hasattr(trained_model, "feature_importances_"):
+            importances = trained_model.feature_importances_
+            feature_importance_df = pd.DataFrame({'Feature': X.columns, 'Importance': importances})
+            feature_importance_df = feature_importance_df.sort_values(by='Importance', ascending=False)
+            st.write("Feature Importance:")
+            st.dataframe(feature_importance_df)
+
+        if fpr is not None and tpr is not None and roc_auc is not None:
+            fig, ax = plt.subplots()
+            ax.plot(fpr, tpr, label=f'{model_name} (AUC = {roc_auc:.2f})')
+            ax.plot([0, 1], [0, 1], 'k--')
+            ax.set_xlabel('False Positive Rate')
+            ax.set_ylabel('True Positive Rate')
+            ax.set_title('ROC Curve')
+            ax.legend()
+            st.pyplot(fig)
+
+else:
+    st.write("Please upload a CSV file to begin.")

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+pandas
+sklearn
+matplotlib
+seaborn