Graph_e2e.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "class Graph(object):\n",
    "    def __init__(self, reads):\n",
    "        \"\"\"\n",
    "\n",
    "        \"\"\"\n",
    "        # Edges in our graph\n",
    "        self.reads = reads\n",
    "\n",
    "\n",
    "    def _find_a_user(self, input_User, debug=False):\n",
    "        \"\"\"\n",
    "        Find a user in the graph N hops from an author in the\n",
    "        user's list of read authors:\n",
    "        \"\"\"\n",
    "        _author_list = input_User.author_list\n",
    "        if debug:\n",
    "            print (\"Method: _find_N_user : `_author_list`: \", _author_list)\n",
    "        # Do we have any authors in the list?\n",
    "        _n_authors = len(_author_list)\n",
    "        if _n_authors > 0:\n",
    "            # Pick an Author. Any Author.\n",
    "            _reader_list = None\n",
    "            while _reader_list == None:\n",
    "                _next_author = _author_list[np.random.randint(_n_authors)] #Inclusive, random integer\n",
    "                if debug:\n",
    "                    print (\"Method: _find_N_user : `_next_author` : \", _next_author)\n",
    "                if len(_next_author.reader_list) > 1: # Is there anyone in this bucket?\n",
    "                    _reader_list = _next_author.reader_list # Who reads this Author?\n",
    "\n",
    "            _next_User = None\n",
    "            while _next_User == None:\n",
    "                _choice = _reader_list[np.random.randint(len(_reader_list))]\n",
    "                if _choice != input_User:\n",
    "                    _next_User = _choice # Make sure we do not pick ourselves\n",
    "            if debug:\n",
    "                print (\"Method: _find_N_user : `_next_User`: \", _next_User)\n",
    "            return _next_User # We finally made a choice!\n",
    "        else:\n",
    "            return None\n",
    "\n",
    "    def _book2book(self, input_Book, N=3 , debug=False):\n",
    "        \"\"\" Sanity Checker:\n",
    "        Developer Function to quickly get similar, unpopular books\n",
    "        recommended that is not based on a User. Simply input a book,\n",
    "        go up the Author tree, and then find a random user, and their\n",
    "        unpopular book.\n",
    "\n",
    "        This is quicker, in theory, for testing out the predictions, as you\n",
    "        don't have to build a User + Read objects for the Graph.\n",
    "        \"\"\"\n",
    "        def _sort_tuple(tuple_val):\n",
    "            \"\"\" For sorting our unread list based on popularity\n",
    "                [(book1,popularity1),...,(bookn,popularityn)]\n",
    "            \"\"\"\n",
    "            return tuple_val[1]\n",
    "\n",
    "        out_recs = []\n",
    "        for i in range(N):\n",
    "            _reader_list = input_Book.reader_list\n",
    "            _len_rl = len(_reader_list)\n",
    "            _rand_User = _reader_list[np.random.randint(_len_rl)]\n",
    "            _list = [(book, book.popularity, rating) for book, rating in _rand_User.shelf\n",
    "                    if rating > 4] #NB; No filtering on read books, as no input user.\n",
    "            _list = sorted(_list, key=_sort_tuple, reverse=False)\n",
    "            unpopular_book, popularity, rating = _list[0]\n",
    "            out_recs.append(unpopular_book)\n",
    "\n",
    "        return out_recs\n",
    "\n",
    "    def _find_a_book(self, input_User, two_hop=False, debug=False):\n",
    "        \"\"\"\n",
    "        Given a user, recommend an unpopular book:\n",
    "        1) Take an input_user, go to an Author node, grab another user that has\n",
    "            read that author.\n",
    "        2) Grab that User's book list and compare it to the input user.\n",
    "        \"\"\"\n",
    "        def _sort_tuple(tuple_val):\n",
    "            \"\"\" For sorting our unread list based on popularity\n",
    "                [(book1,popularity1),...,(bookn,popularityn)]\n",
    "            \"\"\"\n",
    "            return tuple_val[1]\n",
    "\n",
    "        if debug:\n",
    "            print (\"Method: _find_a_book : `input_User`: \", input_User)\n",
    "\n",
    "        _next_User = self._find_a_user(input_User, debug=debug)\n",
    "\n",
    "        if two_hop:\n",
    "            try:\n",
    "                _two_hop = self._find_a_user(_next_User, debug)\n",
    "                _next_User = _two_hop if _two_hop != input_User else _next_User\n",
    "            except Exception as e:\n",
    "                if debug:\n",
    "                    print (\"Method: _find_a_book : Exception at `two_hop`: \", input_User, e)\n",
    "\n",
    "        if debug:\n",
    "            print (\"Method: _find_a_book : `_next_User`: \", _next_User)\n",
    "\n",
    "        counter= 0\n",
    "        while counter < 100:\n",
    "            counter+=1\n",
    "\n",
    "            \"\"\"\n",
    "            First, let's see how many books this user has read that\n",
    "            the input_User has not AND is rated above 4 stars.\n",
    "            NB: We could also add a maximum popularity here, just in case!\n",
    "            This will form our set from which we can find unpopular books:\n",
    "            \"\"\"\n",
    "            try:\n",
    "                _unread_list = [(book, book.popularity, rating) for book, rating in _next_User.shelf\n",
    "                                if book not in [_books for _books, _rating in input_User.shelf] and rating > 4]\n",
    "                _n_unread = len(_unread_list)\n",
    "                if debug:\n",
    "                    print (\"Method: _find_a_book : Length of the unread shelf: \", _n_unread)\n",
    "            except Exception as e:\n",
    "                print (\"Method: _find_a_book : `_unread_list` threw an exception: \", _next_User, e)\n",
    "\n",
    "            \"\"\"\n",
    "            Now, we take our unsorted, unread list of books, and sort them\n",
    "            in ascending order. The first entry should be our best bet!\n",
    "            \"\"\"\n",
    "            try:\n",
    "                _unread_list = sorted(_unread_list, key=_sort_tuple, reverse=False)\n",
    "\n",
    "                if debug:\n",
    "                    if _n_unread > 1:\n",
    "                        print (\"Method: _find_a_book : Most unpopular book title, popularity, and rating \",\n",
    "                               _unread_list[0][0].book_id, _unread_list[0][1])\n",
    "                        print (\"Method: _find_a_book : Most popular book title and popularity \",\n",
    "                               _unread_list[_n_unread-1][0].book_id, _unread_list[_n_unread-1][1])\n",
    "                    else:\n",
    "                        print (\"Method: _find_a_book : Most unpopular book title and popularity \",\n",
    "                               _unread_list[0][0].book_id, _unread_list[0][1])\n",
    "            except Exception as e:\n",
    "                if debug:\n",
    "                    print (\"Method: _find_a_book : `_unread_list` sorting threw an exception: \", e)\n",
    "\n",
    "            # So we may have found a good, rare book. Return it!\n",
    "            unpopular_book, popularity, rating = _unread_list[0]\n",
    "            if unpopular_book != None:\n",
    "                return unpopular_book\n",
    "        # Base case: We did not find any good books.\n",
    "        return None\n",
    "\n",
    "    def GrabNBooks(self, input_User, N=3, debug=False):\n",
    "        \"\"\"\n",
    "        Our main class to find three unpopular books. Relies on two helper classes:\n",
    "            _find_a_book: Grabs a rare books from a neighbor that reads similar books to you\n",
    "            _find_a_user: Finds the neighbor to a book from your collection!\n",
    "\n",
    "        If you enable two_hop = True in your calls, it can help preserve the privacy of your users,\n",
    "            as you really start to jump around the graph. Want more privacy? Enable more random jumps.\n",
    "        \"\"\"\n",
    "        if debug:\n",
    "            print (\"Method: GrabThreeBooks : Beginning :\", input_User.user_id)\n",
    "\n",
    "        RareBooks = []\n",
    "        counter = 0\n",
    "        while counter < 100:\n",
    "            \"\"\"\n",
    "            try:\n",
    "                _book = self._find_a_book(input_User, debug)\n",
    "\n",
    "                if _book != None:\n",
    "                    RareBooks.append(_book)\n",
    "            except Exception as e:\n",
    "                if debug:\n",
    "                    print (\"Method: GrabThreeBooks : Exception = \", e)\n",
    "            \"\"\"\n",
    "            _book = self._find_a_book(input_User, debug=debug)\n",
    "            RareBooks.append(_book)\n",
    "            if len(RareBooks) == N:\n",
    "                return RareBooks\n",
    "            # Increase the counter so that we don't get stuck in a loop\n",
    "            else:\n",
    "                counter+=1\n",
    "        #Base case in case something goes wrong...\n",
    "        return None\n",
    "\n",
    "\n",
    "class User(object):\n",
    "    def __init__(self,user_id):\n",
    "        self.user_id = user_id\n",
    "        self.shelf = [] # Books read\n",
    "        self.author_list = [] # Authors read\n",
    "\n",
    "class Book(object):\n",
    "    def __init__(self, book_id, Author, ratings_5, popularity, image_url):\n",
    "        self.book_id = book_id\n",
    "        self.author = Author\n",
    "        self.author_id = Author.author_id\n",
    "        self.ratings_5 = ratings_5 # Number of people that rated the book a 5\n",
    "        self.popularity = popularity # What fraction of ratings does this book have?+\n",
    "        self.image_url = image_url\n",
    "        self.reader_list = [] #Users that read the book\n",
    "\n",
    "    def add_reader(self,User):\n",
    "        if User not in self.reader_list:\n",
    "            self.reader_list.append(User) # User read this book\n",
    "\n",
    "class Author(object):\n",
    "    def __init__(self, author_id):\n",
    "            self.author_id = author_id\n",
    "            self.reader_list = [] #People who read the book\n",
    "\n",
    "    def add_reader(self,User):\n",
    "        if User not in self.reader_list:\n",
    "            self.reader_list.append(User) # User read this book\n",
    "\n",
    "\n",
    "class Read(object):\n",
    "    def __init__(self, User, Book, Author, rating=None):\n",
    "        \"\"\"\n",
    "        The edge connecting User, Book, and Author nodes\n",
    "        \"\"\"\n",
    "        if Book not in User.shelf:\n",
    "            User.shelf.append((Book, rating)) # User read this book and rated it.\n",
    "        if Author not in User.author_list:\n",
    "            User.author_list.append(Author)\n",
    "\n",
    "        self.user = User\n",
    "        self.book = Book\n",
    "        self.author = Author\n",
    "        self.rating = rating # Optional\n",
    "\n",
    "        Book.add_reader(User)\n",
    "        Author.add_reader(User)\n",
    "\n",
    "\n",
    "def BuildGraph():\n",
    "    \"\"\"\n",
    "    Now we use real data:\n",
    "    `uir` : user,item,rating data\n",
    "    `books`: meta information about each of the items (# of ratings, Author, etc.)\n",
    "    \"\"\"\n",
    "    uir = pd.read_csv(\"data/goodbooks-10k-master/ratings.csv\")\n",
    "\n",
    "    books = pd.read_csv(\"data/goodbooks-10k-master/books.csv\")\n",
    "    books = books[(books[\"language_code\"] == \"eng\") | (books[\"language_code\"] == \"en-US\")]\n",
    "    books[\"author_id\"] = (books[\"authors\"].astype(\"category\")).cat.codes # Gives us an index\n",
    "\n",
    "    \"\"\"\n",
    "    Let's build a few versions of popularity: overall ratings, text review counts, and\n",
    "    fraction of all people that rated this book with 5-stars.\n",
    "    \"\"\"\n",
    "    books[\"popularity_ratings\"] = books[\"ratings_count\"]/np.sum(books[\"ratings_count\"])\n",
    "    books[\"popularity_text_reviews\"] = books[\"work_text_reviews_count\"]/np.sum(books[\"work_text_reviews_count\"])\n",
    "    books[\"popularity_ratings5\" ]= books[\"ratings_5\"]/np.sum(books[\"ratings_5\"])\n",
    "\n",
    "    \"\"\"\n",
    "    Join these two dataframes together:\n",
    "    1) This filters out non-English books\n",
    "    2) Gives us book info as well as the Author\n",
    "    \"\"\"\n",
    "    uir = pd.merge(uir, books[[\"book_id\", \"author_id\",\"popularity_ratings\",\"ratings_5\", \"small_image_url\"]], on=[\"book_id\"])\n",
    "\n",
    "    \"\"\"\n",
    "    Let's build a catelog of Author objects first,\n",
    "    as they do not depend on any other objects in our graph.\n",
    "    \"\"\"\n",
    "    unique_authors = uir[[\"author_id\"]].drop_duplicates()\n",
    "    unique_authors[\"Author\"] = [Author(aid) for aid in unique_authors[\"author_id\"]]\n",
    "    unique_authors = unique_authors.set_index(\"author_id\", drop=True)\n",
    "\n",
    "    \"\"\"\n",
    "    Now we can do the same for the users:\n",
    "\n",
    "    \"\"\"\n",
    "    unique_users = uir[[\"user_id\"]].drop_duplicates()\n",
    "    unique_users[\"User\"] = [User(uid) for uid in unique_users[\"user_id\"]]\n",
    "    unique_users = unique_users.set_index(\"user_id\", drop=True)\n",
    "\n",
    "    \"\"\"\n",
    "    We can build a set of dictionaries for easy reference later\n",
    "    \"\"\"\n",
    "    user_dict = unique_users.to_dict(\"index\")\n",
    "    author_dict =  unique_authors.to_dict(\"index\")\n",
    "\n",
    "    \"\"\"\n",
    "    There are a number of ways we could proceed now, depending on our\n",
    "    space and speed constraints. If we had memory limitations, we could\n",
    "    save our unique_users and unique_authors dataframes as Dictionaries,\n",
    "    then just call them whenever needed. I think for our relatively small\n",
    "    dataset, we could just join them to our original dataframe:\n",
    "\n",
    "      `uir = pd.merge(uir, unique_users, on=[\"user_id\"])`\n",
    "      `uir = pd.merge(uir, unique_authors, on=[\"author_id\"])`\n",
    "\n",
    "    and then process the Books inline with a list comprehension:\n",
    "\n",
    "      `uir[\"Book\"] = [Book(bid, aid, rat, pop , url) for bid, aid, rat, pop , url\n",
    "                 in uir[[\"book_id\",\"Author\",\"ratings_5\",\"popularity_ratings\",\"small_image_url\"]].values]`\n",
    "\n",
    "    But I don't want to be too lazy here, so we will use the dictionary route:\n",
    "    \"\"\"\n",
    "    unique_books = uir[[\"book_id\", \"author_id\", \"ratings_5\", \"popularity_ratings\", \"small_image_url\"]].drop_duplicates()\n",
    "    unique_books[\"Book\"] = [Book(bid, author_dict[aid][\"Author\"], rat, pop , url) for bid, aid, rat, pop , url\n",
    "                 in unique_books[[\"book_id\",\"author_id\",\"ratings_5\",\"popularity_ratings\",\"small_image_url\"]].values]\n",
    "\n",
    "    #Now that we have our Book objects, let's build it into a dictionary\n",
    "    unique_books = unique_books.set_index(\"book_id\", drop=True)\n",
    "    unique_books = unique_books.drop([\"author_id\", \"ratings_5\", \"popularity_ratings\", \"small_image_url\"], axis=1)#Drop everything\n",
    "    book_dict =  unique_books.to_dict(\"index\")\n",
    "\n",
    "    \"\"\"\n",
    "    We can finally build our graph by assembling\n",
    "    our collection of Read() objects and passing the\n",
    "    list to our Graph: `Read(user, book1, author1) : `\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    read_list = [Read(user_dict[u][\"User\"], book_dict[b][\"Book\"], author_dict[a][\"Author\"], rating=int(r))\n",
    "               for u, b, a, r in uir[[\"user_id\",\"book_id\",\"author_id\", \"rating\"]].values]\n",
    "\n",
    "    BigGraph = Graph(read_list)\n",
    "\n",
    "    return BigGraph\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = BuildGraph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}