ContentBasedRecom_v1a.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "17983c8f",
   "metadata": {},
   "source": [
    "# Content-Based Recommender\n",
    "We calculate the similarity of the movie content using cosine similarity and recommend the movie with similar content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bd672797",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from ast import literal_eval\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.metrics.pairwise import linear_kernel\n",
    "\n",
    "class ContentBasedRecommender:\n",
    "    \n",
    "    def __init__(self, database):\n",
    "        \n",
    "        path_database = database\n",
    "        self.df = pd.read_csv(path_database, low_memory=True)\n",
    "        #print(\"keys:\", self.df.keys())\n",
    "    \n",
    "    def convert_int(self, x):\n",
    "        \"\"\"Function to convert NaN to 0 and all other years to integers\"\"\"\n",
    "        try:\n",
    "            return int(x)\n",
    "        except:\n",
    "            return 0\n",
    "        \n",
    "    def get_release_year(self, df):\n",
    "        \n",
    "        \"\"\"Function to ruled-out some movie by precondition\n",
    "\n",
    "        Args:\n",
    "            df(object): the dataframe(pandas), which is the dataset\n",
    "        Return:\n",
    "            df(object): the dataframe(pandas) with the new collum 'year'\n",
    "\n",
    "        \"\"\"\n",
    "        \n",
    "        #Convert release_date into pandas datetime format\n",
    "        df['release_date'] = pd.to_datetime(df['release_date'], errors='coerce')\n",
    "\n",
    "        #Extract year from the datetime\n",
    "        df['year'] = df['release_date'].apply(lambda x: str(x).split('-')[0] if x != np.nan else np.nan)\n",
    "        \n",
    "        #Apply convert_int to the year feature\n",
    "        df['year'] = df['year'].apply(self.convert_int)\n",
    "\n",
    "        return df\n",
    "    \n",
    "    def get_genre(self, df):\n",
    "        \n",
    "        \"\"\"Function to ruled-out some movie by precondition\n",
    "\n",
    "        Args:\n",
    "            df(object): the dataframe(pandas), which is the dataset\n",
    "        Return:\n",
    "            df(object): the dataframe(pandas) with the new collum 'genre' \n",
    "\n",
    "        \"\"\"\n",
    "        #Convert all NaN into stringified empty lists\n",
    "        df['genres'] = df['genres'].fillna('[]')\n",
    "\n",
    "        #Apply literal_eval to convert stringified empty lists to the list object\n",
    "        df['genres'] = df['genres'].apply(literal_eval)\n",
    "\n",
    "        #Convert list of dictionaries to a list of strings\n",
    "        df['genres'] = df['genres'].apply(lambda x: [i['name'].lower() for i in x] if isinstance(x, list) else [])\n",
    "        \n",
    "        #Create a new feature by exploding genres\n",
    "        s = df.apply(lambda x: pd.Series(x['genres']),axis=1).stack().reset_index(level=1, drop=True)\n",
    "\n",
    "        #Name the new feature as 'genre'\n",
    "        s.name = 'genre'\n",
    "\n",
    "        #Create a new dataframe gen_df which by dropping the old 'genres' feature and adding the new 'genre'.\n",
    "        df = df.join(s)\n",
    "        \n",
    "        return df\n",
    "    \n",
    "    def precondition(self, df, quantile_num=0.80, runtime=[45,300]):\n",
    "        \n",
    "        \"\"\"Function to ruled-out some movie by precondition\n",
    "\n",
    "        Args:\n",
    "            df(object): the dataframe(pandas), which is the dataset\n",
    "            quantile_num(float): the number to indicate the 80th percentile\n",
    "            runtime(array): rumtime movies longer than array[0] minutes and shorter than array[1] minutes\n",
    "            \n",
    "        Return:\n",
    "            df_q_movies(object): the movies that made the cut\n",
    "            \n",
    "        \"\"\"\n",
    "        \n",
    "        #m (int): the minimum number of votes requred for the movie to be in the chart\n",
    "        self.m = df['vote_count'].quantile(quantile_num)\n",
    "        #C (float): the mean rating of all the movies in the dataset\n",
    "        self.C = df['vote_average'].mean()\n",
    "        \n",
    "        #Only consider some movies with runtime conditions \n",
    "        df_q_movies = df[(df['runtime'] >= runtime[0]) & (df['runtime'] <= runtime[1])]\n",
    "\n",
    "        #Only consider movies that have garnered more than m votes\n",
    "        df_q_movies = df_q_movies[df_q_movies['vote_count'] >= self.m]\n",
    "        \n",
    "        return df_q_movies\n",
    "    \n",
    "    def weighted_rating(self, df):\n",
    "        \n",
    "        \"\"\"Function to compute the IMDB weighted rating for each movie\n",
    "\n",
    "        Args:\n",
    "            df(object): the dataframe(pandas), which is the dataset\n",
    "        \n",
    "        Return:\n",
    "            weight_score(float): the weighted score\n",
    "            \n",
    "        \"\"\"\n",
    "        v = df['vote_count']\n",
    "        R = df['vote_average']\n",
    "        weight_score = (v/(v+self.m) * R) + (self.m/(self.m+v) * self.C)\n",
    "\n",
    "        return weight_score\n",
    "    \n",
    "    def get_preferrence(self):\n",
    "        \n",
    "        \"\"\"Function take useer input to set the user-preferrence \"\"\"\n",
    "            \n",
    "        #Ask for preferred genres\n",
    "        print(\"Input preferred genre\")\n",
    "        self.genre = input()\n",
    "\n",
    "        #Ask for lower limit of duration\n",
    "        print(\"Input shortest duration(mins)\")\n",
    "        self.low_time = int(input())\n",
    "\n",
    "        #Ask for upper limit of duration\n",
    "        print(\"Input longest duration(mins)\")\n",
    "        self.high_time = int(input())\n",
    "\n",
    "        #Ask for lower limit of timeline\n",
    "        print(\"Input earliest year\")\n",
    "        self.low_year = int(input())\n",
    "\n",
    "        #Ask for upper limit of timeline\n",
    "        print(\"Input latest year\")\n",
    "        self.high_year = int(input())\n",
    "    \n",
    "    def cal_tfidf(self, df, stop_words_list=['english']):\n",
    "        \n",
    "        \"\"\"Function to creat the Term Frequency-Inverse Document Frequency (TF-IDF) matrix\n",
    "\n",
    "        Args:\n",
    "            df(object): the dataframe(pandas), which is the dataset that contain 'overview' documents of movies\n",
    "            stop_words(list): the words that extremly commom in the 'overview' documents of movies\n",
    "        \n",
    "        Return:\n",
    "            tfidf_matrix (tensor): the word vecterized-matrix\n",
    "        \"\"\"\n",
    "        \n",
    "        #Define a TF-IDF Vectorizer Object. Remove all english stopwords\n",
    "        tfidf = TfidfVectorizer(stop_words=stop_words_list)\n",
    "\n",
    "        #Replace NaN with an empty string\n",
    "        df['overview'] = df['overview'].fillna('')\n",
    "\n",
    "        #Construct the required TF-IDF matrix by applying the fit_transform method on the overview feature\n",
    "        tfidf_matrix = tfidf.fit_transform(df['overview'])\n",
    "        \n",
    "        return tfidf_matrix\n",
    "        \n",
    "    def get_cosine_sim(self, tfidf_matrix):\n",
    "        \n",
    "        \"\"\"Function to compute the cosine similarity matrix \n",
    "\n",
    "        Args:\n",
    "            tfidf_matrix (tensor): the word vecterized-matrix\n",
    "        \n",
    "        Return:\n",
    "            cosine similarity matrix(tensor)\n",
    "        \"\"\"\n",
    "        \n",
    "        # Compute the cosine similarity matrix\n",
    "        cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)\n",
    "\n",
    "        return cosine_sim\n",
    "    \n",
    "    def get_indices(self, df):\n",
    "        \n",
    "        \"\"\"Function to construct a reverse mapping of indices and movie titles, \n",
    "        and drop duplicate titles(if any)\"\"\"\n",
    "        \n",
    "        indices = pd.Series(df.index, index=df['title']).drop_duplicates()\n",
    "        \n",
    "        return indices\n",
    "        \n",
    "    def main(self, title_input, see_top =25):\n",
    "        \n",
    "        \"\"\"Function to takes in movie title as input and gives recommendations\n",
    "        \n",
    "        Args:\n",
    "            title_input (string): the movie name\n",
    "        \n",
    "        Return:\n",
    "            recommendation (object):\n",
    "        \"\"\"\n",
    "    \n",
    "        # Obtain the index of the movie that matches the title\n",
    "        indices = self.get_indices(self.df)\n",
    "        idx = indices[title_input]\n",
    "\n",
    "        # Get the pairwsie similarity scores of all movies with that movie\n",
    "        # And convert it into a list of tuples \n",
    "        tfidf_matrix = self.cal_tfidf(self.df)\n",
    "        cosine_sim = self.get_cosine_sim(tfidf_matrix)\n",
    "        sim_scores = list(enumerate(cosine_sim[idx]))\n",
    "\n",
    "        # Sort the movies based on the cosine similarity scores\n",
    "        sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)\n",
    "\n",
    "        # Get the scores of the 'see_top' most similar movies. Ignore the first movie(itself).\n",
    "        sim_scores = sim_scores[1:see_top+1]\n",
    "\n",
    "        # Get the movie indices\n",
    "        movie_indices = [i[0] for i in sim_scores]\n",
    "\n",
    "        # Return the top 10 most similar movies\n",
    "        \n",
    "        return self.df['title'].iloc[movie_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8d35df59",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\MMIL\\AppData\\Local\\Temp\\ipykernel_11540\\1419909415.py:12: DtypeWarning: Columns (10) have mixed types. Specify dtype option on import or set low_memory=False.\n",
      "  self.df = pd.read_csv(path_database, low_memory=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "34682    How the Lion Cub and the Turtle Sang a Song\n",
       "9115                  The Lion King 2: Simba's Pride\n",
       "7658                                The Razor's Edge\n",
       "9353                                The Lion King 1½\n",
       "27933              Massaï, les guerriers de la pluie\n",
       "13079                                     Crows Zero\n",
       "31208                                     White Lion\n",
       "14797                                Extreme Justice\n",
       "28909                            House of Mortal Sin\n",
       "11244     The Criminal Life of Archibaldo de la Cruz\n",
       "Name: title, dtype: object"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#set the CSV File into df\n",
    "database = r'C:\\Users\\MMIL\\Panithan\\Git_projects\\movies_metadata.csv'\n",
    "\n",
    "recommender= ContentBasedRecommender(database)\n",
    "recommender.main(title_input='The Lion King', see_top =10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "97ba0ee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26558    Avengers: Age of Ultron\n",
       "2782               The Dark Half\n",
       "12588                   Iron Man\n",
       "20047             The Guilt Trip\n",
       "386                Jason's Lyric\n",
       "20830                 Iron Man 3\n",
       "1833          All the King's Men\n",
       "43540          The Kinematograph\n",
       "1203               Touch of Evil\n",
       "19854             Excuse My Dust\n",
       "Name: title, dtype: object"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recommender.main(title_input='Iron Man 2', see_top =10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e4bde5d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}