Upload 10 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+recommendation_module_project/data/processed/artist_album.csv filter=lfs diff=lfs merge=lfs -text
+recommendation_module_project/data/processed/playlists.csv filter=lfs diff=lfs merge=lfs -text

recommendation_module_project/data/processed/artist_album.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:332fcb8cb088acbc5390f00e451b33575dadc63b467e4859dd9e532ef5819f73
+size 106221612

recommendation_module_project/data/processed/playlists.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc20e6149aea14d381a19507b256dce9ecb56bf987af6f37ec59f70f3ee3d060
+size 206998675

recommendation_module_project/data/raw/data/playlists_100.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df1c572599da09a2b9d22f424bf20ef954c5e2d368501ca6400e3fae13f20b2c
+size 82850937

recommendation_module_project/data/raw/data/playlists_150.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1c69aea4f0cb5b97e7539d567119f1b72346f83333ccca3d0feb79c249bdb84
+size 82830471

recommendation_module_project/data/raw/data/playlists_200.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb3dd72495402bbf4ddf5ea270d042965ee3ed2b7ea7b7161c7ccb6db07654e5
+size 83074496

recommendation_module_project/data/raw/data/playlists_50.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60d4db353205c231cbae85d0e6140fdb5f38c2d03dfd4a71b2be81e8ff581ca2
+size 82772449

recommendation_module_project/model.ipynb

@@ -0,0 +1,1076 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "uq9k8YYUKjnp"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import urllib.request\n",
+        "import zipfile\n",
+        "import json\n",
+        "import pandas as pd\n",
+        "import time\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import torch.nn as nn\n",
+        "import torch.nn.functional as F\n",
+        "import torch.optim as optim\n",
+        "from torch.utils.data import DataLoader, TensorDataset\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import matplotlib.pyplot as plt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "L5h3Tsa0LIoo"
+      },
+      "outputs": [],
+      "source": [
+        "def unzip_archive(filepath, dir_path):\n",
+        "  with zipfile.ZipFile(f\"{filepath}\", 'r') as zip_ref:\n",
+        "    zip_ref.extractall(dir_path)\n",
+        "\n",
+        "unzip_archive(os.getcwd() + '/data/raw/spotify_million_playlist_dataset.zip', os.getcwd() + '/data/raw/playlists')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import shutil\n",
+        "\n",
+        "def make_dir(directory):\n",
+        "    if os.path.exists(directory):\n",
+        "        shutil.rmtree(directory)\n",
+        "        os.makedirs(directory)\n",
+        "    else:\n",
+        "        os.makedirs(directory)\n",
+        "        \n",
+        "directory = os.getcwd() + '/data/raw/data'\n",
+        "make_dir(directory)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "cols = [\n",
+        "    'name',\n",
+        "    'pid',\n",
+        "    'num_followers',\n",
+        "    'pos',\n",
+        "    'artist_name',\n",
+        "    'track_name',\n",
+        "    'album_name'\n",
+        "]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qyCujIu8cDGg",
+        "outputId": "0964ace3-2916-49e3-eebf-2e08e61d95d9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "mpd.slice.188000-188999.json\t100/1000\t10.0%"
+          ]
+        }
+      ],
+      "source": [
+        "\n",
+        "directory = os.getcwd() + '/data/raw/playlists/data'\n",
+        "df = pd.DataFrame()\n",
+        "index = 0\n",
+        "# Loop through all files in the directory\n",
+        "for filename in os.listdir(directory):\n",
+        "    # Check if the item is a file (not a subdirectory)\n",
+        "    if os.path.isfile(os.path.join(directory, filename)):\n",
+        "        if filename.find('.json') != -1 :\n",
+        "          index += 1\n",
+        "\n",
+        "          # Print the filename or perform operations on the file\n",
+        "          print(f'\\r{filename}\\t{index}/1000\\t{((index/1000)*100):.1f}%', end='')\n",
+        "\n",
+        "          # If you need the full file path, you can use:\n",
+        "          full_path = os.path.join(directory, filename)\n",
+        "\n",
+        "          with open(full_path, 'r') as file:\n",
+        "              json_data = json.load(file)\n",
+        "\n",
+        "          temp = pd.DataFrame(json_data['playlists'])\n",
+        "          expanded_df = temp.explode('tracks').reset_index(drop=True)\n",
+        "\n",
+        "          # Normalize the JSON data\n",
+        "          json_normalized = pd.json_normalize(expanded_df['tracks'])\n",
+        "\n",
+        "          # Concatenate the original DataFrame with the normalized JSON data\n",
+        "          result = pd.concat([expanded_df.drop(columns=['tracks']), json_normalized], axis=1)\n",
+        "          \n",
+        "          result = result[cols]\n",
+        "\n",
+        "          df = pd.concat([df, result], axis=0, ignore_index=True)\n",
+        "          \n",
+        "        if index % 50 == 0:\n",
+        "            df.to_parquet(f'{os.getcwd()}/data/raw/data/playlists_{index % 1000}.parquet')\n",
+        "            del df\n",
+        "            df = pd.DataFrame()\n",
+        "            if index % 100 == 0:\n",
+        "                break"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import pyarrow.parquet as pq\n",
+        "\n",
+        "def read_parquet_folder(folder_path):\n",
+        "    dataframes = []\n",
+        "    for file in os.listdir(folder_path):\n",
+        "        if file.endswith('.parquet'):\n",
+        "            file_path = os.path.join(folder_path, file)\n",
+        "            df = pd.read_parquet(file_path)\n",
+        "            dataframes.append(df)\n",
+        "    \n",
+        "    return pd.concat(dataframes, ignore_index=True)\n",
+        "\n",
+        "folder_path = os.getcwd() + '/data/raw/data'\n",
+        "df = read_parquet_folder(folder_path)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "directory = os.getcwd() + '/data/raw/mappings'\n",
+        "make_dir(directory)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def create_ids(df, col, name):\n",
+        "    # Create a dictionary mapping unique values to IDs\n",
+        "    value_to_id = {val: i for i, val in enumerate(df[col].unique())}\n",
+        "\n",
+        "    # Create a new column with the IDs\n",
+        "    df[f'{name}_id'] = df[col].map(value_to_id)\n",
+        "    df[[f'{name}_id', col]].drop_duplicates().to_csv(os.getcwd() + f'/data/raw/mappings/{name}.csv')\n",
+        "    # df = df.drop(col, axis=1)\n",
+        "    return df"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df = create_ids(df, 'artist_name', 'artist')\n",
+        "df = create_ids(df, 'pid', 'playlist')\n",
+        "df = create_ids(df, 'track_name', 'song')\n",
+        "df = create_ids(df, 'album_name', 'album')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df['artist_count'] = df.groupby(['playlist_id','artist_id'])['song_id'].transform('nunique')\n",
+        "df['album_count'] = df.groupby(['playlist_id','artist_id'])['album_id'].transform('nunique')\n",
+        "df['song_count'] = df.groupby(['playlist_id','artist_id'])['song_id'].transform('count')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df['playlist_songs'] = df.groupby(['playlist_id'])['pos'].transform('max')\n",
+        "df['playlist_songs'] += 1"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df['artist_percent'] = df['artist_count'] / df['playlist_songs']\n",
+        "df['song_percent'] = df['song_count'] / df['playlist_songs']\n",
+        "df['album_percent'] = df['album_count'] / df['playlist_songs']"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>name</th>\n",
+              "      <th>pid</th>\n",
+              "      <th>num_followers</th>\n",
+              "      <th>pos</th>\n",
+              "      <th>artist_name</th>\n",
+              "      <th>track_name</th>\n",
+              "      <th>album_name</th>\n",
+              "      <th>artist_id</th>\n",
+              "      <th>playlist_id</th>\n",
+              "      <th>song_id</th>\n",
+              "      <th>album_id</th>\n",
+              "      <th>artist_count</th>\n",
+              "      <th>album_count</th>\n",
+              "      <th>song_count</th>\n",
+              "      <th>playlist_songs</th>\n",
+              "      <th>artist_percent</th>\n",
+              "      <th>song_percent</th>\n",
+              "      <th>album_percent</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>212</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>0</td>\n",
+              "      <td>R. Kelly</td>\n",
+              "      <td>Ignition - Remix</td>\n",
+              "      <td>Chocolate Factory</td>\n",
+              "      <td>108</td>\n",
+              "      <td>5</td>\n",
+              "      <td>203</td>\n",
+              "      <td>152</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>213</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>Backstreet Boys</td>\n",
+              "      <td>I Want It That Way</td>\n",
+              "      <td>Original Album Classics</td>\n",
+              "      <td>109</td>\n",
+              "      <td>5</td>\n",
+              "      <td>204</td>\n",
+              "      <td>153</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>214</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>2</td>\n",
+              "      <td>*NSYNC</td>\n",
+              "      <td>Bye Bye Bye</td>\n",
+              "      <td>No Strings Attached</td>\n",
+              "      <td>110</td>\n",
+              "      <td>5</td>\n",
+              "      <td>205</td>\n",
+              "      <td>154</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>215</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>3</td>\n",
+              "      <td>Fountains Of Wayne</td>\n",
+              "      <td>Stacy's Mom</td>\n",
+              "      <td>Welcome Interstate Managers</td>\n",
+              "      <td>111</td>\n",
+              "      <td>5</td>\n",
+              "      <td>206</td>\n",
+              "      <td>155</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>216</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>4</td>\n",
+              "      <td>Bowling For Soup</td>\n",
+              "      <td>1985</td>\n",
+              "      <td>A Hangover You Don't Deserve</td>\n",
+              "      <td>112</td>\n",
+              "      <td>5</td>\n",
+              "      <td>207</td>\n",
+              "      <td>156</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>400</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>188</td>\n",
+              "      <td>JoJo</td>\n",
+              "      <td>Too Little, Too Late - Radio Version</td>\n",
+              "      <td>Too Little, Too Late</td>\n",
+              "      <td>199</td>\n",
+              "      <td>5</td>\n",
+              "      <td>390</td>\n",
+              "      <td>293</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>401</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>189</td>\n",
+              "      <td>Spice Girls</td>\n",
+              "      <td>Wannabe - Radio Edit</td>\n",
+              "      <td>Spice</td>\n",
+              "      <td>200</td>\n",
+              "      <td>5</td>\n",
+              "      <td>391</td>\n",
+              "      <td>294</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>402</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>190</td>\n",
+              "      <td>MiMS</td>\n",
+              "      <td>This Is Why I'm Hot</td>\n",
+              "      <td>Music Is My Savior</td>\n",
+              "      <td>201</td>\n",
+              "      <td>5</td>\n",
+              "      <td>392</td>\n",
+              "      <td>295</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>403</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>191</td>\n",
+              "      <td>Rihanna</td>\n",
+              "      <td>Disturbia</td>\n",
+              "      <td>Good Girl Gone Bad</td>\n",
+              "      <td>115</td>\n",
+              "      <td>5</td>\n",
+              "      <td>393</td>\n",
+              "      <td>296</td>\n",
+              "      <td>3</td>\n",
+              "      <td>3</td>\n",
+              "      <td>3</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.015544</td>\n",
+              "      <td>0.015544</td>\n",
+              "      <td>0.015544</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>404</th>\n",
+              "      <td>throwbacks</td>\n",
+              "      <td>143005</td>\n",
+              "      <td>2</td>\n",
+              "      <td>192</td>\n",
+              "      <td>DEV</td>\n",
+              "      <td>Bass Down Low</td>\n",
+              "      <td>The Night The Sun Came Up</td>\n",
+              "      <td>179</td>\n",
+              "      <td>5</td>\n",
+              "      <td>394</td>\n",
+              "      <td>264</td>\n",
+              "      <td>2</td>\n",
+              "      <td>1</td>\n",
+              "      <td>2</td>\n",
+              "      <td>193</td>\n",
+              "      <td>0.010363</td>\n",
+              "      <td>0.010363</td>\n",
+              "      <td>0.005181</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>193 rows × 18 columns</p>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "           name     pid  num_followers  pos         artist_name  \\\n",
+              "212  throwbacks  143005              2    0            R. Kelly   \n",
+              "213  throwbacks  143005              2    1     Backstreet Boys   \n",
+              "214  throwbacks  143005              2    2              *NSYNC   \n",
+              "215  throwbacks  143005              2    3  Fountains Of Wayne   \n",
+              "216  throwbacks  143005              2    4    Bowling For Soup   \n",
+              "..          ...     ...            ...  ...                 ...   \n",
+              "400  throwbacks  143005              2  188                JoJo   \n",
+              "401  throwbacks  143005              2  189         Spice Girls   \n",
+              "402  throwbacks  143005              2  190                MiMS   \n",
+              "403  throwbacks  143005              2  191             Rihanna   \n",
+              "404  throwbacks  143005              2  192                 DEV   \n",
+              "\n",
+              "                               track_name                    album_name  \\\n",
+              "212                      Ignition - Remix             Chocolate Factory   \n",
+              "213                    I Want It That Way       Original Album Classics   \n",
+              "214                           Bye Bye Bye           No Strings Attached   \n",
+              "215                           Stacy's Mom   Welcome Interstate Managers   \n",
+              "216                                  1985  A Hangover You Don't Deserve   \n",
+              "..                                    ...                           ...   \n",
+              "400  Too Little, Too Late - Radio Version          Too Little, Too Late   \n",
+              "401                  Wannabe - Radio Edit                         Spice   \n",
+              "402                   This Is Why I'm Hot            Music Is My Savior   \n",
+              "403                             Disturbia            Good Girl Gone Bad   \n",
+              "404                         Bass Down Low     The Night The Sun Came Up   \n",
+              "\n",
+              "     artist_id  playlist_id  song_id  album_id  artist_count  album_count  \\\n",
+              "212        108            5      203       152             1            1   \n",
+              "213        109            5      204       153             1            1   \n",
+              "214        110            5      205       154             1            1   \n",
+              "215        111            5      206       155             1            1   \n",
+              "216        112            5      207       156             1            1   \n",
+              "..         ...          ...      ...       ...           ...          ...   \n",
+              "400        199            5      390       293             1            1   \n",
+              "401        200            5      391       294             1            1   \n",
+              "402        201            5      392       295             1            1   \n",
+              "403        115            5      393       296             3            3   \n",
+              "404        179            5      394       264             2            1   \n",
+              "\n",
+              "     song_count  playlist_songs  artist_percent  song_percent  album_percent  \n",
+              "212           1             193        0.005181      0.005181       0.005181  \n",
+              "213           1             193        0.005181      0.005181       0.005181  \n",
+              "214           1             193        0.005181      0.005181       0.005181  \n",
+              "215           1             193        0.005181      0.005181       0.005181  \n",
+              "216           1             193        0.005181      0.005181       0.005181  \n",
+              "..          ...             ...             ...           ...            ...  \n",
+              "400           1             193        0.005181      0.005181       0.005181  \n",
+              "401           1             193        0.005181      0.005181       0.005181  \n",
+              "402           1             193        0.005181      0.005181       0.005181  \n",
+              "403           3             193        0.015544      0.015544       0.015544  \n",
+              "404           2             193        0.010363      0.010363       0.005181  \n",
+              "\n",
+              "[193 rows x 18 columns]"
+            ]
+          },
+          "execution_count": 13,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "df[df['playlist_id'] == 5]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>playlist_id</th>\n",
+              "      <th>artist_id</th>\n",
+              "      <th>artist_percent</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.571429</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.571429</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.571429</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.571429</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.571429</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "   playlist_id  artist_id  artist_percent\n",
+              "0            0          0        0.571429\n",
+              "1            0          0        0.571429\n",
+              "2            0          0        0.571429\n",
+              "3            0          0        0.571429\n",
+              "4            0          0        0.571429"
+            ]
+          },
+          "execution_count": 14,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "artists = df.loc[:,['playlist_id','artist_id','album_id','album_percent']]\n",
+        "artists.head()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "X = artists.loc[:,['playlist_id','artist_id','album_id']]\n",
+        "y = artists.loc[:,'album_percent']\n",
+        "\n",
+        "# Split our data into training and test sets\n",
+        "X_train, X_val, y_train, y_val = train_test_split(X,y,random_state=0, test_size=0.2)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def prep_dataloaders(X_train,y_train,X_val,y_val,batch_size):\n",
+        "    # Convert training and test data to TensorDatasets\n",
+        "    trainset = TensorDataset(torch.from_numpy(np.array(X_train)).long(), \n",
+        "                            torch.from_numpy(np.array(y_train)).float())\n",
+        "    valset = TensorDataset(torch.from_numpy(np.array(X_val)).long(), \n",
+        "                            torch.from_numpy(np.array(y_val)).float())\n",
+        "\n",
+        "    # Create Dataloaders for our training and test data to allow us to iterate over minibatches \n",
+        "    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)\n",
+        "    valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False)\n",
+        "\n",
+        "    return trainloader, valloader\n",
+        "\n",
+        "batchsize = 64\n",
+        "trainloader,valloader = prep_dataloaders(X_train,y_train,X_val,y_val,batchsize)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class NNColabFiltering(nn.Module):\n",
+        "    \n",
+        "    def __init__(self, n_playlists, n_artists, embedding_dim_users, embedding_dim_items, n_activations, rating_range):\n",
+        "        super().__init__()\n",
+        "        self.user_embeddings = nn.Embedding(num_embeddings=n_playlists,embedding_dim=embedding_dim_users)\n",
+        "        self.item_embeddings = nn.Embedding(num_embeddings=n_artists,embedding_dim=embedding_dim_items)\n",
+        "        self.fc1 = nn.Linear(embedding_dim_users+embedding_dim_items,n_activations)\n",
+        "        self.fc2 = nn.Linear(n_activations,1)\n",
+        "        self.rating_range = rating_range\n",
+        "\n",
+        "    def forward(self, X):\n",
+        "        # Get embeddings for minibatch\n",
+        "        embedded_users = self.user_embeddings(X[:,0])\n",
+        "        embedded_items = self.item_embeddings(X[:,1])\n",
+        "        # Concatenate user and item embeddings\n",
+        "        embeddings = torch.cat([embedded_users,embedded_items],dim=1)\n",
+        "        # Pass embeddings through network\n",
+        "        preds = self.fc1(embeddings)\n",
+        "        preds = F.relu(preds)\n",
+        "        preds = self.fc2(preds)\n",
+        "        # Scale predicted ratings to target-range [low,high]\n",
+        "        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]\n",
+        "        return preds"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class PMFRecommender(nn.Module):\n",
+        "    \n",
+        "    def __init__(self,n_users, n_items, embedding_dim ,rating_range):\n",
+        "        super().__init__() \n",
+        "        self.user_embeddings = nn.Embedding(num_embeddings=n_users,embedding_dim=embedding_dim) # user embeddings\n",
+        "        self.user_bias = nn.Embedding(num_embeddings=n_users,embedding_dim=1) # user bias\n",
+        "        self.item_embeddings = nn.Embedding(num_embeddings=n_items,embedding_dim=embedding_dim) # item embeddings\n",
+        "        self.item_bias = nn.Embedding(num_embeddings=n_items,embedding_dim=1) # item bias\n",
+        "        self.rating_range = rating_range # range of expected ratings e.g. 0-5\n",
+        "\n",
+        "    def forward(self, X):\n",
+        "        embedded_users = self.user_embeddings(X[:,0]) # dims = [batch_size, embedding_dim]\n",
+        "        embedded_items = self.item_embeddings(X[:,1]) # dims = [batch_size, embedding_dim]\n",
+        "        # Take dot product of each user embedding with the embedding of item to be rated to get the predicted rating\n",
+        "        preds = torch.sum(embedded_users * embedded_items, dim=1, keepdim=True) \n",
+        "        # Add user and item bias to rating\n",
+        "        preds = preds.view(-1,1) + self.user_bias(X[:,0]) + self.item_bias(X[:,1])\n",
+        "        # Scale predicted ratings to target-range [low,high]\n",
+        "        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]\n",
+        "        return preds\n",
+        "        "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "class NNHybridFiltering(nn.Module):\n",
+        "    \n",
+        "    def __init__(self, n_users, n_items, n_genres, embdim_users, embdim_items, embdim_genres, n_activations, rating_range):\n",
+        "        super().__init__()\n",
+        "        self.user_embeddings = nn.Embedding(num_embeddings=n_users,embedding_dim=embdim_users)\n",
+        "        self.item_embeddings = nn.Embedding(num_embeddings=n_items,embedding_dim=embdim_items)\n",
+        "        self.genre_embeddings = nn.Embedding(num_embeddings=n_genres,embedding_dim=embdim_genres)\n",
+        "        self.fc1 = nn.Linear(embdim_users+embdim_items+embdim_genres,n_activations)\n",
+        "        self.fc2 = nn.Linear(n_activations,1)\n",
+        "        self.rating_range = rating_range\n",
+        "\n",
+        "    def forward(self, X):\n",
+        "        # Get embeddings for minibatch\n",
+        "        embedded_users = self.user_embeddings(X[:,0])\n",
+        "        embedded_items = self.item_embeddings(X[:,1])\n",
+        "        embedded_genres = self.genre_embeddings(X[:,2])\n",
+        "        # Concatenate user, item and genre embeddings\n",
+        "        embeddings = torch.cat([embedded_users,embedded_items,embedded_genres],dim=1)\n",
+        "        # Pass embeddings through network\n",
+        "        preds = self.fc1(embeddings)\n",
+        "        preds = F.relu(preds)\n",
+        "        preds = self.fc2(preds)\n",
+        "        # Scale predicted ratings to target-range [low,high]\n",
+        "        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]\n",
+        "        return preds\n",
+        "        "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def train_model(model, criterion, optimizer, dataloaders, device, num_epochs=5, scheduler=None):\n",
+        "    model = model.to(device) # Send model to GPU if available\n",
+        "    since = time.time()\n",
+        "\n",
+        "    costpaths = {'train':[],'val':[]}\n",
+        "\n",
+        "    for epoch in range(num_epochs):\n",
+        "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
+        "        print('-' * 10)\n",
+        "\n",
+        "        # Each epoch has a training and validation phase\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                model.train()  # Set model to training mode\n",
+        "            else:\n",
+        "                model.eval()   # Set model to evaluate mode\n",
+        "\n",
+        "            running_loss = 0.0\n",
+        "\n",
+        "            # Get the inputs and labels, and send to GPU if available\n",
+        "            index = 0\n",
+        "            for (inputs,labels) in dataloaders[phase]:\n",
+        "                inputs = inputs.to(device)\n",
+        "                labels = labels.to(device)\n",
+        "\n",
+        "                # Zero the weight gradients\n",
+        "                optimizer.zero_grad()\n",
+        "\n",
+        "                # Forward pass to get outputs and calculate loss\n",
+        "                # Track gradient only for training data\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = model.forward(inputs).view(-1)\n",
+        "                    loss = criterion(outputs, labels)\n",
+        "\n",
+        "                    # Backpropagation to get the gradients with respect to each weight\n",
+        "                    # Only if in train\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        # Update the weights\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                # Convert loss into a scalar and add it to running_loss\n",
+        "                running_loss += np.sqrt(loss.item()) * labels.size(0)\n",
+        "                print(f'\\r{running_loss} {index} {index / len(dataloaders[phase])}', end='')\n",
+        "                index +=1\n",
+        "\n",
+        "            # Step along learning rate scheduler when in train\n",
+        "            if (phase == 'train') and (scheduler is not None):\n",
+        "                scheduler.step()\n",
+        "\n",
+        "            # Calculate and display average loss and accuracy for the epoch\n",
+        "            epoch_loss = running_loss / len(dataloaders[phase].dataset)\n",
+        "            costpaths[phase].append(epoch_loss)\n",
+        "            print('{} loss: {:.4f}'.format(phase, epoch_loss))\n",
+        "\n",
+        "    time_elapsed = time.time() - since\n",
+        "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
+        "        time_elapsed // 60, time_elapsed % 60))\n",
+        "\n",
+        "    return costpaths"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Train the model\n",
+        "dataloaders = {'train':trainloader, 'val':valloader}\n",
+        "n_users = X.loc[:,'playlist_id'].max()+1\n",
+        "n_items = X.loc[:,'artist_id'].max()+1\n",
+        "n_genres = X.loc[:,'album_id'].max()+1\n",
+        "model = NNHybridFiltering(n_users,\n",
+        "                       n_items,\n",
+        "                       n_genres,\n",
+        "                       embdim_users=50, \n",
+        "                       embdim_items=50, \n",
+        "                       embdim_genres=25,\n",
+        "                       n_activations = 100,\n",
+        "                       rating_range=[0.,1.])\n",
+        "criterion = nn.MSELoss()\n",
+        "lr=0.001\n",
+        "n_epochs=10\n",
+        "wd=1e-3\n",
+        "optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=wd)\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "cost_paths = train_model(model,criterion,optimizer,dataloaders, device,n_epochs, scheduler=None)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch 0/0\n",
+            "----------\n",
+            "620559.3337308276 83563 0.999988033124312train loss: 0.1160\n",
+            "153259.98286122305 20890 0.9999521324972476val loss: 0.1146\n",
+            "Training complete in 18m 4s\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Train the model\n",
+        "dataloaders = {'train':trainloader, 'val':valloader}\n",
+        "n_playlists = X.loc[:,'playlist_id'].max()+1\n",
+        "n_artists = X.loc[:,'artist_id'].max()+1\n",
+        "model = NNColabFiltering(n_playlists,n_artists,embedding_dim_users=1, embedding_dim_items=1, n_activations = 5,rating_range=[0.,1.])\n",
+        "criterion = nn.MSELoss()\n",
+        "lr=0.001\n",
+        "n_epochs=1\n",
+        "wd=1e-3\n",
+        "optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=wd)\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "cost_paths = train_model(model,criterion,optimizer,dataloaders, device,n_epochs, scheduler=None)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1500x500 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Plot the cost over training and validation sets\n",
+        "fig,ax = plt.subplots(1,2,figsize=(15,5))\n",
+        "for i,key in enumerate(cost_paths.keys()):\n",
+        "    ax_sub=ax[i%3]\n",
+        "    ax_sub.plot(cost_paths[key])\n",
+        "    ax_sub.set_title(key)\n",
+        "    ax_sub.set_xlabel('Epoch')\n",
+        "    ax_sub.set_ylabel('Loss')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Save the entire model\n",
+        "torch.save(model, os.getcwd() + 'recommender.pt')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Predicted rating is 0.1\n"
+          ]
+        }
+      ],
+      "source": [
+        "def predict_rating(model,playlist_id,artist_id, device):\n",
+        "    # Get predicted rating for a specific user-item pair from model\n",
+        "    model = model.to(device)\n",
+        "    with torch.no_grad():\n",
+        "        model.eval()\n",
+        "        X = torch.Tensor([playlist_id,artist_id]).long().view(1,-1)\n",
+        "        X = X.to(device)\n",
+        "        pred = model.forward(X)\n",
+        "        return pred\n",
+        "\n",
+        "# Get predicted rating for a random user-item pair\n",
+        "rating = predict_rating(model,5,10,device)\n",
+        "print('Predicted rating is {:.1f}'.format(rating.detach().cpu().item()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def generate_recommendations(movies,X,model,playlist_id,device):\n",
+        "    # Get predicted ratings for every movie\n",
+        "    pred_ratings = []\n",
+        "    for movie in movies['artist_id'].tolist():\n",
+        "        pred = predict_rating(model,playlist_id,movie,device)\n",
+        "        pred_ratings.append(pred.detach().cpu().item())\n",
+        "    # Sort movies by predicted rating\n",
+        "    idxs = np.argsort(np.array(pred_ratings))[::-1]\n",
+        "    recs = movies.iloc[idxs]['artist_id'].values.tolist()\n",
+        "    # Filter out movies already watched by user\n",
+        "    movies_watched = X.loc[X['playlist_id']==playlist_id, 'artist_id'].tolist()\n",
+        "    recs = [rec for rec in recs if not rec in movies_watched]\n",
+        "    # Filter to top 10 recommendations\n",
+        "    recs = recs[:10]\n",
+        "    # Convert artist_ids to titles\n",
+        "    recs_names = []\n",
+        "    for rec in recs:\n",
+        "        recs_names.append(movies.loc[movies['artist_id']==rec,'artist_name'].values[0])\n",
+        "    return recs_names"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {},
+      "outputs": [
+        {
+          "ename": "FileNotFoundError",
+          "evalue": "[Errno 2] No such file or directory: 'c:\\\\Users\\\\keese\\\\OneDrive - Duke University\\\\Desktop\\\\recommendation_module_project/raw/data\\\\artists.csv'",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+            "Cell \u001b[1;32mIn[25], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Get recommendations for a random user\u001b[39;00m\n\u001b[0;32m      2\u001b[0m playlist_id \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[1;32m----> 3\u001b[0m movies \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetcwd\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m/raw/data\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43martists.csv\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      4\u001b[0m recs \u001b[38;5;241m=\u001b[39m generate_recommendations(movies,X,model,playlist_id,device)\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i,rec \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(recs):\n",
+            "File \u001b[1;32mc:\\Users\\keese\\anaconda3\\envs\\term_project\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[1;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[0;32m   1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[0;32m   1014\u001b[0m     dialect,\n\u001b[0;32m   1015\u001b[0m     delimiter,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1022\u001b[0m     dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[0;32m   1023\u001b[0m )\n\u001b[0;32m   1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[1;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
+            "File \u001b[1;32mc:\\Users\\keese\\anaconda3\\envs\\term_project\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[1;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[0;32m    617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[0;32m    619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[1;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m TextFileReader(filepath_or_buffer, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m    622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[0;32m    623\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m parser\n",
+            "File \u001b[1;32mc:\\Users\\keese\\anaconda3\\envs\\term_project\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[1;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[0;32m   1617\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m   1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n",
+            "File \u001b[1;32mc:\\Users\\keese\\anaconda3\\envs\\term_project\\lib\\site-packages\\pandas\\io\\parsers\\readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[1;34m(self, f, engine)\u001b[0m\n\u001b[0;32m   1878\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[0;32m   1879\u001b[0m         mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1881\u001b[0m \u001b[43m    \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1882\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1883\u001b[0m \u001b[43m    \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1884\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1885\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1886\u001b[0m \u001b[43m    \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1887\u001b[0m \u001b[43m    \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1888\u001b[0m \u001b[43m    \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1889\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n",
+            "File \u001b[1;32mc:\\Users\\keese\\anaconda3\\envs\\term_project\\lib\\site-packages\\pandas\\io\\common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[1;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[0;32m    868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m    869\u001b[0m     \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[0;32m    870\u001b[0m     \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[0;32m    871\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[0;32m    872\u001b[0m         \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[1;32m--> 873\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[0;32m    874\u001b[0m \u001b[43m            \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    875\u001b[0m \u001b[43m            \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    876\u001b[0m \u001b[43m            \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    877\u001b[0m \u001b[43m            \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    878\u001b[0m \u001b[43m            \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m    879\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    880\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    881\u001b[0m         \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[0;32m    882\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n",
+            "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'c:\\\\Users\\\\keese\\\\OneDrive - Duke University\\\\Desktop\\\\recommendation_module_project/raw/data\\\\artists.csv'"
+          ]
+        }
+      ],
+      "source": [
+        "# Get recommendations for a random user\n",
+        "playlist_id = 5\n",
+        "movies = pd.read_csv(os.path.join(os.getcwd() + '/raw/data','artists.csv'))\n",
+        "recs = generate_recommendations(movies,X,model,playlist_id,device)\n",
+        "for i,rec in enumerate(recs):\n",
+        "  print('Recommendation {}: {}'.format(i,rec))"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "machine_shape": "hm",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.19"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

recommendation_module_project/model_(2).py

@@ -0,0 +1,632 @@
+# -*- coding: utf-8 -*-
+"""model (2).ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1suM8thtI4fHajXQDsGPBRodH_76G2iEI
+"""
+
+import os
+import urllib.request
+import zipfile
+import json
+import pandas as pd
+import time
+import torch
+import numpy as np
+import pandas as pd
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import LabelEncoder
+
+from google.colab import drive
+drive.mount('/content/drive')
+
+# prompt: copy a file from another directory to current directory in python code and create folders if needed
+
+import shutil
+import os
+
+def copy_file(src, dst):
+  """
+  Copies a file from src to dst, creating any necessary directories.
+
+  Args:
+    src: The path to the source file.
+    dst: The path to the destination file.
+  """
+  # Create the destination directory if it doesn't exist.
+  dst_dir = os.path.dirname(dst)
+  if not os.path.exists(dst_dir):
+    os.makedirs(dst_dir)
+
+  # Copy the file.
+  shutil.copy2(src, dst)
+
+copy_file('/content/drive/MyDrive/rec_data/spotify_million_playlist_dataset.zip', os.getcwd() + '/data/raw/spotify_million_playlist_dataset.zip')
+
+def unzip_archive(filepath, dir_path):
+  with zipfile.ZipFile(f"{filepath}", 'r') as zip_ref:
+    zip_ref.extractall(dir_path)
+
+unzip_archive(os.getcwd() + '/data/raw/spotify_million_playlist_dataset.zip', os.getcwd() + '/data/raw/playlists')
+
+import shutil
+
+def make_dir(directory):
+    if os.path.exists(directory):
+        shutil.rmtree(directory)
+        os.makedirs(directory)
+    else:
+        os.makedirs(directory)
+
+directory = os.getcwd() + '/data/raw/data'
+make_dir(directory)
+
+cols = [
+    'name',
+    'pid',
+    'num_followers',
+    'pos',
+    'artist_name',
+    'track_name',
+    'album_name'
+]
+
+directory = os.getcwd() + '/data/raw/playlists/data'
+df = pd.DataFrame()
+index = 0
+# Loop through all files in the directory
+for filename in os.listdir(directory):
+    # Check if the item is a file (not a subdirectory)
+    if os.path.isfile(os.path.join(directory, filename)):
+        if filename.find('.json') != -1 :
+          index += 1
+
+          # Print the filename or perform operations on the file
+          print(f'\r{filename}\t{index}/1000\t{((index/1000)*100):.1f}%', end='')
+
+          # If you need the full file path, you can use:
+          full_path = os.path.join(directory, filename)
+
+          with open(full_path, 'r') as file:
+              json_data = json.load(file)
+
+          temp = pd.DataFrame(json_data['playlists'])
+          expanded_df = temp.explode('tracks').reset_index(drop=True)
+
+          # Normalize the JSON data
+          json_normalized = pd.json_normalize(expanded_df['tracks'])
+
+          # Concatenate the original DataFrame with the normalized JSON data
+          result = pd.concat([expanded_df.drop(columns=['tracks']), json_normalized], axis=1)
+
+          result = result[cols]
+
+          df = pd.concat([df, result], axis=0, ignore_index=True)
+
+        if index % 50 == 0:
+            df.to_parquet(f'{os.getcwd()}/data/raw/data/playlists_{index % 1000}.parquet')
+            del df
+            df = pd.DataFrame()
+            if index % 200 == 0:
+                break
+
+import pyarrow.parquet as pq
+
+def read_parquet_folder(folder_path):
+    dataframes = []
+    for file in os.listdir(folder_path):
+        if file.endswith('.parquet'):
+            file_path = os.path.join(folder_path, file)
+            df = pd.read_parquet(file_path)
+            dataframes.append(df)
+
+    return pd.concat(dataframes, ignore_index=True)
+
+folder_path = os.getcwd() + '/data/raw/data'
+df = read_parquet_folder(folder_path)
+
+directory = os.getcwd() + '/data/raw/mappings'
+make_dir(directory)
+
+def create_ids(df, col, name):
+    # Create a dictionary mapping unique values to IDs
+    value_to_id = {val: i for i, val in enumerate(df[col].unique())}
+
+    # Create a new column with the IDs
+    df[f'{name}_id'] = df[col].map(value_to_id)
+    df[[f'{name}_id', col]].drop_duplicates().to_csv(os.getcwd() + f'/data/raw/mappings/{name}.csv')
+
+    return df
+
+# df = create_ids(df, 'artist_name', 'artist')
+df = create_ids(df, 'pid', 'playlist')
+# df = create_ids(df, 'track_name', 'track')
+# df = create_ids(df, 'album_name', 'album')
+
+df['song_count'] = df.groupby(['pid','artist_name','album_name'])['track_name'].transform('nunique')
+
+df['playlist_songs'] = df.groupby(['pid'])['pos'].transform('max')
+df['playlist_songs'] += 1
+
+df['artist_album'] = df[['artist_name', 'album_name']].agg('::'.join, axis=1)
+
+# Step 2: Create a dictionary mapping unique combined values to IDs
+value_to_id = {val: i for i, val in enumerate(df['artist_album'].unique())}
+
+# Step 3: Map these IDs back to the DataFrame
+df['artist_album_id'] = df['artist_album'].map(value_to_id)
+
+df[[f'artist_album_id', 'artist_album', 'artist_name', 'album_name', 'track_name']].drop_duplicates().to_csv(os.getcwd() + f'/data/raw/mappings/artist_album.csv')
+
+# df = df.groupby(['playlist_id','artist_album','artist_album_id','playlist_songs']).agg({
+#     'song_count': 'sum',
+#     'track_name': '|'.join,
+#     'track_name': '|'.join,
+# }).reset_index()
+df['song_count'] =  df.groupby(['playlist_id','artist_album_id'])['song_count'].transform('sum')
+
+# Encode the genres data
+encoder = LabelEncoder()
+encoder.fit(df['track_name'])
+df['track_id'] = encoder.transform(df['track_name'])
+
+# df['artist_count'] = df.groupby(['playlist_id','artist_id'])['song_id'].transform('nunique')
+# df['album_count'] = df.groupby(['playlist_id','artist_id','album_id'])['song_id'].transform('nunique')
+# df['song_count'] = df.groupby(['artist_id'])['song_id'].transform('count')
+
+# df['artist_percent'] = df['artist_count'] / df['playlist_songs']
+df['song_percent'] = df['song_count'] / df['playlist_songs']
+# df['album_percent'] = df['album_count'] / df['playlist_songs']
+
+import numpy as np
+
+# Assuming you have a DataFrame 'df' with a column 'column_name'
+df['song_percent'] = 1 / (1 + np.exp(-df['song_percent']))
+
+artists = df.loc[:,['playlist_id','artist_album_id','song_percent']].drop_duplicates()
+artists.head()
+
+X = artists.loc[:,['playlist_id','artist_album_id',]]
+y = artists.loc[:,'song_percent']
+
+# Split our data into training and test sets
+X_train, X_val, y_train, y_val = train_test_split(X,y,random_state=0, test_size=0.2)
+
+def prep_dataloaders(X_train,y_train,X_val,y_val,batch_size):
+    # Convert training and test data to TensorDatasets
+    trainset = TensorDataset(torch.from_numpy(np.array(X_train)).long(),
+                            torch.from_numpy(np.array(y_train)).float())
+    valset = TensorDataset(torch.from_numpy(np.array(X_val)).long(),
+                            torch.from_numpy(np.array(y_val)).float())
+
+    # Create Dataloaders for our training and test data to allow us to iterate over minibatches
+    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)
+    valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False)
+
+    return trainloader, valloader
+
+batchsize = 64
+trainloader,valloader = prep_dataloaders(X_train,y_train,X_val,y_val,batchsize)
+
+class NNColabFiltering(nn.Module):
+
+    def __init__(self, n_playlists, n_artists, embedding_dim_users, embedding_dim_items, n_activations, rating_range):
+        super().__init__()
+        self.user_embeddings = nn.Embedding(num_embeddings=n_playlists,embedding_dim=embedding_dim_users)
+        self.item_embeddings = nn.Embedding(num_embeddings=n_artists,embedding_dim=embedding_dim_items)
+        self.fc1 = nn.Linear(embedding_dim_users+embedding_dim_items,n_activations)
+        self.fc2 = nn.Linear(n_activations,1)
+        self.rating_range = rating_range
+
+    def forward(self, X):
+        # Get embeddings for minibatch
+        embedded_users = self.user_embeddings(X[:,0])
+        embedded_items = self.item_embeddings(X[:,1])
+        # Concatenate user and item embeddings
+        embeddings = torch.cat([embedded_users,embedded_items],dim=1)
+        # Pass embeddings through network
+        preds = self.fc1(embeddings)
+        preds = F.relu(preds)
+        preds = self.fc2(preds)
+        # Scale predicted ratings to target-range [low,high]
+        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]
+        return preds
+
+class PMFRecommender(nn.Module):
+
+    def __init__(self,n_users, n_items, embedding_dim ,rating_range):
+        super().__init__()
+        self.user_embeddings = nn.Embedding(num_embeddings=n_users,embedding_dim=embedding_dim) # user embeddings
+        self.user_bias = nn.Embedding(num_embeddings=n_users,embedding_dim=1) # user bias
+        self.item_embeddings = nn.Embedding(num_embeddings=n_items,embedding_dim=embedding_dim) # item embeddings
+        self.item_bias = nn.Embedding(num_embeddings=n_items,embedding_dim=1) # item bias
+        self.rating_range = rating_range # range of expected ratings e.g. 0-5
+
+    def forward(self, X):
+        embedded_users = self.user_embeddings(X[:,0]) # dims = [batch_size, embedding_dim]
+        embedded_items = self.item_embeddings(X[:,1]) # dims = [batch_size, embedding_dim]
+        # Take dot product of each user embedding with the embedding of item to be rated to get the predicted rating
+        preds = torch.sum(embedded_users * embedded_items, dim=1, keepdim=True)
+        # Add user and item bias to rating
+        preds = preds.view(-1,1) + self.user_bias(X[:,0]) + self.item_bias(X[:,1])
+        # Scale predicted ratings to target-range [low,high]
+        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]
+        return preds
+
+class NNHybridFiltering(nn.Module):
+
+    def __init__(self, n_users, n_items, n_genres, embdim_users, embdim_items, embdim_genres, n_activations, rating_range):
+        super().__init__()
+        self.user_embeddings = nn.Embedding(num_embeddings=n_users,embedding_dim=embdim_users)
+        self.item_embeddings = nn.Embedding(num_embeddings=n_items,embedding_dim=embdim_items)
+        self.genre_embeddings = nn.Embedding(num_embeddings=n_genres,embedding_dim=embdim_genres)
+        self.fc1 = nn.Linear(embdim_users+embdim_items+embdim_genres,n_activations)
+        self.fc2 = nn.Linear(n_activations,1)
+        self.rating_range = rating_range
+
+    def forward(self, X):
+        # Get embeddings for minibatch
+        embedded_users = self.user_embeddings(X[:,0])
+        embedded_items = self.item_embeddings(X[:,1])
+        embedded_genres = self.genre_embeddings(X[:,2])
+        # Concatenate user, item and genre embeddings
+        embeddings = torch.cat([embedded_users,embedded_items,embedded_genres],dim=1)
+        # Pass embeddings through network
+        preds = self.fc1(embeddings)
+        preds = F.relu(preds)
+        preds = self.fc2(preds)
+        # Scale predicted ratings to target-range [low,high]
+        preds = torch.sigmoid(preds) * (self.rating_range[1]-self.rating_range[0]) + self.rating_range[0]
+        return preds
+
+class EfficientHybridFiltering(nn.Module):
+    def __init__(self, n_users, n_items, n_genres, embdim, n_factors, rating_range):
+        super().__init__()
+        self.user_factors = nn.Embedding(n_users, n_factors)
+        self.item_factors = nn.Embedding(n_items, n_factors)
+        self.genre_embeddings = nn.Embedding(n_genres, embdim)
+        self.user_bias = nn.Embedding(n_users, 1)
+        self.item_bias = nn.Embedding(n_items, 1)
+        self.genre_projection = nn.Linear(embdim, n_factors)
+        self.global_bias = nn.Parameter(torch.zeros(1))
+        self.rating_range = rating_range
+
+    def forward(self, X):
+        users, items, genres = X[:, 0], X[:, 1], X[:, 2]
+        user_factors = self.user_factors(users)
+        item_factors = self.item_factors(items)
+        genre_emb = self.genre_embeddings(genres)
+        genre_factors = self.genre_projection(genre_emb)
+
+        dot = (user_factors * item_factors * genre_factors).sum(1)
+        bias = self.global_bias + self.user_bias(users).squeeze() + self.item_bias(items).squeeze()
+
+        preds = torch.sigmoid(dot + bias)
+        preds = preds * (self.rating_range[1] - self.rating_range[0]) + self.rating_range[0]
+        return preds
+
+def train_model(model, criterion, optimizer, dataloaders, device, num_epochs=5, scheduler=None):
+    model = model.to(device) # Send model to GPU if available
+    since = time.time()
+
+    costpaths = {'train':[],'val':[]}
+
+    for epoch in range(num_epochs):
+        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
+        print('-' * 10)
+
+        # Each epoch has a training and validation phase
+        for phase in ['train', 'val']:
+            if phase == 'train':
+                model.train()  # Set model to training mode
+            else:
+                model.eval()   # Set model to evaluate mode
+
+            running_loss = 0.0
+
+            # Get the inputs and labels, and send to GPU if available
+            index = 0
+            for (inputs,labels) in dataloaders[phase]:
+                inputs = inputs.to(device)
+                labels = labels.to(device)
+
+                # Zero the weight gradients
+                optimizer.zero_grad()
+
+                # Forward pass to get outputs and calculate loss
+                # Track gradient only for training data
+                with torch.set_grad_enabled(phase == 'train'):
+                    outputs = model.forward(inputs).view(-1)
+                    loss = criterion(outputs, labels)
+
+                    # Backpropagation to get the gradients with respect to each weight
+                    # Only if in train
+                    if phase == 'train':
+                        loss.backward()
+                        # Update the weights
+                        optimizer.step()
+
+                # Convert loss into a scalar and add it to running_loss
+                running_loss += np.sqrt(loss.item()) * labels.size(0)
+                print(f'\r{running_loss} {index} {(index / len(dataloaders[phase]))*100:.2f}%', end='')
+                index +=1
+
+            # Step along learning rate scheduler when in train
+            if (phase == 'train') and (scheduler is not None):
+                scheduler.step()
+
+            # Calculate and display average loss and accuracy for the epoch
+            epoch_loss = running_loss / len(dataloaders[phase].dataset)
+            costpaths[phase].append(epoch_loss)
+            print('\n{} loss: {:.4f}'.format(phase, epoch_loss))
+
+    time_elapsed = time.time() - since
+    print('Training complete in {:.0f}m {:.0f}s'.format(
+        time_elapsed // 60, time_elapsed % 60))
+
+    return costpaths
+
+# Train the model
+dataloaders = {'train':trainloader, 'val':valloader}
+n_users = X.loc[:,'playlist_id'].max()+1
+n_items = X.loc[:,'artist_album_id'].max()+1
+model = NNColabFiltering(n_users,n_items,embedding_dim_users=50, embedding_dim_items=50, n_activations = 100,rating_range=[0.,1.])
+criterion = nn.MSELoss()
+lr=0.001
+n_epochs=10
+wd=1e-3
+optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+cost_paths = train_model(model,criterion,optimizer,dataloaders, device,n_epochs, scheduler=None)
+
+# Plot the cost over training and validation sets
+fig,ax = plt.subplots(1,2,figsize=(15,5))
+for i,key in enumerate(cost_paths.keys()):
+    ax_sub=ax[i%3]
+    ax_sub.plot(cost_paths[key])
+    ax_sub.set_title(key)
+    ax_sub.set_xlabel('Epoch')
+    ax_sub.set_ylabel('Loss')
+plt.show()
+
+# Save the entire model
+torch.save(model, os.getcwd() + '/recommender.pt')
+
+df[df['playlist_id'] == 5]
+
+def predict_rating(model,userId,movieId, device):
+    # Get predicted rating for a specific user-item pair from model
+    model = model.to(device)
+    with torch.no_grad():
+        model.eval()
+        X = torch.Tensor([userId,movieId]).long().view(1,-1)
+        X = X.to(device)
+        pred = model.forward(X)
+        return pred
+
+# Get predicted rating for a random user-item pair
+rating = predict_rating(model,5,10,device)
+print('Predicted rating is {:.1f}'.format(rating.detach().cpu().item()))
+
+def generate_recommendations(movies,X,model,userId,device):
+    # Get predicted ratings for every movie
+    pred_ratings = []
+    for movie in movies['artist_album_id'].tolist():
+        pred = predict_rating(model,userId,movie,device)
+        pred_ratings.append(pred.detach().cpu().item())
+    # Sort movies by predicted rating
+    idxs = np.argsort(np.array(pred_ratings))[::-1]
+    recs = movies.iloc[idxs]['artist_album_id'].values.tolist()
+    # Filter out movies already watched by user
+    movies_watched = X.loc[X['playlist_id']==userId, 'artist_album_id'].tolist()
+    recs = [rec for rec in recs if not rec in movies_watched]
+    # Filter to top 10 recommendations
+    recs = recs[:10]
+    # Convert movieIDs to titles
+    recs_names = []
+    for rec in recs:
+        recs_names.append(movies.loc[movies['artist_album_id']==rec,'title'].values[0])
+    return recs_names
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+def generate_recommendations_efficient(movies, user_data, model, userId, device, top_n=10, batch_size=1024):
+    model.eval()
+
+    # Get all movie IDs
+    all_movie_ids = torch.tensor(movies['artist_album_id'].values, dtype=torch.long, device=device)
+
+    # Create a tensor of user IDs
+    user_ids = torch.full((len(all_movie_ids),), userId, dtype=torch.long, device=device)
+
+    # Initialize tensor to store all predictions
+    all_predictions = torch.zeros(len(all_movie_ids), device=device)
+
+    # Generate predictions in batches
+    with torch.no_grad():
+        for i in range(0, len(all_movie_ids), batch_size):
+            batch_user_ids = user_ids[i:i+batch_size]
+            batch_movie_ids = all_movie_ids[i:i+batch_size]
+
+            input_tensor = torch.stack([batch_user_ids, batch_movie_ids], dim=1)
+            batch_predictions = model(input_tensor).squeeze()
+            all_predictions[i:i+batch_size] = batch_predictions
+
+    # Convert to numpy for easier handling
+    predictions = all_predictions.cpu().numpy()
+
+    # Get movies watched by the user
+    movies_watched = set(user_data.loc[user_data['playlist_id'] == userId, 'artist_album_id'].tolist())
+
+    # Create a mask for unwatched movies
+    unwatched_mask = np.isin(movies['artist_album_id'].values, list(movies_watched), invert=True)
+
+    # Get top N recommendations
+    top_indices = np.argsort(predictions[unwatched_mask])[-top_n:][::-1]
+    recs = movies['artist_album_id'].values[unwatched_mask][top_indices]
+
+    # Get the titles of recommended movies
+    recs_names = movies.loc[movies['artist_album_id'].isin(recs), 'artist_album'].values
+
+    return recs_names.tolist()
+
+# Example usage
+userId = 5  # The user you want recommendations for
+movies = pd.read_csv(os.path.join(os.getcwd() + '/data/raw/mappings','artist_album.csv'))
+movies = movies[['artist_album_id','artist_album','artist_name','album_name']].drop_duplicates()
+recommendations = generate_recommendations_efficient(movies, X, model, userId, device)
+
+print("Recommendations for user", userId)
+for rec in recommendations:
+    print(rec)
+
+df[df['playlist_id'] == 5]
+
+import torch
+import torch.nn.functional as F
+
+def generate_recommendations_for_new_user(model, item_id, n_similar_items=50, top_n=10):
+    model.eval()
+    device = next(model.parameters()).device
+
+    # Get the embedding for the given item
+    item_embedding = model.item_embeddings.weight[item_id].unsqueeze(0)
+
+    # Compute similarity with all other items
+    all_item_embeddings = model.item_embeddings.weight
+    similarity = F.cosine_similarity(item_embedding, all_item_embeddings)
+
+    # Get top N similar items (excluding the item itself)
+    top_similar_indices = torch.argsort(similarity, descending=True)[1:n_similar_items+1]
+
+    # Create a "virtual" user embedding based on the similar items
+    virtual_user_embedding = torch.mean(all_item_embeddings[top_similar_indices], dim=0).unsqueeze(0)
+
+    # Predict ratings for all items using this virtual user
+    n_items = model.item_embeddings.num_embeddings
+    all_items = torch.arange(n_items, device=device)
+
+    # Generate predictions in batches
+    batch_size = 1000
+    all_predictions = []
+
+    for i in range(0, n_items, batch_size):
+        batch_items = all_items[i:i+batch_size]
+        batch_users = virtual_user_embedding.repeat(len(batch_items), 1)
+        batch_items_emb = model.item_embeddings(batch_items)
+
+        # Concatenate user and item embeddings
+        embeddings = torch.cat([batch_users, batch_items_emb], dim=1)
+
+        # Pass through the network
+        with torch.no_grad():
+            preds = model.fc1(embeddings)
+            preds = F.relu(preds)
+            preds = model.fc2(preds)
+            preds = torch.sigmoid(preds) * (model.rating_range[1] - model.rating_range[0]) + model.rating_range[0]
+
+        all_predictions.append(preds)
+
+    predictions = torch.cat(all_predictions).squeeze()
+
+    # Get top N recommendations
+    top_indices = torch.argsort(predictions, descending=True)[:top_n]
+    top_items = all_items[top_indices].cpu().numpy()
+    top_scores = predictions[top_indices].cpu().numpy()
+
+    return top_items, top_scores
+
+# Example usage
+item_id = 5  # The item the new user has shown interest in
+
+top_items, top_scores = generate_recommendations_for_new_user(model, item_id)
+
+print("Recommendations based on item", item_id)
+for item, score in zip(top_items, top_scores):
+    print(f"Item ID: {item}, Predicted Rating: {score:.2f}")
+
+def generate_recommendations(movies,X,model,userId,encoder,device):
+    # Get predicted ratings for every movie
+    pred_ratings = []
+    for movie in movies['artist_album_id'].tolist():
+        genre = movies.loc[movies['artist_album_id']==movie,'track_name'].iloc[0]
+        pred = predict_rating(model,userId,movie,genre,encoder,device)
+        pred_ratings.append(pred.detach().cpu().item())
+        print(f"\r{len(pred_ratings)}\t{len(movies['artist_album_id'].tolist())}", end='')
+    # Sort movies by predicted rating
+    idxs = np.argsort(np.array(pred_ratings))[::-1]
+    recs = movies.iloc[idxs]['artist_album_id'].values.tolist()
+    # Filter out movies already watched by user
+    movies_watched = X.loc[X['playlist_id']==userId, 'artist_album_id'].tolist()
+    recs = [rec for rec in recs if not rec in movies_watched]
+    # Filter to top 10 recommendations
+    recs = recs[:10]
+    # Convert movieIDs to titles
+    recs_names = []
+    for rec in recs:
+        recs_names.append(movies.loc[movies['artist_album_id']==rec,'album_name'].values[0])
+    return recs_names
+
+import torch
+import torch.nn.functional as F
+
+def generate_rapid_recommendations(model, user_id, item_ids, genre_ids, top_n=10, batch_size=10000):
+    model.eval()
+    device = next(model.parameters()).device
+
+    # Prepare input data
+    num_items = len(item_ids)
+    users = torch.full((num_items,), user_id, dtype=torch.long, device=device)
+    items = torch.tensor(item_ids, dtype=torch.long, device=device)
+    genres = torch.tensor(genre_ids, dtype=torch.long, device=device)
+
+    # Initialize tensor to store all predictions
+    all_predictions = torch.zeros(num_items, device=device)
+
+    # Generate predictions in batches
+    with torch.no_grad():
+        for i in range(0, num_items, batch_size):
+            batch_users = users[i:i+batch_size]
+            batch_items = items[i:i+batch_size]
+            batch_genres = genres[i:i+batch_size]
+
+            X = torch.stack([batch_users, batch_items, batch_genres], dim=1)
+            batch_predictions = model(X).squeeze()
+            all_predictions[i:i+batch_size] = batch_predictions
+
+    # Get the top N recommendations
+    top_indices = torch.argsort(all_predictions, descending=True)[:top_n]
+    top_items = items[top_indices].cpu().numpy()
+    top_scores = all_predictions[top_indices].cpu().numpy()
+
+    return top_items, top_scores
+
+# Example usage
+user_id = 5  # The user you want recommendations for
+item_ids = list(df)  # Assume we have 10,000 items
+genre_ids = [0] * 10000  # Assume all items are of genre 0 for this example
+
+# Generate recommendations
+top_items, top_scores = generate_rapid_recommendations(model, user_id, item_ids, genre_ids)
+
+# Print results
+for item, score in zip(top_items, top_scores):
+    print(f"Item ID: {item}, Predicted Rating: {score:.2f}")
+
+# Get recommendations for a random user
+userId = 5
+movies = pd.read_csv(os.path.join(os.getcwd() + '/data/raw/mappings','artist_album.csv'))
+recs = generate_recommendations(movies,X,model,userId,encoder,device)
+for i,rec in enumerate(recs):
+  print('Recommendation {}: {}'.format(i,rec))
+

recommendation_module_project/recommender.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7c8e2b8fc581d039c84e3e0c9983b17a6fa328563c253a03b139d49dc87f3e9
+size 120583728