MovieRecommendationSystem.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vw0M02Amf_0L"
      },
      "outputs": [],
      "source": [
        "# importing useful libraries\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import csv\n",
        "import ast\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "import nltk\n",
        "from nltk.stem.porter import PorterStemmer\n",
        "from sklearn.metrics.pairwise import cosine_similarity\n",
        "import pickle"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reading the datasets\n",
        "movies=pd.read_csv('/content/tmdb_5000_movies.csv')\n",
        "credits=pd.read_csv('/content/tmdb_5000_credits.csv')"
      ],
      "metadata": {
        "id": "exdQ61NPlOTL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# need to merge the datasets on a common column \n",
        "\n",
        "movies=movies.merge(credits, on ='title')"
      ],
      "metadata": {
        "id": "hq2fI7peqkmn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#movie_id\n",
        "#title\n",
        "#overview\n",
        "#genres\n",
        "#keywrods\n",
        "#cast\n",
        "#crew\n",
        "# the above list of columns are only useful information to recommend the movies\n",
        "movies=movies[['movie_id','title','overview','genres','keywords','cast','crew']]"
      ],
      "metadata": {
        "id": "9yTmWcvWrYv0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# remove missing data\n",
        "movies.isnull().sum\n",
        "movies.dropna(inplace=True)\n",
        "\n",
        "# check for duplicates\n",
        "movies.duplicated().sum()"
      ],
      "metadata": {
        "id": "MAFYjYwxsi6y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "95a37d4f-a628-4923-bb9b-3417c5269066"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# helper functions to convert genres,cast and crew into required format\n",
        "\n",
        "def convert(obj):\n",
        "    list=[]\n",
        "    obj=ast.literal_eval(obj)\n",
        "    for i in obj:\n",
        "        list.append(i['name'])\n",
        "    return list\n",
        "\n",
        "def fetch_cast(obj):\n",
        "    list=[]\n",
        "    counter=0\n",
        "    obj=ast.literal_eval(obj)\n",
        "    for i in obj:\n",
        "        if counter!=3:\n",
        "            list.append(i['name'])\n",
        "            counter+=1\n",
        "        else:\n",
        "            break\n",
        "    return list\n",
        "\n",
        "def fetch_crew(obj):\n",
        "    list=[]\n",
        "    obj=ast.literal_eval(obj)\n",
        "    for i in obj:\n",
        "        if i['job'] == 'Director':\n",
        "            list.append(i['name'])\n",
        "            break\n",
        "    return list\n"
      ],
      "metadata": {
        "id": "BdC4gkRJuF0y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# converting the columns overview, genres, cast and crew into desirable format using helper functions\n",
        "movies['overview']=movies['overview'].apply(lambda x:x.split())\n",
        "movies['genres']=movies['genres'].apply(convert)\n",
        "movies['keywords']=movies['keywords'].apply(convert)\n",
        "movies['cast']=movies['cast'].apply(fetch_cast)\n",
        "movies['crew']=movies['crew'].apply(fetch_crew)\n"
      ],
      "metadata": {
        "id": "mbSHdlabv39H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# removing spaces between the words to consider it as a single word because Sam Worthing is different from Sam Anderson so removing spaces between them.\n",
        "movies['genres']= movies['genres'].apply(lambda x:[i.replace(\" \",\"\") for i in x])\n",
        "movies['keywords']= movies['keywords'].apply(lambda x:[i.replace(\" \",\"\") for i in x])\n",
        "movies['cast']= movies['cast'].apply(lambda x:[i.replace(\" \",\"\") for i in x])\n",
        "movies['crew']= movies['crew'].apply(lambda x:[i.replace(\" \",\"\") for i in x])"
      ],
      "metadata": {
        "id": "HqcXVdh10oLe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#concatenate all the necessary columns into a new column tags\n",
        "\n",
        "movies['tags']= movies['overview'] + movies['genres'] + movies['keywords']+ movies['cast'] + movies['crew']\n",
        "\n",
        "#create a new dataframe with only necessary columns \n",
        "movies = movies[['movie_id','title', 'tags']]\n",
        "\n",
        "# converting list items string (into a paragraph)\n",
        "movies['tags'] = movies['tags'].apply(lambda x:\" \".join(x))\n",
        "\n",
        "#convert the tags into lower case\n",
        "movies['tags'] = movies['tags'].apply(lambda x:x.lower())\n",
        "\n"
      ],
      "metadata": {
        "id": "ztIwQZsi1ghB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#need to perform stemming on the tags so that words like action, actions doesn't get repeated as diffferent words. \n",
        "\n",
        "ps = PorterStemmer()\n",
        "\n",
        "#helper function for stemming\n",
        "def stem(text):\n",
        "    y = []\n",
        "    for i in text.split():\n",
        "        y.append(ps.stem(i))\n",
        "    return \" \".join(y)\n",
        "\n",
        "movies['tags'] = movies['tags'].apply(stem)"
      ],
      "metadata": {
        "id": "RTEsa8ZKyTTe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#movies.head()\n",
        "#movies['tags'][0]\n",
        "#need t convert each movie into vectors through vectorization\n",
        "#using bag of words method choosing most frequent 5000 words from the concatenation of all tags. \n",
        "cv = CountVectorizer(max_features=5000,stop_words='english')\n",
        "\n",
        "#converting the sparse matrix into a numpy array\n",
        "vectors = cv.fit_transform(movies['tags']).toarray()\n",
        "#"
      ],
      "metadata": {
        "id": "t-4l2ZXcxWjm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# we need to find the cosine distances between each pair of vectors we have created. \n",
        "#So that lesser the distance more the similarity is. Also we can find similarity directly.\n",
        "\n",
        "similarity = cosine_similarity(vectors)\n",
        "\n",
        "#converting similarities of each movie into a list of tuples having index and similairty of specific movie as elements of tuples\n",
        "sorted(list(enumerate(similarity[0])),reverse = True,key=lambda x:x[1])[1:6]"
      ],
      "metadata": {
        "id": "NIWc_khsyCOg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def recommend(movie):\n",
        "    #fetching index of movies\n",
        "    \n",
        "    movie_index = movies[movies['title'] == movie].index[0]\n",
        "\n",
        "    #converting similarities of each movie into a list of tuples having index and similairty of specific movie as elements of tuples\n",
        "    movies_list = sorted(list(enumerate(similarity[movie_index])),reverse = True,key=lambda x:x[1])[1:10]\n",
        "\n",
        "    for i in movies_list:\n",
        "        print(movies.iloc[i[0]].title)\n",
        "\n",
        "def recommend_movies(movie_list):\n",
        "\n",
        "    total = movie_list\n",
        "    for i in range(3):\n",
        "        movie_index = movies[movies['title'] == movie_list[i]].index[0]\n",
        "        movies_list = sorted(list(enumerate(similarity[movie_index])),reverse = True,key=lambda x:x[1])[1:10]\n",
        "        movie_name=[]\n",
        "        counter=0\n",
        "        for j in movies_list:\n",
        "            movie_name = movies.iloc[j[0]].title\n",
        "            if movie_name in total:\n",
        "                continue\n",
        "            else:\n",
        "                counter+=1\n",
        "                print(movie_name)\n",
        "                total+=[movie_name]\n",
        "                if i==0:\n",
        "                    if counter==3:\n",
        "                        break\n",
        "                if i>0:\n",
        "                    if counter==1:\n",
        "                        break\n",
        "\n",
        "            \n",
        "\n",
        "\n",
        "\n",
        "        \n"
      ],
      "metadata": {
        "id": "uZCG6KpL7B2O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#recommend('Spider-Man 2')\n",
        "recommend_movies(['Spider-Man','Spider-Man 3','Spider-Man 2'])"
      ],
      "metadata": {
        "id": "eaPDasLz9w4q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pickle.dump(movies.to_dict(),open('movies_dict.pkl','wb'))"
      ],
      "metadata": {
        "id": "R9QZKgDQSyOr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pickle.dump(similarity,open('similarity.pkl','wb'))"
      ],
      "metadata": {
        "id": "PMBqWhp7bwOg"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}