DeepFM

deepfm.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:59:39.021558Z","iopub.execute_input":"2022-11-07T02:59:39.022790Z","iopub.status.idle":"2022-11-07T02:59:41.140032Z","shell.execute_reply.started":"2022-11-07T02:59:39.022675Z","shell.execute_reply":"2022-11-07T02:59:41.138841Z"},"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:59:41.142411Z","iopub.execute_input":"2022-11-07T02:59:41.143016Z","iopub.status.idle":"2022-11-07T02:59:41.211984Z","shell.execute_reply.started":"2022-11-07T02:59:41.142978Z","shell.execute_reply":"2022-11-07T02:59:41.210984Z"},"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:59:41.213850Z","iopub.execute_input":"2022-11-07T02:59:41.214562Z","iopub.status.idle":"2022-11-07T02:59:41.227750Z","shell.execute_reply.started":"2022-11-07T02:59:41.214474Z","shell.execute_reply":"2022-11-07T02:59:41.226706Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"def load_and_process_data_deepfm():\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 DeepFM(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(embed_size, 1024, device=device),\n            nn.ReLU(),\n            nn.Linear(1024, 512, device=device),\n            nn.ReLU(),\n            nn.Linear(512, 256, device=device),\n            nn.ReLU()\n        )\n        self.output = nn.Linear(256+1, n_class, device=device)\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(embed_x)\n        \n        output = self.output(torch.cat((out_inter.unsqueeze(1), out_deep), dim=1)) + out_lin\n        return output\n\ndef run_gradient_descent_deepfm(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:59:41.231556Z","iopub.execute_input":"2022-11-07T02:59:41.231826Z","iopub.status.idle":"2022-11-07T02:59:41.273320Z","shell.execute_reply.started":"2022-11-07T02:59:41.231801Z","shell.execute_reply":"2022-11-07T02:59:41.271973Z"},"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_deepfm()","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:59:41.274897Z","iopub.execute_input":"2022-11-07T02:59:41.275312Z","iopub.status.idle":"2022-11-07T03:00:48.835362Z","shell.execute_reply.started":"2022-11-07T02:59:41.275264Z","shell.execute_reply":"2022-11-07T03:00:48.834123Z"},"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":"deepfm_model = DeepFM(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-07T03:00:48.837040Z","iopub.execute_input":"2022-11-07T03:00:48.837736Z","iopub.status.idle":"2022-11-07T03:00:48.862030Z","shell.execute_reply.started":"2022-11-07T03:00:48.837697Z","shell.execute_reply":"2022-11-07T03:00:48.861207Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"deepfm_model_trained, iters, train_losses, test_losses = run_gradient_descent_deepfm(deepfm_model, num_epochs=1500, weight_decay=0, learning_rate=0.03)","metadata":{"execution":{"iopub.status.busy":"2022-11-07T03:00:48.863541Z","iopub.execute_input":"2022-11-07T03:00:48.864178Z","iopub.status.idle":"2022-11-07T03:19:14.762165Z","shell.execute_reply.started":"2022-11-07T03:00:48.864140Z","shell.execute_reply":"2022-11-07T03:19:14.761188Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"Epoch: 0 | Loss: 7.53568, Acc: 0.04% | Test Loss: 16.97324, Test Acc: 0.27% Test mean rank: 951\nEpoch: 100 | Loss: 2.62395, Acc: 42.59% | Test Loss: 11.62288, Test Acc: 1.30% Test mean rank: 908\nEpoch: 200 | Loss: 1.74222, Acc: 62.17% | Test Loss: 14.83390, Test Acc: 1.12% Test mean rank: 830\nEpoch: 300 | Loss: 1.31452, Acc: 74.47% | Test Loss: 17.82988, Test Acc: 1.11% Test mean rank: 762\nEpoch: 400 | Loss: 1.05564, Acc: 81.14% | Test Loss: 20.57037, Test Acc: 1.09% Test mean rank: 703\nEpoch: 500 | Loss: 0.87396, Acc: 86.14% | Test Loss: 23.01068, Test Acc: 1.08% Test mean rank: 693\nEpoch: 600 | Loss: 0.74620, Acc: 88.89% | Test Loss: 25.18114, Test Acc: 1.04% Test mean rank: 702\nEpoch: 700 | Loss: 0.65234, Acc: 91.30% | Test Loss: 27.40661, Test Acc: 0.96% Test mean rank: 732\nEpoch: 800 | Loss: 0.56963, Acc: 93.18% | Test Loss: 29.28725, Test Acc: 0.99% Test mean rank: 739\nEpoch: 900 | Loss: 0.51674, Acc: 93.56% | Test Loss: 31.22412, Test Acc: 0.93% Test mean rank: 769\nEpoch: 1000 | Loss: 0.44811, Acc: 95.44% | Test Loss: 33.03899, Test Acc: 0.98% Test mean rank: 784\nEpoch: 1100 | Loss: 0.41048, Acc: 95.70% | Test Loss: 34.92923, Test Acc: 1.05% Test mean rank: 809\nEpoch: 1200 | Loss: 0.36680, Acc: 96.64% | Test Loss: 36.32341, Test Acc: 0.99% Test mean rank: 815\nEpoch: 1300 | Loss: 0.33854, Acc: 96.91% | Test Loss: 37.96173, Test Acc: 0.98% Test mean rank: 829\nEpoch: 1400 | Loss: 0.31360, Acc: 97.13% | Test Loss: 39.61852, Test Acc: 0.95% Test mean rank: 830\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"}}]}]}