Tag-Aware Personalized Recommendation Using a Hybrid Deep Model

1 Introduction

In the era of the Web 2.0, social tagging systems are introduced by many websites, where users can freely annotate online items using arbitrary tags (commonly known as folksonomy [Hotho et al., 2006]). Since social tags are good summaries of the relevant items and the users' preferences, and they also contain little sensitive information about their creators, they are valuable information for privacy-enhanced personalized recommendation. Consequently, many efforts have been put on tag-aware personalized recommendation using content-based filtering [Cantador et al., 2010; Shepitsen et al., 2008] or collaborative filtering [Bouadjenek et al., 2013; Tso-Sutter et al., 2008]. However, as users can freely choose their own vocabulary, social tags may contain many uncontrolled vocabularies, such as homonyms, synonyms, words in arbitrary languages, or even user-created words. This results into very sparse, redundant, and ambiguous tag information, which greatly degrades the performance of tag-aware recommendation systems.

∗ Principal corresponding author

†Corresponding author

A solution to this problem is to apply clustering in the tag space [Shepitsen et al., 2008]; however, clustering requests to compute the similarity between tags, which is usually very time-consuming. Another solution is to use autoencoders; in [Zuo et al., 2016], abstract feature representations for tag-based user profiles are first modeled by autoencoders and then used as inputs of user-based collaborative filtering to generate recommendations. Although this method is reported to achieve better performance than the clustering-based collaborative filtering method [Zuo et al., 2016], it still suffers from the following drawback: the model's learning signal is not directly related to the objective of personalized recommendation, i.e., distinguishing the user's target items from the irrelevant ones; so, the resulting abstract feature representations may not be effective for personalized recommendation.

In this paper, motivated by the above observations, we propose to address the uncontrolled vocabulary problem by using deep neural networks to map the tag-based user and item profiles to an abstract deep feature space, where the similarities between users and their target items (resp., irrelevant items) are maximized (resp., minimized). We call the similarities on the deep feature space deep-semantic similarities and this model the deep-semantic similarity-based personalized recommendation (DSPR) model. DSPR has the following advantages: (i) the deep model is trained using a recommendationoriented learning signal, which is directly correlated with differentiating the user's target items from the irrelevant ones; so, the resulting abstract features for user and item profiles are very effective representations for personalized recommendation. (ii) Deep neural networks in DSPR extract more abstract and denser features layer-by-layer, so DSPR overcomes sparsity and redundancy problems in the input tag space. (iii) Also, the input synonyms (resp., homonyms) have similar (resp., different) impact on output features of DSPR, which addresses the ambiguity problem in the social tag space. (iv) Interpretability (transparency) is a common concern for some deep learning applications; this problem can be remedied in DSPR by finding the most influential input tags for each abstract feature in the output deep feature space and then using them to summarize the semantics of corresponding features.

Despite achieving superior performance, the training of the DSPR model is usually very time-consuming in practice, mainly because DSPR has many hidden layers and a huge number of candidate items. Specifically, on the one hand, since the deep neural networks in DSPR have many hidden layers, when learning signals are backpropagated to the first few layers, they become minuscule and insignificant, resulting into numerous training runs needed to reach model convergence (widely known as diffusion of gradients). On the other hand, to train DSPR, the deep-semantic similarities between the user in each training sample and all the candidate items have to be computed in each training run. Since the number of candidate items for an online recommendation system is usually very large (millions), and training deep neural networks often requires many training samples, the processing of each training run is computationally very expensive.

To solve the former problem, we propose an approach, called hybrid deep learning, which directly integrates autoencoders with the neural networks of DSPR to generate additional learning signals based on reconstruction errors. Experiments show that hybrid deep learning can greatly accelerate the deep model's learning progress and reduce training runs needed for model convergence by tens of times. As for the latter problem, to reduce the processing time needed for each training run, we further use negative sampling [Mikolov et al., 2013] to randomly sample a small number of negative examples to approximate the noise. The resulting efficient model is called hybrid deep learning-based personalized recommendation with negative sampling (HDLPR-NS).

The contributions of this paper are briefly as follows: (i) We propose DSPR which uses deep neural networks to solve the uncontrolled vocabulary problem in social tags. (ii) We further propose HDLPR-NS, which uses hybrid deep learning and negative sampling to achieve very efficient model training. (iii) Experimental results show that DSPR and HDLPRNS both significantly outperform the state-of-the-art baselines in tag-aware personalized recommendation (3.8 times better than the best baseline), and that, by using hybrid deep learning and negative sampling, the model training of HDLPR-NS is hundreds of times more efficient than DSPR, while achieving similar (and sometimes even better) training quality and recommendation performance.

2 RelatedWork

Deep learning has already been successfully applied in many search and recommendation applications, such as music [Van den Oord et al., 2013], movie [Salakhutdinov et al., 2007], and item recommendation [Elkahky et al., 2015], and Web search [Huang et al., 2013]. Similarly to our work, Elkahky et al. [2015] and Huang et al. [2013] use deepsemantic similarity models with a ranking-oriented training objective. But these models are very different from the ones proposed here: (i) they are not tag-aware systems and not designed to solve the redundancy, sparsity, and ambiguity problems in the tag space; (ii) hybrid deep learning is not applied in these works to accelerate the convergence of the model; (iii) instead of using negative sampling, these two works intentionally assume the number of candidate items to be very small (5 in [Huang et al., 2013] and 10 in [Elkahky et al.,

2015]) to make the model trainable. Clearly, this assumption is unreasonable in real-world situations. Negative sampling has been introduced first in the NLP community to learn word representations more efficiently [Mikolov et al., 2013]. To our knowledge, we are the first who apply hybrid deep learning and negative sampling to enhance the training efficiency of deep-semantic similarity-based recommendation or search.

A widely used solution for the diffusion of gradients is to pre-train each layer before using back-propagation to finetune the entire deep neural network [Erhan et al., 2010], where the pre-training is usually done by restricted Boltzmann machines (RBMs) [Hinton and Salakhutdinov, 2006; Hinton et al., 2006] or autoencoders [Bengio et al., 2007]. Instead of using autoencoders for pre-training, in this work, we propose to overcome the bottleneck of back-propagation by directly integrating autoencoders into the network to generate additional learning signals based on reconstruction errors. Here, hybrid deep learning is used individually to accelerate the deep model's learning progress; but it can also be used as a complement of pre-training to speed up the learning process in the "fine-tuning" step.

3 Preliminaries

Personalized recommendation is defined as follows. Given a user u and a set of items {i1, . . . , in}, the system produces a ranked recommendation list τ = [i1 ≥ i2 ≥ · · · ≥ in] s.t. ia ≥ib iff Rlv(u, ia)≥Rlv(u, ib), where Rlv(u, i) is a function measuring how relevant an item i is to the user u.

A folksonomy is a tuple F = (U, T, I,A), where U, T, and I are sets of users, tags, and items, respectively, and A ⊆ U × T × I is a set of assignments (u, t, i) of a tag t to an item i by a user u [Hotho et al., 2006].

A user profile is a feature vector xu = (gu 1 , . . . , guM ), where M = |T| is the tag vocabulary's size, and gu j = |{(u, tj, i) ∈ A | i∈I}| is the number of times that user u annotates items with tag tj . Similarly, an item profile is a vector xi = (gi1 , . . . , giM ), where gij = |{(u, tj, i)∈A | u∈U}| is the number of times that the item i is annotated with the tag tj [Cantador et al., 2010].

4 Deep-semantic Similarity-based Personalized Recommendation

Figure 1 shows an overview of the deep-semantic similarity-based personalized recommendation (DSPR) model. Generally, DSPR takes the tag-based user and item profiles xu and xi (as defined above) as inputs of two deep neural networks with shared parameters. These inputs are then passed through multiple hidden layers and projected into an abstract deep feature space on the final hidden layer, where the similarities between the abstract representations of user and item profiles are computed. Finally, ranked recommendation lists are generated using relevance scores, computed by applying the softmax function on the resulting similarities.

Formally, given the user profile xu, the item profile xi, a weight matrix W1, and a bias vector b1, the intermediate output h1 of the first hidden layer is defined as follows:

where tanh is used as the activation function. Similarly, the intermediate output of the jth hidden layer hj, j ∈ {2, . . . ,K}, is defined as:

where Wj and bj are the weight matrix and the bias vector, respectively, for the jth hidden layer, and K is the total number of hidden layers. The outputs of the Kth hidden layer are the abstract feature representations of user and item profiles, denoted ˜ xu and ˜ xi, respectively. Formally,

Then, the similarity between a user u and an item i is measured using the cosine similarity between the abstract representations of their profiles, formally defined as

and called deep-semantic similarity.

Finally, the relevance scores [Huang et al., 2013] of items i to a given user u are measured by applying the softmax function on the resulting deep-semantic similarities between u and i, which are then used to rank a personalized recommendation list for the given user u. Formally,

As we assume that the target items of a given user are those annotated by this user, to achieve good personalized recommendation, these items should have higher relevance scores than others. We thus conduct the model training with an objective to maximize the relevance scores of target items; equivalently, this means to maximize the deep-semantic similarities between users and their target items and minimize those with irrelevant ones. Formally, this is equivalent to minimizing the following loss function:

where Θ represents the parameters Wj and bj in the neural networks; (u, i∗ ) are training samples, which are pairs of a user u and his/her target item i∗ , generated from assignments (u, t, i∗ ) in a training dataset.

In training, we first initialize the weight matrices Wj, using the random normal distribution, and initialize the biases bj to be zero vectors; the model is then trained by backpropagation using mini-batch gradient descent; finally, the training stops when the model converges or reaches the maximum training runs.

5 Hybrid Deep Learning-based Personalized Recommendation with Negative Sampling

To enhance DSPR's training efficiency and ensure the scalability in practice, we propose to use hybrid deep learning and negative sampling [Mikolov et al., 2013] to reduce the number of training runs needed for model convergence and to reduce the processing time needed for each training run. This is called hybrid deep learning-based personalized recommendation with negative sampling (HDLPR-NS).

5.1 Hybrid Deep Learning

Training deep neural networks using back-propagation is difficult, because the learning signals become minuscule and insignificant when they are backpropagated to the first few layers, which results into a very slow learning progress and numerous training runs for model convergence. This problem is called diffusion of gradients, which can be remedied by pre-training each layer before using back-propagation to finetune the entire network [Hinton and Salakhutdinov, 2006; Bengio et al., 2007]. In this work, we propose a new solution called hybrid deep learning with an idea of integrating autoencoders with the neural networks of DSPR to generate additional learning signals based on reconstruction errors, which is then combined with the deep-semantic similaritybased relevance scores in DSPR to form a hybrid deep learning signal for model training. The model is called hybrid deep learning-based personalized recommendation (HDLPR).

Intuitively, for the following reason, adding reconstruction errors as learning signals can greatly accelerate the deep model's learning progress and reduce training runs needed for model convergence: In DSPR, the deep-semantic similaritybased learning signal becomes very weak when it is backpropagated to the first few layers, so learning the first few weight matrices, e.g., W1 and W2, is very slow. In HDLPR, since we use tied weights in autoencoders, i.e., the weight matrices in the decoder are the transposes of those in the encoder, the reconstruction-error-based learning signal will be used to first update W T 1 , then back-propagated to updatingW T 2 ,W T 3 , and so on. As updating W T j is equivalent to updating Wj, it remedies the diffusion of gradients in DSPR.

Figure 2 shows the overall process of the proposed hybrid deep learning-based personalized recommendation (HDLPR) model. The structure of HDLPR is similar to the one of DSPR, but adds K layers to form a decoder; so, by taking the first K+1 layers as encoder, we convert each neural network to an autoencoder with tied weights. Then, the decoders take the abstract feature representations of user and item profiles, ˜ xu and ˜ xi, as inputs and generate reconstructed user and item profiles in their output layers, denoted x′u and x′i . Finally, the reconstruction errors of user (resp., item) profiles are computed as the Euclidean (i.e., L2) norms of the differences between xu (resp., xi) and x′u (resp., x′i ).

Formally, the definitions of layers in encoders are the same as the ones in the neural networks of DSPR. As for the decoders, the intermediate output of the K + jth hidden layer hK+j , j ∈ {1, . . . , K - 1}, is formally defined as:

whereW TK-(j-1) is the transpose of WK-(j-1), and bK+j is the bias vector for the (K + j)th hidden layer. The outputs of the (2K-1)th hidden layer are used to generate reconstructed user and item profiles, denoted x′u and x′i , in the output layer:

Then, the reconstruction errors of user (resp.,item) profiles are computed as the Euclidean (i.e., L2) norms of the differences between xu (resp., xi) and x′u (resp., x′i ). By integrating the reconstruction errors with the deep-semantic similaritybased relevance scores in DSPR, the training objective of HDLPR is to maximize the relevance scores of target items and also to minimize the reconstruction errors of the user and target item profiles in each training sample. Formally, it is equivalent to minimizing the following hybrid loss function:

where the first term is a L2 regularization used to prevent overfitting; the second term is the sum of reconstruction errors of the user and target item profiles in each training sample; and the third term is the deep-semantic similarity-based learning signal, L(Θ), as defined in Eq. (8); λθ and λe are parameters representing different importances of the corresponding terms, where λe > 0, λθ > 0, and λθ + λe < 1.

5.2 Negative Sampling

Although hybrid deep learning greatly reduces the number of training runs needed for model convergence, the processing of each training run in both DSPR and HDLPR is still very time-consuming, since the deep-semantic similaritybased loss function L(Θ) as defined in Eq. (8), which is also the third term of Lh(Θ), is computationally very expensive.

Specifically, for each training sample (u, i∗ ) in each training run, the second term of L(Θ) requests to compute and sum the deep-semantic similarities between u and all candidate items in I. In practice, the number of candidate items for an online recommendation system is usually very large (millions), and training a deep neural network often requires numerous training samples; therefore, the cost of processing each training run in both DSPR and HDLPR is very high. However, this term is essential: with its help, minimizing L(Θ) not only maximizes the deep-semantic similarity between the given user and his/her target items, but also minimizes those with irrelevant items. Consequently, it helps to distinguish the target item from the irrelevant ones.

To tackle this dilemma, in this work, we use negative sampling [Mikolov et al., 2013] to greatly reduce the time needed to process each training sample. In negative sampling, instead of using all irrelevant items, for each training sample, we randomly sample only a small number (S) of irrelevant items from the set of candidate items as negative examples to approximate the noise and to differentiate target items from irrelevant ones. The resulting efficient model is called HDLPR with negative sampling (HDLPR-NS); and its loss function is formally defined as follows:

where (u, i-) are negative samples, which are contained in a negative dataset D- and generated by randomly sampling S negative examples i- for each training sample (u, i∗ ).

6 Experiments

Three state-of-the-art solutions for the uncontrolled vocabulary problem as baselines are: (i) Clustering-based cosine similarity (CCS): hierarchical clustering [Shepitsen et al., 2008] models the users and items as cluster-based feature vectors, upon which content-based filtering with the cosine similarity is used for recommendations. (ii) Clustering-based collaborative filtering (CCF): CCF is similar to CCS in feature modeling, but uses user-based collaborative filtering for recommendations. (iii) Autoencoder-based collaborative filtering (ACF) [Zuo et al., 2016]: an autoencoder is used to obtain abstract representations of user profiles, on which userbased collaborative filtering is applied for recommendations.

For a fair comparison, the experiments are performed on the same public real-world datasets, Delicious and Last.Fm, as used in [Zuo et al., 2016], which are gathered from the Delicious bookmarking system and the Last.Fm online music system, respectively, and are both released in HetRec

2011 [Cantador et al., 2011]. After using the same preprocessing to remove infrequent tags, which are used less than 15 (resp., 5) times in Delicious (resp., Last.Fm), the information of the resulting datasets is shown in Table 1.

As we assume that the target items of a given user are those annotated by this user, for both datasets, we randomly select 80% of the assignment data as training set, 5% as validation set, and 15% as test set. The assignments (u, t, i∗ ) in the training set are used to construct user and item profiles and to extract the user-item pairs (u, i∗ ) as training samples. We also extract user-item pairs from the assignments in the validation set as validation samples, which are used to avoid over-fitting by early stopping. Finally, user-item pairs extracted from the assignments in the test set are used as test samples to evaluate the recommendation performance.

All models are implemented using Python and Theano, and run on a GPU server [Richards, 2015] with an NVIDIA Tesla K40 GPU and 12GB GPU memory. The parameters of DSPR are selected by grid search and set as follows: (i) # of hidden layers (i.e., K) is 3; (ii) # of neurons in the 1st, 2nd, and 3rd hidden layers are 2 000, 300, and 128, respectively; (iii) training batch size is 128; and (iv) learning rate for model training is 0.005. These parameters are the same in HDLPR-NS, with the following additional settings: (v) two extra hidden layers, and # of neurons in the 4th and 5th hidden layers are 300 and 2000, respectively; (vi) the balancing parameters λθ and λe are set to 0.01 and 0.2, respectively; and (vii) # of negative examples for each training sample (i.e., S) is 127.

The most popular metrics for the evaluation of recommendation systems are precision, recall, and F1-score [Bobadilla et al., 2013]. Since users usually only browse the topmost recommended items, we apply these metrics at a given cutoff rank k, i.e., considering only the top-k results on the recommendation list, called precision at k (P@k), recall at k (R@k), and F1-score at k (F@k). Since users always prefer to have their target items ranked in the front of the recommendation list, we also employ mean reciprocal rank (MRR) [Voorhees, 1999] as the evaluation metric, which gives greater importance to items ranked higher. The p-value [Rice, 1989] is used to measure the significance of improvements.

6.1 Main Results

Figure 3 depicts in detail the personalized recommendation performances of DSPR, HDLPR-NS, and the three baselines on the Delicious and Last.Fm datasets in terms of MRR, P@k, R@k, and F@k, where ten cut-off ranks k =5, 10, . . . , 50 are selected for evaluation.

In Figure 3, despite some slight differences due to the randomweights' initializations and dataset partitions, the results of CCF and ACF in Figure 3 are highly consistent with the results reported in [Zuo et al., 2016] in terms of orders of magnitude, tendencies, and relative performances. Furthermore, the performances of the proposed DSPR and HDLPR- NS models are very similar (e.g., p-value = 94.31% in MRR) on the Delicious dataset; while HDLPR-NS slightly outperforms DSPR on Last.Fm. This indicates that integrating hybrid deep learning and negative sampling with DSPR will not degrade its performance (and sometimes even improve it).

In general, Figure 3 shows that the DSPR and HDLPR-NS models both significantly outperform the three baselines in all metrics; e.g., the MRRs (resp., average R@k) of DSPR and HDLPR-NS are both more than 3.8 times (resp., 34%) better than the best baseline, CCS, on Delicious (resp., Last.Fm) with p-value both smaller than 0.04% (resp., 0.09%), and the improvements in other metrics are also similar. The superior performances of DSPR and HDLPR-NS are mainly because the training objectives of DSPR and HDLPR-NS are both directly correlated with distinguishing the user's target items from the irrelevant ones; so, the resulting abstract features for user and item profiles are much more effective representations for personalized recommendation than those generated solely by clustering and autoencoders.

We also note in Figure 3 that DSPR and HDLPR-NS achieve much higher improvements on Delicious than on Last.Fm, as DSPR and HDLPR-NS maintain a relatively stable performance on both datasets, but the performance of the baselines dramatically degrades on Delicious: all metrics are 1/5 or less than those on Last.Fm. This may be because: items in Last.Fm are solely in the domain of music, but items in Delicious are webpages in various domains; so, even with higher tag-removing threshold, Delicious still has a more variable, redundant, and ambiguous tag space than Last.Fm, which can not be properly handled by the baselines. This shows that DSPR and HDLPR-NS can solve the uncontrolled vocabulary problem better than the baselines; and the more uncontrolled the dataset, the higher the achieved improvement.

6.2 Efficiency and Scalability

We also investigate the training efficiency and scalability of DSPR and HDLPR-NS. The training time is recorded to compare the training efficiency of the two models. But the standard training loss is not suitable to compare the models' training quality, as DSPR and HDLPR-NS have different loss functions. Here, we use MRR on validation samples (MRRVS) to measure the training quality, because (i) the training objectives of both models are to get a better performance in personalized recommendation, so the higher the MRR-VS, the better the models, and (ii) the values of MRR-VS are computed every 10 training runs to avoid over-fitting, so using it will not increase the training time.

We first explore the effect of using hybrid deep learning. To avoid interference, we use HDLPR (hybrid model without negative sampling) for comparison. As shown in Figure 4, with the increase of the number of training runs, HDLPR converges much faster than DSPR on both datasets. DSPR takes 810 (resp., 1750) training runs to reach model convergence on Delicious (resp., Last.Fm), which costs HDLPR only 70 (resp., 80) runs. This shows that hybrid deep learning can significantly enhance the model's learning progress and reduce the training runs needed for model convergence by tens of times. Also, when the models converge, the MRR-VS of HDLPR is almost the same as that of DSPR on Delicious

(0.0244 in HDLPR vs. 0.0245 in DSPR) and is slightly higher on Last.Fm (0.0306 in HDLPR vs. 0.0291 in DSPR), which demonstrates that using hybrid deep learning will not degrade the models' training quality.

We then apply negative sampling on HDLPR and find that the resulting HDLPR-NS has a very similar training progress to HDLPR: as shown in Table 2, it takes HDLPRNS 70 (resp., 80) runs to converge at MRR-VS = 0.0243 (resp., = 0.0304) on Delicious (resp., Last.Fm); these values are almost the same as those of HDLPR as shown in Figure 4. Therefore, using negative sampling will not influence the benefit of using hybrid deep learning. Furthermore, Table 2 also shows that, with the help of negative sampling, the time needed to process one training run on Delicious (resp., Last.Fm) is greatly reduced from 0.405 (resp., 0.1133) hours in DSPR to 0.0095 (resp., 0.0037) hours in HDLPR-NS. This proves that using negative sampling can substantially reduce the processing time needed for each training run.

Consequently, the total time-cost to reach model convergence in HDLPR-NS is only 0.665 (resp., 0.296) hours on Delicious (resp., Last.Fm), which is roughly 492 (resp., 668) times quicker than that in DSPR. In summary, by using hybrid deep learning and negative sampling, the model training efficiency of HDLPR-NS is hundreds of times better than the one of DSPR, while maintaining a similar training quality.

7 Summary and Outlook

We have proposed a deep-semantic similarity model, DSPR, to address the uncontrolled vocabulary problem and to achieve superior personalized recommendations. We have also proposed an improved model, HDLPR-NS, to use hybrid deep learning and negative sampling to greatly reduce the system's training time and to ensure a good scalability in practice. Experiments show that DSPR and HDLPR-NS both significantly outperform the state-of-the-art baselines in personalized recommendation in all metrics. In addition, the training efficiency of HDLPR-NS is hundreds of times better than the one of DSPR, while maintaining a similar training quality and performance in personalized recommendation.

In the future, we will further improve our models with more sophisticated neural networks, e.g., recurrent networks. We will also apply the hybrid deep model on other real-world applications and conduct extensive experiments to get more insights about its performance in various practical situations.

Acknowledgments

This work was supported by the UK EPSRC grants EP/J008346/1, EP/L012138/1, and EP/M025268/1, and by The Alan Turing Institute under the EPSRC grant EP/N510129/1. Cheng Chen and Xiangwu Meng are supported by the Mutual Project of Beijing Municipal Education Commission.