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() diff --git a/1_Descriptive_Statistics_Museum.ipynb b/Musee/1_Descriptive_Statistics_Museum.ipynb similarity index 72% rename from 1_Descriptive_Statistics_Museum.ipynb rename to Musee/1_Descriptive_Statistics_Museum.ipynb index 1023f39..b172044 100644 --- a/1_Descriptive_Statistics_Museum.ipynb +++ b/Musee/1_Descriptive_Statistics_Museum.ipynb @@ -93,16 +93,442 @@ }, { "cell_type": "code", - "execution_count": 56, + "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", + "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", @@ -1242,120 +1668,17 @@ { "cell_type": "markdown", "id": "45d5261f-4d46-49cb-8582-dd2121122b05", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 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" ] @@ -3782,7 +4105,9 @@ { "cell_type": "markdown", "id": "d679204b-f3e8-4502-8de9-3bf4180da3bd", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 2 - Autres informations sur client " ] @@ -3996,6 +4321,463 @@ "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": { 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 +}