CoupledCF: Learning Explicit and Implicit User-item Couplings in Recommendation for Deep Collaborative Filtering

1 Introduction

Collaborative filtering (CF) is dominant for recommender systems (RS) to predict new user-item interactions (e.g., ratings) by analyzing the relationships between users (or items) in terms of the past user behavior [Koren, 2008], such as ratings, viewing, clicking or purchasing behaviors on items. The user-item rating matrix shows the user preference on items, in which each entry denotes the preference of a user on an item. The rating matrix is widely used as the main data source for recommendation study.

In practice, often the rating matrix is very sparse, i.e., most of its entries are absent. It would be very difficult to gain reasonable recommendation accuracy when just based on this sparse data. In addition to approaches such as dimensionality reduction, which do not fundamentally change the problem nature, increasing efforts are made on incorporating side information into rating estimation, especially for issues as sparsity and cold start. For this, user and/or item attributes [Shi et al., 2014; Li et al., 2015] are increasingly used to leverage the rating data for better recommendation quality.

Incorporating and learning user/item attributes and contextual information have been a recent focus in recommender systems. For example, Bayesian matrix factorization with side information [Park et al., 2013] handles cold start problems. In [Yao et al., 2015], contextual information is incorporated into CF and Context-aware Personalized Random Walk and Semantic Path-based Random Walk methods are proposed. Li et al. [Li et al., 2014] involved user information such as a user's query history, purchasing and browsing activities. In [Pan and Chen, 2016], a group Bayesian personalized ranking introduces group preference instead of individual preference to relax the individual and independence assumptions. To various extents, the above work aims to involve specific user/item properties and characteristics, such as contexts, user historical activities, demographics and reviews, and item description into recommenders for addressing the shortage of ratings alone and respective challenges such as sparsity and cold start.

However, existing relevant approaches can only lead to limited improvement as they assume users and items are independent and identically distributed (IID). For example, some of the above work simply incorporates user or item properties into a recommendation model but overlooks the various coupling relationships [Cao et al., 2012] within and between users and items and the non-IID nature of recommendation [Cao, 2015; 2016], which may essentially disclose why a user likes (or dislikes) an item [Cao, 2016]. Methods treating user/item information as IID cannot take the full advantage of user/item information to improve the recommendation performance when users/items are actually non-IID. Non-IID recommender systems were introduced to cater for the nonIID nature of users/items in [Cao, 2016], i.e., learning couplings and heterogeneities within/between users and items, and some impressive achievements have been made in creating non-IID RS, e.g., coupled user/item similarity-based matrix factorization [Li et al., 2013; 2015] and in many other learning tasks [Wang et al., 2015a; Chen et al., 2015; Pang et al., 2016; Georgiev and Nakov, 2013; Jian et al., 2018; Do and Cao, 2018; Zhu et al., 2018].

While the above work considers the user-user and/or itemitem couplings but does not jointly learns explicit and implicit user-item couplings in deep networks for CF. Modeling explicit and implicit user-item couplings in deep models for CF is actually highly challenging, as this involves highdimensional and diverse interactions between observable and latent user/item attributes [Cao, 2015]. In addition, deep neural networks such as CNN have demonstrated their power in representing abstract features and made significant achievements in image processing and natural language processing. However, few deep models incorporate explicit attributes and their relations, resulting in gaps in sufficiently representing both implicit and explicit attributes and relations.

In this paper, we propose a coupled CF model, CoupledCF, which jointly learns and integrates both explicit and implicit user-item couplings in terms of both deep features learned by CNN and explicit attributes describing users and items.

• CoupledCF first learns the explicit user-item couplings w.r.t. user attributes and item attributes by a CNN-based user-item coupling learning network, then builds a deep CF (DeepCF) model to learn the implicit user-item couplings, and finally integrates the learned explicit useritem couplings with DeepCF to systematically represent user, item and user-item couplings.
• The CNN-based user-item coupling learning model consists of two components: a local CoupledCF which models the explicit user-item couplings by a convolution filter-based neural network (CNN) to capture local useritem interactions, and a global CoupledCF which combines local CoupledCF output with the user/item embedding product-based representation to capture the global user-item interactions.
• We co-train two neural networks: the local/global CoupledCF and DeepCF, to embed both implicit and explicit user/item features and relations into CF to jointly learn both explicit and implicit user-item couplings towards a comprehensive representation of user-item interactions.

Empirical evaluation of various CoupledCF models: local CoupledCF, global CoupledCF, DeepCF, and their combination CoupledCF are conducted on two real-life large datasets with certain user/item information. The results show all CoupledCF models outperform the baselines; in particular, CoupledCF significantly beats neural MF [He et al., 2017] (by over 40%) and Google's Wide&Deep network (by over 15%) on MovieLens 1M and Tafeng data.

2 RelatedWork

Deep learning is promising for effective and abstract representations in computer vision, natural language processing and speech recognition and deep networks-based representations [Cheng et al., 2016; Guo et al., 2017; He et al., 2017]. Convolutional neural network (CNN) is a widely-used deep learning model in computer vision and natural language processing. CNN shows high potential in effectively representing local and abstract features in image or documents. In recent years, deep learning has been used in recommender systems, such as [Wang et al., 2015b; 2018]. In [Kim et al.,

2016], CNN is integrated into probabilistic MF for document context-aware recommendation. In [He et al., 2017], a neural CF combines a shallow MF-based neural network with a multi-layer perceptron, NCF, to learn a user-item interaction function with implicit feedback. In this model, we build and combine a CNN-based user-item coupling learning network with a deep CF model to co-train both explicit and implicit user-item couplings, which cannot be done by existing work.

User/item information has been increasingly involved into CF. In [Cheng et al., 2016], Wide&Deep learning jointly trains wide linear models and deep neural networks. In the wide model, they use cross-product feature transformations to get the benefit of memorization; and in the deep model, they use a three-ReLU-layer neural network for generalization of recommendation. A DeepFM was proposed in [Guo et al., 2017]. Unlike Google's Wide&Deep model, shared raw features are treated as input to DeepFM without feature engineering. In [Zhao et al., 2016], a linear regression model is built on the item information and incorporated into the lowrank CF. In [Park et al., 2013], a Bayesian MF with side information handles the cold start problems. In this paper, we build the embeddings of the user/item information as input into a CNN-based network to learn a user-item coupling representation.

The nature of recommendation is non-IID [Cao, 2016]. Some pioneerning works have been introduced about learning the non-IIDness in recommendation [Cao, 2014], such as in CF [Yu et al., 2013; Li et al., 2013; 2015],[Georgiev and Nakov, 2013; Wang et al., 2015b], and by statistical learning [Do and Cao, 2018]. This paper builds on the framework of non-IID recommendation, and integrates non-IID explicit coupling learning with CNN to propose a deep CF model.

3 The CoupledCFModel

3.1 Preliminaries

Given a recommendation problem, assume a user set U = {u1 , u2 , . . . , um} and an item set V = {v1 , v2 , . . . , vn } contains m users and n items respectively, and the rating behaviors reflect the interactions between users and items, forming the rating matrix R. Each element yij in R reflects the interactions between user i and item j, which represents the user's explicit (such as 5-star ratings) or implicit preference on an item. In this work, we focus on user's implicit feedback on items, which can be formulated as a logistic regression problem to predict whether there will be interactions (such as clicking, viewing or purchasing behaviors) between users and items. Besides the above rating matrix, we involve the user and item attributes such as user demographics and item description in the interaction prediction.

Below, we present the CNN-based user-item coupling learning framework in Section 3.2, then introduce the DeepCF model in Section 3.3 and the corresponding CoupledCF model in Section 3.4.

3.2 CNN-based Explicit User-itemCoupling Learning

Figure 1 shows the CNN-based user-item coupling learning by involving user/item attributes. To learn the attributesbased user-item couplings, we embed the user and item information as dense vectors uc = {uc1, uc2, . . . , ucm} and vc = {vc1, vc2, . . . , vcm} respectively in the same vector space. uci (vci) denotes the ith element in vector uc (vc). In practice, the user information may be user demographics, user review information, or social relationships between users; The item information may include item descriptions. Accordingly, we take different embedding methods for different types of user/item information. For the embedding vectors uc and vc, we construct a function to calculate the coupling relationships, i.e., fΘ(uc, vc), which measures the interactions between elements of uc and vc. Θ denotes the parameters of f, which in practice can be fixed or learned. We then obtain a user-item coupling matrix Xc, in which each element is denoted as fi,j , to represent the couplings between the element uci of vector uc and element vcj of vector vc.

For the coupling matrix Xc, we utilize CNN to learn the local user-item couplings, forming the local CoupledCF model, as shown in the left box in Figure 1. The local CoupledCF model consists of convolutional and pooling layers. The convolution is performed as:

∗ is the convolution operator, W are the filters, b is a bias for W, and g is a non-linear activation function such as ReLU. On top of the convolutional layer, the pooling layers reduce the representation size of the outputs of the convolution to speed up the computation and refine the features from convolution for better discrimination/robustness. The pooling is performed as:

Ap is the pooling function such as max pooling or average pooling. The CNN represents the attributes-based local useritem couplings w.r.t. a local convolution filter to capture the local user-item interactions, represented as a local vector. To learn the global user-item couplings, we flatten the coupling matrix Xc as a vector and then concatenate it with the local user-item coupling representation to obtain the global useritem coupling representation, denoted as a global vector ec.

3.3 DeepCF for Implicit User-itemCoupling Learning

We construct a deep CF model, DeepCF, to predict the probability of a user-item interaction, shown in Figure 2. This model captures the implicit user-item couplings w.r.t. latent user and item factors inferred from the rating behaviors [Koren, 2008], explaining the rating formation. The latent item factors may explain the explicit characteristics such as a movie's genre and/or the hidden features of items. The user factors measure how much a user likes a movie in terms of the corresponding latent factors. With similar purpose as in NCF [He et al., 2017], DeepCF concatenates the user and item latent factors into a multi-layer fully-connected neural network to learn the implicit user-item interactions. For this, DeepCF represents the user identities and item identities as one-hot vectors u and v respectively. Inspired by the SkipGram model [Mikolov et al., 2013], a fully-connected layer is used as the embedding layer to learn the lower-dimension dense vectors, denoted as p and q for u and v respectively. The embedding process is formulated as:

The weight matrices Wu ∈ Rk×|U| and Wv ∈ Rk×|V | are fully connected between the input and embedding layers.

DeepCF maps both users and items to a joint latent factor space with the same dimensionality k. Further, the embedding vectors p and q are fed into a multiplication layer which conducts the element-wise product of p and q. It then outputs a linear interaction vector r which represents the linear user-item interactions. We formulate it as

Unlike Matrix Factorization models that model user-item ratings by inner-products, we feed vector r into a multi-layer fully-connected neural network to deeply learn the high-level abstract user-item interactions. After training DeepCF, matrices Wu and Wv represent the latent factors for all users and items. With the one-hot encoded representation of users and items, each column of Wu and Wv represents a certain user or item's latent factors p and q respectively. For a given item v, each dimension of v measures the extent to which the item has these factors. For a given user u, each dimension of v measures the extent of interest the user has in the corresponding factors of the item. Accordingly, the output vector r of the element product layer captures the linear interactions between users and items. The fully-connected layers further transform the output to represent the non-linear interactions between users and items. We formulate it as

W1,W2, . . . ,WL and b1, b2, . . . , bL denote the weight matrices and biases of each layer, and a1, a2, . . . , aL denote the output of each layer activated by the ReLU function.

DeepCF further predicts the probability of user-item interactions (e.g., rating or not) by a logistic Sigmoid function to squash the model output into the interval [0, 1], where 1 indicates a user favors an item, otherwise 0, by converting the multi-scale ratings to binary. It interprets a user-item interaction prediction w.r.t. a probability:

where Θ is the neural network weights. We use ˆ y as the prediction output.

As CF models do not involve negative examples, we sample some negative examples by a negative sampling strategy to make DeepCF discriminative. In our experiments, we sample negative examples from the unobserved interactions in the matrix R by a uniform negative sampling strategy as in [He et al., 2017].

For an example in the training dataset D = {< (u(i) , v(i) ), y(i) >} and the corresponding predicted output ˆ y(i) (here i denotes the ith example and i ∈ {1, 2, 3, . . . , |D|}) the loss is:

We then learn the network parameters Θ per the following cost function:

3.4 CoupledCF: Integrating Explicit and Implicit User-item Coupling Learning

Here we integrate the CNN-based local/global explicit useritem coupling learning with the implicit user-item coupling learner DeepCF to construct a comprehensive coupled CF model: CoupledCF.

The left network in Figure 3 implements the CNN-based user-item coupling learning, where user demographic information and item attributes are used as the user and item information. For user information, a dense embedding vector is learned for each categorical feature. We concatenate all the user embeddings with the numerical features which are normalized. The item information is processed in the same way as for the user information. Accordingly, two vectors uc and vc are generated and fed into the coupling layer. In our experiments, to simplify the learning, we define a user-item coupling calculation function below:

Accordingly, the user-item matrix Xc can be viewed as the cross-product of uc and vc. We execute two processes on the user-item matrix Xc. First, Xc is fed into the CNN components to learn the local user-item coupling vector. Second, Xc is flattened as a vector to learn the global user-item couplings. The local and global vectors are concatenated and then fed into a multilayer perceptron (MLP) network to learn highly abstract representation.

We further integrate the CNN-based local/global explicit user-item coupling learning with the DeepCF-based implicit user-item coupling learning by concatenating the output of these two networks. The concatenated vector (denoted as r) is processed by a fully-connected layer to generate the final user-item coupling vector. The integration forms the CoupledCF model. The overall output of CoupledCF is activated by a Sigmoid function and squashed to the range [0,1].

Hence, the training dataset of CoupledCF can be represented as D = {< (u(i) , v(i) , u(i) c , v(i) c ), yi >} i ∈ {1, 2, . . . , |D|}, and the objective of CoupledCF is implemented by predicting the probability PΘ:

The final output ˆ y of coupledCF is formulated as:

The cost function in Eqn. (9) is used to train CoupledCF.

4 Experiments and Evaluation

Similar to most CF methods [He et al., 2017; Rendle et al., 2009], we test our methods against the baselines for recommendations items to users who may likely be interested in based on implicit feedback reflecting user-item interactions.

4.1 Experimental Settings

Datasets. As few large-scale datasets are available with consistent ratings and user/item information, MovieLens 1M

[Harper and Konstan, 2016] and Tafeng dataset are used in our experiments. MovieLens1M consists of 1M transactions from 6,040 users and 3,952 items, Tafeng contains 817,741 transactions with 32,266 users and 23,812 items. Both datasets have user demographics (Gender, Age, Occupation and Zip code in MovieLens 1M and Customer ID, Age, and Region in Tafeng) and some item attributes (Genres in MovieLens 1M and Original ID, Sub class, Amount, Asset and Price in Tafeng). To create implicit feedbacks in these datasets, similar to the above methods, we binarize the ratings in two datasets to create implicit feedback for evaluation. Accordingly, we transform the original rating matrix scaled from ˜R ∈ {1, 2, . . . , 5} into a binarized preference matrix R ∈ {0, 1}, in which each rating element is expressed as either 0 or 1, where 1 indicates an interaction between a user and an item; otherwise 0. After transforming the attributed datasets to the implicit version, we uniform-randomly sample 4 negative instances for each positive instance.

Baseline Methods. Our CoupledCF is customized to four versions below to learn various types of user-item couplings:

• DeepCF: only learns the user-item interactions based on latent user/item factors (Figure 2);
• lCoupledCF: the CoupledCF integrating the the CNNbased local user-item coupling learning and DeepCF (the model with the local vector in Figure 1);
• gCoupledCF: the CoupledCF including the global coupling learning component without the CNN component (the model with the global vector in Figure 1);
• CoupledCF: the CoupledCF consisting of the local vector, global vector and DeepCF.

The following relevant and representative state-of-the-art methods are used as the baselines to evaluate our methods.

• NeuMF [He et al., 2017]: a CF method with implicit feedback embedded into a neural network. It verifies the contributions made by learning user/item information and how well our method with user/item information performs compared to the basic neural CF without side information.
• Wide&Deep [Cheng et al., 2016]: a benchmark Google's wide&deep neural network combining memorization and generalization for recommendation, which involves feature engineering (such as cross-product features) of the input to the wide network. To be fair, we transform the relevant user/item attributes to crossproduct features, which are then entered together with the raw features into the Wide&Deep model. We compare the performance of our model embedded with explicit/implicit user-item attributes to this Wide&Deep model that uses refined cross-product features.

Modeling Settings. The CoupledCF model is implemented in Python based on the Keras framework. All the baseline methods are implemented per their Github settings. All the experiments are performed in a 3.4GHz Titan Cluster with 96GB memory. The hyper-parameters of CoupledCF mainly include:

• The dimensionality of the embedding layers of the DeepCF model: After testing a various number of embedding layers, we empirically choose the best number 32 corresponding to Tafeng for both datasets.
• The number of the embedding layers of the CNN-based user-item coupling learning network: We evaluated it w.r.t. {8, 16, 32, 64, 128, 256}, and got the best performance on the model with 8 embedding layers for both datasets.
• We construct two CNN layers, set the filter as (8,8) and the channel as 8 for both datasets.
• The number of the fully-connected layers before the final output layer: We evaluated it w.r.t. {8, 16, 32, 64, 128, 256}, and got the best performance on the model with 64 fully-connected layers for the two datasets.
• The learning rate: We set it as 0.001 for MovieLens1M and 0.005 for Tafeng.

We use Adam as the optimizer for our model. For parameter initialization, we initialize the embedding matrix with a random normal distribution (the mean and standard deviation are 0 and 0.01 respectively) and use glorot-uniform as the initializer for the fully-connected layers. All biases in this model are initialized with zero.

Evaluation Metrics. We use the widely-used leave-oneout performance validation to evaluate all the comparison methods for implicit feedback-based recommendation as in [Bayer et al., 2017]. Similar to [Koren, 2008], we randomly sample one item with user-item interactions as the test item for each user and the remaining items with interactions as the training data. We randomly sample another 99 items which are not in the user's interacted item set to form the user's test data together with the above selected test item. We let each model to rank these 100 items for each user, and then evaluate the performance. We take the top-K Hit Ratio (HR@K) and Normalized Discounted Cumulative Gain (NDCG) [He et al., 2017] as evaluation metrics.

• HR@K: a recall-based measure, i.e., HR@K = #hits@K |GT| , to indicate whether the test item is in the topK recommended item list.
• NDCG: is a ranking-based measure, NDCG@K = Zk ∑Ki=1 2reli -1 log2 (i+1) , which assigns higher scores to hits with top ranks.

where GT denotes the test list set, reli is the graded relevance value of the item at position i and ZK is the normalization. In our experiments, we set reli ∈ {0, 1}, which depends on whether i is in the test dataset.

4.2 Results and Analysis

Top-K item recommendation results. The performance of the CoupledCF models against the baselines is reported in terms of HR@10 and NDCG@10 for top-10 items in Table 1. We also test the top-K (K=1 to 10) item recommendations in Figure 4 and Figure 5. CoupledCF is compared with local CoupledCF (lCoupledCF for short in Table 1), global CoupledCF (gCoupledCF), and DeepCF as well as all the baselines. The results show that CoupledCF significantly improves recommendation performance, e.g., up to 40.25% improvement over NeuMF (HR@2) and up to 15.27% improvement over Wide&Deep (NDCG@1), and averaged 22.84% improvement over NeuMF and averaged 11.78% over Wide&Deep.

Comparison with baselines. First, compared to neural MF model NeuMF, as shown in Table 1, CoupledCF beats NeuMF by 12.89% on MovieLens1M and 6.66% on Tafeng w.r.t. on HR@10; and 21.70% MovieLens1M and 6.79% on Tafeng w.r.t. NDCG@10. It shows our model involving user/item information significantly outperforms the neural MF without side information.

Second, compared to the Google benchmark Wide&Deep model, CoupledCF beats it by 9.52% MovieLens 1M and 5.21% on Tafeng w.r.t. on HR@10; and 9.60% MovieLens1M and 3.89% on Tafeng w.r.t. NDCG@10. This shows the way of CoupledCF learning and integrating explicit/implicit user-item interactions outperforms the feature engineering-based Wide&Deep's.

Testing the CoupledCF effectiveness. We further evaluate the working mechanism of CoupledCF in terms of different components embedded in the model. As introduced earlier, CoupledCF is customized to four versions: DeepCF, local CoupledCF, global CoupledCF, and the comprehensive CoupledCF. As shown in Table 1 and Figures 4 and 5, CoupledCF generally outperforms other versions for top-K item recommendations on both datasets. By comparison, local CoupledCF beats DeepCF and global CoupledCF in all cases. For example, for top-10 item recommendations, local CoupledCF beats DeepCF by 14.90% improvement and beats global CoupledCF by 4.93% w.r.t. HR@10 on Movielens1M, showing local CoupledCF captures CNN-based explicit user-item coupling learning outperforms the implicit user-item coupling neural network.

As shown in Figures 4 and 5, the above observations remain for the top-K item recommendation where K ranges from 1 to 10. The results show that both the local CNNbased component and the global coupling learning component contribute to improve the recommendation performance, while the comprehensive CoupledCF model integrating local/global attribute-based user-item coupling and implicit user-item couplings generally gains the best performance.

5 Conclusions

The nature of recommendation is non-IID. This work learns explicit and latent user-item interactions for recommendation: user/item attributes-based user-item interactions by CNN, implicit user-item interactions by MLP, and their integration. We propose a coupled deep collaborative filter: CoupledCF to learn and combine the above user-item interactions. The experimental results show significant improvement over stateof-the-art baselines on large datasets. In this work, we only use the user demographic information and limited item attributes, while the real-life data may obtain all user/item attributes. We are working on finding real-life business data with rich user/item attributes to test the CoupledCF model and exploring other deep architectures for representing hierarchical and heterogeneous user-item coupling relationships.

6 Acknowledgments

This work is sponsored by the China Scholarship Council (CSC NO. 201508210315 ).