MXNet for Collaborative Deep Learning in Recommender Systems

In this tutorial, we build on MXNet to implement the Collaborative Deep Learning (CDL) [1] model for recommender systems.

Brief Introduction of CDL

In CDL, a probabilistic stacked denoising autoencoder (pSDAE) is connected to a matrix factorization (MF) component. Model training will alternate between pSDAE and MF. In each epoch, a pSDAE with a reconstruction target at the end and a regression target in the bottleneck will be udpated before updating the latent factors U and V in the regularized MF.

Below is the graphical model for CDL. The part in the red rectangle is pSDAE and the rest is the MF component regularized by pSDAE. Essentially, the updating will alternate between pSDAE (updating $W^+$) and the MF component (updating $u$ and $v$).

Some Notation:

• $x_0$: the input vectors to pSDAE (corrupted data, e.g., randomly deleting some entries of the input)
• $x_c$: the reconstruction target vectors (the uncorrupted data)
• $x_{L/2}$: the output vectors of pSDAE's middle layer (bottleneck layer)
• $X_0$: the matrix consists of vectors $x_0$
• $X_c$: the matrix consists of vectors $x_c$
• $W^+$: weights and biases of pSDAE
• $v$: latent item vectors
• $u$: latent user vectors
• $R$: rating matrix ('1' if the article is in the user's library and '0' otherwise)
• $I$: number of users
• $J$: number of items
• $\lambda_u$, $\lambda_v$, $\lambda_w$, $\lambda_n$: hyperparameters

Below we show a special case of CDL (from a neural network perspective), where it degenerates to simultaneously training two neural networks overlaid together with a common input layer (the corrupted input) but different output layers. This might be a lot easier to understand for people not familiar with graphical models.

The objective function (which we use in this implementation) for this special case is: \begin{align} \mathscr{L}=&-\frac{\lambda_u}{2}\sum\limits_i \|u_i\|_2^2 -\frac{\lambda_w}{2}\sum\limits_l(\|W_l\|_F^2+\|b_l\|_2^2)\nonumber \\ &-\frac{\lambda_v}{2}\sum\limits_j\|v_j-f_e(X_{0,j*},W^+)^T\|_2^2 \nonumber \\ &-\frac{\lambda_n}{2}\sum\limits_j\|f_r(X_{0,j*},W^+)-X_{c,j*}\|_2^2 \nonumber \\ &-\sum\limits_{i,j}\frac{C_{ij}}{2}(R_{ij}-u_i^Tv_j)^2, \end{align} where the encoder function $f_e(\cdot,W^+)$ takes the corrupted content vector $X_{0,j*}$ of item $j$ as input and computes the encoding of the item, and the function $f_r(\cdot,W^+)$ also takes $X_{0,j*}$ as input, computes the encoding and then the reconstructed content vector of item $j$. Here $\lambda_w$, $\lambda_n$, $\lambda_u$, and $\lambda_v$ are hyperparameters and $C_{ij}$ is a confidence parameter ($C_{ij} = a$ if $R_{ij}=1$ and $C_{ij}=b$ otherwise). For example, if the number of layers $L=6$, $f_e(X_{0,j*},W^+)$ is the output of the third layer while $f_r(X_{0,j*},W^+)$ is the output of the sixth layer.

To learn CDL, we have to implement the block coordinate descent (BCD) update using numpy/mshadow and call this BCD procedure after each epoch of pSDAE. Besides the MF part, another difference between CDL and conventional deep learning models is that pSDAE has a fixed target at the end and a dynamic target (the latent item factors V) in the bottleneck layer. It might need some hacking to make this work.

[1] H. Wang, N. Wang, and D. Yeung. Collaborative deep learning for recommender systems. In KDD, 2015.

Implementing CDL in MXNet for Recommender Systerms

Setting Hyperparameters

• lambda_u: regularization coefficent for user latent matrix U
• lambda_v: regularization coefficent for item latent matrix V
• K: number of latent factors
• is_dummy: whether to use a dummy dataset for demo
• num_iter: number of iterations (minibatches) to train (a epoch in the used dataset takes about 68 iterations)
• batch_size: minibatch size
• dir_save: directory to save training results
• lv: lambda_v/lambda_n in CDL; this controls the trade-off between reconstruction error in pSDAE and recommendation accuracy during training

Create the directory and the log file.

Loading Data

Here we load the text information (as input to pSDAE) in the file mult.dat and the rating matrix (as input for the MF part) in the file cf-train-1-users.dat. Code for loading the data are packed in data.py.

We use the CiteULike dataset here. The input text is bag-of-words vectors normalized to [0,1]. Some details:

• task: recommend articles to users
• number of users: 5551
• number of items: 16980
• number of ratings for training: ~169800
• number of terms: 8000

Network Definition

Here we deine the logging level and construct the network. As mentioned before, pSDAE has multiple targets, we used mx.symbol.Group to group both loss. The codes snippets are shown as following, refer to autoencode.py for more details.

fe_loss = mx.symbol.LinearRegressionOutput(
            data=self.lambda_v_rt*self.encoder,
            label=self.lambda_v_rt*self.V)
fr_loss = mx.symbol.LinearRegressionOutput(
            data=self.decoder, label=self.data)
loss = mx.symbol.Group([fe_loss, fr_loss])

Initializing Variables

Here we initialize several variables. V is the latent item matrix and lambda_v_rt is an ndarray with entries equal to sqrt(lv). We need this lambda_v_rt to hack the trade-off between two targets in pSDAE.

Training the CDL

Train the whole CDL (joint training of pSDAE and the connected MF). We use SGD for pSDAE and BCD for the MF part. U is the user latent matrix, V is the item latent matrix, theta is the output of pSDAE's middle layer, and BCD_loss equals to rating_loss+reg_loss_for_U+reg_loss_for_V. For demostration we train for only 100 iterations (about 1.5 epochs) here. The shown recommendations in later parts are results after 100 epochs.

The function finetune below will call the function 'solve' in the solver.py, where the customized training loop resides. In the training loop, we call the following code after each epoch of pSDAE to update U and V using BCD. The BCD updating procedure is wrapped up in the function BCD_one. Note that after each epoch, we upate U and V for only one iteration.

theta = model.extract_feature(sym[0], args, auxs,
    data_iter, X.shape[0], xpu).values()[0]
# update U, V and get BCD loss
U, V, BCD_loss = BCD_one(R, U, V, theta,
    lambda_u, lambda_v, dir_save, True)
# get recon' loss
Y = model.extract_feature(sym[1], args, auxs,
    data_iter, X.shape[0], xpu).values()[0]
Recon_loss = lambda_v/np.square(lambda_v_rt_old[0,0])*np.sum(np.square(Y-X))/2.0
lambda_v_rt[:] = lambda_v_rt_old[:] # back to normal lambda_v_rt
data_iter = mx.io.NDArrayIter({'data': X, 'V': V, 'lambda_v_rt':
    lambda_v_rt},
    batch_size=batch_size, shuffle=False,
    last_batch_handle='pad')
data_iter.reset()
batch = data_iter.next()

Saving Models and Parameters

Save the network (pSDAE) parameters, latent matrices, and middle-layer output.

Computing Training Error

The training loss consists of the loss in pSDAE and that in MF.

Generating Recommendations

Load the latent matrices (U and V), compute the predicted ratings R=UV^T, and generate recommendation lists for each user. There 5551 users in the dataset.

Show Recommendations

Load the article titles (raw-data.csv), ratings (cf-train-1-users.dat and cf-test-1-users.dat), and recommendation lists (rec-list.dat).

Show the titles of articles in the training set and titles of recommended articles. Correctly recommended articles are marked by asterisks.