6. Run music paper's code on sampled dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bf74ec66",
   "metadata": {},
   "source": [
    "# Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e329ab58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import random as rd\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from collections import defaultdict\n",
    "from scipy import stats\n",
    "from surprise import AlgoBase\n",
    "from surprise import BaselineOnly\n",
    "from surprise import KNNBasic\n",
    "from surprise import KNNWithMeans\n",
    "from surprise import NMF\n",
    "from surprise import Dataset\n",
    "from surprise import Reader\n",
    "from surprise import accuracy\n",
    "from surprise.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af233b13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# constants and initialization\n",
    "item_threshold = 1 # 1 means no filtering\n",
    "my_seed = 0\n",
    "rd.seed(my_seed)\n",
    "np.random.seed(my_seed)\n",
    "predict_col = 'artist'\n",
    "top_fraction = 0.2\n",
    "user_events_file = 'https://raw.githubusercontent.com/SavvinaDaniil/UnfairnessOfPopularityBias/main/data/relevant_music_data_20.csv'\n",
    "low_user_file = 'data/low_main_users.txt'\n",
    "medium_user_file = 'data/medium_main_users.txt'\n",
    "high_user_file = 'data/high_main_users.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8603b5e2-a986-4733-8276-eedba22eebd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# read user events\n",
    "cols = ['user', 'artist','count']\n",
    "df_events = pd.read_csv(user_events_file,  names=cols, header=0)\n",
    "print('No. of user events: ' + str(len(df_events)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7446d2c7-9f90-4c58-82c3-125a22d5f1e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e521ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('No. filtered user events: ' + str(len(df_events)))\n",
    "print('No. filtered items: ' + str(len(df_events[predict_col].unique())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ad42ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get user distribution\n",
    "user_dist = df_events['user'].value_counts()\n",
    "num_users = len(user_dist)\n",
    "print('Mean artists per user: ' + str(user_dist.mean()))\n",
    "print('Min artists per user: ' + str(user_dist.min()))\n",
    "print('Max artists per user: ' + str(user_dist.max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59d54a60-d83c-4efd-bb08-738bb133f9a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get item distribution\n",
    "item_dist = df_events[predict_col].value_counts()\n",
    "num_items = len(item_dist)\n",
    "print('No. items: ' + str(num_items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7f36233-4164-4c9c-b2fc-f8c4d5d4b14e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get top items\n",
    "num_top = int(top_fraction * num_items)\n",
    "top_item_dist = item_dist.loc[:num_top]\n",
    "print('No. top items: ' + str(len(top_item_dist)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ecc0aba-0d34-47df-8858-fe491b439a4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# read users\n",
    "low_users = pd.read_csv(low_user_file, sep=',').set_index('user_id')\n",
    "medium_users = pd.read_csv(medium_user_file, sep=',').set_index('user_id')\n",
    "high_users = pd.read_csv(high_user_file, sep=',').set_index('user_id')\n",
    "no_users = len(low_users) + len(medium_users) + len(high_users)\n",
    "print('No. of users: ' + str(no_users))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f60a87a-a9ab-4eeb-ae7f-8302588eeb5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get pop fractions\n",
    "pop_count = [] # number of top items per user\n",
    "user_hist = [] # user history sizes\n",
    "pop_fraq = [] # relative number of top items per user\n",
    "pop_item_fraq = [] # average popularity of items in user profiles\n",
    "low_profile_size = 0\n",
    "low_gap = 0\n",
    "medium_profile_size = 0\n",
    "medium_gap = 0\n",
    "high_profile_size = 0\n",
    "high_gap = 0\n",
    "low_count = 0\n",
    "med_count = 0\n",
    "high_count = 0\n",
    "for u, df in df_events.groupby('user'):\n",
    "    no_user_items = len(set(df[predict_col])) # profile size\n",
    "    no_user_pop_items = len(set(df[predict_col]) & set(top_item_dist.index)) # top items in profile\n",
    "    pop_count.append(no_user_pop_items)\n",
    "    user_hist.append(no_user_items)\n",
    "    pop_fraq.append(no_user_pop_items / no_user_items)\n",
    "    # get popularity (= fraction of users interacted with item) of user items and calculate average of it\n",
    "    user_pop_item_fraq = sum(item_dist[df[predict_col]] / no_users) / no_user_items\n",
    "    pop_item_fraq.append(user_pop_item_fraq)\n",
    "    if u in low_users.index: # get user group-specific values\n",
    "        low_profile_size += no_user_items\n",
    "        low_gap += user_pop_item_fraq\n",
    "        low_count += 1\n",
    "    elif u in medium_users.index:\n",
    "        medium_profile_size += no_user_items\n",
    "        medium_gap += user_pop_item_fraq\n",
    "        med_count += 1\n",
    "    else:\n",
    "        high_profile_size += no_user_items\n",
    "        high_gap += user_pop_item_fraq\n",
    "        high_count += 1\n",
    "low_profile_size /= len(low_users)\n",
    "medium_profile_size /= len(medium_users)\n",
    "high_profile_size /= len(high_users)\n",
    "low_gap /= len(low_users)\n",
    "medium_gap /= len(medium_users)\n",
    "high_gap /= len(high_users)\n",
    "print('Low count (for check): ' + str(low_count))\n",
    "print('Med count (for check): ' + str(med_count))\n",
    "print('High count (for check): ' + str(high_count))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c024fe93-3657-4716-b6e7-e8d709750226",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot(sorted(pop_fraq))\n",
    "plt.xlabel('User', fontsize='15')\n",
    "plt.xticks(fontsize='13')\n",
    "plt.ylabel('Ratio of popular artists', fontsize='15')\n",
    "plt.yticks(fontsize='13')\n",
    "plt.axhline(y=0.8, color='black', linestyle='--', label='80% ratio of popular artists')\n",
    "plt.legend(fontsize='15')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f2a0169-2cce-469d-b82b-e7c83745be10",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Average LowMS profile size: ' + str(low_profile_size))\n",
    "print('Average MedMS profile size: ' + str(medium_profile_size))\n",
    "print('Average HighMS profile size: ' + str(high_profile_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e72cdf92-d22d-4dbd-9b4d-af7b9ebe10a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "scaled_df_events = pd.DataFrame()\n",
    "for user_id, group in df_events.groupby('user'):\n",
    "    min_rating = group['count'].min()\n",
    "    max_rating = group['count'].max()\n",
    "    scaler = MinMaxScaler(feature_range=(1, 1000))\n",
    "    scaled_ratings = scaler.fit_transform(group['count'].values.reshape(-1, 1).astype(float))\n",
    "    new_rows = group.copy()\n",
    "    new_rows['count'] = scaled_ratings\n",
    "    scaled_df_events = scaled_df_events.append(new_rows)\n",
    "\n",
    "scaled_df_events.head()\n",
    "#scaled_df_events = scaled_df_events.set_index('user') # needed for new python/surprise version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f37f38e-0751-41c5-92da-d154ca1a1646",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_events = scaled_df_events\n",
    "print('Min rating: ' + str(df_events['count'].min()))\n",
    "print('Max rating: ' + str(df_events['count'].max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ba65565-a562-4465-885f-eef9916206b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "reader = Reader(rating_scale=(df_events['count'].min(), df_events['count'].max()))\n",
    "df_events.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d6b1da7-cd9c-4bc5-bab4-79921a9e21e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The columns must correspond to user id, item id and ratings (in that order).\n",
    "data = Dataset.load_from_df(df_events, reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd69147e-b7ef-4ff0-85c1-b29a14b087ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainset, testset = train_test_split(data, test_size = 0.2, random_state = my_seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30d258ac-fbba-4249-98e7-5535c2c0bbc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_n(predictions, n=10):\n",
    "    # First map the predictions to each user.\n",
    "    top_n = defaultdict(list)\n",
    "    for uid, iid, true_r, est, _ in predictions:\n",
    "        top_n[uid].append((iid, est))\n",
    "    # Then sort the predictions for each user and retrieve the k highest ones.\n",
    "    for uid, user_ratings in top_n.items():\n",
    "        user_ratings.sort(key=lambda x: x[1], reverse=True)\n",
    "        top_n[uid] = user_ratings[:n]\n",
    "    return top_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1da92568-ca25-4d8b-8217-c84e1d5ea06c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_n_random(testset, n=10):\n",
    "    top_n = defaultdict(list)\n",
    "    for uid, iid, true_r in testset:\n",
    "        if len(top_n[uid]) == 0:\n",
    "            for i in range(0, 10):\n",
    "                top_n[uid].append((rd.choice(item_dist.index), i))\n",
    "    return top_n\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3923f04a-a77a-46e7-bca1-795f154d11a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_n_mp(testset, n=10):\n",
    "    top_n = defaultdict(list)\n",
    "    for uid, iid, true_r in testset:\n",
    "        if len(top_n[uid]) == 0:\n",
    "            for iid, count in item_dist[:n].items():\n",
    "                top_n[uid].append((iid, count))\n",
    "    return top_n\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "405cc84b-3188-45bd-8926-925e278f8f4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mae_of_groups(predictions):\n",
    "    print('All: ')\n",
    "    accuracy.mae(predictions)\n",
    "    low_predictions = []\n",
    "    med_predictions = []\n",
    "    high_predictions = []\n",
    "    for uid, iid, true_r, est, details in predictions:\n",
    "        prediction = [(uid, iid, true_r, est, details)]\n",
    "        if uid in low_users.index:\n",
    "            low_predictions.append(accuracy.mae(prediction, verbose=False))\n",
    "        elif uid in medium_users.index:\n",
    "            med_predictions.append(accuracy.mae(prediction, verbose=False))\n",
    "        else:\n",
    "            high_predictions.append(accuracy.mae(prediction, verbose=False))\n",
    "    print('LowMS: ' + str(np.mean(low_predictions)))\n",
    "    print('MedMS: ' + str(np.mean(med_predictions)))\n",
    "    print('HighMS: ' + str(np.mean(high_predictions)))\n",
    "    print(stats.ttest_ind(low_predictions, high_predictions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f095cefc-d6b6-461d-89b7-c978e65f906a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create item dataframe with normalized item counts\n",
    "df_item_dist = pd.DataFrame(item_dist)\n",
    "df_item_dist.columns = ['count']\n",
    "df_item_dist['count'] /= no_users\n",
    "#df_item_dist.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40c3f411-8a3a-45c2-aad8-2927f4d00504",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_users = {'name': 'cosine', 'user_based': True}  # compute cosine similarities between users\n",
    "algos = [] # Random and MostPopular is calculated by default\n",
    "algos.append(KNNBasic(sim_options = sim_users, k=40)) \n",
    "algos.append(KNNWithMeans(sim_options = sim_users, k=40)) \n",
    "algos.append(NMF(n_factors = 15))\n",
    "algo_names = [\n",
    "              'UserKNN',\n",
    "              'UserKNNAvg',\n",
    "              'NMF']\n",
    "\n",
    "i = 0\n",
    "low_rec_gap_list = [] # one entry per algorithmus\n",
    "medium_rec_gap_list = []\n",
    "high_rec_gap_list = []\n",
    "for i in range(0, len(algo_names)):\n",
    "    df_item_dist[algo_names[i]] = 0\n",
    "    low_rec_gap = 0\n",
    "    medium_rec_gap = 0\n",
    "    high_rec_gap = 0\n",
    "    \n",
    "    # get accuracy for personalized approaches\n",
    "    if algo_names[i] != 'Random' and algo_names[i] != 'MostPopular':\n",
    "        algos[i].fit(trainset)\n",
    "        predictions = algos[i].test(testset)\n",
    "        print(algo_names[i])\n",
    "        get_mae_of_groups(predictions)\n",
    "    \n",
    "    # get top-n items and calculate gaps for all algorithms\n",
    "    if algo_names[i] == 'Random':\n",
    "        top_n = get_top_n_random(testset, n=10)\n",
    "    elif algo_names[i] == 'MostPopular':\n",
    "        top_n = get_top_n_mp(testset, n=10)\n",
    "    else:\n",
    "        top_n = get_top_n(predictions, n=10)\n",
    "    low_count = 0\n",
    "    med_count = 0\n",
    "    high_count = 0\n",
    "    for uid, user_ratings in top_n.items():\n",
    "        iid_list = []\n",
    "        for (iid, _) in user_ratings:\n",
    "            df_item_dist.loc[iid, algo_names[i]] += 1\n",
    "            iid_list.append(iid)\n",
    "        gap = sum(item_dist[iid_list] / no_users) / len(iid_list)\n",
    "        if uid in low_users.index:\n",
    "            low_rec_gap += gap\n",
    "            low_count += 1\n",
    "        elif uid in medium_users.index:\n",
    "            medium_rec_gap += gap\n",
    "            med_count += 1\n",
    "        elif uid in high_users.index:\n",
    "            high_rec_gap += gap\n",
    "            high_count += 1\n",
    "    low_rec_gap_list.append(low_rec_gap / low_count)\n",
    "    medium_rec_gap_list.append(medium_rec_gap / med_count)\n",
    "    high_rec_gap_list.append(high_rec_gap / high_count)\n",
    "    i += 1 # next algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f7a012f-1500-49b0-bcf9-0e016339adb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, len(algo_names)):\n",
    "    plt.figure()\n",
    "    x = df_item_dist['count']\n",
    "    y = df_item_dist[algo_names[i]]\n",
    "    plt.title(algo_names[i])\n",
    "    #slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)\n",
    "    #line = slope * np.array(x) + intercept\n",
    "    #print(r_value)\n",
    "    if algo_names[i] != 'Random' and algo_names[i] != 'MostPopular':\n",
    "        plt.gca().set_ylim(0, 300)\n",
    "    plt.plot(x, y, 'o')#, x, line)\n",
    "    plt.xlabel('Item popularity in profile', fontsize='15')\n",
    "    plt.ylabel('Recommendation frequency', fontsize='15')\n",
    "    plt.xticks(fontsize='13')\n",
    "    plt.yticks(fontsize='13')\n",
    "    plt.savefig(\"graphs/\"+algo_names[i]+\"_sampled_data_results_new.png\")\n",
    "    plt.show()\n",
    "    #plt.savefig('data/ECIR/rec_' + algo_names[i] + '.png', dpi=300, bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}