movie_recommeder_withoutComments.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "movie-recommeder.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOlewPT8KvT+9K21DcXoWFX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vishnureddys/movie-recommender-system/blob/main/movie_recommeder_withoutComments.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i-wH2JqaI6bl"
      },
      "source": [
        "# Initial Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5A9HwPFjJv2K"
      },
      "source": [
        "#installing Apache Spark on Colab\n",
        "import os"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N3gqb5ffJ1te"
      },
      "source": [
        "#Downloading Java JDK version 8\n",
        "!apt-get install openjdk-8-jdk-headless -qq > /dev/null"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59wUXYxbL8km"
      },
      "source": [
        "#Downloading and installing Apache Spark along with Findspark\n",
        "!wget -q https://downloads.apache.org/spark/spark-2.4.7/spark-2.4.7-bin-hadoop2.7.tgz\n",
        "!tar xf spark-2.4.7-bin-hadoop2.7.tgz\n",
        "!pip install -q Findspark\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "chMlh1ccMKbE",
        "outputId": "a34a7b4b-55e7-447f-a84b-a0f64f14ced8"
      },
      "source": [
        "# Change Java Version Frim JDK-11 to JDK-8\n",
        "!update-alternatives --set java /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java\n",
        "\n",
        "# Set Environment Variables\n",
        "os.environ[\"JAVA_HOME\"] = \"/usr/lib/jvm/java-8-openjdk-amd64\"\n",
        "os.environ[\"SPARK_HOME\"] = \"/content/spark-2.4.7-bin-hadoop2.7\""
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "update-alternatives: using /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java to provide /usr/bin/java (java) in manual mode\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XnHLiBWEMZFv",
        "outputId": "3f662de5-7af0-4f88-b026-663a26cc03ec"
      },
      "source": [
        "#Now launching a spark session on colab\n",
        "\n",
        "import findspark\n",
        "findspark.init()\n",
        "\n",
        "#Start Apache Spark session and context\n",
        "import pyspark\n",
        "from pyspark.sql import SQLContext\n",
        "\n",
        "sc = pyspark.SparkContext(appName='bd_project')\n",
        "sqlContext = SQLContext(sc)\n",
        "\n",
        "print('Master : ', sc.master)\n",
        "print('Cores  : ', sc.defaultParallelism)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Master :  local[*]\n",
            "Cores  :  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dlww_U6FNSMr"
      },
      "source": [
        "# Required Later\n",
        "sqlContext.sparkSession.conf.set(\"spark.sql.autoBroadcastJoinThreshold\", -1)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3FmPEEHcNWz-",
        "outputId": "5924c18b-6a36-4ea5-c68f-2d6a380d5503"
      },
      "source": [
        "#The packages we will be needing\n",
        "!pip install koalas"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting koalas\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/0f/fa/26bfdc01856c15c9c953851659432ccc623be1b0168a76bf0e2eb8b423f4/koalas-1.4.0-py3-none-any.whl (769kB)\n",
            "\u001b[K     |████████████████████████████████| 778kB 4.9MB/s \n",
            "\u001b[?25hRequirement already satisfied: matplotlib>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from koalas) (3.2.2)\n",
            "Requirement already satisfied: pyarrow>=0.10 in /usr/local/lib/python3.6/dist-packages (from koalas) (0.14.1)\n",
            "Requirement already satisfied: pandas>=0.23.2 in /usr/local/lib/python3.6/dist-packages (from koalas) (1.1.4)\n",
            "Requirement already satisfied: numpy>=1.14 in /usr/local/lib/python3.6/dist-packages (from koalas) (1.18.5)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib>=3.0.0->koalas) (0.10.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib>=3.0.0->koalas) (1.3.1)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib>=3.0.0->koalas) (2.4.7)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib>=3.0.0->koalas) (2.8.1)\n",
            "Requirement already satisfied: six>=1.0.0 in /usr/local/lib/python3.6/dist-packages (from pyarrow>=0.10->koalas) (1.15.0)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.23.2->koalas) (2018.9)\n",
            "Installing collected packages: koalas\n",
            "Successfully installed koalas-1.4.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0NyLNu2UNfpF"
      },
      "source": [
        "# Default Packages (available by Default in Google Colab)\n",
        "import math\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.ticker as ticker\n",
        "import seaborn as sns\n",
        "import random\n",
        "from pprint import pprint\n",
        "from matplotlib.lines import Line2D\n",
        "\n",
        "# Downloaded Packages (not available by Default)\n",
        "import databricks.koalas\n",
        "\n",
        "# PySpark Utilities\n",
        "import pyspark.sql.functions as F\n",
        "from pyspark.sql.types import *\n",
        "from pyspark.ml.recommendation import ALS, ALSModel\n",
        "from pyspark.ml.evaluation import RegressionEvaluator, BinaryClassificationEvaluator\n",
        "from pyspark.ml.tuning import ParamGridBuilder, TrainValidationSplit\n",
        "from pyspark.mllib.evaluation import RegressionMetrics, RankingMetrics\n",
        "\n",
        "# Random Seed\n",
        "SEED = 1492\n",
        "\n",
        "# Set-up\n",
        "plt.style.use('seaborn')"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z58ZTba8Nnl6",
        "outputId": "58144098-0f0b-4c00-f3b0-e9a5f63c2f0f"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive');"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "twBjg55TN36P",
        "outputId": "8e9abc86-8829-4955-e721-0c7c273deb4a"
      },
      "source": [
        "!ls \"drive/My Drive/MovieRecommender\""
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Data  Results\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mbHbnw9J8njg"
      },
      "source": [
        "#Path to Data Folder\n",
        "DATA_PATH = \"drive/My Drive/MovieRecommender/Data\"\n",
        "\n",
        "#Path to Results Folder\n",
        "RESULTS_PATH = \"drive/My Drive/MovieRecommender/Results\""
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TKw0hUqS9ZKH"
      },
      "source": [
        "# Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hsofFjRr9dKm"
      },
      "source": [
        "class MovieLensDatasets(object):\n",
        "    \"\"\"\n",
        "    Class for loading and preprocesing MovieLens Dataset\n",
        "    \"\"\"\n",
        "    def __init__(self, ratings, movies, links, personalRatings, debug=True, debugLimit=10000):\n",
        "        # Load Existing Data\n",
        "        if debug:\n",
        "            debugLimit = debugLimit\n",
        "            ratings = ratings.limit(debugLimit)\n",
        "        else:\n",
        "            ratings = ratings      \n",
        "\n",
        "        self.ratings = ratings\n",
        "        self.movies = movies\n",
        "        self.links = links\n",
        "        self.personalRatings = personalRatings\n",
        "\n",
        "        # Create New DataFrame\n",
        "        users = ratings.select('userId').distinct()\n",
        "        self.users = users\n",
        "\n",
        "    def preprocessing(self):\n",
        "        # Preprocess MovieLens Ratings\n",
        "        self.ratings = self.ratings.withColumn('rating',\n",
        "        F.col('rating').cast('double')).drop('timestamp') \\\n",
        "        .withColumn('userId', F.col('userId').cast('int')) \\\n",
        "        .withColumn('movieId', F.col('movieId').cast('int'))\n",
        "\n",
        "        # Preprocess Personal IMDb Ratings To MovieLens Ratings\n",
        "        self.personalRatings = self.personalRatings.select(['Const',\n",
        "                                                'Your Rating']) \\\n",
        "        .withColumnRenamed('Const', 'imdbId') \\\n",
        "        .withColumnRenamed('Your Rating', 'personalRating')\n",
        "\n",
        "        self.personalRatings = self.personalRatings \\\n",
        "        .withColumn('personalRating', F.col('personalRating').cast('double')*0.5) \\\n",
        "        .withColumn('imdbId', F.expr(\"substr(imdbId, 3)\"))\n",
        "\n",
        "        self.personalRatings = self.personalRatings.join(\n",
        "        self.links.select('movieId', 'imdbId'), ['imdbId'], how='inner')\n",
        "\n",
        "        # Insert IMDb Ratings into MovieLens Ratings Dataset\n",
        "        self.personalRatings = self.personalRatings \\\n",
        "                    .withColumn('userId', F.lit('0'))\n",
        "        self.personalRatings = self.personalRatings \\\n",
        "                    .select(['userId', 'movieId', 'personalRating']) \\\n",
        "                    .toDF('userId', 'movieId', 'rating')\n",
        "        self.ratings = self.ratings.union(self.personalRatings)\n",
        "\n",
        "        # Binarize MovieLens Ratings (if rating >= 3.0, then 1.0, else 0.0)\n",
        "        udf_scale_ratings = F.udf(lambda x: x - 2.5, DoubleType())\n",
        "        udf_binary_ratings = F.udf(lambda x: 1.0 if x > 0.0 else 0.0, DoubleType())\n",
        "\n",
        "        self.ratings = self.ratings \\\n",
        "        .withColumn('ratingsScaled', udf_scale_ratings(F.col('rating'))) \\\n",
        "        .withColumn('ratingsBinary', udf_binary_ratings(F.col('ratingsScaled')))\n",
        "\n",
        "    def get_ratings(self):\n",
        "        return self.ratings\n",
        "\n",
        "    def get_movies(self):\n",
        "        return self.movies\n",
        "\n",
        "    # Displaying Null Values\n",
        "    def spark_df_display_null_values(sparkDf):\n",
        "        print('NaN values ?')\n",
        "        sparkDf.select([F.count(F.when(F.isnan(c), c)).alias(c) for c in sparkDf.columns]).show()\n",
        "\n",
        "        print('Null values ?')\n",
        "        sparkDf.select([F.count(F.when(F.isnull(c), c)).alias(c) for c in sparkDf.columns]).show()"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1Eq-jXqT9yca",
        "outputId": "8d3622ef-714e-416d-afb9-0bcf4fc1474e"
      },
      "source": [
        "%%time\n",
        "# Set to True if only testing\n",
        "# For testing: use debug=True option (subset of all ratings)\n",
        "debug = False\n",
        "\n",
        "# Load Datasets\n",
        "movies = sqlContext \\\n",
        "            .read.format('csv').option(\"header\", \"true\") \\\n",
        "            .load(DATA_PATH + \"/movies.csv\")\n",
        "\n",
        "links = sqlContext \\\n",
        "            .read.format('csv').option(\"header\", \"true\") \\\n",
        "            .load(DATA_PATH + \"/links.csv\")\n",
        "\n",
        "ratings = sqlContext.read \\\n",
        "            .format('csv').option(\"header\", \"true\") \\\n",
        "            .load(DATA_PATH + \"/ratings.csv\")\n",
        "\n",
        "personalRatings = sqlContext \\\n",
        "            .read.format('csv').option(\"header\", \"true\") \\\n",
        "            .load(DATA_PATH + \"/my_IMDB.csv\")\n",
        "\n",
        "\n",
        "# Data Preprocessing\n",
        "movieLensDatasets = MovieLensDatasets(ratings=ratings, movies=movies,\n",
        "                                      links=links,\n",
        "                                      personalRatings=personalRatings,\n",
        "                                      debug=debug)\n",
        "\n",
        "movieLensDatasets.preprocessing()\n",
        "dfRatings = movieLensDatasets.get_ratings() \n",
        "dfMovies = movieLensDatasets.get_movies()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 125 ms, sys: 3.38 ms, total: 128 ms\n",
            "Wall time: 2.15 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGlvmmAHC4hI"
      },
      "source": [
        "# EDA"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_8Tj1uOjC5-_"
      },
      "source": [
        "dfRatingsKdf = dfRatings.to_koalas()"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "id": "yWPBjT0HC8fV",
        "outputId": "74f09084-2d94-4bfe-ff7f-47462511e4e0"
      },
      "source": [
        "%%time\n",
        "f, ax = plt.subplots(figsize=(12,6))\n",
        "userRatingGroup = dfRatingsKdf.groupby(\"userId\")['rating'].count()\n",
        "userRatingGroup.hist(bins=100, color='blue', edgecolor='black',\n",
        "                     linewidth=1.25, alpha=0.78, ax=ax)\n",
        "ax.set_xlabel('Nb. of Ratings per User')\n",
        "ax.set_xlim(0.0)\n",
        "ax.set_xticklabels(['{:,}'.format(int(x)) for x in ax.get_xticks().tolist()])\n",
        "ax.set_yticklabels(['{:,}'.format(int(x)) for x in ax.get_yticks().tolist()])\n",
        "plt.show()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 497 ms, sys: 34.4 ms, total: 532 ms\n",
            "Wall time: 2min 2s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "id": "-CMmiIVIC-q3",
        "outputId": "41d7e4d8-e9d1-4dac-8d22-224faac2a33c"
      },
      "source": [
        "%%time\n",
        "f, ax = plt.subplots(figsize=(12,6))\n",
        "movieRatingGroup = dfRatingsKdf.groupby(\"movieId\")['rating'].count()\n",
        "movieRatingGroup.hist(bins=100, color='blue', edgecolor='black',\n",
        "                      linewidth=1.25, alpha=0.78, ax=ax)\n",
        "ax.set_xlabel('Nb. of Ratings per Movie')\n",
        "ax.set_xlim(0.0)\n",
        "ax.set_xticklabels(['{:,}'.format(int(x)) for x in ax.get_xticks().tolist()])\n",
        "ax.set_yticklabels(['{:,}'.format(int(x)) for x in ax.get_yticks().tolist()])\n",
        "plt.show()"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 428 ms, sys: 17.2 ms, total: 445 ms\n",
            "Wall time: 1min 45s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 429
        },
        "id": "b_xL0wAYD21n",
        "outputId": "e7cc90a4-392a-4fa2-bf1d-0751782f6963"
      },
      "source": [
        "%%time\n",
        "movieRatingDistGroup = dfRatingsKdf['rating'].value_counts() \\\n",
        "                                             .sort_index() \\\n",
        "                                             .reset_index() \\\n",
        "                                             .to_pandas()\n",
        "\n",
        "# Create Matplotlib Figure\n",
        "fig, ax = plt.subplots(figsize=(12,6))\n",
        "\n",
        "# Main Figure: Seaborn Barplot\n",
        "sns.barplot(data=movieRatingDistGroup, x='index', y='rating',\n",
        "            palette='RdYlGn', edgecolor=\"black\", ax=ax)\n",
        "\n",
        "# Set Xaxis and Yaxis\n",
        "ax.set_xlabel(\"User-Movie Ratings\")\n",
        "ax.set_ylabel('Nb. of Users')\n",
        "ax.xaxis.set_tick_params(rotation=45)\n",
        "\n",
        "# Thousand separator on Yaxis labels\n",
        "ax.set_yticklabels(['{:,}'.format(int(x)) for x in ax.get_yticks().tolist()])\n",
        "\n",
        "# Add percentage text on top of each bar\n",
        "total = float(movieRatingDistGroup['rating'].sum())\n",
        "for p in ax.patches:\n",
        "    height = p.get_height()\n",
        "    ax.text(p.get_x()+p.get_width()/2.,\n",
        "            height+350,\n",
        "            '{0:.0%}'.format(height/total),\n",
        "            ha=\"center\") \n",
        "\n",
        "# Display plot\n",
        "plt.show()"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 324 ms, sys: 8.2 ms, total: 332 ms\n",
            "Wall time: 43.7 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xswm1t67FZga"
      },
      "source": [
        "# Model Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QydZHBKPFc2Z"
      },
      "source": [
        "ratingsPrepare = dfRatings.withColumn(\"userId\", F.col(\"userId\").cast('int')) \\\n",
        "                          .withColumn(\"movieId\", F.col(\"movieId\").cast('int'))\n",
        "\n",
        "dfRatingsTrain, dfRatingsTest = ratingsPrepare.randomSplit([0.8, 0.2],\n",
        "                                                           seed=SEED)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Phu1W9TsFeZL"
      },
      "source": [
        "def catalog_coverage(predicted, catalog, k):\n",
        "    \"\"\"\n",
        "    Computes the catalog coverage for k lists of recommendations\n",
        "    Parameters\n",
        "    ----------\n",
        "    predicted : a list of lists\n",
        "        Ordered predictions\n",
        "        example: [['X', 'Y', 'Z'], ['X', 'Y', 'Z']]\n",
        "    catalog: list\n",
        "        A list of all unique items in the training data\n",
        "        example: ['A', 'B', 'C', 'X', 'Y', Z]\n",
        "    k: integer\n",
        "        The number of observed recommendation lists\n",
        "        which randomly choosed in our offline setup\n",
        "    Returns\n",
        "    ----------\n",
        "    catalog_coverage:\n",
        "        The catalog coverage of the recommendations as a percent\n",
        "        rounded to 2 decimal places\n",
        "    ----------    \n",
        "    Metric Defintion:\n",
        "    Ge, M., Delgado-Battenfeld, C., & Jannach, D. (2010, September).\n",
        "    Beyond accuracy: evaluating recommender systems by coverage and\n",
        "    serendipity.\n",
        "    In Proceedings of the fourth ACM conference on Recommender systems\n",
        "    (pp. 257-260). ACM.\n",
        "    \"\"\"\n",
        "    sampling = random.choices(predicted, k=k)\n",
        "    predicted_flattened = [p for sublist in sampling for p in sublist]\n",
        "    L_predictions = len(set(predicted_flattened))\n",
        "    catalog_coverage = L_predictions/(len(catalog)*1.0)\n",
        "    return catalog_coverage\n",
        "\n",
        "\n",
        "def get_rec_sys_results(relevantDocumentsDf, dfMovies):\n",
        "    \"\"\"\n",
        "    Returns dictionnary of recommender system metrics\n",
        "    Since Spark ML DataFrame-based doesn't have a\n",
        "    specific function for evaluating the soundness\n",
        "    of item recommendations, we will have to use\n",
        "    Spark MLlib RDD-based API\n",
        "    \"\"\"\n",
        "    # Transform Spark Dataframe into Spark RDD\n",
        "    relevantDocuments = relevantDocumentsDf.rdd \\\n",
        "        .map(lambda row: (row.predictions, row.groundTruth))\n",
        "    \n",
        "    # Get Catalog Coverage\n",
        "    moviesCatalog = dfMovies.select(\"movieId\") \\\n",
        "                            .orderBy(\"movieId\") \\\n",
        "                            .distinct() \\\n",
        "                            .toPandas()\n",
        "    predictions = relevantDocumentsDf.select(\"predictions\").toPandas()\n",
        "    predictionsList = predictions.values.tolist()\n",
        "    predictionsList = [sublist[0] for sublist in predictionsList]\n",
        "    cc = catalog_coverage(predicted=predictionsList,\n",
        "                          catalog=moviesCatalog, k=100)\n",
        "\n",
        "    # Get Results\n",
        "    metrics = RankingMetrics(relevantDocuments)\n",
        "    pk20 = metrics.precisionAt(20)\n",
        "    ndcg20 = metrics.ndcgAt(20)\n",
        "    \n",
        "    results = dict(Pk20=pk20, NDCGk20=ndcg20, CC=cc)\n",
        "    \n",
        "    return results\n",
        "\n",
        "\n",
        "def format_recommendations(rowPreds):\n",
        "    # From recommendations column extract only items\n",
        "    # recommended and ignore ratings\n",
        "    rowPredsList = [row.movieId for row in rowPreds]\n",
        "    return rowPredsList\n",
        "\n",
        "udf_format_recommendations = F.udf(lambda x: format_recommendations(x),\n",
        "                                   ArrayType(IntegerType()))"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lnOWRbmCFlwt"
      },
      "source": [
        "class PopularityRecommenderModel(object):\n",
        "    \"\"\"\n",
        "    Class for generating movie item recommendations based on movie popularity\n",
        "    (from average ratings with logarithmic scaling factor that penalizes movies\n",
        "    with few ratings). By default, only the top 10 rated movies are selected.\n",
        "\n",
        "    Approach studied during MS Big Data's SD 701 Big Data Mining Course.\n",
        "    \"\"\"\n",
        "    def __init__(self, ratingsTrain, ratingsTest):\n",
        "        self.ratingsTrain = ratingsTrain\n",
        "        self.ratingsTest = ratingsTest\n",
        "\n",
        "    def generate_recommendations_for_all_users(self, topk=10):\n",
        "        # Get list of top k rated movies\n",
        "        topRated = self._get_top_k_best_movies(topk=topk)\n",
        "\n",
        "        # Compare most popular movies with user's personal preferences\n",
        "        # Important: only keep recommendations with rating over 3/5\n",
        "        results = self.ratingsTest \\\n",
        "                 .filter(F.col(\"ratingsBinary\")==1.0) \\\n",
        "                 .withColumn('movieId', F.col('movieId').cast('int')) \\\n",
        "                 .orderBy('rating', ascending=False) \\\n",
        "                 .groupby(\"userId\") \\\n",
        "                 .agg(F.collect_list(\"movieId\").alias('groundTruth')) \\\n",
        "                 .withColumn('predictions', F.array([F.lit(el)\n",
        "                        for el in topRated])) \\\n",
        "                 .select(['userId', 'predictions', 'groundTruth'])\n",
        "\n",
        "        return results\n",
        "\n",
        "    def _get_top_k_best_movies(self, topk):\n",
        "\n",
        "        # Function\n",
        "        def _get_mean_rating_w_log_penalty(arr):\n",
        "            sumRatings, nbRatings = arr[0], arr[1]\n",
        "            grade = (sumRatings / nbRatings) * math.log(nbRatings)\n",
        "            return grade\n",
        "\n",
        "        # UDF\n",
        "        udf_mean_rating_w_log_penalty = F.udf(\n",
        "            lambda arr: _get_mean_rating_w_log_penalty(arr),\n",
        "            DoubleType()\n",
        "        )\n",
        "\n",
        "        # Get top k Best Rated Movies\n",
        "        ranking = self.ratingsTrain.groupBy('movieId') \\\n",
        "              .agg({'rating': 'sum', 'userId': 'count'}) \\\n",
        "              .toDF('movieId', 'sumRating', 'nbRatings')\n",
        "\n",
        "        ranking = ranking \\\n",
        "        .withColumn(\"meanLogUserRating\",\n",
        "         udf_mean_rating_w_log_penalty(F.array(\"sumRating\", \"nbRatings\"))\n",
        "         ) \\\n",
        "        .sort(['meanLogUserRating', 'nbRatings'], ascending=[False, True]) \\\n",
        "        .limit(topk)\n",
        "\n",
        "        self.topRatedMovies = ranking\n",
        "        ratingsTop = [int(row.movieId) for row in ranking.collect()]\n",
        "\n",
        "        return ratingsTop"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n9pYy2DoF1ky",
        "outputId": "2ead7184-b110-4948-f0c3-45ab58544b94"
      },
      "source": [
        "%%time\n",
        "pbrModel = PopularityRecommenderModel(dfRatingsTrain, dfRatingsTest)\n",
        "resultsPop = pbrModel.generate_recommendations_for_all_users(topk=20)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 85 ms, sys: 23.9 ms, total: 109 ms\n",
            "Wall time: 2min 16s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EOfcKCh-GdNt",
        "outputId": "5c23141f-5e34-408f-ad16-21a2ea09aee2"
      },
      "source": [
        "%%time\n",
        "resultsPop.limit(5).orderBy('userId').show(5)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "+------+--------------------+--------------------+\n",
            "|userId|         predictions|         groundTruth|\n",
            "+------+--------------------+--------------------+\n",
            "|   148|[318, 296, 858, 5...|[1209, 2959, 293,...|\n",
            "|   463|[318, 296, 858, 5...|      [32, 785, 762]|\n",
            "|   471|[318, 296, 858, 5...|[60069, 68954, 95...|\n",
            "|   496|[318, 296, 858, 5...|[199, 1247, 71579...|\n",
            "|   833|[318, 296, 858, 5...|[260, 68954, 1, 2...|\n",
            "+------+--------------------+--------------------+\n",
            "\n",
            "CPU times: user 108 ms, sys: 17.5 ms, total: 125 ms\n",
            "Wall time: 6min 15s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AuoE1_VUHgCO",
        "outputId": "29a8c87b-7fdb-4f97-867b-3abe1fca821f"
      },
      "source": [
        "%%time\n",
        "results = get_rec_sys_results(resultsPop, dfMovies)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 2.22 s, sys: 150 ms, total: 2.37 s\n",
            "Wall time: 12min 57s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xN7VGb8sJIWL",
        "outputId": "c9869021-3f5a-4ba0-9aed-982b628bf6ca"
      },
      "source": [
        "pprint(results)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'CC': 0.00032039472630280506,\n",
            " 'NDCGk20': 0.09535904901542727,\n",
            " 'Pk20': 0.06771431044717054}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pZHIlEnqMP-K",
        "outputId": "a9d5bb77-4b33-4a0d-cb2d-5a501e679238"
      },
      "source": [
        "%%time\n",
        "_ = pbrModel.generate_recommendations_for_all_users(topk=20)\n",
        "pbrModel.topRatedMovies \\\n",
        "    .join(dfMovies.select(['movieId', 'title']), 'movieId') \\\n",
        "    .orderBy('meanLogUserRating', ascending=False) \\\n",
        "    .show(20, truncate=False)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "+-------+---------+---------+------------------+------------------------------------------------------------------------------+\n",
            "|movieId|sumRating|nbRatings|meanLogUserRating |title                                                                         |\n",
            "+-------+---------+---------+------------------+------------------------------------------------------------------------------+\n",
            "|318    |288098.5 |65251    |48.9472805946674  |Shawshank Redemption, The (1994)                                              |\n",
            "|296    |266833.0 |63666    |46.35988020423733 |Pulp Fiction (1994)                                                           |\n",
            "|858    |182023.5 |42077    |46.05962647076001 |Godfather, The (1972)                                                         |\n",
            "|50     |189592.5 |44245    |45.83942418693688 |Usual Suspects, The (1995)                                                    |\n",
            "|527    |205136.5 |48311    |45.7966548667675  |Schindler's List (1993)                                                       |\n",
            "|593    |246565.0 |59374    |45.6453454135832  |Silence of the Lambs, The (1991)                                              |\n",
            "|2571   |241797.5 |58218    |45.56992763924904 |Matrix, The (1999)                                                            |\n",
            "|2959   |198858.5 |47013    |45.50561388997872 |Fight Club (1999)                                                             |\n",
            "|260    |226279.5 |54912    |44.971926409367185|Star Wars: Episode IV - A New Hope (1977)                                     |\n",
            "|356    |263817.5 |65140    |44.8914760998126  |Forrest Gump (1994)                                                           |\n",
            "|1196   |190280.0 |45912    |44.488525807276936|Star Wars: Episode V - The Empire Strikes Back (1980)                         |\n",
            "|1198   |179996.0 |43627    |44.07763396393697 |Raiders of the Lost Ark (Indiana Jones and the Raiders of the Lost Ark) (1981)|\n",
            "|2858   |176664.0 |42998    |43.8348788018898  |American Beauty (1999)                                                        |\n",
            "|4993   |182495.0 |44627    |43.78086552645706 |Lord of the Rings: The Fellowship of the Ring, The (2001)                     |\n",
            "|1221   |116665.0 |27368    |43.553838042987806|Godfather: Part II, The (1974)                                                |\n",
            "|608    |157518.0 |38329    |43.37287685968001 |Fargo (1996)                                                                  |\n",
            "|58559  |138408.5 |33223    |43.372680770588154|Dark Knight, The (2008)                                                       |\n",
            "|7153   |166169.5 |40667    |43.36650166378857 |Lord of the Rings: The Return of the King, The (2003)                         |\n",
            "|1193   |121581.5 |28831    |43.30566151630536 |One Flew Over the Cuckoo's Nest (1975)                                        |\n",
            "|47     |165762.5 |40638    |43.28824531670545 |Seven (a.k.a. Se7en) (1995)                                                   |\n",
            "+-------+---------+---------+------------------+------------------------------------------------------------------------------+\n",
            "\n",
            "CPU times: user 155 ms, sys: 45 ms, total: 200 ms\n",
            "Wall time: 4min 29s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfGWvzYJNfya"
      },
      "source": [
        "# Model-Based Collaborative Filtering"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4YGYQpGzNm8v"
      },
      "source": [
        "Model Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1nMxOb0PNq3p",
        "outputId": "33b9be71-c4a5-4f9b-91da-9142adbeb9f4"
      },
      "source": [
        "%%time\n",
        "tempALS = ALS(maxIter=10, rank=10, regParam=0.1, nonnegative=True,\n",
        "              userCol='userId', itemCol='movieId', ratingCol='rating',\n",
        "              coldStartStrategy='drop', implicitPrefs=False, seed=SEED)\n",
        "\n",
        "mlALSFitted = tempALS.fit(dfRatingsTrain)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 133 ms, sys: 37.9 ms, total: 171 ms\n",
            "Wall time: 5min 12s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cjqsMjw0Ntga"
      },
      "source": [
        "mlALSFitted.save(RESULTS_PATH+\"/ALS_MovieLens_25M\")"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1nzbswrZO_tQ"
      },
      "source": [
        "\n",
        "mlALSFitted = ALSModel.load(RESULTS_PATH+\"/ALS_MovieLens_25M\")"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKvvUnnuPIkC"
      },
      "source": [
        "RSME on Test set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zP8vwi9QPKzF",
        "outputId": "4d3457b0-9fbd-4e18-ace7-b939f3fc9e2c"
      },
      "source": [
        "%%time\n",
        "predictions = mlALSFitted.transform(dfRatingsTest)\n",
        "evaluator = RegressionEvaluator(metricName='rmse', labelCol='rating',\n",
        "                                predictionCol='prediction')\n",
        "rmse = evaluator.evaluate(predictions)\n",
        "print('RMSE (Test Set):', rmse)"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "RMSE (Test Set): 0.8147418252855383\n",
            "CPU times: user 87.5 ms, sys: 29 ms, total: 116 ms\n",
            "Wall time: 2min 40s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1tXV0wcqP8bo"
      },
      "source": [
        "Evaluating Recommedations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SyVd9FEfP-Qp"
      },
      "source": [
        "resultsALS = mlALSFitted.recommendForAllUsers(20)\n",
        "\n",
        "resultsALS = resultsALS.withColumn('recommendations',\n",
        "              udf_format_recommendations(F.col(\"recommendations\"))) \\\n",
        "              .toDF('userId', 'predictions')"
      ],
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2oOUgzoOP_le"
      },
      "source": [
        "resultsALSExpanded = resultsALS \\\n",
        "                        .withColumn(\"movieId\", F.explode(\"predictions\")) \\\n",
        "                        .drop('predictions') \\\n",
        "                        .join(dfMovies, \"movieId\")\n",
        "\n",
        "resultsALSKdf = resultsALSExpanded.to_koalas()\n",
        "\n",
        "MostRecommendedMoviesForAllUsers = resultsALSKdf.groupby([\"movieId\", \"title\"])['userId'].count()\n",
        "MostRecommendedMoviesForAllUsers = MostRecommendedMoviesForAllUsers.sort_values(ascending=False)"
      ],
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1Bw0ElJFQDpS",
        "outputId": "947c57df-274c-4807-e928-ae94e835930a"
      },
      "source": [
        "%%time\n",
        "MostRecommendedMoviesForAllUsers.head(20)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 8.77 ms, sys: 1.42 ms, total: 10.2 ms\n",
            "Wall time: 41.9 ms\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "movieId  title                                             \n",
              "151989   The Thorn (1971)                                      158503\n",
              "194434   Adrenaline (1990)                                     152557\n",
              "203086   Truth and Justice (2019)                              146142\n",
              "203882   Dead in the Water (2006)                              143944\n",
              "183947   NOFX Backstage Passport 2                             137260\n",
              "202231   Foster (2018)                                         122000\n",
              "192261   Don't Laugh at My Romance (2008)                      110486\n",
              "192089   National Theatre Live: One Man, Two Guvnors (2011)    101177\n",
              "196787   The Law and the Fist (1964)                            94660\n",
              "197355   Once Upon a Ladder (2016)                              76203\n",
              "165559   Ο Θανάσης στη χώρα της σφαλιάρας (1976)                71018\n",
              "194332   Muchas gracias de nada (1980)                          69834\n",
              "157789   .hack Liminality In the Case of Yuki Aihara            58732\n",
              "157787   .hack Liminality: In the Case of Mai Minase            58626\n",
              "166812   Seeing Red: Stories of American Communists (1983)      58107\n",
              "165689   Head Trauma (2006)                                     57988\n",
              "205277   Inside Out (1991)                                      56622\n",
              "187949   Furious Love (2010)                                    51055\n",
              "187947   Finger of God (2007)                                   50971\n",
              "194883   The Go-Betweens: Right Here (2017)                     48672\n",
              "Name: userId, dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IunfLFp6QGt3"
      },
      "source": [
        "resultsALS = resultsALS \\\n",
        "                 .join(\n",
        "                 dfRatingsTest \\\n",
        "                 .filter(F.col(\"ratingsBinary\")==1.0) \\\n",
        "                 .withColumn('movieId', F.col('movieId').cast('int')) \\\n",
        "                 .groupby(\"userId\") \\\n",
        "                 .agg(F.collect_list(\"movieId\").alias(\"groundTruth\")),\n",
        "                     'userId'\n",
        "                 )\n",
        "\n",
        "# resultsALS.orderBy('userId').limit(10).show(10)"
      ],
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MqYTx8p2S0ee",
        "outputId": "41e708dd-0c41-4a49-f38c-12d20dbf238b"
      },
      "source": [
        "%%time\n",
        "resultsALSMetrics = get_rec_sys_results(resultsALS, dfMovies)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 2.31 s, sys: 259 ms, total: 2.57 s\n",
            "Wall time: 27min 18s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkSs-Dq5S3-V",
        "outputId": "60ac7a29-a96b-49ef-e308-403217ca1f17"
      },
      "source": [
        "pprint(resultsALSMetrics)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'CC': 0.0036364801435368375,\n",
            " 'NDCGk20': 3.6917610374570712e-06,\n",
            " 'Pk20': 3.4007716660071253e-06}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3OAKAWQCZvWo"
      },
      "source": [
        "# Results"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8S4eIv8sZxt-"
      },
      "source": [
        "results = {'CC': 0.00032039472630280506,\n",
        " 'NDCGk20': 0.09535904901542727,\n",
        " 'Pk20': 0.06771431044717054}"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cRN9DJUeZ7aV"
      },
      "source": [
        "results['RMSE'] = 'N/A'\n",
        "resultsALSMetrics['RMSE'] = rmse"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "B0ddDnCFZ-f7",
        "outputId": "c5e5f0ee-e0ea-4b42-f57b-cebb43286670"
      },
      "source": [
        "modelResults = pd.DataFrame([results, resultsALSMetrics],\n",
        "                             index=['PopRec', 'CF-ALS'])\n",
        "\n",
        "modelResults.transpose()"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "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>PopRec</th>\n",
              "      <th>CF-ALS</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>CC</th>\n",
              "      <td>0.000320395</td>\n",
              "      <td>0.00363648</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>NDCGk20</th>\n",
              "      <td>0.095359</td>\n",
              "      <td>3.69176e-06</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Pk20</th>\n",
              "      <td>0.0677143</td>\n",
              "      <td>3.40077e-06</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>RMSE</th>\n",
              "      <td>N/A</td>\n",
              "      <td>0.814742</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "              PopRec       CF-ALS\n",
              "CC       0.000320395   0.00363648\n",
              "NDCGk20     0.095359  3.69176e-06\n",
              "Pk20       0.0677143  3.40077e-06\n",
              "RMSE             N/A     0.814742"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9iLSYYpCaDu3"
      },
      "source": [
        "Testing with my values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gsDS_aVYaFW-",
        "outputId": "ac1ba508-7a76-4f35-c36f-2a9bc5e8acfd"
      },
      "source": [
        "%%time\n",
        "dfRatingsTrain.filter(F.col(\"userId\")==0).count()"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 34.1 ms, sys: 9.53 ms, total: 43.6 ms\n",
            "Wall time: 2min 12s\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "57"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1y5eDs83aHsF",
        "outputId": "046a25c8-20ab-48c9-ee8d-088fd89bef94"
      },
      "source": [
        "%%time\n",
        "predictionsPerso = resultsALS.filter(F.col(\"userId\")==0) \\\n",
        "                             .select(F.explode(\"predictions\") \\\n",
        "                             .alias(\"movieId\")) \\\n",
        "                             .join(dfMovies.select([\"movieId\", \"title\"]),\n",
        "                                   \"movieId\") \\\n",
        "                             .join(dfRatings.filter(F.col(\"userId\")==0),\n",
        "                                   ['movieId'], how='left')\n",
        "\n",
        "predictionsPerso.select([\"title\", \"rating\"]).show(10, truncate=False)"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "+-------------------------------------+------+\n",
            "|title                                |rating|\n",
            "+-------------------------------------+------+\n",
            "|Foster (2018)                        |null  |\n",
            "|The Thorn (1971)                     |null  |\n",
            "|Hoaxed (2019)                        |null  |\n",
            "|My Best Enemy (2006)                 |null  |\n",
            "|The Challengers (1990)               |null  |\n",
            "|Fracchia la belva umana (1981)       |null  |\n",
            "|La leggenda di Al, John e Jack (2002)|null  |\n",
            "|Heroes Above All (2017)              |null  |\n",
            "|Of Two Minds (2012)                  |null  |\n",
            "|King for a Day (1983)                |null  |\n",
            "+-------------------------------------+------+\n",
            "only showing top 10 rows\n",
            "\n",
            "CPU times: user 149 ms, sys: 42.2 ms, total: 191 ms\n",
            "Wall time: 12min 52s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6dCSEx_Ja2TL"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}