Leveraging User Comments for Recommendation in E-Commerce

Abstract

Collaborative filtering recommender systems traditionally recommend products to users solely based on the given user-item rating matrix. Two main issues, data sparsity and scalability, have long been concerns. In our previous work, an approach was proposed to address the scalability issue by clustering the products using the content of the user-item rating matrix. However, it still suffers from these concerns. In this paper, we improve the approach by employing user comments to address the issues of data sparsity and scalability. Word2Vec is applied to produce item vectors, one item vector for each product, from the comments made by users on their previously bought goods. Through the user-item rating matrix, the user vectors of all the customers are produced. By clustering, products and users are partitioned into item groups and user groups, respectively. Based on these groups, recommendations to a user can be made. Experimental results show that both the inaccuracy caused by a sparse user-item rating matrix and the inefficiency due to an enormous amount of data can be much alleviated.

1. Introduction

Recommender systems [1,2,3] are able to analyze the past behavior of customers and recommend the products in which they might be interested. Recommender systems can roughly be categorized into two types: collaborative filtering and content-based filtering. Content-based filtering [4,5,6] assumes that customers will buy things that are similar to what they have bought in the past. Therefore, detailed information about products and users are required for recommendations. However, the information needed is growing harder to get in the modern age of privacy awareness. Collaborative filtering [7,8,9,10,11,12,13,14,15,16,17] assumes that similar users have similar interest in items and similar items have similar ratings by users. Traditionally, users give their preference ratings for the previously purchased products, and these ratings are maintained in a user-item rating matrix. Based on the content of the matrix, collaborative filtering makes recommendations to a user according to the opinions of other like-minded users on the products. In general, collaborative filtering is simpler and more practical, and it tends to be more appealing in the E-commerce community.

However, there exist some issues with collaborative filtering. Two of them are data sparsity and scalability [18,19,20]. Data sparsity is related to the sparse ratings in the user-item rating matrix, and it can lead to inaccurate recommendations. Scalability is related to the huge number of products or/and users involved, which may cause an unacceptably long delay before valuable recommendations are acquired. In this paper, we propose a novel approach to deal with data sparsity and scalability. First of all, we apply Word2Vec [21,22], which is a word semantic tool developed by Google, to analyze the user comments on their previously bought goods. Each word is assigned a unique vector that represents its semantics. A set of item vectors, one item vector for each product, is then developed. Through the user-item rating matrix, the user vectors of all the users are obtained. Principal component analysis and an iterative self-constructing clustering algorithm are applied to reduce the time complexity related to the large numbers of items and users. Then, recommendation work is done with the resulting clusters. Finally, reverse transformation is performed, and a ranked list of recommended items can be offered to each user. With the proposed approach, the inaccuracy caused by the sparse ratings in the user-item rating matrix is overcome, and the processing time for making recommendations from an enormous amount of data is much reduced.

The proposed approach is an extension of our previous work published in [23]. Some major advantages over the previous work are provided. Word2Vec is applied on user comments to find the similarity relationship among products. Therefore, the sparsity problem is alleviated, and the accuracy of recommendation is improved. An iterative self-constructing clustering algorithm is used. The clusters obtained are less dependent on the order of the training patterns presented to the clustering algorithm, leading to more robust recommended results. Finally, clustering is applied not only on the products but also on the users. Consequently, the scalability problem can be further alleviated.

The rest of this paper is organized as follows. In Section 2, collaborative filtering, particularly our previous work [23], is briefly introduced. Some other related work is reviewed and discussed in Section 3. The proposed approach is described in detail in Section 4. Experimental results are presented in Section 5. Finally, a conclusion is given in Section 6.

2. Collaborative Filtering

Suppose there is a set of $N$ users, $u_i$,$1\le i\le N$, and a set of $M$ products, $p_j$, $1\le j\le M$. A user $u_i$ may express his/her evaluation to a product $p_j$ by providing a rating $r_{ij}$, which is a positive integer, for $p_j$. Usually, a higher rating is assumed to indicate a more favorable feedback from the user. If user $u_i$ has not provided a rating for product $p_j$, $r_{ij}=0$. Such information can be represented by the following user-item rating matrix $R$:

$$R=\left[\begin{array}{cc}\begin{array}{cc}{r}_{11}& r_{12}\\ r_{21}& r_{22}\end{array}& \begin{array}{cc}\cdots & r_{1M}\\ \cdots & r_{2M}\end{array}\\ \begin{array}{cc}⋮& ⋮\\ r_{N1}& r_{N2}\end{array}& \begin{array}{cc}\ddots & ⋮\\ \cdots & r_{NM}\end{array}\end{array}\right]$$

(1)

which is an $N\times M$ matrix. Traditionally, collaborative filtering recommends products to each user solely based on such a user-item rating matrix. The idea is simple, but issues of data sparsity and scalability may arise.

In [23], we proposed an approach to address the problem of scalability. Each product $p_i$, $1\le i\le M$, is represented as a $N$-vector, which is the $i$th column in $R$. A self-constructing clustering algorithm is applied to divide the products into a collection of $g$ clusters $C_1, C_2,\cdots , C_g$, with $g\le M$. Each cluster is regarded as one item group. Therefore, $g$ item groups, denoted $I_1, I_2,\cdots , I_g$, respectively, are obtained. Then a $M\times g$ transformation matrix $T$ is formed, with the $\left(i, j\right)$th entry $t_{ij}$ denoting the membership degree of product $p_i$ to item group $I_j$, $1\le i\le M$, $1\le j\le g$.

Next, the original user-item rating matrix $R$ is transformed to a reduced matrix $B$ by

$$\mathit{B}=RT$$

(2)

which is an $N\times g$ matrix. Based on $B$, a $g\times g$ correlation matrix is constructed. Then, ItemRank is applied, and a predicted preference list of item groups, $h_i$, is iteratively derived for each user $u_i$. Since recommendation is done with $B$, which is of size $N\times g$, rather than with $R$, which is of size $N\times M$, efficiency is improved. Finally, the reverse transformation is performed:

$$s_i=T{h}_i$$

(3)

which is the predicted preference list of products for user $u_i$, $1\le i\le N$.

However, collaborative filtering recommender systems may encounter difficulty due to sparsity. Consider

Table 1. A small user-item rating matrix $R$.

	${\mathit{p}}_1$	${\mathit{p}}_2$	${\mathit{p}}_3$	${\mathit{p}}_4$	${\mathit{p}}_5$	${\mathit{p}}_6$	${\mathit{p}}_7$
$u_1$	5	0	0	0	1	0	0
$u_2$	0	5	0	0	0	1	0
$u_3$	0	0	5	0	0	1	0
$u_4$	0	0	0	5	0	0	1
$u_5$	1	0	0	0	5	0	0
$u_6$	0	1	0	0	0	5	0
$u_7$	0	0	1	0	0	0	5

, which is a small user-item rating matrix, consisting of 7 users and 7 items. Clearly, there are many missing ratings in $R$.

Note that, because of sparsity, the rows of $R$ are hardly similar to each other. Recommendations based on the similarity between the users will not be accurate at all. In addition, because of sparsity, the columns of $R$ are hardly similar to each other. It is impossible to reduce the number of items by clustering techniques based on the similarity between the items. It is also impossible to reduce the number of users based on the similarity between the users. Therefore, data sparsity makes it hard in this case to get recommendations right and efficiently by collaborative filtering through similarity between the users or/and items.

3. Related Work

Various methods have been proposed to address to address the issues of data sparsity and scalability associated with collaborative filtering. In matrix factorization methods [24,25], an $\mathit{M}\times \mathit{N}$ user-item rating matrix is decomposed into two matrices of size $\mathit{M}\times \mathit{K}$ and $\mathit{K}\times \mathit{N}$, respectively. In this way, $\mathit{K}$ groups are obtained. Bobadilla et al. [18] use a Bayesian non-negative matrix factorization method and apply K-means to get better parameters for matrix factorization. These methods have a drawback in common. When encountering a heavily sparse user-item rating matrix, the groups obtained are not reliable. As a result, the resulting recommendations are not accurate and may not be useful. Zhang et al. [26] introduce the concepts of popular items and frequent raters. They assume that the ratings match some probability model. To overcome the data sparsity and rating diversity, smoothing and fusion techniques are employed. However, the method may encounter difficulties with a user-item rating matrix having a high degree of sparsity.

Clustering-based methods [2,23,27,28,29,30,31,32,33] have been proposed to address the scalability issue. Users or/and items are clustered into groups, and thus the numbers of users or/and items are reduced. Park [34] proposes a method that identifies tail items, having only a few ratings, from head items, having an enough number of ratings, according to their popularities. The recommendations for tail items are based on the ratings of clustered groups, while the recommendations for head items are based on the ratings of individual items or groups clustered to a lesser extent. However, this method tends to recommend tail items as a whole to users. Das et al. [30] use the DBSCAN clustering algorithm for clustering the users, and then implement voting algorithms to recommend items to the user depending on the cluster into which it belongs. The idea is to partition the users and apply the recommendation algorithm separately to each partition. Allahbakhsh and Ignjatovic [35] propose an iterative method that regards all the users as one user. The ratings by individual users are integrated together according to each user’s credibility, which is iteratively updated. This can reduce the sparsity difficulty. However, it cannot give personalized recommendations to each user. In our previous work [23], we apply a self-clustering algorithm to cluster products into item groups. However, the users are not clustered. This may encounter the scalability problem when a huge number of users are involved.

Incorporating information from sources other than the user-item rating matrix may help to overcome the sparsity problem [6,20,36,37,38]. Victor et al. [39] consider the trust and distrust relationship between users when doing rating prediction by collaborative filtering. The information about the trust and distrust relationship is gathered from the “useful” or “not useful” tag in the user text comments on items. If a user gives a useful tag in another user’s comments, a positive relationship will be considered to exist between them. Forsati et al. [40] also consider the trust and distrust relationship between users, taken from social networks, to mitigate the sparsity issue. They improve the matrix factorization method by adding a condition to the optimization function in which the trust and distrust information is embedded. Huang et al. [41] apply the user-item rating matrix, user social networks, and item features extracted from the DBpedia knowledge base to cluster users and items into multiple groups simultaneously. By merging the predictions from each cluster, the top-n recommendations to the target users are returned. Zheng et al. [42] propose a matrix factorization method that takes advantages of user comments to items. The comments are converted to item vectors with elements corresponding to the predefined keywords. If a keyword appears in the comments about an item, the corresponding element of the item vector is set to 1; otherwise, it is set to 0. One difficulty of this method is that the keywords have to be manually defined. Barkan et al. [43] use Word2Vec to analyze the metadata of items and construct item vectors. Then, items are clustered, and the top-k similar items can be found. However, for most of these methods, accessing user relationships from social networks is getting harder when the awareness of privacy is soaring nowadays. Besides, the information obtained indirectly through friends in social networks may not always be relevant. For instance, one may have a friend who has a really different lifestyle, contradicting the basic assumption for the trust relationship.

4. Proposed Approach

Suppose, from some other sources, we know that $p_1, p_2, p_3$, and $p_4$ in Table 1 are similar to each other, and so are $p_5, p_6$, and $p_7$. Then, we can somehow cluster these seven products into two item groups, say, $p_1^g$ and $p_2^g$, and transform the matrix to something similar to the one shown in

Table 2. The user-item rating matrix after a clustering of products.

	${\mathit{p}}_1^{\mathit{g}}$	${\mathit{p}}_2^{\mathit{g}}$
$u_1$	5	1
$u_2$	5	1
$u_3$	5	1
$u_4$	5	1
$u_5$	1	5
$u_6$	1	5
$u_7$	1	5

. Assume that the ratings in this table are obtained by taking the maximum of the original product ratings. Clearly, there exist two groups of similar users, namely, $\left\{u_1, u_2,u_3, u_4\right\}$ and $\left\{u_5, u_6,u_7\right\}$, and recommendations through the similarity between users can be done by collaborative filtering.

Motivated by this idea, we propose a novel approach to overcome the inaccuracy and inefficiency caused by data sparsity and scalability. Our approach consists of five steps: developing item and user vectors, grouping for items and users, getting a reduced user-item rating matrix, calculating group rating scores, and deriving individual preference lists. Step 1 aims to overcome the sparsity problem by exploiting extra information from user comments. Item and user vectors are derived. Step 2 aims to deal with the scalability problem. In this step, products and users are clustered into item groups and user groups, respectively. As a result, the numbers of products and users are greatly reduced. In step 3, the original user-item rating matrix is converted to a reduced user-item rating matrix that involves item groups and user groups. In step 4, a series of random walks are executed on the reduced user-item rating matrix, and a preference list of item groups is derived for each user group. Since low numbers of item groups and user groups are involved, this step can be done efficiently. Finally, in step 5, reverse transformations are performed, and preference lists of individual products are offered to each user. The pseudo-code of the approach is given below. Details will be described later.

The Proposed Approach

/⋆ Step 1: Developing item and user vectors ⋆/ Extract training patterns from the collected user comments; Train the Word2Vec network and obtain item vectors and user vectors; /⋆ Step 2: Grouping for items and users ⋆/ Reduce the dimensionality of item and user vectors; Cluster the item and user vectors into item and user groups; Obtain transformation matrices of membership degrees; /⋆ Step 3: Getting the reduced user-item rating matrix ⋆/ Transform the original user-item rating matrix to the reduced matrix; /⋆ Step 4: Calculating group rating scores ⋆/ Construct the correlation matrix from the reduced user-item rating matrix; Apply ItemRank to predict preference lists of item groups for user groups; /⋆ Step 5: Deriving individual preference lists ⋆/ Reversely transform to obtain preference lists of products for users;

4.1. Step 1—Developing Item and User Vectors

As mentioned, it is usually difficult to discover similarity between items or users solely based on the sparse ratings provided in the user-item rating matrix. Extra sources have to be consulted for help. In this step, we apply Word2Vec on user comments to discover semantic relationships between products. Each product is converted to an item vector. Then, the item vectors can be used for clustering products later. In addition, the users can be converted to user vectors, by which the clustering on users can be done.

We address the data sparsity problem by finding the relationship between items from the user comments posted on the public domain. We use these user comments to train a Word2Vec network. The word vectors obtained after training should reveal semantic relationships among items, so it is required that the inputs to the Word2Vec network be items in the training patterns.

We take the user review text of an item and insert the item identity into the text repeatedly. Suppose that the window size is $2s+1$. The item identity is inserted in the middle of every $2s$ words in the original text. Training patterns, each consisting of an input–output word pair $(x,y)$, are extracted from the windows. For each window, the central word is taken as input $x$, and each of its context words is taken as output $y$ to form training patterns. Assume that a window contains $2s+1$ words, $w{\prime }_{r+1}\cdots w{\prime }_{r+s}w{\prime }_{r+s+1}w{\prime }_{r+s+2}\cdots w{\prime }_{r+2s+1}$, where $w{\prime }_{r+s+1}$ is the central word and the other words are context words. Then, there are $2s$ training patterns, $(w{\prime }_{r+s+1},w{\prime }_{r+1})$, …, $(w{\prime }_{r+s+1},w{\prime }_{r+s})$, $(w{\prime }_{r+s+1},w{\prime }_{r+s+2})$, …, $(w{\prime }_{r+s+1},w{\prime }_{r+2s+1})$, extracted from the window. Let the review text of an item, with its item identity being 0000013714, be:

I bought this for my husband who plays the piano He is having a wonderful time playing these old hymns The music is at times hard to read because we …

For $s=3$, the user review text after insertion is shown below, ignoring punctuation marks:

I bought this0000013714for my husband who plays the0000013714piano He is having a wonderful0000013714time playing these old hymns The0000013714music is at times hard to0000013714read because we …

Note that the item identity 0000013714 appears in the middle of each non-overlapping window of seven words. For instance, the first window consists of the following words:

I bought this0000013714for my husband.

Then, we extract training patterns from each window. Considering the first window above, six training patterns are extracted:

(0000013714, I), (0000013714, bought), (0000013714, this),

(0000013714, for), (0000013714, my), (0000013714, husband).

For the second window “who plays the 0000013714 piano He is”, another six training patterns are extracted:

(0000013714, who), (0000013714, plays), (0000013714, the),

(0000013714, piano), (0000013714, He), (0000013714, is).

Note that the first words in the training patterns are the item identity.

After extracting the training patterns from the collected user comments, the training patterns are fed into the Word2Vec network [21,22], as shown in Figure 1, for training.

The neural network is trained as follows. Suppose $\left(w_i,w_k\right)$ is a training pattern involving two words, $w_i$ and $w_k$. Word $w_i$ corresponds to node $i$ in the input layer, and word $w_k$ corresponds to node $k$ in the output layer, with input weights $v_i^1={\left[v_{1i}^1\cdots v_{Hi}^1\right]}^T$ and output weights $v_k^2={\left[v_{k1}^2\cdots v_{kH}^2\right]}^T$. Note that the input value at node $i$ is 1, while those at the other nodes in the input layer are 0. In addition, the desired value at node $k$ is 1, while those at the other nodes in the output layer are 0. The network output at node $k$ is

$$o_k=\frac{1}{1+e^{-v_i^1·v_k^2}}$$

(4)

where `·’ is the inner product operator. Let $J$ be $J=-{\log }_e{o}_k$. By steepest descent, $v_i^1$ and $v_k^2$ are adjusted as

$$v_i^1\leftarrow v_i^1-\eta {\nabla }_{v_i^1}J=v_i^1-\eta \left(o_k-1\right)v_k^2,$$

(5)

$$v_k^2\leftarrow v_k^2-\eta {\nabla }_{v_k^2}J=v_k^2-\eta \left(o_k-1\right)v_i^1$$

(6)

where $\eta$ is the learning rate. During the learning, if two training patterns $\left(w_i,w_k\right)$ and $\left(w_j,w_k\right)$ occur frequently in the training documents, $v_i^1$ and $v_j^1$ will be close to each other. When the learning is completed, the input weights of the network are taken to be item vectors. That is, $v_1^1$ is the word vector of word $w_1$, $v_2^1$ is the word vector of word $w_2$, etc. Note that item vectors are word vectors of the item identities. For $M$ products, we have $M$ item vectors in total, $p_1, p_2,\cdots , p_M$, as shown below:

$$p_i=\left[\begin{array}{c}{p}_{1i}\\ \begin{array}{c}{p}_{2i}\\ ⋮\end{array}\\ p_{Hi}\end{array}\right]=\left[\begin{array}{c}{v}_{1i}^1\\ \begin{array}{c}{v}_{2i}^1\\ ⋮\end{array}\\ v_{Hi}^1\end{array}\right]$$

(7)

for $i=1 ,\cdots , M$. Clearly, each item vector contains $H$ components. In this work, we set $H=100$. Note that if two items are semantically similar, then their corresponding item vectors are close to each other.

Now that item vectors are available, we can derive user vectors, which can then be used for similarity computation. First, we normalize each row in the user-item rating matrix R as follows:

$$a_{ij}=\frac{r_{ij}}{{\sum }_{k=1}^M{r}_{ik}}, 1\le j\le M$$

(8)

for $1\le i\le N$. Then, user vectors, $u_k$, $1\le k\le N$, are derived as follows:

$$u_k=\left[\begin{array}{c}{u}_{1k}\\ \begin{array}{c}{u}_{2k}\\ ⋮\end{array}\\ u_{Hk}\end{array}\right]={\sum }_{j=1}^M{a}_{kj}{p}_j.$$

(9)

Note that each user vector also contains $H$ components.

4.2. Step 2—Grouping for Items and Users

This step aims to deal with the scalability problem. First of all, the dimensionality, $H$, can be too large for effective processing. PCA (Principal Component Analysis) [44,45] is applied to reduce the dimensionality of the item and user vectors. We choose $q_p$ and $q_u$ as principal components so that they are as small as possible, and the cumulative energy is above a certain threshold $\theta$, e.g., 0.7. Therefore, there are $q_p$, instead of $H$, values in $p_i$, $i=1,\cdots , M$, and there are $q_u$, instead of $H$, values in $u_i$, $i=1,\cdots , N$.

Now, we apply an iterative self-constructing clustering algorithm [46], which is an iterative version of that used in [23], to partition the item and user vectors into item and user groups, respectively. We feed the item vectors, $p_i$, $1\le i\le M$, as the training patterns, to the clustering algorithm. For each pattern $p_i$, $i=1,\cdots ,M$, the membership degree of the pattern to each existing cluster $C_j$, with center ${\left[c_{1j}^p\cdots c_{q_{p}j}^p\right]}^T$ and deviation ${\left[d_{1j}^p\cdots d_{q_{p}j}^p\right]}^T$, is calculated as

$$G_j\left(p_i\right)={\displaystyle \prod }_{k=1}^{q_p}\exp \left[-{\left(\frac{p_{ki}-c_{kj}^p}{d_{kj}^p}\right)}^2\right].$$

(10)

If $G_j\left(p_i\right)<\rho$ for all existing clusters, a new cluster is created, and $p_i$ is included in the new cluster. Otherwise, $p_i$ is added into the cluster with the largest membership degree. Note that Gaussian is adopted to describe the data distribution of each cluster, and $G_j\left(p_i\right)$ lies in the range of $\left(0,1\right]$. Suppose we have $M_g$ clusters $C_1^p,C_2^p,\cdots ,C_{M_g}^p$ at the end, each having its own center and deviation. Each cluster is regarded as one item group. Therefore, we have $M_g$ item groups, denoted $p_1^g,p_2^g,\cdots ,p_{M_g}^g$, respectively. Let

$$t_{ij}^p=G_j\left(p_i\right)$$

(11)

for $1\le i\le M$ and $1\le j\le M_g$. Then, we form the transformation matrix

$$T_p=\left[\begin{array}{cc}\begin{array}{cc}{t}_{11}^p& t_{12}^p\\ t_{21}^p& t_{22}^p\end{array}& \begin{array}{cc}\cdots & t_{1M_g}^p\\ \cdots & t_{2M_g}^p\end{array}\\ \begin{array}{cc}⋮& ⋮\\ t_{M1}^p& t_{M2}^p\end{array}& \begin{array}{cc}\ddots & ⋮\\ \cdots & t_{M{M}_g}^p\end{array}\end{array}\right]$$

(12)

which is an $M\times M_g$ matrix, containing all the membership degrees of the products $p_i$, $1\le i\le M$, to the item groups $p_j^g$, $1\le i\le M_g$.

Next, we feed the user vectors, $u_i$, $1\le i\le N$, as the training patterns, to the clustering algorithm. Suppose we have $N_g$ clusters $C_1^u, C_2^u,\cdots , C_{N_g}^u$ at the end. Each cluster is regarded as one user group. Therefore, we have $N_g$ user groups, denoted $u_1^g, u_2^g,\cdots , u_{N_g}^g$, respectively. Let $t_{ij}^u$ denote the membership degree of $u_i$ to cluster $C_j^u$, computed as

$$t_{ij}^u=G_j\left(u_i\right)={\displaystyle \prod }_{k=1}^{q_u}\exp \left[-{\left(\frac{u_{ki}-c_{kj}^u}{d_{kj}^u}\right)}^2\right]$$

(13)

for $1\le i\le N$ and $1\le j\le N_g$. Then, we form the transformation matrix

$$T^u=\left[\begin{array}{cc}\begin{array}{cc}{t}_{11}^u& t_{12}^u\\ t_{21}^u& t_{22}^u\end{array}& \begin{array}{cc}\cdots & t_{1N_g}^u\\ \cdots & t_{2N_g}^u\end{array}\\ \begin{array}{cc}⋮& ⋮\\ t_{N1}^u& t_{N2}^u\end{array}& \begin{array}{cc}\ddots & ⋮\\ \cdots & t_{N{N}_g}^u\end{array}\end{array}\right]$$

(14)

which is an $N\times N_g$ matrix, containing all the membership degrees of the users $u_i$, $1\le i\le N$, to the user groups $u_j^g$, $1\le j\le N_g$.

4.3. Step 3—Getting a Reduced User-Item Rating Matrix

In this step, we transform the original user-item rating matrix $R$ to the reduced matrix $R_g$. We first convert $R$ to a matrix $B$ by

$$B=R{T}_p$$

(15)

which is an $N\times M_g$ matrix, indicating the ratings for the $M_g$ item groups by the $N$ users. Next, we convert $B$ to $R_g$ by

$$R_g={\left\{T_u\right\}}^{T}B={\left\{T_u\right\}}^{T}R{T}_p=\left[\begin{array}{cc}\begin{array}{cc}{r}_{11}^g& r_{12}^g\\ r_{21}^g& r_{22}^g\end{array}& \begin{array}{cc}\cdots & r_{1M_g}^g\\ \cdots & r_{2M_g}^g\end{array}\\ \begin{array}{cc}⋮& ⋮\\ r_{N_{g}1}^g& r_{N_{g}2}^g\end{array}& \begin{array}{cc}\ddots & ⋮\\ \cdots & r_{N_g{M}_g}^g\end{array}\end{array}\right]$$

(16)

which is an $N_g\times M_g$ matrix. Note that $R_g$ contains the ratings for the $M_g$ item groups by the $N_g$ user groups. We call $R_g$ the reduced user-item rating matrix.

4.4. Step 4—Calculating Group Rating Scores

In this step, one preference list of item groups is derived for each user group. Since low numbers of item groups and user groups are involved, this step can be done efficiently. Firstly, a correlation graph is built from the reduced user-item rating matrix $R_g$. Then, a series of random walks based on ItemRank [9] are performed.

Based on $R_g$, we construct a correlation graph that shows the inter-relationship among the item groups. Each item group is regarded as a node in the graph, and thus we have $M_g$ nodes in total. The weight $m_{ij}^g$ on the edge between node $p_i^g$ and node $p_j^g$, $1\le i, j\le M_g$ is properly defined [23]. When the correlation graph is completed, we have the following correlation matrix:

$$M_g=\left[\begin{array}{cc}\begin{array}{cc}{m}_{11}^g& m_{12}^g\\ m_{21}^g& m_{22}^g\end{array}& \begin{array}{cc}\cdots & m_{1M_g}^g\\ \cdots & m_{2M_g}^g\end{array}\\ \begin{array}{cc}⋮& ⋮\\ m_{M_{g}1}^g& m_{M_{g}2}^g\end{array}& \begin{array}{cc}\ddots & ⋮\\ \cdots & m_{M_g{M}_g}^g\end{array}\end{array}\right]$$

(17)

which is a $M_g\times M_g$ matrix. Then, we normalized each column by:

$$m_{ij}^g\leftarrow \frac{m_{ij}^g}{{\sum }_{k=1}^{M^g}{m}_{kj}^g}, 1\le i\le M_g$$

(18)

for $1\le j\le M_g$.

After creating the correlation matrix $M_g$, we proceed with ItemRank to predict a preference list of item groups for each user group. Consider any user group $u_i^g$, $1\le i\le N_g$. Let $h_i\left(0\right)$ be

$$h_i\left(0\right)=\left[\begin{array}{c}1/M_g\\ \begin{array}{c}1/M_g\\ ⋮\end{array}\\ 1/M_g\end{array}\right]$$

(19)

which is a vector with $M_g$ elements. The following operation

$$h_i\left(t+1\right)=\alpha M_g{h}_i\left(t\right)+\left(1-\alpha \right)r_i^g$$

(20)

is performed iteratively for $t=0, 1, 2, \cdots$ until convergence. Note that $r_i^g$ is the transpose of the ith row of $R_g$ and $\alpha \in \left[0,1\right]$ is a user-defined constant. A common choice for $\alpha$ is 0.85. Usually, convergence is reached after 20 iterations [9]. Let $h_i$ be the converged result, having $M_g$ components. Then, $h_i$ is the predicted preference list of item groups for the user group $u_i^g$, $1\le i\le N_g$.

4.5. Step 5—Deriving Individual Preference Lists

Now, we have obtained $h_1, h_1, \cdots , h_{N_g}$ for user groups $u_1^g, u_2^g, \cdots , u_{N_g}^g$, respectively. Each $h_i$, $1\le i\le N_g$, is a preference list in which $M_g$ item groups are involved. However, we are interested in recommending individual products to each user. In this step, we do reverse transformation to get a predicted preference list of products for each user.

Firstly, we find a predicted preference list of products for each user group. We compute vector $y_i$ by

$$y_i=T_p{h}_i$$

(21)

for $1\le i\le N_g$. Clearly, $y_i$ is of length $M$, and it is the predicted preference list of products for user group $u_i^g$. Next, we compute vector $s_i$ as

$$s_i=t_{i1}^u{y}_1+t_{i2}^u{y}_2+\cdots +t_{i{N}_g}^u{y}_{N_g}$$

(22)

for $1\le i\le N$, which is the predicted preference list of products for user $u_i$. Similar to ItemRank, the products can be recommended to user $u_i$ in the order according to the magnitudes of the elements in $s_i$.

5. Experimental Results

To evaluate the performance of our proposed approach, we conduct a set of experiments on several benchmark datasets. For convenience, we call our approach CFUCC (Collaborative Filtering based on User Comments and Clustering) in the remainder of this section. We also compare our CFUCC approach with some other collaborative filtering recommender systems.

Two metrics are adopted for comparison of recommendation accuracy, mean absolute error (MAE) and root mean squared error (RMSE) [47]. Let $\mathcal{P}$ be the set of all products, and ${\mathcal{L}}_i$ and ${\mathcal{T}}_i$ be two sets containing the products user $u_i$ has rated in the training set and in the testing set, respectively. Note that it is required that none of ${\mathcal{L}}_i$ is empty, i.e., ${\mathcal{L}}_i\ne \varnothing$, $1\le i\le N$. To compute MAE or RMSE, we have to convert predicted preferences to corresponding predicted scores. Let ${\widehat{r}}_{ij}$ be the predicted score corresponding to the predicted preference of product $p_j$ for user $u_j$. We compute ${\widehat{r}}_{ij}$ by

$${\widehat{r}}_{ij}=r_i^a+\frac{{\sum }_{k=1\wedge k\ne i}^N\left[\mathrm{Sim}\left(u_i,u_k\right)\times \left(r_{kj}-r_k^a\right)\right]}{{\sum }_{k=1\wedge k\ne i}^N\mathrm{Sim}\left(u_i,u_k\right)}$$

(23)

where $r_i^a$ is the average of the ratings in ${\mathcal{L}}_i$, $r_k^a$ is the average of the ratings in ${\mathcal{L}}_k$, $r_{kj}$ is the rating for product $j$ in ${\mathcal{L}}_k$, and $\mathrm{Sim}\left(u_i,u_k\right)$ indicates the similarity between user $u_i$ and user $u_k$ defined by the cosine of the predicted preference lists $s_i$ and $s_k$:

$$\mathrm{Sim}\left(u_i,u_k\right)=\frac{s_i\cdot s_k}{\sqrt{s_i\cdot s_i}\sqrt{s_k\cdot s_k}}$$

(24)

with `·’ being the inner product operator for vectors. Then, MAE and RMSE are defined as

$$\mathrm{MAE}=\frac{{\sum }_{i=1}^N{\sum }_{j=1\wedge r_{ij}\in {\mathcal{T}}_i}^M\left|r_{ij}-{\widehat{r}}_{ij}\right|}{{\sum }_{i=1}^N\left|{\mathcal{T}}_i\right|}$$

(25)

$$\mathrm{RMSE}=\sqrt{\frac{{\sum }_{i=1}^N{\sum }_{j=1\wedge r_{ij}\in {\mathcal{T}}_i}^M{\left(r_{ij}-{\widehat{r}}_{ij}\right)}^2}{{\sum }_{i=1}^N\left|{\mathcal{T}}_i\right|}}.$$

(26)

Note that a low MAE or RMSE value indicates the superiority of a recommender system.

A 5-fold cross-validation is adopted for our experiments. In each experiment, the entries in a dataset are split randomly into five different subsets. Then, five runs are performed. Each time, four of the five subsets are used for training, and the remaining one is used for testing. Then, the results of the five runs are averaged. Note that in each of the following experiments, the predicted preference lists are derived from the training set and all MAE and RMSE are measured on the testing set. In addition, no overlapping exists between the training set and the testing set in any experiment.

In the following experiments, we work with three datasets, Amazon Digital Music, Amazon Video Game, and Amazon Apps for Android. They were collected by Julian McAuley from Amazon.com over a period of 18 years (2014−1996) and were described in [48,49]. Each piece of data contains the information as shown in Figure 2. Several fields of information were recorded.

However, we are interested in the fields of ’reviewerID’ (user ID), ’asin’ (item ID), ’reviewText’ (user text comments to the item), and ’overall’ (user’s rating to the item). Among them, ’asin’ and ’reviewText’ are used by Word2Vec to form item vectors, while ’reviewerID’ and ’overall’ are used in forming the user-item rating matrix. Each non-zero entry in the matrix is represented as a triple $\left(u_i, p_i, r_{ij}\right)$ where $r_{ij}\in \left\{1, 2, 3, 4, 5\right\}$. The Amazon Digital Music dataset contains 64,706 reviews, with 5541 users and 3568 items. The sparsity of this dataset is $1-\frac{64706}{5541\times 3568}=99.7\%$. The Amazon Video Game dataset contains 231,780 reviews, with 24,303 users and 10,672 items. The sparsity of this dataset is 99.9%. The original Amazon Apps for Android dataset contains 752,937 reviews, with 97,281 users and 13,209 items and a sparsity of 99.93%. To run other systems easily, we randomly take 385,482 reviews, with 35,001 users and a sparsity of 99.92%. The characteristics of these datasets are summarized in

Table 3. Characteristics of the datasets used for experiments.

	# Of Users	# Of Products	# Of Ratings	Sparsity
Amazon Digital Music	5541	3568	64,706	99.7%
Amazon Video Game	24,303	10,674	231,780	99.9%
Amazon Apps for Android	35,001	13,209	385,482	99.92%

. As can be seen, sparsity and scalability are very serious in all of these datasets.

We show the effectiveness, both regarding the accuracy and efficiency, of our approach, CFUCC, by comparing it with some other collaborative filtering methods, including SCC (Self-Constructing Clustering) [23], CFCB (Collaborative Filtering by Clustering Both users and items) [2], BiFu (Biclustering and Fusion) [26], and ICRRS (Iterative method for Calculating Robust Rating Scores) [35]. SCC applies clustering on products, but users are not clustered. BiFu applies K-means to cluster the users and products, and ICRRS uses a reduction technique that decouples the credibility assessment of the cast evaluations from the ranking itself. CFCB clusters users based on users’ ratings on products. For a fair comparison, we wrote programs for these methods. All the programs were written in Python 3.6, running on a computer with Intel(R) Core(TW) i7-4790K CPU, 4.00 GHz, 32GB of RAM, and 64 bits windows 10.

5.1. Experiment 1—Amazon Digital Music Dataset

We work with the Amazon Digital Music dataset in this experiment.

Table 4. Performance comparisons among different methods for Experiment 1.

	CFUCC	SCC	ICRRS	CFCB	BiFu
MAE	0.709	0.835	0.998	0.830	0.837
RMSE	0.996	1.168	1.419	1.235	1.202
Time(s)	51.9	945.3	358.5	373.7	660.2

shows comparisons on MAE, RMSE, and Time(s) among CFUCC, SCC, ICRRS, CFCB, and BiFu. In this table, the value obtained by the best method for each case is shown in boldface. For CFUCC, we use $\rho =0.7$ for item clustering, $\rho =0.6$ for user clustering, $v_0=0.5$, and $\theta =0.7$ for PCA. CFUCC clusters products into 35 groups and users into 32 groups, SCC clusters products into 204 groups, CFCB clusters products into 35 groups, and BIFU divides into 35 groups for items and users, respectively. As can be seen from Table 4, CFUCC is the best among the methods. CFUCC has the lowest value, 0.709, in MAE and the lowest value, 0.996, in RMSE, and runs most efficiently, 51.9 s in the CPU time.

5.2. Experiment 2—Amazon Video Game Dataset

We work with the Amazon Video Game dataset in this experiment.

Table 5. Performance comparisons among different methods for Experiment 2.

	CFUCC	SCC	ICRRS	CFCB	BiFu
MAE	0.791	0.957	0.954	1.757	1.789
RMSE	1.224	1.323	1.374	1.948	2.041
Time(s)	111.7	2495.5	4187.9	8348.9	13492.2

shows comparisons among different methods. CFUCC clusters products into 32 groups and users into 15 groups, SCC clusters products into 19 groups, CFCB clusters products into 35 groups, and BIFU divides into 35 and 20 groups for items and users, respectively. As can be seen from this table, CFUCC performs the best. CFUCC has the lowest value, 0.791, in MAE and the lowest value, 1.224, in RMSE, and runs most efficiently, 111.7 s in the CPU time.

5.3. Experiment 3—Amazon Apps for Android Dataset

We work with the reduced version of the Amazon Apps for Android dataset in this experiment.

Table 6. Performance comparisons among different methods for Experiment 3.

	CFUCC	SCC	ICRRS	CFCB	BiFu
MAE	1.024	1.141	1.169	1.218	1.126
RMSE	1.331	1.555	1.650	1.641	1.516
Time(s)	194.2	6154.9	7507.9	18826.3	24075.3

shows comparisons among different methods. CFUCC clusters products into 25 groups and users into 38 groups, SCC clusters products into 153 groups, CFCB clusters products into 35 groups, and BIFU divides into 25 and 35 groups for items and users, respectively. In this experiment, CFUCC performs the best in every case. CFUCC has the lowest value, 1.024, in MAE, the lowest value, 1.331, in RMSE, and it runs most efficiently, 194.2 s in the CPU time.

5.4. Experiment 4—Impact of Imputation

In this experiment, we show how imputation has an impact on the recommended results. Several strategies have been proposed to deal with missing values in the user-item rating matrix. Among them, four popular ones are:

• No imputation. If user $u_i$ has not provided a rating for product $p_j$, $r_{ij}=$0. That is, a missing value is treated as 0.
• Imputation by least. Each missing value is replaced with the least positive score. For the case of scores being 1–5, a missing value is replaced with 1.
• Imputation by mid. Each missing value is replaced with the middle of positive scores. For the case of scores being 1–5, a missing value is replaced with 3.
• Imputation by mean. Each missing value is replaced with the mean value of all the positive ratings in the given user-item rating matrix.

Table 7. Impact of imputation on performance for different methods.

		CFUCC	SCC	ICRRS	CFCB	BiFu
No imputation	MAE	0.996	1.168	1.419	1.235	1.202
	RMSE	0.709	0.835	0.998	0.830	0.837
Imputation by least	MAE	0.996	1.028	3.398	3.325	3.305
	RMSE	0.709	0.746	3.222	3.139	3.120
Imputation by mid	MAE	0.996	1.514	1.630	1.610	1.635
	RMSE	0.709	1.381	1.485	1.464	1.568
Imputation by mean	MAE	0.996	1.176	1.418	1.174	1.218
	RMSE	0.709	0.842	0.998	0.796	0.804

shows the performance comparison of these four strategies for the Amazon Digital Music dataset. As can be seen, CFUCC is hardly affected by imputation. The reason is that CFUCC uses user comments, instead of rating scores in the user-item rating matrix, to generate and cluster item vectors. Therefore, it is more resistant to the noise caused by imputation strategies. For the other methods, the recommended results depend on the rating scores in the matrix, and thus, they behave differently with different imputation strategies.

5.5. Experiment 5—Different Ways of Producing User Vectors

We compare three methods of producing user vectors in CFUCC. The three methods are:

• Method 1. This is the method CFUCC adopts, as described previously.
• Method 2. The user identity shown in the “reviewerID” field is inserted repetitively into the review text in the “reviewText” field, as the way we do for generating item vectors. By training a Word2Vec network, the user vectors are produced.
• Method 3. All the review texts of a user are collected in one document. Then, Doc2Vec [50] is applied to obtain a document vector for the document, and the obtained document vector is regarded as the user vector for this user.

Table 8. Performance comparisons among different methods of generating user vectors.

	Method 1	Method 2	Method 3
MAE	0.709	1.526	1.530
RMSE	0.996	1.723	1.742

shows the performance comparison of these methods for the Amazon Digital Music dataset.

As can be seen, Method 1, which we adopt in CFUCC, gets the best results. In general, a review given by a user provides comments on items instead of on users. Therefore, the user vectors obtained by Method 2 are less effective. In addition, the collected document for a user is usually too short to represent himself/herself in a distinctive way. Worst of all, a user may not have given any comments. Consequently, Method 3 performs less effectively.

5.6. Experiment 6—Impact of User Comments

We show the effectiveness of using user comments for clustering products and users in CFUCC.

• Method 1. This is the method that CFUCC adopts. That is, it applies Word2Vec on user comments to get item vectors from which user vectors are obtained, and then clusters products and users based on the item and user vectors.
• Method 2. User comments are not used. Products and users are clustered directly based on the rating scores provided in the given user-item rating matrix.

Table 9. Performance comparisons between using and without using user comments.

	MAE	RMSE	Time(s)
Method 1	0.709	0.996	51.9
Method 2	1.180	1.410	3248.0

shows the performance comparison of these methods for the Amazon Digital Music dataset. Note that both methods use identical values for the parameters involved in the recommendation process.

As can be seen, Method 1, which we adopt in CFUCC, performs better in terms of both accuracy and efficiency. Method 2 uses the user-item rating matrix for clustering. This causes the sparsity problem and makes the recommended results less accurate. Clearly, both the MAE and RMSE of Method 2 are worse than those of Method 1. Secondly, Method 2 clusters users directly. Since there are 3568 products in Amazon Digital Music dataset, each pattern is a 3568-dimensional vector to be considered in the clustering process. In Method 1, by PCA and Word2Vec, each pattern is only a vector of size less than 100. Therefore, users can be clustered faster by Method 1, and recommendation can be done more efficiently.

5.7. Experiment 7—Impact of Parameter Settings

The energy threshold $\theta$ determines the degree of reduction on the dimensionality of the vectors produced by PCA.

Table 10. Performance comparisons among different values of $\theta$.

	URdim	IRdim	MAE	RMSE
$\theta =0.6$	6	18	0.716	1.012
$\theta =0.7$	9	28	0.709	0.996
$\theta =0.8$	18	43	0.712	0.998
$\theta =0.9$	37	62	0.730	1.216

compares the performance of four different values of $\theta$ for the Amazon Digital Music dataset. The columns “URdim” and “IRdim” indicate the reduced dimensionality of user vectors and item vectors, respectively, after PCA. Note that the original vectors have 100 dimensions. When $\theta =0.7$, the reduced user vectors have nine dimensions, while the reduced item vectors have 28 dimensions. As expected, a larger $\theta$ results in a higher dimensionality of the reduced vectors. Note that CFUCC with $\theta =0.7$ performs the best. However, the performance is pretty stable with values near 0.7.

Next, we show the impact of different values of $\rho$ on the recommended results obtained by CFUCC. Note that a different $\rho$ value can lead to a different number of clusters produced. A higher $\rho$ will produce more clusters.

Table 11. Performance comparisons among different values of $\rho$.

$\mathit{\rho }=0.6\mathbf{For}\mathbf{Users}$			$\mathit{\rho }=0.7\mathbf{For}\mathbf{Items}$
$\rho$ For Items	MAE	RMSE	$\rho$ For Users	MAE	RMSE
$\rho =0.6$	0.723	0.997	$\rho =0.5$	0.710	0.997
$\rho =0.7$	0.709	0.996	$\rho =0.6$	0.709	0.996
$\rho =0.8$	0.712	1.000	$\rho =0.7$	0.713	0.999

compares the performance of different values of $\rho$ for the Amazon Digital Music dataset. In the left part of the table, the $\rho$ for clustering user vectors is kept at 0.6, while the $\rho$ value varies for clustering item vectors. In the right part of the table, the $\rho$ for the clustering item vectors is kept at 0.7, while the $\rho$ value varies for clustering user vectors. As can be seen, the value of $\rho$ does affect the performance of CFUCC, but not significantly.

6. Conclusions

We have presented an extension of [23] to address the inaccuracy and inefficiency caused by the data sparsity and scalability in collaborative filtering recommendation. Word2Vec is applied on user comments to assign an item vector to each product. Through the user-item rating matrix, the user vectors of all the users are also produced. Then, the products and users are clustered into item groups and user groups, respectively. Based on these item groups and user groups, recommendations to a user can be made. Experimental results have shown that both the accuracy and efficiency of recommendation are improved by the proposed approach.

Some research work will be investigated for the system in the future. Doc2Vec or other embedding techniques may be used for developing item vectors. Item descriptions, such as those available in the Amazon datasets, can be used for creating item or user vectors. We may use the reviews to learn word embeddings and take each item to be the aggregation of the embedded vectors of the words that are in the reviews. We have only adopted MAE and RMSE to evaluate the quality of the predictions. Other measures such as the precision, recall, and nDCG may be used to evaluate the quality of recommendations. Recently, neural collaborative filtering has been proposed for recommendation [51,52]. It will be interesting to investigate the effectiveness of incorporating it in our system.