Wide & Deep Learning

wide_n_deep.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-07T01:41:06.702429Z","iopub.execute_input":"2022-11-07T01:41:06.702914Z","iopub.status.idle":"2022-11-07T01:41:09.006235Z","shell.execute_reply.started":"2022-11-07T01:41:06.702822Z","shell.execute_reply":"2022-11-07T01:41:09.005224Z"},"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-07T01:41:09.011809Z","iopub.execute_input":"2022-11-07T01:41:09.014401Z","iopub.status.idle":"2022-11-07T01:41:09.090847Z","shell.execute_reply.started":"2022-11-07T01:41:09.014358Z","shell.execute_reply":"2022-11-07T01:41:09.089107Z"},"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","metadata":{"execution":{"iopub.status.busy":"2022-11-07T01:41:09.096682Z","iopub.execute_input":"2022-11-07T01:41:09.099400Z","iopub.status.idle":"2022-11-07T01:41:09.108898Z","shell.execute_reply.started":"2022-11-07T01:41:09.099206Z","shell.execute_reply":"2022-11-07T01:41:09.107778Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"# 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\n\n\ndef load_and_process_data_wnd():\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 total) 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    crossed_col_names = (['gender', 'occupation'], ['age', 'gender'])\n    # Build the crossed columns\n    crossed_columns = []\n    for cols in crossed_col_names:\n        colname = '_'.join(cols)\n        dataset[colname] = dataset[cols].apply(lambda x: '-'.join(x.astype(str)), axis=1)\n        crossed_columns.append(colname)\n    \n    occupations_categoricals = dataset['occupation'].unique().tolist()\n    dummy_crossed_columns = []\n    for col in crossed_columns:\n        dummy_crossed_columns.extend(dataset[col].unique().tolist())\n\n    dataset['gender'] = (dataset['gender'] == 'M').astype(int) # change gender to 0/1 integer\n    dataset = pd.concat([dataset.drop(['occupation']+crossed_columns, axis=1), pd.get_dummies(dataset[['occupation']+crossed_columns], 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 + dummy_crossed_columns\n    df_wide = filtred_data[wide_data_column_names]\n    df_wide_without_cross = filtred_data[continuous_cols + categoricals]\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    X_train_wide_wo_cross, X_test_wide_wo_cross = df_wide_without_cross[:int(len(df_wide_without_cross)*(1-TEST_SIZE))], df_wide_without_cross[int(len(df_wide_without_cross)*(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_train_wide_wo_cross_tensor = torch.Tensor(X_train_wide_wo_cross.fillna(0).values).to(device)\n    X_test_wide_tensor = torch.Tensor(X_test_wide.fillna(0).values).to(device)\n    X_test_wide_wo_cross_tensor = torch.Tensor(X_test_wide_wo_cross.fillna(0).values).to(device)\n    \n    return X_train_wide_tensor, X_train_wide_wo_cross_tensor, X_test_wide_tensor, X_test_wide_wo_cross_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","metadata":{"execution":{"iopub.status.busy":"2022-11-07T01:41:09.115599Z","iopub.execute_input":"2022-11-07T01:41:09.117760Z","iopub.status.idle":"2022-11-07T01:41:09.177199Z","shell.execute_reply.started":"2022-11-07T01:41:09.117727Z","shell.execute_reply":"2022-11-07T01:41:09.176250Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"class WideDeep(nn.Module):\n    def __init__(self, wide_dim, n_class, embed_dim, embed_size, pad_idx=0):\n        super(WideDeep, self).__init__()\n        self.embed = nn.Embedding(embed_dim, embed_size, padding_idx=pad_idx, device=device)\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+wide_dim, n_class, device=device)\n        \n    def forward(self, X_w, X_sparse_idx):\n        embed = self.embed(X_sparse_idx) # movies_train_idx\n        embed = torch.mean(embed, dim=1)\n        deep_logits = self.linear_relu_stack(embed)\n        total_logits = self.output(torch.cat((deep_logits, X_w), dim=1))\n        return total_logits\n\ndef run_gradient_descent_wnd(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-07T01:41:09.181664Z","iopub.execute_input":"2022-11-07T01:41:09.183830Z","iopub.status.idle":"2022-11-07T01:41:09.223478Z","shell.execute_reply.started":"2022-11-07T01:41:09.183796Z","shell.execute_reply":"2022-11-07T01:41:09.222451Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"code","source":"X_train_wide_tensor, X_train_wide_wo_cross_tensor, X_test_wide_tensor, X_test_wide_wo_cross_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_wnd()","metadata":{"execution":{"iopub.status.busy":"2022-11-07T01:41:09.238530Z","iopub.execute_input":"2022-11-07T01:41:09.240874Z","iopub.status.idle":"2022-11-07T01:42:36.851253Z","shell.execute_reply.started":"2022-11-07T01:41:09.240834Z","shell.execute_reply":"2022-11-07T01:42:36.850173Z"},"trusted":true},"execution_count":6,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:150: 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":"wide_and_deep_model = WideDeep(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-07T01:42:36.852863Z","iopub.execute_input":"2022-11-07T01:42:36.853262Z","iopub.status.idle":"2022-11-07T01:42:36.874171Z","shell.execute_reply.started":"2022-11-07T01:42:36.853225Z","shell.execute_reply":"2022-11-07T01:42:36.873359Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"code","source":"wide_and_deep_model_trained, iters, train_losses, test_losses = run_gradient_descent_wnd(wide_and_deep_model, num_epochs=1000, weight_decay=0, learning_rate=0.03)","metadata":{"execution":{"iopub.status.busy":"2022-11-07T01:42:36.875385Z","iopub.execute_input":"2022-11-07T01:42:36.876090Z","iopub.status.idle":"2022-11-07T01:55:52.856349Z","shell.execute_reply.started":"2022-11-07T01:42:36.876052Z","shell.execute_reply":"2022-11-07T01:55:52.855294Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"Epoch: 0 | Loss: 7.53350, Acc: 0.04% | Test Loss: 16.95257, Test Acc: 0.20% Test mean rank: 960\nEpoch: 100 | Loss: 2.46722, Acc: 45.85% | Test Loss: 11.89806, Test Acc: 1.30% Test mean rank: 908\nEpoch: 200 | Loss: 1.60657, Acc: 67.28% | Test Loss: 15.36075, Test Acc: 1.17% Test mean rank: 857\nEpoch: 300 | Loss: 1.18522, Acc: 79.23% | Test Loss: 18.48282, Test Acc: 1.09% Test mean rank: 822\nEpoch: 400 | Loss: 0.96231, Acc: 84.40% | Test Loss: 21.25227, Test Acc: 0.99% Test mean rank: 797\nEpoch: 500 | Loss: 0.76772, Acc: 89.98% | Test Loss: 23.71025, Test Acc: 0.95% Test mean rank: 782\nEpoch: 600 | Loss: 0.64600, Acc: 92.51% | Test Loss: 25.95594, Test Acc: 0.96% Test mean rank: 775\nEpoch: 700 | Loss: 0.55119, Acc: 95.08% | Test Loss: 27.99042, Test Acc: 0.93% Test mean rank: 770\nEpoch: 800 | Loss: 0.48001, Acc: 96.26% | Test Loss: 29.95028, Test Acc: 0.92% Test mean rank: 766\nEpoch: 900 | Loss: 0.42119, Acc: 97.14% | Test Loss: 31.84937, Test Acc: 0.92% Test mean rank: 768\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":[]}]}