Identifying Cross Selling Opportunities with Machine Learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collaborative Filtering is a common approach to developing recommendation engines.  Essentially it is an algorithm that relies on user behavior to provide a recommendation.  For further detail please visit https://www.analyticsvidhya.com/blog/2015/10/recommendation-engines/. \n",
    "\n",
    "In this post, we will generate user purchase data and utilize the scikit Suprise library to implement a recommendation engine to identify cross selling opportunities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from collections import defaultdict\n",
    "import math\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from surprise import KNNBasic\n",
    "from surprise import Dataset\n",
    "from surprise import Reader\n",
    "from surprise.model_selection import cross_validate\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data is a matrix of purchase history that contains 1,000 different users and 100 different products.  If the user owns the product then it will be represented as the number \"1\" else it will be represented as the number \"0\".   \n",
    "\n",
    "Our goal is to have our algorithm recommend products that make sense to cross sell.  In order make sure our algorithm works, we've created a pattern in the data where the first 100 users only own products 0 thru 9 and the next 100 users own only products 10 thru 19, and so on.  There is only a 35% chance that the user will own the product to ensure we have cross selling opportunities.\n",
    "\n",
    "The below heatmap you can see a visualization of the data. The rows are our 1,000 users and the columns are 100 products.  Each green dash is a product owned by that particular user.  Each square block is a cluster of products and users.  You could think of these clusters as being specific product division within a company.\n",
    "\n",
    "If our algorithm is working correctly then it should only recommend cross selling opportunities within each user/product cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.zeros((1000, 100))\n",
    "purchases = np.random.choice(2, size=(1000, 10), p=[.65, .35])\n",
    "\n",
    "for n in range(1000):\n",
    "    # https://stackoverflow.com/questions/26454649/python-round-up-to-the-nearest-ten\n",
    "    index = int(math.ceil((n+1) / 100.0)) * 10 \n",
    "    data[n, index-10 : index] = purchases[n]\n",
    "    \n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "plt.figure(figsize=(13, 10))\n",
    "sns.heatmap(df,\n",
    "            cbar=False,\n",
    "            xticklabels=False,\n",
    "            yticklabels=False,\n",
    "            cmap=sns.color_palette([\"#34495e\", \"#2ecc71\"]));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course with the data above you wouldn't need an algorithm to help you provide recommendations for cross selling but if we were to shuffle the rows and columns around a bit you will get a more sporadic looking dataset that visually looks random. However, the pattern we created still exists within the data even though it's shuffled.  This is where a recommendation algorithm can be useful as it will find any trends if they exist and provide us with useful recommendations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# https://stackoverflow.com/questions/47923429/how-to-shuffle-a-pandas-dataframe-randomly-by-row\n",
    "df = df.sample(frac=1, axis=0).sample(frac=1, axis=1)\n",
    "\n",
    "plt.figure(figsize=(13, 10))\n",
    "sns.heatmap(df,\n",
    "            cbar=False,\n",
    "            xticklabels=False,\n",
    "            yticklabels=False,\n",
    "            cmap=sns.color_palette([\"#34495e\", \"#2ecc71\"]));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The algorithm we are using requires the data be in a transactional format where each row represents the user, the product, and whether or not the product is purchased (1 = purchased, 0 = not purchased).\n",
    "\n",
    "To better distinguish users from products we'll prefix the user_id with 'u_' and the product_id with 'p_'.  This will be useful in understanding the outputs from our algorithm as it can also similar users if we desire.  \n",
    "\n",
    "Below is the first 10 rows in our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_id</th>\n",
       "      <th>product_id</th>\n",
       "      <th>is_purchase</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>u_913</td>\n",
       "      <td>p_99</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>u_521</td>\n",
       "      <td>p_15</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>u_597</td>\n",
       "      <td>p_75</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>u_436</td>\n",
       "      <td>p_78</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>u_799</td>\n",
       "      <td>p_23</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>u_687</td>\n",
       "      <td>p_34</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>u_862</td>\n",
       "      <td>p_87</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>u_520</td>\n",
       "      <td>p_52</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>u_480</td>\n",
       "      <td>p_63</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>u_500</td>\n",
       "      <td>p_7</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  user_id product_id  is_purchase\n",
       "0   u_913       p_99          0.0\n",
       "1   u_521       p_15          0.0\n",
       "2   u_597       p_75          0.0\n",
       "3   u_436       p_78          0.0\n",
       "4   u_799       p_23          0.0\n",
       "5   u_687       p_34          0.0\n",
       "6   u_862       p_87          0.0\n",
       "7   u_520       p_52          0.0\n",
       "8   u_480       p_63          0.0\n",
       "9   u_500        p_7          0.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# https://stackoverflow.com/questions/26639003/python-unpivot-data\n",
    "\n",
    "df = pd.melt(df.reset_index(), id_vars=['index'])\n",
    "df = df.sample(frac=1, axis=0).reset_index(drop=True)\n",
    "df.columns = ['user_id', 'product_id', 'is_purchase']\n",
    "df.user_id = df.user_id.map(lambda x: f'u_{x}')\n",
    "df.product_id = df.product_id.map(lambda x: f'p_{x}')\n",
    "\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that our data is ready we can train/fit the algorithm. The algorithm \"KNNBasic\" computes a similarity matrix between users and then uses that matrix to predict whether or not the user owns the product.\n",
    "\n",
    "We've created a function called \"get_top_n\" that by default uses our trained algorithm to make a prediction for every user and then returns the 10 products that had the highest probability of being owned by the user.\n",
    "\n",
    "If our algorithm is working correctly it will recommend for users 0–99 products 0–9, for users 100–199 products 10–19 and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "\n",
      " First 20 Results: \n",
      "\n",
      "u_913 ['p_95', 'p_97', 'p_92', 'p_90', 'p_98', 'p_96', 'p_99', 'p_91', 'p_93', 'p_94']\n",
      "u_521 ['p_52', 'p_55', 'p_51', 'p_50', 'p_53', 'p_58', 'p_57', 'p_54', 'p_47', 'p_90']\n",
      "u_597 ['p_53', 'p_59', 'p_52', 'p_57', 'p_54', 'p_56', 'p_50', 'p_51', 'p_58', 'p_55']\n",
      "u_436 ['p_44', 'p_41', 'p_43', 'p_45', 'p_47', 'p_48', 'p_40', 'p_42', 'p_49', 'p_46']\n",
      "u_799 ['p_76', 'p_70', 'p_74', 'p_71', 'p_73', 'p_23', 'p_79', 'p_90', 'p_47', 'p_19']\n",
      "u_687 ['p_61', 'p_60', 'p_63', 'p_64', 'p_66', 'p_69', 'p_68', 'p_62', 'p_65', 'p_67']\n",
      "u_862 ['p_88', 'p_81', 'p_86', 'p_89', 'p_83', 'p_84', 'p_85', 'p_87', 'p_82', 'p_80']\n",
      "u_520 ['p_50', 'p_57', 'p_56', 'p_51', 'p_55', 'p_52', 'p_59', 'p_68', 'p_84', 'p_2']\n",
      "u_480 ['p_44', 'p_49', 'p_45', 'p_43', 'p_47', 'p_42', 'p_40', 'p_41', 'p_48', 'p_46']\n",
      "u_500 ['p_58', 'p_55', 'p_57', 'p_56', 'p_52', 'p_54', 'p_50', 'p_51', 'p_53', 'p_59']\n",
      "u_85 ['p_9', 'p_0', 'p_8', 'p_1', 'p_4', 'p_2', 'p_5', 'p_3', 'p_7', 'p_6']\n",
      "u_706 ['p_76', 'p_75', 'p_78', 'p_70', 'p_72', 'p_71', 'p_79', 'p_74', 'p_77', 'p_73']\n",
      "u_125 ['p_15', 'p_11', 'p_17', 'p_16', 'p_10', 'p_14', 'p_13', 'p_12', 'p_19', 'p_18']\n",
      "u_42 ['p_8', 'p_9', 'p_3', 'p_6', 'p_4', 'p_7', 'p_0', 'p_1', 'p_2', 'p_5']\n",
      "u_958 ['p_99', 'p_94', 'p_91', 'p_96', 'p_92', 'p_93', 'p_95', 'p_98', 'p_97', 'p_90']\n",
      "u_590 ['p_56', 'p_58', 'p_54', 'p_57', 'p_52', 'p_55', 'p_51', 'p_59', 'p_50', 'p_53']\n",
      "u_860 ['p_86', 'p_82', 'p_83', 'p_80', 'p_84', 'p_87', 'p_81', 'p_68', 'p_19', 'p_24']\n",
      "u_823 ['p_88', 'p_85', 'p_84', 'p_83', 'p_87', 'p_86', 'p_23', 'p_76', 'p_79', 'p_89']\n",
      "u_31 ['p_8', 'p_0', 'p_2', 'p_1', 'p_6', 'p_5', 'p_9', 'p_7', 'p_4', 'p_3']\n",
      "u_424 ['p_49', 'p_40', 'p_48', 'p_46', 'p_41', 'p_44', 'p_43', 'p_42', 'p_47', 'p_45']\n"
     ]
    }
   ],
   "source": [
    "reader = Reader(rating_scale=(0, 1))\n",
    "data = Dataset.load_from_df(df, reader)\n",
    "algo = KNNBasic(sim_options={'user_based': True})\n",
    "trainset = data.build_full_trainset()\n",
    "algo.fit(trainset)\n",
    "testset = trainset.build_testset()\n",
    "predictions = algo.test(testset)\n",
    "\n",
    "def get_top_n(predictions, n=10):\n",
    "    '''\n",
    "    Return the top-N recommendation for each user from a set of predictions.\n",
    "    \n",
    "    Source: \n",
    "        https://surprise.readthedocs.io/en/stable/FAQ.html\n",
    "\n",
    "    Args:\n",
    "        predictions(list of Prediction objects): The list of predictions, as\n",
    "            returned by the test method of an algorithm.\n",
    "        n(int): The number of recommendation to output for each user. Default\n",
    "            is 10.\n",
    "\n",
    "    Returns:\n",
    "    A dict where keys are user (raw) ids and values are lists of tuples:\n",
    "        [(raw item id, rating estimation), ...] of size n.\n",
    "    '''\n",
    "\n",
    "    # First map the predictions to each user.\n",
    "    top_n = defaultdict(list)\n",
    "    for uid, iid, true_r, est, _ in predictions:\n",
    "        top_n[uid].append((iid, est))\n",
    "\n",
    "    # Then sort the predictions for each user and retrieve the k highest ones.\n",
    "    for uid, user_ratings in top_n.items():\n",
    "        user_ratings.sort(key=lambda x: x[1], reverse=True)\n",
    "        top_n[uid] = user_ratings[:n]\n",
    "\n",
    "    return top_n\n",
    "\n",
    "top_n = get_top_n(predictions, n=10)\n",
    "print('\\n First 20 Results: \\n')\n",
    "count = 0\n",
    "for uid, user_ratings in top_n.items():\n",
    "    print(uid, [iid for (iid, _) in user_ratings])\n",
    "    count += 1\n",
    "    if count == 20:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the top 10 product recommendations for each user available to us, we can use it to generate Opportunities for specific users.\n",
    "\n",
    "Below we iterate through the top recommendations for User 'u_9' and identify cross selling opportunities with the label \"Opportunity:\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Purchased: p_9\n",
      "Purchased: p_4\n",
      "Purchased: p_1\n",
      "Opporutnity: p_2\n",
      "Opporutnity: p_7\n",
      "Opporutnity: p_3\n",
      "Opporutnity: p_8\n",
      "Opporutnity: p_0\n",
      "Opporutnity: p_5\n",
      "Opporutnity: p_6\n"
     ]
    }
   ],
   "source": [
    "for item in top_n['u_9']:\n",
    "    if item[0] in df[(df.user_id =='u_9') & (df.is_purchase==1)].product_id.to_list():\n",
    "        print(f'Purchased: {item[0]}')\n",
    "    else:\n",
    "        print(f'Opporutnity: {item[0]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because our algorithm computes a similarity matrix we can leverage it to find the n nearest neighbors for any user. This can be leveraged for other tasks such as pricing guidance or would could just retrain our algorithm to predict pricing instead of purchases and use those predictions as pricing recommendations.\n",
    "\n",
    "Below we show the 25 nearest neighbors to user \"u_1\". If it is working correctly we should see mostly 25 users within the range of users 0–99."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 most similar Users to 'u_1': \n",
      "\n",
      "['u_30', 'u_73', 'u_23', 'u_76', 'u_51', 'u_86', 'u_36', 'u_78', 'u_35', 'u_68', 'u_26', 'u_63', 'u_11', 'u_2', 'u_32', 'u_85', 'u_31', 'u_54', 'u_67', 'u_61', 'u_7', 'u_45', 'u_21', 'u_66', 'u_25']\n"
     ]
    }
   ],
   "source": [
    "neighbors = algo.get_neighbors(trainset.to_inner_uid('u_1'), k=25)\n",
    "\n",
    "print(\"25 most similar Users to 'u_1': \\n\")\n",
    "print([trainset.to_raw_uid(user) for user in neighbors])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we're using \"user based similarities\" to provide recommendations we can't provide recommendations for a new user. This is termed the \"cold start problem\".\n",
    "\n",
    "Instead, we can train a separate algorithm that uses \"item based similarities\" to recommend products that are similar to one another. For example, if our new user is interested in product 25 \"p_25\" our algorithm should be able to recommend products 20 thru 29 as cross selling opportunities.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "\n",
      " 9 most similar Products to p_25: \n",
      "\n",
      "['p_21', 'p_29', 'p_28', 'p_22', 'p_26', 'p_27', 'p_23', 'p_24', 'p_20']\n"
     ]
    }
   ],
   "source": [
    "algo = KNNBasic(sim_options={'user_based': False})\n",
    "algo.fit(trainset)\n",
    "neighbors = algo.get_neighbors(trainset.to_inner_iid('p_25'), k=9)\n",
    "print(\"\\n 9 most similar Products to p_25: \\n\")\n",
    "print([trainset.to_raw_iid(item) for item in neighbors])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources:\n",
    "\n",
    "* http://surpriselib.com/\n",
    "* https://www.analyticsvidhya.com/blog/2015/10/recommendation-engines/\n",
    "* https://www.datacamp.com/community/tutorials/recommender-systems-python\n",
    "* https://realpython.com/build-recommendation-engine-collaborative-filtering/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}