Neural Factorization Machine

nfm.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import torch\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport torch.nn as nn\n\nfrom scipy.sparse import coo_matrix\nfrom scipy.stats import rankdata\nfrom sklearn.preprocessing import StandardScaler","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:36:49.636960Z","iopub.execute_input":"2022-11-07T02:36:49.637458Z","iopub.status.idle":"2022-11-07T02:36:51.947487Z","shell.execute_reply.started":"2022-11-07T02:36:49.637356Z","shell.execute_reply":"2022-11-07T02:36:51.946391Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"code","source":"device = 'cuda' if torch.cuda.is_available() else 'cpu'\nPAD_IDX = 0","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:36:51.949739Z","iopub.execute_input":"2022-11-07T02:36:51.950715Z","iopub.status.idle":"2022-11-07T02:36:52.030409Z","shell.execute_reply.started":"2022-11-07T02:36:51.950671Z","shell.execute_reply":"2022-11-07T02:36:52.028560Z"},"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"code","source":"# purpose: convert target with index of movie to series of all zeros and one in place of index\n# We will use this to compute the expected output of the model to be compared with actual output\ndef idx_to_sparse(idx, sparse_dim):\n    sparse = np.zeros(sparse_dim) # vector of 1683 zeroes\n    sparse[int(idx)] = 1 # set a given index to 1\n    return pd.Series(sparse, dtype=int) # make a pandas series of 0s and 1s\n\n\n# Calculate accuracy (a classification metric)\ndef accuracy_fn(y_true, y_pred):\n    correct = torch.eq(y_true, y_pred).sum().item() # torch.eq() calculates where two tensors are equal\n    acc = (correct / len(y_pred)) * 100 \n    return acc\n\n# r,c = get_coo_indexes(dataset['prev movies'].tolist())\n# print(len(r), len(c))\n# 10150406 10150406\n# print(r[:11], c[:11])\n# [0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4] ['168', '168', '172', '168', '172', '165', '168', '172', '165', '156', '168']\n# basically the information that row0 has 168, row1 has 168 and 172, row2 has 168, 172, 165 and so on..\n# note that the length of first list represents number of \"1s\", while zip(first,second) gives row, col indices that should be one\ndef get_coo_indexes(lil):\n    rows = []\n    cols = []\n    for i, el in enumerate(lil):\n        if type(el)!=list:\n            el = [el]\n        for j in el:\n            rows.append(i)\n            cols.append(j)\n    return rows, cols\n\n\n# This function creates a sparse matrix given the \"prev movies\" column\ndef get_sparse_features(series, shape):\n    # get row, column pairs such that column value represents the watched movie\n    coo_indexes = get_coo_indexes(series.tolist())\n    # Create a matrix of 0s and 1s of size orignal dataset rows and number of movies as columns; then convert it into coord based sparse matrix\n    # sparse matrix would be of the size tuple (original rows count x number of movies); matrix starts with 1; we keep one extra column because movie id starts with 1 in the dataset\n    # In the tuple, first argument specifies the number of 1s to be put in the sparse matrix, the second item (another tuple) specified row and column indexes for the positions where corresponding each value ie. 1 should be placed in the sparse matrix\n    sparse_df = coo_matrix((np.ones(len(coo_indexes[0])), (coo_indexes[0], coo_indexes[1])), shape=shape)\n    return sparse_df\n\n\n# purpose: convert indexes of previous watched movies to series of films indexes\n# given a sparse matrix input, this function returns a corresponding padded 2D matrix\n# We use this to make binary features for the model training and testing\ndef sparse_to_idx(data, pad_idx=-1):\n    # Returns a tuple of arrays (row,col) containing the indices of the non-zero elements of the matrix.\n    indexes = data.nonzero()\n    # for prev_movies_train, this dataset will be 7957390 rows × 2 columns because of repeating values of rows\n    indexes_df = pd.DataFrame()\n    indexes_df['rows'] = indexes[0]\n    indexes_df['cols'] = indexes[1]\n    \n    # group by the rows, and make a list of all the corresponding columns\n    # rows\n    # 0                                [255, 286, 298, 185, 173]\n    # 1                      [255, 286, 298, 185, 173, 772, 108]\n    # 2                           [255, 286, 298, 185, 173, 772]\n    # 3                 [255, 286, 298, 185, 173, 772, 108, 288]\n    mdf = indexes_df.groupby('rows').apply(lambda x: x['cols'].tolist())\n    max_len = mdf.apply(lambda x: len(x)).max() # longest list is 736 sized\n    return mdf.apply(lambda x: pd.Series(x + [pad_idx] * (max_len - len(x)))).values # pad zeroes in the list upto 736 values; this result is (76228, 736) shaped","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:36:52.033409Z","iopub.execute_input":"2022-11-07T02:36:52.033787Z","iopub.status.idle":"2022-11-07T02:36:52.051198Z","shell.execute_reply.started":"2022-11-07T02:36:52.033750Z","shell.execute_reply":"2022-11-07T02:36:52.050165Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"def load_and_process_data_nfm():\n    #Load the Ratings data\n    data = pd.read_csv('../input/movielens-100k-dataset/ml-100k/u.data', sep=\"\\t\", header=None)\n    data.columns = ['user id', 'movie id', 'rating', 'timestamp']\n    #Load the User data\n    users = pd.read_csv('../input/movielens-100k-dataset/ml-100k/u.user', sep=\"|\", encoding='latin-1', header=None)\n    users.columns = ['user id', 'age', 'gender', 'occupation', 'zip code']\n    #Load movie data\n    items = pd.read_csv('../input/movielens-100k-dataset/ml-100k/u.item', \n                    sep=\"|\", encoding='latin-1', header=None)\n    items.columns = ['movie id', 'movie title' ,'release date','video release date', 'IMDb URL', \n                     'unknown', 'Action', 'Adventure', 'Animation', 'Children\\'s', 'Comedy', \n                     'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', \n                     'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Thriller', 'War', 'Western']\n    GENRES = pd.read_csv('../input/movielens-100k-dataset/ml-100k/u.genre', \n                     sep=\"|\", header=None, usecols=[0])[0].tolist()\n    \n    # Sort the dataset by user-id and time\n    dataset = data.sort_values(['user id', 'timestamp']).reset_index(drop=True)\n    dataset['one'] = 1 # add a column containing all 1s\n    dataset['sample_num'] = dataset.groupby('user id')['one'].cumsum() # use the 1s column to create a sample number for each user\n    # Create a target column by shifting movie-id for each user-id one step back, effectively this means that we have a column that has id for the next movie the user is going to watch \n    # (it is NaN for the row representing the last movie the user watches). We will predict this column.\n    dataset['target'] = dataset.groupby('user id')['movie id'].shift(-1)\n    # create a column that represents average movie rating given by user till that time (represented by row)\n    dataset['mean_rate'] = dataset.groupby('user id')['rating'].cumsum() / dataset['sample_num']\n    \n    # Create a column that has a list of movies that the user has watched so far. We will create sparse vector and embedding vectors from this later on.\n    dataset['prev movies'] = dataset['movie id'].apply(lambda x: str(x))\n    dataset['prev movies'] = dataset.groupby('user id')['prev movies'].apply(lambda x: (x + ' ').cumsum().str.strip())\n    dataset['prev movies'] = dataset['prev movies'].apply(lambda x: x.split())\n    \n    # do a left join with movies dataframe and bring all the genre representations (0/1 binary values for each movie representing its category) here.\n    dataset = dataset.merge(items[['movie id'] + GENRES], on='movie id', how='left')\n    \n    # For each genre column (19) creates another column (total 19 more). This column represents a given user's mean score (float value) for a given genre till that time (represented by row).\n    # Note that we also update the genre columns such that each column now has cumulative sum, i.e. the corresponding number of movies that the user has watched in that genre so far.\n    for genre in GENRES:\n        dataset[f'{genre}_rate'] = dataset[genre]*dataset['rating']\n        dataset[genre] = dataset.groupby('user id')[genre].cumsum()\n        dataset[f'{genre}_rate'] = dataset.groupby('user id')[f'{genre}_rate'].cumsum() / dataset[genre]\n    \n    # Next we normalize the scores for movies in each genre such that we divide it by the number of movies that the user has watched so far.\n    dataset[GENRES] = dataset[GENRES].apply(lambda x: x / dataset['sample_num'])\n    # do a left-join on users data and get more information on users\n    dataset = dataset.merge(users, on='user id', how='left')\n    \n    occupations_categoricals = dataset['occupation'].unique().tolist()\n\n    dataset['gender'] = (dataset['gender'] == 'M').astype(int) # change gender to 0/1 integer\n    dataset = pd.concat([dataset.drop(['occupation'], axis=1), pd.get_dummies(dataset[['occupation']], prefix=\"\", prefix_sep=\"\")], axis=1) # get occupation dummy variables and drop occupation column\n    dataset.drop('zip code', axis=1, inplace=True)\n    \n    COLD_START_TRESH = 5 # take the rows AFTER each user has watched at least 4 movies\n    # filter using threshold and remove null target rows\n    filtred_data = dataset[(dataset['sample_num'] >= COLD_START_TRESH) &\n                           ~(dataset['target'].isna())].sort_values('timestamp')\n    \n    continuous_cols = ['age', 'gender', 'mean_rate'] + GENRES + [gen+\"_rate\" for gen in GENRES] # 41\n    categoricals = occupations_categoricals# already dummy encoded\n    wide_data_column_names = continuous_cols + categoricals\n    df_wide = filtred_data[wide_data_column_names]\n    \n    scaler = StandardScaler()\n    pd.options.mode.chained_assignment = None\n    \n    TEST_SIZE = 0.2 # size of test set\n    X_train_wide, X_test_wide = df_wide[:int(len(df_wide)*(1-TEST_SIZE))], df_wide[int(len(df_wide)*(1-TEST_SIZE)):]\n\n    filtered_train_data, filtered_test_data = filtred_data[:int(len(filtred_data)*(1-TEST_SIZE))], filtred_data[int(len(filtred_data)*(1-TEST_SIZE)):]\n    y_train, y_test = filtered_train_data['target'], filtered_test_data['target']\n    \n    # create sparse matrix out of prev_movies column for both train and test sets\n    prev_movies_train = get_sparse_features(filtered_train_data['prev movies'], (len(filtered_train_data), filtred_data['movie id'].max()+1))\n    prev_movies_test = get_sparse_features(filtered_test_data['prev movies'], (len(filtered_test_data), filtred_data['movie id'].max()+1))\n\n    # tensor with sequence of indexes\n    movies_train_tensor = torch.sparse_coo_tensor(\n        indices=prev_movies_train.nonzero(), # The indices are the coordinates of the non-zero values in the matrix (7957390,7957390)\n        values=[1]*len(prev_movies_train.nonzero()[0]), # Initial values for the tensor, 7957390 1s\n        size=prev_movies_train.shape #  Size of the sparse tensor (76228, 1683)\n    ).to_dense().to(device)\n    \n    movies_test_tensor = torch.sparse_coo_tensor(\n        indices=prev_movies_test.nonzero(), \n        values=[1]*len(prev_movies_test.nonzero()[0]),\n        size=prev_movies_test.shape\n    ).to_dense().to(device)\n    \n    # Train part\n    # tensor with binary features\n    # to get embeddings for sequence of indexes\n    movies_train_idx = torch.Tensor(\n        sparse_to_idx(prev_movies_train, pad_idx=PAD_IDX),\n    ).long().to(device)\n    \n    movies_test_idx = torch.Tensor(\n        sparse_to_idx(prev_movies_test, pad_idx=PAD_IDX),\n    ).long().to(device)\n    \n    # target\n    target_train = torch.Tensor(y_train.values).long().to(device)\n    target_test = torch.Tensor(y_test.values).long().to(device)\n    target_test_sparse = y_test.apply(lambda x: idx_to_sparse(x, items['movie id'].nunique() + 1)) # to calculate mean rank over test set during training\n    \n    # tensor with continuous features\n    X_train_wide_tensor = torch.Tensor(X_train_wide.fillna(0).values).to(device)\n    X_test_wide_tensor = torch.Tensor(X_test_wide.fillna(0).values).to(device)\n    \n    return X_train_wide_tensor, X_test_wide_tensor, movies_train_tensor, movies_test_tensor, movies_train_idx, movies_test_idx, target_train, target_test, target_test_sparse, items['movie id'].nunique() + 1\n\nclass NFM(nn.Module):\n    def __init__(self, embed_dim, embed_size, wide_dim, n_class, pad_idx=0):\n        super().__init__()\n        self.embedding = nn.Embedding(embed_dim, embed_size, padding_idx=pad_idx, device=device)\n        self.linear_layer = nn.Linear(wide_dim, n_class, device=device)\n        \n        self.linear_relu_stack = nn.Sequential(\n            nn.Linear(1, 1024, device=device),\n            nn.ReLU(),\n            nn.Linear(1024, 512, device=device),\n            nn.ReLU(),\n            nn.Linear(512, n_class, device=device),\n            nn.ReLU()\n        )\n\n    def forward(self, X_w, X_sparse_idx):\n        embed_x = self.embedding(X_sparse_idx) # movies_train_idx\n        embed_x = torch.mean(embed_x, dim=1)\n        \n        # FM\n        square_of_sum = torch.sum(embed_x, dim=1) ** 2\n        sum_of_square = torch.sum(embed_x ** 2, dim=1)\n        out_inter = 0.5 * (square_of_sum - sum_of_square)\n        # Linear\n        out_lin = self.linear_layer(X_w)\n        # Deep\n        out_deep = self.linear_relu_stack(out_inter.unsqueeze(1))\n        \n        output = out_deep + out_lin\n        return output\n\ndef run_gradient_descent_nfm(model,\n    learning_rate=1e-3,\n    weight_decay=0.01,\n    num_epochs=10):\n    loss_fn = nn.CrossEntropyLoss(ignore_index=PAD_IDX) # the model doesn't need to predict padding index\n    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n    \n    iters, train_losses, test_losses, mean_test_ranks = [], [], [], []\n    \n    # training\n    n = 0 # the number of iterations\n    for epoch in range(num_epochs):\n        model.train()\n        y_logits = model(torch.cat([X_train_wide_tensor, movies_train_tensor], dim=1), movies_train_idx)\n        loss_train = loss_fn(y_logits, target_train)\n\n        # Backpropagation\n        optimizer.zero_grad() # a clean up step for PyTorch\n        loss_train.backward() # compute updates for each parameter\n        optimizer.step() # make the updates for each parameter\n\n        # save the current training information\n        if n%100 == 0:\n            pred_train = torch.softmax(y_logits, dim=1).argmax(dim=1)\n            acc = accuracy_fn(y_true=target_train, y_pred=pred_train)\n            \n            model.eval()\n            with torch.inference_mode():\n                test_logits = model(torch.cat([X_test_wide_tensor, movies_test_tensor], dim=1), movies_test_idx)\n                test_pred = torch.softmax(test_logits, dim=1).argmax(dim=1)\n                loss_test = loss_fn(test_logits, target_test)\n                test_acc = accuracy_fn(y_true=target_test,y_pred=test_pred)\n            \n            # calculate mean rank on test set\n            softmax = nn.Softmax(dim=0)\n            preds_wnd = softmax(test_logits.float()).cpu().detach().numpy()\n            ranks_wnd = pd.DataFrame(preds_wnd).apply(lambda x: pd.Series(rankdata(-x)), axis=1)\n            ranks_target_wnd = (ranks_wnd.values * target_test_sparse).sum(axis=1)\n            mean_rank_wnd = ranks_target_wnd.mean()\n            \n            print(f\"Epoch: {epoch} | Loss: {loss_train:.5f}, Acc: {acc:.2f}% | Test Loss: {loss_test:.5f}, Test Acc: {test_acc:.2f}% Test mean rank: {mean_rank_wnd:.0f}\")\n            \n            iters.append(n)\n            train_losses.append(float(loss_train))\n            test_losses.append(float(loss_test))\n            mean_test_ranks.append(mean_rank_wnd)\n            \n            # increment the iteration number\n        n += 1\n    \n    # plotting\n    plt.figure(figsize=(12, 8), dpi=100)\n    plt.title(f\"Training Curve (lr={learning_rate})\")\n    plt.plot(iters, train_losses, label=\"Train Loss\")\n    plt.plot(iters, test_losses, label=\"Test Loss\")\n    plt.xlabel(\"Iterations\")\n    plt.ylabel(\"Loss\")\n    plt.legend(loc='best')\n    plt.show()\n    \n    plt.figure(figsize=(12, 8), dpi=100)\n    plt.plot(iters, mean_test_ranks, label=\"Test Rank\")\n    plt.xlabel(\"Iterations\")\n    plt.ylabel(\"Mean Rank on testset\")\n    plt.legend(loc='best')\n    plt.show()\n    \n    return model, iters, train_losses, test_losses","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:36:52.056103Z","iopub.execute_input":"2022-11-07T02:36:52.056855Z","iopub.status.idle":"2022-11-07T02:36:52.108214Z","shell.execute_reply.started":"2022-11-07T02:36:52.056799Z","shell.execute_reply":"2022-11-07T02:36:52.106378Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"X_train_wide_tensor, X_test_wide_tensor, movies_train_tensor, movies_test_tensor, movies_train_idx, movies_test_idx, target_train, target_test, target_test_sparse, n_classes = load_and_process_data_nfm()","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:36:52.109803Z","iopub.execute_input":"2022-11-07T02:36:52.110165Z","iopub.status.idle":"2022-11-07T02:38:05.135473Z","shell.execute_reply.started":"2022-11-07T02:36:52.110113Z","shell.execute_reply":"2022-11-07T02:38:05.134316Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:81: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  /usr/local/src/pytorch/torch/csrc/utils/tensor_new.cpp:207.)\n","output_type":"stream"}]},{"cell_type":"code","source":"nfm_model = NFM(wide_dim=torch.cat([X_train_wide_tensor, movies_train_tensor], dim=1).shape[1],\n        n_class=n_classes,\n        embed_dim=n_classes,\n        embed_size=16,) # randomly chosen","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:38:05.137117Z","iopub.execute_input":"2022-11-07T02:38:05.137500Z","iopub.status.idle":"2022-11-07T02:38:05.156925Z","shell.execute_reply.started":"2022-11-07T02:38:05.137461Z","shell.execute_reply":"2022-11-07T02:38:05.156099Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"nfm_model_trained, iters, train_losses, test_losses = run_gradient_descent_nfm(nfm_model, num_epochs=1500, weight_decay=0, learning_rate=0.03)","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:38:05.158412Z","iopub.execute_input":"2022-11-07T02:38:05.158849Z","iopub.status.idle":"2022-11-07T02:56:55.930795Z","shell.execute_reply.started":"2022-11-07T02:38:05.158793Z","shell.execute_reply":"2022-11-07T02:56:55.929754Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"Epoch: 0 | Loss: 7.58600, Acc: 0.06% | Test Loss: 32.42220, Test Acc: 0.43% Test mean rank: 966\nEpoch: 100 | Loss: 2.82782, Acc: 38.75% | Test Loss: 11.44560, Test Acc: 1.35% Test mean rank: 965\nEpoch: 200 | Loss: 1.92606, Acc: 59.25% | Test Loss: 14.28082, Test Acc: 1.27% Test mean rank: 913\nEpoch: 300 | Loss: 1.46414, Acc: 71.32% | Test Loss: 16.97747, Test Acc: 1.20% Test mean rank: 878\nEpoch: 400 | Loss: 1.19138, Acc: 78.74% | Test Loss: 19.42645, Test Acc: 1.12% Test mean rank: 853\nEpoch: 500 | Loss: 1.00358, Acc: 83.52% | Test Loss: 21.65411, Test Acc: 1.11% Test mean rank: 834\nEpoch: 600 | Loss: 0.86592, Acc: 86.77% | Test Loss: 23.70844, Test Acc: 1.05% Test mean rank: 821\nEpoch: 700 | Loss: 0.76175, Acc: 89.04% | Test Loss: 25.62745, Test Acc: 1.03% Test mean rank: 811\nEpoch: 800 | Loss: 0.67870, Acc: 90.92% | Test Loss: 27.44921, Test Acc: 1.04% Test mean rank: 804\nEpoch: 900 | Loss: 0.97516, Acc: 82.44% | Test Loss: 29.29519, Test Acc: 0.98% Test mean rank: 793\nEpoch: 1000 | Loss: 0.57078, Acc: 92.68% | Test Loss: 30.51948, Test Acc: 1.03% Test mean rank: 784\nEpoch: 1100 | Loss: 0.52215, Acc: 93.62% | Test Loss: 31.84329, Test Acc: 1.02% Test mean rank: 784\nEpoch: 1200 | Loss: 0.48289, Acc: 94.31% | Test Loss: 33.14582, Test Acc: 1.04% Test mean rank: 785\nEpoch: 1300 | Loss: 0.44872, Acc: 94.85% | Test Loss: 34.42956, Test Acc: 1.00% Test mean rank: 787\nEpoch: 1400 | Loss: 0.41858, Acc: 95.29% | Test Loss: 35.69404, Test Acc: 0.99% Test mean rank: 790\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x800 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x800 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]}]}