Recommendations_with_IBM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recommendations with IBM Watson Studio \n",
    "---\n",
    "[Udacity Nanodegree in Data Science - Project 4](https://www.udacity.com/course/data-scientist-nanodegree--nd025)\n",
    "\n",
    "\n",
    "In this project, I analyze the interactions that users have with articles on the IBM Watson Studio platform to make recommendations of new articles that might be of their interest.\n",
    "\n",
    "The table of contents outlines the different methods for making recommendations that will be used in this notebook.\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",
    "V. [Conclusions, Actions and Future Directions](#conclusion)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Let's get started by importing the necessary libraries and reading in the data.\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "sys.path.append('./tests')\n",
    "import project_tests as t\n",
    "import pickle\n",
    "from typing import List, Tuple\n",
    "from itertools import permutations\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Read raw data\n",
    "df = pd.read_csv('data/user-item-interactions.csv').drop(columns=['Unnamed: 0'])\n",
    "df_content = pd.read_csv('data/articles_community.csv').drop(columns=['Unnamed: 0'])"
   ]
  },
  {
   "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...</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                                              title  \\\n",
       "0      1430.0  using pixiedust for fast, flexible, and easier...   \n",
       "1      1314.0       healthcare python streaming application demo   \n",
       "2      1429.0         use deep learning for image classification   \n",
       "3      1338.0          ml optimization using cognitive assistant   \n",
       "4      1276.0          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": [
    "# Show df to get an idea of the data\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 45993 entries, 0 to 45992\n",
      "Data columns (total 3 columns):\n",
      " #   Column      Non-Null Count  Dtype  \n",
      "---  ------      --------------  -----  \n",
      " 0   article_id  45993 non-null  float64\n",
      " 1   title       45993 non-null  object \n",
      " 2   email       45976 non-null  object \n",
      "dtypes: float64(1), object(2)\n",
      "memory usage: 1.1+ MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "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...</td>\n",
       "      <td>Detect bad readings in real time using Python ...</td>\n",
       "      <td>Detect Malfunctioning IoT Sensors with Streami...</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 ...</td>\n",
       "      <td>See the forest, see the trees. Here lies the c...</td>\n",
       "      <td>Communicating data science: A guide to present...</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 Pat...</td>\n",
       "      <td>Here’s this week’s news in Data Science and Bi...</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 SCA...</td>\n",
       "      <td>Learn how distributed DBs solve the problem of...</td>\n",
       "      <td>DataLayer Conference: Boost the performance of...</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...</td>\n",
       "      <td>This video demonstrates the power of IBM DataS...</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...   \n",
       "1  No Free Hunch Navigation * kaggle.com\\r\\n\\r\\n ...   \n",
       "2  ☰ * Login\\r\\n * Sign Up\\r\\n\\r\\n * Learning Pat...   \n",
       "3  DATALAYER: HIGH THROUGHPUT, LOW LATENCY AT SCA...   \n",
       "4  Skip navigation Sign in SearchLoading...\\r\\n\\r...   \n",
       "\n",
       "                                     doc_description  \\\n",
       "0  Detect bad readings in real time using Python ...   \n",
       "1  See the forest, see the trees. Here lies the c...   \n",
       "2  Here’s this week’s news in Data Science and Bi...   \n",
       "3  Learn how distributed DBs solve the problem of...   \n",
       "4  This video demonstrates the power of IBM DataS...   \n",
       "\n",
       "                                       doc_full_name doc_status  article_id  \n",
       "0  Detect Malfunctioning IoT Sensors with Streami...       Live           0  \n",
       "1  Communicating data science: A guide to present...       Live           1  \n",
       "2         This Week in Data Science (April 18, 2017)       Live           2  \n",
       "3  DataLayer Conference: Boost the performance of...       Live           3  \n",
       "4      Analyze NY Restaurant data using Spark in DSX       Live           4  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show df_content to get an idea of the data\n",
    "df_content.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 1056 entries, 0 to 1055\n",
      "Data columns (total 5 columns):\n",
      " #   Column           Non-Null Count  Dtype \n",
      "---  ------           --------------  ----- \n",
      " 0   doc_body         1042 non-null   object\n",
      " 1   doc_description  1053 non-null   object\n",
      " 2   doc_full_name    1056 non-null   object\n",
      " 3   doc_status       1056 non-null   object\n",
      " 4   article_id       1056 non-null   int64 \n",
      "dtypes: int64(1), object(4)\n",
      "memory usage: 41.4+ KB\n"
     ]
    }
   ],
   "source": [
    "df_content.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Exploratory-Data-Analysis\">Part I : Exploratory Data Analysis</a>\n",
    "---\n",
    "\n",
    "First, let's use some descriptive statistics and basic visualization techniques to understand the data.\n",
    "\n",
    " - What is the distribution of how many articles a user interacts with an article in the dataset?  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ECDF(\n",
    "    array: np.array,\n",
    ") -> Tuple[np.array, np.array]:\n",
    "    \"\"\"Empirical Cumulative Distribution Function. \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    array : numpy array\n",
    "        Array with datapoints. \n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    x : np.array\n",
    "    y : np.array\n",
    "    \n",
    "    \"\"\"\n",
    "    y = np.linspace(0, 1, num=array.size)\n",
    "    x = sorted(array)\n",
    "    \n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`1.` Number of Interactions \n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get individual interactions \n",
    "n_unique_users = df.email.value_counts().index.size\n",
    "n_interactions_by_user = df.email.value_counts().values\n",
    "\n",
    "fig, axs = plt.subplots(1, 2, figsize=(15, 5))\n",
    "\n",
    "axs[0].hist(\n",
    "    n_interactions_by_user,\n",
    "    bins=100, density=True,\n",
    "    label=f'n_users: {n_unique_users}'\n",
    ")\n",
    "\n",
    "axs[0].set(\n",
    "    ylabel='Density',\n",
    "    xlabel='n_article_interactions'\n",
    ")\n",
    "\n",
    "# plot the ECDF\n",
    "x, y = ECDF(n_interactions_by_user)\n",
    "\n",
    "axs[1].plot(\n",
    "    x,\n",
    "    y,\n",
    "    label=f'n_users: {n_unique_users}'\n",
    ")\n",
    "axs[1].set(\n",
    "    ylabel='ECDF',\n",
    "    xlabel='n_article_interactions'\n",
    ")\n",
    "\n",
    "# Add legend\n",
    "for i in range(2):\n",
    "    axs[i].legend()\n",
    "\n",
    "fig.suptitle('Distribution of user-article interactions')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50% of the users interact with 3.0 articles or fewer.\n",
      "The maximum number of user-article interactions is 364.\n"
     ]
    }
   ],
   "source": [
    "median_val = np.median(n_interactions_by_user)\n",
    "max_views_by_user = np.max(n_interactions_by_user)\n",
    "\n",
    "print(f'50% of the users interact with {median_val} articles or fewer.')\n",
    "print(f'The maximum number of user-article interactions is {max_views_by_user}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` Explore and remove duplicate articles from the **df_content** dataframe.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1056, 5)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Shape of the dataframe\n",
    "df_content.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of duplicate entries is 5 articles.\n"
     ]
    }
   ],
   "source": [
    "# How many duplicate articles exist?\n",
    "n_duplicates_before = df_content.shape[0] - df_content.article_id.unique().size\n",
    "\n",
    "print(f'The number of duplicate entries is {n_duplicates_before} articles.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Remove any rows that have the same article_id - only keep the first\n",
    "df_content.drop_duplicates('article_id', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of duplicate entries after removal of duplicates is 0 articles.\n"
     ]
    }
   ],
   "source": [
    "n_duplicates_after = df_content.shape[0] - df_content.article_id.unique().size\n",
    "\n",
    "print(f'The number of duplicate entries after removal of duplicates is {n_duplicates_after} articles.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.` Other important information about the data:\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": {
    "tags": []
   },
   "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...</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                                              title  \\\n",
       "0      1430.0  using pixiedust for fast, flexible, and easier...   \n",
       "1      1314.0       healthcare python streaming application demo   \n",
       "2      1429.0         use deep learning for image classification   \n",
       "3      1338.0          ml optimization using cognitive assistant   \n",
       "4      1276.0          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": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The number of unique articles that have at least one interaction\n",
    "if df.groupby(['article_id'])['email'].count().min() >= 1:\n",
    "    unique_articles = df.groupby(['article_id'])['email'].count().index.size\n",
    "\n",
    "# The number of unique articles on the IBM platform\n",
    "total_articles = df_content.article_id.unique().size\n",
    "\n",
    "# The number of unique users\n",
    "unique_users = df.email.unique().size # includes 1 null user.\n",
    "\n",
    "# The number of user-article interactions\n",
    "user_article_interactions = df.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of unique articles that have at least one interaction is 714.\n",
      "The number of unique articles on the IBM platform is 1051.\n",
      "The number of unique users is 5149.\n",
      "The number of user-article interactions is 45993.\n"
     ]
    }
   ],
   "source": [
    "print(f'The number of unique articles that have at least one interaction is {unique_articles}.')\n",
    "print(f'The number of unique articles on the IBM platform is {total_articles}.')\n",
    "print(f'The number of unique users is {unique_users}.')\n",
    "print(f'The number of user-article interactions is {user_article_interactions}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` cells below show the most viewed **article_id**, as well as how often it was viewed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most viewed article was 1429 with 937 views.\n"
     ]
    }
   ],
   "source": [
    "# The most viewed article in the dataset as a string with one value following the decimal \n",
    "most_viewed_article_id = df.groupby(['article_id'])['email'].count()\\\n",
    "                                                            .sort_values(ascending=False)\\\n",
    "                                                            .index[0]\n",
    "        \n",
    "# The most viewed article in the dataset was viewed how many times?\n",
    "max_views = df.groupby(['article_id'])['email'].count()\\\n",
    "                                               .sort_values(ascending=False)\\\n",
    "                                               .astype(str)\\\n",
    "                                               .iloc[0]\n",
    "\n",
    "\n",
    "print(f'The most viewed article was {int(most_viewed_article_id)} with {max_views} views.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY MAINTENCANCE FUNCTION AND GRADER\n",
    "---\n",
    "\n",
    "After talking to the company leaders, the `email_mapper` function was deemed a reasonable way to map users to ids.  There were a small number of null values, and it was found that all of these null values likely belonged to a single user (which is how they are stored using the function below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "## UDACITY MAINTENANCE FUNCTION\n",
    "## No need to change the code here - this will be helpful for later parts of the notebook\n",
    "## Run this cell to map the user email to a user_id column and remove the email column\n",
    "\n",
    "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",
    "            \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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It looks like you have everything right here! Nice job!\n"
     ]
    }
   ],
   "source": [
    "sol_1_dict = {\n",
    "    '`50% of individuals have _____ or fewer interactions.`': median_val,\n",
    "    '`The total number of user-article interactions in the dataset is ______.`': user_article_interactions,\n",
    "    '`The maximum number of user-article interactions by any 1 user is ______.`': max_views_by_user,\n",
    "    '`The most viewed article in the dataset was viewed _____ times.`': int(max_views),\n",
    "    '`The article_id of the most viewed article is ______.`': str(most_viewed_article_id),\n",
    "    '`The number of unique articles that have at least 1 rating ______.`': unique_articles,\n",
    "    '`The number of unique users in the dataset is ______`': unique_users - 1, #  remove one null user\n",
    "    '`The number of unique articles on the IBM platform`': total_articles\n",
    "}\n",
    "\n",
    "# Test your dictionary against the solution\n",
    "t.sol_1_test(sol_1_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Rank\">Part II: Rank-Based Recommendations</a>\n",
    "---\n",
    "\n",
    "There are several ways to quantify the rank of an article. For the purpose of this project and given that the data provided by UDACITY does not contain a rating (as proxy for whether a user liked an article or not), I will quantify the **popularity of an article based on how often an article was interacted with**.\n",
    "\n",
    "`1.` The function below returns the **n** top articles ordered with most interactions as the top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_articles(\n",
    "    n: int,\n",
    "    df: pd.DataFrame = df,\n",
    ") -> List[str]:\n",
    "    '''Return the n top article titles based on rank (ie most interactions).\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    n : int\n",
    "        The number of top articles to return.\n",
    "    df : pd.DataFrame \n",
    "        The df as defined at the top of the notebook.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    top_articles : list\n",
    "        A list of the top 'n' article titles. \n",
    "    \n",
    "    '''\n",
    "    \n",
    "    # get the article ids\n",
    "    top_articles_id = df.groupby(['article_id'])['user_id'].count()\\\n",
    "                                                           .sort_values(ascending=False)\\\n",
    "                                                           .iloc[:n]\\\n",
    "                                                           .index\\\n",
    "                                                           .tolist()\n",
    "                                                           \n",
    "    # get the article titles\n",
    "    top_articles = df[df.article_id.isin(top_articles_id)].title\\\n",
    "                                                          .unique()\\\n",
    "                                                          .tolist()\n",
    "    \n",
    "    \n",
    "    return top_articles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test your function by returning the top 5, 10, and 20 articles\n",
    "top_5 = get_top_articles(5)\n",
    "top_10 = get_top_articles(10)\n",
    "top_20 = get_top_articles(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your top_5 looks like the solution list! Nice job.\n",
      "Your top_10 looks like the solution list! Nice job.\n",
      "Your to_20 looks like the solution list! Nice job.\n"
     ]
    }
   ],
   "source": [
    "# Test each of your three lists from above\n",
    "t.sol_2_test(get_top_articles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"User-User\">Part III: User-User Based Collaborative Filtering</a>\n",
    "---\n",
    "\n",
    "In order to implement user-user based collaborative filtering, I will consider whether an user interacted or not with an article. Other implementations could also consider the number of interactions or the rating of an individual article (for our current dataset, this information is missing). \n",
    "\n",
    "\n",
    "`1.` First, reformat the **df** dataframe to be shaped with users as the rows and articles as the columns. This implies:  \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**. \n"
   ]
  },
  {
   "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...</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                                              title  user_id\n",
       "0      1430.0  using pixiedust for fast, flexible, and easier...        1\n",
       "1      1314.0       healthcare python streaming application demo        2\n",
       "2      1429.0         use deep learning for image classification        3\n",
       "3      1338.0          ml optimization using cognitive assistant        4\n",
       "4      1276.0          deploy your python model as a restful api        5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the user-article matrix with 1's and 0's\n",
    "\n",
    "def create_user_item_matrix(df):\n",
    "    '''Returns a user-item matrix.\n",
    "    \n",
    "    The matrix contains user ids as rows and article ids on the columns\n",
    "    with 1 values where a user interacted with an article and a 0 otherwise.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    df : pd.DataFrame\n",
    "        Dataframe with article_id, title, user_id columns.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    user_item : pd.DataFrame\n",
    "        The user-item matrix.\n",
    "    '''\n",
    "    \n",
    "    # interactions any() 1 else 0\n",
    "    user_item = df.groupby(['user_id', 'article_id']).any()\\\n",
    "                                                     .unstack()\n",
    "    # not interactions counts as 0\n",
    "    user_item.fillna(value=0, inplace=True)\n",
    "    \n",
    "    # replace bool True with 1\n",
    "    user_item = user_item.astype(int)\n",
    "    \n",
    "    return user_item\n",
    "\n",
    "# Create user-item matrix of interations\n",
    "user_item = create_user_item_matrix(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have passed our quick tests!  Please proceed!\n"
     ]
    }
   ],
   "source": [
    "## Tests: You should just need to run this cell.  Don't change the code.\n",
    "assert user_item.shape[0] == 5149, \"Oops!  The number of users in the user-article matrix doesn't look right.\"\n",
    "assert user_item.shape[1] == 714, \"Oops!  The number of articles in the user-article matrix doesn't look right.\"\n",
    "assert user_item.sum(axis=1)[1] == 36, \"Oops!  The number of articles seen by user 1 doesn't look right.\"\n",
    "print(\"You have passed our quick tests!  Please proceed!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` Complete the function below 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. \n",
    "\n",
    "Use the tests to test your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_similar_users(\n",
    "    user_id: int,\n",
    "    user_item: pd.DataFrame = user_item,\n",
    ") -> List[int]:\n",
    "    '''Computes the similarity of every pair of users based on the dot product.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    user_id : int\n",
    "        An user_id.\n",
    "    user_item : pd.DataFrame\n",
    "        The matrix of users-by-articles: \n",
    "               - 1's when a user has interacted with an article,\n",
    "               - 0 otherwise.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    similar_users : list of int\n",
    "        An ordered list where the closest users with\n",
    "        the largest dot product are listed first.\n",
    "        \n",
    "    '''\n",
    "    # get the user_id vector with article interaction info\n",
    "    user_id_vector = user_item.loc[user_id, :]\n",
    "    \n",
    "    # Create dictionary to hold similarities with different users\n",
    "    user_sim = {}\n",
    "    \n",
    "    # for each user to compare with...\n",
    "    for user_2 in user_item.index:\n",
    "\n",
    "        # the it is the same user, continue to the next user\n",
    "        if user_id == user_2: \n",
    "            continue\n",
    "\n",
    "        else:\n",
    "            # get the user_2 vector with article interaction info\n",
    "            user_2_vector = user_item.loc[user_2, :]\n",
    "\n",
    "            # calculate dot product\n",
    "            dot = np.dot(user_id_vector, user_2_vector)\n",
    "\n",
    "            # add the result in the dictionary\n",
    "            user_sim[user_2] = dot\n",
    "    \n",
    "    # Build the similarities dataframe\n",
    "    temp_df = pd.DataFrame(\n",
    "        {'user1': [user_id] * len(user_sim.keys()),\n",
    "         'user2': user_sim.keys(),\n",
    "         'similarity': user_sim.values()})\n",
    "\n",
    "    # get sorted list of user_2 ids based on similarity\n",
    "    most_similar_users = temp_df.sort_values('similarity', ascending=False)\\\n",
    "                                .user2\\\n",
    "                                .to_list()\n",
    "    \n",
    "    # return a list of the users in order from most to least similar\n",
    "    return most_similar_users "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 10 most similar users to user 1 are: [3933, 23, 3782, 203, 4459, 3870, 131, 46, 4201, 395]\n",
      "The 5 most similar users to user 3933 are: [1, 23, 3782, 4459, 203]\n",
      "The 3 most similar users to user 46 are: [4201, 23, 3782]\n"
     ]
    }
   ],
   "source": [
    "# Quick check on the function\n",
    "print(\"The 10 most similar users to user 1 are: {}\".format(find_similar_users(1)[:10]))\n",
    "print(\"The 5 most similar users to user 3933 are: {}\".format(find_similar_users(3933)[:5]))\n",
    "print(\"The 3 most similar users to user 46 are: {}\".format(find_similar_users(46)[:3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.` Now that the function that provides the most similar users to each user is ready, I can use these users to find articles you can recommend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['article_id'] = df['article_id'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_article_names(\n",
    "    article_ids: List[str],\n",
    "    df: pd.DataFrame = df,\n",
    ") -> List[str]:\n",
    "    '''Returns the titles of the articles based on article ids.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    article_ids : list of str\n",
    "        A list of article ids.\n",
    "    df : pd.DataFrame \n",
    "     The dataframe df as defined at the top of the notebook.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    article_names - list of str\n",
    "        A list of article names associated with the list of article ids: \n",
    "            - this is identified by the title column.    \n",
    "    '''\n",
    "    \n",
    "    # get article names based on ids\n",
    "    article_names = df[df.article_id.isin(article_ids)]\\\n",
    "                                    .title\\\n",
    "                                    .unique()\n",
    "    \n",
    "    # Return the article names associated with list of article ids\n",
    "    return article_names \n",
    "\n",
    "\n",
    "def get_user_articles(\n",
    "    user_id: int,\n",
    "    user_item: pd.DataFrame = user_item,\n",
    ") -> Tuple[List[int], List[str]]:\n",
    "    '''Provides a list of the article_ids and article titles that have been seen by a user_id.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    user_id : int \n",
    "    A user id\n",
    "    user_item - pd.DataFrame\n",
    "        Matrix of users by articles: \n",
    "                - 1's when a user has interacted with an article,\n",
    "                - 0 otherwise.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    article_ids : list of int\n",
    "        A list of the article ids seen by the user.\n",
    "    article_names - list of str\n",
    "        A list of article names associated with the list of article ids. \n",
    "        This is identified by the doc_full_name column in df_content.\n",
    "    \n",
    "    '''\n",
    "    # condition to subset articles read by user\n",
    "    article_read_by_user = user_item.loc[user_id].isin([1])\n",
    "\n",
    "    # get articles id \n",
    "    article_ids = user_item.loc[user_id, article_read_by_user].unstack().columns.astype(str)\n",
    "\n",
    "    # get article names based on ids\n",
    "    article_names = get_article_names(article_ids, df=df)\n",
    "    \n",
    "    # return the ids and names\n",
    "    return article_ids, article_names \n",
    "\n",
    "\n",
    "def user_user_recs(\n",
    "    user_id: int,\n",
    "    m: int = 10,\n",
    ") -> List[str]:\n",
    "    '''Returns the recommendations for a specific user_id.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    user_id : int\n",
    "        An user id.\n",
    "    m : int\n",
    "        The number of recommendations you want for the user.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    recs : list of str \n",
    "        A list of recommendations for the user.\n",
    "    \n",
    "    Notes\n",
    "    -----\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",
    "    Users who are the same closeness are chosen arbitrarily as the 'next' user.\n",
    "    \n",
    "    For the user where the number of recommended articles starts below m \n",
    "    and ends exceeding m, the last items are chosen arbitrarily.\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    # Calculate similarities\n",
    "    similar_users = find_similar_users(user_id, user_item=user_item)\n",
    "    \n",
    "    # get articles that user read\n",
    "    u1_article_ids, u1_article_names = get_user_articles(user_id, user_item=user_item)\n",
    "    \n",
    "    # instantiate list to hold recommendations\n",
    "    recs = []\n",
    "    \n",
    "    # go \n",
    "    for u2 in similar_users:\n",
    "        \n",
    "        # get u2 article ids\n",
    "        u2_article_ids, u2_article_names = get_user_articles(u2, user_item=user_item)\n",
    "        \n",
    "        # go over each article read by u2\n",
    "        for u2_article_id in u2_article_ids:\n",
    "            \n",
    "            # Check if articles are new to user1 \n",
    "            # and if they are already in recs\n",
    "            if (u2_article_id not in u1_article_ids)\\\n",
    "               and (u2_article_id not in recs):\n",
    "                \n",
    "                #append to recs if n recs below threshold\n",
    "                if len(recs) < m:\n",
    "   \n",
    "                    recs.append(str(u2_article_id))\n",
    "                else:\n",
    "                    break\n",
    "\n",
    "        # if enough recs terminate search\n",
    "        if len(recs) == m:\n",
    "            break\n",
    "    \n",
    "    # return your recommendations for this user_id\n",
    "    return recs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['got zip code data? prep it for analytics. – ibm watson data lab – medium',\n",
       "       'timeseries data analysis of iot events by using jupyter notebook',\n",
       "       'graph-based machine learning',\n",
       "       'using brunel in ipython/jupyter notebooks',\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",
       "       'this week in data science (april 18, 2017)',\n",
       "       'higher-order logistic regression for large datasets',\n",
       "       'using machine learning to predict parking difficulty'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return 10 recommendations for user 1\n",
    "get_article_names(user_user_recs(1, 10)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "If this is all you see, you passed all of our tests!  Nice job!\n"
     ]
    }
   ],
   "source": [
    "# Test your functions here - No need to change this code - just run this cell\n",
    "assert set(get_article_names(['1024.0', '1176.0', '1305.0', '1314.0', '1422.0', '1427.0'])) == set(['using deep learning to reconstruct high-resolution audio', 'build a python app on the streaming analytics service', 'gosales transactions for naive bayes model', 'healthcare python streaming application demo', 'use r dataframes & ibm watson natural language understanding', 'use xgboost, scikit-learn & ibm watson machine learning apis']), \"Oops! Your the get_article_names function doesn't work quite how we expect.\"\n",
    "assert set(get_article_names(['1320.0', '232.0', '844.0'])) == set(['housing (2015): united states demographic measures','self-service data preparation with ibm data refinery','use the cloudant-spark connector in python notebook']), \"Oops! Your the get_article_names function doesn't work quite how we expect.\"\n",
    "assert set(get_user_articles(20)[0]) == set(['1320.0', '232.0', '844.0'])\n",
    "assert set(get_user_articles(20)[1]) == set(['housing (2015): united states demographic measures', 'self-service data preparation with ibm data refinery','use the cloudant-spark connector in python notebook'])\n",
    "assert set(get_user_articles(2)[0]) == set(['1024.0', '1176.0', '1305.0', '1314.0', '1422.0', '1427.0'])\n",
    "assert set(get_user_articles(2)[1]) == set(['using deep learning to reconstruct high-resolution audio', 'build a python app on the streaming analytics service', 'gosales transactions for naive bayes model', 'healthcare python streaming application demo', 'use r dataframes & ibm watson natural language understanding', 'use xgboost, scikit-learn & ibm watson machine learning apis'])\n",
    "print(\"If this is all you see, you passed all of our tests!  Nice job!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` The next step is to improve the consistency of the **user_user_recs** function from above. Some extra layers can be added to the recommender:\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 you wrote earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_sorted_users(\n",
    "    user_id: int,\n",
    "    df: pd.DataFrame = df,\n",
    "    user_item: pd.DataFrame = user_item,\n",
    ") -> pd.DataFrame:\n",
    "    '''Returns a dataframe with neighbor_id, similarity and num_interactions.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    user_id : int\n",
    "        The id of the user.\n",
    "    df : pd.DataFrame\n",
    "        df as defined at the top of the notebook.\n",
    "    user_item : pd.DataFrame\n",
    "        A matrix of users by articles: \n",
    "            - 1's when a user has interacted with an article,\n",
    "            - 0 otherwise.\n",
    "            \n",
    "    Returns\n",
    "    -------\n",
    "    neighbors_df : pd.DataFrame\n",
    "        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",
    "    Notes\n",
    "    -----\n",
    "        neighbors_df is sorted by the similarity \n",
    "        and then by number of interactions where \n",
    "        highest of each is higher in the dataframe.\n",
    "     \n",
    "    '''\n",
    "    \n",
    "    # Get the interactions vector for user_id\n",
    "    user_id_vector = user_item.loc[user_id, :]\n",
    "    \n",
    "    user_sim = {}\n",
    "    interactions = []\n",
    "    \n",
    "    # for every user\n",
    "    for user_2 in user_item.index:\n",
    "\n",
    "        # the it is the same user, continue to the next\n",
    "        if user_id == user_2: \n",
    "            continue\n",
    "\n",
    "        else:\n",
    "            # get user_2 vector\n",
    "            user_2_vector = user_item.loc[user_2, :]\n",
    "\n",
    "            # calculate dot (ie similarity)\n",
    "            dot = np.dot(user_id_vector, user_2_vector)\n",
    "\n",
    "            # append the result in a dictionary\n",
    "            user_sim[user_2] = dot\n",
    "\n",
    "            # calculate interactions\n",
    "            n_interactions = df.groupby('user_id')['article_id'].count().loc[user_2]\n",
    "\n",
    "            # collect interactions\n",
    "            interactions.append(n_interactions)\n",
    "\n",
    "    neighbors_df = pd.DataFrame(\n",
    "        {'neighbor_id': user_sim.keys(),\n",
    "         'similarity': user_sim.values(),\n",
    "         'num_interactions': interactions},\n",
    "    ).sort_values(by=['similarity', 'num_interactions'], ascending=False)\n",
    "\n",
    "    # Return the dataframe specified in the doc_string\n",
    "    return neighbors_df \n",
    "\n",
    "\n",
    "def user_user_recs_part2(\n",
    "    user_id: int,\n",
    "    m: int = 10,\n",
    ") -> Tuple[List[int], List[str]]:\n",
    "    '''Returns the recommendations for a specific user_id.\n",
    "\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\n",
    "    and provides them as recs. \n",
    "    Does this until m recommendations are found.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    user_id : int\n",
    "        An user id.\n",
    "    m : int \n",
    "        The number of recommendations you want for the user.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    recs : list\n",
    "        A list of recommendations for the user by article id.\n",
    "    rec_names : list\n",
    "        A list of recommendations for the user by article title.\n",
    "    \n",
    "    Notes\n",
    "    -----\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",
    "    # Calculate similarities\n",
    "    similarity_df = get_top_sorted_users(user_id, user_item=user_item)\n",
    "    \n",
    "    # get articles that user read\n",
    "    u1_article_ids, u1_article_names = get_user_articles(user_id, user_item=user_item)\n",
    "    \n",
    "    # create recommendations\n",
    "    recs = []\n",
    "    \n",
    "    # go \n",
    "    for u2 in similarity_df.neighbor_id:\n",
    "        \n",
    "        # get u2 article ids\n",
    "        u2_article_ids, u2_article_names = get_user_articles(u2, user_item=user_item)\n",
    "        \n",
    "        # go over each article read by u2\n",
    "        for u2_article_id in u2_article_ids:\n",
    "            \n",
    "           \n",
    "            if (u2_article_id not in u1_article_ids)\\\n",
    "               and (u2_article_id not in recs):\n",
    "                \n",
    "                #append to recs if n recs below threshold\n",
    "                if len(recs) < m:\n",
    "   \n",
    "                    recs.append(str(u2_article_id))\n",
    "                else:\n",
    "                    break\n",
    "\n",
    "        # if enough recs, then terminate search\n",
    "        if len(recs) == m:\n",
    "            break\n",
    "        \n",
    "    rec_names = get_article_names(recs)\n",
    "    \n",
    "    return recs, rec_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The top 10 recommendations for user 20 are the following article ids:\n",
      "['12.0', '109.0', '125.0', '142.0', '164.0', '205.0', '302.0', '336.0', '362.0', '465.0'] \n",
      "\n",
      "The top 10 recommendations for user 20 are the following article names:\n",
      "['timeseries data analysis of iot events by using jupyter notebook'\n",
      " 'dsx: hybrid mode' 'accelerate your workflow with dsx'\n",
      " 'learn tensorflow and deep learning together and now!'\n",
      " \"a beginner's guide to variational methods\" 'tensorflow quick tips'\n",
      " 'challenges in deep learning'\n",
      " 'neural networks for beginners: popular types and applications'\n",
      " 'statistics for hackers'\n",
      " 'introduction to neural networks, advantages and applications']\n"
     ]
    }
   ],
   "source": [
    "# Quick spot check\n",
    "user_id = 20\n",
    "n_recs = 10\n",
    "\n",
    "rec_ids, rec_names = user_user_recs_part2(user_id, n_recs)\n",
    "\n",
    "print(f\"The top {n_recs} recommendations for user {user_id} are the following article ids:\")\n",
    "print(rec_ids, '\\n')\n",
    "print(f\"The top {n_recs} recommendations for user {user_id} are the following article names:\")\n",
    "print(rec_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---\n",
    "`5.` Verify the validity of the recommender."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the user that is most similar to user 1 \n",
    "user1_most_sim = get_top_sorted_users(user_id=1, df=df, user_item=user_item)['neighbor_id'].to_list()[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the 10th most similar user to user 131\n",
    "user131_10th_sim = get_top_sorted_users(user_id=131, df=df, user_item=user_item)['neighbor_id'].to_list()[9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This all looks good!  Nice job!\n"
     ]
    }
   ],
   "source": [
    "sol_5_dict = {\n",
    "    'The user that is most similar to user 1.': user1_most_sim, \n",
    "    'The user that is the 10th most similar to user 131': user131_10th_sim,\n",
    "}\n",
    "\n",
    "t.sol_5_test(sol_5_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`6.` What about **new users**? Which of the above functions would be able to use to make recommendations?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collaborative filtering is a powerful method to provide recommendations based on similarities between users. However this system does not work for new users since there will be no similarity (at least in the very beginning) with other users. Therefore, one way to bypass this _\"cold start problem\"_ would be to provide recommendations based on popularity (ie **Rand-based recommendations**) of articles among all users.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`7.` Let's Provide the top 10 recommended articles for the a new putative user below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The recommendations for new user 0.0 are:\n",
      "1314.0 >>> healthcare python streaming application demo      \n",
      "1429.0 >>> use deep learning for image classification        \n",
      "1170.0 >>> apache spark lab, part 1: basic concepts          \n",
      "1364.0 >>> predicting churn with the spss random tree algorithm\n",
      "1162.0 >>> analyze energy consumption in buildings           \n",
      "1431.0 >>> visualize car data with brunel                    \n",
      "1427.0 >>> use xgboost, scikit-learn & ibm watson machine learning apis\n",
      "1304.0 >>> gosales transactions for logistic regression model\n",
      "1330.0 >>> insights from new york car accident reports       \n",
      "1293.0 >>> finding optimal locations of new store using decision optimization\n"
     ]
    }
   ],
   "source": [
    "new_user = '0.0'\n",
    "\n",
    "# Get rank-based recommendations for user \"0.0\"\n",
    "new_user_recs_article_names = get_top_articles(10)\n",
    "\n",
    "# get article ids\n",
    "new_user_recs = df[df.title.isin(get_top_articles(10))].article_id.unique()\n",
    "\n",
    "print(f'The recommendations for new user {new_user} are:', )\n",
    "for idx, rec in zip(new_user_recs, new_user_recs_article_names):\n",
    "    print(f'{idx: <6} >>> {rec:<50}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "That's right!  Nice job!\n"
     ]
    }
   ],
   "source": [
    "new_user_recs_article_ids = df[df.title.isin(new_user_recs)].article_id.unique().astype(str)\n",
    "\n",
    "assert set(new_user_recs) == set(['1314.0','1429.0','1293.0','1427.0','1162.0','1364.0','1304.0','1170.0','1431.0','1330.0']), \"Oops!  It makes sense that in this case we would want to recommend the most popular articles, because we don't know anything about these users.\"\n",
    "\n",
    "print(\"That's right!  Nice job!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"Matrix-Fact\">Part IV: Matrix Factorization</a>\n",
    "---\n",
    "\n",
    "Matrix Factorization is a power technique to make recommendations to the users on the IBM Watson Studio platform.\n",
    "\n",
    "`1.` This first question here will just require to run the cells below to get things set up for the rest of **Part V** of the notebook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5149, 714)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load matrix\n",
    "user_item_matrix = pd.read_pickle('data/user_item_matrix.p')\n",
    "\n",
    "# quick look at the matrix\n",
    "user_item_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`2.` First, let's 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.  \n",
    "**[Udacity Question]** - Explain why this is different than in the lesson."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform SVD on the User-Item Matrix Here\n",
    "\n",
    "u, s, vt = np.linalg.svd(user_item_matrix, full_matrices=False) # use the built in to get the three matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this specific example, our data matrix is filled with binary inputs (1 for interaction, 0 for no interaction) and therefore there are no missing values. The presence of all values, even in highly sparse matrices is a precodition to use Single Value Decomposition.\n",
    "\n",
    "In the lesson, the data matrix used to build the user-item matrix contained ratings and during aggregation of data, some of the values where absent due of the lack of reviews of a specific item by a specific user. Because the sparse matrix contanined NaNs, the usage of traditional Single Value Decomposition became imposssible. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`3.` How do we choose the number of latent features to use?  Running the below cell, we can see 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.   \n",
    "\n",
    "Run the cell below to get an idea of how the accuracy improves as we increase the number of latent features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_latent_feats = np.arange(start=10, stop=700+10, step=20)\n",
    "sum_errs = []\n",
    "acc = [] # Accuracy sklearn\n",
    "\n",
    "for k in num_latent_feats:\n",
    "    \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",
    "    accucary = accuracy_score(user_item_matrix.to_numpy().flatten(), user_item_est.flatten())\n",
    "    \n",
    "    sum_errs.append(err)\n",
    "    acc.append(accucary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()    \n",
    "\n",
    "ax.plot(\n",
    "    num_latent_feats,\n",
    "    acc,\n",
    ");\n",
    "\n",
    "ax.set(\n",
    "    xlabel='Number of Latent Features',\n",
    "    ylabel='Accuracy',\n",
    "    title='Accuracy vs. Number of Latent Features',\n",
    ");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`4.` From the above, it is difficult to be sure about 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.\n",
    "\n",
    "Another strategy is to implement a division of the dataset into training and testing subsets and perform decomposition on the training with increasing number of latent features and evaluate the result on the test subset. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divive the main dataframe into train and test subsets\n",
    "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",
    "    '''Split user-item matrix into train and test sets.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    df_train : pd.DataFrame\n",
    "        Training dataframe\n",
    "    df_test : pd.DataFrame\n",
    "        Test dataframe\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    user_item_train : pd.DataFrame\n",
    "        A user-item matrix of the training dataframe with\n",
    "        unique users for each row and unique articles for each column.\n",
    "    user_item_test : pd.DataFrame\n",
    "        A user-item matrix of the testing dataframe \n",
    "        unique users for each row and unique articles for each column.    \n",
    "    test_idx : np.array\n",
    "        All of the test user ids.   \n",
    "    test_arts : np.array\n",
    "        All of the test article ids.\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    user_item_train = create_user_item_matrix(df_train)\n",
    "    \n",
    "    user_item_test = create_user_item_matrix(df_test)\n",
    "    \n",
    "    test_idx = user_item_test.index\n",
    "    \n",
    "    test_arts = user_item_test.columns.get_level_values(1)\n",
    "    \n",
    "    \n",
    "    return user_item_train, user_item_test, test_idx, test_arts\n",
    "\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": [
    "`Q4.1` How many users can we make predictions for in the test set?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can make predictions for 20 users in the test dataset.\n"
     ]
    }
   ],
   "source": [
    "answer4_1 = user_item_train.index.isin(test_idx).sum()\n",
    "\n",
    "print(f'We can make predictions for {answer4_1} users in the test dataset.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### `Q4.2` How many users are we not able to make predictions for because of the cold start problem?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We cannot make predictions for 662 users in the test dataset.\n"
     ]
    }
   ],
   "source": [
    "answer4_2 = user_item_test.index.unique().size - answer4_1\n",
    "\n",
    "print(f'We cannot make predictions for {answer4_2} users in the test dataset.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### `Q4.3` How many articles can we make predictions for in the test set?    \n",
    "*In other words, how many articles of the test dataset are contained in the train dataset?*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are able to make predictions for 574 articles.\n"
     ]
    }
   ],
   "source": [
    "answer4_3 = user_item_train.columns.get_level_values(1)\\\n",
    "                                   .isin(test_arts)\\\n",
    "                                   .sum()\n",
    "\n",
    "print(f'We are able to make predictions for {answer4_3} articles.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### `Q4.4` How many articles are we not able to make predictions for because of the cold start problem? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are NOT able to make predictions for 0 articles.\n"
     ]
    }
   ],
   "source": [
    "answer4_4 = user_item_test.columns.get_level_values(1).size - answer4_3\n",
    "\n",
    "print(f'We are NOT able to make predictions for {answer4_4} articles.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UDACITY GRADER\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Awesome job!  That's right!  All of the test movies are in the training data, but there are only 20 test users that were also in the training set.  All of the other users that are in the test set we have no data on.  Therefore, we cannot make predictions for these users using SVD.\n"
     ]
    }
   ],
   "source": [
    "a = 662 \n",
    "b = 574 \n",
    "c = 20 \n",
    "d = 0 \n",
    "\n",
    "sol_4_dict = {\n",
    "    'How many users can we make predictions for in the test set?': c,\n",
    "    'How many users in the test set are we not able to make predictions for because of the cold start problem?': a, \n",
    "    'How many articles can we make predictions for in the test set?': b,\n",
    "    'How many articles in the test set are we not able to make predictions for because of the cold start problem?': d\n",
    "}\n",
    "\n",
    "t.sol_4_test(sol_4_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`5.` Now let's use the **user_item_train** dataset from above to find U, S, and V transpose using SVD.   \n",
    "\n",
    "To find the appropriate number of latent features necessary to provide good results on the test set, we can: \n",
    "\n",
    "1 - 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. This will require combining what was done in questions `2` - `4`.\n",
    "\n",
    "**How well SVD works towards making predictions for recommendations on the test data?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit SVD on the user_item_train matrix\n",
    "u_train, s_train, vt_train = np.linalg.svd(user_item_train, full_matrices=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find common ids in train and test (ie ROWs)\n",
    "common_ids = user_item_train.index[user_item_train.index.isin(test_idx)]\n",
    "\n",
    "# get conditions to subset user_item_test matrix\n",
    "test_row_bool = user_item_test.index.isin(common_ids)\n",
    "train_row_bool = user_item_train.index.isin(common_ids)\n",
    "\n",
    "# Subset columns\n",
    "train_columns_bool = user_item_train.columns.get_level_values(1).isin(test_arts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_latent_feats = np.arange(10,700+10,20)\n",
    "\n",
    "# Absolute error scores\n",
    "sum_errs_train = []\n",
    "sum_errs_test = []\n",
    "\n",
    "# Accuracy scores\n",
    "score_train = []\n",
    "score_test = []\n",
    "\n",
    "for k in num_latent_feats:\n",
    "    \n",
    "    # restructure with k latent features\n",
    "    s_new, u_new, vt_new = np.diag(s_train[:k]), u_train[:, :k], vt_train[:k, :]\n",
    "    \n",
    "    # take dot product\n",
    "    user_item_est_train_est = np.around(np.dot(np.dot(u_new, s_new), vt_new))\n",
    "    \n",
    "    # compute error for each prediction to actual value\n",
    "    train_sub_est = user_item_est_train_est[train_row_bool][:, train_columns_bool]\n",
    "    \n",
    "    # subset matrices for common users/common articles\n",
    "    test_sub = user_item_test.to_numpy()[test_row_bool, :]\n",
    "    train_sub = user_item_train.to_numpy()[train_row_bool][:, train_columns_bool]\n",
    "    \n",
    "    diffs_train = np.subtract(train_sub, train_sub_est)\n",
    "    diff_test = np.subtract(test_sub, train_sub_est)\n",
    "    \n",
    "    # Calculate total error and store it\n",
    "    # Absolute error\n",
    "    err_train = np.sum(np.abs(diffs_train))\n",
    "    err_test = np.sum(np.abs(diff_test))\n",
    "    \n",
    "    # Accurary\n",
    "    score_train.append(accuracy_score(train_sub.flatten(), train_sub_est.flatten()))\n",
    "    score_test.append(accuracy_score(test_sub.flatten(), train_sub_est.flatten()))\n",
    "    \n",
    "    sum_errs_train.append(err_train)\n",
    "    sum_errs_test.append(err_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the impact on accuracy of the training and test sets of data with different numbers of latent features?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(\n",
    "    num_latent_feats,\n",
    "    score_train,\n",
    "    label='train'\n",
    ");\n",
    "ax.plot(\n",
    "    num_latent_feats,\n",
    "    score_test,\n",
    "    label='test'\n",
    "\n",
    ")\n",
    "\n",
    "ax.set(\n",
    "    xlabel='Number of Latent Features',\n",
    "    ylabel='Accuracy',\n",
    "    title='Accuracy vs. Number of Latent Features',\n",
    ");\n",
    "\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a class=\"anchor\" id=\"conclusion\">Part V: Conclusions, Actions and Future Directions</a>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our plot shows that we are able to get accurate predictions on the **training dataset** when we use an increasingly high number of latent features.\n",
    "\n",
    "However, when we evaluate our method with the **test dataset**, we can see that the performance decreases with an increasingly higher number of features. Because we have only 20 users and a highly imbalanced dataset (far more negative class compared to positive), we would need to **increase the number of users and article interactions in our dataset** in order to have better results.\n",
    "\n",
    "**Current issues and challenges**\n",
    "\n",
    "\n",
    "A fundamental issue with the dataset and approach used in this section (Matrix factorization and SVD) is that we do not have information about whether users like the article or not (i.e. no rating), and we also do not consider the total number of interactions (only interaction vs no interaction). \n",
    "Therefore __we have no information about whether the recommendations are useful or relevant__. \n",
    "\n",
    "**Actionable Items and Future Directions** \n",
    "\n",
    "* Start by deploying the User-User Based Collaborative Filtering for existing users and Rank-based recommendations for new users.\n",
    "* Evaluate current solutions (Rank-based and User-User Collaborative Filtering) with a A/B TEST, comparing the number of interactions for users before and after deplyoing the solution. A good recommender should lead to an increase of the number of interactions for users.\n",
    "* Ask quantitative user feedback (e.g. a rating from 1-10) in the environment where the recommender is deployed. \n",
    "* Combine new user rating information and total number of interactions in a single, ensemble system to make more reliable recommendations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To generate an html view of this notebook\n",
    "! python -m nbconvert --to html Recommendations_with_IBM.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "2021 - [Jose Oliveira da Cruz](https://github.com/joseferncruz)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}