├── ModelBuilding.ipynb
├── README.md
├── clustering_helper_functions .ipynb
├── customer_segmentation.csv
├── order_segmentation_0.0.csv
├── ulabox_customer_segmentation_0.0.ipynb
└── ulabox_order_segmentation_0.0.ipynb


/ModelBuilding.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "markdown",
   5 |    "metadata": {},
   6 |    "source": [
   7 |     "Here we will build a gradient boosting trees model to classify the customers into corresponding classes.<br>\n",
   8 |     "<br>\n",
   9 |     "Recall that we used averages over all the orders of a customer to calculate Food%, Fresh% etc. of a customer. A customer may change from one class to another, which is natural. Birth of a new baby may make the customer new_parents, after years once the baby grows up they become normal again. A customer may turn more health concious when he gets old.<br>\n",
  10 |     "<br>\n",
  11 |     "To address this problem we can update the data of the customer with the current average after every order and put the data again to be predicted by the model. A better idea will be to use the concept of exponential moving average which is used in technical analysis of stock markets. We can have a certain number of orders as the look back period for the exponential moving average. What a moving average does is, it gives exponentially more importance to the recent data and less importance to the earlier data. Their by catching current trend in the customer's orders.<br>"
  12 |    ]
  13 |   },
  14 |   {
  15 |    "cell_type": "markdown",
  16 |    "metadata": {},
  17 |    "source": [
  18 |     "Here we will just create a basic model with the data we have."
  19 |    ]
  20 |   },
  21 |   {
  22 |    "cell_type": "code",
  23 |    "execution_count": 1,
  24 |    "metadata": {},
  25 |    "outputs": [],
  26 |    "source": [
  27 |     "import pandas as pd\n",
  28 |     "import numpy as np\n",
  29 |     "import matplotlib.pyplot as plt\n",
  30 |     "import matplotlib as mpl\n",
  31 |     "import seaborn as sns\n",
  32 |     "import scipy as sc\n",
  33 |     "import xgboost as xgb\n",
  34 |     "import itertools"
  35 |    ]
  36 |   },
  37 |   {
  38 |    "cell_type": "code",
  39 |    "execution_count": 14,
  40 |    "metadata": {},
  41 |    "outputs": [],
  42 |    "source": [
  43 |     "from xgboost.sklearn import XGBClassifier"
  44 |    ]
  45 |   },
  46 |   {
  47 |    "cell_type": "code",
  48 |    "execution_count": 18,
  49 |    "metadata": {},
  50 |    "outputs": [],
  51 |    "source": [
  52 |     "import warnings\n",
  53 |     "warnings.filterwarnings('ignore')"
  54 |    ]
  55 |   },
  56 |   {
  57 |    "cell_type": "code",
  58 |    "execution_count": 2,
  59 |    "metadata": {},
  60 |    "outputs": [],
  61 |    "source": [
  62 |     "data = pd.read_csv('customer_segmentation.csv')"
  63 |    ]
  64 |   },
  65 |   {
  66 |    "cell_type": "code",
  67 |    "execution_count": 3,
  68 |    "metadata": {},
  69 |    "outputs": [
  70 |     {
  71 |      "data": {
  72 |       "text/html": [
  73 |        "<div>\n",
  74 |        "<style scoped>\n",
  75 |        "    .dataframe tbody tr th:only-of-type {\n",
  76 |        "        vertical-align: middle;\n",
  77 |        "    }\n",
  78 |        "\n",
  79 |        "    .dataframe tbody tr th {\n",
  80 |        "        vertical-align: top;\n",
  81 |        "    }\n",
  82 |        "\n",
  83 |        "    .dataframe thead th {\n",
  84 |        "        text-align: right;\n",
  85 |        "    }\n",
  86 |        "</style>\n",
  87 |        "<table border=\"1\" class=\"dataframe\">\n",
  88 |        "  <thead>\n",
  89 |        "    <tr style=\"text-align: right;\">\n",
  90 |        "      <th></th>\n",
  91 |        "      <th>customer</th>\n",
  92 |        "      <th>order</th>\n",
  93 |        "      <th>total_items</th>\n",
  94 |        "      <th>discount%</th>\n",
  95 |        "      <th>weekday</th>\n",
  96 |        "      <th>hour</th>\n",
  97 |        "      <th>Food%</th>\n",
  98 |        "      <th>Fresh%</th>\n",
  99 |        "      <th>Drinks%</th>\n",
 100 |        "      <th>Home%</th>\n",
 101 |        "      <th>Beauty%</th>\n",
 102 |        "      <th>Health%</th>\n",
 103 |        "      <th>Baby%</th>\n",
 104 |        "      <th>Pets%</th>\n",
 105 |        "      <th>num_orders</th>\n",
 106 |        "      <th>labels</th>\n",
 107 |        "      <th>class</th>\n",
 108 |        "    </tr>\n",
 109 |        "  </thead>\n",
 110 |        "  <tbody>\n",
 111 |        "    <tr>\n",
 112 |        "      <th>0</th>\n",
 113 |        "      <td>0</td>\n",
 114 |        "      <td>0</td>\n",
 115 |        "      <td>44.666667</td>\n",
 116 |        "      <td>14.110000</td>\n",
 117 |        "      <td>4</td>\n",
 118 |        "      <td>13</td>\n",
 119 |        "      <td>14.070000</td>\n",
 120 |        "      <td>73.203333</td>\n",
 121 |        "      <td>4.356667</td>\n",
 122 |        "      <td>6.200000</td>\n",
 123 |        "      <td>2.176667</td>\n",
 124 |        "      <td>0.000</td>\n",
 125 |        "      <td>0.000000</td>\n",
 126 |        "      <td>0.0</td>\n",
 127 |        "      <td>3.0</td>\n",
 128 |        "      <td>1</td>\n",
 129 |        "      <td>fresh_regulars</td>\n",
 130 |        "    </tr>\n",
 131 |        "    <tr>\n",
 132 |        "      <th>1</th>\n",
 133 |        "      <td>1</td>\n",
 134 |        "      <td>3</td>\n",
 135 |        "      <td>31.150000</td>\n",
 136 |        "      <td>17.849000</td>\n",
 137 |        "      <td>1</td>\n",
 138 |        "      <td>12</td>\n",
 139 |        "      <td>17.762000</td>\n",
 140 |        "      <td>52.909000</td>\n",
 141 |        "      <td>17.761000</td>\n",
 142 |        "      <td>3.207500</td>\n",
 143 |        "      <td>2.314500</td>\n",
 144 |        "      <td>4.352</td>\n",
 145 |        "      <td>1.695000</td>\n",
 146 |        "      <td>0.0</td>\n",
 147 |        "      <td>20.0</td>\n",
 148 |        "      <td>4</td>\n",
 149 |        "      <td>loyals</td>\n",
 150 |        "    </tr>\n",
 151 |        "    <tr>\n",
 152 |        "      <th>2</th>\n",
 153 |        "      <td>2</td>\n",
 154 |        "      <td>23</td>\n",
 155 |        "      <td>26.000000</td>\n",
 156 |        "      <td>2.970000</td>\n",
 157 |        "      <td>6</td>\n",
 158 |        "      <td>23</td>\n",
 159 |        "      <td>24.100000</td>\n",
 160 |        "      <td>22.290000</td>\n",
 161 |        "      <td>38.690000</td>\n",
 162 |        "      <td>14.920000</td>\n",
 163 |        "      <td>0.000000</td>\n",
 164 |        "      <td>0.000</td>\n",
 165 |        "      <td>0.000000</td>\n",
 166 |        "      <td>0.0</td>\n",
 167 |        "      <td>1.0</td>\n",
 168 |        "      <td>8</td>\n",
 169 |        "      <td>grocery_regulars</td>\n",
 170 |        "    </tr>\n",
 171 |        "    <tr>\n",
 172 |        "      <th>3</th>\n",
 173 |        "      <td>3</td>\n",
 174 |        "      <td>24</td>\n",
 175 |        "      <td>27.782609</td>\n",
 176 |        "      <td>4.102174</td>\n",
 177 |        "      <td>1</td>\n",
 178 |        "      <td>10</td>\n",
 179 |        "      <td>23.825652</td>\n",
 180 |        "      <td>51.280870</td>\n",
 181 |        "      <td>8.220870</td>\n",
 182 |        "      <td>14.773478</td>\n",
 183 |        "      <td>0.000000</td>\n",
 184 |        "      <td>0.000</td>\n",
 185 |        "      <td>1.898696</td>\n",
 186 |        "      <td>0.0</td>\n",
 187 |        "      <td>23.0</td>\n",
 188 |        "      <td>4</td>\n",
 189 |        "      <td>loyals</td>\n",
 190 |        "    </tr>\n",
 191 |        "    <tr>\n",
 192 |        "      <th>4</th>\n",
 193 |        "      <td>4</td>\n",
 194 |        "      <td>47</td>\n",
 195 |        "      <td>17.103448</td>\n",
 196 |        "      <td>4.373103</td>\n",
 197 |        "      <td>3</td>\n",
 198 |        "      <td>9</td>\n",
 199 |        "      <td>24.841379</td>\n",
 200 |        "      <td>51.082414</td>\n",
 201 |        "      <td>10.291034</td>\n",
 202 |        "      <td>13.035172</td>\n",
 203 |        "      <td>0.683793</td>\n",
 204 |        "      <td>0.000</td>\n",
 205 |        "      <td>0.065517</td>\n",
 206 |        "      <td>0.0</td>\n",
 207 |        "      <td>29.0</td>\n",
 208 |        "      <td>4</td>\n",
 209 |        "      <td>loyals</td>\n",
 210 |        "    </tr>\n",
 211 |        "  </tbody>\n",
 212 |        "</table>\n",
 213 |        "</div>"
 214 |       ],
 215 |       "text/plain": [
 216 |        "   customer  order  total_items  discount%  weekday  hour      Food%  \\\n",
 217 |        "0         0      0    44.666667  14.110000        4    13  14.070000   \n",
 218 |        "1         1      3    31.150000  17.849000        1    12  17.762000   \n",
 219 |        "2         2     23    26.000000   2.970000        6    23  24.100000   \n",
 220 |        "3         3     24    27.782609   4.102174        1    10  23.825652   \n",
 221 |        "4         4     47    17.103448   4.373103        3     9  24.841379   \n",
 222 |        "\n",
 223 |        "      Fresh%    Drinks%      Home%   Beauty%  Health%     Baby%  Pets%  \\\n",
 224 |        "0  73.203333   4.356667   6.200000  2.176667    0.000  0.000000    0.0   \n",
 225 |        "1  52.909000  17.761000   3.207500  2.314500    4.352  1.695000    0.0   \n",
 226 |        "2  22.290000  38.690000  14.920000  0.000000    0.000  0.000000    0.0   \n",
 227 |        "3  51.280870   8.220870  14.773478  0.000000    0.000  1.898696    0.0   \n",
 228 |        "4  51.082414  10.291034  13.035172  0.683793    0.000  0.065517    0.0   \n",
 229 |        "\n",
 230 |        "   num_orders  labels             class  \n",
 231 |        "0         3.0       1    fresh_regulars  \n",
 232 |        "1        20.0       4            loyals  \n",
 233 |        "2         1.0       8  grocery_regulars  \n",
 234 |        "3        23.0       4            loyals  \n",
 235 |        "4        29.0       4            loyals  "
 236 |       ]
 237 |      },
 238 |      "execution_count": 3,
 239 |      "metadata": {},
 240 |      "output_type": "execute_result"
 241 |     }
 242 |    ],
 243 |    "source": [
 244 |     "data.head()"
 245 |    ]
 246 |   },
 247 |   {
 248 |    "cell_type": "code",
 249 |    "execution_count": 4,
 250 |    "metadata": {},
 251 |    "outputs": [
 252 |     {
 253 |      "data": {
 254 |       "text/html": [
 255 |        "<div>\n",
 256 |        "<style scoped>\n",
 257 |        "    .dataframe tbody tr th:only-of-type {\n",
 258 |        "        vertical-align: middle;\n",
 259 |        "    }\n",
 260 |        "\n",
 261 |        "    .dataframe tbody tr th {\n",
 262 |        "        vertical-align: top;\n",
 263 |        "    }\n",
 264 |        "\n",
 265 |        "    .dataframe thead th {\n",
 266 |        "        text-align: right;\n",
 267 |        "    }\n",
 268 |        "</style>\n",
 269 |        "<table border=\"1\" class=\"dataframe\">\n",
 270 |        "  <thead>\n",
 271 |        "    <tr style=\"text-align: right;\">\n",
 272 |        "      <th></th>\n",
 273 |        "      <th>customer</th>\n",
 274 |        "      <th>order</th>\n",
 275 |        "      <th>total_items</th>\n",
 276 |        "      <th>discount%</th>\n",
 277 |        "      <th>weekday</th>\n",
 278 |        "      <th>hour</th>\n",
 279 |        "      <th>Food%</th>\n",
 280 |        "      <th>Fresh%</th>\n",
 281 |        "      <th>Drinks%</th>\n",
 282 |        "      <th>Home%</th>\n",
 283 |        "      <th>Beauty%</th>\n",
 284 |        "      <th>Health%</th>\n",
 285 |        "      <th>Baby%</th>\n",
 286 |        "      <th>Pets%</th>\n",
 287 |        "      <th>num_orders</th>\n",
 288 |        "      <th>labels</th>\n",
 289 |        "    </tr>\n",
 290 |        "  </thead>\n",
 291 |        "  <tbody>\n",
 292 |        "    <tr>\n",
 293 |        "      <th>count</th>\n",
 294 |        "      <td>9354.000000</td>\n",
 295 |        "      <td>9354.000000</td>\n",
 296 |        "      <td>9354.000000</td>\n",
 297 |        "      <td>9354.000000</td>\n",
 298 |        "      <td>9354.000000</td>\n",
 299 |        "      <td>9354.000000</td>\n",
 300 |        "      <td>9354.000000</td>\n",
 301 |        "      <td>9354.000000</td>\n",
 302 |        "      <td>9354.000000</td>\n",
 303 |        "      <td>9354.000000</td>\n",
 304 |        "      <td>9354.000000</td>\n",
 305 |        "      <td>9354.000000</td>\n",
 306 |        "      <td>9354.000000</td>\n",
 307 |        "      <td>9354.000000</td>\n",
 308 |        "      <td>9354.000000</td>\n",
 309 |        "      <td>9354.000000</td>\n",
 310 |        "    </tr>\n",
 311 |        "    <tr>\n",
 312 |        "      <th>mean</th>\n",
 313 |        "      <td>5022.473808</td>\n",
 314 |        "      <td>15025.143789</td>\n",
 315 |        "      <td>32.022679</td>\n",
 316 |        "      <td>11.857907</td>\n",
 317 |        "      <td>3.657473</td>\n",
 318 |        "      <td>15.258071</td>\n",
 319 |        "      <td>25.886560</td>\n",
 320 |        "      <td>15.173542</td>\n",
 321 |        "      <td>23.717923</td>\n",
 322 |        "      <td>15.517726</td>\n",
 323 |        "      <td>6.083896</td>\n",
 324 |        "      <td>1.280169</td>\n",
 325 |        "      <td>11.036040</td>\n",
 326 |        "      <td>1.144381</td>\n",
 327 |        "      <td>3.085311</td>\n",
 328 |        "      <td>4.904319</td>\n",
 329 |        "    </tr>\n",
 330 |        "    <tr>\n",
 331 |        "      <th>std</th>\n",
 332 |        "      <td>2945.899928</td>\n",
 333 |        "      <td>8825.170543</td>\n",
 334 |        "      <td>18.724271</td>\n",
 335 |        "      <td>19.372177</td>\n",
 336 |        "      <td>2.181161</td>\n",
 337 |        "      <td>5.709821</td>\n",
 338 |        "      <td>24.018227</td>\n",
 339 |        "      <td>19.856395</td>\n",
 340 |        "      <td>21.745537</td>\n",
 341 |        "      <td>18.024529</td>\n",
 342 |        "      <td>11.766312</td>\n",
 343 |        "      <td>5.089555</td>\n",
 344 |        "      <td>23.515242</td>\n",
 345 |        "      <td>6.224596</td>\n",
 346 |        "      <td>3.247710</td>\n",
 347 |        "      <td>2.906824</td>\n",
 348 |        "    </tr>\n",
 349 |        "    <tr>\n",
 350 |        "      <th>min</th>\n",
 351 |        "      <td>0.000000</td>\n",
 352 |        "      <td>0.000000</td>\n",
 353 |        "      <td>4.250000</td>\n",
 354 |        "      <td>-31.820000</td>\n",
 355 |        "      <td>1.000000</td>\n",
 356 |        "      <td>0.000000</td>\n",
 357 |        "      <td>0.000000</td>\n",
 358 |        "      <td>0.000000</td>\n",
 359 |        "      <td>0.000000</td>\n",
 360 |        "      <td>0.000000</td>\n",
 361 |        "      <td>0.000000</td>\n",
 362 |        "      <td>0.000000</td>\n",
 363 |        "      <td>0.000000</td>\n",
 364 |        "      <td>0.000000</td>\n",
 365 |        "      <td>1.000000</td>\n",
 366 |        "      <td>0.000000</td>\n",
 367 |        "    </tr>\n",
 368 |        "    <tr>\n",
 369 |        "      <th>25%</th>\n",
 370 |        "      <td>2457.250000</td>\n",
 371 |        "      <td>7307.750000</td>\n",
 372 |        "      <td>19.446970</td>\n",
 373 |        "      <td>2.560000</td>\n",
 374 |        "      <td>2.000000</td>\n",
 375 |        "      <td>11.000000</td>\n",
 376 |        "      <td>9.608750</td>\n",
 377 |        "      <td>0.000000</td>\n",
 378 |        "      <td>7.880250</td>\n",
 379 |        "      <td>2.125833</td>\n",
 380 |        "      <td>0.000000</td>\n",
 381 |        "      <td>0.000000</td>\n",
 382 |        "      <td>0.000000</td>\n",
 383 |        "      <td>0.000000</td>\n",
 384 |        "      <td>1.000000</td>\n",
 385 |        "      <td>2.000000</td>\n",
 386 |        "    </tr>\n",
 387 |        "    <tr>\n",
 388 |        "      <th>50%</th>\n",
 389 |        "      <td>4951.500000</td>\n",
 390 |        "      <td>14777.500000</td>\n",
 391 |        "      <td>28.763889</td>\n",
 392 |        "      <td>5.750000</td>\n",
 393 |        "      <td>3.000000</td>\n",
 394 |        "      <td>16.000000</td>\n",
 395 |        "      <td>20.900000</td>\n",
 396 |        "      <td>4.867000</td>\n",
 397 |        "      <td>18.971500</td>\n",
 398 |        "      <td>10.501250</td>\n",
 399 |        "      <td>2.280417</td>\n",
 400 |        "      <td>0.000000</td>\n",
 401 |        "      <td>0.000000</td>\n",
 402 |        "      <td>0.000000</td>\n",
 403 |        "      <td>2.000000</td>\n",
 404 |        "      <td>5.000000</td>\n",
 405 |        "    </tr>\n",
 406 |        "    <tr>\n",
 407 |        "      <th>75%</th>\n",
 408 |        "      <td>7573.750000</td>\n",
 409 |        "      <td>22804.750000</td>\n",
 410 |        "      <td>40.000000</td>\n",
 411 |        "      <td>12.382500</td>\n",
 412 |        "      <td>6.000000</td>\n",
 413 |        "      <td>20.000000</td>\n",
 414 |        "      <td>33.802500</td>\n",
 415 |        "      <td>26.487083</td>\n",
 416 |        "      <td>33.567292</td>\n",
 417 |        "      <td>21.720000</td>\n",
 418 |        "      <td>7.350000</td>\n",
 419 |        "      <td>0.000000</td>\n",
 420 |        "      <td>7.097250</td>\n",
 421 |        "      <td>0.000000</td>\n",
 422 |        "      <td>4.000000</td>\n",
 423 |        "      <td>8.000000</td>\n",
 424 |        "    </tr>\n",
 425 |        "    <tr>\n",
 426 |        "      <th>max</th>\n",
 427 |        "      <td>10237.000000</td>\n",
 428 |        "      <td>29997.000000</td>\n",
 429 |        "      <td>147.500000</td>\n",
 430 |        "      <td>100.000000</td>\n",
 431 |        "      <td>7.000000</td>\n",
 432 |        "      <td>23.000000</td>\n",
 433 |        "      <td>100.000000</td>\n",
 434 |        "      <td>100.000000</td>\n",
 435 |        "      <td>100.000000</td>\n",
 436 |        "      <td>100.000000</td>\n",
 437 |        "      <td>100.000000</td>\n",
 438 |        "      <td>100.000000</td>\n",
 439 |        "      <td>100.000000</td>\n",
 440 |        "      <td>100.000000</td>\n",
 441 |        "      <td>52.000000</td>\n",
 442 |        "      <td>9.000000</td>\n",
 443 |        "    </tr>\n",
 444 |        "  </tbody>\n",
 445 |        "</table>\n",
 446 |        "</div>"
 447 |       ],
 448 |       "text/plain": [
 449 |        "           customer         order  total_items    discount%      weekday  \\\n",
 450 |        "count   9354.000000   9354.000000  9354.000000  9354.000000  9354.000000   \n",
 451 |        "mean    5022.473808  15025.143789    32.022679    11.857907     3.657473   \n",
 452 |        "std     2945.899928   8825.170543    18.724271    19.372177     2.181161   \n",
 453 |        "min        0.000000      0.000000     4.250000   -31.820000     1.000000   \n",
 454 |        "25%     2457.250000   7307.750000    19.446970     2.560000     2.000000   \n",
 455 |        "50%     4951.500000  14777.500000    28.763889     5.750000     3.000000   \n",
 456 |        "75%     7573.750000  22804.750000    40.000000    12.382500     6.000000   \n",
 457 |        "max    10237.000000  29997.000000   147.500000   100.000000     7.000000   \n",
 458 |        "\n",
 459 |        "              hour        Food%       Fresh%      Drinks%        Home%  \\\n",
 460 |        "count  9354.000000  9354.000000  9354.000000  9354.000000  9354.000000   \n",
 461 |        "mean     15.258071    25.886560    15.173542    23.717923    15.517726   \n",
 462 |        "std       5.709821    24.018227    19.856395    21.745537    18.024529   \n",
 463 |        "min       0.000000     0.000000     0.000000     0.000000     0.000000   \n",
 464 |        "25%      11.000000     9.608750     0.000000     7.880250     2.125833   \n",
 465 |        "50%      16.000000    20.900000     4.867000    18.971500    10.501250   \n",
 466 |        "75%      20.000000    33.802500    26.487083    33.567292    21.720000   \n",
 467 |        "max      23.000000   100.000000   100.000000   100.000000   100.000000   \n",
 468 |        "\n",
 469 |        "           Beauty%      Health%        Baby%        Pets%   num_orders  \\\n",
 470 |        "count  9354.000000  9354.000000  9354.000000  9354.000000  9354.000000   \n",
 471 |        "mean      6.083896     1.280169    11.036040     1.144381     3.085311   \n",
 472 |        "std      11.766312     5.089555    23.515242     6.224596     3.247710   \n",
 473 |        "min       0.000000     0.000000     0.000000     0.000000     1.000000   \n",
 474 |        "25%       0.000000     0.000000     0.000000     0.000000     1.000000   \n",
 475 |        "50%       2.280417     0.000000     0.000000     0.000000     2.000000   \n",
 476 |        "75%       7.350000     0.000000     7.097250     0.000000     4.000000   \n",
 477 |        "max     100.000000   100.000000   100.000000   100.000000    52.000000   \n",
 478 |        "\n",
 479 |        "            labels  \n",
 480 |        "count  9354.000000  \n",
 481 |        "mean      4.904319  \n",
 482 |        "std       2.906824  \n",
 483 |        "min       0.000000  \n",
 484 |        "25%       2.000000  \n",
 485 |        "50%       5.000000  \n",
 486 |        "75%       8.000000  \n",
 487 |        "max       9.000000  "
 488 |       ]
 489 |      },
 490 |      "execution_count": 4,
 491 |      "metadata": {},
 492 |      "output_type": "execute_result"
 493 |     }
 494 |    ],
 495 |    "source": [
 496 |     "data.describe()"
 497 |    ]
 498 |   },
 499 |   {
 500 |    "cell_type": "code",
 501 |    "execution_count": 11,
 502 |    "metadata": {},
 503 |    "outputs": [],
 504 |    "source": [
 505 |     "y = data['labels'].values\n",
 506 |     "X = data.drop(['weekday', 'hour','labels', 'class'], axis=1).values"
 507 |    ]
 508 |   },
 509 |   {
 510 |    "cell_type": "code",
 511 |    "execution_count": 7,
 512 |    "metadata": {},
 513 |    "outputs": [],
 514 |    "source": [
 515 |     "from sklearn.model_selection import StratifiedKFold"
 516 |    ]
 517 |   },
 518 |   {
 519 |    "cell_type": "code",
 520 |    "execution_count": 8,
 521 |    "metadata": {},
 522 |    "outputs": [],
 523 |    "source": [
 524 |     "skf = StratifiedKFold(n_splits = 5, shuffle=True, random_state=42)"
 525 |    ]
 526 |   },
 527 |   {
 528 |    "cell_type": "code",
 529 |    "execution_count": 9,
 530 |    "metadata": {},
 531 |    "outputs": [],
 532 |    "source": [
 533 |     "xgbc = XGBClassifier()"
 534 |    ]
 535 |   },
 536 |   {
 537 |    "cell_type": "code",
 538 |    "execution_count": 56,
 539 |    "metadata": {},
 540 |    "outputs": [
 541 |     {
 542 |      "name": "stdout",
 543 |      "output_type": "stream",
 544 |      "text": [
 545 |       "0.9797441364605544\n",
 546 |       "0.9770544290288153\n",
 547 |       "0.9705724986623863\n",
 548 |       "0.9689507494646681\n",
 549 |       "0.9716122121049813\n"
 550 |      ]
 551 |     }
 552 |    ],
 553 |    "source": [
 554 |     "cv_scores = []\n",
 555 |     "for train_index, test_index in skf.split(X,y):\n",
 556 |     "    X_train, X_test = X[train_index], X[test_index]\n",
 557 |     "    y_train, y_test = y[train_index], y[test_index]\n",
 558 |     "    xgbc.fit(X_train, y_train)\n",
 559 |     "    score = xgbc.score(X_test, y_test)\n",
 560 |     "    print(score)\n",
 561 |     "    cv_scores.append(score)"
 562 |    ]
 563 |   },
 564 |   {
 565 |    "cell_type": "markdown",
 566 |    "metadata": {},
 567 |    "source": [
 568 |     "That's not a bad score, let's try to improve it by tuning parameters."
 569 |    ]
 570 |   },
 571 |   {
 572 |    "cell_type": "code",
 573 |    "execution_count": 13,
 574 |    "metadata": {},
 575 |    "outputs": [],
 576 |    "source": [
 577 |     "from sklearn.model_selection import GridSearchCV"
 578 |    ]
 579 |   },
 580 |   {
 581 |    "cell_type": "code",
 582 |    "execution_count": 44,
 583 |    "metadata": {},
 584 |    "outputs": [],
 585 |    "source": [
 586 |     "params={\n",
 587 |     "    'max_depth':[6,7],\n",
 588 |     "    'learning_rate':[0.05],\n",
 589 |     "    'n_estimators':[500],\n",
 590 |     "    'objective':['multi:softprob'],\n",
 591 |     "    'gamma':[0],\n",
 592 |     "    'max_delta_step':[1],\n",
 593 |     "    'subsample':[0.9,0.8],\n",
 594 |     "    'colsample_bytree':[1.0],\n",
 595 |     "    'colsample_bylevel':[1.0],\n",
 596 |     "    'min_child_weight':[1.0]\n",
 597 |     "}"
 598 |    ]
 599 |   },
 600 |   {
 601 |    "cell_type": "code",
 602 |    "execution_count": 45,
 603 |    "metadata": {},
 604 |    "outputs": [],
 605 |    "source": [
 606 |     "grid_search_xgb = GridSearchCV(estimator=XGBClassifier(), param_grid=params, n_jobs=-1)"
 607 |    ]
 608 |   },
 609 |   {
 610 |    "cell_type": "code",
 611 |    "execution_count": 46,
 612 |    "metadata": {
 613 |     "scrolled": true
 614 |    },
 615 |    "outputs": [
 616 |     {
 617 |      "data": {
 618 |       "text/plain": [
 619 |        "GridSearchCV(cv=None, error_score='raise',\n",
 620 |        "       estimator=XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
 621 |        "       colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
 622 |        "       max_depth=3, min_child_weight=1, missing=None, n_estimators=100,\n",
 623 |        "       n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n",
 624 |        "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n",
 625 |        "       silent=True, subsample=1),\n",
 626 |        "       fit_params=None, iid=True, n_jobs=-1,\n",
 627 |        "       param_grid={'colsample_bylevel': [1.0], 'colsample_bytree': [1.0], 'gamma': [0], 'subsample': [0.9, 0.8], 'min_child_weight': [1.0], 'max_delta_step': [1], 'objective': ['multi:softprob'], 'n_estimators': [500], 'learning_rate': [0.05], 'max_depth': [6, 7]},\n",
 628 |        "       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n",
 629 |        "       scoring=None, verbose=0)"
 630 |       ]
 631 |      },
 632 |      "execution_count": 46,
 633 |      "metadata": {},
 634 |      "output_type": "execute_result"
 635 |     }
 636 |    ],
 637 |    "source": [
 638 |     "grid_search_xgb.fit(X,y)"
 639 |    ]
 640 |   },
 641 |   {
 642 |    "cell_type": "code",
 643 |    "execution_count": 47,
 644 |    "metadata": {},
 645 |    "outputs": [
 646 |     {
 647 |      "name": "stdout",
 648 |      "output_type": "stream",
 649 |      "text": [
 650 |       "{'colsample_bylevel': 1.0, 'colsample_bytree': 1.0, 'gamma': 0, 'subsample': 0.9, 'min_child_weight': 1.0, 'max_delta_step': 1, 'objective': 'multi:softprob', 'n_estimators': 500, 'learning_rate': 0.05, 'max_depth': 6}\n"
 651 |      ]
 652 |     }
 653 |    ],
 654 |    "source": [
 655 |     "print(grid_search_xgb.best_params_)"
 656 |    ]
 657 |   },
 658 |   {
 659 |    "cell_type": "code",
 660 |    "execution_count": 48,
 661 |    "metadata": {},
 662 |    "outputs": [],
 663 |    "source": [
 664 |     "#results = pd.DataFrame(grid_search_xgb.cv_results_)\n",
 665 |     "results = pd.concat([results, pd.DataFrame(grid_search_xgb.cv_results_)], axis=0)"
 666 |    ]
 667 |   },
 668 |   {
 669 |    "cell_type": "code",
 670 |    "execution_count": 49,
 671 |    "metadata": {},
 672 |    "outputs": [
 673 |     {
 674 |      "data": {
 675 |       "text/html": [
 676 |        "<div>\n",
 677 |        "<style scoped>\n",
 678 |        "    .dataframe tbody tr th:only-of-type {\n",
 679 |        "        vertical-align: middle;\n",
 680 |        "    }\n",
 681 |        "\n",
 682 |        "    .dataframe tbody tr th {\n",
 683 |        "        vertical-align: top;\n",
 684 |        "    }\n",
 685 |        "\n",
 686 |        "    .dataframe thead th {\n",
 687 |        "        text-align: right;\n",
 688 |        "    }\n",
 689 |        "</style>\n",
 690 |        "<table border=\"1\" class=\"dataframe\">\n",
 691 |        "  <thead>\n",
 692 |        "    <tr style=\"text-align: right;\">\n",
 693 |        "      <th></th>\n",
 694 |        "      <th>21</th>\n",
 695 |        "      <th>0</th>\n",
 696 |        "      <th>1</th>\n",
 697 |        "    </tr>\n",
 698 |        "  </thead>\n",
 699 |        "  <tbody>\n",
 700 |        "    <tr>\n",
 701 |        "      <th>mean_fit_time</th>\n",
 702 |        "      <td>30.7451</td>\n",
 703 |        "      <td>28.9921</td>\n",
 704 |        "      <td>28.5919</td>\n",
 705 |        "    </tr>\n",
 706 |        "    <tr>\n",
 707 |        "      <th>mean_score_time</th>\n",
 708 |        "      <td>1.22534</td>\n",
 709 |        "      <td>2.06268</td>\n",
 710 |        "      <td>1.80435</td>\n",
 711 |        "    </tr>\n",
 712 |        "    <tr>\n",
 713 |        "      <th>mean_test_score</th>\n",
 714 |        "      <td>0.972525</td>\n",
 715 |        "      <td>0.972525</td>\n",
 716 |        "      <td>0.972525</td>\n",
 717 |        "    </tr>\n",
 718 |        "    <tr>\n",
 719 |        "      <th>mean_train_score</th>\n",
 720 |        "      <td>1</td>\n",
 721 |        "      <td>1</td>\n",
 722 |        "      <td>1</td>\n",
 723 |        "    </tr>\n",
 724 |        "    <tr>\n",
 725 |        "      <th>param_colsample_bylevel</th>\n",
 726 |        "      <td>1</td>\n",
 727 |        "      <td>1</td>\n",
 728 |        "      <td>1</td>\n",
 729 |        "    </tr>\n",
 730 |        "    <tr>\n",
 731 |        "      <th>param_colsample_bytree</th>\n",
 732 |        "      <td>1</td>\n",
 733 |        "      <td>1</td>\n",
 734 |        "      <td>1</td>\n",
 735 |        "    </tr>\n",
 736 |        "    <tr>\n",
 737 |        "      <th>param_gamma</th>\n",
 738 |        "      <td>0</td>\n",
 739 |        "      <td>0</td>\n",
 740 |        "      <td>0</td>\n",
 741 |        "    </tr>\n",
 742 |        "    <tr>\n",
 743 |        "      <th>param_learning_rate</th>\n",
 744 |        "      <td>0.05</td>\n",
 745 |        "      <td>0.05</td>\n",
 746 |        "      <td>0.05</td>\n",
 747 |        "    </tr>\n",
 748 |        "    <tr>\n",
 749 |        "      <th>param_max_delta_step</th>\n",
 750 |        "      <td>1</td>\n",
 751 |        "      <td>1</td>\n",
 752 |        "      <td>1</td>\n",
 753 |        "    </tr>\n",
 754 |        "    <tr>\n",
 755 |        "      <th>param_max_depth</th>\n",
 756 |        "      <td>6</td>\n",
 757 |        "      <td>6</td>\n",
 758 |        "      <td>6</td>\n",
 759 |        "    </tr>\n",
 760 |        "    <tr>\n",
 761 |        "      <th>param_min_child_weight</th>\n",
 762 |        "      <td>1</td>\n",
 763 |        "      <td>1</td>\n",
 764 |        "      <td>1</td>\n",
 765 |        "    </tr>\n",
 766 |        "    <tr>\n",
 767 |        "      <th>param_n_estimators</th>\n",
 768 |        "      <td>500</td>\n",
 769 |        "      <td>500</td>\n",
 770 |        "      <td>500</td>\n",
 771 |        "    </tr>\n",
 772 |        "    <tr>\n",
 773 |        "      <th>param_objective</th>\n",
 774 |        "      <td>multi:softprob</td>\n",
 775 |        "      <td>multi:softprob</td>\n",
 776 |        "      <td>multi:softprob</td>\n",
 777 |        "    </tr>\n",
 778 |        "    <tr>\n",
 779 |        "      <th>param_subsample</th>\n",
 780 |        "      <td>0.9</td>\n",
 781 |        "      <td>0.9</td>\n",
 782 |        "      <td>0.8</td>\n",
 783 |        "    </tr>\n",
 784 |        "    <tr>\n",
 785 |        "      <th>params</th>\n",
 786 |        "      <td>{'colsample_bylevel': 1.0, 'colsample_bytree':...</td>\n",
 787 |        "      <td>{'colsample_bylevel': 1.0, 'colsample_bytree':...</td>\n",
 788 |        "      <td>{'colsample_bylevel': 1.0, 'colsample_bytree':...</td>\n",
 789 |        "    </tr>\n",
 790 |        "    <tr>\n",
 791 |        "      <th>rank_test_score</th>\n",
 792 |        "      <td>1</td>\n",
 793 |        "      <td>1</td>\n",
 794 |        "      <td>1</td>\n",
 795 |        "    </tr>\n",
 796 |        "    <tr>\n",
 797 |        "      <th>split0_test_score</th>\n",
 798 |        "      <td>0.966037</td>\n",
 799 |        "      <td>0.966037</td>\n",
 800 |        "      <td>0.966037</td>\n",
 801 |        "    </tr>\n",
 802 |        "    <tr>\n",
 803 |        "      <th>split0_train_score</th>\n",
 804 |        "      <td>1</td>\n",
 805 |        "      <td>1</td>\n",
 806 |        "      <td>1</td>\n",
 807 |        "    </tr>\n",
 808 |        "    <tr>\n",
 809 |        "      <th>split1_test_score</th>\n",
 810 |        "      <td>0.978198</td>\n",
 811 |        "      <td>0.978198</td>\n",
 812 |        "      <td>0.978839</td>\n",
 813 |        "    </tr>\n",
 814 |        "    <tr>\n",
 815 |        "      <th>split1_train_score</th>\n",
 816 |        "      <td>1</td>\n",
 817 |        "      <td>1</td>\n",
 818 |        "      <td>1</td>\n",
 819 |        "    </tr>\n",
 820 |        "    <tr>\n",
 821 |        "      <th>split2_test_score</th>\n",
 822 |        "      <td>0.973346</td>\n",
 823 |        "      <td>0.973346</td>\n",
 824 |        "      <td>0.972704</td>\n",
 825 |        "    </tr>\n",
 826 |        "    <tr>\n",
 827 |        "      <th>split2_train_score</th>\n",
 828 |        "      <td>1</td>\n",
 829 |        "      <td>1</td>\n",
 830 |        "      <td>1</td>\n",
 831 |        "    </tr>\n",
 832 |        "    <tr>\n",
 833 |        "      <th>std_fit_time</th>\n",
 834 |        "      <td>0.52249</td>\n",
 835 |        "      <td>0.455066</td>\n",
 836 |        "      <td>0.425876</td>\n",
 837 |        "    </tr>\n",
 838 |        "    <tr>\n",
 839 |        "      <th>std_score_time</th>\n",
 840 |        "      <td>0.302093</td>\n",
 841 |        "      <td>0.588788</td>\n",
 842 |        "      <td>0.687544</td>\n",
 843 |        "    </tr>\n",
 844 |        "    <tr>\n",
 845 |        "      <th>std_test_score</th>\n",
 846 |        "      <td>0.0050003</td>\n",
 847 |        "      <td>0.0050003</td>\n",
 848 |        "      <td>0.00522994</td>\n",
 849 |        "    </tr>\n",
 850 |        "    <tr>\n",
 851 |        "      <th>std_train_score</th>\n",
 852 |        "      <td>0</td>\n",
 853 |        "      <td>0</td>\n",
 854 |        "      <td>0</td>\n",
 855 |        "    </tr>\n",
 856 |        "  </tbody>\n",
 857 |        "</table>\n",
 858 |        "</div>"
 859 |       ],
 860 |       "text/plain": [
 861 |        "                                                                        21  \\\n",
 862 |        "mean_fit_time                                                      30.7451   \n",
 863 |        "mean_score_time                                                    1.22534   \n",
 864 |        "mean_test_score                                                   0.972525   \n",
 865 |        "mean_train_score                                                         1   \n",
 866 |        "param_colsample_bylevel                                                  1   \n",
 867 |        "param_colsample_bytree                                                   1   \n",
 868 |        "param_gamma                                                              0   \n",
 869 |        "param_learning_rate                                                   0.05   \n",
 870 |        "param_max_delta_step                                                     1   \n",
 871 |        "param_max_depth                                                          6   \n",
 872 |        "param_min_child_weight                                                   1   \n",
 873 |        "param_n_estimators                                                     500   \n",
 874 |        "param_objective                                             multi:softprob   \n",
 875 |        "param_subsample                                                        0.9   \n",
 876 |        "params                   {'colsample_bylevel': 1.0, 'colsample_bytree':...   \n",
 877 |        "rank_test_score                                                          1   \n",
 878 |        "split0_test_score                                                 0.966037   \n",
 879 |        "split0_train_score                                                       1   \n",
 880 |        "split1_test_score                                                 0.978198   \n",
 881 |        "split1_train_score                                                       1   \n",
 882 |        "split2_test_score                                                 0.973346   \n",
 883 |        "split2_train_score                                                       1   \n",
 884 |        "std_fit_time                                                       0.52249   \n",
 885 |        "std_score_time                                                    0.302093   \n",
 886 |        "std_test_score                                                   0.0050003   \n",
 887 |        "std_train_score                                                          0   \n",
 888 |        "\n",
 889 |        "                                                                        0   \\\n",
 890 |        "mean_fit_time                                                      28.9921   \n",
 891 |        "mean_score_time                                                    2.06268   \n",
 892 |        "mean_test_score                                                   0.972525   \n",
 893 |        "mean_train_score                                                         1   \n",
 894 |        "param_colsample_bylevel                                                  1   \n",
 895 |        "param_colsample_bytree                                                   1   \n",
 896 |        "param_gamma                                                              0   \n",
 897 |        "param_learning_rate                                                   0.05   \n",
 898 |        "param_max_delta_step                                                     1   \n",
 899 |        "param_max_depth                                                          6   \n",
 900 |        "param_min_child_weight                                                   1   \n",
 901 |        "param_n_estimators                                                     500   \n",
 902 |        "param_objective                                             multi:softprob   \n",
 903 |        "param_subsample                                                        0.9   \n",
 904 |        "params                   {'colsample_bylevel': 1.0, 'colsample_bytree':...   \n",
 905 |        "rank_test_score                                                          1   \n",
 906 |        "split0_test_score                                                 0.966037   \n",
 907 |        "split0_train_score                                                       1   \n",
 908 |        "split1_test_score                                                 0.978198   \n",
 909 |        "split1_train_score                                                       1   \n",
 910 |        "split2_test_score                                                 0.973346   \n",
 911 |        "split2_train_score                                                       1   \n",
 912 |        "std_fit_time                                                      0.455066   \n",
 913 |        "std_score_time                                                    0.588788   \n",
 914 |        "std_test_score                                                   0.0050003   \n",
 915 |        "std_train_score                                                          0   \n",
 916 |        "\n",
 917 |        "                                                                        1   \n",
 918 |        "mean_fit_time                                                      28.5919  \n",
 919 |        "mean_score_time                                                    1.80435  \n",
 920 |        "mean_test_score                                                   0.972525  \n",
 921 |        "mean_train_score                                                         1  \n",
 922 |        "param_colsample_bylevel                                                  1  \n",
 923 |        "param_colsample_bytree                                                   1  \n",
 924 |        "param_gamma                                                              0  \n",
 925 |        "param_learning_rate                                                   0.05  \n",
 926 |        "param_max_delta_step                                                     1  \n",
 927 |        "param_max_depth                                                          6  \n",
 928 |        "param_min_child_weight                                                   1  \n",
 929 |        "param_n_estimators                                                     500  \n",
 930 |        "param_objective                                             multi:softprob  \n",
 931 |        "param_subsample                                                        0.8  \n",
 932 |        "params                   {'colsample_bylevel': 1.0, 'colsample_bytree':...  \n",
 933 |        "rank_test_score                                                          1  \n",
 934 |        "split0_test_score                                                 0.966037  \n",
 935 |        "split0_train_score                                                       1  \n",
 936 |        "split1_test_score                                                 0.978839  \n",
 937 |        "split1_train_score                                                       1  \n",
 938 |        "split2_test_score                                                 0.972704  \n",
 939 |        "split2_train_score                                                       1  \n",
 940 |        "std_fit_time                                                      0.425876  \n",
 941 |        "std_score_time                                                    0.687544  \n",
 942 |        "std_test_score                                                  0.00522994  \n",
 943 |        "std_train_score                                                          0  "
 944 |       ]
 945 |      },
 946 |      "execution_count": 49,
 947 |      "metadata": {},
 948 |      "output_type": "execute_result"
 949 |     }
 950 |    ],
 951 |    "source": [
 952 |     "results[results['mean_test_score']==results['mean_test_score'].max()].T"
 953 |    ]
 954 |   },
 955 |   {
 956 |    "cell_type": "code",
 957 |    "execution_count": 50,
 958 |    "metadata": {},
 959 |    "outputs": [],
 960 |    "source": [
 961 |     "selected_xgbc = XGBClassifier(learning_rate=0.05, max_depth=6, n_estimators=500, subsample=0.9)"
 962 |    ]
 963 |   },
 964 |   {
 965 |    "cell_type": "code",
 966 |    "execution_count": 51,
 967 |    "metadata": {},
 968 |    "outputs": [],
 969 |    "source": [
 970 |     "from sklearn.model_selection import train_test_split"
 971 |    ]
 972 |   },
 973 |   {
 974 |    "cell_type": "code",
 975 |    "execution_count": 52,
 976 |    "metadata": {},
 977 |    "outputs": [],
 978 |    "source": [
 979 |     "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.1)"
 980 |    ]
 981 |   },
 982 |   {
 983 |    "cell_type": "code",
 984 |    "execution_count": 53,
 985 |    "metadata": {},
 986 |    "outputs": [
 987 |     {
 988 |      "data": {
 989 |       "text/plain": [
 990 |        "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
 991 |        "       colsample_bytree=1, gamma=0, learning_rate=0.05, max_delta_step=0,\n",
 992 |        "       max_depth=6, min_child_weight=1, missing=None, n_estimators=500,\n",
 993 |        "       n_jobs=1, nthread=None, objective='multi:softprob', random_state=0,\n",
 994 |        "       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n",
 995 |        "       silent=True, subsample=0.9)"
 996 |       ]
 997 |      },
 998 |      "execution_count": 53,
 999 |      "metadata": {},
1000 |      "output_type": "execute_result"
1001 |     }
1002 |    ],
1003 |    "source": [
1004 |     "selected_xgbc.fit(X_train, y_train)"
1005 |    ]
1006 |   },
1007 |   {
1008 |    "cell_type": "code",
1009 |    "execution_count": 54,
1010 |    "metadata": {},
1011 |    "outputs": [
1012 |     {
1013 |      "data": {
1014 |       "text/plain": [
1015 |        "1.0"
1016 |       ]
1017 |      },
1018 |      "execution_count": 54,
1019 |      "metadata": {},
1020 |      "output_type": "execute_result"
1021 |     }
1022 |    ],
1023 |    "source": [
1024 |     "selected_xgbc.score(X_train, y_train)"
1025 |    ]
1026 |   },
1027 |   {
1028 |    "cell_type": "code",
1029 |    "execution_count": 55,
1030 |    "metadata": {},
1031 |    "outputs": [
1032 |     {
1033 |      "data": {
1034 |       "text/plain": [
1035 |        "0.9850427350427351"
1036 |       ]
1037 |      },
1038 |      "execution_count": 55,
1039 |      "metadata": {},
1040 |      "output_type": "execute_result"
1041 |     }
1042 |    ],
1043 |    "source": [
1044 |     "selected_xgbc.score(X_test, y_test)"
1045 |    ]
1046 |   },
1047 |   {
1048 |    "cell_type": "markdown",
1049 |    "metadata": {},
1050 |    "source": [
1051 |     "Well, That's an improvement! This model can be further used to predict the classes of customers."
1052 |    ]
1053 |   }
1054 |  ],
1055 |  "metadata": {
1056 |   "kernelspec": {
1057 |    "display_name": "Python 3",
1058 |    "language": "python",
1059 |    "name": "python3"
1060 |   },
1061 |   "language_info": {
1062 |    "codemirror_mode": {
1063 |     "name": "ipython",
1064 |     "version": 3
1065 |    },
1066 |    "file_extension": ".py",
1067 |    "mimetype": "text/x-python",
1068 |    "name": "python",
1069 |    "nbconvert_exporter": "python",
1070 |    "pygments_lexer": "ipython3",
1071 |    "version": "3.5.2"
1072 |   }
1073 |  },
1074 |  "nbformat": 4,
1075 |  "nbformat_minor": 2
1076 | }
1077 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # customer-segmentation-python
 2 | This project applies customer segmentation to the customer data from a company and derives conclusions and data driven ideas based on it.
 3 | ### Dataset
 4 | This data set is the customer data of a online super market company Ulabox. The data set is available in this link https://github.com/ulabox/datasets
 5 | ### Customer segmentation
 6 | In customer segmentation we categorize similar customers together in the same cluster and analyse them. It can reveal information like: 
 7 | 1) who are the most valuable customers of the company 
 8 | 2) what kinds of customers does the company have
 9 | 3) This can be used for targeted marketing and other marketing strategies.
10 | 4) Sometimes it can even reveal a potential white space in the market place which no company has yet occupied.
11 | Well we can get creative here.
12 | ### Clustering
13 | Clustering is a process in which we put similar data points into the same cluster. There are a lot of algorithms to do this, for example agglomerative heirarchical clustering, kmeans clustering, Gaussian Mixture Model etc.
14 | ## Map to the project
15 | 1) The order_segmentation_0.0.ipynb file contains detailed notes and explanation of doing segmentation of orders in the data. I have also added my ideas in it. It's a clean walk through. I suggest to start there.
16 | 2) The customer_segmentation.ipynb file tries to do segmentation of customers in the data. It is very much similar to the order segmentation notebook. Though it doesn't have a lot of explanation you should be able to understand it after going through the former notebook. At the end of this notebook it gets real interesting.
17 | 3) I have added another file which is a bunch of functions that could help in visualizing and finding meaningful clusters within the data. These functions provide various ways to analyse for clusters in the data.<br>
18 | 4) Model_Building.ipynb is where we build a model to predict the class of each customer, which can be used to find the classes of customers in future. I have added some ideas there.
19 | 5) The two csv files are the results after clustering.<br>
20 | Thank you for your time :)
21 | 


--------------------------------------------------------------------------------
/clustering_helper_functions .ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "def pca_results(pca, df):\n",
 10 |     "    dimensions = ['dimention {}'.format(i) for i in range(1,pca.n_components_+1)]\n",
 11 |     "    fig, ax = plt.subplots(figsize=(18,12))\n",
 12 |     "    components = pd.DataFrame(pca.components_)\n",
 13 |     "    components.plot(ax=ax, kind='bar');\n",
 14 |     "    labels = [str(s) for s in df.columns]\n",
 15 |     "    ax.legend(labels)\n",
 16 |     "    ax.set_ylabel('Feature Weights')\n",
 17 |     "    ax.set_xticklabels(dimensions, rotation=90)\n",
 18 |     "    for i, ev in enumerate(np.round(pca.explained_variance_ratio_, 3)):\n",
 19 |     "        ax.text(i-0.04, ax.get_ylim()[1]+0.05, ev)\n",
 20 |     "    plt.show()"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 2,
 26 |    "metadata": {},
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "def pca_2d_plot(pca, df):\n",
 30 |     "    fig, ax = plt.subplots(figsize=(10,10))\n",
 31 |     "    transformed_data = pca.transform(df.values)\n",
 32 |     "    ax.scatter(transformed_data[:,0], transformed_data[:,1], s=3)\n",
 33 |     "    plt.show()"
 34 |    ]
 35 |   },
 36 |   {
 37 |    "cell_type": "code",
 38 |    "execution_count": 3,
 39 |    "metadata": {},
 40 |    "outputs": [],
 41 |    "source": [
 42 |     "def dependant_variable_detector(df):\n",
 43 |     "    from sklearn.preprocessing import StandardScaler\n",
 44 |     "    from sklearn.linear_model import LinearRegression\n",
 45 |     "    scaler = StandardScaler()\n",
 46 |     "    lr = LinearRegression()\n",
 47 |     "    columns = list(df.columns)\n",
 48 |     "    for col in columns:\n",
 49 |     "        y = scaler.fit_transform(df[col].values.reshape(-1,1))\n",
 50 |     "        X = scaler.fit_transform(df.drop(col, axis=1).values)\n",
 51 |     "        lr.fit(X,y)\n",
 52 |     "        print('Using '+col+' as dependent variable R2 score is :'+str(lr.score(X,y)))"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 4,
 58 |    "metadata": {},
 59 |    "outputs": [],
 60 |    "source": [
 61 |     "def plot_corr_matrix(df):\n",
 62 |     "    df_corr = df.corr()\n",
 63 |     "    fig, ax = plt.subplots(figsize=(12,12))\n",
 64 |     "    cax = ax.matshow(df_corr.values, interpolation='nearest')\n",
 65 |     "    fig.colorbar(cax)\n",
 66 |     "    plt.xticks(range(len(df.columns)), df.columns)\n",
 67 |     "    plt.yticks(range(len(df.columns)), df.columns)"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "code",
 72 |    "execution_count": 5,
 73 |    "metadata": {},
 74 |    "outputs": [],
 75 |    "source": [
 76 |     "def turkey_outlier_detector(df, cols=None):\n",
 77 |     "    if cols  is None:\n",
 78 |     "        cols = [str(s) for s in df.describe().columns]\n",
 79 |     "        \n",
 80 |     "    q1 = {}\n",
 81 |     "    q3 = {}\n",
 82 |     "    iqd = {}\n",
 83 |     "    r_limit = {}\n",
 84 |     "    l_limit = {}\n",
 85 |     "    outlier_count = {}\n",
 86 |     "    outlier_indices = {}\n",
 87 |     "    for col in cols:\n",
 88 |     "        q1[col] = np.percentile(df[col].values, 25)\n",
 89 |     "        q3[col] = np.percentile(df[col].values, 75)\n",
 90 |     "        iqd[col] = q3[col] - q1[col]\n",
 91 |     "        r_limit[col] = q3[col] + 1.5*iqd[col]\n",
 92 |     "        l_limit[col] = q1[col] - 1.5*iqd[col]\n",
 93 |     "        data_outlier = df[~((df[col]<r_limit[col]).multiply(df[col]>l_limit[col]))]\n",
 94 |     "        outlier_count[col] = data_outlier.shape[0]\n",
 95 |     "        outlier_indices[col] = data_outlier.index\n",
 96 |     "        \n",
 97 |     "    for col in cols:\n",
 98 |     "        print('_'*25)\n",
 99 |     "        print(col+'-'*8+'>'+str(outlier_count[col]))\n",
100 |     "        \n",
101 |     "    return outlier_indices"
102 |    ]
103 |   },
104 |   {
105 |    "cell_type": "code",
106 |    "execution_count": 6,
107 |    "metadata": {},
108 |    "outputs": [],
109 |    "source": [
110 |     "def hopkins_statistic(df):\n",
111 |     "    from sklearn.neighbors import NearestNeighbors\n",
112 |     "    from sklearn.preprocessing import StandardScaler\n",
113 |     "    n_samples = df.shape[0]\n",
114 |     "    num_samples = [int(f*n_samples) for f in [0.25,0.5,0.75]]\n",
115 |     "    states = [123,42,67,248,654]\n",
116 |     "    for n in num_samples:\n",
117 |     "        print('-'*12+str(n)+'-'*12)\n",
118 |     "        hopkins_statistic = []\n",
119 |     "        for random_state in states:\n",
120 |     "            data = df.sample(n=n, random_state=random_state)\n",
121 |     "            nbrs = NearestNeighbors(n_neighbors=2)\n",
122 |     "            scaler = StandardScaler()\n",
123 |     "            X = scaler.fit_transform(data.values)\n",
124 |     "            nbrs.fit(X)\n",
125 |     "            sample_dist = nbrs.kneighbors(X)[0][:,1]\n",
126 |     "            sample_dist = np.sum(sample_dist)\n",
127 |     "            random_data = np.random.rand(X.shape[0], X.shape[1])\n",
128 |     "            nbrs.fit(random_data)\n",
129 |     "            random_dist = nbrs.kneighbors(random_data)[0][:,1]\n",
130 |     "            random_dist = np.sum(random_dist)\n",
131 |     "            hs = sample_dist/(sample_dist+random_dist)\n",
132 |     "            hopkins_statistic.append(hs)\n",
133 |     "            print('*'*25)\n",
134 |     "            print('hopkins statistic :'+str(hs))\n",
135 |     "        print('mean hopkins statistic :'+str(np.mean(np.array(hopkins_statistic))))\n",
136 |     "        print('hopkins statistic standard deviation :'+str(np.std(np.array(hopkins_statistic))))"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 7,
142 |    "metadata": {},
143 |    "outputs": [],
144 |    "source": [
145 |     "def kth_nearest_data_point(df, k_max):\n",
146 |     "    from sklearn.neighbors import NearestNeighbors\n",
147 |     "    from sklearn.preprocessing import StandardScaler\n",
148 |     "    ks = range(1,k_max+1)\n",
149 |     "    scaler = StandardScaler()\n",
150 |     "    X = scaler.fit_transform(df.values)\n",
151 |     "    nbrs = NearestNeighbors(n_neighbors=k_max)\n",
152 |     "    nbrs.fit(X)\n",
153 |     "    kneighbors_result = nbrs.kneighbors()[0]\n",
154 |     "    kth_neighbor_dist = list(np.sum(kneighbors_result, axis=0))\n",
155 |     "    fig, ax = plt.subplots(figsize=(12,12))\n",
156 |     "    ax.plot(ks, kth_neighbor_dist);\n",
157 |     "    plt.show()"
158 |    ]
159 |   },
160 |   {
161 |    "cell_type": "code",
162 |    "execution_count": 8,
163 |    "metadata": {},
164 |    "outputs": [],
165 |    "source": [
166 |     "def plot_silhoutte_score(X, max_clusters=20):\n",
167 |     "    from sklearn.cluster import KMeans\n",
168 |     "    from sklearn.metrics import silhouette_score\n",
169 |     "    num_clusters = range(2,max_clusters+1)\n",
170 |     "    sil_score = []\n",
171 |     "    for n in num_clusters:\n",
172 |     "        kmeans = KMeans(n_clusters=n)\n",
173 |     "        kmeans.fit(X)\n",
174 |     "        preds = kmeans.predict(X)\n",
175 |     "        sil_score.append(silhouette_score(X, preds))\n",
176 |     "        \n",
177 |     "    fig, ax = plt.subplots(figsize=(12,12))\n",
178 |     "    ax.plot(num_clusters, sil_score)\n",
179 |     "    plt.show()"
180 |    ]
181 |   },
182 |   {
183 |    "cell_type": "code",
184 |    "execution_count": 9,
185 |    "metadata": {},
186 |    "outputs": [],
187 |    "source": [
188 |     "def under_partition_measure(X, k_max):\n",
189 |     "    from sklearn.cluster import KMeans\n",
190 |     "    ks = range(1,k_max+1)\n",
191 |     "    UPM = []\n",
192 |     "    for k in ks:\n",
193 |     "        kmeans = KMeans(n_clusters=k)\n",
194 |     "        kmeans.fit(X)\n",
195 |     "        UPM.append(kmeans.inertia_)\n",
196 |     "    fig, ax = plt.subplots(figsize=(14,14))\n",
197 |     "    ax.plot(ks, UPM);\n",
198 |     "    plt.show()\n",
199 |     "    return UPM"
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "code",
204 |    "execution_count": 10,
205 |    "metadata": {},
206 |    "outputs": [],
207 |    "source": [
208 |     "def over_partition_measure(X, k_max):\n",
209 |     "    from sklearn.cluster import KMeans\n",
210 |     "    from sklearn.metrics.pairwise import  pairwise_distances\n",
211 |     "    ks = range(1,k_max+1)\n",
212 |     "    OPM = []\n",
213 |     "    for k in ks:\n",
214 |     "        kmeans = KMeans(n_clusters=k)\n",
215 |     "        kmeans.fit(X)\n",
216 |     "        centers = kmeans.cluster_centers_\n",
217 |     "        d_min = np.inf\n",
218 |     "        for pair in list(itertools.combinations(centers, 2)):\n",
219 |     "            d = pairwise_distances(pair[0].reshape(1,-1), pair[1].reshape(1,-1), metric='euclidean')\n",
220 |     "            if d<d_min:\n",
221 |     "                d_min = d\n",
222 |     "        OPM.append(k/d_min)\n",
223 |     "        \n",
224 |     "    fig, ax = plt.subplots(figsize=(12,12))\n",
225 |     "    ax.plot(ks, OPM)\n",
226 |     "    plt.show()\n",
227 |     "    return OPM"
228 |    ]
229 |   },
230 |   {
231 |    "cell_type": "code",
232 |    "execution_count": 11,
233 |    "metadata": {},
234 |    "outputs": [],
235 |    "source": [
236 |     "def validity_index(X, k_max):\n",
237 |     "    UPM = under_partition_measure(X, k_max)\n",
238 |     "    OPM = over_partition_measure(X, k_max)\n",
239 |     "    UPM_min = np.min(UPM)\n",
240 |     "    OPM_min = np.min(OPM)\n",
241 |     "    UPM_max = np.max(UPM)\n",
242 |     "    OPM_max = np.max(OPM)\n",
243 |     "    norm_UPM = []\n",
244 |     "    norm_OPM = []\n",
245 |     "    for i in range(k_max):\n",
246 |     "        norm_UPM.append((UPM[i]-UPM_min)/(UPM_max-UPM_min))\n",
247 |     "        norm_OPM.append((OPM[i]-OPM_min)/(OPM_max-OPM_min))\n",
248 |     "        \n",
249 |     "    validity_index = np.array(norm_UPM)+np.array(norm_OPM)\n",
250 |     "    fig, ax = plt.subplots(figsize=(12,12))\n",
251 |     "    ax.plot(range(1,k_max+1), validity_index)\n",
252 |     "    return validity_index"
253 |    ]
254 |   },
255 |   {
256 |    "cell_type": "code",
257 |    "execution_count": null,
258 |    "metadata": {},
259 |    "outputs": [],
260 |    "source": []
261 |   }
262 |  ],
263 |  "metadata": {
264 |   "kernelspec": {
265 |    "display_name": "Python 3",
266 |    "language": "python",
267 |    "name": "python3"
268 |   },
269 |   "language_info": {
270 |    "codemirror_mode": {
271 |     "name": "ipython",
272 |     "version": 3
273 |    },
274 |    "file_extension": ".py",
275 |    "mimetype": "text/x-python",
276 |    "name": "python",
277 |    "nbconvert_exporter": "python",
278 |    "pygments_lexer": "ipython3",
279 |    "version": "3.5.2"
280 |   }
281 |  },
282 |  "nbformat": 4,
283 |  "nbformat_minor": 2
284 | }
285 | 


--------------------------------------------------------------------------------