Modeling.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rlf7-Ia7DFYV"
      },
      "source": [
        "#Modeling\n",
        "\n",
        "In this section, we propose several models to predict whether or not a song has been listened to. We begin with the implementation of several baselines, and proceed with a more advanced model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 287,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8LDhbyDqB-hh",
        "outputId": "c55f730e-c28f-4acc-bafc-2b8a62917ded"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: spotipy in /usr/local/lib/python3.7/dist-packages (2.21.0)\n",
            "Requirement already satisfied: requests>=2.25.0 in /usr/local/lib/python3.7/dist-packages (from spotipy) (2.28.1)\n",
            "Requirement already satisfied: six>=1.15.0 in /usr/local/lib/python3.7/dist-packages (from spotipy) (1.15.0)\n",
            "Requirement already satisfied: urllib3>=1.26.0 in /usr/local/lib/python3.7/dist-packages (from spotipy) (1.26.13)\n",
            "Requirement already satisfied: redis>=3.5.3 in /usr/local/lib/python3.7/dist-packages (from spotipy) (4.3.5)\n",
            "Requirement already satisfied: packaging>=20.4 in /usr/local/lib/python3.7/dist-packages (from redis>=3.5.3->spotipy) (21.3)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from redis>=3.5.3->spotipy) (4.1.1)\n",
            "Requirement already satisfied: async-timeout>=4.0.2 in /usr/local/lib/python3.7/dist-packages (from redis>=3.5.3->spotipy) (4.0.2)\n",
            "Requirement already satisfied: importlib-metadata>=1.0 in /usr/local/lib/python3.7/dist-packages (from redis>=3.5.3->spotipy) (4.13.0)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=1.0->redis>=3.5.3->spotipy) (3.10.0)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=20.4->redis>=3.5.3->spotipy) (3.0.9)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.25.0->spotipy) (2022.9.24)\n",
            "Requirement already satisfied: charset-normalizer<3,>=2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.25.0->spotipy) (2.1.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.25.0->spotipy) (2.10)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: nimfa in /usr/local/lib/python3.7/dist-packages (1.4.0)\n",
            "Requirement already satisfied: numpy>=1.7.0 in /usr/local/lib/python3.7/dist-packages (from nimfa) (1.21.6)\n",
            "Requirement already satisfied: scipy>=0.12.0 in /usr/local/lib/python3.7/dist-packages (from nimfa) (1.7.3)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting textdistance\n",
            "  Downloading textdistance-4.5.0-py3-none-any.whl (31 kB)\n",
            "Installing collected packages: textdistance\n",
            "Successfully installed textdistance-4.5.0\n"
          ]
        }
      ],
      "source": [
        "!pip install spotipy\n",
        "!pip install nimfa\n",
        "!pip install textdistance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 438,
      "metadata": {
        "id": "3IK293-hyAgP"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import json\n",
        "import re\n",
        "import os\n",
        "from collections import defaultdict\n",
        "import copy\n",
        "import spotipy\n",
        "import nimfa\n",
        "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
        "from textdistance import jaccard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 168,
      "metadata": {
        "id": "VFEBc8coe7fp"
      },
      "outputs": [],
      "source": [
        "def build_relevant_ds(songs: list):\n",
        "    \"\"\"\n",
        "    Preprocesses data, simultaneously building relevant data structures\n",
        "    \n",
        "    @param data - a data list of playlist dictionaries to preprocess\n",
        "    @returns a list of tracks per user, users per track, watered down data list\n",
        "    \"\"\"\n",
        "    \n",
        "    def process_uri(uri:str):\n",
        "        \"\"\"URI Processing method\"\"\"\n",
        "        return uri.split(\":\")[2]\n",
        "        \n",
        "    print(\"Preprocessing started...\")\n",
        "    tracks_per_user, users_per_track, users_per_artist, artists_per_user = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)\n",
        "    \n",
        "    # Traversing through data and preprocessing\n",
        "    for song in songs:\n",
        "\n",
        "      # Obtaining user\n",
        "      user = song['user']\n",
        "\n",
        "      # obtaining necessary data\n",
        "      track, artist, album = song['track_name'], song['artist_name'], song['album_name']\n",
        "      \n",
        "      # Appending data to data structures\n",
        "      tracks_per_user[user].append(track)\n",
        "      users_per_track[track].append(user)\n",
        "      users_per_artist[artist].append(user)\n",
        "      artists_per_user[user].append(artist)\n",
        "            \n",
        "    return tracks_per_user, users_per_track, users_per_artist, artists_per_user\n",
        "            \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 240,
      "metadata": {
        "id": "yl6pmXmgDpWG"
      },
      "outputs": [],
      "source": [
        "# Reading in training and testing data\n",
        "with open('data_train.json', 'r') as train_reader:\n",
        "  data_train_val = json.load(train_reader)\n",
        "\n",
        "with open('data_test.json', 'r') as test_reader:\n",
        "  data_test= json.load(test_reader) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 244,
      "metadata": {
        "id": "kquJLueVIoiH"
      },
      "outputs": [],
      "source": [
        "data_train, data_val = data_train_val[:600_000], data_train_val[600_000:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 245,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Tm-cp11h6by",
        "outputId": "28cda097-db37-40c9-98dc-3ba04ccb4cd2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preprocessing started...\n"
          ]
        }
      ],
      "source": [
        "val_tracks_per_user, val_users_per_track, val_users_per_artist, val_artists_per_user = build_relevant_ds(data_val)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMZV5f21b4CH"
      },
      "source": [
        "#### Validation, Test Set Construction\n",
        "\n",
        "The Validation and Test set are balanced sets of positive and negative instances, maintaining 1/2 positive user-item pairs (the user listened to the song) and 1/2 negative user-item pairs (the user did not listen to the song)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 246,
      "metadata": {
        "id": "BNCSPXAHPCUS"
      },
      "outputs": [],
      "source": [
        "# Adding negative records to validation data (already exist in test data)\n",
        "val_neg_ex = []\n",
        "\n",
        "# Sampling negatives\n",
        "for ex in data_val:\n",
        "    user = ex['user']\n",
        "    random_song = ex\n",
        "    \n",
        "    # Sampling random songs until one found from different playlist\n",
        "    while random_song['track_name'] in val_tracks_per_user[user]:\n",
        "        random_song = data_val[np.random.randint(0, len(data_val))]\n",
        "    \n",
        "    # Negative example modification\n",
        "    neg_ex = copy.deepcopy(random_song)\n",
        "    neg_ex['listened'] = False\n",
        "\n",
        "    # Group user with negative example\n",
        "    neg_ex['user'] = user\n",
        "    neg_ex['playlist_name'] = ex['playlist_name']\n",
        "    \n",
        "    # Appending\n",
        "    val_neg_ex.append(neg_ex)\n",
        "\n",
        "data_val += val_neg_ex"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 247,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4gy-TSglKEe",
        "outputId": "0a8a143c-b245-4caa-8632-a84d676b173d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preprocessing started...\n"
          ]
        }
      ],
      "source": [
        "test_tracks_per_user, test_users_per_track, test_users_per_artist, test_artists_per_user = build_relevant_ds(data_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 248,
      "metadata": {
        "id": "HmGyo6m_jrrw"
      },
      "outputs": [],
      "source": [
        "# Adding negative records to validation data (already exist in test data)\n",
        "test_neg_ex = []\n",
        "\n",
        "# Sampling negatives\n",
        "for ex in data_test:\n",
        "    user = ex['user']\n",
        "    random_song = ex\n",
        "    \n",
        "    # Sampling random songs until one found from different playlist\n",
        "    while random_song['track_name'] in test_tracks_per_user[user]:\n",
        "        random_song = data_test[np.random.randint(0, len(data_test))]\n",
        "    \n",
        "    # Negative example modification\n",
        "    neg_ex = copy.deepcopy(random_song)\n",
        "    neg_ex['listened'] = False\n",
        "\n",
        "    # Group user with negative example\n",
        "    neg_ex['user'] = user\n",
        "    neg_ex['playlist_name'] = ex['playlist_name']\n",
        "    \n",
        "    # Appending\n",
        "    test_neg_ex.append(neg_ex)\n",
        "\n",
        "data_test += test_neg_ex"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 249,
      "metadata": {
        "id": "bs-xyAGYN7hr"
      },
      "outputs": [],
      "source": [
        "# Storing data as dataframe for easier use\n",
        "train_df = pd.DataFrame.from_records(data_train)\n",
        "val_df = pd.DataFrame.from_records(data_val)\n",
        "test_df = pd.DataFrame.from_records(data_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 250,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hcT7ukUJJuHi",
        "outputId": "ada27b9d-a13b-4a56-b05e-82f0d5f3bde4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Length: 400000, Test Length: 400000\n"
          ]
        }
      ],
      "source": [
        "print(f\"Validation Length: {len(data_val)}, Test Length: {len(data_test)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3mEsLB_dC7gS"
      },
      "source": [
        "##Baseline Models\n",
        "\n",
        "We implement the following baseline models, and attempt to exceed the performance of both:\n",
        "\n",
        "1. Totally Naive Baseline: Prediction by Popularity\n",
        "2. Standard Tier Baseline: Collaborative Filtering\n",
        "3. Supposedly good baseline: Personalized Logistic Regression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 253,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6chZ25OgCqoU",
        "outputId": "39fc2d8e-5eba-4bab-c1e4-c695b93905c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preprocessing started...\n"
          ]
        }
      ],
      "source": [
        "# Necessary data structures\n",
        "tracks_per_user, users_per_track, users_per_artist, artists_per_user = build_relevant_ds(data_train)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h5mQbLFOYPRa"
      },
      "source": [
        "### Motivating Naive Basline: Prediction by Popularity (Unpersonalized Recommendation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 254,
      "metadata": {
        "id": "F_PKbJKGEzbC"
      },
      "outputs": [],
      "source": [
        "def predict_by_pop(tracks: np.array, most_popular: set):\n",
        "  \"\"\"Predicts that a song was listened to if it was among the most popular songs\"\"\"\n",
        "  return [True if track in most_popular else False for track in tracks]\n",
        "\n",
        "def construct_most_popular(users_per_track: list) -> set:\n",
        "    \"\"\"Naive Baseline: Predicts track has been listened to by user if it's in the tracks that account for top 1/2 of listens\"\"\"\n",
        "    # Most popular list init\n",
        "    most_popular = []\n",
        "\n",
        "    # Sorting tracks by popularity\n",
        "    track_popularities = [(len(users_per_track[track]), track) for track in users_per_track]\n",
        "    track_popularities.sort(reverse = True)\n",
        "\n",
        "    # Computing half of total listens\n",
        "    half_tot_popularity = sum([len(users_per_track[track]) for track in users_per_track]) // 2\n",
        "    \n",
        "    # init cumulative popularity\n",
        "    cum_pop, counter = 0,0\n",
        "\n",
        "    # While haven't accounted for half of total listens\n",
        "    while(cum_pop < half_tot_popularity):\n",
        "      # Appending song and adjusting iterators\n",
        "      most_popular.append(track_popularities[counter][1])\n",
        "      cum_pop += track_popularities[counter][0]\n",
        "      counter += 1\n",
        "\n",
        "    return set(most_popular)\n",
        "\n",
        "\n",
        "def acc(labels: np.array, predictions: np.array):\n",
        "  \"\"\"Accuracy computation\"\"\"\n",
        "  return sum(predictions == labels) / len(labels)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PUaKjuifE2dh"
      },
      "outputs": [],
      "source": [
        "most_popular = construct_most_popular(users_per_track)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IT5WToG0HKak",
        "outputId": "4d6e9566-aade-4b4e-cf24-a1fb8ebac086"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Val Accuracy: 0.499755\n"
          ]
        }
      ],
      "source": [
        "val_predictions = predict_by_pop(val_df['track_name'], most_popular)\n",
        "print(f\"Val Accuracy: {acc(val_df['listened'], val_predictions)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NOwHI4SILc0K",
        "outputId": "7b176d2a-75e8-4fe2-8649-cc2c26c89257"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.50026\n"
          ]
        }
      ],
      "source": [
        "test_predictions = predict_by_pop(test_df['track_name'], most_popular)\n",
        "print(f\"Test Accuracy: {acc(test_df['listened'], test_predictions)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sWdXWeibQbGh"
      },
      "source": [
        "### Conclusions from extremely naive Baseline\n",
        "\n",
        "Due to the construction of our validation and test set, prediction by popularity is an entirely ineffective way to build a decision boundary. \n",
        "\n",
        "Although the top 55% (55% was the optimal validation parameter) of Popular songs comprise more of the positive instances, they also comprise more of the equivalent number of randomly sampled negative instances. \n",
        "\n",
        "Since we were just as likely to sample a popular song as a positive instance as we were to sample a popular song as a negative instance, prediction by popularity provides no new information. This motivates that all improvement over random chance can **only** be accounted for by personalization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OzxD3Gl5dXeg"
      },
      "source": [
        "### Basic Personalization Basline: Prediction by Collaborative Filtering (Personalized Recommendation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 415,
      "metadata": {
        "id": "JaSwpZ0BQoo8"
      },
      "outputs": [],
      "source": [
        "def jaccard(set1: set, set2: set):\n",
        "  \"\"\"Jaccard similarity metric\"\"\"\n",
        "  inter = len(set1.intersection(set2))\n",
        "  union = len(set1.union(set2))\n",
        "  return inter / union if union !=0 else 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L8ij6vyUa7iN"
      },
      "outputs": [],
      "source": [
        "def collab_filter_predict(users: list, tracks: list, tracks_per_user: dict, users_per_track:dict):\n",
        "  \"\"\"Semi-Personalized Baseline: prediction on the basis of similar users\"\"\"\n",
        "  predictions = []\n",
        "  iter = 0\n",
        "  for track_user, track in zip(users, tracks):\n",
        "\n",
        "    # Similarity vector\n",
        "    similarities = []\n",
        "\n",
        "    # Obtaining set of user other tracks\n",
        "    user_tracks = tracks_per_user[track_user]\n",
        "    track_users = set(users_per_track[track])\n",
        "\n",
        "    # Seeing if other tracks user listens to are similar\n",
        "    for external_track in user_tracks:\n",
        "\n",
        "      # Ensuring don't use track itself\n",
        "      if external_track == track:\n",
        "        continue\n",
        "\n",
        "      # Obtaining other track users\n",
        "      other_track_users = set(users_per_track[external_track])\n",
        "\n",
        "      # Computing cross track similarity\n",
        "      similarities.append(jaccard(other_track_users, track_users))\n",
        "\n",
        "    predictions.append(True if (len(similarities) != 0 and max(similarities) > 0.005) else False)\n",
        "  \n",
        "  return predictions\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQS4eekHa8FT",
        "outputId": "264fc7d1-4122-472a-93f3-63e854fee5d7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Val Accuracy: 0.663725\n"
          ]
        }
      ],
      "source": [
        "val_predictions = collab_filter_predict(val_df['user'], val_df['track_name'], tracks_per_user, users_per_track)\n",
        "print(f\"Val Accuracy: {acc(val_df['listened'], val_predictions)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GxACLAOPa8Z2",
        "outputId": "52e3a480-c0f6-4295-b485-e50dd6fac9a6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.6981475\n"
          ]
        }
      ],
      "source": [
        "test_predictions = collab_filter_predict(test_df['user'], test_df['track_name'], tracks_per_user, users_per_track)\n",
        "print(f\"Test Accuracy: {acc(test_df['listened'], test_predictions)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3V4Ha81P0-BD"
      },
      "source": [
        "This thresholded collaborative filtering already does pretty well! By leveraging the properties of the validation and test sets (half of the examples are positive, so we can utilize only our 200_000 most positive predictions) let's check if we can do better by utilizing this ranking approach!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fogXbaW7a8kg"
      },
      "outputs": [],
      "source": [
        "def collab_filter_predict_structurally(users: list, tracks: list, tracks_per_user: dict, users_per_track:dict):\n",
        "  \"\"\"Semi-Personalized Baseline: prediction on the basis of similar users\"\"\"\n",
        "  predictions = []\n",
        "  max_similarities = []\n",
        "  for track_user, track in zip(users, tracks):\n",
        "\n",
        "    # Similarity vector\n",
        "    sims = []\n",
        "\n",
        "    # Obtaining set of user other tracks\n",
        "    user_tracks = tracks_per_user[track_user]\n",
        "    track_users = set(users_per_track[track])\n",
        "\n",
        "    # Seeing if other tracks user listens to are similar\n",
        "    for external_track in user_tracks:\n",
        "\n",
        "      # Ensuring don't use track itself\n",
        "      if external_track == track:\n",
        "        continue\n",
        "\n",
        "      # Obtaining other track users\n",
        "      other_track_users = set(users_per_track[external_track])\n",
        "\n",
        "      # Computing cross track similarity\n",
        "      sims.append(jaccard(other_track_users, track_users))\n",
        "\n",
        "    # If other tracks exist for user, append compute\n",
        "    max_similarities.append(max(sims) if len(sims) > 0 else 0)\n",
        "  \n",
        "  sorted_max_sims = sorted(max_similarities, reverse=True)\n",
        "  confidence_thresh = sorted_max_sims[len(max_similarities)//2]\n",
        "\n",
        "  predictions = [True if sim > confidence_thresh else False for sim in max_similarities]\n",
        "  \n",
        "  return predictions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3uaBlK9sa85h",
        "outputId": "d0a2794d-db58-4540-e508-e5ca862e972a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Val Accuracy: 0.6425425\n"
          ]
        }
      ],
      "source": [
        "val_predictions = collab_filter_predict_structurally(val_df['user'], val_df['track_name'], tracks_per_user, users_per_track)\n",
        "print(f\"Val Accuracy: {acc(val_df['listened'], val_predictions)}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GE2zMnX5223V",
        "outputId": "03f614a3-5861-4a97-cd59-02b442486042"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.690045\n"
          ]
        }
      ],
      "source": [
        "test_predictions = collab_filter_predict_structurally(test_df['user'], test_df['track_name'], tracks_per_user, users_per_track)\n",
        "print(f\"Test Accuracy: {acc(test_df['listened'], test_predictions)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nnyGVZI19rc6"
      },
      "source": [
        "Somehow, adding structure did not make our model better. This could be due to several factors. For one, we suffer from a massive sparsity problem: many of our tracks have very few and hence only 0 overlap. This is part of the cold start problem: it is very unlikely that tracks with very few listeners will overlap with other tracks. We must figure out a better way to handle such tracks, as they are an integral part of our recommender system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hjv3TWTI6Bc3"
      },
      "source": [
        "### Model Basline: Logistic Regression\n",
        "We hope to also beat primitive regression modeling, as even with similarity metrics it is not meant to account particularly for interaction"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ufEO9yH0fYBD",
        "outputId": "19fc7a62-8a14-45be-8141-ed2aec0c35b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Preprocessing started...\n"
          ]
        }
      ],
      "source": [
        "tracks_per_user, users_per_track, users_per_artist, artists_per_user, durations_per_user = build_relevant_ds_regression(data_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zvrDc0SlPmGO"
      },
      "outputs": [],
      "source": [
        "def build_relevant_ds_regression(songs: list):\n",
        "    \"\"\"\n",
        "    Preprocesses data, simultaneously building relevant data structures\n",
        "    \n",
        "    @param data - a data list of playlist dictionaries to preprocess\n",
        "    @returns a list of tracks per user, users per track, watered down data list\n",
        "    \"\"\"\n",
        "    \n",
        "    def process_uri(uri:str):\n",
        "        \"\"\"URI Processing method\"\"\"\n",
        "        return uri.split(\":\")[2]\n",
        "        \n",
        "    print(\"Preprocessing started...\")\n",
        "    tracks_per_user, users_per_track, users_per_artist, artists_per_user, durations_per_user = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)\n",
        "    \n",
        "    # Traversing through data and preprocessing\n",
        "    for song in songs:\n",
        "\n",
        "      # Obtaining user\n",
        "      user = song['user']\n",
        "\n",
        "      # obtaining necessary data\n",
        "      track, artist, album, duration = song['track_name'], song['artist_name'], song['album_name'], song['duration_ms']\n",
        "      \n",
        "      # Appending data to data structures\n",
        "      tracks_per_user[user].append(track)\n",
        "      users_per_track[track].append(user)\n",
        "      users_per_artist[artist].append(user)\n",
        "      artists_per_user[user].append(artist)\n",
        "      durations_per_user[user].append(duration)\n",
        "\n",
        "            \n",
        "    return tracks_per_user, users_per_track, users_per_artist, artists_per_user, durations_per_user"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jE2oUNC-6g9j"
      },
      "outputs": [],
      "source": [
        "def advanced_linear_model(df, tracks_per_user, users_per_track, durations_per_user):\n",
        "  \"\"\"Linear Accounts for Jaccard similarity, but also other factors\"\"\"\n",
        "  # Accounts for Jaccard similarity, but also other factors\n",
        "  feature_vector, labels = linear_feature(df, tracks_per_user, users_per_track, durations_per_user)\n",
        "  model = LogisticRegression()\n",
        "  model.fit(feature_vector,labels)\n",
        "  return model, feature_vector\n",
        "\n",
        "def linear_feature(df, tracks_per_user, users_per_track, durations_per_user):\n",
        "  \"\"\"Creates linear model features\"\"\"\n",
        "  feature_vector = []\n",
        "\n",
        "  for index, record in df.iterrows():\n",
        "    track_user = record['user']\n",
        "    track = record['track_name']\n",
        "\n",
        "    # Similarity vector\n",
        "    similarities = []\n",
        "    ex_features = []\n",
        "\n",
        "    # Obtaining set of user other tracks\n",
        "    user_tracks = tracks_per_user[track_user]\n",
        "    track_users = set(users_per_track[track])\n",
        "\n",
        "    # Seeing if other tracks user listens to are similar\n",
        "    for external_track in user_tracks:\n",
        "\n",
        "      # Ensuring don't use track itself\n",
        "      if external_track == track:\n",
        "        continue\n",
        "\n",
        "      # Obtaining other track users\n",
        "      other_track_users = set(users_per_track[external_track])\n",
        "\n",
        "      # Computing cross track similarity\n",
        "      similarities.append(jaccard(other_track_users, track_users))\n",
        "    \n",
        "    # append similarity\n",
        "    ex_features.append(max(similarities) if len(similarities) != 0 else 0)\n",
        "    ex_features.append(int(len(similarities)!=0))\n",
        "\n",
        "    # Appending example features\n",
        "    feature_vector.append(ex_features)\n",
        "\n",
        "  return feature_vector, df['listened']\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OTCS3ts1dBHx"
      },
      "outputs": [],
      "source": [
        "# Adding negative records to validation data (already exist in test data)\n",
        "train_neg_ex = []\n",
        "\n",
        "# Sampling negatives\n",
        "for ex in data_train:\n",
        "    user = ex['user']\n",
        "    random_song = ex\n",
        "    \n",
        "    # Sampling random songs until one found from different playlist\n",
        "    while random_song['track_name'] in val_tracks_per_user[user]:\n",
        "        random_song = data_train[np.random.randint(0, len(data_val))]\n",
        "    \n",
        "    # Negative example modification\n",
        "    neg_ex = copy.deepcopy(random_song)\n",
        "    neg_ex['listened'] = False\n",
        "\n",
        "    # Group user with negative example\n",
        "    neg_ex['user'] = user\n",
        "    \n",
        "    # Appending\n",
        "    train_neg_ex.append(neg_ex)\n",
        "\n",
        "data_train += train_neg_ex"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B3RuIUFBdlQR"
      },
      "outputs": [],
      "source": [
        "reg_train_df = pd.DataFrame.from_records(data_train).iloc[np.random.randint(0, len(data_train), 100_000)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hT779XZqdqEc"
      },
      "outputs": [],
      "source": [
        "model, feature_vector = advanced_linear_model(reg_train_df, tracks_per_user, users_per_track, durations_per_user)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eLnZ2hxohOWS",
        "outputId": "514d6d0b-1443-4737-e4c9-23188ed43213"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Train Accuracy: 0.50202\n"
          ]
        }
      ],
      "source": [
        "print(f\"Train Accuracy: {acc(model.predict(feature_vector), reg_train_df['listened'])}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rCxuiMb7kwCU"
      },
      "outputs": [],
      "source": [
        "test_features, test_labels = linear_feature(test_df, tracks_per_user, users_per_track, durations_per_user)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e1Zi51a2kw4W",
        "outputId": "8a5b4aae-a59c-40cf-f999-65e8ce6e3910"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.4986575\n"
          ]
        }
      ],
      "source": [
        "print(f\"Test Accuracy: {acc(model.predict(test_features), test_labels)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mkqmhkEUtFHd"
      },
      "source": [
        "## The Actual Model: (CF+CBM)++\n",
        "\n",
        "Our actual model upgrades the Personalization effect. We opt to ensemble 2 different collaborative filtering models, which we will weigh by their validation accuracies, to compute a new set of predictions for items for which collaborative data exists. The first one uses user-item interaction, whereas the other utilizes interaction with the metadata (artist) in order to make more eudcated predictions regarding whether or not the user will enjoy the track. Holistically, the 2 models together outperform the sum of their parts. When collaborative data does not exist, we opt for content based recommendation, attempting to match the user playlist name with the song or album title via string jaccard similarity. This also yields a slight increase in accuracy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 494,
      "metadata": {
        "id": "OB-bitd6rHbA"
      },
      "outputs": [],
      "source": [
        "def collab_filter_predict(users: list, tracks: list, tracks_per_user: dict, users_per_track:dict, title_content_preds: list):\n",
        "  \"\"\"Semi-Personalized Baseline: prediction on the basis of similar users\"\"\"\n",
        "  predictions = []\n",
        "  iter = 0\n",
        "  for track_user, track, pred in zip(users, tracks, title_content_preds):\n",
        "\n",
        "    # Similarity vector\n",
        "    similarities = []\n",
        "\n",
        "    # Obtaining set of user other tracks\n",
        "    user_tracks = tracks_per_user[track_user]\n",
        "    print(user_tracks)\n",
        "    track_users = set(users_per_track[track])\n",
        "\n",
        "    # Seeing if other tracks user listens to are similar\n",
        "    for external_track in user_tracks[:20]:\n",
        "\n",
        "      # Ensuring don't use track itself\n",
        "      if external_track == track:\n",
        "        continue\n",
        "\n",
        "      # Obtaining other track users\n",
        "      other_track_users = set(users_per_track[external_track])\n",
        "\n",
        "      # Computing cross track similarity\n",
        "      similarities.append(jaccard(other_track_users, track_users))\n",
        "\n",
        "    similarity_max = max(similarities) if len(similarities) != 0 else pred\n",
        "    predictions.append(similarity_max)\n",
        "  \n",
        "  return predictions\n",
        "\n",
        "\n",
        "def artist_collab_filter_predict(users: list, artists: pd.Series, artists_per_user: dict, users_per_artist:dict, title_content_preds: list):\n",
        "  \"\"\"Semi-Personalized Baseline: prediction on the basis of similar artist\"\"\"\n",
        "  predictions = []\n",
        "  iter = 0\n",
        "  for track_user, track_artist, content_pred in zip(users, artists, title_content_preds):\n",
        "    # Similarity vector\n",
        "    similarities = []\n",
        "\n",
        "    # Obtaining set of user other tracks\n",
        "    user_artists = artists_per_user[track_user]\n",
        "    artists_users = set(users_per_artist[track_artist])\n",
        "\n",
        "    # Seeing if other tracks user listens to are similar\n",
        "    for external_artist in user_artists[:5]:\n",
        "\n",
        "      # Ensuring don't use track itself\n",
        "      if external_artist == track_artist:\n",
        "        continue\n",
        "\n",
        "      # Obtaining other track users\n",
        "      other_artist_users= set(users_per_artist[external_artist])\n",
        "\n",
        "      # Computing cross track similarity\n",
        "      similarities.append(jaccard(other_artist_users, artists_users))\n",
        "\n",
        "    # Personalized recommendation when data, \n",
        "    similarity_max = max(similarities) if len(similarities) != 0 else content_pred\n",
        "    predictions.append(similarity_max)\n",
        "  \n",
        "  return predictions\n",
        "\n",
        "\n",
        "def title_content_model(playlist_names: str, track_names: str, album_names: str):\n",
        "  \"\"\"Attempting modeling utilizing sentiment analysis\"\"\"\n",
        "  predictions = []\n",
        "  for playlist_name, track_name, album_name in zip(playlist_names, track_names, album_names):\n",
        "    #  Triviality\n",
        "    if album_name == playlist_name or track_name == playlist_name:\n",
        "      predictions.append(1)\n",
        "    else:\n",
        "      # Prediction by jaccard distance based on playlist title\n",
        "      min_text_distance = min(jaccard.distance(playlist_name, track_name), jaccard.distance(playlist_name, album_name))\n",
        "      predictions.append((1-min_text_distance) / 20)\n",
        "\n",
        "  return predictions\n",
        "        \n",
        "\n",
        "  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 404,
      "metadata": {
        "id": "6TeSrzkvJe-8"
      },
      "outputs": [],
      "source": [
        "def ensemble_predictions_tune(predictions1: np.array, a1: float, predictions2: np.array, a2: float, val_labels: pd.Series):\n",
        "  \"\"\"\"Ensembles predictions from 3 different models, leverages dataset information to predict 1/2 positives\"\"\"\n",
        "  new_pred = predictions1*a1 + predictions2 * a2\n",
        "  max_acc, max_thresh = 0,0\n",
        "\n",
        "  for threshold in np.arange(0, 0.2, 0.0025):\n",
        "    # Computing accuracy\n",
        "    accuracy = acc(new_pred > threshold, val_labels)\n",
        "    \n",
        "    # Updating threshold if need be\n",
        "    if accuracy > max_acc:\n",
        "      max_acc = accuracy\n",
        "      max_thresh = threshold\n",
        "\n",
        "  # Returning threshold\n",
        "  return max_acc, max_thresh\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "title_content_preds = title_content_model(val_df['playlist_name'], val_df['track_name'], val_df['album_name'])"
      ],
      "metadata": {
        "id": "P6o7fHZzP9-d"
      },
      "execution_count": 439,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "val_max_sims_artist = artist_collab_filter_predict(val_df['user'], val_df['artist_name'], artists_per_user, users_per_artist, title_content_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-6PfZHITUll",
        "outputId": "1b19d12a-1f37-42d8-9cef-9c3e42e5e4dc"
      },
      "execution_count": 333,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20000\n",
            "40000\n",
            "60000\n",
            "80000\n",
            "100000\n",
            "120000\n",
            "140000\n",
            "160000\n",
            "180000\n",
            "200000\n",
            "220000\n",
            "240000\n",
            "260000\n",
            "280000\n",
            "300000\n",
            "320000\n",
            "340000\n",
            "360000\n",
            "380000\n",
            "400000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "val_max_sims_track = collab_filter_predict(val_df['user'], val_df['track_name'], tracks_per_user, users_per_track, title_content_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TMwWbA8KgtUV",
        "outputId": "b3983a6b-ffa6-4012-fc8d-01060b1de274"
      },
      "execution_count": 369,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iter: 30000\n",
            "iter: 60000\n",
            "iter: 90000\n",
            "iter: 120000\n",
            "iter: 150000\n",
            "iter: 180000\n",
            "iter: 210000\n",
            "iter: 240000\n",
            "iter: 270000\n",
            "iter: 300000\n",
            "iter: 330000\n",
            "iter: 360000\n",
            "iter: 390000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "acc_artist = acc(np.array(val_max_sims_artist) > 0.01, val_df['listened'])"
      ],
      "metadata": {
        "id": "sQiXXbN6hupZ"
      },
      "execution_count": 379,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "acc_track = acc(np.array(val_max_sims_track) > 0.01, val_df['listened'])"
      ],
      "metadata": {
        "id": "-ZN4Wlu5mUG0"
      },
      "execution_count": 380,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuning predictions\n",
        "new_val_acc, new_val_threshold = ensemble_predictions_tune(np.array(val_max_sims_artist), acc_artist, np.array(val_max_sims_track), acc_track, val_df['listened'])"
      ],
      "metadata": {
        "id": "bYb7qol9rl1d"
      },
      "execution_count": 405,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_val_threshold"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T54Cr3aGxVyV",
        "outputId": "3b648ce3-d8ca-49c4-8ffd-56936416049e"
      },
      "execution_count": 436,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.015"
            ]
          },
          "metadata": {},
          "execution_count": 436
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "new_val_acc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jso-8Vj_r98L",
        "outputId": "060e9754-9e4a-46e2-d0a6-5ef7554054fc"
      },
      "execution_count": 408,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7629075"
            ]
          },
          "metadata": {},
          "execution_count": 408
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "title_content_preds_test = title_content_model(test_df['playlist_name'], test_df['track_name'], test_df['album_name'])"
      ],
      "metadata": {
        "id": "MPz8ldTisP5h"
      },
      "execution_count": 410,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_max_sims_artist = artist_collab_filter_predict(test_df['user'], test_df['artist_name'], artists_per_user, users_per_artist, title_content_preds_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1D1auEJPtjMH",
        "outputId": "f2f89b4b-1712-4eeb-af85-4eba6fafa262"
      },
      "execution_count": 417,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iter20000\n",
            "iter40000\n",
            "iter60000\n",
            "iter80000\n",
            "iter100000\n",
            "iter120000\n",
            "iter140000\n",
            "iter160000\n",
            "iter180000\n",
            "iter200000\n",
            "iter220000\n",
            "iter240000\n",
            "iter260000\n",
            "iter280000\n",
            "iter300000\n",
            "iter320000\n",
            "iter340000\n",
            "iter360000\n",
            "iter380000\n",
            "iter400000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_acc_m1 = acc(np.array(test_max_sims_artist) > 0.01, test_df['listened'])\n",
        "test_acc_m1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U761qiaPwJA3",
        "outputId": "c9f31882-caae-42e7-e40c-366f66fbe830"
      },
      "execution_count": 430,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.756675"
            ]
          },
          "metadata": {},
          "execution_count": 430
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_max_sims_track = collab_filter_predict(test_df['user'], test_df['track_name'], tracks_per_user, users_per_track, title_content_preds_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xLW0x6Hit2ts",
        "outputId": "ff505d15-7b53-4cb5-bae5-ce1da508ad1f"
      },
      "execution_count": 431,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iter: 30000\n",
            "iter: 60000\n",
            "iter: 90000\n",
            "iter: 120000\n",
            "iter: 150000\n",
            "iter: 180000\n",
            "iter: 210000\n",
            "iter: 240000\n",
            "iter: 270000\n",
            "iter: 300000\n",
            "iter: 330000\n",
            "iter: 360000\n",
            "iter: 390000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_acc_m2 = acc(np.array(test_max_sims_track) > 0.01, test_df['listened'])\n",
        "test_acc_m2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ogaMYkEcwjkT",
        "outputId": "01eae559-7e66-4396-de00-147e771abffa"
      },
      "execution_count": 435,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6857975"
            ]
          },
          "metadata": {},
          "execution_count": 435
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_acc_ensemble = acc(((acc_track * np.array(test_max_sims_track) + acc_artist * np.array(test_max_sims_artist) ) > new_val_threshold), test_df['listened'])\n",
        "test_acc_ensemble"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c05Qb9M1xMOt",
        "outputId": "aa53a82f-4cb4-488d-d523-267400a2902b"
      },
      "execution_count": 437,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7641325"
            ]
          },
          "metadata": {},
          "execution_count": 437
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Let's Generate Some Predictions using both Artist and Song Similarity!\n",
        "These are to check the reasonability of our model!"
      ],
      "metadata": {
        "id": "kXsqrjcJculx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example data\n",
        "some_tracks =  [{'pos': 86,\n",
        "  'artist_name': 'Justin Bieber',\n",
        "  'track_uri': 'spotify:track:23vVELyLQ5VgRChKLFj12d',\n",
        "  'artist_uri': 'spotify:artist:2bNoMMVO2QO6vySQvjn50L',\n",
        "  'track_name': 'Baby',\n",
        "  'album_uri': 'spotify:album:3UlI6o0XhIv0Jh6DCQo35G',\n",
        "  'duration_ms': 227470,\n",
        "  'album_name': 'Rose Tint',\n",
        "  'playlist_name': 'BEST',\n",
        "  'playlist_mod_at': 1475452800,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 41851,\n",
        "  'listened': True},\n",
        " {'pos': 6,\n",
        "  'artist_name': 'Louis Armstrong',\n",
        "  'track_uri': 'spotify:track:7LRmY1B3Z2N5gXHXFJ5n2a',\n",
        "  'artist_uri': 'spotify:artist:1uNFoZAHBGtllmzznpCI3s',\n",
        "  'track_name': 'All I Want For Christmas Is You (SuperFestive!) Duet with Mariah Carey',\n",
        "  'album_uri': 'spotify:album:1wEnjjF0dtWufdTzWeQAm2',\n",
        "  'duration_ms': 240333,\n",
        "  'album_name': 'Under The Mistletoe',\n",
        "  'playlist_name': 'Happy Holidays ',\n",
        "  'playlist_mod_at': 1480723200,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 40554,\n",
        "  'listened': True},\n",
        " {'pos': 209,\n",
        "  'artist_name': 'Louis Armstrong',\n",
        "  'track_uri': 'spotify:track:2E6JyQDG81p96JgJDvX1nl',\n",
        "  'artist_uri': 'spotify:artist:7n2wHs1TKAczGzO7Dd2rGr',\n",
        "  'track_name': 'As Long As You Love Me',\n",
        "  'album_uri': 'spotify:album:6FLZDJq4UuwqcaQlI4XCP1',\n",
        "  'duration_ms': 186960,\n",
        "  'album_name': 'West End Blues',\n",
        "  'playlist_name': '2016 jams',\n",
        "  'playlist_mod_at': 1488844800,\n",
        "  'playlist_num_followers': 3,\n",
        "  'user': 21135,\n",
        "  'listened': True},\n",
        " {'pos': 153,\n",
        "  'artist_name': 'Louis Armstrong',\n",
        "  'track_uri': 'spotify:track:29U7stRjqHU6rMiS8BfaI9',\n",
        "  'artist_uri': 'spotify:artist:19eLuQmk9aCobbVDHc6eek',\n",
        "  'track_name': 'What A Wonderful World - Single Version',\n",
        "  'album_uri': 'spotify:album:6mmv0gwumlFGWDGJXF4yEv',\n",
        "  'duration_ms': 139226,\n",
        "  'album_name': 'What A Wonderful World',\n",
        "  'playlist_name': 'Swing',\n",
        "  'playlist_mod_at': 1440460800,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 37306,\n",
        "  'listened': True},\n",
        " {'pos': 11,\n",
        "  'artist_name': 'Arctic Monkeys',\n",
        "  'track_uri': 'spotify:track:3xAXYCtd98G5G0SSJAHtqd',\n",
        "  'artist_uri': 'spotify:artist:1URnnhqYAYcrqrcwql10ft',\n",
        "  'track_name': 'Do I Wanna Know?',\n",
        "  'album_uri': 'spotify:album:1HSyuTHvLXMWyPJQGnQTLw',\n",
        "  'duration_ms': 151614,\n",
        "  'album_name': 'AM',\n",
        "  'playlist_name': 'SQUAD',\n",
        "  'playlist_mod_at': 1506988800,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 19733,\n",
        "  'listened': True},\n",
        " {'pos': 8,\n",
        "  'artist_name': 'Cold War Kids',\n",
        "  'track_uri': 'spotify:track:3IXRdLsQib8m0hBbQpe7T8',\n",
        "  'artist_uri': 'spotify:artist:6VDdCwrBM4qQaGxoAyxyJC',\n",
        "  'track_name': 'Hang Me Up To Dry',\n",
        "  'album_uri': 'spotify:album:1LTbo93CjLo48yNP8Ysaz5',\n",
        "  'duration_ms': 218786,\n",
        "  'album_name': 'Robbers & Cowards',\n",
        "  'playlist_name': 'Marathon',\n",
        "  'playlist_mod_at': 1416614400,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 1189,\n",
        "  'listened': True},\n",
        " {'pos': 32,\n",
        "  'artist_name': 'Matchbox Twenty',\n",
        "  'track_uri': 'spotify:track:4dZhQj20JbKlD9oR0X8kjZ',\n",
        "  'artist_uri': 'spotify:artist:3Ngh2zDBRPEriyxQDAMKd1',\n",
        "  'track_name': 'Bright Lights',\n",
        "  'album_uri': 'spotify:album:7fv4OVYUiixcwCGDRwvcH8',\n",
        "  'duration_ms': 234426,\n",
        "  'album_name': 'More Than You Think You Are',\n",
        "  'playlist_name': '4th of July',\n",
        "  'playlist_mod_at': 1503014400,\n",
        "  'playlist_num_followers': 1,\n",
        "  'user': 41157,\n",
        "  'listened': True}]"
      ],
      "metadata": {
        "id": "CwDZ6dIwFqaL"
      },
      "execution_count": 575,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_predictions(some_tracks: list, data_train: pd.DataFrame):\n",
        "  \"\"\"Generates predictions using hybrid user artist model\"\"\"\n",
        "  # Prediction array\n",
        "  predictions = []\n",
        "\n",
        "  # Encriching data, building data structures\n",
        "  tracks_per_user_g, users_per_track_g, users_per_artist_g, artists_per_user_g, artists_per_song = build_relevant_ds_generate(data_train[:200_000])\n",
        "\n",
        "  # For each track building recommendations by finding a similar user\n",
        "  for track in some_tracks:\n",
        "    artist = track['artist_name']\n",
        "    songs = {track['track_name'] for track in some_tracks}\n",
        "    sims = []\n",
        "\n",
        "    # finding most similar user who has also listened to artist\n",
        "    for ext_user in users_per_artist_g[artist]:\n",
        "      sims.append((jaccard(songs, set(tracks_per_user_g[user])), ext_user))\n",
        "\n",
        "    # If have found similar user\n",
        "    if len(sims) != 0:\n",
        "      closest_user = max(sims)\n",
        "\n",
        "      # Randomly selecting from closest user tracks\n",
        "      closest_user_tracks = tracks_per_user_g[closest_user[1]]\n",
        "\n",
        "      # Predicting novel songs\n",
        "      choice = predictions[0][0] if len(predictions) > 0 else \"\"\n",
        "      s_artist = predictions[0][0] if len(predictions) > 0 else \"\"\n",
        "      iter = 0\n",
        "\n",
        "      while (choice, s_artist) in predictions and iter < 5:\n",
        "        iter += 1\n",
        "        choice = closest_user_tracks[np.random.randint(len(closest_user_tracks))]\n",
        "        s_artist = artists_per_song[choice][0] if choice in artists_per_song else [\"\"]\n",
        "      \n",
        "      if(iter < 5):\n",
        "        predictions.append((choice, s_artist))\n",
        "\n",
        "  return predictions[1:11]\n",
        "\n",
        "\n",
        "def build_relevant_ds_generate(songs: list):\n",
        "    \"\"\"\n",
        "    Preprocesses data, simultaneously building relevant data structures\n",
        "    \n",
        "    @param data - a data list of playlist dictionaries to preprocess\n",
        "    @returns a list of tracks per user, users per track, watered down data list\n",
        "    \"\"\"\n",
        "    \n",
        "    def process_uri(uri:str):\n",
        "        \"\"\"URI Processing method\"\"\"\n",
        "        return uri.split(\":\")[2]\n",
        "        \n",
        "    print(\"Preprocessing started...\")\n",
        "    tracks_per_user, users_per_track, users_per_artist, artists_per_user, artists_per_song = defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list), defaultdict(list)\n",
        "    \n",
        "    # Traversing through data and preprocessing\n",
        "    for song in songs:\n",
        "\n",
        "      # Obtaining user\n",
        "      user = song['user']\n",
        "\n",
        "      # obtaining necessary data\n",
        "      track, artist, album = song['track_name'], song['artist_name'], song['album_name']\n",
        "      \n",
        "      # Appending data to data structures\n",
        "      tracks_per_user[user].append(track)\n",
        "      users_per_track[track].append(user)\n",
        "      users_per_artist[artist].append(user)\n",
        "      artists_per_user[user].append(artist)\n",
        "      artists_per_song[track].append(artist)\n",
        "            \n",
        "    return tracks_per_user, users_per_track, users_per_artist, artists_per_user, artists_per_song\n",
        "            "
      ],
      "metadata": {
        "id": "D8LQshGqIePa"
      },
      "execution_count": 603,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "generate_predictions(some_tracks, data_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AlvRjkSvIfrJ",
        "outputId": "fc217284-920e-4496-efd2-bf5cd0253d7b"
      },
      "execution_count": 604,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preprocessing started...\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[('Put On Your Sunday Clothes - 1969 Soundtrack Recording',\n",
              "  'Michael Crawford'),\n",
              " ('Born To Be Wild', 'Steppenwolf'),\n",
              " ('If You Wannabe My Lover', 'Groovio'),\n",
              " ('Hypnus', 'Moon Taxi'),\n",
              " ('What The Water Gave Me', 'Florence + The Machine'),\n",
              " ('Closing Time', 'Semisonic')]"
            ]
          },
          "metadata": {},
          "execution_count": 604
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Result Plots and Final Conclusions\n",
        "In Conclusion, our method strongly outperformed the basline, as can be seen in the plots below. An inexact recreation of it (one which threw out user data) also did quite a good job of recommending songs!"
      ],
      "metadata": {
        "id": "02nJhk1zc5Qx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "EZS_2449Nazx"
      },
      "execution_count": 561,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_labels_val = ['Pop. Heuristic', 'Logistic Regression', 'CF', '(CF+CBM)++']\n",
        "y_labels_val = [0.499755,  0.5, 0.663725, 0.7629075]\n",
        "\n",
        "x_labels_test = ['Popularity Model', 'Logistic Regression', 'CF', '(CF+CBM)++']\n",
        "y_labels_test = [0.50026, 0.4986575, 0.6981475, 0.7641325]"
      ],
      "metadata": {
        "id": "0-JN71ChWAJg"
      },
      "execution_count": 573,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.bar(x_labels_val, y_labels_val, color ='maroon',\n",
        "        width = 0.4)\n",
        " \n",
        "plt.xlabel(\"Method\")\n",
        "plt.ylabel(\"Validation Accuracy\")\n",
        "plt.title(\"Validation Accuracy Across Baselines and Final Method\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "DjbvAWxcbnLJ",
        "outputId": "fdd62c77-6bfe-414a-d1ec-928a2494ab11"
      },
      "execution_count": 567,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.bar(x_labels_test, y_labels_test, color ='maroon',\n",
        "        width = 0.4)\n",
        " \n",
        "plt.xlabel(\"Method\")\n",
        "plt.ylabel(\"Test Accuracy\")\n",
        "plt.title(\"Test Accuracy Across Baselines and Final Method\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "-73KoZu9b53J",
        "outputId": "fa876b5f-6375-4467-fa65-1d53f1e4549d"
      },
      "execution_count": 574,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "machine_shape": "hm",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}