{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 0
},
"source": [
"# AutoRec: Rating Prediction with Autoencoders\n",
"\n",
"Although the matrix factorization model achieves decent performance on the rating prediction task, it is essentially a linear model. Thus, such models are not capable of capturing complex nonlinear and intricate relationships that may be predictive of users' preferences. In this section, we introduce a nonlinear neural network collaborative filtering model, AutoRec :cite:`Sedhain.Menon.Sanner.ea.2015`. It identifies collaborative filtering (CF) with an autoencoder architecture and aims to integrate nonlinear transformations into CF on the basis of explicit feedback. Neural networks have been proven to be capable of approximating any continuous function, making it suitable to address the limitation of matrix factorization and enrich the expressiveness of matrix factorization.\n",
"\n",
"On one hand, AutoRec has the same structure as an autoencoder which consists of an input layer, a hidden layer, and a reconstruction (output) layer. An autoencoder is a neural network that learns to copy its input to its output in order to code the inputs into the hidden (and usually low-dimensional) representations. In AutoRec, instead of explicitly embedding users/items into low-dimensional space, it uses the column/row of the interaction matrix as the input, then reconstructs the interaction matrix in the output layer.\n",
"\n",
"On the other hand, AutoRec differs from a traditional autoencoder: rather than learning the hidden representations, AutoRec focuses on learning/reconstructing the output layer. It uses a partially observed interaction matrix as the input, aiming to reconstruct a completed rating matrix. In the meantime, the missing entries of the input are filled in the output layer via reconstruction for the purpose of recommendation. \n",
"\n",
"There are two variants of AutoRec: user-based and item-based. For brevity, here we only introduce the item-based AutoRec. User-based AutoRec can be derived accordingly.\n",
"\n",
"\n",
"## Model\n",
"\n",
"Let $\\mathbf{R}_{*i}$ denote the $i^\\mathrm{th}$ column of the rating matrix, where unknown ratings are set to zeros by default. The neural architecture is defined as:\n",
"\n",
"$$\n",
"h(\\mathbf{R}_{*i}) = f(\\mathbf{W} \\cdot g(\\mathbf{V} \\mathbf{R}_{*i} + \\mu) + b)\n",
"$$\n",
"\n",
"where $f(\\cdot)$ and $g(\\cdot)$ represent activation functions, $\\mathbf{W}$ and $\\mathbf{V}$ are weight matrices, $\\mu$ and $b$ are biases. Let $h( \\cdot )$ denote the whole network of AutoRec. The output $h(\\mathbf{R}_{*i})$ is the reconstruction of the $i^\\mathrm{th}$ column of the rating matrix.\n",
"\n",
"The following objective function aims to minimize the reconstruction error:\n",
"\n",
"$$\n",
"\\underset{\\mathbf{W},\\mathbf{V},\\mu, b}{\\mathrm{argmin}} \\sum_{i=1}^M{\\parallel \\mathbf{R}_{*i} - h(\\mathbf{R}_{*i})\\parallel_{\\mathcal{O}}^2} +\\lambda(\\| \\mathbf{W} \\|_F^2 + \\| \\mathbf{V}\\|_F^2)\n",
"$$\n",
"\n",
"where $\\| \\cdot \\|_{\\mathcal{O}}$ means only the contribution of observed ratings are considered, that is, only weights that are associated with observed inputs are updated during back-propagation.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"attributes": {
"classes": [],
"id": "",
"n": "3"
},
"origin_pos": 1,
"tab": [
"mxnet"
]
},
"outputs": [],
"source": [
"import mxnet as mx\n",
"from mxnet import autograd, gluon, np, npx\n",
"from mxnet.gluon import nn\n",
"from d2l import mxnet as d2l\n",
"\n",
"npx.set_np()"
]
},
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 2
},
"source": [
"## Implementing the Model\n",
"\n",
"A typical autoencoder consists of an encoder and a decoder. The encoder projects the input to hidden representations and the decoder maps the hidden layer to the reconstruction layer. We follow this practice and create the encoder and decoder with dense layers. The activation of encoder is set to `sigmoid` by default and no activation is applied for decoder. Dropout is included after the encoding transformation to reduce over-fitting. The gradients of unobserved inputs are masked out to ensure that only observed ratings contribute to the model learning process.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"attributes": {
"classes": [],
"id": "",
"n": "2"
},
"origin_pos": 3,
"tab": [
"mxnet"
]
},
"outputs": [],
"source": [
"class AutoRec(nn.Block):\n",
" def __init__(self, num_hidden, num_users, dropout=0.05):\n",
" super(AutoRec, self).__init__()\n",
" self.encoder = nn.Dense(num_hidden, activation='sigmoid',\n",
" use_bias=True)\n",
" self.decoder = nn.Dense(num_users, use_bias=True)\n",
" self.dropout = nn.Dropout(dropout)\n",
"\n",
" def forward(self, input):\n",
" hidden = self.dropout(self.encoder(input))\n",
" pred = self.decoder(hidden)\n",
" if autograd.is_training(): # Mask the gradient during training\n",
" return pred * np.sign(input)\n",
" else:\n",
" return pred"
]
},
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 4
},
"source": [
"## Reimplementing the Evaluator\n",
"\n",
"Since the input and output have been changed, we need to reimplement the evaluation function, while we still use RMSE as the accuracy measure.\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"attributes": {
"classes": [],
"id": "",
"n": "3"
},
"origin_pos": 5,
"tab": [
"mxnet"
]
},
"outputs": [],
"source": [
"def evaluator(network, inter_matrix, test_data, devices):\n",
" scores = []\n",
" for values in inter_matrix:\n",
" feat = gluon.utils.split_and_load(values, devices, even_split=False)\n",
" scores.extend([network(i).asnumpy() for i in feat])\n",
" recons = np.array([item for sublist in scores for item in sublist])\n",
" # Calculate the test RMSE\n",
" rmse = np.sqrt(np.sum(np.square(test_data - np.sign(test_data) * recons))\n",
" / np.sum(np.sign(test_data)))\n",
" return float(rmse)"
]
},
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 6
},
"source": [
"## Training and Evaluating the Model\n",
"\n",
"Now, let us train and evaluate AutoRec on the MovieLens dataset. We can clearly see that the test RMSE is lower than the matrix factorization model, confirming the effectiveness of neural networks in the rating prediction task.\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"attributes": {
"classes": [],
"id": "",
"n": "4"
},
"origin_pos": 7,
"tab": [
"mxnet"
]
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"train loss 0.000, test RMSE 0.898\n",
"26944453.6 examples/sec on [gpu(0), gpu(1)]\n"
]
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"devices = d2l.try_all_gpus()\n",
"# Load the MovieLens 100K dataset\n",
"df, num_users, num_items = d2l.read_data_ml100k()\n",
"train_data, test_data = d2l.split_data_ml100k(df, num_users, num_items)\n",
"_, _, _, train_inter_mat = d2l.load_data_ml100k(train_data, num_users,\n",
" num_items)\n",
"_, _, _, test_inter_mat = d2l.load_data_ml100k(test_data, num_users,\n",
" num_items)\n",
"train_iter = gluon.data.DataLoader(train_inter_mat, shuffle=True,\n",
" last_batch=\"rollover\", batch_size=256,\n",
" num_workers=d2l.get_dataloader_workers())\n",
"test_iter = gluon.data.DataLoader(np.array(train_inter_mat), shuffle=False,\n",
" last_batch=\"keep\", batch_size=1024,\n",
" num_workers=d2l.get_dataloader_workers())\n",
"# Model initialization, training, and evaluation\n",
"net = AutoRec(500, num_users)\n",
"net.initialize(ctx=devices, force_reinit=True, init=mx.init.Normal(0.01))\n",
"lr, num_epochs, wd, optimizer = 0.002, 25, 1e-5, 'adam'\n",
"loss = gluon.loss.L2Loss()\n",
"trainer = gluon.Trainer(net.collect_params(), optimizer,\n",
" {\"learning_rate\": lr, 'wd': wd})\n",
"d2l.train_recsys_rating(net, train_iter, test_iter, loss, trainer, num_epochs,\n",
" devices, evaluator, inter_mat=test_inter_mat)"
]
},
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 8
},
"source": [
"## Summary\n",
"\n",
"* We can frame the matrix factorization algorithm with autoencoders, while integrating non-linear layers and dropout regularization. \n",
"* Experiments on the MovieLens 100K dataset show that AutoRec achieves superior performance than matrix factorization.\n",
"\n",
"\n",
"\n",
"## Exercises\n",
"\n",
"* Vary the hidden dimension of AutoRec to see its impact on the model performance.\n",
"* Try to add more hidden layers. Is it helpful to improve the model performance?\n",
"* Can you find a better combination of decoder and encoder activation functions?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"origin_pos": 9,
"tab": [
"mxnet"
]
},
"source": [
"[Discussions](https://discuss.d2l.ai/t/401)\n"
]
}
],
"metadata": {
"language_info": {
"name": "python"
}
},
"nbformat": 4,
"nbformat_minor": 4
}