add customer churn use case

data/classification/churn/churn_cm_train.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a7360924d1a9e7d2a0e93afdbeca7226c5ba0d2292fc1ba1fefe8dc52d7b86f
+size 733

data/classification/churn/churn_feature_importance.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d95b8565af221ab29cba5fe0d8f982068c87ad2b90b6006c7d39b872113486e5
+size 1311

data/classification/churn/churn_test_pp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a406bd34ff2df71ca5454979a01ccfe3e313041300b6885fff071918af3d6fa
+size 201179

data/classification/churn/churn_test_raw.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:970db62984f6dc49cf3fbc80d38d53d308b0f440e8bfa1344393e3bad7364864
+size 135341

data/classification/churn/churn_train_raw.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a2c861f06e3ff8ee471b18a8a2b9c55f9d77aff19b402c8d80bbd06920f3a19
+size 6148

pages/supervised_unsupervised_page.py

@@ -4,6 +4,7 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import plotly.express as px
+from PIL import Image
 
 from utils import load_data_pickle, load_model_pickle
 from annotated_text import annotated_text
@@ -226,6 +227,9 @@ if learning_type == "Supervised Learning":
 
         st.markdown(" ")
         st.markdown(" ")
+        
+        
+        ## Make predictions 
         st.markdown("#### Predict credit score 🆕")
         st.info("You can only predict the credit score of new clients once the **model has been trained.**")
         st.markdown("  ")
@@ -333,10 +337,303 @@ if learning_type == "Supervised Learning":
 
 
 
+
+
     ################################# CUSTOMER CHURN #####################################
         
     elif sl_usecase == "Customer churn prediction ❌":
-        st.warning("This page is under construction")
+        #st.warning("This page is under construction")
+        path_churn = r"data\classification\churn"
+
+        ## Description of the use case
+        st.divider()
+        st.markdown("## Customer churn prediction ❌")
+        st.info(""" Classification is a type of supervised learning model whose goal is to categorize input data into predefined classes or categories. 
+                In this example, we will build a **customer churn classification model** that can predict whether a customer is likely to leave a company's service in the future using historical data. 
+        """)
+
+        st.markdown(" ")
+
+        ## Load data 
+        churn_data = load_data_pickle(path_churn, "churn_train_raw.pkl") 
+        
+        _, col, _ = st.columns([0.1,0.8,0.1])
+        with col:
+            st.image("images/customer-churn.png", use_column_width=True)
+        
+        st.markdown(" ")
+
+        ## Learn about the data
+        st.markdown("#### About the data 📋")
+        st.markdown("""To train the customer churn classification model, you were provided a **labeled** database with around 7000 clients of a telecommunications company. <br>
+                    The data contains information on which services the customer has signed for, information on his account as well as whether the customer churned or not (our label here).""",
+                    unsafe_allow_html=True)
+        # st.markdown("This dataset is 'labeled' since it contains information on what we are trying to predict, which is the **Churn** variable.")
+        st.info("**Note**: The variables that had two possible values (Yes or No) where transformed into binary variables (0 or 1) with 0 being 'No' and 1 being 'Yes'.")
+
+        see_data = st.checkbox('**See the data**', key="churn-data")
+
+        if see_data:
+            st.warning("You can only view the first 30 customers in this section.")
+            churn_data = load_data_pickle(path_churn, "churn_train_raw.pkl") 
+            st.dataframe(churn_data)
+
+        learn_data = st.checkbox('**Learn more about the data**', key="churn-var")
+        if learn_data:
+            st.markdown("""
+- **SeniorCitizen**: Whether the customer is a senior citizen or not (1, 0)
+- **Partner**: Whether the customer has a partner or not (Yes, No)
+- **Dependents**: Whether the customer has dependents or not (Yes, No)
+- **tenure**: Number of months the customer has stayed with the company
+- **PhoneService**: Whether the customer has a phone service or not (Yes, No)
+- **MultipleLines**: Whether the customer has multiple lines or not (Yes, No)
+- **InternetService**: Customer’s internet service provider (DSL, Fiber optic, No)
+- **OnlineSecurity**: Whether the customer has online security or not (Yes, No)
+- **OnlineBackup**: Whether the customer has online backup or not (Yes, No)
+- **DeviceProtection**: Whether the customer has device protection or not (Yes, No)
+- **TechSupport**: Whether the customer has tech support or not (Yes, No)
+- **StreamingTV**: Whether the customer has streaming TV or not (Yes, No)
+- **StreamingMovies**: Whether the customer has streaming movies or not (Yes, No)
+- **Contract**: The contract term of the customer (Month-to-month, One year, Two year)
+- **PaperlessBilling**: Whether the customer has paperless billing or not (Yes, No)
+- **PaymentMethod**: The customer’s payment method (Electronic check, Mailed check, Bank transfer (automatic), Credit card (automatic))
+- **MonthlyCharges**: The amount charged to the customer monthly
+- **TotalCharges**: The total amount charged to the customer
+- <span style="color: red;"> **Churn** (the variable we want to predict): Whether the customer churned or not (Yes or No) </span>
+""", unsafe_allow_html=True)
+            
+        st.markdown("  ")
+        st.markdown("  ")
+
+
+        ## Exploratory data analysis
+        st.markdown("#### Exploratory Data Analysis 🔎")
+        st.markdown("""Exploratory Data Analysis (EDA) is a crucial step in the machine learning workflow. 
+                    It helps practitioners understand the structure, patterns, and characteristics of the data they are working with. 
+                    For this use case, we will perform EDA by analyzing the **proportion of clients who have churned or not** based on the dataset's other variables.""")
+        
+        st.info("**Note**: EDA is usually preformed before model training as it helps inform decisions made by the model throughout the modeling process.")
+
+        see_EDA = st.checkbox('**View the analysis**', key="churn-EDA")
+        if see_EDA:
+            st.markdown(" ")
+
+            # Show EDA image
+            st.markdown("""Exploratory Data Analysis has been preformed between the predicted variable `Churn` with 15 other variables present in the dataset. <br>
+                        Each graphs shows the proportion of churned and not churned customer based on the variable's possible values.""", unsafe_allow_html=True)
+            st.markdown(" ")
+
+            img_eda = os.path.join(path_churn, "EDA_churn.png")
+            st.image(img_eda)
+            
+            st.markdown(" ")
+            
+            # Intepretation
+            st.markdown("""**Interpretation** <br>
+            For variables such as `Contract`, `PaperlessBilling`, `PaymentMethod` and `InternetService`, we can see a significant difference in the proportion of churned customers based on the variable's value. 
+            In the *Contract* graph,  clients with a 'Month-to-Month' tend to churn more often than those with a longer contract.
+            In the *InternetService* graph, clients with a 'Fiber optic' service are more likely to churn than those with DSL or no internet service. """, unsafe_allow_html=True) 
+
+            st.info("""**Note**: Performing EDA can give us an indication as to which variables might be more significant in the customer churn model. 
+                    It can be a valuable tool to study the relationship between two variables but can sometimes be too simplistic. Some relationships might be top complex to be seen through EDA.""")
+                
+        
+
+        st.markdown(""" """)
+        st.markdown(""" """)
+
+        ## Train the algorithm
+        st.markdown("#### Train the algorithm ⚙️")
+        st.markdown("""**Training the model** means feeding it data that contains multiple examples of what you are trying to predict (here it is `Churn`).  
+                This allows the model to **learn relationships** between the `Churn` variable and the additional variables provided for the analysis and make accuracte predictions.""")
+        st.info("**Note**: A model is always trained before it can used to make predictions on new 'unlabeled' data.")        
+                
+
+        if 'model_train_churn' not in st.session_state:
+            st.session_state['model_train_churn'] = False
+
+        if st.session_state.model_train_churn:
+            st.write("The model has already been trained.")
+        else:
+            st.write("The model hasn't been trained yet")
+
+        run_churn_model = st.button("**Train the model**")
+
+
+        if run_churn_model:
+            st.session_state.model_train_churn = True
+            with st.spinner('Wait for it...'):
+                st.markdown(" ")
+                st.markdown(" ")
+                time.sleep(2)
+                st.markdown("#### See the results ☑️")
+                tab1, tab2 = st.tabs(["Performance", "Explainability"])
+                
+                ######## MODEL PERFORMANCE 
+                with tab1:
+                    results_train = load_data_pickle(path_churn,"churn_cm_train.pkl")
+                    results_train = results_train.to_numpy()
+                    accuracy = np.round(results_train.diagonal()*100)
+                    df_accuracy = pd.DataFrame({"Churn":["No","Yes"],
+                                                "Accuracy":accuracy})
+                    
+                    df_accuracy["Accuracy"] = np.round(df_accuracy["Accuracy"]/100)
+                    
+                    st.markdown(" ")
+                    st.info("""**Note**: Evaluating a model's performance helps provide a quantitative measure of the model's ability to make accurate decisions.
+                                In this use case, the performance of the customer churn model was measured by comparing the clients' churn variables with the value predicted by the trained model.""")
+
+                    fig = px.bar(df_accuracy, y='Accuracy', x='Churn', color="Churn", title="Model performance", text_auto=True)
+                    fig.update_traces(textfont_size=16)
+                    #fig.update_traces(textposition='inside', textfont=dict(color='white'))
+                    st.plotly_chart(fig, use_container_width=True)
+
+                    # st.markdown("""<i>The model's accuracy was measured for both Churn and No Churn.</i>
+                    #             <i>This is crucial as to understand whether the model is consistant in its performance, or whether it has trouble distinguishing between two kinds of credit score.</i>""", 
+                    #             unsafe_allow_html=True)
+
+                    st.markdown(" ")
+
+                    st.markdown("""**Interpretation**: <br>
+                                The model has a 88% accuracy in predicting customer that haven't churned, and a 94% accurate in predicting customer who have churned. <br>
+                                This means that the model's overall performance is good (at around 91%) but isn't equally as good for both predicted classes.
+                                """, unsafe_allow_html=True)
+                    
+                ##### MODEL EXPLAINABILITY
+                with tab2:
+                    st.markdown(" ")
+                    st.info("""**Note**: Explainability in AI refers to the ability to understand which variable used by a model during training had the most impact on the final predictions and how to quantify this impact.
+                            Understanding the inner workings of a model helps build trust among users and stakeholders, as well as increase acceptance.""")
+                    
+                    # Import feature importance dataframe
+                    df_var_importance = load_data_pickle(path_churn, "churn_feature_importance.pkl")                    
+                    df_var_importance.rename({"importance":"score"}, axis=1, inplace=True)
+                    df_var_importance.sort_values(by=["score"], inplace=True)
+                    df_var_importance["score"] = df_var_importance["score"].round(3)                
+
+                    # Feature importance plot with plotly
+                    fig = px.bar(df_var_importance, x='score', y='variable', color="score", orientation="h", title="Model explainability")
+                    st.plotly_chart(fig, use_container_width=True)
+
+                    st.markdown("""<b>Interpretation</b> <br>
+                                The client's tenure, amount of Monthly and Total Charges, as well as the type of Contract had the most impact on the model's churn predictions. 
+                                On the other hand, whether the client is subscribed to a streaming platform, he is covered by device protection or he has or not phone service had a very contribution in the final predictions.
+                                """, unsafe_allow_html=True)
+                    
+        st.markdown(" ") 
+        st.markdown(" ")                
+
+        st.markdown("#### Predict customer churn 🆕")
+        st.markdown("Once you have trained the model, you can use it predict whether a client will churn or not on new data.")
+
+        st.markdown(" ")
+
+        col1, col2 = st.columns([0.25,0.75], gap="medium")
+            
+        churn_test = load_data_pickle(path_churn,"churn_test_raw.pkl")
+        churn_test.reset_index(drop=True, inplace=True)
+        churn_test.insert(0, "Client ID", [f"{i}" for i in range(churn_test.shape[0])])
+
+        with col1:
+            st.markdown("""<b>Filter the data</b> <br>
+            You can select clients based on their *Tenure*, *Total Charges* or *Contract*.""", 
+            unsafe_allow_html=True)
+
+            select_image_box = st.radio(" ",
+            ["Filter by Tenure", "Filter by Total Charges", "Filter by Contract", "No filters"],
+            label_visibility="collapsed")
+
+            if select_image_box == "Filter by Tenure":
+                st.markdown(" ")
+                min_tenure, max_tenure = st.slider('Select a range', churn_test["tenure"].astype(int).min(), churn_test["tenure"].astype(int).max(), (1,50), 
+                                                key="tenure", label_visibility="collapsed")
+                churn_test = churn_test.loc[churn_test["tenure"].between(min_tenure,max_tenure)]
+
+            if select_image_box == "Filter by Total Charges":
+                st.markdown(" ")
+                min_charges, max_charges = st.slider('Select a range', churn_test["TotalCharges"].astype(int).min(), churn_test["TotalCharges"].astype(int).max(), (50, 5000), 
+                                                        label_visibility="collapsed", key="totalcharges")
+                churn_test = churn_test.loc[churn_test["TotalCharges"].between(min_charges, max_charges)]
+
+            if select_image_box == "Filter by Contract":
+                contract = st.selectbox('Select a type of contract', churn_test["Contract"].unique(), index=0, label_visibility="collapsed", key="contract", 
+                                            placeholder = "Choose one or more options")
+                churn_test = churn_test.loc[churn_test["Contract"]==contract]
+
+            if select_image_box == "No filters":
+                pass
+
+        st.markdown(" ")
+        st.markdown("""<b>Select a threshold for the alert</b> <br>
+                    A warning message will be displayed if the percentage of churned customers exceeds this threshold.
+                    """, unsafe_allow_html=True)
+        warning_threshold = st.slider('Select a value', min_value=20, max_value=100, step=10, 
+                                        label_visibility="collapsed", key="warning")
+
+        st.markdown(" ")
+        st.write("The threshold is at", warning_threshold, "%")
+            
+
+        with col2:
+            #st.markdown("**View the database**")
+            st.dataframe(churn_test)
+
+
+        # Button to make predictions
+        make_predictions = st.button("**Make predictions**")
+        st.markdown(" ")
+
+        if make_predictions:
+            if st.session_state.model_train_churn is True:            
+                
+                ## Load preprocessed test data and model
+                churn_test_pp = load_data_pickle(path_churn, "churn_test_pp.pkl")
+                churn_model = load_model_pickle(path_pretrained_supervised,"churn_model.pkl")
+
+                X_test = churn_test_pp.iloc[churn_test.index,:].to_numpy()
+                predictions = churn_model.predict(X_test)
+                predictions = ["No" if x==0 else "Yes" for x in predictions]
+                
+                df_results_pred = churn_test.copy()
+                df_results_pred["Churn"] = predictions
+                df_mean_pred = df_results_pred["Churn"].value_counts().to_frame().reset_index()
+                df_mean_pred.columns = ["Churn", "Proportion"]
+                df_mean_pred["Proportion"] = (100*df_mean_pred["Proportion"]/df_results_pred.shape[0]).round()
+
+                perct_churned = df_mean_pred.loc[df_mean_pred["Churn"]=="Yes"]["Proportion"].to_numpy()
+
+                if perct_churned >= warning_threshold:
+                    st.error(f"The proportion of clients that have churned is above {warning_threshold}% (at {perct_churned[0]}%)⚠️")
+
+                st.markdown(" ")
+
+                col1, col2 = st.columns([0.4,0.6], gap="large")
+                with col1:
+                    st.markdown("**Proporition of predicted churn**")
+                    fig = px.pie(df_mean_pred, values='Proportion', names='Churn', color="Churn", 
+                                    color_discrete_map={'No':'royalblue', 'Yes':'red'})
+                    st.plotly_chart(fig, use_container_width=True)
+                
+                with col2:
+                    df_show_results = df_results_pred[["Churn","Client ID"] + [col for col in df_results_pred.columns if col not in ["Client ID","Churn"]]]                    
+                    columns_float = df_show_results.select_dtypes(include="float").columns
+                    df_show_results[columns_float] = df_show_results[columns_float].astype(int)
+                    
+                    def highlight_score(val):
+                        if val == "No":
+                            color = 'royalblue'
+                        if val == 'Yes':
+                            color= "red"
+                        return f'color: {color}'
+                    
+                    df_show_results_color = df_show_results.style.applymap(highlight_score, subset=['Churn'])
+                    
+                    st.markdown("**Overall results**")
+                    st.dataframe(df_show_results_color)
+
+            else:
+                st.error("You have to train the credit score model first.")
+
 
 
 
@@ -375,9 +672,9 @@ if learning_type == "Unsupervised Learning":
         st.divider()
         st.markdown("## Customer Segmentation (Clustering) 🧑‍🤝‍🧑")
 
-        st.info("""**Unsupervised learning** methods, such as clustering, are valulable tools for cases where you want a model to discover patterns by itself, without having to give it examples to learn from.
-                    They can be useful for companies that want to perform **Customer Segmentation**. 
-                    The AI clustering model can identify unknown groups of clients, which in turn helps the company create more targeted add campaigns, based on their consumer's behavior and preferences.
+        st.info("""**Unsupervised learning** models are valulable tools for cases where you want your model to discover patterns by itself, without having to give it examples to learn from (especially if you don't have labeled data).
+                    In this use case, we will show how they can be useful for **Customer Segmentation** to detect unknown groups of clients in a company's customer base.
+                Using this previously unknown segmentation, companies can then create more targeted add campaigns based on their consumer's behavior and preferences.
         """)
         st.markdown("  ")
 
@@ -388,9 +685,8 @@ if learning_type == "Unsupervised Learning":
 
         ## About the use case
         st.markdown("#### About the use case 📋")
-        st.markdown("""You are giving a database that contains information on around 2000 customers of a mass-market retailer. 
-                    The database's contains personal information (age, income, number of kids...), as well as information on the client's behavior. 
-                    This includes what types of products were purchased by the client, how long has he been enrolled as a client and where these purchases were made. """, unsafe_allow_html=True)
+        st.markdown("""You are giving a database that contains information on around **2000 customers** of a mass-market retailer. 
+                    The database's contains **personal information** (age, income, number of kids...), as well as information on what types of products were purchased by the client, how long has he been enrolled as a client and where these purchases were made. """, unsafe_allow_html=True)
 
         see_data = st.checkbox('**See the data**', key="dataframe")
 

pretrained_models/supervised_learning/churn_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10f3d99a69381ae5625ae9c35a370c365caa31e0fc1808a23d8002484cabf3ab
+size 7866941