Movie_Recommender_Using_NMF.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/glynismattheisen/anaconda3/lib/python3.6/site-packages/fuzzywuzzy/fuzz.py:11: UserWarning: Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning\n",
      "  warnings.warn('Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.decomposition import NMF\n",
    "import random\n",
    "from random import randint\n",
    "from matplotlib import pyplot as plt\n",
    "from fuzzywuzzy import process\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing ratings and movies csv files\n",
    "PATH_ratings = \"ratings.csv\"\n",
    "PATH_movies = \"movies.csv\"\n",
    "ratings, movies_ind = pd.read_csv(PATH_ratings), pd.read_csv(PATH_movies)\n",
    "\n",
    "del ratings['timestamp'] #format ratings dataframe\n",
    "ratings.set_index(['userId','movieId'], inplace=True)\n",
    "ratings = ratings.unstack(0)\n",
    "\n",
    "ratings_count = ratings.count(axis=1) # count the number of ratings for each movie as a measure of popularity\n",
    "top = pd.DataFrame(ratings_count.sort_values(ascending = False).head(10)) # create a dataframe of the top 10 most popular movies\n",
    "top.reset_index(inplace=True)\n",
    "movies_ind.set_index('movieId',inplace=True)\n",
    "top_movies = movies_ind.loc[top['movieId']]['title'].values # get movie titles from Id\n",
    "movies_ind.reset_index(inplace=True)\n",
    "top_movies_index = movies_ind.index[top['movieId']].values\n",
    "\n",
    "ratings = ratings.fillna(0) # fill unknowns with 0 rating\n",
    "ratings = ratings[\"rating\"]\n",
    "ratings = ratings.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_input(top_movies, top_movies_index):\n",
    "    print(\"Of the following movies, rate all that you have seen on a scale of 1-5.\")\n",
    "    print(\"If you have not seen a movie, rate 0.\")\n",
    "    \n",
    "    #creates a list of ratings for the prompted movies\n",
    "    user_input = []\n",
    "    for i in range(0,10):\n",
    "        answer = int(input(\"How would you rate \" + str(top_movies[i])))\n",
    "        if answer > 5:\n",
    "            answer = 5\n",
    "        elif answer < 0:\n",
    "            answer = 0\n",
    "        user_input.append(answer)\n",
    "        \n",
    "    user_ratings = np.zeros(9724) # create an empty array the length of number of movies in system\n",
    "    # inputs user rating into large array (9,000+ count) at appropriate indexes\n",
    "    for i in range(0,10):\n",
    "        user_ratings[top_movies_index[i]] = user_input[i]\n",
    "    return user_ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Of the following movies, rate all that you have seen on a scale of 1-5.\n",
      "If you have not seen a movie, rate 0.\n",
      "How would you rate Forrest Gump (1994)2\n",
      "How would you rate Shawshank Redemption, The (1994)2\n",
      "How would you rate Pulp Fiction (1994)23\n",
      "How would you rate Silence of the Lambs, The (1991)2\n",
      "How would you rate Matrix, The (1999)3\n",
      "How would you rate Star Wars: Episode IV - A New Hope (1977)2\n",
      "How would you rate Jurassic Park (1993)3\n",
      "How would you rate Braveheart (1995)2\n",
      "How would you rate Terminator 2: Judgment Day (1991)2\n",
      "How would you rate Schindler's List (1993)2\n"
     ]
    }
   ],
   "source": [
    "user_ratings = get_input(top_movies, top_movies_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_ratings_NMF(ratings, movies_ind, n_components):\n",
    "    R = pd.DataFrame(ratings) # model assumes R ~ PQ'\n",
    "    model = NMF(n_components=n_components, init='random', random_state=10)\n",
    "    model.fit(R)\n",
    "\n",
    "    P = model.components_  # Movie feature\n",
    "    Q = model.transform(R)  # User features\n",
    "\n",
    "    query = user_ratings.reshape(1,-1)\n",
    "\n",
    "    t=model.transform(query)\n",
    "    \n",
    "    # prediction movie ratings of input user\n",
    "    outcome = np.dot(t,P)\n",
    "    outcome=pd.DataFrame(outcome)\n",
    "    outcome = outcome.transpose()\n",
    "    outcome['movieId'] = movies_ind['movieId']\n",
    "    outcome = outcome.rename(columns={0:'rating'})\n",
    "    top = outcome.sort_values(by='rating',ascending=False).head(150) # top 100 ratings from predictions list\n",
    "    \n",
    "    return top"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "top = model_ratings_NMF(ratings, movies_ind, n_components =5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# collects titles of the top movie predictions\n",
    "top_movie_recs = movies_ind.loc[top['movieId']]['title'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing genres\n",
    "PATHG = \"movie_genres_years.csv\"\n",
    "movie_genres = pd.read_csv(PATHG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "genres = movie_genres.columns.values[3:22] # creates list of genres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary with keys equal to genre\n",
    "b,c = {}, {}\n",
    "for x in genres:\n",
    "    key = x\n",
    "    value = ''\n",
    "    b[key],c[key] = value, value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fills keys with list of movies that belong to respective genre\n",
    "for x in genres:\n",
    "    li = []\n",
    "    for id in top['movieId']:\n",
    "        if id in list(movie_genres.loc[movie_genres[x] == 1]['movieId']):\n",
    "            li.append(movies_ind[movies_ind['movieId']==id]['title'].values)\n",
    "    c[x] = li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fills keys with random choice in the list of films within a genre\n",
    "for x in genres:\n",
    "    if len(c[x])>0:\n",
    "        b[x] = c[x][randint(0, len(c[x])-1)][0]\n",
    "    else:\n",
    "        b[x] = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add an option for not choosing a genre\n",
    "genres_for_q = np.append(genres, 'none')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What genre of film would you like to watch?comedy\n"
     ]
    }
   ],
   "source": [
    "genre_answer = process.extractOne(input(\"What genre of film would you like to watch?\"),genres_for_q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We recommend Ace Ventura: Pet Detective (1994)\n"
     ]
    }
   ],
   "source": [
    "#picks a top movie of the selected genre\n",
    "for x in genres:\n",
    "    if genre_answer[0] == x:\n",
    "        if len(b[x]) == 0:\n",
    "            print('No ' +x+ ' recommedations')\n",
    "        else:\n",
    "            print('We recommend ' + b[x])\n",
    "            \n",
    "# if they don't want a specific genre\n",
    "if genre_answer[0] == 'none':\n",
    "        Select = top_movie_recs[randint(0, 4)]\n",
    "        print('We recommend ' + Select)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}