From 11e2e8658329c2354b20219e8c1b597dcde47f9e Mon Sep 17 00:00:00 2001 From: ajoubrel-ensae Date: Sat, 9 Mar 2024 14:50:58 +0000 Subject: [PATCH 1/5] Ajout et sauvegarde --- 1_Descriptive_Statistics_Museum.ipynb | 201 ++++++++++++-------------- 1 file changed, 93 insertions(+), 108 deletions(-) diff --git a/1_Descriptive_Statistics_Museum.ipynb b/1_Descriptive_Statistics_Museum.ipynb index 1023f39..859c41b 100644 --- a/1_Descriptive_Statistics_Museum.ipynb +++ b/1_Descriptive_Statistics_Museum.ipynb @@ -93,16 +93,106 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 4, "id": "09daec01-9927-45c7-a6d4-9b9d0340ee02", "metadata": {}, "outputs": [], "source": [ - "companies = {'musee' : ['1', '2', '3', '4', '101'],\n", + "companies = {'musee' : ['1', '2', '3', '4'], # , '101'\n", " 'sport': ['5', '6', '7', '8', '9'],\n", " 'musique' : ['10', '11', '12', '13', '14']}" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "d9ccb033-3c7a-4647-ae1a-3a439dec2ea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + } + ], + "source": [ + "# création des bases contenant les KPI pour les 5 compagnies de spectacle\n", + "\n", + "# liste des compagnies de spectacle\n", + "nb_compagnie= companies['musee']\n", + "\n", + "customer_sport = pd.DataFrame()\n", + "campaigns_sport_brut = pd.DataFrame()\n", + "campaigns_sport_kpi = pd.DataFrame()\n", + "products_sport = pd.DataFrame()\n", + "tickets_sport = pd.DataFrame()\n", + "\n", + "# début de la boucle permettant de générer des datasets agrégés pour les 5 compagnies de spectacle\n", + "for directory_path in nb_compagnie:\n", + " df_customerplus_clean_0 = display_databases(directory_path, file_name = \"customerplus_cleaned\")\n", + " df_campaigns_brut = display_databases(directory_path, file_name = \"campaigns_information\", datetime_col = ['opened_at', 'sent_at', 'campaign_sent_at'])\n", + " df_products_purchased_reduced = display_databases(directory_path, file_name = \"products_purchased_reduced\", datetime_col = ['purchase_date'])\n", + " df_target_information = display_databases(directory_path, file_name = \"target_information\")\n", + " \n", + " df_campaigns_kpi = campaigns_kpi_function(campaigns_information = df_campaigns_brut) \n", + " df_tickets_kpi = tickets_kpi_function(tickets_information = df_products_purchased_reduced)\n", + " df_customerplus_clean = customerplus_kpi_function(customerplus_clean = df_customerplus_clean_0)\n", + "\n", + " \n", + "# creation de la colonne Number compagnie, qui permettra d'agréger les résultats\n", + " df_tickets_kpi[\"number_company\"]=int(directory_path)\n", + " df_campaigns_brut[\"number_company\"]=int(directory_path)\n", + " df_campaigns_kpi[\"number_company\"]=int(directory_path)\n", + " df_customerplus_clean[\"number_company\"]=int(directory_path)\n", + " df_target_information[\"number_company\"]=int(directory_path)\n", + "\n", + "# Traitement des index\n", + " df_tickets_kpi[\"customer_id\"]= directory_path + '_' + df_tickets_kpi['customer_id'].astype('str')\n", + " df_campaigns_brut[\"customer_id\"]= directory_path + '_' + df_campaigns_brut['customer_id'].astype('str')\n", + " df_campaigns_kpi[\"customer_id\"]= directory_path + '_' + df_campaigns_kpi['customer_id'].astype('str') \n", + " df_customerplus_clean[\"customer_id\"]= directory_path + '_' + df_customerplus_clean['customer_id'].astype('str') \n", + " df_products_purchased_reduced[\"customer_id\"]= directory_path + '_' + df_products_purchased_reduced['customer_id'].astype('str') \n", + "\n", + "# Concaténation\n", + " customer_sport = pd.concat([customer_sport, df_customerplus_clean], ignore_index=True)\n", + " campaigns_sport_kpi = pd.concat([campaigns_sport_kpi, df_campaigns_kpi], ignore_index=True)\n", + " campaigns_sport_brut = pd.concat([campaigns_sport_brut, df_campaigns_brut], ignore_index=True) \n", + " tickets_sport = pd.concat([tickets_sport, df_tickets_kpi], ignore_index=True)\n", + " products_sport = pd.concat([products_sport, df_products_purchased_reduced], ignore_index=True)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "105862bd-5d66-45ed-be71-ec6e1e103963", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "ae3c0c33-55a7-4a28-9a62-3ce13496917a", @@ -1247,115 +1337,10 @@ "# 1 - Comportement d'achat" ] }, - { - "cell_type": "code", - "execution_count": 34, - "id": "8917cc1b-4728-460c-8432-a633de7f039b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_1/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_2/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":13: DtypeWarning: Columns (12) have mixed types. Specify dtype option on import or set low_memory=False.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_101/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_101/products_purchased_reduced_1.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - } - ], - "source": [ - "for company_number in ['1', '2', '3', '4', '101'] :\n", - " nom_dataframe = 'df'+ company_number +'_tickets'\n", - " globals()[nom_dataframe] = display_databases(company_number, file_name = 'products_purchased_reduced' , datetime_col = ['purchase_date'])\n", - "\n", - " if company_number == \"101\" :\n", - " df101_tickets_1 = display_databases(company_number, file_name = 'products_purchased_reduced_1' , datetime_col = ['purchase_date'])\n", - "\n", - " " - ] - }, { "cell_type": "markdown", "id": "3479960c-0d23-45f1-8fff-d87395205731", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, + "metadata": {}, "source": [ "## Outlier" ] From 14922dccfa85123d5ae539590bc33f82d6822868 Mon Sep 17 00:00:00 2001 From: ajoubrel-ensae Date: Sat, 9 Mar 2024 16:20:32 +0000 Subject: [PATCH 2/5] Ajout des graphiques communs --- 1_Descriptive_Statistics_Museum.ipynb | 838 +++++++++++++++++++++++++- 1 file changed, 818 insertions(+), 20 deletions(-) diff --git a/1_Descriptive_Statistics_Museum.ipynb b/1_Descriptive_Statistics_Museum.ipynb index 859c41b..0247d9a 100644 --- a/1_Descriptive_Statistics_Museum.ipynb +++ b/1_Descriptive_Statistics_Museum.ipynb @@ -93,21 +93,22 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "09daec01-9927-45c7-a6d4-9b9d0340ee02", "metadata": {}, "outputs": [], "source": [ "companies = {'musee' : ['1', '2', '3', '4'], # , '101'\n", - " 'sport': ['5', '6', '7', '8', '9'],\n", " 'musique' : ['10', '11', '12', '13', '14']}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "d9ccb033-3c7a-4647-ae1a-3a439dec2ea1", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -136,6 +137,209 @@ "text": [ ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/campaigns_information.csv\n", + "File path : projet-bdc2324-team1/0_Input/Company_2/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (12) have mixed types. Specify dtype option on import or set low_memory=False.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] } ], "source": [ @@ -144,11 +348,11 @@ "# liste des compagnies de spectacle\n", "nb_compagnie= companies['musee']\n", "\n", - "customer_sport = pd.DataFrame()\n", - "campaigns_sport_brut = pd.DataFrame()\n", - "campaigns_sport_kpi = pd.DataFrame()\n", - "products_sport = pd.DataFrame()\n", - "tickets_sport = pd.DataFrame()\n", + "customer_musee = pd.DataFrame()\n", + "campaigns_musee_brut = pd.DataFrame()\n", + "campaigns_musee_kpi = pd.DataFrame()\n", + "products_musee = pd.DataFrame()\n", + "tickets_musee = pd.DataFrame()\n", "\n", "# début de la boucle permettant de générer des datasets agrégés pour les 5 compagnies de spectacle\n", "for directory_path in nb_compagnie:\n", @@ -177,21 +381,153 @@ " df_products_purchased_reduced[\"customer_id\"]= directory_path + '_' + df_products_purchased_reduced['customer_id'].astype('str') \n", "\n", "# Concaténation\n", - " customer_sport = pd.concat([customer_sport, df_customerplus_clean], ignore_index=True)\n", - " campaigns_sport_kpi = pd.concat([campaigns_sport_kpi, df_campaigns_kpi], ignore_index=True)\n", - " campaigns_sport_brut = pd.concat([campaigns_sport_brut, df_campaigns_brut], ignore_index=True) \n", - " tickets_sport = pd.concat([tickets_sport, df_tickets_kpi], ignore_index=True)\n", - " products_sport = pd.concat([products_sport, df_products_purchased_reduced], ignore_index=True)\n", + " customer_musee = pd.concat([customer_musee, df_customerplus_clean], ignore_index=True)\n", + " campaigns_musee_kpi = pd.concat([campaigns_musee_kpi, df_campaigns_kpi], ignore_index=True)\n", + " campaigns_musee_brut = pd.concat([campaigns_musee_brut, df_campaigns_brut], ignore_index=True) \n", + " tickets_musee = pd.concat([tickets_musee, df_tickets_kpi], ignore_index=True)\n", + " products_musee = pd.concat([products_musee, df_products_purchased_reduced], ignore_index=True)\n", " " ] }, { "cell_type": "code", - "execution_count": null, - "id": "105862bd-5d66-45ed-be71-ec6e1e103963", - "metadata": {}, + "execution_count": 25, + "id": "e6324fb6-7432-4925-beb0-a831a13be7d5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 1005251 entries, 0 to 1005250\n", + "Data columns (total 28 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 customer_id 1005251 non-null object \n", + " 1 street_id 1005251 non-null int64 \n", + " 2 structure_id 92386 non-null float64\n", + " 3 mcp_contact_id 453246 non-null float64\n", + " 4 fidelity 1005251 non-null int64 \n", + " 5 tenant_id 1005251 non-null int64 \n", + " 6 is_partner 1005251 non-null bool \n", + " 7 deleted_at 0 non-null float64\n", + " 8 gender 1005251 non-null int64 \n", + " 9 is_email_true 1005251 non-null bool \n", + " 10 opt_in 1005251 non-null bool \n", + " 11 last_buying_date 625674 non-null object \n", + " 12 max_price 625674 non-null float64\n", + " 13 ticket_sum 1005251 non-null int64 \n", + " 14 average_price 790528 non-null float64\n", + " 15 average_purchase_delay 625674 non-null float64\n", + " 16 average_price_basket 625674 non-null float64\n", + " 17 average_ticket_basket 625674 non-null float64\n", + " 18 total_price 840397 non-null float64\n", + " 19 purchase_count 1005251 non-null int64 \n", + " 20 first_buying_date 625674 non-null object \n", + " 21 country 593083 non-null object \n", + " 22 gender_label 1005251 non-null object \n", + " 23 gender_female 1005251 non-null int64 \n", + " 24 gender_male 1005251 non-null int64 \n", + " 25 gender_other 1005251 non-null int64 \n", + " 26 country_fr 593083 non-null float64\n", + " 27 number_company 1005251 non-null int64 \n", + "dtypes: bool(3), float64(10), int64(10), object(5)\n", + "memory usage: 194.6+ MB\n" + ] + } + ], + "source": [ + "customer_musee.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e7fa2e45-cb48-4c79-994f-9f836d566c21", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [], - "source": [] + "source": [ + "anonymous_customer = {'1' : '1_1', '2' : '2_12184', '3' : '3_1', '4' : '4_2', '101' : '101_1',\n", + " '5' : '5_191835', '6' : '6_591412', '7' : '7_49632', '8' : '8_1942', '9' : '9_19683',\n", + " '10' : '10_19521', '11' : '11_36', '12' : '12_1706757', '13' : '13_8422', '14' : '14_6354'}" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "51d02f4f-980c-4ab9-b295-f9632af9c2f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1_1',\n", + " '2_12184',\n", + " '3_1',\n", + " '4_2',\n", + " '101_1',\n", + " '5_191835',\n", + " '6_591412',\n", + " '7_49632',\n", + " '8_1942',\n", + " '9_19683',\n", + " '10_19521',\n", + " '11_36',\n", + " '12_1706757',\n", + " '13_8422',\n", + " '14_6354']" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(anonymous_customer.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "70b6e961-c303-465e-93f4-609721d38454", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# On filtre les outliers\n", + "\n", + "def remove_elements(lst, elements_to_remove):\n", + " return ''.join([x for x in lst if x not in elements_to_remove])\n", + " \n", + "databases = [customer_musee, campaigns_musee_kpi, tickets_musee, products_musee]\n", + "\n", + "outlier_list = list(anonymous_customer.values())\n", + "\n", + "\n", + "customer_musee = customer_musee[~customer_musee['customer_id'].isin(outlier_list)]\n", + "campaigns_musee_kpi = campaigns_musee_kpi[~campaigns_musee_kpi['customer_id'].isin(outlier_list)]\n", + "tickets_musee = tickets_musee[~tickets_musee['customer_id'].isin(outlier_list)]\n", + "products_musee = products_musee[~products_musee['customer_id'].isin(outlier_list)]" + ] }, { "cell_type": "markdown", @@ -1332,7 +1668,9 @@ { "cell_type": "markdown", "id": "45d5261f-4d46-49cb-8582-dd2121122b05", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 1 - Comportement d'achat" ] @@ -3767,7 +4105,9 @@ { "cell_type": "markdown", "id": "d679204b-f3e8-4502-8de9-3bf4180da3bd", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 2 - Autres informations sur client " ] @@ -3981,6 +4321,464 @@ "source": [ "tags_comparaison" ] + }, + { + "cell_type": "markdown", + "id": "507c1db3-1d6c-4106-a9a2-0187055e0480", + "metadata": {}, + "source": [ + "# 3 - Graphiques communs" + ] + }, + { + "cell_type": "markdown", + "id": "aac367ed-9d5e-482a-a376-bfc7d1a5767e", + "metadata": {}, + "source": [ + "## Nombre de clients" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "94254c32-dc81-42f2-9d27-372ff38c70ed", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_nb_clients(customer_musee):\n", + " company_nb_clients = customer_musee[customer_musee[\"purchase_count\"]>0].groupby(\"number_company\")[\"customer_id\"].count().reset_index()\n", + " plt.bar(company_nb_clients[\"number_company\"], company_nb_clients[\"customer_id\"]/1000)\n", + "\n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (milliers)\")\n", + " plt.title(\"Nombre de clients de chaque compagnie de musee\")\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "aed68c8c-1912-4d8d-a974-11ad371f6ee8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compute_nb_clients(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "5eb3efcc-c7a9-4a0e-aab1-29a36032cb31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de consentement à la reception de mails" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "848963c9-6129-4106-80b5-76bf814b70d1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/1336968363.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n" + ] + } + ], + "source": [ + "customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n", + "\n", + "def mailing_consent(customer_musee):\n", + " df_graph = customer_musee.groupby([\"number_company\", \"already_purchased\"])[\"opt_in\"].mean().reset_index()\n", + " # Création du barplot groupé\n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " \n", + " categories = df_graph[\"number_company\"].unique()\n", + " bar_width = 0.35\n", + " bar_positions = np.arange(len(categories))\n", + " \n", + " # Grouper les données par label et créer les barres groupées\n", + " for label in df_graph[\"already_purchased\"].unique():\n", + " label_data = df_graph[df_graph['already_purchased'] == label]\n", + " values = [label_data[label_data['number_company'] == category]['opt_in'].values[0]*100 for category in categories]\n", + " \n", + " label_printed = \"purchased\" if label else \"no purchase\"\n", + " ax.bar(bar_positions, values, bar_width, label=label_printed)\n", + " \n", + " # Mise à jour des positions des barres pour le prochain groupe\n", + " bar_positions = [pos + bar_width for pos in bar_positions]\n", + " \n", + " # Ajout des étiquettes, de la légende, etc.\n", + " ax.set_xlabel('Numero de compagnie')\n", + " ax.set_ylabel('Part de consentement (%)')\n", + " ax.set_title('Part de consentement au mailing selon les compagnies')\n", + " ax.set_xticks([pos + bar_width / 2 for pos in np.arange(len(categories))])\n", + " ax.set_xticklabels(categories)\n", + " ax.legend()\n", + " \n", + " # Affichage du plot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "c7239078-5c1a-4522-8d72-848efe7df28f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mailing_consent(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "a6c94f0f-4ef4-432f-b2c9-11f51627b7e9", + "metadata": {}, + "source": [ + "## Part homme / femme client" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "321feb43-242e-4147-a5c8-ad1b41fc1246", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
customer_idstreet_idstructure_idmcp_contact_idfidelitytenant_idis_partnerdeleted_atgenderis_email_trueopt_inlast_buying_datemax_priceticket_sumaverage_priceaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepurchase_countfirst_buying_datecountrygender_labelgender_femalegender_malegender_othercountry_frnumber_companyalready_purchased
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [customer_id, street_id, structure_id, mcp_contact_id, fidelity, tenant_id, is_partner, deleted_at, gender, is_email_true, opt_in, last_buying_date, max_price, ticket_sum, average_price, average_purchase_delay, average_price_basket, average_ticket_basket, total_price, purchase_count, first_buying_date, country, gender_label, gender_female, gender_male, gender_other, country_fr, number_company, already_purchased]\n", + "Index: []" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "customer_musee[customer_musee['gender_male'] + customer_musee['gender_female'] + customer_musee['gender_other'] == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "3bb5dc1e-05dc-41da-83bb-cb6b8d43fa73", + "metadata": {}, + "outputs": [], + "source": [ + "def gender_bar(customer_musee):\n", + " company_genders = customer_musee.groupby(\"number_company\")[[\"gender_male\", \"gender_female\", \"gender_other\"]].mean().reset_index()\n", + " \n", + " # Création du barplot\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_male\"], label = \"Homme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_female\"], \n", + " bottom = company_genders[\"gender_male\"], label = \"Femme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_other\"], \n", + " bottom = company_genders[\"gender_male\"] + company_genders[\"gender_female\"], label = \"Inconnu\")\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients de chaque sexe\")\n", + " plt.title(\"Sexe des clients de chaque compagnie de musee\")\n", + " plt.legend()\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_genders[\"number_company\"], [\"{}\".format(i) for i in company_genders[\"number_company\"]])\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "c61c4b41-ba31-44f4-9515-25922798b86a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gender_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "b02a2668-5cea-44db-b2b5-168f7738a949", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de clients français" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "4b3bb641-814b-4679-9a67-4eca87a920a6", + "metadata": {}, + "outputs": [], + "source": [ + "def country_bar(customer_sport):\n", + " company_country_fr = customer_sport.groupby(\"number_company\")[\"country_fr\"].mean().reset_index()\n", + " # Création du barplot\n", + " plt.bar(company_country_fr[\"number_company\"], company_country_fr[\"country_fr\"])\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients français\")\n", + " plt.title(\"Nationalité des clients de chaque compagnie de musée\")\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_country_fr[\"number_company\"], [\"{}\".format(i) for i in company_country_fr[\"number_company\"]])\n", + "\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "01258674-6b98-49e4-93f4-f4185964999f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "country_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "6c9e8051-06d1-44ed-aa17-eb8ddd9fb5ed", + "metadata": {}, + "source": [ + "## Ouverture mails" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "e346fdc0-617f-463b-af29-caa0d9f88485", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def campaigns_effectiveness(customer_sport, Train=False):\n", + " if not Train:\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n", + "\n", + " nb_customers_purchasing = customer_sport[customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + " nb_customers_no_purchase = customer_sport[~customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + "\n", + " plt.bar(nb_customers_purchasing[\"number_company\"], nb_customers_purchasing[\"customer_id\"]/1000, label = \"has purchased\")\n", + " plt.bar(nb_customers_no_purchase[\"number_company\"], nb_customers_no_purchase[\"customer_id\"]/1000, \n", + " bottom = nb_customers_purchasing[\"customer_id\"]/1000, label = \"has not purchased\")\n", + " \n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (en milliers)\")\n", + " plt.title(\"Nombre de clients ayant acheté ou été ciblés par des mails pour les compagnies de musée\")\n", + " plt.legend()\n", + "\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "928dab1d-96ff-4fc2-91ea-2ff119620f31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/3480143790.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "campaigns_effectiveness(customer_musee)" + ] } ], "metadata": { From 0b56e4e6961d75dc7e5e6fecdfbc309a84c036e3 Mon Sep 17 00:00:00 2001 From: ajoubrel-ensae Date: Sat, 9 Mar 2024 17:49:45 +0000 Subject: [PATCH 3/5] =?UTF-8?q?Ajout=20dossier=20mus=C3=A9e=20+=20debut=20?= =?UTF-8?q?modelisation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Musee/1_Descriptive_Statistics_Museum.ipynb | 4804 +++++++++++++++++++ Musee/2_modelisation_pipeline+visu.ipynb | 2877 +++++++++++ 2 files changed, 7681 insertions(+) create mode 100644 Musee/1_Descriptive_Statistics_Museum.ipynb create mode 100644 Musee/2_modelisation_pipeline+visu.ipynb diff --git a/Musee/1_Descriptive_Statistics_Museum.ipynb b/Musee/1_Descriptive_Statistics_Museum.ipynb new file mode 100644 index 0000000..b172044 --- /dev/null +++ b/Musee/1_Descriptive_Statistics_Museum.ipynb @@ -0,0 +1,4804 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f41343f-7205-41d9-89dd-88039e301413", + "metadata": {}, + "source": [ + "# Statistiques descriptives" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "abfaf341-7b35-4407-9133-d21336c04027", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "import s3fs\n", + "import re\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "from datetime import datetime, date, timedelta\n", + "from dateutil.relativedelta import relativedelta\n", + "import warnings" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7fb72fa3-7940-496f-ac78-c2837f65eefa", + "metadata": {}, + "outputs": [], + "source": [ + "# Create filesystem object\n", + "S3_ENDPOINT_URL = \"https://\" + os.environ[\"AWS_S3_ENDPOINT\"]\n", + "fs = s3fs.S3FileSystem(client_kwargs={'endpoint_url': S3_ENDPOINT_URL})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c34e13f4-e043-43d6-ba8c-2e13d008647c", + "metadata": {}, + "outputs": [], + "source": [ + "# Import cleaning and merge functions\n", + "exec(open('0_KPI_functions.py').read())\n", + "\n", + "# Useful functions :\n", + " # display_databases(directory_path, file_name = ['customerplus_cleaned', 'target_information', 'campaigns_information', 'products_purchased_reduced'], datetime_col = None)\n", + " # campaigns_kpi_function(campaigns_information = None)\n", + " # tickets_kpi_function(tickets_information = None)\n", + " # customerplus_kpi_function(customerplus_clean = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c60505f4-b95b-4c61-b842-26b27af7e280", + "metadata": {}, + "outputs": [], + "source": [ + "# set the max columns to none\n", + "pd.set_option('display.max_columns', None)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aaffd291-2c88-44c8-a951-0ef1f8369ba3", + "metadata": {}, + "outputs": [], + "source": [ + "# Additional function to load initial \n", + "def load_dataset_2(directory_path, file_name):\n", + " \"\"\"\n", + " This function loads csv file\n", + " \"\"\"\n", + " file_path = \"bdc2324-data\" + \"/\" + directory_path + \"/\" + directory_path + file_name + \".csv\"\n", + " with fs.open(file_path, mode=\"rb\") as file_in:\n", + " df = pd.read_csv(file_in, sep=\",\")\n", + "\n", + " # drop na :\n", + " #df = df.dropna(axis=1, thresh=len(df))\n", + " # if identifier in table : delete it\n", + " if 'identifier' in df.columns:\n", + " df = df.drop(columns = 'identifier')\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "09daec01-9927-45c7-a6d4-9b9d0340ee02", + "metadata": {}, + "outputs": [], + "source": [ + "companies = {'musee' : ['1', '2', '3', '4'], # , '101'\n", + " 'musique' : ['10', '11', '12', '13', '14']}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d9ccb033-3c7a-4647-ae1a-3a439dec2ea1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/campaigns_information.csv\n", + "File path : projet-bdc2324-team1/0_Input/Company_2/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (12) have mixed types. Specify dtype option on import or set low_memory=False.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + } + ], + "source": [ + "# création des bases contenant les KPI pour les 5 compagnies de spectacle\n", + "\n", + "# liste des compagnies de spectacle\n", + "nb_compagnie= companies['musee']\n", + "\n", + "customer_musee = pd.DataFrame()\n", + "campaigns_musee_brut = pd.DataFrame()\n", + "campaigns_musee_kpi = pd.DataFrame()\n", + "products_musee = pd.DataFrame()\n", + "tickets_musee = pd.DataFrame()\n", + "\n", + "# début de la boucle permettant de générer des datasets agrégés pour les 5 compagnies de spectacle\n", + "for directory_path in nb_compagnie:\n", + " df_customerplus_clean_0 = display_databases(directory_path, file_name = \"customerplus_cleaned\")\n", + " df_campaigns_brut = display_databases(directory_path, file_name = \"campaigns_information\", datetime_col = ['opened_at', 'sent_at', 'campaign_sent_at'])\n", + " df_products_purchased_reduced = display_databases(directory_path, file_name = \"products_purchased_reduced\", datetime_col = ['purchase_date'])\n", + " df_target_information = display_databases(directory_path, file_name = \"target_information\")\n", + " \n", + " df_campaigns_kpi = campaigns_kpi_function(campaigns_information = df_campaigns_brut) \n", + " df_tickets_kpi = tickets_kpi_function(tickets_information = df_products_purchased_reduced)\n", + " df_customerplus_clean = customerplus_kpi_function(customerplus_clean = df_customerplus_clean_0)\n", + "\n", + " \n", + "# creation de la colonne Number compagnie, qui permettra d'agréger les résultats\n", + " df_tickets_kpi[\"number_company\"]=int(directory_path)\n", + " df_campaigns_brut[\"number_company\"]=int(directory_path)\n", + " df_campaigns_kpi[\"number_company\"]=int(directory_path)\n", + " df_customerplus_clean[\"number_company\"]=int(directory_path)\n", + " df_target_information[\"number_company\"]=int(directory_path)\n", + "\n", + "# Traitement des index\n", + " df_tickets_kpi[\"customer_id\"]= directory_path + '_' + df_tickets_kpi['customer_id'].astype('str')\n", + " df_campaigns_brut[\"customer_id\"]= directory_path + '_' + df_campaigns_brut['customer_id'].astype('str')\n", + " df_campaigns_kpi[\"customer_id\"]= directory_path + '_' + df_campaigns_kpi['customer_id'].astype('str') \n", + " df_customerplus_clean[\"customer_id\"]= directory_path + '_' + df_customerplus_clean['customer_id'].astype('str') \n", + " df_products_purchased_reduced[\"customer_id\"]= directory_path + '_' + df_products_purchased_reduced['customer_id'].astype('str') \n", + "\n", + "# Concaténation\n", + " customer_musee = pd.concat([customer_musee, df_customerplus_clean], ignore_index=True)\n", + " campaigns_musee_kpi = pd.concat([campaigns_musee_kpi, df_campaigns_kpi], ignore_index=True)\n", + " campaigns_musee_brut = pd.concat([campaigns_musee_brut, df_campaigns_brut], ignore_index=True) \n", + " tickets_musee = pd.concat([tickets_musee, df_tickets_kpi], ignore_index=True)\n", + " products_musee = pd.concat([products_musee, df_products_purchased_reduced], ignore_index=True)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e6324fb6-7432-4925-beb0-a831a13be7d5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 1005251 entries, 0 to 1005250\n", + "Data columns (total 28 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 customer_id 1005251 non-null object \n", + " 1 street_id 1005251 non-null int64 \n", + " 2 structure_id 92386 non-null float64\n", + " 3 mcp_contact_id 453246 non-null float64\n", + " 4 fidelity 1005251 non-null int64 \n", + " 5 tenant_id 1005251 non-null int64 \n", + " 6 is_partner 1005251 non-null bool \n", + " 7 deleted_at 0 non-null float64\n", + " 8 gender 1005251 non-null int64 \n", + " 9 is_email_true 1005251 non-null bool \n", + " 10 opt_in 1005251 non-null bool \n", + " 11 last_buying_date 625674 non-null object \n", + " 12 max_price 625674 non-null float64\n", + " 13 ticket_sum 1005251 non-null int64 \n", + " 14 average_price 790528 non-null float64\n", + " 15 average_purchase_delay 625674 non-null float64\n", + " 16 average_price_basket 625674 non-null float64\n", + " 17 average_ticket_basket 625674 non-null float64\n", + " 18 total_price 840397 non-null float64\n", + " 19 purchase_count 1005251 non-null int64 \n", + " 20 first_buying_date 625674 non-null object \n", + " 21 country 593083 non-null object \n", + " 22 gender_label 1005251 non-null object \n", + " 23 gender_female 1005251 non-null int64 \n", + " 24 gender_male 1005251 non-null int64 \n", + " 25 gender_other 1005251 non-null int64 \n", + " 26 country_fr 593083 non-null float64\n", + " 27 number_company 1005251 non-null int64 \n", + "dtypes: bool(3), float64(10), int64(10), object(5)\n", + "memory usage: 194.6+ MB\n" + ] + } + ], + "source": [ + "customer_musee.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e7fa2e45-cb48-4c79-994f-9f836d566c21", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "anonymous_customer = {'1' : '1_1', '2' : '2_12184', '3' : '3_1', '4' : '4_2', '101' : '101_1',\n", + " '5' : '5_191835', '6' : '6_591412', '7' : '7_49632', '8' : '8_1942', '9' : '9_19683',\n", + " '10' : '10_19521', '11' : '11_36', '12' : '12_1706757', '13' : '13_8422', '14' : '14_6354'}" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "51d02f4f-980c-4ab9-b295-f9632af9c2f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1_1',\n", + " '2_12184',\n", + " '3_1',\n", + " '4_2',\n", + " '101_1',\n", + " '5_191835',\n", + " '6_591412',\n", + " '7_49632',\n", + " '8_1942',\n", + " '9_19683',\n", + " '10_19521',\n", + " '11_36',\n", + " '12_1706757',\n", + " '13_8422',\n", + " '14_6354']" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(anonymous_customer.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "70b6e961-c303-465e-93f4-609721d38454", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# On filtre les outliers\n", + "\n", + "def remove_elements(lst, elements_to_remove):\n", + " return ''.join([x for x in lst if x not in elements_to_remove])\n", + " \n", + "databases = [customer_musee, campaigns_musee_kpi, tickets_musee, products_musee]\n", + "\n", + "outlier_list = list(anonymous_customer.values())\n", + "\n", + "\n", + "customer_musee = customer_musee[~customer_musee['customer_id'].isin(outlier_list)]\n", + "campaigns_musee_kpi = campaigns_musee_kpi[~campaigns_musee_kpi['customer_id'].isin(outlier_list)]\n", + "tickets_musee = tickets_musee[~tickets_musee['customer_id'].isin(outlier_list)]\n", + "products_musee = products_musee[~products_musee['customer_id'].isin(outlier_list)]" + ] + }, + { + "cell_type": "markdown", + "id": "ae3c0c33-55a7-4a28-9a62-3ce13496917a", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# 0 - Specificité de la company 101" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "f8a8dedc-2f67-407c-9bbf-f70d236fc783", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idnamecreated_atupdated_atstreet_idfixed_capacity
261atelier des lumieres2020-10-12 08:57:27.783770+02:002020-10-12 08:57:27.783770+02:001NaN
1714007fabrique des lumieres2022-05-17 09:11:19.416106+02:002022-05-17 09:11:19.416106+02:002NaN
322non défini2020-10-12 08:57:27.785329+02:002020-10-12 08:57:27.785329+02:002NaN
1010755NaN2022-01-28 12:07:16.602885+01:002022-01-28 12:07:16.602885+01:002NaN
1613583hôtel de caumont2022-05-13 10:59:06.829576+02:002022-05-13 10:59:06.829576+02:00859NaN
216422atelier des lumières - cézanne2022-08-04 04:03:31.045648+02:002022-08-04 04:03:31.045648+02:00859NaN
2021098bassins des lumières - 2022 - venise2023-04-08 03:49:46.916777+02:002023-04-08 03:49:46.916777+02:00859NaN
1823460immersive box2023-08-29 17:39:55.188028+02:002023-08-29 17:39:55.188028+02:00859NaN
813584bassins des lumières - venise2022-05-13 11:00:14.943669+02:002022-05-13 11:00:14.943669+02:00859NaN
1521096atelier des lumières - 2022 - cézanne2023-04-08 03:42:10.395124+02:002023-04-08 03:42:10.395124+02:00859NaN
27260musée jacquemart andré2020-10-18 01:20:12.738229+02:002020-10-18 01:20:12.738229+02:003525NaN
3371cité de l'automobile2020-10-13 11:05:43.705639+02:002020-12-03 08:33:15.576065+01:00449992NaN
3089bassins de lumieres2020-10-13 14:56:27.206958+02:002020-10-13 14:56:27.206958+02:00460754NaN
7108les baux de provence2020-10-14 14:16:20.284658+02:002020-10-14 14:16:20.284658+02:00481475NaN
19161les carrières de lumières2020-10-14 18:06:57.059828+02:002020-10-14 18:06:57.059828+02:00483815NaN
24118villa ephrussi de rothschild2020-10-14 15:02:40.478501+02:002020-10-14 15:02:40.478501+02:00485539NaN
29128théâtre antique orange2020-10-14 15:46:44.072307+02:002020-10-14 15:46:44.072307+02:00499380NaN
283875carrieres de lumieres2021-06-11 10:52:15.706030+02:002021-06-11 10:52:15.706030+02:00535931NaN
253866baux-de-provence2021-06-11 10:28:30.237144+02:002021-06-11 10:28:30.237144+02:00569179NaN
22392tour magne de nîmes2020-10-19 17:51:45.915572+02:002020-10-19 17:51:45.915572+02:00717981NaN
3263musée maillol2020-10-18 01:30:23.853673+02:002020-10-18 01:30:23.853673+02:00852301NaN
6264cinéma d'aigues mortes2020-10-18 01:30:23.863631+02:002020-10-18 01:30:23.863631+02:00852302NaN
21388maison carrée de nîmes2020-10-19 17:37:09.345955+02:002020-10-19 17:37:09.345955+02:00867431NaN
23333les arènes de nîmes2020-10-19 10:17:55.757817+02:002020-10-19 10:17:55.757817+02:00867431NaN
31170caumont centre d'art2020-10-14 19:13:55.213186+02:002022-10-14 06:21:53.310810+02:00887751NaN
51665cité de l'auto2020-12-08 18:46:15.957997+01:002020-12-08 18:46:15.957997+01:001418086NaN
1411836phoenix des lumières2022-03-08 16:30:03.135537+01:002022-03-08 16:30:03.135537+01:003639035NaN
113501château de boutemont2022-05-10 14:56:36.025562+02:002022-05-10 14:56:36.025562+02:004209418NaN
413502fabrique des lumières2022-05-10 15:05:40.443121+02:002022-05-10 15:05:40.443121+02:004209419NaN
1222219immersive box belgique2023-06-13 16:17:37.818103+02:002023-06-13 16:17:37.818103+02:007335205NaN
1322512hall des lumières2023-06-29 09:31:23.575220+02:002023-06-29 09:31:23.575220+02:007364467NaN
1122348hdl2023-06-20 17:58:19.153019+02:002023-06-29 09:38:51.592547+02:007364467NaN
022516hall des lumieres2023-06-29 09:46:44.718839+02:002023-06-29 09:46:44.718839+02:007364467NaN
911835hdl - ny2022-03-08 16:00:20.821212+01:002023-06-29 09:27:59.256591+02:007446203NaN
\n", + "
" + ], + "text/plain": [ + " id name \\\n", + "26 1 atelier des lumieres \n", + "17 14007 fabrique des lumieres \n", + "32 2 non défini \n", + "10 10755 NaN \n", + "16 13583 hôtel de caumont \n", + "2 16422 atelier des lumières - cézanne \n", + "20 21098 bassins des lumières - 2022 - venise \n", + "18 23460 immersive box \n", + "8 13584 bassins des lumières - venise \n", + "15 21096 atelier des lumières - 2022 - cézanne \n", + "27 260 musée jacquemart andré \n", + "33 71 cité de l'automobile \n", + "30 89 bassins de lumieres \n", + "7 108 les baux de provence \n", + "19 161 les carrières de lumières \n", + "24 118 villa ephrussi de rothschild \n", + "29 128 théâtre antique orange \n", + "28 3875 carrieres de lumieres \n", + "25 3866 baux-de-provence \n", + "22 392 tour magne de nîmes \n", + "3 263 musée maillol \n", + "6 264 cinéma d'aigues mortes \n", + "21 388 maison carrée de nîmes \n", + "23 333 les arènes de nîmes \n", + "31 170 caumont centre d'art \n", + "5 1665 cité de l'auto \n", + "14 11836 phoenix des lumières \n", + "1 13501 château de boutemont \n", + "4 13502 fabrique des lumières \n", + "12 22219 immersive box belgique \n", + "13 22512 hall des lumières \n", + "11 22348 hdl \n", + "0 22516 hall des lumieres \n", + "9 11835 hdl - ny \n", + "\n", + " created_at updated_at \\\n", + "26 2020-10-12 08:57:27.783770+02:00 2020-10-12 08:57:27.783770+02:00 \n", + "17 2022-05-17 09:11:19.416106+02:00 2022-05-17 09:11:19.416106+02:00 \n", + "32 2020-10-12 08:57:27.785329+02:00 2020-10-12 08:57:27.785329+02:00 \n", + "10 2022-01-28 12:07:16.602885+01:00 2022-01-28 12:07:16.602885+01:00 \n", + "16 2022-05-13 10:59:06.829576+02:00 2022-05-13 10:59:06.829576+02:00 \n", + "2 2022-08-04 04:03:31.045648+02:00 2022-08-04 04:03:31.045648+02:00 \n", + "20 2023-04-08 03:49:46.916777+02:00 2023-04-08 03:49:46.916777+02:00 \n", + "18 2023-08-29 17:39:55.188028+02:00 2023-08-29 17:39:55.188028+02:00 \n", + "8 2022-05-13 11:00:14.943669+02:00 2022-05-13 11:00:14.943669+02:00 \n", + "15 2023-04-08 03:42:10.395124+02:00 2023-04-08 03:42:10.395124+02:00 \n", + "27 2020-10-18 01:20:12.738229+02:00 2020-10-18 01:20:12.738229+02:00 \n", + "33 2020-10-13 11:05:43.705639+02:00 2020-12-03 08:33:15.576065+01:00 \n", + "30 2020-10-13 14:56:27.206958+02:00 2020-10-13 14:56:27.206958+02:00 \n", + "7 2020-10-14 14:16:20.284658+02:00 2020-10-14 14:16:20.284658+02:00 \n", + "19 2020-10-14 18:06:57.059828+02:00 2020-10-14 18:06:57.059828+02:00 \n", + "24 2020-10-14 15:02:40.478501+02:00 2020-10-14 15:02:40.478501+02:00 \n", + "29 2020-10-14 15:46:44.072307+02:00 2020-10-14 15:46:44.072307+02:00 \n", + "28 2021-06-11 10:52:15.706030+02:00 2021-06-11 10:52:15.706030+02:00 \n", + "25 2021-06-11 10:28:30.237144+02:00 2021-06-11 10:28:30.237144+02:00 \n", + "22 2020-10-19 17:51:45.915572+02:00 2020-10-19 17:51:45.915572+02:00 \n", + "3 2020-10-18 01:30:23.853673+02:00 2020-10-18 01:30:23.853673+02:00 \n", + "6 2020-10-18 01:30:23.863631+02:00 2020-10-18 01:30:23.863631+02:00 \n", + "21 2020-10-19 17:37:09.345955+02:00 2020-10-19 17:37:09.345955+02:00 \n", + "23 2020-10-19 10:17:55.757817+02:00 2020-10-19 10:17:55.757817+02:00 \n", + "31 2020-10-14 19:13:55.213186+02:00 2022-10-14 06:21:53.310810+02:00 \n", + "5 2020-12-08 18:46:15.957997+01:00 2020-12-08 18:46:15.957997+01:00 \n", + "14 2022-03-08 16:30:03.135537+01:00 2022-03-08 16:30:03.135537+01:00 \n", + "1 2022-05-10 14:56:36.025562+02:00 2022-05-10 14:56:36.025562+02:00 \n", + "4 2022-05-10 15:05:40.443121+02:00 2022-05-10 15:05:40.443121+02:00 \n", + "12 2023-06-13 16:17:37.818103+02:00 2023-06-13 16:17:37.818103+02:00 \n", + "13 2023-06-29 09:31:23.575220+02:00 2023-06-29 09:31:23.575220+02:00 \n", + "11 2023-06-20 17:58:19.153019+02:00 2023-06-29 09:38:51.592547+02:00 \n", + "0 2023-06-29 09:46:44.718839+02:00 2023-06-29 09:46:44.718839+02:00 \n", + "9 2022-03-08 16:00:20.821212+01:00 2023-06-29 09:27:59.256591+02:00 \n", + "\n", + " street_id fixed_capacity \n", + "26 1 NaN \n", + "17 2 NaN \n", + "32 2 NaN \n", + "10 2 NaN \n", + "16 859 NaN \n", + "2 859 NaN \n", + "20 859 NaN \n", + "18 859 NaN \n", + "8 859 NaN \n", + "15 859 NaN \n", + "27 3525 NaN \n", + "33 449992 NaN \n", + "30 460754 NaN \n", + "7 481475 NaN \n", + "19 483815 NaN \n", + "24 485539 NaN \n", + "29 499380 NaN \n", + "28 535931 NaN \n", + "25 569179 NaN \n", + "22 717981 NaN \n", + "3 852301 NaN \n", + "6 852302 NaN \n", + "21 867431 NaN \n", + "23 867431 NaN \n", + "31 887751 NaN \n", + "5 1418086 NaN \n", + "14 3639035 NaN \n", + "1 4209418 NaN \n", + "4 4209419 NaN \n", + "12 7335205 NaN \n", + "13 7364467 NaN \n", + "11 7364467 NaN \n", + "0 7364467 NaN \n", + "9 7446203 NaN " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "company_number = '101'\n", + "\n", + "facilities = load_dataset_2(company_number, \"facilities\")\n", + "\n", + "facilities.sort_values(by = 'street_id')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c8c8eea4-21a2-487b-b20a-15d73616a253", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
id_xsent_atsoftwaresatisfactionextra_fieldcustomer_idcontribution_site_idcreated_at_xupdated_at_xid_yfacility_idcreated_at_yupdated_at_y
01349102017-07-30 15:50:15+02:00NaN8.0NaN91936702020-09-25 20:41:07.752795+02:002020-09-25 20:41:07.752795+02:00704382020-09-25 20:41:07.735280+02:002020-09-25 20:41:07.735280+02:00
158484272020-03-04 16:18:13.597000+01:00NaNNaNNaN22445034202022-01-21 02:44:34.857144+01:002022-01-21 02:44:34.857144+01:00342066502022-01-21 02:44:34.690938+01:002022-01-21 02:44:34.690938+01:00
29183832020-10-24 14:59:22.784000+02:00NaNNaNNaN3977182082020-10-25 02:06:54.048105+02:002020-10-25 02:06:54.048105+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
39183842020-10-24 14:35:39.725000+02:00NaNNaNNaN3977192082020-10-25 02:06:54.050218+02:002020-10-25 02:06:54.050218+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
49183852020-10-24 12:45:35.225000+02:00NaN10.0NaN22082020-10-25 02:06:54.052201+02:002020-10-25 02:06:54.052201+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
..........................................
2545419512018-03-20 09:34:09+01:00NaN8.0NaN6969412020-09-25 20:06:37.138272+02:002020-09-25 20:06:37.138272+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545519522018-03-20 09:31:56+01:00NaNNaNNaN6969412020-09-25 20:06:37.138874+02:002020-09-25 20:06:37.138874+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545619542018-03-20 09:30:44+01:00NaNNaNNaN6969412020-09-25 20:06:37.140372+02:002020-09-25 20:06:37.140372+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545719552018-03-20 09:28:49+01:00NaN8.0NaN6969512020-09-25 20:06:37.140966+02:002020-09-25 20:06:37.140966+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545819532018-03-20 09:31:23.361000+01:00NaN8.0NaN212020-09-25 20:06:37.139437+02:002020-09-25 20:06:37.139437+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
\n", + "

25459 rows × 13 columns

\n", + "
" + ], + "text/plain": [ + " id_x sent_at software satisfaction \\\n", + "0 134910 2017-07-30 15:50:15+02:00 NaN 8.0 \n", + "1 5848427 2020-03-04 16:18:13.597000+01:00 NaN NaN \n", + "2 918383 2020-10-24 14:59:22.784000+02:00 NaN NaN \n", + "3 918384 2020-10-24 14:35:39.725000+02:00 NaN NaN \n", + "4 918385 2020-10-24 12:45:35.225000+02:00 NaN 10.0 \n", + "... ... ... ... ... \n", + "25454 1951 2018-03-20 09:34:09+01:00 NaN 8.0 \n", + "25455 1952 2018-03-20 09:31:56+01:00 NaN NaN \n", + "25456 1954 2018-03-20 09:30:44+01:00 NaN NaN \n", + "25457 1955 2018-03-20 09:28:49+01:00 NaN 8.0 \n", + "25458 1953 2018-03-20 09:31:23.361000+01:00 NaN 8.0 \n", + "\n", + " extra_field customer_id contribution_site_id \\\n", + "0 NaN 91936 70 \n", + "1 NaN 224450 3420 \n", + "2 NaN 397718 208 \n", + "3 NaN 397719 208 \n", + "4 NaN 2 208 \n", + "... ... ... ... \n", + "25454 NaN 69694 1 \n", + "25455 NaN 69694 1 \n", + "25456 NaN 69694 1 \n", + "25457 NaN 69695 1 \n", + "25458 NaN 2 1 \n", + "\n", + " created_at_x updated_at_x \\\n", + "0 2020-09-25 20:41:07.752795+02:00 2020-09-25 20:41:07.752795+02:00 \n", + "1 2022-01-21 02:44:34.857144+01:00 2022-01-21 02:44:34.857144+01:00 \n", + "2 2020-10-25 02:06:54.048105+02:00 2020-10-25 02:06:54.048105+02:00 \n", + "3 2020-10-25 02:06:54.050218+02:00 2020-10-25 02:06:54.050218+02:00 \n", + "4 2020-10-25 02:06:54.052201+02:00 2020-10-25 02:06:54.052201+02:00 \n", + "... ... ... \n", + "25454 2020-09-25 20:06:37.138272+02:00 2020-09-25 20:06:37.138272+02:00 \n", + "25455 2020-09-25 20:06:37.138874+02:00 2020-09-25 20:06:37.138874+02:00 \n", + "25456 2020-09-25 20:06:37.140372+02:00 2020-09-25 20:06:37.140372+02:00 \n", + "25457 2020-09-25 20:06:37.140966+02:00 2020-09-25 20:06:37.140966+02:00 \n", + "25458 2020-09-25 20:06:37.139437+02:00 2020-09-25 20:06:37.139437+02:00 \n", + "\n", + " id_y facility_id created_at_y \\\n", + "0 70 438 2020-09-25 20:41:07.735280+02:00 \n", + "1 3420 6650 2022-01-21 02:44:34.690938+01:00 \n", + "2 208 576 2020-09-27 18:05:14.671650+02:00 \n", + "3 208 576 2020-09-27 18:05:14.671650+02:00 \n", + "4 208 576 2020-09-27 18:05:14.671650+02:00 \n", + "... ... ... ... \n", + "25454 1 369 2020-09-25 20:06:35.964342+02:00 \n", + "25455 1 369 2020-09-25 20:06:35.964342+02:00 \n", + "25456 1 369 2020-09-25 20:06:35.964342+02:00 \n", + "25457 1 369 2020-09-25 20:06:35.964342+02:00 \n", + "25458 1 369 2020-09-25 20:06:35.964342+02:00 \n", + "\n", + " updated_at_y \n", + "0 2020-09-25 20:41:07.735280+02:00 \n", + "1 2022-01-21 02:44:34.690938+01:00 \n", + "2 2020-09-27 18:05:14.671650+02:00 \n", + "3 2020-09-27 18:05:14.671650+02:00 \n", + "4 2020-09-27 18:05:14.671650+02:00 \n", + "... ... \n", + "25454 2020-09-25 20:06:35.964342+02:00 \n", + "25455 2020-09-25 20:06:35.964342+02:00 \n", + "25456 2020-09-25 20:06:35.964342+02:00 \n", + "25457 2020-09-25 20:06:35.964342+02:00 \n", + "25458 2020-09-25 20:06:35.964342+02:00 \n", + "\n", + "[25459 rows x 13 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# contribution and contribution sites \n", + "contributions = load_dataset_2(company_number, \"contributions\")\n", + "contribution_sites = load_dataset_2(company_number, \"contribution_sites\")\n", + "\n", + "pd.merge(contributions, contribution_sites, left_on = 'contribution_site_id', right_on = 'id', how = 'inner')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "85b70219-f753-422e-9f57-a26eb28e7481", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "id 0.000000\n", + "sent_at 0.000000\n", + "software 1.000000\n", + "satisfaction 0.430732\n", + "extra_field 1.000000\n", + "customer_id 0.000000\n", + "contribution_site_id 0.000000\n", + "created_at 0.000000\n", + "updated_at 0.000000\n", + "dtype: float64" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "contributions.isna().sum()/len(contributions)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "647920c8-da07-4e87-964b-304fd7ff79f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idnamecreated_atupdated_at
01eur2023-07-17 15:35:19.957203+02:002023-07-17 15:35:19.957203+02:00
12usd2023-07-17 15:35:21.132408+02:002023-07-17 15:35:21.132408+02:00
23gbp2023-07-17 15:35:21.843594+02:002023-07-17 15:35:21.843594+02:00
34chf2023-07-17 15:35:23.229322+02:002023-07-17 15:35:23.229322+02:00
45cad2023-07-17 15:35:24.262466+02:002023-07-17 15:35:24.262466+02:00
\n", + "
" + ], + "text/plain": [ + " id name created_at updated_at\n", + "0 1 eur 2023-07-17 15:35:19.957203+02:00 2023-07-17 15:35:19.957203+02:00\n", + "1 2 usd 2023-07-17 15:35:21.132408+02:00 2023-07-17 15:35:21.132408+02:00\n", + "2 3 gbp 2023-07-17 15:35:21.843594+02:00 2023-07-17 15:35:21.843594+02:00\n", + "3 4 chf 2023-07-17 15:35:23.229322+02:00 2023-07-17 15:35:23.229322+02:00\n", + "4 5 cad 2023-07-17 15:35:24.262466+02:00 2023-07-17 15:35:24.262466+02:00" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "company_number = \"2\"\n", + "\n", + "load_dataset_2(company_number, \"currencies\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "bc1f3d28-7f0c-4e87-baf7-dddcf03a7145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idpercent_pricemax_pricemin_pricecategory_idpricing_formula_idrepresentation_idcreated_atupdated_at
01100.00.00.01112023-10-13 13:02:32.517137+02:002023-10-13 13:02:32.517137+02:00
12100.00.00.01122023-10-13 13:02:32.531505+02:002023-10-13 13:02:32.531505+02:00
23100.00.00.01132023-10-13 13:02:32.532172+02:002023-10-13 13:02:32.532172+02:00
34100.00.00.01142023-10-13 13:02:32.532665+02:002023-10-13 13:02:32.532665+02:00
45100.00.00.01152023-10-13 13:02:32.533142+02:002023-10-13 13:02:32.533142+02:00
..............................
779980810312100.00.00.0115672542023-11-09 05:14:16.770130+01:002023-11-09 05:14:16.770130+01:00
779981810313100.00.00.0145672542023-11-09 05:14:16.770538+01:002023-11-09 05:14:16.770538+01:00
779982810314100.00.00.0115672552023-11-09 05:14:16.770916+01:002023-11-09 05:14:16.770916+01:00
779983810315100.00.00.0115672562023-11-09 05:14:16.771359+01:002023-11-09 05:14:16.771359+01:00
779984810316100.00.00.0115672572023-11-09 05:14:16.771761+01:002023-11-09 05:14:16.771761+01:00
\n", + "

779985 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " id percent_price max_price min_price category_id \\\n", + "0 1 100.0 0.0 0.0 1 \n", + "1 2 100.0 0.0 0.0 1 \n", + "2 3 100.0 0.0 0.0 1 \n", + "3 4 100.0 0.0 0.0 1 \n", + "4 5 100.0 0.0 0.0 1 \n", + "... ... ... ... ... ... \n", + "779980 810312 100.0 0.0 0.0 1 \n", + "779981 810313 100.0 0.0 0.0 1 \n", + "779982 810314 100.0 0.0 0.0 1 \n", + "779983 810315 100.0 0.0 0.0 1 \n", + "779984 810316 100.0 0.0 0.0 1 \n", + "\n", + " pricing_formula_id representation_id \\\n", + "0 1 1 \n", + "1 1 2 \n", + "2 1 3 \n", + "3 1 4 \n", + "4 1 5 \n", + "... ... ... \n", + "779980 1 567254 \n", + "779981 4 567254 \n", + "779982 1 567255 \n", + "779983 1 567256 \n", + "779984 1 567257 \n", + "\n", + " created_at updated_at \n", + "0 2023-10-13 13:02:32.517137+02:00 2023-10-13 13:02:32.517137+02:00 \n", + "1 2023-10-13 13:02:32.531505+02:00 2023-10-13 13:02:32.531505+02:00 \n", + "2 2023-10-13 13:02:32.532172+02:00 2023-10-13 13:02:32.532172+02:00 \n", + "3 2023-10-13 13:02:32.532665+02:00 2023-10-13 13:02:32.532665+02:00 \n", + "4 2023-10-13 13:02:32.533142+02:00 2023-10-13 13:02:32.533142+02:00 \n", + "... ... ... \n", + "779980 2023-11-09 05:14:16.770130+01:00 2023-11-09 05:14:16.770130+01:00 \n", + "779981 2023-11-09 05:14:16.770538+01:00 2023-11-09 05:14:16.770538+01:00 \n", + "779982 2023-11-09 05:14:16.770916+01:00 2023-11-09 05:14:16.770916+01:00 \n", + "779983 2023-11-09 05:14:16.771359+01:00 2023-11-09 05:14:16.771359+01:00 \n", + "779984 2023-11-09 05:14:16.771761+01:00 2023-11-09 05:14:16.771761+01:00 \n", + "\n", + "[779985 rows x 9 columns]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "load_dataset_2(company_number, \"products_groups\")" + ] + }, + { + "cell_type": "markdown", + "id": "45d5261f-4d46-49cb-8582-dd2121122b05", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# 1 - Comportement d'achat" + ] + }, + { + "cell_type": "markdown", + "id": "3479960c-0d23-45f1-8fff-d87395205731", + "metadata": {}, + "source": [ + "## Outlier" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9376af51-4320-44b6-8f30-1e1234371556", + "metadata": {}, + "outputs": [], + "source": [ + "def outlier_detection(directory_path = \"1\", coupure = 1):\n", + " nom_dataframe = 'df'+ directory_path +'_tickets'\n", + " df_tickets = globals()[nom_dataframe].copy()\n", + " df_tickets_kpi = tickets_kpi_function(df_tickets)\n", + "\n", + " if directory_path == \"101\" :\n", + " df_tickets_1 = df101_tickets_1.copy()\n", + " df_tickets_kpi_1 = tickets_kpi_function(df_tickets_1)\n", + "\n", + " df_tickets_kpi = pd.concat([df_tickets_kpi, df_tickets_kpi_1])\n", + " # Part du CA par customer\n", + " total_amount_share = df_tickets_kpi.groupby('customer_id')['total_amount'].sum().reset_index()\n", + " total_amount_share['total_amount_entreprise'] = total_amount_share['total_amount'].sum()\n", + " total_amount_share['share_total_amount'] = total_amount_share['total_amount']/total_amount_share['total_amount_entreprise']\n", + " \n", + " total_amount_share_index = total_amount_share.set_index('customer_id')\n", + " df_circulaire = total_amount_share_index['total_amount'].sort_values(axis = 0, ascending = False)\n", + " \n", + " top = df_circulaire[:coupure]\n", + " rest = df_circulaire[coupure:]\n", + " \n", + " # Calculez la somme du reste\n", + " rest_sum = rest.sum()\n", + " \n", + " # Créez une nouvelle série avec les cinq plus grandes parts et 'Autre'\n", + " new_series = pd.concat([top, pd.Series([rest_sum], index=['Autre'])])\n", + " \n", + " # Créez le graphique circulaire\n", + " plt.figure(figsize=(3, 3))\n", + " plt.pie(new_series, labels=new_series.index, autopct='%1.1f%%', startangle=140, pctdistance=0.5)\n", + " plt.axis('equal') # Assurez-vous que le graphique est un cercle\n", + " plt.title('Répartition des montants totaux')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "73211efc-b79f-4235-a250-c0699ea277bf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_detection(directory_path = \"1\", coupure = 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "5c8e9bb7-a403-4898-b40b-47aa37237bc6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
582011NaNNaNNaNNaN22020-09-03 13:11:25.569167+02:002023-03-04 13:27:42.761679+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaNNaNFalse2023-11-08 03:20:0745.012547757.030122330831-67.79096913.751531.9560878821221.5NaNNaNNaN6414722013-06-10 12:37:58+02:00NaNNaNfrNaN1311
\n", + "
" + ], + "text/plain": [ + " id lastname firstname birthdate email street_id \\\n", + "58201 1 NaN NaN NaN NaN 2 \n", + "\n", + " created_at updated_at \\\n", + "58201 2020-09-03 13:11:25.569167+02:00 2023-03-04 13:27:42.761679+01:00 \n", + "\n", + " civility is_partner extra deleted_at reference gender \\\n", + "58201 NaN False NaN NaN NaN 2 \n", + "\n", + " is_email_true extra_field opt_in structure_id note profession \\\n", + "58201 True NaN False NaN NaN NaN \n", + "\n", + " language mcp_contact_id need_reload last_buying_date max_price \\\n", + "58201 NaN NaN False 2023-11-08 03:20:07 45.0 \n", + "\n", + " ticket_sum average_price fidelity average_purchase_delay \\\n", + "58201 1254775 7.030122 330831 -67.790969 \n", + "\n", + " average_price_basket average_ticket_basket total_price \\\n", + "58201 13.75153 1.956087 8821221.5 \n", + "\n", + " preferred_category preferred_supplier preferred_formula \\\n", + "58201 NaN NaN NaN \n", + "\n", + " purchase_count first_buying_date last_visiting_date zipcode \\\n", + "58201 641472 2013-06-10 12:37:58+02:00 NaN NaN \n", + "\n", + " country age tenant_id \n", + "58201 fr NaN 1311 " + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = load_dataset_2('1', 'customersplus')\n", + "df[df['id'] == 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4455b6b9-8395-47ea-b976-d98a2d3c782c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_detection(directory_path = \"2\", coupure = 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "ee16cf31-18e1-4803-b003-ba1d1a3fc333", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
17024612184NaNNaNNaNNaN35642023-10-12 12:25:15.438714+02:002023-11-09 05:14:01.944407+01:00NaNFalseNaNNaNNaN2TrueNaNFalse1275.0NaNNaNNaNNaNFalse2023-11-08 19:17:50.56500075.051283112.6454381973580.031.7195772.5083816484972.4NaNNaNNaN2044472020-08-28 08:55:55.710000+02:00NaNNaNNaNNaN1879
\n", + "
" + ], + "text/plain": [ + " id lastname firstname birthdate email street_id \\\n", + "170246 12184 NaN NaN NaN NaN 3564 \n", + "\n", + " created_at updated_at \\\n", + "170246 2023-10-12 12:25:15.438714+02:00 2023-11-09 05:14:01.944407+01:00 \n", + "\n", + " civility is_partner extra deleted_at reference gender \\\n", + "170246 NaN False NaN NaN NaN 2 \n", + "\n", + " is_email_true extra_field opt_in structure_id note profession \\\n", + "170246 True NaN False 1275.0 NaN NaN \n", + "\n", + " language mcp_contact_id need_reload last_buying_date \\\n", + "170246 NaN NaN False 2023-11-08 19:17:50.565000 \n", + "\n", + " max_price ticket_sum average_price fidelity \\\n", + "170246 75.0 512831 12.645438 197358 \n", + "\n", + " average_purchase_delay average_price_basket average_ticket_basket \\\n", + "170246 0.0 31.719577 2.508381 \n", + "\n", + " total_price preferred_category preferred_supplier \\\n", + "170246 6484972.4 NaN NaN \n", + "\n", + " preferred_formula purchase_count first_buying_date \\\n", + "170246 NaN 204447 2020-08-28 08:55:55.710000+02:00 \n", + "\n", + " last_visiting_date zipcode country age tenant_id \n", + "170246 NaN NaN NaN NaN 1879 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = load_dataset_2('2', 'customersplus')\n", + "df[df['id'] == 12184]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4073c986-3e2c-4945-8601-220fea747c9c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
1026391NaNNaNNaNemail112023-07-20 17:16:27.062822+02:002023-07-20 17:16:27.074952+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaN1.0FalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNfrNaN1879
2244532NaNfirstname2NaNNaN22023-07-21 10:18:44.502496+02:002023-07-21 10:18:44.502496+02:00NaNFalseNaNNaNNaN1TrueNaNFalseNaNNaNNaNjosefNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1030133NaNfirstname3NaNNaN32023-07-21 10:18:44.503913+02:002023-07-21 10:18:44.503913+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdominicNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1383864NaNfirstname4NaNNaN32023-07-21 10:18:44.504404+02:002023-07-21 10:18:44.504404+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNabigailNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1900875NaNfirstname5NaNNaN32023-07-21 10:18:44.504841+02:002023-07-21 10:18:44.504841+02:00NaNFalseNaNNaNNaN1TrueNaNFalseNaNNaNNaNsophiaNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
.................................................................................................................................
101868601387lastname601387firstname601387NaNemail60138735502023-11-09 05:13:57.358715+01:002023-11-09 05:13:57.358715+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNNaNNaN1879
205168601388lastname601388firstname601388NaNemail60138835502023-11-09 05:13:57.359234+01:002023-11-09 05:13:57.359234+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalse2023-11-09 00:25:24.71600015.0214.010.028.02.028.0NaNNaNNaN12023-11-09 00:25:24.716000+01:00NaNNaNNaNNaN1879
67641601389lastname601389firstname601389NaNemail60138935502023-11-09 05:13:57.360373+01:002023-11-09 05:13:57.360373+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalse2023-11-09 00:28:07.51100015.0215.010.030.02.030.0NaNNaNNaN12023-11-09 00:28:07.511000+01:00NaNNaNNaNNaN1879
67639601390lastname601390firstname601390NaNemail60139035502023-11-09 05:13:57.360903+01:002023-11-09 05:13:57.360903+01:00NaNFalseNaNNaNNaN0TrueNaNFalseNaNNaNNaNNaNNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNNaNNaN1879
256450601391lastname601391firstname601391NaNemail60139135502023-11-09 05:13:57.361432+01:002023-11-09 05:14:18.906054+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaNNaNFalse2023-11-09 00:36:41.17200015.0215.010.030.02.030.0NaNNaNNaN12023-11-09 00:36:41.172000+01:00NaNNaNNaNNaN1879
\n", + "

275622 rows × 42 columns

\n", + "
" + ], + "text/plain": [ + " id lastname firstname birthdate email \\\n", + "102639 1 NaN NaN NaN email1 \n", + "224453 2 NaN firstname2 NaN NaN \n", + "103013 3 NaN firstname3 NaN NaN \n", + "138386 4 NaN firstname4 NaN NaN \n", + "190087 5 NaN firstname5 NaN NaN \n", + "... ... ... ... ... ... \n", + "101868 601387 lastname601387 firstname601387 NaN email601387 \n", + "205168 601388 lastname601388 firstname601388 NaN email601388 \n", + "67641 601389 lastname601389 firstname601389 NaN email601389 \n", + "67639 601390 lastname601390 firstname601390 NaN email601390 \n", + "256450 601391 lastname601391 firstname601391 NaN email601391 \n", + "\n", + " street_id created_at \\\n", + "102639 1 2023-07-20 17:16:27.062822+02:00 \n", + "224453 2 2023-07-21 10:18:44.502496+02:00 \n", + "103013 3 2023-07-21 10:18:44.503913+02:00 \n", + "138386 3 2023-07-21 10:18:44.504404+02:00 \n", + "190087 3 2023-07-21 10:18:44.504841+02:00 \n", + "... ... ... \n", + "101868 3550 2023-11-09 05:13:57.358715+01:00 \n", + "205168 3550 2023-11-09 05:13:57.359234+01:00 \n", + "67641 3550 2023-11-09 05:13:57.360373+01:00 \n", + "67639 3550 2023-11-09 05:13:57.360903+01:00 \n", + "256450 3550 2023-11-09 05:13:57.361432+01:00 \n", + "\n", + " updated_at civility is_partner extra \\\n", + "102639 2023-07-20 17:16:27.074952+02:00 NaN False NaN \n", + "224453 2023-07-21 10:18:44.502496+02:00 NaN False NaN \n", + "103013 2023-07-21 10:18:44.503913+02:00 NaN False NaN \n", + "138386 2023-07-21 10:18:44.504404+02:00 NaN False NaN \n", + "190087 2023-07-21 10:18:44.504841+02:00 NaN False NaN \n", + "... ... ... ... ... \n", + "101868 2023-11-09 05:13:57.358715+01:00 NaN False NaN \n", + "205168 2023-11-09 05:13:57.359234+01:00 NaN False NaN \n", + "67641 2023-11-09 05:13:57.360373+01:00 NaN False NaN \n", + "67639 2023-11-09 05:13:57.360903+01:00 NaN False NaN \n", + "256450 2023-11-09 05:14:18.906054+01:00 NaN False NaN \n", + "\n", + " deleted_at reference gender is_email_true extra_field opt_in \\\n", + "102639 NaN NaN 2 True NaN False \n", + "224453 NaN NaN 1 True NaN False \n", + "103013 NaN NaN 2 True NaN False \n", + "138386 NaN NaN 2 True NaN False \n", + "190087 NaN NaN 1 True NaN False \n", + "... ... ... ... ... ... ... \n", + "101868 NaN NaN 2 True NaN False \n", + "205168 NaN NaN 2 True NaN False \n", + "67641 NaN NaN 2 True NaN False \n", + "67639 NaN NaN 0 True NaN False \n", + "256450 NaN NaN 2 True NaN False \n", + "\n", + " structure_id note profession language mcp_contact_id need_reload \\\n", + "102639 NaN NaN NaN NaN 1.0 False \n", + "224453 NaN NaN NaN josef NaN False \n", + "103013 NaN NaN NaN dominic NaN False \n", + "138386 NaN NaN NaN abigail NaN False \n", + "190087 NaN NaN NaN sophia NaN False \n", + "... ... ... ... ... ... ... \n", + "101868 NaN NaN NaN de NaN False \n", + "205168 NaN NaN NaN de NaN False \n", + "67641 NaN NaN NaN de NaN False \n", + "67639 NaN NaN NaN NaN NaN False \n", + "256450 NaN NaN NaN NaN NaN False \n", + "\n", + " last_buying_date max_price ticket_sum average_price \\\n", + "102639 NaN NaN 0 NaN \n", + "224453 NaN NaN 0 NaN \n", + "103013 NaN NaN 0 NaN \n", + "138386 NaN NaN 0 NaN \n", + "190087 NaN NaN 0 NaN \n", + "... ... ... ... ... \n", + "101868 NaN NaN 0 NaN \n", + "205168 2023-11-09 00:25:24.716000 15.0 2 14.0 \n", + "67641 2023-11-09 00:28:07.511000 15.0 2 15.0 \n", + "67639 NaN NaN 0 NaN \n", + "256450 2023-11-09 00:36:41.172000 15.0 2 15.0 \n", + "\n", + " fidelity average_purchase_delay average_price_basket \\\n", + "102639 0 NaN NaN \n", + "224453 0 NaN NaN \n", + "103013 0 NaN NaN \n", + "138386 0 NaN NaN \n", + "190087 0 NaN NaN \n", + "... ... ... ... \n", + "101868 0 NaN NaN \n", + "205168 1 0.0 28.0 \n", + "67641 1 0.0 30.0 \n", + "67639 0 NaN NaN \n", + "256450 1 0.0 30.0 \n", + "\n", + " average_ticket_basket total_price preferred_category \\\n", + "102639 NaN 0.0 NaN \n", + "224453 NaN 0.0 NaN \n", + "103013 NaN 0.0 NaN \n", + "138386 NaN 0.0 NaN \n", + "190087 NaN 0.0 NaN \n", + "... ... ... ... \n", + "101868 NaN 0.0 NaN \n", + "205168 2.0 28.0 NaN \n", + "67641 2.0 30.0 NaN \n", + "67639 NaN 0.0 NaN \n", + "256450 2.0 30.0 NaN \n", + "\n", + " preferred_supplier preferred_formula purchase_count \\\n", + "102639 NaN NaN 0 \n", + "224453 NaN NaN 0 \n", + "103013 NaN NaN 0 \n", + "138386 NaN NaN 0 \n", + "190087 NaN NaN 0 \n", + "... ... ... ... \n", + "101868 NaN NaN 0 \n", + "205168 NaN NaN 1 \n", + "67641 NaN NaN 1 \n", + "67639 NaN NaN 0 \n", + "256450 NaN NaN 1 \n", + "\n", + " first_buying_date last_visiting_date zipcode country \\\n", + "102639 NaN NaN NaN fr \n", + "224453 NaN NaN NaN ch \n", + "103013 NaN NaN NaN ch \n", + "138386 NaN NaN NaN ch \n", + "190087 NaN NaN NaN ch \n", + "... ... ... ... ... \n", + "101868 NaN NaN NaN NaN \n", + "205168 2023-11-09 00:25:24.716000+01:00 NaN NaN NaN \n", + "67641 2023-11-09 00:28:07.511000+01:00 NaN NaN NaN \n", + "67639 NaN NaN NaN NaN \n", + "256450 2023-11-09 00:36:41.172000+01:00 NaN NaN NaN \n", + "\n", + " age tenant_id \n", + "102639 NaN 1879 \n", + "224453 NaN 1879 \n", + "103013 NaN 1879 \n", + "138386 NaN 1879 \n", + "190087 NaN 1879 \n", + "... ... ... \n", + "101868 NaN 1879 \n", + "205168 NaN 1879 \n", + "67641 NaN 1879 \n", + "67639 NaN 1879 \n", + "256450 NaN 1879 \n", + "\n", + "[275622 rows x 42 columns]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(by = 'id')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "475030ad-6a69-4c91-9cd6-943a0edeaf01", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_detection(directory_path = \"3\", coupure = 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b64d04db-1c3f-4538-9d05-8f7d62c7c046", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
1057201NaNNaN1961-12-04NaN911592021-03-02 15:35:40.452065+01:002023-11-09 01:31:07.539604+01:00NaNFalseNaNNaNNaN2FalseNaNFalse19715.0NaNNaNNaNNaNFalse2023-11-06 16:57:197500.0229771610.15219614917-39771.16514727.5148112.7102322.332686e+07NaNNaNNaN8477932016-01-01 10:23:36+01:002023-11-06 17:12:0013090fr61.01512
\n", + "
" + ], + "text/plain": [ + " id lastname firstname birthdate email street_id \\\n", + "105720 1 NaN NaN 1961-12-04 NaN 91159 \n", + "\n", + " created_at updated_at \\\n", + "105720 2021-03-02 15:35:40.452065+01:00 2023-11-09 01:31:07.539604+01:00 \n", + "\n", + " civility is_partner extra deleted_at reference gender \\\n", + "105720 NaN False NaN NaN NaN 2 \n", + "\n", + " is_email_true extra_field opt_in structure_id note profession \\\n", + "105720 False NaN False 19715.0 NaN NaN \n", + "\n", + " language mcp_contact_id need_reload last_buying_date max_price \\\n", + "105720 NaN NaN False 2023-11-06 16:57:19 7500.0 \n", + "\n", + " ticket_sum average_price fidelity average_purchase_delay \\\n", + "105720 2297716 10.152196 14917 -39771.165147 \n", + "\n", + " average_price_basket average_ticket_basket total_price \\\n", + "105720 27.514811 2.710232 2.332686e+07 \n", + "\n", + " preferred_category preferred_supplier preferred_formula \\\n", + "105720 NaN NaN NaN \n", + "\n", + " purchase_count first_buying_date last_visiting_date \\\n", + "105720 847793 2016-01-01 10:23:36+01:00 2023-11-06 17:12:00 \n", + "\n", + " zipcode country age tenant_id \n", + "105720 13090 fr 61.0 1512 " + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = load_dataset_2('3', 'customersplus')\n", + "df[df['id'] == 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1d817bee-3ded-4066-9f91-6cf095591b0e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_detection(directory_path = \"4\", coupure = 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "4cc07982-1070-439b-a579-fd3f351778b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
3007542NaNNaNNaNNaN22020-09-25 19:09:07.669208+02:002021-11-30 02:07:28.120188+01:00NaNFalseNaNNaNNaN2FalseNaNFalseNaNNaNNaNNaNNaNFalse2023-11-07 16:33:09360.012372246.0562482368500.01552813.4936122.2280487492935.0NaNNaNNaN5552951901-01-01 00:09:21+00:09NaNNaNNaNNaN1342
\n", + "
" + ], + "text/plain": [ + " id lastname firstname birthdate email street_id \\\n", + "300754 2 NaN NaN NaN NaN 2 \n", + "\n", + " created_at updated_at \\\n", + "300754 2020-09-25 19:09:07.669208+02:00 2021-11-30 02:07:28.120188+01:00 \n", + "\n", + " civility is_partner extra deleted_at reference gender \\\n", + "300754 NaN False NaN NaN NaN 2 \n", + "\n", + " is_email_true extra_field opt_in structure_id note profession \\\n", + "300754 False NaN False NaN NaN NaN \n", + "\n", + " language mcp_contact_id need_reload last_buying_date max_price \\\n", + "300754 NaN NaN False 2023-11-07 16:33:09 360.0 \n", + "\n", + " ticket_sum average_price fidelity average_purchase_delay \\\n", + "300754 1237224 6.056248 236850 0.015528 \n", + "\n", + " average_price_basket average_ticket_basket total_price \\\n", + "300754 13.493612 2.228048 7492935.0 \n", + "\n", + " preferred_category preferred_supplier preferred_formula \\\n", + "300754 NaN NaN NaN \n", + "\n", + " purchase_count first_buying_date last_visiting_date zipcode \\\n", + "300754 555295 1901-01-01 00:09:21+00:09 NaN NaN \n", + "\n", + " country age tenant_id \n", + "300754 NaN NaN 1342 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = load_dataset_2('4', 'customersplus')\n", + "df[df['id'] == 2]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f74a9e62-a0f7-41cf-9834-78a99204547c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "outlier_detection(directory_path = \"101\", coupure = 2)" + ] + }, + { + "cell_type": "markdown", + "id": "dbebfa92-310a-417b-a7fa-36ac3593db06", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## Evolution des commandes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "06137694-7f50-47ba-8749-68471ececc1e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_448/3643128924.py:11: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + " purchases = pd.read_csv(file_in, sep=\",\", parse_dates = ['purchase_date'], date_parser=custom_date_parser)\n", + "/tmp/ipykernel_448/3643128924.py:19: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + " campaigns = pd.read_csv(file_in, sep=\",\", parse_dates = ['sent_at'], date_parser=custom_date_parser)\n" + ] + } + ], + "source": [ + "# Importation - Chargement des données temporaires\n", + "company_number = \"1\"\n", + "nom_dataframe = 'df'+ company_number +'_tickets'\n", + "purchases = globals()[nom_dataframe].copy()\n", + "\n", + "campaigns = display_databases(company_number,'campaigns_information', ['sent_at'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e6b962d4-1a30-4133-ac0f-359f7afef42c", + "metadata": {}, + "outputs": [], + "source": [ + "# Mois du premier achat\n", + "purchase_min = purchases.groupby(['customer_id'])['purchase_date'].min().reset_index()\n", + "purchase_min.rename(columns = {'purchase_date' : 'first_purchase_event'}, inplace = True)\n", + "purchase_min['first_purchase_event'] = pd.to_datetime(purchase_min['first_purchase_event'])\n", + "purchase_min['first_purchase_month'] = pd.to_datetime(purchase_min['first_purchase_event'].dt.strftime('%Y-%m'))\n", + "\n", + "# Mois du premier mails\n", + "first_mail_received = campaigns.groupby('customer_id')['sent_at'].min().reset_index()\n", + "first_mail_received.rename(columns = {'sent_at' : 'first_email_reception'}, inplace = True)\n", + "first_mail_received['first_email_reception'] = pd.to_datetime(first_mail_received['first_email_reception'])\n", + "first_mail_received['first_email_month'] = pd.to_datetime(first_mail_received['first_email_reception'].dt.strftime('%Y-%m'))\n", + "\n", + "# Fusion \n", + "known_customer = pd.merge(purchase_min[['customer_id', 'first_purchase_month']], \n", + " first_mail_received[['customer_id', 'first_email_month']], on = 'customer_id', how = 'outer')\n", + "\n", + "# Mois à partir duquel le client est considere comme connu\n", + "known_customer['known_date'] = pd.to_datetime(known_customer[['first_email_month', 'first_purchase_month']].min(axis = 1), utc = True, format = 'ISO8601')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9c56e5ac-cbf4-4343-80ba-be2ab8b60eab", + "metadata": {}, + "outputs": [], + "source": [ + "# Nombre de commande par mois\n", + "purchases_count = pd.merge(purchases[['customer_id', 'purchase_id', 'purchase_date']].drop_duplicates(), known_customer[['customer_id', 'known_date']], on = ['customer_id'], how = 'inner')\n", + "purchases_count['is_customer_known'] = purchases_count['purchase_date'] > purchases_count['known_date'] + pd.DateOffset(months=1)\n", + "purchases_count['purchase_date_month'] = pd.to_datetime(purchases_count['purchase_date'].dt.strftime('%Y-%m'))\n", + "purchases_count = purchases_count[purchases_count['customer_id'] != 1]\n", + "\n", + "# Nombre de commande par mois par type de client\n", + "nb_purchases_graph = purchases_count.groupby(['purchase_date_month', 'is_customer_known'])['purchase_id'].count().reset_index()\n", + "nb_purchases_graph.rename(columns = {'purchase_id' : 'nb_purchases'}, inplace = True)\n", + "\n", + "nb_purchases_graph_2 = purchases_count.groupby(['purchase_date_month', 'is_customer_known'])['customer_id'].nunique().reset_index()\n", + "nb_purchases_graph_2.rename(columns = {'customer_id' : 'nb_new_customer'}, inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8c1aed44-03d3-49f9-b96c-b06a0df03dde", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Graphique en nombre de commande\n", + "purchases_graph = nb_purchases_graph\n", + "\n", + "purchases_graph_used = purchases_graph[purchases_graph[\"purchase_date_month\"] >= datetime(2021,3,1)]\n", + "purchases_graph_used_0 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==False]\n", + "purchases_graph_used_1 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==True]\n", + "\n", + "\n", + "# Création du barplot\n", + "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_0[\"nb_purchases\"], width=12, label = \"Nouveau client\")\n", + "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_1[\"nb_purchases\"], \n", + " bottom = purchases_graph_used_0[\"nb_purchases\"], width=12, label = \"Ancien client\")\n", + "\n", + "\n", + "# commande pr afficher slt\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b%y'))\n", + "\n", + "\n", + "# Ajout de titres et d'étiquettes\n", + "plt.xlabel('Mois')\n", + "plt.ylabel(\"Nombre d'achats\")\n", + "plt.title(\"Nombre d'achats - MUCEM\")\n", + "plt.legend()\n", + "\n", + "# Affichage du barplot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d312276c-4c46-4d29-b6d6-ed110f59890d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# graphique en nombre de client ayant commandé\n", + "purchases_graph = nb_purchases_graph_2\n", + "\n", + "purchases_graph_used = purchases_graph[purchases_graph[\"purchase_date_month\"] >= datetime(2021,4,1)]\n", + "purchases_graph_used_0 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==False]\n", + "purchases_graph_used_1 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==True]\n", + "\n", + "\n", + "# Création du barplot\n", + "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_0[\"nb_new_customer\"], width=12, label = \"Nouveau client\")\n", + "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_1[\"nb_new_customer\"], \n", + " bottom = purchases_graph_used_0[\"nb_new_customer\"], width=12, label = \"Ancien client\")\n", + "\n", + "\n", + "# commande pr afficher slt\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b%y'))\n", + "\n", + "\n", + "# Ajout de titres et d'étiquettes\n", + "plt.xlabel('Mois')\n", + "plt.ylabel(\"Nombre de client ayant commandé\")\n", + "plt.title(\"Nombre de client ayant commandé un ticket pour l'offre 'muséale groupe'\")\n", + "plt.legend()\n", + "\n", + "# Affichage du barplot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "82895dfc-e5ca-4be0-af24-93c1be8f6248", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## Proportion de tickets de prix 0" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "10828dd8-8ec9-49eb-b450-acca741964c7", + "metadata": {}, + "outputs": [], + "source": [ + "barplot_prop_free_price = pd.DataFrame()\n", + "for company_number in ['1', '2', '3', '4', '101'] : # \n", + " nom_dataframe = 'df'+ company_number +'_tickets'\n", + " df_tickets = globals()[nom_dataframe].copy()\n", + " df_free_tickets = df_tickets[df_tickets['amount'] == 0 | df_tickets['amount'].isna()]\n", + "\n", + " if company_number == '101' :\n", + " df_free_tickets_1 = df101_tickets_1[df101_tickets_1['amount'] == 0]\n", + " nb_tickets = len(df_tickets) + len(df101_tickets_1)\n", + " nb_free_tickets = len(df_free_tickets) + len(df_free_tickets_1)\n", + " \n", + " graph_dataframe = pd.DataFrame({'company_number' : [company_number], \n", + " 'prop_free_tickets' : [nb_free_tickets / nb_tickets],\n", + " 'nb_tickets' : [nb_tickets]})\n", + " \n", + " else : \n", + " graph_dataframe = pd.DataFrame({'company_number' : [company_number], \n", + " 'prop_free_tickets' : [len(df_free_tickets) / len(df_tickets)],\n", + " 'nb_tickets' : [len(df_tickets)]})\n", + "\n", + " barplot_prop_free_price = pd.concat([barplot_prop_free_price, graph_dataframe])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "065576ef-2515-43eb-a65d-21f07f228c9e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "barplot_prop_free_price\n", + "\n", + "df = barplot_prop_free_price.sort_values( by = 'prop_free_tickets')\n", + "\n", + "# Création du barplot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.bar(df['company_number'], df['prop_free_tickets'])\n", + "plt.xlabel('Numéro de la société')\n", + "plt.ylabel('Proportion de billets gratuits')\n", + "plt.title('Proportion de billets gratuits par musée')\n", + "plt.xticks(df['company_number'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d6de664a-a303-48f5-bca6-1e9e9d17c461", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "## Répartition des prix de vente" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "150825c6-08b5-44ad-a02e-98ee44192d94", + "metadata": {}, + "outputs": [], + "source": [ + "boxplot_amount = {} \n", + "\n", + "for company_number in ['1', '2', '3', '4', '101'] :\n", + " nom_dataframe = 'df'+ company_number +'_tickets'\n", + " df_tickets = globals()[nom_dataframe].copy()\n", + " df_notfree_tickets = df_tickets[df_tickets['amount'] > 0]\n", + " \n", + " boxplot_amount[company_number] = df_notfree_tickets['amount']\n", + "\n", + "amount_df = pd.DataFrame(boxplot_amount)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "c6ce46c8-5ad1-42c0-9b9a-a84df52a3411", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1234101
count1.062722e+061.475197e+063.051426e+061.280045e+061.133556e+07
mean1.076436e+011.519766e+011.285360e+011.139475e+011.350509e+01
std9.243106e+005.714467e+001.445236e+011.657010e+011.492325e+01
min2.500000e+005.000000e+003.000000e-011.000000e+002.000000e-02
25%9.500000e+001.300000e+016.000000e+006.000000e+001.000000e+01
50%1.100000e+011.500000e+011.350000e+011.000000e+011.300000e+01
75%1.100000e+011.500000e+011.700000e+011.200000e+011.450000e+01
max3.200000e+023.000000e+027.500000e+031.500000e+031.633000e+03
\n", + "
" + ], + "text/plain": [ + " 1 2 3 4 101\n", + "count 1.062722e+06 1.475197e+06 3.051426e+06 1.280045e+06 1.133556e+07\n", + "mean 1.076436e+01 1.519766e+01 1.285360e+01 1.139475e+01 1.350509e+01\n", + "std 9.243106e+00 5.714467e+00 1.445236e+01 1.657010e+01 1.492325e+01\n", + "min 2.500000e+00 5.000000e+00 3.000000e-01 1.000000e+00 2.000000e-02\n", + "25% 9.500000e+00 1.300000e+01 6.000000e+00 6.000000e+00 1.000000e+01\n", + "50% 1.100000e+01 1.500000e+01 1.350000e+01 1.000000e+01 1.300000e+01\n", + "75% 1.100000e+01 1.500000e+01 1.700000e+01 1.200000e+01 1.450000e+01\n", + "max 3.200000e+02 3.000000e+02 7.500000e+03 1.500000e+03 1.633000e+03" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "amount_df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "a54269c1-9aec-4e49-91ba-d39fa5ece850", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "means = amount_df.mean()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "amount_df.boxplot()\n", + "plt.scatter(x=range(1, len(means) + 1), y=means, marker='D', color='red', s=100)\n", + "plt.title('Répartition des prix des billets non gratuits')\n", + "plt.ylabel('Montant')\n", + "plt.xlabel('Compagnie')\n", + "plt.ylim(0, 50) \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b41b5434-0e5b-495b-bede-23f5cb45272c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
purchase_idticket_id
count73518.0000007.351800e+04
mean10.0961672.484660e+01
std2367.7026034.636993e+03
min1.0000001.000000e+00
25%1.0000001.000000e+00
50%1.0000002.000000e+00
75%1.0000003.000000e+00
max641981.0000001.256574e+06
\n", + "
" + ], + "text/plain": [ + " purchase_id ticket_id\n", + "count 73518.000000 7.351800e+04\n", + "mean 10.096167 2.484660e+01\n", + "std 2367.702603 4.636993e+03\n", + "min 1.000000 1.000000e+00\n", + "25% 1.000000 1.000000e+00\n", + "50% 1.000000 2.000000e+00\n", + "75% 1.000000 3.000000e+00\n", + "max 641981.000000 1.256574e+06" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "purchases.groupby('customer_id')[['purchase_id', 'ticket_id']].nunique().describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d1212b10-3933-450a-b001-9e2cbf308f79", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ticket_idcustomer_idpurchase_idevent_type_idsupplier_namepurchase_datetype_of_ticket_nameamountchildrenis_full_pricename_event_typesname_facilitiesname_categoriesname_eventsname_seasons
0130708594818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier8.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
1130708604818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
2130708614818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
3130708624818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
4130708634818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
................................................
182666720662815125613580076975vente en ligne2023-11-08 17:23:54+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182666820662816125613680076985vente en ligne2023-11-08 18:32:18+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182666920662817125613680076985vente en ligne2023-11-08 18:32:18+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182667020662818125613780076995vente en ligne2023-11-08 19:30:28+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182667120662819125613780076995vente en ligne2023-11-08 19:30:28+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
\n", + "

1826672 rows × 15 columns

\n", + "
" + ], + "text/plain": [ + " ticket_id customer_id purchase_id event_type_id supplier_name \\\n", + "0 13070859 48187 5107462 4 vente en ligne \n", + "1 13070860 48187 5107462 4 vente en ligne \n", + "2 13070861 48187 5107462 4 vente en ligne \n", + "3 13070862 48187 5107462 4 vente en ligne \n", + "4 13070863 48187 5107462 4 vente en ligne \n", + "... ... ... ... ... ... \n", + "1826667 20662815 1256135 8007697 5 vente en ligne \n", + "1826668 20662816 1256136 8007698 5 vente en ligne \n", + "1826669 20662817 1256136 8007698 5 vente en ligne \n", + "1826670 20662818 1256137 8007699 5 vente en ligne \n", + "1826671 20662819 1256137 8007699 5 vente en ligne \n", + "\n", + " purchase_date type_of_ticket_name amount \\\n", + "0 2018-12-28 14:47:50+00:00 Atelier 8.0 \n", + "1 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", + "2 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", + "3 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", + "4 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", + "... ... ... ... \n", + "1826667 2023-11-08 17:23:54+00:00 Atelier 11.0 \n", + "1826668 2023-11-08 18:32:18+00:00 Atelier 11.0 \n", + "1826669 2023-11-08 18:32:18+00:00 Atelier 11.0 \n", + "1826670 2023-11-08 19:30:28+00:00 Atelier 11.0 \n", + "1826671 2023-11-08 19:30:28+00:00 Atelier 11.0 \n", + "\n", + " children is_full_price name_event_types name_facilities \\\n", + "0 pricing_formula False spectacle vivant mucem \n", + "1 pricing_formula False spectacle vivant mucem \n", + "2 pricing_formula False spectacle vivant mucem \n", + "3 pricing_formula False spectacle vivant mucem \n", + "4 pricing_formula False spectacle vivant mucem \n", + "... ... ... ... ... \n", + "1826667 pricing_formula False offre muséale groupe mucem \n", + "1826668 pricing_formula False offre muséale groupe mucem \n", + "1826669 pricing_formula False offre muséale groupe mucem \n", + "1826670 pricing_formula False offre muséale groupe mucem \n", + "1826671 pricing_formula False offre muséale groupe mucem \n", + "\n", + " name_categories name_events name_seasons \n", + "0 indiv prog enfant l'école des magiciens 2018 \n", + "1 indiv prog enfant l'école des magiciens 2018 \n", + "2 indiv prog enfant l'école des magiciens 2018 \n", + "3 indiv prog enfant l'école des magiciens 2018 \n", + "4 indiv prog enfant l'école des magiciens 2018 \n", + "... ... ... ... \n", + "1826667 indiv entrées tp NaN 2023 \n", + "1826668 indiv entrées tp NaN 2023 \n", + "1826669 indiv entrées tp NaN 2023 \n", + "1826670 indiv entrées tp NaN 2023 \n", + "1826671 indiv entrées tp NaN 2023 \n", + "\n", + "[1826672 rows x 15 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "purchases" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "49d5fd2d-9bc1-43ac-9270-1efd73759854", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Nombre Total de tickets achetés sur Internet par Type d'évènements\n", + "\n", + "nb_tickets_internet = customer.groupby('name_event_types')['nb_tickets_internet'].sum()\n", + "nb_tickets_internet.plot(kind='bar', figsize=(8, 5))\n", + "plt.xlabel(\"Type d'évènements\")\n", + "plt.ylabel('Nombre Total de tickets achetés sur Internet')\n", + "plt.title(\"Nombre Total de tickets achetés sur Internet par Type d'évènements\")\n", + "plt.xticks(rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d679204b-f3e8-4502-8de9-3bf4180da3bd", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# 2 - Autres informations sur client " + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "1df2a145-f47f-4511-aa76-0df7531dd2ec", + "metadata": {}, + "outputs": [], + "source": [ + "def tags_information(tenant_id, first_tags = 20):\n", + "\n", + " customersplus = load_dataset_2(tenant_id, \"customersplus\")[['id', 'structure_id']]\n", + " customersplus.rename(columns = {'id' : 'customer_id'}, inplace = True)\n", + " tags = load_dataset_2(tenant_id, \"tags\")[['id', 'name']]\n", + " tags.rename(columns = {'id' : 'tag_id', 'name' : 'tag_name'}, inplace = True)\n", + " structure_tag_mappings = load_dataset_2(tenant_id, \"structure_tag_mappings\")[['structure_id', 'tag_id']]\n", + " \n", + " customer_tags = pd.merge(customersplus, structure_tag_mappings, on = 'structure_id', how = 'left')\n", + " customer_tags = pd.merge(customer_tags, tags, on = 'tag_id', how = 'inner')\n", + " \n", + " nb_customers_with_tag = customer_tags['customer_id'].nunique()\n", + " \n", + " # print('Nombre de client avec tag : ', nb_customers_with_tag)\n", + " # print('Proportion de clients avec tags : ', nb_customers_with_tag/len(customersplus))\n", + " # print('Moyenne de tags par client : ', len(customer_tags)/nb_customers_with_tag)\n", + " \n", + " # info = customer_tags.groupby(['tag_id', 'tag_name'])['customer_id'].count().reset_index().sort_values('customer_id', ascending = False).head(first_tags)\n", + "\n", + " tags_informations = pd.DataFrame({'company_number' : tenant_id,\n", + " 'nb_customers_with_tags' : [nb_customers_with_tag],\n", + " 'prop_customers_with_tags' : [nb_customers_with_tag/len(customersplus)],\n", + " 'mean_tags_per_customers' : [len(customer_tags)/nb_customers_with_tag]})\n", + " \n", + " return tags_informations" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "c4ecbb15-0f55-46dc-a3df-6e8c4ae44ebd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nombre de client avec tag : 13320\n", + "Proportion de clients avec tags : 0.0877089012682233\n", + "Moyenne de tags par client : 2.1725975975975977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (20) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df = pd.read_csv(file_in, sep=\",\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nombre de client avec tag : 5953\n", + "Proportion de clients avec tags : 0.021598421025897787\n", + "Moyenne de tags par client : 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (19,20) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df = pd.read_csv(file_in, sep=\",\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nombre de client avec tag : 23659\n", + "Proportion de clients avec tags : 0.09207484608139978\n", + "Moyenne de tags par client : 3.0620482691576143\n", + "Nombre de client avec tag : 10495\n", + "Proportion de clients avec tags : 0.03271416949025744\n", + "Moyenne de tags par client : 5.298427822772749\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (20) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df = pd.read_csv(file_in, sep=\",\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nombre de client avec tag : 532342\n", + "Proportion de clients avec tags : 0.18660686931118298\n", + "Moyenne de tags par client : 24.114082676174338\n" + ] + } + ], + "source": [ + "tags_comparaison = pd.DataFrame()\n", + "\n", + "for tenant_id in companies['musee'] : \n", + " \n", + " tags_comparaison = pd.concat([tags_comparaison, tags_information(tenant_id)])" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "bd2dd513-3375-4073-a12a-fa0e9f20571e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
company_numbernb_customers_with_tagsprop_customers_with_tagsmean_tags_per_customers
01133200.0877092.172598
0259530.0215981.000000
03236590.0920753.062048
04104950.0327145.298428
01015323420.18660724.114083
\n", + "
" + ], + "text/plain": [ + " company_number nb_customers_with_tags prop_customers_with_tags \\\n", + "0 1 13320 0.087709 \n", + "0 2 5953 0.021598 \n", + "0 3 23659 0.092075 \n", + "0 4 10495 0.032714 \n", + "0 101 532342 0.186607 \n", + "\n", + " mean_tags_per_customers \n", + "0 2.172598 \n", + "0 1.000000 \n", + "0 3.062048 \n", + "0 5.298428 \n", + "0 24.114083 " + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tags_comparaison" + ] + }, + { + "cell_type": "markdown", + "id": "507c1db3-1d6c-4106-a9a2-0187055e0480", + "metadata": {}, + "source": [ + "# 3 - Graphiques communs" + ] + }, + { + "cell_type": "markdown", + "id": "aac367ed-9d5e-482a-a376-bfc7d1a5767e", + "metadata": {}, + "source": [ + "## Nombre de clients" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "94254c32-dc81-42f2-9d27-372ff38c70ed", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_nb_clients(customer_musee):\n", + " company_nb_clients = customer_musee[customer_musee[\"purchase_count\"]>0].groupby(\"number_company\")[\"customer_id\"].count().reset_index()\n", + " plt.bar(company_nb_clients[\"number_company\"], company_nb_clients[\"customer_id\"]/1000)\n", + "\n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (milliers)\")\n", + " plt.title(\"Nombre de clients de chaque compagnie de musee\")\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "aed68c8c-1912-4d8d-a974-11ad371f6ee8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAHFCAYAAAD2eiPWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJYElEQVR4nO3dd3RU1f7+8WcgPYRAAqRACAFCMwSkFzWUAEZBEBQsl6LIRSlKuyqiF1CKFKkqXq9KsQAqRSkCkRJFBKlSBAUvVYn0BCIEkuzfH34zP4YEyJAJSY7v11qzFrNnzzmffXYyeThtbMYYIwAAAAsrkt8FAAAA5DUCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCTwEza9Ys2Ww2eXl56fDhw1leb9asmaKiovKhMqlHjx4qVqxYvqz7Zmw2m0aMGHFb19msWTM1a9bsttexfPny2zbW/NiuFSpUUNu2bW/rOlHwHTp0SDabTbNmzcrzdeXHzz3yHoGngEpNTdXLL7+c32XASd9//72eeuqpPF3H8uXLNXLkyDxdB1DQhISE6Pvvv9f999+f36WgkCLwFFD33nuvPvnkE/3444/5XYpLGGN08eLF/C4jzzVq1EjlypXL7zIAy/H09FSjRo1UunTp/C4FhRSBp4B6/vnnFRgYqBdeeOGmfS9duqShQ4cqIiJCHh4eKlu2rPr27atz58459Ms8VLB06VLdeeed8vb2VvXq1bV06VJJfx1Oq169unx9fdWgQQNt2bIl2/Xt2bNHLVu2lK+vr0qXLq1+/frpzz//dOhjs9nUr18/vfPOO6pevbo8PT01e/ZsSdL+/fv12GOPqUyZMvL09FT16tX11ltv5Wi7JCcnq1evXgoMDFSxYsV077336pdffsm2b27Wk5GRoenTp6t27dry9vZWiRIl1KhRI3355Zc3fF92u8ITExPVu3dvlStXTh4eHoqIiNDIkSOVlpZm75O5u37ixImaNGmSIiIiVKxYMTVu3FgbN2609+vRo4d9DDabzf44dOiQJOmzzz5Tw4YN5e/vLx8fH1WsWFFPPvnkTcdbELfrihUrVKdOHXl7e6tatWr64IMPHF4/efKk+vTpoxo1aqhYsWIqU6aMWrRooW+//TbLsn7//Xd17txZfn5+8vf3V5cuXbRx48Ysh0iyO0wp/bXdK1So4NB2+fJljRo1StWqVZOnp6dKly6tJ554QidPnszRtti0aZPatWunwMBAeXl5qVKlShowYIBDn/Xr16tly5by8/OTj4+PmjRpomXLljn0yTwMvmbNGvscFi9eXN26dVNKSooSExPVuXNnlShRQiEhIRoyZIiuXLlif3/mz9748eM1evRolS9fXl5eXqpXr55Wr17tsK4DBw7oiSeeUGRkpHx8fFS2bFm1a9dOu3btyjK+PXv2qHXr1vLx8VHp0qXVt29fLVu2TDabTevWrXPY5lFRUdq8ebPuvvtu+8/t66+/royMjCx1XntIqzB8nmR+Hs6cOVNVq1aVt7e36tWrp40bN8oYowkTJth/51u0aKEDBw44vL9ChQrq0aNHluVe+/OakZGhUaNG2ddRokQJRUdHa+rUqbc0luTkZA0ZMsThb8uAAQOUkpKSo3EXOAYFysyZM40ks3nzZjN16lQjyaxevdr+ekxMjLnjjjvszzMyMkybNm2Mm5ubeeWVV8yqVavMxIkTja+vr7nzzjvNpUuX7H3Dw8NNuXLlTFRUlJk7d65Zvny5adiwoXF3dzf//ve/TdOmTc3ChQvNokWLTJUqVUxQUJD5888/7e/v3r278fDwMOXLlzejR482q1atMiNGjDBubm6mbdu2DuOQZMqWLWuio6PNJ598YtasWWN2795t9uzZY/z9/U3NmjXNnDlzzKpVq8zgwYNNkSJFzIgRI264bTIyMkzz5s2Np6enff3Dhw83FStWNJLM8OHD7X1zsx5jjOnataux2WzmqaeeMl988YX56quvzOjRo83UqVMd5iImJibLuK+u4/jx4yYsLMyEh4eb//znP+brr782r732mvH09DQ9evSw9zt48KCRZCpUqGDuvfdes3jxYrN48WJTs2ZNU7JkSXPu3DljjDEHDhwwDz30kJFkvv/+e/vj0qVLZsOGDcZms5lHHnnELF++3KxZs8bMnDnTdO3atVBt18yf0xo1apg5c+aYlStXmocffthIMgkJCfZ++/btM88884yZN2+eWbdunVm6dKnp2bOnKVKkiFm7dq29359//mmqV69u/P39zfTp083KlSvNs88+a8qXL28kmZkzZ95wTo3562c/PDzc/jw9Pd3ce++9xtfX14wcOdLEx8eb9957z5QtW9bUqFHD4fcmOytWrDDu7u4mOjrazJo1y6xZs8Z88MEH5pFHHrH3WbdunXF3dzd169Y18+fPN4sXLzatW7c2NpvNzJs3z94v8zMjIiLCDB482KxatcqMGzfOFC1a1Dz66KOmTp06ZtSoUSY+Pt688MILRpJ544037O/P/NkLCwszd911l1mwYIH57LPPTP369Y27u7vZsGGDvW9CQoIZPHiw+fzzz01CQoJZtGiR6dChg/H29jb79u2z9/v9999NYGCgKV++vJk1a5ZZvny56dq1q6lQoYKR5DA/MTExJjAw0ERGRpp33nnHxMfHmz59+hhJZvbs2VnqvHq+CsvniSQTHh5umjRp4vAZGxAQYAYOHGjat29vli5daj7++GMTFBRkoqOjTUZGhv394eHhpnv37lmWe+3P69ixY03RokXN8OHDzerVq82KFSvMlClTHGrM6VhSUlJM7dq1TalSpcykSZPM119/baZOnWr8/f1NixYtHOorLAg8BczVgSc1NdVUrFjR1KtXz/7DdW3gWbFihZFkxo8f77Cc+fPnG0nm3XfftbeFh4cbb29vc+zYMXvbjh07jCQTEhJiUlJS7O2LFy82ksyXX35pb+vevbuR5PDHyRhjRo8ebSSZ9evX29skGX9/f3PmzBmHvm3atDHlypUzSUlJDu39+vUzXl5eWfpf7auvvrrh+q/+gMrNer755hsjyQwbNuy6fYzJWeDp3bu3KVasmDl8+LBDv4kTJxpJZs+ePcaY//9hXrNmTZOWlmbv98MPPxhJZu7cufa2vn37muz+r5K5zMxwlFMFbbuGh4cbLy8vh2128eJFExAQYHr37n3d96WlpZkrV66Yli1bmgcffNDePmPGDCPJfPHFFw79e/XqdcuBZ+7cuUaSWbBggUO/zZs3G0nm7bffvuEYK1WqZCpVqmQuXrx43T6NGjUyZcqUMefPn3cYY1RUlClXrpz9MyHzM6N///4O7+/QoYORZCZNmuTQXrt2bVOnTh3788yfvdDQUId6kpOTTUBAgImNjb1ujWlpaeby5csmMjLSDBw40N7+r3/9y9hsNvvPd6Y2bdpkG3gkmU2bNjn0rVGjhmnTpk2WOq+er8LweWLMX58LwcHB5sKFC/a2zM/Y2rVrO4SHKVOmGElm586d9racBp62bdua2rVr37CWnI5l7NixpkiRImbz5s0O/T7//HMjySxfvvyG6ymIOKRVgHl4eGjUqFHasmWLPv3002z7rFmzRpKy7O58+OGH5evrm2WXdO3atVW2bFn78+rVq0v6a9eoj49PlvbsrhR7/PHHHZ4/9thjkqS1a9c6tLdo0UIlS5a0P7906ZJWr16tBx98UD4+PkpLS7M/7rvvPl26dMnh8M21Mpd/vfW7aj1fffWVJKlv377X7ZNTS5cuVfPmzRUaGupQR1xcnCQpISHBof/999+vokWL2p9HR0dLyn4erlW/fn1JUufOnfXpp5/qt99+y1GNBXG71q5dW+XLl7c/9/LyUpUqVbJsh3feeUd16tSRl5eX3Nzc5O7urtWrV2vv3r0O4/Pz89MDDzxww/E5Y+nSpSpRooTatWvnsB1q166t4OBgh0M21/rll1/066+/qmfPnvLy8sq2T0pKijZt2qSHHnrI4crIokWLqmvXrjp27Jh+/vlnh/dce2Vb5u/wtSf5Vq9ePdufp44dOzrU4+fnp3bt2umbb75Renq6JCktLU1jxoxRjRo15OHhITc3N3l4eGj//v0O2zwhIUFRUVGqUaOGwzoeffTRbMcbHBysBg0aOLRFR0ff8Oe+sHyeZGrevLl8fX3tzzPnJy4uTjabLUt7Tn7nr9WgQQP9+OOP6tOnj1auXKnk5ORbHsvSpUsVFRWl2rVrO/Rr06ZNlsOShQWBp4B75JFHVKdOHQ0bNszhuHum06dPy83NLcuJfDabTcHBwTp9+rRDe0BAgMNzDw+PG7ZfunTJod3NzU2BgYEObcHBwfZarhYSEpKl1rS0NE2fPl3u7u4Oj/vuu0+SdOrUqSxjvHas11u/q9Zz8uRJFS1aNMtyb8Uff/yhJUuWZKnjjjvuyLaOa8fm6ekpSTk64fuee+7R4sWLlZaWpm7duqlcuXKKiorS3Llzb/i+grhdr61F+mtbXL0dJk2apGeeeUYNGzbUggULtHHjRm3evFn33nuvQ7/Tp08rKCgoy/JyM79//PGHzp07Jw8PjyzbIjEx8abbQdINT24/e/asjDFZfockKTQ0VFLW3zdnfrev/b2Wst8ewcHBunz5si5cuCBJGjRokF555RV16NBBS5Ys0aZNm7R582bVqlUrR9s8uzYpZ/N9rcLyeZIpt5+9OTF06FBNnDhRGzduVFxcnAIDA9WyZUv7+ZjOjOWPP/7Qzp07s/Tz8/OTMSZHYy5o3PK7ANyYzWbTuHHj1KpVK7377rtZXg8MDFRaWppOnjzpEHqMMUpMTLT/r99V0tLSdPr0aYcPicTERHst19Z+tZIlS9r/h3q9/+VHRERcd92ZY73e+l21ntKlSys9PV2JiYnZ/sFxRqlSpRQdHa3Ro0dn+3rmHy9Xad++vdq3b6/U1FRt3LhRY8eO1WOPPaYKFSqocePG2b6nMG5XSfroo4/UrFkzzZgxw6H9/PnzDs8DAwP1ww8/ZHn/teOT/tqTlJSUlKX92g/3UqVKKTAwUCtWrMi2Nj8/v+vWnfl7euzYsev2KVmypIoUKaLjx49nee3333+31+BK2W2PxMREeXh42PcyffTRR+rWrZvGjBnj0O/UqVMqUaKE/XlgYKD++OOPHK3jVhWWzxNX8PLyUmpqapb2U6dOOfwcuLm5adCgQRo0aJDOnTunr7/+Wi+99JLatGmjo0ePOjWWUqVKydvbO8vFAplc/fN3O7CHpxCIjY1Vq1at9Oqrr9r/p5WpZcuWkv76ILraggULlJKSYn/dlT7++GOH55988okkZXt1y9V8fHzUvHlzbd++XdHR0apXr16WR3b/08vUvHnzG67fVevJPNx07R/SW9G2bVvt3r1blSpVyraOWwk8Odnr4+npqZiYGI0bN06StH379uv2LYzbVforUGdui0w7d+7U999/79DWvHlznT9/PsuVYNeOT/rraphffvnF4Y/L6dOntWHDBod+bdu21enTp5Wenp7tdqhatep1665SpYoqVaqkDz74INs/YpLk6+urhg0bauHChQ7znJGRoY8++kjlypVTlSpVrruOW7Fw4UKHvQrnz5/XkiVLdPfdd9sPs2a3zZctW5bl8GlMTIx2796tn376yaF93rx5Lqu3sHyeuEKFChW0c+dOh7Zffvkly2HNq5UoUUIPPfSQ+vbtqzNnzujQoUNOjaVt27b69ddfFRgYmG2/a69aLAzYw1NIjBs3TnXr1tWJEyfsh0MkqVWrVmrTpo1eeOEFJScnq2nTptq5c6eGDx+uO++8U127dnVpHR4eHnrjjTd04cIF1a9fXxs2bNCoUaMUFxenu+6666bvnzp1qu666y7dfffdeuaZZ1ShQgWdP39eBw4c0JIlS+znJGWndevWuueee/T8888rJSVF9erV03fffacPP/zQpeu5++671bVrV40aNUp//PGH2rZtK09PT23fvl0+Pj7q379/zjaWpFdffVXx8fFq0qSJnn32WVWtWlWXLl3SoUOHtHz5cr3zzjtO37enZs2akv76mYiLi1PRokUVHR2tUaNG6dixY2rZsqXKlSunc+fOaerUqXJ3d1dMTMx1l1cYt6v01wfya6+9puHDhysmJkY///yzXn31VUVERDhc8t+tWzdNnjxZ3bp10+jRoxUZGanly5dr5cqVWZbZtWtX/ec//9E//vEP9erVS6dPn9b48eNVvHhxh36PPPKIPv74Y91333167rnn1KBBA7m7u+vYsWNau3at2rdvrwcffPC6tb/11ltq166dGjVqpIEDB6p8+fI6cuSIVq5caf8DPHbsWLVq1UrNmzfXkCFD5OHhobffflu7d+/W3Llzs+xBza2iRYuqVatWGjRokDIyMjRu3DglJyc73OSybdu2mjVrlqpVq6bo6Ght3bpVEyZMyPIzPGDAAH3wwQeKi4vTq6++qqCgIH3yySfat2+fJKlIEdf8X7swfJ64QteuXfWPf/xDffr0UadOnXT48GGNHz8+y6kM7dq1U1RUlOrVq6fSpUvr8OHDmjJlisLDwxUZGenUWAYMGKAFCxbonnvu0cCBAxUdHa2MjAwdOXJEq1at0uDBg9WwYcM8HbfL5fNJ07jG1VdpXeuxxx4zkhyu0jLmrytYXnjhBRMeHm7c3d1NSEiIeeaZZ8zZs2cd+oWHh5v7778/y3Ilmb59+zq0ZV4RMWHCBHtb9+7dja+vr9m5c6dp1qyZ8fb2NgEBAeaZZ55xuPrgesu8etlPPvmkKVu2rHF3dzelS5c2TZo0MaNGjbrhtjHGmHPnzpknn3zSlChRwvj4+JhWrVqZffv2ZbmqIrfrSU9PN5MnTzZRUVHGw8PD+Pv7m8aNG5slS5bY++TkKi1jjDl58qR59tlnTUREhHF3dzcBAQGmbt26ZtiwYfbtlt32vt4yU1NTzVNPPWVKly5tbDabkWQOHjxoli5dauLi4kzZsmWNh4eHKVOmjLnvvvvMt99+e9PxFqTter2f02u3d2pqqhkyZIgpW7as8fLyMnXq1DGLFy/OckWVMcYcO3bMdOrUyRQrVsz4+fmZTp06mQ0bNmS56scYY2bPnm2qV69uvLy8TI0aNcz8+fOzXeaVK1fMxIkTTa1atYyXl5cpVqyYqVatmundu7fZv3//TbfF999/b+Li4oy/v7/x9PQ0lSpVcrjSyRhjvv32W9OiRQvj6+trvL29TaNGjRy2lTHX/8wYPny4kWROnjzp0J75e5wp82dv3LhxZuTIkaZcuXLGw8PD3HnnnWblypUO7z179qzp2bOnKVOmjPHx8TF33XWX+fbbb7P9Xdi9e7eJjY01Xl5eJiAgwPTs2dPMnj3bSDI//vijvd+1V55eXefV2zy7q7Qy2wv650lOP2ONMWbt2rVGkvnss8/sbRkZGWb8+PGmYsWKxsvLy9SrV8+sWbMmy3Z/4403TJMmTUypUqXstxDp2bOnOXTo0C2N5cKFC+bll182VatWtf++1qxZ0wwcONAkJibedNwFjc0YY25rwgKAAuDQoUOKiIjQzJkzs72p299F5naYMGGChgwZkqfr+uc//6m5c+fq9OnT9pNzgduFQ1oAAJd79dVXFRoaqooVK+rChQtaunSp3nvvPb388suEHeQLAg8AwOXc3d01YcIEHTt2TGlpaYqMjNSkSZP03HPP5Xdp+JvikBYAALA8LksHAACWR+ABAACWR+ABAACWx0nL+uvupb///rv8/PxcfjMvAACQN4wxOn/+vEJDQ29+Q8v8vAnQmDFjTL169UyxYsVM6dKlTfv27c2+ffsc+nTv3t1Icng0bNjQoc+lS5dMv379TGBgoPHx8THt2rUzR48ezXEdR48ezbIOHjx48ODBg0fheOTkb36+7uFJSEhQ3759Vb9+faWlpWnYsGFq3bq1fvrpJ/n6+tr73XvvvZo5c6b9+bX3cBgwYICWLFmiefPmKTAwUIMHD1bbtm21detW+3fA3EjmF/0dPXo0yy3kAQBAwZScnKywsLAbfmFvpgJ1WfrJkydVpkwZJSQk6J577pEk9ejRQ+fOndPixYuzfU9SUpJKly6tDz/8UF26dJH017cJh4WFafny5WrTps1N15ucnCx/f38lJSUReAAAKCSc+ftdoE5aTkpKkiQFBAQ4tK9bt05lypRRlSpV1KtXL504ccL+2tatW3XlyhW1bt3a3hYaGqqoqKgs33CcKTU1VcnJyQ4PAABgXQUm8BhjNGjQIN11112Kioqyt8fFxenjjz/WmjVr9MYbb2jz5s1q0aKFUlNTJUmJiYny8PBQyZIlHZYXFBSkxMTEbNc1duxY+fv72x9hYWF5NzAAAJDvCsxVWv369dPOnTu1fv16h/bMw1SS7F97Hx4ermXLlqljx47XXZ4x5rpXXA0dOlSDBg2yP888BggAAKypQOzh6d+/v7788kutXbtW5cqVu2HfkJAQhYeHa//+/ZKk4OBgXb58WWfPnnXod+LECQUFBWW7DE9PTxUvXtzhAQAArCtfA48xRv369dPChQu1Zs0aRURE3PQ9p0+f1tGjRxUSEiJJqlu3rtzd3RUfH2/vc/z4ce3evVtNmjTJs9oBAEDhka+HtPr27atPPvlEX3zxhfz8/Ozn3Pj7+8vb21sXLlzQiBEj1KlTJ4WEhOjQoUN66aWXVKpUKT344IP2vj179tTgwYMVGBiogIAADRkyRDVr1lRsbGx+Dg8AABQQ+Rp4ZsyYIUlq1qyZQ/vMmTPVo0cPFS1aVLt27dKcOXN07tw5hYSEqHnz5po/f77DNfeTJ0+Wm5ubOnfurIsXL6ply5aaNWtWju7BAwAArK9A3Ycnv3AfHgAACp9Cex8eAACAvEDgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlldgvjwUKGwqvLgsv0v42zr0+v35XQKAQoY9PAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPLyNfCMHTtW9evXl5+fn8qUKaMOHTro559/duhjjNGIESMUGhoqb29vNWvWTHv27HHok5qaqv79+6tUqVLy9fXVAw88oGPHjt3OoQAAgAIsXwNPQkKC+vbtq40bNyo+Pl5paWlq3bq1UlJS7H3Gjx+vSZMm6c0339TmzZsVHBysVq1a6fz58/Y+AwYM0KJFizRv3jytX79eFy5cUNu2bZWenp4fwwIAAAWMzRhj8ruITCdPnlSZMmWUkJCge+65R8YYhYaGasCAAXrhhRck/bU3JygoSOPGjVPv3r2VlJSk0qVL68MPP1SXLl0kSb///rvCwsK0fPlytWnT5qbrTU5Olr+/v5KSklS8ePE8HSOso8KLy/K7hL+tQ6/fn98lACgAnPn7XaDO4UlKSpIkBQQESJIOHjyoxMREtW7d2t7H09NTMTEx2rBhgyRp69atunLlikOf0NBQRUVF2fsAAIC/N7f8LiCTMUaDBg3SXXfdpaioKElSYmKiJCkoKMihb1BQkA4fPmzv4+HhoZIlS2bpk/n+a6Wmpio1NdX+PDk52WXjAAAABU+B2cPTr18/7dy5U3Pnzs3yms1mc3hujMnSdq0b9Rk7dqz8/f3tj7CwsFsvHAAAFHgFIvD0799fX375pdauXaty5crZ24ODgyUpy56aEydO2Pf6BAcH6/Llyzp79ux1+1xr6NChSkpKsj+OHj3qyuEAAIACJl8DjzFG/fr108KFC7VmzRpFREQ4vB4REaHg4GDFx8fb2y5fvqyEhAQ1adJEklS3bl25u7s79Dl+/Lh2795t73MtT09PFS9e3OEBAACsK1/P4enbt68++eQTffHFF/Lz87PvyfH395e3t7dsNpsGDBigMWPGKDIyUpGRkRozZox8fHz02GOP2fv27NlTgwcPVmBgoAICAjRkyBDVrFlTsbGx+Tk8AABQQORr4JkxY4YkqVmzZg7tM2fOVI8ePSRJzz//vC5evKg+ffro7NmzatiwoVatWiU/Pz97/8mTJ8vNzU2dO3fWxYsX1bJlS82aNUtFixa9XUMBAAAFWIG6D09+4T48uBXchyf/cB8eAFIhvg8PAABAXiDwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAy8tV4Ln6CzgBAAAKKqcCz8qVK9WjRw9VqlRJ7u7u8vHxkZ+fn2JiYjR69Gj9/vvveVUnAADALctR4Fm8eLGqVq2q7t27q0iRIvrXv/6lhQsXauXKlXr//fcVExOjr7/+WhUrVtTTTz+tkydP5nXdAAAAOZajr5YYM2aMJk6cqPvvv19FimTNSJ07d5Yk/fbbb5o6darmzJmjwYMHu7ZSAACAW5SjwPPDDz/kaGFly5bV+PHjc1UQAACAq+X6Kq309HTt2LFDZ8+edUU9AAAALud04BkwYIDef/99SX+FnZiYGNWpU0dhYWFat26dq+sDAADINacDz+eff65atWpJkpYsWaKDBw9q3759GjBggIYNG+byAgEAAHLL6cBz6tQpBQcHS5KWL1+uhx9+WFWqVFHPnj21a9culxcIAACQW04HnqCgIP30009KT0/XihUrFBsbK0n6888/VbRoUZcXCAAAkFs5ukrrak888YQ6d+6skJAQ2Ww2tWrVSpK0adMmVatWzeUFAgAA5JbTgWfEiBGqWbOmjhw5oocfflienp6SpKJFi+rFF190eYEAAAC55VTguXLlilq3bq3//Oc/6tSpk8Nr3bt3d2lhAAAAruLUOTzu7u7avXu3bDZbXtUDAADgck6ftNytWzf7fXgAAAAKA6fP4bl8+bLee+89xcfHq169evL19XV4fdKkSS4rDgAAwBWcDjy7d+9WnTp1JEm//PKLw2sc6gIAAAWR04Fn7dq1eVEHAABAnrnlLw89cOCAVq5cqYsXL0qSjDEuKwoAAMCVnA48p0+fVsuWLVWlShXdd999On78uCTpqaee0uDBg11eIAAAQG45HXgGDhwod3d3HTlyRD4+Pvb2Ll26aMWKFS4tDgAAwBWcPodn1apVWrlypcqVK+fQHhkZqcOHD7usMAAAAFdxeg9PSkqKw56dTKdOnbJ/zQQAAEBB4nTgueeeezRnzhz7c5vNpoyMDE2YMEHNmzd3aXEAAACu4PQhrQkTJqhZs2basmWLLl++rOeff1579uzRmTNn9N133+VFjQAAALni9B6eGjVqaOfOnWrQoIFatWqllJQUdezYUdu3b1elSpXyokYAAIBccXoPjyQFBwdr5MiRrq4FAAAgT+Qo8OzcuVNRUVEqUqSIdu7cecO+0dHRLikMAADAVXIUeGrXrq3ExESVKVNGtWvXls1my/bOyjabTenp6S4vEgAAIDdyFHgOHjyo0qVL2/8NAABQmOQo8ISHh2f7bwAAgMIgR4Hnyy+/zPECH3jggVsuBgAAIC/kKPB06NAhRwvjHB4AAFAQ5SjwZGRk5HUdAAAAecbpGw8CAAAUNjnawzNt2rQcL/DZZ5+95WIAAADyQo4Cz+TJk3O0MJvNRuABAAAFTo7vwwMAAFBYcQ4PAACwvBzt4Rk0aJBee+01+fr6atCgQTfsO2nSJJcUBgAA4Co5Cjzbt2/XlStX7P++HpvN5pqqACAfVXhxWX6X8Ld16PX787sEWFSOAs/atWuz/TcAAEBhwDk8AADA8nK0h+dqly5d0vTp07V27VqdOHEiy12Yt23b5rLiAAAAXMHpwPPkk08qPj5eDz30kBo0aMB5OwAAoMBzOvAsW7ZMy5cvV9OmTfOiHgAAAJdz+hyesmXLys/PLy9qAQAAyBNO7+F544039MILL+idd95ReHh4XtQEAIDLcbuB/FMQbjfgdOCpV6+eLl26pIoVK8rHx0fu7u4Or585c8ZlxQEAALiC04Hn0Ucf1W+//aYxY8YoKCiIk5YBAECB53Tg2bBhg77//nvVqlUrL+oBAABwOadPWq5WrZouXryYF7UAAADkCacDz+uvv67Bgwdr3bp1On36tJKTkx0eAAAABY3Th7TuvfdeSVLLli0d2o0xstlsSk9Pd01lAAAALuJ04OHLQwEAQGHjdOCJiYnJizoAAADyTI7O4Tly5IhTC/3tt99y1O+bb75Ru3btFBoaKpvNpsWLFzu83qNHD9lsNodHo0aNHPqkpqaqf//+KlWqlHx9ffXAAw/o2LFjTtULAACsLUeBp379+urVq5d++OGH6/ZJSkrSf//7X0VFRWnhwoU5WnlKSopq1aqlN99887p97r33Xh0/ftz+WL58ucPrAwYM0KJFizRv3jytX79eFy5cUNu2bTmXCAAA2OXokNbevXs1ZswY3XvvvXJ3d1e9evUUGhoqLy8vnT17Vj/99JP27NmjevXqacKECYqLi8vRyuPi4m7a19PTU8HBwdm+lpSUpPfff18ffvihYmNjJUkfffSRwsLC9PXXX6tNmzY5qgMAAFhbjvbwBAQEaOLEifr99981Y8YMValSRadOndL+/fslSY8//ri2bt2q7777LsdhJ6fWrVunMmXKqEqVKurVq5dOnDhhf23r1q26cuWKWrdubW8LDQ1VVFSUNmzY4NI6AABA4eXUScteXl7q2LGjOnbsmFf1OIiLi9PDDz+s8PBwHTx4UK+88opatGihrVu3ytPTU4mJifLw8FDJkiUd3hcUFKTExMTrLjc1NVWpqan259w/CAAAa3P6Kq3bqUuXLvZ/R0VFqV69egoPD9eyZctuGLoy7wl0PWPHjtXIkSNdWisAACi4nL7Tcn4KCQlReHi4/VBacHCwLl++rLNnzzr0O3HihIKCgq67nKFDhyopKcn+OHr0aJ7WDQAA8lehCjynT5/W0aNHFRISIkmqW7eu3N3dFR8fb+9z/Phx7d69W02aNLnucjw9PVW8eHGHBwAAsK58PaR14cIFHThwwP784MGD2rFjhwICAhQQEKARI0aoU6dOCgkJ0aFDh/TSSy+pVKlSevDBByVJ/v7+6tmzpwYPHqzAwEAFBARoyJAhqlmzpv2qLQAAgHwNPFu2bFHz5s3tzwcNGiRJ6t69u2bMmKFdu3Zpzpw5OnfunEJCQtS8eXPNnz9ffn5+9vdMnjxZbm5u6ty5sy5evKiWLVtq1qxZKlq06G0fDwAAKJicDjyzZ89WqVKldP/990uSnn/+eb377ruqUaOG5s6dq/Dw8Bwvq1mzZjLGXPf1lStX3nQZXl5emj59uqZPn57j9QIAgL8Xp8/hGTNmjLy9vSVJ33//vd58802NHz9epUqV0sCBA11eIAAAQG45vYfn6NGjqly5siRp8eLFeuihh/TPf/5TTZs2VbNmzVxdHwAAQK45vYenWLFiOn36tCRp1apV9pODvby8dPHiRddWBwAA4AJO7+Fp1aqVnnrqKd1555365Zdf7Ofy7NmzRxUqVHB1fQAAALnm9B6et956S40bN9bJkye1YMECBQYGSvrre60effRRlxcIAACQW07v4UlOTta0adNUpIhjVhoxYgR3LAYAAAWS03t4IiIidOrUqSztZ86cUUREhEuKAgAAcCWnA8/17ptz4cIFeXl55bogAAAAV8vxIa3MuyDbbDb9+9//lo+Pj/219PR0bdq0SbVr13Z5gQAAALmV48Czfft2SX/t4dm1a5c8PDzsr3l4eKhWrVoaMmSI6ysEAADIpRwHnrVr10qSnnjiCU2dOpVvGAcAAIWG01dpzZw5My/qAAAAyDNOB56UlBS9/vrrWr16tU6cOKGMjAyH1//3v/+5rDgAAABXcDrwPPXUU0pISFDXrl0VEhIim82WF3UBAAC4jNOB56uvvtKyZcvUtGnTvKgHAADA5Zy+D0/JkiUVEBCQF7UAAADkCacDz2uvvaZ///vf+vPPP/OiHgAAAJdz+pDWG2+8oV9//VVBQUGqUKGC3N3dHV7ftm2by4oDAABwBacDT4cOHfKgDAAAgLzjdOAZPnx4XtQBAACQZ5w+h0eSzp07p/fee09Dhw7VmTNnJP11KOu3335zaXEAAACu4PQenp07dyo2Nlb+/v46dOiQevXqpYCAAC1atEiHDx/WnDlz8qJOAACAW+b0Hp5BgwapR48e2r9/v7y8vOztcXFx+uabb1xaHAAAgCs4HXg2b96s3r17Z2kvW7asEhMTXVIUAACAKzkdeLy8vJScnJyl/eeff1bp0qVdUhQAAIArOR142rdvr1dffVVXrlyRJNlsNh05ckQvvviiOnXq5PICAQAAcsvpwDNx4kSdPHlSZcqU0cWLFxUTE6PKlSvLz89Po0ePzosaAQAAcsXpq7SKFy+u9evXa82aNdq2bZsyMjJUp04dxcbG5kV9AAAAueZ04MnUokULtWjRwpW1AAAA5IkcBZ5p06bpn//8p7y8vDRt2rQb9n322WddUhgAAICr5CjwTJ48WY8//ri8vLw0efLk6/az2WwEHgAAUODkKPAcPHgw238DAAAUBrf0XVoAAACFSY728AwaNCjHC5w0adItFwMAAJAXchR4tm/fnqOF2Wy2XBUDAACQF3IUeNauXZvXdQAAAOQZp8/hSUpK0pkzZ7K0nzlzJtvv2AIAAMhvTgeeRx55RPPmzcvS/umnn+qRRx5xSVEAAACu5HTg2bRpk5o3b56lvVmzZtq0aZNLigIAAHAlpwNPamqq0tLSsrRfuXJFFy9edElRAAAAruR04Klfv77efffdLO3vvPOO6tat65KiAAAAXMnpLw8dPXq0YmNj9eOPP6ply5aSpNWrV2vz5s1atWqVywsEAADILaf38DRt2lTff/+9wsLC9Omnn2rJkiWqXLmydu7cqbvvvjsvagQAAMgVp/fwSFLt2rX18ccfu7oWAACAPMF3aQEAAMsj8AAAAMsj8AAAAMsj8AAAAMu75cBz4MABrVy50n6zQWOMy4oCAABwJacDz+nTpxUbG6sqVarovvvu0/HjxyVJTz31lAYPHuzyAgEAAHLL6cAzcOBAubm56ciRI/Lx8bG3d+nSRStWrHBpcQAAAK7g9H14Vq1apZUrV6pcuXIO7ZGRkTp8+LDLCgMAAHAVp/fwpKSkOOzZyXTq1Cl5enq6pCgAAABXcjrw3HPPPZozZ479uc1mU0ZGhiZMmKDmzZu7tDgAAABXcPqQ1oQJE9SsWTNt2bJFly9f1vPPP689e/bozJkz+u677/KiRgAAgFxxeg9PjRo1tHPnTjVo0ECtWrVSSkqKOnbsqO3bt6tSpUp5USMAAECu3NKXhwYHB2vkyJGurgUAACBP5Cjw7Ny5M8cLjI6OvuViAAAA8kKOAk/t2rVls9lkjJHNZrO3Z95d+eq29PR0F5cIAACQOzk6h+fgwYP63//+p4MHD2rBggWKiIjQ22+/rR07dmjHjh16++23ValSJS1YsCCv6wUAAHBajvbwhIeH2//98MMPa9q0abrvvvvsbdHR0QoLC9Mrr7yiDh06uLxIAACA3HD6Kq1du3YpIiIiS3tERIR++uknlxQFAADgSk4HnurVq2vUqFG6dOmSvS01NVWjRo1S9erVnVrWN998o3bt2ik0NFQ2m02LFy92eN0YoxEjRig0NFTe3t5q1qyZ9uzZ49AnNTVV/fv3V6lSpeTr66sHHnhAx44dc3ZYAADAwpwOPO+8846+/vprhYWFKTY2VrGxsSpXrpzi4+P1zjvvOLWslJQU1apVS2+++Wa2r48fP16TJk3Sm2++qc2bNys4OFitWrXS+fPn7X0GDBigRYsWad68eVq/fr0uXLigtm3bcvI0AACwc/o+PA0aNNDBgwf10Ucfad++fTLGqEuXLnrsscfk6+vr1LLi4uIUFxeX7WvGGE2ZMkXDhg1Tx44dJUmzZ89WUFCQPvnkE/Xu3VtJSUl6//339eGHHyo2NlaS9NFHHyksLExff/212rRp4+zwAACABd3SjQd9fHz0z3/+09W1ODh48KASExPVunVre5unp6diYmK0YcMG9e7dW1u3btWVK1cc+oSGhioqKkobNmwg8AAAAEm3GHhuh8TERElSUFCQQ3tQUJAOHz5s7+Ph4aGSJUtm6ZP5/uykpqYqNTXV/jw5OdlVZQMAgALI6XN4brerb2ooKcvND7Nzsz5jx46Vv7+//REWFuaSWgEAQMFUYANPcHCwJGXZU3PixAn7Xp/g4GBdvnxZZ8+evW6f7AwdOlRJSUn2x9GjR11cPQAAKEgKbOCJiIhQcHCw4uPj7W2XL19WQkKCmjRpIkmqW7eu3N3dHfocP35cu3fvtvfJjqenp4oXL+7wAAAA1nVL5/CcO3dOn3/+uX799Vf961//UkBAgLZt26agoCCVLVs2x8u5cOGCDhw4YH9+8OBB7dixQwEBASpfvrwGDBigMWPGKDIyUpGRkRozZox8fHz02GOPSZL8/f3Vs2dPDR48WIGBgQoICNCQIUNUs2ZN+1VbAAAATgeenTt3KjY2Vv7+/jp06JB69eqlgIAALVq0SIcPH9acOXNyvKwtW7aoefPm9ueDBg2SJHXv3l2zZs3S888/r4sXL6pPnz46e/asGjZsqFWrVsnPz8/+nsmTJ8vNzU2dO3fWxYsX1bJlS82aNUtFixZ1dmgAAMCinA48gwYNUo8ePTR+/HiH4BEXF2ff85JTzZo1s3/jenZsNptGjBihESNGXLePl5eXpk+frunTpzu1bgAA8Pfh9Dk8mzdvVu/evbO0ly1b9oaXggMAAOQXpwOPl5dXtvet+fnnn1W6dGmXFAUAAOBKTgee9u3b69VXX9WVK1ck/XXY6ciRI3rxxRfVqVMnlxcIAACQW04HnokTJ+rkyZMqU6aMLl68qJiYGFWuXFl+fn4aPXp0XtQIAACQK06ftFy8eHGtX79ea9as0bZt25SRkaE6depwGTgAACiwnAo8aWlp8vLy0o4dO9SiRQu1aNEir+oCAABwGacOabm5uSk8PFzp6el5VQ8AAIDLOX0Oz8svv6yhQ4fqzJkzeVEPAACAyzl9Ds+0adN04MABhYaGKjw8XL6+vg6vb9u2zWXFAQAAuILTgadDhw55UAYAAEDecTrwDB8+PC/qAAAAyDO39G3p0l9f/Ll3717ZbDZVr15ddevWdWVdAAAALuN04Dl27JgeffRRfffddypRooQk6dy5c2rSpInmzp2rsLAwV9cIAACQK05fpfXkk0/qypUr2rt3r86cOaMzZ85o7969MsaoZ8+eeVEjAABArji9h+fbb7/Vhg0bVLVqVXtb1apVNX36dDVt2tSlxQEAALiC03t4ypcvb//i0KulpaWpbNmyLikKAADAlZwOPOPHj1f//v21ZcsWGWMk/XUC83PPPaeJEye6vEAAAIDcytEhrZIlS8pms9mfp6SkqGHDhnJz++vtaWlpcnNz05NPPsl9egAAQIGTo8AzZcqUPC4DAAAg7+Qo8HTv3j2v6wAAAMgzt3zjwRMnTujEiRPKyMhwaI+Ojs51UQAAAK7kdODZunWrunfvbr/3ztVsNpvS09NdVhwAAIArOB14nnjiCVWpUkXvv/++goKCHE5mBgAAKIicDjwHDx7UwoULVbly5byoBwAAwOWcvg9Py5Yt9eOPP+ZFLQAAAHnC6T087733nrp3767du3crKipK7u7uDq8/8MADLisOAADAFZwOPBs2bND69ev11VdfZXmNk5YBAEBB5PQhrWeffVZdu3bV8ePHlZGR4fAg7AAAgILI6cBz+vRpDRw4UEFBQXlRDwAAgMs5HXg6duyotWvX5kUtAAAAecLpc3iqVKmioUOHav369apZs2aWk5afffZZlxUHAADgCrd0lVaxYsWUkJCghIQEh9dsNhuBBwAAFDi3dONB5FyFF5fldwl/W4devz+/SwAAFBBOn8NzNWNMlu/TAgAAKGhuKfDMmTNHNWvWlLe3t7y9vRUdHa0PP/zQ1bUBAAC4hNOHtCZNmqRXXnlF/fr1U9OmTWWM0Xfffaenn35ap06d0sCBA/OiTgAAgFvmdOCZPn26ZsyYoW7dutnb2rdvrzvuuEMjRowg8AAAgALH6UNax48fV5MmTbK0N2nSRMePH3dJUQAAAK7kdOCpXLmyPv300yzt8+fPV2RkpEuKAgAAcCWnD2mNHDlSXbp00TfffKOmTZvKZrNp/fr1Wr16dbZBCAAAIL85vYenU6dO2rRpk0qVKqXFixdr4cKFKlWqlH744Qc9+OCDeVEjAABArji9h0eS6tatq48++sjVtQAAAOSJXN14EAAAoDDI8R6eIkWKyGaz3bCPzWZTWlparosCAABwpRwHnkWLFl33tQ0bNmj69Ol8zQQAACiQchx42rdvn6Vt3759Gjp0qJYsWaLHH39cr732mkuLAwAAcIVbOofn999/V69evRQdHa20tDTt2LFDs2fPVvny5V1dHwAAQK45FXiSkpL0wgsvqHLlytqzZ49Wr16tJUuWKCoqKq/qAwAAyLUcH9IaP368xo0bp+DgYM2dOzfbQ1wAAAAFUY4Dz4svvihvb29VrlxZs2fP1uzZs7Ptt3DhQpcVBwAA4Ao5DjzdunW76WXpAAAABVGOA8+sWbPysAwAAIC8w52WAQCA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RXowDNixAjZbDaHR3BwsP11Y4xGjBih0NBQeXt7q1mzZtqzZ08+VgwAAAqiAh14JOmOO+7Q8ePH7Y9du3bZXxs/frwmTZqkN998U5s3b1ZwcLBatWql8+fP52PFAACgoCnwgcfNzU3BwcH2R+nSpSX9tXdnypQpGjZsmDp27KioqCjNnj1bf/75pz755JN8rhoAABQkBT7w7N+/X6GhoYqIiNAjjzyi//3vf5KkgwcPKjExUa1bt7b39fT0VExMjDZs2JBf5QIAgALILb8LuJGGDRtqzpw5qlKliv744w+NGjVKTZo00Z49e5SYmChJCgoKcnhPUFCQDh8+fMPlpqamKjU11f48OTnZ9cUDAIACo0AHnri4OPu/a9asqcaNG6tSpUqaPXu2GjVqJEmy2WwO7zHGZGm71tixYzVy5EjXFwwAAAqkAn9I62q+vr6qWbOm9u/fb79aK3NPT6YTJ05k2etzraFDhyopKcn+OHr0aJ7VDAAA8l+hCjypqanau3evQkJCFBERoeDgYMXHx9tfv3z5shISEtSkSZMbLsfT01PFixd3eAAAAOsq0Ie0hgwZonbt2ql8+fI6ceKERo0apeTkZHXv3l02m00DBgzQmDFjFBkZqcjISI0ZM0Y+Pj567LHH8rt0AABQgBTowHPs2DE9+uijOnXqlEqXLq1GjRpp48aNCg8PlyQ9//zzunjxovr06aOzZ8+qYcOGWrVqlfz8/PK5cgAAUJAU6MAzb968G75us9k0YsQIjRgx4vYUBAAACqVCdQ4PAADArSDwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAy7NM4Hn77bcVEREhLy8v1a1bV99++21+lwQAAAoISwSe+fPna8CAARo2bJi2b9+uu+++W3FxcTpy5Eh+lwYAAAoASwSeSZMmqWfPnnrqqadUvXp1TZkyRWFhYZoxY0Z+lwYAAAqAQh94Ll++rK1bt6p169YO7a1bt9aGDRvyqSoAAFCQuOV3Abl16tQppaenKygoyKE9KChIiYmJ2b4nNTVVqamp9udJSUmSpOTkZJfXl5H6p8uXiZzJi/m8GnObf5hb68rLuWVe809ezWvmco0xN+1b6ANPJpvN5vDcGJOlLdPYsWM1cuTILO1hYWF5Uhvyh/+U/K4AeYW5tS7m1pryel7Pnz8vf3//G/Yp9IGnVKlSKlq0aJa9OSdOnMiy1yfT0KFDNWjQIPvzjIwMnTlzRoGBgdcNSZmSk5MVFhamo0ePqnjx4rkfQAHGWK3r7zRexmpdf6fxMtbsGWN0/vx5hYaG3nS5hT7weHh4qG7duoqPj9eDDz5ob4+Pj1f79u2zfY+np6c8PT0d2kqUKOHUeosXL275H7pMjNW6/k7jZazW9XcaL2PN6mZ7djIV+sAjSYMGDVLXrl1Vr149NW7cWO+++66OHDmip59+Or9LAwAABYAlAk+XLl10+vRpvfrqqzp+/LiioqK0fPlyhYeH53dpAACgALBE4JGkPn36qE+fPnm+Hk9PTw0fPjzLITErYqzW9XcaL2O1rr/TeBlr7tlMTq7lAgAAKMQK/Y0HAQAAbobAAwAALI/AAwAALI/AAwAALI/Ac423335bERER8vLyUt26dfXtt99et++6detks9myPPbt23cbK74133zzjdq1a6fQ0FDZbDYtXrz4pu9JSEhQ3bp15eXlpYoVK+qdd97J+0JdxNnxFua5HTt2rOrXry8/Pz+VKVNGHTp00M8//3zT9xXG+b2VsRbWuZ0xY4aio6PtN2Nr3Lixvvrqqxu+pzDOaSZnx1tY5zU7Y8eOlc1m04ABA27YrzDPb6acjNVVc0vgucr8+fM1YMAADRs2TNu3b9fdd9+tuLg4HTly5Ibv+/nnn3X8+HH7IzIy8jZVfOtSUlJUq1Ytvfnmmznqf/DgQd133326++67tX37dr300kt69tlntWDBgjyu1DWcHW+mwji3CQkJ6tu3rzZu3Kj4+HilpaWpdevWSklJue57Cuv83spYMxW2uS1Xrpxef/11bdmyRVu2bFGLFi3Uvn177dmzJ9v+hXVOMzk73kyFbV6vtXnzZr377ruKjo6+Yb/CPr9SzseaKddza2DXoEED8/TTTzu0VatWzbz44ovZ9l+7dq2RZM6ePXsbqss7ksyiRYtu2Of555831apVc2jr3bu3adSoUR5WljdyMl6rzK0xxpw4ccJIMgkJCdftY5X5zclYrTS3JUuWNO+99162r1llTq92o/FaYV7Pnz9vIiMjTXx8vImJiTHPPffcdfsW9vl1Zqyumlv28Pyfy5cva+vWrWrdurVDe+vWrbVhw4YbvvfOO+9USEiIWrZsqbVr1+Zlmfnm+++/z7Jt2rRpoy1btujKlSv5VFXes8LcJiUlSZICAgKu28cq85uTsWYqzHObnp6uefPmKSUlRY0bN862j1XmVMrZeDMV5nnt27ev7r//fsXGxt60b2GfX2fGmim3c2uZOy3n1qlTp5Senp7lG9aDgoKyfBN7ppCQEL377ruqW7euUlNT9eGHH6ply5Zat26d7rnnnttR9m2TmJiY7bZJS0vTqVOnFBISkk+V5Q2rzK0xRoMGDdJdd92lqKio6/azwvzmdKyFeW537dqlxo0b69KlSypWrJgWLVqkGjVqZNvXCnPqzHgL87xK0rx587Rt2zZt3rw5R/0L8/w6O1ZXzS2B5xo2m83huTEmS1umqlWrqmrVqvbnjRs31tGjRzVx4sRC8QvmrOy2TXbtVmCVue3Xr5927typ9evX37RvYZ/fnI61MM9t1apVtWPHDp07d04LFixQ9+7dlZCQcN0QUNjn1JnxFuZ5PXr0qJ577jmtWrVKXl5eOX5fYZzfWxmrq+aWQ1r/p1SpUipatGiWvTknTpzIkqJvpFGjRtq/f7+ry8t3wcHB2W4bNzc3BQYG5lNVt1dhm9v+/fvryy+/1Nq1a1WuXLkb9i3s8+vMWLNTWObWw8NDlStXVr169TR27FjVqlVLU6dOzbZvYZ9TybnxZqewzOvWrVt14sQJ1a1bV25ubnJzc1NCQoKmTZsmNzc3paenZ3lPYZ3fWxlrdm5lbtnD8388PDxUt25dxcfH68EHH7S3x8fHq3379jlezvbt2wv0rsRb1bhxYy1ZssShbdWqVapXr57c3d3zqarbq7DMrTFG/fv316JFi7Ru3TpFRETc9D2FdX5vZazZKSxzey1jjFJTU7N9rbDO6Y3caLzZKSzz2rJlS+3atcuh7YknnlC1atX0wgsvqGjRolneU1jn91bGmp1bmttcnfJsMfPmzTPu7u7m/fffNz/99JMZMGCA8fX1NYcOHTLGGPPiiy+arl272vtPnjzZLFq0yPzyyy9m9+7d5sUXXzSSzIIFC/JrCDl2/vx5s337drN9+3YjyUyaNMls377dHD582BiTdaz/+9//jI+Pjxk4cKD56aefzPvvv2/c3d3N559/nl9DcIqz4y3Mc/vMM88Yf39/s27dOnP8+HH7488//7T3scr83spYC+vcDh061HzzzTfm4MGDZufOneall14yRYoUMatWrTLGWGdOMzk73sI6r9dz7ZVLVpvfq91srK6aWwLPNd566y0THh5uPDw8TJ06dRwub+3evbuJiYmxPx83bpypVKmS8fLyMiVLljR33XWXWbZsWT5U7bzMy/yufXTv3t0Yk3Wsxhizbt06c+eddxoPDw9ToUIFM2PGjNtf+C1ydryFeW6zG6ckM3PmTHsfq8zvrYy1sM7tk08+af9sKl26tGnZsqX9j78x1pnTTM6Ot7DO6/VcGwKsNr9Xu9lYXTW3NmP+7ywnAAAAi+KkZQAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgC3TWJiovr376+KFSvK09NTYWFhateunVavXp3fpQGwOL48FMBtcejQITVt2lQlSpTQ+PHjFR0drStXrmjlypXq27ev9u3bl98lArAw9vAAuC369Okjm82mH374QQ899JCqVKmiO+64Q4MGDdLGjRslSUeOHFH79u1VrFgxFS9eXJ07d9Yff/xhX8aIESNUu3ZtffDBBypfvryKFSumZ555Runp6Ro/fryCg4NVpkwZjR492mHdNptNM2bMUFxcnLy9vRUREaHPPvvMoc8LL7ygKlWqyMfHRxUrVtQrr7yiK1euZFn3hx9+qAoVKsjf31+PPPKIzp8/L0maM2eOAgMDs3ybd6dOndStWzeXbksAziPwAMhzZ86c0YoVK9S3b1/5+vpmeb1EiRIyxqhDhw46c+aMEhISFB8fr19//VVdunRx6Pvrr7/qq6++0ooVKzR37lx98MEHuv/++3Xs2DElJCRo3Lhxevnll+0hKtMrr7yiTp066ccff9Q//vEPPfroo9q7d6/9dT8/P82aNUs//fSTpk6dqv/+97+aPHlylnUvXrxYS5cu1dKlS5WQkKDXX39dkvTwww8rPT1dX375pb3/qVOntHTpUj3xxBO53oYAcim333IKADezadMmI8ksXLjwun1WrVplihYtao4cOWJv27Nnj5FkfvjhB2OMMcOHDzc+Pj4mOTnZ3qdNmzamQoUKJj093d5WtWpVM3bsWPtzSebpp592WF/Dhg3NM888c916xo8fb+rWrWt/nt26//Wvf5mGDRvanz/zzDMmLi7O/nzKlCmmYsWKJiMj47rrAXB7cA4PgDxnjJH016Gl69m7d6/CwsIUFhZmb6tRo4ZKlCihvXv3qn79+pKkChUqyM/Pz94nKChIRYsWVZEiRRzaTpw44bD8xo0bZ3m+Y8cO+/PPP/9cU6ZM0YEDB3ThwgWlpaWpePHiDu+5dt0hISEO6+nVq5fq16+v3377TWXLltXMmTPVo0ePG44bwO3BIS0AeS4yMlI2m83hENK1jDHZBoNr293d3R1et9ls2bZlZGTctK7M5W7cuFGPPPKI4uLitHTpUm3fvl3Dhg3T5cuXHfrfbD133nmnatWqpTlz5mjbtm3atWuXevTocdM6AOQ9Ag+APBcQEKA2bdrorbfeUkpKSpbXz507pxo1aujIkSM6evSovf2nn35SUlKSqlevnusarj2nZ+PGjapWrZok6bvvvlN4eLiGDRumevXqKTIyUocPH76l9Tz11FOaOXOmPvjgA8XGxjrssQKQfwg8AG6Lt99+W+np6WrQoIEWLFig/fv3a+/evZo2bZoaN26s2NhYRUdH6/HHH9e2bdv0ww8/qFu3boqJiVG9evVyvf7PPvtMH3zwgX755RcNHz5cP/zwg/r16ydJqly5so4cOaJ58+bp119/1bRp07Ro0aJbWs/jjz+u3377Tf/973/15JNP5rpuAK5B4AFwW0RERGjbtm1q3ry5Bg8erKioKLVq1UqrV6/WjBkzZLPZtHjxYpUsWVL33HOPYmNjVbFiRc2fP98l6x85cqTmzZun6OhozZ49Wx9//LFq1KghSWrfvr0GDhyofv36qXbt2tqwYYNeeeWVW1pP8eLF1alTJxUrVkwdOnRwSe0Acs9mMs8mBACLstlsWrRo0W0LIK1atVL16tU1bdq027I+ADfHVVoA4CJnzpzRqlWrtGbNGr355pv5XQ6AqxB4AMBF6tSpo7Nnz2rcuHGqWrVqfpcD4Coc0gIAAJbHScsAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDy/h/zrjlJvMlDWgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compute_nb_clients(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "5eb3efcc-c7a9-4a0e-aab1-29a36032cb31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de consentement à la reception de mails" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "848963c9-6129-4106-80b5-76bf814b70d1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/1336968363.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n" + ] + } + ], + "source": [ + "customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n", + "\n", + "def mailing_consent(customer_musee):\n", + " df_graph = customer_musee.groupby([\"number_company\", \"already_purchased\"])[\"opt_in\"].mean().reset_index()\n", + " # Création du barplot groupé\n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " \n", + " categories = df_graph[\"number_company\"].unique()\n", + " bar_width = 0.35\n", + " bar_positions = np.arange(len(categories))\n", + " \n", + " # Grouper les données par label et créer les barres groupées\n", + " for label in df_graph[\"already_purchased\"].unique():\n", + " label_data = df_graph[df_graph['already_purchased'] == label]\n", + " values = [label_data[label_data['number_company'] == category]['opt_in'].values[0]*100 for category in categories]\n", + " \n", + " label_printed = \"purchased\" if label else \"no purchase\"\n", + " ax.bar(bar_positions, values, bar_width, label=label_printed)\n", + " \n", + " # Mise à jour des positions des barres pour le prochain groupe\n", + " bar_positions = [pos + bar_width for pos in bar_positions]\n", + " \n", + " # Ajout des étiquettes, de la légende, etc.\n", + " ax.set_xlabel('Numero de compagnie')\n", + " ax.set_ylabel('Part de consentement (%)')\n", + " ax.set_title('Part de consentement au mailing selon les compagnies')\n", + " ax.set_xticks([pos + bar_width / 2 for pos in np.arange(len(categories))])\n", + " ax.set_xticklabels(categories)\n", + " ax.legend()\n", + " \n", + " # Affichage du plot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "c7239078-5c1a-4522-8d72-848efe7df28f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mailing_consent(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "a6c94f0f-4ef4-432f-b2c9-11f51627b7e9", + "metadata": {}, + "source": [ + "## Part homme / femme client" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "321feb43-242e-4147-a5c8-ad1b41fc1246", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
customer_idstreet_idstructure_idmcp_contact_idfidelitytenant_idis_partnerdeleted_atgenderis_email_trueopt_inlast_buying_datemax_priceticket_sumaverage_priceaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepurchase_countfirst_buying_datecountrygender_labelgender_femalegender_malegender_othercountry_frnumber_companyalready_purchased
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [customer_id, street_id, structure_id, mcp_contact_id, fidelity, tenant_id, is_partner, deleted_at, gender, is_email_true, opt_in, last_buying_date, max_price, ticket_sum, average_price, average_purchase_delay, average_price_basket, average_ticket_basket, total_price, purchase_count, first_buying_date, country, gender_label, gender_female, gender_male, gender_other, country_fr, number_company, already_purchased]\n", + "Index: []" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "customer_musee[customer_musee['gender_male'] + customer_musee['gender_female'] + customer_musee['gender_other'] == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "3bb5dc1e-05dc-41da-83bb-cb6b8d43fa73", + "metadata": {}, + "outputs": [], + "source": [ + "def gender_bar(customer_musee):\n", + " company_genders = customer_musee.groupby(\"number_company\")[[\"gender_male\", \"gender_female\", \"gender_other\"]].mean().reset_index()\n", + " \n", + " # Création du barplot\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_male\"], label = \"Homme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_female\"], \n", + " bottom = company_genders[\"gender_male\"], label = \"Femme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_other\"], \n", + " bottom = company_genders[\"gender_male\"] + company_genders[\"gender_female\"], label = \"Inconnu\")\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients de chaque sexe\")\n", + " plt.title(\"Sexe des clients de chaque compagnie de musee\")\n", + " plt.legend()\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_genders[\"number_company\"], [\"{}\".format(i) for i in company_genders[\"number_company\"]])\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "c61c4b41-ba31-44f4-9515-25922798b86a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gender_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "b02a2668-5cea-44db-b2b5-168f7738a949", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de clients français" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "4b3bb641-814b-4679-9a67-4eca87a920a6", + "metadata": {}, + "outputs": [], + "source": [ + "def country_bar(customer_sport):\n", + " company_country_fr = customer_sport.groupby(\"number_company\")[\"country_fr\"].mean().reset_index()\n", + " # Création du barplot\n", + " plt.bar(company_country_fr[\"number_company\"], company_country_fr[\"country_fr\"])\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients français\")\n", + " plt.title(\"Nationalité des clients de chaque compagnie de musée\")\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_country_fr[\"number_company\"], [\"{}\".format(i) for i in company_country_fr[\"number_company\"]])\n", + "\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "01258674-6b98-49e4-93f4-f4185964999f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "country_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "6c9e8051-06d1-44ed-aa17-eb8ddd9fb5ed", + "metadata": {}, + "source": [ + "## Ouverture mails" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "e346fdc0-617f-463b-af29-caa0d9f88485", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def campaigns_effectiveness(customer_sport, Train=False):\n", + " if not Train:\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n", + "\n", + " nb_customers_purchasing = customer_sport[customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + " nb_customers_no_purchase = customer_sport[~customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + "\n", + " plt.bar(nb_customers_purchasing[\"number_company\"], nb_customers_purchasing[\"customer_id\"]/1000, label = \"has purchased\")\n", + " plt.bar(nb_customers_no_purchase[\"number_company\"], nb_customers_no_purchase[\"customer_id\"]/1000, \n", + " bottom = nb_customers_purchasing[\"customer_id\"]/1000, label = \"has not purchased\")\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (en milliers)\")\n", + " plt.title(\"Nombre de clients ayant acheté ou été ciblés par des mails pour les compagnies de musée\")\n", + " plt.legend()\n", + "\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "928dab1d-96ff-4fc2-91ea-2ff119620f31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/3480143790.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "campaigns_effectiveness(customer_musee)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Musee/2_modelisation_pipeline+visu.ipynb b/Musee/2_modelisation_pipeline+visu.ipynb new file mode 100644 index 0000000..b2ee9b2 --- /dev/null +++ b/Musee/2_modelisation_pipeline+visu.ipynb @@ -0,0 +1,2877 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ac01a6ea-bef6-4ace-89ff-1dc03a4215c2", + "metadata": {}, + "source": [ + "# Segmentation des clients par régression logistique" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bca785be-39f7-4583-9bd8-67c1134ae275", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "import s3fs\n", + "import re\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n", + "from sklearn.preprocessing import StandardScaler\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import roc_curve, auc, precision_recall_curve, average_precision_score\n", + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "14378e7b-240f-4df7-9ce8-5e60920a7729", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'1.12.0'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scipy\n", + "scipy.__version__ # il faut cette version pr eviter les pb" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3bf57816-b023-4e84-9450-095620bddebc", + "metadata": {}, + "outputs": [], + "source": [ + "# Create filesystem object\n", + "S3_ENDPOINT_URL = \"https://\" + os.environ[\"AWS_S3_ENDPOINT\"]\n", + "fs = s3fs.S3FileSystem(client_kwargs={'endpoint_url': S3_ENDPOINT_URL})" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "27002f2f-a78a-414c-8e4f-b15bf6dd9e40", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3769/2190163697.py:7: DtypeWarning: Columns (38) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " dataset_train = pd.read_csv(file_in, sep=\",\")\n", + "/tmp/ipykernel_3769/2190163697.py:12: DtypeWarning: Columns (38) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " dataset_test = pd.read_csv(file_in, sep=\",\")\n" + ] + } + ], + "source": [ + "# Importation des données\n", + "BUCKET = \"projet-bdc2324-team1/Generalization/musee\"\n", + "\n", + "FILE_PATH_S3 = BUCKET + \"/\" + \"Train_set.csv\"\n", + "\n", + "with fs.open(FILE_PATH_S3, mode=\"rb\") as file_in:\n", + " dataset_train = pd.read_csv(file_in, sep=\",\")\n", + "\n", + "FILE_PATH_S3 = BUCKET + \"/\" + \"Test_set.csv\"\n", + "\n", + "with fs.open(FILE_PATH_S3, mode=\"rb\") as file_in:\n", + " dataset_test = pd.read_csv(file_in, sep=\",\")\n", + "\n", + "# Choosed features\n", + "features = ['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'vente_internet_max', 'purchase_date_min',\n", + " 'purchase_date_max', 'time_between_purchase', 'nb_tickets_internet', 'fidelity', 'is_partner', 'is_email_true', \n", + " 'opt_in', 'gender_female', 'gender_male', 'country_fr', 'nb_campaigns', 'nb_campaigns_opened', 'y_has_purchased'] \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3964cd4a-ab47-4b5b-8a19-cfc9286d0083", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f3a32a9e-feff-4112-8d86-57a61b60f564", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['customer_id', 'nb_tickets', 'nb_purchases', 'total_amount',\n", + " 'nb_suppliers', 'vente_internet_max', 'purchase_date_min',\n", + " 'purchase_date_max', 'time_between_purchase', 'nb_tickets_internet',\n", + " 'street_id', 'structure_id', 'mcp_contact_id', 'fidelity', 'tenant_id',\n", + " 'is_partner', 'deleted_at', 'gender', 'is_email_true', 'opt_in',\n", + " 'last_buying_date', 'max_price', 'ticket_sum', 'average_price',\n", + " 'average_purchase_delay', 'average_price_basket',\n", + " 'average_ticket_basket', 'total_price', 'purchase_count',\n", + " 'first_buying_date', 'country', 'gender_label', 'gender_female',\n", + " 'gender_male', 'gender_other', 'country_fr', 'nb_campaigns',\n", + " 'nb_campaigns_opened', 'time_to_open', 'y_has_purchased'],\n", + " dtype='object')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3c225a17-26d0-4764-a8fe-59db216d4498", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "customer_id 0.000000\n", + "nb_tickets 0.000000\n", + "nb_purchases 0.000000\n", + "total_amount 0.000000\n", + "nb_suppliers 0.000000\n", + "vente_internet_max 0.000000\n", + "purchase_date_min 0.000000\n", + "purchase_date_max 0.000000\n", + "time_between_purchase 0.000000\n", + "nb_tickets_internet 0.000000\n", + "street_id 0.000000\n", + "structure_id 0.908249\n", + "mcp_contact_id 0.548870\n", + "fidelity 0.000000\n", + "tenant_id 0.000000\n", + "is_partner 0.000000\n", + "deleted_at 1.000000\n", + "gender 0.000000\n", + "is_email_true 0.000000\n", + "opt_in 0.000000\n", + "last_buying_date 0.377696\n", + "max_price 0.377696\n", + "ticket_sum 0.000000\n", + "average_price 0.212994\n", + "average_purchase_delay 0.377696\n", + "average_price_basket 0.377696\n", + "average_ticket_basket 0.377696\n", + "total_price 0.164701\n", + "purchase_count 0.000000\n", + "first_buying_date 0.377696\n", + "country 0.410248\n", + "gender_label 0.000000\n", + "gender_female 0.000000\n", + "gender_male 0.000000\n", + "gender_other 0.000000\n", + "country_fr 0.410248\n", + "nb_campaigns 0.000000\n", + "nb_campaigns_opened 0.000000\n", + "time_to_open 0.750637\n", + "y_has_purchased 0.000000\n", + "dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_test.isna().sum() / len(dataset_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c3928b55-8821-46da-b3b5-a036efd6d2cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
event_type_idname_event_types
02.0offre muséale individuel
14.0spectacle vivant
25.0offre muséale groupe
3NaNNaN
\n", + "
" + ], + "text/plain": [ + " event_type_id name_event_types\n", + "0 2.0 offre muséale individuel\n", + "1 4.0 spectacle vivant\n", + "2 5.0 offre muséale groupe\n", + "3 NaN NaN" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train[['event_type_id', 'name_event_types']].drop_duplicates()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7e8a9d4d-7e55-4173-a7f4-8b8baa9610d2", + "metadata": {}, + "outputs": [], + "source": [ + "#Choose type of event \n", + "type_event_choosed = 5\n", + "\n", + "dataset_test = dataset_test[(dataset_test['event_type_id'] == type_event_choosed) | np.isnan(dataset_test['event_type_id'])]\n", + "dataset_test['y_has_purchased'] = dataset_test['y_has_purchased'].fillna(0)\n", + "dataset_train = dataset_train[(dataset_train['event_type_id'] == type_event_choosed) | np.isnan(dataset_train['event_type_id'])]\n", + "dataset_train['y_has_purchased'] = dataset_train['y_has_purchased'].fillna(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e20ced8f-df1c-43bb-8d15-79f414c8225c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "customer_id 0.000000\n", + "event_type_id 0.967882\n", + "nb_tickets 0.000000\n", + "nb_purchases 0.000000\n", + "total_amount 0.000000\n", + "nb_suppliers 0.000000\n", + "vente_internet_max 0.000000\n", + "purchase_date_min 0.967882\n", + "purchase_date_max 0.967882\n", + "time_between_purchase 0.967882\n", + "nb_tickets_internet 0.000000\n", + "name_event_types 0.967882\n", + "avg_amount 0.967882\n", + "street_id 0.000000\n", + "is_partner 0.000000\n", + "gender 0.000000\n", + "is_email_true 0.000000\n", + "opt_in 0.000000\n", + "structure_id 0.856471\n", + "mcp_contact_id 0.297844\n", + "last_buying_date 0.642312\n", + "max_price 0.642312\n", + "ticket_sum 0.000000\n", + "average_price 0.107403\n", + "fidelity 0.000000\n", + "average_purchase_delay 0.642312\n", + "average_price_basket 0.642312\n", + "average_ticket_basket 0.642312\n", + "total_price 0.534909\n", + "purchase_count 0.000000\n", + "first_buying_date 0.642312\n", + "country 0.066622\n", + "tenant_id 0.000000\n", + "gender_label 0.000000\n", + "gender_female 0.000000\n", + "gender_male 0.000000\n", + "gender_other 0.000000\n", + "country_fr 0.066622\n", + "nb_campaigns 0.000000\n", + "nb_campaigns_opened 0.000000\n", + "time_to_open 0.553988\n", + "y_has_purchased 0.000000\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train.isna().sum()/len(dataset_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "05e29adb-7eef-416f-8f7b-248229eee0fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nb_tickets 0\n", + "nb_purchases 0\n", + "total_amount 0\n", + "nb_suppliers 0\n", + "vente_internet_max 0\n", + "nb_tickets_internet 0\n", + "opt_in 0\n", + "fidelity 0\n", + "nb_campaigns 0\n", + "nb_campaigns_opened 0\n", + "dtype: int64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train[['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'vente_internet_max', 'nb_tickets_internet', 'opt_in', 'fidelity', 'nb_campaigns', 'nb_campaigns_opened']].isna().sum()\n", + "# pas de NaN, OK !" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2ce94258-e2d1-472a-81fc-fc11e247b423", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "228.0" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train['y_has_purchased'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "34bae3f7-d579-4f80-a38d-a83eb5ea8a7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9986037223669636\n", + "Confusion Matrix:\n", + " [[128000 37]\n", + " [ 142 19]]\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0.0 1.00 1.00 1.00 128037\n", + " 1.0 0.34 0.12 0.18 161\n", + "\n", + " accuracy 1.00 128198\n", + " macro avg 0.67 0.56 0.59 128198\n", + "weighted avg 1.00 1.00 1.00 128198\n", + "\n" + ] + } + ], + "source": [ + "\n", + "reg_columns = ['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'vente_internet_max', 'nb_tickets_internet', 'opt_in', 'fidelity', 'nb_campaigns', 'nb_campaigns_opened']\n", + "\n", + "X_train = dataset_train[reg_columns]\n", + "y_train = dataset_train['y_has_purchased']\n", + "X_test = dataset_test[reg_columns]\n", + "y_test = dataset_test['y_has_purchased']\n", + "\n", + "# Fit and transform the scaler on the training data\n", + "scaler = StandardScaler()\n", + "\n", + "# Transform the test data using the same scaler\n", + "X_train_scaled = scaler.fit_transform(X_train)\n", + "X_test_scaled = scaler.fit_transform(X_test)\n", + "\n", + "# Create and fit the linear regression model\n", + "logit_model = LogisticRegression(penalty='l1', solver='liblinear', C=1.0)\n", + "logit_model.fit(X_train_scaled, y_train)\n", + "\n", + "y_pred = logit_model.predict(X_test_scaled)\n", + "\n", + "#Evaluation du modèle \n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "class_report = classification_report(y_test, y_pred)\n", + "\n", + "print(\"Accuracy:\", accuracy)\n", + "print(\"Confusion Matrix:\\n\", conf_matrix)\n", + "print(\"Classification Report:\\n\", class_report)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ccc78c36-3287-46e6-89ac-7494c1a7106a", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Class 0', 'Class 1'], yticklabels=['Class 0', 'Class 1'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fe6e14d2-001d-4585-9344-f240b84ce4af", + "metadata": {}, + "source": [ + "## Ajout TP : test d'une nouvelle pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3782988b-52f9-4172-92d4-68948bf259c9", + "metadata": {}, + "outputs": [], + "source": [ + "# etape supp : suppression du client 1 (outlier car client anonyme)\n", + "\n", + "dataset_train = dataset_train[dataset_train[\"customer_id\"]!=1]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d19f8c0-ed31-46cd-8879-47810fa099d6", + "metadata": {}, + "outputs": [], + "source": [ + "# definition des variables utilisées\n", + "\n", + "numeric_features = ['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'nb_tickets_internet', 'fidelity', 'nb_campaigns', 'nb_campaigns_opened']\n", + "# categorical_features = [\"opt_in\"]\n", + "encoded_features = [\"opt_in\", \"vente_internet_max\"]\n", + "features = numeric_features + encoded_features\n", + "X_train = dataset_train[features]\n", + "y_train = dataset_train['y_has_purchased']\n", + "X_test = dataset_test[features]\n", + "y_test = dataset_test['y_has_purchased']" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "412ddfad-3d20-4fa0-afaa-79ec87b3122d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 122016.000000\n", + "mean 0.307656\n", + "std 3.135563\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.000000\n", + "75% 0.000000\n", + "max 907.000000\n", + "Name: fidelity, dtype: float64" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### variable fidelity\n", + "\n", + "X_train[\"fidelity\"].describe() # sûrement un problème d'outlier pour fidelity\n", + "# X_train[\"total_amount\"].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "97e1cd25-0961-45dd-af7f-78ab1d8088ee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nb_ticketsnb_purchasestotal_amountnb_suppliersnb_tickets_internetfidelitynb_campaignsnb_campaigns_openedopt_invente_internet_max
30.00.00.00.00.01732.00.0True0.0
152233.066.025703.02.02.094130.060.0True1.0
240.00.00.00.00.022416.00.0True0.0
28557.025.00.02.0175.03432.015.0True1.0
340.00.00.00.00.0240.00.0True0.0
.................................
1448230.00.00.00.00.090.00.0True0.0
1448240.00.00.00.00.01200.00.0True0.0
1448680.00.00.00.00.09070.00.0True0.0
1448770.00.00.00.00.080.00.0True0.0
1505950.00.00.00.00.060.00.0True0.0
\n", + "

279 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " nb_tickets nb_purchases total_amount nb_suppliers \\\n", + "3 0.0 0.0 0.0 0.0 \n", + "15 2233.0 66.0 25703.0 2.0 \n", + "24 0.0 0.0 0.0 0.0 \n", + "28 557.0 25.0 0.0 2.0 \n", + "34 0.0 0.0 0.0 0.0 \n", + "... ... ... ... ... \n", + "144823 0.0 0.0 0.0 0.0 \n", + "144824 0.0 0.0 0.0 0.0 \n", + "144868 0.0 0.0 0.0 0.0 \n", + "144877 0.0 0.0 0.0 0.0 \n", + "150595 0.0 0.0 0.0 0.0 \n", + "\n", + " nb_tickets_internet fidelity nb_campaigns nb_campaigns_opened \\\n", + "3 0.0 173 2.0 0.0 \n", + "15 2.0 94 130.0 60.0 \n", + "24 0.0 224 16.0 0.0 \n", + "28 175.0 34 32.0 15.0 \n", + "34 0.0 24 0.0 0.0 \n", + "... ... ... ... ... \n", + "144823 0.0 9 0.0 0.0 \n", + "144824 0.0 120 0.0 0.0 \n", + "144868 0.0 907 0.0 0.0 \n", + "144877 0.0 8 0.0 0.0 \n", + "150595 0.0 6 0.0 0.0 \n", + "\n", + " opt_in vente_internet_max \n", + "3 True 0.0 \n", + "15 True 1.0 \n", + "24 True 0.0 \n", + "28 True 1.0 \n", + "34 True 0.0 \n", + "... ... ... \n", + "144823 True 0.0 \n", + "144824 True 0.0 \n", + "144868 True 0.0 \n", + "144877 True 0.0 \n", + "150595 True 0.0 \n", + "\n", + "[279 rows x 10 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train[X_train[\"fidelity\"]>5]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "fc17957e-b684-41cd-880f-049a4ffcc7dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
customer_idevent_type_idnb_ticketsnb_purchasestotal_amountnb_suppliersvente_internet_maxpurchase_date_minpurchase_date_maxtime_between_purchase...tenant_idgender_labelgender_femalegender_malegender_othercountry_frnb_campaignsnb_campaigns_openedtime_to_openy_has_purchased
32NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.02.00.0NaN0.0
43NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.0125.071.01 days 04:13:20.4929577460.0
65NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.02.00.0NaN0.0
76NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.017.00.0NaN0.0
87NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.027.013.05 days 18:07:22.6153846150.0
..................................................................
1525541256102NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.00.00.0NaN0.0
1525551256103NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1525561256104NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1525571256105NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1525581256106NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
\n", + "

122016 rows × 42 columns

\n", + "
" + ], + "text/plain": [ + " customer_id event_type_id nb_tickets nb_purchases total_amount \\\n", + "3 2 NaN 0.0 0.0 0.0 \n", + "4 3 NaN 0.0 0.0 0.0 \n", + "6 5 NaN 0.0 0.0 0.0 \n", + "7 6 NaN 0.0 0.0 0.0 \n", + "8 7 NaN 0.0 0.0 0.0 \n", + "... ... ... ... ... ... \n", + "152554 1256102 NaN 0.0 0.0 0.0 \n", + "152555 1256103 NaN 0.0 0.0 0.0 \n", + "152556 1256104 NaN 0.0 0.0 0.0 \n", + "152557 1256105 NaN 0.0 0.0 0.0 \n", + "152558 1256106 NaN 0.0 0.0 0.0 \n", + "\n", + " nb_suppliers vente_internet_max purchase_date_min \\\n", + "3 0.0 0.0 NaN \n", + "4 0.0 0.0 NaN \n", + "6 0.0 0.0 NaN \n", + "7 0.0 0.0 NaN \n", + "8 0.0 0.0 NaN \n", + "... ... ... ... \n", + "152554 0.0 0.0 NaN \n", + "152555 0.0 0.0 NaN \n", + "152556 0.0 0.0 NaN \n", + "152557 0.0 0.0 NaN \n", + "152558 0.0 0.0 NaN \n", + "\n", + " purchase_date_max time_between_purchase ... tenant_id gender_label \\\n", + "3 NaN NaN ... 1311 male \n", + "4 NaN NaN ... 1311 male \n", + "6 NaN NaN ... 1311 male \n", + "7 NaN NaN ... 1311 male \n", + "8 NaN NaN ... 1311 female \n", + "... ... ... ... ... ... \n", + "152554 NaN NaN ... 1311 female \n", + "152555 NaN NaN ... 1311 other \n", + "152556 NaN NaN ... 1311 other \n", + "152557 NaN NaN ... 1311 other \n", + "152558 NaN NaN ... 1311 other \n", + "\n", + " gender_female gender_male gender_other country_fr nb_campaigns \\\n", + "3 0 1 0 1.0 2.0 \n", + "4 0 1 0 1.0 125.0 \n", + "6 0 1 0 1.0 2.0 \n", + "7 0 1 0 1.0 17.0 \n", + "8 1 0 0 1.0 27.0 \n", + "... ... ... ... ... ... \n", + "152554 1 0 0 1.0 0.0 \n", + "152555 0 0 1 NaN 0.0 \n", + "152556 0 0 1 NaN 0.0 \n", + "152557 0 0 1 NaN 0.0 \n", + "152558 0 0 1 NaN 0.0 \n", + "\n", + " nb_campaigns_opened time_to_open y_has_purchased \n", + "3 0.0 NaN 0.0 \n", + "4 71.0 1 days 04:13:20.492957746 0.0 \n", + "6 0.0 NaN 0.0 \n", + "7 0.0 NaN 0.0 \n", + "8 13.0 5 days 18:07:22.615384615 0.0 \n", + "... ... ... ... \n", + "152554 0.0 NaN 0.0 \n", + "152555 0.0 NaN 0.0 \n", + "152556 0.0 NaN 0.0 \n", + "152557 0.0 NaN 0.0 \n", + "152558 0.0 NaN 0.0 \n", + "\n", + "[122016 rows x 42 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# on transforme opt_in en indicatrice\n", + "\n", + "dataset_train[\"opt_in\"] = dataset_train[\"opt_in\"].astype(int)\n", + "dataset_train" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8ad69b5d-e2e2-4d70-b8f0-ea0d37f7fe0c", + "metadata": {}, + "outputs": [], + "source": [ + "# definition des variables utilisées\n", + "\n", + "numeric_features = ['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'nb_tickets_internet', 'fidelity', 'nb_campaigns', 'nb_campaigns_opened']\n", + "# categorical_features = [\"opt_in\"]\n", + "encoded_features = [\"opt_in\", \"vente_internet_max\"]\n", + "features = numeric_features + encoded_features\n", + "X_train = dataset_train[features]\n", + "y_train = dataset_train['y_has_purchased']\n", + "X_test = dataset_test[features]\n", + "y_test = dataset_test['y_has_purchased']" + ] + }, + { + "cell_type": "markdown", + "id": "3ed647a6-db9a-4737-b819-57cb81691ea2", + "metadata": {}, + "source": [ + "### Autre ajout : travail de preprocessing des données - étude des outliers" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "3771eeb1-5221-44e5-a5cd-15475fbe4858", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 128198.000000\n", + "mean 0.582536\n", + "std 181.774597\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.000000\n", + "75% 0.000000\n", + "max 65082.000000\n", + "Name: nb_purchases, dtype: float64" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 1. number of purchases\n", + "\n", + "X_train[\"nb_purchases\"].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "63c44b80-88cd-4339-91b9-3764e2690316", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nb_ticketsnb_purchasestotal_amountnb_suppliersnb_tickets_internetfidelitynb_campaignsnb_campaigns_openedopt_invente_internet_max
2122983.065082.0878762.55.09.03308310.00.001.0
152773.081.032338.02.02.094126.050.011.0
28282.015.00.02.053.03432.013.011.0
2940.02.00.01.00.0424.017.010.0
3152.02.00.01.00.0522.06.010.0
.................................
1471554.02.044.01.04.020.00.001.0
1472423.02.040.01.03.020.00.001.0
14741412.02.0132.01.012.020.00.001.0
14763615.02.0165.01.015.020.00.001.0
1479502.02.029.01.02.020.00.001.0
\n", + "

747 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " nb_tickets nb_purchases total_amount nb_suppliers \\\n", + "2 122983.0 65082.0 878762.5 5.0 \n", + "15 2773.0 81.0 32338.0 2.0 \n", + "28 282.0 15.0 0.0 2.0 \n", + "29 40.0 2.0 0.0 1.0 \n", + "31 52.0 2.0 0.0 1.0 \n", + "... ... ... ... ... \n", + "147155 4.0 2.0 44.0 1.0 \n", + "147242 3.0 2.0 40.0 1.0 \n", + "147414 12.0 2.0 132.0 1.0 \n", + "147636 15.0 2.0 165.0 1.0 \n", + "147950 2.0 2.0 29.0 1.0 \n", + "\n", + " nb_tickets_internet fidelity nb_campaigns nb_campaigns_opened \\\n", + "2 9.0 330831 0.0 0.0 \n", + "15 2.0 94 126.0 50.0 \n", + "28 53.0 34 32.0 13.0 \n", + "29 0.0 4 24.0 17.0 \n", + "31 0.0 5 22.0 6.0 \n", + "... ... ... ... ... \n", + "147155 4.0 2 0.0 0.0 \n", + "147242 3.0 2 0.0 0.0 \n", + "147414 12.0 2 0.0 0.0 \n", + "147636 15.0 2 0.0 0.0 \n", + "147950 2.0 2 0.0 0.0 \n", + "\n", + " opt_in vente_internet_max \n", + "2 0 1.0 \n", + "15 1 1.0 \n", + "28 1 1.0 \n", + "29 1 0.0 \n", + "31 1 0.0 \n", + "... ... ... \n", + "147155 0 1.0 \n", + "147242 0 1.0 \n", + "147414 0 1.0 \n", + "147636 0 1.0 \n", + "147950 0 1.0 \n", + "\n", + "[747 rows x 10 columns]" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train[X_train[\"nb_purchases\"]>1]" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "032fbc5a-9044-41bd-b992-78077a6c8432", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.quantile(X_train[\"nb_purchases\"], 0.99)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "cad9f7cb-8b71-49a6-874b-e15cb9d7a204", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "count 128198.000000\n", + "mean 1.946941\n", + "std 343.940117\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.000000\n", + "75% 0.000000\n", + "max 122983.000000\n", + "Name: nb_tickets, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "23.0" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### 2. nb tickets\n", + "\n", + "print(X_train[\"nb_tickets\"].describe())\n", + "np.quantile(X_train[\"nb_tickets\"], 0.99)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "6bb0c86d-eb61-473d-a29b-c59e7e5af489", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "count 128198.000000\n", + "mean 10.496193\n", + "std 2457.094272\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.000000\n", + "75% 0.000000\n", + "max 878762.500000\n", + "Name: total_amount, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "44.0" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 3. total amount\n", + "\n", + "print(X_train[\"total_amount\"].describe())\n", + "np.quantile(X_train[\"total_amount\"], 0.99)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "ab6fded3-d8a5-4bb4-8f2d-472ea0e5e755", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "count 128198.000000\n", + "mean 2.924687\n", + "std 923.990506\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.000000\n", + "75% 1.000000\n", + "max 330831.000000\n", + "Name: fidelity, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "2.0" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 4. fidelity\n", + "\n", + "print(X_train[\"fidelity\"].describe())\n", + "np.quantile(X_train[\"fidelity\"], 0.99)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "c1f0ac75-71a4-43fb-844b-e006acf5927b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "count 128198.000000\n", + "mean 24.276463\n", + "std 37.899868\n", + "min 0.000000\n", + "25% 1.000000\n", + "50% 4.000000\n", + "75% 28.000000\n", + "max 299.000000\n", + "Name: nb_campaigns, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "133.0" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 5. nb campaigns - semble pas aberrant meme si forte variance\n", + "\n", + "print(X_train[\"nb_campaigns\"].describe())\n", + "np.quantile(X_train[\"nb_campaigns\"], 0.99)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "8bb01064-1c23-4100-ace8-56f155e0b4ab", + "metadata": {}, + "outputs": [], + "source": [ + "### on retire les outliers - variables : nb purchases, nb tickets, total amount, fidelity\n", + "\n", + "p99_nb_purchases = np.quantile(X_train[\"nb_purchases\"], 0.99)\n", + "p99_nb_tickets = np.quantile(X_train[\"nb_tickets\"], 0.99)\n", + "p99_total_amount = np.quantile(X_train[\"total_amount\"], 0.99)\n", + "p99_fidelity = np.quantile(X_train[\"fidelity\"], 0.99)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "b2b43ab6-16aa-41bc-9a62-47ab769c5bf2", + "metadata": {}, + "outputs": [], + "source": [ + "# filtre - on enlève les valeurs aberrantes sur les variables problématiques (retire 2% des valeurs en tt)\n", + "\n", + "X_train = X_train.loc[(X_train[\"nb_purchases\"] <= p99_nb_purchases) &\n", + "(X_train[\"nb_tickets\"] <= p99_nb_tickets) &\n", + "(X_train[\"total_amount\"] <= p99_total_amount) &\n", + "(X_train[\"fidelity\"] <= p99_fidelity)]" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "b254a671-9e57-4123-ae65-55c852eb64cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nb_ticketsnb_purchasestotal_amountnb_suppliersnb_tickets_internetfidelitynb_campaignsnb_campaigns_openedopt_invente_internet_max
60.00.00.00.00.012.00.010.0
70.00.00.00.00.0112.00.010.0
80.00.00.00.00.0124.010.010.0
90.00.00.00.00.0114.07.010.0
100.00.00.00.00.0123.011.010.0
\n", + "
" + ], + "text/plain": [ + " nb_tickets nb_purchases total_amount nb_suppliers nb_tickets_internet \\\n", + "6 0.0 0.0 0.0 0.0 0.0 \n", + "7 0.0 0.0 0.0 0.0 0.0 \n", + "8 0.0 0.0 0.0 0.0 0.0 \n", + "9 0.0 0.0 0.0 0.0 0.0 \n", + "10 0.0 0.0 0.0 0.0 0.0 \n", + "\n", + " fidelity nb_campaigns nb_campaigns_opened opt_in vente_internet_max \n", + "6 1 2.0 0.0 1 0.0 \n", + "7 1 12.0 0.0 1 0.0 \n", + "8 1 24.0 10.0 1 0.0 \n", + "9 1 14.0 7.0 1 0.0 \n", + "10 1 23.0 11.0 1 0.0 " + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "86d90380-6ad2-4c6b-a103-53e4c1fa59e0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
customer_idevent_type_idnb_ticketsnb_purchasestotal_amountnb_suppliersvente_internet_maxpurchase_date_minpurchase_date_maxtime_between_purchase...tenant_idgender_labelgender_femalegender_malegender_othercountry_frnb_campaignsnb_campaigns_openedtime_to_openy_has_purchased
65NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.02.00.0NaN0.0
76NaN0.00.00.00.00.0NaNNaNNaN...1311male0101.012.00.0NaN0.0
87NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.024.010.05 days 11:58:520.0
98NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.014.07.00 days 13:29:25.7142857140.0
109NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.023.011.00 days 17:17:44.0909090900.0
..................................................................
1526451256102NaN0.00.00.00.00.0NaNNaNNaN...1311female1001.00.00.0NaN0.0
1526461256103NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1526471256104NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1526481256105NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
1526491256106NaN0.00.00.00.00.0NaNNaNNaN...1311other001NaN0.00.0NaN0.0
\n", + "

125792 rows × 42 columns

\n", + "
" + ], + "text/plain": [ + " customer_id event_type_id nb_tickets nb_purchases total_amount \\\n", + "6 5 NaN 0.0 0.0 0.0 \n", + "7 6 NaN 0.0 0.0 0.0 \n", + "8 7 NaN 0.0 0.0 0.0 \n", + "9 8 NaN 0.0 0.0 0.0 \n", + "10 9 NaN 0.0 0.0 0.0 \n", + "... ... ... ... ... ... \n", + "152645 1256102 NaN 0.0 0.0 0.0 \n", + "152646 1256103 NaN 0.0 0.0 0.0 \n", + "152647 1256104 NaN 0.0 0.0 0.0 \n", + "152648 1256105 NaN 0.0 0.0 0.0 \n", + "152649 1256106 NaN 0.0 0.0 0.0 \n", + "\n", + " nb_suppliers vente_internet_max purchase_date_min \\\n", + "6 0.0 0.0 NaN \n", + "7 0.0 0.0 NaN \n", + "8 0.0 0.0 NaN \n", + "9 0.0 0.0 NaN \n", + "10 0.0 0.0 NaN \n", + "... ... ... ... \n", + "152645 0.0 0.0 NaN \n", + "152646 0.0 0.0 NaN \n", + "152647 0.0 0.0 NaN \n", + "152648 0.0 0.0 NaN \n", + "152649 0.0 0.0 NaN \n", + "\n", + " purchase_date_max time_between_purchase ... tenant_id gender_label \\\n", + "6 NaN NaN ... 1311 male \n", + "7 NaN NaN ... 1311 male \n", + "8 NaN NaN ... 1311 female \n", + "9 NaN NaN ... 1311 female \n", + "10 NaN NaN ... 1311 female \n", + "... ... ... ... ... ... \n", + "152645 NaN NaN ... 1311 female \n", + "152646 NaN NaN ... 1311 other \n", + "152647 NaN NaN ... 1311 other \n", + "152648 NaN NaN ... 1311 other \n", + "152649 NaN NaN ... 1311 other \n", + "\n", + " gender_female gender_male gender_other country_fr nb_campaigns \\\n", + "6 0 1 0 1.0 2.0 \n", + "7 0 1 0 1.0 12.0 \n", + "8 1 0 0 1.0 24.0 \n", + "9 1 0 0 1.0 14.0 \n", + "10 1 0 0 1.0 23.0 \n", + "... ... ... ... ... ... \n", + "152645 1 0 0 1.0 0.0 \n", + "152646 0 0 1 NaN 0.0 \n", + "152647 0 0 1 NaN 0.0 \n", + "152648 0 0 1 NaN 0.0 \n", + "152649 0 0 1 NaN 0.0 \n", + "\n", + " nb_campaigns_opened time_to_open y_has_purchased \n", + "6 0.0 NaN 0.0 \n", + "7 0.0 NaN 0.0 \n", + "8 10.0 5 days 11:58:52 0.0 \n", + "9 7.0 0 days 13:29:25.714285714 0.0 \n", + "10 11.0 0 days 17:17:44.090909090 0.0 \n", + "... ... ... ... \n", + "152645 0.0 NaN 0.0 \n", + "152646 0.0 NaN 0.0 \n", + "152647 0.0 NaN 0.0 \n", + "152648 0.0 NaN 0.0 \n", + "152649 0.0 NaN 0.0 \n", + "\n", + "[125792 rows x 42 columns]" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "\n", + "dataset_train = dataset_train.loc[(dataset_train[\"nb_purchases\"] <= p99_nb_purchases) &\n", + "(dataset_train[\"nb_tickets\"] <= p99_nb_tickets) &\n", + "(dataset_train[\"total_amount\"] <= p99_total_amount) &\n", + "(dataset_train[\"fidelity\"] <= p99_fidelity)]\n", + "\n", + "dataset_train" + ] + }, + { + "cell_type": "markdown", + "id": "f9487c48-b973-4d9e-abb9-902800ab778f", + "metadata": {}, + "source": [ + "En enlevant les outliers, on supprime la plupart des clients ayant acheté à nouveau ... Il faut trouver un autre moyen de preprocessing qui ne dégrade pas le dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "9fe7513b-f23b-4bee-957d-f98919d6eb30", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.0" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset_train[\"y_has_purchased\"].sum() # pb : on passe de 161 à 19 clients ayant acheté ..." + ] + }, + { + "cell_type": "markdown", + "id": "b531aebb-3b2f-4c62-ae01-84bdf8e45f49", + "metadata": {}, + "source": [ + "### Construction de la pipeline pour le modèle de régression logistique et résultats" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1476da0d-cbb5-46ac-9f97-10855eec0108", + "metadata": {}, + "outputs": [], + "source": [ + "# importations pr créer la pipeline\n", + "\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.preprocessing import StandardScaler, MaxAbsScaler, MinMaxScaler\n", + "from sklearn.metrics import make_scorer, f1_score, balanced_accuracy_score" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f905cb6f-b0be-4a47-ac8d-7b3e16ff1dce", + "metadata": {}, + "outputs": [], + "source": [ + "# debut de la pipeline\n", + "numeric_transformer = Pipeline(steps=[\n", + " # (\"imputer\", SimpleImputer(strategy=\"mean\")), # NaN remplacés par la moyenne, mais peu importe car on a supprimé les valeurs manquantes\n", + " (\"scaler\", StandardScaler())])\n", + "\"\"\"\n", + "categorical_transformer = Pipeline(steps=[\n", + " (\"imputer\", SimpleImputer(strategy=\"constant\", fill_value=\"Not defined\")),\n", + " (\"onehot\", OneHotEncoder(handle_unknown='ignore'))]) # to deal with missing categorical data\n", + "\n", + "\"\"\"\n", + "preproc = ColumnTransformer(transformers=[(\"num\", numeric_transformer, numeric_features)])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d322fb8f-1e97-4a44-96ca-c0f5d7ebd383", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Returned hyperparameter: {'logreg__C': 0.0009765625, 'logreg__class_weight': 'balanced'}\n", + "Best classification accuracy in train is: 0.25403118665289387\n", + "Classification accuracy on test is: 0.0495079950799508\n" + ] + } + ], + "source": [ + "# on doit prendre une métrique adaptée aux datasets déséquilibrés\n", + "balanced_scorer = make_scorer(balanced_accuracy_score)\n", + "f1_scorer = make_scorer(f1_score)\n", + "\n", + "parameter_space = np.logspace(-10, 6, 17, base=2)\n", + "\n", + "pipe = Pipeline([('preprocessor', preproc), ('logreg', LogisticRegression(max_iter=500))]) # prendre 5k iter\n", + "# on met plus de poids sur les observations rares (utile pr gérer le déséquilibre du dataset)\n", + "parameters4 = {'logreg__C': parameter_space, 'logreg__class_weight': ['balanced']} \n", + "clf4 = GridSearchCV(pipe, parameters4, cv=3, scoring = f1_scorer)\n", + "clf4.fit(X_train, y_train)\n", + "\n", + "# print results\n", + "# print(clf4.cv_results_)\n", + "print('Returned hyperparameter: {}'.format(clf4.best_params_))\n", + "print('Best classification accuracy in train is: {}'.format(clf4.best_score_))\n", + "print('Classification accuracy on test is: {}'.format(clf4.score(X_test, y_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "b32bb668-c816-4055-b786-e548eb71f318", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9517777188411676\n", + "Confusion Matrix:\n", + " [[121855 6182]\n", + " [ 0 161]]\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0.0 1.00 0.95 0.98 128037\n", + " 1.0 0.03 1.00 0.05 161\n", + "\n", + " accuracy 0.95 128198\n", + " macro avg 0.51 0.98 0.51 128198\n", + "weighted avg 1.00 0.95 0.97 128198\n", + "\n" + ] + } + ], + "source": [ + "# visualisation des résultats \n", + "\n", + "y_pred = clf4.predict(X_test)\n", + "\n", + "#Evaluation du modèle \n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "class_report = classification_report(y_test, y_pred)\n", + "\n", + "print(\"Accuracy:\", accuracy)\n", + "print(\"Confusion Matrix:\\n\", conf_matrix)\n", + "print(\"Classification Report:\\n\", class_report)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "faebbecb-3f85-4181-8005-2f52180fa37e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# matrice de confusion\n", + "\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Class 0', 'Class 1'], yticklabels=['Class 0', 'Class 1'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "dc66d09e-3f7b-4f6d-a60f-c21a3a057c6d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# on trace la courbe ROC\n", + "\n", + "# Prédictions sur l'ensemble de test\n", + "y_pred_prob = clf4.predict_proba(X_test)[:, 1]\n", + "\n", + "# Calcul des taux de faux positifs (FPR) et de vrais positifs (TPR)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)\n", + "\n", + "# Calcul de l'aire sous la courbe ROC (AUC)\n", + "roc_auc = auc(fpr, tpr)\n", + "\n", + "# Tracé de la courbe ROC\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'AUC = {roc_auc:.2f}')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlabel('Taux de faux positifs (FPR)')\n", + "plt.ylabel('Taux de vrais positifs (TPR)')\n", + "plt.title('Courbe ROC : modèle logistique')\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "b36a11db-5d7a-487a-9b22-f02339e6d413", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calcul des valeurs de précision et de rappel à différents seuils\n", + "precision, recall, thresholds = precision_recall_curve(y_test, y_pred_prob)\n", + "\n", + "# Calcul de l'aire sous la courbe PR (AUC-PR)\n", + "average_precision = average_precision_score(y_test, y_pred_prob)\n", + "\n", + "# Tracé de la courbe PR\n", + "plt.figure(figsize=(8, 6))\n", + "plt.step(recall, precision, color='b', alpha=0.2, where='post')\n", + "plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')\n", + "plt.xlabel('Rappel')\n", + "plt.ylabel('Précision')\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlim([0.0, 1.0])\n", + "plt.title(f'Courbe PR (AUC-PR = {average_precision:.2f})')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "7fb157b6-4e4e-4c7d-8a37-c3ac99323795", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# utilisation d'une métrique plus adaptée aux modèles de marketing : courbe de lift\n", + "\n", + "# Tri des prédictions de probabilités et des vraies valeurs\n", + "sorted_indices = np.argsort(y_pred_prob)[::-1]\n", + "y_pred_prob_sorted = y_pred_prob[sorted_indices]\n", + "y_test_sorted = y_test.iloc[sorted_indices]\n", + "\n", + "# Calcul du gain cumulatif\n", + "cumulative_gain = np.cumsum(y_test_sorted) / np.sum(y_test_sorted)\n", + "\n", + "# Tracé de la courbe de lift\n", + "plt.plot(np.linspace(0, 1, len(cumulative_gain))[:10000], (cumulative_gain/np.linspace(0, 1, len(cumulative_gain)))[:10000], label='Courbe de lift')\n", + "plt.xlabel('Pourcentage des données')\n", + "plt.ylabel('Gain cumulatif')\n", + "plt.title('Courbe de Lift')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "98b93d38-a5d7-4480-91e6-e79be5de18e7", + "metadata": {}, + "source": [ + "## Random forest" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "771bee72-8b12-4ffb-b3ce-82f7e2ba6a8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 9 candidates, totalling 27 fits\n", + "Best parameters: {'max_depth': 20, 'n_estimators': 100, 'random_state': 20}\n", + "Best classification accuracy in train is: 0.3224906065485776\n", + "Classification accuracy on test is: 0.31906614785992216\n", + "------\n" + ] + } + ], + "source": [ + "# Define models and parameters for GridSearch\n", + "params = {\n", + " 'n_estimators': [100, 150, 200],\n", + " 'max_depth': [5, 20, 30],\n", + " 'random_state' : [20]\n", + " }\n", + "\n", + "\n", + "# define model and pipeline - no preprocessing\n", + "clf = GridSearchCV(RandomForestClassifier(), params, cv=3, scoring=f1_scorer, verbose=True)\n", + "clf.fit(X_train, y_train)\n", + "\n", + "print(f\"Best parameters: {clf.best_params_}\")\n", + "print('Best classification accuracy in train is: {}'.format(clf.best_score_))\n", + "print('Classification accuracy on test is: {}'.format(clf.score(X_test, y_test)))\n", + "print(\"------\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "bf44a84d-607e-48c3-b8c6-28a07d1b1c14", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.99863492410178\n", + "Confusion Matrix:\n", + " [[127982 55]\n", + " [ 120 41]]\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0.0 1.00 1.00 1.00 128037\n", + " 1.0 0.43 0.25 0.32 161\n", + "\n", + " accuracy 1.00 128198\n", + " macro avg 0.71 0.63 0.66 128198\n", + "weighted avg 1.00 1.00 1.00 128198\n", + "\n" + ] + } + ], + "source": [ + "# visualisation des résultats \n", + "\n", + "y_pred = clf.predict(X_test)\n", + "\n", + "#Evaluation du modèle \n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "conf_matrix = confusion_matrix(y_test, y_pred)\n", + "class_report = classification_report(y_test, y_pred)\n", + "\n", + "print(\"Accuracy:\", accuracy)\n", + "print(\"Confusion Matrix:\\n\", conf_matrix)\n", + "print(\"Classification Report:\\n\", class_report)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0fa2189c-5c0a-405b-b686-b9df3958c85c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# matrice de confusion\n", + "\n", + "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Class 0', 'Class 1'], yticklabels=['Class 0', 'Class 1'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "311f0208-b79e-4e80-8016-075a98708f6e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# on trace la courbe ROC\n", + "\n", + "# Prédictions sur l'ensemble de test\n", + "y_pred_prob = clf.predict_proba(X_test)[:, 1]\n", + "\n", + "# Calcul des taux de faux positifs (FPR) et de vrais positifs (TPR)\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)\n", + "\n", + "# Calcul de l'aire sous la courbe ROC (AUC)\n", + "roc_auc = auc(fpr, tpr)\n", + "\n", + "# Tracé de la courbe ROC\n", + "plt.figure(figsize=(8, 6))\n", + "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'AUC = {roc_auc:.2f}')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlabel('Taux de faux positifs (FPR)')\n", + "plt.ylabel('Taux de vrais positifs (TPR)')\n", + "plt.title('Courbe ROC : random forest')\n", + "plt.legend(loc='lower right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e20e9ac2-7232-4418-87f0-c7299a6d7de3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calcul des valeurs de précision et de rappel à différents seuils\n", + "precision, recall, thresholds = precision_recall_curve(y_test, y_pred_prob)\n", + "\n", + "# Calcul de l'aire sous la courbe PR (AUC-PR)\n", + "average_precision = average_precision_score(y_test, y_pred_prob)\n", + "\n", + "# Tracé de la courbe PR\n", + "plt.figure(figsize=(8, 6))\n", + "plt.step(recall, precision, color='b', alpha=0.2, where='post')\n", + "plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')\n", + "plt.xlabel('Rappel')\n", + "plt.ylabel('Précision')\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlim([0.0, 1.0])\n", + "plt.title(f'Courbe PR (AUC-PR = {average_precision:.2f})')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "0633df2d-686e-4f9d-823e-e54c23f983f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# utilisation d'une métrique plus adaptée aux modèles de marketing : courbe de lift\n", + "\n", + "# Tri des prédictions de probabilités et des vraies valeurs\n", + "sorted_indices = np.argsort(y_pred_prob)[::-1]\n", + "y_pred_prob_sorted = y_pred_prob[sorted_indices]\n", + "y_test_sorted = y_test.iloc[sorted_indices]\n", + "\n", + "# Calcul du gain cumulatif\n", + "cumulative_gain = np.cumsum(y_test_sorted) / np.sum(y_test_sorted)\n", + "\n", + "# Tracé de la courbe de lift\n", + "plt.plot(np.linspace(0, 1, len(cumulative_gain))[:10000], (cumulative_gain/np.linspace(0, 1, len(cumulative_gain)))[:10000], label='Courbe de lift')\n", + "plt.xlabel('Pourcentage des données')\n", + "plt.ylabel('Gain cumulatif')\n", + "plt.title('Courbe de Lift')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "49dc4e25-a79e-44d7-a577-524468336b96", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "52512 0.000000\n", + "87081 0.000000\n", + "2695 0.000000\n", + "51486 0.006211\n", + "15 0.012422\n", + " ... \n", + "86959 1.000000\n", + "86960 1.000000\n", + "86961 1.000000\n", + "86962 1.000000\n", + "65836 1.000000\n", + "Name: y_has_purchased, Length: 128198, dtype: float64" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cumulative_gain" + ] + }, + { + "cell_type": "markdown", + "id": "5fde953b-4cce-4879-bb5e-1852511e7054", + "metadata": {}, + "source": [ + "## Sauvegarde des résultats (à reprendre))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "7ac941bf-7994-4baf-8d9f-13b93eed73a9", + "metadata": {}, + "outputs": [], + "source": [ + "# sauvegarde\n", + "\n", + "with open('test_logit.pkl', 'wb') as file:\n", + " pickle.dump(clf4, file)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3ac3def3-00f2-4b31-b6f7-2cae5038b766", + "metadata": {}, + "outputs": [], + "source": [ + "# pour charger les paramètres \n", + "\n", + "# Chargement du modèle à partir du fichier\n", + "with open('test_logit.pkl', 'rb') as file:\n", + " loaded_logit = pickle.load(file)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c6abfbe76ed1e2a07d3d84b21ddadfc05f89209b Mon Sep 17 00:00:00 2001 From: ajoubrel-ensae Date: Sat, 9 Mar 2024 17:50:32 +0000 Subject: [PATCH 4/5] Correction construction --- 0_2_Dataset_construction.py | 12 ++++++++---- 0_KPI_functions.py | 3 ++- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/0_2_Dataset_construction.py b/0_2_Dataset_construction.py index 543a286..75c8259 100644 --- a/0_2_Dataset_construction.py +++ b/0_2_Dataset_construction.py @@ -110,6 +110,10 @@ def dataset_construction(min_date, end_features_date, max_date, directory_path): # Fill NaN values df_customer_product[['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'vente_internet_max', 'nb_tickets_internet']] = df_customer_product[['nb_tickets', 'nb_purchases', 'total_amount', 'nb_suppliers', 'vente_internet_max', 'nb_tickets_internet']].fillna(0) + max_interval = (end_features_date - min_date) / np.timedelta64(1, 'D') + 1 + df_customer_product[['purchase_date_max', 'purchase_date_min']] = df_customer_product[['purchase_date_max', 'purchase_date_min']].fillna(max_interval) + df_customer_product[['time_between_purchase']] = df_customer_product[['time_between_purchase']].fillna(-1) + print("Explanatory variable construction : SUCCESS") # 2. Construction of the explained variable @@ -126,7 +130,7 @@ def dataset_construction(min_date, end_features_date, max_date, directory_path): dataset = pd.merge(df_customer_product, y, on = ['customer_id'], how = 'left') # 0 if there is no purchase - dataset[['y_has_purchased']].fillna(0) + dataset[['y_has_purchased']] = dataset[['y_has_purchased']].fillna(0) # add id_company prefix to customer_id dataset['customer_id'] = directory_path + '_' + dataset['customer_id'].astype('str') @@ -156,9 +160,9 @@ end_of_features = "2022-11-01" final_date = "2023-11-01" -anonymous_customer = {'1' : 1_1, '2' : 2_12184, '3' : 3_1, '4' : 4_2, '101' : 101_1, - '5' : 5_191835, '6' : 6_591412, '7' : 7_49632, '8' : 8_1942, '9' : 9_19683, - '10' : 10_19521, '11' : 11_36 , '12' : 12_1706757, '13' : 13_8422, '14' : 14_6354 } +anonymous_customer = {'1' : '1_1', '2' : '2_12184', '3' : '3_1', '4' : '4_2', '101' : '101_1', + '5' : '5_191835', '6' : '6_591412', '7' : '7_49632', '8' : '8_1942', '9' : '9_19683', + '10' : '10_19521', '11' : '11_36', '12' : '12_1706757', '13' : '13_8422', '14' : '14_6354'} for company in list_of_comp: dataset = dataset_construction(min_date = start_date, end_features_date = end_of_features, diff --git a/0_KPI_functions.py b/0_KPI_functions.py index 837e785..f991ced 100644 --- a/0_KPI_functions.py +++ b/0_KPI_functions.py @@ -18,7 +18,8 @@ def campaigns_kpi_function(campaigns_information = None): # Nombre de campagnes de mails nb_campaigns = campaigns_information[['customer_id', 'campaign_name']].groupby('customer_id').count().reset_index() nb_campaigns.rename(columns = {'campaign_name' : 'nb_campaigns'}, inplace = True) - # Temps d'ouverture en min moyen + + # Temps d'ouverture moyen (en minutes) campaigns_information['time_to_open'] = pd.to_datetime(campaigns_information['opened_at'], utc = True, format = 'ISO8601') - pd.to_datetime(campaigns_information['delivered_at'], utc = True, format = 'ISO8601') time_to_open = campaigns_information[['customer_id', 'time_to_open']].groupby('customer_id').mean().reset_index() From 0eedea6e263a53930129b2a809f6ec6a545b07a6 Mon Sep 17 00:00:00 2001 From: ajoubrel-ensae Date: Sat, 9 Mar 2024 17:50:46 +0000 Subject: [PATCH 5/5] Changement dossier --- 1_Descriptive_Statistics_Museum.ipynb | 4805 ------------------------- 1 file changed, 4805 deletions(-) delete mode 100644 1_Descriptive_Statistics_Museum.ipynb diff --git a/1_Descriptive_Statistics_Museum.ipynb b/1_Descriptive_Statistics_Museum.ipynb deleted file mode 100644 index 0247d9a..0000000 --- a/1_Descriptive_Statistics_Museum.ipynb +++ /dev/null @@ -1,4805 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3f41343f-7205-41d9-89dd-88039e301413", - "metadata": {}, - "source": [ - "# Statistiques descriptives" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "abfaf341-7b35-4407-9133-d21336c04027", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import os\n", - "import s3fs\n", - "import re\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.dates as mdates\n", - "from datetime import datetime, date, timedelta\n", - "from dateutil.relativedelta import relativedelta\n", - "import warnings" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "7fb72fa3-7940-496f-ac78-c2837f65eefa", - "metadata": {}, - "outputs": [], - "source": [ - "# Create filesystem object\n", - "S3_ENDPOINT_URL = \"https://\" + os.environ[\"AWS_S3_ENDPOINT\"]\n", - "fs = s3fs.S3FileSystem(client_kwargs={'endpoint_url': S3_ENDPOINT_URL})" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c34e13f4-e043-43d6-ba8c-2e13d008647c", - "metadata": {}, - "outputs": [], - "source": [ - "# Import cleaning and merge functions\n", - "exec(open('0_KPI_functions.py').read())\n", - "\n", - "# Useful functions :\n", - " # display_databases(directory_path, file_name = ['customerplus_cleaned', 'target_information', 'campaigns_information', 'products_purchased_reduced'], datetime_col = None)\n", - " # campaigns_kpi_function(campaigns_information = None)\n", - " # tickets_kpi_function(tickets_information = None)\n", - " # customerplus_kpi_function(customerplus_clean = None)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c60505f4-b95b-4c61-b842-26b27af7e280", - "metadata": {}, - "outputs": [], - "source": [ - "# set the max columns to none\n", - "pd.set_option('display.max_columns', None)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "aaffd291-2c88-44c8-a951-0ef1f8369ba3", - "metadata": {}, - "outputs": [], - "source": [ - "# Additional function to load initial \n", - "def load_dataset_2(directory_path, file_name):\n", - " \"\"\"\n", - " This function loads csv file\n", - " \"\"\"\n", - " file_path = \"bdc2324-data\" + \"/\" + directory_path + \"/\" + directory_path + file_name + \".csv\"\n", - " with fs.open(file_path, mode=\"rb\") as file_in:\n", - " df = pd.read_csv(file_in, sep=\",\")\n", - "\n", - " # drop na :\n", - " #df = df.dropna(axis=1, thresh=len(df))\n", - " # if identifier in table : delete it\n", - " if 'identifier' in df.columns:\n", - " df = df.drop(columns = 'identifier')\n", - " return df" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "09daec01-9927-45c7-a6d4-9b9d0340ee02", - "metadata": {}, - "outputs": [], - "source": [ - "companies = {'musee' : ['1', '2', '3', '4'], # , '101'\n", - " 'musique' : ['10', '11', '12', '13', '14']}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "d9ccb033-3c7a-4647-ae1a-3a439dec2ea1", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_1/customerplus_cleaned.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_1/campaigns_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_1/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_1/target_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":27: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_2/customerplus_cleaned.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_2/campaigns_information.csv\n", - "File path : projet-bdc2324-team1/0_Input/Company_2/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_2/target_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", - ":27: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/customerplus_cleaned.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/campaigns_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/target_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", - ":27: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/customerplus_cleaned.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/campaigns_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":13: DtypeWarning: Columns (12) have mixed types. Specify dtype option on import or set low_memory=False.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/target_information.csv\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - ":27: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - } - ], - "source": [ - "# création des bases contenant les KPI pour les 5 compagnies de spectacle\n", - "\n", - "# liste des compagnies de spectacle\n", - "nb_compagnie= companies['musee']\n", - "\n", - "customer_musee = pd.DataFrame()\n", - "campaigns_musee_brut = pd.DataFrame()\n", - "campaigns_musee_kpi = pd.DataFrame()\n", - "products_musee = pd.DataFrame()\n", - "tickets_musee = pd.DataFrame()\n", - "\n", - "# début de la boucle permettant de générer des datasets agrégés pour les 5 compagnies de spectacle\n", - "for directory_path in nb_compagnie:\n", - " df_customerplus_clean_0 = display_databases(directory_path, file_name = \"customerplus_cleaned\")\n", - " df_campaigns_brut = display_databases(directory_path, file_name = \"campaigns_information\", datetime_col = ['opened_at', 'sent_at', 'campaign_sent_at'])\n", - " df_products_purchased_reduced = display_databases(directory_path, file_name = \"products_purchased_reduced\", datetime_col = ['purchase_date'])\n", - " df_target_information = display_databases(directory_path, file_name = \"target_information\")\n", - " \n", - " df_campaigns_kpi = campaigns_kpi_function(campaigns_information = df_campaigns_brut) \n", - " df_tickets_kpi = tickets_kpi_function(tickets_information = df_products_purchased_reduced)\n", - " df_customerplus_clean = customerplus_kpi_function(customerplus_clean = df_customerplus_clean_0)\n", - "\n", - " \n", - "# creation de la colonne Number compagnie, qui permettra d'agréger les résultats\n", - " df_tickets_kpi[\"number_company\"]=int(directory_path)\n", - " df_campaigns_brut[\"number_company\"]=int(directory_path)\n", - " df_campaigns_kpi[\"number_company\"]=int(directory_path)\n", - " df_customerplus_clean[\"number_company\"]=int(directory_path)\n", - " df_target_information[\"number_company\"]=int(directory_path)\n", - "\n", - "# Traitement des index\n", - " df_tickets_kpi[\"customer_id\"]= directory_path + '_' + df_tickets_kpi['customer_id'].astype('str')\n", - " df_campaigns_brut[\"customer_id\"]= directory_path + '_' + df_campaigns_brut['customer_id'].astype('str')\n", - " df_campaigns_kpi[\"customer_id\"]= directory_path + '_' + df_campaigns_kpi['customer_id'].astype('str') \n", - " df_customerplus_clean[\"customer_id\"]= directory_path + '_' + df_customerplus_clean['customer_id'].astype('str') \n", - " df_products_purchased_reduced[\"customer_id\"]= directory_path + '_' + df_products_purchased_reduced['customer_id'].astype('str') \n", - "\n", - "# Concaténation\n", - " customer_musee = pd.concat([customer_musee, df_customerplus_clean], ignore_index=True)\n", - " campaigns_musee_kpi = pd.concat([campaigns_musee_kpi, df_campaigns_kpi], ignore_index=True)\n", - " campaigns_musee_brut = pd.concat([campaigns_musee_brut, df_campaigns_brut], ignore_index=True) \n", - " tickets_musee = pd.concat([tickets_musee, df_tickets_kpi], ignore_index=True)\n", - " products_musee = pd.concat([products_musee, df_products_purchased_reduced], ignore_index=True)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "e6324fb6-7432-4925-beb0-a831a13be7d5", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "RangeIndex: 1005251 entries, 0 to 1005250\n", - "Data columns (total 28 columns):\n", - " # Column Non-Null Count Dtype \n", - "--- ------ -------------- ----- \n", - " 0 customer_id 1005251 non-null object \n", - " 1 street_id 1005251 non-null int64 \n", - " 2 structure_id 92386 non-null float64\n", - " 3 mcp_contact_id 453246 non-null float64\n", - " 4 fidelity 1005251 non-null int64 \n", - " 5 tenant_id 1005251 non-null int64 \n", - " 6 is_partner 1005251 non-null bool \n", - " 7 deleted_at 0 non-null float64\n", - " 8 gender 1005251 non-null int64 \n", - " 9 is_email_true 1005251 non-null bool \n", - " 10 opt_in 1005251 non-null bool \n", - " 11 last_buying_date 625674 non-null object \n", - " 12 max_price 625674 non-null float64\n", - " 13 ticket_sum 1005251 non-null int64 \n", - " 14 average_price 790528 non-null float64\n", - " 15 average_purchase_delay 625674 non-null float64\n", - " 16 average_price_basket 625674 non-null float64\n", - " 17 average_ticket_basket 625674 non-null float64\n", - " 18 total_price 840397 non-null float64\n", - " 19 purchase_count 1005251 non-null int64 \n", - " 20 first_buying_date 625674 non-null object \n", - " 21 country 593083 non-null object \n", - " 22 gender_label 1005251 non-null object \n", - " 23 gender_female 1005251 non-null int64 \n", - " 24 gender_male 1005251 non-null int64 \n", - " 25 gender_other 1005251 non-null int64 \n", - " 26 country_fr 593083 non-null float64\n", - " 27 number_company 1005251 non-null int64 \n", - "dtypes: bool(3), float64(10), int64(10), object(5)\n", - "memory usage: 194.6+ MB\n" - ] - } - ], - "source": [ - "customer_musee.info()" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "e7fa2e45-cb48-4c79-994f-9f836d566c21", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "anonymous_customer = {'1' : '1_1', '2' : '2_12184', '3' : '3_1', '4' : '4_2', '101' : '101_1',\n", - " '5' : '5_191835', '6' : '6_591412', '7' : '7_49632', '8' : '8_1942', '9' : '9_19683',\n", - " '10' : '10_19521', '11' : '11_36', '12' : '12_1706757', '13' : '13_8422', '14' : '14_6354'}" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "51d02f4f-980c-4ab9-b295-f9632af9c2f0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['1_1',\n", - " '2_12184',\n", - " '3_1',\n", - " '4_2',\n", - " '101_1',\n", - " '5_191835',\n", - " '6_591412',\n", - " '7_49632',\n", - " '8_1942',\n", - " '9_19683',\n", - " '10_19521',\n", - " '11_36',\n", - " '12_1706757',\n", - " '13_8422',\n", - " '14_6354']" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(anonymous_customer.values())" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "70b6e961-c303-465e-93f4-609721d38454", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "# On filtre les outliers\n", - "\n", - "def remove_elements(lst, elements_to_remove):\n", - " return ''.join([x for x in lst if x not in elements_to_remove])\n", - " \n", - "databases = [customer_musee, campaigns_musee_kpi, tickets_musee, products_musee]\n", - "\n", - "outlier_list = list(anonymous_customer.values())\n", - "\n", - "\n", - "customer_musee = customer_musee[~customer_musee['customer_id'].isin(outlier_list)]\n", - "campaigns_musee_kpi = campaigns_musee_kpi[~campaigns_musee_kpi['customer_id'].isin(outlier_list)]\n", - "tickets_musee = tickets_musee[~tickets_musee['customer_id'].isin(outlier_list)]\n", - "products_musee = products_musee[~products_musee['customer_id'].isin(outlier_list)]" - ] - }, - { - "cell_type": "markdown", - "id": "ae3c0c33-55a7-4a28-9a62-3ce13496917a", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "# 0 - Specificité de la company 101" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "f8a8dedc-2f67-407c-9bbf-f70d236fc783", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idnamecreated_atupdated_atstreet_idfixed_capacity
261atelier des lumieres2020-10-12 08:57:27.783770+02:002020-10-12 08:57:27.783770+02:001NaN
1714007fabrique des lumieres2022-05-17 09:11:19.416106+02:002022-05-17 09:11:19.416106+02:002NaN
322non défini2020-10-12 08:57:27.785329+02:002020-10-12 08:57:27.785329+02:002NaN
1010755NaN2022-01-28 12:07:16.602885+01:002022-01-28 12:07:16.602885+01:002NaN
1613583hôtel de caumont2022-05-13 10:59:06.829576+02:002022-05-13 10:59:06.829576+02:00859NaN
216422atelier des lumières - cézanne2022-08-04 04:03:31.045648+02:002022-08-04 04:03:31.045648+02:00859NaN
2021098bassins des lumières - 2022 - venise2023-04-08 03:49:46.916777+02:002023-04-08 03:49:46.916777+02:00859NaN
1823460immersive box2023-08-29 17:39:55.188028+02:002023-08-29 17:39:55.188028+02:00859NaN
813584bassins des lumières - venise2022-05-13 11:00:14.943669+02:002022-05-13 11:00:14.943669+02:00859NaN
1521096atelier des lumières - 2022 - cézanne2023-04-08 03:42:10.395124+02:002023-04-08 03:42:10.395124+02:00859NaN
27260musée jacquemart andré2020-10-18 01:20:12.738229+02:002020-10-18 01:20:12.738229+02:003525NaN
3371cité de l'automobile2020-10-13 11:05:43.705639+02:002020-12-03 08:33:15.576065+01:00449992NaN
3089bassins de lumieres2020-10-13 14:56:27.206958+02:002020-10-13 14:56:27.206958+02:00460754NaN
7108les baux de provence2020-10-14 14:16:20.284658+02:002020-10-14 14:16:20.284658+02:00481475NaN
19161les carrières de lumières2020-10-14 18:06:57.059828+02:002020-10-14 18:06:57.059828+02:00483815NaN
24118villa ephrussi de rothschild2020-10-14 15:02:40.478501+02:002020-10-14 15:02:40.478501+02:00485539NaN
29128théâtre antique orange2020-10-14 15:46:44.072307+02:002020-10-14 15:46:44.072307+02:00499380NaN
283875carrieres de lumieres2021-06-11 10:52:15.706030+02:002021-06-11 10:52:15.706030+02:00535931NaN
253866baux-de-provence2021-06-11 10:28:30.237144+02:002021-06-11 10:28:30.237144+02:00569179NaN
22392tour magne de nîmes2020-10-19 17:51:45.915572+02:002020-10-19 17:51:45.915572+02:00717981NaN
3263musée maillol2020-10-18 01:30:23.853673+02:002020-10-18 01:30:23.853673+02:00852301NaN
6264cinéma d'aigues mortes2020-10-18 01:30:23.863631+02:002020-10-18 01:30:23.863631+02:00852302NaN
21388maison carrée de nîmes2020-10-19 17:37:09.345955+02:002020-10-19 17:37:09.345955+02:00867431NaN
23333les arènes de nîmes2020-10-19 10:17:55.757817+02:002020-10-19 10:17:55.757817+02:00867431NaN
31170caumont centre d'art2020-10-14 19:13:55.213186+02:002022-10-14 06:21:53.310810+02:00887751NaN
51665cité de l'auto2020-12-08 18:46:15.957997+01:002020-12-08 18:46:15.957997+01:001418086NaN
1411836phoenix des lumières2022-03-08 16:30:03.135537+01:002022-03-08 16:30:03.135537+01:003639035NaN
113501château de boutemont2022-05-10 14:56:36.025562+02:002022-05-10 14:56:36.025562+02:004209418NaN
413502fabrique des lumières2022-05-10 15:05:40.443121+02:002022-05-10 15:05:40.443121+02:004209419NaN
1222219immersive box belgique2023-06-13 16:17:37.818103+02:002023-06-13 16:17:37.818103+02:007335205NaN
1322512hall des lumières2023-06-29 09:31:23.575220+02:002023-06-29 09:31:23.575220+02:007364467NaN
1122348hdl2023-06-20 17:58:19.153019+02:002023-06-29 09:38:51.592547+02:007364467NaN
022516hall des lumieres2023-06-29 09:46:44.718839+02:002023-06-29 09:46:44.718839+02:007364467NaN
911835hdl - ny2022-03-08 16:00:20.821212+01:002023-06-29 09:27:59.256591+02:007446203NaN
\n", - "
" - ], - "text/plain": [ - " id name \\\n", - "26 1 atelier des lumieres \n", - "17 14007 fabrique des lumieres \n", - "32 2 non défini \n", - "10 10755 NaN \n", - "16 13583 hôtel de caumont \n", - "2 16422 atelier des lumières - cézanne \n", - "20 21098 bassins des lumières - 2022 - venise \n", - "18 23460 immersive box \n", - "8 13584 bassins des lumières - venise \n", - "15 21096 atelier des lumières - 2022 - cézanne \n", - "27 260 musée jacquemart andré \n", - "33 71 cité de l'automobile \n", - "30 89 bassins de lumieres \n", - "7 108 les baux de provence \n", - "19 161 les carrières de lumières \n", - "24 118 villa ephrussi de rothschild \n", - "29 128 théâtre antique orange \n", - "28 3875 carrieres de lumieres \n", - "25 3866 baux-de-provence \n", - "22 392 tour magne de nîmes \n", - "3 263 musée maillol \n", - "6 264 cinéma d'aigues mortes \n", - "21 388 maison carrée de nîmes \n", - "23 333 les arènes de nîmes \n", - "31 170 caumont centre d'art \n", - "5 1665 cité de l'auto \n", - "14 11836 phoenix des lumières \n", - "1 13501 château de boutemont \n", - "4 13502 fabrique des lumières \n", - "12 22219 immersive box belgique \n", - "13 22512 hall des lumières \n", - "11 22348 hdl \n", - "0 22516 hall des lumieres \n", - "9 11835 hdl - ny \n", - "\n", - " created_at updated_at \\\n", - "26 2020-10-12 08:57:27.783770+02:00 2020-10-12 08:57:27.783770+02:00 \n", - "17 2022-05-17 09:11:19.416106+02:00 2022-05-17 09:11:19.416106+02:00 \n", - "32 2020-10-12 08:57:27.785329+02:00 2020-10-12 08:57:27.785329+02:00 \n", - "10 2022-01-28 12:07:16.602885+01:00 2022-01-28 12:07:16.602885+01:00 \n", - "16 2022-05-13 10:59:06.829576+02:00 2022-05-13 10:59:06.829576+02:00 \n", - "2 2022-08-04 04:03:31.045648+02:00 2022-08-04 04:03:31.045648+02:00 \n", - "20 2023-04-08 03:49:46.916777+02:00 2023-04-08 03:49:46.916777+02:00 \n", - "18 2023-08-29 17:39:55.188028+02:00 2023-08-29 17:39:55.188028+02:00 \n", - "8 2022-05-13 11:00:14.943669+02:00 2022-05-13 11:00:14.943669+02:00 \n", - "15 2023-04-08 03:42:10.395124+02:00 2023-04-08 03:42:10.395124+02:00 \n", - "27 2020-10-18 01:20:12.738229+02:00 2020-10-18 01:20:12.738229+02:00 \n", - "33 2020-10-13 11:05:43.705639+02:00 2020-12-03 08:33:15.576065+01:00 \n", - "30 2020-10-13 14:56:27.206958+02:00 2020-10-13 14:56:27.206958+02:00 \n", - "7 2020-10-14 14:16:20.284658+02:00 2020-10-14 14:16:20.284658+02:00 \n", - "19 2020-10-14 18:06:57.059828+02:00 2020-10-14 18:06:57.059828+02:00 \n", - "24 2020-10-14 15:02:40.478501+02:00 2020-10-14 15:02:40.478501+02:00 \n", - "29 2020-10-14 15:46:44.072307+02:00 2020-10-14 15:46:44.072307+02:00 \n", - "28 2021-06-11 10:52:15.706030+02:00 2021-06-11 10:52:15.706030+02:00 \n", - "25 2021-06-11 10:28:30.237144+02:00 2021-06-11 10:28:30.237144+02:00 \n", - "22 2020-10-19 17:51:45.915572+02:00 2020-10-19 17:51:45.915572+02:00 \n", - "3 2020-10-18 01:30:23.853673+02:00 2020-10-18 01:30:23.853673+02:00 \n", - "6 2020-10-18 01:30:23.863631+02:00 2020-10-18 01:30:23.863631+02:00 \n", - "21 2020-10-19 17:37:09.345955+02:00 2020-10-19 17:37:09.345955+02:00 \n", - "23 2020-10-19 10:17:55.757817+02:00 2020-10-19 10:17:55.757817+02:00 \n", - "31 2020-10-14 19:13:55.213186+02:00 2022-10-14 06:21:53.310810+02:00 \n", - "5 2020-12-08 18:46:15.957997+01:00 2020-12-08 18:46:15.957997+01:00 \n", - "14 2022-03-08 16:30:03.135537+01:00 2022-03-08 16:30:03.135537+01:00 \n", - "1 2022-05-10 14:56:36.025562+02:00 2022-05-10 14:56:36.025562+02:00 \n", - "4 2022-05-10 15:05:40.443121+02:00 2022-05-10 15:05:40.443121+02:00 \n", - "12 2023-06-13 16:17:37.818103+02:00 2023-06-13 16:17:37.818103+02:00 \n", - "13 2023-06-29 09:31:23.575220+02:00 2023-06-29 09:31:23.575220+02:00 \n", - "11 2023-06-20 17:58:19.153019+02:00 2023-06-29 09:38:51.592547+02:00 \n", - "0 2023-06-29 09:46:44.718839+02:00 2023-06-29 09:46:44.718839+02:00 \n", - "9 2022-03-08 16:00:20.821212+01:00 2023-06-29 09:27:59.256591+02:00 \n", - "\n", - " street_id fixed_capacity \n", - "26 1 NaN \n", - "17 2 NaN \n", - "32 2 NaN \n", - "10 2 NaN \n", - "16 859 NaN \n", - "2 859 NaN \n", - "20 859 NaN \n", - "18 859 NaN \n", - "8 859 NaN \n", - "15 859 NaN \n", - "27 3525 NaN \n", - "33 449992 NaN \n", - "30 460754 NaN \n", - "7 481475 NaN \n", - "19 483815 NaN \n", - "24 485539 NaN \n", - "29 499380 NaN \n", - "28 535931 NaN \n", - "25 569179 NaN \n", - "22 717981 NaN \n", - "3 852301 NaN \n", - "6 852302 NaN \n", - "21 867431 NaN \n", - "23 867431 NaN \n", - "31 887751 NaN \n", - "5 1418086 NaN \n", - "14 3639035 NaN \n", - "1 4209418 NaN \n", - "4 4209419 NaN \n", - "12 7335205 NaN \n", - "13 7364467 NaN \n", - "11 7364467 NaN \n", - "0 7364467 NaN \n", - "9 7446203 NaN " - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "company_number = '101'\n", - "\n", - "facilities = load_dataset_2(company_number, \"facilities\")\n", - "\n", - "facilities.sort_values(by = 'street_id')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c8c8eea4-21a2-487b-b20a-15d73616a253", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
id_xsent_atsoftwaresatisfactionextra_fieldcustomer_idcontribution_site_idcreated_at_xupdated_at_xid_yfacility_idcreated_at_yupdated_at_y
01349102017-07-30 15:50:15+02:00NaN8.0NaN91936702020-09-25 20:41:07.752795+02:002020-09-25 20:41:07.752795+02:00704382020-09-25 20:41:07.735280+02:002020-09-25 20:41:07.735280+02:00
158484272020-03-04 16:18:13.597000+01:00NaNNaNNaN22445034202022-01-21 02:44:34.857144+01:002022-01-21 02:44:34.857144+01:00342066502022-01-21 02:44:34.690938+01:002022-01-21 02:44:34.690938+01:00
29183832020-10-24 14:59:22.784000+02:00NaNNaNNaN3977182082020-10-25 02:06:54.048105+02:002020-10-25 02:06:54.048105+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
39183842020-10-24 14:35:39.725000+02:00NaNNaNNaN3977192082020-10-25 02:06:54.050218+02:002020-10-25 02:06:54.050218+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
49183852020-10-24 12:45:35.225000+02:00NaN10.0NaN22082020-10-25 02:06:54.052201+02:002020-10-25 02:06:54.052201+02:002085762020-09-27 18:05:14.671650+02:002020-09-27 18:05:14.671650+02:00
..........................................
2545419512018-03-20 09:34:09+01:00NaN8.0NaN6969412020-09-25 20:06:37.138272+02:002020-09-25 20:06:37.138272+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545519522018-03-20 09:31:56+01:00NaNNaNNaN6969412020-09-25 20:06:37.138874+02:002020-09-25 20:06:37.138874+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545619542018-03-20 09:30:44+01:00NaNNaNNaN6969412020-09-25 20:06:37.140372+02:002020-09-25 20:06:37.140372+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545719552018-03-20 09:28:49+01:00NaN8.0NaN6969512020-09-25 20:06:37.140966+02:002020-09-25 20:06:37.140966+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
2545819532018-03-20 09:31:23.361000+01:00NaN8.0NaN212020-09-25 20:06:37.139437+02:002020-09-25 20:06:37.139437+02:0013692020-09-25 20:06:35.964342+02:002020-09-25 20:06:35.964342+02:00
\n", - "

25459 rows × 13 columns

\n", - "
" - ], - "text/plain": [ - " id_x sent_at software satisfaction \\\n", - "0 134910 2017-07-30 15:50:15+02:00 NaN 8.0 \n", - "1 5848427 2020-03-04 16:18:13.597000+01:00 NaN NaN \n", - "2 918383 2020-10-24 14:59:22.784000+02:00 NaN NaN \n", - "3 918384 2020-10-24 14:35:39.725000+02:00 NaN NaN \n", - "4 918385 2020-10-24 12:45:35.225000+02:00 NaN 10.0 \n", - "... ... ... ... ... \n", - "25454 1951 2018-03-20 09:34:09+01:00 NaN 8.0 \n", - "25455 1952 2018-03-20 09:31:56+01:00 NaN NaN \n", - "25456 1954 2018-03-20 09:30:44+01:00 NaN NaN \n", - "25457 1955 2018-03-20 09:28:49+01:00 NaN 8.0 \n", - "25458 1953 2018-03-20 09:31:23.361000+01:00 NaN 8.0 \n", - "\n", - " extra_field customer_id contribution_site_id \\\n", - "0 NaN 91936 70 \n", - "1 NaN 224450 3420 \n", - "2 NaN 397718 208 \n", - "3 NaN 397719 208 \n", - "4 NaN 2 208 \n", - "... ... ... ... \n", - "25454 NaN 69694 1 \n", - "25455 NaN 69694 1 \n", - "25456 NaN 69694 1 \n", - "25457 NaN 69695 1 \n", - "25458 NaN 2 1 \n", - "\n", - " created_at_x updated_at_x \\\n", - "0 2020-09-25 20:41:07.752795+02:00 2020-09-25 20:41:07.752795+02:00 \n", - "1 2022-01-21 02:44:34.857144+01:00 2022-01-21 02:44:34.857144+01:00 \n", - "2 2020-10-25 02:06:54.048105+02:00 2020-10-25 02:06:54.048105+02:00 \n", - "3 2020-10-25 02:06:54.050218+02:00 2020-10-25 02:06:54.050218+02:00 \n", - "4 2020-10-25 02:06:54.052201+02:00 2020-10-25 02:06:54.052201+02:00 \n", - "... ... ... \n", - "25454 2020-09-25 20:06:37.138272+02:00 2020-09-25 20:06:37.138272+02:00 \n", - "25455 2020-09-25 20:06:37.138874+02:00 2020-09-25 20:06:37.138874+02:00 \n", - "25456 2020-09-25 20:06:37.140372+02:00 2020-09-25 20:06:37.140372+02:00 \n", - "25457 2020-09-25 20:06:37.140966+02:00 2020-09-25 20:06:37.140966+02:00 \n", - "25458 2020-09-25 20:06:37.139437+02:00 2020-09-25 20:06:37.139437+02:00 \n", - "\n", - " id_y facility_id created_at_y \\\n", - "0 70 438 2020-09-25 20:41:07.735280+02:00 \n", - "1 3420 6650 2022-01-21 02:44:34.690938+01:00 \n", - "2 208 576 2020-09-27 18:05:14.671650+02:00 \n", - "3 208 576 2020-09-27 18:05:14.671650+02:00 \n", - "4 208 576 2020-09-27 18:05:14.671650+02:00 \n", - "... ... ... ... \n", - "25454 1 369 2020-09-25 20:06:35.964342+02:00 \n", - "25455 1 369 2020-09-25 20:06:35.964342+02:00 \n", - "25456 1 369 2020-09-25 20:06:35.964342+02:00 \n", - "25457 1 369 2020-09-25 20:06:35.964342+02:00 \n", - "25458 1 369 2020-09-25 20:06:35.964342+02:00 \n", - "\n", - " updated_at_y \n", - "0 2020-09-25 20:41:07.735280+02:00 \n", - "1 2022-01-21 02:44:34.690938+01:00 \n", - "2 2020-09-27 18:05:14.671650+02:00 \n", - "3 2020-09-27 18:05:14.671650+02:00 \n", - "4 2020-09-27 18:05:14.671650+02:00 \n", - "... ... \n", - "25454 2020-09-25 20:06:35.964342+02:00 \n", - "25455 2020-09-25 20:06:35.964342+02:00 \n", - "25456 2020-09-25 20:06:35.964342+02:00 \n", - "25457 2020-09-25 20:06:35.964342+02:00 \n", - "25458 2020-09-25 20:06:35.964342+02:00 \n", - "\n", - "[25459 rows x 13 columns]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# contribution and contribution sites \n", - "contributions = load_dataset_2(company_number, \"contributions\")\n", - "contribution_sites = load_dataset_2(company_number, \"contribution_sites\")\n", - "\n", - "pd.merge(contributions, contribution_sites, left_on = 'contribution_site_id', right_on = 'id', how = 'inner')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "85b70219-f753-422e-9f57-a26eb28e7481", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "id 0.000000\n", - "sent_at 0.000000\n", - "software 1.000000\n", - "satisfaction 0.430732\n", - "extra_field 1.000000\n", - "customer_id 0.000000\n", - "contribution_site_id 0.000000\n", - "created_at 0.000000\n", - "updated_at 0.000000\n", - "dtype: float64" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "contributions.isna().sum()/len(contributions)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "647920c8-da07-4e87-964b-304fd7ff79f5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idnamecreated_atupdated_at
01eur2023-07-17 15:35:19.957203+02:002023-07-17 15:35:19.957203+02:00
12usd2023-07-17 15:35:21.132408+02:002023-07-17 15:35:21.132408+02:00
23gbp2023-07-17 15:35:21.843594+02:002023-07-17 15:35:21.843594+02:00
34chf2023-07-17 15:35:23.229322+02:002023-07-17 15:35:23.229322+02:00
45cad2023-07-17 15:35:24.262466+02:002023-07-17 15:35:24.262466+02:00
\n", - "
" - ], - "text/plain": [ - " id name created_at updated_at\n", - "0 1 eur 2023-07-17 15:35:19.957203+02:00 2023-07-17 15:35:19.957203+02:00\n", - "1 2 usd 2023-07-17 15:35:21.132408+02:00 2023-07-17 15:35:21.132408+02:00\n", - "2 3 gbp 2023-07-17 15:35:21.843594+02:00 2023-07-17 15:35:21.843594+02:00\n", - "3 4 chf 2023-07-17 15:35:23.229322+02:00 2023-07-17 15:35:23.229322+02:00\n", - "4 5 cad 2023-07-17 15:35:24.262466+02:00 2023-07-17 15:35:24.262466+02:00" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "company_number = \"2\"\n", - "\n", - "load_dataset_2(company_number, \"currencies\")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "bc1f3d28-7f0c-4e87-baf7-dddcf03a7145", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idpercent_pricemax_pricemin_pricecategory_idpricing_formula_idrepresentation_idcreated_atupdated_at
01100.00.00.01112023-10-13 13:02:32.517137+02:002023-10-13 13:02:32.517137+02:00
12100.00.00.01122023-10-13 13:02:32.531505+02:002023-10-13 13:02:32.531505+02:00
23100.00.00.01132023-10-13 13:02:32.532172+02:002023-10-13 13:02:32.532172+02:00
34100.00.00.01142023-10-13 13:02:32.532665+02:002023-10-13 13:02:32.532665+02:00
45100.00.00.01152023-10-13 13:02:32.533142+02:002023-10-13 13:02:32.533142+02:00
..............................
779980810312100.00.00.0115672542023-11-09 05:14:16.770130+01:002023-11-09 05:14:16.770130+01:00
779981810313100.00.00.0145672542023-11-09 05:14:16.770538+01:002023-11-09 05:14:16.770538+01:00
779982810314100.00.00.0115672552023-11-09 05:14:16.770916+01:002023-11-09 05:14:16.770916+01:00
779983810315100.00.00.0115672562023-11-09 05:14:16.771359+01:002023-11-09 05:14:16.771359+01:00
779984810316100.00.00.0115672572023-11-09 05:14:16.771761+01:002023-11-09 05:14:16.771761+01:00
\n", - "

779985 rows × 9 columns

\n", - "
" - ], - "text/plain": [ - " id percent_price max_price min_price category_id \\\n", - "0 1 100.0 0.0 0.0 1 \n", - "1 2 100.0 0.0 0.0 1 \n", - "2 3 100.0 0.0 0.0 1 \n", - "3 4 100.0 0.0 0.0 1 \n", - "4 5 100.0 0.0 0.0 1 \n", - "... ... ... ... ... ... \n", - "779980 810312 100.0 0.0 0.0 1 \n", - "779981 810313 100.0 0.0 0.0 1 \n", - "779982 810314 100.0 0.0 0.0 1 \n", - "779983 810315 100.0 0.0 0.0 1 \n", - "779984 810316 100.0 0.0 0.0 1 \n", - "\n", - " pricing_formula_id representation_id \\\n", - "0 1 1 \n", - "1 1 2 \n", - "2 1 3 \n", - "3 1 4 \n", - "4 1 5 \n", - "... ... ... \n", - "779980 1 567254 \n", - "779981 4 567254 \n", - "779982 1 567255 \n", - "779983 1 567256 \n", - "779984 1 567257 \n", - "\n", - " created_at updated_at \n", - "0 2023-10-13 13:02:32.517137+02:00 2023-10-13 13:02:32.517137+02:00 \n", - "1 2023-10-13 13:02:32.531505+02:00 2023-10-13 13:02:32.531505+02:00 \n", - "2 2023-10-13 13:02:32.532172+02:00 2023-10-13 13:02:32.532172+02:00 \n", - "3 2023-10-13 13:02:32.532665+02:00 2023-10-13 13:02:32.532665+02:00 \n", - "4 2023-10-13 13:02:32.533142+02:00 2023-10-13 13:02:32.533142+02:00 \n", - "... ... ... \n", - "779980 2023-11-09 05:14:16.770130+01:00 2023-11-09 05:14:16.770130+01:00 \n", - "779981 2023-11-09 05:14:16.770538+01:00 2023-11-09 05:14:16.770538+01:00 \n", - "779982 2023-11-09 05:14:16.770916+01:00 2023-11-09 05:14:16.770916+01:00 \n", - "779983 2023-11-09 05:14:16.771359+01:00 2023-11-09 05:14:16.771359+01:00 \n", - "779984 2023-11-09 05:14:16.771761+01:00 2023-11-09 05:14:16.771761+01:00 \n", - "\n", - "[779985 rows x 9 columns]" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "load_dataset_2(company_number, \"products_groups\")" - ] - }, - { - "cell_type": "markdown", - "id": "45d5261f-4d46-49cb-8582-dd2121122b05", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "# 1 - Comportement d'achat" - ] - }, - { - "cell_type": "markdown", - "id": "3479960c-0d23-45f1-8fff-d87395205731", - "metadata": {}, - "source": [ - "## Outlier" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9376af51-4320-44b6-8f30-1e1234371556", - "metadata": {}, - "outputs": [], - "source": [ - "def outlier_detection(directory_path = \"1\", coupure = 1):\n", - " nom_dataframe = 'df'+ directory_path +'_tickets'\n", - " df_tickets = globals()[nom_dataframe].copy()\n", - " df_tickets_kpi = tickets_kpi_function(df_tickets)\n", - "\n", - " if directory_path == \"101\" :\n", - " df_tickets_1 = df101_tickets_1.copy()\n", - " df_tickets_kpi_1 = tickets_kpi_function(df_tickets_1)\n", - "\n", - " df_tickets_kpi = pd.concat([df_tickets_kpi, df_tickets_kpi_1])\n", - " # Part du CA par customer\n", - " total_amount_share = df_tickets_kpi.groupby('customer_id')['total_amount'].sum().reset_index()\n", - " total_amount_share['total_amount_entreprise'] = total_amount_share['total_amount'].sum()\n", - " total_amount_share['share_total_amount'] = total_amount_share['total_amount']/total_amount_share['total_amount_entreprise']\n", - " \n", - " total_amount_share_index = total_amount_share.set_index('customer_id')\n", - " df_circulaire = total_amount_share_index['total_amount'].sort_values(axis = 0, ascending = False)\n", - " \n", - " top = df_circulaire[:coupure]\n", - " rest = df_circulaire[coupure:]\n", - " \n", - " # Calculez la somme du reste\n", - " rest_sum = rest.sum()\n", - " \n", - " # Créez une nouvelle série avec les cinq plus grandes parts et 'Autre'\n", - " new_series = pd.concat([top, pd.Series([rest_sum], index=['Autre'])])\n", - " \n", - " # Créez le graphique circulaire\n", - " plt.figure(figsize=(3, 3))\n", - " plt.pie(new_series, labels=new_series.index, autopct='%1.1f%%', startangle=140, pctdistance=0.5)\n", - " plt.axis('equal') # Assurez-vous que le graphique est un cercle\n", - " plt.title('Répartition des montants totaux')\n", - " plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "73211efc-b79f-4235-a250-c0699ea277bf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "outlier_detection(directory_path = \"1\", coupure = 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "5c8e9bb7-a403-4898-b40b-47aa37237bc6", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
582011NaNNaNNaNNaN22020-09-03 13:11:25.569167+02:002023-03-04 13:27:42.761679+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaNNaNFalse2023-11-08 03:20:0745.012547757.030122330831-67.79096913.751531.9560878821221.5NaNNaNNaN6414722013-06-10 12:37:58+02:00NaNNaNfrNaN1311
\n", - "
" - ], - "text/plain": [ - " id lastname firstname birthdate email street_id \\\n", - "58201 1 NaN NaN NaN NaN 2 \n", - "\n", - " created_at updated_at \\\n", - "58201 2020-09-03 13:11:25.569167+02:00 2023-03-04 13:27:42.761679+01:00 \n", - "\n", - " civility is_partner extra deleted_at reference gender \\\n", - "58201 NaN False NaN NaN NaN 2 \n", - "\n", - " is_email_true extra_field opt_in structure_id note profession \\\n", - "58201 True NaN False NaN NaN NaN \n", - "\n", - " language mcp_contact_id need_reload last_buying_date max_price \\\n", - "58201 NaN NaN False 2023-11-08 03:20:07 45.0 \n", - "\n", - " ticket_sum average_price fidelity average_purchase_delay \\\n", - "58201 1254775 7.030122 330831 -67.790969 \n", - "\n", - " average_price_basket average_ticket_basket total_price \\\n", - "58201 13.75153 1.956087 8821221.5 \n", - "\n", - " preferred_category preferred_supplier preferred_formula \\\n", - "58201 NaN NaN NaN \n", - "\n", - " purchase_count first_buying_date last_visiting_date zipcode \\\n", - "58201 641472 2013-06-10 12:37:58+02:00 NaN NaN \n", - "\n", - " country age tenant_id \n", - "58201 fr NaN 1311 " - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = load_dataset_2('1', 'customersplus')\n", - "df[df['id'] == 1]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "4455b6b9-8395-47ea-b976-d98a2d3c782c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "outlier_detection(directory_path = \"2\", coupure = 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "ee16cf31-18e1-4803-b003-ba1d1a3fc333", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
17024612184NaNNaNNaNNaN35642023-10-12 12:25:15.438714+02:002023-11-09 05:14:01.944407+01:00NaNFalseNaNNaNNaN2TrueNaNFalse1275.0NaNNaNNaNNaNFalse2023-11-08 19:17:50.56500075.051283112.6454381973580.031.7195772.5083816484972.4NaNNaNNaN2044472020-08-28 08:55:55.710000+02:00NaNNaNNaNNaN1879
\n", - "
" - ], - "text/plain": [ - " id lastname firstname birthdate email street_id \\\n", - "170246 12184 NaN NaN NaN NaN 3564 \n", - "\n", - " created_at updated_at \\\n", - "170246 2023-10-12 12:25:15.438714+02:00 2023-11-09 05:14:01.944407+01:00 \n", - "\n", - " civility is_partner extra deleted_at reference gender \\\n", - "170246 NaN False NaN NaN NaN 2 \n", - "\n", - " is_email_true extra_field opt_in structure_id note profession \\\n", - "170246 True NaN False 1275.0 NaN NaN \n", - "\n", - " language mcp_contact_id need_reload last_buying_date \\\n", - "170246 NaN NaN False 2023-11-08 19:17:50.565000 \n", - "\n", - " max_price ticket_sum average_price fidelity \\\n", - "170246 75.0 512831 12.645438 197358 \n", - "\n", - " average_purchase_delay average_price_basket average_ticket_basket \\\n", - "170246 0.0 31.719577 2.508381 \n", - "\n", - " total_price preferred_category preferred_supplier \\\n", - "170246 6484972.4 NaN NaN \n", - "\n", - " preferred_formula purchase_count first_buying_date \\\n", - "170246 NaN 204447 2020-08-28 08:55:55.710000+02:00 \n", - "\n", - " last_visiting_date zipcode country age tenant_id \n", - "170246 NaN NaN NaN NaN 1879 " - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = load_dataset_2('2', 'customersplus')\n", - "df[df['id'] == 12184]" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "4073c986-3e2c-4945-8601-220fea747c9c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
1026391NaNNaNNaNemail112023-07-20 17:16:27.062822+02:002023-07-20 17:16:27.074952+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaN1.0FalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNfrNaN1879
2244532NaNfirstname2NaNNaN22023-07-21 10:18:44.502496+02:002023-07-21 10:18:44.502496+02:00NaNFalseNaNNaNNaN1TrueNaNFalseNaNNaNNaNjosefNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1030133NaNfirstname3NaNNaN32023-07-21 10:18:44.503913+02:002023-07-21 10:18:44.503913+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdominicNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1383864NaNfirstname4NaNNaN32023-07-21 10:18:44.504404+02:002023-07-21 10:18:44.504404+02:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNabigailNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
1900875NaNfirstname5NaNNaN32023-07-21 10:18:44.504841+02:002023-07-21 10:18:44.504841+02:00NaNFalseNaNNaNNaN1TrueNaNFalseNaNNaNNaNsophiaNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNchNaN1879
.................................................................................................................................
101868601387lastname601387firstname601387NaNemail60138735502023-11-09 05:13:57.358715+01:002023-11-09 05:13:57.358715+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNNaNNaN1879
205168601388lastname601388firstname601388NaNemail60138835502023-11-09 05:13:57.359234+01:002023-11-09 05:13:57.359234+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalse2023-11-09 00:25:24.71600015.0214.010.028.02.028.0NaNNaNNaN12023-11-09 00:25:24.716000+01:00NaNNaNNaNNaN1879
67641601389lastname601389firstname601389NaNemail60138935502023-11-09 05:13:57.360373+01:002023-11-09 05:13:57.360373+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNdeNaNFalse2023-11-09 00:28:07.51100015.0215.010.030.02.030.0NaNNaNNaN12023-11-09 00:28:07.511000+01:00NaNNaNNaNNaN1879
67639601390lastname601390firstname601390NaNemail60139035502023-11-09 05:13:57.360903+01:002023-11-09 05:13:57.360903+01:00NaNFalseNaNNaNNaN0TrueNaNFalseNaNNaNNaNNaNNaNFalseNaNNaN0NaN0NaNNaNNaN0.0NaNNaNNaN0NaNNaNNaNNaNNaN1879
256450601391lastname601391firstname601391NaNemail60139135502023-11-09 05:13:57.361432+01:002023-11-09 05:14:18.906054+01:00NaNFalseNaNNaNNaN2TrueNaNFalseNaNNaNNaNNaNNaNFalse2023-11-09 00:36:41.17200015.0215.010.030.02.030.0NaNNaNNaN12023-11-09 00:36:41.172000+01:00NaNNaNNaNNaN1879
\n", - "

275622 rows × 42 columns

\n", - "
" - ], - "text/plain": [ - " id lastname firstname birthdate email \\\n", - "102639 1 NaN NaN NaN email1 \n", - "224453 2 NaN firstname2 NaN NaN \n", - "103013 3 NaN firstname3 NaN NaN \n", - "138386 4 NaN firstname4 NaN NaN \n", - "190087 5 NaN firstname5 NaN NaN \n", - "... ... ... ... ... ... \n", - "101868 601387 lastname601387 firstname601387 NaN email601387 \n", - "205168 601388 lastname601388 firstname601388 NaN email601388 \n", - "67641 601389 lastname601389 firstname601389 NaN email601389 \n", - "67639 601390 lastname601390 firstname601390 NaN email601390 \n", - "256450 601391 lastname601391 firstname601391 NaN email601391 \n", - "\n", - " street_id created_at \\\n", - "102639 1 2023-07-20 17:16:27.062822+02:00 \n", - "224453 2 2023-07-21 10:18:44.502496+02:00 \n", - "103013 3 2023-07-21 10:18:44.503913+02:00 \n", - "138386 3 2023-07-21 10:18:44.504404+02:00 \n", - "190087 3 2023-07-21 10:18:44.504841+02:00 \n", - "... ... ... \n", - "101868 3550 2023-11-09 05:13:57.358715+01:00 \n", - "205168 3550 2023-11-09 05:13:57.359234+01:00 \n", - "67641 3550 2023-11-09 05:13:57.360373+01:00 \n", - "67639 3550 2023-11-09 05:13:57.360903+01:00 \n", - "256450 3550 2023-11-09 05:13:57.361432+01:00 \n", - "\n", - " updated_at civility is_partner extra \\\n", - "102639 2023-07-20 17:16:27.074952+02:00 NaN False NaN \n", - "224453 2023-07-21 10:18:44.502496+02:00 NaN False NaN \n", - "103013 2023-07-21 10:18:44.503913+02:00 NaN False NaN \n", - "138386 2023-07-21 10:18:44.504404+02:00 NaN False NaN \n", - "190087 2023-07-21 10:18:44.504841+02:00 NaN False NaN \n", - "... ... ... ... ... \n", - "101868 2023-11-09 05:13:57.358715+01:00 NaN False NaN \n", - "205168 2023-11-09 05:13:57.359234+01:00 NaN False NaN \n", - "67641 2023-11-09 05:13:57.360373+01:00 NaN False NaN \n", - "67639 2023-11-09 05:13:57.360903+01:00 NaN False NaN \n", - "256450 2023-11-09 05:14:18.906054+01:00 NaN False NaN \n", - "\n", - " deleted_at reference gender is_email_true extra_field opt_in \\\n", - "102639 NaN NaN 2 True NaN False \n", - "224453 NaN NaN 1 True NaN False \n", - "103013 NaN NaN 2 True NaN False \n", - "138386 NaN NaN 2 True NaN False \n", - "190087 NaN NaN 1 True NaN False \n", - "... ... ... ... ... ... ... \n", - "101868 NaN NaN 2 True NaN False \n", - "205168 NaN NaN 2 True NaN False \n", - "67641 NaN NaN 2 True NaN False \n", - "67639 NaN NaN 0 True NaN False \n", - "256450 NaN NaN 2 True NaN False \n", - "\n", - " structure_id note profession language mcp_contact_id need_reload \\\n", - "102639 NaN NaN NaN NaN 1.0 False \n", - "224453 NaN NaN NaN josef NaN False \n", - "103013 NaN NaN NaN dominic NaN False \n", - "138386 NaN NaN NaN abigail NaN False \n", - "190087 NaN NaN NaN sophia NaN False \n", - "... ... ... ... ... ... ... \n", - "101868 NaN NaN NaN de NaN False \n", - "205168 NaN NaN NaN de NaN False \n", - "67641 NaN NaN NaN de NaN False \n", - "67639 NaN NaN NaN NaN NaN False \n", - "256450 NaN NaN NaN NaN NaN False \n", - "\n", - " last_buying_date max_price ticket_sum average_price \\\n", - "102639 NaN NaN 0 NaN \n", - "224453 NaN NaN 0 NaN \n", - "103013 NaN NaN 0 NaN \n", - "138386 NaN NaN 0 NaN \n", - "190087 NaN NaN 0 NaN \n", - "... ... ... ... ... \n", - "101868 NaN NaN 0 NaN \n", - "205168 2023-11-09 00:25:24.716000 15.0 2 14.0 \n", - "67641 2023-11-09 00:28:07.511000 15.0 2 15.0 \n", - "67639 NaN NaN 0 NaN \n", - "256450 2023-11-09 00:36:41.172000 15.0 2 15.0 \n", - "\n", - " fidelity average_purchase_delay average_price_basket \\\n", - "102639 0 NaN NaN \n", - "224453 0 NaN NaN \n", - "103013 0 NaN NaN \n", - "138386 0 NaN NaN \n", - "190087 0 NaN NaN \n", - "... ... ... ... \n", - "101868 0 NaN NaN \n", - "205168 1 0.0 28.0 \n", - "67641 1 0.0 30.0 \n", - "67639 0 NaN NaN \n", - "256450 1 0.0 30.0 \n", - "\n", - " average_ticket_basket total_price preferred_category \\\n", - "102639 NaN 0.0 NaN \n", - "224453 NaN 0.0 NaN \n", - "103013 NaN 0.0 NaN \n", - "138386 NaN 0.0 NaN \n", - "190087 NaN 0.0 NaN \n", - "... ... ... ... \n", - "101868 NaN 0.0 NaN \n", - "205168 2.0 28.0 NaN \n", - "67641 2.0 30.0 NaN \n", - "67639 NaN 0.0 NaN \n", - "256450 2.0 30.0 NaN \n", - "\n", - " preferred_supplier preferred_formula purchase_count \\\n", - "102639 NaN NaN 0 \n", - "224453 NaN NaN 0 \n", - "103013 NaN NaN 0 \n", - "138386 NaN NaN 0 \n", - "190087 NaN NaN 0 \n", - "... ... ... ... \n", - "101868 NaN NaN 0 \n", - "205168 NaN NaN 1 \n", - "67641 NaN NaN 1 \n", - "67639 NaN NaN 0 \n", - "256450 NaN NaN 1 \n", - "\n", - " first_buying_date last_visiting_date zipcode country \\\n", - "102639 NaN NaN NaN fr \n", - "224453 NaN NaN NaN ch \n", - "103013 NaN NaN NaN ch \n", - "138386 NaN NaN NaN ch \n", - "190087 NaN NaN NaN ch \n", - "... ... ... ... ... \n", - "101868 NaN NaN NaN NaN \n", - "205168 2023-11-09 00:25:24.716000+01:00 NaN NaN NaN \n", - "67641 2023-11-09 00:28:07.511000+01:00 NaN NaN NaN \n", - "67639 NaN NaN NaN NaN \n", - "256450 2023-11-09 00:36:41.172000+01:00 NaN NaN NaN \n", - "\n", - " age tenant_id \n", - "102639 NaN 1879 \n", - "224453 NaN 1879 \n", - "103013 NaN 1879 \n", - "138386 NaN 1879 \n", - "190087 NaN 1879 \n", - "... ... ... \n", - "101868 NaN 1879 \n", - "205168 NaN 1879 \n", - "67641 NaN 1879 \n", - "67639 NaN 1879 \n", - "256450 NaN 1879 \n", - "\n", - "[275622 rows x 42 columns]" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.sort_values(by = 'id')" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "475030ad-6a69-4c91-9cd6-943a0edeaf01", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "outlier_detection(directory_path = \"3\", coupure = 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "b64d04db-1c3f-4538-9d05-8f7d62c7c046", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
1057201NaNNaN1961-12-04NaN911592021-03-02 15:35:40.452065+01:002023-11-09 01:31:07.539604+01:00NaNFalseNaNNaNNaN2FalseNaNFalse19715.0NaNNaNNaNNaNFalse2023-11-06 16:57:197500.0229771610.15219614917-39771.16514727.5148112.7102322.332686e+07NaNNaNNaN8477932016-01-01 10:23:36+01:002023-11-06 17:12:0013090fr61.01512
\n", - "
" - ], - "text/plain": [ - " id lastname firstname birthdate email street_id \\\n", - "105720 1 NaN NaN 1961-12-04 NaN 91159 \n", - "\n", - " created_at updated_at \\\n", - "105720 2021-03-02 15:35:40.452065+01:00 2023-11-09 01:31:07.539604+01:00 \n", - "\n", - " civility is_partner extra deleted_at reference gender \\\n", - "105720 NaN False NaN NaN NaN 2 \n", - "\n", - " is_email_true extra_field opt_in structure_id note profession \\\n", - "105720 False NaN False 19715.0 NaN NaN \n", - "\n", - " language mcp_contact_id need_reload last_buying_date max_price \\\n", - "105720 NaN NaN False 2023-11-06 16:57:19 7500.0 \n", - "\n", - " ticket_sum average_price fidelity average_purchase_delay \\\n", - "105720 2297716 10.152196 14917 -39771.165147 \n", - "\n", - " average_price_basket average_ticket_basket total_price \\\n", - "105720 27.514811 2.710232 2.332686e+07 \n", - "\n", - " preferred_category preferred_supplier preferred_formula \\\n", - "105720 NaN NaN NaN \n", - "\n", - " purchase_count first_buying_date last_visiting_date \\\n", - "105720 847793 2016-01-01 10:23:36+01:00 2023-11-06 17:12:00 \n", - "\n", - " zipcode country age tenant_id \n", - "105720 13090 fr 61.0 1512 " - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = load_dataset_2('3', 'customersplus')\n", - "df[df['id'] == 1]" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "1d817bee-3ded-4066-9f91-6cf095591b0e", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "outlier_detection(directory_path = \"4\", coupure = 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "4cc07982-1070-439b-a579-fd3f351778b3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idlastnamefirstnamebirthdateemailstreet_idcreated_atupdated_atcivilityis_partnerextradeleted_atreferencegenderis_email_trueextra_fieldopt_instructure_idnoteprofessionlanguagemcp_contact_idneed_reloadlast_buying_datemax_priceticket_sumaverage_pricefidelityaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepreferred_categorypreferred_supplierpreferred_formulapurchase_countfirst_buying_datelast_visiting_datezipcodecountryagetenant_id
3007542NaNNaNNaNNaN22020-09-25 19:09:07.669208+02:002021-11-30 02:07:28.120188+01:00NaNFalseNaNNaNNaN2FalseNaNFalseNaNNaNNaNNaNNaNFalse2023-11-07 16:33:09360.012372246.0562482368500.01552813.4936122.2280487492935.0NaNNaNNaN5552951901-01-01 00:09:21+00:09NaNNaNNaNNaN1342
\n", - "
" - ], - "text/plain": [ - " id lastname firstname birthdate email street_id \\\n", - "300754 2 NaN NaN NaN NaN 2 \n", - "\n", - " created_at updated_at \\\n", - "300754 2020-09-25 19:09:07.669208+02:00 2021-11-30 02:07:28.120188+01:00 \n", - "\n", - " civility is_partner extra deleted_at reference gender \\\n", - "300754 NaN False NaN NaN NaN 2 \n", - "\n", - " is_email_true extra_field opt_in structure_id note profession \\\n", - "300754 False NaN False NaN NaN NaN \n", - "\n", - " language mcp_contact_id need_reload last_buying_date max_price \\\n", - "300754 NaN NaN False 2023-11-07 16:33:09 360.0 \n", - "\n", - " ticket_sum average_price fidelity average_purchase_delay \\\n", - "300754 1237224 6.056248 236850 0.015528 \n", - "\n", - " average_price_basket average_ticket_basket total_price \\\n", - "300754 13.493612 2.228048 7492935.0 \n", - "\n", - " preferred_category preferred_supplier preferred_formula \\\n", - "300754 NaN NaN NaN \n", - "\n", - " purchase_count first_buying_date last_visiting_date zipcode \\\n", - "300754 555295 1901-01-01 00:09:21+00:09 NaN NaN \n", - "\n", - " country age tenant_id \n", - "300754 NaN NaN 1342 " - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = load_dataset_2('4', 'customersplus')\n", - "df[df['id'] == 2]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "f74a9e62-a0f7-41cf-9834-78a99204547c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAATEAAAEQCAYAAADYlUP7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABBNklEQVR4nO3dd3gUVdsG8Ht7S9s00isQWkIiSJUSBAIYmoAUQToKCKIoIK+0V3xRPgsISpEAgqioIAIKhI5IgFASSigJpJFOeja72Xa+P2IWlvSQZHZ2z++6csHOnp15ZndyZ+bM2RkOIYSAoiiKpbhMF0BRFPU8aIhRFMVqNMQoimI1GmIURbEaDTGKoliNhhhFUaxGQ4yiKFajIUZRFKvREKMoitWaLcRu3LgBqVSKDRs2NNciKYqyAPUKsZ07d4LD4Rh++Hw+XF1dMW7cOMTHx1f7uuLiYowePRrz5s3DvHnznrvo5/HXX39h5cqVVT7n4+ODKVOmGB6np6dj5cqViImJqdR25cqV4HA4TVNkA3E4nGrXzVLExcVh5cqVSEpKapbl/e9//8OBAwcabX6NUX9N27hZIvWwY8cOAoDs2LGDREVFkdOnT5PVq1cTiURCnJ2dSV5eXpWvGzNmDHn99deJXq+vz+KaxNy5c0l1q33t2jWSkJBgeBwdHW1Y32elpqaSqKiopiqzQQCQFStWMF0Go3799VcCgJw+fbpZlieTycjkyZMbbX6NUX9N27g54jck+Dp06IDOnTsDAPr27QudTocVK1bgwIEDmDp1aqX2v/zySwMjtvGUlpZCKpXW2CYkJKTO8/Pw8ICHh8fzlkVR1POqT+JV7IlFR0cbTf/zzz8JALJmzRqj6dHR0WTo0KFELpcTkUhEgoODyd69e6ucZ2RkJJkyZQqRy+VEKpWS8PBw8uDBA6O2kZGRZNiwYcTd3Z2IRCLi7+9PZs2aRXJycozarVixggAgV69eJaNGjSJ2dnbExcWFTJ48mQCo9JOYmEgIIcTb29vwV/X06dNVtq3Y06lYxtN0Oh357LPPSEBAABEKhcTJyYlMmjSJpKamGrXr06cPad++Pbl8+TJ56aWXiEQiIb6+vmTNmjVEp9PV+jkUFhaSGTNmEHt7eyKTyUhYWBi5d+9elXti9+/fJ+PHjydOTk5EKBSSNm3akI0bN1aq++OPPyatW7cmYrGY2NraksDAQLJu3boa66h4j/bs2UMWLVpEXFxciEwmI+Hh4SQzM5MUFRWRmTNnEgcHB+Lg4ECmTJlCiouLjeahVCrJkiVLiI+PDxEIBMTNzY3MmTOH5OfnG7Xz9vYmr7zyCjly5AgJCQkhYrGYBAQEkIiICEObim3p2Z+KPen6bj+3bt0i48aNIzY2NsTZ2ZlMnTqVFBQUGNpVtaw+ffoQQghRKBRk4cKFxMfHh4hEIiKXy0mnTp3Ijz/+WO37WVv9hBASERFBgoKCDPMcMWIEiYuLMzxf2za+ceNG0qtXL+Lk5ESkUinp0KED+eyzz4hara70fle1h9mnTx/DOhJCyJtvvklEIhG5cuWKYZpOpyP9+vUjzs7OJD09vdr1bSyNEmIbN24kAMi+ffsM006dOkWEQiHp1asX2bt3Lzl69CiZMmVKpQ+lYp6enp5k2rRp5MiRI2Tr1q3E2dmZeHp6Gm3MmzZtImvWrCEHDx4kZ8+eJd9//z3p2LEjCQgIMPoQKjZCb29vsnjxYnL8+HFy4MABkpCQQEaPHk0AkKioKMOPSqUihBh/cIWFhYbaPvroI0PbikCqKsRmzZpFAJC3336bHD16lGzevJk4OTkRT09Po1+UPn36EAcHB9KqVSuyefNmcvz4cTJnzhwCgHz//fc1fgZ6vZ6EhoYSkUhEPvnkExIZGUlWrFhB/Pz8KoXY7du3DYG0a9cuEhkZSRYuXEi4XC5ZuXKlod2aNWsIj8cjK1asICdPniRHjx4l69atM2pTlYoQ8/b2JlOmTDGss5WVFQkNDSUDBgwg77//PomMjCSfffYZ4fF4ZN68eUbrEhYWRvh8Plm2bBmJjIwkn3/+OZHJZCQkJMTwuVR8Nh4eHqRdu3Zk165d5NixY2TMmDEEADl79iwhhJDs7Gzyv//9jwAg33zzjeEzy87ObtD2ExAQQJYvX06OHz9OvvzySyISicjUqVMN7aKioohEIiFDhgwxLOv27duEkPJfbqlUSr788kty+vRpcvjwYfLpp5+SDRs2VPt+1lZ/xXPjx48nf/75J9m1axfx8/Mjtra25P79+4QQUus2/u6775JNmzaRo0ePklOnTpGvvvqKODo6Gq1XxftdlxBTKpUkODiY+Pn5GX5Xly9fTrhcLomMjKx2XRtTg0Ls4sWLRKPRkOLiYnL06FHi4uJCevfuTTQajaFtmzZtSEhIiNE0QggJDw8nrq6uhj2OinmOHDnSqN0///xDAJDVq1dXWYterycajYYkJycTAOSPP/4wPFexES5fvrzS62rqL3j2g6upT+zZELtz5w4BQObMmWPU7tKlSwQAWbp0qWFanz59CABy6dIlo7bt2rUjYWFhVdZW4ciRIwQAWb9+vdH0Tz75pFKIhYWFEQ8PD1JYWGjU9u233yZisdjQhxkeHk6Cg4NrXG5VKkJs6NChRtMXLFhAAJD58+cbTR8xYgSxt7c3PD569CgBQNauXWvUbu/evQQA2bp1q2Gat7c3EYvFJDk52TBNqVQSe3t78uabbxqm1bVPqS7bz7N1zZkzh4jFYqO+3er6xDp06EBGjBhRYw1Vqa7+/Px8Q2A+LSUlhYhEIjJhwgTDtLr2iel0OqLRaMiuXbsIj8cz6tOua4gRQkh8fDyxsbEhI0aMICdOnCBcLpd89NFHta9sI2nQEItu3bpBIBDA2toagwYNglwuxx9//AE+v7yLLSEhAXfv3sXrr78OANBqtYafIUOGICMjA/fu3TOaZ0XbCj169IC3tzdOnz5tmJadnY233noLnp6e4PP5EAgE8Pb2BgDcuXOnUp2jRo1qyOo1SEWdT5/dBIAuXbqgbdu2OHnypNF0FxcXdOnSxWhaUFAQkpOT67ScZ9+vCRMmGD1WqVQ4efIkRo4cCalUWukzUKlUuHjxoqHG2NhYzJkzB8eOHUNRUVHdVvpf4eHhRo/btm0LAHjllVcqTc/Ly0NJSQkA4NSpUwAqv2djxoyBTCar9J4FBwfDy8vL8FgsFqN169a1vmcV6rv9DBs2zOhxUFAQVCoVsrOza11Wly5dcOTIESxZsgRnzpyBUqmsU43ViYqKglKprPReeXp6ol+/fpXeq+pcv34dw4YNg4ODA3g8HgQCAd544w3odDrcv3+/QbW1bNkS3333HQ4cOIDw8HD06tWrWc+ONijEdu3ahejoaJw6dQpvvvkm7ty5g/Hjxxuez8rKAgC8//77EAgERj9z5swBADx+/Nhoni4uLpWW4+LigtzcXACAXq/HwIEDsX//fixatAgnT57E5cuXDb+IVW0krq6uDVm9Bqmos6plurm5GZ6v4ODgUKmdSCSqdWPPzc0Fn8+v9Ppn37/c3FxotVps2LCh0mcwZMgQAE8+gw8//BCff/45Ll68iMGDB8PBwQEvv/wyrly5Ustal7O3tzd6LBQKa5yuUqmM1sXJycmoHYfDMfrsKzT0PQMatv08uzyRSFRt22d9/fXXWLx4MQ4cOIDQ0FDY29tjxIgRNQ5Fqkl9t6+qpKSkoFevXkhLS8P69evx999/Izo6Gt988w2Auq1XdV555RW0aNECKpUK7733Hng8XoPnVV8NOjvZtm1bw9nJ0NBQ6HQ6bNu2Db/99htGjx4NR0dHAOW/HK+++mqV8wgICDB6nJmZWalNZmYmWrZsCQC4desWYmNjsXPnTkyePNnQJiEhodo6m3McV8UGn5GRUemsZXp6uuE9aYzlaLVa5ObmGv2SPfv+yeVy8Hg8TJo0CXPnzq1yXr6+vgAAPp+P9957D++99x4KCgpw4sQJLF26FGFhYUhNTa31rO7zrktOTo5RkBFCkJmZiRdffLHRltWQ7ed5yGQyrFq1CqtWrUJWVpZhr2zo0KG4e/duvef39Pb1rLpuXwcOHIBCocD+/fsNe6AAqhwHKRaLUVZWVmn648ePq1zWW2+9heLiYrRv3x7z589Hr169IJfLa62pMTTKiP21a9dCLpdj+fLl0Ov1CAgIQKtWrRAbG4vOnTtX+WNtbW00jz179hg9vnDhApKTk9G3b18ATwKp4q9hhS1bttSr1vr8Na1P2379+gEAfvjhB6Pp0dHRuHPnDl5++eV61Vmd0NBQAJXfrx9//NHosVQqRWhoKK5fv46goKAqP4Oq9mzs7OwwevRozJ07F3l5eU06aLTiPXn2Pdu3bx8UCkWD3rPqPrPG2n6qWl5t20eLFi0wZcoUjB8/Hvfu3UNpaWmN8wMq19+9e3dIJJJK79WjR49w6tQpo/eqPu8BIQTfffddpTp8fHxw48YNo2n379+v1A0EANu2bcMPP/yAjRs34uDBgygoKKhyqFVTadCe2LPkcjk+/PBDLFq0CD/++CMmTpyILVu2YPDgwQgLC8OUKVPg7u6OvLw83LlzB9euXcOvv/5qNI8rV65gxowZGDNmDFJTU/Gf//wH7u7uhsPPNm3awN/fH0uWLAEhBPb29jh06BCOHz9er1oDAwMBAJ999hkGDx4MHo+HoKAgw6HO0/z9/SGRSLBnzx60bdsWVlZWcHNzg5ubW6W2AQEBmDVrFjZs2AAul4vBgwcjKSkJy5Ytg6enJ95999161VmdgQMHonfv3li0aBEUCgU6d+6Mf/75B7t3767Udv369XjppZfQq1cvzJ49Gz4+PiguLkZCQgIOHTpk6JMaOnSoYeyfk5MTkpOTsW7dOnh7e6NVq1aNUndVBgwYgLCwMCxevBhFRUXo2bMnbty4gRUrViAkJASTJk2q9zw7dOgAANi6dSusra0hFovh6+vbaNvPswIDA3HmzBkcOnQIrq6usLa2RkBAALp27Yrw8HAEBQVBLpfjzp072L17N7p3717jnm119Ts4OGDZsmVYunQp3njjDYwfPx65ublYtWoVxGIxVqxYYVQTUHkbHzBgAIRCIcaPH49FixZBpVJh06ZNyM/Pr1THpEmTMHHiRMyZMwejRo1CcnIy1q5dW+nQ/+bNm5g/fz4mT55sCK6IiAiMHj0a69atw4IFC57r/a2T+pwFqG6IBSHlZ4q8vLxIq1atiFarJYQQEhsbS1577TXi7OxMBAIBcXFxIf369SObN2+uNM/IyEgyadIkYmdnZzgLEx8fb7SMuLg4MmDAAGJtbU3kcjkZM2YMSUlJqXRWruLs0rPjfwghpKysjMyYMYM4OTkRDodT7TixCj/99BNp06YNEQgEdR4n1rp1ayIQCIijoyOZOHFitePEnjV58mTi7e1dafqzCgoKyLRp04idnR2RSqVkwIAB5O7du1WOE0tMTCTTpk0j7u7uRCAQECcnJ9KjRw+js75ffPEF6dGjB3F0dCRCoZB4eXmR6dOnk6SkpBrrqDg7+euvvxpNr247qepzUSqVZPHixcTb25sIBALi6upKZs+eXe04sWdVdbZs3bp1xNfXl/B4PKOzy8+7/VSsV8X2QgghMTExpGfPnkQqlRqNE1uyZAnp3LmzYYykn58feffdd8njx49reEdrrp8QQrZt20aCgoKIUCgktra2ZPjw4YZhHRVq2sYPHTpEOnbsSMRiMXF3dycffPCB4Yz302dE9Xo9Wbt2LfHz8yNisZh07tyZnDp1yuj9LikpIW3atCHt2rUjCoXCqIa5c+cSgUBQ6Qx8U+AQwuwt23bu3ImpU6ciOjra0M9GURRVV/RSPBRFsRoNMYqiWI3xw0mKoqjnQffEKIpiNRpiFEWxGg0xiqJYjYYYRVGsRkOMoihWoyFGURSr0RCjKIrVaIhRFMVqNMQoimI1GmIURbEaDTGKoliNhhhFUaxGQ4yiKFZrlMtTU5aBEAKlVolSbSlKNaUo1ZZCp9dByBNCzBdDwpdAxBNBzBdDwBUwXS5lIWiIUQCAUk0pHhY+xIOCB0gsTESuKhf5qnzkl+UjX5WPAlUBSjQlIKjblZv4HD5EfBFEPBEkfAnEPDGcpE7wsvaCl40XPKw94GXtBU9rT4j54iZeO8qc0euJWZinw+pBwQMkFCTgYeFDpJek1zmgGhMHHDhJnOBp42kINT87P4Q4h8BebF/7DCiLR0PMzGUqMnEh/QKi0qNw8/FNxsKqIfxs/dCpRSd0btEZnV06w1nqzHRJlAmiIWZmSjWliM6MxoX0C7iQfgFJRUlMl9RoPK09DaHWqUUneFh71P4iyuzREGM5PdEjLjfOsLcVmxMLjV7DdFnNwlXmir6efRHmE4YQ5xBwOfRkuyWiIcZSSYVJ+D3hdxx6cAg5yhymy2Gcs8QZ/b37Y5DvIAQ7BRvudk2ZPxpiLFKqKcWxpGM4kHAA17KvMV2OyXK3cscw/2EY5j+MHnJaABpiLBCTHYPfE37HsaRjUGgUTJfDGhxw0KlFJwxvORyDfQdDxBMxXRLVBGiImag8VR7+SPgDBxIO4GHhQ6bLYT0HsQMmtpuIcQHjYCW0YrocqhHREDMxmYpM7Li1A/vj90OlUzFdjtmxFlhjbJuxmNh2IhwkDkyXQzUCGmIm4lHxI2y7uQ0HHxy0mLOLTBLzxBjRcgSmdpgKNys3psuhngMNMYZllGRgU+wmHHpwCFqiZboci8Pn8DHYdzCmB06Hv50/0+VQDUBDjCF5qjx8d+M7/HLvF6j1aqbLsXgccNDfuz8Wdl4Idyt3psuh6oGGWDNTapXYfms7dt3ehVJtKdPlUM8Q88SYETgDUztMhZAnZLocqg7oEOdmdCH9Akb+MRKbYzfTADNRKp0KG2M24tWDr+KftH+addkXLlwAj8fDoEGD6v3alStXIjg4uPGLYgEaYs2gsKwQ/zn/H7x5/E2klaQxXQ5VB8lFyXjrxFt49/S7yFRkNssyt2/fjnnz5uH8+fNISUlpkmVoNOZ30oiGWBP76+FfGHZgGA4+OMh0KVQDnEg5gWEHhmHbzW1NetZYoVDgl19+wezZsxEeHo6dO3cantu5cyfs7OyM2h84cMDw1aqdO3di1apViI2NBYfDAYfDMbyew+Fg8+bNGD58OGQyGVavXg0AOHToEDp16gSxWAw/Pz+sWrUKWi07TyzREGsimYpMzD05F4v/Xow8VR7T5VDPQalVYv219Rh1cBQuZVxqkmXs3bsXAQEBCAgIwMSJE7Fjxw7Utbt67NixWLhwIdq3b4+MjAxkZGRg7NixhudXrFiB4cOH4+bNm5g2bRqOHTuGiRMnYv78+YiLi8OWLVuwc+dOfPLJJ02ybk2Nhlgj0xM99tzZg+EHhuPco3NMl0M1osTCRMyMnIkvr3wJrb5x91oiIiIwceJEAMCgQYNQUlKCkydP1um1EokEVlZW4PP5cHFxgYuLCyQSieH5CRMmYNq0afDz84O3tzc++eQTLFmyBJMnT4afnx8GDBiAjz/+GFu2bGnUdWou9PLUjSi9JB2Lzy1GTE4M06VQTYSAYMftHbiefR3/1+f/4CJzee553rt3D5cvX8b+/fsBAHw+H2PHjsX27dvRv3//555/586djR5fvXoV0dHRRnteOp0OKpUKpaWlkEqlz73M5kRDrJFEpUdh0blFKCgrYLoUqhnE5MRgzKEx+OSlT9Dbo/dzzSsiIgJarRbu7k/GpxFCIBAIkJ+fDy6XW+nQsj4d9DKZzOixXq/HqlWr8Oqrr1ZqKxaz734HNMQawfZb2/H1ta+hIzqmS6GaUUFZAd4++TamtJ+C+S/MB59b/18nrVaLXbt24YsvvsDAgQONnhs1ahT27NkDf39/FBcXQ6FQGAIpJibGqK1QKIROV7ft74UXXsC9e/fQsmXLetdrimiIPYdSTSmW/bMMkcmRTJdCMeR5Dy8PHz6M/Px8TJ8+Hba2tkbPjR49GhERETh58iSkUimWLl2KefPm4fLly0ZnLwHAx8cHiYmJiImJgYeHB6ytrSESVX3poeXLlyM8PByenp4YM2YMuFwubty4gZs3bxrOXrIJ7dhvoOSiZLz+1+s0wCgATw4v63syJyIiAv37968UYED5nlhMTAySkpLwww8/4K+//kJgYCB++uknrFy5slLbQYMGITQ0FE5OTvjpp5+qXWZYWBgOHz6M48eP48UXX0S3bt3w5Zdfwtvbu161mwr6taMGOJt6Fh/+/SGKNcVMl0KZGA44mB08G7M7zma6FItBQ6weCCHYFLsJm2M3s+a2ZxQzRrUahWXdloHH5TFditmjIVZHOr0OS88vxV+JfzFdCsUSfT36Ym2ftZDwJbU3phqMhlgdaPQaLD63GMeTjzNdCsUyQU5B+KbfN7AT2zFditmiIVYLjU6D986+hzOpZ5guhWKplnYt8d3A7+AocWS6FLNEQ6wGZboyvHP6nWa/JAtlfrysvbBt4Da4WrkyXYrZoSFWDaVWiXmn5jXZF34py+Mqc8W2gdvgZePFdClmhYZYFUo1pZhzcg6uZl1luhTKzDhKHLEjbAd8bH2YLsVs0BB7RrG6GLNPzEZsTizTpVBmyt3KHT8M+YH2kTUSOmL/KQqNArMiZ9EAo5pUWkka5p6ci1INvUR5Y6Ah9i+tXouFZxfiVu4tpkuhLEBcbhwWnl3Y6Ncls0Q0xP61+uJqehaSalbn087jv1H/ZboM1qMhBmDbzW3YF7+P6TIoC/R7wu/4NuZbpstgNYsPsZMJN7Hh+gamy6As2KbYTdgfv5/pMljLokPsVloh3v4+Da05syHmse+KlpT5+DjqY/z96G+my2Alix1ikVtShmEb/0FagRIA0NqzAGrHCOSqchiujLJUEr4EuwfvRoB9ANOlsIpF7olpdHrM3nPNEGAAcD/VDorEufC1phsQxQylVolF5xZBqVXW3pgysMgQ++TPO7icWPlekDkFYsTHvIFAu5cYqIqigIeFD7E2ei3TZbCKxYXYufs52HkhqdrnlWoeoi6+ghCb0c1XFEU95bf7v+Fkct3uOUlZWJ9YYakGA9edRVZRWZ3adwtMQrx+O9R6dRNXRlHGbEW22Dd0H1rIWjBdismzqD2xj/64VecAA4CLN33grFgAuci+CauiqMoKywqx9PxS6Ime6VJMnsWE2MHYdByKTa/36+4k2UOTOg9eVv5NUBVFVe9y5mVsv7Wd6TJMnkWEWFaRCssONPw7kRm5EiTfnIr2dt0asSqKqt0317/BzZybTJdh0iwixD747QYKlXW/7XtVSlR8XL44DCE2wxupKoqqnZZosfjvxVBoFEyXYrLMPsR2RyXh3P3GGcCqJ1ycu9QdgcKZDbplPUU1RGpxKr66+hXTZZgssw6xlNxS/O+vu40+3wux/vBQvQMbYeW7NlNUU/jt/m+Iz49nugyTZNYhtubIHSg1uiaZ980HTuBmzIe7jF4vnWp6OqLDZ9GfMV2GSTLbEItOysORW5lNuozUbBnS4maijW2nJl0ORQHApYxLOJVyiukyTI5ZhhghBKsPxzXLsopLBbh+eRRCbIc0y/Ioy/b5lc+h0T3fSSpzY5Yh9kdMOmIfFTbb8rR6Ls5d7I2OkingcXjNtlzK8qQWp2L3nd1Ml2FSzC7EVBod/u/YPUaWff5aG/ho58NKYMXI8inLsPXGVjxWPma6DJNhdiEWcT7R6BI7zS3mfguIchbARerOWA2UeVNoFPj62tdMl2EyzCrEcorLsOnMA6bLQFKGFR7ffxOtbIKYLoUyU388+ANxuc3T72vqzCrEvjpxHyVlpnELrPxiIW5dGYeOdv2ZLoUyQ3qix+dXPme6DJNgNiGWmleKvdGpTJdhRK3j4nxUfwTLJoLLMZu3mjIR0ZnRiMmOYboMxpnNb9b2fxKh05vmpdH+vtIBLcnbkPKlTJdCmZmImxFMl8A4swixYpUGv155xHQZNbp6xw1WeQvgLHFhuhTKjJx9dBYJ+QlMl8Eos/gW88+XU02mL6wmD9Js4FA8B/5tf8aDItopCwBZv2ch5w/jL+jzbfho83UbAEDhlULkn8mHMkkJXYkO/qv8IfGW1DjP/L/zkRaRVml6u63twBWW/90uuFCAzN8yQcoI5L3kcBn35I+LOkeNpM+T4L/SHzyJaY/7IyCIuBWBNb3WMF0KY1gfYjo9qfGa+aYmt0iIkmuvo3Pn47hRcIbpckyCyF0Enw98DI85XI7h//oyPaStpLB50QbpO+p+UUuuhItWa1oZT/s3wLTFWqTtSIPHDA8InARI/ioZsjYyWAdbAwDSd6WjxZgWJh9gFY4mHsU7L7wDF5ll7uWz/nDyyK0MRseFNUSZhod/ogYhxHosOODU/gIzx+FyILATGH74Nk/+tsp7yuE83BlW7eo/gPjpeQrsBIbp6hw1eBIebLvaQuonhaytDKp0FQCgIKoAHD4Htp3Zc4USLdFi7729TJfBGNaHWMT5RKZLaLBzl0PQhjcbIgu/+3hZVhnuLriLe+/fQ+q3qVBnP/+NWfRletxbeA93372L5K+SoUx+8odO1EIEvVoPZbIS2hItlIlKiD3F0JZokf17Nlwnuj738pvbvvv7UKar+/0jzAmr73Z0NTkfozZdYLqM5xbglY8yhwjkqizvqyTFN4qhL9ND5CKCtkiL7IPZUGeo0fJ/LcG3erJHps5R4/4H9+vUJ1aaUAp1thoiDxH0Sj1yj+ei+EYxWv63JUQuIgBA0dUiZP2eBaImsO1uixYjW+BRxCOIPcWQeEuQsScDREfgPMIZti+yY6/svz3+i5GtRjJdRrNj9Z5YxPmHTJfQKO6lyKFMehs+1q2ZLqXZWQdZw/ZFW4g9xbBqbwWf93wAAAXnCxo8T2lLKex62EHiJYEsQAbPOZ4QtRAh90SuoY1NJxu0Wt0Krde2RouRLVBypwRlj8pg38ceqZtS4TrBFV5veyFtexq0RaZ/0ggAfrr7E9MlMIK1Ifa4pAzHbmcxXUajycoX40HsZHSw68l0KYziirgQeYqgzmq8e31yuBxIfCXVzlOv0SNjdwbcJrtBna0G0RHI2sggchVB5CJC6YPSRqulKd3Ju4Pbj28zXUazY22IHbmVabKDWxuqtIyHixfDEWLzKtOlMEav0aMsvQx8u8Y7cU4IgSpVVe08cw7mwCrQChIfCYieAE/d6pFojR+bumPJx5guodmxNsT+vFH/e0iyASEcnLvUBe0Fb0LAFdT+ApbL+DkDirsKqHPUKH1QitSNqdAr9bDraQcA5R3vyUqUpZd3Wqsz1VAmK6EpeHJhwEdbHyHz1ydX8c0+kI3im8VQZ5e3TdueBmWKEvahlW+CrEpTofByIVq8Wn6nbZGrCOAAeWfzUBxTjLKMMkj8au6DMyXHk44zXUKzY+U4sexiFS4n5jFdRpO6eMMX7XwXoNh2GwrK8pkup8lo87RI3ZwKXbEOPGsepP5S+C3zg9BRCAAovl5sNHA1dVP592Odhjuhxcjy4FHnqvH0SBVdqQ7pO9OhLdSCK+FC4i2B34d+kPoZf+2LEIL0HelwGe8Crqj87zlXyIX7DHdk7M4A0RC4TnKFQM6ePyaPSh4hLjcO7RzaMV1Ks2Hl2cnvLyRhxUHLOPZ3cyyFne9upJawdygJ1bymd5iOBZ0WMF1Gs2Hl4eSfNzKYLqHZpD+WIvXmdLSz68J0KRRLRCZHMl1Cs2JdiGUVqXAl2bwPJZ9VrOLjyqWRCLEdxnQpFAukFqfiTu4dpstoNqwLsb9uZsDMTkrWiU7PwbmLPRAomg4+h5VdmVQzsqS9MdaF2GELOpSsyoWYVvBUz4e1wIbpUigTFplEQ8wkZRercC3FfM/U1dWNBGfws96Bm9ST6VIoE5VSnIK7eXeZLqNZsCrELifmgX3nUptGSpYMGXdnIcA2hOlSKBN1OuU00yU0C1aF2JUkuhf2tCKFADGXxyDYbhDTpVAmKCYnhukSmgWrQszcB7g2hFbPxd9RfdFR+ga9+zhl5GbOTbBwGGi9sSbEilUa3M0sYroMk3X+ajv46uZBRu8+Tv2rWFOMBwXM34e1qbEmxK4m51vk0Ir6uH7PBZLH78BF6sZ0KZSJiM2JZbqEJseaEKP9YXWTmG6N3PtvoZVNINOlUCaAhpgJuZxE+8PqKq9YiFtXxqOj3ctMl0IxjIaYiVBr9YhNLWC6DFYpv/v4AARbTaA3I7FgiYWJKCwrZLqMJsWKELuZVogyLYuuTGdC/o4OQmvOXEj47LkmFtV4CAhu5NxguowmxYoQi0s3778kTe1KnAds8xfAUeLMdCkUA8z9kJIVIZaUy45rnJuy+Ee2KHkwB37WbZkuhWpmdE/MBCTnKpguwSzkFIpxL2YiAu16M10K1YySi5KZLqFJsSLE6J5Y41GpeYi6OBgh1mOYLoVqJtml2dDpdUyX0WRMPsT0eoKUPBpijYkQDs5d7oS2vDkQ8URMl0M1MS3RIkeZw3QZTcbkQyyzSAU1PTPZJC7f8oJj8QLYixyYLoVqYhkK870On8mHWBLtD2tSd5PlKEt+G95WLZkuhWpCGSU0xBiTTPvDmlxmvgSJN6agvV13pkuhmki6wjzv0wqwIMTonljzUJTxcfniUITYjGC6FKoJZCoya2/EUiYfYqm0U7/Z6AkX5y51QwfhTIu4+7glSS+he2KMyVdoam9ENaqoWH+4Kd+BrdCW6VKoRkI79hlUqtYyXYJFuvXQEST9HXjIfJguhWoENMQYVKo230F6pi4tR4pHt6ejre2LTJdCPSeFRoFSjXl2zdAQo2pUrBTg6uVXEWIbznQp1HNS6VRMl9AkTD7EFPRwknHldx9/CUHiqfTu4yxWpi1juoQmYfIhRvfETMc/1wPgpZkPK4E106VQDUD3xBig1enpV45MTGy8MwTZ78BV6sF0KVQ9lenonlizU9C9MJOUkmmFrHtvorVtMNOlUPVAQ4wBShpiJquwRIAb0a8h2C6M6VKoOtIT8zyqMe0Q09AQM2UaHRd/R4Wik9UEpkuhLJhJhxifS+/SwwZnooPQ32Y002VQFsqkQ0zEN+nyqKccvPwCRsmHMF0GZYFMOiVEfB7TJVB1pCNc/B7dA5PsQ5kuhbIwph1iApMuj3pGoYaP4zG9MU3eg+lSqCqY671HTTolxAIeOLRbjFXiFRLE3OuFGXadmC6FeoZcJGe6hCZh0iEGAFZC+jUXtjmbK0duck/MsOvIdCnUU+zF9kyX0CRMPsRsJPTifGy0K90NNpnBmG4XxHQpFABrgTUEPPP8XaIhRjWZVYltEfzYC1PtApkuxeLZS8xzLwxgQ4iJ6eEkm02JfwlDH0vxBt0jY5S5HkoCLAgxuVTIdAnUcxryYASmZRZjIg0yxphrpz7AghDztDfP08KWRKPnYFDaNMxPScIEOQ0yJtDDSQb5OMqYLoFqBDlqAV4tXIAP4q9jrJz2kTU3uifGIF8HGmLm4k6JFHPIh1h6+zzG0CBrVg4SB6ZLaDImH2LedE/MrEQ+tsen1h/io9jjGEWDrNk4iGmIMcbNVky/CG5mtj7ywt4WC7Hi+hGMoEHWLHxtfZkuocmYfDpwOBx4O0iZLoNqZB8+DMQlj+lYdf0IhtEga1JCrhB+dn5Ml9FkTD7EAMCH9ouZpXHxoUhxH4qPrx9BuLwD0+WYLX87fwi45jtonB0hRvvFzNbgxNEoatENq68fw2AaZE0iwD6A6RKaFDtCjO6JmS2ljofBmbOglbfEmuvHECZvz3RJZqeNfRumS2hSrAixVi2smC6BakIZKiHGKxYCUkd8GnMcA2iQNaoAOd0TY1yQhy2E9AylWbtWaIUFvKXg8UVYG3McL8vbMV2S2aCHkyZAxOeho4ct02VQTexQthO+tFsKHiH4v5iTCKVB9tzcrdxhLTTvO7azIsQA4EUf8/3uF/XEhhRf/OH+LgR6Db6IPYU+dm2ZLonVzP1QEmBRiHXxpSFmKRYkvIBrnlMg0Knx5Y0zeMnOvDumm5K5d+oDLAqxTt5y8Oh9KC3GqIQBeOQxBEJdGdbfOIueNMgapKOz+V8inDUhZi0WoK2reR/bU08QwkFY0ngUOb9YHmQ3z6G7nfkfGjUmKV+KF1u8yHQZTY41IQbQfjFLo9DyEJ4zG2o7f4i0Knx96zy62rVmuizW6ObazWyvq/80VoVYV9ovZnFSlGJMUn0AvdQRYo0SG25fQBdbGmR10dujN9MlNAtWhRjdE7NMlwpssFi4FIQvgURdig1xUehk24rpskwaBxwaYqbIwUqEjp52TJdBMeDXTBdsclgCwuFCqlbg2zuX8IJtS6bLMllt7NvASerEdBnNglUhBgBDg1yZLoFiyNrkVjjmPg8AIC0rwbd3ohFs489wVabJUvbCABaG2CtBruDQkRYW662ErrjtOQEAICsrxqZ7VxFkY77XymqoPh59mC6h2XAIIYTpIuprzOYLiE7KZ7qMeiuM+gUF53bButMw2PefBQBI/iy8yrZ2fafCtuuoKp8ruXkCuX+tqzTda+F+cPjlt7gruX0aBWe/B9GoYBU0EPLQaYZ22sIsZO1dBtfJ68AVse+CkzyOHv/4fg+X9OMAgGKxLWYFBONWUSLDlZkGe7E9zrx2BhwL+WvPyjvThge5sS7EyjLuozj2GAROPkbTPebuNnqsfHgFuUe+hjSgZ43z4wilcJ+5xXjavwGmKy1E3tENcBiyAHw7F2T/tgoir0BI/cvHDOUe+xbyPlNMNsBUqbdQdGkf1FkPoCvJg9PI/0DaurvheR3hIix1Ei645ECWEwNrVSEmHb2IiSfUKEgpAl/Oh9NgJ9j3e3IiqORWCdJ3p0NbpIXNCzZwm+oG7r8XFdCV6vBg1QP4LPKB0IH99znt5d7LYgIMYOHhJAAMCXRl1eh9vVqJx4c+h8OgeeCKjS8rxLOSG/2UJlyC2DsQAjuXmmfK4VR6bQVtQSY4IilkbXtD5NoaYq8gaB6nAAAUcWfA4fEhDejR6OvZWIhaBYGzH+z7v1Vtm0INHyPy5kFj443EfD3G7MjBWFc9Bn7RC07hTsjYk4HC6MLy+ekJUrekwj7UHn4f+UH5UIn8M0/+CGb+kgn7UHuzCDAACPUKZbqEZsXKEHOyFrFqzFje8U2Q+L8IiU9wje10inwoH0TDKmhgrfMkaiUebZqKR99MRvZvq6DOemB4jm/vDqIpK9+TURZDnXEfQicf6JTFKPh7D+wHVB8OpkDi3xny3pNqDdp4hQQzdIuwKYYLL1suNvXnYK8qGd3DQ2DXyw6Pjz4GAOhKdNAV62Dfzx5idzGsQ6xRll4GAFDEK6BMUsJhoHncDchebG9RnfoAS0MMKD+kZANF3FmoMx9A3mdyrW1Lbp0EVyiBtHXNv7wCew84vPIunEctg+OwD8DhCZD5wyJo8tIAADyxFRxfeRePD3+JzF3vQdahHyR+nZB/OgLWncKhLcxC+o75SI+YA8Xd842ynkw5myvH3rQWGNBSBACwLc3Hdw/i0PpFXyiTlCBaAp41D3w7Pkpul0Cv1kNxXwGxpxh6rR7p36fDfbI7OCzas6/JMP9hZn09/aqwsk8MAAZ3cMHyP25Bqzfd8xLaohzknfwOLcb+19BfVZOSGycga9e31rYi9zYQuT/5QrTIox0ydr6D4muHYd//TQCAtHUPozBUpdyAJicZ9gPeQvrWWXAc+gF4Mjkydr0HsWcH8GR2DVtJE5Cep0Bahz4giAIHBHJFLlYqyjBYB2hLtBDYCeA5xxOZP2UiY08GrIOsIe8lR86fObBqZwWOkIOHqx9CW6KFQ38HOPRn717ZyFYjmS6h2bE2xOQyIfq1cUZkXBbTpVRLnZkAfWkBMnYueDKR6FGWehvF1w7D6/3fweHyAJR3ZmvzHsFq+KJ6L4fD4ULk0gqavPQqnydaDfIiN8EhfCG0+Rkgeh3EXuW3SRPYu6Ms4x6kLbvWe7mm5FS+M856zkbf1G8BANbKAgCAt8wN6ciBrLUM/iuejCkryyxDwYUC+K/yR+KaRDgMdIB1oDXi/xMPWYAMYk8xE6vxXIKdguFna3nDTVgbYgAwo5efSYeY2LsjXKdtNJqW+9d6CBw8YNN1lCHAAKDkxnEIXVpC6Fz/jZAQAnV2IgRO3lU+X3DhZ4j9OkHk0rK870yve/JavRbQ6+u9TFPCk8mhU+RjSvxrON4qG61Sf0O2goDPBXbmpWKWnz+SFGmG9oQQpO1Ig8s4F4AAqmQVbDvbgiviQhYgg+KugpUhNqp11UNyzB1r+8SA8gslmvJlq7kiKYROPkY/HIEIXLE1hE8NtdCXlaL03vlqO/QfH/4C+Wd3Gh4XnP8RyodXoSnIhDrrIXKPrIc6+yGsgwdXeq06Jxmld8/B7qWJAAC+vQfA4aI4NhKlD6KhyX0EoSu7v4cocm8DVVIMAGDIg5HIde2DyAdadHbjwbU0G9tTEuEje9KHmn8uH3wrPmxCbIB/85voiOFfYsJdFNWRi+QY7Fv587cErN4TA8r3xub9dJ3pMp6L4s45gACydlWPstYW5QCcJ39v9GUK5B7bCJ0iH1yRDEJnP7hM+BQiN+PrbRFCkHdsI+T9ZoIrLN+z4ApEcBiyAHnHN4HoNLAf8Bb41o5Nt3INoFcroc3PMDzWFmZBnfUQXIkV+DbOyD+7E7riXDiGLwQAWAUPRvG1w8g7+R2sOw5C51teSIvR4qdXy9fZqSgTEakcTPXwwsPMVOQczIHfR+V7vDwZDyI3EXIjc2HVwQqKOwo4DWXfdw5HtR4FEU/EdBmMYOWI/afp9AS9155GWoGS6VKoRqJKuYGsn5ZWmi7r8HL5Wdc/v4K2MAsuEz596jU3kX9qG9SPk8GzckBA76GI7fMP+MVPDiMz7dzxwq95gB/XqPO+9GEp0r5Lg7ZIC4eBDnAe7ty0K9jI+Bw+jow6AhdZLWMLzRTrQwwAtv39EKv/vMN0GZSJGeiYhy2apeCUFRmmZdp5YIq7K9JKTbcvtb4GeA/Al32/ZLoMxrC6T6zC2Bc9YS1i/ZEx1cgiH9tjjfVSkKfGTbkUPML29Cy4Sdi1t1WTye1rH4NozswixKzFAozr4sl0GZQJ2vrICz+7vG80zS0/BRGZ2XCVsK/v61l9Pfuio5P53wykJmYRYgAwtacv+GYy6ppqXB8+DMRFz5lG0zzyUhCR9RgtJKZ1UqM+uBwu3gl5h+kyGGc2IeZmJ8GoFzyYLoMyUePiQ5HkMdxommduMrZn58NZzM4gC/cLR0s5vbqt2YQYACwMaw2ZkFd7Q8oiDU4cjQIX4++lej1ORMTjQjiJ2XNBAQAQcAWYGzyX6TJMglmFmLO1GG/1oZcrpqqm1PEwOHMWyuyNx9P55DxAxONiOIrYE2SvBbwGNyt2XAShqZlViAHAzN5+cLNl31dGqOaRoRJivGIhdLIWRtN9cx4gIk8Be5G8mleaDilfillBs5guw2SYXYiJBTwsHkxveU9V71qhFRbwloIIZUbT/bLjEZGvgr3IjpnC6uiN9m/AnmWHv03J7EIMAIZ1dEMwvbUbVYND2U740m4pCMe4D7Vl1j18l6+GXGia38mVi+SY0n4K02WYFLMMMQ6Hg2XhbZkugzJxG1J88Yf7u5Wmt866i+8KdbAzwSCbGTQTMoGs9oYWxCxDDAA6edsjnN6jkqrFgoQXcM1zSqXpAZlx2Fqkg43QuvmLqkZ7h/aY0GYC02WYHLMNMQBYMrgNxAKzXkWqEYxKGIBHHkMqTW+bEYetxRxYC6yqeFXzEnKFWN1zNXhcOoToWWb9G+4hl2LJINrJT9WMEA7CksajyPnFSs+1T7+FrQoe40E2O3g2HdhaDbMOMQCY3MMHvVqxc0Q21XwUWh7Cc2ZDbVd5nGGHtJvYXCqAFUN9UYGOgZjafiojy2YDsw8xDoeD/xvdEbYSy7oDDFV/KUoxJqk+gF5a+Y9e0KNYbFKKIOM37w2H6WFk7cw+xADAxVaM1SM6MF0GxQKXCmywWLgUhC+p9Fxwagw2qSSQNmOQzQmeAz87y7v5R31YRIgBwNCObhjWkX5Ng6rdr5ku2OSwBIRT+dcjJPU6vlHLIKki5BpbkGMQHRNWBxYTYgDw8YgOcKVfSaLqYG1yKxxzn1flc52Tr+IbjQ0kvKbblkQ8ET5+6WN6GFkHFhVithIBPh/TERx62TGqDt5K6IrbnlWPy3oxKRobdLYQN9HNOeaFzLPIe0g2hEWFGAD0bOmIqT18mS6DYolhCUOQ6Tagyue6JkZjvc6+0e8yNNh3sMVfcro+LC7EAODDIW3QzY9+gZaqnY5wEZY6CQqn4Cqf75F4Cev1DhByhY2yvA4OHfBxz48bZV6WwiJDTMDjYvPETvB1pN9Bo2pXqOFjWO48aGyqvsN6z4cX8RWcIeA+3zAeZ4kz1vdbb7H3j2woiwwxALCTChExuTMdP0bVyYNSCaZrF0Mvrvp6Y70fXMBXHJcGB5mIJ8L6fuvhLDWfuzA1F4sNMQDwc7LCptdfgIBHe/qp2p3Ls8MK6VKQavaU+iT8gy+4ruBz63/7wP/2+C86ONKxjA1h0SEGAD1aOuLj4XTjoepmd7o7djgvAkHVf/hC48/jc647+Jy6B9nMwJkY4lf5C+hU3Vh8iAHAuC5emPESPWNJ1c1/E9vijOecap9/Of5vfCbwqFOQ9fPsh3khVY9Ho+qGQwghTBdhCvR6glm7r+DEnWymS6FY4nir39Eq9ddqnz8a0AdLNCnQEV2Vz7eWt8buwbshFTTv9zHNDd0T+xeXy8H6cSHoSC9rTdXRkAcjkOvap9rnB907i/8JfcDjVB5172Pjgy0DttAAawQ0xJ4iE/Gxe3oXBHmY3mWJKdOj0XMwKG0alDV0yA+5exqrhb7gPvU9TE9rT2wbuA2OLL77uCmhIfYMG7EAu6d1RXs3G6ZLoVggRy3AqwULoLV2r7ZN+N1T+FjkDy6HC3crd2wP244Wz9wyjmo42idWjYJSNSZ8dwlxGUVMl0KxwADHPGzVLAWnrPrt5cgLoxDU72O4W1UfeFT90RCrQWGpBm/suIzY1AKmS6FYYIZHKv6T9xE4ek3lJ+28gcmHAHnVo/6phqOHkzWwlQqwZ0ZXdPWl37OkarftkSd+cnm/8hOOAcC0ozTAmohFhNi5c+cwdOhQuLm5gcPh4MCBA3V+rZWIj++ndUGf1k5NVyBlNpY+DESU56wnE9w7lQeYDb0gZ1OxiBBTKBTo2LEjNm7c2KDXiwU8fPdGZ4wMoX0ZVO3Gx/dFoscIoOWA8kNIKd2Tb0oWEWKDBw/G6tWr8eqrrzZ4HkI+F1+NDcaHg9uAS79qSdVit9N7wPifAWHdrpRS09GCRqPB4sWLERgYCJlMBjc3N7zxxhtIT083mkdZWRnmzZsHR0dHyGQyDBs2DI8ePTJqk5+fj0mTJsHW1ha2traYNGkSCgoKDM/v3LkTHA6nyp/s7PKB4CqVClOmTEFgYCD4fD5GjBhRaX3OnDlT5Tzu3r1raHP79m2MGjUKPj4+4HA4WLduXZ3eq2dZRIg1pjf7+GPH1C6wEdf/S76U+eNxOVge3g7Lh3cEeHXfRmo6WigtLcW1a9ewbNkyXLt2Dfv378f9+/cxbNgwo3YLFizA77//jp9//hnnz59HSUkJwsPDodM9+cbAhAkTEBMTg6NHj+Lo0aOIiYnBpEmTDM+PHTsWGRkZRj9hYWHo06cPnJ3Lr7Ch0+kgkUgwf/589O/fv8b1unfvntG8WrVqZbRefn5++PTTT+Hi4lLn9+pZFnd2ksPh4Pfff6/yr0d9JD5WYOauK0jILmmcwijWsxLxsWF8CELbPN/ldOqyjUZHR6NLly5ITk6Gl5cXCgsL4eTkhN27d2Ps2LEAgPT0dHh6euKvv/5CWFgY7ty5g3bt2uHixYvo2rUrAODixYvo3r077t69i4CAgErLycnJgbu7OyIiIozCrsKUKVNQUFBQqZ/5zJkzCA0NRX5+Puzs7GpdZx8fHyxYsAALFiyote2z6J5YA/k6ynBgbk/0b0uv/0QB/k4y7Jvd47kDrK4KCwvB4XAMAXH16lVoNBoMHDjQ0MbNzQ0dOnTAhQsXAABRUVGwtbU1BBgAdOvWDba2toY2z9q1axekUilGjx7doDpDQkLg6uqKl19+GadPn27QPGpDQ+w5WIn4+O6Nzng7lN5e3pKN7+KFw/N6IcDFulmWp1KpsGTJEkyYMAE2NuXfLMnMzIRQKIRcbnzRxhYtWiAzM9PQpuKQ8GnOzs6GNs/avn07JkyYAImkfreoc3V1xdatW7Fv3z7s378fAQEBePnll3Hu3Ll6zacuaMfOc+JwOHg/LADt3GywZN8NFKm0TJdENRO5VIBPRwUhrH3D+3PqS6PRYNy4cdDr9fj2229rbU8IAeep23txqrjV17NtKkRFRSEuLg67du2qd50BAQFGh6fdu3dHamoqPv/8c/Tu3bve86uJReyJlZSUICYmBjExMQCAxMRExMTEICUlpdGWMSTQFZHv9kFoAB1PZgm6+zngyDu9mz3AXnvtNSQmJuL48eOGvTAAcHFxgVqtRn5+vtFrsrOz0aJFC0ObrKysSvPNyckxtHnatm3bEBwcjE6dOjVK/d26dUN8fHyjzOtpFhFiV65cQUhICEJCQgAA7733HkJCQrB8+fJGXY6LrRg7pnbB2tFBsKZnL82SgMfBokEB2DOjK1ya8UbMFQEWHx+PEydOwMHBwej5Tp06QSAQ4Pjx44ZpGRkZuHXrFnr06AGgfG+osLAQly9fNrS5dOkSCgsLDW0qlJSU4JdffsH06dMbbR2uX78OV1fXRptfBYv4Tevbty+a8yTsa5090buVE5bsv4Ez93KabblU0/J1lGH9uGAEedg1+rxLSkqQkJBgeFxxtGBvbw83NzeMHj0a165dw+HDh6HT6Qx9WPb29hAKhbC1tcX06dOxcOFCODg4wN7eHu+//z4CAwMNwyDatm2LQYMGYebMmdiyZQsAYNasWQgPD690ZnLv3r3QarV4/fXXq6w3Li4OarUaeXl5KC4uNhzlBAcHAwDWrVsHHx8ftG/fHmq1Gj/88AP27duHffv2GeahVqsRFxdn+H9aWhpiYmJgZWWFli3r3s9scUMsmtsvV1Lx8eE4FNO+MtYS8riY+pIP5vdrBZmoaf7uVwxJeNbkyZOxcuVK+PpWffn006dPo2/fvgDKO/w/+OAD/Pjjj1AqlXj55Zfx7bffwtPT09A+Ly8P8+fPx8GDBwEAw4YNw8aNGysNg+jRowd8fX2xZ8+eKpfr4+OD5OTkStMr4mTt2rXYunUr0tLSIJFI0L59e3z44YcYMuTJvQSSkpKqXK8+ffrgzJkzVS63KjTEmkFGoRJL9t3E2ft0r4xtQgOcsHxoe3qPUhNGQ6wZHb2VgbVH7+HhYwXTpVC18HWUYXl4u2Yb90U1HA2xZqbV6bH3SirWnYhHTnEZ0+VQz7AS8fF2v5aY1tMXQr5FnPdiPRpiDClVaxHxdyK2nnuI4jLaX8Y0DgcYGeKOJYPawNmm+c46Us+PhhjD8hRqfH0yHj9eSoFap2e6HIvD5QCDO7hidl9/dHCnN4hhIxpiJiIltxRfHr+HwzcyoNXTj6SpCflcjHrBA7N6+9FOe5ajIWZiMgtV2HMpGT9dTsHjEjXT5ZgdazEfE7t5Y2pPHzhb08NGc0BDzESVaXU4HJuB76OScONRIdPlsJ6ztQjTXvLF6129YC0WMF0O1YhoiLHAtZR8fH8hCX/dzIBGRz+uuuJxOejh74ARwe4I7+gKEb/ynbgp9qMhxiLZxSr8fDkVh2LTEU8vxlitQHdbDA92w7BgN3rIaAFoiLFUQnYJjt3OxNFbmbiZRg83Pe0lGN7RHSNC3NHS2YrpcqhmREPMDKQVKHH0ViaO3crEleQ8WMrJTT8nGXq1dMTQjm7o7EPvKGSpaIiZmcclZYi8nYXzCTm4llyAzCIV0yU1Gk97CXr4OaK7vwN6+DvQQakUABpiZi+9QInrKQW4lpKP6yn5uJVeBLWWHYNqXWzE6OHvgG7/hpaHXMp0SZQJoiFmYdRaPW6nF+JaSgFiUguQnKvAo3wl8hTMjUlrYSNCS2crtHSygv+//7Z0tqJ7WlSd0BCjAJR/l/NRvhKP8kv//bf8/2n5SqQXqlCi0kKl1aGuWwuHU/5lahuxALYSAWwk/PJ/xQI4Wovg/29Q+TvJ6Lgt6rnQEKPqjBCCUrUOCrUWKrUeWr0eekKg1RPo/j2bYCMuDyprMR9ceqt0qhnQEKMoitXoBZMoimI1GmIURbEaDTGKoliNhhhFUaxGQ4yiKFajIUZRFKvREKMoitVoiFEUxWo0xCiKYjUaYhRFsRoNMYqiWI2GGEVRrEZDjKIoVqMhRlEUq9EQoyiK1WiIURTFajTEKIpiNRpiFEWx2v8Dz26FQMIdIk0AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "outlier_detection(directory_path = \"101\", coupure = 2)" - ] - }, - { - "cell_type": "markdown", - "id": "dbebfa92-310a-417b-a7fa-36ac3593db06", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## Evolution des commandes" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "06137694-7f50-47ba-8749-68471ececc1e", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_448/3643128924.py:11: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - " purchases = pd.read_csv(file_in, sep=\",\", parse_dates = ['purchase_date'], date_parser=custom_date_parser)\n", - "/tmp/ipykernel_448/3643128924.py:19: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", - " campaigns = pd.read_csv(file_in, sep=\",\", parse_dates = ['sent_at'], date_parser=custom_date_parser)\n" - ] - } - ], - "source": [ - "# Importation - Chargement des données temporaires\n", - "company_number = \"1\"\n", - "nom_dataframe = 'df'+ company_number +'_tickets'\n", - "purchases = globals()[nom_dataframe].copy()\n", - "\n", - "campaigns = display_databases(company_number,'campaigns_information', ['sent_at'])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e6b962d4-1a30-4133-ac0f-359f7afef42c", - "metadata": {}, - "outputs": [], - "source": [ - "# Mois du premier achat\n", - "purchase_min = purchases.groupby(['customer_id'])['purchase_date'].min().reset_index()\n", - "purchase_min.rename(columns = {'purchase_date' : 'first_purchase_event'}, inplace = True)\n", - "purchase_min['first_purchase_event'] = pd.to_datetime(purchase_min['first_purchase_event'])\n", - "purchase_min['first_purchase_month'] = pd.to_datetime(purchase_min['first_purchase_event'].dt.strftime('%Y-%m'))\n", - "\n", - "# Mois du premier mails\n", - "first_mail_received = campaigns.groupby('customer_id')['sent_at'].min().reset_index()\n", - "first_mail_received.rename(columns = {'sent_at' : 'first_email_reception'}, inplace = True)\n", - "first_mail_received['first_email_reception'] = pd.to_datetime(first_mail_received['first_email_reception'])\n", - "first_mail_received['first_email_month'] = pd.to_datetime(first_mail_received['first_email_reception'].dt.strftime('%Y-%m'))\n", - "\n", - "# Fusion \n", - "known_customer = pd.merge(purchase_min[['customer_id', 'first_purchase_month']], \n", - " first_mail_received[['customer_id', 'first_email_month']], on = 'customer_id', how = 'outer')\n", - "\n", - "# Mois à partir duquel le client est considere comme connu\n", - "known_customer['known_date'] = pd.to_datetime(known_customer[['first_email_month', 'first_purchase_month']].min(axis = 1), utc = True, format = 'ISO8601')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9c56e5ac-cbf4-4343-80ba-be2ab8b60eab", - "metadata": {}, - "outputs": [], - "source": [ - "# Nombre de commande par mois\n", - "purchases_count = pd.merge(purchases[['customer_id', 'purchase_id', 'purchase_date']].drop_duplicates(), known_customer[['customer_id', 'known_date']], on = ['customer_id'], how = 'inner')\n", - "purchases_count['is_customer_known'] = purchases_count['purchase_date'] > purchases_count['known_date'] + pd.DateOffset(months=1)\n", - "purchases_count['purchase_date_month'] = pd.to_datetime(purchases_count['purchase_date'].dt.strftime('%Y-%m'))\n", - "purchases_count = purchases_count[purchases_count['customer_id'] != 1]\n", - "\n", - "# Nombre de commande par mois par type de client\n", - "nb_purchases_graph = purchases_count.groupby(['purchase_date_month', 'is_customer_known'])['purchase_id'].count().reset_index()\n", - "nb_purchases_graph.rename(columns = {'purchase_id' : 'nb_purchases'}, inplace = True)\n", - "\n", - "nb_purchases_graph_2 = purchases_count.groupby(['purchase_date_month', 'is_customer_known'])['customer_id'].nunique().reset_index()\n", - "nb_purchases_graph_2.rename(columns = {'customer_id' : 'nb_new_customer'}, inplace = True)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "8c1aed44-03d3-49f9-b96c-b06a0df03dde", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Graphique en nombre de commande\n", - "purchases_graph = nb_purchases_graph\n", - "\n", - "purchases_graph_used = purchases_graph[purchases_graph[\"purchase_date_month\"] >= datetime(2021,3,1)]\n", - "purchases_graph_used_0 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==False]\n", - "purchases_graph_used_1 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==True]\n", - "\n", - "\n", - "# Création du barplot\n", - "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_0[\"nb_purchases\"], width=12, label = \"Nouveau client\")\n", - "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_1[\"nb_purchases\"], \n", - " bottom = purchases_graph_used_0[\"nb_purchases\"], width=12, label = \"Ancien client\")\n", - "\n", - "\n", - "# commande pr afficher slt\n", - "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b%y'))\n", - "\n", - "\n", - "# Ajout de titres et d'étiquettes\n", - "plt.xlabel('Mois')\n", - "plt.ylabel(\"Nombre d'achats\")\n", - "plt.title(\"Nombre d'achats - MUCEM\")\n", - "plt.legend()\n", - "\n", - "# Affichage du barplot\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "d312276c-4c46-4d29-b6d6-ed110f59890d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# graphique en nombre de client ayant commandé\n", - "purchases_graph = nb_purchases_graph_2\n", - "\n", - "purchases_graph_used = purchases_graph[purchases_graph[\"purchase_date_month\"] >= datetime(2021,4,1)]\n", - "purchases_graph_used_0 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==False]\n", - "purchases_graph_used_1 = purchases_graph_used[purchases_graph_used[\"is_customer_known\"]==True]\n", - "\n", - "\n", - "# Création du barplot\n", - "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_0[\"nb_new_customer\"], width=12, label = \"Nouveau client\")\n", - "plt.bar(purchases_graph_used_0[\"purchase_date_month\"], purchases_graph_used_1[\"nb_new_customer\"], \n", - " bottom = purchases_graph_used_0[\"nb_new_customer\"], width=12, label = \"Ancien client\")\n", - "\n", - "\n", - "# commande pr afficher slt\n", - "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b%y'))\n", - "\n", - "\n", - "# Ajout de titres et d'étiquettes\n", - "plt.xlabel('Mois')\n", - "plt.ylabel(\"Nombre de client ayant commandé\")\n", - "plt.title(\"Nombre de client ayant commandé un ticket pour l'offre 'muséale groupe'\")\n", - "plt.legend()\n", - "\n", - "# Affichage du barplot\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "82895dfc-e5ca-4be0-af24-93c1be8f6248", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## Proportion de tickets de prix 0" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "10828dd8-8ec9-49eb-b450-acca741964c7", - "metadata": {}, - "outputs": [], - "source": [ - "barplot_prop_free_price = pd.DataFrame()\n", - "for company_number in ['1', '2', '3', '4', '101'] : # \n", - " nom_dataframe = 'df'+ company_number +'_tickets'\n", - " df_tickets = globals()[nom_dataframe].copy()\n", - " df_free_tickets = df_tickets[df_tickets['amount'] == 0 | df_tickets['amount'].isna()]\n", - "\n", - " if company_number == '101' :\n", - " df_free_tickets_1 = df101_tickets_1[df101_tickets_1['amount'] == 0]\n", - " nb_tickets = len(df_tickets) + len(df101_tickets_1)\n", - " nb_free_tickets = len(df_free_tickets) + len(df_free_tickets_1)\n", - " \n", - " graph_dataframe = pd.DataFrame({'company_number' : [company_number], \n", - " 'prop_free_tickets' : [nb_free_tickets / nb_tickets],\n", - " 'nb_tickets' : [nb_tickets]})\n", - " \n", - " else : \n", - " graph_dataframe = pd.DataFrame({'company_number' : [company_number], \n", - " 'prop_free_tickets' : [len(df_free_tickets) / len(df_tickets)],\n", - " 'nb_tickets' : [len(df_tickets)]})\n", - "\n", - " barplot_prop_free_price = pd.concat([barplot_prop_free_price, graph_dataframe])" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "065576ef-2515-43eb-a65d-21f07f228c9e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "barplot_prop_free_price\n", - "\n", - "df = barplot_prop_free_price.sort_values( by = 'prop_free_tickets')\n", - "\n", - "# Création du barplot\n", - "plt.figure(figsize=(10, 6))\n", - "plt.bar(df['company_number'], df['prop_free_tickets'])\n", - "plt.xlabel('Numéro de la société')\n", - "plt.ylabel('Proportion de billets gratuits')\n", - "plt.title('Proportion de billets gratuits par musée')\n", - "plt.xticks(df['company_number'])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d6de664a-a303-48f5-bca6-1e9e9d17c461", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## Répartition des prix de vente" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "150825c6-08b5-44ad-a02e-98ee44192d94", - "metadata": {}, - "outputs": [], - "source": [ - "boxplot_amount = {} \n", - "\n", - "for company_number in ['1', '2', '3', '4', '101'] :\n", - " nom_dataframe = 'df'+ company_number +'_tickets'\n", - " df_tickets = globals()[nom_dataframe].copy()\n", - " df_notfree_tickets = df_tickets[df_tickets['amount'] > 0]\n", - " \n", - " boxplot_amount[company_number] = df_notfree_tickets['amount']\n", - "\n", - "amount_df = pd.DataFrame(boxplot_amount)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "c6ce46c8-5ad1-42c0-9b9a-a84df52a3411", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
1234101
count1.062722e+061.475197e+063.051426e+061.280045e+061.133556e+07
mean1.076436e+011.519766e+011.285360e+011.139475e+011.350509e+01
std9.243106e+005.714467e+001.445236e+011.657010e+011.492325e+01
min2.500000e+005.000000e+003.000000e-011.000000e+002.000000e-02
25%9.500000e+001.300000e+016.000000e+006.000000e+001.000000e+01
50%1.100000e+011.500000e+011.350000e+011.000000e+011.300000e+01
75%1.100000e+011.500000e+011.700000e+011.200000e+011.450000e+01
max3.200000e+023.000000e+027.500000e+031.500000e+031.633000e+03
\n", - "
" - ], - "text/plain": [ - " 1 2 3 4 101\n", - "count 1.062722e+06 1.475197e+06 3.051426e+06 1.280045e+06 1.133556e+07\n", - "mean 1.076436e+01 1.519766e+01 1.285360e+01 1.139475e+01 1.350509e+01\n", - "std 9.243106e+00 5.714467e+00 1.445236e+01 1.657010e+01 1.492325e+01\n", - "min 2.500000e+00 5.000000e+00 3.000000e-01 1.000000e+00 2.000000e-02\n", - "25% 9.500000e+00 1.300000e+01 6.000000e+00 6.000000e+00 1.000000e+01\n", - "50% 1.100000e+01 1.500000e+01 1.350000e+01 1.000000e+01 1.300000e+01\n", - "75% 1.100000e+01 1.500000e+01 1.700000e+01 1.200000e+01 1.450000e+01\n", - "max 3.200000e+02 3.000000e+02 7.500000e+03 1.500000e+03 1.633000e+03" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "amount_df.describe()" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "a54269c1-9aec-4e49-91ba-d39fa5ece850", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "means = amount_df.mean()\n", - "\n", - "plt.figure(figsize=(10, 6))\n", - "amount_df.boxplot()\n", - "plt.scatter(x=range(1, len(means) + 1), y=means, marker='D', color='red', s=100)\n", - "plt.title('Répartition des prix des billets non gratuits')\n", - "plt.ylabel('Montant')\n", - "plt.xlabel('Compagnie')\n", - "plt.ylim(0, 50) \n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "b41b5434-0e5b-495b-bede-23f5cb45272c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
purchase_idticket_id
count73518.0000007.351800e+04
mean10.0961672.484660e+01
std2367.7026034.636993e+03
min1.0000001.000000e+00
25%1.0000001.000000e+00
50%1.0000002.000000e+00
75%1.0000003.000000e+00
max641981.0000001.256574e+06
\n", - "
" - ], - "text/plain": [ - " purchase_id ticket_id\n", - "count 73518.000000 7.351800e+04\n", - "mean 10.096167 2.484660e+01\n", - "std 2367.702603 4.636993e+03\n", - "min 1.000000 1.000000e+00\n", - "25% 1.000000 1.000000e+00\n", - "50% 1.000000 2.000000e+00\n", - "75% 1.000000 3.000000e+00\n", - "max 641981.000000 1.256574e+06" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "purchases.groupby('customer_id')[['purchase_id', 'ticket_id']].nunique().describe()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "d1212b10-3933-450a-b001-9e2cbf308f79", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ticket_idcustomer_idpurchase_idevent_type_idsupplier_namepurchase_datetype_of_ticket_nameamountchildrenis_full_pricename_event_typesname_facilitiesname_categoriesname_eventsname_seasons
0130708594818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier8.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
1130708604818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
2130708614818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
3130708624818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
4130708634818751074624vente en ligne2018-12-28 14:47:50+00:00Atelier4.0pricing_formulaFalsespectacle vivantmucemindiv prog enfantl'école des magiciens2018
................................................
182666720662815125613580076975vente en ligne2023-11-08 17:23:54+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182666820662816125613680076985vente en ligne2023-11-08 18:32:18+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182666920662817125613680076985vente en ligne2023-11-08 18:32:18+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182667020662818125613780076995vente en ligne2023-11-08 19:30:28+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
182667120662819125613780076995vente en ligne2023-11-08 19:30:28+00:00Atelier11.0pricing_formulaFalseoffre muséale groupemucemindiv entrées tpNaN2023
\n", - "

1826672 rows × 15 columns

\n", - "
" - ], - "text/plain": [ - " ticket_id customer_id purchase_id event_type_id supplier_name \\\n", - "0 13070859 48187 5107462 4 vente en ligne \n", - "1 13070860 48187 5107462 4 vente en ligne \n", - "2 13070861 48187 5107462 4 vente en ligne \n", - "3 13070862 48187 5107462 4 vente en ligne \n", - "4 13070863 48187 5107462 4 vente en ligne \n", - "... ... ... ... ... ... \n", - "1826667 20662815 1256135 8007697 5 vente en ligne \n", - "1826668 20662816 1256136 8007698 5 vente en ligne \n", - "1826669 20662817 1256136 8007698 5 vente en ligne \n", - "1826670 20662818 1256137 8007699 5 vente en ligne \n", - "1826671 20662819 1256137 8007699 5 vente en ligne \n", - "\n", - " purchase_date type_of_ticket_name amount \\\n", - "0 2018-12-28 14:47:50+00:00 Atelier 8.0 \n", - "1 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", - "2 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", - "3 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", - "4 2018-12-28 14:47:50+00:00 Atelier 4.0 \n", - "... ... ... ... \n", - "1826667 2023-11-08 17:23:54+00:00 Atelier 11.0 \n", - "1826668 2023-11-08 18:32:18+00:00 Atelier 11.0 \n", - "1826669 2023-11-08 18:32:18+00:00 Atelier 11.0 \n", - "1826670 2023-11-08 19:30:28+00:00 Atelier 11.0 \n", - "1826671 2023-11-08 19:30:28+00:00 Atelier 11.0 \n", - "\n", - " children is_full_price name_event_types name_facilities \\\n", - "0 pricing_formula False spectacle vivant mucem \n", - "1 pricing_formula False spectacle vivant mucem \n", - "2 pricing_formula False spectacle vivant mucem \n", - "3 pricing_formula False spectacle vivant mucem \n", - "4 pricing_formula False spectacle vivant mucem \n", - "... ... ... ... ... \n", - "1826667 pricing_formula False offre muséale groupe mucem \n", - "1826668 pricing_formula False offre muséale groupe mucem \n", - "1826669 pricing_formula False offre muséale groupe mucem \n", - "1826670 pricing_formula False offre muséale groupe mucem \n", - "1826671 pricing_formula False offre muséale groupe mucem \n", - "\n", - " name_categories name_events name_seasons \n", - "0 indiv prog enfant l'école des magiciens 2018 \n", - "1 indiv prog enfant l'école des magiciens 2018 \n", - "2 indiv prog enfant l'école des magiciens 2018 \n", - "3 indiv prog enfant l'école des magiciens 2018 \n", - "4 indiv prog enfant l'école des magiciens 2018 \n", - "... ... ... ... \n", - "1826667 indiv entrées tp NaN 2023 \n", - "1826668 indiv entrées tp NaN 2023 \n", - "1826669 indiv entrées tp NaN 2023 \n", - "1826670 indiv entrées tp NaN 2023 \n", - "1826671 indiv entrées tp NaN 2023 \n", - "\n", - "[1826672 rows x 15 columns]" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "purchases" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "49d5fd2d-9bc1-43ac-9270-1efd73759854", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Nombre Total de tickets achetés sur Internet par Type d'évènements\n", - "\n", - "nb_tickets_internet = customer.groupby('name_event_types')['nb_tickets_internet'].sum()\n", - "nb_tickets_internet.plot(kind='bar', figsize=(8, 5))\n", - "plt.xlabel(\"Type d'évènements\")\n", - "plt.ylabel('Nombre Total de tickets achetés sur Internet')\n", - "plt.title(\"Nombre Total de tickets achetés sur Internet par Type d'évènements\")\n", - "plt.xticks(rotation=45)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d679204b-f3e8-4502-8de9-3bf4180da3bd", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "# 2 - Autres informations sur client " - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "1df2a145-f47f-4511-aa76-0df7531dd2ec", - "metadata": {}, - "outputs": [], - "source": [ - "def tags_information(tenant_id, first_tags = 20):\n", - "\n", - " customersplus = load_dataset_2(tenant_id, \"customersplus\")[['id', 'structure_id']]\n", - " customersplus.rename(columns = {'id' : 'customer_id'}, inplace = True)\n", - " tags = load_dataset_2(tenant_id, \"tags\")[['id', 'name']]\n", - " tags.rename(columns = {'id' : 'tag_id', 'name' : 'tag_name'}, inplace = True)\n", - " structure_tag_mappings = load_dataset_2(tenant_id, \"structure_tag_mappings\")[['structure_id', 'tag_id']]\n", - " \n", - " customer_tags = pd.merge(customersplus, structure_tag_mappings, on = 'structure_id', how = 'left')\n", - " customer_tags = pd.merge(customer_tags, tags, on = 'tag_id', how = 'inner')\n", - " \n", - " nb_customers_with_tag = customer_tags['customer_id'].nunique()\n", - " \n", - " # print('Nombre de client avec tag : ', nb_customers_with_tag)\n", - " # print('Proportion de clients avec tags : ', nb_customers_with_tag/len(customersplus))\n", - " # print('Moyenne de tags par client : ', len(customer_tags)/nb_customers_with_tag)\n", - " \n", - " # info = customer_tags.groupby(['tag_id', 'tag_name'])['customer_id'].count().reset_index().sort_values('customer_id', ascending = False).head(first_tags)\n", - "\n", - " tags_informations = pd.DataFrame({'company_number' : tenant_id,\n", - " 'nb_customers_with_tags' : [nb_customers_with_tag],\n", - " 'prop_customers_with_tags' : [nb_customers_with_tag/len(customersplus)],\n", - " 'mean_tags_per_customers' : [len(customer_tags)/nb_customers_with_tag]})\n", - " \n", - " return tags_informations" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "c4ecbb15-0f55-46dc-a3df-6e8c4ae44ebd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nombre de client avec tag : 13320\n", - "Proportion de clients avec tags : 0.0877089012682233\n", - "Moyenne de tags par client : 2.1725975975975977\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (20) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " df = pd.read_csv(file_in, sep=\",\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nombre de client avec tag : 5953\n", - "Proportion de clients avec tags : 0.021598421025897787\n", - "Moyenne de tags par client : 1.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (19,20) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " df = pd.read_csv(file_in, sep=\",\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nombre de client avec tag : 23659\n", - "Proportion de clients avec tags : 0.09207484608139978\n", - "Moyenne de tags par client : 3.0620482691576143\n", - "Nombre de client avec tag : 10495\n", - "Proportion de clients avec tags : 0.03271416949025744\n", - "Moyenne de tags par client : 5.298427822772749\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_467/1769900082.py:8: DtypeWarning: Columns (20) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " df = pd.read_csv(file_in, sep=\",\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Nombre de client avec tag : 532342\n", - "Proportion de clients avec tags : 0.18660686931118298\n", - "Moyenne de tags par client : 24.114082676174338\n" - ] - } - ], - "source": [ - "tags_comparaison = pd.DataFrame()\n", - "\n", - "for tenant_id in companies['musee'] : \n", - " \n", - " tags_comparaison = pd.concat([tags_comparaison, tags_information(tenant_id)])" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "bd2dd513-3375-4073-a12a-fa0e9f20571e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
company_numbernb_customers_with_tagsprop_customers_with_tagsmean_tags_per_customers
01133200.0877092.172598
0259530.0215981.000000
03236590.0920753.062048
04104950.0327145.298428
01015323420.18660724.114083
\n", - "
" - ], - "text/plain": [ - " company_number nb_customers_with_tags prop_customers_with_tags \\\n", - "0 1 13320 0.087709 \n", - "0 2 5953 0.021598 \n", - "0 3 23659 0.092075 \n", - "0 4 10495 0.032714 \n", - "0 101 532342 0.186607 \n", - "\n", - " mean_tags_per_customers \n", - "0 2.172598 \n", - "0 1.000000 \n", - "0 3.062048 \n", - "0 5.298428 \n", - "0 24.114083 " - ] - }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tags_comparaison" - ] - }, - { - "cell_type": "markdown", - "id": "507c1db3-1d6c-4106-a9a2-0187055e0480", - "metadata": {}, - "source": [ - "# 3 - Graphiques communs" - ] - }, - { - "cell_type": "markdown", - "id": "aac367ed-9d5e-482a-a376-bfc7d1a5767e", - "metadata": {}, - "source": [ - "## Nombre de clients" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "94254c32-dc81-42f2-9d27-372ff38c70ed", - "metadata": {}, - "outputs": [], - "source": [ - "def compute_nb_clients(customer_musee):\n", - " company_nb_clients = customer_musee[customer_musee[\"purchase_count\"]>0].groupby(\"number_company\")[\"customer_id\"].count().reset_index()\n", - " plt.bar(company_nb_clients[\"number_company\"], company_nb_clients[\"customer_id\"]/1000)\n", - "\n", - " # Ajout de titres et d'étiquettes\n", - " plt.xlabel('Company')\n", - " plt.ylabel(\"Nombre de clients (milliers)\")\n", - " plt.title(\"Nombre de clients de chaque compagnie de musee\")\n", - " \n", - " # Affichage du barplot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "aed68c8c-1912-4d8d-a974-11ad371f6ee8", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAHFCAYAAAD2eiPWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJYElEQVR4nO3dd3RU1f7+8WcgPYRAAqRACAFCMwSkFzWUAEZBEBQsl6LIRSlKuyqiF1CKFKkqXq9KsQAqRSkCkRJFBKlSBAUvVYn0BCIEkuzfH34zP4YEyJAJSY7v11qzFrNnzzmffXYyeThtbMYYIwAAAAsrkt8FAAAA5DUCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCDwAAsDwCTwEza9Ys2Ww2eXl56fDhw1leb9asmaKiovKhMqlHjx4qVqxYvqz7Zmw2m0aMGHFb19msWTM1a9bsttexfPny2zbW/NiuFSpUUNu2bW/rOlHwHTp0SDabTbNmzcrzdeXHzz3yHoGngEpNTdXLL7+c32XASd9//72eeuqpPF3H8uXLNXLkyDxdB1DQhISE6Pvvv9f999+f36WgkCLwFFD33nuvPvnkE/3444/5XYpLGGN08eLF/C4jzzVq1EjlypXL7zIAy/H09FSjRo1UunTp/C4FhRSBp4B6/vnnFRgYqBdeeOGmfS9duqShQ4cqIiJCHh4eKlu2rPr27atz58459Ms8VLB06VLdeeed8vb2VvXq1bV06VJJfx1Oq169unx9fdWgQQNt2bIl2/Xt2bNHLVu2lK+vr0qXLq1+/frpzz//dOhjs9nUr18/vfPOO6pevbo8PT01e/ZsSdL+/fv12GOPqUyZMvL09FT16tX11ltv5Wi7JCcnq1evXgoMDFSxYsV077336pdffsm2b27Wk5GRoenTp6t27dry9vZWiRIl1KhRI3355Zc3fF92u8ITExPVu3dvlStXTh4eHoqIiNDIkSOVlpZm75O5u37ixImaNGmSIiIiVKxYMTVu3FgbN2609+vRo4d9DDabzf44dOiQJOmzzz5Tw4YN5e/vLx8fH1WsWFFPPvnkTcdbELfrihUrVKdOHXl7e6tatWr64IMPHF4/efKk+vTpoxo1aqhYsWIqU6aMWrRooW+//TbLsn7//Xd17txZfn5+8vf3V5cuXbRx48Ysh0iyO0wp/bXdK1So4NB2+fJljRo1StWqVZOnp6dKly6tJ554QidPnszRtti0aZPatWunwMBAeXl5qVKlShowYIBDn/Xr16tly5by8/OTj4+PmjRpomXLljn0yTwMvmbNGvscFi9eXN26dVNKSooSExPVuXNnlShRQiEhIRoyZIiuXLlif3/mz9748eM1evRolS9fXl5eXqpXr55Wr17tsK4DBw7oiSeeUGRkpHx8fFS2bFm1a9dOu3btyjK+PXv2qHXr1vLx8VHp0qXVt29fLVu2TDabTevWrXPY5lFRUdq8ebPuvvtu+8/t66+/royMjCx1XntIqzB8nmR+Hs6cOVNVq1aVt7e36tWrp40bN8oYowkTJth/51u0aKEDBw44vL9ChQrq0aNHluVe+/OakZGhUaNG2ddRokQJRUdHa+rUqbc0luTkZA0ZMsThb8uAAQOUkpKSo3EXOAYFysyZM40ks3nzZjN16lQjyaxevdr+ekxMjLnjjjvszzMyMkybNm2Mm5ubeeWVV8yqVavMxIkTja+vr7nzzjvNpUuX7H3Dw8NNuXLlTFRUlJk7d65Zvny5adiwoXF3dzf//ve/TdOmTc3ChQvNokWLTJUqVUxQUJD5888/7e/v3r278fDwMOXLlzejR482q1atMiNGjDBubm6mbdu2DuOQZMqWLWuio6PNJ598YtasWWN2795t9uzZY/z9/U3NmjXNnDlzzKpVq8zgwYNNkSJFzIgRI264bTIyMkzz5s2Np6enff3Dhw83FStWNJLM8OHD7X1zsx5jjOnataux2WzmqaeeMl988YX56quvzOjRo83UqVMd5iImJibLuK+u4/jx4yYsLMyEh4eb//znP+brr782r732mvH09DQ9evSw9zt48KCRZCpUqGDuvfdes3jxYrN48WJTs2ZNU7JkSXPu3DljjDEHDhwwDz30kJFkvv/+e/vj0qVLZsOGDcZms5lHHnnELF++3KxZs8bMnDnTdO3atVBt18yf0xo1apg5c+aYlStXmocffthIMgkJCfZ++/btM88884yZN2+eWbdunVm6dKnp2bOnKVKkiFm7dq29359//mmqV69u/P39zfTp083KlSvNs88+a8qXL28kmZkzZ95wTo3562c/PDzc/jw9Pd3ce++9xtfX14wcOdLEx8eb9957z5QtW9bUqFHD4fcmOytWrDDu7u4mOjrazJo1y6xZs8Z88MEH5pFHHrH3WbdunXF3dzd169Y18+fPN4sXLzatW7c2NpvNzJs3z94v8zMjIiLCDB482KxatcqMGzfOFC1a1Dz66KOmTp06ZtSoUSY+Pt688MILRpJ544037O/P/NkLCwszd911l1mwYIH57LPPTP369Y27u7vZsGGDvW9CQoIZPHiw+fzzz01CQoJZtGiR6dChg/H29jb79u2z9/v9999NYGCgKV++vJk1a5ZZvny56dq1q6lQoYKR5DA/MTExJjAw0ERGRpp33nnHxMfHmz59+hhJZvbs2VnqvHq+CsvniSQTHh5umjRp4vAZGxAQYAYOHGjat29vli5daj7++GMTFBRkoqOjTUZGhv394eHhpnv37lmWe+3P69ixY03RokXN8OHDzerVq82KFSvMlClTHGrM6VhSUlJM7dq1TalSpcykSZPM119/baZOnWr8/f1NixYtHOorLAg8BczVgSc1NdVUrFjR1KtXz/7DdW3gWbFihZFkxo8f77Cc+fPnG0nm3XfftbeFh4cbb29vc+zYMXvbjh07jCQTEhJiUlJS7O2LFy82ksyXX35pb+vevbuR5PDHyRhjRo8ebSSZ9evX29skGX9/f3PmzBmHvm3atDHlypUzSUlJDu39+vUzXl5eWfpf7auvvrrh+q/+gMrNer755hsjyQwbNuy6fYzJWeDp3bu3KVasmDl8+LBDv4kTJxpJZs+ePcaY//9hXrNmTZOWlmbv98MPPxhJZu7cufa2vn37muz+r5K5zMxwlFMFbbuGh4cbLy8vh2128eJFExAQYHr37n3d96WlpZkrV66Yli1bmgcffNDePmPGDCPJfPHFFw79e/XqdcuBZ+7cuUaSWbBggUO/zZs3G0nm7bffvuEYK1WqZCpVqmQuXrx43T6NGjUyZcqUMefPn3cYY1RUlClXrpz9MyHzM6N///4O7+/QoYORZCZNmuTQXrt2bVOnTh3788yfvdDQUId6kpOTTUBAgImNjb1ujWlpaeby5csmMjLSDBw40N7+r3/9y9hsNvvPd6Y2bdpkG3gkmU2bNjn0rVGjhmnTpk2WOq+er8LweWLMX58LwcHB5sKFC/a2zM/Y2rVrO4SHKVOmGElm586d9racBp62bdua2rVr37CWnI5l7NixpkiRImbz5s0O/T7//HMjySxfvvyG6ymIOKRVgHl4eGjUqFHasmWLPv3002z7rFmzRpKy7O58+OGH5evrm2WXdO3atVW2bFn78+rVq0v6a9eoj49PlvbsrhR7/PHHHZ4/9thjkqS1a9c6tLdo0UIlS5a0P7906ZJWr16tBx98UD4+PkpLS7M/7rvvPl26dMnh8M21Mpd/vfW7aj1fffWVJKlv377X7ZNTS5cuVfPmzRUaGupQR1xcnCQpISHBof/999+vokWL2p9HR0dLyn4erlW/fn1JUufOnfXpp5/qt99+y1GNBXG71q5dW+XLl7c/9/LyUpUqVbJsh3feeUd16tSRl5eX3Nzc5O7urtWrV2vv3r0O4/Pz89MDDzxww/E5Y+nSpSpRooTatWvnsB1q166t4OBgh0M21/rll1/066+/qmfPnvLy8sq2T0pKijZt2qSHHnrI4crIokWLqmvXrjp27Jh+/vlnh/dce2Vb5u/wtSf5Vq9ePdufp44dOzrU4+fnp3bt2umbb75Renq6JCktLU1jxoxRjRo15OHhITc3N3l4eGj//v0O2zwhIUFRUVGqUaOGwzoeffTRbMcbHBysBg0aOLRFR0ff8Oe+sHyeZGrevLl8fX3tzzPnJy4uTjabLUt7Tn7nr9WgQQP9+OOP6tOnj1auXKnk5ORbHsvSpUsVFRWl2rVrO/Rr06ZNlsOShQWBp4B75JFHVKdOHQ0bNszhuHum06dPy83NLcuJfDabTcHBwTp9+rRDe0BAgMNzDw+PG7ZfunTJod3NzU2BgYEObcHBwfZarhYSEpKl1rS0NE2fPl3u7u4Oj/vuu0+SdOrUqSxjvHas11u/q9Zz8uRJFS1aNMtyb8Uff/yhJUuWZKnjjjvuyLaOa8fm6ekpSTk64fuee+7R4sWLlZaWpm7duqlcuXKKiorS3Llzb/i+grhdr61F+mtbXL0dJk2apGeeeUYNGzbUggULtHHjRm3evFn33nuvQ7/Tp08rKCgoy/JyM79//PGHzp07Jw8PjyzbIjEx8abbQdINT24/e/asjDFZfockKTQ0VFLW3zdnfrev/b2Wst8ewcHBunz5si5cuCBJGjRokF555RV16NBBS5Ys0aZNm7R582bVqlUrR9s8uzYpZ/N9rcLyeZIpt5+9OTF06FBNnDhRGzduVFxcnAIDA9WyZUv7+ZjOjOWPP/7Qzp07s/Tz8/OTMSZHYy5o3PK7ANyYzWbTuHHj1KpVK7377rtZXg8MDFRaWppOnjzpEHqMMUpMTLT/r99V0tLSdPr0aYcPicTERHst19Z+tZIlS9r/h3q9/+VHRERcd92ZY73e+l21ntKlSys9PV2JiYnZ/sFxRqlSpRQdHa3Ro0dn+3rmHy9Xad++vdq3b6/U1FRt3LhRY8eO1WOPPaYKFSqocePG2b6nMG5XSfroo4/UrFkzzZgxw6H9/PnzDs8DAwP1ww8/ZHn/teOT/tqTlJSUlKX92g/3UqVKKTAwUCtWrMi2Nj8/v+vWnfl7euzYsev2KVmypIoUKaLjx49nee3333+31+BK2W2PxMREeXh42PcyffTRR+rWrZvGjBnj0O/UqVMqUaKE/XlgYKD++OOPHK3jVhWWzxNX8PLyUmpqapb2U6dOOfwcuLm5adCgQRo0aJDOnTunr7/+Wi+99JLatGmjo0ePOjWWUqVKydvbO8vFAplc/fN3O7CHpxCIjY1Vq1at9Oqrr9r/p5WpZcuWkv76ILraggULlJKSYn/dlT7++GOH55988okkZXt1y9V8fHzUvHlzbd++XdHR0apXr16WR3b/08vUvHnzG67fVevJPNx07R/SW9G2bVvt3r1blSpVyraOWwk8Odnr4+npqZiYGI0bN06StH379uv2LYzbVforUGdui0w7d+7U999/79DWvHlznT9/PsuVYNeOT/rraphffvnF4Y/L6dOntWHDBod+bdu21enTp5Wenp7tdqhatep1665SpYoqVaqkDz74INs/YpLk6+urhg0bauHChQ7znJGRoY8++kjlypVTlSpVrruOW7Fw4UKHvQrnz5/XkiVLdPfdd9sPs2a3zZctW5bl8GlMTIx2796tn376yaF93rx5Lqu3sHyeuEKFChW0c+dOh7Zffvkly2HNq5UoUUIPPfSQ+vbtqzNnzujQoUNOjaVt27b69ddfFRgYmG2/a69aLAzYw1NIjBs3TnXr1tWJEyfsh0MkqVWrVmrTpo1eeOEFJScnq2nTptq5c6eGDx+uO++8U127dnVpHR4eHnrjjTd04cIF1a9fXxs2bNCoUaMUFxenu+6666bvnzp1qu666y7dfffdeuaZZ1ShQgWdP39eBw4c0JIlS+znJGWndevWuueee/T8888rJSVF9erV03fffacPP/zQpeu5++671bVrV40aNUp//PGH2rZtK09PT23fvl0+Pj7q379/zjaWpFdffVXx8fFq0qSJnn32WVWtWlWXLl3SoUOHtHz5cr3zzjtO37enZs2akv76mYiLi1PRokUVHR2tUaNG6dixY2rZsqXKlSunc+fOaerUqXJ3d1dMTMx1l1cYt6v01wfya6+9puHDhysmJkY///yzXn31VUVERDhc8t+tWzdNnjxZ3bp10+jRoxUZGanly5dr5cqVWZbZtWtX/ec//9E//vEP9erVS6dPn9b48eNVvHhxh36PPPKIPv74Y91333167rnn1KBBA7m7u+vYsWNau3at2rdvrwcffPC6tb/11ltq166dGjVqpIEDB6p8+fI6cuSIVq5caf8DPHbsWLVq1UrNmzfXkCFD5OHhobffflu7d+/W3Llzs+xBza2iRYuqVatWGjRokDIyMjRu3DglJyc73OSybdu2mjVrlqpVq6bo6Ght3bpVEyZMyPIzPGDAAH3wwQeKi4vTq6++qqCgIH3yySfat2+fJKlIEdf8X7swfJ64QteuXfWPf/xDffr0UadOnXT48GGNHz8+y6kM7dq1U1RUlOrVq6fSpUvr8OHDmjJlisLDwxUZGenUWAYMGKAFCxbonnvu0cCBAxUdHa2MjAwdOXJEq1at0uDBg9WwYcM8HbfL5fNJ07jG1VdpXeuxxx4zkhyu0jLmrytYXnjhBRMeHm7c3d1NSEiIeeaZZ8zZs2cd+oWHh5v7778/y3Ilmb59+zq0ZV4RMWHCBHtb9+7dja+vr9m5c6dp1qyZ8fb2NgEBAeaZZ55xuPrgesu8etlPPvmkKVu2rHF3dzelS5c2TZo0MaNGjbrhtjHGmHPnzpknn3zSlChRwvj4+JhWrVqZffv2ZbmqIrfrSU9PN5MnTzZRUVHGw8PD+Pv7m8aNG5slS5bY++TkKi1jjDl58qR59tlnTUREhHF3dzcBAQGmbt26ZtiwYfbtlt32vt4yU1NTzVNPPWVKly5tbDabkWQOHjxoli5dauLi4kzZsmWNh4eHKVOmjLnvvvvMt99+e9PxFqTter2f02u3d2pqqhkyZIgpW7as8fLyMnXq1DGLFy/OckWVMcYcO3bMdOrUyRQrVsz4+fmZTp06mQ0bNmS56scYY2bPnm2qV69uvLy8TI0aNcz8+fOzXeaVK1fMxIkTTa1atYyXl5cpVqyYqVatmundu7fZv3//TbfF999/b+Li4oy/v7/x9PQ0lSpVcrjSyRhjvv32W9OiRQvj6+trvL29TaNGjRy2lTHX/8wYPny4kWROnjzp0J75e5wp82dv3LhxZuTIkaZcuXLGw8PD3HnnnWblypUO7z179qzp2bOnKVOmjPHx8TF33XWX+fbbb7P9Xdi9e7eJjY01Xl5eJiAgwPTs2dPMnj3bSDI//vijvd+1V55eXefV2zy7q7Qy2wv650lOP2ONMWbt2rVGkvnss8/sbRkZGWb8+PGmYsWKxsvLy9SrV8+sWbMmy3Z/4403TJMmTUypUqXstxDp2bOnOXTo0C2N5cKFC+bll182VatWtf++1qxZ0wwcONAkJibedNwFjc0YY25rwgKAAuDQoUOKiIjQzJkzs72p299F5naYMGGChgwZkqfr+uc//6m5c+fq9OnT9pNzgduFQ1oAAJd79dVXFRoaqooVK+rChQtaunSp3nvvPb388suEHeQLAg8AwOXc3d01YcIEHTt2TGlpaYqMjNSkSZP03HPP5Xdp+JvikBYAALA8LksHAACWR+ABAACWR+ABAACWx0nL+uvupb///rv8/PxcfjMvAACQN4wxOn/+vEJDQ29+Q8v8vAnQmDFjTL169UyxYsVM6dKlTfv27c2+ffsc+nTv3t1Icng0bNjQoc+lS5dMv379TGBgoPHx8THt2rUzR48ezXEdR48ezbIOHjx48ODBg0fheOTkb36+7uFJSEhQ3759Vb9+faWlpWnYsGFq3bq1fvrpJ/n6+tr73XvvvZo5c6b9+bX3cBgwYICWLFmiefPmKTAwUIMHD1bbtm21detW+3fA3EjmF/0dPXo0yy3kAQBAwZScnKywsLAbfmFvpgJ1WfrJkydVpkwZJSQk6J577pEk9ejRQ+fOndPixYuzfU9SUpJKly6tDz/8UF26dJH017cJh4WFafny5WrTps1N15ucnCx/f38lJSUReAAAKCSc+ftdoE5aTkpKkiQFBAQ4tK9bt05lypRRlSpV1KtXL504ccL+2tatW3XlyhW1bt3a3hYaGqqoqKgs33CcKTU1VcnJyQ4PAABgXQUm8BhjNGjQIN11112Kioqyt8fFxenjjz/WmjVr9MYbb2jz5s1q0aKFUlNTJUmJiYny8PBQyZIlHZYXFBSkxMTEbNc1duxY+fv72x9hYWF5NzAAAJDvCsxVWv369dPOnTu1fv16h/bMw1SS7F97Hx4ermXLlqljx47XXZ4x5rpXXA0dOlSDBg2yP888BggAAKypQOzh6d+/v7788kutXbtW5cqVu2HfkJAQhYeHa//+/ZKk4OBgXb58WWfPnnXod+LECQUFBWW7DE9PTxUvXtzhAQAArCtfA48xRv369dPChQu1Zs0aRURE3PQ9p0+f1tGjRxUSEiJJqlu3rtzd3RUfH2/vc/z4ce3evVtNmjTJs9oBAEDhka+HtPr27atPPvlEX3zxhfz8/Ozn3Pj7+8vb21sXLlzQiBEj1KlTJ4WEhOjQoUN66aWXVKpUKT344IP2vj179tTgwYMVGBiogIAADRkyRDVr1lRsbGx+Dg8AABQQ+Rp4ZsyYIUlq1qyZQ/vMmTPVo0cPFS1aVLt27dKcOXN07tw5hYSEqHnz5po/f77DNfeTJ0+Wm5ubOnfurIsXL6ply5aaNWtWju7BAwAArK9A3Ycnv3AfHgAACp9Cex8eAACAvEDgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlkfgAQAAlldgvjwUKGwqvLgsv0v42zr0+v35XQKAQoY9PAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPIIPAAAwPLyNfCMHTtW9evXl5+fn8qUKaMOHTro559/duhjjNGIESMUGhoqb29vNWvWTHv27HHok5qaqv79+6tUqVLy9fXVAw88oGPHjt3OoQAAgAIsXwNPQkKC+vbtq40bNyo+Pl5paWlq3bq1UlJS7H3Gjx+vSZMm6c0339TmzZsVHBysVq1a6fz58/Y+AwYM0KJFizRv3jytX79eFy5cUNu2bZWenp4fwwIAAAWMzRhj8ruITCdPnlSZMmWUkJCge+65R8YYhYaGasCAAXrhhRck/bU3JygoSOPGjVPv3r2VlJSk0qVL68MPP1SXLl0kSb///rvCwsK0fPlytWnT5qbrTU5Olr+/v5KSklS8ePE8HSOso8KLy/K7hL+tQ6/fn98lACgAnPn7XaDO4UlKSpIkBQQESJIOHjyoxMREtW7d2t7H09NTMTEx2rBhgyRp69atunLlikOf0NBQRUVF2fsAAIC/N7f8LiCTMUaDBg3SXXfdpaioKElSYmKiJCkoKMihb1BQkA4fPmzv4+HhoZIlS2bpk/n+a6Wmpio1NdX+PDk52WXjAAAABU+B2cPTr18/7dy5U3Pnzs3yms1mc3hujMnSdq0b9Rk7dqz8/f3tj7CwsFsvHAAAFHgFIvD0799fX375pdauXaty5crZ24ODgyUpy56aEydO2Pf6BAcH6/Llyzp79ux1+1xr6NChSkpKsj+OHj3qyuEAAIACJl8DjzFG/fr108KFC7VmzRpFREQ4vB4REaHg4GDFx8fb2y5fvqyEhAQ1adJEklS3bl25u7s79Dl+/Lh2795t73MtT09PFS9e3OEBAACsK1/P4enbt68++eQTffHFF/Lz87PvyfH395e3t7dsNpsGDBigMWPGKDIyUpGRkRozZox8fHz02GOP2fv27NlTgwcPVmBgoAICAjRkyBDVrFlTsbGx+Tk8AABQQORr4JkxY4YkqVmzZg7tM2fOVI8ePSRJzz//vC5evKg+ffro7NmzatiwoVatWiU/Pz97/8mTJ8vNzU2dO3fWxYsX1bJlS82aNUtFixa9XUMBAAAFWIG6D09+4T48uBXchyf/cB8eAFIhvg8PAABAXiDwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAy8tV4Ln6CzgBAAAKKqcCz8qVK9WjRw9VqlRJ7u7u8vHxkZ+fn2JiYjR69Gj9/vvveVUnAADALctR4Fm8eLGqVq2q7t27q0iRIvrXv/6lhQsXauXKlXr//fcVExOjr7/+WhUrVtTTTz+tkydP5nXdAAAAOZajr5YYM2aMJk6cqPvvv19FimTNSJ07d5Yk/fbbb5o6darmzJmjwYMHu7ZSAACAW5SjwPPDDz/kaGFly5bV+PHjc1UQAACAq+X6Kq309HTt2LFDZ8+edUU9AAAALud04BkwYIDef/99SX+FnZiYGNWpU0dhYWFat26dq+sDAADINacDz+eff65atWpJkpYsWaKDBw9q3759GjBggIYNG+byAgEAAHLL6cBz6tQpBQcHS5KWL1+uhx9+WFWqVFHPnj21a9culxcIAACQW04HnqCgIP30009KT0/XihUrFBsbK0n6888/VbRoUZcXCAAAkFs5ukrrak888YQ6d+6skJAQ2Ww2tWrVSpK0adMmVatWzeUFAgAA5JbTgWfEiBGqWbOmjhw5oocfflienp6SpKJFi+rFF190eYEAAAC55VTguXLlilq3bq3//Oc/6tSpk8Nr3bt3d2lhAAAAruLUOTzu7u7avXu3bDZbXtUDAADgck6ftNytWzf7fXgAAAAKA6fP4bl8+bLee+89xcfHq169evL19XV4fdKkSS4rDgAAwBWcDjy7d+9WnTp1JEm//PKLw2sc6gIAAAWR04Fn7dq1eVEHAABAnrnlLw89cOCAVq5cqYsXL0qSjDEuKwoAAMCVnA48p0+fVsuWLVWlShXdd999On78uCTpqaee0uDBg11eIAAAQG45HXgGDhwod3d3HTlyRD4+Pvb2Ll26aMWKFS4tDgAAwBWcPodn1apVWrlypcqVK+fQHhkZqcOHD7usMAAAAFdxeg9PSkqKw56dTKdOnbJ/zQQAAEBB4nTgueeeezRnzhz7c5vNpoyMDE2YMEHNmzd3aXEAAACu4PQhrQkTJqhZs2basmWLLl++rOeff1579uzRmTNn9N133+VFjQAAALni9B6eGjVqaOfOnWrQoIFatWqllJQUdezYUdu3b1elSpXyokYAAIBccXoPjyQFBwdr5MiRrq4FAAAgT+Qo8OzcuVNRUVEqUqSIdu7cecO+0dHRLikMAADAVXIUeGrXrq3ExESVKVNGtWvXls1my/bOyjabTenp6S4vEgAAIDdyFHgOHjyo0qVL2/8NAABQmOQo8ISHh2f7bwAAgMIgR4Hnyy+/zPECH3jggVsuBgAAIC/kKPB06NAhRwvjHB4AAFAQ5SjwZGRk5HUdAAAAecbpGw8CAAAUNjnawzNt2rQcL/DZZ5+95WIAAADyQo4Cz+TJk3O0MJvNRuABAAAFTo7vwwMAAFBYcQ4PAACwvBzt4Rk0aJBee+01+fr6atCgQTfsO2nSJJcUBgAA4Co5Cjzbt2/XlStX7P++HpvN5pqqACAfVXhxWX6X8Ld16PX787sEWFSOAs/atWuz/TcAAEBhwDk8AADA8nK0h+dqly5d0vTp07V27VqdOHEiy12Yt23b5rLiAAAAXMHpwPPkk08qPj5eDz30kBo0aMB5OwAAoMBzOvAsW7ZMy5cvV9OmTfOiHgAAAJdz+hyesmXLys/PLy9qAQAAyBNO7+F544039MILL+idd95ReHh4XtQEAIDLcbuB/FMQbjfgdOCpV6+eLl26pIoVK8rHx0fu7u4Or585c8ZlxQEAALiC04Hn0Ucf1W+//aYxY8YoKCiIk5YBAECB53Tg2bBhg77//nvVqlUrL+oBAABwOadPWq5WrZouXryYF7UAAADkCacDz+uvv67Bgwdr3bp1On36tJKTkx0eAAAABY3Th7TuvfdeSVLLli0d2o0xstlsSk9Pd01lAAAALuJ04OHLQwEAQGHjdOCJiYnJizoAAADyTI7O4Tly5IhTC/3tt99y1O+bb75Ru3btFBoaKpvNpsWLFzu83qNHD9lsNodHo0aNHPqkpqaqf//+KlWqlHx9ffXAAw/o2LFjTtULAACsLUeBp379+urVq5d++OGH6/ZJSkrSf//7X0VFRWnhwoU5WnlKSopq1aqlN99887p97r33Xh0/ftz+WL58ucPrAwYM0KJFizRv3jytX79eFy5cUNu2bTmXCAAA2OXokNbevXs1ZswY3XvvvXJ3d1e9evUUGhoqLy8vnT17Vj/99JP27NmjevXqacKECYqLi8vRyuPi4m7a19PTU8HBwdm+lpSUpPfff18ffvihYmNjJUkfffSRwsLC9PXXX6tNmzY5qgMAAFhbjvbwBAQEaOLEifr99981Y8YMValSRadOndL+/fslSY8//ri2bt2q7777LsdhJ6fWrVunMmXKqEqVKurVq5dOnDhhf23r1q26cuWKWrdubW8LDQ1VVFSUNmzY4NI6AABA4eXUScteXl7q2LGjOnbsmFf1OIiLi9PDDz+s8PBwHTx4UK+88opatGihrVu3ytPTU4mJifLw8FDJkiUd3hcUFKTExMTrLjc1NVWpqan259w/CAAAa3P6Kq3bqUuXLvZ/R0VFqV69egoPD9eyZctuGLoy7wl0PWPHjtXIkSNdWisAACi4nL7Tcn4KCQlReHi4/VBacHCwLl++rLNnzzr0O3HihIKCgq67nKFDhyopKcn+OHr0aJ7WDQAA8lehCjynT5/W0aNHFRISIkmqW7eu3N3dFR8fb+9z/Phx7d69W02aNLnucjw9PVW8eHGHBwAAsK58PaR14cIFHThwwP784MGD2rFjhwICAhQQEKARI0aoU6dOCgkJ0aFDh/TSSy+pVKlSevDBByVJ/v7+6tmzpwYPHqzAwEAFBARoyJAhqlmzpv2qLQAAgHwNPFu2bFHz5s3tzwcNGiRJ6t69u2bMmKFdu3Zpzpw5OnfunEJCQtS8eXPNnz9ffn5+9vdMnjxZbm5u6ty5sy5evKiWLVtq1qxZKlq06G0fDwAAKJicDjyzZ89WqVKldP/990uSnn/+eb377ruqUaOG5s6dq/Dw8Bwvq1mzZjLGXPf1lStX3nQZXl5emj59uqZPn57j9QIAgL8Xp8/hGTNmjLy9vSVJ33//vd58802NHz9epUqV0sCBA11eIAAAQG45vYfn6NGjqly5siRp8eLFeuihh/TPf/5TTZs2VbNmzVxdHwAAQK45vYenWLFiOn36tCRp1apV9pODvby8dPHiRddWBwAA4AJO7+Fp1aqVnnrqKd1555365Zdf7Ofy7NmzRxUqVHB1fQAAALnm9B6et956S40bN9bJkye1YMECBQYGSvrre60effRRlxcIAACQW07v4UlOTta0adNUpIhjVhoxYgR3LAYAAAWS03t4IiIidOrUqSztZ86cUUREhEuKAgAAcCWnA8/17ptz4cIFeXl55bogAAAAV8vxIa3MuyDbbDb9+9//lo+Pj/219PR0bdq0SbVr13Z5gQAAALmV48Czfft2SX/t4dm1a5c8PDzsr3l4eKhWrVoaMmSI6ysEAADIpRwHnrVr10qSnnjiCU2dOpVvGAcAAIWG01dpzZw5My/qAAAAyDNOB56UlBS9/vrrWr16tU6cOKGMjAyH1//3v/+5rDgAAABXcDrwPPXUU0pISFDXrl0VEhIim82WF3UBAAC4jNOB56uvvtKyZcvUtGnTvKgHAADA5Zy+D0/JkiUVEBCQF7UAAADkCacDz2uvvaZ///vf+vPPP/OiHgAAAJdz+pDWG2+8oV9//VVBQUGqUKGC3N3dHV7ftm2by4oDAABwBacDT4cOHfKgDAAAgLzjdOAZPnx4XtQBAACQZ5w+h0eSzp07p/fee09Dhw7VmTNnJP11KOu3335zaXEAAACu4PQenp07dyo2Nlb+/v46dOiQevXqpYCAAC1atEiHDx/WnDlz8qJOAACAW+b0Hp5BgwapR48e2r9/v7y8vOztcXFx+uabb1xaHAAAgCs4HXg2b96s3r17Z2kvW7asEhMTXVIUAACAKzkdeLy8vJScnJyl/eeff1bp0qVdUhQAAIArOR142rdvr1dffVVXrlyRJNlsNh05ckQvvviiOnXq5PICAQAAcsvpwDNx4kSdPHlSZcqU0cWLFxUTE6PKlSvLz89Po0ePzosaAQAAcsXpq7SKFy+u9evXa82aNdq2bZsyMjJUp04dxcbG5kV9AAAAueZ04MnUokULtWjRwpW1AAAA5IkcBZ5p06bpn//8p7y8vDRt2rQb9n322WddUhgAAICr5CjwTJ48WY8//ri8vLw0efLk6/az2WwEHgAAUODkKPAcPHgw238DAAAUBrf0XVoAAACFSY728AwaNCjHC5w0adItFwMAAJAXchR4tm/fnqOF2Wy2XBUDAACQF3IUeNauXZvXdQAAAOQZp8/hSUpK0pkzZ7K0nzlzJtvv2AIAAMhvTgeeRx55RPPmzcvS/umnn+qRRx5xSVEAAACu5HTg2bRpk5o3b56lvVmzZtq0aZNLigIAAHAlpwNPamqq0tLSsrRfuXJFFy9edElRAAAAruR04Klfv77efffdLO3vvPOO6tat65KiAAAAXMnpLw8dPXq0YmNj9eOPP6ply5aSpNWrV2vz5s1atWqVywsEAADILaf38DRt2lTff/+9wsLC9Omnn2rJkiWqXLmydu7cqbvvvjsvagQAAMgVp/fwSFLt2rX18ccfu7oWAACAPMF3aQEAAMsj8AAAAMsj8AAAAMsj8AAAAMu75cBz4MABrVy50n6zQWOMy4oCAABwJacDz+nTpxUbG6sqVarovvvu0/HjxyVJTz31lAYPHuzyAgEAAHLL6cAzcOBAubm56ciRI/Lx8bG3d+nSRStWrHBpcQAAAK7g9H14Vq1apZUrV6pcuXIO7ZGRkTp8+LDLCgMAAHAVp/fwpKSkOOzZyXTq1Cl5enq6pCgAAABXcjrw3HPPPZozZ479uc1mU0ZGhiZMmKDmzZu7tDgAAABXcPqQ1oQJE9SsWTNt2bJFly9f1vPPP689e/bozJkz+u677/KiRgAAgFxxeg9PjRo1tHPnTjVo0ECtWrVSSkqKOnbsqO3bt6tSpUp5USMAAECu3NKXhwYHB2vkyJGurgUAACBP5Cjw7Ny5M8cLjI6OvuViAAAA8kKOAk/t2rVls9lkjJHNZrO3Z95d+eq29PR0F5cIAACQOzk6h+fgwYP63//+p4MHD2rBggWKiIjQ22+/rR07dmjHjh16++23ValSJS1YsCCv6wUAAHBajvbwhIeH2//98MMPa9q0abrvvvvsbdHR0QoLC9Mrr7yiDh06uLxIAACA3HD6Kq1du3YpIiIiS3tERIR++uknlxQFAADgSk4HnurVq2vUqFG6dOmSvS01NVWjRo1S9erVnVrWN998o3bt2ik0NFQ2m02LFy92eN0YoxEjRig0NFTe3t5q1qyZ9uzZ49AnNTVV/fv3V6lSpeTr66sHHnhAx44dc3ZYAADAwpwOPO+8846+/vprhYWFKTY2VrGxsSpXrpzi4+P1zjvvOLWslJQU1apVS2+++Wa2r48fP16TJk3Sm2++qc2bNys4OFitWrXS+fPn7X0GDBigRYsWad68eVq/fr0uXLigtm3bcvI0AACwc/o+PA0aNNDBgwf10Ucfad++fTLGqEuXLnrsscfk6+vr1LLi4uIUFxeX7WvGGE2ZMkXDhg1Tx44dJUmzZ89WUFCQPvnkE/Xu3VtJSUl6//339eGHHyo2NlaS9NFHHyksLExff/212rRp4+zwAACABd3SjQd9fHz0z3/+09W1ODh48KASExPVunVre5unp6diYmK0YcMG9e7dW1u3btWVK1cc+oSGhioqKkobNmwg8AAAAEm3GHhuh8TERElSUFCQQ3tQUJAOHz5s7+Ph4aGSJUtm6ZP5/uykpqYqNTXV/jw5OdlVZQMAgALI6XN4brerb2ooKcvND7Nzsz5jx46Vv7+//REWFuaSWgEAQMFUYANPcHCwJGXZU3PixAn7Xp/g4GBdvnxZZ8+evW6f7AwdOlRJSUn2x9GjR11cPQAAKEgKbOCJiIhQcHCw4uPj7W2XL19WQkKCmjRpIkmqW7eu3N3dHfocP35cu3fvtvfJjqenp4oXL+7wAAAA1nVL5/CcO3dOn3/+uX799Vf961//UkBAgLZt26agoCCVLVs2x8u5cOGCDhw4YH9+8OBB7dixQwEBASpfvrwGDBigMWPGKDIyUpGRkRozZox8fHz02GOPSZL8/f3Vs2dPDR48WIGBgQoICNCQIUNUs2ZN+1VbAAAATgeenTt3KjY2Vv7+/jp06JB69eqlgIAALVq0SIcPH9acOXNyvKwtW7aoefPm9ueDBg2SJHXv3l2zZs3S888/r4sXL6pPnz46e/asGjZsqFWrVsnPz8/+nsmTJ8vNzU2dO3fWxYsX1bJlS82aNUtFixZ1dmgAAMCinA48gwYNUo8ePTR+/HiH4BEXF2ff85JTzZo1s3/jenZsNptGjBihESNGXLePl5eXpk+frunTpzu1bgAA8Pfh9Dk8mzdvVu/evbO0ly1b9oaXggMAAOQXpwOPl5dXtvet+fnnn1W6dGmXFAUAAOBKTgee9u3b69VXX9WVK1ck/XXY6ciRI3rxxRfVqVMnlxcIAACQW04HnokTJ+rkyZMqU6aMLl68qJiYGFWuXFl+fn4aPXp0XtQIAACQK06ftFy8eHGtX79ea9as0bZt25SRkaE6depwGTgAACiwnAo8aWlp8vLy0o4dO9SiRQu1aNEir+oCAABwGacOabm5uSk8PFzp6el5VQ8AAIDLOX0Oz8svv6yhQ4fqzJkzeVEPAACAyzl9Ds+0adN04MABhYaGKjw8XL6+vg6vb9u2zWXFAQAAuILTgadDhw55UAYAAEDecTrwDB8+PC/qAAAAyDO39G3p0l9f/Ll3717ZbDZVr15ddevWdWVdAAAALuN04Dl27JgeffRRfffddypRooQk6dy5c2rSpInmzp2rsLAwV9cIAACQK05fpfXkk0/qypUr2rt3r86cOaMzZ85o7969MsaoZ8+eeVEjAABArji9h+fbb7/Vhg0bVLVqVXtb1apVNX36dDVt2tSlxQEAALiC03t4ypcvb//i0KulpaWpbNmyLikKAADAlZwOPOPHj1f//v21ZcsWGWMk/XUC83PPPaeJEye6vEAAAIDcytEhrZIlS8pms9mfp6SkqGHDhnJz++vtaWlpcnNz05NPPsl9egAAQIGTo8AzZcqUPC4DAAAg7+Qo8HTv3j2v6wAAAMgzt3zjwRMnTujEiRPKyMhwaI+Ojs51UQAAAK7kdODZunWrunfvbr/3ztVsNpvS09NdVhwAAIArOB14nnjiCVWpUkXvv/++goKCHE5mBgAAKIicDjwHDx7UwoULVbly5byoBwAAwOWcvg9Py5Yt9eOPP+ZFLQAAAHnC6T087733nrp3767du3crKipK7u7uDq8/8MADLisOAADAFZwOPBs2bND69ev11VdfZXmNk5YBAEBB5PQhrWeffVZdu3bV8ePHlZGR4fAg7AAAgILI6cBz+vRpDRw4UEFBQXlRDwAAgMs5HXg6duyotWvX5kUtAAAAecLpc3iqVKmioUOHav369apZs2aWk5afffZZlxUHAADgCrd0lVaxYsWUkJCghIQEh9dsNhuBBwAAFDi3dONB5FyFF5fldwl/W4devz+/SwAAFBBOn8NzNWNMlu/TAgAAKGhuKfDMmTNHNWvWlLe3t7y9vRUdHa0PP/zQ1bUBAAC4hNOHtCZNmqRXXnlF/fr1U9OmTWWM0Xfffaenn35ap06d0sCBA/OiTgAAgFvmdOCZPn26ZsyYoW7dutnb2rdvrzvuuEMjRowg8AAAgALH6UNax48fV5MmTbK0N2nSRMePH3dJUQAAAK7kdOCpXLmyPv300yzt8+fPV2RkpEuKAgAAcCWnD2mNHDlSXbp00TfffKOmTZvKZrNp/fr1Wr16dbZBCAAAIL85vYenU6dO2rRpk0qVKqXFixdr4cKFKlWqlH744Qc9+OCDeVEjAABArji9h0eS6tatq48++sjVtQAAAOSJXN14EAAAoDDI8R6eIkWKyGaz3bCPzWZTWlparosCAABwpRwHnkWLFl33tQ0bNmj69Ol8zQQAACiQchx42rdvn6Vt3759Gjp0qJYsWaLHH39cr732mkuLAwAAcIVbOofn999/V69evRQdHa20tDTt2LFDs2fPVvny5V1dHwAAQK45FXiSkpL0wgsvqHLlytqzZ49Wr16tJUuWKCoqKq/qAwAAyLUcH9IaP368xo0bp+DgYM2dOzfbQ1wAAAAFUY4Dz4svvihvb29VrlxZs2fP1uzZs7Ptt3DhQpcVBwAA4Ao5DjzdunW76WXpAAAABVGOA8+sWbPysAwAAIC8w52WAQCA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RF4AACA5RXowDNixAjZbDaHR3BwsP11Y4xGjBih0NBQeXt7q1mzZtqzZ08+VgwAAAqiAh14JOmOO+7Q8ePH7Y9du3bZXxs/frwmTZqkN998U5s3b1ZwcLBatWql8+fP52PFAACgoCnwgcfNzU3BwcH2R+nSpSX9tXdnypQpGjZsmDp27KioqCjNnj1bf/75pz755JN8rhoAABQkBT7w7N+/X6GhoYqIiNAjjzyi//3vf5KkgwcPKjExUa1bt7b39fT0VExMjDZs2JBf5QIAgALILb8LuJGGDRtqzpw5qlKliv744w+NGjVKTZo00Z49e5SYmChJCgoKcnhPUFCQDh8+fMPlpqamKjU11f48OTnZ9cUDAIACo0AHnri4OPu/a9asqcaNG6tSpUqaPXu2GjVqJEmy2WwO7zHGZGm71tixYzVy5EjXFwwAAAqkAn9I62q+vr6qWbOm9u/fb79aK3NPT6YTJ05k2etzraFDhyopKcn+OHr0aJ7VDAAA8l+hCjypqanau3evQkJCFBERoeDgYMXHx9tfv3z5shISEtSkSZMbLsfT01PFixd3eAAAAOsq0Ie0hgwZonbt2ql8+fI6ceKERo0apeTkZHXv3l02m00DBgzQmDFjFBkZqcjISI0ZM0Y+Pj567LHH8rt0AABQgBTowHPs2DE9+uijOnXqlEqXLq1GjRpp48aNCg8PlyQ9//zzunjxovr06aOzZ8+qYcOGWrVqlfz8/PK5cgAAUJAU6MAzb968G75us9k0YsQIjRgx4vYUBAAACqVCdQ4PAADArSDwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAyyPwAAAAy7NM4Hn77bcVEREhLy8v1a1bV99++21+lwQAAAoISwSe+fPna8CAARo2bJi2b9+uu+++W3FxcTpy5Eh+lwYAAAoASwSeSZMmqWfPnnrqqadUvXp1TZkyRWFhYZoxY0Z+lwYAAAqAQh94Ll++rK1bt6p169YO7a1bt9aGDRvyqSoAAFCQuOV3Abl16tQppaenKygoyKE9KChIiYmJ2b4nNTVVqamp9udJSUmSpOTkZJfXl5H6p8uXiZzJi/m8GnObf5hb68rLuWVe809ezWvmco0xN+1b6ANPJpvN5vDcGJOlLdPYsWM1cuTILO1hYWF5Uhvyh/+U/K4AeYW5tS7m1pryel7Pnz8vf3//G/Yp9IGnVKlSKlq0aJa9OSdOnMiy1yfT0KFDNWjQIPvzjIwMnTlzRoGBgdcNSZmSk5MVFhamo0ePqnjx4rkfQAHGWK3r7zRexmpdf6fxMtbsGWN0/vx5hYaG3nS5hT7weHh4qG7duoqPj9eDDz5ob4+Pj1f79u2zfY+np6c8PT0d2kqUKOHUeosXL275H7pMjNW6/k7jZazW9XcaL2PN6mZ7djIV+sAjSYMGDVLXrl1Vr149NW7cWO+++66OHDmip59+Or9LAwAABYAlAk+XLl10+vRpvfrqqzp+/LiioqK0fPlyhYeH53dpAACgALBE4JGkPn36qE+fPnm+Hk9PTw0fPjzLITErYqzW9XcaL2O1rr/TeBlr7tlMTq7lAgAAKMQK/Y0HAQAAbobAAwAALI/AAwAALI/AAwAALI/Ac423335bERER8vLyUt26dfXtt99et++6detks9myPPbt23cbK74133zzjdq1a6fQ0FDZbDYtXrz4pu9JSEhQ3bp15eXlpYoVK+qdd97J+0JdxNnxFua5HTt2rOrXry8/Pz+VKVNGHTp00M8//3zT9xXG+b2VsRbWuZ0xY4aio6PtN2Nr3Lixvvrqqxu+pzDOaSZnx1tY5zU7Y8eOlc1m04ABA27YrzDPb6acjNVVc0vgucr8+fM1YMAADRs2TNu3b9fdd9+tuLg4HTly5Ibv+/nnn3X8+HH7IzIy8jZVfOtSUlJUq1Ytvfnmmznqf/DgQd133326++67tX37dr300kt69tlntWDBgjyu1DWcHW+mwji3CQkJ6tu3rzZu3Kj4+HilpaWpdevWSklJue57Cuv83spYMxW2uS1Xrpxef/11bdmyRVu2bFGLFi3Uvn177dmzJ9v+hXVOMzk73kyFbV6vtXnzZr377ruKjo6+Yb/CPr9SzseaKddza2DXoEED8/TTTzu0VatWzbz44ovZ9l+7dq2RZM6ePXsbqss7ksyiRYtu2Of555831apVc2jr3bu3adSoUR5WljdyMl6rzK0xxpw4ccJIMgkJCdftY5X5zclYrTS3JUuWNO+99162r1llTq92o/FaYV7Pnz9vIiMjTXx8vImJiTHPPffcdfsW9vl1Zqyumlv28Pyfy5cva+vWrWrdurVDe+vWrbVhw4YbvvfOO+9USEiIWrZsqbVr1+Zlmfnm+++/z7Jt2rRpoy1btujKlSv5VFXes8LcJiUlSZICAgKu28cq85uTsWYqzHObnp6uefPmKSUlRY0bN862j1XmVMrZeDMV5nnt27ev7r//fsXGxt60b2GfX2fGmim3c2uZOy3n1qlTp5Senp7lG9aDgoKyfBN7ppCQEL377ruqW7euUlNT9eGHH6ply5Zat26d7rnnnttR9m2TmJiY7bZJS0vTqVOnFBISkk+V5Q2rzK0xRoMGDdJdd92lqKio6/azwvzmdKyFeW537dqlxo0b69KlSypWrJgWLVqkGjVqZNvXCnPqzHgL87xK0rx587Rt2zZt3rw5R/0L8/w6O1ZXzS2B5xo2m83huTEmS1umqlWrqmrVqvbnjRs31tGjRzVx4sRC8QvmrOy2TXbtVmCVue3Xr5927typ9evX37RvYZ/fnI61MM9t1apVtWPHDp07d04LFixQ9+7dlZCQcN0QUNjn1JnxFuZ5PXr0qJ577jmtWrVKXl5eOX5fYZzfWxmrq+aWQ1r/p1SpUipatGiWvTknTpzIkqJvpFGjRtq/f7+ry8t3wcHB2W4bNzc3BQYG5lNVt1dhm9v+/fvryy+/1Nq1a1WuXLkb9i3s8+vMWLNTWObWw8NDlStXVr169TR27FjVqlVLU6dOzbZvYZ9TybnxZqewzOvWrVt14sQJ1a1bV25ubnJzc1NCQoKmTZsmNzc3paenZ3lPYZ3fWxlrdm5lbtnD8388PDxUt25dxcfH68EHH7S3x8fHq3379jlezvbt2wv0rsRb1bhxYy1ZssShbdWqVapXr57c3d3zqarbq7DMrTFG/fv316JFi7Ru3TpFRETc9D2FdX5vZazZKSxzey1jjFJTU7N9rbDO6Y3caLzZKSzz2rJlS+3atcuh7YknnlC1atX0wgsvqGjRolneU1jn91bGmp1bmttcnfJsMfPmzTPu7u7m/fffNz/99JMZMGCA8fX1NYcOHTLGGPPiiy+arl272vtPnjzZLFq0yPzyyy9m9+7d5sUXXzSSzIIFC/JrCDl2/vx5s337drN9+3YjyUyaNMls377dHD582BiTdaz/+9//jI+Pjxk4cKD56aefzPvvv2/c3d3N559/nl9DcIqz4y3Mc/vMM88Yf39/s27dOnP8+HH7488//7T3scr83spYC+vcDh061HzzzTfm4MGDZufOneall14yRYoUMatWrTLGWGdOMzk73sI6r9dz7ZVLVpvfq91srK6aWwLPNd566y0THh5uPDw8TJ06dRwub+3evbuJiYmxPx83bpypVKmS8fLyMiVLljR33XWXWbZsWT5U7bzMy/yufXTv3t0Yk3Wsxhizbt06c+eddxoPDw9ToUIFM2PGjNtf+C1ydryFeW6zG6ckM3PmTHsfq8zvrYy1sM7tk08+af9sKl26tGnZsqX9j78x1pnTTM6Ot7DO6/VcGwKsNr9Xu9lYXTW3NmP+7ywnAAAAi+KkZQAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgAAYHkEHgC3TWJiovr376+KFSvK09NTYWFhateunVavXp3fpQGwOL48FMBtcejQITVt2lQlSpTQ+PHjFR0drStXrmjlypXq27ev9u3bl98lArAw9vAAuC369Okjm82mH374QQ899JCqVKmiO+64Q4MGDdLGjRslSUeOHFH79u1VrFgxFS9eXJ07d9Yff/xhX8aIESNUu3ZtffDBBypfvryKFSumZ555Runp6Ro/fryCg4NVpkwZjR492mHdNptNM2bMUFxcnLy9vRUREaHPPvvMoc8LL7ygKlWqyMfHRxUrVtQrr7yiK1euZFn3hx9+qAoVKsjf31+PPPKIzp8/L0maM2eOAgMDs3ybd6dOndStWzeXbksAziPwAMhzZ86c0YoVK9S3b1/5+vpmeb1EiRIyxqhDhw46c+aMEhISFB8fr19//VVdunRx6Pvrr7/qq6++0ooVKzR37lx98MEHuv/++3Xs2DElJCRo3Lhxevnll+0hKtMrr7yiTp066ccff9Q//vEPPfroo9q7d6/9dT8/P82aNUs//fSTpk6dqv/+97+aPHlylnUvXrxYS5cu1dKlS5WQkKDXX39dkvTwww8rPT1dX375pb3/qVOntHTpUj3xxBO53oYAcim333IKADezadMmI8ksXLjwun1WrVplihYtao4cOWJv27Nnj5FkfvjhB2OMMcOHDzc+Pj4mOTnZ3qdNmzamQoUKJj093d5WtWpVM3bsWPtzSebpp592WF/Dhg3NM888c916xo8fb+rWrWt/nt26//Wvf5mGDRvanz/zzDMmLi7O/nzKlCmmYsWKJiMj47rrAXB7cA4PgDxnjJH016Gl69m7d6/CwsIUFhZmb6tRo4ZKlCihvXv3qn79+pKkChUqyM/Pz94nKChIRYsWVZEiRRzaTpw44bD8xo0bZ3m+Y8cO+/PPP/9cU6ZM0YEDB3ThwgWlpaWpePHiDu+5dt0hISEO6+nVq5fq16+v3377TWXLltXMmTPVo0ePG44bwO3BIS0AeS4yMlI2m83hENK1jDHZBoNr293d3R1et9ls2bZlZGTctK7M5W7cuFGPPPKI4uLitHTpUm3fvl3Dhg3T5cuXHfrfbD133nmnatWqpTlz5mjbtm3atWuXevTocdM6AOQ9Ag+APBcQEKA2bdrorbfeUkpKSpbXz507pxo1aujIkSM6evSovf2nn35SUlKSqlevnusarj2nZ+PGjapWrZok6bvvvlN4eLiGDRumevXqKTIyUocPH76l9Tz11FOaOXOmPvjgA8XGxjrssQKQfwg8AG6Lt99+W+np6WrQoIEWLFig/fv3a+/evZo2bZoaN26s2NhYRUdH6/HHH9e2bdv0ww8/qFu3boqJiVG9evVyvf7PPvtMH3zwgX755RcNHz5cP/zwg/r16ydJqly5so4cOaJ58+bp119/1bRp07Ro0aJbWs/jjz+u3377Tf/973/15JNP5rpuAK5B4AFwW0RERGjbtm1q3ry5Bg8erKioKLVq1UqrV6/WjBkzZLPZtHjxYpUsWVL33HOPYmNjVbFiRc2fP98l6x85cqTmzZun6OhozZ49Wx9//LFq1KghSWrfvr0GDhyofv36qXbt2tqwYYNeeeWVW1pP8eLF1alTJxUrVkwdOnRwSe0Acs9mMs8mBACLstlsWrRo0W0LIK1atVL16tU1bdq027I+ADfHVVoA4CJnzpzRqlWrtGbNGr355pv5XQ6AqxB4AMBF6tSpo7Nnz2rcuHGqWrVqfpcD4Coc0gIAAJbHScsAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDyCDwAAMDy/h/zrjlJvMlDWgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "compute_nb_clients(customer_musee)" - ] - }, - { - "cell_type": "markdown", - "id": "5eb3efcc-c7a9-4a0e-aab1-29a36032cb31", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "source": [ - "## Part de consentement à la reception de mails" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "848963c9-6129-4106-80b5-76bf814b70d1", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_449/1336968363.py:1: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n" - ] - } - ], - "source": [ - "customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n", - "\n", - "def mailing_consent(customer_musee):\n", - " df_graph = customer_musee.groupby([\"number_company\", \"already_purchased\"])[\"opt_in\"].mean().reset_index()\n", - " # Création du barplot groupé\n", - " fig, ax = plt.subplots(figsize=(10, 6))\n", - " \n", - " categories = df_graph[\"number_company\"].unique()\n", - " bar_width = 0.35\n", - " bar_positions = np.arange(len(categories))\n", - " \n", - " # Grouper les données par label et créer les barres groupées\n", - " for label in df_graph[\"already_purchased\"].unique():\n", - " label_data = df_graph[df_graph['already_purchased'] == label]\n", - " values = [label_data[label_data['number_company'] == category]['opt_in'].values[0]*100 for category in categories]\n", - " \n", - " label_printed = \"purchased\" if label else \"no purchase\"\n", - " ax.bar(bar_positions, values, bar_width, label=label_printed)\n", - " \n", - " # Mise à jour des positions des barres pour le prochain groupe\n", - " bar_positions = [pos + bar_width for pos in bar_positions]\n", - " \n", - " # Ajout des étiquettes, de la légende, etc.\n", - " ax.set_xlabel('Numero de compagnie')\n", - " ax.set_ylabel('Part de consentement (%)')\n", - " ax.set_title('Part de consentement au mailing selon les compagnies')\n", - " ax.set_xticks([pos + bar_width / 2 for pos in np.arange(len(categories))])\n", - " ax.set_xticklabels(categories)\n", - " ax.legend()\n", - " \n", - " # Affichage du plot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "c7239078-5c1a-4522-8d72-848efe7df28f", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mailing_consent(customer_musee)" - ] - }, - { - "cell_type": "markdown", - "id": "a6c94f0f-4ef4-432f-b2c9-11f51627b7e9", - "metadata": {}, - "source": [ - "## Part homme / femme client" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "321feb43-242e-4147-a5c8-ad1b41fc1246", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
customer_idstreet_idstructure_idmcp_contact_idfidelitytenant_idis_partnerdeleted_atgenderis_email_trueopt_inlast_buying_datemax_priceticket_sumaverage_priceaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepurchase_countfirst_buying_datecountrygender_labelgender_femalegender_malegender_othercountry_frnumber_companyalready_purchased
\n", - "
" - ], - "text/plain": [ - "Empty DataFrame\n", - "Columns: [customer_id, street_id, structure_id, mcp_contact_id, fidelity, tenant_id, is_partner, deleted_at, gender, is_email_true, opt_in, last_buying_date, max_price, ticket_sum, average_price, average_purchase_delay, average_price_basket, average_ticket_basket, total_price, purchase_count, first_buying_date, country, gender_label, gender_female, gender_male, gender_other, country_fr, number_company, already_purchased]\n", - "Index: []" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "customer_musee[customer_musee['gender_male'] + customer_musee['gender_female'] + customer_musee['gender_other'] == 0]" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "3bb5dc1e-05dc-41da-83bb-cb6b8d43fa73", - "metadata": {}, - "outputs": [], - "source": [ - "def gender_bar(customer_musee):\n", - " company_genders = customer_musee.groupby(\"number_company\")[[\"gender_male\", \"gender_female\", \"gender_other\"]].mean().reset_index()\n", - " \n", - " # Création du barplot\n", - " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_male\"], label = \"Homme\")\n", - " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_female\"], \n", - " bottom = company_genders[\"gender_male\"], label = \"Femme\")\n", - " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_other\"], \n", - " bottom = company_genders[\"gender_male\"] + company_genders[\"gender_female\"], label = \"Inconnu\")\n", - " \n", - " # Ajout de titres et d'étiquettes\n", - " plt.xlabel('Company')\n", - " plt.ylabel(\"Part de clients de chaque sexe\")\n", - " plt.title(\"Sexe des clients de chaque compagnie de musee\")\n", - " plt.legend()\n", - "\n", - " # Définir les étiquettes de l'axe x\n", - " plt.xticks(company_genders[\"number_company\"], [\"{}\".format(i) for i in company_genders[\"number_company\"]])\n", - " \n", - " \n", - " # Affichage du barplot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "id": "c61c4b41-ba31-44f4-9515-25922798b86a", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "gender_bar(customer_musee)" - ] - }, - { - "cell_type": "markdown", - "id": "b02a2668-5cea-44db-b2b5-168f7738a949", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "source": [ - "## Part de clients français" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "id": "4b3bb641-814b-4679-9a67-4eca87a920a6", - "metadata": {}, - "outputs": [], - "source": [ - "def country_bar(customer_sport):\n", - " company_country_fr = customer_sport.groupby(\"number_company\")[\"country_fr\"].mean().reset_index()\n", - " # Création du barplot\n", - " plt.bar(company_country_fr[\"number_company\"], company_country_fr[\"country_fr\"])\n", - " \n", - " # Ajout de titres et d'étiquettes\n", - " plt.xlabel('Company')\n", - " plt.ylabel(\"Part de clients français\")\n", - " plt.title(\"Nationalité des clients de chaque compagnie de musée\")\n", - "\n", - " # Définir les étiquettes de l'axe x\n", - " plt.xticks(company_country_fr[\"number_company\"], [\"{}\".format(i) for i in company_country_fr[\"number_company\"]])\n", - "\n", - " \n", - " # Affichage du barplot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "id": "01258674-6b98-49e4-93f4-f4185964999f", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "country_bar(customer_musee)" - ] - }, - { - "cell_type": "markdown", - "id": "6c9e8051-06d1-44ed-aa17-eb8ddd9fb5ed", - "metadata": {}, - "source": [ - "## Ouverture mails" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "id": "e346fdc0-617f-463b-af29-caa0d9f88485", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "def campaigns_effectiveness(customer_sport, Train=False):\n", - " if not Train:\n", - " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n", - "\n", - " nb_customers_purchasing = customer_sport[customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", - " nb_customers_no_purchase = customer_sport[~customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", - "\n", - " plt.bar(nb_customers_purchasing[\"number_company\"], nb_customers_purchasing[\"customer_id\"]/1000, label = \"has purchased\")\n", - " plt.bar(nb_customers_no_purchase[\"number_company\"], nb_customers_no_purchase[\"customer_id\"]/1000, \n", - " bottom = nb_customers_purchasing[\"customer_id\"]/1000, label = \"has not purchased\")\n", - " \n", - " \n", - " # Ajout de titres et d'étiquettes\n", - " plt.xlabel('Company')\n", - " plt.ylabel(\"Nombre de clients (en milliers)\")\n", - " plt.title(\"Nombre de clients ayant acheté ou été ciblés par des mails pour les compagnies de musée\")\n", - " plt.legend()\n", - "\n", - " \n", - " \n", - " # Affichage du barplot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "id": "928dab1d-96ff-4fc2-91ea-2ff119620f31", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_449/3480143790.py:3: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "campaigns_effectiveness(customer_musee)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}