Deep Learning Recommendation Model

dlrm.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 itertools import combinations\nfrom scipy.sparse import coo_matrix\nfrom scipy.stats import rankdata\nfrom sklearn.preprocessing import StandardScaler","metadata":{"execution":{"iopub.status.busy":"2022-11-05T10:11:43.408638Z","iopub.execute_input":"2022-11-05T10:11:43.409197Z","iopub.status.idle":"2022-11-05T10:11:45.540036Z","shell.execute_reply.started":"2022-11-05T10:11:43.409088Z","shell.execute_reply":"2022-11-05T10:11:45.538996Z"},"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-05T10:11:45.542202Z","iopub.execute_input":"2022-11-05T10:11:45.542613Z","iopub.status.idle":"2022-11-05T10:11:45.612188Z","shell.execute_reply.started":"2022-11-05T10:11:45.542586Z","shell.execute_reply":"2022-11-05T10:11:45.610774Z"},"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, max_length=None):\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() if max_length is None else max_length# longest list is 736 sized\n    return max_len, 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-05T10:11:45.614025Z","iopub.execute_input":"2022-11-05T10:11:45.614614Z","iopub.status.idle":"2022-11-05T10:11:45.629650Z","shell.execute_reply.started":"2022-11-05T10:11:45.614576Z","shell.execute_reply":"2022-11-05T10:11:45.628739Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"def load_and_process_data_dlrm():\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    df_deep = filtred_data[continuous_cols] # this and embeddings will be fed to the deep part\n    \n    scaler = StandardScaler()\n    pd.options.mode.chained_assignment = None\n    for cc in continuous_cols:\n        df_deep[cc]  = scaler.fit_transform(df_deep[cc].values.reshape(-1,1))\n    \n    TEST_SIZE = 0.2 # size of test set\n    X_train_deep, X_test_deep = df_deep[:int(len(df_deep)*(1-TEST_SIZE))], df_deep[int(len(df_deep)*(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    # Train part\n    # tensor with binary features\n    # to get embeddings for sequence of indexes\n    # We use this as index for nn Embeddings and feed that along with X_train_tensor to deep part\n    max_train_len, movies_train_idx = sparse_to_idx(prev_movies_train, pad_idx=PAD_IDX)\n    movies_train_idx = torch.Tensor(movies_train_idx).long().to(device)\n    \n    _, movies_test_idx = sparse_to_idx(prev_movies_test, pad_idx=PAD_IDX, max_length=max_train_len)\n    movies_test_idx = torch.Tensor(movies_test_idx).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 continious features\n    X_train_deep_tensor = torch.Tensor(X_train_deep.fillna(0).values).to(device)\n    X_test_deep_tensor = torch.Tensor(X_test_deep.fillna(0).values).to(device)\n    \n    return X_train_deep_tensor, X_test_deep_tensor, movies_train_idx, movies_test_idx, target_train, target_test, target_test_sparse, items['movie id'].nunique() + 1\n\nclass DLRM(nn.Module):\n    def __init__(self, embed_dim, embed_size, deep_dim, n_fields, n_class, pad_idx=0, interaction_op=\"cat\"):\n        super().__init__()\n        self.embedding = nn.Embedding(embed_dim, embed_size, padding_idx=pad_idx, device=device)\n        \n        self.bottom_mlp_stack = nn.Sequential(\n            nn.Linear(deep_dim, 1024, device=device),\n            nn.ReLU(),\n            nn.Linear(1024, 512, device=device),\n            nn.ReLU(),\n            nn.Linear(512, embed_size, device=device),\n            nn.ReLU()\n        )\n        self.interaction_op = interaction_op # [\"dot\", \"cat\"]\n        if self.interaction_op == \"dot\":\n            p, q = zip(*list(combinations(range(n_fields), 2)))\n            self.field_p = nn.Parameter(torch.LongTensor(p), requires_grad=False)\n            self.field_q = nn.Parameter(torch.LongTensor(q), requires_grad=False)\n            self.interaction_units = int(n_fields * (n_fields - 1) / 2)\n            self.upper_triange_mask = nn.Parameter(torch.triu(torch.ones(n_fields, n_fields), 1).type(torch.ByteTensor),\n                                                   requires_grad=False)\n            # torchrec style implementation (as an alterante to above)\n            # self.triu_indices: torch.Tensor = torch.triu_indices(\n            #     self.n_fields + 1, self.n_fields + 1, offset=1\n            # )\n            self.top_input_dim = (n_fields * (n_fields - 1)) // 2 + embed_size\n        elif self.interaction_op == \"cat\":\n            self.top_input_dim = (n_fields+1) * embed_size\n        \n        self.top_mlp_stack = nn.Sequential(\n            nn.Linear(self.top_input_dim, 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_d, X_sparse_idx):\n        embed_x = self.embedding(X_sparse_idx) # movies_train_idx\n        \n        # bottom mlp\n        dense_out = self.bottom_mlp_stack(X_d).unsqueeze(1)\n        feat_emb = torch.cat([embed_x, dense_out], dim=1)\n        \n        # interaction\n        if self.interaction_op == \"dot\":\n            inner_product_matrix = torch.bmm(feat_emb, feat_emb.transpose(1, 2))\n            flat_upper_triange = torch.masked_select(inner_product_matrix, self.upper_triange_mask)\n            interact_out = flat_upper_triange.view(-1, self.interaction_units)\n            # torchrec style implementation (as an alterante to above)\n            # interactions = torch.bmm(\n            #     feat_emb, torch.transpose(feat_emb, 1, 2)\n            # )\n            # interactions_flat = interactions[:, self.triu_indices[0], self.triu_indices[1]]\n            # interact_out = torch.cat((dense_out, interactions_flat), dim=1)\n        else:\n            interact_out = feat_emb.flatten(start_dim=1) # torch.Size([76228, 11792]) 737*16\n        \n        # top mlp\n        output = self.top_mlp_stack(interact_out)\n        return output\n\ndef run_gradient_descent_dlrm(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(X_train_deep_tensor, 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(X_test_deep_tensor, 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-05T10:11:45.631505Z","iopub.execute_input":"2022-11-05T10:11:45.631947Z","iopub.status.idle":"2022-11-05T10:11:45.676732Z","shell.execute_reply.started":"2022-11-05T10:11:45.631915Z","shell.execute_reply":"2022-11-05T10:11:45.675849Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"X_train_deep_tensor, X_test_deep_tensor, movies_train_idx, movies_test_idx, target_train, target_test, target_test_sparse, n_classes = load_and_process_data_dlrm()","metadata":{"execution":{"iopub.status.busy":"2022-11-05T10:11:45.679835Z","iopub.execute_input":"2022-11-05T10:11:45.680539Z","iopub.status.idle":"2022-11-05T10:12:50.244892Z","shell.execute_reply.started":"2022-11-05T10:11:45.680487Z","shell.execute_reply":"2022-11-05T10:12:50.243751Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"code","source":"dlrm_model = DLRM(\n    embed_dim=n_classes,\n    embed_size=16,\n    deep_dim=X_train_deep_tensor.shape[1],\n    n_fields=movies_train_idx.shape[1],\n    n_class=n_classes,) # randomly chosen","metadata":{"execution":{"iopub.status.busy":"2022-11-05T10:12:50.246730Z","iopub.execute_input":"2022-11-05T10:12:50.247150Z","iopub.status.idle":"2022-11-05T10:12:50.261991Z","shell.execute_reply.started":"2022-11-05T10:12:50.247109Z","shell.execute_reply":"2022-11-05T10:12:50.260721Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"dlrm_model_trained, iters, train_losses, test_losses = run_gradient_descent_dlrm(dlrm_model, num_epochs=1000, weight_decay=0, learning_rate=0.03)","metadata":{"execution":{"iopub.status.busy":"2022-11-05T10:12:50.307143Z","iopub.execute_input":"2022-11-05T10:12:50.308132Z","iopub.status.idle":"2022-11-05T10:34:36.763541Z","shell.execute_reply.started":"2022-11-05T10:12:50.308096Z","shell.execute_reply":"2022-11-05T10:34:36.762617Z"},"trusted":true},"execution_count":11,"outputs":[{"name":"stdout","text":"Epoch: 0 | Loss: 7.42922, Acc: 0.08% | Test Loss: 539.31897, Test Acc: 0.44% Test mean rank: 1155\nEpoch: 100 | Loss: 6.56626, Acc: 1.23% | Test Loss: 7.09442, Test Acc: 0.52% Test mean rank: 922\nEpoch: 200 | Loss: 6.50729, Acc: 1.69% | Test Loss: 7.09041, Test Acc: 0.52% Test mean rank: 891\nEpoch: 300 | Loss: 6.47858, Acc: 1.93% | Test Loss: 7.07938, Test Acc: 0.52% Test mean rank: 791\nEpoch: 400 | Loss: 6.45101, Acc: 2.27% | Test Loss: 7.05669, Test Acc: 0.52% Test mean rank: 757\nEpoch: 500 | Loss: 6.43888, Acc: 2.59% | Test Loss: 7.06469, Test Acc: 0.52% Test mean rank: 749\nEpoch: 600 | Loss: 6.43282, Acc: 2.76% | Test Loss: 7.05829, Test Acc: 0.52% Test mean rank: 741\nEpoch: 700 | Loss: 6.42656, Acc: 2.93% | Test Loss: 7.06306, Test Acc: 0.52% Test mean rank: 739\nEpoch: 800 | Loss: 6.42380, Acc: 2.97% | Test Loss: 7.05855, Test Acc: 0.52% Test mean rank: 767\nEpoch: 900 | Loss: 6.41983, Acc: 3.33% | Test Loss: 7.06801, Test Acc: 0.52% Test mean rank: 793\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"}}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}