{"cells":[{"cell_type":"markdown","metadata":{"id":"1HeyIgs-1O4k"},"source":["# **<span style=\"color: #8181FF\">Simulation to determine the required update frequency</span>**"]},{"cell_type":"markdown","metadata":{"id":"x4A6HmHm1O4m"},"source":["## **Goal**\n","\n","We want to test the model's stability over time.<br>\n","Since we can't predict what data will be added to the dataset in the future, we'll go back in time.<br>\n","First, we will train the model on the customers of an initial period. Each of these customers will be assigned a cluster label.<br>\n","We will then re-train the model, successively adding data and watching the evolution of the labels assigned to customers in the initial period..<br>\n","To compare labels, I'll use the Adjusted Rand Score (ARI)."]},{"cell_type":"markdown","source":["## Importing Libraries"],"metadata":{"id":"-g5XZvycWm9U"}},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":14688,"status":"ok","timestamp":1745568375892,"user":{"displayName":"Grégoire","userId":"01249298206117462766"},"user_tz":-120},"id":"b39AUUH4QUuX","outputId":"8dbc595c-c1e0-4625-e4ad-3ef5514358b8"},"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]},{"output_type":"execute_result","data":{"text/plain":["['Liste+de+requetes+SQL+pour+le+dashboard.pdf',\n"," 'olist.db',\n"," 'scripts_sql.sql',\n"," 'requirements.txt',\n"," 'Copie de 01-Analyse_Exploratoire.ipynb',\n"," 'X_tSNE.xlsx',\n"," 'X_tSNE_birch.xlsx',\n"," 'X_tSNE_8_parameters.xlsx',\n"," 'X_tSNE_17_parameters.xlsx',\n"," 'X_tSNE_3_parameters.xlsx',\n"," 'X_tSNE_4_parameters.xlsx',\n"," 'X_tSNE_5_parameters__avg_payment_sequential_avg_review_score.xlsx',\n"," 'Copie de 02-Modélisation.ipynb',\n"," '03-FRQ~1.ipynb',\n"," 'data_global.xlsx',\n"," '01-Analyse_Exploratoire.ipynb',\n"," '02-Modélisation.ipynb',\n"," '03-Fréquence_de_mise_à_jour.ipynb']"]},"metadata":{},"execution_count":6}],"source":["from google.colab import drive\n","drive.mount('/content/drive')\n","import os\n","drive_folder=  \"/content/drive/MyDrive/Colab_Notebooks/Project_5\"\n","os.chdir(drive_folder)\n","os.listdir()"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4,"status":"ok","timestamp":1745568404406,"user":{"displayName":"Grégoire","userId":"01249298206117462766"},"user_tz":-120},"id":"RvYrULWEdOI5","outputId":"87dbab99-efb1-4b73-8285-d2a593d3e30b"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["['Liste+de+requetes+SQL+pour+le+dashboard.pdf',\n"," 'olist.db',\n"," 'scripts_sql.sql',\n"," 'requirements.txt',\n"," 'Copie de 01-Analyse_Exploratoire.ipynb',\n"," 'X_tSNE.xlsx',\n"," 'X_tSNE_birch.xlsx',\n"," 'X_tSNE_8_parameters.xlsx',\n"," 'X_tSNE_17_parameters.xlsx',\n"," 'X_tSNE_3_parameters.xlsx',\n"," 'X_tSNE_4_parameters.xlsx',\n"," 'X_tSNE_5_parameters__avg_payment_sequential_avg_review_score.xlsx',\n"," 'Copie de 02-Modélisation.ipynb',\n"," '03-FRQ~1.ipynb',\n"," 'data_global.xlsx',\n"," '01-Analyse_Exploratoire.ipynb',\n"," '02-Modélisation.ipynb',\n"," '03-Fréquence_de_mise_à_jour.ipynb']"]},"metadata":{},"execution_count":8}],"source":["import os\n","os.listdir()"]},{"cell_type":"code","execution_count":9,"metadata":{"id":"017sZl9-1O4m","executionInfo":{"status":"ok","timestamp":1745568404444,"user_tz":-120,"elapsed":39,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["# Basic libraries\n","import pandas as pd\n","import numpy as np\n","\n","# Visualizations\n","import matplotlib.pyplot as plt\n","\n","# To normalize and encode data\n","from sklearn.preprocessing import StandardScaler, OneHotEncoder\n","from sklearn.compose import ColumnTransformer\n","\n","# Used for clustering model\n","from sklearn import cluster\n","\n","# Used to compare clusters\n","from sklearn.metrics import adjusted_rand_score\n","\n","# To measure fits and notebook runtimes\n","import time"]},{"cell_type":"markdown","metadata":{"id":"_hiA3KOA1O4n"},"source":["- Measuring notebook runtime :"]},{"cell_type":"code","execution_count":10,"metadata":{"id":"MLcRArut1O4n","executionInfo":{"status":"ok","timestamp":1745568404470,"user_tz":-120,"elapsed":25,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["t_notebook = time.time()"]},{"cell_type":"markdown","metadata":{"id":"w57ZD2X91O4n"},"source":["## **Dataset import**"]},{"cell_type":"code","execution_count":7,"metadata":{"id":"Jv49vT6J1O4n","executionInfo":{"status":"ok","timestamp":1745568404401,"user_tz":-120,"elapsed":28507,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["data = pd.read_excel(\"data_global.xlsx\")"]},{"cell_type":"markdown","metadata":{"id":"M0Eh1NOg1O4n"},"source":["## **Defining the functions to be used**"]},{"cell_type":"markdown","metadata":{"id":"2OmZHa191O4n"},"source":["- For scaling numerical variables and encoding categorical variables :"]},{"cell_type":"code","execution_count":11,"metadata":{"id":"EMtS797J1O4o","executionInfo":{"status":"ok","timestamp":1745568404472,"user_tz":-120,"elapsed":1,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["def scale_and_encode(features, data, display=True):\n","    \"\"\"\n","    This function scales numerical data and encodes categorical variables while preserving\n","    column names after transformation.\n","\n","    - features: list of columns to include\n","    - data: data used (Pandas DataFrame)\n","    - Returns a DataFrame with the transformed columns and their updated names.\n","    \"\"\"\n","\n","    # Select numerical variables\n","    numeric_features = data[features].select_dtypes(include=['number']).columns.tolist()\n","\n","    # Selection of categorical variables\n","    categorical_features = data[features].select_dtypes(exclude=['number']).columns.tolist()\n","\n","    if display:\n","      print(\"Standard-scaled numeric features:\", numeric_features)\n","      print(\"One hot encoded categorical features:\", categorical_features)\n","\n","    # Data selection\n","    X = data.loc[:, features]\n","\n","    # Scaler instantiation\n","    numeric_transformer = StandardScaler()\n","    # Encoder instantiation\n","    categorical_transformer = OneHotEncoder(sparse_output=False)\n","\n","    # Combining transformations\n","    transformers = []\n","    if categorical_features:  # Add categorical transformer only if there are categorical features\n","        transformers.append(('cat', categorical_transformer, categorical_features))\n","    if numeric_features:  # Add numeric transformer only if there are numeric features\n","        transformers.append(('num', numeric_transformer, numeric_features))\n","\n","    feature_encoder = ColumnTransformer(transformers=transformers)\n","\n","    # Data transformation\n","    X_transformed = feature_encoder.fit_transform(X)\n","\n","    # Recovery of transformed column names\n","    all_column_names = []\n","    if categorical_features:\n","        cat_column_names = feature_encoder.named_transformers_['cat'].get_feature_names_out(categorical_features)\n","        all_column_names.extend(cat_column_names)\n","    if numeric_features:\n","        all_column_names.extend(numeric_features)\n","\n","    # Construction of the final DataFrame with the names\n","    X_transformed_df = pd.DataFrame(X_transformed, columns=all_column_names, index=data.index)\n","\n","    return X_transformed_df\n"]},{"cell_type":"markdown","metadata":{"id":"Kp8uoz4q1O4o"},"source":["- Measuring stability over time :"]},{"cell_type":"code","source":["from sklearn.cluster import KMeans, BisectingKMeans\n","from sklearn.metrics import adjusted_rand_score\n","import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","def delta_ari(data, features, delta=1, initial_duration=12, clusters=5, display_table=True, n_init=10, model_type='KMeans'):\n","    \"\"\"\n","    This function calculates the Adjusted Rand Index (ARI) score between cluster labels\n","    determined over the initial period and when new data is added to the initial dataset.\n","\n","    ARI (between 0 and 1) will compare individuals in common for two clusters models (e.g the first trained on 12 months, the second on 15 months).\n","    Roughly, the goal is to compare the in-common individuals clusters tags. If they have changed, then que ARI is falling:\n","    Low ARI scores mean the model has to be retrained.\n","\n","    delta: Time interval (in months) at which to calculate the comparison.\n","    initial_duration: Duration (in months) covered by the initial period.\n","    clusters: Number of clusters to return using the specified clustering model.\n","    display_table: Whether to show the ARI scores in a table (True/False).\n","    n_init: Number of initializations for clustering algorithms.\n","    model_type: Type of clustering model to use ('KMeans' or 'BisectingKMeans').\n","    \"\"\"\n","\n","    # Validate the model_type parameter\n","    if model_type not in ['KMeans', 'BisectingKMeans']:\n","        raise ValueError(\"model_type must be either 'KMeans' or 'BisectingKMeans'.\")\n","\n","    # Select the clustering model class based on the model_type\n","    if model_type == 'KMeans':\n","        ClusteringModel = KMeans\n","    elif model_type == 'BisectingKMeans':\n","        ClusteringModel = BisectingKMeans\n","\n","    # Calculate the total period (in months) covered by the dataset\n","    period_months = (data['first_purchase_date'].max() - data['first_purchase_date'].min()).days / 30.44  # Approx. days/month\n","    print(f\"Total period covered by the dataset: {period_months:.2f} months\")\n","    initial_period = initial_duration\n","    print(f\"Selected duration for the initial period: {initial_period} months.\")\n","\n","    # Number of clusters for the clustering model\n","    cluster_nb = clusters\n","\n","    # Create the dataset covering the initial period\n","    start_date_initial = data['first_purchase_date'].min().replace(day=1)\n","    end_date_initial = start_date_initial + pd.DateOffset(months=initial_period)\n","    end_date_initial = end_date_initial.replace(day=pd.to_datetime(end_date_initial).days_in_month)\n","    data_initial = data[(data['first_purchase_date'] >= start_date_initial) & (data['first_purchase_date'] < end_date_initial)].copy()\n","\n","    # Recompute recency and frequency variables since we have a new segment\n","    data_initial['recency'] = (data_initial['last_purchase_date'].max() - data_initial['last_purchase_date']).dt.days\n","    data_initial['frequency'] = (data_initial['last_purchase_date'].max() - data_initial['first_purchase_date']).dt.days / data_initial['orders_number']\n","\n","    # Train the model on the initial period\n","    X_scaled__initial = scale_and_encode(features=features_list, data=data_initial, display=False)\n","    X_model = X_scaled__initial\n","    clustering_model = ClusteringModel(\n","        n_clusters=cluster_nb,\n","        init='k-means++',\n","        random_state=19,\n","        n_init=n_init,\n","        max_iter=300\n","    )\n","    clustering_model.fit(X_model)\n","    labels_initial = clustering_model.labels_\n","    data_initial['Initial_Clusters'] = labels_initial\n","\n","    # Time interval (delta) for adding new data\n","    delta_chosen = delta\n","    print(\"Chosen delta for tracking:\", delta_chosen, \"months.\")\n","\n","    # ARI scores for each period will be stored in this list\n","    ari_scores = []\n","\n","    # First additional period will equal delta_chosen\n","    period = delta_chosen\n","\n","    # Train the model for each period and compare labels to the initial period\n","    # Each new iteration, the model will be trained on data_initial time range + i*delta_chosen until reaching the whole data time range\n","    # Each iteration prédictions will be compared with\n","    for i in range(int((period_months - initial_duration) / delta_chosen)):\n","        # Create the dataset for the new period including the initial period + additional data\n","        start_date = data['first_purchase_date'].min().replace(day=1)\n","        end_date = start_date + pd.DateOffset(months=initial_duration) + pd.DateOffset(months=period)\n","        end_date = end_date.replace(day=pd.to_datetime(end_date).days_in_month)\n","        data_period = data[(data['first_purchase_date'] >= start_date) & (data['first_purchase_date'] < end_date)].copy()\n","\n","        # Recompute recency and frequency variables\n","        data_period['recency'] = (data_period['last_purchase_date'].max() - data_period['last_purchase_date']).dt.days\n","        data_period['frequency'] = (data_period['last_purchase_date'].max() - data_period['first_purchase_date']).dt.days / data_period['orders_number']\n","\n","        # Train the model on the current period\n","        X_scaled_period = scale_and_encode(features=features_list, data=data_period, display=False)\n","        X_model = X_scaled_period\n","        clustering_model = ClusteringModel(\n","            n_clusters=cluster_nb,\n","            init='k-means++',\n","            random_state=19,\n","            n_init=n_init,\n","            max_iter=300\n","        )\n","        clustering_model.fit(X_model)\n","        labels_period = clustering_model.labels_\n","        data_period['Period_Clusters'] = labels_period\n","\n","        # Clusters of initial clients using the initial period data\n","        a = data_initial['Initial_Clusters']\n","\n","        # Clusters of initial clients using the data from the current period\n","        b = data_period.loc[data_period['first_purchase_date'] <= data_initial['first_purchase_date'].max()]['Period_Clusters']\n","\n","        # Append the calculated ARI score\n","        ari_scores.append([period, adjusted_rand_score(a, b)])\n","\n","        # Increment the period for the next iteration\n","        period += delta_chosen\n","\n","    # Create a DataFrame with ARI scores for each period\n","    ari_scores = pd.DataFrame(ari_scores, columns=[\"Months\", \"ARI Score\"])\n","\n","    # Optionally display the dataframe of ARI scores\n","    if display_table:\n","        display(ari_scores)\n","\n","    # Plot the ARI scores over time\n","    fig, ax = plt.subplots(figsize=(12, 8))\n","\n","    plt.grid(\n","        True,\n","        linestyle='--',\n","        color='gray',\n","        linewidth=0.5,\n","    )\n","\n","    ax.plot(\n","        ari_scores[\"Months\"],\n","        ari_scores[\"ARI Score\"],\n","        marker='o',\n","        markersize=10,\n","        linestyle='-',\n","        color=\"#8181FF\",\n","        linewidth=3,\n","    )\n","\n","    # Set x-axis ticks based on delta_chosen\n","    ax.set_xticks(range(delta_chosen, period, delta_chosen))\n","    ax.set_xlim(delta_chosen, period - delta_chosen)\n","\n","    plt.title(f'\\nCluster evolution over time\\ncompared to the initial period ({initial_duration} months)\\n', fontsize=25)\n","    plt.xticks(fontsize=16)\n","    plt.yticks(fontsize=16)\n","    ax.set_xlabel(\"\\nMonths\\n\", fontsize=25)\n","    ax.set_ylabel(\"\\nARI Scores\\n\", fontsize=25)\n","\n","    plt.show()\n"],"metadata":{"id":"dMhkg7vVJNp8","executionInfo":{"status":"ok","timestamp":1745568690973,"user_tz":-120,"elapsed":19,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"execution_count":16,"outputs":[]},{"cell_type":"markdown","source":["## RFM Model only"],"metadata":{"id":"MfBcl6ohB0FY"}},{"cell_type":"markdown","metadata":{"id":"Nbd-_D89J1Ew"},"source":["### **Choosing features to use with the model.**"]},{"cell_type":"markdown","metadata":{"id":"BuuUQENuJ1Ew"},"source":["- Choosing features :"]},{"cell_type":"code","execution_count":13,"metadata":{"id":"OvYeodjZJ1Ew","executionInfo":{"status":"ok","timestamp":1745568404534,"user_tz":-120,"elapsed":17,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["features_list = [\n","    # 'customer_lat',\n","    # 'customer_lng',\n","    # 'orders_number',\n","    # 'first_purchase_date',\n","    # 'last_purchase_date',\n","    'recency', # keep this one (RFM)\n","    'frequency', # keep this one (RFM)\n","    # 'avg_spent',\n","    'total_spent', # keep this one (RFM)\n","    # 'preferred_payment_type',\n","    # 'avg_payment_sequential',\n","    # 'avg_payment_installments',\n","    # 'shipping_fees_proportion',\n","    # 'avg_customer_seller_distance_km',\n","    # 'avg_delivery_time',\n","    # 'preferred_category', # tested : generates noise.\n","    # 'avg_review_score',\n","]"]},{"cell_type":"markdown","metadata":{"id":"NzqAugL6J1Ew"},"source":["### **Model stability over time**"]},{"cell_type":"code","source":["delta_ari(data=data, features=features_list, delta=1, initial_duration=14, clusters=5, display_table=False, n_init=10, model_type='KMeans')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"qK4yzjSOKEOV","executionInfo":{"status":"ok","timestamp":1745568700587,"user_tz":-120,"elapsed":7516,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}},"outputId":"415b5876-6671-46df-8bf0-d2075a16184b"},"execution_count":17,"outputs":[{"output_type":"stream","name":"stdout","text":["Total period covered by the dataset: 23.42 months\n","Selected duration for the initial period: 14 months.\n","Chosen delta for tracking: 1 months.\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x800 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"AgJ2PGgCJ1Ex"},"source":["**The ARI score falls fastly. The best thing would be to re-train the model every month. Every 2 months stays acceptable.**"]},{"cell_type":"markdown","source":["## Advanced Model"],"metadata":{"id":"0FGBfbUZB2LS"}},{"cell_type":"markdown","metadata":{"id":"CHaUOh_O1O4o"},"source":["### **Choosing features to use with the model.**"]},{"cell_type":"markdown","metadata":{"id":"jREK38uR1O4o"},"source":["- Choosing features :"]},{"cell_type":"code","execution_count":18,"metadata":{"id":"Npqld4241O4o","executionInfo":{"status":"ok","timestamp":1745568704243,"user_tz":-120,"elapsed":41,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[],"source":["features_list = [\n","    # 'customer_lat',\n","    # 'customer_lng',\n","    # 'orders_number',\n","    # 'first_purchase_date',\n","    # 'last_purchase_date',\n","    'recency', # keep this one (RFM)\n","    'frequency', # keep this one (RFM)\n","    # 'avg_spent',\n","    'total_spent', # keep this one (RFM)\n","    # 'preferred_payment_type',\n","    'avg_payment_sequential',\n","    # 'avg_payment_installments',\n","    # 'shipping_fees_proportion',\n","    # 'avg_customer_seller_distance_km',\n","    # 'avg_delivery_time',\n","    # 'preferred_category', # tested : generates noise.\n","    'avg_review_score',\n","]"]},{"cell_type":"markdown","metadata":{"id":"GjXsFwFA1O4o"},"source":["### **Model stability over time**"]},{"cell_type":"code","source":["delta_ari(data=data, features=features_list, delta=1, initial_duration=14, clusters=5, display_table=False, n_init=10, model_type='KMeans')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"dXg25Fs5J92y","executionInfo":{"status":"ok","timestamp":1745568712151,"user_tz":-120,"elapsed":6896,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}},"outputId":"860e2e5e-1438-4d5d-fd8d-8ef10ccc8034"},"execution_count":19,"outputs":[{"output_type":"stream","name":"stdout","text":["Total period covered by the dataset: 23.42 months\n","Selected duration for the initial period: 14 months.\n","Chosen delta for tracking: 1 months.\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1200x800 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"xEZ0u1Z61O4o"},"source":["**The ARI score falls fastly. The best thing would be to re-train the model every month. 2 to 3 months can be accepted.**\n","\n","This model has the best performances and is definitely recommended compared to the standard RFM one."]},{"cell_type":"markdown","metadata":{"id":"Ad4kCan81O4o"},"source":["# Notebook runtime display :"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"EVW5jH7t1O4p","outputId":"9431496b-5157-4eb9-e718-1d43492e17cf","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1745421305011,"user_tz":-120,"elapsed":3,"user":{"displayName":"Grégoire","userId":"01249298206117462766"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Notebook runtime (excluding imports): 01:15\n"]}],"source":["temps_secondes = time.time() - t_notebook\n","\n","# Conversion to minutes and seconds\n","minutes = int(temps_secondes // 60)\n","seconds = int(temps_secondes % 60)\n","\n","# Result formatting\n","formatted_time = f\"{minutes:02}:{seconds:02}\"\n","\n","print(f\"Notebook runtime (excluding imports): {formatted_time}\")"]},{"cell_type":"code","source":[],"metadata":{"id":"e5svFnUnZ-ab"},"execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"base","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.10.9"},"orig_nbformat":4,"colab":{"provenance":[],"toc_visible":true}},"nbformat":4,"nbformat_minor":0}