Spotify-MPD-spark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glint-FMPair evaluation on Spotify MPD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"PYSPARK_SUBMIT_ARGS\"] = \"--conf spark.driver.memory=35G \" + \\\n",
    "    \"--conf \\\"spark.driver.extraJavaOptions=-XX:+UseG1GC -XX:InitiatingHeapOccupancyPercent=35 -XX:-ResizePLAB\\\" \" + \\\n",
    "    \"--conf spark.driverEnv.LD_PRELOAD=/opt/cloudera/parcels/mkl/linux/mkl/lib/intel64/libmkl_rt.so \" + \\\n",
    "    \"--conf spark.driverEnv.MKL_VERBOSE=0 \" + \\\n",
    "    \"--jars glint-fmpair/target/scala-2.11/glint-fmpair-assembly-1.0.jar pyspark-shell\"\n",
    "\n",
    "import pickle\n",
    "import random\n",
    "import time\n",
    "\n",
    "from math import log2, ceil\n",
    "from matplotlib import pyplot as plt, patches as mpatches\n",
    "\n",
    "from pyspark.ml.linalg import VectorUDT\n",
    "from pyspark.ml.feature import VectorAssembler, StringIndexer, RegexTokenizer, \\\n",
    "    StopWordsRemover, CountVectorizer, StringIndexerModel, CountVectorizerModel, Bucketizer\n",
    "from pyspark.sql.functions import collect_set, udf, col, mean, first, year, lower, \\\n",
    "    explode, explode_outer, lag, to_timestamp, regexp_replace, expr, when, posexplode, \\\n",
    "    lit, count, max as sparkMax, sum as sparkSum, array_remove\n",
    "from pyspark.sql import SparkSession, Window, Row\n",
    "\n",
    "\n",
    "from glintfmpair import WeightHotEncoderEstimator, WeightHotEncoderModel, \\\n",
    "    GlintFMPair, GlintFMPairModel, PopRank, SAGH, KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder \\\n",
    "    .appName(\"Glint-FMPair evaluation on Spotify MPD\") \\\n",
    "    .master(\"yarn\") \\\n",
    "    .config(\"spark.submit.deployMode\",\"client\") \\\n",
    "    .config(\"spark.dynamicAllocation.enabled\", \"false\") \\\n",
    "    .config(\"spark.executor.memory\", \"25G\") \\\n",
    "    .config(\"spark.yarn.executor.memoryOverhead\", \"5G\") \\\n",
    "    .config(\"spark.executor.instances\", \"80\") \\\n",
    "    .config(\"spark.executor.cores\", \"5\") \\\n",
    "    .config(\"spark.executor.extraJavaOptions\" \"-XX:+UseG1GC -XX:InitiatingHeapOccupancyPercent=35 -XX:-ResizePLAB\") \\\n",
    "    .config(\"spark.executorEnv.LD_PRELOAD\",\n",
    "            \"/opt/cloudera/parcels/mkl/linux/mkl/lib/intel64/libmkl_rt.so\") \\\n",
    "    .config(\"spark.executorEnv.MKL_VERBOSE\", \"0\") \\\n",
    "    .config(\"spark.jars\", \"glint-fmpair/target/scala-2.11/glint-fmpair-assembly-1.0.jar\") \\\n",
    "    .config(\"spark.kryoserializer.buffer.max\", \"256m\") \\\n",
    "    .config(\"spark.executor.heartbeatInterval\", \"100000\") \\\n",
    "    .config(\"spark.network.timeout\", \"1000000\") \\\n",
    "    .config(\"spark.maxRemoteBlockSizeFetchToMem\", \"256m\") \\\n",
    "    .config(\"spark.driver.maxResultSize\", \"8G\") \\\n",
    "    .config(\"spark.default.parallelism\", \"400\") \\\n",
    "    .getOrCreate()\n",
    "\n",
    "sc = spark.sparkContext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.udf.registerJavaFunction(\"resizeVector\", \"org.apache.spark.ml.recommendation.ResizeVector\", VectorUDT())\n",
    "spark.udf.registerJavaFunction(\"weighVector\", \"org.apache.spark.ml.recommendation.WeighVector\", VectorUDT())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataPath = \"hdfs:/user/app/2018S/public/recsys_spotify_2018/mpd.v1/mpd.slice.*.json\"\n",
    "albumDataPath = \"spotify-albums.csv\"\n",
    "audioDataPath = \"spotify-audio.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "trans=False\n",
    "valSplit=False\n",
    "seedsSplit=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if seedsSplit:\n",
    "    if trans:\n",
    "        indexedTrainDataPath = \"MPD-train-trans-seeds.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-valseeds-trans-seeds.parquet\"\n",
    "        indexedValDataPath = \"MPD-val-trans-seeds.parquet\"\n",
    "        indexedValCtxDataPath = \"MPD-val-ctx-trans-seeds.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-{}-indexer-trans-seeds.model\"\n",
    "        nameEncoderModelPath = \"MPD-nameencoder-trans-seeds.model\"\n",
    "        encoderModelPaths = [\"MPD-usercoldstartencoder-trans-seeds.model\",\n",
    "                             \"MPD-userencoder-trans-seeds.model\",\n",
    "                             \"MPD-itemencoder-trans-seeds.model\",\n",
    "                             \"MPD-ctxitemencoder-trans-seeds.model\"]\n",
    "    else:\n",
    "        indexedTrainDataPath = \"MPD-train-seeds.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-valseeds-seeds.parquet\"\n",
    "        indexedValDataPath = \"MPD-val-seeds.parquet\"\n",
    "        indexedValCtxDataPath = \"MPD-val-ctx-seeds.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-{}-indexer-seeds.model\"\n",
    "        nameEncoderModelPath = \"MPD-nameencoder-seeds.model\"\n",
    "        encoderModelPaths = [\"MPD-usercoldstartencoder-seeds.model\",\n",
    "                             \"MPD-userencoder-seeds.model\",\n",
    "                             \"MPD-itemencoder-seeds.model\",\n",
    "                             \"MPD-ctxitemencoder-seeds.model\"]    \n",
    "elif valSplit:\n",
    "    if trans:\n",
    "        indexedTrainDataPath = \"MPD-train-trans.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-valseeds-trans.parquet\"\n",
    "        indexedValDataPath = \"MPD-val-trans.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-{}-indexer-trans.model\"\n",
    "        nameEncoderModelPath = \"MPD-nameencoder-trans.model\"\n",
    "        encoderModelPaths = [\"MPD-usercoldstartencoder-trans.model\", \"MPD-userencoder-trans.model\",\n",
    "                             \"MPD-itemencoder-trans.model\", \"MPD-ctxitemencoder-trans.model\"]\n",
    "    else:\n",
    "        indexedTrainDataPath = \"MPD-train.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-valseeds.parquet\"\n",
    "        indexedValDataPath = \"MPD-val.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-{}-indexer.model\"\n",
    "        nameEncoderModelPath = \"MPD-nameencoder.model\"\n",
    "        encoderModelPaths = [\"MPD-usercoldstartencoder.model\", \"MPD-userencoder.model\",\n",
    "                             \"MPD-itemencoder.model\", \"MPD-ctxitemencoder.model\"]\n",
    "else:\n",
    "    if trans:\n",
    "        indexedTrainDataPath = \"MPD-test-train-trans.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-test-valseeds-trans.parquet\"\n",
    "        indexedValDataPath = \"MPD-val-test-trans.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-test-{}-indexer-trans.model\"\n",
    "        nameEncoderModelPath = \"MPD-test-nameencoder-trans.model\"\n",
    "        encoderModelPaths = [\"MPD-test-usercoldstartencoder-trans.model\", \"MPD-test-userencoder-trans.model\",\n",
    "                             \"MPD-test-itemencoder-trans.model\", \"MPD-test-ctxitemencoder-trans.model\"]\n",
    "    else:\n",
    "        indexedTrainDataPath = \"MPD-test-train.parquet\"\n",
    "        indexedValSeedsDataPath = \"MPD-test-valseeds.parquet\"\n",
    "        indexedValDataPath = \"MPD-test-val.parquet\"\n",
    "        indexerModelPathFormat = \"MPD-test-{}-indexer.model\"\n",
    "        nameEncoderModelPath = \"MPD-test-nameencoder.model\"\n",
    "        encoderModelPaths = [\"MPD-test-usercoldstartencoder.model\", \"MPD-test-userencoder.model\",\n",
    "                             \"MPD-test-itemencoder.model\", \"MPD-test-ctxitemencoder.model\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameterServerHost=\"10.7.0.117\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadFeatures=False\n",
    "saveFeatures=False\n",
    "loadIndexed=True\n",
    "saveIndexed=False\n",
    "\n",
    "loadIndexers=True\n",
    "saveIndexers=False\n",
    "loadNameEncoder=True\n",
    "saveNameEncoder=False\n",
    "loadEncoders=True\n",
    "saveEncoders=False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadData(s, dataPath): \n",
    "    return s.read.option(\"multiLine\", \"true\").json(dataPath) \\\n",
    "        .select(explode(col(\"playlists\")).alias(\"playlist\")) \\\n",
    "        .select(\"playlist.pid\", \"playlist.name\", \"playlist.modified_at\", \"playlist.tracks\") \\\n",
    "        .select(col(\"pid\").cast(\"integer\"), \\\n",
    "                lower(col(\"name\")).alias(\"name\"), \\\n",
    "                year(to_timestamp(\"modified_at\")).alias(\"modified_at_year\"), \\\n",
    "                explode_outer(col(\"tracks\")).alias(\"track\")) \\\n",
    "        .select(\"pid\", \"name\", \"modified_at_year\", \\\n",
    "                \"track.track_uri\", \"track.album_uri\", \"track.artist_uri\", \"track.pos\") \\\n",
    "        .select(\"pid\", \"name\", \"modified_at_year\", \"pos\", \\\n",
    "                regexp_replace(\"track_uri\", \"spotify:track:\", \"\").alias(\"track_uri\"), \\\n",
    "                regexp_replace(\"album_uri\", \"spotify:album:\", \"\").alias(\"album_uri\"), \\\n",
    "                regexp_replace(\"artist_uri\", \"spotify:artist:\", \"\").alias(\"artist_uri\"))\n",
    "\n",
    "\n",
    "def withAlbumData(df, s, dataPath):\n",
    "    albumDf = s.read.option(\"header\", \"true\").csv(dataPath) \\\n",
    "        .select(col(\"id\").alias(\"album_uri\"), col(\"release_date\").substr(0, 4).alias(\"release_date\"))\n",
    "    return df.join(albumDf, \"album_uri\", how=\"left\")\n",
    "\n",
    "\n",
    "def withAudioData(df, s, dataPath):\n",
    "    audioDf = s.read.option(\"header\", \"true\").csv(dataPath).select(\n",
    "        col(\"id\").alias(\"track_uri\"),\n",
    "        col(\"danceability\").cast(\"double\").alias(\"danceability\"),\n",
    "        col(\"energy\").cast(\"double\").alias(\"energy\"),\n",
    "        col(\"valence\").cast(\"double\").alias(\"valence\"),\n",
    "        col(\"acousticness\").cast(\"double\").alias(\"acousticness\"),\n",
    "        when(col(\"key\") == -1, 12).otherwise(col(\"key\")).cast(\"integer\").alias(\"keyid\"),\n",
    "        col(\"loudness\").cast(\"double\").alias(\"loudness\"),\n",
    "        col(\"mode\").cast(\"integer\").alias(\"modeid\"),  # TODO: rerun\n",
    "        col(\"tempo\").cast(\"double\").alias(\"tempo\"))\n",
    "    \n",
    "    return df.join(audioDf, \"track_uri\", how=\"left\") \\\n",
    "        .fillna(12, subset=[\"keyid\"]) \\\n",
    "        .fillna(2, subset=[\"modeid\"])\n",
    "\n",
    "\n",
    "def withPrevData(df):\n",
    "    prevWindow = Window.partitionBy(\"pid\").orderBy(\"pos\")\n",
    "    return df \\\n",
    "        .withColumn(\"prev_track_uri\", lag(\"track_uri\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_album_uri\", lag(\"album_uri\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_artist_uri\", lag(\"artist_uri\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_release_date\", lag(\"release_date\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_danceability\", lag(\"danceability\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_energy\", lag(\"energy\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_valence\", lag(\"valence\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_acousticness\", lag(\"acousticness\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_keyid\", lag(\"keyid\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_loudness\", lag(\"loudness\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_modeid\", lag(\"modeid\", 1).over(prevWindow)) \\\n",
    "        .withColumn(\"prev_tempo\", lag(\"tempo\", 1).over(prevWindow)) \\\n",
    "        .fillna(12, subset=[\"prev_keyid\"]) \\\n",
    "        .fillna(2, subset=[\"prev_modeid\"])\n",
    "\n",
    "\n",
    "if not loadFeatures and not loadIndexed:\n",
    "    data = loadData(spark, dataPath)\n",
    "    data = withAlbumData(data, spark, albumDataPath)\n",
    "    data = withAudioData(data, spark, audioDataPath)\n",
    "    data = withPrevData(data)\n",
    "    if not seedsSplit and trans:\n",
    "        data = data.where(col(\"pos\") != 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66350223"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.select(\"pid\").dropDuplicates().count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2262292"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.select(\"track_uri\").dropDuplicates().count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "734684"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.select(\"album_uri\").dropDuplicates().count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "295860"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.select(\"artist_uri\").dropDuplicates().count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------------+\n",
      "|average playlist length|\n",
      "+-----------------------+\n",
      "|              66.350223|\n",
      "+-----------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "trackCountsDf = data.select(\"pid\", \"track_uri\") \\\n",
    "    .groupBy(\"pid\") \\\n",
    "    .agg(count(\"track_uri\").alias(\"count\")) \\\n",
    "    .select(\"count\")\n",
    "\n",
    "trackCountsDf.select(mean(\"count\").alias(\"average playlist length\")).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trackCounts = trackCountsDf.rdd.map(lambda r: r[0]).collect()\n",
    "plt.hist(trackCounts, bins=max(trackCounts));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------------------+\n",
      "|average playlists per track|\n",
      "+---------------------------+\n",
      "|         29.328761715994222|\n",
      "+---------------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "playlistCountsDf = data.select(\"pid\", \"track_uri\") \\\n",
    "    .groupBy(\"track_uri\") \\\n",
    "    .agg(count(\"pid\").alias(\"count\")) \\\n",
    "    .select(\"count\")\n",
    "\n",
    "playlistCountsDf.select(mean(\"count\").alias(\"average playlists per track\")).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "playlistCounts = playlistCountsDf.rdd.map(lambda r: r[0]).collect()\n",
    "plt.hist(playlistCounts, bins=range(0, 50));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadFeatures and not loadIndexed:\n",
    "    random.seed(1)\n",
    "    testPids = [random.randint(0, 1000000) for i in range(1000)]\n",
    "\n",
    "def trainTestSplit(data):\n",
    "    train = data.where(~col(\"pid\").isin(testPids))\n",
    "    test = data.where(col(\"pid\").isin(testPids))\n",
    "    return train, test\n",
    "\n",
    "\n",
    "def seedsCtxSplit(data):\n",
    "    maxPosWindow = sparkMax(\"pos\").over(Window.partitionBy(\"pid\"))\n",
    "    data = data.withColumn(\"maxPos\", maxPosWindow)\n",
    "    seeds = data.where(col(\"pos\") < col(\"maxPos\")).drop(\"maxPos\")\n",
    "    context = data.where(col(\"pos\") == col(\"maxPos\")).drop(\"maxPos\")\n",
    "    return seeds, context\n",
    "\n",
    "\n",
    "def posSplit(data, splitPos):\n",
    "    ltSplit = data.where(col(\"pos\") < splitPos)\n",
    "    geSplit = data.where(col(\"pos\") >= splitPos)\n",
    "    return ltSplit, geSplit\n",
    "                \n",
    "\n",
    "def lastTrackSplit(data, valSplit=False):\n",
    "    train, test = trainTestSplit(data)\n",
    "    testSeeds, test = seedsCtxSplit(test)\n",
    "    if valSplit:\n",
    "        valSeeds, val = seedsCtxSplit(testSeeds)\n",
    "        return train.unionAll(valSeeds), valSeeds, val\n",
    "    return train.unionAll(testSeeds), testSeeds, test\n",
    "\n",
    "\n",
    "def seedTracksSplit(data):\n",
    "    train, test = trainTestSplit(data)\n",
    "    testSeeds, test = posSplit(test, 25)\n",
    "    testCtx, _ = posSplit(test, 26)\n",
    "    return train, testSeeds, testCtx, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadFeatures and not loadIndexed:\n",
    "    if seedsSplit:\n",
    "        trainData, valSeedsData, valCtxData, valData = seedTracksSplit(data)\n",
    "        if trans:\n",
    "            trainData = trainData.where(col(\"pos\") != 0)\n",
    "    else:\n",
    "        trainData, valSeedsData, valData = lastTrackSplit(data, valSplit=valSplit)\n",
    "        valCtxData = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "buckets = [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45,\n",
    "           0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0]\n",
    "bucketizerCols = [(\"danceability\", \"danceabilityid\"), (\"energy\", \"energyid\"),\n",
    "                  (\"valence\", \"valenceid\"), (\"acousticness\", \"acousticnessid\"),\n",
    "                  (\"prev_danceability\", \"prev_danceabilityid\"), (\"prev_energy\", \"prev_energyid\"),\n",
    "                  (\"prev_valence\", \"prev_valenceid\"), (\"prev_acousticness\", \"prev_acousticnessid\")]\n",
    "\n",
    "tempoBuckets = [0, 60, 70, 80, 90, 100, 110, 120, 130,\n",
    "                140, 150, 160, 170, 180, 190, 200, 500]\n",
    "loudnessBuckets = [-100, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11,\n",
    "                   -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 10]\n",
    "\n",
    "buckets = [buckets] * len(bucketizerCols) + [tempoBuckets, tempoBuckets] + [loudnessBuckets, loudnessBuckets]\n",
    "bucketizerCols = bucketizerCols + [(\"tempo\", \"tempoid\"), (\"prev_tempo\", \"prev_tempoid\"),\n",
    "                                   (\"loudness\", \"loudnessid\"), (\"prev_loudness\", \"prev_loudnessid\")]\n",
    "\n",
    "\n",
    "keepCols = [\"pid\", \"keyid\", \"modeid\", \"prev_keyid\", \"prev_modeid\", \"name\", \"pos\"]\n",
    "\n",
    "userIndexerCols = [(\"modified_at_year\", \"pyear\")]\n",
    "itemIndexerCols = [(\"track_uri\", \"traid\"), (\"album_uri\", \"albid\"),\n",
    "                   (\"artist_uri\", \"artid\"), (\"release_date\", \"releaseid\")]\n",
    "prevItemIndexerCols = [(\"prev_\" + i, \"prev_\" + o) for i, o in itemIndexerCols]\n",
    "indexerCols = userIndexerCols + itemIndexerCols + prevItemIndexerCols\n",
    "\n",
    "\n",
    "def toBucketized(data):\n",
    "    for bucketSplit, bucketizerCol in zip(buckets, bucketizerCols):\n",
    "        bucketizer = Bucketizer(inputCol=bucketizerCol[0], outputCol=bucketizerCol[1],\n",
    "                                splits=bucketSplit, handleInvalid=\"keep\")\n",
    "        data = bucketizer.transform(data.fillna(float(\"nan\"), subset=[bucketizerCol[0]]))\n",
    "    \n",
    "    return data.select(*(keepCols +\n",
    "                         [i for i, o in indexerCols] +\n",
    "                         [col(o).cast(\"integer\").alias(o) for i, o in bucketizerCols]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saveIndexerModels(models, modelPathFormat):\n",
    "    return [model.save(modelPathFormat.format(i))\n",
    "            for model, (i, o) in zip(models, userIndexerCols + itemIndexerCols + prevItemIndexerCols)]   \n",
    "\n",
    "    \n",
    "def loadIndexerModels(modelPathFormat):\n",
    "    return [StringIndexerModel.load(modelPathFormat.format(i))\n",
    "            for i, o in userIndexerCols + itemIndexerCols + prevItemIndexerCols]\n",
    "\n",
    "\n",
    "def fitIndexerModels(data):\n",
    "    userIndexers = [StringIndexer(inputCol=i, outputCol=o, handleInvalid=\"keep\").fit(data)\n",
    "                    for i, o in userIndexerCols]\n",
    "    itemIndexers = [StringIndexer(inputCol=i, outputCol=o, handleInvalid=\"keep\").fit(data)\n",
    "                    for i, o in itemIndexerCols]\n",
    "    prevItemIndexers = [ii.copy({ii.inputCol: i, ii.outputCol: o})\n",
    "                        for (ii, (i, o)) in zip(itemIndexers, prevItemIndexerCols)]\n",
    "\n",
    "    return userIndexers + itemIndexers + prevItemIndexers\n",
    "\n",
    "\n",
    "def toIndexed(data, indexerModels):\n",
    "    for model, modelCols in zip(indexerModels, indexerCols):\n",
    "        data = model.transform(data)\n",
    "    return data.select(*(keepCols +\n",
    "                         [col(o).cast(\"integer\").alias(o) for i, o in indexerCols] +\n",
    "                         [o for i, o in bucketizerCols]))\n",
    "\n",
    "\n",
    "def toNameTransformed(data):\n",
    "    data = RegexTokenizer(inputCol=\"name\", outputCol=\"name_tokenized\", minTokenLength=3) \\\n",
    "        .transform(data)\n",
    "    data = StopWordsRemover(inputCol=\"name_tokenized\", outputCol=\"name_swremoved\") \\\n",
    "        .transform(data)\n",
    "    return data.drop(\"name\", \"name_tokenized\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadFeatures:\n",
    "    \n",
    "    # loading / fitting and saving indexer and indexing\n",
    "    # also bucketize and name transform\n",
    "    if loadIndexed:\n",
    "        trainData = spark.read.parquet(indexedTrainDataPath)\n",
    "        valSeedsData = spark.read.parquet(indexedValSeedsDataPath)\n",
    "        valData = spark.read.parquet(indexedValDataPath)\n",
    "        if seedsSplit:\n",
    "            valCtxData = spark.read.parquet(indexedValCtxDataPath)\n",
    "    else:\n",
    "        if loadIndexers:\n",
    "            indexerModels = loadIndexerModels(indexerModelPathFormat)\n",
    "        else:\n",
    "            indexerModels = fitIndexerModels(trainData)\n",
    "            if saveIndexers:\n",
    "                saveIndexerModels(indexerModels, indexerModelPathFormat)\n",
    "\n",
    "        trainData = toBucketized(trainData)\n",
    "        valSeedsData = toBucketized(valSeedsData)\n",
    "        valData = toBucketized(valData)\n",
    "        if valCtxData:\n",
    "            valCtxData = toBucketized(valCtxData)\n",
    "                \n",
    "        trainData = toIndexed(trainData, indexerModels)\n",
    "        valSeedsData = toIndexed(valSeedsData, indexerModels)\n",
    "        valData = toIndexed(valData, indexerModels)\n",
    "        if valCtxData:\n",
    "            valCtxData = toIndexed(valCtxData, indexerModels)\n",
    "\n",
    "        trainData = toNameTransformed(trainData)\n",
    "        valSeedsData = toNameTransformed(valSeedsData)\n",
    "        valData = toNameTransformed(valData)\n",
    "        if valCtxData:\n",
    "            valCtxData = toNameTransformed(valCtxData)\n",
    "\n",
    "        if saveIndexed:\n",
    "            trainData.write.save(indexedTrainDataPath, format=\"parquet\", mode=\"overwrite\")\n",
    "            valSeedsData.write.save(indexedValSeedsDataPath, format=\"parquet\", mode=\"overwrite\")\n",
    "            valData.write.save(indexedValDataPath, format=\"parquet\", mode=\"overwrite\")\n",
    "            if valCtxData:\n",
    "                valCtxData.write.save(indexedValCtxDataPath, format=\"parquet\", mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadNameEncoderModel(modelPath):\n",
    "    return CountVectorizerModel.load(modelPath)\n",
    "\n",
    "\n",
    "def fitNameEncoderModel(data):\n",
    "    return CountVectorizer(\n",
    "        inputCol=\"name_swremoved\", outputCol=\"pname\", vocabSize=10000, minDF=10.0, binary=True\n",
    "    ).fit(data.groupby(\"pid\").agg(first(\"name_swremoved\").alias(\"name_swremoved\")))\n",
    "    \n",
    "\n",
    "def loadEncoderModels(modelPaths):\n",
    "    return tuple(WeightHotEncoderModel.load(modelPath) for modelPath in modelPaths)\n",
    "    \n",
    "\n",
    "def fitEncoderModels(data):\n",
    "    userColdStartGroupCols = [\"pid\"]\n",
    "    userColdStartCols = [\"traid\"]\n",
    "    userColdStartWeights = [1.0]\n",
    "    userColdStartEncoderModel = WeightHotEncoderEstimator(\n",
    "        weights=userColdStartWeights, inputCols=userColdStartCols,\n",
    "        outputCols=[c + \"_cold_encoded\" for c in userColdStartCols],\n",
    "        groupCols=userColdStartGroupCols, groupWeighting=\"sqrt\",\n",
    "        dropLast=True, handleInvalid=\"keep\"\n",
    "    ).fit(data)\n",
    "    \n",
    "    # dropLast, missing user features are simply ignored, no problem for ranking\n",
    "    userCols = [\"pid\", \"pyear\"]\n",
    "    userWeights = [1.0, 1.0]\n",
    "    userEncoderModel = WeightHotEncoderEstimator(\n",
    "        weights=userWeights, inputCols=userCols,\n",
    "        outputCols=[c + \"_encoded\" for c in userCols], dropLast=True\n",
    "    ).fit(data)\n",
    "    \n",
    "    # missing item features are mapped to the missing feature index\n",
    "    itemCols = [\"traid\", \"albid\", \"artid\", \"releaseid\", \n",
    "                \"danceabilityid\", \"energyid\", \"valenceid\", \"acousticnessid\",\n",
    "                \"keyid\", \"loudnessid\", \"modeid\", \"tempoid\"]\n",
    "    itemWeights = [1.0, 1.0, 1.0, 0.125,\n",
    "                   0.125, 0.125, 0.125, 0.125,\n",
    "                   0.125, 0.125, 0.125, 0.125]\n",
    "    itemEncoderModel = WeightHotEncoderEstimator(\n",
    "        weights=itemWeights, inputCols=itemCols,\n",
    "        outputCols=[c + \"_encoded\" for c in itemCols], dropLast=False\n",
    "    ).fit(data)\n",
    "\n",
    "    # dropLast, missing user features are simply ignored, no problem for ranking\n",
    "    ctxitemCols = [\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\",\n",
    "                   \"prev_danceabilityid\", \"prev_energyid\", \"prev_valenceid\", \"prev_acousticnessid\",\n",
    "                   \"prev_keyid\", \"prev_loudnessid\", \"prev_modeid\", \"prev_tempoid\"]\n",
    "    ctxitemWeights = itemWeights\n",
    "    ctxitemEncoderModel = itemEncoderModel.copy({\n",
    "        itemEncoderModel.weights: ctxitemWeights,\n",
    "        itemEncoderModel.inputCols: ctxitemCols,\n",
    "        itemEncoderModel.outputCols: [c + \"_encoded\" for c in ctxitemCols],\n",
    "        itemEncoderModel.dropLast: True,\n",
    "        itemEncoderModel.handleInvalid: \"keep\"\n",
    "    })\n",
    "    \n",
    "    return userColdStartEncoderModel, userEncoderModel, itemEncoderModel, ctxitemEncoderModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not loadFeatures:\n",
    "    \n",
    "    # loading / fitting and saving name encoder and name encoding\n",
    "    if loadNameEncoder:\n",
    "        nameEncoderModel = loadNameEncoderModel(nameEncoderModelPath)\n",
    "    else:\n",
    "        nameEncoderModel = fitNameEncoderModel(trainData)\n",
    "        if saveNameEncoder:\n",
    "            nameEncoderModel.save(nameEncoderModelPath)\n",
    "    \n",
    "    trainData = nameEncoderModel.transform(trainData).drop(\"name_swremoved\")\n",
    "    valSeedsData = nameEncoderModel.transform(valSeedsData).drop(\"name_swremoved\")\n",
    "    valData = nameEncoderModel.transform(valData).drop(\"name_swremoved\")\n",
    "    if seedsSplit:\n",
    "        valCtxData = nameEncoderModel.transform(valCtxData).drop(\"name_swremoved\")\n",
    "    \n",
    "    # loading / fitting and saving encoder\n",
    "    if loadEncoders:\n",
    "        encoderModels = loadEncoderModels(encoderModelPaths)\n",
    "    else:\n",
    "        encoderModels = fitEncoderModels(trainData)\n",
    "        if saveEncoders:\n",
    "            for model, modelPath in zip(encoderModels, encoderModelPaths):\n",
    "                model.save(modelPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7625"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(nameEncoderModel.vocabulary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def toFeatures(data, encoderModels, queryctxData=None, sharedItemFeatures=False,\n",
    "               allUserColdStartWeights=[1.0],\n",
    "               userColdStartWeighting=\"sqrt\",\n",
    "               allUserWeights=[1.0, 0.125],\n",
    "               allUserNameWeights=[1.0],\n",
    "               allCtxitemWeights=[1.0, 1.0, 1.0, 0.5,\n",
    "                                  0.125, 0.125, 0.125, 0.125,\n",
    "                                  0.125, 0.125, 0.125, 0.125],\n",
    "               allItemWeights=[1.0, 1.0, 1.0, 0.5,\n",
    "                               0.125, 0.125, 0.125, 0.125,\n",
    "                               0.125, 0.125, 0.125, 0.125],\n",
    "               coldStartUserCols=[],\n",
    "               userNameCols=[],\n",
    "               userCols=[\"pid\", \"pyear\"],\n",
    "               ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\",\n",
    "                            \"prev_danceabilityid\", \"prev_energyid\", \"prev_valenceid\", \"prev_acousticnessid\",\n",
    "                            \"prev_keyid\", \"prev_loudnessid\", \"prev_modeid\", \"prev_tempoid\"],\n",
    "               itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\",\n",
    "                         \"danceabilityid\", \"energyid\", \"valenceid\", \"acousticnessid\",\n",
    "                         \"keyid\", \"loudnessid\", \"modeid\", \"tempoid\"]):\n",
    "    \n",
    "    userColdStartEncoderModel, userEncoderModel, itemEncoderModel, ctxitemEncoderModel = encoderModels\n",
    "    \n",
    "    encodedColdStartUserCols = [c + \"_cold_encoded\" for c in coldStartUserCols]\n",
    "    encodedUserNameCols = [c + \"_encoded\" for c in userNameCols]\n",
    "    encodedUserCols = [c + \"_encoded\" for c in userCols]\n",
    "    encodedItemCols = [c + \"_encoded\" for c in itemCols]\n",
    "    encodedCtxitemCols = [c + \"_encoded\" for c in ctxitemCols]\n",
    "    \n",
    "    # hot encode\n",
    "    if coldStartUserCols:\n",
    "        data = userColdStartEncoderModel \\\n",
    "            .setWeights(allUserColdStartWeights) \\\n",
    "            .setGroupWeighting(userColdStartWeighting) \\\n",
    "            .transform(data)\n",
    "    \n",
    "    if queryctxData:\n",
    "        firstColdStartUserCols = [first(c).alias(c) for c in encodedColdStartUserCols]\n",
    "        data = data.groupBy(\"pid\") \\\n",
    "            .agg(collect_set(col(\"traid\").cast(\"int\")).alias(\"filteritemids\"), *firstColdStartUserCols) \\\n",
    "            .select(\"pid\", \"filteritemids\", *encodedColdStartUserCols) \\\n",
    "            .join(queryctxData, \"pid\")\n",
    "    else:\n",
    "        data = itemEncoderModel.setWeights(allItemWeights).transform(data)\n",
    "    \n",
    "    if userNameCols:\n",
    "        for userNameCol, encodedUserNameCol, userNameWeight in zip(userNameCols, encodedUserNameCols, allUserNameWeights):\n",
    "            data = data.withColumn(encodedUserNameCol,\n",
    "                                   expr(\"weighVector({}, cast({} as double))\".format(userNameCol, userNameWeight)))\n",
    "    \n",
    "    if userCols: \n",
    "        data = userEncoderModel.setWeights(allUserWeights).transform(data)\n",
    "        \n",
    "    if ctxitemCols:\n",
    "        data = ctxitemEncoderModel.setWeights(allCtxitemWeights).transform(data)\n",
    "        \n",
    "    # assemble feature vectors of required hot-encoded columns into combined feature vectors\n",
    "    userInputCols = encodedCtxitemCols + encodedColdStartUserCols + encodedUserNameCols + encodedUserCols\n",
    "    userAssembler = VectorAssembler(inputCols=userInputCols, outputCol=\"userctxfeatures\")\n",
    "    data = userAssembler.transform(data)\n",
    "\n",
    "    if not queryctxData:\n",
    "        itemInputCols = encodedItemCols\n",
    "        itemAssembler = VectorAssembler(inputCols=itemInputCols, outputCol=\"itemfeatures\")\n",
    "        data = itemAssembler.transform(data)\n",
    "\n",
    "    # rename columns to Glint-FMPair names\n",
    "    cols = [col(\"userctxfeatures\"), col(\"pid\").cast(\"int\").alias(\"userid\")]\n",
    "    \n",
    "    if queryctxData:\n",
    "        cols += [col(\"filteritemids\")]\n",
    "    elif sharedItemFeatures:\n",
    "        cols += [expr(\"resizeVector(itemfeatures,userctxfeatures)\").alias(\"itemfeatures\"), \n",
    "                 col(\"traid\").cast(\"int\").alias(\"itemid\"),\n",
    "                 col(\"albid\").cast(\"int\"), col(\"artid\").cast(\"int\")]\n",
    "    else:\n",
    "        cols += [col(\"itemfeatures\"), col(\"traid\").cast(\"int\").alias(\"itemid\"),\n",
    "                 col(\"albid\").cast(\"int\"), col(\"artid\").cast(\"int\")]\n",
    "    \n",
    "    return data.select(*cols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dcg(itemid, recs):\n",
    "    return sum(1.0 / log2(i + 2) if rec[\"itemid\"] == itemid else 0.0\n",
    "               for i, rec in enumerate(recs))\n",
    "\n",
    "def hitRate(itemid, recs):\n",
    "    return 1.0 if recs[0][\"itemid\"] == itemid else 0\n",
    "\n",
    "\n",
    "dcgUdf = udf(dcg)\n",
    "hitRateUdf = udf(hitRate)\n",
    "\n",
    "\n",
    "def evaluateModel(queryfeatures, evaldata, model, withHitRates=False, traindata=None):\n",
    "    if traindata:\n",
    "        recdata = model.recommendForUserSubset(queryfeatures, traindata, 500)\n",
    "    else:\n",
    "        recdata = model.recommendForUserSubset(queryfeatures.coalesce(80), 500).cache()\n",
    "    scores = evaldata.join(recdata, \"userid\") \\\n",
    "        .select(hitRateUdf(\"itemid\", \"recommendations\").alias(\"hitRate\"), \\\n",
    "                dcgUdf(\"itemid\", \"recommendations\").alias(\"dcg\")) \\\n",
    "        .select(mean(col(\"hitRate\")), mean(col(\"dcg\"))) \\\n",
    "        .first()\n",
    "\n",
    "    hitRate = scores[0]\n",
    "    ndcg = scores[1]\n",
    "    \n",
    "    if withHitRates:\n",
    "        \n",
    "        numUsers = evaldata.select(\"userid\").dropDuplicates().count()\n",
    "        \n",
    "        hitRates = evaldata.join(recdata, \"userid\") \\\n",
    "            .select(\"itemid\", posexplode(\"recommendations\")) \\\n",
    "            .where(col(\"itemid\") == col(\"col.itemid\")) \\\n",
    "            .groupBy(\"pos\") \\\n",
    "            .agg(count(\"itemid\").alias(\"hitRate\"))\n",
    "         \n",
    "        hitRates = sc.range(0, 500).map(lambda p: Row(pos=p)).toDF() \\\n",
    "            .join(hitRates, on=\"pos\", how=\"left\") \\\n",
    "            .fillna(0.0, subset=[\"hitRate\"]) \\\n",
    "            .select(\"pos\", sparkSum(\"hitRate\").over(Window.orderBy(\"pos\")).alias(\"hitRate\")) \\\n",
    "            .orderBy(\"pos\") \\\n",
    "            .select(\"hitRate\") \\\n",
    "            .rdd \\\n",
    "            .map(lambda r: r[0] / numUsers) \\\n",
    "            .collect()\n",
    "        \n",
    "        return hitRate, ndcg, hitRates\n",
    "\n",
    "    return hitRate, ndcg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ndcgMulti(itemids, recs):\n",
    "    dcg = sum(1.0 / log2(i + 2) if rec[\"itemid\"] in itemids else 0.0\n",
    "              for i, rec in enumerate(recs))\n",
    "    idcg = sum(1.0 / log2(i + 2) for i, itemid in enumerate(itemids))\n",
    "    return dcg / idcg\n",
    "\n",
    "\n",
    "ndcgMultiUdf = udf(ndcgMulti)\n",
    "\n",
    "\n",
    "def evaluateModelMulti(queryfeatures, evaldata, model, withHitRates=False, traindata=None):\n",
    "    if traindata:\n",
    "        recdata = model.recommendForUserSubset(queryfeatures, traindata, 500)\n",
    "    else:\n",
    "        recdata = model.recommendForUserSubset(queryfeatures.coalesce(80), 500).cache()\n",
    "    scores = evaldata \\\n",
    "        .groupby(\"userid\") \\\n",
    "        .agg(collect_set(\"itemid\").alias(\"itemids\")) \\\n",
    "        .join(recdata, \"userid\") \\\n",
    "        .select(ndcgMultiUdf(\"itemids\", \"recommendations\").alias(\"ndcg\")) \\\n",
    "        .select(mean(col(\"ndcg\"))) \\\n",
    "        .first()\n",
    "\n",
    "    ndcg = scores[0]\n",
    "    \n",
    "    if withHitRates:\n",
    "        \n",
    "        numUsers = recdata.select(\"userid\").dropDuplicates().count()\n",
    "        \n",
    "        userWindow = Window.partitionBy(\"userid\")\n",
    "        hitRates = evaldata \\\n",
    "            .select(\"userid\", \"itemid\", count(\"itemid\").over(userWindow).alias(\"numuseritems\")) \\\n",
    "            .join(recdata, \"userid\") \\\n",
    "            .select(\"itemid\", \"numuseritems\", posexplode(\"recommendations\")) \\\n",
    "            .where(col(\"itemid\") == col(\"col.itemid\")) \\\n",
    "            .groupBy(\"pos\") \\\n",
    "            .agg(sparkSum(expr(\"1.0 / numuseritems\")).alias(\"hitRate\"))\n",
    "         \n",
    "        hitRates = sc.range(0, 500).map(lambda p: Row(pos=p)).toDF() \\\n",
    "            .join(hitRates, on=\"pos\", how=\"left\") \\\n",
    "            .fillna(0.0, subset=[\"hitRate\"]) \\\n",
    "            .select(\"pos\", sparkSum(\"hitRate\").over(Window.orderBy(\"pos\")).alias(\"hitRate\")) \\\n",
    "            .orderBy(\"pos\") \\\n",
    "            .select(\"hitRate\") \\\n",
    "            .rdd \\\n",
    "            .map(lambda r: r[0] / numUsers) \\\n",
    "            .collect()\n",
    "        \n",
    "        return ndcg, hitRates\n",
    "\n",
    "    return ndcg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeaturesPath = \"MPD-trainfeatures.parquet\"\n",
    "valqueryFeaturesPath = \"MPD-valqueryfeatures.parquet\"\n",
    "\n",
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\"], ctxitemCols=[])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "if saveFeatures:\n",
    "    trainFeatures.write.save(trainFeaturesPath, format=\"parquet\", mode=\"overwrite\")\n",
    "    valqueryFeatures.write.save(valqueryFeaturesPath, format=\"parquet\", mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "metadataPath = \"MPD.meta\"\n",
    "metadataPathExp = \"MPD-exp.meta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=256, stepSize=0.1, linearReg=0.1, factorsReg=0.003, numDims=50,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"uniform\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=256, stepSize=0.1, linearReg=0.1, factorsReg=0.003, numDims=50,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"uniform\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linearRegs = [0.03, 0.3]\n",
    "for linearReg in linearRegs:\n",
    "    fitStart = time.time()\n",
    "    model = GlintFMPair(\n",
    "        batchSize=256, stepSize=0.1, linearReg=linearReg, factorsReg=0.003, numDims=50,\n",
    "        parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "        samplingCol=\"\", sampler=\"uniform\", filterItemsCol=\"filteritemids\",\n",
    "        loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    "    ).fit(trainFeatures)\n",
    "    fitEnd = time.time()\n",
    "    fitTime = fitEnd - fitStart\n",
    "\n",
    "    hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "    model.destroy()\n",
    "    print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "factorsRegs = [0.01, 0.001, 0.0003]\n",
    "for factorsReg in factorsRegs:\n",
    "    fitStart = time.time()\n",
    "    model = GlintFMPair(\n",
    "        batchSize=256, stepSize=0.1, linearReg=0.1, factorsReg=factorsReg, numDims=50,\n",
    "        parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "        samplingCol=\"\", sampler=\"uniform\", filterItemsCol=\"filteritemids\",\n",
    "        loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    "    ).fit(trainFeatures)\n",
    "    fitEnd = time.time()\n",
    "    fitTime = fitEnd - fitStart\n",
    "\n",
    "    hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "    model.destroy()\n",
    "    print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 1503.47400s fit time\n",
    "# 0.005000 hit rate\n",
    "# 0.061949 NDCG\n",
    "\n",
    "# 1516.09630s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.071506 NDCG\n",
    "\n",
    "# 1583.56542s fit time\n",
    "# 0.008000 hit rate\n",
    "# 0.071309 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ks = [100, 150, 200, 250, 300, 350, 400]\n",
    "kNdcgs = []\n",
    "kFitTimes = []\n",
    "for k in ks:\n",
    "    fitStart = time.time()\n",
    "    model = GlintFMPair(\n",
    "        batchSize=256, stepSize=0.1, linearReg=0.1, factorsReg=0.001, numDims=k,\n",
    "        parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "        samplingCol=\"\", sampler=\"uniform\", filterItemsCol=\"filteritemids\",\n",
    "        loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    "    ).fit(trainFeatures)\n",
    "    fitEnd = time.time()\n",
    "    fitTime = fitEnd - fitStart\n",
    "\n",
    "    hitRate, ndcg = evaluateModel(valqueryFeatures, valData, model)\n",
    "    model.destroy()\n",
    "    print(\"k {}:\".format(k))\n",
    "    print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "    kNdcgs.append(ndcg)\n",
    "    kFitTimes.append(fitTime)\n",
    "\n",
    "# k 100:\n",
    "# 1732.85702s fit time\n",
    "# 0.004000 hit rate\n",
    "# 0.069570 NDCG\n",
    "# k 150:\n",
    "# 1753.28953s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.075285 NDCG\n",
    "# k 200:\n",
    "# 2056.79767s fit time\n",
    "# 0.012000 hit rate\n",
    "# 0.078022 NDCG\n",
    "# k 250:\n",
    "# 2244.53965s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.077795 NDCG\n",
    "# k 300:\n",
    "# 2501.21044s fit time\n",
    "# 0.011000 hit rate\n",
    "# 0.078540 NDCG\n",
    "# k 350:\n",
    "# 2530.06946s fit time\n",
    "# 0.012000 hit rate\n",
    "# 0.079428 NDCG\n",
    "# k 400:\n",
    "# 2746.25606s fit time\n",
    "# 0.009000 hit rate\n",
    "# 0.078083 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAADgCAYAAAApH+CEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XmYVdWZ7/HvT4pBcEQFldkbTCQRjZSo0VYSJzDdQbvxEUOcYiQmcrsTOzEYE5N4o91J30Rv0qY7OIIgYjS2dILiFNokKgrGCRFT4lSgEGSMA4i+94+1yzoU59Qp2XXqVFG/z/Ocp85ee+1d794U5z1rrb3XVkRgZma2rXaodgBmZtaxOZGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGYVJOkuSWcVLP9Q0ipJr1czLrPW5ERinY6koyQ9JGmdpNWS/ijp0FbY7/clTS8si4gxETE1Wz8A+GdgWETs/SH3PVhSSHq8SfmekjZJeqmg7CVJb0v6q6QVkm6QtFO2bp6kdyRtkLRe0kJJkyV138bDNnMisc5F0i7Ab4CfA72BfsAPgI1t8OsHAW9ExMoc++gl6RMFy58HXixS7+8iYifgEOBQ4DsF6yZFxM7APqTENh6YI0k54rJOzInEOpv9ASJiZkS8FxFvR8Q9EfEUgKSzsxbKz7MWy3OSjm3YWNK+kmZnLZk6Sedl5aOBbwOnZS2BJ7PyeZK+JOk44F5g32z9jZJ+K+l/FwYn6SlJJzcT/03AWQXLZwLTSlWOiGXAXcAniqx7MyLmAZ8DjgA+28zvNSvJicQ6m+eB9yRNlTRG0u5F6hwGLAX2BL4H/FpS72zdTKAe2BcYB1wh6diIuBu4ApgVETtFxEGFO4yI+4AxwPJs/dnAVOALDXUkHURqIc1pJv7pwHhJXSQdAOwMzC9VOetOOwn4U6k6EfEKsAD4m2Z+r1lJTiTWqUTEeuAoIIBrgL9kLYy+BdVWAldFxLsRMQtYAnw2+1A+CvhWRLwTEU8A1wJnbGM4dwJDJQ3Nls8gJaJNzWxTn8VzHKllUqo18l+S1gJ/AP6HlOSas5zU1Wf2oTmRWKcTEYsj4uyI6E/q8tkXuKqgyrLYcjbTl7M6+wKrI2JDk3X9tjGOjcCtwBck7QCcTuq6KmcacHZWf3qJOidHxG4RMSgivhoRb5fZZz9gdcsiN9uSE4l1ahHxHHAjW44h9Gsy8DyQ9I19OdBb0s5N1i1r2N02hDAVmAAcC7wVEQ+3YJvbSeMZSyPi5W34nVvIWlojgN/n3Zd1Tk4k1qlI+pikf5bUP1seQPpm/0hBtT7AP0rqKulU4ABgTkS8CjwE/IukHpKGA+cCM7LtVgCDs9ZFi2SJ433gJ7SsNUJEvAl8BvhSS39PMZJ6SjqG1MX2KM2PzZiV5ERinc0G0mD6fElvkhLIM6TLYBvMB4YCq4DLgXER8Ua27nRgMKl1cgfwvYi4N1v3q+znG03v9yhjGnAgpbupthIRCyLihQ/xOwr9u6QNpMR3FamFMzoi3t/G/VknJz/YyqyRpLOBL0XEUW34O88EJrbl7zRrTW6RmFWRpJ7AV4Ep1Y7FbFtVNJFIGi1pSXbj1uQi67tLmpWtny9pcFbeLZvW4WlJT0oaVbDNiKy8TtLPfDeudVSSTgT+QupiurnK4Zhts4p1bUnqQrr563jSte+PAadHxLMFdb4KDI+I8yWNB06JiNMkXQDURsQ5kvqQ7sw9NCLel/Qo8E+kvu05wM8i4q6KHISZmZVVyRbJSKAuIpZmN1jdAoxtUmcs6fJHgNuAY7MWxjDgfoBsXqK1QK2kfYBdIuLh7Dr/aUBz00mYmVmFVTKR9ANeLViuZ+sbtz6oExGbgXXAHsCTwFhJNZKGkK5xH5DVry+zTzMza0M1Fdx3sbGLpv1opepcT7p2fwHpzuGHgM0t3GfasTQRmAiw4447jhgwYEDLojYzMwCef/75VRGxV7l6lUwk9aRWRIP+pGvvi9Wpl1QD7EqagiKArzdUkvQQ8GdgTbaf5vYJQERMIbsSpra2NhYsWJDrYMzMOhtJLZo5oZJdW4+RJqQbIqkb6ZkHs5vUmU3jlNjjgAciIrI7bnsBSDoe2BwRz0bEa8AGSYdnYylnku7KNTOzKqlYiyQiNkuaBMwFugDXR8QiSZcBCyJiNnAdcJOkOtKEceOzzfsAcyW9T5rHqHB21a+Q5kbakXQ1l6/YMjOrok5xZ7u7tszMPjxJCyOitlw939luZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS4VTSSSRktaIqlO0uQi67tLmpWtny9pcFbeVdJUSU9LWizp4oJtXsrKn5Dk5+eamVVZxRKJpC7A1cAYYBhwuqRhTaqdC6yJiI8AVwI/yspPBbpHxIHACODLDUkm8+mIOLglzxI2M7PKqmSLZCRQFxFLI2ITcAswtkmdscDU7P1twLGSBATQS1INsCOwCVhfwVjNzGwbVTKR9ANeLViuz8qK1omIzcA6YA9SUnkTeA14Bfi/EbE62yaAeyQtlDSxcuGbmVlL1FRw3ypSFi2sMxJ4D9gX2B34vaT7ImIpcGRELJfUB7hX0nMR8eBWvzwlmYkAffv2Zd68edt+JGZmVlIlE0k9MKBguT+wvESd+qwba1dgNfB54O6IeBdYKemPQC2wNCKWA0TESkl3kJLOVokkIqYAUwBqa2tj1KhRrXhoZmbWoJJdW48BQyUNkdQNGA/MblJnNnBW9n4c8EBEBKk76zNKegGHA89J6iVpZ4Cs/ATgmQoeg5mZlVGxFklEbJY0CZgLdAGuj4hFki4DFkTEbOA64CZJdaSWyPhs86uBG0hJQsANEfGUpP2AO9J4PDXAzRFxd6WOwczMylNqAGzfamtrY8EC33JiZvZhSFrYktssfGe7mZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS4VTSSSRktaIqlO0uQi67tLmpWtny9pcFbeVdJUSU9LWizp4pbu08zM2lbFEomkLsDVwBhgGHC6pGFNqp0LrImIjwBXAj/Kyk8FukfEgcAI4MuSBrdwn2Zm1oYq2SIZCdRFxNKI2ATcAoxtUmcsMDV7fxtwrCQBAfSSVAPsCGwC1rdwn2Zm1oZqKrjvfsCrBcv1wGGl6kTEZknrgD1ISWUs8BrQE/h6RKyW1JJ9AiBpIjARoG/fvsybNy/v8ZhZJ9bnvvvY79pr6b5yJRv79GHpl77EyuOOq3ZY7UIlE4mKlEUL64wE3gP2BXYHfi/pvhbuMxVGTAGmANTW1saoUaNaFrWZWVMzZsCVV8JbbwHQY8UKhl15JcMOOAAmTKhycNVXya6temBAwXJ/YHmpOlk31q7AauDzwN0R8W5ErAT+CNS2cJ9mZq1jxQpYuBC+/vUPksgH3noLvv3t6sTVzlSyRfIYMFTSEGAZMJ6UIArNBs4CHgbGAQ9EREh6BfiMpOmkrq3DgauAZ1uwTzOzlnniCXjxRaivT69XX4UDDoDvfjet339/WL++9PavvAKHHQYf/3jja8QI2Guvtom/nahYIsnGPCYBc4EuwPURsUjSZcCCiJgNXAfcJKmO1BIZn21+NXAD8AypO+uGiHgKoNg+K3UMZtYBRYCyXvDf/Q6eeaYxSdTXQ79+MHNmWv+FL8Ci7COkWzfo3x/23LNxX7/4Bey0E5x/Prz++ta/a+ed0/o5c+CGG1LZj38M3/wmvPYaXHrplklmn30aY9uOKKLoEMN2pba2NhYsWFDtMMys0IwZcMkl6Vv9wIFw+eXlxxvefx/eeKPxG//s2fCHP2zZoujWDZYsSevHjIG7725MEv37pxbDT3+a1j/0EHTvDgMGpASyQ4ne/hkzYOLELbu3evaEKVMaY37jjZSUBg6EwYPh0Ufhs5+FVasat9ltN5g1C044AZYvh8WLU4Lp27ddJhhJCyOitly9SnZtmZkV1/SD+eWX0/K6dTByJBxySPpQv/329GpoTSxbluq/805a/9//DdOmpQQxYAAceSTst1/j7/nlL6FHj5R4in1Qf+pTLYu3IVk0l/j22AOOPrpxeeRI+MtfYOXKlGAaXkOGpPV33w3nnpve9+7d2Gq59NLUctm8GWo6xke0WyRmVlnvvps+UF9/vfH1ve+lxFDKa6/B3nvDv/4rXHNNY6Jo+HneeamV8fbbKVG0w2/zZa1ZA48/vmWSWbQI/vzn1Dq67DL493+HYcO27B476ijo0qVNQmxpi8SJxKw529L90pmsWZOuampIECtWpJ8XX5w+AGfOTOer6eeMtHVZgzvvhGOPhV69Kh9/e1M4vjNnDtxxR2OCWb8edtwRNmxIieSqq2Dp0i2TzO67p21b6e/WXVtmeZXqfoH2m0zyfIBEpA+p119PH0h77ZX68a++esvWxOuvp2/Kp5ySvlEff3zjPnr0SC2Jv/wlLQ8fnlofe++dXn37pp/HHJNibGrQIPjc5/Kfh46qsGV10knpBenfpr4+nbOG1sjixXDzzfDXvzZuc8QRcMEFbf536xaJWSmDB6f/hE3V1MBxx8Fdd6Xl734XnnoqDdr26JF+DhoE3/lOWj91avrwLVy/775w4olp/fz5qfune/fG1667pg9cgI0boWvX0gPBDUoNCF99NXz601smggMPTOMDK1akhNBQ/vbbabsrr4SvfQ2eey7V7dNny2Rw3nnpQ2vt2nTsDet23rll3UwtGby28iJScmlotXTtmloqxf5uBw2Cl176ULt3i8RsW2zcCPfcA//1X8W/MUMaBO3fv3F59er0H3fjxjQIvHEjfOQjjYnkF79IV/AU+tSnGhPJF78Izz675foTT0yDsQBDh6bB5pqaxmR0yilp7ADSt/uNG9M9ERs3brmft96Cc87Z+hi+8Y0Uw047pS6kI4/cssVwWDbz0P77p32WSmK77bblAHNLtWTw2sqTUoIYNKix9XLhhcXrlvp7bgVOJGabN8MDD6TLMn/96/Qtu3fv9IH62mtb1x80qPFDHNI3/uY89FD6MC5MNIWDpTfemH5nQ52NG1MLoMFFF6Vk1bDtxo1w0EGN6/feu3H7Uq67bstE0bD/Xr3g3ntLb1euFZTHhAlOHJUwcGDxFsnAgRX7le7ass7pvffgzTdhl13gkUdSN80uu8DJJ8P48anr6tZbO1b3S6muuG3o0rAOrBW7DVvateUnJFrnEZGSxte+li4hnZw9F+2ww9L9CCtWpPGMMWNSX/OECek/36BBjV0I7TWJQOoa6tlzy7KePVO5dR5V+Lt1i8Q6h3/5l3Rz2ssvp3GGMWPS2MTf/V21I2tdvlzZWlGrtEgknSvpmwXLyyStl7RB0ldaI1Czinj2Wfi3f2u8V2HZsnSd/dSpqeVxxx3bXxKBlDReeilNJfLSS04i1ibKDbafD4wuWF4ZEf0k9QDuAf6jYpGZfVh1dWnA/JZb0kR9O+yQksXHPgY//3nHvPvZrAMol0h2iIg3CpZ/BRAR70jasXJhmbVQw53A993XeGPcUUelG+bGjUtXKYGTiFkFlUskuxYuRMQVAJJ2ID0S16ztLV8Ov/pVanmcdFK6IfCoo9KMruPGpYF0M2sz5a7aukfSD4uUX0bq2jJrO9dfn+7Q7t8/XXn11lvp2RKQbtL7+tedRMyqoFyL5JvAtdmDp57Myg4CFgBfqmRgZqxdCw8+2Dj30p13Nj4s6LTT0pPszKzqmk0kEfEmcLqk/YCPZ8XPRsQLFY/MOqcNG9I9HbfcAnPnwqZN6ZLdgQNh+vQ0pYfHO8zalXKX/54oaVxELI2I/85eL0iaIOn45rY1K2nGjHQX9g47pJ8zZqTyu+9OU3dMmJBmlb3ggjShYUN3VUsnBDSzNlWua+sHQLGL7e8H7gCamaQHJI0G/h/p+erXRsS/NlnfHZgGjADeAE6LiJckTSB1qzUYDhwSEU9ImgfsA2TTlHJCRKwscxzWXhSbmv2LX0zvTzghvR8/Pk0iWMl5nsys1TR7Z7ukpyJi+Iddl63vAjwPHA/UA48Bp0fEswV1vgoMj4jzJY0HTomI05rs50DgzojYL1ueB3wjIlp8q7rvbG9HPB+UWYfRWnNt9ZC0VatFUleg3H0kI4G6rFtsE3ALMLZJnbHA1Oz9bcCx0lZ9F6cDM8v8LusoiiURqOgU12ZWWeW6tn4NXCNpUjbwjqRewM+ydc3pB7xasFwPHFaqTkRslrSOdH/KqoI6p7F1ArpB0nvA7cAPo0izStJEYCJA3759mTdvXplwrS18arfd6LZ27Vbl7/TpwyP+NzLrkMolku8APwRelvQyIGAAcB3w3TLbFhsVbfqB32wdSYcBb0XEMwXrJ0TEMkk7kxLJGaRxli13EjEFmAKpa2vUqFFlwrWKiIBp09JNhBdfnO44LzLFdY+f/AT/G5l1TM12bUXE5oiYTEoeZwNnAQMjYnJEvFtm3/XZdg36A8tL1cm60HYFVhesH0+Tbq2IWJb93ADcTOpCs/Zo7Vo4/XQ4++w0hcnmzR1vanYzK6vsExIl7QF8HvhYVrRY0swmc3AV8xgwVNIQYBkpKXy+SZ3ZpOT0MDAOeKChmyqbhuVU4IPneGbJZreIWJWN0/wtcF+5Y7Aq+P3v4QtfSC2Ryy+Hb32r8amAfjKe2Xal2UQi6QDgAWAu8CdSV9ShwLclfSYiniu1bTbmMSnbtgtwfUQsknQZsCAiZpO6yG7K7pxfTUo2DY4G6iNiaUFZd2BulkS6kJJIwTNPrV1YuTJdytu/P/zxjzDSjUaz7Vm5y39vA26NiFublP8D8PmI+IcKx9cqfPlvG1m1CvbcM72fOzfdC7LTTtWNycy2WWtd/ntg0yQCEBG3A5/Y1uBsOxORHhg1ZEh6YBTAiSc6iZh1EuUSyZvbuM46i8IB9REjoLbslxcz286UG2zvI+nCIuUC9qpAPNaR/OEPadC82IC6mXUa5RLJNcDOJdZd28qxWEezdCl06+YBdbNOrtnB9u2FB9tb0QsvwNNPw8knp7GRd96BHf3UZbPtUUsH28td/ntpM6sjIv7Ph47MOqaGO9QnTYJddoHRo9NTCZ1EzDq9lgy2N30BnAt8q4JxWXtSOKD+yU/Cww+nJGJmRvknJP6k4X02t9U/AeeQZvL9SantbDuyfj0cfDDU13tA3cyKaskUKb2BC4EJpCnfD4mINZUOzKosIs2FtcsucP758OlPw2FNJ282Myv/qN1/I82ZtYF0c+L3nUQ6gRdegKOPTl1YAJMnO4mYWUnlxkj+GdiXNJ38cknrs9cGSesrH14VlXqu+Pas4Q71gw9OV2a9UW5eTjOz8mMknfOh2cWeKz5xYnq/vc5au3Zt6sKaNQv+5m9g+nQYOLDaUZlZB9A5E0U5l1yy5YOXIC1fckl14mkLU6fCbbfBD38Iv/udk4iZtZgTSTGlnh/+8svwi1/Aq68WX9/RbN4Mixen95MmweOPp2Tpq7LM7ENwIimm1LfxLl3gggvg0UfT8pIlcOWVsHBh+lDuSJYuTV1YxxwD69alYxs+vNpRmVkH5ERSzOWXQ8+eW5b17Jm6f154IU2RDjBvHlx4YZrxtnfvdLf3FVek8Yb2KgJuuikNqC9eDD//Oey6a7WjMrMOzHNtlTJjRurmeeWV1EK5/PLiA+3Ll6fHyj74YHotWQJr1kCvXnDjjfDii+mb/xFHpLJq2rgRzjkHZs70gLqZldXSubacSFrb+vXpJj6AL38Zrr0W3n8famrS8zpOOgkubW4KswqKSFOdHHhgujfEYyFm1ozWekJi3iBGS1oiqU7S5CLru0uala2fL2lwVj5B0hMFr/clHZytGyHp6Wybn0lSJY/hQ2tIIgC//GVqndx9N1x0EXTtmga0G4wfD//4j+lqqRUrKhPP5s1w2WVQV5fuVJ850wPqZta6IqIiL6AL8AKwH9ANeBIY1qTOV4H/zN6PB2YV2c+BwNKC5UeBI0gP17oLGFMulhEjRkS78f776ee770accEJEz54Rqa0Q8dGPRlxzTev9rhdeiDj88LTvK65ovf2aWacALIgWfN5XskUyEqiLiKURsYk00ePYJnXGkubvArgNOLZIC+N0YCaApH2AXSLi4ewgpwEnV+oAKqLh8GpqYO7cNDD/yCPw4x/D0KGp1QLpUuNBg+CMM1L32PPPp3TTEk0H1G+5BS6+uDLHY2adXtlJG3PoBxTecFEPNJ2w6YM6EbFZ0jpgD2BVQZ3TaExA/bL9FO6zX7FfLmkiMBGgb9++zJs3b5sOos0cemh6AcybR89XXmHwkCHs9tvf0m36dAA27b47i37wA9YdeCDatImoqYEddqDPffex37XX0n3lSjb26cMbhx5Kv9/8hrXDh7P4299mY9++6QozM7MKqGQiKTZ20fQrdbN1JB0GvBURz3yIfabCiCnAFEiD7aNGjSoXb/tz5pmpdfH88/Dgg3R78EE++fd/D/36pct2L700zQO2aBG8+y4APVasoN/998NZZ7HbdddxhMdCzKzCKplI6oEBBcv9geUl6tRLqgF2BVYXrB9P1q1VUL9/mX1uXyT46EfT67zzGssPOghOPRVuuGHrmyHffju1QJxEzKwNVHKM5DFgqKQhkrqRksLsJnVmA2dl78cBD2RjH0jaATiVNLYCQES8BmyQdHg2lnImcGcFj6H9OvpomDIF3nuv+PpS07yYmbWyiiWSiNgMTALmAouBWyNikaTLJH0uq3YdsIekOtLDswovET4aqI+IpU12/RXgWqCOdFXYXZU6hg6h1A2FvtHQzNqIb0js6JpOeQ9pOpcpU7bfKe/NrE20ixsSrQ1MmJCSxqBBaTxl0CAnETNrU5UcbLe2MmGCE4eZVY1bJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLhVNJJJGS1oiqU7S5CLru0uala2fL2lwwbrhkh6WtEjS05J6ZOXzsn0+kb36VPIYzMyseRV7QqKkLsDVwPFAPfCYpNkR8WxBtXOBNRHxEUnjgR8Bp0mqAaYDZ0TEk5L2AN4t2G5CRGynD2E3M+tYKtkiGQnURcTSiNgE3AKMbVJnLDA1e38bcKwkAScAT0XEkwAR8UZEvFfBWM3MbBtVMpH0A14tWK7PyorWiYjNwDpgD2B/ICTNlfS4pIuabHdD1q313SzxmJlZlVSsawso9gEfLaxTAxwFHAq8BdwvaWFE3E/q1lomaWfgduAMYNpWv1yaCEwE6Nu3L/PmzdvW4zAzs2ZUMpHUAwMKlvsDy0vUqc/GRXYFVmfl/xMRqwAkzQEOAe6PiGUAEbFB0s2kLrStEklETAGmANTW1saoUaNa78jMzOwDlezaegwYKmmIpG7AeGB2kzqzgbOy9+OAByIigLnAcEk9swRzDPCspBpJewJI6gr8LfBMBY/BzMzKqFiLJCI2S5pESgpdgOsjYpGky4AFETEbuA64SVIdqSUyPtt2jaSfkpJRAHMi4reSegFzsyTSBbgPuKZSx2BmZuUpNQC2b7W1tbFgga8WNjP7MLKx6dpy9Xxnu5mZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5OJGYmVkuTiRmZpaLE4mZmeXiRGJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl4kRiZma5VDSRSBotaYmkOkmTi6zvLmlWtn6+pMEF64ZLeljSIklPS+qRlY/Ilusk/UySKnkMZmbWvIolEkldgKuBMcAw4HRJw5pUOxdYExEfAa4EfpRtWwNMB86PiI8Do4B3s23+A5gIDM1eoyt1DGZmVl4lWyQjgbqIWBoRm4BbgLFN6owFpmbvbwOOzVoYJwBPRcSTABHxRkS8J2kfYJeIeDgiApgGnFzBYzAzszIqmUj6Aa8WLNdnZUXrRMRmYB2wB7A/EJLmSnpc0kUF9evL7NPMzNpQTQX3XWzsIlpYpwY4CjgUeAu4X9JCYH0L9pl2LE0kdYEB/FXSkpYEXcSewKpt3LatdaRYoWPF25FihY4Vb0eKFTpWvHljHdSSSpVMJPXAgILl/sDyEnXqs3GRXYHVWfn/RMQqAElzgENI4yb9y+wTgIiYAkzJexCSFkREbd79tIWOFCt0rHg7UqzQseLtSLFCx4q3rWKtZNfWY8BQSUMkdQPGA7Ob1JkNnJW9Hwc8kI19zAWGS+qZJZhjgGcj4jVgg6TDs7GUM4E7K3gMZmZWRsVaJBGxWdIkUlLoAlwfEYskXQYsiIjZwHXATZLqSC2R8dm2ayT9lJSMApgTEb/Ndv0V4EZgR+Cu7GVmZlVSya4tImIOMKdJ2aUF798BTi2x7XRSV1bT8gXAJ1o30mbl7h5rQx0pVuhY8XakWKFjxduRYoWOFW+bxKrUk2RmZrZtPEWKmZnl4kRSQNJL2fQrT0hakJX1lnSvpD9nP3evYnzXS1op6ZmCsqLxKflZNpXMU5IOaSfxfl/SsuwcPyHppIJ1F2fxLpF0YhvHOkDS7yQtzqbl+aesvN2d32Ziba/ntoekRyU9mcX7g6x8SDY10p+zqZK6ZeUlp06qYqw3Snqx4NwenJW3h/9nXST9SdJvsuW2P68R4Vf2Al4C9mxS9mNgcvZ+MvCjKsZ3NOky6GfKxQecRLoQQcDhwPx2Eu/3gW8UqTsMeBLoDgwBXgC6tGGs+wCHZO93Bp7PYmp357eZWNvruRWwU/a+KzA/O2e3AuOz8v8EvpK9/yrwn9n78cCsdhDrjcC4IvXbw/+zC4Gbgd9ky21+Xt0iKa9wGpepVHFKloh4kHR1W6FS8Y0FpkXyCLCb0hQzbaZEvKWMBW6JiI0R8SJQR5oL/PNLAAADm0lEQVRmp01ExGsR8Xj2fgOwmDRrQrs7v83EWkq1z21ExF+zxa7ZK4DPkKZGgq3PbbGpk6oZaylV/X8mqT/wWeDabFlU4bw6kWwpgHskLVS6Mx6gb6T7V8h+9qladMWViq8lU9RUy6SsG+D6gq7CdhNv1uT/JOnbaLs+v01ihXZ6brPulyeAlcC9pFbR2khTIzWNqdTUSVWJNSIazu3l2bm9UlL3prFm2vrcXgVcBLyfLe9BFc6rE8mWjoyIQ0gzFl8g6ehqB5RDS6aoqYb/AP4XcDDwGvCTrLxdxCtpJ+B24GsRUWxKng+qFilr03iLxNpuz21EvBcRB5NmoxgJHNBMTFWNt2mskj4BXAx8jDRtU2/gW1n1qsUq6W+BlRGxsLC4mXgqFqsTSYGIWJ79XAncQfqDX9HQVM1+rqxehEWViq8lU9S0uYhYkf1HfR+4hsYulqrHK6kr6YN5RkT8Oitul+e3WKzt+dw2iIi1wDzSeMJuSjNXNI3pg3i15dRJbaog1tFZd2JExEbgBtrHuT0S+Jykl0izq3+G1EJp8/PqRJKR1EvSzg3vSVPZP8OW07icRfubkqVUfLOBM7OrSg4H1jV00VRTk/7jU0jnGFK847MrS4aQnjXzaBvGJdJMC4sj4qcFq9rd+S0Vazs+t3tJ2i17vyNwHGlc53ekqZFg63NbbOqkasX6XMGXCZHGHArPbVX+DiLi4ojoHxGDSYPnD0TEBKpxXlvz6oGO/AL2I13Z8iSwCLgkK98DuB/4c/azdxVjnEnqsniX9O3i3FLxkZqxV5P6op8GattJvDdl8TyV/WHvU1D/kizeJcCYNo71KFIz/yngiex1Uns8v83E2l7P7XDgT1lczwCXZuX7kRJaHfAroHtW3iNbrsvW79cOYn0gO7fPkGbcaLiyq+r/z7I4RtF41Vabn1ff2W5mZrm4a8vMzHJxIjEzs1ycSMzMLBcnEjMzy8WJxMzMcnEiMasCSYNVMCuyWUfmRGJmZrk4kZhVmaT9sudJHFrtWMy2hROJWRVJ+ihpzqxzIuKxasdjti1qylcxswrZizQP0j9ExKJqB2O2rdwiMauedaTnQxxZ7UDM8nCLxKx6NpFmkp0r6a8RcXO1AzLbFk4kZlUUEW9mDyi6V9KbEdHeHlNgVpZn/zUzs1w8RmJmZrk4kZiZWS5OJGZmlosTiZmZ5eJEYmZmuTiRmJlZLk4kZmaWixOJmZnl8v8Bq9zHRo0S39MAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 3))\n",
    "\n",
    "ks = [50, 100, 150, 200, 250, 300, 350, 400]\n",
    "kNdcgs = [0.071506, 0.069570, 0.075285, 0.078022, 0.077795, 0.078540, 0.079428, 0.078083]\n",
    "\n",
    "plt.plot(ks, kNdcgs, \"o--\", color=\"red\")\n",
    "plt.xticks(ks)\n",
    "plt.ylim(bottom=0.06, top=0.09)\n",
    "plt.grid(True, axis=\"y\")\n",
    "\n",
    "plt.ylabel(\"NDCG\")\n",
    "plt.xlabel(\"k\")\n",
    "plt.title(\"Spotify MPD\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEICAYAAABWJCMKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8VPW9//HXJ5OQhH2HkLCLLIICpoBXa12qgNoKtvZqtaW99mJ/1S63rVW7em9vq1dvtbUPq8Wl7lXqynVDqrauKKGgoEiJ7BDZ9wSyzOf3x3yDA2QDkpkk5/18POYxM9/znZnPHMJ5n/M9Z84xd0dERKInI90FiIhIeigAREQiSgEgIhJRCgARkYhSAIiIRJQCQEQkohQAklJmFjOz3WbWrzH7NlJtL5rZJan4rHrq+IuZnVdPn1wzW2pm3VJVVw01PGhm16Xr8+XoKQCkTmEBXH2Lm1lZ0vPDXli6e5W7t3f31Y3Z93CZ2X+b2b0Hfd7Z7v5QY3/W4TCzMcAwd3+mrn7uXgbcB/woJYVJq6QAkDqFBXB7d28PrAY+l9R2yMLSzDJTX2Wr8k3gwQb2fQj4upllNWE9gP5dWysFgByVsCb9qJn92cx2AZea2UlmNtfMtptZiZndWr2QMrNMM3MzGxCePximP29mu8zsLTMbeLh9w/TJZvZPM9thZr83szfM7Gs11HweiTXnS8KWzPzQ/np1fzP7hpn9PXzedjMrNrPxZnaZma0xsw1mdmnSe+aY2c1J0/5gZjlhWk8zey68z1Yze7WOWToZ+HvS+x5rZq+G77TZzB6unubuq4A9wLh6/m3+EuZXkZmNSppeYGZPmtkmM1thZlfU9e9aR82YWcdQ5y1mZnX1leZDASCNYSrwMNAJeBSoBL4LdAdOBiYBl9fx+i8DPwO6ktjK+OXh9jWznsBM4KrwuSuoZcEYhlduBB4KWzIn1vJZJwPzgG7AY+H9TwCOAb4O3GZmbUPf/wUGAscDQ4ABwE/CtKuA5UAPoHeo/xBm1gnoCyxNav4V8CzQBSgAbjvoZUtCTbW5gMS/TdfwHZ4MwRoDngnfLx84C7jKzM5Meu3B/641MrPuwMvAy+7+H67zy7QYCgBpDK+7+/+5e9zdy9x9nru/7e6V7r4cmAF8po7XP+buRe5eQWJYY/QR9D0PWOjuT4dptwCbj/J7LXP3B9y9isQCsB/wn+6+z92fC30GmVkG8A3ge+6+zd13AtcDF4U+FUAfoJ+7l7v736lZ53C/K6mtgkSY5Ln7Xnd/46DX7Ep6XU3edvcnwzy5CegIfAqYAHR091+HmoqBu5NqhoP+XWt5/3wSWywPuft1ddQhzZACQBrDmuQnZjbMzJ41s4/NbCfwXyTWymvzcdLjUqD9EfTtk1xHWAtd24Da67Ih6XEZUOXuWw5qa09irT4beDcM82wnsXbdM/S7AVgFvGRmH5nZVbV83vZw3yGp7QdAFlBkZovMbNpBr+mQ9LqaJM+TKmAdiXnVH+hXXW+o+Ufhuxzy2jp8PtR3ZwP6SjOjAJDGcPAm/x+BxcAx7t4R+DnQ1OPCJSSGSAAI49D5dfRvzGGKDUA5MNTdO4dbJ3fvBODuO8PQyABgCnC1mR2yReTuO0gExbFJbSXu/g13zwOuAGYk7/cAhgPv1lFb3+oHYUslH1hPYuG+LKnezu7ewd0/l1xSA777HcArwLNJw2HSQigApCl0AHYAe8xsOHWP/zeWZ4CxZva5cMTKd0mMuddmAzCgMXZYhjXru4DfmlkPSygws7MBQk2Dw2ftAKrCrSbPkTRcZmZfMrPqINtOYqFcFab1I7EFMq+O8saZ2flhJ/wPSQwZzQPeAsrN7AdhB3bMzEaZWW37Q2r9+iSOXFoOzKre8S0tgwJAmsIPgGkkFjZ/pI4diI3F3TcA/wrcDGwBBgMLgH21vORRoA2w1czeaYQSfkBi7f0dEgv5F0nsDAYYSmIn6W7gDeB37v56Le8zgwOPuBkPzDOzPcATwBVJv4u4BPiTu5fXUdeT4f22kpg/F4R9M5XAOSR2lK8ksb/kjyT2ERyWMNx2GbCRxE7m7MN9D0kP0w57aY3CUS7rgS+6+2vprudwmNlM4P66fgxmZrnAQuBkd69xZ7eZ/TdQ4O5fa5JCpcXTjzuk1TCzSSSGNvYC15I4HLUx1u5Tyt2/1IA+ZSS2LESOmIaApDU5hcRY9GYSvz2Y4u61DQGJRJ6GgEREIkpbACIiEdWs9wF0797dBwwYkO4yRERalPnz529297oOgwaaeQAMGDCAoqKidJchItKimNmqhvRr1gEgIhI1Ty1Yx02zl7J+exl9Oudy1cShTBlT14/aj5wCQESkmXhqwTqufWIRZRWJH4qv217GtU8sAmiSENBOYBGRZuKm2Uv3L/yrlVVUcdPspbW84uhoC0BEJM3KK+P8dckG1m2v+azb62tpP1oKABGRNNq1t4LTbvobW/aUk2EQr+GnWX065zbJZysARERSaOfeCp55t4Q120q5etIwOuRkcemE/ozu15ltu8v5yVOLDxgGys2KcdXEpjnrhwJARKSJuTtvr9jKzHlreG5xCXsr4hzXpyPfP+tYsmIZ/MdZ+y8BQUaG6SggEZHW4u7XV/Dfzy6hQ3YmXxhbwJcK+3J8QSdquhzFlDH5TbbAP5gCQESkEZVXxnlpyQZmFq3honH9mHhcb849Po9u7dsw6bg8ctvE0l3ifgoAEZFG8M8Nu3h03hqeXLCOrXvK6d0xh9LySgDyOuUydUxBPe+QegoAEZEjVFkVJzOWgbtz+QPzWbutlLNG9OLCwr6cOqQHsYymvhT20VEAiIgcBnfnnRVbebRoDW99tIVXfngaOVkxfvuvoynokku39i3nipgKABGRBti8ex+PzlvDX4rWsHJLKR2yM/nc6D6UlleRkxXjhL6d013iYVMAiIjUorwyTml5JZ3btmH11lJumr2U8QO78p0zhzB5ZPPaoXskFAAiIgdJ3qE7aWRvfj11FGP6dua1H51O365t011eo1EAiIgETy1Yx71vrmThmu1kxYzPDu/FOSPzADCzVrXwBwWAiESYu/OP1dsY268LZkbRqq2Ullfy03OHM3VMfovaoXskFAAi0uodfJGVfz91IHv2Ve3fofvYN0+icEBXfnruCLIzM2r8hW5rpAAQkVatpousXDfrAwDGDezKt88Ywog+HQHIyWrZO3UPV70BYGZ9gfuB3kAcmOHuvzOz64B/BzaFrj929+fCa64FLgOqgO+4++zQPgn4HRAD7nL3Gxr364hIKqTysoUAVXHf/6OqjzbtZtuecnbvq2TPvir27KukS7s2nDWiFwA3vvAh67eXsXtfJbv3VTJ/1TYqqg49x3KvjtnMvPykJqu5JWjIFkAl8AN3/4eZdQDmm9mcMO0Wd//f5M5mNgK4CDgO6AP81cyqT3V3G3AWsBaYZ2az3P2DxvgiIpIaDblsobuztyK+fyFcXhlnaO8OALz50WZWbN7Dnn2V7A4L8HZtYnz/7MQpj3/61CKKVm5jT3liAb97XyXDendg1pWnAPDthxfwQcnOA2oaP7Dr/gCYu3wLm3eX0y47kw7ZmTUu/AE27tzXyHOm5ak3ANy9BCgJj3eZ2RKgrqg/H3jE3fcBK8ysGBgXphW7+3IAM3sk9FUAiLQgdV22cMqYfK59YhGPzlt9wIVNurTNYsHPzwbgvjdXMvv9DfuntWsTY3DP9vsDoH12FgVd2tIhJ5N22THaZWfSt8snR9/87LwRlFfFaZ8do312Fu2yY3TMzdo//YlvnXxAbSff8HKNV9pqqoustCSHtQ/AzAYAY4C3gZOBK83sq0ARia2EbSTCYW7Sy9bySWCsOah9fA2fMR2YDtCvX7/DKU9EUqC+yxaeckx3urVrQ7vszMRCOieTjjmfLKB/ef5I/vPzI2mfk0nbrBgZB50v55rJw+r8/JMGdzuseq+aOPSALRZo2oustCQNDgAzaw88DnzP3Xea2e3ALwEP978B/g2oafe5U/MF6A/ZNnP3GcAMgMLCwpq33UQkpT5Yv5N22TH6d2tHjw7ZbNp16PBJ9Rr1ucfnce7xebW+V8+OOU1WZ02qh6VSuc+ipWhQAJhZFomF/0Pu/gSAu29Imn4n8Ex4uhbom/TyAmB9eFxbu4g0M+7OG8Vb+OOrH/Hass1ceGIBN114Aj85Z3iLW6NO5UVWWpKGHAVkwN3AEne/Oak9L+wfAJgKLA6PZwEPm9nNJHYCDwHeIbFlMMTMBgLrSOwo/nJjfRERaTwvLC7h9y8X8/76nfTokM1VE4dy6fj+gNaoW5OGbAGcDHwFWGRmC0Pbj4GLzWw0iWGclcDlAO7+vpnNJLFztxK4wt2rAMzsSmA2icNA73H39xvxu4jIUSgtryQ3K4aZMW/lNvZWVPE/XxjFlDH5ZGceeHy81qhbB3NvvsPshYWFXlRUlO4yRFq1jbv2ct+bK3lw7mpu+/JYThnSnbLyKrIzMw7ZQSstg5nNd/fC+vrpl8AiEfXRpt3c9dpyHv/HOiqq4kwc0ZvuHdoAtPjTHEvDKABEIqgq7lxy59tsKy3nwhML+ManBzGwe7t0lyUppgAQiYB43Hnxgw08vXAdt148hqxYBrdePIZBPdrRvZWf8VJqpwAQacX2VlTxxD/Wcddry1m+eQ8FXXJZs7WUQT3aM25g13SXJ2mmABBppVZvKeWC299g8+5yRuV34vcXj2HyyN5kxmr6TaZEkQJApBVZs7WUf27YxZnDe1HQJZezj+vNecfncdKgbpE5x700nAJApBVYvG4Hf3x1Oc8tKqFzbhZzf3wmWbEMfj11VLpLk2ZMASDSgi1et4Prn1/CG8VbaJ+dyWWnDOTrJw8gS8M80gAKAJEWpqIqzp59lXRu24aquFO8cTfXTh7GxeP7HXDWTZH6KABEWojd+yp55J3V3P36Cj49pDs3fvEETujbmdevPkNr/HJEFAAizdyGnXv50xsreejtVezaW8mEQV059/g++6dr4S9HSgEg0kzUdp3dP7xSzANzVzF5ZB7TTx3ECX07p7tUaSUUACLNQE3X2f3R4+8B8K3Tj+HfThlI/246VYM0Lm07ijQDNzz/4SHX2S2vjHPT7KX06pijhb80CQWASJqUlScW+O7Oxzv31thnfS3X3xVpDBoCEkmhjbv28sLij3n2vRJWbtnDm9ecSSzD6NauDVv2lB/Sv/o6uyJNQQEgkgJvfbSF3730T95esRV3GNKzPReP60d5ZZzcNjF+dt6IFnedXWn5FAAiTWDz7n28sPhjJgzqyjE9O1BRFWfz7nK+c8YQzj0+j2N7dTigv66zK+mgS0KKNJItu/fxwvuJ4Z25y7cQd7h60jD+32mDqf5/phOySSrokpAiKVBRFScrlkFFVZzT/vdv7NpbyaDu7bji9GM49/g8hoY1fS34pTlSAIgcpq17ypkd1vS3l5XzzLc/TVYsg19NHcUxPdozPK+DFvjSIigARBrotWWbmPHqct78aAtVcWdAt7acMyqPyqo4mbEMPn9Cn/rfRKQZUQCI1GJ7aTkvvr+BzwztQa+OOWzcuY/VW0uZfuogzh2Vx3F9OmpNX1o0BYBIkh2lFcz+IDG880bxZirjzq+mjuSS8f2ZMiafC8bma6EvrYYCQCIvHncyMoydeyv41K//SnllnL5dc7ns0wM5b1QfRuZ3BCCWoQW/tC4KAImkHWUVzPlgA8++t54MM+7+2qfomJPFz84bwQkFnRiV30lr+tLqKQCk1arp9Mqd2mbxwFureG3ZJiqqnPzOuXx+dB/cHTPjKxP6p7tskZRRAEirVNPpla99YhGfHd6TpR/v4mv/MoBzj+/DCQVa05foUgBIq3TjC4eeXrmsoor5q7bxxjVnaKEvggJAWpl43HlmUQnrd9R8euWSHXu18BcJ6r0egJn1NbNXzGyJmb1vZt8N7V3NbI6ZLQv3XUK7mdmtZlZsZu+Z2dik95oW+i8zs2lN97Ukyu58dTmZtRyxo9Mri3yiIReEqQR+4O7DgQnAFWY2ArgGeMndhwAvhecAk4Eh4TYduB0SgQH8AhgPjAN+UR0aIkdj8bodXP5AEdv2lJORYdz9tUJu+sLx5GbFDuin0yuLHKjeISB3LwFKwuNdZrYEyAfOB04L3e4D/gZcHdrv98TpD+eaWWczywt957j7VgAzmwNMAv7ciN9HImT1llJ+M2cpTy9cT+e2WSzdsIsJg7rRs0MOU08swDJMp1cWqcNh7QMwswHAGOBtoFcIB9y9xMx6hm75wJqkl60NbbW1H/wZ00lsOdCvX7/DKU8iIh53fvnsBzw4dxWxDONbpw3mm6cNpmNO1gH9pozJ1wJfpA4NDgAzaw88DnzP3XfWsSOtpgleR/uBDe4zgBmQuB5AQ+uT1q/6pGsZGcbGXfv44okFfPfMY+ndKSfdpYm0SA26KLyZZZFY+D/k7k+E5g1haIdwvzG0rwX6Jr28AFhfR7tInSqq4jw4dxWfvvEVijfuBuD3F43h+guO18Jf5Cg05CggA+4Glrj7zUmTZgHVR/JMA55Oav9qOBpoArAjDBXNBs42sy5h5+/ZoU2kRu7Oc4tKOPuWV/npU4sp6JJLVTyxUZih8/KIHLWGDAGdDHwFWGRmC0Pbj4EbgJlmdhmwGrgwTHsOOAcoBkqBrwO4+1Yz+yUwL/T7r+odwiIHi8edi+6cyzsrtjKkZ3vu+mohZw7vqWP4RRqRrgkszcqqLXvo360dAHf8/SO6tmvDF8YW6EycIodB1wSWFmXttlJufvGfPLlwHQ/823hOGdKdb35mcLrLEmnVFACSVtv2lHPbK8Xc/9YqMJh+6iBG5XdKd1kikaAAkLSJx50Lbn+TVVv28IWxBfzHWcfqVA0iKaQAkJSqrIrz7KISzh2VR2Ysg5+dN5z8zm0Z2rtDuksTiRwFgKSEuzPngw3cOHspxRt30yaWweRReZwxrFe6SxOJLAWANLmilVu5/vkPmb9qG4N6tOOOS09k4nFa8IukmwJAmlQ87vz4yUVsL63g+gtGceGJBWTGGvQDdBFpYgoAaXTrt5dxx98/4ocTh9IxJ4vbLz2RvE45tG2jPzeR5kT/I6XR7Cit4A9/L+beN1biDqcP68npQ3syuEf7dJcmIjVQAMhRi8edO19bzm2vFLNrXyVTR+fz/bOPpaBL23SXJiJ1UADIYXlqwbqki6zkcNXEYUwZk8+bH21hbP8u/GjiMEb06ZjuMkWkARQA0mBPLVjHtU8soqyiCoB12/dy9ePvAXDHpSeS2yZW18tFpJlRAKTZgWvUTXvZwtLySsrKqyirqGJvRRV7K+K0z85kQPfEydf+7931B0wvq6hiVH4nzhzei/LK+AEL/2r7KuPcNHuprrwl0gIpANLo0DXqMq5+/D1WbtnDuAFdKauoIjcrxr8c0x2Ax+evpWRHWVhAxymrqKJf17b7T5r2nT8vYPXW0v0L770VVfzL4O7c8q+jATjlf15h657yA2qYMroPv71oDABXPfYueyviB0z/yoT+nDm8F5kZdsjCv9r67WWNN1NEJGUUAGl0/fNLalyj/u1fl+1/PiKvI89999MA3P/WSt5du4NYhtE2K0Z2VozxA7vu7xvLMDrmZtGzQza5bWLkZsU4LunEat8/61iq4k5uVoycNjFyMjPI7/LJuXee+86naZOZkZgebtWnYc7IMPI757KuhoW9zt8j0jLpegApVlZexfOLS5hZtIa5y2u/Hs6j0yeQ2yZGh5wsBoYhmrLyKjJjRlaafkh18BYLQG5WjOsvGKUhIJFmRNcDaIb+tnQj3354Abv2VdK/W1s65mSyc2/lIf3yO+cyflC3Q9rTvZO1eiGfqn0WItK0FABNaOuecp5csI5jerbnM8f2YHheR84a0Ysvfaov4wZ0Zda762tco75q4tA0Vl23KWPytcAXaSUUAI2sKu68umwTfylaw5wPNlBR5Uw7qT+fObYHvTrmcHPYIQtaoxaR9FIANLJp97zD68Wb6dI2i69MGMCXPlXAsN61/zBKa9Qiki4KgKNQVl7FC++X8H/vlnDbl8eS2ybGpRP68+Xx/fjs8F60ydRZL0Wk+VIAHCZ35721O5hZtIZZC9fv36G7emspQ3t3YNLI3ukuUUSkQRQADeTumBkffryL8297g5ysDM4ZmceFhX0ZP7ArGeF4eRGRlkIBUIequPPask3MLFpDl7Zt+NXUUQzr3YHfXTSa04f1pGNOVrpLFBE5YgqAGqzeUspf5q/hsflrKdmxly5ts7hkfH8AzIzzR2unrYi0fAqAYG9FFW1iGWRkGH96cwX3vbmSU4/twc/PG8GZ2qErIq1QpAPA3Vm0LrFD9+mF65nxlUJOGtyNy08dzPRTB5HXSee4EZHWK5IBsLeiioffXs3MojV8+PEusjMzOGdUHl3btQGgd6ecNFcoItL0WmUA1HSO/c+d0Id128ro160tsQzjD38rJr9zLr+aOpLPndBHO3RFJHLqPRuomd0DnAdsdPeRoe064N+BTaHbj939uTDtWuAyoAr4jrvPDu2TgN8BMeAud7+hvuKO5GygNZ2xMjPDaJcdo12bTF67+gxiGcaW3fvo1j77sN5bRKQlaOjZQBuyZ/NeYFIN7be4++hwq174jwAuAo4Lr/mDmcXMLAbcBkwGRgAXh76N7qbZSw85x35l3NlbEeen533ykVr4i0jU1TsE5O6vmtmABr7f+cAj7r4PWGFmxcC4MK3Y3ZcDmNkjoe8Hh11xPWq7OlV5ZZxzRuU19seJiLRYR3Ns45Vm9p6Z3WNmXUJbPrAmqc/a0FZbe6Or7epUumqViMiBjjQAbgcGA6OBEuA3ob2m8yF4He2HMLPpZlZkZkWbNm2qqUudrpo4lNysAy+c0tzPsS8ikg5HFADuvsHdq9w9DtzJJ8M8a4G+SV0LgPV1tNf03jPcvdDdC3v06HHYtU0Zk8/1F4wiv3MuRuLqWrpkoYjIoY7oMFAzy3P3kvB0KrA4PJ4FPGxmNwN9gCHAOyS2AIaY2UBgHYkdxV8+msLronPsi4jUr94AMLM/A6cB3c1sLfAL4DQzG01iGGclcDmAu79vZjNJ7NytBK5w96rwPlcCs0kcBnqPu7/f6N9GREQarN7fAaTTkfwOQEQk6hrzdwAiItIKKQBERCJKASAiElEKABGRiFIAiIhElAJARCSiFAAiIhGlABARiSgFgIhIRCkAREQiSgEgIhJRCgARkYhSAIiIRJQCQEQkohQAIiIRpQAQEYkoBYCISEQpAEREIkoBICISUQoAEZGIUgCIiESUAkBEJKIUACIiEaUAEBGJKAWAiEhEKQBERCJKASAiElEKABGRiFIAiIhElAJARCSi6g0AM7vHzDaa2eKktq5mNsfMloX7LqHdzOxWMys2s/fMbGzSa6aF/svMbFrTfB0REWmohmwB3AtMOqjtGuAldx8CvBSeA0wGhoTbdOB2SAQG8AtgPDAO+EV1aIiISHrUGwDu/iqw9aDm84H7wuP7gClJ7fd7wlygs5nlAROBOe6+1d23AXM4NFRERCSFjnQfQC93LwEI9z1Dez6wJqnf2tBWW/shzGy6mRWZWdGmTZuOsDwREalPY+8EthravI72QxvdZ7h7obsX9ujRo1GLExGRTxxpAGwIQzuE+42hfS3QN6lfAbC+jnYREUmTIw2AWUD1kTzTgKeT2r8ajgaaAOwIQ0SzgbPNrEvY+Xt2aBMRkTTJrK+Dmf0ZOA3obmZrSRzNcwMw08wuA1YDF4buzwHnAMVAKfB1AHffama/BOaFfv/l7gfvWBYRkRQy9xqH4puFwsJCLyoqSncZIiItipnNd/fC+vrpl8AiIhGlABARiSgFgIhIRCkAREQiSgEgIhJRCgARkYhSAIiIRJQCQEQkohQAIiIRpQAQEYkoBYCISEQpAEREIkoBICISUQoAEZGIUgCIiESUAkBEJKIUACIiEaUAEBGJKAWAiEhEKQBERCJKASAiElEKABGRiFIAiIhElAJARCSiFAAiIhGlABARiSgFgIhIRCkAREQiSgEgIhJRCgARkYg6qgAws5VmtsjMFppZUWjramZzzGxZuO8S2s3MbjWzYjN7z8zGNsYXEBGRI9MYWwCnu/tody8Mz68BXnL3IcBL4TnAZGBIuE0Hbm+EzxYRkSPUFENA5wP3hcf3AVOS2u/3hLlAZzPLa4LPFxGRBjjaAHDgRTObb2bTQ1svdy8BCPc9Q3s+sCbptWtD2wHMbLqZFZlZ0aZNm46yPBERqU3mUb7+ZHdfb2Y9gTlm9mEdfa2GNj+kwX0GMAOgsLDwkOkiItI4jmoLwN3Xh/uNwJPAOGBD9dBOuN8Yuq8F+ia9vABYfzSfLyIiR+6IA8DM2plZh+rHwNnAYmAWMC10mwY8HR7PAr4ajgaaAOyoHioSEZHUO5ohoF7Ak2ZW/T4Pu/sLZjYPmGlmlwGrgQtD/+eAc4BioBT4+lF8toiIHKUjDgB3Xw6cUEP7FuDMGtoduOJIP09ERBqXfgksIhJRCgARkYhSAIiIRJQCQEQkohQAIiIRpQAQEYkoBYCISEQpAEREIkoBICISUQoAEZGIUgCIiESUAkBEJKIUACIiEaUAEBGJKAWAiEhEKQBERCJKASAiElEKABGRiFIAiIhElAJARCSiFAAiIhGlABARiSgFgIhIRCkAREQiSgEgIhJRCgARkYhSAIiIRJQCQEQkohQAIiIRpQAQEYmolAeAmU0ys6VmVmxm16T680VEJCGlAWBmMeA2YDIwArjYzEaksgYREUlI9RbAOKDY3Ze7eznwCHB+imsQEREgM8Wflw+sSXq+Fhif3MHMpgPTw9PdZrb0KD6vO7D5KF6fSi2pVmhZ9bakWqFl1duSaoWWVe/R1Nq/IZ1SHQBWQ5sf8MR9BjCjUT7MrMjdCxvjvZpaS6oVWla9LalWaFn1tqRaoWXVm4paUz0EtBbom/S8AFif4hpERITUB8A8YIiZDTSzNsBFwKwU1yAiIqR4CMjdK83sSmA2EAPucff3m/AjG2UoKUVaUq3QsuptSbVCy6q3JdUKLaveJq/V3L3+XiIi0urol8AiIhGlABCD76k8AAAEaklEQVQRiahWEwBmttLMFpnZQjMrCm1dzWyOmS0L913SWN89ZrbRzBYntdVYnyXcGk6X8Z6ZjW0GtV5nZuvC/F1oZuckTbs21LrUzCamuNa+ZvaKmS0xs/fN7LuhvbnO29rqbXbz18xyzOwdM3s31PqfoX2gmb0d5u2j4YAOzCw7PC8O0wekqtZ66r3XzFYkzdvRoT2tfwuhhpiZLTCzZ8Lz1M5bd28VN2Al0P2gthuBa8Lja4D/SWN9pwJjgcX11QecAzxP4ncTE4C3m0Gt1wE/rKHvCOBdIBsYCHwExFJYax4wNjzuAPwz1NRc521t9Ta7+RvmUfvwOAt4O8yzmcBFof0O4P+Fx98C7giPLwIeTfG8ra3ee4Ev1tA/rX8LoYbvAw8Dz4TnKZ23rWYLoBbnA/eFx/cBU9JViLu/Cmw9qLm2+s4H7veEuUBnM8tLTaW11lqb84FH3H2fu68Aikmc8iMl3L3E3f8RHu8ClpD4xXlznbe11VubtM3fMI92h6dZ4ebAGcBjof3geVs9zx8DzjSzmn782STqqLc2af1bMLMC4FzgrvDcSPG8bU0B4MCLZjbfEqeTAOjl7iWQ+I8H9ExbdTWrrb6aTplR10IiVa4Mm8r3JA2nNZtaw2bxGBJrfs1+3h5ULzTD+RuGKBYCG4E5JLZAtrt7ZQ317K81TN8BdEtVrTXV6+7V8/ZXYd7eYmbZB9cbpPpv4bfAj4B4eN6NFM/b1hQAJ7v7WBJnGr3CzE5Nd0FHod5TZqTB7cBgYDRQAvwmtDeLWs2sPfA48D1331lX1xramkO9zXL+unuVu48m8av9ccDwOupJ+7w9uF4zGwlcCwwDPgV0Ba4O3dNWr5mdB2x09/nJzXXU0yS1tpoAcPf14X4j8CSJP9YN1Zt04X5j+iqsUW31NbtTZrj7hvCfKw7cySfDEGmv1cyySCxMH3L3J0Jzs523NdXbnOdvqG878DcSY+Wdzaz6R6TJ9eyvNUzvRMOHEhtVUr2TwrCbu/s+4E80j3l7MvB5M1tJ4qzIZ5DYIkjpvG0VAWBm7cysQ/Vj4GxgMYnTTEwL3aYBT6enwlrVVt8s4KvhKIUJwI7q4Yx0OWhsdCqJ+QuJWi8KRykMBIYA76SwLgPuBpa4+81Jk5rlvK2t3uY4f82sh5l1Do9zgc+S2GfxCvDF0O3geVs9z78IvOxhr2Ua6/0waUXASIypJ8/btPwtuPu17l7g7gNI7NR92d0vIdXztrH3aqfjBgwicaTEu8D7wE9CezfgJWBZuO+axhr/TGLTvoJEml9WW30kNvduIzHeuggobAa1PhBqeS/8MeYl9f9JqHUpMDnFtZ5CYlP4PWBhuJ3TjOdtbfU2u/kLHA8sCDUtBn4e2geRCKFi4C9AdmjPCc+Lw/RBKZ63tdX7cpi3i4EH+eRIobT+LSTVfRqfHAWU0nmrU0GIiERUqxgCEhGRw6cAEBGJKAWAiEhEKQBERCJKASAiElEKABGRiFIAiIhE1P8H7RLy9K9IEjMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "kTimes = [1516, 1732, 1753, 2056, 2244, 2501, 2530, 2746]\n",
    "\n",
    "plt.plot(ks, kTimes, \"o--\")\n",
    "plt.xticks(ks)\n",
    "plt.ylim(bottom=0.0)\n",
    "\n",
    "plt.title(\"Training times (s) per k\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "samplingCols = [\"itemid\", \"albid\", \"artid\",\n",
    "                \"\", \"itemid\", \"albid\", \"artid\",\n",
    "                \"\", \"itemid\", \"albid\", \"artid\"]\n",
    "samplers = [\"uniform\", \"uniform\", \"uniform\",\n",
    "            \"exp\", \"exp\", \"exp\", \"exp\",\n",
    "            \"crossbatch\", \"crossbatch\", \"crossbatch\", \"crossbatch\"]\n",
    "lrs = [0.1, 0.1, 0.1,\n",
    "       0.1, 0.1, 0.1, 0.1,\n",
    "       1.0, 1.0, 1.0, 1.0]\n",
    "maxIters = [100, 100, 100,\n",
    "            100, 100, 100, 100,\n",
    "            10, 10, 10, 10]\n",
    "\n",
    "metadataPaths = [metadataPath, metadataPath, metadataPath,\n",
    "                 metadataPathExp, metadataPathExp, metadataPathExp, metadataPathExp,\n",
    "                 metadataPath, metadataPath, metadataPath, metadataPath]\n",
    "\n",
    "for samplingCol, sampler, lr, maxIter, metadataPath in zip(\n",
    "    samplingCols, samplers, lrs, maxIters, metadataPaths):\n",
    "    \n",
    "    fitStart = time.time()\n",
    "    model = GlintFMPair(\n",
    "        batchSize=256, stepSize=lr, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "        parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=maxIter,\n",
    "        samplingCol=samplingCol, sampler=sampler, filterItemsCol=\"filteritemids\",\n",
    "        loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    "    ).fit(trainFeatures)\n",
    "    fitEnd = time.time()\n",
    "    fitTime = fitEnd - fitStart\n",
    "\n",
    "    hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "    model.destroy()\n",
    "    print(\"{} {}:\".format(sampler, samplingCol))\n",
    "    print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# uniform itemid:\n",
    "# 2484.56083s fit time\n",
    "# 0.012000 hit rate\n",
    "# 0.077789 NDCG\n",
    "# uniform albid:\n",
    "# 2261.73976s fit time\n",
    "# 0.013000 hit rate\n",
    "# 0.078428 NDCG\n",
    "# uniform artid:\n",
    "# 2228.59741s fit time\n",
    "# 0.013000 hit rate\n",
    "# 0.078954 NDCG\n",
    "\n",
    "# exp :\n",
    "# 3248.20180s fit time\n",
    "# 0.009000 hit rate\n",
    "# 0.085025 NDCG\n",
    "# exp itemid:\n",
    "# 2419.82472s fit time\n",
    "# 0.009000 hit rate\n",
    "# 0.084813 NDCG\n",
    "# exp albid:\n",
    "# 6692.71261s fit time\n",
    "# 0.009000 hit rate\n",
    "# 0.085049 NDCG\n",
    "\n",
    "# crossbatch :\n",
    "# 1473.46355s fit time\n",
    "# 0.007000 hit rate\n",
    "# 0.078983 NDCG\n",
    "# crossbatch itemid:\n",
    "# 1450.87150s fit time\n",
    "# 0.008000 hit rate\n",
    "# 0.080761 NDCG\n",
    "# crossbatch albid:\n",
    "# 1513.42223s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.082243 NDCG\n",
    "# crossbatch artid:\n",
    "# 1565.71061s fit time\n",
    "# 0.011000 hit rate\n",
    "# 0.082407 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1254.15832s fit time\n",
      "0.008000 hit rate\n",
      "0.081026 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=256, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=4, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1563.28630s fit time\n",
      "0.010000 hit rate\n",
      "0.086589 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=4, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1606.61577s fit time\n",
      "0.009000 hit rate\n",
      "0.083519 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=5, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "samplingCols = [\"\", \"itemid\", \"albid\", \"artid\"]\n",
    "\n",
    "for samplingCol in samplingCols:\n",
    "    fitStart = time.time()\n",
    "    model = GlintFMPair(\n",
    "        batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "        parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "        samplingCol=samplingCol, sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "        loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    "    ).fit(trainFeatures)\n",
    "    fitEnd = time.time()\n",
    "    fitTime = fitEnd - fitStart\n",
    "\n",
    "    hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "    model.destroy()\n",
    "    print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 1642.53664s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.083997 NDCG\n",
    "# 1651.15506s fit time\n",
    "# 0.009000 hit rate\n",
    "# 0.084216 NDCG\n",
    "# 1596.04214s fit time\n",
    "# 0.008000 hit rate\n",
    "# 0.083720 NDCG\n",
    "# 1602.16093s fit time\n",
    "# 0.010000 hit rate\n",
    "# 0.083944 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\"], ctxitemCols=[])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 4388.87591s fit time\n",
    "# 0.011000 hit rate\n",
    "# 0.089265 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4089.90604s fit time\n",
      "0.013000 hit rate\n",
      "0.089112 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,       \n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                           itemCols=[\"traid\", \"albid\", \"artid\"], ctxitemCols=[])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item-name0125-10.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,       \n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\", \"pyear\"],\n",
    "                           itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"], ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\", \"pyear\"],\n",
    "                              ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item-name-year.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 1477.09409s fit time\n",
    "# 0.012000 hit rate\n",
    "# 0.089227 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1525.40498s fit time\n",
      "0.011000 hit rate\n",
      "0.090719 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,       \n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                           itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"], ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item-name-release.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1502.16055s fit time\n",
      "0.010000 hit rate\n",
      "0.089899 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,       \n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                           itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\",\n",
    "                                     \"danceabilityid\", \"energyid\", \"valenceid\", \"acousticnessid\"],\n",
    "                           ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item-name-release-music1.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2721.11135s fit time\n",
      "0.009000 hit rate\n",
      "0.088851 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,       \n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                           itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\",\n",
    "                                     \"keyid\", \"loudnessid\", \"modeid\", \"tempoid\"],\n",
    "                           ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-item-name-release-music2.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\"], ctxitemCols=[\"prev_traid\"])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[\"prev_traid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-prev.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 3000.97390s fit time\n",
    "# 0.036000 hit rate\n",
    "# 0.123655 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-prev-item.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 2396.39066s fit time\n",
    "# 0.030000 hit rate\n",
    "# 0.131917 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3007.79344s fit time\n",
      "0.033000 hit rate\n",
      "0.132544 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\"], ctxitemCols=[\"prev_traid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True,\n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[\"prev_traid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "modelPath = \"MPD-trans-prev.model\"\n",
    "metadataPath = \"MPD-trans-prev.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 1531.65764s fit time\n",
    "# 0.040000 hit rate\n",
    "# 0.131463 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], sharedItemFeatures=True,\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "metadataPath = \"MPD-trans-prev-item.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 1735.86304s fit time\n",
    "# 0.037000 hit rate\n",
    "# 0.140176 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2189.88675s fit time\n",
      "0.039000 hit rate\n",
      "0.140461 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2232.94610s fit time\n",
      "0.043000 hit rate\n",
      "0.143323 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5385.25767s fit time\n",
      "0.037000 hit rate\n",
      "0.139278 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], coldStartUserCols=[\"traid\"], userCols=[],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-cold-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userColdStartWeighting=\"equi\",\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                              userColdStartWeighting=\"equi\",\n",
    "                              coldStartUserCols=[\"traid\"], userCols=[],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-cold-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "# 0.133758 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6418.01548s fit time\n",
      "0.000000 hit rate\n",
      "0.000000 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userColdStartWeighting=\"one\",\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], coldStartUserCols=[\"traid\"], userCols=[],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-cold-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.10198s fit time\n",
      "0.001000 hit rate\n",
      "0.019462 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = PopRank(filterUserItems=True).fit(trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")))\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg, popRankHitRates = evaluateModel(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    model, withHitRates=True)\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09328s fit time\n",
      "0.008000 hit rate\n",
      "0.049862 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = SAGH(filterUserItems=True).fit(\n",
    "    trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"), \"artid\"))\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "hitRate, ndcg, saghHitRates = evaluateModel(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"), \"artid\"),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    model, withHitRates=True)\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 k\n",
      "0.010000 hit rate\n",
      "0.082170 NDCG\n",
      "50 k\n",
      "0.015000 hit rate\n",
      "0.099304 NDCG\n",
      "100 k\n",
      "0.017000 hit rate\n",
      "0.101515 NDCG\n",
      "150 k\n",
      "0.014000 hit rate\n",
      "0.098603 NDCG\n",
      "200 k\n",
      "0.015000 hit rate\n",
      "0.098978 NDCG\n",
      "250 k\n",
      "0.017000 hit rate\n",
      "0.100175 NDCG\n",
      "300 k\n",
      "0.017000 hit rate\n",
      "0.099544 NDCG\n",
      "350 k\n",
      "0.015000 hit rate\n",
      "0.098489 NDCG\n",
      "400 k\n",
      "0.015000 hit rate\n",
      "0.097493 NDCG\n",
      "450 k\n",
      "0.015000 hit rate\n",
      "0.097460 NDCG\n",
      "500 k\n",
      "0.013000 hit rate\n",
      "0.096539 NDCG\n",
      "1000 k\n",
      "0.011000 hit rate\n",
      "0.093401 NDCG\n"
     ]
    }
   ],
   "source": [
    "ks = [10, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 1000]\n",
    "for k in ks:\n",
    "    hitRate, ndcg = evaluateModel(\n",
    "        valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "        valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "        KNN(filterUserItems=True, k=k),\n",
    "        traindata=trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")))\n",
    "    print(\"{} k\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(k, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.014000 hit rate\n",
      "0.081457 NDCG\n"
     ]
    }
   ],
   "source": [
    "hitRate, ndcg, kHitRates = evaluateModel(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"), \"artid\"),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    KNN(filterUserItems=True, k=100), withHitRates=True,\n",
    "    traindata=trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")))\n",
    "print(\"{:.6f} hit rate\\n{:.6f} NDCG\".format(hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1203.41381s fit time\n",
      "0.006000 hit rate\n",
      "0.070129 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\"], ctxitemCols=[])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg, hitRates = evaluateModel(valqueryFeatures, valFeatures, model, withHitRates=True)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "with open(\"MPD-final-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12477.29742s fit time\n",
      "0.005000 hit rate\n",
      "0.072082 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\"], ctxitemCols=[])\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valData,\n",
    "                              userCols=[\"pid\"], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=1.0, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg, hitRates = evaluateModel(valqueryFeatures, valFeatures, model, withHitRates=True)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "\n",
    "with open(\"MPD-final-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17809.19791s fit time\n",
      "0.032000 hit rate\n",
      "0.122871 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg = evaluateModel(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12449.02096s fit time\n",
      "0.032000 hit rate\n",
      "0.124586 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           userCols=[\"pid\"], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], userCols=[\"pid\"],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "hitRate, ndcg, hitRates = evaluateModel(valqueryFeatures, valFeatures, model, withHitRates=True)\n",
    "print(\"{:.5f}s fit time\\n{:.6f} hit rate\\n{:.6f} NDCG\".format(fitTime, hitRate, ndcg))\n",
    "with open(\"MPD-final-prev-all-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)\n",
    "    \n",
    "model.destroy(terminateOtherClients=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"MPD-final-hitRates.pickle\", \"rb\") as f:\n",
    "    hitRates = pickle.load(f)\n",
    "\n",
    "with open(\"MPD-final-prev-all-hitRates.pickle\", \"rb\") as f:\n",
    "    hitRates2 = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 5))\n",
    "plt.plot(popRankHitRates, color=\"yellowgreen\")\n",
    "plt.plot(saghHitRates, color=\"lime\")\n",
    "plt.plot(kHitRates, color=\"green\")\n",
    "plt.plot(hitRates, color=\"orange\")\n",
    "plt.plot(hitRates2, color=\"red\")\n",
    "\n",
    "yellowgreen_patch = mpatches.Patch(color=\"yellowgreen\",\n",
    "                                   label=\"0.019462 Pop Rank\")\n",
    "green_patch = mpatches.Patch(color=\"lime\",\n",
    "                             label=\"0.049862 SAGH\")\n",
    "dgreen_patch = mpatches.Patch(color=\"green\",\n",
    "                              label=\"0.081457 kNN, k 100\")\n",
    "orange_patch = mpatches.Patch(color=\"orange\",\n",
    "                              label=\"0.072082 FM\")\n",
    "red_patch = mpatches.Patch(color=\"red\",\n",
    "                           label=\"0.124586 FM, trans prev + all\")\n",
    "patches = [red_patch, dgreen_patch, orange_patch,\n",
    "           green_patch, yellowgreen_patch]\n",
    "plt.legend(handles=patches, loc=\"lower right\")\n",
    "\n",
    "plt.ylabel(\"hit rate\")\n",
    "plt.xlabel(\"recommendations\")\n",
    "plt.title(\"Spotify MPD\")\n",
    "\n",
    "plt.savefig(\"MPD-baselines.png\", bbox_inches=\"tight\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final cold-start evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.23967s fit time\n",
      "0.079953 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = PopRank(filterUserItems=True).fit(trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")))\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "ndcg, popRankHitRates = evaluateModelMulti(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    model, withHitRates=True)\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09313s fit time\n",
      "0.096829 NDCG\n"
     ]
    }
   ],
   "source": [
    "fitStart = time.time()\n",
    "model = SAGH(filterUserItems=True).fit(\n",
    "    trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"), \"artid\"))\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "            \n",
    "ndcg, saghHitRates = evaluateModelMulti(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"), \"artid\"),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    model, withHitRates=True)\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.307606 NDCG\n"
     ]
    }
   ],
   "source": [
    "ndcg, kHitRates = evaluateModelMulti(\n",
    "    valSeedsData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")),\n",
    "    KNN(filterUserItems=True, k=100), withHitRates=True,\n",
    "    traindata=trainData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\")))\n",
    "print(\"{:.6f} NDCG\".format(ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4645.22943s fit time\n",
      "0.168570 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\"], ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valCtxData,\n",
    "                              coldStartUserCols=[\"traid\"],\n",
    "                              userCols=[], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-seeds2.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "ndcg = evaluateModelMulti(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels,\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\"], ctxitemCols=[]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, \n",
    "                              queryctxData=valCtxData,\n",
    "                              coldStartUserCols=[\"traid\"],\n",
    "                              userCols=[], ctxitemCols=[])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-seeds2.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "ndcg = evaluateModelMulti(valqueryFeatures, valFeatures, model)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))\n",
    "\n",
    "with open(\"MPD-final-seeds-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)\n",
    "\n",
    "# 57678.36900s fit time\n",
    "# 0.184790 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6202.73424s fit time\n",
      "0.240857 NDCG\n"
     ]
    }
   ],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valCtxData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], coldStartUserCols=[\"traid\"], userCols=[],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-seeds-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=10,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "ndcg, hitRates = evaluateModelMulti(valqueryFeatures, valFeatures, model, withHitRates=True)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))\n",
    "\n",
    "with open(\"MPD-final-seeds-trans-prev-all-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainFeatures = toFeatures(trainData, encoderModels, sharedItemFeatures=True,\n",
    "                           allUserNameWeights=[0.125], userNameCols=[\"pname\"],\n",
    "                           coldStartUserCols=[\"traid\"],\n",
    "                           userCols=[], itemCols=[\"traid\", \"albid\", \"artid\", \"releaseid\"],\n",
    "                           ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"]).coalesce(400).cache()\n",
    "valqueryFeatures = toFeatures(valSeedsData, encoderModels, sharedItemFeatures=True, \n",
    "                              queryctxData=valCtxData,\n",
    "                              allUserNameWeights=[0.125], userNameCols=[\"pname\"], coldStartUserCols=[\"traid\"], userCols=[],\n",
    "                              ctxitemCols=[\"prev_traid\", \"prev_albid\", \"prev_artid\", \"prev_releaseid\"])\n",
    "valFeatures = valData.select(col(\"pid\").alias(\"userid\"), col(\"traid\").alias(\"itemid\"))\n",
    "\n",
    "\n",
    "metadataPath = \"MPD-final-seeds-trans-prev-all.meta\"\n",
    "\n",
    "fitStart = time.time()\n",
    "model = GlintFMPair(\n",
    "    batchSize=1024, stepSize=0.6, linearReg=0.1, factorsReg=0.001, numDims=300,\n",
    "    parameterServerHost=parameterServerHost, numParameterServers=3, maxIter=100,\n",
    "    samplingCol=\"\", sampler=\"crossbatch\", filterItemsCol=\"filteritemids\",\n",
    "    loadMetadata=True, saveMetadata=True, metadataPath=metadataPath\n",
    ").fit(trainFeatures)\n",
    "fitEnd = time.time()\n",
    "fitTime = fitEnd - fitStart\n",
    "\n",
    "ndcg, hitRates = evaluateModelMulti(valqueryFeatures, valFeatures, model, withHitRates=True)\n",
    "model.destroy()\n",
    "print(\"{:.5f}s fit time\\n{:.6f} NDCG\".format(fitTime, ndcg))\n",
    "\n",
    "with open(\"MPD-final-seeds-trans-prev-all-hitRates.pickle\", \"wb\") as f:\n",
    "    pickle.dump(hitRates, f)\n",
    "    \n",
    "# 53675.63951s fit time\n",
    "# 0.255734 NDCG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"MPD-final-seeds-hitRates.pickle\", \"rb\") as f:\n",
    "    hitRates = pickle.load(f)\n",
    "\n",
    "with open(\"MPD-final-seeds-trans-prev-all-hitRates.pickle\", \"rb\") as f:\n",
    "    hitRates2 = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 5))\n",
    "plt.plot(popRankHitRates, color=\"yellowgreen\")\n",
    "plt.plot(saghHitRates, color=\"lime\")\n",
    "plt.plot(kHitRates, color=\"green\")\n",
    "plt.plot(hitRates, color=\"orange\")\n",
    "plt.plot(hitRates2, color=\"red\")\n",
    "\n",
    "yellowgreen_patch = mpatches.Patch(color=\"yellowgreen\",\n",
    "                                   label=\"0.079953 Pop Rank\")\n",
    "green_patch = mpatches.Patch(color=\"lime\",\n",
    "                             label=\"0.096829 SAGH\")\n",
    "dgreen_patch = mpatches.Patch(color=\"green\",\n",
    "                              label=\"0.307607 kNN, k 100\")\n",
    "orange_patch = mpatches.Patch(color=\"orange\",\n",
    "                              label=\"0.184790 FM\")\n",
    "red_patch = mpatches.Patch(color=\"red\",\n",
    "                           label=\"0.255734 FM, trans prev + all\")\n",
    "patches = [dgreen_patch, red_patch, orange_patch,\n",
    "           green_patch, yellowgreen_patch]\n",
    "plt.legend(handles=patches, loc=\"lower right\")\n",
    "\n",
    "plt.ylabel(\"hit rate\")\n",
    "plt.xlabel(\"recommendations\")\n",
    "plt.title(\"Spotify MPD\")\n",
    "\n",
    "plt.savefig(\"MPD-cold-baselines.png\", bbox_inches=\"tight\");"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PySpark3",
   "language": "python",
   "name": "pyspark3kernel"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}