100-Million-Ratings-with-Spark-on-a-Mac-M1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cf9a05cf-eab4-41c4-b309-8ca7301a2056",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# 100 Million Ratings with Spark on a Mac M1\n",
    "\n",
    "<br>\n",
    "\n",
    "Is it feasable to train a model on 100 million rows using nothing more than a common laptop? Let's find out. \n",
    "\n",
    "I've been refreshing Spark lately and wanted to give it a try on a dataset I wouldn't be able to deal with using non-big data tools such as Pandas and Numpy. I came across the dataset and the Netflix challenge it originates from some time ago, but have never really had any reason to work on it. Until now.\n",
    "\n",
    "\n",
    "The dataset can be downloaded through [this](https://www.kaggle.com/netflix-inc/netflix-prize-data) link.\n",
    "\n",
    "[Conclusions](#conclusions) can be found at the end.\n",
    "\n",
    "\n",
    "\n",
    "<br><br>\n",
    "\n",
    "\n",
    "<a name=\"top\"></a>\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "## Index\n",
    "\n",
    "\n",
    "- [Prepare, Merge and Convert the Data to Parquet Format](#prepare_merge_convert)\n",
    "    - [Prepare the Data](#prepare)\n",
    "    - [Merge and Convert to Parquet Format](#convert_parquet)\n",
    "- [Initial Exploratory Data Analysis](#initial_eda)\n",
    "- [Feature Engineering](#FE)\n",
    "- [Data Visualisation](#data_vis)\n",
    "- [Machine Learning modelling](#ml-modelling)\n",
    "    - [Get Baseline Results with Linear Regression](#baseline)\n",
    "    - [Tune and Evaluate Multiple Regressors](#regressors)\n",
    "- [Train the Best GBTRegressor on the Full Dataset](#best_model)\n",
    "- [Which Features are most Important?](#feature_importance)\n",
    "- [Conclusions](#conclusions)\n",
    "\n",
    "\n",
    "<br><br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c22b6692-355c-4abc-8b34-6bc251fbb9de",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import pandas as pd\n",
    "\n",
    "from pyspark import SparkContext, SparkConf\n",
    "from pyspark.sql import SparkSession, Window\n",
    "from pyspark.sql.types import IntegerType, DoubleType\n",
    "from pyspark.sql.functions import date_format, datediff, to_date, udf, count, countDistinct\n",
    "from pyspark.sql.functions import round as spark_round\n",
    "from pyspark.ml.feature import FeatureHasher, StringIndexer, VectorAssembler\n",
    "from pyspark.ml.regression import LinearRegression, DecisionTreeRegressor\n",
    "from pyspark.ml.regression import RandomForestRegressor, GBTRegressor\n",
    "from pyspark.ml.evaluation import RegressionEvaluator\n",
    "from pyspark.ml.tuning import TrainValidationSplit, ParamGridBuilder\n",
    "from pyspark.ml import Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18e65caa",
   "metadata": {},
   "source": [
    "<a name=\"prepare_merge_convert\"></a>\n",
    "\n",
    "\n",
    "## [Prepare, Merge and Convert the Data to Parquet Format](#top)\n",
    "\n",
    "The steps in this notebook assumes that the data has already been prepared and converted to a format more suitable for larger datasets. In case you haven't done that already, below scripts allows you to do that. \n",
    "\n",
    "\n",
    "<a name=\"prepare\"></a>\n",
    "\n",
    "\n",
    "### [Prepare the Data](#top)\n",
    "\n",
    "The data comes ill-suited for analysis and needs to be prepared before taking any further steps. Run the cell below to create a file called `prepare_data.py` before executing the script `!python3 prepare_data.py`. Note that the script may take some time. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b94b5145",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing prepare_data.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile prepare_data.py\n",
    "import os\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    # Get file names\n",
    "    d = \"netflix-dataset\"\n",
    "    original_files = [f for f in os.listdir(d) if \"combined_data\" in f]\n",
    "\n",
    "    # Loop over the original files and clean them up\n",
    "    for filename in original_files:\n",
    "        new_lines = []\n",
    "        print(f\"Working on file {filename}...\")\n",
    "\n",
    "        # Open the file filename, identify the movieID and add it to corresponding rows\n",
    "        with open(f\"netflix-dataset/{filename}\") as data:\n",
    "            for line in data:\n",
    "                if \":\\n\" in line:\n",
    "                    movieID = line.strip(\":\\n\")\n",
    "                else:\n",
    "                    new_line = movieID+\",\"+line\n",
    "                    new_line = new_line.strip(\"\\n\").split(\",\")\n",
    "                    new_lines.append(new_line)\n",
    "\n",
    "            # Save to new file\n",
    "            df = pd.DataFrame(new_lines)\n",
    "            new_filename = \"cleaned_\" + filename.replace(\"txt\", \"csv\")\n",
    "            df.to_csv(f'cleaned-dataset/{new_filename}', header=False, index=False)\n",
    "\n",
    "            print(\"Done!\")\n",
    "            print(f\"Stored to {new_filename}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24bbc029",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment to run the clean_data.py script\n",
    "#!python3 prepare_data.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae96280",
   "metadata": {},
   "source": [
    "<a name=\"convert_parquet\"></a>\n",
    "\n",
    "### [Merge and Convert to Parquet Format](#top)\n",
    "\n",
    "Movie release year is not integrated in the main data files. In order to integrate it we have to load and merge it with the `movie_titles.csv` file. Then we convert it to Parquet format. Run the cell below to create the `convert_parquet.py` file before executing the following script. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "09fd4dbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing convert_parquet.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile convert_parquet.py\n",
    "from pyspark import SparkContext, SparkConf\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.types import StructType, StructField, IntegerType, DateType, StringType, FloatType\n",
    "import os\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    # Input and output data paths\n",
    "    data_csv = \"cleaned-dataset-csv/cleaned_*.csv\"\n",
    "    movie_titles_path = \"netflix-dataset/movie_titles.csv\"\n",
    "    output_data_parquet = \"data-parquet\"\n",
    "\n",
    "\n",
    "    skip = False\n",
    "\n",
    "    # If parquet file already exist, don't convert it. \n",
    "    if os.path.exists(output_data_parquet):\n",
    "        skip = True\n",
    "\n",
    "\n",
    "    if not skip:\n",
    "        # Initiate SparkContext if currently not running\n",
    "        try:\n",
    "            sc = SparkContext(appName=\"CSV to Parquet\")\n",
    "            spark = SparkSession.builder.master(\"local\").getOrCreate()\n",
    "        except: \n",
    "            pass\n",
    "\n",
    "\n",
    "    # Specify name and data type for each column and DataFrame\n",
    "    schema_data = StructType([\n",
    "        StructField(\"MovieID\", IntegerType(), True),\n",
    "        StructField(\"CustomerID\", IntegerType(), True),\n",
    "        StructField(\"Rating\", FloatType(), True),\n",
    "        StructField(\"RatingDate\", DateType(), True)])\n",
    "    schema_movies = StructType([\n",
    "        StructField(\"MovieID\", IntegerType(), True),\n",
    "        StructField(\"YearOfRelease\", IntegerType(), True)])\n",
    "\n",
    "\n",
    "    # Load the datasets with the specified schemas\n",
    "    if not skip:\n",
    "        df = spark.read.csv(\"cleaned-dataset-csv/cleaned_*.csv\", \n",
    "                            header=False, \n",
    "                            schema=schema_data)\n",
    "        movie_titles = spark.read.csv(movie_titles_path, \n",
    "                                      schema=schema_movies)\n",
    "\n",
    "\n",
    "    # Specify alias for the DataFrames to facilitate a join\n",
    "    df = df.alias(\"df\")\n",
    "    movie_titles = movie_titles.alias(\"movie_titles\")\n",
    "\n",
    "    # Join the two DataFrames on MovieID. Select only columns of interest\n",
    "    df = df.join(movie_titles,\n",
    "                 df.MovieID == movie_titles.MovieID,\n",
    "                 \"left\").select(\"df.*\", \"movie_titles.YearOfRelease\")\n",
    "    \n",
    "    # Shuffle the data\n",
    "    df = df.orderBy(rand())\n",
    "\n",
    "    # Write to Parquet\n",
    "    if not skip:\n",
    "        df.write.parquet(output_data_parquet)\n",
    "    \n",
    "    # Stop SparkContext\n",
    "    sc.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "927d3779",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment cell to run the convert_parquet.py script\n",
    "#!python3 convert_parquet.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "545a5387-0933-4208-b326-8aa4cad06eb4",
   "metadata": {},
   "source": [
    "<br><br><br><br>\n",
    "\n",
    "\n",
    "\n",
    "<a name=\"initial_eda\"></a>\n",
    "\n",
    "\n",
    "## [Initial Exploratory Data Analysis](#top)\n",
    "\n",
    "Now when the data has gone through some initial preparation and convertion we can take a closer look at it. Start by initiating a SparkContext and SparkSession. To deal with potential memory issues during later model training on the full dataset, the following settings in the `spark-default.conf` file will help mitigate those. \n",
    "\n",
    "\n",
    "```conf\n",
    "spark.executor.JavaOptions -XX:+UseG1GC\n",
    "spark.executor.extraJavaOptions -XX:ConcGCThreads=20 -XX:InitiatingHeapOcuupancyPercent=35\n",
    "spark.driver.memory 15g\n",
    "spark.sql.autoBroadcastJoinThreshold -1\n",
    "spark.storage.memoryFraction 0.75\n",
    "```\n",
    "\n",
    "<a name=\"data_path\"></a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "83cc7bf5-2795-4cee-af18-c52fbba569ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify data path\n",
    "data_path = \"data-parquet/part-0*.parquet\"\n",
    "\n",
    "# Initiate SparkContext and SparkSession\n",
    "try:\n",
    "    conf = SparkConf().setMaster(\"local[*]\")\n",
    "    sc = SparkContext.getOrCreate(conf)\n",
    "    spark = SparkSession.builder.master(\"local\").getOrCreate()\n",
    "    spark.sparkContext.setLogLevel(\"ERROR\")\n",
    "except:\n",
    "    print(\"SparkContext already running?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "96463d86-1151-442e-9a48-44b905322b7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|\n",
      "+-------+----------+------+----------+-------------+\n",
      "|  11607|   2018894|   5.0|2005-05-31|         2005|\n",
      "|  14590|   1427512|   5.0|2000-04-29|         1995|\n",
      "|    330|   2510262|   3.0|2003-03-23|         1998|\n",
      "|  14574|    782212|   3.0|2005-09-02|         1998|\n",
      "|  14858|    121218|   3.0|2005-05-22|         1995|\n",
      "+-------+----------+------+----------+-------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Load and display the first five rows of the data\n",
    "df = spark.read.parquet(data_path)\n",
    "df.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dffcdbc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 9:====================================================>      (8 + 1) / 9]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------------+\n",
      "|count(DISTINCT CustomerID)|\n",
      "+--------------------------+\n",
      "|                    480189|\n",
      "+--------------------------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Get the unique number of customers\n",
    "df.select(countDistinct('CustomerID')).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "96876356",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 15:======>                                                   (1 + 8) / 9]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------------+\n",
      "|count(DISTINCT MovieID)|\n",
      "+-----------------------+\n",
      "|                  17770|\n",
      "+-----------------------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Get the unique number of movies\n",
    "df.select(countDistinct('MovieID')).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7f2a8e62-3f75-4e45-86ba-2610c5944efb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- MovieID: integer (nullable = true)\n",
      " |-- CustomerID: integer (nullable = true)\n",
      " |-- Rating: float (nullable = true)\n",
      " |-- RatingDate: date (nullable = true)\n",
      " |-- YearOfRelease: integer (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Verify that the data types are as expected\n",
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "8b66b813-f810-42e5-a0f5-a4314fbcb3e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 2:====================================================>     (9 + 1) / 10]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------------+------------------+------------------+------------------+\n",
      "|summary|MovieID          |CustomerID        |Rating            |YearOfRelease     |\n",
      "+-------+-----------------+------------------+------------------+------------------+\n",
      "|count  |100480507        |100480507         |100480507         |100479542         |\n",
      "|mean   |9070.914762472286|1322488.5067232791|3.604289964420661 |1993.9115270947393|\n",
      "|stddev |5131.890697186413|764536.8002745779 |1.0852185646295627|12.400832155509613|\n",
      "|min    |1                |6                 |1.0               |1896              |\n",
      "|25%    |4677             |661149            |3.0               |1990              |\n",
      "|50%    |9051             |1318979           |4.0               |1998              |\n",
      "|75%    |13636            |1984445           |4.0               |2002              |\n",
      "|max    |17770            |2649429           |5.0               |2005              |\n",
      "+-------+-----------------+------------------+------------------+------------------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Display a summary over the dataset\n",
    "df.summary().show(truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a5a959",
   "metadata": {},
   "source": [
    "We can verify that we have around 100 million ratings in the range [1-5] and that each column has the expected data type. The following can also be noted:\n",
    "\n",
    "- There are 17770 unique movies\n",
    "- Over 2.6 million unique customers\n",
    "- The oldest movie was released in 1896, while the most recent in 2005\n",
    "- There are some missing values in the `YearOfRelease` column\n",
    "\n",
    "\n",
    "While we will do a more thorough visulisation of the dataset efter engineering more features, we can already now remove missing values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "78982ca8-e6ea-4af7-b663-e220c3f5127c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop rows with NULL values\n",
    "df = df.dropna(how=\"any\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "61bd3fcb-4660-4529-a1bb-81dffaa8d17e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "[Stage 17:===========================================>              (3 + 1) / 4]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+-------------+----------------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|RatingYear|RatingMonth|Diff_RatingRelease|Diff_binned|HashedMovieID|HashedCustomerID|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+-------------+----------------+\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+-------------+----------------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# filter on NULL values to confirm there are no left\n",
    "df.filter(\" is NULL OR \".join(df.columns) + \" is NULL\").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e62d02b",
   "metadata": {},
   "source": [
    "It's confirmed - there are no `NULL` values left.\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "<a name=\"FE\"></a>\n",
    "\n",
    "\n",
    "## [Feature Engineering](#top)\n",
    "\n",
    "We will do some simple feature engineering by extracting year and month from the `RatingDate` column as well as calculating the difference in years between that column and the `YearOfRelease` column. Perhaps knowing when the rating was given and its relation to the release date might better help us determine what rating was given by a specific user. We should also make sure to convert the columns to adequate data types using the `.cast()` method. \n",
    "\n",
    "Engineering the difference, `Diff_RatingRelease`, is the trickiest and needs some extra work. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "19139a05-6873-4e62-821b-e69b0d715118",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|RatingYear|RatingMonth|Diff_RatingRelease|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+\n",
      "|  11607|   2018894|   5.0|2005-05-31|         2005|      2005|          5|               0.0|\n",
      "|  14590|   1427512|   5.0|2000-04-29|         1995|      2000|          4|               5.0|\n",
      "|    330|   2510262|   3.0|2003-03-23|         1998|      2003|          3|               5.0|\n",
      "|  14574|    782212|   3.0|2005-09-02|         1998|      2005|          9|               8.0|\n",
      "|  14858|    121218|   3.0|2005-05-22|         1995|      2005|          5|              10.0|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Create new columns RatingYear, RatingMonth and Diff_RatingRelease\n",
    "df = df.withColumn(\"RatingYear\", date_format(df.RatingDate, \"yyyy\").cast(IntegerType())) \\\n",
    "       .withColumn(\"RatingMonth\", date_format(df.RatingDate, \"M\").cast(IntegerType())) \\\n",
    "       .withColumn(\"Diff_RatingRelease\", \n",
    "                   spark_round(datediff(df.RatingDate, \n",
    "                            to_date(df.YearOfRelease.cast(\"string\"), \n",
    "                                    \"yyyy\"))/365.25, 0)\n",
    "                  )\n",
    "\n",
    "df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aae43c20-5f46-48ea-a92f-7bf3f7068a30",
   "metadata": {},
   "source": [
    "Furthermore, we can also bin the `Diff_ReleaseRating` column into `Diff_binned` to have fewer categories to deal with. I'm creating these bins rather arbitrary for now. Ideally however, we would bin in several different ways before training and evaluating these models to find the most suited bins for the problem. I will take a shortcut and bin in the following way though:\n",
    "\n",
    " \n",
    "| Values        | Bin                |\n",
    "|---------------|--------------------|\n",
    "| Negative      | -1                 |\n",
    "| 1 - 4.99      | 1, 2, 3, 4 and 5, respectively |\n",
    "| 5 - 9.99      | 5                  |\n",
    "| 10 - 49.99    | 10                 |\n",
    "| 50 and above  | 50                 |\n",
    "\n",
    "<br>\n",
    "\n",
    "The process for that is displayed below, with the function `bin_diff` deciding what thresholds to bin on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0b25a08e-2a64-4780-8f1a-26a83c1aff8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "@udf\n",
    "def bin_diff(x):\n",
    "    \"\"\" Function for binning a value x. \"\"\"\n",
    "    if x is not None:\n",
    "        if x < 0:\n",
    "            return -1\n",
    "        if x < 5:\n",
    "            return x\n",
    "        elif x < 10:\n",
    "            return 5\n",
    "        elif x < 50:\n",
    "            return 10\n",
    "        else:\n",
    "            return 50\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1293abc5-9699-4b1b-85bb-a5ebb8fa0e8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|RatingYear|RatingMonth|Diff_RatingRelease|Diff_binned|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+\n",
      "|  11607|   2018894|   5.0|2005-05-31|         2005|      2005|          5|               0.0|          0|\n",
      "|  14590|   1427512|   5.0|2000-04-29|         1995|      2000|          4|               5.0|          5|\n",
      "|    330|   2510262|   3.0|2003-03-23|         1998|      2003|          3|               5.0|          5|\n",
      "|  14574|    782212|   3.0|2005-09-02|         1998|      2005|          9|               8.0|          5|\n",
      "|  14858|    121218|   3.0|2005-05-22|         1995|      2005|          5|              10.0|         10|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Bin the Diff_RatingRelease column\n",
    "df = df.withColumn(\"Diff_binned\", bin_diff(\"Diff_RatingRelease\").cast(IntegerType()))\n",
    "df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3afa60a4-6ba5-4853-8528-58c1310876df",
   "metadata": {},
   "source": [
    "Moreover, we have some categorical variables that should be treated before moving forward. These are the nominal variables `MovieID` and `CustomerID`. Under current rank order representation, the `CustomerID` column will teach the estimator that, for example, the customer with `CustomerID` *1488844* is larger/bigger/worth more than the customer with `CustomerID` *822109*. Such bias is misleading and we need to address that. There are several options we can take here, such as one-hot encoding and bin-counting, but we will go with hashing as it's more straight forward and offers computational advantages. Spark's `FeatureHasher` is well suited for this.  \n",
    "\n",
    "We leave the ordinal variables `YearOfRelease`, `RatingYear` and `RatingsMonth` as is since they are sensitive to rank order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d00df65e-7982-48f1-9184-5d1a79f3d1b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|RatingYear|RatingMonth|Diff_RatingRelease|Diff_binned|       HashedMovieID|    HashedCustomerID|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "|  11607|   2018894|   5.0|2005-05-31|         2005|      2005|          5|               0.0|          0|(262144,[138338],...|(262144,[211647],...|\n",
      "|  14590|   1427512|   5.0|2000-04-29|         1995|      2000|          4|               5.0|          5|(262144,[138338],...|(262144,[211647],...|\n",
      "|    330|   2510262|   3.0|2003-03-23|         1998|      2003|          3|               5.0|          5|(262144,[138338],...|(262144,[211647],...|\n",
      "|  14574|    782212|   3.0|2005-09-02|         1998|      2005|          9|               8.0|          5|(262144,[138338],...|(262144,[211647],...|\n",
      "|  14858|    121218|   3.0|2005-05-22|         1995|      2005|          5|              10.0|         10|(262144,[138338],...|(262144,[211647],...|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Create two hashers to keep the columns apart\n",
    "hasherM = FeatureHasher().setInputCols([\"MovieID\"]) \\\n",
    "                        .setOutputCol(\"HashedMovieID\")\n",
    "hasherC = FeatureHasher().setInputCols([\"CustomerID\"]) \\\n",
    "                        .setOutputCol(\"HashedCustomerID\")\n",
    "\n",
    "# Apply the hashers on the dataset and display the resulting DataFrame\n",
    "df = hasherM.transform(df)\n",
    "df = hasherC.transform(df)\n",
    "df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e932a1-ec50-41ca-b73f-f8326dbab254",
   "metadata": {},
   "source": [
    "Let's keep the target variable `Rating` as a float. This allow us to approach it as a regression rather than as a classification problem, with the advantage of providing us with the size of the error on each prediction. Besides, that was the approach in the competition.\n",
    "\n",
    "<a name=\"data_vis\"></a>\n",
    "\n",
    "\n",
    "## [Data Visualisation](#top)\n",
    "\n",
    "\n",
    "Plot the count for each of the columns to get a fair estimate of their distribution. The `MovieID` and `CustomerID` columns are truncated due to their large size and only display the lowest five (which each has `count=1`) and highest 100 counts. We also sort these columns on their counts to facilitate interpretation. No need to display the hashed columns as they are hard to interpret for the human eye anyway. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9291ba35-ae23-4053-b147-072c4233c749",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1800 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Select columns to plot\n",
    "cols_for_display = [\"MovieID\", \n",
    "                    \"CustomerID\", \n",
    "                    \"YearOfRelease\", \n",
    "                    \"Rating\", \n",
    "                    \"RatingYear\", \n",
    "                    \"RatingMonth\", \n",
    "                    \"Diff_binned\"\n",
    "                   ]\n",
    "\n",
    "plt.figure(figsize=(20, 25))\n",
    "for i, col in enumerate(cols_for_display, 1):\n",
    "    plt.subplot(4, 2, i)\n",
    "    \n",
    "    # Due to their large counts, prepare the ID columns different\n",
    "    if col in [\"CustomerID\", \"MovieID\"]:\n",
    "        counts = df.groupBy(col).count().orderBy(\"count\").toPandas()\n",
    "        cc = pd.concat([counts.head(), counts.tail(100)], ignore_index=True)\n",
    "        \n",
    "        sns.barplot(x=col, \n",
    "                    y=\"count\", \n",
    "                    data=cc, \n",
    "                    order=cc.sort_values(\"count\")[str(col)],\n",
    "                    palette=\"crest\")\n",
    "    else:\n",
    "        sns.barplot(x=col, \n",
    "                y=\"count\", \n",
    "                data=df.groupBy(col).count().toPandas(),\n",
    "                palette=\"crest\")\n",
    "      \n",
    "    # Specify labels, title and their size\n",
    "    plt.xlabel(col, size=14)\n",
    "    plt.ylabel(\"Count\", size=14)\n",
    "    plt.title(f\"{col} count\", size=18)\n",
    "    \n",
    "plt.subplots_adjust(hspace=0.3, wspace=0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e67f1a00",
   "metadata": {},
   "source": [
    "Among other things, we learn the following from above plot:\n",
    "\n",
    "- `MovieID` and `CustomerID` counts are highly skewed with some movies receiving many reviews and some customers giving many reviews. \n",
    "- Most movies are released recently. \n",
    "- Most movies have received a *3* or *4* in rating, but there are also many *5*s. *1*s are the rarest.\n",
    "- Most movies were rated in 2004 and 2005, with over 50% of the ratings in 2005. \n",
    "- August, September and October are the most popular months to rate a moive. February the least. \n",
    "- Few movies are rated close to their release date (`Diff_binned` = 0). A lot of movies are rated the year after their release or within five years thereafter. *The interpretation of this last plot depends of course a lot on how we binned the column before. And as previously stated, binning is something that should be experimented with for best result.* "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5162c52a-de42-44b2-85d2-9e7a0e87dda8",
   "metadata": {},
   "source": [
    "<a name=\"ml-modelling\"></a>\n",
    "\n",
    "## [Machine Learning modelling](#top)\n",
    "\n",
    "\n",
    "With a smaller dataset we would prefer to train and test many models using cross-validation. However, with over 100 million ratings, we can consider the data to be fairly large and will thus go with a more traditional train / test split. 80% of the data will be dedicated for training the model while 20% for testing it. Providing a `seed` will allow us to replicate the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "67ff56ca-2847-498e-91b1-6a155f7fe7ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split into train and test sets\n",
    "splits = df.randomSplit([0.8, 0.2], seed=747)\n",
    "df_train = splits[0]\n",
    "df_test = splits[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7885169b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "[Stage 8:>                                                          (0 + 1) / 1]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "|MovieID|CustomerID|Rating|RatingDate|YearOfRelease|RatingYear|RatingMonth|Diff_RatingRelease|Diff_binned|       HashedMovieID|    HashedCustomerID|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "|      1|     13651|   3.0|2004-06-16|         2003|      2004|          6|               1.0|          1|(262144,[138338],...|(262144,[211647],...|\n",
      "|      1|     14924|   5.0|2005-10-04|         2003|      2005|         10|               3.0|          3|(262144,[138338],...|(262144,[211647],...|\n",
      "|      1|    145873|   3.0|2004-02-25|         2003|      2004|          2|               1.0|          1|(262144,[138338],...|(262144,[211647],...|\n",
      "|      1|    188613|   4.0|2005-09-15|         2003|      2005|          9|               3.0|          3|(262144,[138338],...|(262144,[211647],...|\n",
      "|      1|    230112|   3.0|2004-08-26|         2003|      2004|          8|               2.0|          2|(262144,[138338],...|(262144,[211647],...|\n",
      "+-------+----------+------+----------+-------------+----------+-----------+------------------+-----------+--------------------+--------------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# Display the first five rows on the train set\n",
    "df_train.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "108d3465",
   "metadata": {},
   "source": [
    "Specify target variable and features for modelling. Root Mean Squared Error (RMSE) will be used for evaluating the performance of the model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "04707894-a6c9-447e-9ecf-4090b4f57014",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify target variable\n",
    "target = StringIndexer(inputCol=\"Rating\", \n",
    "                       outputCol=\"label\")\n",
    "\n",
    "# Specify features\n",
    "input_cols = [\"YearOfRelease\", \n",
    "              \"MovieID\", \n",
    "              \"CustomerID\",\n",
    "              \"RatingYear\", \n",
    "              \"RatingMonth\", \n",
    "              \"Diff_binned\"]\n",
    "featureAssembler = VectorAssembler(inputCols=input_cols, \n",
    "                                   outputCol=\"features\")\n",
    "\n",
    "# Specify evaluator with the default RMSE as metric\n",
    "evaluator = RegressionEvaluator(metricName=\"rmse\", \n",
    "                                predictionCol=\"prediction\", \n",
    "                                labelCol=\"label\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3554735-3fa6-43ad-a453-01975f8751ed",
   "metadata": {},
   "source": [
    "<a name=\"baseline\"></a>\n",
    "\n",
    "\n",
    "### [Get baseline results with Linear Regression](#top)\n",
    "\n",
    "To have something to compare with, we will train and evaluate one of the more simplistic algorithms on the data; Linear Regression, using its default parameters. \n",
    "\n",
    "Note that we do this on a smaller fraction of the data to speed things up (file `part-00000*.parquet`, which is around 2.5 million reviews). You can load it by changing the `data_path` [above](#data_path). \n",
    "\n",
    "```python\n",
    "# Specify data path\n",
    "data_path = \"data-parquet/part-00000*.parquet\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9afb02fe-87ce-4e74-abbc-f836753d4197",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 16:================================================>         (5 + 1) / 6]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 24.6 ms, sys: 8.59 ms, total: 33.2 ms\n",
      "Wall time: 34.7 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Instantiate a Linear regression model with default parameters\n",
    "lr = LinearRegression()\n",
    "\n",
    "# Put everything in a Pipeline\n",
    "pipeline = Pipeline(stages=[target, featureAssembler, lr])\n",
    "\n",
    "# Train the model\n",
    "baseline = pipeline.fit(df_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3b14c146-1607-4b29-b9ac-c59a555b095a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_model(model, trainSet, testSet):\n",
    "    \"\"\" Function for evaluating a model on a train and test set\"\"\"\n",
    "    \n",
    "    # Evaluate model on train set\n",
    "    pred_train = model.transform(trainSet)\n",
    "    rmse_train = evaluator.evaluate(pred_train, {evaluator.metricName: \"rmse\"})\n",
    "\n",
    "    # Evaluate model on test set\n",
    "    pred_test = model.transform(testSet)\n",
    "    rmse_test = evaluator.evaluate(pred_test, {evaluator.metricName: \"rmse\"})\n",
    "    \n",
    "    # Display results\n",
    "    time.sleep(1)\n",
    "    print(f\"RMSE train set: {rmse_train:.5f}\")\n",
    "    print(f\"RMSE test set:  {rmse_test:.5f}\")\n",
    "    \n",
    "    return rmse_train, rmse_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "250f73bf-35a5-42e3-acb7-bc3a1ebff58c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.15156\n",
      "RMSE test set:  1.15247\n"
     ]
    }
   ],
   "source": [
    "# Evaluate baseline model\n",
    "rmse_train, rmse_test = evaluate_model(baseline, df_train, df_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7509e9-1cd9-4d0c-8302-fdd5dcf19601",
   "metadata": {},
   "source": [
    "A baseline of 1.152 is achieved on the test set. There's practically no difference between the train and test sets, which means variance is low. \n",
    "\n",
    "> After evaluating a model using the original `CustomerID` and `MovieID` features instead of the hashed alternatives, `HashedCustomerID` and `HashedMovieID`, I found practically no differences between the two. I will thus go with the original features, and you will simply have to take my words for it. :)\n",
    "\n",
    "\n",
    "<a name=\"regressors\"></a>\n",
    "\n",
    "\n",
    "### [Tune and Evaluate Multiple Regressors](#top)\n",
    "\n",
    "\n",
    "In order to find the best model for the problem, we will evaluate several standard algorithms. Train, tune and evaluate Decision Trees, Random Forest, Gradient-Boosted Trees and Linear Regressors on the dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "90a6365d-b4b8-4e87-aaaf-2c5dbe1f2238",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Tuning DecisionTreeRegressor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.14973\n",
      "RMSE test set:  1.15098\n",
      "\n",
      "Tuning RandomForestRegressor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.15065\n",
      "RMSE test set:  1.15171\n",
      "\n",
      "Tuning GBTRegressor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.14881\n",
      "RMSE test set:  1.15005\n",
      "\n",
      "Tuning LinearRegression\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.15156\n",
      "RMSE test set:  1.15247\n",
      "CPU times: user 2.29 s, sys: 897 ms, total: 3.18 s\n",
      "Wall time: 10min 56s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Specify regressors to evaluate\n",
    "dt = DecisionTreeRegressor()\n",
    "rf = RandomForestRegressor()\n",
    "gb = GBTRegressor()\n",
    "lr = LinearRegression()\n",
    "\n",
    "regressors = [{\"regressor\": dt,\n",
    "               \"paramGrid\": ParamGridBuilder().addGrid(dt.maxBins, [16, 32]) \\\n",
    "                                              .addGrid(dt.maxDepth, [3, 5, 7]) \\\n",
    "                                              .build()},\n",
    "              {\"regressor\": rf,\n",
    "               \"paramGrid\": ParamGridBuilder().addGrid(rf.numTrees, [20, 40, 60]) \\\n",
    "                                              .addGrid(rf.maxDepth, [3, 5]) \\\n",
    "                                              .build()},\n",
    "              {\"regressor\": gb,\n",
    "               \"paramGrid\": ParamGridBuilder().addGrid(gb.subsamplingRate, [1.0, 0.7]) \\\n",
    "                                              .addGrid(gb.maxDepth, [3, 5]) \\\n",
    "                                              .build()},\n",
    "              {\"regressor\": lr,\n",
    "               \"paramGrid\": ParamGridBuilder().addGrid(lr.maxIter, [100, 1000]) \\\n",
    "                                              .addGrid(lr.regParam, [0.0, 0.01, 0.1]) \\\n",
    "                                              .addGrid(lr.elasticNetParam, [0.0, 0.5, 1.0]) \\\n",
    "                                              .build()}\n",
    "             ]\n",
    "\n",
    "results = {}\n",
    "for regressor in regressors:\n",
    "    name = str(regressor[\"regressor\"]).split(\"_\")[0]\n",
    "    print(f\"\\nTuning {name}\")\n",
    "    \n",
    "    # Create Pipeline\n",
    "    pipeline = Pipeline(stages=[target, featureAssembler, regressor[\"regressor\"]])\n",
    "    \n",
    "    # Specify model training specs\n",
    "    tvs = TrainValidationSplit(estimator=pipeline, \n",
    "                               estimatorParamMaps=regressor[\"paramGrid\"], \n",
    "                               evaluator=evaluator,\n",
    "                               trainRatio=0.75,\n",
    "                               parallelism=8, \n",
    "                               seed=72)\n",
    "    \n",
    "    # Train model\n",
    "    model = tvs.fit(df_train)\n",
    "    \n",
    "    # Evaluate model\n",
    "    rmse_train, rmse_test = evaluate_model(model, df_train, df_test)\n",
    "    \n",
    "    # Store the results\n",
    "    results[name] = {\"model\": model,\n",
    "                     \"rmse_train\": rmse_train,\n",
    "                     \"rmse_test\": rmse_test}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c241bd4d",
   "metadata": {},
   "source": [
    "Although with a very small margin, the Gradient-Boosted Tree Regressor (GBTRegressor) is the most performant model on the test data. Let's extract the best parameters and train it on the entire dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2496f533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maxDepth:         5\n",
      "subSamplingsRate: 0.7\n"
     ]
    }
   ],
   "source": [
    "# Get the best GBTR parameters\n",
    "best_gbtr = results[\"GBTRegressor\"][\"model\"].bestModel\n",
    "maxDepth = best_gbtr.stages[-1]._java_obj.getMaxDepth()\n",
    "subSamplingsRate = best_gbtr.stages[-1]._java_obj.getSubsamplingRate()\n",
    "\n",
    "print(\"maxDepth:        \", maxDepth)\n",
    "print(\"subSamplingsRate:\", subSamplingsRate)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d267773c-b19e-4c2e-9086-2c72ee8cd59f",
   "metadata": {},
   "source": [
    "\n",
    "<a name=\"best_model\"></a>\n",
    "\n",
    "\n",
    "## [Train the Best GBTRegressor on the Full Dataset](#top)\n",
    "\n",
    "\n",
    "Train the GBTRegressor on the entire dataset using the best parameters. Load the entire dataset by updating [above](#data_path) code to the following:  \n",
    "\n",
    "\n",
    "```python\n",
    "# Specify data path\n",
    "data_path = \"data-parquet/part-0*.parquet\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a54856d1-cbbe-49b2-a963-101250c7a7b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.31 s, sys: 1.54 s, total: 2.85 s\n",
      "Wall time: 1h 25min 23s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Specify model parameters from previous step\n",
    "gb_best = GBTRegressor(maxDepth=5,\n",
    "                       subsamplingRate=0.7)\n",
    "\n",
    "# Put everything in a Pipeline\n",
    "pipeline = Pipeline(stages=[target, featureAssembler, gb_best])\n",
    "\n",
    "# Train model\n",
    "final_model = pipeline.fit(df_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6447d30f-9cfe-4c88-a387-0c101192701b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE train set: 1.14898\n",
      "RMSE test set:  1.14893\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model\n",
    "best_rmse_train_, best_rmse_test = evaluate_model(final_model, df_train, df_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4533b97",
   "metadata": {},
   "source": [
    "We have a final score of 1.149 on the test set. It's barely better than the 1.152 baseline though, and significantly worse than the 0.8572 the team who won the challenge in 2009 got. \n",
    "\n",
    "Let's further explore which of the features are most important for the model to make its predicitons. \n",
    "\n",
    "<a name=\"feature_importance\"></a>\n",
    "\n",
    "\n",
    "## [Which Features are most Important?](#top)\n",
    "\n",
    "The most important features are `YearOfRelease`, `MovieID` and `RatingMonth`, contributing 37, 27 and 20%, respectively, as displayed in the plot below. The difference between the release and rating year, `Diff_binned` contributes a meek 3% to the overall, while `CustomerID` less than 1 percent. \n",
    "\n",
    "This means that it matters little *who* rated the movie and far more *which* movie it is. This is reasonable as one would expect that most people would rate a good movie as good and a bad one as bad. \n",
    "\n",
    "However, that the release year matters this much is quite surprising. We would need to dig deeper into the data to find out why this may be the case. We won't do that here, but can speculate that, perhaps, older movies are held to newer standards, and since all ratings are from 1999 and later, while some movies are 100 years older than that, their ratings might be biased by this. Who hasn't re-watched a favourite movie from childhood and found it awful at later years? Or perhaps, newer movies might simply be better than older? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a1088918",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot and rank the features in importance\n",
    "importance = pd.DataFrame(zip(final_model.stages[-1].featureImportances.toArray(), \n",
    "                              input_cols),\n",
    "                         columns=[\"Importance\", \"Feature\"])\n",
    "\n",
    "plt.figure(figsize=(10, 5))\n",
    "sns.barplot(x=\"Feature\",\n",
    "            y=\"Importance\", \n",
    "            data=importance,\n",
    "            order=importance.sort_values(\"Importance\", \n",
    "                                         ascending=False)[\"Feature\"])\n",
    "\n",
    "plt.xlabel(\"Feature\", size=16)\n",
    "plt.ylabel(\"Importance\", size=16)\n",
    "plt.title(\"Feature Importance\", size=18);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5931ae47",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "<a name=\"conclusions\"></a>\n",
    "\n",
    "## [Conclusions](#top)\n",
    "\n",
    "We've trained a few models on the 100 million ratings dataset obtained from the Netflix challenge back in 2009 using nothing but a laptop. Although the model performance isn't as good as what was attained by the winning teams (they [reportedly](https://netflixtechblog.com/netflix-recommendations-beyond-the-5-stars-part-1-55838468f429) spent 2,000 hours during the first year of the competition), we've been successful in training a fairly large dataset locally. This in less time than what it takes to return from an outdoor exercise session.\n",
    "\n",
    "A final score of 1.149 RMSE (interpreted as 1.149 points off, on average) was achieved while identifying release year, movie ID and rating month to be the most important features when predicting a movie's rating. This is not to say that other features wouldn't be important in making this prediction, but rather that out of the features available in the dataset, these are the most important. \n",
    "\n",
    "We only briefly covered feature engineering - the process of creating new features out of current or external data - but this is often an incredibly important aspect in machine learning with significant predictive benefits. Examples of engineered features can be the average rating per movie or year, or count/average of ratings per day and movie, number of days since a customer's first rating, and many more. "
   ]
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}