Recommendations_with_IBM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recommendations with IBM\n",
    "\n",
    "Aim of this notebook is to put my recommendation skills to use on real data from the IBM Watson Studio platform. \n",
    "\n",
    "In the following section I am buildig out a number of different methods for making recommendations that can be used for different situations. \n",
    "\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "I. [Exploratory Data Analysis](#Exploratory-Data-Analysis)<br>\n",
    "II. [Rank Based Recommendations](#Rank)<br>\n",
    "III. [User-User Based Collaborative Filtering](#User-User)<br>\n",
    "IV. [Matrix Factorization](#Matrix-Fact)<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>article_id</th>\n",
       "      <th>title</th>\n",
       "      <th>email</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1430.0</td>\n",
       "      <td>using pixiedust for fast, flexible, and easier data analysis and experimentation</td>\n",
       "      <td>ef5f11f77ba020cd36e1105a00ab868bbdbf7fe7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1314.0</td>\n",
       "      <td>healthcare python streaming application demo</td>\n",
       "      <td>083cbdfa93c8444beaa4c5f5e0f5f9198e4f9e0b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1429.0</td>\n",
       "      <td>use deep learning for image classification</td>\n",
       "      <td>b96a4f2e92d8572034b1e9b28f9ac673765cd074</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1338.0</td>\n",
       "      <td>ml optimization using cognitive assistant</td>\n",
       "      <td>06485706b34a5c9bf2a0ecdac41daf7e7654ceb7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1276.0</td>\n",
       "      <td>deploy your python model as a restful api</td>\n",
       "      <td>f01220c46fc92c6e6b161b1849de11faacd7ccb2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   article_id  \\\n",
       "0      1430.0   \n",
       "1      1314.0   \n",
       "2      1429.0   \n",
       "3      1338.0   \n",
       "4      1276.0   \n",
       "\n",
       "                                                                              title  \\\n",
       "0  using pixiedust for fast, flexible, and easier data analysis and experimentation   \n",
       "1                                      healthcare python streaming application demo   \n",
       "2                                        use deep learning for image classification   \n",
       "3                                         ml optimization using cognitive assistant   \n",
       "4                                         deploy your python model as a restful api   \n",
       "\n",
       "                                      email  \n",
       "0  ef5f11f77ba020cd36e1105a00ab868bbdbf7fe7  \n",
       "1  083cbdfa93c8444beaa4c5f5e0f5f9198e4f9e0b  \n",
       "2  b96a4f2e92d8572034b1e9b28f9ac673765cd074  \n",
       "3  06485706b34a5c9bf2a0ecdac41daf7e7654ceb7  \n",
       "4  f01220c46fc92c6e6b161b1849de11faacd7ccb2  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import project_tests as t\n",
    "import pickle\n",
    "pd.options.display.max_colwidth = 100\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "df = pd.read_csv('data/user-item-interactions.csv')\n",
    "df_content = pd.read_csv('data/articles_community.csv')\n",
    "del df['Unnamed: 0']\n",
    "del df_content['Unnamed: 0']\n",
    "\n",
    "# Show df to get an idea of the data\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>doc_body</th>\n",
       "      <th>doc_description</th>\n",
       "      <th>doc_full_name</th>\n",
       "      <th>doc_status</th>\n",
       "      <th>article_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Skip navigation Sign in SearchLoading...\\r\\n\\r\\nClose Yeah, keep it Undo CloseTHIS VIDEO IS UNAV...</td>\n",
       "      <td>Detect bad readings in real time using Python and Streaming Analytics.</td>\n",
       "      <td>Detect Malfunctioning IoT Sensors with Streaming Analytics</td>\n",
       "      <td>Live</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>No Free Hunch Navigation * kaggle.com\\r\\n\\r\\n * kaggle.com\\r\\n\\r\\nCommunicating data science: A ...</td>\n",
       "      <td>See the forest, see the trees. Here lies the challenge in both performing and presenting an anal...</td>\n",
       "      <td>Communicating data science: A guide to presenting your work</td>\n",
       "      <td>Live</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>☰ * Login\\r\\n * Sign Up\\r\\n\\r\\n * Learning Paths\\r\\n * Courses * Our Courses\\r\\n    * Partner Co...</td>\n",
       "      <td>Here’s this week’s news in Data Science and Big Data.</td>\n",
       "      <td>This Week in Data Science (April 18, 2017)</td>\n",
       "      <td>Live</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DATALAYER: HIGH THROUGHPUT, LOW LATENCY AT SCALE - BOOST THE PERFORMANCE OF YOUR\\r\\nDISTRIBUTED ...</td>\n",
       "      <td>Learn how distributed DBs solve the problem of scaling persistent storage, but introduce latency...</td>\n",
       "      <td>DataLayer Conference: Boost the performance of your distributed database</td>\n",
       "      <td>Live</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Skip navigation Sign in SearchLoading...\\r\\n\\r\\nClose Yeah, keep it Undo CloseTHIS VIDEO IS UNAV...</td>\n",
       "      <td>This video demonstrates the power of IBM DataScience Experience using a simple New York State Re...</td>\n",
       "      <td>Analyze NY Restaurant data using Spark in DSX</td>\n",
       "      <td>Live</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                                              doc_body  \\\n",
       "0  Skip navigation Sign in SearchLoading...\\r\\n\\r\\nClose Yeah, keep it Undo CloseTHIS VIDEO IS UNAV...   \n",
       "1  No Free Hunch Navigation * kaggle.com\\r\\n\\r\\n * kaggle.com\\r\\n\\r\\nCommunicating data science: A ...   \n",
       "2  ☰ * Login\\r\\n * Sign Up\\r\\n\\r\\n * Learning Paths\\r\\n * Courses * Our Courses\\r\\n    * Partner Co...   \n",
       "3  DATALAYER: HIGH THROUGHPUT, LOW LATENCY AT SCALE - BOOST THE PERFORMANCE OF YOUR\\r\\nDISTRIBUTED ...   \n",
       "4  Skip navigation Sign in SearchLoading...\\r\\n\\r\\nClose Yeah, keep it Undo CloseTHIS VIDEO IS UNAV...   \n",
       "\n",
       "                                                                                       doc_description  \\\n",
       "0                               Detect bad readings in real time using Python and Streaming Analytics.   \n",
       "1  See the forest, see the trees. Here lies the challenge in both performing and presenting an anal...   \n",
       "2                                                Here’s this week’s news in Data Science and Big Data.   \n",
       "3  Learn how distributed DBs solve the problem of scaling persistent storage, but introduce latency...   \n",
       "4  This video demonstrates the power of IBM DataScience Experience using a simple New York State Re...   \n",
       "\n",
       "                                                              doc_full_name  \\\n",
       "0                Detect Malfunctioning IoT Sensors with Streaming Analytics   \n",
       "1               Communicating data science: A guide to presenting your work   \n",
       "2                                This Week in Data Science (April 18, 2017)   \n",
       "3  DataLayer Conference: Boost the performance of your distributed database   \n",
       "4                             Analyze NY Restaurant data using Spark in DSX   \n",
       "\n",
       "  doc_status  article_id  \n",
       "0       Live           0  \n",
       "1       Live           1  \n",
       "2       Live           2  \n",
       "3       Live           3  \n",
       "4       Live           4  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show df_content to get an idea of the data\n",
    "df_content.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Exploratory-Data-Analysis\">Part I : Exploratory Data Analysis</a>\n",
    "\n",
    "`1.` Provide a visual and descriptive statistics to assist with giving a look at the number of times each user interacts with an article.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0103ee4cf8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_interactions = df.groupby(\"email\").nunique()['article_id'].to_frame().reset_index() \\\n",
    "                    .sort_values(\"article_id\" , ascending = False).rename(columns = {\"article_id\" : \"nr_articles\"})\n",
    "\n",
    "plt.hist(df_interactions['nr_articles'] , 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    5148.000000\n",
       "mean        6.540210\n",
       "std         9.990676\n",
       "min         1.000000\n",
       "25%         1.000000\n",
       "50%         3.000000\n",
       "75%         7.000000\n",
       "max       135.000000\n",
       "Name: nr_articles, dtype: float64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_interactions['nr_articles'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50% of individuals interact with 3.0 number of articles or fewer.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "median_val = df_interactions['nr_articles'].median()\n",
    "print(f\"50% of individuals interact with {median_val } number of articles or fewer.\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum number of user-article interactions by any 1 user is 364. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_interactions_2 = df.groupby(\"email\").count()['article_id']\n",
    "df_interactions_2 = df_interactions_2.to_frame().reset_index().rename(columns = {\"article_id\": \"Nr_interactions\"})\n",
    "\n",
    "df_interactions_2.sort_values(by=\"Nr_interactions\" , ascending = False)\n",
    "max_views_by_user = df_interactions_2['Nr_interactions'].max()\n",
    "\n",
    "print(f\"The maximum number of user-article interactions by any 1 user is {max_views_by_user}. \\n\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` Explore and remove duplicate articles from the **df_content** dataframe.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>article_id</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>221</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>232</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>577</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>398</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   article_id  Count\n",
       "0         221      2\n",
       "1         232      2\n",
       "2         577      2\n",
       "3         398      2\n",
       "4          50      2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find and explore duplicate articles\n",
    "\n",
    "df_grouped_id = df_content.groupby(\"article_id\")['article_id'].count().sort_values(ascending = False) \\\n",
    "                          .to_frame().rename(columns ={\"article_id\":\"Count\"}).reset_index()\n",
    "\n",
    "\n",
    "df_grouped_id[df_grouped_id['Count'] > 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove any rows that have the same article_id - only keep the first\n",
    "\n",
    "df_content.drop_duplicates(subset = ['article_id'] , keep = 'first' , inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.` Use below cells to find:\n",
    "\n",
    "**a.** The number of unique articles that have an interaction with a user.  \n",
    "**b.** The number of unique articles in the dataset (whether they have any interactions or not).<br>\n",
    "**c.** The number of unique users in the dataset. (excluding null values) <br>\n",
    "**d.** The number of user-article interactions in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique articles that have at least one interaction is 714.\n"
     ]
    }
   ],
   "source": [
    "unique_articles = df['article_id'].nunique()\n",
    "print(f\"Number of unique articles that have at least one interaction is {unique_articles}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique articles on the IBM platform is 1051.\n"
     ]
    }
   ],
   "source": [
    "total_articles = df_content['article_id'].nunique()\n",
    "print(f\"Number of unique articles on the IBM platform is {total_articles}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique users is 5148.\n"
     ]
    }
   ],
   "source": [
    "unique_users = df['email'].nunique()\n",
    "print(f\"Number of unique users is {unique_users}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of user-article interactions in the dataset is 45993.\n"
     ]
    }
   ],
   "source": [
    "user_article_interactions = df.shape[0]\n",
    "print(f\"Total number of user-article interactions in the dataset is {user_article_interactions}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` Find the most viewed **article_id**, as well as how often it was viewed.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>article_id</th>\n",
       "      <th>title</th>\n",
       "      <th>email</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1430.0</td>\n",
       "      <td>using pixiedust for fast, flexible, and easier data analysis and experimentation</td>\n",
       "      <td>ef5f11f77ba020cd36e1105a00ab868bbdbf7fe7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1314.0</td>\n",
       "      <td>healthcare python streaming application demo</td>\n",
       "      <td>083cbdfa93c8444beaa4c5f5e0f5f9198e4f9e0b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1429.0</td>\n",
       "      <td>use deep learning for image classification</td>\n",
       "      <td>b96a4f2e92d8572034b1e9b28f9ac673765cd074</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1338.0</td>\n",
       "      <td>ml optimization using cognitive assistant</td>\n",
       "      <td>06485706b34a5c9bf2a0ecdac41daf7e7654ceb7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1276.0</td>\n",
       "      <td>deploy your python model as a restful api</td>\n",
       "      <td>f01220c46fc92c6e6b161b1849de11faacd7ccb2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   article_id  \\\n",
       "0      1430.0   \n",
       "1      1314.0   \n",
       "2      1429.0   \n",
       "3      1338.0   \n",
       "4      1276.0   \n",
       "\n",
       "                                                                              title  \\\n",
       "0  using pixiedust for fast, flexible, and easier data analysis and experimentation   \n",
       "1                                      healthcare python streaming application demo   \n",
       "2                                        use deep learning for image classification   \n",
       "3                                         ml optimization using cognitive assistant   \n",
       "4                                         deploy your python model as a restful api   \n",
       "\n",
       "                                      email  \n",
       "0  ef5f11f77ba020cd36e1105a00ab868bbdbf7fe7  \n",
       "1  083cbdfa93c8444beaa4c5f5e0f5f9198e4f9e0b  \n",
       "2  b96a4f2e92d8572034b1e9b28f9ac673765cd074  \n",
       "3  06485706b34a5c9bf2a0ecdac41daf7e7654ceb7  \n",
       "4  f01220c46fc92c6e6b161b1849de11faacd7ccb2  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The article_id of the most viewed article is\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "most_viewed_article_id = df.groupby([\"article_id\"  ])['email'].count().to_frame() \\\n",
    "                           .rename(columns={\"email\":\"Counts\"}).reset_index()  \\\n",
    "                           .sort_values(\"Counts\", ascending = False)['article_id'][:1].item()\n",
    "\n",
    "most_viewed_article_id = str(most_viewed_article_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most viewed article in the dataset is 1429.0\n"
     ]
    }
   ],
   "source": [
    "print(f\"The most viewed article in the dataset is {most_viewed_article_id}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most viewed article in the dataset was viewed 937 times.\n"
     ]
    }
   ],
   "source": [
    "max_views = df.groupby([\"article_id\"  ])['email'].count().to_frame() \\\n",
    "                           .rename(columns={\"email\":\"Counts\"}).reset_index()  \\\n",
    "                           .sort_values(\"Counts\", ascending = False)['Counts'][:1].item()\n",
    "\n",
    "print(f\"The most viewed article in the dataset was viewed {max_views} times.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a function which maps email to a user_id column and removes the email column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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>article_id</th>\n",
       "      <th>title</th>\n",
       "      <th>user_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1430.0</td>\n",
       "      <td>using pixiedust for fast, flexible, and easier data analysis and experimentation</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1314.0</td>\n",
       "      <td>healthcare python streaming application demo</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1429.0</td>\n",
       "      <td>use deep learning for image classification</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1338.0</td>\n",
       "      <td>ml optimization using cognitive assistant</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1276.0</td>\n",
       "      <td>deploy your python model as a restful api</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   article_id  \\\n",
       "0      1430.0   \n",
       "1      1314.0   \n",
       "2      1429.0   \n",
       "3      1338.0   \n",
       "4      1276.0   \n",
       "\n",
       "                                                                              title  \\\n",
       "0  using pixiedust for fast, flexible, and easier data analysis and experimentation   \n",
       "1                                      healthcare python streaming application demo   \n",
       "2                                        use deep learning for image classification   \n",
       "3                                         ml optimization using cognitive assistant   \n",
       "4                                         deploy your python model as a restful api   \n",
       "\n",
       "   user_id  \n",
       "0        1  \n",
       "1        2  \n",
       "2        3  \n",
       "3        4  \n",
       "4        5  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def email_mapper():\n",
    "    coded_dict = dict()\n",
    "    cter = 1\n",
    "    email_encoded = []\n",
    "    \n",
    "    for val in df['email']:\n",
    "        if val not in coded_dict:\n",
    "            coded_dict[val] = cter\n",
    "            cter+=1\n",
    "        \n",
    "        email_encoded.append(coded_dict[val])\n",
    "    return email_encoded\n",
    "\n",
    "email_encoded = email_mapper()\n",
    "del df['email']\n",
    "df['user_id'] = email_encoded\n",
    "\n",
    "# show header\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Rank\">Part II: Rank-Based Recommendations</a>\n",
    "\n",
    "We don't actually have ratings for whether a user liked an article or not.  We only know that a user has interacted with an article.  In these cases, the popularity of an article can really only be based on how often an article was interacted with.\n",
    "\n",
    "`1.` Create a function that returns the **n** top articles ordered with most interactions as the top. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_articles(n, df=df):\n",
    "    '''\n",
    "    INPUT:\n",
    "    n - (int) the number of top articles to return\n",
    "    df - (pandas dataframe) df as defined at the top of the notebook \n",
    "    \n",
    "    OUTPUT:\n",
    "    top_articles - (list) A list of the top 'n' article titles \n",
    "    \n",
    "    '''\n",
    "    #Group records of input dataframe by article_id and title; order by count value in descending order\n",
    "    top_articles = list(df.groupby([\"article_id\", \"title\"  ])['user_id'].count().to_frame() \\\n",
    "                           .rename(columns={\"user_id\":\"Counts\"}).reset_index()  \\\n",
    "                           .sort_values(\"Counts\", ascending = False)[\"title\"][:n])\n",
    "    \n",
    "    #Return titles for top articles\n",
    "    return top_articles\n",
    "\n",
    "def get_top_article_ids(n, df=df):\n",
    "    '''\n",
    "    INPUT:\n",
    "    n - (int) the number of top articles to return\n",
    "    df - (pandas dataframe) df as defined at the top of the notebook \n",
    "    \n",
    "    OUTPUT:\n",
    "    top_articles - (list) A list of the top 'n' article titles \n",
    "    \n",
    "    '''\n",
    "    #Group records of input dataframe by article_id and title; order by count value in descending order\n",
    "    top_articles = list(df.groupby([\"article_id\"  ])['user_id'].count().to_frame() \\\n",
    "                           .rename(columns={\"user_id\":\"Counts\"}).reset_index()  \\\n",
    "                           .sort_values(\"Counts\", ascending = False)['article_id'][:n])\n",
    "    \n",
    "    \n",
    "    top_articles = [str(x) for x in top_articles]\n",
    "    \n",
    "    #Return IDs for top articles\n",
    "    return top_articles "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['use deep learning for image classification', 'insights from new york car accident reports', 'visualize car data with brunel', 'use xgboost, scikit-learn & ibm watson machine learning apis', 'predicting churn with the spss random tree algorithm', 'healthcare python streaming application demo', 'finding optimal locations of new store using decision optimization', 'apache spark lab, part 1: basic concepts', 'analyze energy consumption in buildings', 'gosales transactions for logistic regression model']\n",
      "['1429.0', '1330.0', '1431.0', '1427.0', '1364.0', '1314.0', '1293.0', '1170.0', '1162.0', '1304.0']\n"
     ]
    }
   ],
   "source": [
    "print(get_top_articles(10))\n",
    "print(get_top_article_ids(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"User-User\">Part III: User-User Based Collaborative Filtering</a>\n",
    "\n",
    "`1.` Create a function to reformat the **df** dataframe to be shaped with users as rows and articles as columns.  \n",
    "\n",
    "* Each **user** should only appear in each **row** once.\n",
    "\n",
    "\n",
    "* Each **article** should only show up in one **column**.  \n",
    "\n",
    "\n",
    "* **If a user has interacted with an article, then place a 1 where the user-row meets for that article-column**.  It does not matter how many times a user has interacted with the article, all entries where a user has interacted with an article should be a 1.  \n",
    "\n",
    "\n",
    "* **If a user has not interacted with an item, then place a zero where the user-row meets for that article-column**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the user-article matrix with 1's and 0's\n",
    "\n",
    "def create_user_item_matrix(df):\n",
    "    '''\n",
    "    INPUT:\n",
    "    df - pandas dataframe with article_id, title, user_id columns\n",
    "    \n",
    "    OUTPUT:\n",
    "    user_item - user item matrix \n",
    "    \n",
    "    Description:\n",
    "    Return a matrix with user ids as rows and article ids on the columns with 1 values where a user interacted with \n",
    "    an article and a 0 otherwise\n",
    "    '''\n",
    "    \n",
    "    #Create a dataframe which has user id as rows and article_ids as columns\n",
    "    user_item = df.groupby(['user_id', 'article_id'])['title'].min().unstack()\n",
    "    \n",
    "    #Replace values with 1s and nulls with 0s\n",
    "    user_item = user_item.applymap(lambda x: 0 if pd.isnull(x) else 1)\n",
    "    \n",
    "    #Return the matrix\n",
    "    return user_item  \n",
    "\n",
    "user_item = create_user_item_matrix(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` Create a function which should take a user_id and provide an ordered list of the most similar users to that user (from most similar to least similar).  The returned result should not contain the provided user_id, as we know that each user is similar to him/herself. Because the results for each user here are binary, it (perhaps) makes sense to compute similarity as the dot product of two users. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_similar_users(user_id, user_item=user_item):\n",
    "    '''\n",
    "    INPUT:\n",
    "    user_id - (int) a user_id\n",
    "    user_item - (pandas dataframe) matrix of users by articles: \n",
    "                1's when a user has interacted with an article, 0 otherwise\n",
    "    \n",
    "    OUTPUT:\n",
    "    similar_users - (list) an ordered list where the closest users (largest dot product users)\n",
    "                    are listed first\n",
    "    \n",
    "    Description:\n",
    "    Computes the similarity of every pair of users based on the dot product\n",
    "    Returns an ordered list from most to least similar\n",
    "    \n",
    "    '''\n",
    "\n",
    "    dot_product = dict()\n",
    "\n",
    "    #Loop through all the users in user_item dataframe\n",
    "    for indx in user_item.index:\n",
    "\n",
    "        #Pass if the input user_id is equal to the user_id in the looping parameter\n",
    "        if indx == user_id:\n",
    "            pass\n",
    "        else:\n",
    "            #Get the dot product of the array created by the input user and all other users in the dataframe\n",
    "            dot_product[indx] = user_item.loc[user_id].dot(user_item.loc[indx])\n",
    "            #Remove records where dot product is zero\n",
    "            dot_product = {x:y for x,y in dot_product.items() if y!=0}\n",
    "            \n",
    "    #Sort the dictionary in descending order and save it as a list      \n",
    "    most_similar_users = list(dict(sorted(dot_product.items() , key=lambda x:x[1] , reverse=True)))\n",
    "       \n",
    "    return most_similar_users "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.` Now that we have a function that provides the most similar users to each user, we will want to use these users to find articles to recommend. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_article_names(article_ids, df=df):\n",
    "    '''\n",
    "    INPUT:\n",
    "    article_ids - (list) a list of article ids\n",
    "    df - (pandas dataframe) df as defined at the top of the notebook\n",
    "    \n",
    "    OUTPUT:\n",
    "    article_names - (list) a list of article names associated with the list of article ids \n",
    "                    (this is identified by the title column)\n",
    "    '''\n",
    "    # Get article names for inputted articleids, save it as a list\n",
    "    article_names = list(set( df['title'][df['article_id'].isin(article_ids)]))\n",
    "    \n",
    "    return article_names \n",
    "\n",
    "\n",
    "\n",
    "def get_user_articles(user_id, user_item=user_item):\n",
    "    '''\n",
    "    INPUT:\n",
    "    user_id - (int) a user id\n",
    "    user_item - (pandas dataframe) matrix of users by articles:\n",
    "                1's when a user has interacted with an article, 0 otherwise\n",
    "\n",
    "    OUTPUT:\n",
    "    article_ids - (list) a list of the article ids seen by the user\n",
    "    article_names - (list) a list of article names associated with\n",
    "                    the list of article ids\n",
    "\n",
    "    Description:\n",
    "    Provides a list of the article_ids and article titles that have\n",
    "    been seen by a user\n",
    "    '''\n",
    "    \n",
    "    #Create a dataframe with all article_ids for the user_id\n",
    "    user_articles = (user_item.loc[user_id] == 1).to_frame().reset_index()\n",
    "    #Filter for article_ids seen by the user, save it as a list\n",
    "    user_articles_lst = list(user_articles['article_id'][user_articles[user_id] == True].astype(str))\n",
    "    #Get all artcile names by calling above function\n",
    "    user_articles_names = get_article_names(user_articles_lst, df=df)\n",
    "    #Return article_ids along with artile names seen by a specific user \n",
    "    return user_articles_lst , user_articles_names\n",
    "\n",
    "\n",
    "def user_user_recs(user_id, m=10):\n",
    "    '''\n",
    "    INPUT:\n",
    "    user_id - (int) a user id\n",
    "    m - (int) the number of recommendations you want for the user\n",
    "    \n",
    "    OUTPUT:\n",
    "    recs - (list) a list of recommendations for the user\n",
    "    \n",
    "    Description:\n",
    "    Loops through the users based on closeness to the input user_id\n",
    "    For each user - finds articles the user hasn't seen before and provides them as recs\n",
    "    Does this until m recommendations are found\n",
    "    \n",
    "    '''\n",
    "    #Get ids for the inputted user_id\n",
    "    user_articles_lst = get_user_articles(user_id)[0]\n",
    "\n",
    "    #Find similar users by calling above function\n",
    "    similar_users = find_similar_users(user_id,user_item)\n",
    "\n",
    "    recs = []\n",
    "    \n",
    "    #Loop through all similar users \n",
    "    for sim_user in similar_users:\n",
    "        #Loop through all the items inputted user_id has seen\n",
    "        for i in  get_user_articles(sim_user)[0] :\n",
    "                #Filter for all items that the inputted user_id has not seen \n",
    "                if i not in user_articles_lst and i not in recs:\n",
    "\n",
    "                        recs.append(i)\n",
    "\n",
    "                if len(recs) > 10:\n",
    "                        break\n",
    "                        \n",
    "        if len(recs) > 10:\n",
    "                        break\n",
    "\n",
    "    return recs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this week in data science (may 2, 2017)',\n",
       " 'higher-order logistic regression for large datasets',\n",
       " 'timeseries data analysis of iot events by using jupyter notebook',\n",
       " 'graph-based machine learning',\n",
       " 'experience iot with coursera',\n",
       " 'the 3 kinds of context: machine learning and the art of the frame',\n",
       " 'deep forest: towards an alternative to deep neural networks',\n",
       " 'using machine learning to predict parking difficulty',\n",
       " 'this week in data science (april 18, 2017)',\n",
       " 'got zip code data? prep it for analytics. – ibm watson data lab – medium',\n",
       " 'using brunel in ipython/jupyter notebooks']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check Results\n",
    "get_article_names(user_user_recs(1, 10)) # Return 10 recommendations for user 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` Now we are going to improve the consistency of the **user_user_recs** function from above.  \n",
    "\n",
    "* Instead of arbitrarily choosing when we obtain users who are all the same closeness to a given user - choose the users that have the most total article interactions before choosing those with fewer article interactions.\n",
    "\n",
    "\n",
    "* Instead of arbitrarily choosing articles from the user where the number of recommended articles starts below m and ends exceeding m, choose articles with the articles with the most total interactions before choosing those with fewer total interactions. This ranking should be  what would be obtained from the **top_articles** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_sorted_users(user_id, df=df, user_item=user_item):\n",
    "    '''\n",
    "    INPUT:\n",
    "    user_id - (int)\n",
    "    df - (pandas dataframe) df as defined at the top of the notebook \n",
    "    user_item - (pandas dataframe) matrix of users by articles: \n",
    "            1's when a user has interacted with an article, 0 otherwise\n",
    "    \n",
    "            \n",
    "    OUTPUT:\n",
    "    neighbors_df - (pandas dataframe) a dataframe with:\n",
    "                    neighbor_id - is a neighbor user_id\n",
    "                    similarity - measure of the similarity of each user to the provided user_id\n",
    "                    num_interactions - the number of articles viewed by the user - if a u\n",
    "                    \n",
    "    Other Details - sort the neighbors_df by the similarity and then by number of interactions where \n",
    "                    highest of each is higher in the dataframe\n",
    "     \n",
    "    '''\n",
    "    \n",
    "    #Get all info related to the inputted user\n",
    "    specific_user_info = user_item.loc[user_id]\n",
    "    #Calculate similarity as a dot product and create a dataframe\n",
    "    df_specific_user_info = user_item.dot(specific_user_info).sort_values(ascending = False) \\\n",
    "                                    .to_frame().reset_index().rename(columns = {0:\"Similarity\" , 'user_id': 'neighbor_id'})\n",
    "    #Find number of interactions for each user_id and create a dataframe\n",
    "    df_nr_interactions = df.groupby('user_id').count()['article_id'].reset_index() \\\n",
    "            .rename(columns ={'user_id':'neighbor_id' , 'article_id':'nr_interactions'} )\n",
    "\n",
    "    #Merge above dataframes together \n",
    "    neighbors_df = pd.merge(df_specific_user_info , df_nr_interactions , on = \"neighbor_id\" , how = \"inner\")\n",
    "\n",
    "    #Sort the dataframe\n",
    "    neighbors_df = neighbors_df.sort_values(by=['Similarity','nr_interactions'], ascending=False)\n",
    "    #Remove the row similar to the entered user_id\n",
    "    neighbors_df = neighbors_df[~ (neighbors_df['neighbor_id'] == user_id)]\n",
    "    #Drop the index\n",
    "    neighbors_df = neighbors_df.reset_index().drop(columns = 'index')\n",
    "    \n",
    "    return neighbors_df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def user_user_recs_part2(user_id, m=10):\n",
    "    '''\n",
    "    INPUT:\n",
    "    user_id - (int) a user id\n",
    "    m - (int) the number of recommendations you want for the user\n",
    "    \n",
    "    OUTPUT:\n",
    "    recs - (list) a list of recommendations for the user by article id\n",
    "    rec_names - (list) a list of recommendations for the user by article title\n",
    "    \n",
    "    Description:\n",
    "    Loops through the users based on closeness to the input user_id\n",
    "    For each user - finds articles the user hasn't seen before and provides them as recs\n",
    "    Does this until m recommendations are found\n",
    "    \n",
    "    Notes:\n",
    "    * Choose the users that have the most total article interactions \n",
    "    before choosing those with fewer article interactions.\n",
    "\n",
    "    * Choose articles with the articles with the most total interactions \n",
    "    before choosing those with fewer total interactions. \n",
    "   \n",
    "    '''\n",
    "    \n",
    "    #Get top sorted users\n",
    "    close_neighbors = get_top_sorted_users(user_id)['neighbor_id'] \n",
    "\n",
    "    full_df = []\n",
    "    articles_interactions = {}\n",
    " \n",
    "    #Store articles_ids for each of the close neigbor to the list   \n",
    "    for i in close_neighbors:\n",
    "            article_ids = user_item.loc[i][user_item.loc[i] == 1].index\n",
    "            for j in range(len(article_ids)):\n",
    "                   full_df.append(article_ids[j])\n",
    "\n",
    "            full_df = list(set(full_df))\n",
    "\n",
    "    #Transpose user_item matrix to find total number of interactions for each artile and sort the dict descending\n",
    "    for j in full_df:\n",
    "\n",
    "            articles_interactions[j] = user_item.T.loc[j].sum()\n",
    "\n",
    "            articles_interactions = dict(sorted(articles_interactions.items() , key=lambda x:x[1] , reverse=True))\n",
    "\n",
    "\n",
    "    recs = list(articles_interactions)[:m]\n",
    "    rec_names = get_article_names(recs)\n",
    "\n",
    "\n",
    "\n",
    "    return recs, rec_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The top 10 recommendations for user 20 are the following article ids:\n",
      "[1330.0, 1429.0, 1364.0, 1314.0, 1398.0, 1431.0, 1271.0, 1427.0, 43.0, 1160.0]\n",
      "\n",
      "The top 10 recommendations for user 20 are the following article names:\n",
      "['customer demographics and sales', 'total population by country', 'insights from new york car accident reports', 'deep learning with tensorflow course by big data university', 'visualize car data with brunel', 'analyze accident reports on amazon emr spark', 'use xgboost, scikit-learn & ibm watson machine learning apis', 'predicting churn with the spss random tree algorithm', 'use deep learning for image classification', 'healthcare python streaming application demo']\n"
     ]
    }
   ],
   "source": [
    "#Testing\n",
    "rec_ids, rec_names = user_user_recs_part2(20, 10)\n",
    "print(\"The top 10 recommendations for user 20 are the following article ids:\")\n",
    "print(rec_ids)\n",
    "print()\n",
    "print(\"The top 10 recommendations for user 20 are the following article names:\")\n",
    "print(rec_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These approaches might work well for users for which we have historical data. In cases of new users there is no information available hence we don't have users to compare with each-other. In this situation we can recommend top 10 articles by using function: **get_top_article_ids(10).**\n",
    "\n",
    "Other ways to make recommendations for new users might be knowledge based or content based recommendation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Matrix-Fact\">Part IV: Matrix Factorization</a>\n",
    "\n",
    "`1`. In this part of the notebook, I use matrix factorization to make article recommendations to the users on the IBM Watson Studio platform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the matrix here\n",
    "user_item_matrix = pd.read_pickle('user_item_matrix.p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>article_id</th>\n",
       "      <th>0.0</th>\n",
       "      <th>100.0</th>\n",
       "      <th>1000.0</th>\n",
       "      <th>1004.0</th>\n",
       "      <th>1006.0</th>\n",
       "      <th>1008.0</th>\n",
       "      <th>101.0</th>\n",
       "      <th>1014.0</th>\n",
       "      <th>1015.0</th>\n",
       "      <th>1016.0</th>\n",
       "      <th>...</th>\n",
       "      <th>977.0</th>\n",
       "      <th>98.0</th>\n",
       "      <th>981.0</th>\n",
       "      <th>984.0</th>\n",
       "      <th>985.0</th>\n",
       "      <th>986.0</th>\n",
       "      <th>990.0</th>\n",
       "      <th>993.0</th>\n",
       "      <th>996.0</th>\n",
       "      <th>997.0</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>user_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 714 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "article_id  0.0  100.0  1000.0  1004.0  1006.0  1008.0  101.0  1014.0  1015.0  \\\n",
       "user_id                                                                         \n",
       "1           0.0    0.0     0.0     0.0     0.0     0.0    0.0     0.0     0.0   \n",
       "2           0.0    0.0     0.0     0.0     0.0     0.0    0.0     0.0     0.0   \n",
       "3           0.0    0.0     0.0     0.0     0.0     0.0    0.0     0.0     0.0   \n",
       "4           0.0    0.0     0.0     0.0     0.0     0.0    0.0     0.0     0.0   \n",
       "5           0.0    0.0     0.0     0.0     0.0     0.0    0.0     0.0     0.0   \n",
       "\n",
       "article_id  1016.0  ...    977.0  98.0  981.0  984.0  985.0  986.0  990.0  \\\n",
       "user_id             ...                                                     \n",
       "1              0.0  ...      0.0   0.0    1.0    0.0    0.0    0.0    0.0   \n",
       "2              0.0  ...      0.0   0.0    0.0    0.0    0.0    0.0    0.0   \n",
       "3              0.0  ...      1.0   0.0    0.0    0.0    0.0    0.0    0.0   \n",
       "4              0.0  ...      0.0   0.0    0.0    0.0    0.0    0.0    0.0   \n",
       "5              0.0  ...      0.0   0.0    0.0    0.0    0.0    0.0    0.0   \n",
       "\n",
       "article_id  993.0  996.0  997.0  \n",
       "user_id                          \n",
       "1             0.0    0.0    0.0  \n",
       "2             0.0    0.0    0.0  \n",
       "3             0.0    0.0    0.0  \n",
       "4             0.0    0.0    0.0  \n",
       "5             0.0    0.0    0.0  \n",
       "\n",
       "[5 rows x 714 columns]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# quick look at the matrix\n",
    "user_item_matrix.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` In this situation, I will use Singular Value Decomposition from [numpy](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.linalg.svd.html) on the user-item matrix.  Afterwards will perform SVD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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>article_id</th>\n",
       "      <th>Na_counts</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [article_id, Na_counts]\n",
       "Index: []"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perform SVD on the User-Item Matrix\n",
    "\n",
    "u, s, vt = np.linalg.svd(user_item_matrix)\n",
    "df_na_matrix = user_item_matrix.isna().sum().to_frame().rename(columns = {0:\"Na_counts\"}).reset_index()\n",
    "df_na_matrix[df_na_matrix['Na_counts'] > 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.`How do we choose the number of latent features to use?  Below code shows that as the number of latent features increases, we obtain a lower error rate on making predictions for the 1 and 0 values in the user-item matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0101d69780>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_latent_feats = np.arange(10,700+10,20)\n",
    "sum_errs = []\n",
    "\n",
    "for k in num_latent_feats:\n",
    "    # restructure with k latent features\n",
    "    s_new, u_new, vt_new = np.diag(s[:k]), u[:, :k], vt[:k, :]\n",
    "    \n",
    "    # take dot product\n",
    "    user_item_est = np.around(np.dot(np.dot(u_new, s_new), vt_new))\n",
    "    \n",
    "    # compute error for each prediction to actual value\n",
    "    diffs = np.subtract(user_item_matrix, user_item_est)\n",
    "    \n",
    "    # total errors and keep track of them\n",
    "    err = np.sum(np.sum(np.abs(diffs)))\n",
    "    sum_errs.append(err)\n",
    "    \n",
    "    \n",
    "plt.plot(num_latent_feats, 1 - np.array(sum_errs)/df.shape[0]);\n",
    "plt.xlabel('Number of Latent Features');\n",
    "plt.ylabel('Accuracy');\n",
    "plt.title('Accuracy vs. Number of Latent Features');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` From the above, we can't really be sure how many features to use, because simply having a better way to predict the 1's and 0's of the matrix doesn't exactly give us an indication of if we are able to make good recommendations.  Instead, we might split our dataset into a training and test set of data, as shown in the cell below.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = df.head(40000)\n",
    "df_test = df.tail(5993)\n",
    "\n",
    "def create_test_and_train_user_item(df_train, df_test):\n",
    "    '''\n",
    "    INPUT:\n",
    "    df_train - training dataframe\n",
    "    df_test - test dataframe\n",
    "    \n",
    "    OUTPUT:\n",
    "    user_item_train - a user-item matrix of the training dataframe \n",
    "                      (unique users for each row and unique articles for each column)\n",
    "    user_item_test - a user-item matrix of the testing dataframe \n",
    "                    (unique users for each row and unique articles for each column)\n",
    "    test_idx - all of the test user ids\n",
    "    test_arts - all of the test article ids\n",
    "    \n",
    "    '''\n",
    "    #Use function from previous section to create user_item train and test matrixes\n",
    "    user_item_train = create_user_item_matrix(df_train)\n",
    "    user_item_test = create_user_item_matrix(df_test)\n",
    "\n",
    "    #Get a list of all unique  user ids in test set\n",
    "    test_idx = list(set(user_item_test.index))\n",
    "    #Get a list of all unique article ids in test set\n",
    "    test_arts = list(set(user_item_test.T.index))\n",
    "\n",
    "    #Get a list of all unique user ids in the train set\n",
    "    train_idx = list(set(user_item_train.index))\n",
    "    #Get a list of all unique article ids in the train set\n",
    "    train_arts = list(set(user_item_train.T.index))\n",
    "\n",
    "    #Find the common ids between training and testing sets to avoid the cold start problem \n",
    "    common_ids = set(train_idx).intersection(test_idx) \n",
    "    common_arts  = set(train_arts).intersection(test_arts) \n",
    "\n",
    "    #Select from test set only the common ids\n",
    "    user_item_test = user_item_test.loc[common_ids , common_arts]\n",
    "    \n",
    "    \n",
    "    return user_item_train, user_item_test, test_idx, test_arts\n",
    "\n",
    "user_item_train, user_item_test, test_idx, test_arts = create_test_and_train_user_item(df_train, df_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`5.` Use the **user_item_train** dataset from above to find U, S, and V transpose using SVD.\n",
    "Find the subset of rows in the **user_item_test** dataset that you can predict using this matrix decomposition with different numbers of latent features to see how many features makes sense to keep based on the accuracy on the test data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit SVD on the user_item_train matrix\n",
    "u_train, s_train, vt_train = np.linalg.svd(user_item_train)\n",
    "\n",
    "\n",
    "id_index = user_item_train.index.isin(test_idx)\n",
    "article_idx = user_item_train.columns.isin(test_arts)\n",
    "\n",
    "u_test = u_train[id_index, :]\n",
    "vt_test = vt_train[:, article_idx]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0101cbe5c0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_latent_feats = np.arange(10,700+10,20)\n",
    "sum_train_errs  = []\n",
    "sum_test_errs  = []\n",
    "\n",
    "#Loop through different numbers in the num_latent_feats\n",
    "\n",
    "for k in num_latent_feats:\n",
    "    \n",
    "    #Filter from datasets for number of k\n",
    "    s_new_train, u_new_train, vt_new_train , u_new_test, vt_new_test = np.diag(s_train[:k]), u_train[:, :k], vt_train[:k, :] , u_test[:, :k], vt_test[:k, :]\n",
    "    \n",
    "    #Calculate the dot product\n",
    "    \n",
    "    user_item_train_dot_prod = np.around(np.dot(np.dot(u_new_train, s_new_train), vt_new_train))\n",
    "    user_item_test_dot_prod = np.around(np.dot(np.dot(u_new_test, s_new_train), vt_new_test))\n",
    "    \n",
    "    #Get the error by subtracting prediction from the true value\n",
    "    err_diff_train = np.subtract(user_item_train, user_item_train_dot_prod)\n",
    "    err_diff_test = np.subtract(user_item_test, user_item_test_dot_prod)\n",
    "    \n",
    "    \n",
    "    #Sum for the total errors\n",
    "    train_err = np.sum(np.sum(np.abs(err_diff_train)))\n",
    "    test_err  = np.sum(np.sum(np.abs(err_diff_test)))\n",
    "    \n",
    "    #Append to the lists\n",
    "    sum_train_errs.append(train_err)\n",
    "    sum_test_errs.append(test_err )\n",
    "    \n",
    "plt.plot(num_latent_feats, 1 - np.array(sum_train_errs)/(user_item_train.shape[0]*user_item_test.shape[1]), label='Train');\n",
    "plt.plot(num_latent_feats, 1 - np.array(sum_test_errs )/(user_item_test.shape[0]*user_item_test.shape[1]), label='Test');\n",
    "plt.xlabel('Number of Latent Features');\n",
    "plt.ylabel('Accuracy');\n",
    "plt.title('Accuracy vs. Number of Latent Features');\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although the Matrix Factorization yields nice results for small number of latent features, it drops very quickly as the number of latent features increases. As it can be seen from the chart, when number of features passes the number of users (only 20) accuracy drops for testing set and increases for training data, this indicates overfitting - algorithm fits training data very well but doesn't perfom the same in the testing set. \n",
    "\n",
    "\n",
    "I think we still need to work to create a better recommendation system. We might need to work in increasing the number of data points/dimensionality, or augment the testing set to overcome the imbalance issue. Also, we can try other ML techniques in combination with A/B testing."
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}