add password

main_page.py

@@ -1,11 +1,7 @@
-import os
 import streamlit as st
-import pandas as pd
-import numpy as np
-
 from st_pages import Page, show_pages, Section, add_indentation
 from PIL import Image
-#from utils import authenticate_drive
+from utils import check_password
 
 
 
@@ -14,10 +10,16 @@ from PIL import Image
 ##################################################################################
 
 st.set_page_config(layout="wide")
-#add_indentation()
 
 
 
+##################################################################################
+#                              PASSWORD CHECK                                    #
+##################################################################################
+
+if check_password():
+
+
 
 ##################################################################################
 #                              GOOGLE DRIVE CONNEXION                            #
@@ -36,107 +38,107 @@ st.set_page_config(layout="wide")
 ##################################################################################
 
 
-st.image("images/AI.jpg")
-st.markdown(" ")
+    st.image("images/AI.jpg")
+    st.markdown(" ")
 
-col1, col2 = st.columns([0.65,0.35], gap="medium")
+    col1, col2 = st.columns([0.65,0.35], gap="medium")
 
-with col1:
-    st.title("AI and Data Science Examples")
-    st.subheader("HEC Paris, 2023-2024")
-    # st.markdown("""**Course provided by Shirish C. SRIVASTAVA** <br>
-    #             **Hi! PARIS Engineering team**: Laurène DAVID, Salma HOUIDI and Maeva N'GUESSAN""", unsafe_allow_html=True)
-#st.markdown("in collaboration with Hi! PARIS engineers: Laurène DAVID, Salma HOUIDI and Maeva N'GUESSAN")
+    with col1:
+        st.title("AI and Data Science Examples")
+        st.subheader("HEC Paris, 2023-2024")
+        # st.markdown("""**Course provided by Shirish C. SRIVASTAVA** <br>
+        #             **Hi! PARIS Engineering team**: Laurène DAVID, Salma HOUIDI and Maeva N'GUESSAN""", unsafe_allow_html=True)
+    #st.markdown("in collaboration with Hi! PARIS engineers: Laurène DAVID, Salma HOUIDI and Maeva N'GUESSAN")
 
-# with col2:
-#Hi! PARIS collaboration mention
-    # st.markdown("  ")
-    # st.markdown("  ")
-    #st.markdown("  ")
-    
-    url = "https://www.hi-paris.fr/"
-    #st.markdown("This app was funded by the Hi! PARIS Center")
-    st.markdown("""###### **The app was made in collaboration with [Hi! PARIS](%s)** """ % url, unsafe_allow_html=True)
-    image_hiparis = Image.open('images/hi-paris.png')
-    st.image(image_hiparis, width=150)
+    # with col2:
+    #Hi! PARIS collaboration mention
+        # st.markdown("  ")
+        # st.markdown("  ")
+        #st.markdown("  ")
+        
+        url = "https://www.hi-paris.fr/"
+        #st.markdown("This app was funded by the Hi! PARIS Center")
+        st.markdown("""###### **The app was made in collaboration with [Hi! PARIS](%s)** """ % url, unsafe_allow_html=True)
+        image_hiparis = Image.open('images/hi-paris.png')
+        st.image(image_hiparis, width=150)
 
 
-st.markdown(" ")
-st.divider()
+    st.markdown(" ")
+    st.divider()
 
 
-# #Hi! PARIS collaboration mention
-# st.markdown("  ")
-# image_hiparis = Image.open('images/hi-paris.png')
-# st.image(image_hiparis, width=150)
-# url = "https://www.hi-paris.fr/"
-# st.markdown("**The app was made in collaboration with [Hi! PARIS](%s)**" % url)
+    # #Hi! PARIS collaboration mention
+    # st.markdown("  ")
+    # image_hiparis = Image.open('images/hi-paris.png')
+    # st.image(image_hiparis, width=150)
+    # url = "https://www.hi-paris.fr/"
+    # st.markdown("**The app was made in collaboration with [Hi! PARIS](%s)**" % url)
 
 
 
 
-##################################################################################
-#                              DASHBOARD/SIDEBAR                                 #
-##################################################################################
+    ##################################################################################
+    #                              DASHBOARD/SIDEBAR                                 #
+    ##################################################################################
 
 
-# AI use case pages
-show_pages(
-    [
-        Page("main_page.py", "Home Page", "🏠"),
-        Section(name=" ", icon=""),
-        Section(name=" ", icon=""),
-        
-        Section(name="Machine Learning", icon="1️⃣"),
-            Page("pages/supervised_unsupervised_page.py", "1| Supervised vs Unsupervised 🔍", ""), 
-            Page("pages/timeseries_analysis.py", "2| Time Series Forecasting 📈", ""),
-            Page("pages/recommendation_system.py", "3| Recommendation systems 🛒", ""),
-        
-        Section(name="Natural Language Processing", icon="2️⃣"),
-            Page("pages/topic_modeling.py", "1| Topic Modeling 📚", ""),
-            Page("pages/sentiment_analysis.py", "2| Sentiment Analysis 👍", ""),
-        
-        Section(name="Computer Vision", icon="3️⃣"),
-            Page("pages/image_classification.py", "1| Image Classification 🖼️", ""),
-            Page("pages/object_detection.py", "2| Object Detection 📹", ""),
+    # AI use case pages
+    show_pages(
+        [
+            Page("main_page.py", "Home Page", "🏠"),
+            Section(name=" ", icon=""),
+            Section(name=" ", icon=""),
+            
+            Section(name="Machine Learning", icon="1️⃣"),
+                Page("pages/supervised_unsupervised_page.py", "1| Supervised vs Unsupervised 🔍", ""), 
+                Page("pages/timeseries_analysis.py", "2| Time Series Forecasting 📈", ""),
+                Page("pages/recommendation_system.py", "3| Recommendation systems 🛒", ""),
+            
+            Section(name="Natural Language Processing", icon="2️⃣"),
+                Page("pages/topic_modeling.py", "1| Topic Modeling 📚", ""),
+                Page("pages/sentiment_analysis.py", "2| Sentiment Analysis 👍", ""),
+            
+            Section(name="Computer Vision", icon="3️⃣"),
+                Page("pages/image_classification.py", "1| Image Classification 🖼️", ""),
+                Page("pages/object_detection.py", "2| Object Detection 📹", ""),
 
-        Page("pages/go_further.py", "🚀 Go further")
-    ]
-)
+            Page("pages/go_further.py", "🚀 Go further")
+        ]
+    )
 
 
 
-##################################################################################
-#                               PAGE CONTENT                                     #
-##################################################################################
+    ##################################################################################
+    #                               PAGE CONTENT                                     #
+    ##################################################################################
 
 
-st.header("About the app")
+    st.header("About the app")
 
 
-st.info("""The goal of the **AI and Data Science Examples** is to give an introduction to Data Science by showcasing real-life applications.
-        The app includes use cases using traditional Machine Learning algorithms on structured data, as well as models that analyze unstructured data (text, images,...).""")
+    st.info("""The goal of the **AI and Data Science Examples** is to give an introduction to Data Science by showcasing real-life applications.
+            The app includes use cases using traditional Machine Learning algorithms on structured data, as well as models that analyze unstructured data (text, images,...).""")
 
-st.markdown(" ")
+    st.markdown(" ")
 
-st.markdown("""The app contains four sections:
+    st.markdown("""The app contains four sections:
 - 1️⃣ **Machine Learning**: This first section covers use cases where structured data (data in a tabular format) is used to train an AI model.
-            You will find pages on *Supervised/Unsupervised Learning*, *Time Series Forecasting* and AI powered *Recommendation Systems*.
+                You will find pages on *Supervised/Unsupervised Learning*, *Time Series Forecasting* and AI powered *Recommendation Systems*.
 - 2️⃣ **Natural Language Processing** (NLP): This second section showcases AI applications where large amounts of text data is analyzed using Deep Learning models.
-            Pages on *Topic Modeling* and *Sentiment Analysis*, which are different kinds of NLP models, can be found in this section.
+                Pages on *Topic Modeling* and *Sentiment Analysis*, which are different kinds of NLP models, can be found in this section.
 - 3️⃣ **Computer Vision**: This third section covers a sub-field of AI called Computer Vision, which deals with image/video data.
-    The field of Computer Vision includes *Image classification* and *Object Detection*, which are both featured in this section.
+        The field of Computer Vision includes *Image classification* and *Object Detection*, which are both featured in this section.
 - 🚀 **Go further**: In the final section, you will gain a deeper understanding of AI models and how they function.
-            The page features multiple models to try, as well as different datasets to train a model on.
-            """)
+                The page features multiple models to try, as well as different datasets to train a model on.
+                """)
 
-st.image("images/ML_domains.png", 
-         caption="""This figure showcases a selection of sub-fields of AI, which includes
-                    Machine Learning, NLP and Computer Vision.""")
+    st.image("images/ML_domains.png", 
+            caption="""This figure showcases a selection of sub-fields of AI, which includes
+                        Machine Learning, NLP and Computer Vision.""")
 
 
-# st.markdown(" ")
-# st.markdown(" ")
-# st.markdown("## Want to learn more about AI ?")
-# st.markdown("""**Hi! PARIS**, a multidisciplinary center on Data Analysis and AI founded by Institut Polytechnique de Paris and HEC Paris, 
-#             hosts every year a **Data Science Bootcamp** for students of all levels.""")
+    # st.markdown(" ")
+    # st.markdown(" ")
+    # st.markdown("## Want to learn more about AI ?")
+    # st.markdown("""**Hi! PARIS**, a multidisciplinary center on Data Analysis and AI founded by Institut Polytechnique de Paris and HEC Paris, 
+    #             hosts every year a **Data Science Bootcamp** for students of all levels.""")

pages/go_further.py

@@ -9,7 +9,7 @@ import altair as alt
 import plotly.express as px
 
 from st_pages import add_indentation
-from utils import load_data_csv
+from utils import load_data_csv, check_password
 
 from sklearn.datasets import fetch_california_housing
 from sklearn.compose import make_column_selector as selector
@@ -123,350 +123,353 @@ scores = np.diag(cm)
 #                                    START OF THE PAGE
 ##############################################################################################
 
-st.image("images/ML_header.jpg")
-st.markdown("# Go further 🚀")
-st.markdown("""This page allows you to test and compare results between different AI models, and gain a deeper understanding of how they make predictions. <br>
-            It includes three different types of **classification models** with Python code illustrations, as well as four datasets to choose from.
-        
+if check_password():
+
+    st.image("images/ML_header.jpg")
+    st.markdown("# Go further 🚀")
+    st.markdown("""This page allows you to test and compare results between different AI models, and gain a deeper understanding of how they make predictions. <br>
+                It includes three different types of **classification models** with Python code illustrations, as well as four datasets to choose from.
+            
 **Explainability** is also given for most models. 
 These results give an indication on which variable had the most impact on the model's final prediction. <br>
 Note that each model has its own way of measuring explainability, which makes comparisions between model explainabilities difficult.
 
 All of the classification models used in this page come from `scikit-learn`, which is a popular Data Science library in Python.
-            """, unsafe_allow_html=True) 
-try:
-    st.link_button("Go to the scikit-learn website", "https://scikit-learn.org/stable/index.html")
-except:
-    st.markdown("You need internet connexion to access the link.")
+                """, unsafe_allow_html=True) 
+    try:
+        st.link_button("Go to the scikit-learn website", "https://scikit-learn.org/stable/index.html")
+    except:
+        st.markdown("You need internet connexion to access the link.")
 
-st.markdown("  ")
-st.divider()
+    st.markdown("  ")
+    st.divider()
 
 
-path_data = r'data/other_data'
+    path_data = r'data/other_data'
 
-st.markdown("# Classification ")
-st.markdown("""**Reminder**: Classification models are AI models that are trained to predict a finite number of values/categories.
-        Examples can be found in the *Supervised vs Unsupervised* page with the credit score classification and customer churn prediction use cases.""")
-st.markdown("  ")
-st.markdown("  ")
+    st.markdown("# Classification ")
+    st.markdown("""**Reminder**: Classification models are AI models that are trained to predict a finite number of values/categories.
+            Examples can be found in the *Supervised vs Unsupervised* page with the credit score classification and customer churn prediction use cases.""")
+    st.markdown("  ")
+    st.markdown("  ")
 
 
 
 
-########################## SELECT A DATASET ###############################
+    ########################## SELECT A DATASET ###############################
 
-st.markdown("### Select a dataset 📋")
-st.markdown("""To perform the classification task, you can choose between three different datasets: **Titanic**, **Car evaluation**, **Wine quality** and **Diabetes prevention** <br>
-            Each dataset will be shown in its original format and will go through pre-processing steps to insure its quality and usability for the chosen model.
-            """, unsafe_allow_html=True)
+    st.markdown("### Select a dataset 📋")
+    st.markdown("""To perform the classification task, you can choose between three different datasets: **Titanic**, **Car evaluation**, **Wine quality** and **Diabetes prevention** <br>
+                Each dataset will be shown in its original format and will go through pre-processing steps to insure its quality and usability for the chosen model.
+                """, unsafe_allow_html=True)
 
-st.warning("""**Note:** The performance of a Machine Learning model is sensitive to the data being used to train it.
-    Data cleaning and pre-processing are usually as important as training the AI model. These steps can include removing missing values, identifying outliers and transforming columns from text to numbers.""")
+    st.warning("""**Note:** The performance of a Machine Learning model is sensitive to the data being used to train it.
+        Data cleaning and pre-processing are usually as important as training the AI model. These steps can include removing missing values, identifying outliers and transforming columns from text to numbers.""")
 
-select_data = st.selectbox("Choose an option", ["Titanic 🚢", "Car evaluation 🚙", "Wine quality 🍷", "Diabetes prevention 👩‍⚕️"]) #label_visibility="collapsed")
-st.markdown(" ")
+    select_data = st.selectbox("Choose an option", ["Titanic 🚢", "Car evaluation 🚙", "Wine quality 🍷", "Diabetes prevention 👩‍⚕️"]) #label_visibility="collapsed")
+    st.markdown(" ")
 
-if select_data =="Wine quality 🍷":
-    # Load data and clean it
-    data = load_data_csv(path_data, "winequality.csv")
-    data = data.loc[data["residual sugar"] < 40]
-    data = data.loc[data["free sulfur dioxide"] < 200]
-    data = data.loc[data["total sulfur dioxide"] < 400]
-    data.drop(columns=["free sulfur dioxide"], inplace=True)
+    if select_data =="Wine quality 🍷":
+        # Load data and clean it
+        data = load_data_csv(path_data, "winequality.csv")
+        data = data.loc[data["residual sugar"] < 40]
+        data = data.loc[data["free sulfur dioxide"] < 200]
+        data = data.loc[data["total sulfur dioxide"] < 400]
+        data.drop(columns=["free sulfur dioxide"], inplace=True)
 
-    X = data.drop(columns=["quality"])
-    y = data["quality"]
+        X = data.drop(columns=["quality"])
+        y = data["quality"]
 
-    # Information on the data
-    st.info("""**About the data**: The goal of the wine quality dataset is to **predict the quality** of different wines using their formulation. 
-                The target in this use case is the `quality` variable which has two possible values (Good and Mediocre).""")
+        # Information on the data
+        st.info("""**About the data**: The goal of the wine quality dataset is to **predict the quality** of different wines using their formulation. 
+                    The target in this use case is the `quality` variable which has two possible values (Good and Mediocre).""")
 
-    # View data
-    view_data = st.checkbox("View the data", key="wine")
-    if view_data:
-        st.dataframe(data)
+        # View data
+        view_data = st.checkbox("View the data", key="wine")
+        if view_data:
+            st.dataframe(data)
 
-    
-if select_data == "Titanic 🚢":
-    # Load data and clean it
-    data = load_data_csv(path_data, "titanic.csv")
-    data = data.drop(columns=["Name","Cabin","Ticket","PassengerId"]).dropna()
-    data["Survived"] = data["Survived"].map({0: "Died", 1:"Survived"})
-    data.rename({"Sex":"Gender"}, axis=1, inplace=True)
-    data["Age"] = data["Age"].astype(int)
-    data["Fare"] = data["Fare"].round(2)
-    
-    cat_columns = data.select_dtypes(include="object").columns
-    data[cat_columns] = data[cat_columns].astype("category")
+        
+    if select_data == "Titanic 🚢":
+        # Load data and clean it
+        data = load_data_csv(path_data, "titanic.csv")
+        data = data.drop(columns=["Name","Cabin","Ticket","PassengerId"]).dropna()
+        data["Survived"] = data["Survived"].map({0: "Died", 1:"Survived"})
+        data.rename({"Sex":"Gender"}, axis=1, inplace=True)
+        data["Age"] = data["Age"].astype(int)
+        data["Fare"] = data["Fare"].round(2)
+        
+        cat_columns = data.select_dtypes(include="object").columns
+        data[cat_columns] = data[cat_columns].astype("category")
 
-    X = data.drop(columns=["Survived"])
-    y = data["Survived"]
+        X = data.drop(columns=["Survived"])
+        y = data["Survived"]
 
-    # Information on the data
-    st.info("""**About the data**: The goal of the titanic dataset is to **predict whether a passenger on the ship survived**. 
-                The target in this use case is the `Survived` variable which has two possible values (Died or Survived).
-                """)
+        # Information on the data
+        st.info("""**About the data**: The goal of the titanic dataset is to **predict whether a passenger on the ship survived**. 
+                    The target in this use case is the `Survived` variable which has two possible values (Died or Survived).
+                    """)
 
-    # View data
-    view_data = st.checkbox("View the data", key="titanic")
-    if view_data:
-        st.dataframe(data)
-        
-    # About the variables
-    about_var = st.checkbox("Information on the variables", key="titanic-var")
-    if about_var:
-        st.markdown("""
-- **Survived**: Survival (Died or Survived)
-- **Pclass**: Ticket class of the passenger (1=First, 2=Second, 3=Third)
-- **Gender**: Gender
-- **Age**: Age in years
-- **SibSp**: Number of siblings aboard the Titanic
-- **Parch**: Number of parents/children aboard the Titanic
-- **Fare**: Passenger fare
-- **Embarked**: Port of Embarkation (C=Cherbourg, Q=Queenstown, S=Southampton)""")
-
-if select_data == "Car evaluation 🚙":
-    # Load data and clean it
-    data = load_data_csv(path_data, "car.csv")
-    data.rename({"Price":"Buying"}, axis=1, inplace=True)
-    cat_columns = data.select_dtypes(include="object").columns
-    data[cat_columns] = data[cat_columns].astype("category")
-
-    X = data.drop(columns="Evaluation")
-    y = data["Evaluation"]
-
-    # Information on the data
-    st.info("""**About the data**: The goal of the car evaluation dataset is to predict the evaluation made about a car before being sold.
-            The target in this use case is the `Evaluation` variable, which has two possible values (Not acceptable or acceptable)""")
-
-    # View data
-    view_data = st.checkbox("View the data", key="car")
-    if view_data:
-        st.dataframe(data)
-
-    # View data
-    about_var = st.checkbox("Information on the variables", key="car-var")
-    if about_var:
-        st.markdown("""
-- **Buying**: Buying price of the vehicule (Very high, high, medium, low)
-- **Maintenance**: Price for maintenance (Very high, high, medium, low)
-- **Doors**: Number of doors in the vehicule (2, 3, 4, 5 or more)
-- **Persons**: Capacity in terms of persons to carry (2, 4, more)
-- **Luggage boot**: Size of luggage boot 
-- **Safety**: Estimated safety of the car (low, medium, high)
-- **Evaluation**: Evaluation level (unacceptable, acceptable)""")
-        
+        # View data
+        view_data = st.checkbox("View the data", key="titanic")
+        if view_data:
+            st.dataframe(data)
+            
+        # About the variables
+        about_var = st.checkbox("Information on the variables", key="titanic-var")
+        if about_var:
+            st.markdown("""
+    - **Survived**: Survival (Died or Survived)
+    - **Pclass**: Ticket class of the passenger (1=First, 2=Second, 3=Third)
+    - **Gender**: Gender
+    - **Age**: Age in years
+    - **SibSp**: Number of siblings aboard the Titanic
+    - **Parch**: Number of parents/children aboard the Titanic
+    - **Fare**: Passenger fare
+    - **Embarked**: Port of Embarkation (C=Cherbourg, Q=Queenstown, S=Southampton)""")
+
+    if select_data == "Car evaluation 🚙":
+        # Load data and clean it
+        data = load_data_csv(path_data, "car.csv")
+        data.rename({"Price":"Buying"}, axis=1, inplace=True)
+        cat_columns = data.select_dtypes(include="object").columns
+        data[cat_columns] = data[cat_columns].astype("category")
+
+        X = data.drop(columns="Evaluation")
+        y = data["Evaluation"]
+
+        # Information on the data
+        st.info("""**About the data**: The goal of the car evaluation dataset is to predict the evaluation made about a car before being sold.
+                The target in this use case is the `Evaluation` variable, which has two possible values (Not acceptable or acceptable)""")
+
+        # View data
+        view_data = st.checkbox("View the data", key="car")
+        if view_data:
+            st.dataframe(data)
+
+        # View data
+        about_var = st.checkbox("Information on the variables", key="car-var")
+        if about_var:
+            st.markdown("""
+    - **Buying**: Buying price of the vehicule (Very high, high, medium, low)
+    - **Maintenance**: Price for maintenance (Very high, high, medium, low)
+    - **Doors**: Number of doors in the vehicule (2, 3, 4, 5 or more)
+    - **Persons**: Capacity in terms of persons to carry (2, 4, more)
+    - **Luggage boot**: Size of luggage boot 
+    - **Safety**: Estimated safety of the car (low, medium, high)
+    - **Evaluation**: Evaluation level (unacceptable, acceptable)""")
+            
 
-if select_data == "Diabetes prevention 👩‍⚕️":
-    # Load data and clean it
-    data = load_data_csv(path_data, "diabetes.csv")
-    data["Outcome"] = data["Outcome"].map({1:"Yes", 0:"No"})
-    #data.drop(columns=["DiabetesPedigreeFunction"], inplace=True)
-    # data.rename({"Price":"Buying"}, axis=1, inplace=True)
-    cat_columns = data.select_dtypes(include="object").columns
-    data[cat_columns] = data[cat_columns].astype("category")
+    if select_data == "Diabetes prevention 👩‍⚕️":
+        # Load data and clean it
+        data = load_data_csv(path_data, "diabetes.csv")
+        data["Outcome"] = data["Outcome"].map({1:"Yes", 0:"No"})
+        #data.drop(columns=["DiabetesPedigreeFunction"], inplace=True)
+        # data.rename({"Price":"Buying"}, axis=1, inplace=True)
+        cat_columns = data.select_dtypes(include="object").columns
+        data[cat_columns] = data[cat_columns].astype("category")
 
-    X = data.drop(columns="Outcome")
-    y = data["Outcome"]
+        X = data.drop(columns="Outcome")
+        y = data["Outcome"]
 
 
-    # Information on the data
-    st.info("""**About the data**: The goal of the diabetes dataset is to predict whether a patient has diabetes.
-            The target in this use case is the `Outcome` variable, which has two possible values (Yes or No)""")
+        # Information on the data
+        st.info("""**About the data**: The goal of the diabetes dataset is to predict whether a patient has diabetes.
+                The target in this use case is the `Outcome` variable, which has two possible values (Yes or No)""")
 
-    # View data
-    view_data = st.checkbox("View the data", key="diabetes")
-    if view_data:
-        st.dataframe(data)
+        # View data
+        view_data = st.checkbox("View the data", key="diabetes")
+        if view_data:
+            st.dataframe(data)
 
-    # View data
-    about_var = st.checkbox("Information on the variables", key="car-var")
-    if about_var:
-        st.markdown("""
-- **Pregnancies**: Number of pregnancies had
-- **Glucose**: The level of glucose in the patient's blood
-- **BloodPressure**: Blood pressure measurement
-- **SkinThickness**: Thickness of the skin
-- **Insulin**: Level of insulin in the blood
-- **BMI**: Body mass index
-- **DiabetesPedigreeFunction**: Likelihood of diabetes depending on the patient's age and diabetic family history
-- **Age**: Age of the patient
-- **Outcome**: Whether the patient has diabetes (Yes or No)""")
+        # View data
+        about_var = st.checkbox("Information on the variables", key="car-var")
+        if about_var:
+            st.markdown("""
+    - **Pregnancies**: Number of pregnancies had
+    - **Glucose**: The level of glucose in the patient's blood
+    - **BloodPressure**: Blood pressure measurement
+    - **SkinThickness**: Thickness of the skin
+    - **Insulin**: Level of insulin in the blood
+    - **BMI**: Body mass index
+    - **DiabetesPedigreeFunction**: Likelihood of diabetes depending on the patient's age and diabetic family history
+    - **Age**: Age of the patient
+    - **Outcome**: Whether the patient has diabetes (Yes or No)""")
 
-st.markdown(" ")
-st.markdown(" ")
+    st.markdown(" ")
+    st.markdown(" ")
 
 
 
 
-########################## SELECT A MODEL ###############################
+    ########################## SELECT A MODEL ###############################
 
-st.markdown("### Select a model 📚")
-st.markdown("""You can choose between three types of classification models: **K nearest neighbors (KNN)**, **Decision Trees** and **Random Forests**. <br>
-    For each model, you will be given a short explanation as to how they function.
-    """, unsafe_allow_html=True)
+    st.markdown("### Select a model 📚")
+    st.markdown("""You can choose between three types of classification models: **K nearest neighbors (KNN)**, **Decision Trees** and **Random Forests**. <br>
+        For each model, you will be given a short explanation as to how they function.
+        """, unsafe_allow_html=True)
 
-st.warning("""**Note**: Different types of models exists for most Machine Learning tasks. 
-           Models tend to vary in complexity and picking which one to train for a specific use case isn't always straightforward. 
-           Complex model might output better results but take longer to make predictions.
-           The model selection step requires a good amount of testing by practitioners.""")
+    st.warning("""**Note**: Different types of models exists for most Machine Learning tasks. 
+            Models tend to vary in complexity and picking which one to train for a specific use case isn't always straightforward. 
+            Complex model might output better results but take longer to make predictions.
+            The model selection step requires a good amount of testing by practitioners.""")
 
-select_model = st.selectbox("**Choose an option**", ["K-nearest-neighbor 🏘️", "Decision Tree 🌳", "Random Forest 🏕️"])
-st.markdown(" ")
+    select_model = st.selectbox("**Choose an option**", ["K-nearest-neighbor 🏘️", "Decision Tree 🌳", "Random Forest 🏕️"])
+    st.markdown(" ")
 
 
-if select_model == "K-nearest-neighbor 🏘️":
-    #st.markdown("#### Model: K-nearest-neighbor")
-    st.info("""**About the model**: K-nearest-neighbor (or KNN) is a type of classification model that uses neighboring points to classify new data.
-            When trying to predict a class to new data point, the algorithm will look at points in close proximity (or in its neighborhood) to make a decision.
-            The most common class in the points' neighborhood will then be chosen as the final prediction.""")
-    
-    select_param = 6
-    model_dict = {"model":select_model, "param":select_param}
+    if select_model == "K-nearest-neighbor 🏘️":
+        #st.markdown("#### Model: K-nearest-neighbor")
+        st.info("""**About the model**: K-nearest-neighbor (or KNN) is a type of classification model that uses neighboring points to classify new data.
+                When trying to predict a class to new data point, the algorithm will look at points in close proximity (or in its neighborhood) to make a decision.
+                The most common class in the points' neighborhood will then be chosen as the final prediction.""")
+        
+        select_param = 6
+        model_dict = {"model":select_model, "param":select_param}
 
-    learn_model = st.checkbox("Learn more about the model", key="knn")
-    if learn_model:
-        st.markdown("""An important parameter in KNN algorithms is the number of points to choose as neighboors. <br>
-                The image below shows two cases where the number of neighboors (k) are equal to 3 and 6.
+        learn_model = st.checkbox("Learn more about the model", key="knn")
+        if learn_model:
+            st.markdown("""An important parameter in KNN algorithms is the number of points to choose as neighboors. <br>
+                        The image below shows two cases where the number of neighboors (k) are equal to 3 and 6.
 - When k is equal to 3 (the small dotted circle in the image below), the most common class is **Class B**. The red point will then be predicted as Classe B.
 - When k is equal to 6 (the large dotted circle in the image below), the  the most common class is **Class A**. The red point will then be predicted as Classe A.""", 
-                unsafe_allow_html=True)
-        
-        st.image("images/knn.png", width=600)
-        st.markdown("""K-nearest-neighbor algorithm are popular for their simplicity. <br>
-                        This can be a drawback for use cases/dataset that require a more complex approach to make accurate predictions.""", unsafe_allow_html=True)
-    
-    see_code_box = st.checkbox("See the code", key='knn_code')
-    if see_code_box:
-        see_code(select_model)
-    
-
-if select_model == "Decision Tree 🌳":
-    st.info("""**About the model**: Decision trees are classification model that split the prediction task into a succession of decisions, each with only two possible outcomes.
-            These decisions can be visualized as a tree, with data points arriving from the top of the tree and landing at final "prediction regions".""")
-    
-    select_param = 8
-    model_dict = {"model":select_model, "param":select_param}
-    
-    learn_model = st.checkbox("Learn more about the model", key="tree")
-    if learn_model:        
-        st.markdown("""The following image showcases a decision tree which predicts whether a **bank should give out a loan** to a client. <br>
-                    The data used to train the model has each client's **age**, **salary** and **number of children**.""", unsafe_allow_html=True)
+                    unsafe_allow_html=True)
+            
+            st.image("images/knn.png", width=600)
+            st.markdown("""K-nearest-neighbor algorithm are popular for their simplicity. <br>
+                            This can be a drawback for use cases/dataset that require a more complex approach to make accurate predictions.""", unsafe_allow_html=True)
         
-        st.markdown("""To predict whether a client gets a loan, the client's data goes through each 'leaf' in the tree (leaves are the blue box question in the image below) and **gets assigned the class of the final leaf it fell into** (either Get loan or Don't get loan). 
-                    For example, a client that is under 30 years old and has a lower salary than 2500$ will not be awarded a loan by the model.""", unsafe_allow_html=True)
+        see_code_box = st.checkbox("See the code", key='knn_code')
+        if see_code_box:
+            see_code(select_model)
         
-        st.image("images/decisiontree.png", width=800)
-        st.markdown("""Decision tree models are popular as they are easy to interpret. <br>
-                    The higher the variable is on the tree, the more important it is in the decision process.""", unsafe_allow_html=True)
+
+    if select_model == "Decision Tree 🌳":
+        st.info("""**About the model**: Decision trees are classification model that split the prediction task into a succession of decisions, each with only two possible outcomes.
+                These decisions can be visualized as a tree, with data points arriving from the top of the tree and landing at final "prediction regions".""")
         
-    see_code_box = st.checkbox("See the code", key='tree_code')
-    if see_code_box:
-        see_code(select_model)
+        select_param = 8
+        model_dict = {"model":select_model, "param":select_param}
         
+        learn_model = st.checkbox("Learn more about the model", key="tree")
+        if learn_model:        
+            st.markdown("""The following image showcases a decision tree which predicts whether a **bank should give out a loan** to a client. <br>
+                        The data used to train the model has each client's **age**, **salary** and **number of children**.""", unsafe_allow_html=True)
+            
+            st.markdown("""To predict whether a client gets a loan, the client's data goes through each 'leaf' in the tree (leaves are the blue box question in the image below) and **gets assigned the class of the final leaf it fell into** (either Get loan or Don't get loan). 
+                        For example, a client that is under 30 years old and has a lower salary than 2500$ will not be awarded a loan by the model.""", unsafe_allow_html=True)
+            
+            st.image("images/decisiontree.png", width=800)
+            st.markdown("""Decision tree models are popular as they are easy to interpret. <br>
+                        The higher the variable is on the tree, the more important it is in the decision process.""", unsafe_allow_html=True)
+            
+        see_code_box = st.checkbox("See the code", key='tree_code')
+        if see_code_box:
+            see_code(select_model)
+            
 
 
-if select_model == "Random Forest 🏕️":
-    st.info("""**About the model:** Random Forest models generate multiple decision tree models to make predictions. 
-            The main drawback of decision trees is that their predictions can be unstable, meaning that their output often changes.
-            Random Forest models combine the predictions of multiple decision trees to reduce this unstability and improve robustness.""")
-    
-    select_param = 8
-    model_dict = {"model":select_model, "param":select_param}
-
-    learn_model = st.checkbox("Learn more about the model", key="tree")
-    if learn_model:
-        st.markdown("""Random Forests classifiers combine the results of multiple trees by apply **majority voting**, which means selecting the class that was most often predicted by trees as the final prediction. 
-                    In the following image, the random forest model built four decision trees, who each have made their own class prediction. <br>"""
-                    , unsafe_allow_html=True)
-        
-        st.markdown("""Class C was predicted twice, whereas Class B et D where only predicted once. <br> 
-                    The final prediction of the random forest model is thus Class C.""", unsafe_allow_html=True)
+    if select_model == "Random Forest 🏕️":
+        st.info("""**About the model:** Random Forest models generate multiple decision tree models to make predictions. 
+                The main drawback of decision trees is that their predictions can be unstable, meaning that their output often changes.
+                Random Forest models combine the predictions of multiple decision trees to reduce this unstability and improve robustness.""")
         
-        st.image("images/randomforest.png", width=800)
+        select_param = 8
+        model_dict = {"model":select_model, "param":select_param}
+
+        learn_model = st.checkbox("Learn more about the model", key="tree")
+        if learn_model:
+            st.markdown("""Random Forests classifiers combine the results of multiple trees by apply **majority voting**, which means selecting the class that was most often predicted by trees as the final prediction. 
+                        In the following image, the random forest model built four decision trees, who each have made their own class prediction. <br>"""
+                        , unsafe_allow_html=True)
+            
+            st.markdown("""Class C was predicted twice, whereas Class B et D where only predicted once. <br> 
+                        The final prediction of the random forest model is thus Class C.""", unsafe_allow_html=True)
+            
+            st.image("images/randomforest.png", width=800)
 
-    see_code_box = st.checkbox("See the code", key='forest_code')
-    if see_code_box:
-        see_code(select_model)
+        see_code_box = st.checkbox("See the code", key='forest_code')
+        if see_code_box:
+            see_code(select_model)
 
 
 
-st.markdown(" ")
-st.markdown(" ")
+    st.markdown(" ")
+    st.markdown(" ")
 
-########################## RUN THE MODEL ###############################
+    ########################## RUN THE MODEL ###############################
 
-st.markdown("### Train the model ⚙️")
-st.markdown("""Now, you can build the chosen classification model and use the selected dataset to train it. <br>
-            You will get the model's accuracy in predicting each category, as well as the importance of each variable in the final predictions.""", unsafe_allow_html=True)
+    st.markdown("### Train the model ⚙️")
+    st.markdown("""Now, you can build the chosen classification model and use the selected dataset to train it. <br>
+                You will get the model's accuracy in predicting each category, as well as the importance of each variable in the final predictions.""", unsafe_allow_html=True)
 
-st.warning("""**Note**: Most machine learning models have an element of randomness in their predictions. 
-            This explains why a model's accuracy might change even if you run it with the same dataset.""")
+    st.warning("""**Note**: Most machine learning models have an element of randomness in their predictions. 
+                This explains why a model's accuracy might change even if you run it with the same dataset.""")
 
-st.markdown(f"""You've selected the **{select_data}** dataset and the **{select_model}** model.""")
+    st.markdown(f"""You've selected the **{select_data}** dataset and the **{select_model}** model.""")
 
 
-run_model = st.button("Run model", type="primary")
-st.markdown("  ")
+    run_model = st.button("Run model", type="primary")
+    st.markdown("  ")
+    st.markdown("  ")
 
-if run_model:
-    score, feature_imp, feature_names, labels = model_training(X, y, model_dict, _num_transformer=StandardScaler())
-    
-    if select_model in ["Decision Tree 🌳", "Random Forest 🏕️"]: # show explainability for decision tree, random firest
-        tab1, tab2 = st.tabs(["Results", "Explainability"])
+    if run_model:
+        score, feature_imp, feature_names, labels = model_training(X, y, model_dict, _num_transformer=StandardScaler())
+        
+        if select_model in ["Decision Tree 🌳", "Random Forest 🏕️"]: # show explainability for decision tree, random firest
+            tab1, tab2 = st.tabs(["Results", "Explainability"])
+
+            with tab1:
+                st.markdown("### Results")
+                st.markdown("""The values below represent the model's accuracy for each possible class. 
+                        The lowest possible accuracy is 0 and the highest 100.""")
+                if select_data == "Diabetes prevention 👩‍⚕️":
+                    st.warning("""**Note**: The Diabetes dataset only contains information on 768 patients. 500 patients don't have diabetes and 268 do have the disease. 
+                                This small number of patient data explains why the model's performance isn't optimal. 
+                                Additional data collection as well as hyperparameter tuning can be conducted to improve results.""")
+                    
+                score_df = pd.DataFrame({"label":labels, "accuracy":np.round(score*100)})
+                fig = px.bar(score_df, x="label", y="accuracy", color="label", text_auto=True)
+                st.plotly_chart(fig, use_container_width=True)
+            
+                st.warning("""**Note**: To improve the results of a model, practionners often conduct *hyperparameter tuning*. 
+                            It consists of trying different combination of the model's parameters to maximise the accuracy score. 
+                            Hyperparameter tuning wasn't conduct here in order to insure the app doesn't lag.""")
+
+                
+            with tab2:
+                st.markdown("### Explainability")
+                st.markdown("""Variables with a high explainability score had the most impact on the model's predictions.
+                            Variables with a low explainability score had a much smaller impact.""")
+
+                df_feature_imp = pd.DataFrame({"variable":feature_names, "importance":feature_imp})
+                df_feature_imp = df_feature_imp.groupby("variable").mean().reset_index()
+                df_feature_imp["importance"] = df_feature_imp["importance"].round(2)
+                df_feature_imp.sort_values(by=["importance"], ascending=False, inplace=True)
+                
+                fig = px.bar(df_feature_imp, x="importance", y="variable", color="importance")
+                st.plotly_chart(fig, use_container_width=True)
 
-        with tab1:
-            st.markdown("#### Results")
+        else: # only show results for knn
+            st.markdown("### Results")
             st.markdown("""The values below represent the model's accuracy for each possible class. 
-                    The lowest possible accuracy is 0 and the highest 100.""")
+                        The lowest possible accuracy is 0 and the highest 100.""")
+
+            st.warning("""**Note**: The K-nearest-neighbor algorithm doesn't have a built-in solution to compute model explainability with `scikit-learn`.
+                        You can use other python packages such as `SHAP` to compute explainability, which we didn't use here since they usually take a long time to output results.""")
+            
             if select_data == "Diabetes prevention 👩‍⚕️":
                 st.warning("""**Note**: The Diabetes dataset only contains information on 768 patients. 500 patients don't have diabetes and 268 do have the disease. 
-                            This small number of patient data explains why the model's performance isn't optimal. 
-                            Additional data collection as well as hyperparameter tuning can be conducted to improve results.""")
-                
+                                This small number of patient data explains why the model's performance isn't optimal. 
+                                Additional data collection as well as hyperparameter tuning can be conducted to improve results.""")
+                    
             score_df = pd.DataFrame({"label":labels, "accuracy":np.round(score*100)})
-            fig = px.bar(score_df, x="label", y="accuracy", color="label", text_auto=True)
-            st.plotly_chart(fig, use_container_width=True)
-        
-            st.warning("""**Note**: To improve the results of a model, practionners often conduct *hyperparameter tuning*. 
-                        It consists of trying different combination of the model's parameters to maximise the accuracy score. 
-                        Hyperparameter tuning wasn't conduct here in order to insure the app doesn't lag.""")
-
-            
-        with tab2:
-            st.markdown("#### Explainability")
-            st.markdown("""Variables with a high explainability score had the most impact on the model's predictions.
-                        Variables with a low explainability score had a much smaller impact.""")
-
-            df_feature_imp = pd.DataFrame({"variable":feature_names, "importance":feature_imp})
-            df_feature_imp = df_feature_imp.groupby("variable").mean().reset_index()
-            df_feature_imp["importance"] = df_feature_imp["importance"].round(2)
-            df_feature_imp.sort_values(by=["importance"], ascending=False, inplace=True)
-            
-            fig = px.bar(df_feature_imp, x="importance", y="variable", color="importance")
+            fig = px.bar(score_df, x="label", y="accuracy", color="label", title="Accuracy results", text_auto=True)
             st.plotly_chart(fig, use_container_width=True)
 
-    else: # only show results for knn
-        st.markdown("#### Results")
-        st.markdown("""The values below represent the model's accuracy for each possible class. 
-                    The lowest possible accuracy is 0 and the highest 100.""")
-
-        st.markdown("""The K-nearest-neighbor algorithm doesn't have a built-in solution to compute model explainability with `scikit-learn`.
-                    You can use other python packages such as `SHAP` to compute explainability, which we didn't use here since they usually take a long time to output results.""")
-        
-        if select_data == "Diabetes prevention 👩‍⚕️":
-            st.warning("""**Note**: The Diabetes dataset only contains information on 768 patients. 500 patients don't have diabetes and 268 do have the disease. 
-                            This small number of patient data explains why the model's performance isn't optimal. 
-                            Additional data collection as well as hyperparameter tuning can be conducted to improve results.""")
-                
-        score_df = pd.DataFrame({"label":labels, "accuracy":np.round(score*100)})
-        fig = px.bar(score_df, x="label", y="accuracy", color="label", title="Accuracy results", text_auto=True)
-        st.plotly_chart(fig, use_container_width=True)
-
-        st.warning("""**Note**: To improve the results of a model, practionners often conduct *hyperparameter tuning*. 
-                        It consists of trying different combination of the model's parameters to maximise the accuracy score. 
-                        Hyperparameter tuning wasn't conduct here in order to insure the app doesn't lag.""")
+            st.warning("""**Note**: To improve the results of a model, practionners often conduct *hyperparameter tuning*. 
+                            It consists of trying different combination of the model's parameters to maximise the accuracy score. 
+                            Hyperparameter tuning wasn't conduct here in order to insure the app doesn't lag.""")
 
 
 

pages/image_classification.py

@@ -5,7 +5,7 @@ import os
 import pandas as pd
 import plotly.express as px
 from PIL import Image
-from utils import load_data_pickle
+from utils import load_data_pickle, check_password
 
 
 # import gradcam
@@ -72,259 +72,260 @@ gradcam_images_paths = ["images/meningioma_tumor.png", "images/no_tumor.png", "i
 
 ###################################### TITLE ####################################
 
-st.markdown("# Image Classification 🖼️")
+if check_password():
 
-st.markdown("### What is Image classification ?")
-st.info("""**Image classification** is a process in Machine Learning and Computer Vision where an algorithm is trained to recognize and categorize images into predefined classes. It involves analyzing the visual content of an image and assigning it to a specific label based on its features.""")
-            #unsafe_allow_html=True)
-st.markdown(" ")
-st.markdown("""State-of-the-art image classification models use **neural networks** to predict whether an image belongs to a specific class.<br>
-Each of the possible predicted classes are given a probability then the class with the highest value is assigned to the input image.""",
-unsafe_allow_html=True)
+    st.markdown("# Image Classification 🖼️")
 
-image_ts = Image.open('images/cnn_example.png')
-_, col, _ = st.columns([0.2,0.8,0.2])
-with col:
-    st.image(image_ts, 
-             caption="An example of an image classification model, with the 'backbone model' as the neural network.")
+    st.markdown("### What is Image classification ?")
+    st.info("""**Image classification** is a process in Machine Learning and Computer Vision where an algorithm is trained to recognize and categorize images into predefined classes. It involves analyzing the visual content of an image and assigning it to a specific label based on its features.""")
+                #unsafe_allow_html=True)
+    st.markdown(" ")
+    st.markdown("""State-of-the-art image classification models use **neural networks** to predict whether an image belongs to a specific class.<br>
+    Each of the possible predicted classes are given a probability then the class with the highest value is assigned to the input image.""",
+    unsafe_allow_html=True)
+
+    image_ts = Image.open('images/cnn_example.png')
+    _, col, _ = st.columns([0.2,0.8,0.2])
+    with col:
+        st.image(image_ts, 
+                caption="An example of an image classification model, with the 'backbone model' as the neural network.")
 
-st.markdown("    ")
+    st.markdown("    ")
 
-st.markdown("""Real-life applications of image classification includes:
+    st.markdown("""Real-life applications of image classification includes:
 - **Medical Imaging 👨‍⚕️**: Diagnose diseases and medical conditions from images such as X-rays, MRIs and CT scans to, for example, identify tumors and classify different types of cancers.
 - **Autonomous Vehicules** 🏎️: Classify objects such as pedestrians, vehicles, traffic signs, lane markings, and obstacles, which is crucial for navigation and collision avoidance.
 - **Satellite and Remote Sensing 🛰️**: Analyze satellite imagery to identify land use patterns, monitor vegetation health, assess environmental changes, and detect natural disasters such as wildfires and floods.
 - **Quality Control 🛂**: Inspect products and identify defects to ensure compliance with quality standards during the manufacturying process.
-            """)
+                """)
 
-# st.markdown("""Real-life applications of Brain Tumor includes:
-# - **Research and development💰**: The technologies and methodologies developed for brain tumor classification can advance research in neuroscience, oncology, and the development of new diagnostic tools and treatments.
-# - **Healthcare👨‍⚕️**: Data derived from the classification and analysis of brain tumors can inform public health decisions, healthcare policies, and resource allocation, emphasizing areas with higher incidences of certain types of tumors.
-# - **Insurance Industry 🏬**: Predict future demand for products to optimize inventory levels, reduce holding costs, and improve supply chain efficiency.
-# """)
+    # st.markdown("""Real-life applications of Brain Tumor includes:
+    # - **Research and development💰**: The technologies and methodologies developed for brain tumor classification can advance research in neuroscience, oncology, and the development of new diagnostic tools and treatments.
+    # - **Healthcare👨‍⚕️**: Data derived from the classification and analysis of brain tumors can inform public health decisions, healthcare policies, and resource allocation, emphasizing areas with higher incidences of certain types of tumors.
+    # - **Insurance Industry 🏬**: Predict future demand for products to optimize inventory levels, reduce holding costs, and improve supply chain efficiency.
+    # """)
 
 
-    ###################################### USE CASE #######################################
+        ###################################### USE CASE #######################################
 
 
-# BEGINNING OF USE CASE
-st.divider()
-st.markdown("# Brain Tumor Classification 🧠")
+    # BEGINNING OF USE CASE
+    st.divider()
+    st.markdown("# Brain Tumor Classification 🧠")
 
-st.info("""In this use case, a **brain tumor classification** model is leveraged to accurately identify the presence of tumors in MRI scans of the brain. 
-        This application can be a great resource for healthcare professionals to facilite early detection and consequently improve treatment outcomes for patients.""")
+    st.info("""In this use case, a **brain tumor classification** model is leveraged to accurately identify the presence of tumors in MRI scans of the brain. 
+            This application can be a great resource for healthcare professionals to facilite early detection and consequently improve treatment outcomes for patients.""")
 
-st.markdown(" ")
-_, col, _ = st.columns([0.1,0.8,0.1])
-with col:
-    st.image("images/brain_tumor.jpg")
+    st.markdown(" ")
+    _, col, _ = st.columns([0.1,0.8,0.1])
+    with col:
+        st.image("images/brain_tumor.jpg")
 
-st.markdown(" ")
-st.markdown(" ")
+    st.markdown(" ")
+    st.markdown(" ")
 
-### WHAT ARE BRAIN TUMORS ?
-st.markdown(" ### What is a Brain Tumor ?")
-st.markdown("""Before introducing the use case, let's give a short description on what a brain tumor is.
-            A brain tumor occurs when **abnormal cells form within the brain**. Two main types of tumors exist: **cancerous (malignant) tumors** and **benign tumors**. 
+    ### WHAT ARE BRAIN TUMORS ?
+    st.markdown(" ### What is a Brain Tumor ?")
+    st.markdown("""A brain tumor occurs when **abnormal cells form within the brain**. Two main types of tumors exist: **cancerous (malignant) tumors** and **benign tumors**. 
 - **Cancerous tumors** are malignant tumors that have the ability to invade nearby tissues and spread to other parts of the body through a process called metastasis.
 - **Benign tumors** can become quite large but will not invade nearby tissue or spread to other parts of the body. They can still cause serious health problems depending on their size, location and rate of growth.
-            """, unsafe_allow_html=True)
-
-
+                """, unsafe_allow_html=True)
 
-st.markdown("    ")
-st.markdown("    ")
-st.markdown("### About the data 📋")
 
-st.markdown("""You were provided with a large dataset which contains **anonymized patient MRI scans** categorized into three distinct classes: **pituitary tumor** (in most cases benign), **meningioma tumor** (cancerous) and **no tumor**.
-            This dataset will serve as the foundation for training our classification model, offering a comprehensive view of varied tumor presentations within the brain.""")
 
-_, col, _ = st.columns([0.15,0.7,0.15])
-with col:
-    st.image("images/tumors_types_class.png")
+    st.markdown("    ")
+    st.markdown("    ")
+    st.markdown("### About the data 📋")
 
-# see_data = st.checkbox('**See the data**', key="image_class\seedata")
-# if see_data:
-#     st.warning("You can view here a few examples of the MRI training data.")
-#     # image selection
-#     images = os.listdir(DATA_DIR)
-#     selected_image1 = st.selectbox("Choose an image to visualize 🔎 :", images, key="selectionbox_key_2")
+    st.markdown("""You were provided with a large dataset which contains **anonymized patient MRI scans** categorized into three distinct classes: **pituitary tumor** (in most cases benign), **meningioma tumor** (cancerous) and **no tumor**.
+                This dataset will serve as the foundation for training our classification model, offering a comprehensive view of varied tumor presentations within the brain.""")
 
-#     # show image
-#     image_path = os.path.join(DATA_DIR, selected_image1)
-#     image = Image.open(image_path)
-#     st.image(image, caption="Image selected", width=450)
+    _, col, _ = st.columns([0.15,0.7,0.15])
+    with col:
+        st.image("images/tumors_types_class.png")
 
-# st.info("""**Note**: This dataset will serve as the foundation for training our classification model, offering a comprehensive view of varied tumor presentations within the brain. 
-#             By analyzing these images, the model learns to discern the subtle differences between each class, thereby enabling the precise identification of tumor types.""")
+    # see_data = st.checkbox('**See the data**', key="image_class\seedata")
+    # if see_data:
+    #     st.warning("You can view here a few examples of the MRI training data.")
+    #     # image selection
+    #     images = os.listdir(DATA_DIR)
+    #     selected_image1 = st.selectbox("Choose an image to visualize 🔎 :", images, key="selectionbox_key_2")
 
-st.markdown(" ")
-st.markdown(" ")
+    #     # show image
+    #     image_path = os.path.join(DATA_DIR, selected_image1)
+    #     image = Image.open(image_path)
+    #     st.image(image, caption="Image selected", width=450)
 
+    # st.info("""**Note**: This dataset will serve as the foundation for training our classification model, offering a comprehensive view of varied tumor presentations within the brain. 
+    #             By analyzing these images, the model learns to discern the subtle differences between each class, thereby enabling the precise identification of tumor types.""")
 
+    st.markdown(" ")
+    st.markdown(" ")
 
-st.markdown("### Train the algorithm ⚙️")
-st.markdown("""**Training an AI model** means feeding it data that contains multiple examples/images each type of tumor to be detected. 
-            By analyzing the provided MRI images, the model learns to discern the subtle differences between each classes, thereby enabling the precise identification of tumor types.""")
 
 
-### CONDITION ##
+    st.markdown("### Train the algorithm ⚙️")
+    st.markdown("""**Training an AI model** means feeding it data that contains multiple examples/images each type of tumor to be detected. 
+                By analyzing the provided MRI images, the model learns to discern the subtle differences between each classes, thereby enabling the precise identification of tumor types.""")
 
-# Initialisation de l'état du modèle
-if 'model_train' not in st.session_state:
-    st.session_state['model_train'] = False
 
-run_model = st.button("Train the model")
+    ### CONDITION ##
 
-if run_model:
-    # Simuler l'entraînement du modèle
-    st.session_state.model_train = True
-    with st.spinner('Training the model...'):
-        time.sleep(2)  
-    st.success("The model has been trained.")
-else:
-    # Afficher le statut
-    st.info("The model hasn't been trained yet.")
+    # Initialisation de l'état du modèle
+    if 'model_train' not in st.session_state:
+        st.session_state['model_train'] = False
 
-# Afficher les résultats 
-if st.session_state.model_train:
-    st.markdown(" ")
-    st.markdown("  ")
-    st.markdown("### See the results ☑️")
-    tab1, tab2 = st.tabs(["Performance", "Explainability"])
-
-    with tab1:
-        #st.subheader("Performance")
-        st.info("""**Evaluating a model's performance** helps provide a quantitative measurement of it's ability to make accurate predictions.
-                    In this use case, the performance of the brain tumor classification model was measured by comparing the patient's true diagnosis with the class predicted by the trained model.""")
-
-        class_accuracy_path = "data/image_classification/class_accuracies.pkl"
-
-        # Charger les données depuis le fichier Pickle
-        try:
-            with open(class_accuracy_path, 'rb') as file:
-                class_accuracy = pickle.load(file)
-        except Exception as e:
-            st.error(f"Erreur lors du chargement du fichier : {e}")
-            class_accuracy = {}  
-
-        if not isinstance(class_accuracy, dict):
-            st.error(f"Expected a dictionary, but got: {type(class_accuracy)}")
-        else:
-            # Conversion des données en DataFrame 
-            df_accuracy = pd.DataFrame(list(class_accuracy.items()), columns=['Tumor Type', 'Accuracy'])
-            df_accuracy['Accuracy'] = ((df_accuracy['Accuracy'] * 100).round()).astype(int) 
-
-            # Générer le graphique à barres avec Plotly 
-            fig = px.bar(df_accuracy, x='Tumor Type', y='Accuracy', 
-                         text='Accuracy', color='Tumor Type', 
-                         title="Model Performance",
-                         labels={'Accuracy': 'Accuracy (%)', 'Tumor Type': 'Tumor Type'})
-
-            fig.update_traces(texttemplate='%{text}%', textposition='outside')
-
-            # Afficher le graphique dans Streamlit
-            st.plotly_chart(fig, use_container_width=True)
+    run_model = st.button("Train the model")
 
-        
-        st.markdown("""<i>The model's accuracy was evaluated across two types of tumors (pituitary and meningioma) and no tumor type.</i>
-                                <i>This evaluation is vital for determining if the model performs consistently across different tumor classifications, or if it encounters difficulties in accurately distinguishing between these two types of tumors.""", 
-                                unsafe_allow_html=True)
+    if run_model:
+        # Simuler l'entraînement du modèle
+        st.session_state.model_train = True
+        with st.spinner('Training the model...'):
+            time.sleep(2)  
+        st.success("The model has been trained.")
+    else:
+        # Afficher le statut
+        st.info("The model hasn't been trained yet.")
 
+    # Afficher les résultats 
+    if st.session_state.model_train:
         st.markdown(" ")
+        st.markdown("  ")
+        st.markdown("### See the results ☑️")
+        tab1, tab2 = st.tabs(["Performance", "Explainability"])
+
+        with tab1:
+            #st.subheader("Performance")
+            st.info("""**Evaluating a model's performance** helps provide a quantitative measurement of it's ability to make accurate predictions.
+                        In this use case, the performance of the brain tumor classification model was measured by comparing the patient's true diagnosis with the class predicted by the trained model.""")
+
+            class_accuracy_path = "data/image_classification/class_accuracies.pkl"
+
+            # Charger les données depuis le fichier Pickle
+            try:
+                with open(class_accuracy_path, 'rb') as file:
+                    class_accuracy = pickle.load(file)
+            except Exception as e:
+                st.error(f"Erreur lors du chargement du fichier : {e}")
+                class_accuracy = {}  
+
+            if not isinstance(class_accuracy, dict):
+                st.error(f"Expected a dictionary, but got: {type(class_accuracy)}")
+            else:
+                # Conversion des données en DataFrame 
+                df_accuracy = pd.DataFrame(list(class_accuracy.items()), columns=['Tumor Type', 'Accuracy'])
+                df_accuracy['Accuracy'] = ((df_accuracy['Accuracy'] * 100).round()).astype(int) 
+
+                # Générer le graphique à barres avec Plotly 
+                fig = px.bar(df_accuracy, x='Tumor Type', y='Accuracy', 
+                            text='Accuracy', color='Tumor Type', 
+                            title="Model Performance",
+                            labels={'Accuracy': 'Accuracy (%)', 'Tumor Type': 'Tumor Type'})
+
+                fig.update_traces(texttemplate='%{text}%', textposition='outside')
+
+                # Afficher le graphique dans Streamlit
+                st.plotly_chart(fig, use_container_width=True)
 
-        st.markdown("""**Interpretation**: <br>
-                    Our model demonstrates high accuracy in predicting cancerous type tumors (meningioma) as well as 'healthy' brain scans (no tumor) with a 98% accuracy for both.
-                    It is observed that the model's performance is lower for pituitary type tumors, as it is around 81%.
-                    This discrepancy may indicate that the model finds it more challenging to distinguish pituitary tumors from other tumor 
-                    types, possibly due to their unique characteristics or lower representation in the training data.
-                                """, unsafe_allow_html=True)
-    
-    with tab2:
-        #st.subheader("Model Explainability with Grad-CAM")
-        st.info("""**Explainability in AI** refers to the ability to **understand and interpret how AI systems make predictions** and how to quantify the impact of the provided data on its results.
-                     In the case of image classification, explainability can be measured by analyzing which of the image's pixel had the most impact on the model's output.""")
-        st.markdown(" ")
-        st.markdown("""The following images show the output of image classification explainability applied on three images used during training. <br>
-                    Pixels that are colored in 'red' had a larger impact on the model's output and thus its ability to distinguish different tumor types (or none).
-                
-                    """, unsafe_allow_html=True)
+            
+            st.markdown("""<i>The model's accuracy was evaluated across two types of tumors (pituitary and meningioma) and no tumor type.</i>
+                                    <i>This evaluation is vital for determining if the model performs consistently across different tumor classifications, or if it encounters difficulties accurately distinguishing between two classes.""", 
+                                    unsafe_allow_html=True)
+
+            st.markdown(" ")
+
+            st.markdown("""**Interpretation**: <br>
+                        Our model demonstrates high accuracy in predicting cancerous type tumors (meningioma) as well as 'healthy' brain scans (no tumor) with a 98% accuracy for both.
+                        It is observed that the model's performance is lower for pituitary type tumors, as it is around 81%.
+                        This discrepancy may indicate that the model finds it more challenging to distinguish pituitary tumors from other tumor 
+                        types, possibly due to their unique characteristics or lower representation in the training data.
+                                    """, unsafe_allow_html=True)
         
-        st.markdown(" ")
-        gradcam_images_paths = ["images/meningioma_tumor.png", "images/no_tumor.png", "images/pituitary.png"]
-        class_names = ["Meningioma Tumor", "No Tumor", "Pituitary Tumor"]
-
-        for path, class_name in zip(gradcam_images_paths, class_names):
-            st.image(path, caption=f"Explainability for {class_name}")
-
-        # st.markdown("""
-        # <b>Interpretation</b>: <br>
+        with tab2:
+            #st.subheader("Model Explainability with Grad-CAM")
+            st.info("""**Explainability in AI** refers to the ability to **understand and interpret how AI systems make predictions** and how to quantify the impact of the provided data on its results.
+                        In the case of image classification, explainability can be measured by analyzing which of the image's pixel had the most impact on the model's output.""")
+            st.markdown(" ")
+            st.markdown("""The following images show the output of image classification explainability applied on three images used during training. <br>
+                        Pixels that are colored in 'red' had a larger impact on the model's output and thus its ability to distinguish different tumor types (or none).
                     
-        # ### Meningioma Tumors <br>
-        # **Meningiomas** are tumors that originate from the meninges, the layers of tissue 
-        #             that envelop the brain and spinal cord. Although they are most often benign 
-        #             (noncancerous) and grow slowly, their location can cause significant issues by 
-        #             exerting pressure on the brain or spinal cord. Meningiomas can occur at various 
-        #             places around the brain and spinal cord and are more common in women than in men.
-
-        # ### Pituitary Tumors <br>
-        # **Pituitary** are growths that develop in the pituitary gland, a small gland located at the 
-        #             base of the brain, behind the nose, and between the ears. Despite their critical location, 
-        #             the majority of pituitary tumors are benign and grow slowly. This gland regulates many of the 
-        #             hormones that control various body functions, so even a small tumor can affect hormone production, 
-        #             leading to a variety of symptoms.""", unsafe_allow_html=True)
-
-
-#################################################
+                        """, unsafe_allow_html=True)
             
-st.markdown("  ")
-st.markdown("  ")
-st.markdown("### Classify MRI scans 🆕")  
-
-st.info("**Note**: The brain tumor classification model can classify new MRI images only if it has been previously trained.")  
-
-st.markdown("""Here, you are provided the MRI scans of nine new patients. 
-            Select an image and press 'run the model' to classify the MRI as either a pituitary tumor, a meningioma tumor or no tumor.""")
+            st.markdown(" ")
+            gradcam_images_paths = ["images/meningioma_tumor.png", "images/no_tumor.png", "images/pituitary.png"]
+            class_names = ["Meningioma Tumor", "No Tumor", "Pituitary Tumor"]
+
+            for path, class_name in zip(gradcam_images_paths, class_names):
+                st.image(path, caption=f"Explainability for {class_name}")
+
+            # st.markdown("""
+            # <b>Interpretation</b>: <br>
+                        
+            # ### Meningioma Tumors <br>
+            # **Meningiomas** are tumors that originate from the meninges, the layers of tissue 
+            #             that envelop the brain and spinal cord. Although they are most often benign 
+            #             (noncancerous) and grow slowly, their location can cause significant issues by 
+            #             exerting pressure on the brain or spinal cord. Meningiomas can occur at various 
+            #             places around the brain and spinal cord and are more common in women than in men.
+
+            # ### Pituitary Tumors <br>
+            # **Pituitary** are growths that develop in the pituitary gland, a small gland located at the 
+            #             base of the brain, behind the nose, and between the ears. Despite their critical location, 
+            #             the majority of pituitary tumors are benign and grow slowly. This gland regulates many of the 
+            #             hormones that control various body functions, so even a small tumor can affect hormone production, 
+            #             leading to a variety of symptoms.""", unsafe_allow_html=True)
+
+
+    #################################################
+                
+    st.markdown("  ")
+    st.markdown("  ")
+    st.markdown("### Classify new MRI scans 🆕")  
 
+    st.info("**Note**: The brain tumor classification model can classify new MRI images only if it has been previously trained.")  
 
-# Définition des catégories de tumeurs
-categories = ["pituitary tumor", "no tumor", "meningioma tumor"]
+    st.markdown("""Here, you are provided the MRI scans of nine new patients. 
+                Select an image and press 'run the model' to classify the MRI as either a pituitary tumor, a meningioma tumor or no tumor.""")
 
-# Selection des images
-images = os.listdir(DATA_DIR)
-selected_image2 = st.selectbox("Choose an image", images, key="selectionbox_key_1")
 
-# show image
-image_path = os.path.join(DATA_DIR, selected_image2)
-image = Image.open(image_path)
-st.markdown("#### You've selected the following image.")
-st.image(image, caption="Image selected", width=300)
+    # Définition des catégories de tumeurs
+    categories = ["pituitary tumor", "no tumor", "meningioma tumor"]
 
+    # Selection des images
+    images = os.listdir(DATA_DIR)
+    selected_image2 = st.selectbox("Choose an image", images, key="selectionbox_key_1")
 
-if st.button('**Make predictions**', key='another_action_button'):
-    results_path = r"data/image_classification"
-    df_results = load_data_pickle(results_path, "results.pkl")
-    predicted_category = df_results.loc[df_results["image"]==selected_image2,"class"].to_numpy()
-    
-    # # Prétraitement et prédiction
-    # image_preprocessed = preprocess(image)
-    # predicted_tensor, _ = predict(image_preprocessed, model)
+    # show image
+    image_path = os.path.join(DATA_DIR, selected_image2)
+    image = Image.open(image_path)
+    st.markdown("#### You've selected the following image.")
+    st.image(image, caption="Image selected", width=300)
 
-    # predicted_idx = predicted_tensor.item()
-    # predicted_category = categories[predicted_idx]  
 
-    # Affichage de la prédiction avec la catégorie prédite
-    if predicted_category == "pituitary":
-        st.warning(f"**Results**: Pituitary tumor was detected. ")
-    elif predicted_category == "no tumor":
-        st.success(f"**Results**: No tumor was detected.")
-    elif predicted_category == "meningnoma":
-        st.error(f"**Results**: Meningioma was detected.")
-    
+    if st.button('**Make predictions**', key='another_action_button'):
+        results_path = r"data/image_classification"
+        df_results = load_data_pickle(results_path, "results.pkl")
+        predicted_category = df_results.loc[df_results["image"]==selected_image2,"class"].to_numpy()
+        
+        # # Prétraitement et prédiction
+        # image_preprocessed = preprocess(image)
+        # predicted_tensor, _ = predict(image_preprocessed, model)
+
+        # predicted_idx = predicted_tensor.item()
+        # predicted_category = categories[predicted_idx]  
+
+        # Affichage de la prédiction avec la catégorie prédite
+        if predicted_category == "pituitary":
+            st.warning(f"**Results**: Pituitary tumor was detected. ")
+        elif predicted_category == "no tumor":
+            st.success(f"**Results**: No tumor was detected.")
+        elif predicted_category == "meningnoma":
+            st.error(f"**Results**: Meningioma was detected.")
+        
 
-    # image_path = os.path.join(DATA_DIR, selected_image2)
-    # image = Image.open(image_path)
-    # st.image(image, caption="Image selected", width=450)
+        # image_path = os.path.join(DATA_DIR, selected_image2)
+        # image = Image.open(image_path)
+        # st.image(image, caption="Image selected", width=450)
 
-        
+            
 

pages/object_detection.py

@@ -8,6 +8,7 @@ import plotly.express as px
 import pickle
 import random
 
+from utils import check_password
 from PIL import Image
 from transformers import YolosFeatureExtractor, YolosForObjectDetection
 from torchvision.transforms import ToTensor, ToPILImage
@@ -137,257 +138,257 @@ cats = ['shirt, blouse', 'top, t-shirt, sweatshirt', 'sweater', 'cardigan', 'jac
 
 ######################################################################################################################################
 
-#st.image("images/od_header.jpg")
-st.markdown("# Object Detection 📹")
+if check_password():
+    st.markdown("# Object Detection 📹")
 
-st.markdown("### What is Object Detection ?")
-           
-#st.markdown("""Object detection involves **identifying** and **locating objects** within an image or video frame through bounding boxes. """)
-st.info("""Object Detection is a computer vision task in which the goal is to **detect** and **locate objects** of interest in an image or video. 
-            The task involves identifying the position and boundaries of objects (or **bounding boxes**) in an image, and classifying the objects into different categories.""")
+    st.markdown("### What is Object Detection ?")
+            
+    #st.markdown("""Object detection involves **identifying** and **locating objects** within an image or video frame through bounding boxes. """)
+    st.info("""Object Detection is a computer vision task in which the goal is to **detect** and **locate objects** of interest in an image or video. 
+                The task involves identifying the position and boundaries of objects (or **bounding boxes**) in an image, and classifying the objects into different categories.""")
 
 
-st.markdown("Here is an example of Object Detection for Traffic Analysis.")
-#image_od = Image.open('images/od_2.png')
-#st.image(image_od, width=600)
-st.video(data='https://www.youtube.com/watch?v=PVCGDoTZHaI')
+    st.markdown("Here is an example of Object Detection for Traffic Analysis.")
+    #image_od = Image.open('images/od_2.png')
+    #st.image(image_od, width=600)
+    st.video(data='https://www.youtube.com/watch?v=PVCGDoTZHaI')
 
-st.markdown(" ")
+    st.markdown(" ")
 
-st.markdown("""Common applications of Object Detection include:
+    st.markdown("""Common applications of Object Detection include:
 - **Autonomous Vehicles** :car: : Object detection is crucial for self-driving cars to track pedestrians, cyclists, other vehicles, and obstacles on the road.
 - **Retail** 🏬 : Implementing smart shelves and checkout systems that use object detection to track inventory and monitor stock levels.
 - **Healthcare** 👨‍⚕️: Detecting and tracking anomalies in medical images, such as tumors or abnormalities, for diagnostic purposes or prevention.
 - **Manufacturing** 🏭: Quality control on production lines by detecting defects or irregularities in manufactured products. Ensuring workplace safety by monitoring the movement of workers and equipment.
-""")
-
+    """)
 
 
-############################# USE CASE #############################
-st.markdown("  ")
-st.divider()
 
-st.markdown("# Fashion Object Detection 👗")
-# st.info("""This use case showcases the application of **Object detection** to detect clothing items/features on images. <br>
-#             The images used were gathered from Dior's""")
-st.info("""**Object detection models** can very valuable for fashion retailers wishing to improve customer experience. They can provide, for example, **product recognition**, **visual search** 
-        and even **virtual try-ons**.""")
+    ############################# USE CASE #############################
+    st.markdown("  ")
+    st.divider()
 
-st.markdown("In this use case, we are going to show an object detection model that as able to identify and locate different articles of clothings on fashion show images.")
+    st.markdown("# Fashion Object Detection 👗")
+    # st.info("""This use case showcases the application of **Object detection** to detect clothing items/features on images. <br>
+    #             The images used were gathered from Dior's""")
+    st.info("""**Object detection models** can very valuable for fashion retailers wishing to improve customer experience. They can provide, for example, **product recognition**, **visual search** 
+            and even **virtual try-ons**.""")
 
-st.markdown("  ")
-st.markdown("  ")
+    st.markdown("In this use case, we are going to show an object detection model that as able to identify and locate different articles of clothings on fashion show images.")
 
-# images_dior = [os.path.join("data/dior_show/images",url) for url in os.listdir("data/dior_show/images") if url != "results"]
-# columns_img = st.columns(4)
-# for img, col in zip(images_dior,columns_img):
-#     with col:
-#         st.image(img)
+    st.markdown("  ")
+    st.markdown("  ")
 
-_, col, _ = st.columns([0.1,0.8,0.1])
-with col:
-    st.image("images/fashion_od2.png")
+    # images_dior = [os.path.join("data/dior_show/images",url) for url in os.listdir("data/dior_show/images") if url != "results"]
+    # columns_img = st.columns(4)
+    # for img, col in zip(images_dior,columns_img):
+    #     with col:
+    #         st.image(img)
 
+    _, col, _ = st.columns([0.1,0.8,0.1])
+    with col:
+        st.image("images/fashion_od2.png")
 
-st.markdown("  ")
-st.markdown("  ")
 
+    st.markdown("  ")
+    st.markdown("  ")
 
-st.markdown("### About the model 📚")
-st.markdown("""The object detection model was trained to **detect specific clothing items** on images. <br> 
-            Below is a list of the <b>46</b> different types of clothing items the model can identify and locate.""", unsafe_allow_html=True)
 
-colors = ["#8ef", "#faa", "#afa", "#fea", "#8ef","#afa"]*7 + ["#8ef", "#faa", "#afa", "#fea"]
+    st.markdown("### About the model 📚")
+    st.markdown("""The object detection model was trained to **detect specific clothing items** on images. <br> 
+                Below is a list of the <b>46</b> different types of clothing items the model can identify and locate.""", unsafe_allow_html=True)
 
-cats_annotated = [(g,"","#afa") for g in cats]
-annotated_text([cats_annotated])
+    colors = ["#8ef", "#faa", "#afa", "#fea", "#8ef","#afa"]*7 + ["#8ef", "#faa", "#afa", "#fea"]
 
-# st.markdown("""**Here are the 'objects' the model is able to detect**: <br>
-#             'shirt, blouse', 'top, t-shirt, sweatshirt', 'sweater', 'cardigan', 'jacket', 'vest', 'pants', 'shorts', 'skirt', 
-#             'coat', 'dress', 'jumpsuit', 'cape', 'glasses', 'hat', 'headband, head covering, hair accessory', 'tie', 'glove', 'watch', 
-#             'belt', 'leg warmer', 'tights, stockings', 'sock', 'shoe', 'bag, wallet', 'scarf', 'umbrella', 'hood', 'collar', 'lapel', 
-#             'epaulette', 'sleeve', 'pocket', 'neckline', 'buckle', 'zipper', 'applique', 'bead', 'bow', 'flower', 'fringe', 'ribbon', 'rivet', 
-#             'ruffle', 'sequin', 'tassel'""", unsafe_allow_html=True)
+    cats_annotated = [(g,"","#afa") for g in cats]
+    annotated_text([cats_annotated])
 
-st.markdown("Credits for the model: https://huggingface.co/valentinafeve/yolos-fashionpedia")
-st.markdown("")
-st.markdown("")
+    # st.markdown("""**Here are the 'objects' the model is able to detect**: <br>
+    #             'shirt, blouse', 'top, t-shirt, sweatshirt', 'sweater', 'cardigan', 'jacket', 'vest', 'pants', 'shorts', 'skirt', 
+    #             'coat', 'dress', 'jumpsuit', 'cape', 'glasses', 'hat', 'headband, head covering, hair accessory', 'tie', 'glove', 'watch', 
+    #             'belt', 'leg warmer', 'tights, stockings', 'sock', 'shoe', 'bag, wallet', 'scarf', 'umbrella', 'hood', 'collar', 'lapel', 
+    #             'epaulette', 'sleeve', 'pocket', 'neckline', 'buckle', 'zipper', 'applique', 'bead', 'bow', 'flower', 'fringe', 'ribbon', 'rivet', 
+    #             'ruffle', 'sequin', 'tassel'""", unsafe_allow_html=True)
 
+    st.markdown("Credits for the model: https://huggingface.co/valentinafeve/yolos-fashionpedia")
+    st.markdown("")
+    st.markdown("")
 
 
-############## SELECT AN IMAGE ###############
 
-st.markdown("### Select an image 🖼️")
-st.markdown("""The images provided were taken from **Dior's 2020 Fall Women Fashion Show**""") 
+    ############## SELECT AN IMAGE ###############
 
-image_ = None
-fashion_images_path = r"data/dior_show/images"
-list_images = os.listdir(fashion_images_path)
-image_name = st.selectbox("Choose an image", list_images)
-image_ = os.path.join(fashion_images_path, image_name)
-st.image(image_, width=300)
+    st.markdown("### Select an image 🖼️")
+    st.markdown("""The images provided were taken from **Dior's 2020 Fall Women Fashion Show**""") 
 
+    image_ = None
+    fashion_images_path = r"data/dior_show/images"
+    list_images = os.listdir(fashion_images_path)
+    image_name = st.selectbox("Choose an image", list_images)
+    image_ = os.path.join(fashion_images_path, image_name)
+    st.image(image_, width=300)
 
-# image_ = None
-# select_image_box = st.radio(
-#     "**Select the image you wish to run the model on**",
-#     ["Choose an existing image", "Load your own image"],
-#     index=None,)# #label_visibility="collapsed")
 
-# if select_image_box == "Choose an existing image":
-#     fashion_images_path = r"data/dior_show/images"
-#     list_images = os.listdir(fashion_images_path)
-#     image_ = st.selectbox("", list_images, label_visibility="collapsed")
-    
-#     if image_ is not None:
-#         image_ = os.path.join(fashion_images_path,image_)
-#         st.markdown("You've selected the following image:")
-#         st.image(image_, width=300)
-
-# elif select_image_box == "Load your own image":
-#     image_ = st.file_uploader("Load an image here", 
-#                                 key="OD_dior", type=['jpg','jpeg','png'], label_visibility="collapsed")
-    
-#     st.warning("""**Note**: The model tends to perform better with images of people/clothing items facing forward. 
-#            Choose this type of image if you want optimal results.""")
-#     st.warning("""**Note:** The model was trained to detect clothing items on a single person. 
-#                If your image contains more than one person, the model won't detect the items of the other persons.""")
+    # image_ = None
+    # select_image_box = st.radio(
+    #     "**Select the image you wish to run the model on**",
+    #     ["Choose an existing image", "Load your own image"],
+    #     index=None,)# #label_visibility="collapsed")
 
-#     if image_ is not None:
-#         st.image(Image.open(image_), width=300)
+    # if select_image_box == "Choose an existing image":
+    #     fashion_images_path = r"data/dior_show/images"
+    #     list_images = os.listdir(fashion_images_path)
+    #     image_ = st.selectbox("", list_images, label_visibility="collapsed")
+        
+    #     if image_ is not None:
+    #         image_ = os.path.join(fashion_images_path,image_)
+    #         st.markdown("You've selected the following image:")
+    #         st.image(image_, width=300)
 
+    # elif select_image_box == "Load your own image":
+    #     image_ = st.file_uploader("Load an image here", 
+    #                                 key="OD_dior", type=['jpg','jpeg','png'], label_visibility="collapsed")
+        
+    #     st.warning("""**Note**: The model tends to perform better with images of people/clothing items facing forward. 
+    #            Choose this type of image if you want optimal results.""")
+    #     st.warning("""**Note:** The model was trained to detect clothing items on a single person. 
+    #                If your image contains more than one person, the model won't detect the items of the other persons.""")
 
-st.markdown("  ")
-st.markdown("  ")
+    #     if image_ is not None:
+    #         st.image(Image.open(image_), width=300)
 
 
+    st.markdown("  ")
+    st.markdown("  ")
 
-########## SELECT AN ELEMENT TO DETECT ##################
 
 
-dict_cats = dict(zip(np.arange(len(cats)), cats))
+    ########## SELECT AN ELEMENT TO DETECT ##################
 
-# st.markdown("#### Choose the elements you want to detect 👉")
 
-# # Select one or more elements to detect
-# container = st.container()
-# selected_options = None
-# all = st.checkbox("Select all")
+    dict_cats = dict(zip(np.arange(len(cats)), cats))
 
-# if all:
-#     selected_options = container.multiselect("**Select one or more items**", cats, cats)
-# else:
-#     selected_options = container.multiselect("**Select one or more items**", cats)
+    # st.markdown("#### Choose the elements you want to detect 👉")
 
-#cats = selected_options 
-selected_options = cats
-dict_cats_final = {key:value for (key,value) in dict_cats.items() if value in selected_options}
+    # # Select one or more elements to detect
+    # container = st.container()
+    # selected_options = None
+    # all = st.checkbox("Select all")
 
+    # if all:
+    #     selected_options = container.multiselect("**Select one or more items**", cats, cats)
+    # else:
+    #     selected_options = container.multiselect("**Select one or more items**", cats)
 
-# st.markdown("  ")
-# st.markdown("  ")
+    #cats = selected_options 
+    selected_options = cats
+    dict_cats_final = {key:value for (key,value) in dict_cats.items() if value in selected_options}
 
 
+    # st.markdown("  ")
+    # st.markdown("  ")
 
-############## SELECT A THRESHOLD ###############
 
-st.markdown("### Define a threshold for predictions 🔎")
-st.markdown("""In this section, you can select a threshold for the model's final predictions. <br>
-            Objects that are given a lower score than the chosen threshold will be ignored in the final results""", unsafe_allow_html=True)
 
-st.info("""**Note**: Object detection models detect objects using bounding boxes as well as assign objects to specific classes.
-        Each object is given a class based on a probability score computed by the model. A high probability signals that the model is confident in its prediction. 
-        On the contrary, a lower probability score signals a level of uncertainty.""")
+    ############## SELECT A THRESHOLD ###############
 
-st.markdown(" ")
-#st.markdown("The images below are examples of probability scores given by object detection models for each element detected.")
+    st.markdown("### Define a threshold for predictions 🔎")
+    st.markdown("""In this section, you can select a threshold for the model's final predictions. <br>
+                Objects that are given a lower score than the chosen threshold will be ignored in the final results""", unsafe_allow_html=True)
 
-_, col, _ = st.columns([0.2,0.6,0.2])
-with col:
-    st.image("images/probability_od.png", 
-            caption="Examples of object detection with bounding boses and probability scores")
+    st.info("""**Note**: Object detection models detect objects using bounding boxes as well as assign objects to specific classes.
+            Each object is given a class based on a probability score computed by the model. A high probability signals that the model is confident in its prediction. 
+            On the contrary, a lower probability score signals a level of uncertainty.""")
 
-st.markdown(" ")
+    st.markdown(" ")
+    #st.markdown("The images below are examples of probability scores given by object detection models for each element detected.")
 
-st.markdown("**Select a threshold** ")
+    _, col, _ = st.columns([0.2,0.6,0.2])
+    with col:
+        st.image("images/probability_od.png", 
+                caption="Examples of object detection with bounding boses and probability scores")
 
-# st.warning("""**Note**: The threshold helps you decide how confident you want your model to be with its predictions. 
-#             Elements that are identified with a lower probability than the given threshold will be ignored in the final results.""")
+    st.markdown(" ")
 
-threshold = st.slider('**Select a threshold**', min_value=0.5, step=0.05, max_value=1.0, value=0.75, label_visibility="collapsed")
+    st.markdown("**Select a threshold** ")
 
+    # st.warning("""**Note**: The threshold helps you decide how confident you want your model to be with its predictions. 
+    #             Elements that are identified with a lower probability than the given threshold will be ignored in the final results.""")
 
-# if threshold < 0.6:
-#     st.error("""**Warning**: Selecting a low threshold (below 0.6) could lead the model to make errors and detect too many objects.""")
+    threshold = st.slider('**Select a threshold**', min_value=0.5, step=0.05, max_value=1.0, value=0.75, label_visibility="collapsed")
 
-st.write("You've selected a threshold at", threshold)
-st.markdown("  ")
 
+    # if threshold < 0.6:
+    #     st.error("""**Warning**: Selecting a low threshold (below 0.6) could lead the model to make errors and detect too many objects.""")
 
+    st.write("You've selected a threshold at", threshold)
+    st.markdown("  ")
 
-pickle_file_path = r"data/dior_show/results"
 
 
-############# RUN MODEL ################
+    pickle_file_path = r"data/dior_show/results"
 
-run_model = st.button("**Run the model**", type="primary")
 
-if run_model:
-    if image_ != None and selected_options != None and threshold!= None:
-        with st.spinner('Wait for it...'):
-            ## SELECT IMAGE
-            #st.write(image_)
-            image = Image.open(image_)
-            image = fix_channels(ToTensor()(image))
+    ############# RUN MODEL ################
 
-            ## LOAD OBJECT DETECTION MODEL
-            FEATURE_EXTRACTOR_PATH = "hustvl/yolos-small"
-            MODEL_PATH = "valentinafeve/yolos-fashionpedia"
-            # feature_extractor, model = load_model(FEATURE_EXTRACTOR_PATH, MODEL_PATH)
+    run_model = st.button("**Run the model**", type="primary")
 
-            # # RUN MODEL ON IMAGE
-            # inputs = feature_extractor(images=image, return_tensors="pt")
-            # outputs = model(**inputs)
-            
-            # Save results 
-            # pickle_file_path = r"data/dior_show/results"
-            # image_name = image_.split('\\')[1][:5]
-            # with open(os.path.join(pickle_file_path, f"{image_name}_results.pkl"), 'wb') as file:
-            #     pickle.dump(outputs, file)
-            
-            image_name = image_name[:5]
-            path_load_pickle = os.path.join(pickle_file_path, f"{image_name}_results.pkl")
-            with open(path_load_pickle, 'rb') as pickle_file:
-                outputs = pickle.load(pickle_file)
-            
-            probas, keep = return_probas(outputs, threshold)
+    if run_model:
+        if image_ != None and selected_options != None and threshold!= None:
+            with st.spinner('Wait for it...'):
+                ## SELECT IMAGE
+                #st.write(image_)
+                image = Image.open(image_)
+                image = fix_channels(ToTensor()(image))
 
-            st.markdown("#### See the results ☑️")
+                ## LOAD OBJECT DETECTION MODEL
+                FEATURE_EXTRACTOR_PATH = "hustvl/yolos-small"
+                MODEL_PATH = "valentinafeve/yolos-fashionpedia"
+                # feature_extractor, model = load_model(FEATURE_EXTRACTOR_PATH, MODEL_PATH)
 
-            # PLOT BOUNDING BOX AND BARS/PROBA
-            col1, col2 = st.columns(2)
-            with col1:
-                st.markdown(" ")
-                st.markdown("##### 1. Bounding box results")
-                bboxes_scaled = rescale_bboxes(outputs.pred_boxes[0, keep].cpu(), image.size)
-                colors_used = plot_results(image, probas[keep], bboxes_scaled)
-            
-            with col2: 
-                #st.markdown("**Probability scores**")
-                if not any(keep.tolist()):
-                    st.error("""No objects were detected on the image. 
-                             Decrease your threshold or choose differents items to detect.""")
-                else:
-                    st.markdown(" ")
-                    st.markdown("##### 2. Probability score of each object")
-                    st.info("""**Note**: Some items might have been detected more than once on the image.
-                            For these items, we've computed the average probability score across all detections.""")
-                    visualize_probas(probas, threshold, colors_used)
+                # # RUN MODEL ON IMAGE
+                # inputs = feature_extractor(images=image, return_tensors="pt")
+                # outputs = model(**inputs)
+                
+                # Save results 
+                # pickle_file_path = r"data/dior_show/results"
+                # image_name = image_.split('\\')[1][:5]
+                # with open(os.path.join(pickle_file_path, f"{image_name}_results.pkl"), 'wb') as file:
+                #     pickle.dump(outputs, file)
+                
+                image_name = image_name[:5]
+                path_load_pickle = os.path.join(pickle_file_path, f"{image_name}_results.pkl")
+                with open(path_load_pickle, 'rb') as pickle_file:
+                    outputs = pickle.load(pickle_file)
+                
+                probas, keep = return_probas(outputs, threshold)
 
-            
+                st.markdown("#### See the results ☑️")
 
-    else:
-        st.error("You must select an **image**, **elements to detect** and a **threshold** to run the model !")
+                # PLOT BOUNDING BOX AND BARS/PROBA
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.markdown(" ")
+                    st.markdown("##### 1. Bounding box results")
+                    bboxes_scaled = rescale_bboxes(outputs.pred_boxes[0, keep].cpu(), image.size)
+                    colors_used = plot_results(image, probas[keep], bboxes_scaled)
+                
+                with col2: 
+                    #st.markdown("**Probability scores**")
+                    if not any(keep.tolist()):
+                        st.error("""No objects were detected on the image. 
+                                Decrease your threshold or choose differents items to detect.""")
+                    else:
+                        st.markdown(" ")
+                        st.markdown("##### 2. Probability score of each object")
+                        st.info("""**Note**: Some items might have been detected more than once on the image.
+                                For these items, we've computed the average probability score across all detections.""")
+                        visualize_probas(probas, threshold, colors_used)
+
+                
+
+        else:
+            st.error("You must select an **image**, **elements to detect** and a **threshold** to run the model !")
 
 
     

pages/recommendation_system.py

@@ -10,7 +10,7 @@ import plotly.express as px
 from sklearn.preprocessing import MinMaxScaler
 from sklearn.metrics.pairwise import cosine_similarity
 from annotated_text import annotated_text
-from utils import load_data_pickle, load_model_pickle, load_data_csv
+from utils import load_model_pickle, load_data_csv, check_password
 from st_pages import add_indentation
 
 #add_indentation()
@@ -18,445 +18,444 @@ from st_pages import add_indentation
 
 st.set_page_config(layout="wide")
 
-#st.image("images/recom_system_header.png")
-st.markdown("# Recommendation systems 🛒")
+if check_password():
+    st.markdown("# Recommendation systems 🛒")
+    st.markdown("### What is a Recommendation System ?")
 
-st.markdown("### What is a Recommendation System ?")
+    st.info("""**Recommendation systems** are algorithms built to **suggest** or **recommend** **products** to consumers.
+            They are very common in social media platforms such as TikTok, Youtube or Instagram or e-commerce websites as they help improve and personalize a consumer's experience.""")
 
-st.info("""**Recommendation systems** are algorithms built to **suggest** or **recommend** **products** to consumers.
-        They are very common in social media platforms such as TikTok, Youtube or Instagram or e-commerce websites as they help improve and personalize a consumer's experience.""")
-
-st.markdown("""There are two main types of recommendation systems:
+    st.markdown("""There are two main types of recommendation systems:
 - **Content-based filtering**: Recommendations are made based on the user's own preferences
 - **Collaborative filtering**: Recommendations are made based on the preferences and behavior of similar users""", unsafe_allow_html=True)
-            
-# st.markdown("""Here is an example of **Content-based filtering versus Collaborative filtering** for movie recommendations.""")
-st.markdown(" ")
-st.markdown(" ")
+                
+    # st.markdown("""Here is an example of **Content-based filtering versus Collaborative filtering** for movie recommendations.""")
+    st.markdown(" ")
+    st.markdown(" ")
 
-# _, col_img, _ = st.columns(spec=[0.2,0.6,0.2])
-# with col_img:
-#     st.image("images/rs.png")
+    # _, col_img, _ = st.columns(spec=[0.2,0.6,0.2])
+    # with col_img:
+    #     st.image("images/rs.png")
 
-st.image("images/rs.png")
+    st.image("images/rs.png")
 
-st.markdown(" ")
+    st.markdown(" ")
 
-st.markdown("""Common applications of Recommendation systems include:
+    st.markdown("""Common applications of Recommendation systems include:
 - **E-Commerce Platforms** 🛍️: Suggest products to users based on their browsing history, purchase patterns, and preferences. 
 - **Streaming Services** 📽️: Recommend movies, TV shows, or songs based on users' viewing/listening history and preferences. 
 - **Social Media Platforms** 📱: Suggest friends, groups, or content based on users' connections, interests, and engagement history.
 - **Automotive and Navigation Systems** 🗺️: Suggest optimal routes based on real-time traffic conditions, historical data, and user preferences.   
-""")
+    """)
 
-st.markdown(" ")
+    st.markdown(" ")
 
-select_usecase = st.selectbox("**Choose a use case**", 
-                              ["Movie recommendation system 📽️", 
-                               "Hotel recommendation system 🛎️"])
+    select_usecase = st.selectbox("**Choose a use case**", 
+                                ["Movie recommendation system 📽️", 
+                                "Hotel recommendation system 🛎️"])
 
-st.divider()
+    st.divider()
 
 
 
-#####################################################################################################
-#                                       MOVIE RECOMMENDATION SYSTEM                                 #
-#####################################################################################################
+    #####################################################################################################
+    #                                       MOVIE RECOMMENDATION SYSTEM                                 #
+    #####################################################################################################
 
-# Recommendation function
-def recommend(movie_name, nb):
-    n_movies_to_recommend = nb
-    idx = movies[movies['title'] == movie_name].index[0]
+    # Recommendation function
+    def recommend(movie_name, nb):
+        n_movies_to_recommend = nb
+        idx = movies[movies['title'] == movie_name].index[0]
 
-    distances, indices = model.kneighbors(csr_data[idx], n_neighbors=n_movies_to_recommend + 1)
-    idx = list(indices.squeeze())
-    df = np.take(movies, idx, axis=0)
+        distances, indices = model.kneighbors(csr_data[idx], n_neighbors=n_movies_to_recommend + 1)
+        idx = list(indices.squeeze())
+        df = np.take(movies, idx, axis=0)
 
-    movies_list = list(df.title[1:])
+        movies_list = list(df.title[1:])
 
-    recommend_movies_names = []
-    recommend_posters = []
-    movie_ids = []
-    for i in movies_list:
-        temp_movie_id = (movies[movies.title ==i].movie_id).values[0]
-        movie_ids.append(temp_movie_id)
+        recommend_movies_names = []
+        recommend_posters = []
+        movie_ids = []
+        for i in movies_list:
+            temp_movie_id = (movies[movies.title ==i].movie_id).values[0]
+            movie_ids.append(temp_movie_id)
 
-        poster = fetch_poster(temp_movie_id)
-        recommend_posters.append(poster)
-        
-        # fetch poster
-        try:
             poster = fetch_poster(temp_movie_id)
             recommend_posters.append(poster)
-        except:
-            recommend_posters.append(None)
-        
-        recommend_movies_names.append(i)
-    return recommend_movies_names, recommend_posters, movie_ids
-
-# Get poster
-def fetch_poster(movie_id):
-    response = requests.get(f'https://api.themoviedb.org/3/movie/{movie_id}?api_key={api_key}')
-    data = response.json()
-    return "https://image.tmdb.org/t/p/w500/" + data["poster_path"]
-
+            
+            # fetch poster
+            try:
+                poster = fetch_poster(temp_movie_id)
+                recommend_posters.append(poster)
+            except:
+                recommend_posters.append(None)
+            
+            recommend_movies_names.append(i)
+        return recommend_movies_names, recommend_posters, movie_ids
 
+    # Get poster
+    def fetch_poster(movie_id):
+        response = requests.get(f'https://api.themoviedb.org/3/movie/{movie_id}?api_key={api_key}')
+        data = response.json()
+        return "https://image.tmdb.org/t/p/w500/" + data["poster_path"]
 
-if select_usecase == "Movie recommendation system 📽️":
 
-    colors = ["#8ef", "#faa", "#afa", "#fea", "#8ef","#afa"]
-    #api_key = st.secrets["recommendation_system"]["key"]
-    api_key = os.environ["MOVIE_RECOM_API"]
 
-    # Load data 
-    path_data = r"data/movies"
-    path_models = r"pretrained_models/recommendation_system"
+    if select_usecase == "Movie recommendation system 📽️":
 
-    movies_dict = pickle.load(open(os.path.join(path_data,"movies_dict2.pkl"),"rb"))
-    movies = pd.DataFrame(movies_dict)
-    movies.drop_duplicates(inplace=True)
+        colors = ["#8ef", "#faa", "#afa", "#fea", "#8ef","#afa"]
+        #api_key = st.secrets["recommendation_system"]["key"]
+        api_key = os.environ["MOVIE_RECOM_API"]
 
-    vote_info = pickle.load(open(os.path.join(path_data,"vote_info.pkl"),"rb"))
-    vote = pd.DataFrame(vote_info)
+        # Load data 
+        path_data = r"data/movies"
+        path_models = r"pretrained_models/recommendation_system"
 
-    # Load model
-    model = load_model_pickle(path_models,"model.pkl")
-    with open(os.path.join(path_data,'csr_data_tf.pkl'), 'rb') as file:
-        csr_data = pickle.load(file)
+        movies_dict = pickle.load(open(os.path.join(path_data,"movies_dict2.pkl"),"rb"))
+        movies = pd.DataFrame(movies_dict)
+        movies.drop_duplicates(inplace=True)
 
+        vote_info = pickle.load(open(os.path.join(path_data,"vote_info.pkl"),"rb"))
+        vote = pd.DataFrame(vote_info)
 
-    # Description of the use case
-    st.markdown("""# Movie Recommendation System 📽️""")
+        # Load model
+        model = load_model_pickle(path_models,"model.pkl")
+        with open(os.path.join(path_data,'csr_data_tf.pkl'), 'rb') as file:
+            csr_data = pickle.load(file)
 
-    #st.info(""" """)
 
-    st.markdown("""This use case showcases the use of recommender systems for **movie recommendations** using **collaborative filtering**. <br>
-                   The model recommends and ranks movies based on what users, who have also watched the chosen movie, have watched else on the platform. <br> 
-    """, unsafe_allow_html=True)
-    st.markdown(" ")
+        # Description of the use case
+        st.markdown("""# Movie Recommendation System 📽️""")
 
-    
-    # User selection
-    selected_movie = st.selectbox("**Select a movie**", movies["title"].values[:-3])
-    selected_nb_movies = st.selectbox("**Select a number of movies to recommend**", np.arange(2,7), index=3)
-
-    # Show user selection on the app
-    c1, c2 = st.columns([0.7,0.3], gap="medium")
-    with c1:
-        new_movies = movies.rename({"movie_id":"id"},axis=1).merge(vote, on="id", how="left")
-        description = new_movies.loc[new_movies["title"]==selected_movie,"description"].to_list()[0]
-        genre = new_movies.loc[new_movies["title"]==selected_movie,"genre"].to_list()[0]
-        vote_ = new_movies.loc[new_movies["title"]==selected_movie,"vote_average"].to_list()[0]
-        vote_count = new_movies.loc[new_movies["title"]==selected_movie,"vote_count"].to_list()[0]
-        
-        list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]
-        
-        st.header(selected_movie, divider="grey")
-        st.markdown(f"**Synopsis**: {description}")
-        annotated_text(["**Genre(s)**: ", list_genres])
-        st.markdown(f"**Rating**: {vote_}:star:")
-        st.markdown(f"**Votes**: {vote_count}")
+        #st.info(""" """)
 
-        st.info(f"You've selected {selected_nb_movies} movies to recommend")
+        st.markdown("""This use case showcases the use of recommender systems for **movie recommendations** using **collaborative filtering**. <br>
+                    The model recommends and ranks movies based on what users, who have also watched the chosen movie, have watched else on the platform. <br> 
+        """, unsafe_allow_html=True)
         st.markdown(" ")
-        
-        recommend_button = st.button("**Recommend movies**")
-
-    with c2:
-        try:
-            poster = fetch_poster(movies.loc[movies["title"]==selected_movie,"movie_id"].to_list()[0])
-            st.image(poster, width=300)
-        except:
-            pass
-
-
-    # Run model and show results
-    if recommend_button:
-        st.text("Here are few Recommendations..")
-        names,posters,movie_ids = recommend(selected_movie, selected_nb_movies)
-        tab1, tab2 = st.tabs(["View movies", "View genres"])
-
-        with tab1:
-            cols=st.columns(int(selected_nb_movies))
-            #cols=[col1,col2,col3,col4,col5]
-            for i in range(0,selected_nb_movies):
-                with cols[i]:
-                    expander = st.expander("See movie details")
-                    
-                    # if posters[i] == None:
-                    #     pass
-                    # else:
-                    #     st.image(posters[i])
-                    
-                    st.markdown(f"##### **{i+1}. {names[i]}**")
-                    id = movie_ids[i]
 
-                    genre = movies.loc[movies["movie_id"]==id,"genre"].to_list()[0]
-                    list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]
-
-                    synopsis = movies.loc[movies['movie_id']==id, "description"].to_list()[0]
-                    st.markdown(synopsis)
-
-                    vote_avg, vote_count = vote[vote["id"] == id].vote_average , vote[vote["id"] == id].vote_count
-                    annotated_text(["**Genre(s)**: ", list_genres])
-                    st.markdown(f"""**Rating**: {list(vote_avg.values)[0]}:star:""")
-                    st.markdown(f"**Votes**: {list(vote_count.values)[0]}")
         
-        
-        with tab2:
-            recommended_genres = movies.loc[movies["movie_id"].isin(movie_ids[:5]),"genre"].to_list()
-            list_recom_genres = [genre for list_genres in recommended_genres for genre in list_genres.split(", ")]
-            df_recom_genres = pd.Series(list_recom_genres).value_counts().to_frame().reset_index(names="genre")
-            df_recom_genres["proportion (%)"] = (100*df_recom_genres["count"]/df_recom_genres["count"].sum())
-
-            fig = px.bar(df_recom_genres, x='count', y='genre', color="genre", title='Most recommended genres', orientation="h")
-            st.plotly_chart(fig, use_container_width=True)
+        # User selection
+        selected_movie = st.selectbox("**Select a movie**", movies["title"].values[:-3])
+        selected_nb_movies = st.selectbox("**Select a number of movies to recommend**", np.arange(2,7), index=3)
+
+        # Show user selection on the app
+        c1, c2 = st.columns([0.7,0.3], gap="medium")
+        with c1:
+            new_movies = movies.rename({"movie_id":"id"},axis=1).merge(vote, on="id", how="left")
+            description = new_movies.loc[new_movies["title"]==selected_movie,"description"].to_list()[0]
+            genre = new_movies.loc[new_movies["title"]==selected_movie,"genre"].to_list()[0]
+            vote_ = new_movies.loc[new_movies["title"]==selected_movie,"vote_average"].to_list()[0]
+            vote_count = new_movies.loc[new_movies["title"]==selected_movie,"vote_count"].to_list()[0]
+            
+            list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]
+            
+            st.header(selected_movie, divider="grey")
+            st.markdown(f"**Synopsis**: {description}")
+            annotated_text(["**Genre(s)**: ", list_genres])
+            st.markdown(f"**Rating**: {vote_}:star:")
+            st.markdown(f"**Votes**: {vote_count}")
 
+            st.info(f"You've selected {selected_nb_movies} movies to recommend")
+            st.markdown(" ")
+            
+            recommend_button = st.button("**Recommend movies**")
+
+        with c2:
+            try:
+                poster = fetch_poster(movies.loc[movies["title"]==selected_movie,"movie_id"].to_list()[0])
+                st.image(poster, width=300)
+            except:
+                pass
+
+
+        # Run model and show results
+        if recommend_button:
+            st.text("Here are few Recommendations..")
+            names,posters,movie_ids = recommend(selected_movie, selected_nb_movies)
+            tab1, tab2 = st.tabs(["View movies", "View genres"])
+
+            with tab1:
+                cols=st.columns(int(selected_nb_movies))
+                #cols=[col1,col2,col3,col4,col5]
+                for i in range(0,selected_nb_movies):
+                    with cols[i]:
+                        expander = st.expander("See movie details")
+                        
+                        # if posters[i] == None:
+                        #     pass
+                        # else:
+                        #     st.image(posters[i])
+                        
+                        st.markdown(f"##### **{i+1}. {names[i]}**")
+                        id = movie_ids[i]
+
+                        genre = movies.loc[movies["movie_id"]==id,"genre"].to_list()[0]
+                        list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]
+
+                        synopsis = movies.loc[movies['movie_id']==id, "description"].to_list()[0]
+                        st.markdown(synopsis)
+
+                        vote_avg, vote_count = vote[vote["id"] == id].vote_average , vote[vote["id"] == id].vote_count
+                        annotated_text(["**Genre(s)**: ", list_genres])
+                        st.markdown(f"""**Rating**: {list(vote_avg.values)[0]}:star:""")
+                        st.markdown(f"**Votes**: {list(vote_count.values)[0]}")
+            
+            
+            with tab2:
+                recommended_genres = movies.loc[movies["movie_id"].isin(movie_ids[:5]),"genre"].to_list()
+                list_recom_genres = [genre for list_genres in recommended_genres for genre in list_genres.split(", ")]
+                df_recom_genres = pd.Series(list_recom_genres).value_counts().to_frame().reset_index(names="genre")
+                df_recom_genres["proportion (%)"] = (100*df_recom_genres["count"]/df_recom_genres["count"].sum())
 
+                fig = px.bar(df_recom_genres, x='count', y='genre', color="genre", title='Most recommended genres', orientation="h")
+                st.plotly_chart(fig, use_container_width=True)
 
 
 
 
 
-#####################################################################################################
-#                                       HOTEL RECOMMENDATION SYSTEM                                 #
-#####################################################################################################
-            
 
-# Load scaler with caching
-    
-    
-        
-if select_usecase == "Hotel recommendation system 🛎️":
 
-    @st.cache_data(ttl=3600)
-    def get_scaler(df):
-        scaler = MinMaxScaler()
-        scaler.fit(df[['Rating', 'Price']])
-        return scaler
+    #####################################################################################################
+    #                                       HOTEL RECOMMENDATION SYSTEM                                 #
+    #####################################################################################################
+                
 
-    def recommend_hotels_with_location_and_beds(df, preferences, max_recommendations=5):
-        # Start with the full dataset
-        filtered_df = df.copy()
-        
-        # Filter by Location if specified (either city or country)
-        if 'Location' in preferences and preferences['Location']:
-            filtered_df = filtered_df[(filtered_df['City'].str.contains(preferences['Location'], case=False, na=False)) |
-                                    (filtered_df['Country'].str.contains(preferences['Location'], case=False, na=False))]
-
-        # Filter by Number of beds if specified
-        if 'Number of beds' in preferences:
-            filtered_df = filtered_df[filtered_df['Number of bed'] == preferences['Number of beds']]
+    # Load scaler with caching
         
-        # Filter by Rating if specified
-        if 'Rating' in preferences:
-            min_rating, max_rating = preferences['Rating']
-            filtered_df = filtered_df[filtered_df['Rating'].between(min_rating, max_rating)]
         
-        # Filter by Price range if specified
-        if 'Price' in preferences:
-            min_price, max_price = preferences['Price']
-            filtered_df = filtered_df[filtered_df['Price'].between(min_price, max_price)]
-
-        # Ensure there are still hotels after filtering
-        if filtered_df.empty:
-            # Send a notification if no hotels match the criteria
-            send_notification("No hotels were found matching the specified criteria.")
-            return pd.DataFrame(), "No hotels were found matching the specified criteria."
-        
-        preferences["Rating"] = np.mean(np.array(preferences["Rating"]))
-        preferences["Price"] = np.mean(np.array(preferences["Price"]))
-
-        # Normalize the preferences vector (excluding location and number of beds for similarity calculation)
-        preferences_vector = np.array([[preferences.get('Rating', 0),
-                                        preferences.get('Price', 0)]])
-        preferences_vector_normalized = scaler.transform(preferences_vector)
-
-        # Calculate similarity scores for the filtered hotels
-        filtered_numerical_features = filtered_df[['Rating', 'Price']]
-        filtered_numerical_features_normalized = scaler.transform(filtered_numerical_features)
-        similarity_scores = cosine_similarity(preferences_vector_normalized, filtered_numerical_features_normalized)[0]
-
-        # Get the indices of top_n similar hotels
-        top_indices = similarity_scores.argsort()[-max_recommendations:][::-1]
-        recommended_indices = filtered_df.iloc[top_indices].index
-
-        # Return the recommended hotels with relevant details (including specified columns)
-        return df.loc[recommended_indices], None
-
-
-    def send_notification(message):
-        """
-        Placeholder function to send a notification.
-        This function can be replaced with the actual notification mechanism (e.g., email, SMS).
-        """
-        print("Notification:", message)
-
-
-    def country_info(country):
-        if country == "Thailand":
-            image = "images/thailand.jpeg"
-            emoji = "🏝️"
-            description = """**Description**: 
-Thailand seamlessly fuses ancient traditions with modern dynamism, creating an unparalleled tapestry for travelers. 
-Renowned for its warm hospitality, vibrant culture, and delectable cuisine, Thailand offers an unforgettable experience for every adventurer."""
-            top_places = """
+            
+    if select_usecase == "Hotel recommendation system 🛎️":
+
+        @st.cache_data(ttl=3600)
+        def get_scaler(df):
+            scaler = MinMaxScaler()
+            scaler.fit(df[['Rating', 'Price']])
+            return scaler
+
+        def recommend_hotels_with_location_and_beds(df, preferences, max_recommendations=5):
+            # Start with the full dataset
+            filtered_df = df.copy()
+            
+            # Filter by Location if specified (either city or country)
+            if 'Location' in preferences and preferences['Location']:
+                filtered_df = filtered_df[(filtered_df['City'].str.contains(preferences['Location'], case=False, na=False)) |
+                                        (filtered_df['Country'].str.contains(preferences['Location'], case=False, na=False))]
+
+            # Filter by Number of beds if specified
+            if 'Number of beds' in preferences:
+                filtered_df = filtered_df[filtered_df['Number of bed'] == preferences['Number of beds']]
+            
+            # Filter by Rating if specified
+            if 'Rating' in preferences:
+                min_rating, max_rating = preferences['Rating']
+                filtered_df = filtered_df[filtered_df['Rating'].between(min_rating, max_rating)]
+            
+            # Filter by Price range if specified
+            if 'Price' in preferences:
+                min_price, max_price = preferences['Price']
+                filtered_df = filtered_df[filtered_df['Price'].between(min_price, max_price)]
+
+            # Ensure there are still hotels after filtering
+            if filtered_df.empty:
+                # Send a notification if no hotels match the criteria
+                send_notification("No hotels were found matching the specified criteria.")
+                return pd.DataFrame(), "No hotels were found matching the specified criteria."
+            
+            preferences["Rating"] = np.mean(np.array(preferences["Rating"]))
+            preferences["Price"] = np.mean(np.array(preferences["Price"]))
+
+            # Normalize the preferences vector (excluding location and number of beds for similarity calculation)
+            preferences_vector = np.array([[preferences.get('Rating', 0),
+                                            preferences.get('Price', 0)]])
+            preferences_vector_normalized = scaler.transform(preferences_vector)
+
+            # Calculate similarity scores for the filtered hotels
+            filtered_numerical_features = filtered_df[['Rating', 'Price']]
+            filtered_numerical_features_normalized = scaler.transform(filtered_numerical_features)
+            similarity_scores = cosine_similarity(preferences_vector_normalized, filtered_numerical_features_normalized)[0]
+
+            # Get the indices of top_n similar hotels
+            top_indices = similarity_scores.argsort()[-max_recommendations:][::-1]
+            recommended_indices = filtered_df.iloc[top_indices].index
+
+            # Return the recommended hotels with relevant details (including specified columns)
+            return df.loc[recommended_indices], None
+
+
+        def send_notification(message):
+            """
+            Placeholder function to send a notification.
+            This function can be replaced with the actual notification mechanism (e.g., email, SMS).
+            """
+            print("Notification:", message)
+
+
+        def country_info(country):
+            if country == "Thailand":
+                image = "images/thailand.jpeg"
+                emoji = "🏝️"
+                description = """**Description**: 
+    Thailand seamlessly fuses ancient traditions with modern dynamism, creating an unparalleled tapestry for travelers. 
+    Renowned for its warm hospitality, vibrant culture, and delectable cuisine, Thailand offers an unforgettable experience for every adventurer."""
+                top_places = """
 - **Bangkok**: Immerse yourself in the hustle and bustle of Bangkok's streets, adorned with glittering temples and bustling markets. The Grand Palace and Khao San Road showcase the city's unique blend of tradition and modernity.
 - **Chiang Mai**: Nestled in the misty mountains of Northern Thailand, Chiang Mai captivates with ancient temples, lush landscapes, and vibrant night markets. The Old City exudes a unique atmosphere, while the surrounding hills offer tranquility.
 - **Phuket**: Thailand's largest island, Phuket, beckons beach lovers with its stunning white sands, vibrant nightlife, and water activities. It's a perfect blend of relaxation and excitement."""
 
-        if country == "France":
-            image = "images/france.jpeg"
-            emoji = "⚜️"
-            description ="""**Description**:
-Indulge in the countries rich tapestry of art, culture, and gastronomy. 
-From the romantic allure of Paris to the sun-kissed vineyards of Provence, every corner of this diverse country tells a unique story, promising an unforgettable journey for every traveler."""
-            top_places = """ 
+            if country == "France":
+                image = "images/france.jpeg"
+                emoji = "⚜️"
+                description ="""**Description**:
+    Indulge in the countries rich tapestry of art, culture, and gastronomy. 
+    From the romantic allure of Paris to the sun-kissed vineyards of Provence, every corner of this diverse country tells a unique story, promising an unforgettable journey for every traveler."""
+                top_places = """ 
 - **Paris**: Dive into the city's iconic landmarks such as the Eiffel Tower, Louvre Museum, and Notre-Dame Cathedral grace the skyline.
 - **Provence**: Visit the stunning Palais des Papes in Avignon, explore the colorful markets of Aix-en-Provence, and unwind in the serene beauty of the Luberon region.
 - **Côte d'Azur**: This stunning stretch of the French coastline is a captivating blend of azure waters, picturesque landscapes and charming villages.
-"""
-
-        if country == "Spain":
-            image = "images/spain-banner.jpg"
-            emoji = "☀️"
-            description = """**Description**:
-Embark on an unforgettable journey where tradition and modernity coexist in harmony. 
-From the lively streets of Barcelona to the sun-soaked beaches of Andalusia, Spain offers a captivating blend of history, culture, and natural beauty.            
-"""
-            top_places = """
+    """
+
+            if country == "Spain":
+                image = "images/spain-banner.jpg"
+                emoji = "☀️"
+                description = """**Description**:
+    Embark on an unforgettable journey where tradition and modernity coexist in harmony. 
+    From the lively streets of Barcelona to the sun-soaked beaches of Andalusia, Spain offers a captivating blend of history, culture, and natural beauty.            
+    """
+                top_places = """
 - **Barcelona**: Explore the iconic Sagrada Familia, stroll down the vibrant La Rambla, and soak in the Mediterranean ambiance at Barceloneta Beach.
 - **Seville**: Visit the awe-inspiring Alcázar, marvel at the Giralda Tower, and wander through the enchanting alleys of the Santa Cruz neighborhood.
 - **Granada**: Explore the Generalife Gardens, stroll through the Albayzín quarter with its narrow streets and white houses, and savor the views of the city from the Mirador de San Nicolás.
-"""
+    """
 
-        if country == "Singapore":
-            image = "images/singapore.jpg"
-            emoji = "🏙️"
-            description = """**Description**:
-From gleaming skyscrapers to vibrant neighborhoods, this cosmopolitan gem in Southeast Asia promises an immersive journey into a world where tradition meets cutting-edge technology."""
+            if country == "Singapore":
+                image = "images/singapore.jpg"
+                emoji = "🏙️"
+                description = """**Description**:
+    From gleaming skyscrapers to vibrant neighborhoods, this cosmopolitan gem in Southeast Asia promises an immersive journey into a world where tradition meets cutting-edge technology."""
 
-            top_places = """
+                top_places = """
 - **Marina Bay Sands**: Enjoy panoramic views from the SkyPark, take a dip in the infinity pool, and explore The Shoppes for luxury shopping and entertainment. At night, witness the mesmerizing light and water show at the Marina Bay Sands Skypark.
 - **Gardens by the Bay**: Explore the Flower Dome and Cloud Forest conservatories, and stroll through the scenic OCBC Skyway for breathtaking views of the gardens and city.
 - **Sentosa Island**: Escape to Sentosa Island, a resort destination offering a myriad of attractions. Relax on pristine beaches, visit Universal Studios Singapore for thrilling rides, and explore S.E.A. Aquarium for an underwater adventure.
 
-"""
+    """
 
-        ###### STREAMLIT MARKDOWN ######
-        st.header(f"{country} {emoji}", divider="grey")
-        st.image(image)
-        st.markdown(description)
+            ###### STREAMLIT MARKDOWN ######
+            st.header(f"{country} {emoji}", divider="grey")
+            st.image(image)
+            st.markdown(description)
 
-        see_top_places = st.checkbox("**Top places to visit**", key={country})
-        if see_top_places:
-            st.markdown(top_places)
+            see_top_places = st.checkbox("**Top places to visit**", key={country})
+            if see_top_places:
+                st.markdown(top_places)
 
-    
-    
-    
-    st.markdown("""# Hotel Recommendation System 🛎️""")
+        
+        
+        
+        st.markdown("""# Hotel Recommendation System 🛎️""")
 
-    st.info("""This use case shows how you can create personalized hotel recommendations using a recommendation system with **content-based Filtering**. 
-                Analyzing location, amenities, price, and reviews, the model suggests tailored hotel recommendation based on the user's preference.
-    """)
-    st.markdown(" ")
+        st.info("""This use case shows how you can create personalized hotel recommendations using a recommendation system with **content-based Filtering**. 
+                    Analyzing location, amenities, price, and reviews, the model suggests tailored hotel recommendation based on the user's preference.
+        """)
+        st.markdown(" ")
 
 
-    path_hotels_data = r"data/hotels"
+        path_hotels_data = r"data/hotels"
 
-    # Load hotel data
-    df = load_data_csv(path_hotels_data,"booking_df.csv")
+        # Load hotel data
+        df = load_data_csv(path_hotels_data,"booking_df.csv")
 
-    # clean data
-    df.drop_duplicates(inplace=True)
-    df["Country"] = df["Country"].apply(lambda x: "Spain" if x=="Espagne" else x)
-    list_cities = df["City"].value_counts().to_frame().reset_index()
-    list_cities = list_cities.loc[list_cities["count"]>=5,"City"].to_numpy()
-    df = df.loc[(df["City"].isin(list_cities)) & (df["Number of bed"]<=6)]
-    df["Price"] = df["Price"].astype(int)
-    df.loc[(df["Number of bed"]==0) & (df["Price"]<1000),"Number of bed"] = 1
-    df.loc[(df["Number of bed"]==0) & (df["Price"].between(1000,2000)),"Number of bed"] = 2
-    df.loc[(df["Number of bed"]==0) & (df["Price"]>2000),"Number of bed"] = 3
+        # clean data
+        df.drop_duplicates(inplace=True)
+        df["Country"] = df["Country"].apply(lambda x: "Spain" if x=="Espagne" else x)
+        list_cities = df["City"].value_counts().to_frame().reset_index()
+        list_cities = list_cities.loc[list_cities["count"]>=5,"City"].to_numpy()
+        df = df.loc[(df["City"].isin(list_cities)) & (df["Number of bed"]<=6)]
+        df["Price"] = df["Price"].astype(int)
+        df.loc[(df["Number of bed"]==0) & (df["Price"]<1000),"Number of bed"] = 1
+        df.loc[(df["Number of bed"]==0) & (df["Price"].between(1000,2000)),"Number of bed"] = 2
+        df.loc[(df["Number of bed"]==0) & (df["Price"]>2000),"Number of bed"] = 3
 
-    df["Rating"] = df["Rating"].apply(lambda x: np.nan if x==0 else x)
-    df["Rating"].fillna(np.round(df["Rating"].mean(), 1), inplace=True)
+        df["Rating"] = df["Rating"].apply(lambda x: np.nan if x==0 else x)
+        df["Rating"].fillna(np.round(df["Rating"].mean(), 1), inplace=True)
 
-    scaler = get_scaler(df)
+        scaler = get_scaler(df)
 
 
-    col1, col2 = st.columns([0.3,0.7], gap="large")
+        col1, col2 = st.columns([0.3,0.7], gap="large")
 
-    with col1:
-        # Collect user preferences
-        st.markdown(" ")
-        st.markdown(" ")
-        st.markdown("")
-        #st.markdown("#### Filter preferences")
-        list_countries = df["Country"].unique()
-        location = st.selectbox("Select a Country",list_countries, index=0)
+        with col1:
+            # Collect user preferences
+            st.markdown(" ")
+            st.markdown(" ")
+            st.markdown("")
+            #st.markdown("#### Filter preferences")
+            list_countries = df["Country"].unique()
+            location = st.selectbox("Select a Country",list_countries, index=0)
 
-        list_nb_beds = df["Number of bed"].unique()
-        num_beds = st.selectbox("Number of beds", list_nb_beds, index=0)
-        #if num_beds == "No information"
+            list_nb_beds = df["Number of bed"].unique()
+            num_beds = st.selectbox("Number of beds", list_nb_beds, index=0)
+            #if num_beds == "No information"
 
-        min_rating, max_rating = st.slider("Range of ratings", min_value=df["Rating"].min(), max_value=df["Rating"].max(), step=0.1, value=(5.0, df["Rating"].max()))
-        min_price, max_price = st.slider("Range of room prices", min_value=df["Price"].min(), max_value=df["Price"].max(), step=10, value=(df["Price"].min(), 10000))
+            min_rating, max_rating = st.slider("Range of ratings", min_value=df["Rating"].min(), max_value=df["Rating"].max(), step=0.1, value=(5.0, df["Rating"].max()))
+            min_price, max_price = st.slider("Range of room prices", min_value=df["Price"].min(), max_value=df["Price"].max(), step=10, value=(df["Price"].min(), 10000))
 
-        # Convert price range sliders to integer values
-        min_price = int(min_price)
-        max_price = int(max_price)
+            # Convert price range sliders to integer values
+            min_price = int(min_price)
+            max_price = int(max_price)
 
-    with col2:
-        country_info(location)
+        with col2:
+            country_info(location)
 
 
-    preferences = {
-        'Location': location,
-        'Number of beds': num_beds,
-        'Rating': [min_rating, max_rating],
-        'Price': [min_price, max_price],
-    }
-            
+        preferences = {
+            'Location': location,
+            'Number of beds': num_beds,
+            'Rating': [min_rating, max_rating],
+            'Price': [min_price, max_price],
+        }
+                
 
-    if st.button("Recommend Hotels"):
-        st.info("Hotels were recommended based on how similar they were to the users preferences.")
-        
-        # Default number of recommendations to show
-        max_recommendations = 5
-        
-        # Call the recommendation function
-        recommended_hotels, message = recommend_hotels_with_location_and_beds(df, preferences, max_recommendations)
-        
-        # If no recommendations, reduce the maximum number of recommendations and try again
-        if recommended_hotels.empty:
-            max_recommendations -= 1
+        if st.button("Recommend Hotels"):
+            st.info("Hotels were recommended based on how similar they were to the users preferences.")
+            
+            # Default number of recommendations to show
+            max_recommendations = 5
+            
+            # Call the recommendation function
             recommended_hotels, message = recommend_hotels_with_location_and_beds(df, preferences, max_recommendations)
+            
+            # If no recommendations, reduce the maximum number of recommendations and try again
             if recommended_hotels.empty:
-                st.error(message)
-            # else:
-            #     st.write(recommended_hotels)
-        else:
-            st.markdown(" ")
-            for i in range(len(recommended_hotels)):
-                #st.dataframe(recommended_hotels)
-                df_result = recommended_hotels.iloc[i,:]                    
-                col1_, col2_ = st.columns([0.4,0.6], gap="medium")
-
-                with col1_:
-                    st.image("images/room.jpg",width=100)
-                    st.markdown(f"### {i+1}: {df_result['Hotel Name']}")
-                    st.markdown(f"""**{df_result['Room Type']}** <br>
-                                with {df_result['Bed Type']}
-                                """, unsafe_allow_html=True)
-                with col2_:
-                    st.markdown(" ")
-                    st.markdown(" ")
-                    annotated_text("**Number of beds :** ",(f"{df_result['Number of bed']}","","#faa"))
-                    #st.markdown(f"**Bed type**: {df_result['Bed Type']}")
-                    annotated_text("**City:** ",(f"{df_result['City']}","","#afa"))
-                    annotated_text("**Rating:** ",(f"{df_result['Rating']}","","#8ef"))
-                    annotated_text("**Price:** ",(f"{df_result['Price']}$","","#fea"))
-                
-                st.divider()
-                    
+                max_recommendations -= 1
+                recommended_hotels, message = recommend_hotels_with_location_and_beds(df, preferences, max_recommendations)
+                if recommended_hotels.empty:
+                    st.error(message)
+                # else:
+                #     st.write(recommended_hotels)
+            else:
+                st.markdown(" ")
+                for i in range(len(recommended_hotels)):
+                    #st.dataframe(recommended_hotels)
+                    df_result = recommended_hotels.iloc[i,:]                    
+                    col1_, col2_ = st.columns([0.4,0.6], gap="medium")
+
+                    with col1_:
+                        st.image("images/room.jpg",width=100)
+                        st.markdown(f"### {i+1}: {df_result['Hotel Name']}")
+                        st.markdown(f"""**{df_result['Room Type']}** <br>
+                                    with {df_result['Bed Type']}
+                                    """, unsafe_allow_html=True)
+                    with col2_:
+                        st.markdown(" ")
+                        st.markdown(" ")
+                        annotated_text("**Number of beds :** ",(f"{df_result['Number of bed']}","","#faa"))
+                        #st.markdown(f"**Bed type**: {df_result['Bed Type']}")
+                        annotated_text("**City:** ",(f"{df_result['City']}","","#afa"))
+                        annotated_text("**Rating:** ",(f"{df_result['Rating']}","","#8ef"))
+                        annotated_text("**Price:** ",(f"{df_result['Price']}$","","#fea"))
+                    
+                    st.divider()
+                        

pages/sentiment_analysis.py

@@ -10,7 +10,7 @@ import plotly.express as px
 from st_pages import add_indentation
 
 from pysentimiento import create_analyzer
-from utils import load_data_pickle
+from utils import load_data_pickle, check_password
 
 st.set_page_config(layout="wide")
 #add_indentation()
@@ -33,227 +33,226 @@ def load_sa_model():
 
 
 
-#st.image("images/sa_header.jpg")
-st.markdown("# Sentiment Analysis 👍")
+if check_password():
+    st.markdown("# Sentiment Analysis 👍")
+    st.markdown("### What is Sentiment Analysis ?")
 
-st.markdown("### What is Sentiment Analysis ?")
+    st.info("""
+        Sentiment analysis is a **Natural Language Processing** (NLP) task that involves determining the sentiment or emotion expressed in a piece of text. 
+        It has a wide range of use cases across various industries, as it helps organizations gain insights into the opinions, emotions, and attitudes expressed in text data.""")
 
-st.info("""
-    Sentiment analysis is a **Natural Language Processing** (NLP) task that involves determining the sentiment or emotion expressed in a piece of text. 
-    It has a wide range of use cases across various industries, as it helps organizations gain insights into the opinions, emotions, and attitudes expressed in text data.""")
+    st.markdown("Here is an example of Sentiment analysis used to analyze **Customer Satisfaction** for perfums.")
 
-st.markdown("Here is an example of Sentiment analysis used to analyze **Customer Satisfaction** for perfums.")
+    _, col, _ = st.columns([0.1,0.8,0.1])
+    with col:
+        st.image("images/sentiment_analysis.png") #, width=800)
 
-_, col, _ = st.columns([0.1,0.8,0.1])
-with col:
-    st.image("images/sentiment_analysis.png") #, width=800)
-
-st.markdown(" ")
-
-st.markdown("""
-Common applications of Natural Language Processing include:
-- **Customer Feedback and Reviews** 💯: Assessing reviews on products or services to understand customer satisfaction and identify areas for improvement.
-- **Market Research** 🔍: Analyzing survey responses or online forums to gauge public opinion on products, services, or emerging trends.
-- **Financial Market Analysis** 📉: Monitoring financial news, reports, and social media to gauge investor sentiment and predict market trends.
-- **Government and Public Policy** 📣: Analyzing public opinion on government policies, initiatives, and political decisions to gauge public sentiment and inform decision-making.        
-""")
-
-st.divider()
-
-#sa_pages = ["Starbucks Customer Reviews (Text)", "Tiktok's US Congressional Hearing (Audio)"]
-#st.markdown("### Select a use case ")
-#use_case = st.selectbox("", sa_pages, label_visibility="collapsed")
-
-
-st.markdown("# Customer Review Analysis 📝")
-st.info("""In this use case, **sentiment analysis** is used to predict the **polarity** (negative, neutral, positive) of customer reviews. 
-           You can try the application by using the provided starbucks customer reviews, or by writing your own.""") 
-st.markdown(" ")
-
-_, col, _ = st.columns([0.2,0.6,0.2])
-with col:
-    st.image("images/reviews.png",use_column_width=True)
+    st.markdown(" ")
 
-st.markdown(" ")
+    st.markdown("""
+    Common applications of Natural Language Processing include:
+    - **Customer Feedback and Reviews** 💯: Assessing reviews on products or services to understand customer satisfaction and identify areas for improvement.
+    - **Market Research** 🔍: Analyzing survey responses or online forums to gauge public opinion on products, services, or emerging trends.
+    - **Financial Market Analysis** 📉: Monitoring financial news, reports, and social media to gauge investor sentiment and predict market trends.
+    - **Government and Public Policy** 📣: Analyzing public opinion on government policies, initiatives, and political decisions to gauge public sentiment and inform decision-making.        
+    """)
 
+    st.divider()
 
-# Load data 
-path_sa = "data/sa_data"
-reviews_df = load_data_pickle(path_sa,"reviews_raw.pkl")
-reviews_df.reset_index(drop=True, inplace=True)
-reviews_df["Date"] = reviews_df["Date"].dt.date
-reviews_df["Year"] = reviews_df["Year"].astype(int)
+    #sa_pages = ["Starbucks Customer Reviews (Text)", "Tiktok's US Congressional Hearing (Audio)"]
+    #st.markdown("### Select a use case ")
+    #use_case = st.selectbox("", sa_pages, label_visibility="collapsed")
 
 
+    st.markdown("# Customer Review Analysis 📝")
+    st.info("""In this use case, **sentiment analysis** is used to predict the **polarity** (negative, neutral, positive) of customer reviews. 
+            You can try the application by using the provided starbucks customer reviews, or by writing your own.""") 
+    st.markdown(" ")
 
-st.markdown("#### Predict polarity 🤔")
-tab1_, tab2_ = st.tabs(["Starbucks reviews", "Write a review"])
+    _, col, _ = st.columns([0.2,0.6,0.2])
+    with col:
+        st.image("images/reviews.png",use_column_width=True)
 
-with tab1_:
-    # FILTER DATA
     st.markdown(" ")
 
-    col1, col2 = st.columns([0.2, 0.8], gap="medium")
 
-    with col1:
-        st.markdown("""<b>Filter reviews: </b> <br>
-                    You can filter the dataset by Date, State or Rating""", unsafe_allow_html=True)
-        
-        select_image_box = st.radio("",
-        ["Filter by Date (Year)", "Filter by State", "Filter by Rating", "No filters"],
-        index=3, label_visibility="collapsed")
-
-        if select_image_box == "Filter by Date (Year)":
-            selected_date = st.multiselect("Date (Year)", reviews_df["Year"].unique(), default=reviews_df["Year"].unique()[0])
-            reviews_df = reviews_df.loc[reviews_df["Year"].isin(selected_date)]
-
-        if select_image_box == "Filter by State":
-            selected_state = st.multiselect("State", reviews_df["State"].unique(), default=reviews_df["State"].unique()[0])
-            reviews_df = reviews_df.loc[reviews_df["State"].isin(selected_state)]
-
-        if select_image_box == "Filter by Rating":
-            selected_rating = st.multiselect("Rating", sorted(list(reviews_df["Rating"].dropna().unique())), 
-                                             default = sorted(list(reviews_df["Rating"].dropna().unique()))[0])
-            reviews_df = reviews_df.loc[reviews_df["Rating"].isin(selected_rating)]
-
-        if select_image_box == "No filters":
-            pass
-
-        #st.slider()
-        run_model1 = st.button("**Run the model**", type="primary", key="tab1")
-        st.info("The model has already been trained in this use case.")
-
-    with col2:
-    # VIEW DATA
-        st.markdown("""<b>View the reviews:</b> <br>
-                    The dataset contains the location (State), date, rating, text and images (if provided) for each review.""", 
-                    unsafe_allow_html=True)
-        
-        st.data_editor(
-            reviews_df.drop(columns=["Year"]), 
-            column_config={"Image 1": st.column_config.ImageColumn("Image 1"), 
-                            "Image 2": st.column_config.ImageColumn("Image 2")},
-            hide_index=True)
-        
+    # Load data 
+    path_sa = "data/sa_data"
+    reviews_df = load_data_pickle(path_sa,"reviews_raw.pkl")
+    reviews_df.reset_index(drop=True, inplace=True)
+    reviews_df["Date"] = reviews_df["Date"].dt.date
+    reviews_df["Year"] = reviews_df["Year"].astype(int)
 
-######### SHOW RESULTS ########
-    if run_model1:
-        with st.spinner('Wait for it...'):
-            df_results = load_data_pickle(path_sa,"reviews_results.pkl")
-            df_results.reset_index(drop=True, inplace=True)
 
-            index_row = np.array(reviews_df.index)
-            df_results = df_results.iloc[index_row].reset_index(drop=True)
-            df_results["Review"] = reviews_df["Review"]
-            st.markdown("  ")
 
-            st.markdown("#### See the results ☑️")
-            tab1, tab2, tab3 = st.tabs(["All results", "Results per state", "Results per year"])        
-            
-            with tab1: # Overall results (tab_1)
-                # get results df
-                df_results_tab1 = df_results[["ID","Review","Rating","Negative","Neutral","Positive","Result"]]
+    st.markdown("#### Predict polarity 🤔")
+    tab1_, tab2_ = st.tabs(["Starbucks reviews", "Write a review"])
 
-                # warning message
-                df_warning = df_results_tab1["Result"].value_counts().to_frame().reset_index()
-                df_warning["Percentage"] = (100*df_warning["count"]/df_warning["count"].sum()).round(2)
-                
-                perct_negative = df_warning.loc[df_warning["Result"]=="Negative","Percentage"].to_numpy()[0]
-                if perct_negative > 50:
-                    st.error(f"**Negative reviews alert** ⚠️: The proportion of negative reviews is {perct_negative}% !")
-
-                # show dataframe results
-                st.data_editor(
-                    df_results_tab1, #.loc[df_results_tab1["Customer ID"].isin(filter_customers)],
-                    column_config={
-                        "Negative": st.column_config.ProgressColumn(
-                            "Negative 👎",
-                            help="Negative score of the review",
-                            format="%d%%",
-                            min_value=0,
-                            max_value=100),
-                        "Neutral": st.column_config.ProgressColumn(
-                            "Neutral ✋",
-                            help="Neutral score of the review",
-                            format="%d%%",
-                            min_value=0,
-                            max_value=100),
-                        "Positive": st.column_config.ProgressColumn(
-                            "Positive 👍",
-                            help="Positive score of the review",
-                            format="%d%%",
-                            min_value=0,
-                            max_value=100)},
-                        hide_index=True,
-                )
-
-            with tab2: # Results by state (tab_1)
-                avg_state = df_results[["State","Negative","Neutral","Positive"]].groupby(["State"]).mean().round()
-                avg_state = avg_state.reset_index().melt(id_vars="State", var_name="Sentiment", value_name="Score (%)")
-
-                chart_state = alt.Chart(avg_state, title="Review polarity per state").mark_bar().encode(
-                    x=alt.X('Sentiment', axis=alt.Axis(title=None, labels=False, ticks=False)),
-                    y=alt.Y('Score (%)', axis=alt.Axis(grid=False)),
-                    color='Sentiment',
-                    column=alt.Column('State', header=alt.Header(title=None, labelOrient='bottom'))
-                ).configure_view(
-                    stroke='transparent'
-                ).interactive()
+    with tab1_:
+        # FILTER DATA
+        st.markdown(" ")
 
-                st.markdown(" ")
-                st.altair_chart(chart_state)
+        col1, col2 = st.columns([0.2, 0.8], gap="medium")
 
+        with col1:
+            st.markdown("""<b>Filter reviews: </b> <br>
+                        You can filter the dataset by Date, State or Rating""", unsafe_allow_html=True)
+            
+            select_image_box = st.radio("",
+            ["Filter by Date (Year)", "Filter by State", "Filter by Rating", "No filters"],
+            index=3, label_visibility="collapsed")
+
+            if select_image_box == "Filter by Date (Year)":
+                selected_date = st.multiselect("Date (Year)", reviews_df["Year"].unique(), default=reviews_df["Year"].unique()[0])
+                reviews_df = reviews_df.loc[reviews_df["Year"].isin(selected_date)]
+
+            if select_image_box == "Filter by State":
+                selected_state = st.multiselect("State", reviews_df["State"].unique(), default=reviews_df["State"].unique()[0])
+                reviews_df = reviews_df.loc[reviews_df["State"].isin(selected_state)]
+
+            if select_image_box == "Filter by Rating":
+                selected_rating = st.multiselect("Rating", sorted(list(reviews_df["Rating"].dropna().unique())), 
+                                                default = sorted(list(reviews_df["Rating"].dropna().unique()))[0])
+                reviews_df = reviews_df.loc[reviews_df["Rating"].isin(selected_rating)]
+
+            if select_image_box == "No filters":
+                pass
+
+            #st.slider()
+            run_model1 = st.button("**Run the model**", type="primary", key="tab1")
+            st.info("The model has already been trained in this use case.")
+
+        with col2:
+        # VIEW DATA
+            st.markdown("""<b>View the reviews:</b> <br>
+                        The dataset contains the location (State), date, rating, text and images (if provided) for each review.""", 
+                        unsafe_allow_html=True)
+            
+            st.data_editor(
+                reviews_df.drop(columns=["Year"]), 
+                column_config={"Image 1": st.column_config.ImageColumn("Image 1"), 
+                                "Image 2": st.column_config.ImageColumn("Image 2")},
+                hide_index=True)
+            
 
-            with tab3: # Results by year (tab_1)
-                avg_year = df_results[["Year","Negative","Neutral","Positive"]]
-                #avg_year["Year"] = avg_year["Year"].astype(str)
-                avg_year = avg_year.groupby(["Year"]).mean().round()
-                avg_year = avg_year.reset_index().melt(id_vars="Year", var_name="Sentiment", value_name="Score (%)")
+    ######### SHOW RESULTS ########
+        if run_model1:
+            with st.spinner('Wait for it...'):
+                df_results = load_data_pickle(path_sa,"reviews_results.pkl")
+                df_results.reset_index(drop=True, inplace=True)
 
-                chart_year = alt.Chart(avg_year, title="Evolution of review polarity").mark_area(opacity=0.5).encode(
-                    x='Year',
-                    y='Score (%)',
-                    color='Sentiment',
-                ).interactive()
+                index_row = np.array(reviews_df.index)
+                df_results = df_results.iloc[index_row].reset_index(drop=True)
+                df_results["Review"] = reviews_df["Review"]
+                st.markdown("  ")
 
-                st.markdown(" ")
-                st.altair_chart(chart_year, use_container_width=True)
-        
-        # else:
-        #     st.warning("You must select at least one review to run the model.")
-
-
-#### WRITE YOUR OWN REVIEW #####""
-with tab2_:
-    st.markdown("**Write your own review**")
-
-    txt_review = st.text_area(
-        "Write your review",
-        "I recently visited a local Starbucks, and unfortunately, my experience was far from satisfactory. "
-        "From the moment I stepped in, the atmosphere felt chaotic and disorganized. "
-        "The staff appeared overwhelmed, leading to a significant delay in receiving my order. "
-        "The quality of my drink further added to my disappointment. " 
-        "The coffee tasted burnt, as if it had been sitting on the burner for far too long.",
-        label_visibility="collapsed"
-        )
-    
-    run_model2 = st.button("**Run the model**", type="primary", key="tab2")
+                st.markdown("#### See the results ☑️")
+                tab1, tab2, tab3 = st.tabs(["All results", "Results per state", "Results per year"])        
+                
+                with tab1: # Overall results (tab_1)
+                    # get results df
+                    df_results_tab1 = df_results[["ID","Review","Rating","Negative","Neutral","Positive","Result"]]
+
+                    # warning message
+                    df_warning = df_results_tab1["Result"].value_counts().to_frame().reset_index()
+                    df_warning["Percentage"] = (100*df_warning["count"]/df_warning["count"].sum()).round(2)
+                    
+                    perct_negative = df_warning.loc[df_warning["Result"]=="Negative","Percentage"].to_numpy()[0]
+                    if perct_negative > 50:
+                        st.error(f"**Negative reviews alert** ⚠️: The proportion of negative reviews is {perct_negative}% !")
+
+                    # show dataframe results
+                    st.data_editor(
+                        df_results_tab1, #.loc[df_results_tab1["Customer ID"].isin(filter_customers)],
+                        column_config={
+                            "Negative": st.column_config.ProgressColumn(
+                                "Negative 👎",
+                                help="Negative score of the review",
+                                format="%d%%",
+                                min_value=0,
+                                max_value=100),
+                            "Neutral": st.column_config.ProgressColumn(
+                                "Neutral ✋",
+                                help="Neutral score of the review",
+                                format="%d%%",
+                                min_value=0,
+                                max_value=100),
+                            "Positive": st.column_config.ProgressColumn(
+                                "Positive 👍",
+                                help="Positive score of the review",
+                                format="%d%%",
+                                min_value=0,
+                                max_value=100)},
+                            hide_index=True,
+                    )
+
+                with tab2: # Results by state (tab_1)
+                    avg_state = df_results[["State","Negative","Neutral","Positive"]].groupby(["State"]).mean().round()
+                    avg_state = avg_state.reset_index().melt(id_vars="State", var_name="Sentiment", value_name="Score (%)")
+
+                    chart_state = alt.Chart(avg_state, title="Review polarity per state").mark_bar().encode(
+                        x=alt.X('Sentiment', axis=alt.Axis(title=None, labels=False, ticks=False)),
+                        y=alt.Y('Score (%)', axis=alt.Axis(grid=False)),
+                        color='Sentiment',
+                        column=alt.Column('State', header=alt.Header(title=None, labelOrient='bottom'))
+                    ).configure_view(
+                        stroke='transparent'
+                    ).interactive()
+
+                    st.markdown(" ")
+                    st.altair_chart(chart_state)
+
+
+                with tab3: # Results by year (tab_1)
+                    avg_year = df_results[["Year","Negative","Neutral","Positive"]]
+                    #avg_year["Year"] = avg_year["Year"].astype(str)
+                    avg_year = avg_year.groupby(["Year"]).mean().round()
+                    avg_year = avg_year.reset_index().melt(id_vars="Year", var_name="Sentiment", value_name="Score (%)")
+
+                    chart_year = alt.Chart(avg_year, title="Evolution of review polarity").mark_area(opacity=0.5).encode(
+                        x='Year',
+                        y='Score (%)',
+                        color='Sentiment',
+                    ).interactive()
+
+                    st.markdown(" ")
+                    st.altair_chart(chart_year, use_container_width=True)
+            
+            # else:
+            #     st.warning("You must select at least one review to run the model.")
+
+
+    #### WRITE YOUR OWN REVIEW #####""
+    with tab2_:
+        st.markdown("**Write your own review**")
+
+        txt_review = st.text_area(
+            "Write your review",
+            "I recently visited a local Starbucks, and unfortunately, my experience was far from satisfactory. "
+            "From the moment I stepped in, the atmosphere felt chaotic and disorganized. "
+            "The staff appeared overwhelmed, leading to a significant delay in receiving my order. "
+            "The quality of my drink further added to my disappointment. " 
+            "The coffee tasted burnt, as if it had been sitting on the burner for far too long.",
+            label_visibility="collapsed"
+            )
         
-    if run_model2:
-        with st.spinner('Wait for it...'):
-            #sentiment_analyzer = create_analyzer(task="sentiment", lang="en")
-            # Load model with cache
-            sentiment_analyzer = load_sa_model()
-            q = sentiment_analyzer.predict(txt_review)
-
-            df_review_user = pd.DataFrame({"Polarity":["Positive","Neutral","Negative"], 
-                        "Score":[q.probas['POS'], q.probas['NEU'], q.probas['NEG']]})
+        run_model2 = st.button("**Run the model**", type="primary", key="tab2")
             
-            st.markdown(" ")
-            st.info(f"""Your review was **{int(q.probas['POS']*100)}%** positive, **{int(q.probas['NEU']*100)}%** neutral 
-                    and **{int(q.probas['NEG']*100)}%** negative.""")
+        if run_model2:
+            with st.spinner('Wait for it...'):
+                #sentiment_analyzer = create_analyzer(task="sentiment", lang="en")
+                # Load model with cache
+                sentiment_analyzer = load_sa_model()
+                q = sentiment_analyzer.predict(txt_review)
+
+                df_review_user = pd.DataFrame({"Polarity":["Positive","Neutral","Negative"], 
+                            "Score":[q.probas['POS'], q.probas['NEU'], q.probas['NEG']]})
+                
+                st.markdown(" ")
+                st.info(f"""Your review was **{int(q.probas['POS']*100)}%** positive, **{int(q.probas['NEU']*100)}%** neutral 
+                        and **{int(q.probas['NEG']*100)}%** negative.""")
 
-            fig = px.bar(df_review_user, x='Score', y='Polarity', color="Polarity", title='Sentiment analysis results', orientation="h")
-            st.plotly_chart(fig, use_container_width=True)
+                fig = px.bar(df_review_user, x='Score', y='Polarity', color="Polarity", title='Sentiment analysis results', orientation="h")
+                st.plotly_chart(fig, use_container_width=True)
 
         

pages/supervised_unsupervised_page.py

@@ -6,9 +6,8 @@ import numpy as np
 import plotly.express as px
 from PIL import Image
 
-from utils import load_data_pickle, load_model_pickle
+from utils import load_data_pickle, load_model_pickle, check_password
 from st_pages import add_indentation
-from annotated_text import annotated_text
 
 #####################################################################################
 #                                    PAGE CONFIG
@@ -23,763 +22,763 @@ st.set_page_config(layout="wide")
 #                                    INTRO 
 #####################################################################################
 
-#st.image("images/ML_header.jpg", use_column_width=True)
-st.markdown("# Supervised vs Unsupervised Learning 🔍")
+if check_password():
+    st.markdown("# Supervised vs Unsupervised Learning 🔍")
 
-st.info("""Data Science models are often split into two categories: **Supervised** and **Unsupervised Learning**. 
-        The goal of this page is to present these two kinds of Data Science models, as well as give you multiple use cases to try them with.
-        Note that other kinds of AI models exist such as Reinforcement Learning or Federated Learning, which we won't cover in this app.""")
+    st.info("""Data Science models are often split into two categories: **Supervised** and **Unsupervised Learning**. 
+            The goal of this page is to present these two kinds of Data Science models, as well as give you multiple use cases to try them with.
+            Note that other kinds of AI models exist such as Reinforcement Learning or Federated Learning, which we won't cover in this app.""")
 
-st.markdown(" ")
-#st.markdown("## What are the differences between both ?")
+    st.markdown(" ")
+    #st.markdown("## What are the differences between both ?")
 
-col1, col2 = st.columns(2, gap="large")
+    col1, col2 = st.columns(2, gap="large")
 
-with col1: 
-    st.markdown("## Supervised Learning")
-    st.markdown("""Supervised learning models are trained by learning from **labeled data**. <br>
-                Labeled data provides to the model the desired output, which it will then use to learn relevant patterns and make predictions. 
+    with col1: 
+        st.markdown("## Supervised Learning")
+        st.markdown("""Supervised learning models are trained by learning from **labeled data**. <br>
+                    Labeled data provides to the model the desired output, which it will then use to learn relevant patterns and make predictions. 
 - A model is first **trained** to make predictions using labeled data, which doesn't contain the desired output.
 - The trained model can then be used to **predict values** for new data.
-                """, unsafe_allow_html=True)
-    st.markdown(" ")
-    st.image("images/supervised_learner.png", caption="An example of supervised learning")
+                    """, unsafe_allow_html=True)
+        st.markdown(" ")
+        st.image("images/supervised_learner.png", caption="An example of supervised learning")
 
-with col2:
-    st.markdown("## Unsupervised Learning")
-    st.markdown("""Unsupervised learning models learn the data's inherent structure without any explicit guidance on what to look for.
-                The algorithm will identify any naturally occurring patterns in the dataset using **unlabeled data**. 
+    with col2:
+        st.markdown("## Unsupervised Learning")
+        st.markdown("""Unsupervised learning models learn the data's inherent structure without any explicit guidance on what to look for.
+                    The algorithm will identify any naturally occurring patterns in the dataset using **unlabeled data**. 
 - They can be useful for applications where the goal is to discover **unknown groupings** in the data.
 - They are also used to identify unusual patterns or **outliers**.
-                """, unsafe_allow_html=True)
-    st.markdown(" ")
-    st.image("images/unsupervised_learning.png", caption="An example of unsupervised Learning", 
-                use_column_width=True)
+                    """, unsafe_allow_html=True)
+        st.markdown(" ")
+        st.image("images/unsupervised_learning.png", caption="An example of unsupervised Learning", 
+                    use_column_width=True)
 
-st.markdown("  ")
+    st.markdown("  ")
 
-learning_type = st.selectbox("**Select an AI task**", 
-                             ["Supervised Learning", 
-                           "Unsupervised Learning"])
+    learning_type = st.selectbox("**Select an AI task**", 
+                                ["Supervised Learning", 
+                            "Unsupervised Learning"])
 
 
 
 
 
-#######################################################################################################################
-#                                               SUPERVISED LEARNING
-#######################################################################################################################
+    #######################################################################################################################
+    #                                               SUPERVISED LEARNING
+    #######################################################################################################################
 
 
-if learning_type == "Supervised Learning":
-    sl_usecase = st.selectbox("**Choose a use case**", 
-                          ["Credit score classification 💯", 
-                           "Customer churn prediction ❌"])
-    
-    st.markdown(" ")
-    
-    # st.divider()
-    
-    path_data_supervised = r"data/classification"
-    path_pretrained_supervised = r"pretrained_models/supervised_learning"
-    
-    ################################# CREDIT SCORE ######################################
-    
-    if sl_usecase == "Credit score classification 💯":
-
-        path_credit = os.path.join(path_data_supervised,"credit_score")
-        
-        ## Description of the use case
-        st.divider()
-        st.markdown("# Credit score classification 💯")
-        st.info("""**Classification models** are supervised learning models whose goal is to categorize data into predefined categories. 
-                As opposed to unsupervised learning models, these categories are known beforehand.
-                Other types of supervised learning models include Regression models, which learn how to predict numerical values, instead of a set number of categories.""")
+    if learning_type == "Supervised Learning":
+        sl_usecase = st.selectbox("**Choose a use case**", 
+                            ["Credit score classification 💯", 
+                            "Customer churn prediction ❌"])
         
-        st.markdown("In this use case, we will build a **credit score classification model** which predicts whether a client has a 'Bad', 'Standard', or 'Good' credit score.")
         st.markdown(" ")
-
-        _, col, _ = st.columns([0.25,0.5,0.25])
-        with col:
-            st.image("images/credit_score.jpg")
-
-        ## Learn about the data
-        st.markdown("#### About the data 📋")
-        st.markdown("""To train the credit classification model, you were provided a **labeled** database with 7600 clients and containing bank and credit-related client information. <br> 
-                    This dataset is 'labeled' since it contains information on what we are trying to predict, which is the **Credit_Score** variable.""", 
-                    unsafe_allow_html=True)
         
-        ## Load data 
-        credit_train = load_data_pickle(path_credit, "credit_score_train_raw.pkl")
-        credit_test_pp = load_data_pickle(path_credit, "credit_score_test_pp.pkl")
-        labels = ["Good","Poor","Standard"]
-
-        ## Load model
-        credit_model = load_model_pickle(path_pretrained_supervised,"credit_score_model.pkl")
-
-        # View data
-        see_data = st.checkbox('**See the data**', key="credit_score\data")
-        if see_data:
-            st.warning("The data of only the first 30 clients are shown.") 
-            st.dataframe(credit_train.head(30).reset_index(drop=True))
-
-        learn_data = st.checkbox('**Learn more about the data**', key="credit_score_var")
-        if learn_data:
-            st.markdown("""
-- **Age**: The client's age
-- **Occupation**: The client's occupation/job
-- **Credit_Mix**: Score for the different type of credit accounts a client has (mortgages, loans, credit cards, ...)
-- **Payment_of_Min_Amount**: Whether the client is making the minimum required payments on their credit accounts (Yes, No, NM:Not mentioned)
-- **Annual_Income**: The client's annual income
-- **Num_Bank_Accounts**: Number of bank accounts opened 
-- **Num_Credit_Card**: Number of credit cards owned
-- **Interest_Rate**: The client's average interest rate 
-- **Num_of_Loan**: Number of loans of the client
-- **Changed_Credit_Limit**: Whether a client changed his credit limit once or not (Yes, No)                 - 
-- **Outstanding Debt**: A client's outstanding debt
-- **Credit_History_Age**: The length of a client's credit history (in months)
-""")
-            
-        st.markdown("  ")
-        st.markdown("  ")
-
-        ## Train the algorithm
-        st.markdown("#### Train the algorithm ⚙️")
-        st.info("""**Training** an AI model means feeding it data that contains multiple examples of clients with their credit scores. 
-                Using the labeled data provided, the model will **learn relationships** between a client's credit score and the other bank/credit-related variables provided.
-                Using these learned relationships, the model will then try to make **accurate predictions**.""")
+        # st.divider()
+        
+        path_data_supervised = r"data/classification"
+        path_pretrained_supervised = r"pretrained_models/supervised_learning"
+        
+        ################################# CREDIT SCORE ######################################
+        
+        if sl_usecase == "Credit score classification 💯":
 
-        # st.markdown("""Before feeding the model data for training, exploratory data analysis is often conducted to discover if patterns can discovered beforehand.""")            
-        # st.image("images/models/credit_score/EDA_numeric_credit.png")
-        #st.markdown("In our case, the training data is the dataset containing the bank and credit information of our 7600 customers.")
+            path_credit = os.path.join(path_data_supervised,"credit_score")
+            
+            ## Description of the use case
+            st.divider()
+            st.markdown("# Credit score classification 💯")
+            st.info("""**Classification models** are supervised learning models whose goal is to categorize data into predefined categories. 
+                    As opposed to unsupervised learning models, these categories are known beforehand.
+                    Other types of supervised learning models include Regression models, which learn how to predict numerical values, instead of a set number of categories.""")
+            
+            st.markdown("In this use case, we will build a **credit score classification model** which predicts whether a client has a 'Bad', 'Standard', or 'Good' credit score.")
+            st.markdown(" ")
 
-        if 'model_train' not in st.session_state:
-            st.session_state['model_train'] = False
+            _, col, _ = st.columns([0.25,0.5,0.25])
+            with col:
+                st.image("images/credit_score.jpg")
 
-        if st.session_state.model_train:
-            st.write("The model has been trained.")
-        else:
-            st.write("The model hasn't been trained yet")
+            ## Learn about the data
+            st.markdown("#### About the data 📋")
+            st.markdown("""To train the credit classification model, you were provided a **labeled** database with 7600 clients and containing bank and credit-related client information. <br> 
+                        This dataset is 'labeled' since it contains information on what we are trying to predict, which is the **Credit_Score** variable.""", 
+                        unsafe_allow_html=True)
+            
+            ## Load data 
+            credit_train = load_data_pickle(path_credit, "credit_score_train_raw.pkl")
+            credit_test_pp = load_data_pickle(path_credit, "credit_score_test_pp.pkl")
+            labels = ["Good","Poor","Standard"]
+
+            ## Load model
+            credit_model = load_model_pickle(path_pretrained_supervised,"credit_score_model.pkl")
+
+            # View data
+            see_data = st.checkbox('**See the data**', key="credit_score\data")
+            if see_data:
+                st.warning("The data of only the first 30 clients are shown.") 
+                st.dataframe(credit_train.head(30).reset_index(drop=True))
+
+            learn_data = st.checkbox('**Learn more about the data**', key="credit_score_var")
+            if learn_data:
+                st.markdown("""
+    - **Age**: The client's age
+    - **Occupation**: The client's occupation/job
+    - **Credit_Mix**: Score for the different type of credit accounts a client has (mortgages, loans, credit cards, ...)
+    - **Payment_of_Min_Amount**: Whether the client is making the minimum required payments on their credit accounts (Yes, No, NM:Not mentioned)
+    - **Annual_Income**: The client's annual income
+    - **Num_Bank_Accounts**: Number of bank accounts opened 
+    - **Num_Credit_Card**: Number of credit cards owned
+    - **Interest_Rate**: The client's average interest rate 
+    - **Num_of_Loan**: Number of loans of the client
+    - **Changed_Credit_Limit**: Whether a client changed his credit limit once or not (Yes, No)                 - 
+    - **Outstanding Debt**: A client's outstanding debt
+    - **Credit_History_Age**: The length of a client's credit history (in months)
+    """)
+                
+            st.markdown("  ")
+            st.markdown("  ")
 
-        run_credit_model = st.button("**Train the model**")
+            ## Train the algorithm
+            st.markdown("#### Train the algorithm ⚙️")
+            st.info("""**Training** an AI model means feeding it data that contains multiple examples of clients with their credit scores. 
+                    Using the labeled data provided, the model will **learn relationships** between a client's credit score and the other bank/credit-related variables provided.
+                    Using these learned relationships, the model will then try to make **accurate predictions**.""")
 
-        if run_credit_model:
-            st.session_state.model_train = 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_credit,"credit_score_cm_train")
-                    results_train = results_train.to_numpy()
-                    accuracy = np.round(results_train.diagonal()*100)
-                    df_accuracy = pd.DataFrame({"Credit Score":["Good","Poor","Standard"],
-                                                "Accuracy":accuracy})
+            # st.markdown("""Before feeding the model data for training, exploratory data analysis is often conducted to discover if patterns can discovered beforehand.""")            
+            # st.image("images/models/credit_score/EDA_numeric_credit.png")
+            #st.markdown("In our case, the training data is the dataset containing the bank and credit information of our 7600 customers.")
 
-                    st.markdown(" ")
-                    st.info("""**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 credit score model was measured by comparing clients' true credit scores with the scores predicted by the trained model.""")
+            if 'model_train' not in st.session_state:
+                st.session_state['model_train'] = False
 
-                    fig = px.bar(df_accuracy, y='Accuracy', x='Credit Score', color="Credit Score", title="Model performance")
-                    st.plotly_chart(fig, use_container_width=True)
+            if st.session_state.model_train:
+                st.write("The model has been trained.")
+            else:
+                st.write("The model hasn't been trained yet")
 
-                    st.markdown("""<i>The model's accuracy was measured for every type of credit score (Good, Standard, Poor).</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)
+            run_credit_model = st.button("**Train the model**")
 
+            if run_credit_model:
+                st.session_state.model_train = True
+                with st.spinner('Wait for it...'):
                     st.markdown(" ")
-
-                    st.markdown("""**Interpretation**: <br>
-                                Our model's is overall quite accurate in predicting all types of credit scores with an accuracy that is above 85% for each. 
-                                We do note that is slighly more accuracte in predicting a good credit score (92%) and less for a standard credit score (86%). 
-                                This can be due to the model having a harder time distinguishing between clients with a standard credit score and other more "extreme" credit scores (Good, Bad).
-                                """, unsafe_allow_html=True)
-                    
-                ##### MODEL EXPLAINABILITY
-                with tab2:
                     st.markdown(" ")
-                    st.info("""**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.""")
-                    
-                    # Create feature importance dataframe
-                    df_var_importance = pd.DataFrame({"variable":credit_test_pp.columns,
-                                                    "score":credit_model.feature_importances_})
+                    time.sleep(2)
+                    st.markdown("#### See the results ☑️")
+                    tab1, tab2 = st.tabs(["Performance", "Explainability"])
                     
-                    # Compute average score for categorical variables
-                    for column in ["Occupation","Credit_Mix","Payment_of_Min_Amount"]:
-                        col_remove = [col for col in credit_test_pp.columns if f"{column}_" in col]
-                        avg_score = df_var_importance.loc[df_var_importance["variable"].isin(col_remove)]["score"].mean()
+                    ######## MODEL PERFORMANCE 
+                    with tab1:
+                        results_train = load_data_pickle(path_credit,"credit_score_cm_train")
+                        results_train = results_train.to_numpy()
+                        accuracy = np.round(results_train.diagonal()*100)
+                        df_accuracy = pd.DataFrame({"Credit Score":["Good","Poor","Standard"],
+                                                    "Accuracy":accuracy})
+
+                        st.markdown(" ")
+                        st.info("""**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 credit score model was measured by comparing clients' true credit scores with the scores predicted by the trained model.""")
+
+                        fig = px.bar(df_accuracy, y='Accuracy', x='Credit Score', color="Credit Score", title="Model performance")
+                        st.plotly_chart(fig, use_container_width=True)
+
+                        st.markdown("""<i>The model's accuracy was measured for every type of credit score (Good, Standard, Poor).</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>
+                                    Our model's is overall quite accurate in predicting all types of credit scores with an accuracy that is above 85% for each. 
+                                    We do note that is slighly more accuracte in predicting a good credit score (92%) and less for a standard credit score (86%). 
+                                    This can be due to the model having a harder time distinguishing between clients with a standard credit score and other more "extreme" credit scores (Good, Bad).
+                                    """, unsafe_allow_html=True)
                         
-                        df_var_importance = df_var_importance.loc[~df_var_importance["variable"].isin(col_remove)]                    
-                        new_row = pd.DataFrame([[column, avg_score]], columns=["variable","score"])
-                        df_var_importance = pd.concat([df_var_importance, new_row], ignore_index=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)
+                    ##### MODEL EXPLAINABILITY
+                    with tab2:
+                        st.markdown(" ")
+                        st.info("""**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.""")
+                        
+                        # Create feature importance dataframe
+                        df_var_importance = pd.DataFrame({"variable":credit_test_pp.columns,
+                                                        "score":credit_model.feature_importances_})
+                        
+                        # Compute average score for categorical variables
+                        for column in ["Occupation","Credit_Mix","Payment_of_Min_Amount"]:
+                            col_remove = [col for col in credit_test_pp.columns if f"{column}_" in col]
+                            avg_score = df_var_importance.loc[df_var_importance["variable"].isin(col_remove)]["score"].mean()
+                            
+                            df_var_importance = df_var_importance.loc[~df_var_importance["variable"].isin(col_remove)]                    
+                            new_row = pd.DataFrame([[column, avg_score]], columns=["variable","score"])
+                            df_var_importance = pd.concat([df_var_importance, new_row], ignore_index=True)
+                        
+                        df_var_importance.sort_values(by=["score"], inplace=True)
+                        df_var_importance["score"] = df_var_importance["score"].round(3)                
 
-                    st.markdown("""<b>Interpretation</b>: <br>
-                                A client's outstanding debt, interest rate and delay from due date were the most crucial factors in explaining their final credit score. <br>
-                                Whether a client is making their minimum required payments on their credit accounts (Payment_min_amount), their occupation and their number of loans had a very limited impact on their credit score.,
-                                """, unsafe_allow_html=True)
-                    
+                        # 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(" ")
-        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("  ")
-        
-        col1, col2 = st.columns([0.25,0.75], gap="medium")
-        
-        credit_test = load_data_pickle(path_credit,"credit_score_test_raw.pkl")
-        credit_test.reset_index(drop=True, inplace=True)
-        credit_test.insert(0, "Client ID", [f"{i}" for i in range(credit_test.shape[0])])
-        credit_test = credit_test.loc[credit_test["Num_Bank_Accounts"]>0]
-        #credit_test.drop(columns=["Credit_Score"], inplace=True)
-        
-        with col1:
-            st.markdown("""<b>Filter the data</b> <br>
-            You can select clients based on their *Age*, *Annual income* or *Oustanding Debt*.""", 
-            unsafe_allow_html=True)
-
-            select_image_box = st.radio(" ",
-            ["Filter by Age", "Filter by Income", "Filter by Outstanding Debt", "No filters"],
-            label_visibility="collapsed")
+                        st.markdown("""<b>Interpretation</b>: <br>
+                                    A client's outstanding debt, interest rate and delay from due date were the most crucial factors in explaining their final credit score. <br>
+                                    Whether a client is making their minimum required payments on their credit accounts (Payment_min_amount), their occupation and their number of loans had a very limited impact on their credit score.,
+                                    """, unsafe_allow_html=True)
+                        
 
-            if select_image_box == "Filter by Age":
-                st.markdown(" ")
-                min_age, max_age = st.slider('Select a range', credit_test["Age"].astype(int).min(), credit_test["Age"].astype(int).max(), (19,50), 
-                                             key="age", label_visibility="collapsed")
-                credit_test = credit_test.loc[credit_test["Age"].between(min_age,max_age)]
+            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("  ")
+            
+            col1, col2 = st.columns([0.25,0.75], gap="medium")
+            
+            credit_test = load_data_pickle(path_credit,"credit_score_test_raw.pkl")
+            credit_test.reset_index(drop=True, inplace=True)
+            credit_test.insert(0, "Client ID", [f"{i}" for i in range(credit_test.shape[0])])
+            credit_test = credit_test.loc[credit_test["Num_Bank_Accounts"]>0]
+            #credit_test.drop(columns=["Credit_Score"], inplace=True)
+            
+            with col1:
+                st.markdown("""<b>Filter the data</b> <br>
+                You can select clients based on their *Age*, *Annual income* or *Oustanding Debt*.""", 
+                unsafe_allow_html=True)
 
-            if select_image_box == "Filter by Income":
-                st.markdown(" ")
-                min_income, max_income = st.slider('Select a range', credit_test["Annual_Income"].astype(int).min(), 180000, 
-                                                   (7000, 100000), label_visibility="collapsed", key="income")
-                credit_test = credit_test.loc[credit_test["Annual_Income"].between(min_income, max_income)]
+                select_image_box = st.radio(" ",
+                ["Filter by Age", "Filter by Income", "Filter by Outstanding Debt", "No filters"],
+                label_visibility="collapsed")
 
-            if select_image_box == "Filter by Outstanding Debt":
-                min_debt, max_debt = st.slider('Select a range', credit_test["Outstanding_Debt"].astype(int).min(), credit_test["Outstanding_Debt"].astype(int).max(), 
-                                                (0,2000), label_visibility="collapsed", key="debt")
-                credit_test = credit_test.loc[credit_test["Outstanding_Debt"].between(min_debt, max_debt)]
+                if select_image_box == "Filter by Age":
+                    st.markdown(" ")
+                    min_age, max_age = st.slider('Select a range', credit_test["Age"].astype(int).min(), credit_test["Age"].astype(int).max(), (19,50), 
+                                                key="age", label_visibility="collapsed")
+                    credit_test = credit_test.loc[credit_test["Age"].between(min_age,max_age)]
 
-            if select_image_box == "No filters":
-                pass
+                if select_image_box == "Filter by Income":
+                    st.markdown(" ")
+                    min_income, max_income = st.slider('Select a range', credit_test["Annual_Income"].astype(int).min(), 180000, 
+                                                    (7000, 100000), label_visibility="collapsed", key="income")
+                    credit_test = credit_test.loc[credit_test["Annual_Income"].between(min_income, max_income)]
 
-        st.markdown(" ")
-        st.markdown("""<b>Select a threshold for the alert</b> <br>
-                    A warning message will be displayed if the percentage of poor credit scores 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")
+                if select_image_box == "Filter by Outstanding Debt":
+                    min_debt, max_debt = st.slider('Select a range', credit_test["Outstanding_Debt"].astype(int).min(), credit_test["Outstanding_Debt"].astype(int).max(), 
+                                                    (0,2000), label_visibility="collapsed", key="debt")
+                    credit_test = credit_test.loc[credit_test["Outstanding_Debt"].between(min_debt, max_debt)]
 
-        st.markdown(" ")
-        st.write("The threshold is at", warning_threshold, "%")
-            
+                if select_image_box == "No filters":
+                    pass
 
-        with col2:
-            #st.markdown("**View the database**")
-            st.dataframe(credit_test)
-        
-        make_predictions = st.button("**Make predictions**")
-        st.markdown(" ")
+            st.markdown(" ")
+            st.markdown("""<b>Select a threshold for the alert</b> <br>
+                        A warning message will be displayed if the percentage of poor credit scores 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")
 
-        if make_predictions:
-            if st.session_state.model_train is True:
-                X_test = credit_test_pp.iloc[credit_test.index,:]
-                predictions = credit_model.predict(X_test)
-                
-                df_results_pred = credit_test.copy()
-                df_results_pred["Credit Score"] = predictions
-                df_mean_pred = df_results_pred["Credit Score"].value_counts().to_frame().reset_index()
-                df_mean_pred.columns = ["Credit Score", "Proportion"]
-                df_mean_pred["Proportion"] = (100*df_mean_pred["Proportion"]/df_results_pred.shape[0]).round()
+            st.markdown(" ")
+            st.write("The threshold is at", warning_threshold, "%")
                 
-                perct_bad_score = df_mean_pred.loc[df_mean_pred["Credit Score"]=="Poor"]["Proportion"].to_numpy()
 
-                if perct_bad_score >= warning_threshold:
-                    st.error(f"The proportion of clients with a bad credit score is above {warning_threshold}% (at {perct_bad_score[0]}%)⚠️")
+            with col2:
+                #st.markdown("**View the database**")
+                st.dataframe(credit_test)
+            
+            make_predictions = st.button("**Make predictions**")
+            st.markdown(" ")
 
-                col1, col2 = st.columns([0.4,0.6], gap="large")
-                with col1:
-                    st.markdown("**Proporition of predicted credit scores**")
-                    fig = px.pie(df_mean_pred, values='Proportion', names='Credit Score')
-                                        #title="Proportion of credit scores")
-                    st.plotly_chart(fig, use_container_width=True)
-                
-                with col2:
-                    df_show_results = df_results_pred[["Credit Score","Client ID"] + [col for col in df_results_pred.columns if col not in ["Client ID","Credit Score"]]]                    
-                    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 == "Good":
-                            color = 'red'
-                        if val == 'Standard':
-                            color= "cornflowerblue"
-                        if val == "Poor":
-                            color = 'blue'
-                        return f'color: {color}'
+            if make_predictions:
+                if st.session_state.model_train is True:
+                    X_test = credit_test_pp.iloc[credit_test.index,:]
+                    predictions = credit_model.predict(X_test)
                     
-                    df_show_results_color = df_show_results.style.applymap(highlight_score, subset=['Credit Score'])
+                    df_results_pred = credit_test.copy()
+                    df_results_pred["Credit Score"] = predictions
+                    df_mean_pred = df_results_pred["Credit Score"].value_counts().to_frame().reset_index()
+                    df_mean_pred.columns = ["Credit Score", "Proportion"]
+                    df_mean_pred["Proportion"] = (100*df_mean_pred["Proportion"]/df_results_pred.shape[0]).round()
                     
-                    st.markdown("**Overall results**")
-                    st.dataframe(df_show_results_color)
-
-            else:
-                st.error("You have to train the credit score model first.")
-
+                    perct_bad_score = df_mean_pred.loc[df_mean_pred["Credit Score"]=="Poor"]["Proportion"].to_numpy()
 
+                    if perct_bad_score >= warning_threshold:
+                        st.error(f"The proportion of clients with a bad credit score is above {warning_threshold}% (at {perct_bad_score[0]}%)⚠️")
 
+                    col1, col2 = st.columns([0.4,0.6], gap="large")
+                    with col1:
+                        st.markdown("**Proporition of predicted credit scores**")
+                        fig = px.pie(df_mean_pred, values='Proportion', names='Credit Score')
+                                            #title="Proportion of credit scores")
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+                    with col2:
+                        df_show_results = df_results_pred[["Credit Score","Client ID"] + [col for col in df_results_pred.columns if col not in ["Client ID","Credit Score"]]]                    
+                        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 == "Good":
+                                color = 'red'
+                            if val == 'Standard':
+                                color= "cornflowerblue"
+                            if val == "Poor":
+                                color = 'blue'
+                            return f'color: {color}'
+                        
+                        df_show_results_color = df_show_results.style.applymap(highlight_score, subset=['Credit Score'])
+                        
+                        st.markdown("**Overall results**")
+                        st.dataframe(df_show_results_color)
 
+                else:
+                    st.error("You have to train the credit score model first.")
 
 
-    ################################# CUSTOMER CHURN #####################################
-        
-    elif sl_usecase == "Customer churn prediction ❌":
-        #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 models** are supervised learning models whose goal is to categorize data into predefined categories. 
-                As opposed to unsupervised learning models, these categories are known beforehand.
-                Other types of supervised learning models include Regression models, which learn how to predict numerical values, instead of a set number of categories.""")
-
-        st.markdown("For this use case, we will build a **customer churn classification model** that can predict whether a person will stop being a customer 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 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, account information 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)
+        ################################# CUSTOMER CHURN #####################################
             
-        st.markdown("  ")
-        st.markdown("  ")
+        elif sl_usecase == "Customer churn prediction ❌":
+            #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 ❌")
 
-        ## 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.")
+            st.info("""**Classification models** are supervised learning models whose goal is to categorize data into predefined categories. 
+                    As opposed to unsupervised learning models, these categories are known beforehand.
+                    Other types of supervised learning models include Regression models, which learn how to predict numerical values, instead of a set number of categories.""")
 
-        see_EDA = st.checkbox('**View the analysis**', key="churn-EDA")
-        if see_EDA:
-            st.markdown(" ")
+            st.markdown("For this use case, we will build a **customer churn classification model** that can predict whether a person will stop being a customer using historical data.")
 
-            # 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)
+            ## Load data 
+            churn_data = load_data_pickle(path_churn, "churn_train_raw.pkl") 
             
-            st.markdown(" ")
+            _, col, _ = st.columns([0.1,0.8,0.1])
+            with col:
+                st.image("images/customer-churn.png", use_column_width=True)
             
-            # 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(""" """)
+            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.")        
+            ## Learn about the data
+            st.markdown("#### About the data 📋")
+            st.markdown("""To train the customer churn 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, account information 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("  ")
 
-        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**")
+            ## 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(" ")
 
-        if run_churn_model:
-            st.session_state.model_train_churn = True
-            with st.spinner('Wait for it...'):
+                # 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(" ")
-                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})
+                # 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.""")
                     
-                    df_accuracy["Accuracy"] = np.round(df_accuracy["Accuracy"]/100)
+            
+
+            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.")        
                     
-                    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)
+            if 'model_train_churn' not in st.session_state:
+                st.session_state['model_train_churn'] = False
 
-                    # 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)
+            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")
 
-                    st.markdown(" ")
+            run_churn_model = st.button("**Train the model**")
 
-                    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:
+
+            if run_churn_model:
+                st.session_state.model_train_churn = True
+                with st.spinner('Wait for it...'):
                     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(" ")
+                    time.sleep(2)
+                    st.markdown("#### See the results ☑️")
+                    tab1, tab2 = st.tabs(["Performance", "Explainability"])
                     
-        st.markdown(" ") 
-        st.markdown(" ")                
+                    ######## 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.""")
 
-        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.")
+                        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(" ")
+                        # 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)
 
-        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])])
+                        st.markdown(" ")
 
-        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)
+                        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(" ")                
 
-            select_image_box = st.radio(" ",
-            ["Filter by Tenure", "Filter by Total Charges", "Filter by Contract", "No filters"],
-            label_visibility="collapsed")
+            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.")
 
-            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)]
+            st.markdown(" ")
 
-            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)]
+            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])])
 
-            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]
+            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)
 
-            if select_image_box == "No filters":
-                pass
+                select_image_box = st.radio(" ",
+                ["Filter by Tenure", "Filter by Total Charges", "Filter by Contract", "No filters"],
+                label_visibility="collapsed")
 
-        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, "%")
-            
+                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)]
 
-        with col2:
-            #st.markdown("**View the database**")
-            st.dataframe(churn_test)
+                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]
 
-        # Button to make predictions
-        make_predictions = st.button("**Make predictions**")
-        st.markdown(" ")
+                if select_image_box == "No filters":
+                    pass
 
-        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")
+            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")
 
-                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]
+            st.markdown(" ")
+            st.write("The threshold is at", warning_threshold, "%")
                 
-                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()
+            with col2:
+                #st.markdown("**View the database**")
+                st.dataframe(churn_test)
 
-                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(" ")
+            # Button to make predictions
+            make_predictions = st.button("**Make predictions**")
+            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'])
+            if make_predictions:
+                if st.session_state.model_train_churn is True:            
                     
-                    st.markdown("**Overall results**")
-                    st.dataframe(df_show_results_color)
+                    ## 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")
 
-            else:
-                st.error("You have to train the credit score model first.")
+                    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.")
 
-#######################################################################################################################
-#                                           UNSUPERVISED LEARNING
-#######################################################################################################################
 
 
-def markdown_general_info(df):
-    text = st.markdown(f"""
-- **Age**: {int(np.round(df.Age))}
-- **Yearly income**: {int(df.Income)} $
-- **Number of kids**: {df.Kids}
-- **Days of enrollment**: {int(np.round(df.Days_subscription))}
-- **Web visits per month**: {df.WebVisitsMonth}    
-""")   
-    return text
 
 
 
-if learning_type == "Unsupervised Learning":
-    usl_usecase = st.selectbox("**Choose a use case**", 
-                          ["Customer segmentation (clustering) 🧑‍🤝‍🧑"])
-    
+    #######################################################################################################################
+    #                                           UNSUPERVISED LEARNING
+    #######################################################################################################################
 
-    #################################### CUSTOMER SEGMENTATION ##################################
 
-    path_clustering = r"data/clustering"
-    path_clustering_results = r"data/clustering/results"
+    def markdown_general_info(df):
+        text = st.markdown(f"""
+    - **Age**: {int(np.round(df.Age))}
+    - **Yearly income**: {int(df.Income)} $
+    - **Number of kids**: {df.Kids}
+    - **Days of enrollment**: {int(np.round(df.Days_subscription))}
+    - **Web visits per month**: {df.WebVisitsMonth}    
+    """)   
+        return text
 
-    if usl_usecase == "Customer segmentation (clustering) 🧑‍🤝‍🧑":
 
-        # st.divider()
-        st.divider()
-        st.markdown("# Customer Segmentation (clustering) 🧑‍🤝‍🧑")
 
-        st.markdown("""In this use case, we will use a clustering model, a type of Unsupervised Learning model, to perform **Customer Segmentation**. <br>
-                    Our model will allow similar groups of clients to be identified within company's consumer database based on consumer habits and caracteristics. 
-        """, unsafe_allow_html=True)
+    if learning_type == "Unsupervised Learning":
+        usl_usecase = st.selectbox("**Choose a use case**", 
+                            ["Customer segmentation (clustering) 🧑‍🤝‍🧑"])
         
-        st.markdown("  ")
-
-        ## Show image
-        _, col, _ = st.columns([0.2,0.5,0.3])
-        with col:
-            st.image("images/cs.webp")
-
-        ## 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 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")
-
-        if see_data:
-            customer_data = load_data_pickle(path_clustering, "clean_marketing.pkl") 
-            st.dataframe(customer_data.head(10))
-
-        learn_data = st.checkbox('**Learn more about the variables**', key="variable")
-
-        if learn_data:
-            st.markdown("""
-        - **Age**: Customer's age
-        - **Income**: Customer's yearly household income
-        - **Kids**: Number of children/teenagers in customer's household
-        - **Days_subscription**: Number of days since a customer's enrollment with the company
-        - **Recency**: Number of days since customer's last purchase
-        - **Wines**: Proportion of money spent on wine in last 2 years
-        - **Fruits**: Proportion of money spent on fruits in last 2 years
-        - **MeatProducts**: Proportion of money spent on meat in last 2 years
-        - **FishProducts**: Proportion of money spent on fish in last 2 years
-        - **SweetProducts**: Proportion of money spent sweets in last 2 years
-        - **DealsPurchases**: Proportion of purchases made with a discount
-        - **WebPurchases**: Proportion of purchases made through the company’s website
-        - **CatalogPurchases**: Proporition of purchases made using a catalogue
-        - **StorePurchases**: Proportion of purchases made directly in stores
-        - **WebVisitsMonth**: Proportion of visits to company’s website in the last month""")
+
+        #################################### CUSTOMER SEGMENTATION ##################################
+
+        path_clustering = r"data/clustering"
+        path_clustering_results = r"data/clustering/results"
+
+        if usl_usecase == "Customer segmentation (clustering) 🧑‍🤝‍🧑":
+
+            # st.divider()
             st.divider()
+            st.markdown("# Customer Segmentation (clustering) 🧑‍🤝‍🧑")
 
+            st.markdown("""In this use case, we will use a clustering model, a type of Unsupervised Learning model, to perform **Customer Segmentation**. <br>
+                        Our model will allow similar groups of clients to be identified within company's consumer database based on consumer habits and caracteristics. 
+            """, unsafe_allow_html=True)
+            
+            st.markdown("  ")
+
+            ## Show image
+            _, col, _ = st.columns([0.2,0.5,0.3])
+            with col:
+                st.image("images/cs.webp")
+
+            ## 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 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")
+
+            if see_data:
+                customer_data = load_data_pickle(path_clustering, "clean_marketing.pkl") 
+                st.dataframe(customer_data.head(10))
+
+            learn_data = st.checkbox('**Learn more about the variables**', key="variable")
+
+            if learn_data:
+                st.markdown("""
+            - **Age**: Customer's age
+            - **Income**: Customer's yearly household income
+            - **Kids**: Number of children/teenagers in customer's household
+            - **Days_subscription**: Number of days since a customer's enrollment with the company
+            - **Recency**: Number of days since customer's last purchase
+            - **Wines**: Proportion of money spent on wine in last 2 years
+            - **Fruits**: Proportion of money spent on fruits in last 2 years
+            - **MeatProducts**: Proportion of money spent on meat in last 2 years
+            - **FishProducts**: Proportion of money spent on fish in last 2 years
+            - **SweetProducts**: Proportion of money spent sweets in last 2 years
+            - **DealsPurchases**: Proportion of purchases made with a discount
+            - **WebPurchases**: Proportion of purchases made through the company’s website
+            - **CatalogPurchases**: Proporition of purchases made using a catalogue
+            - **StorePurchases**: Proportion of purchases made directly in stores
+            - **WebVisitsMonth**: Proportion of visits to company’s website in the last month""")
+                st.divider()
 
-        st.markdown(" ")
-        st.markdown(" ")
 
-        st.markdown("#### Clustering algorithm ⚙️")
+            st.markdown(" ")
+            st.markdown(" ")
 
-        st.info("""**Clustering** is a type of unsupervised learning method that learns how to group similar data points together into "clusters", without needing supervision. 
-                    In our case, a data points represents a customer that will be assigned to an unknown group.""")
-        
-#         st.markdown(""" 
-# - The clustering algorithm used in this use case allows a specific number of groups to be identified, which isn't the case for all clustering models.""")
+            st.markdown("#### Clustering algorithm ⚙️")
 
-        st.markdown(" ")
-        st.markdown("Here is an example of grouped data using a clustering model.")
-        st.image("images/clustering.webp")
-
-        st.warning("**Note**: The number of clusters chosen by the user can have a strong impact on the quality of the segmentation. Try to run the model multiple times with different number of clusters and see which number leads to groups with more distinct customer behaviors/preferences.")                    
-
-        nb_groups = st.selectbox("Choose a number of customer groups to identify", np.arange(2,6))
-        df_results = load_data_pickle(path_clustering_results, f"results_{nb_groups}_clusters.pkl")
-
-        st.markdown("  ")
-        run_model = st.button("**Run the model**")
-        #tab1, tab2 = st.tabs(["Results per product type", "Results per channel"])
-        #st.divider()
-
-        if run_model:
-            cols_group = st.columns(int(nb_groups))
-            for nb in range(nb_groups):
-                df_nb = df_results[nb]
-
-                col1, col2 = st.columns([0.3,0.7])
-                with col1:
-                    st.image("images/group.png", width=200)
-                    st.header(f"Group {nb+1}", divider="grey")
-                    markdown_general_info(df_nb)
-
-                with col2:
-                    tab1, tab2 = st.tabs(["Results per product type", "Results per channel"])
-                    list_product_col = [col for col in list(df_nb.index) if "Products" in col]
-                    df_products = df_nb.reset_index()
-                    df_products = df_products.loc[df_products["variable"].isin(list_product_col)]
-                    df_products.columns = ["variables", "values"]
-                    
-                    with tab1:
-                        fig = px.pie(df_products, values='values', names='variables', 
-                                        title="Amount spent per product type (in %)")
-                        st.plotly_chart(fig, width=300)
-
-                    list_purchases_col = [col for col in list(df_nb.index) if "Purchases" in col]
-                    df_products = df_nb.reset_index()
-                    df_products = df_products.loc[df_products["variable"].isin(list_purchases_col)]
-                    df_products.columns = ["variables", "values"]
-                    
-                    with tab2:
-                        fig = px.pie(df_products, values='values', names='variables', 
-                                    title='Proportion of purchases made per channel (in %)')
-                        st.plotly_chart(fig, width=300)
+            st.info("""**Clustering** is a type of unsupervised learning method that learns how to group similar data points together into "clusters", without needing supervision. 
+                        In our case, a data points represents a customer that will be assigned to an unknown group.""")
+            
+    #         st.markdown(""" 
+    # - The clustering algorithm used in this use case allows a specific number of groups to be identified, which isn't the case for all clustering models.""")
+
+            st.markdown(" ")
+            st.markdown("Here is an example of grouped data using a clustering model.")
+            st.image("images/clustering.webp")
+
+            st.warning("**Note**: The number of clusters chosen by the user can have a strong impact on the quality of the segmentation. Try to run the model multiple times with different number of clusters and see which number leads to groups with more distinct customer behaviors/preferences.")                    
+
+            nb_groups = st.selectbox("Choose a number of customer groups to identify", np.arange(2,6))
+            df_results = load_data_pickle(path_clustering_results, f"results_{nb_groups}_clusters.pkl")
+
+            st.markdown("  ")
+            run_model = st.button("**Run the model**")
+            #tab1, tab2 = st.tabs(["Results per product type", "Results per channel"])
+            #st.divider()
+
+            if run_model:
+                cols_group = st.columns(int(nb_groups))
+                for nb in range(nb_groups):
+                    df_nb = df_results[nb]
+
+                    col1, col2 = st.columns([0.3,0.7])
+                    with col1:
+                        st.image("images/group.png", width=200)
+                        st.header(f"Group {nb+1}", divider="grey")
+                        markdown_general_info(df_nb)
+
+                    with col2:
+                        tab1, tab2 = st.tabs(["Results per product type", "Results per channel"])
+                        list_product_col = [col for col in list(df_nb.index) if "Products" in col]
+                        df_products = df_nb.reset_index()
+                        df_products = df_products.loc[df_products["variable"].isin(list_product_col)]
+                        df_products.columns = ["variables", "values"]
+                        
+                        with tab1:
+                            fig = px.pie(df_products, values='values', names='variables', 
+                                            title="Amount spent per product type (in %)")
+                            st.plotly_chart(fig, width=300)
+
+                        list_purchases_col = [col for col in list(df_nb.index) if "Purchases" in col]
+                        df_products = df_nb.reset_index()
+                        df_products = df_products.loc[df_products["variable"].isin(list_purchases_col)]
+                        df_products.columns = ["variables", "values"]
+                        
+                        with tab2:
+                            fig = px.pie(df_products, values='values', names='variables', 
+                                        title='Proportion of purchases made per channel (in %)')
+                            st.plotly_chart(fig, width=300)
         

pages/timeseries_analysis.py

@@ -7,7 +7,7 @@ import numpy as np
 from PIL import Image
 from prophet import Prophet
 from datetime import date
-from utils import load_data_pickle
+from utils import load_data_pickle, check_password
 from sklearn.metrics import root_mean_squared_error
 from st_pages import add_indentation
 
@@ -30,181 +30,180 @@ def forecast_prophet(train, test, col=None):
 
 ###################################### TITLE ####################################
 
-#st.image("images/ts_header.png")
-#st.image("images/ts_header.png", use_column_width=True)
-st.markdown("# Time Series Forecasting 📈")
+if check_password():
+    st.markdown("# Time Series Forecasting 📈")
 
-st.markdown("### What is Time Series Forecasting ?")
-st.info("""Time series forecasting models are AI models built to make predictions about future values using historical data. 
-            These types of models take into account temporal patterns, such as **trends** (long-term movements), **seasonality** (repeating patterns at fixed intervals), and **cyclic patterns** (repeating patterns not necessarily at fixed intervals)""")
-            #unsafe_allow_html=True)
+    st.markdown("### What is Time Series Forecasting ?")
+    st.info("""Time series forecasting models are AI models built to make predictions about future values using historical data. 
+                These types of models take into account temporal patterns, such as **trends** (long-term movements), **seasonality** (repeating patterns at fixed intervals), and **cyclic patterns** (repeating patterns not necessarily at fixed intervals)""")
+                #unsafe_allow_html=True)
 
-st.markdown(" ")
-image_ts = Image.open('images/ts_patterns.png')
-_, col, _ = st.columns([0.15,0.7,0.15])
-with col:
-    st.image(image_ts)
+    st.markdown(" ")
+    image_ts = Image.open('images/ts_patterns.png')
+    _, col, _ = st.columns([0.15,0.7,0.15])
+    with col:
+        st.image(image_ts)
 
-st.markdown("    ")
+    st.markdown("    ")
 
-st.markdown("""Real-life applications of time series forecasting include:
+    st.markdown("""Real-life applications of time series forecasting include:
 - **Finance 💰**: Predict stock prices based on historical data to assist investors and traders in making informed decisions.
 - **Energy ⚡**: Forecast energy consumption patterns to optimize resource allocation, plan maintenance, and manage energy grids more efficiently.
 - **Retail 🏬**: Predict future demand for products to optimize inventory levels, reduce holding costs, and improve supply chain efficiency.
 - **Transportation and Traffic flow :car:**: Forecasting traffic patterns to optimize route planning, reduce congestion, and improve overall transportation efficiency.
 - **Healthcare** 👨‍⚕️: Predicting the number of patient admissions to hospitals, helping healthcare providers allocate resources effectively and manage staffing levels.
 - **Weather 🌦️**: Predicting weather conditions over time, which is crucial for planning various activities, agricultural decisions, and disaster preparedness.
-""")
+    """)
 
 
 
-st.markdown("    ")
+    st.markdown("    ")
 
 
 
 
-###################################### USE CASE #######################################
+    ###################################### USE CASE #######################################
 
-# LOAD DATASET
-path_timeseries = r"data/household"
-data_model = load_data_pickle(path_timeseries,"household_power_consumption_clean.pkl")
-data_model.rename({"Date":"ds", "Global_active_power":"y"}, axis=1, inplace=True)
-data_model.dropna(inplace=True)
-data_model["ds"] = pd.to_datetime(data_model["ds"])
+    # LOAD DATASET
+    path_timeseries = r"data/household"
+    data_model = load_data_pickle(path_timeseries,"household_power_consumption_clean.pkl")
+    data_model.rename({"Date":"ds", "Global_active_power":"y"}, axis=1, inplace=True)
+    data_model.dropna(inplace=True)
+    data_model["ds"] = pd.to_datetime(data_model["ds"])
 
-# BEGINNING OF USE CASE
-st.divider()
-st.markdown("# Power Consumption Forecasting ⚡")
+    # BEGINNING OF USE CASE
+    st.divider()
+    st.markdown("# Power Consumption Forecasting ⚡")
 
-#st.markdown("  ")
-st.info("""In this use case, a time series forecasting model learns how to accuratly predict the **energy consumption** (or global active power in the dataset) of a household using historical data. 
-        A forecasting model can be a valuable tool for energy consumption analysis as it can help **optimize resource planning** and **avoid overloads** during peak demand periods.""")
+    #st.markdown("  ")
+    st.info("""In this use case, a time series forecasting model learns how to accuratly predict the **energy consumption** (or global active power in the dataset) of a household using historical data. 
+            A forecasting model can be a valuable tool for energy consumption analysis as it can help **optimize resource planning** and **avoid overloads** during peak demand periods.""")
 
-st.markdown(" ")
+    st.markdown(" ")
 
-_, col, _ = st.columns([0.15,0.7,0.15])
-with col:
-    st.image("images/energy_consumption.jpg")
+    _, col, _ = st.columns([0.15,0.7,0.15])
+    with col:
+        st.image("images/energy_consumption.jpg")
 
-st.markdown("    ")
-st.markdown("    ")
+    st.markdown("    ")
+    st.markdown("    ")
 
-st.markdown("### About the data 📋")
+    st.markdown("### About the data 📋")
 
-st.markdown("""You were provided data from the **daily energy consumption** of a household between January 2007 and November 2010 (46 months). <br>
-            The goal is to forecast the **Global active power** being produced daily by the household. 
-            Additional variables such as *Global Intensity* and three levels of *Sub-metering* are also available for the forecast.
-            """, unsafe_allow_html=True)
+    st.markdown("""You were provided data from the **daily energy consumption** of a household between January 2007 and November 2010 (46 months). <br>
+                The goal is to forecast the **Global active power** being produced daily by the household. 
+                Additional variables such as *Global Intensity* and three levels of *Sub-metering* are also available for the forecast.
+                """, unsafe_allow_html=True)
 
-st.markdown(" ")
+    st.markdown(" ")
 
-st.info("""The data has been split into "historical data" and "to be predicted". Since forecasting models are **supervised**, we will use the household's energy data from January 2007 to December 2009 as historical data to train the model.
-        We will then use the rest of the available data (starting January 2010) to test the performance of the model.""")
+    st.info("""The data has been split into "historical data" and "to be predicted". Since forecasting models are **supervised**, we will use the household's energy data from January 2007 to December 2009 as historical data to train the model.
+            We will then use the rest of the available data (starting January 2010) to test the performance of the model.""")
 
-select_cutoff_date = date(2010, 1, 1)
-select_cutoff_date = select_cutoff_date.strftime('%Y-%m-%d')
+    select_cutoff_date = date(2010, 1, 1)
+    select_cutoff_date = select_cutoff_date.strftime('%Y-%m-%d')
 
-# SELECT TRAIN/TEST SET
-train = data_model[data_model["ds"] <= select_cutoff_date]
-test = data_model[data_model["ds"] > select_cutoff_date]
+    # SELECT TRAIN/TEST SET
+    train = data_model[data_model["ds"] <= select_cutoff_date]
+    test = data_model[data_model["ds"] > select_cutoff_date]
 
-# PLOT TRAIN/TEST SET
-train_plot = train.copy()
-train_plot["split"] = ["historical data"]*len(train_plot)
+    # PLOT TRAIN/TEST SET
+    train_plot = train.copy()
+    train_plot["split"] = ["historical data"]*len(train_plot)
 
-test_plot = test.copy()
-test_plot["split"] = ["to be predicted"]*len(test_plot)
-data_clean_plot = pd.concat([train_plot, test_plot]) # plot dataset
+    test_plot = test.copy()
+    test_plot["split"] = ["to be predicted"]*len(test_plot)
+    data_clean_plot = pd.concat([train_plot, test_plot]) # plot dataset
 
-st.markdown(" ")
-tab1, tab2, tab3, tab4, tab5 = st.tabs(["Global active power", "Sub metering 1", "Sub metering 2", "Sub metering 3", "Global Intensity"])
+    st.markdown(" ")
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Global active power", "Sub metering 1", "Sub metering 2", "Sub metering 3", "Global Intensity"])
 
-with tab1:
-    ts_chart = alt.Chart(data_clean_plot).mark_line().encode(
-        x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
-        y=alt.Y('y:Q', title="Global active power"),
-        color='split:N',
-    ).interactive()
-
-    st.markdown("**View Global active power** (to be forecasted)")
-    st.altair_chart(ts_chart, use_container_width=True)
-    st.success("""**Global active power** refers to the total real power consumed by electrical devices in the house (in kilowatts).""")
-    
+    with tab1:
+        ts_chart = alt.Chart(data_clean_plot).mark_line().encode(
+            x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
+            y=alt.Y('y:Q', title="Global active power"),
+            color='split:N',
+        ).interactive()
+
+        st.markdown("**View Global active power** (to be forecasted)")
+        st.altair_chart(ts_chart, use_container_width=True)
+        st.success("""**Global active power** refers to the total real power consumed by electrical devices in the house (in kilowatts).""")
+        
+
+    with tab2:
+        ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
+                    x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
+                    y=alt.Y('Sub_metering_1:Q', title="Sub metering 1"),
+                    color=alt.Color('split:N')) #, scale=custom_color_scale))
+                
+        st.markdown("**View Sub-metering 1** (additional)")
+        st.altair_chart(ts_chart.interactive(), use_container_width=True)
+        st.success("**Sub-metering 1** is the total active power consumed by the kitchen in the house (in kilowatts).")
 
-with tab2:
-    ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
-                x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
-                y=alt.Y('Sub_metering_1:Q', title="Sub metering 1"),
-                color=alt.Color('split:N')) #, scale=custom_color_scale))
-            
-    st.markdown("**View Sub-metering 1** (additional)")
-    st.altair_chart(ts_chart.interactive(), use_container_width=True)
-    st.success("**Sub-metering 1** is the total active power consumed by the kitchen in the house (in kilowatts).")
 
 
+    with tab3:    
+        ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
+            x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
+            y=alt.Y('Sub_metering_2:Q', title="Sub metering 2"),
+            color=alt.Color('split:N')) #, scale=custom_color_scale))
 
-with tab3:    
-    ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
-        x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
-        y=alt.Y('Sub_metering_2:Q', title="Sub metering 2"),
-        color=alt.Color('split:N')) #, scale=custom_color_scale))
+        st.markdown("**View Sub-metering 2** (additional)")
+        st.altair_chart(ts_chart.interactive(), use_container_width=True)
+        st.success("**Sub-metering 2** is the total active power consumed by the laundry room in the house (in kilowatts).")
 
-    st.markdown("**View Sub-metering 2** (additional)")
-    st.altair_chart(ts_chart.interactive(), use_container_width=True)
-    st.success("**Sub-metering 2** is the total active power consumed by the laundry room in the house (in kilowatts).")
 
+    with tab4:        
+        ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
+                x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
+                y=alt.Y('Sub_metering_3:Q', title="Sub metering 3"),
+                color=alt.Color('split:N')) #scale=custom_color_scale))
 
-with tab4:        
-    ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
-            x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
-            y=alt.Y('Sub_metering_3:Q', title="Sub metering 3"),
-            color=alt.Color('split:N')) #scale=custom_color_scale))
+        st.markdown("**View Sub-metering 3** (additional)")
+        st.altair_chart(ts_chart.interactive(), use_container_width=True)
+        st.success("**Sub-metering 3** is the active power consumed by the electric water heater and air conditioner in the household (in kilowatts).")
 
-    st.markdown("**View Sub-metering 3** (additional)")
-    st.altair_chart(ts_chart.interactive(), use_container_width=True)
-    st.success("**Sub-metering 3** is the active power consumed by the electric water heater and air conditioner in the household (in kilowatts).")
 
+    with tab5:
+        custom_color_scale = alt.Scale(range=['red', 'lightcoral'])
+        ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
+            x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
+            y=alt.Y('Global_intensity:Q', title="Global active power"),
+            color=alt.Color('split:N')) # scale=custom_color_scale))
 
-with tab5:
-    custom_color_scale = alt.Scale(range=['red', 'lightcoral'])
-    ts_chart = alt.Chart(data_clean_plot.loc[data_clean_plot["split"]=="historical data"]).mark_line().encode(
-        x=alt.X('ds:T', axis=alt.Axis(format='%b %Y', tickCount=12), title="Date"),
-        y=alt.Y('Global_intensity:Q', title="Global active power"),
-        color=alt.Color('split:N')) # scale=custom_color_scale))
+        st.markdown("**View Global intensity** (additional)")
+        st.altair_chart(ts_chart.interactive(), use_container_width=True)
+        st.success("**Global intensity** is the average current intensity delivered to the household (amps).")
 
-    st.markdown("**View Global intensity** (additional)")
-    st.altair_chart(ts_chart.interactive(), use_container_width=True)
-    st.success("**Global intensity** is the average current intensity delivered to the household (amps).")
 
 
+    st.markdown(" ")
+    st.markdown(" ")
+    st.markdown("### Forecast model 📈")
+    st.markdown("""The forecasting model used in this use case allows **additional data** to be used for training. 
+            Try adding more data to the model as it can help improve its performance and accuracy.""")
 
-st.markdown(" ")
-st.markdown(" ")
-st.markdown("### Forecast model 📈")
-st.markdown("""The forecasting model used in this use case allows **additional data** to be used for training. 
-        Try adding more data to the model as it can help improve its performance and accuracy.""")
 
 
+    # ADD VARIABLES TO ANALYSIS
+    add_var = ["Sub_metering_1", "Sub_metering_2", "Sub_metering_3","Global_intensity"]
+    st.markdown("")
+    select_add_var = st.multiselect("**Add variables to the model**", add_var)
 
-# ADD VARIABLES TO ANALYSIS
-add_var = ["Sub_metering_1", "Sub_metering_2", "Sub_metering_3","Global_intensity"]
-st.markdown("")
-select_add_var = st.multiselect("**Add variables to the model**", add_var)
+    if 'model_train' not in st.session_state:
+        st.session_state['model_train'] = False
+        
+    # if st.session_state.model_train:
+    #     text = "The model has alerady been trained."
+    # else:
+    #     st.write("The model hasn't been trained yet")
 
-if 'model_train' not in st.session_state:
-    st.session_state['model_train'] = False
-    
-# if st.session_state.model_train:
-#     text = "The model has alerady been trained."
-# else:
-#     st.write("The model hasn't been trained yet")
+    st.markdown("")
+    run_model = st.button("**Run the model**")
 
-st.markdown("")
-run_model = st.button("**Run the model**")
 
-
-st.markdown("    ")
-st.markdown("    ")
+    st.markdown("    ")
+    st.markdown("    ")
 
 
 
@@ -212,107 +211,107 @@ st.markdown("    ")
 
 ################################## SEE RESULTS ###############################
 
-if "saved_model" not in st.session_state:
-    st.session_state["saved_model"] = False
+    if "saved_model" not in st.session_state:
+        st.session_state["saved_model"] = False
 
 
-if run_model:
-    with st.spinner('Wait for it...'):
-        fbmodel, forecast = forecast_prophet(train, test, col=select_add_var)
-        st.session_state.model_train = True
-        st.session_state.saved_model = fbmodel
+    if run_model:
+        with st.spinner('Wait for it...'):
+            fbmodel, forecast = forecast_prophet(train, test, col=select_add_var)
+            st.session_state.model_train = True
+            st.session_state.saved_model = fbmodel
 
-        ####################### SEE RESULTS ########################
-        st.markdown("#### See the results ☑️")
-        st.info("The model is able to forecast energy consumption as well as learn the predicted data's **trend**, **weekly** and **yearly seasonality**.")
+            ####################### SEE RESULTS ########################
+            st.markdown("#### See the results ☑️")
+            st.info("The model is able to forecast energy consumption as well as learn the predicted data's **trend**, **weekly** and **yearly seasonality**.")
 
-        tab1_result, tab2_result, tab3_result, tab4_result = st.tabs(["Performance", "Trend", "Weekly seasonality", "Yearly seasonality"])
-        with tab1_result:
-            # Compute model root mean squared error
-            y_true = test_plot["y"]
-            y_pred = forecast["yhat"]
-            error = str(np.round(root_mean_squared_error(y_true, y_pred, ),3))
+            tab1_result, tab2_result, tab3_result, tab4_result = st.tabs(["Performance", "Trend", "Weekly seasonality", "Yearly seasonality"])
+            with tab1_result:
+                # Compute model root mean squared error
+                y_true = test_plot["y"]
+                y_pred = forecast["yhat"]
+                error = str(np.round(root_mean_squared_error(y_true, y_pred, ),3))
 
-            col1, col2 = st.columns([0.1,0.9])
+                col1, col2 = st.columns([0.1,0.9])
 
-            with col1:
-                st.markdown("")
-                st.metric(label="**Average error**", value=error)
-            
-            with col2:
-                # Create df for true vs predicted plot
-                df_results = pd.concat([test_plot.reset_index(drop=True), forecast.drop(columns=["ds"]).reset_index(drop=True)], axis=1)[["ds","y","yhat"]]
-                df_results = df_results.melt(id_vars="ds")
-                df_results["variable"] = df_results["variable"].map({"y":"true values", "yhat":"predicted values"})
-                df_results.columns = ["Date", "Variable", "Global Active Power"]
+                with col1:
+                    st.markdown("")
+                    st.metric(label="**Average error**", value=error)
                 
-                fig = px.line(df_results, x="Date", y="Global Active Power", color="Variable", 
-                        color_discrete_sequence=["lightblue", "black"], line_dash = 'Variable')
-
-                fig.update_layout(
-                    title=f'True vs predicted power consumption',
-                    width=1200,  
-                    height=600  
-                )
-
+                with col2:
+                    # Create df for true vs predicted plot
+                    df_results = pd.concat([test_plot.reset_index(drop=True), forecast.drop(columns=["ds"]).reset_index(drop=True)], axis=1)[["ds","y","yhat"]]
+                    df_results = df_results.melt(id_vars="ds")
+                    df_results["variable"] = df_results["variable"].map({"y":"true values", "yhat":"predicted values"})
+                    df_results.columns = ["Date", "Variable", "Global Active Power"]
+                    
+                    fig = px.line(df_results, x="Date", y="Global Active Power", color="Variable", 
+                            color_discrete_sequence=["lightblue", "black"], line_dash = 'Variable')
+
+                    fig.update_layout(
+                        title=f'True vs predicted power consumption',
+                        width=1200,  
+                        height=600  
+                    )
+
+                    st.plotly_chart(fig, use_container_width=True)
+
+            with tab2_result:
+                ymin = forecast["trend"].min() 
+                ymax = forecast["trend"].max()
+                
+                fig = px.area(forecast, x="ds", y="trend", color_discrete_sequence=["red"]) #range_y=[ymin, ymax])
+                fig.update_layout(title="Trend", xaxis_title="Date", yaxis_title="Trend")
                 st.plotly_chart(fig, use_container_width=True)
+                st.markdown("""**Interpretation** <br>
+                            No trend in the household's energy consumption has been detected by the model.""", unsafe_allow_html=True)
 
-        with tab2_result:
-            ymin = forecast["trend"].min() 
-            ymax = forecast["trend"].max()
-            
-            fig = px.area(forecast, x="ds", y="trend", color_discrete_sequence=["red"]) #range_y=[ymin, ymax])
-            fig.update_layout(title="Trend", xaxis_title="Date", yaxis_title="Trend")
-            st.plotly_chart(fig, use_container_width=True)
-            st.markdown("""**Interpretation** <br>
-                        No trend in the household's energy consumption has been detected by the model.""", unsafe_allow_html=True)
+            with tab3_result:
+                #st.success("**Weekly seasonality** refers to a repeating pattern or variation that occurs on a weekly basis on the energy consumption data.")
+                days_week = dict(zip(np.arange(1,8),["Monday", "Tuedsay", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]))
+                forecast_weekly = forecast.copy()
+                forecast_weekly["dayweek"] = forecast_weekly["ds"].apply(lambda x: x.isoweekday()).map(days_week)
 
-        with tab3_result:
-            #st.success("**Weekly seasonality** refers to a repeating pattern or variation that occurs on a weekly basis on the energy consumption data.")
-            days_week = dict(zip(np.arange(1,8),["Monday", "Tuedsay", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]))
-            forecast_weekly = forecast.copy()
-            forecast_weekly["dayweek"] = forecast_weekly["ds"].apply(lambda x: x.isoweekday()).map(days_week)
-
-            fig = px.area(forecast_weekly, x="dayweek", y="weekly", color_discrete_sequence=["purple"])
-            fig.update_layout(title="Weekly seasonality", xaxis_title="Date", yaxis_title="Weekly")
-            st.plotly_chart(fig, use_container_width=True)
+                fig = px.area(forecast_weekly, x="dayweek", y="weekly", color_discrete_sequence=["purple"])
+                fig.update_layout(title="Weekly seasonality", xaxis_title="Date", yaxis_title="Weekly")
+                st.plotly_chart(fig, use_container_width=True)
 
-            st.markdown("""**Interpretation** <br>
-            The household consumes more electrical power during the week-end (Saturday and Sunday) then during the week.           
-                        """, unsafe_allow_html=True)
+                st.markdown("""**Interpretation** <br>
+                The household consumes more electrical power during the week-end (Saturday and Sunday) then during the week.           
+                            """, unsafe_allow_html=True)
 
-        with tab4_result:
-            forecast_year = forecast[["ds","yearly"]].copy()
-            forecast_year["ds_year"] = forecast_year["ds"].apply(lambda x: x.strftime("%B %d"))
-            forecast_year["ds"] = forecast_year["ds"].apply(lambda x: x.strftime("%m-%d"))
-            forecast_year.sort_values(by=["ds"], inplace=True)
-            forecast_year = forecast_year.groupby(["ds","ds_year"]).mean().reset_index()
+            with tab4_result:
+                forecast_year = forecast[["ds","yearly"]].copy()
+                forecast_year["ds_year"] = forecast_year["ds"].apply(lambda x: x.strftime("%B %d"))
+                forecast_year["ds"] = forecast_year["ds"].apply(lambda x: x.strftime("%m-%d"))
+                forecast_year.sort_values(by=["ds"], inplace=True)
+                forecast_year = forecast_year.groupby(["ds","ds_year"]).mean().reset_index()
 
-            st.markdown("")
-            ts_chart = alt.Chart(forecast_year, title="Yearly seasonality").mark_area(opacity=0.5,line = {'color':'darkblue'}).encode(
-                x=alt.X('ds_year:T', axis=alt.Axis(format='%b', tickCount=12), title="Date"),
-                y=alt.Y('yearly:Q', title="Yearly seasonality"),
-                ).interactive()
+                st.markdown("")
+                ts_chart = alt.Chart(forecast_year, title="Yearly seasonality").mark_area(opacity=0.5,line = {'color':'darkblue'}).encode(
+                    x=alt.X('ds_year:T', axis=alt.Axis(format='%b', tickCount=12), title="Date"),
+                    y=alt.Y('yearly:Q', title="Yearly seasonality"),
+                    ).interactive()
 
-            st.altair_chart(ts_chart, use_container_width=True)
+                st.altair_chart(ts_chart, use_container_width=True)
 
-            st.markdown("""**Interpretation** <br>
-            The household consumes more energy during the winter (November to February) and less during the warmer months.           
-                        """, unsafe_allow_html=True)
-            
+                st.markdown("""**Interpretation** <br>
+                The household consumes more energy during the winter (November to February) and less during the warmer months.           
+                            """, unsafe_allow_html=True)
+                
 
 
-################################## MAKE FUTURE PREDICTIONS ###############################
+    ################################## MAKE FUTURE PREDICTIONS ###############################
 
-# st.markdown("#### Forecast new values ")
+    # st.markdown("#### Forecast new values ")
 
-# st.info("**The model needs to be trained before it can predict new values.**")
+    # st.info("**The model needs to be trained before it can predict new values.**")
 
-# st.
+    # st.
 
-# make_predictions = st.button("**Forecast new values**")
+    # make_predictions = st.button("**Forecast new values**")
 
-# if make_predictions is True:
-#     if st.session_state.saved_model is True:
+    # if make_predictions is True:
+    #     if st.session_state.saved_model is True:
 
 

pages/topic_modeling.py

@@ -6,193 +6,192 @@ import pandas as pd
 import matplotlib.pyplot as plt
 import plotly.express as px 
 
-from utils import load_data_csv, load_data_pickle, load_model_pickle, load_numpy
+from utils import load_data_pickle, load_numpy, check_password
 from st_pages import add_indentation
 
 
 st.set_page_config(layout="wide")
 
-## Start of Streamlit app
-st.title("Topic Modeling 📚")
+if check_password():
+    st.title("Topic Modeling 📚")
+    st.markdown("### What is Topic Modeling ?")
 
+    st.info("""
+    Topic modeling is a text-mining technique used to **identify topics within a collection of documents**.
+    It is a useful tool for organizing and summarizing vast amounts of textual data as well as automate the discovery of hidden thematic structures in a corpus of text data, without any prior knowledge.
+    """)
 
-st.markdown("### What is Topic Modeling ?")
-
-st.info("""
-Topic modeling is a text-mining technique used to **identify topics within a collection of documents**.
-It is a useful tool for organizing and summarizing vast amounts of textual data as well as automate the discovery of hidden thematic structures in a corpus of text data, without any prior knowledge.
-""")
-
-st.markdown(" ")
-_, col, _ = st.columns([0.25,0.4,0.35])
-with col:
-    st.image("images/topic_modeling.gif", caption="An example of Topic Modeling", use_column_width=True)
+    st.markdown(" ")
+    _, col, _ = st.columns([0.25,0.4,0.35])
+    with col:
+        st.image("images/topic_modeling.gif", caption="An example of Topic Modeling", use_column_width=True)
 
 
-st.markdown("""Common applications of Topic Modeling include: 
+    st.markdown("""Common applications of Topic Modeling include: 
 - **Search Engine Optimization (SEO): 🔎** Determine the main topics/keywords present on a website to optimize content and improve search engine rankings.
 - **Customer Support** ✍️: Analyze customer support tickets, emails, and chat transcripts to identify common questions and complaints.   
 - **Fraud Detection and Risk Management: 🏦** : Detect fraudulent activities, compliance violations, and operational risks by analyzing textual data such as transaction descriptions, audit reports and regulatory filings.
 - **Market Research 🌎**: Gain competitive intelligence and make informed decisions regarding product development, marketing strategies, and market positioning by analyzing research reports and industry news. 
-""")
-
-
-st.markdown("  ")
-st.divider()
-
-st.markdown("# Topic modeling on product descriptions 🛍️")
-st.markdown("""In this use case, we will use a **topic model** to categorize around **20 000 e-commerce products** as well as identify
-        the main types of products solds.""")
+    """)
 
-_, col, _ = st.columns([0.2,0.6,0.2])
-with col:
-    st.image("images/e-commerce.jpg")
 
-st.markdown(" ")
+    st.markdown("  ")
+    st.divider()
 
-# Load data 
-path_data = "data/topic-modeling"  
-# data = load_data_csv(path_data,"data-topicmodeling.csv")
+    st.markdown("# Topic modeling on product descriptions 🛍️")
+    st.markdown("""In this use case, we will use a **topic model** to categorize around **20 000 e-commerce products** as well as identify
+            the main types of products solds.""")
 
-# Load the topic data
-topic_info = load_data_pickle(path_data, 'topic_info.pkl')
+    _, col, _ = st.columns([0.2,0.6,0.2])
+    with col:
+        st.image("images/e-commerce.jpg")
 
-
-
-##### ABOUT THE USE CASE
-st.markdown("#### About the data 📋")
-st.markdown("""You were provided a dataset with around 20 000 products from a large e-commerce retailer. <br>
-            This dataset contains the products' title and description on the website.""", unsafe_allow_html=True)
-st.info("""**Note**: Some of the descriptions featured below are shown in their 'raw' form, meaning they contain unprocessed html code and special characters.
-        These descriptions were first 'cleaned' (by removing unwanted characters) before being used in the model.""")
-see_data = st.checkbox('**See the data**', key="credit_score_data")  # Corrected the key to use an underscore
-if see_data:
     st.markdown(" ")
-    st.warning("This view only shows a subset of the 20 000 product description used.")
-    data = load_data_pickle(path_data,"data-tm-view.pkl") 
-    data_show = data[["TITLE", "DESCRIPTION"]]
-    st.dataframe(data_show.reset_index(drop=True), use_container_width=True)
-
 
-st.markdown("  ")
-st.markdown("  ")
+    # Load data 
+    path_data = "data/topic-modeling"  
+    # data = load_data_csv(path_data,"data-topicmodeling.csv")
 
+    # Load the topic data
+    topic_info = load_data_pickle(path_data, 'topic_info.pkl')
 
 
-# RUN THE MODEL
-st.markdown("#### About the model 📚")
-st.markdown("""**Topic models** can be seen as unsupervised clustering models where text documents are grouped into topics/clusters based on their similarities.
-            We will use here a topic model to automatically categorize/group the retailer's products based on their description, 
-            as well as understand what are the most common type of products being sold.""", unsafe_allow_html=True)
 
-st.info("""**Note**: In topic modeling, the final topics are represented by the model using 'top words'. 
-        A topic's top words are chosen based on how much they appear in the topic's documents.""")
+    ##### ABOUT THE USE CASE
+    st.markdown("#### About the data 📋")
+    st.markdown("""You were provided a dataset with around 20 000 products from a large e-commerce retailer. <br>
+                This dataset contains the products' title and description on the website.""", unsafe_allow_html=True)
+    st.info("""**Note**: Some of the descriptions featured below are shown in their 'raw' form, meaning they contain unprocessed html code and special characters.
+            These descriptions were first 'cleaned' (by removing unwanted characters) before being used in the model.""")
+    see_data = st.checkbox('**See the data**', key="credit_score_data")  # Corrected the key to use an underscore
+    if see_data:
+        st.markdown(" ")
+        st.warning("This view only shows a subset of the 20 000 product description used.")
+        data = load_data_pickle(path_data,"data-tm-view.pkl") 
+        data_show = data[["TITLE", "DESCRIPTION"]]
+        st.dataframe(data_show.reset_index(drop=True), use_container_width=True)
 
-def show_results():
-    st.markdown("#### See the results ☑️")
-    tab1, tab2 = st.tabs(["Overall results", "Specific Topic Details", ])# "Search Similar Topics"])
-    st.markdown(" ")
 
-    # Tab 1: Summary Table
-    with tab1:
-        st.header("Overall results")
-        st.markdown("""This tab showcases all of the **topics identified** within the product dataset, each topic's most significant words (**top words**), as well as the **proportion** 
-                    of products that were assigned to the specific topic.""")
+    st.markdown("  ")
+    st.markdown("  ")
 
-        summary_table = topic_info[['Title','Representation', 'Percentage']].copy()
-        summary_table['Top Words'] = summary_table['Representation'].apply(lambda x: x[:5]) #:5
-        summary_table = summary_table[["Title","Top Words","Percentage"]]
-        summary_table.rename({"Title":"Topic Title"}, axis=1, inplace=True)
-        
-        st.data_editor(
-            summary_table, #.loc[df_results_tab1["Customer ID"].isin(filter_customers)],
-                column_config={
-                    "Percentage": st.column_config.ProgressColumn(
-                        "Proportion %",
-                        help="Propotion of documents within each topic",
-                        format="%.1f%%",
-                        min_value=0,
-                        max_value=100)},
-            use_container_width=True
-        )
-
-        st.info("""**Note**: The topic 'titles' were not provided by the model but instead were generated by feeding the topic's top words to an LLM.
-            Traditional topic models define topics using representative/top words but weren't built to generate a specific title to each topic.""")
-
-    # Tab 2: Specific Topic Details
-    with tab2:
-
-        # Load top words
-        with open(os.path.join(path_data,"topics_top_words.json"), "r") as json_file:
-            top_words_dict = json.load(json_file)
-        
-        # Load similarity df and scores
-        similarity_df = load_data_pickle(path_data, "similarity_topic_df.pkl")
-        similarity_scores = load_numpy(path_data, "similarity_topic_scores.npy")
 
-        #st.markdown(" ")
-        st.header("Learn more about each topic")
-        st.markdown("""You can **select a specific topic** to get more information on its **top words**, as well as the
-                    **other topics that are most similar to it**.""")
-        # st.info("""In this section, you can find more information on each of the topics identified by the model.
-        #         This includes the topic's a full list of its top words, the importance of each of these words, as well as the top five topics that are most similar to it.""")
 
-        st.markdown(" ")
+    # RUN THE MODEL
+    st.markdown("#### About the model 📚")
+    st.markdown("""**Topic models** can be seen as unsupervised clustering models where text documents are grouped into topics/clusters based on their similarities.
+                We will use here a topic model to automatically categorize/group the retailer's products based on their description, 
+                as well as understand what are the most common type of products being sold.""", unsafe_allow_html=True)
 
-        # Select topic
-        topics = topic_info["Title"].sort_values().to_list()
-        selected_topic = st.selectbox('**Select a Topic**', topics)
-        selected_topic_id = topic_info[topic_info['Title'] == selected_topic]["Topic"].to_numpy()[0] + 1
+    st.info("""**Note**: In topic modeling, the final topics are represented by the model using 'top words'. 
+            A topic's top words are chosen based on how much they appear in the topic's documents.""")
 
+    def show_results():
+        st.markdown("#### See the results ☑️")
+        tab1, tab2 = st.tabs(["Overall results", "Specific Topic Details", ])# "Search Similar Topics"])
         st.markdown(" ")
-        col1, col2 = st.columns(2)
 
-        # Top words 
-        with col1:
-            top_words_df = pd.DataFrame(top_words_dict[selected_topic], columns=["Word", "Importance"])
-            top_words_df.sort_values(by=["Importance"], ascending=False, inplace=True)
-            top_words_df["Importance"] = top_words_df["Importance"].round(2)
+        # Tab 1: Summary Table
+        with tab1:
+            st.header("Overall results")
+            st.markdown("""This tab showcases all of the **topics identified** within the product dataset. <br>
+            Each topic's <b>most significant words</b> (top words), as well as the <b>proportion</b> of products that were assigned to it are given.""", 
+            unsafe_allow_html=True)
+
+            summary_table = topic_info[['Title','Representation', 'Percentage']].copy()
+            summary_table['Top Words'] = summary_table['Representation'].apply(lambda x: x[:5]) #:5
+            summary_table = summary_table[["Title","Top Words","Percentage"]]
+            summary_table.rename({"Title":"Topic Title"}, axis=1, inplace=True)
             
-            fig = px.bar(top_words_df, x='Word', y='Importance', color="Importance", title="Top words", text_auto=True)
-            fig.update_layout(yaxis=dict(range=[0, 1]), xaxis_title="", showlegend=False)
-            st.plotly_chart(fig, use_container_width=True)
-            st.info("""**Note:** Each score was computed based on the words importance in the particular topic using 
-                    a popular metric in NLP called TF-IDF (Term Frequency-Inverse Document Frequency). """)
-
-
-        # Similar topics to the selected topic
-        with col2:
-            similarity_df = similarity_df.loc[similarity_df["Topic"]==selected_topic]
-            similarity_df["scores"] = 100*similarity_scores[selected_topic_id,:] 
-            similarity_df.columns = ["Original Topic", "Rank", "Topic", "Similarity (%)"]
+            st.data_editor(
+                summary_table, #.loc[df_results_tab1["Customer ID"].isin(filter_customers)],
+                    column_config={
+                        "Percentage": st.column_config.ProgressColumn(
+                            "Proportion %",
+                            help="Propotion of documents within each topic",
+                            format="%.1f%%",
+                            min_value=0,
+                            max_value=100)},
+                use_container_width=True
+            )
+
+            st.info("""**Note**: The topic 'titles' were not provided by the model but instead were generated by feeding the topic's top words to an LLM.
+                Traditional topic models define topics using representative/top words but weren't built to generate a specific title to each topic.""")
+
+        # Tab 2: Specific Topic Details
+        with tab2:
+
+            # Load top words
+            with open(os.path.join(path_data,"topics_top_words.json"), "r") as json_file:
+                top_words_dict = json.load(json_file)
             
-            fig = px.bar(similarity_df, y='Similarity (%)', x='Topic', color="Topic", title="Five most similar topics", text_auto=True)
-            fig.update_layout(yaxis=dict(range=[0, 100]), 
-                              xaxis_title="", 
-                              showlegend=False)
-            
-            st.plotly_chart(fig, use_container_width=True)
-            st.info("""**Note:** Topics with a high similarity score can be merged together as to reduce the number of topics, as
-                    well as improve the topics coherence.""")
-    
-    return None
+            # Load similarity df and scores
+            similarity_df = load_data_pickle(path_data, "similarity_topic_df.pkl")
+            similarity_scores = load_numpy(path_data, "similarity_topic_scores.npy")
+
+            #st.markdown(" ")
+            st.header("Learn more about each topic")
+            st.markdown("""You can **select a specific topic** to get more information on its **top words**, as well as the
+                        **other topics that are most similar to it**.""")
+            # st.info("""In this section, you can find more information on each of the topics identified by the model.
+            #         This includes the topic's a full list of its top words, the importance of each of these words, as well as the top five topics that are most similar to it.""")
+
+            st.markdown(" ")
+
+            # Select topic
+            topics = topic_info["Title"].sort_values().to_list()
+            selected_topic = st.selectbox('**Select a Topic**', topics)
+            selected_topic_id = topic_info[topic_info['Title'] == selected_topic]["Topic"].to_numpy()[0] + 1
+
+            st.markdown(" ")
+            col1, col2 = st.columns(2)
+
+            # Top words 
+            with col1:
+                top_words_df = pd.DataFrame(top_words_dict[selected_topic], columns=["Word", "Importance"])
+                top_words_df.sort_values(by=["Importance"], ascending=False, inplace=True)
+                top_words_df["Importance"] = top_words_df["Importance"].round(2)
+                
+                fig = px.bar(top_words_df, x='Word', y='Importance', color="Importance", title="Top words", text_auto=True)
+                fig.update_layout(yaxis=dict(range=[0, 1]), xaxis_title="", showlegend=False)
+                st.plotly_chart(fig, use_container_width=True)
+                st.info("""**Note:** Each score was computed based on the words importance in the particular topic using 
+                        a popular metric in NLP called TF-IDF (Term Frequency-Inverse Document Frequency). """)
+
+
+            # Similar topics to the selected topic
+            with col2:
+                similarity_df = similarity_df.loc[similarity_df["Topic"]==selected_topic]
+                similarity_df["scores"] = 100*similarity_scores[selected_topic_id,:] 
+                similarity_df.columns = ["Original Topic", "Rank", "Topic", "Similarity (%)"]
+                
+                fig = px.bar(similarity_df, y='Similarity (%)', x='Topic', color="Topic", title="Five most similar topics", text_auto=True)
+                fig.update_layout(yaxis=dict(range=[0, 100]), 
+                                xaxis_title="", 
+                                showlegend=False)
+                
+                st.plotly_chart(fig, use_container_width=True)
+                st.info("""**Note:** Topics with a high similarity score can be merged together as to reduce the number of topics, as
+                        well as improve the topics' coherence.""")
+        
+        return None
 
-if 'button_clicked' not in st.session_state:
-    st.session_state['button_clicked'] = False
+    if 'button_clicked' not in st.session_state:
+        st.session_state['button_clicked'] = False
 
-def run_model():
-    run_model = st.button("**Run the model**", type="primary")
-    st.markdown(" ")
-    st.markdown(" ")
+    def run_model():
+        run_model = st.button("**Run the model**", type="primary")
+        st.markdown(" ")
+        st.markdown(" ")
 
-    if not st.session_state['button_clicked']: 
-        if run_model:
+        if not st.session_state['button_clicked']: 
+            if run_model:
+                show_results()
+                st.session_state['button_clicked'] = True 
+        else:
             show_results()
-            st.session_state['button_clicked'] = True 
-    else:
-        show_results()
-        
-run_model()
+            
+    run_model()
 
 
 

utils.py

@@ -108,9 +108,12 @@ def load_model_huggingface(repo_id, token, task=None):
 def check_password():
     """Returns `True` if the user had the correct password."""
 
+    password_key = os.environ["PASSWORD"]
+    #password_key = st.secrets["password"]
+
     def password_entered():
         """Checks whether a password entered by the user is correct."""
-        if "password" in st.session_state and st.session_state["password"] == st.secrets["password"]:
+        if "password" in st.session_state and st.session_state["password"] == password_key:
             st.session_state["password_correct"] = True
             del st.session_state["password"]  # don't store password
         else:
@@ -134,10 +137,6 @@ def check_password():
         return True
 
 
-
-
-
-
 ###################### OTHER ######################
 
 def img_to_bytes(img_path):