Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+get_around_delay_analysis.xlsx filter=lfs diff=lfs merge=lfs -text

get_around_delay_analysis.xlsx

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

pages/1_ETL_GetAround.py

@@ -0,0 +1,116 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+WIDTH = 800
+HEIGHT = 700
+
+st.write("Bienvenue dans le Dashboard de GetAround")
+
+df = pd.read_excel("get_around_delay_analysis.xlsx")
+
+# Calculer le nombre de valeurs manquantes par colonne
+missing_values_count = df.isnull().sum()
+
+# Calculer le pourcentage de valeurs manquantes par colonne
+missing_values_percent = (missing_values_count / len(df)) * 100
+
+# Créer un nouveau DataFrame pour afficher les résultats
+missing_data = pd.DataFrame({
+    'missing_values_count': missing_values_count,
+    'missing_values_percent': missing_values_percent
+})
+
+missing_df = missing_data[missing_data['missing_values_count'] > 0]
+missing_df_percent = missing_df['missing_values_percent'].reset_index()
+
+missing = px.bar(missing_df_percent, x = "index", y = "missing_values_percent",
+       hover_data=['index'], title="Données manquantes en pourcentage", color='index', text_auto='.2s')
+
+st.plotly_chart(missing)
+
+state_car = df['state'].value_counts()
+state_car = pd.DataFrame(state_car).reset_index()
+state_car.columns = ['state', 'count']
+state = px.pie(state_car, values='count', names='state', title='State of the Car', color = 'state', width=WIDTH)
+
+st.plotly_chart(state)
+
+
+import plotly.graph_objects as go
+
+
+fig = go.Figure()
+
+
+# Mask sur les types de checkin vs ended canceled
+checkin_df = df.groupby('checkin_type')['state'].value_counts()
+checkin_df = pd.DataFrame(checkin_df).reset_index()
+checkin_df_connect = checkin_df[checkin_df['checkin_type'] == 'connect']['count'].sum()
+checkin_df_mobile = checkin_df[checkin_df['checkin_type'] == 'mobile']['count'].sum()
+total_checkin = checkin_df['count'].sum()
+checkin_df = checkin_df.assign(percent=lambda x: (x['count'] / total_checkin) * 100)
+
+# Créer la figure Plotly
+fig = go.Figure()
+
+# Ajout des barres pour chaque état
+for state in checkin_df['state'].unique():
+    df_state = checkin_df[checkin_df['state'] == state]
+    fig.add_trace(go.Bar(
+        x=df_state['checkin_type'],
+        y=df_state['percent'],
+        name=state,
+        text=df_state['percent'].apply(lambda x: f'{round(x, 2)}% 🚗'),
+        textfont=dict(size=12, weight='bold'),
+        textposition="outside",
+    ))
+
+# Mise en page
+fig.update_layout(
+    title='Type of Checkin vs State',
+    xaxis_title='Checkin Type',
+    yaxis_title='Percent',
+    barmode='group',
+    width=800,  # Assurez-vous que WIDTH est défini
+    height=600  # Assurez-vous que HEIGHT est défini
+)
+
+# Affichage du graphique dans Streamlit
+st.plotly_chart(fig)
+
+# Mask sur les Canceled
+
+mask_canceled = df['state'] == 'canceled'
+car_canceled_detail = df[mask_canceled]
+
+car_canceled_detail = car_canceled_detail['checkin_type'].value_counts()
+car_canceled_detail = pd.DataFrame(car_canceled_detail).reset_index()
+car_canceled_detail.columns = ['checkin_type', 'count']
+
+cancel_device = px.pie(car_canceled_detail, values='count', names='checkin_type', title='Groupe Cancel : Checkin Type', color = 'checkin_type', width=WIDTH)
+st.plotly_chart(cancel_device)
+
+#Visualisation des Cancels et les outliers
+
+delay_mask = df['delay_at_checkout_in_minutes'] > 0
+delay_dataf = df[delay_mask]
+fig = px.scatter(delay_dataf, x = "delay_at_checkout_in_minutes")
+st.plotly_chart(fig)
+
+#Transformation des status Early en On Time
+
+def status_time(x):
+    if x <0:
+        return 'ONTIME'
+    elif x > 0:
+        return "DELAY"
+    else:
+        return "NOFINFO"
+
+
+df['time'] = df['delay_at_checkout_in_minutes'].apply(status_time)
+df['time'] = df.apply(lambda row: row['state'].upper() if row['time'] == 'NOFINFO' else row['time'], axis=1)
+df_state = df['time'].value_counts()
+df_state_detail = pd.DataFrame(df_state).reset_index()
+status = px.pie(df_state_detail, values='count', names = 'time', width=WIDTH, title="State of the Car")
+st.plotly_chart(status)

pages/2_Simulateur_Seuil.py

@@ -0,0 +1,200 @@
+
+#https://www.youtube.com/watch?v=D0D4Pa22iG0&t=41s
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+
+
+st.title("Simulateur de Seuil")
+
+df = pd.read_excel("get_around_delay_analysis.xlsx")
+
+#st.write(df)
+
+# Mask sur les Canceled
+mask_canceled = df['state'] == 'canceled'
+
+# Mask Delay Checkout supérieur à zéro (donc retard)
+mask_delay = df['delay_at_checkout_in_minutes'] > 0
+df_delay = df[mask_delay]
+
+#Mask sur les Canceled Vs Delay
+df_delay_canceled = df_delay['state'] == 'canceled'
+df_canceled_data = df_delay[df_delay_canceled]
+
+# Groupe "canceled" et Filtre NA sur time_delta
+canceled_vs_delta = df[mask_canceled]
+mask_delta = canceled_vs_delta['time_delta_with_previous_rental_in_minutes'].isna()==False
+canceled_vs_delta_1 = canceled_vs_delta[mask_delta]
+
+# Filtre time_delta > 0
+delta_nb_mask = df['time_delta_with_previous_rental_in_minutes'] > 0
+
+# DataFrame time_delta > 0
+delta_nb_dataf = df[delta_nb_mask]
+
+# Mask time_delta > 0 et state = canceled
+delta_mask_canceled = delta_nb_dataf['state']=='canceled'
+
+#Nombre de cancel avec time_delta > 0
+delta_mask_nb = delta_nb_dataf[delta_mask_canceled]
+#st.write(f'Nombre de Canceled à la 2e location : {delta_mask_nb.shape[0]}')
+delta_mask_ended= delta_nb_dataf['state']=='ended'
+
+#nombre de Ended avec time_delta > 0
+delta_mask_ended_nb = delta_nb_dataf[delta_mask_ended]
+#st.write(f'Nombre de Ended à la 2e location : {delta_mask_ended_nb.shape[0]}')
+#st.write(f"Pourcentage de perte ou de cancel avec un Time Delta > 0 : {round(delta_mask_nb.shape[0] / (delta_mask_nb.shape[0] + delta_mask_ended_nb.shape[0]) * 100, 2)}%")
+
+# canceled_vs_delta_1 = Filtre sur Cancel
+# Calcul nombre de cancel (nombre de lignes) (time_delta en fonction des minutes de temps_cancel donné)
+
+delta_nb_dataf = df[delta_nb_mask]
+delta_nb = delta_nb_dataf.shape[0]
+
+#temps_cancel = [1, 5, 10, 15, 20, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 400, 500, 600, 700, 750]
+
+#Annulation au total
+def cancel(tps_cancel):
+    cancel_10min = (canceled_vs_delta_1[(canceled_vs_delta_1["time_delta_with_previous_rental_in_minutes"] <= tps_cancel)])
+    pourcent_annul = round((cancel_10min.shape[0]/delta_nb)*100,2)
+    #st.write(f"Pourcentage d'annulation après {tps_cancel}min d'attente pour 2e location : {round((cancel_10min.shape[0]/delta_nb)*100,2)}% 😤")
+    return pourcent_annul
+
+# Pourcentage de d'annulation en Mobile selon le temps d'attente
+
+delta_mask_mobile = delta_mask_nb['checkin_type']== 'mobile'
+delta_mobile_nb = delta_mask_nb[delta_mask_mobile]
+
+#Annulation par device : ici mobile
+def cancel_mobile(tps_cancel):
+    cancel_10min = (delta_mobile_nb[(delta_mobile_nb["time_delta_with_previous_rental_in_minutes"] <= tps_cancel)])
+    pourcent_annul_mobile = round((cancel_10min.shape[0]/delta_nb)*100,2)
+    #print(f"Pourcentage d'annulation mobile - 📵 - après {i}min d'attente pour 2e location : {round((cancel_10min.shape[0]/delta_nb)*100,2)} %")
+    return pourcent_annul_mobile
+
+# Pourcentage de d'annulation en Desktop (connect) selon le temps d'attente
+delta_mask_connect = delta_mask_nb['checkin_type']== 'connect'
+delta_connect_nb = delta_mask_nb[delta_mask_connect]
+
+#Annulation par device : ici Desktop
+def cancel_desktop(tps_cancel):
+    cancel_10min = (delta_connect_nb [(delta_connect_nb["time_delta_with_previous_rental_in_minutes"] <= tps_cancel)])
+    pourcent_annul_desktop = round((cancel_10min.shape[0]/delta_nb)*100,2)
+    #print(f"Pourcentage d'annulation - Desktop 🖥 -  après {i}min d'attente pour 2e location : {round((cancel_10min.shape[0]/delta_nb)*100,2)}%")
+    return pourcent_annul_desktop
+
+mask_delta = df['time_delta_with_previous_rental_in_minutes'] >=  0
+delta = df[mask_delta]
+delta_canceled = delta[delta['state'] == 'canceled']
+# Manque à gagner
+def manque_a_gagner(tps_cancel):
+    cancel_now = (delta_canceled [(delta_canceled["time_delta_with_previous_rental_in_minutes"] <= tps_cancel)])
+    client_perdus = cancel_now.shape[0]
+    pourcent_clients_total = round((cancel_now.shape[0]/df.shape[0])*100, 2)
+    client_sauves = round(((delta_canceled.shape[0]-cancel_now.shape[0]) / delta_canceled.shape[0])*100, 2)
+    return client_perdus, pourcent_clients_total, client_sauves
+
+
+
+st.write("### Delta temps entre 2 locations 🚗 ⏱️ 🚗 ")
+time_delta = st.slider("en minutes", min_value=0, max_value=750, value=5)
+col1, col2, col3 = st.columns(3)
+
+
+
+#HTML et CSS pour formater les titres 
+
+# Utilisation de HTML et CSS pour renforcer la typographie
+col1.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">🚘 Total annulations</div>
+    """,
+    unsafe_allow_html=True
+)
+col1.metric(label="", value=f"{cancel(time_delta):,.1f}%")
+
+col2.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">Mobile annulations 📱</div>
+    """,
+    unsafe_allow_html=True
+)
+col2.metric(label="", value=f"{cancel_mobile(time_delta):,.1f}%")
+
+col3.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">Desktop annulations  💻</div>
+    """,
+    unsafe_allow_html=True
+)
+col3.metric(label="", value=f"{cancel_desktop(time_delta):,.1f}%")
+
+col1, col2, col3 = st.columns(3)
+
+client_perdus, pourcent_clients_total, client_sauves = manque_a_gagner(time_delta)
+
+
+#HTML et CSS pour formater les titres 
+
+# Utilisation de HTML et CSS pour renforcer la typographie
+col1.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">🤦‍♀️ Clients perdus en nb</div>
+    """,
+    unsafe_allow_html=True
+)
+col1.metric(label="", value=f"{(client_perdus):,.0f}")
+
+col2.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">🤷‍♂️ Clients perdus en % </div>
+    """,
+    unsafe_allow_html=True
+)
+col2.metric(label="", value=f"{(pourcent_clients_total):,.1f}%")
+
+col3.markdown(
+    """
+    <style>
+    .big-font {
+        font-size: 20px !important;
+        font-weight: bold;
+    }
+    </style>
+    <div class="big-font">🙋‍♀️ Clients sauvés en % </div>
+    """,
+    unsafe_allow_html=True
+)
+col3.metric(label="", value=f"{(client_sauves):,.1f}%")

pages/3_Prediction_Prix.py

@@ -0,0 +1,54 @@
+import streamlit as st
+import streamlit as st
+import requests
+
+# URL de l'API
+api_url = "https://ericjedha-getaroundapi.hf.space/predict/"
+
+# Titre de l'application
+st.title("Application de requête à l'API GetAround")
+
+# Formulaire pour saisir les informations
+with st.form("api_form"):
+    model_key = st.text_input("Model Key")
+    mileage = st.number_input("Mileage", min_value=0)
+    engine_power = st.number_input("Engine Power", min_value=0)
+    fuel = st.text_input("Fuel")
+    paint_color = st.text_input("Paint Color")
+    car_type = st.text_input("Car Type")
+    private_parking_available = st.number_input("Private Parking Available", min_value=0, max_value=1)
+    has_gps = st.number_input("Has GPS", min_value=0, max_value=1)
+    has_air_conditioning = st.number_input("Has Air Conditioning", min_value=0, max_value=1)
+    automatic_car = st.number_input("Automatic Car", min_value=0, max_value=1)
+    has_getaround_connect = st.number_input("Has GetAround Connect", min_value=0, max_value=1)
+    has_speed_regulator = st.number_input("Has Speed Regulator", min_value=0, max_value=1)
+    winter_tires = st.number_input("Winter Tires", min_value=0, max_value=1)
+
+    # Bouton pour envoyer la requête
+    submitted = st.form_submit_button("Envoyer la requête")
+
+# Si le formulaire est soumis
+if submitted:
+    # Préparer les données à envoyer
+    data = {
+        "model_key": model_key,
+        "mileage": mileage,
+        "engine_power": engine_power,
+        "fuel": fuel,
+        "paint_color": paint_color,
+        "car_type": car_type,
+        "private_parking_available": private_parking_available,
+        "has_gps": has_gps,
+        "has_air_conditioning": has_air_conditioning,
+        "automatic_car": automatic_car,
+        "has_getaround_connect": has_getaround_connect,
+        "has_speed_regulator": has_speed_regulator,
+        "winter_tires": winter_tires
+    }
+
+    # Envoyer la requête POST
+    response = requests.post(api_url, json=data)
+
+    # Afficher la réponse de l'API
+    st.write("Réponse de l'API:")
+    st.json(response.json())