Compositional Coding for Collaborative Filtering

TL;DR

This paper introduces CCCF, a novel collaborative filtering framework that combines binary codes with sparse real-valued weights, significantly improving recommendation accuracy and efficiency over existing binarized methods and even surpassing real-valued CF.

Contribution

The paper proposes a compositional coding approach that enhances binary representations with sparse real-valued weights, boosting both accuracy and speed in collaborative filtering.

Findings

CCCF outperforms state-of-the-art binarized CF methods in accuracy.

CCCF achieves higher accuracy than traditional real-valued CF.

The method significantly improves recommendation efficiency.

Abstract

Efficiency is crucial to the online recommender systems. Representing users and items as binary vectors for Collaborative Filtering (CF) can achieve fast user-item affinity computation in the Hamming space, in recent years, we have witnessed an emerging research effort in exploiting binary hashing techniques for CF methods. However, CF with binary codes naturally suffers from low accuracy due to limited representation capability in each bit, which impedes it from modeling complex structure of the data. In this work, we attempt to improve the efficiency without hurting the model performance by utilizing both the accuracy of real-valued vectors and the efficiency of binary codes to represent users/items. In particular, we propose the Compositional Coding for Collaborative Filtering (CCCF) framework, which not only gains better recommendation efficiency than the state-of-the-art binarized CF approaches but also achieves even higher accuracy than the real-valued CF method. Specifically, CCCF innovatively represents each user/item with a set of binary vectors, which are associated with a sparse real-value weight vector. Each value of the weight vector encodes the importance of the corresponding binary vector to the user/item. The continuous weight vectors greatly enhances the representation capability of binary codes, and its sparsity guarantees the processing speed. Furthermore, an integer weight approximation scheme is proposed to further accelerate the speed. Based on the CCCF framework, we design an efficient discrete optimization algorithm to learn its parameters. Extensive experiments on three real-world datasets show that our method outperforms the state-of-the-art binarized CF methods (even achieves better performance than the real-valued CF method) by a large margin in terms of both recommendation accuracy and efficiency.

Tables

Table 1. Table 1. Summary of datasets in our experiments.

Dataset	#Ratings	#Items	#Users	#density
Movielens 1M	1,000,209	3900	6040	4.2%
Yelp	696,865	25,677	25,815	0.11%
Amazon	5,057,936	146,469	189,474	0.02%

Table 2. Table 2. Retrieval time (in seconds) of recommendation methods on three datasets, ’Speedup’ indicates the speedup ( × \times ) of CCCF ( G = 8 , r = 16 formulae-sequence 𝐺 8 𝑟 16 G=8,r=16 ) over baselines.

Dataset	CCCF	MF		DCF
	Time	Time	Speedup	Time	Speedup
Movielens 1M	7.12	49.66	$\times$6.97	10.64	$\times$1.49
Amazon	831.34	5917.56	$\times$7.12	1231.35	$\times$1.48
Yelp	184.48	1450.25	$\times$7.86	264.65	$\times$1.43

Equations

$$\arg \underset{\mathbf{U},\mathbf{V}}{\min }\sum _{(i,j)\in \mathcal{V}}(R_{ij}-{\mathbf{u}}_i^{\top }{\mathbf{v}}_j{)}^2+\lambda R(\mathbf{U},\mathbf{V}),$$

$$\arg \underset{\mathbf{B},\mathbf{D}}{\min }\sum _{(i,j)\in \mathcal{V}}(R_{ij}-{\mathbf{b}}_i^{\top }{\mathbf{d}}_j{)}^2+\lambda R(\mathbf{B},\mathbf{D})$$

$$s.t.\mathbf{B}\in \{\pm 1{\}}^{m\times r},\mathbf{D}\in \{\pm 1{\}}^{n\times r}.$$

$$\mathbf{b}^{(1)}_{i},\dots,\mathbf{b}^{(G)}_{i}\in\{\pm 1\}^{r},\bm{\eta}_{i}=\Big{(}\eta_{i}^{(1)},\cdots,\eta_{i}^{(G)}\Big{)}\in\mathbb{R}^{G}$$

$$\mathbf{d}^{(1)}_{j},\dots,\mathbf{d}^{(G)}_{j}\in\{\pm 1\}^{r},\bm{\xi}_{j}=\Big{(}\xi_{j}^{(1)},\cdots,\xi_{j}^{(G)}\Big{)}\in\mathbb{R}^{G}$$

$${\hat{r}}_{ij}=\sum _{k=1}^G{w}_{ij}^{(k)}({\mathbf{b}}_i^{(k)}{)}^{\top }{\mathbf{d}}_j^{(k)},$$

$$nnz(\mathbf{w})\times T_h+T_s,$$

$$\displaystyle\eta^{(k)}_{i}=\frac{3}{4}\Big{(}1-d(i,i^{\prime}_{t})^{2}\Big{)}\textbf{1}\big{[}d(i,i^{\prime}_{t})<h\big{]},$$

$$\min$$

$$\underset{\text{balanced partition}}{\underbrace{{\text{1}}_m{\mathbf{B}}^{(k)}=0,{\text{1}}_n{\mathbf{D}}^{(k)}=0}},\underset{\text{decorrelation}}{\underbrace{({\mathbf{B}}^{(k)}{)}^{\top }{\mathbf{B}}^{(k)}=m{\mathbf{I}}_r,({\mathbf{D}}^{(k)}{)}^{\top }{\mathbf{D}}^{(k)}=n{\mathbf{I}}_r}}$$

$${\mathbf{B}}^{(k)}\in \{\pm 1{\}}^{m\times r},{\mathbf{D}}^{(k)}\in \{\pm 1{\}}^{n\times r},k=1,\dots ,G.$$

$$\underset{{\mathbf{B}}^{(k)},{\mathbf{D}}^{(k)},{\mathbf{X}}^{(k)},{\mathbf{Y}}^{(k)}}{\min }$$

$$+{\alpha }_1\Vert {\mathbf{B}}^{(k)}-{\mathbf{X}}^{(k)}{\Vert }_F+{\alpha }_2\Vert {\mathbf{D}}^{(k)}-{\mathbf{Y}}^{(k)}{\Vert }_F$$

$${\mathbf{B}}^{(k)}\in \{\pm 1{\}}^{m\times r},{\mathbf{D}}^{(k)}\in \{\pm 1{\}}^{n\times r},$$

$$\underset{{\mathbf{B}}^{(k)},{\mathbf{D}}^{(k)},{\mathbf{X}}^{(k)},{\mathbf{Y}}^{(k)}}{\min }\sum _{(i,j)\in \mathcal{V}}(R_{ij}-\sum _{k=1}^G{w}_{ij}^{(k)}({\mathbf{b}}_i^{(k)}{)}^{\top }{\mathbf{d}}_j^{(k)}{)}^2$$

$$-2{\alpha }_1\text{tr}(({\mathbf{B}}^{(k)}{)}^{\top }{\mathbf{X}}^{(k)})-2{\alpha }_2\text{tr}(({\mathbf{D}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)})$$

$${\text{1}}_m{\mathbf{X}}^{(k)}=0,{\text{1}}_n{\mathbf{X}}^{(k)}=0,({\mathbf{Y}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)}=m{\mathbf{I}}_r,({\mathbf{Y}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)}=n{\mathbf{I}}_r$$

$${\mathbf{B}}^{(k)}\in \{\pm 1{\}}^{m\times r},{\mathbf{D}}^{(k)}\in \{\pm 1{\}}^{n\times r},$$

$$\underset{{\mathbf{b}}_i^{(k)}\in \{\pm 1{\}}^r}{\min }$$

$$\displaystyle-2\Big{(}\sum_{j\in\mathcal{V}_{i}}\tilde{r}_{ij}(\mathbf{d}_{j}^{(k)})^{\top}\Big{)}\mathbf{b}_{i}^{(k)}-2\alpha_{1}(\mathbf{x}^{(k)}_{i})^{\top}\mathbf{b}^{(k)}_{i},$$

$$b_{iq}^{(k)}\leftarrow sgn(O(-{\hat{b}}_{ik}^{(k)},b_{iq}^{(k)}))$$

$${\hat{b}}_{iq}^{(k)}=\sum _{j\in {\mathcal{V}}_i}{\tilde{r}}_{ij}{d}_{jq}^{(k)}-\sum _{j\in {\mathcal{V}}_i}(w_{ij}^{(k)}{)}^2({\mathbf{d}}_j^{(k)}{)}^{\top }{\mathbf{b}}_i^{(k)}{d}_{jq}^{(k)}+\sum _{j\in {\mathcal{V}}_i}{b}_{iq}^{(k)}+{\alpha }_1{x}_{iq}^{(k)},$$

$$\underset{{\mathbf{d}}_j^{(k)}\in \{\pm 1{\}}^r}{\min }$$

$$-2(\sum _{i\in {\mathcal{V}}_j}{\tilde{r}}_{ij}({\mathbf{b}}_i^{(k)}{)}^{\top }){\mathbf{d}}_j^{(k)}-2{\alpha }_2({\mathbf{y}}_j^{(k)}{)}^{\top }{\mathbf{d}}_j^{(k)}.$$

$$d_{jq}^{(k)}\leftarrow sgn(O(-{\hat{d}}_{jq}^{(k)},d_{jq}^{(k)}))$$

$$\underset{{\mathbf{X}}^{(k)}}{\max }tr({\mathbf{B}}^{(k)}({\mathbf{X}}^{(k)}{)}^{\top }),{\text{1}}_m^{\top }{\mathbf{X}}^{(k)}=0,({\mathbf{X}}^{(k)}{)}^{\top }{\mathbf{X}}^{(k)}=m{\mathbf{I}}_r.$$

$${\mathbf{X}}^{(k)}\leftarrow \sqrt{m}[{\mathbf{P}}_b^{(k)},{\hat{\mathbf{P}}}_b^{(k)}][{\mathbf{Q}}_b^{(k)},{\hat{\mathbf{Q}}}_b^{(k)}{]}^{\top }.$$

$$({\bar{\mathbf{B}}}^{(k)}{)}^{\top }{\bar{\mathbf{B}}}^{(k)}=[{\mathbf{Q}}_b^{(k)}{\hat{\mathbf{Q}}}_b^{(k)}]\left[\begin{array}{cc}({\mathbf{\Sigma }}^{(k)}{)}^2& \text{0}\\ \text{0}& \text{0}\end{array}\right][{\mathbf{Q}}_b^{(k)}{\hat{\mathbf{Q}}}_b^{(k)}{]}^{\top },$$

$${\mathbf{P}}_b^{(k)}={\bar{\mathbf{B}}}^{(k)}{\mathbf{Q}}_b^{(k)}({\mathbf{\Sigma }}^{(k)}{)}^{-1}.$$

$$\underset{{\mathbf{Y}}^{(k)}}{\max }tr({\mathbf{D}}^{(k)}({\mathbf{Y}}^{(k)}{)}^{\top }),{\text{1}}_n^{\top }{\mathbf{Y}}^{(k)}=0,({\mathbf{Y}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)}=n{\mathbf{I}}_r.$$

$${\mathbf{Y}}^{(k)}\leftarrow \sqrt{n}[{\mathbf{P}}_d^{(k)},{\hat{\mathbf{P}}}_d^{(k)}][{\mathbf{Q}}_d^{(k)},{\hat{\mathbf{Q}}}_d^{(k)}{]}^{\top }.$$

$$\displaystyle\min\limits_{\mathbf{U}^{(k)},\mathbf{V}^{(k)},\mathbf{X}^{(k)},\mathbf{Y}^{(k)}}\;\sum_{(i,j)\in\mathcal{V}}\Big{(}R_{ij}-\sum^{G}_{k=1}w_{ij}^{(k)}(\mathbf{u}_{i}^{(k)})^{\top}\mathbf{v}_{j}^{(k)}\Big{)}^{2}$$

$$-2{\alpha }_1$$

$${\text{1}}_m{\mathbf{X}}^{(k)}=0,{\text{1}}_n{\mathbf{X}}^{(k)}=0,({\mathbf{Y}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)}=m{\mathbf{I}}_r,({\mathbf{Y}}^{(k)}{)}^{\top }{\mathbf{Y}}^{(k)}=n{\mathbf{I}}_r,$$

$${\mathbf{B}}^{(k)}\leftarrow \text{sgn}({\mathbf{U}}_0^{(k)}),{\mathbf{D}}^{(k)}\leftarrow \text{sgn}({\mathbf{V}}_0^{(k)}),{\mathbf{X}}^{(k)}\leftarrow {\mathbf{X}}_0^{(k)},{\mathbf{Y}}^{(k)}\leftarrow {\mathbf{Y}}_0^{(k)}.$$

$$\displaystyle\hat{\bm{\eta}}_{i}=\Big{\{}\lfloor e\cdot\eta^{(1)}_{i}\rceil,\dots,\lfloor e\cdot\eta^{(G)}_{i}\rceil\Big{\}},\quad\hat{\bm{\xi}}_{j}=\Big{\{}\lfloor e\cdot\xi^{(1)}_{j}\rceil,\dots,\lfloor e\cdot\xi^{(G)}_{j}\rceil\Big{\}},$$

Full text

In this work, we attempt to improve the efficiency without hurting the model performance by utilizing both the accuracy of real-valued vectors and the efficiency of binary codes to represent users/items. In particular, we propose the Compositional Coding for Collaborative Filtering (CCCF) framework, which not only gains better recommendation efficiency than the state-of-the-art binarized CF approaches but also achieves even higher accuracy than the real-valued CF method. Specifically, CCCF innovatively represents each user/item with a set of binary vectors, which are associated with a sparse real-value weight vector. Each value of the weight vector encodes the importance of the corresponding binary vector to the user/item. The continuous weight vectors greatly enhances the representation capability of binary codes, and its sparsity guarantees the processing speed. Furthermore, an integer weight approximation scheme is proposed to further accelerate the speed. Based on the CCCF framework, we design an efficient discrete optimization algorithm to learn its parameters. Extensive experiments on three real-world datasets show that our method outperforms the state-of-the-art binarized CF methods (even achieves better performance than the real-valued CF method) by a large margin in terms of both recommendation accuracy and efficiency. We publish our project at https://github.com/3140102441/CCCF.

Recommendation, Collaborative Filtering, Discrete Hashing

††copyright: rightsretained††doi: 10.475/123_4††isbn: 123-4567-24-567/08/06††conference: SIGIR; 2019; July 2019, Paris, France††journalyear: 2019††article: 4††price: 15.00††ccs: Information systems Recommender System††ccs: Humancentered computing Collaborative filtering

1. Introduction

Real-world recommender systems often have to deal with large numbers of users and items especially for online applications, such as e-commerce or music streaming services (Liu et al., 2016, 2017; Wang et al., 2017; Cheng et al., 2018, 2017). For many modern recommender systems, a de facto solution is often based on Collaborative Filtering (CF) techniques, as exemplified by Matrix Factorization (MF) algorithms (Koren et al., 2009). The principle of MF is to represent users’ preferences and items’ characteristics into $r$ low-dimensional vectors, based on the $m\times n$ user-item interaction matrix of $m$ users and $n$ items. With the obtained user and item vectors (in the offline training stage), during the online recommendation stage, the preference of a user towards an item is computed by the dot product of their represented vectors. However, when dealing with large numbers of users and items (e.g., millions or even billions of users and items), a naive implementation of typical collaborative filtering techniques (e.g., based on MF) will lead to very high computation cost for generating preferred item ranking list for a target user (Li et al., 2017). Specifically, recommending the top-$k$ preferred items for a user from those $n$ items costs $O(nr+n\log k)$ with real-valued vectors. As a result, this process will become a critical efficiency bottleneck in practice where the recommender systems typically require a real-time response for large-scale users simultaneously. Therefore, a fast and scalable yet accurate CF solution is crucial towards building real-time recommender systems.

Recent years have witnessed extensive research efforts for improving the efficiency of CF methods for scalable recommender systems. One promising paradigm is to explore the hashing techniques (Zhou and Zha, 2012; Liu et al., 2014a; Zhang et al., 2014) to represent users/items with binary codes instead of the real-value latent factors in traditional MF methods. In this way, the dot-products of user vector and item vector in MF can be completed by fast bit-operations in the Hamming space (Zhou and Zha, 2012). Furthermore, by exploiting special data structures for indexing all items, the computational complexity of generating top-K preferred items is sub-linear or even constant (Wang et al., 2012; Zhang et al., 2014), which significantly accelerates the recommendation process.

However, learning the binary codes is generally NP-hard (Håstad, 2001) due to its discrete constraints. Given this NP-hardness, a two-stage optimization procedure (Zhou and Zha, 2012; Liu et al., 2014a; Zhang et al., 2014), which first solves a relaxed optimization problem through ignoring the discrete constraints and then binarizes the results by thresholding, becomes a compromising solution. Nevertheless, this solution suffers from a large quantization loss (Zhang et al., 2016) and thus fails to preserve the original data geometry (user-item relevance and user-user relationship) in the continuous real-valued vector space. As accuracy is arguably the most important evaluation metric for recommender systems, researchers put lots of efforts to reduce the quantization loss by direct discrete optimization (Zhang et al., 2016; Lian et al., 2017; Liu et al., 2018). In spite of the advantages of this improved optimization method, compared to real-valued vectors, CF with binary codes naturally suffers from low accuracy due to limited representation capability in each bit, which impedes it from modeling complex relationship between users and items.

Figure 1 gives an example to illustrate the limit of binary codes. From the “film title” and “genres”, we can see that Star Wars is the most similar with Star Wars II, followed by The Matrix Reloaded, and all of them are action movies while Titanic is remarkably dissimilar to them which is categorized as a Drama movie. The real-valued vectors could easily preserve the original data geometry in the continuous vector space (e.g., intrinsic movie relationships), like $\mathbf{v}_{1},\mathbf{v}_{2},\mathbf{v}_{3}$, and $\mathbf{v}_{4}$. However, if we preserve the geometric relations of Star Wars, Star Wars II and The Matrix Reloaded by representing them using the binary codes $\mathbf{d}_{1}$, $\mathbf{d}_{2}$, and $\mathbf{d}_{3}$ in the Hamming space, the binary code of movie Titanic $\mathbf{d}_{4}$ will become close to $\mathbf{d}_{2}$ and $\mathbf{d}_{3}$, which unfortunately leads to a large error.

In this work, we attempt to improve the efficiency without hurting the model performance. We propose a new user/item representation named “Compositional Coding”, which utilizes both the accuracy of real-valued vectors and the efficiency of binary codes to represent users and items. To improve the representation capability of the binary codes, each user/item is represented by $G$ components of $r$-dimensional binary codes ($r$ is relatively small) together with a $G$-dimensional sparse weight vector. The weight vector is real-valued and indicates the importance of the corresponding component of the binary codes. Compared to the binary codes with same length (equal to $Gr$), the real-valued weight vector significantly enriches the representation capability. Meanwhile, the sparsity of the weight vector could preserve the high efficiency. To demonstrate how it works, we derive the Compositional Coding for Collaborative Filtering (CCCF) framework. To tackle the intractable discrete optimization of CCCF, we develop an efficient alternating optimization method which iteratively solves mixed-integer programming subproblems. Besides, we develop an integer approximation strategy for the weight vectors. This strategy can further accelerate the recommendation speed. We conduct extensive experiments in which our promising results show that the proposed CCCF method not only improves the accuracy but also boosts retrieval efficiency over state-of-the-art binary coding methods.

2. Preliminaries

In this section, we first review the two-stage hashing method for collaborative filtering. Then, we introduce the direct discrete optimization method, which has been used in Discrete Collaborative Filtering (DCF) (Zhang et al., 2016). Finally, we discuss the limitation of binary codes in representation capability.

2.1. Two-stage Hashing Method

Matrix Factorization (MF) is the most successful and widely used CF based recommendation method. It represents users and items with real-valued vectors. Then an interaction of the corresponding user and item can be efficiently estimated by the inner product. Formally, given a user-item interaction matrix $\mathbf{R}\in\mathbb{R}^{m\times n}$ with $m$ users and $n$ items. Let $\mathbf{u}_{i}\in\mathbb{R}^{r}$ and $\mathbf{v}_{j}\in\mathbb{R}^{r}$ denote the latent vector for user $i$ and item $j$ respectively. Then, the predicted preference of user $i$ towards item $j$ is formulated as $\hat{r}_{ij}=\mathbf{u}_{i}^{\top}\mathbf{v}_{j}.$ To learn all user latent vectors $\mathbf{U}=[\mathbf{u}_{1},\dots,\mathbf{u}_{m}]^{\top}\in\mathbb{R}^{m\times r}$ and item latent vectors $\mathbf{V}=[\mathbf{v}_{1},\dots,\mathbf{u}_{n}]^{\top}\in\mathbb{R}^{n\times r}$, MF minimizes the following regularized squared loss on the observed ratings:

[TABLE]

where $\mathcal{V}$ denotes the all observed use-item pairs and $R(\mathbf{U},\mathbf{V})$ is the regularization term with respect to $\mathbf{U}$ and $\mathbf{V}$ controlled by $\lambda>0$. To improve recommendation efficiency, after we obtain the optimized user/item real-valued latent vectors, the two-stage hashing method use binary quantization (rounding off (Zhang et al., 2014) or rotate (Zhou and Zha, 2012; Liu et al., 2014a)) to convert the continuous latent representations into binary codes. Let us denote $\mathbf{B}=[\mathbf{b}_{1},\dots,\mathbf{b}_{m}]^{\top}\in\{\pm 1\}^{m\times r}$ and $\mathbf{D}=[\mathbf{d}_{1},\dots,\mathbf{d}_{n}]^{\top}\in\{\pm 1\}^{n\times r}$ respectively as $r$-length user/item binary codes, then the inner product between the binary codes of user and item can be formulated as $\mathbf{b}_{i}^{\top}\mathbf{d}_{j}=2H(\mathbf{b}_{i},\mathbf{d}_{j})-r,$where $H(\cdot)$ denotes the Hamming similarity. Based on fast bit operations, Hamming distance computation is extremely efficient. However, this method usually incurs a large quantization error since the binary bits are obtained by thresholding real values to integers, and thus it cannot preserve the original data geometry in the continuous vector space (Zhang et al., 2016).

2.2. Direct Discrete Optimization Method

To circumvent the above issues, direct discrete optimization method has been proposed in Discrete Collaborative Filtering (DCF) (Zhang et al., 2016) and its extension (Lian et al., 2017; Zhang et al., 2017; Liu et al., 2018). More formally, it learns the binary codes by optimizing the following objective function:

[TABLE]

This objective function is similar to that of a conventional MF task, except the discrete constraint on the user/item embeddings. By additionally imposing balanced and de-correlated constraints, it could derive compact yet informative binary codes for both users and items.

However, compared to real-valued vectors, CF with binary codes naturally suffers from low accuracy due to limited representation capability in each bit. Specifically, the $r$-dimensional real-valued vector space have infinite possibility to model users and items, while the number of unique binary codes in Hamming space is $2^{r}$. An alternative way to resolve this issue is to use a longer code. Unfortunately, it will adversely hurt the generalization of the model especially in the sparse scenarios.

3. Compositional Coding for Collaborative Filtering

3.1. Intuition

In this work, we attempt to improve the efficiency of CF without hurting the prediction performance. We propose a new user/item representation named “Compositional Coding”, which utilizes both the accuracy of real-valued vectors and the efficiency of binary codes to represent users and items. Since the fixed distance between each pair of binary codes impedes them from modeling different magnitudes of relationships between users and items, we assign real-valued weight to each bit to remarkably enrich their representation capability. Besides, the importance parameters could implicitly prune unimportant bits by setting their importance parameters close to [math], which naturally reduces the computation cost.

3.2. Overview

In general, the proposed compositional coding framework assumes each user or item is represented by $G$ components of $r$-dimensional binary codes ($r$ is relatively small) and one $G$-dimensional sparse weight vector. Formally, denote by

[TABLE]

the compositional codes for the $i$-th user, and

[TABLE]

the compositional codes for the $j$-th item, respectively. Then the predicted preference of user $i$ for item $j$ is computed by taking the weighted sum of the inner product with respect to each of the $G$ components:

[TABLE]

where $w_{ij}^{(k)}=\eta_{i}^{(k)}\cdot\xi_{j}^{(k)}$ is the importance weight of the $k$-th component of binary codes with respect to user $i$ and item $j$.

Figure 2 illustrates how to estimate a user-item interaction using compositional codes. The inner product of each component of binary codes $(\mathbf{b}_{i}^{(k)})^{\top}\mathbf{d}_{j}^{(k)}$ can be efficiently computed in Hamming space using fast bit operations. The importance weight of the $k$-th component of binary codes $w_{ij}^{(k)}$ is obtained through a multiplication operation over $\eta_{i}^{(k)}$ and $\xi_{j}^{(k)}$, which ensures that the importance weight will be assigned a high value if and only if both user and item weights are large and will become zero if either of them is zero. It is worth noting that we use the multiplication instead of addition operation over the user and item weight to achieve the high sparsity of the sparse weight vector, which can lead to a significant reduction of computation cost during online recommendation.

Compared to representing users/items with binary codes, the key advantage of the proposed framework is that the sparse real-valued weight vector substantially increases the representation capacity of user/item embeddings by the compositional coding scheme. Recalling the example shown in Figure 1, we can preserve the movie relations by assigning them with different weight vectors, so as to predict user-item interactions with a lower error. Another benefit is mainly from the idea of compositional matrix approximation (Lee et al., 2013; Zhang et al., 2013), which is more suitable for real-world recommender systems, since the interaction matrix is very large and composed of diverse interaction behaviours. Under this view, the proposed compositional coding framework is characterized by multiple components of binary codes. Each component of binary codes can be employed to discover the localized relationships among certain types of similar users and items and thus can be more accurate in this particular region (e.g., young people viewing action movies while old people viewing romance movies). Therefore, the proposed compositional coding framework can encode users and items in a more informative way.

In addition to the improved representation and better accuracy, the compositional coding framework does not lose the high efficiency advantage of binary codes, and can even gain more efficiency when imposing sufficient sparsity. In order to show this, we analyze the time cost of the proposed framework and compare it against the conventional binary coding framework. In particular, assume the time cost of calculating the Hamming distance of $r$-bit codes is $T_{h}$ and the time cost of weighted summation of all of inner product results is $T_{s}$, then the total cost for a user-item similarity search is

[TABLE]

where $nnz(\mathbf{w})$ denotes the average number of non-zero values in component weight vector $\mathbf{w}\in\mathbb{R}^{G}$, which is much smaller than $G$ in our approach due to the sparsity of the user and item weights. Similarly, the cost by conventional hashing based CF models using $(G\times r)$-bit binary codes is $G\times T_{h}$ which can be higher than ours.

Remark. The proposed compositional coding framework is rather general. When identical weight vectors are used, it is degraded to the binary codes of conventional hashing based CF methods. Compositional codes could also be regarded as real-valued latent vectors of CF model, if we adopt the identical binary codes for each component. In summary, compositional code is a flexible representation which could benefit from both the strong representation capability of real-valued vectors and the fast similarity search of binary codes.

3.3. Formulation

In this section, we instantiate the compositional coding framework on Matrix Factorization (MF) models and term the proposed method as the Compositional Coding for Collaborative Filtering (CCCF). Note that the proposed compositional coding framework can be potentially applicable to other types of CF models beyond MF.

Follow the intuition of compositional coding, we assume that there exists a distance function $d$ that measures distances in the space of users ($i=1,\dots,m$) or items ($j=1,\dots,n$). The distance function leads to the notion of neighborhoods of user-user and item-item pairs. Its assumption states that the rating of user-item pair $(i,j)$ could be approximated particularly well in its neighbourhood. Thus, we identify $G$ components surrounding $K$ anchor points $(i^{\prime}_{1},j^{\prime}_{1}),\dots,(i^{\prime}_{G},j^{\prime}_{G})$. Follow the setting of compositional matrix approximation (Lee et al., 2013, 2014), user weight $\eta^{(k)}_{i}$ can be instantiated with an Epanechnikov kernel111Similar to (Lee et al., 2014), we also tried uniform and triangular kernel, but the performance was worse than Epanechnikov kernel, in agreement with the theory of kernel smoothing (Wand and Jones, 1994). (Wand and Jones, 1994), which is formulated as:

[TABLE]

where $h>0$ is a bandwidth parameter, $\bf{1}[\cdot]$ is the indicator function and $d(\cdot)$ is a distance function to measure the similarity between $i$ and $i^{\prime}_{t}$ (we will discuss it in Section 3.6). A large value of $h$ implies that $\bm{\eta}_{i}$ has a wide spread, which means most of the user component weights are non-zero. In contrast, a small $h$ corresponds to narrow spread of $\bm{\eta}_{i}$ and most of the user components will be zero. Item weight $\xi^{(k)}_{j}$ follows the analogous formulation. In this way, we could endow the weight vector $w^{(k)}_{ij}$ for user-item pair, which is defined as multiplication over user and item weight, with the sparsity. The method for selecting anchor points for each component is important as it may affect the values of component weights and further affect the generalization performance. A natural way is to uniformly sample them from the training set. In this work, we run $k$-means clustering with the user/item latent vectors and use the $G$ centroids as anchor points.

To learn the compositional codes, we adopt the squared loss to measure the reconstruction error as the standard MF method. For each set of binary codes, in order to maximize the entropy of each bit and make it as independent as possible, we impose balanced partition and decorrelated constraints. In summary, learning the compositional codes for users and items can be formulated into the following optimization task:

[TABLE]

where we denote $\mathbf{B}^{(k)}=[\mathbf{b}^{(k)}_{1},\dots,\mathbf{b}^{(k)}_{m}]^{\top}\in\{\pm 1\}^{m\times r}$ and $\mathbf{D}^{(k)}=[\mathbf{d}^{(k)}_{1},\dots,\mathbf{d}^{(k)}_{n}]^{\top}\in\{\pm 1\}^{n\times r}$ respectively as user and item binary codes in the $k$-th set of binary codes. The problem formulated in (3.3) is a mixed-binary-integer program which is a challenging task since it is generally NP-hard and involves a combinatorial search over $O(2^{Gr(m+n)})$. An alternative way is to impose auxiliary continuous variables $\mathbf{X}^{(k)}\in\mathcal{B}$ and $\mathbf{Y}^{(k)}\in\mathcal{D}$ for each set of binary codes, where $\mathcal{B}^{(k)}=\{\mathbf{X}^{(k)}\in\mathcal{R}^{m\times r}|\textbf{1}_{m}\mathbf{X}^{(k)}=0,(\mathbf{X}^{(k)})^{\top}\mathbf{X}^{(k)}=m\mathbf{I}_{r}\}$ and $\mathcal{D}^{(k)}=\{\mathbf{Y}^{(k)}\in\mathcal{R}^{n\times r}|\textbf{1}_{n}\mathbf{Y}^{(k)}=0,(\mathbf{Y}^{(k)})^{\top}\mathbf{Y}^{(k)}=n\mathbf{I}_{r}\}$. Then the balanced and de-correlated constraints can be softened by $\min_{\mathbf{X}^{(k)}\in\mathcal{B}^{(k)}}\|\mathbf{B}^{(k)}-\mathbf{X}^{(k)}\|_{F}$ and $\min_{\mathbf{Y}^{(k)}\in\mathcal{D}^{(k)}}\|\mathbf{D}^{(k)}-\mathbf{Y}^{(k)}\|_{F}$, respectively. Finally, we can solve problem (3.3) with respect to the $k$-the set of codes in a computationally tractable manner:

[TABLE]

where $\alpha_{1}$ and $\alpha_{2}$ are tuning parameters. Since $\text{tr}((\mathbf{B}^{(k)})^{\top}\mathbf{B}^{(k)})=\text{tr}((\mathbf{X}^{(k)})^{\top}\mathbf{X}^{(k)})=mr,$ and $\text{tr}((\mathbf{D}^{(k)})^{\top}\mathbf{D}^{(k)})=\text{tr}((\mathbf{Y}^{(k)})^{\top}\mathbf{Y}^{(k)})=nr,$ the above optimization task can be turned into the following

[TABLE]

which is the proposed learning model for CCCF. Note that we do not discard the binary constraints but directly optimize the binary codes of each component. Through joint optimization for the binary codes and the auxiliary real-valued variables, we can achieve nearly balanced and un-correlated binary codes. Next, we will introduce an efficient solution for the mixed-integer optimization problem in Eq. (3.3).

3.4. Optimization

We employ alternative optimization strategy to solve the above problem. Each iteration alternatively updates $\mathbf{B}^{(k)}$, $\mathbf{D}^{(k)}$, $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$. The details are given below.

Learning $\mathbf{B}^{(k)}$ and $\mathbf{D}^{(k)}$: In this subproblem, we update $\mathbf{B}^{(k)}$ with fixed $\mathbf{D}^{(k)}$, $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$. Since the objective function in Eq. (3.3) is based on summing over users of each component independently, so we can update binary codes for each user and item in parallel. Specifically, learning binary codes for user $i$ with respect to component $k$ is to solve the following optimization problem:

[TABLE]

where $\tilde{r}_{ij}=r_{ij}-\sum_{\tilde{k}\neq k}w_{ij}^{\tilde{k}}(\mathbf{b}_{i}^{\tilde{k}})^{\top}\mathbf{d}_{j}^{\tilde{k}}$ is the residual of observed rating excluding the inner product of component $k$.

Due to the discrete constraints, the optimization is generally NP-hard, we adopt the bitwise learning method called Discrete Coordinate Descent (Shen et al., 2015, 2017) to update $\mathbf{b}^{(k)}_{i}$. In particular, denoting $b^{(k)}_{iq}$ as the $q$th bit of $\mathbf{b}^{(k)}_{i}$ and $\mathbf{b}^{(k)}_{i\bar{q}}$ as the rest codes excluding $b^{(k)}_{iq}$, DCD update $b^{(k)}_{iq}$ while fixing $\mathbf{b}^{(k)}_{i\bar{q}}$. Thus, the updating rule for user binary code $b^{(k)}_{iq}$ can be formulated as

[TABLE]

where $\hat{b}^{(k)}_{iq}=\sum_{j\in\mathcal{V}_{i}}(\tilde{r}_{ij}-(w_{ij}^{(k)})^{2}(\mathbf{d}^{(k)}_{j\bar{q}})^{\top}\mathbf{b}^{(k)}_{i\bar{q}})d^{(k)}_{jq}+\alpha_{1}x^{(k)}_{iq}$, $\mathbf{d}^{(k)}_{j\bar{q}}$ is the rest set of item codes excluding $d_{jk}$ and $O(x,y)$ is a function that $O(x,y)=x$ if $x\neq 0$ and $O(x,y)=y$ otherwise. We iteratively update each bit until the procedure convergence. Note that the computational complexity of updating $\mathbf{B}^{(k)}$ is O\big{(}\#iter(mnr^{2})\big{)} which is a critical efficiency bottleneck when $m$ or $n$ is large. To efficiently compute $\hat{b}^{(k)}_{iq}$, we rewrite $\hat{b}^{(k)}_{iq}$ as

[TABLE]

which reduces the computational cost to O\big{(}\#iter(m+n)r^{2}\big{)}.

Similarly, we could learn binary code for item $j$ in component $k$ by solving

[TABLE]

Denote $d^{(k)}_{jq}$ as the $q$-th bit of $\mathbf{d}^{(k)}_{j}$ and $\mathbf{d}^{(k)}_{j\bar{q}}$ as the rest codes excluding $d^{(k)}_{jq}$, we update each bit of $\mathbf{d}^{(k)}_{j}$ according to

[TABLE]

where $\hat{d}^{(k)}_{jq}=\sum_{i\in\mathcal{V}_{j}}(\tilde{r}_{ij}-(w_{ij}^{(k)})^{2}(\mathbf{b}^{(k)}_{i\bar{q}})^{\top}\mathbf{d}^{(k)}_{j\bar{q}})b^{(k)}_{iq}+\alpha_{2}y^{(k)}_{jq}$.

Learning $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$: When fixing $\mathbf{B}^{(k)}$, learning $\mathbf{X}^{(k)}$ could be solved via optimizing the following objective function:

[TABLE]

It can be solved by the aid of SVD according to (Liu et al., 2014b). Let $\bar{\mathbf{B}}^{(k)}$ be a column-wise zero-mean matrix, where $\bar{B}^{(k)}_{ij}=B^{(k)}_{ij}-\frac{1}{m}\sum_{i}B^{(k)}_{ij}$. Assuming $\bar{\mathbf{B}}^{(k)}=\mathbf{P}^{(k)}_{b}\bm{\Sigma}^{(k)}_{b}(\mathbf{Q}^{(k)}_{b})^{\top}$ as its SVD, where each column of $\mathbf{P}^{(k)}_{b}\in\mathbb{R}^{m\times r^{\prime}}$ and $\mathbf{Q}^{(k)}_{b}\in\mathbb{R}^{r\times r^{\prime}}$ represents the left and right singular vectors corresponding to $r^{\prime}$ non-zero singular values in the diagonal matrix $\bm{\Sigma}^{(k)}_{b}$. Since $\bar{\mathbf{B}}^{(k)}$ and $\mathbf{Q}^{(k)}_{b}$ have the same row, we have $\textbf{1}^{\top}{\mathbf{P}^{(k)}}_{b}=0$ due to $\textbf{1}^{\top}\bar{\mathbf{B}}^{(k)}=0$. Then we construct matrices $\hat{\mathbf{P}}^{(k)}_{b}$ of size $m\times(r-r^{\prime})$ and $\hat{\mathbf{Q}}^{(k)}_{b}$ of size $r\times(r-r^{\prime})$ by employing a Gram-Schmidt process such that $(\ \hat{\mathbf{P}}^{(k)})_{b}^{\top}\hat{\mathbf{P}}^{(k)}_{b}=\textbf{I}_{r-r^{\prime}}$, $[\mathbf{P}^{(k)}_{b}\textbf{ 1}]^{\top}\hat{\mathbf{P}}^{(k)}_{b}=0$, and $(\hat{\mathbf{Q}}^{(k)}_{b})^{\top}\hat{\mathbf{Q}}_{b}=\textbf{I}_{r-r^{\prime}}$, $[\mathbf{Q}^{(k)}_{b}\textbf{ 1}]^{\top}\hat{\mathbf{Q}}^{(k)}_{b}=0$. Now we obtain a closed-form update rule for $\mathbf{X}^{(k)}$:

[TABLE]

In practice, to compute such an optimal $\mathbf{X}^{(k)}$, we perform the eigendecomposition over the small $r\times r$ matrix

[TABLE]

which provides $\mathbf{Q}^{(k)}_{b},\hat{\mathbf{Q}}^{(k)}_{b},\bm{\Sigma}^{(k)}$, and we can obtain

[TABLE]

Then matrix $\hat{\mathbf{P}}^{(k)}_{b}$ can be obtained by the aforementioned Gram-Schmidt orthogonalization. Note that it requires O\big{(}r^{2}m\big{)} to perform SVD, Gram-Schimdt orthogonalization and matrix multiplication.

When $\mathbf{D}^{(k)}$ fixed, learning $\mathbf{Y}^{(k)}$ could be solved in a similar way:

[TABLE]

We can obtain an analytic solution:

[TABLE]

where each column of $\mathbf{P}^{(k)}_{d}$ and $\mathbf{Q}^{(k)}_{d}$ is the left and right singular vectors of $\bar{\mathbf{D}}^{(k)}$ respectively. $\hat{\mathbf{Q}}^{(k)}_{d}$ are the left singular vectors corresponding to zero singular values of the $r\times r$ matrix $(\bar{\mathbf{D}}^{(k)})^{\top}\bar{\mathbf{D}}^{(k)}$, and $\hat{\mathbf{P}}^{(k)}_{d}$ are the vectors obtained via the Gram-Schimidt process. We summarize the solution for CCCF in Algorithm 1.

3.5. Initialization

Note that the proposed optimization problem involves a mixed-integer non-convex problem, the initialization of model parameters plays an important role for fast convergence and for finding better local optimum solution. To achieve a good initialization in an efficient way, we essentially relax the binary constraints in Eq. (3.3) into the following optimization:

[TABLE]

We first initialize real-valued matrix $\mathbf{U}^{(k)}$ and $\mathbf{V}^{(k)}$ randomly and find the feasible solution for $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$ according to the above learning method with respect to $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$. Then the alternating optimization are conducted by updating $\mathbf{U}$ and $\mathbf{V}$ with traditional gradient descent method and updating $\mathbf{X}$ and $\mathbf{Y}$ with respect to the similar learning method. Once we obtain the solution $(\mathbf{U}^{(k)}_{0},\mathbf{V}^{(k)}_{0},\mathbf{X}^{(k)}_{0},\mathbf{Y}^{(k)}_{0})$, we can initialize CCCF with respect to component $k$ as:

[TABLE]

The effectiveness of the proposed initialization will be discussed in Section 4.1 (illustrated in Figure 14).

3.6. Distance Function

Previously we assume a general distance function $d$, which is defined to measure the distance between users or items so as to compute the component weights $w_{i}^{(k)}$ and $v_{j}^{(k)}$ in Eq. (4). The metric can be constructed with side information, like users’ social link (Zhao et al., 2017; Wang et al., 2016) or using metric learning techniques (Xing et al., 2003). However, many datasets do not include such data. In this work, we follow the idea of (Lee et al., 2013, 2014) which factorizes the observed interaction matrix using MF and obtain two latent representation matrices $\mathbf{U}$ and $\mathbf{V}$ for users and items, respectively. Then the distance between two users can be computed by the cosine distance between the obtained latent representations, which is formulated as d(u_{i},u_{j})=arccos\Big{(}\frac{\langle\mathbf{u}_{i},\mathbf{u}_{j}\rangle}{\|\mathbf{u}_{i}\|\cdot\|\mathbf{u}_{j}\|}\Big{)}. The distance between two items can be computed in the same way.

3.7. Complexity

The computational complexity of training CCCF is $K$ times the complexity of learning each set of binary codes. It converges quickly in practice, which usually takes about $4\sim 5$ iterations in our experiments. For each iteration, the computational cost for updating $\mathbf{B}^{(k)}$ and $\mathbf{D}^{(k)}$ is O\big{(}\#iter(m+n)r^{2}\big{)}. In practice, $\#iter$ is usually $2\sim 5$. The computational cost for updating $\mathbf{X}^{(k)}$ and $\mathbf{Y}^{(k)}$ is O\big{(}r^{2}m\big{)} and O\big{(}r^{2}n), respectively. Suppose the entire algorithm requires $T$ iterations for convergence, the overall time complexity for Algorithm 1 is $O(Tqr^{2}(m+n))$, where we found $T$ empirically is no more than $5$. In summary, CCCF is efficient and scalable because it scales linearly with the number of users and items.

3.8. Fast Retrieval via Integer Weight Scaling

Floating-point operations over user and item weight vectors invoke more CPU cycles and are usually much slower than integer computation. The cost of top-$k$ recommendation would be remarkably lower when the scalars in the weight vectors are integers instead of floating numbers. An intuitive way is to adopt integer approximation via rounding the scalars in user and item weight vectors. However, if the weights are too small, it will incur large deviation. To tackle this problem, we scale the original scalars by multiplying each weight by $e$ and then approximate them with integers in preprocessing,

[TABLE]

where $\lfloor e\cdot\eta^{(k)}_{i}\rceil$ is a round function to obtain an integer approximation with respect to $e\cdot\eta^{(k)}_{i}$.

4. Experiments

In order to validate the effectiveness and efficacy of the proposed CCCF method for recommender systems, we conduct an extensive set of experiments to examine different aspects of our method in comparison to state-of-the-art methods based on conventional binary coding. We aim to answer the following questions:

• RQ1:

How does CCCF perform as compared to other state-of-the-arts hashing based recommendation methods in terms of both accuracy and retrieval time?

• RQ2:

How do different hyper-parameter settings (e.g., number of components, and code length) affect the accuracy of CCCF ?

• RQ3:

How do the sparsity of component weight vectors (controlled by the bandwidth parameter $h$) and integer scaling (controlled by parameter $e$) affect both the accuracy and retrieval cost of CCCF? How to choose optimal values ?

• RQ4:

Does the representation of compositional codes in CCCF enjoy a much stronger representation capability than the traditional binary codes in DCF given the same model size ?

4.1. Experimental Settings

4.1.1. Datasets and Settings.

We run our experiments on three public datasets: Movielens 1M222http://grouplens.org/datasets/movielens, Amazon and Yelp333 http://www.yelp.com/dataset challenge which are widely used in the literature. All of these ratings range from [math] to $5$. Considering the severe sparsity of Yelp and Amazon original datasets, we followed the conventional filtering strategy (Rendle et al., 2009) by removing users and items with less than $10$ ratings. The statistics of the filtered datasets are shown in Table 1. For each user, we randomly sampled $70\%$ ratings as training data and the rest $30\%$ for test. We repeated for $5$ random splits and reported the averaged results.

4.1.2. Parameter Settings and Performance Metrics.

For CCCF, we vary the number of components and the code length of each component in range $\{4,8,12,16\}$. The hyper-parameters $\alpha$ and $\beta$ are tuned within $\{10^{-4},10^{-3},\dots,10^{2}\}$. Grid search is performed to choose the best parameters on the training split. We evaluate our proposed algorithms by Normalized Discounted Cumulative Gain (NDCG) (Järvelin and Kekäläinen, 2000), which is probably the most popular ranking metric for capturing the importance of retrieving good items at the top of ranked lists. The average NDCG at cut off $[2,4,6,8,10]$ over all users is the final metric. A higher NDCG@K reflects a better accuracy of recommendation performance.

4.1.3. Baseline Methods and Implementations.

To validate the effectiveness of CCCF, we compare it with several state-of-the-art real-valued CF methods and hashing-based CF methods:

• •

MF: This is the classic Matrix Factorization based CF algorithm (Koren et al., 2009), which learns real-valued user and item latent vectors in Euclidean space.

• •

BCCF: This is a two-stage binarized CF method (Zhou and Zha, 2012) with a relaxation stage and a quantization stage. At these two stages, it successively solves MF with balanced code regularization and applies orthogonal rotation to obtain user codes and item codes.

• •

DCF: This is the first method (Zhang et al., 2016) directly tackles a discrete optimization problem for seeking informative and compact binary codes for users and items.

• •

DCMF: This is the state-of-the-art binarized method (Lian et al., 2017) for CF with side information. It extends DCF by encoding the side features as the constraints for user codes and item codes.

The CCCF algorithm empirically converges very fast and using the initialization generally helps as shown in Figure 3.

4.2. Experimental Results

4.2.1. Comparisons with State-of-the-arts (RQ1)

Figure 4 shows the results of top-$k$ recommendation with $k$ setting from $2$ to $10$. Note that the number of components $G$ is fixed to $8$ and the code length of each component varies in $\{4,6,8,10,12,14,16\}$. For fair comparison, the code length of DCF and the rank of MF are equal to the total bits of CCCF, which are equivalent to the summation of each component’s code length of CCCF ($rG$), so that the performance gain is not from increasing model complexity. From Figure 4, we can draw the following major observations:

First of all, we observe that CCCF considerably outperforms BCCF, DCF and DCMF which are the state-of-the-art hashing based CF methods. The performance of CCCF and DCF continiously increase as we increase the code length. Surprisingly, CCCF can even achieve remarkable superior performance using only $32$ bits in comparison to the DCF using $128$ bits on three datasets. This improvement indicates the impressive effectiveness of learning compositional codes.

Second, between baseline methods, DCF consistently outperforms BCCF, while slightly underperforms DCMF. This is consistent with the findings in (Zhang et al., 2016) that the performance of direct discrete optimization could surpass that of the two-stage methods. Besides, side information makes user codes and item codes more representative, which improves the recommendation performance.

Moreover, it is worth mentioning that CCCF outperforms MF, which is a real-valued CF method, particularly on the Amazon and Yelp dataset. The reasons for this are two-fold. First, compositional structure of CCCF has a much stronger representation capability which could discover complex relationships among users and items. Second, the higher sparsity of the dataset makes MF easy to overfit, whereras the binarized and sparse parameters in CCCF could alleviate this issue. This finding again demonstrates the effectiveness of our method.

Finally, Table 2 shows the total time cost (in seconds) taken by each method to generate the top-$k$ item list of all items. Overall, the hashing based methods (DCF and CCCF) outperform real-valued methods (MF), indicating the great advantage of binarizing the real-valued parameters. Moreover, CCCF shows superior retrieval time compared to DCF while enjoying a better accuracy. Thus, CCCF is a suitable model for large-scale recommender systems where the retrieval time is restricted within a limited time quota.

4.2.2. Impact of Hyper-parameter $G$ and $r$ (RQ2)

Our CCCF has two key parameters, the number of components $G$ and code length $r$, to control the complexity and capacity of CCCF. Figure 5(a) and 5(b) evaluate how they affect the recommendation performance under varied total bits and fixed total bits. In Figure 5(a), we vary the code length $r$ from $4$ to $16$ and the component number $G$ from $1$ to $16$. We can see that increasing $G$ leads to continued improvements. When $G$ is larger than $8$, the improvement tends to become saturated as the number of components increases. In addition, a larger value of $G$ would lead to relatively longer training time. Similar observations can be found from the results of hyper-parameter $r$ evaluation. In Figure 5(b), we fix the total bits $rG$ in range $\{32,64,96,128\}$ and varies the component number $G$ from $1$ to $32$. It should be noted that when $G=1$, CCCF model is identical to DCF model. As we gradually increase component number $G$, the recommendation performance grows since the real-valued component weight could enhance the representation capability. The best recommendation performance is achieved when $G=8$ or $16$. When $G$ is larger than the optimal values, increasing $G$ will hurt the performance. The main reason is that we fix the total bits $rG$, so that larger values of $G$ lead to smaller values of $r$. This will reduce the learning space of CCCF since the component weight is calculated by a predefined distance function which does not consider the rating information.

4.2.3. Impact of sparsity of component weight and integer weight scaling (RQ3)

To demonstrate the effectiveness of the integer weight scaling in accuracy and retrieval time , we run two versions of CCCF: EXACT and IWS. EXACT does not adopt the proposed integer weight scaling strategy. IWS uses the integer weight scaling described in Section 3.8. Figure 6 summarizes the speedup of the two versions of CCCF. The retrieval cost is not sensitive to the integer scaling parameter $e$ and we set $e$ to $100$. We can see the gap between the versions is consistent over Amazon and Yelp dataset. The low cost of IWS validates the effectiveness of the integer scaling which replaces the floating-point operations with the fast integer computation.

Figure 7 shows the impact of hyper-parameter $e$ on the accuracy of CCCF. We can find that when $e$ is smaller than $100$, the increase of $e$ leads to gradual improvements. When $e$ is larger than $100$, further increasing its value cannot improve the performance. This indicates that IWS is relatively insensitive when $e$ is sufficiently large. We thus suggest to set $e$ to 100.

To reveal the impact of sparsity of component weight in accuracy and retrieval cost, we vary the bandwidth hyperparameter $h$ from $0.5$ to $1$. It is obvious that decreasing the value of $h$ will increasing the sparsity of component weights. Figure 8 shows the accuracy and retrieval cost of CCCF for differnt $h$. First, we can see that the retrieval cost of CCCF continuously drop as we decrease the values of $h$ since high sparsity lead to fast computation. Second, we observe that the best recomendation performance is achieved when $h=0.7\sim 0.8$. When $h$ is smaller than $0.7\sim 0.8$, increasing the sparsity will make CCCF robust to overfitting. However, when the sparsity level is quite high, the CCF model might not be informative enough for prediction and thus suffer performance drop.

4.2.4. Item Embeddings Visualization (RQ4)

The key advantage of compositional codes is the stronger representational capability in comparison to binary codes. Therefore we visualize the learned item embeddings of the movielens 1M dataset where items are indicated as movies. We use the item representations learned by DCF and CCCF as the input to the visualization tool t-SNE (Maaten and Hinton, 2008). As a result, each movie is mapped into a two-dimensional vector. Then we can visualize each item embedding as a point on a two dimensional space. For items which are labelled as different genres, we adopt different colors on the corresponding points. Thus, a good visualization result is that the points of the same color are closer to each other. The visualization result is shown in Figure 9. We can find that the result of DCF is unsatisfactory since the points belonging to different categories are mixed with each other. For CCCF, we can observed clear clusters of different categories. This again validates the advantage of much stronger representation power of the compositional codes over traditional binary codes.

5. Related Work

As a pioneer work, Locality-Sensitive Hashing has been adopted for generating hash codes for Google News readers based on their click history (Das et al., 2007). Following this work, random projection was applied for mapping learned user/item embeddings from matrix factorization into the Hamming space to obtain binary codes for users and items (Karatzoglou et al., 2010). Similar to the idea of projection, Zhou et al. (Zhou and Zha, 2012) generated binary codes from rotated continuous user/item representations by running Iterative Quantization. In order to derive more compact binary codes, the de-correlated constraint over different binary codes was imposed on user/item continuous representations and then rounded them to produce binary codes (Liu et al., 2014a). The relevant work could be summarized as two independent stages: relaxed learning of user/item representations with some specific constraints and subsequent bianry quantization. However, such two-stage approaches suffer from a large quantization loss according to (Zhang et al., 2016), so direct optimization of matrix factorization with discrete constraints was proposed. To derive compact yet informative binary codes, the balanced and de-correlated constraints were further imposed (Zhang et al., 2016). In order to incorporate content information from users and items, content-aware matrix factorization and factorization machine with binary constraints was further proposed (Lian et al., 2017; Liu et al., 2018). For dealing with social information, a discrete social recommendation model was proposed in (Liu et al., 2019).

Recently, the idea of compositional codes has been explored in the compression of feature embedding (Chen et al., 2018; Shu and Nakayama, 2017; Svenstrup et al., 2017), which has become more and more important in order to deploy large models to small mobile devices. In general, they composed the embedding vectors using a small set of basis vectors. The selection of basis vectors was governed by the hash code of the original symbols. In this way, compositional coding approaches could maximize the storage efficiency by eliminating the redundancy inherent in representing similar symbols with independent embeddings. In contrast, this work employs compositional codes to address the inner product similarity search problem in recommender systems.

6. Conclusion and Future Work

This work contributes a novel and much more effective framework called Compositional Coding for Collaborative Filtering (CCCF). The idea is to represent each user/item by multiple components of binary codes together with a sparse weight vector, where each element of the weight vector encodes the importance of the corresponding component of binary codes to the user/item. In contrast to standard binary codes, compositional codes significantly enriches the representation capability without sacrificing retrieval efficiency. To this end, CCCF can enjoy both the merits of effectiveness and efficiency in recommendation. Extensive experiments demonstrate that CCCF not only outperforms existing hashing-based binary code learning algorithms in terms of recommendation accuracy, but also achieves considerable speedup of retrieval efficiency over the state-of-the-art binary coding approaches. In future, we will apply compositional coding framework to other recommendation models, especially for the more generic feature-based models like Factorization Machines. In addition, we are interested in employing CCCF on the recently developed neural CF models to further advance the performance of item recommendation.

Acknowledgements.

This research is supported by the National Research Foundation Singapore under its AI Singapore Programme [AISG-RP-2018-001]. Xin Wang is supported by China Postdoctoral Science Foundation No. BX201700136.