{'fraction_non_alphanumeric': 0.03880385348916818, 'fraction_numerical': 0.010244999755489266, 'mean_word_length': 4.624948425250997, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Broad Recommender System: An Efficient Nonlinear Collaborative Filtering Approach

Recently, Deep Neural Networks (DNNs) have been widely introduced into Collaborative Filtering (CF) to produce more accurate recommendation results due to their capability of capturing the complex nonlinear relationships between items and users.However, the DNNs-based models usually suffer from high computational complexity, i.e., consuming very long training time and storing huge amount of trainable parameters. To address these problems, we propose a new broad recommender system called Broad Collaborative Filtering (BroadCF), which is an efficient nonlinear collaborative filtering approach. Instead of DNNs, Broad Learning System (BLS) is used as a mapping function to learn the complex nonlinear relationships between users and items, which can avoid the above issues while achieving very satisfactory recommendation performance. However, it is not feasible to directly feed the original rating data into BLS. To this end, we propose a user-item rating collaborative vector preprocessing procedure to generate low-dimensional user-item input data, which is able to harness quality judgments of the most similar users/items. Extensive experiments conducted on seven benchmark datasets have confirmed the effectiveness of the proposed BroadCF algorithm

The traditional collaborative filtering is user-oriented or item-oriented, which relies mainly on the ratings of similar users or items to predict unknown ratings. Among various collaborative filtering techniques, Matrix Factorization (MF) [19], [20], [21], [22] is the most popular approach, which This work was supported by NSFC (62106079 and 62276277), and Natural Science Foundation of Guangdong Province (2020A1515110337).
Ling operates by learning a latent space to represent users and items, and mapping users and items into a common space. In the common space, the recommender system predicts a personalized ranking of a set of items for each user based on the similarity between users and items. However, in practical applications, scoring data is prone to long-tail distribution [23], which can lead to the sparsity problem in the MF methods. To overcome the sparsity problem, several methods have been developed [24], e.g., adding social relations to MF or using invisible feedback [25].
Deep Neural Networks (DNNs) have been developed rapidly in the past few years, which have been widely explored and shown satisfactory results in various fields such as computer vision and natural language processing. DNNs have also been introduced into the field of recommender systems [26], [27], [28], [29], [30], [31]. In the traditional matrix decomposition, the relationships between users and items are usually assumed to be linear, which is however not true in real-world applications. To better learn complex nonlinear relationships between users and items, Xue et al. propose a Deep Matrix Factorization (DMF) [27] that uses a dualpath neural network instead of the linear embedding operation used in the conventional matrix decomposition. DNNs are able to approximate any function, so they are well suitable for learning complex matching functions. For example, He et al. propose NeuMF under the Neural Collaborative Filtering (NCF) framework [28], which takes the connection of user embedding and item embedding as input and uses the Multi-Layer Perceptron (MLP) model for prediction. Deng et al. propose DeepCF [32] which is a unified deep collaborative filtering framework integrating representation learning and matching function learning. However, the DNNs-based models requires a large number of iterative training processes that consume time and computational resources, and therefore cannot be applied to large-scale data and are very time consuming. As shown in our experiments, due to the out-of-memory error, most DNNs-based models fail to generate results when dealing with an Amazon dataset containing 429622 users, 23966 items, and 583933 ratings on a server with an Intel Core i9-10900 CPU, GeForce RTX 3090, and 256GB of RAM. And even for the relatively small datasets that can generate results, most DNNs-based models are time-consuming. In [30], a BP Neural Network with Attention Mechanism (BPAM) has been proposed to mitigate this problem by combining the attention mechanism with the BP network. However, the gradient-based optimization still consumes long time.
To address the above problems, this paper proposes a novel arXiv:2204.11602v3 [cs.IR] 20 Sep 2022 broad recommender system, called Broad Collaborative Filtering (BroadCF), which is an efficient nonlinear collaborative filtering approach. Different from the existing DNNs-based methods that feed the user-item rating data into DNNs, the proposed BroadCF method feeds the user-item rating data into Broad Learning System (BLS) [33]. As shown in the literature [33], [34], BLS is also able to approximate any function, and its general approximation capability has been theoretically analyzed at the beginning of its design and proved by rigorous theoretical proof. In particular, BLS can map the original data points to a discriminative feature space by using random hidden layer weights according to any continuous probability distribution [33], [34]. This random mechanism provides a fast training process for BLS. That is, only the weights from the hidden layer to the output layer need to be trained by a pseudo-inverse algorithm. Therefore, BroadCF does not need to consume so much training time compared with the DNNs-based models, and is more suitable for larger datasets due to the small number of stored parameters.
However, it is not a trivial task to feed the user-item rating data into BLS. The DNNs-based methods take the original user/item rating vectors (or their direct concatenation) as input, which is suitable because the DNNs-based methods learn the latent factor vectors by stacking several hidden layers, the dimensions of which usually decrease monotonously from the input layer to the output layer. Different from the DNNsbased methods, BLS needs to broaden the original input data into the mapped features and enhanced features with severalorder magnitude larger dimensions. Therefore, it is not feasible to take the original user/item rating vectors (or their direct concatenation) as input for BLS. Inspired by the previous work [30], this paper proposes a user-item rating collaborative vector preprocessing to generate low-dimensional user-item input data, which is able to harness quality judgments of the most similar users/items.
The main contributions of this work are concluded as follows.
• A new broad recommender system called BroadCF is proposed to overcome the problems of long training time and huge storage requirements in the DNNs-based recommendation models. • A new data preprocessing procedure is designed to convert the original rating data into the form of (Rating collaborative vector, Rating one-hot vector) as input and output of BroadCF. • Extensive experiments are conducted on seven real datasets to demonstrate the effectiveness of the model. The results show that BroadCF significantly outperforms other state-of-the-art algorithms and significantly reduces training time consumption and storage costs.
The rest of this paper is organized as follows. In Section II, we will review the related work. In Section III, we will introduce the problem definition and preliminaries. In Section IV, we will detail the proposed BroadCF method. In Section V, we will report the experimental results with convincing analysis. We will conclude the paper in Section VI.

II. RELATED WORK A. Shallow Learning based Collaborative Filtering Methods
Collaborative filtering is one of the most widely adopted recommendation algorithms [35]. Early collaborative filtering in its original form is user-oriented or item-oriented [35], which relies primarily on the ratings of similar users/items to predict unknown ratings. Many efforts have been made in developing variants of CF from different perspectives [36], [3], [37], [38], [39], [40]. In [37], Bell and Koren propose to learn the interpolation weights from rating data as a global solution, which leads to an optimization problem of CF and improves the rating prediction performance. In [25], Koren propose to extend the SVD-based latent factor model to the SVD++ model by adding a second set of item factors to model the item-item similarity. Another early attempt is [38], in which the temporal information is considered for improving the accuracy. Instead of relying on the co-rated items, Patra et al. propose to utilize all rating information for searching useful neighbors of the target user from the rating matrix [39]. In order to recommend new items and niche items to users, based on the observation of the Rogers' innovation adoption curve [41], Wang et al. propose an innovator-based collaborative filtering algorithm by designing a new concept called innovators [36], which is able to balance serendipity and accuracy. For more literature reviews of the shallow learning based collaborative filtering methods, please refer to the survey papers [24], [42]. Despite the wide applications, the conventional shallow learning based CF methods assume the linear relationship between users and items, which is however not true in the real-world applications.

B. Deep Learning based Collaborative Filtering Methods
Recently, DNNs have been widely used in collaborative filtering to learn the complex mapping relationships between users and items due to their ability to approximate any continuous function. For example, in [27], Xue et al. propose a new matrix decomposition model based on a neural network structure. It maps users and items into a common lowdimensional space via a nonlinear projection. He et al. propose a neural network structure to model the latent features of users and items, and design a general framework for collaborative filtering based on neural networks, called Neural Collaborative Filtering (NCF) [28]. Three examples are developed, namely Generalized Matrix Decomposition (GMF), Multi-Layer Perceptron (MLP), and Neural Matrix Factorization (NeuMF). In [32], Deng et al. propose a unified deep collaborative filtering framework integrating representation learning and matching function learning. In [43], Xue et al. propose a deep item-based collaborative filtering method, which takes into account of the higher-order relationship among items. In [44], Fu et al. propose a multi-view feed-forward neural network which considers the information of both user and item with the corresponding historical information. In [45], Han et al. develop a DNNs-based recommender framework with an attention factor, which is able to learn the adaptive representations of users. In [46], Liu et al. propose a dual-message propagation mechanism for graph collaborative filtering, which is able Rating of user u to item î r u,i Predicted rating of user u to item i k Pre-specified number of the nearest users of each user u n u ∈ R 1×k KNU index vector of user u, i.e. the index vector storing the indexes of k nearest users (KNU) of user u n u j Index of the j-th nearest user of user u KNU rating vector of user u on item i, i.e. the ratings of the k nearest users of user u on item ī p u i ∈ R 1×k Post-processed KNU rating vector of user u on item i l Pre-specified number of the nearest items of each item i n i ∈ R 1×l LNI index vector of item i, i.e. the index vector storing the indexes of l nearest items (LNI) of item i n i j Index of the j-th nearest item of item i LNI rating vector of item i from user u, i.e. the ratings of user u to the l nearest items of item ī q u i ∈ R 1×l Post-processed LNI rating vector of item i from user u User-item rating collaborative vector for the given user-item pair composed of user u and item i dy Maximum rating, i.e. dimension of user-item rating one-hot vector User-item rating one-hot vector for the given user-item pair composed of user u and item i D Training set of the proposed BroadCF algorithm The j-th mapped feature matrix n Number of the mapped feature groups φ j The j-th nonlinear feature mapping function d h Dimension of each enhanced feature group The j-th enhanced feature matrix m Number of the enhanced feature groups ξ j The j-th nonlinear feature enhancement function W ∈ R (ndz +md h )×dy Learnable weight matrix of BLS to model preferences and similarities for recommendations. In [47], Zhong et al. propose an autoencoder framework with attention mechanism for cross-domain recommendation, which utilizes autoencoder, MLP, and self-attention to learn and fuse latent factors from different domains. For more literature reviews of the deep learning based collaborative filtering methods, please refer to the survey paper [48]. However, due to the large number of trainable parameters and complex structures involved, the DNNs-based models usually suffer from high computational complexity, i.e., consuming very long training time and storing huge amount of trainable parameters.
In this paper, to address the above problems, we propose a new neural network based recommender system called Broad Collaborative Filtering (BroadCF). Instead of DNNs, Broad Learning System (BLS) is used as a mapping function to learn the complex nonlinear relationships between users and items, which can avoid the above issues while achieving very satisfactory recommendation performance.

III. PROBLEM DEFINITION AND PRELIMINARIES
In this section, we will present the problem definition and preliminaries. For clarity, Table I summarizes the major notations used throughout this paper.

A. Problem Definition
Suppose that in the recommender system we are given a user set U and an item set V. Following [32], a user-item rating matrix R ∈ R |U |×|V| is obtained from the users' ratings on items as follows, where r u,i represents the rating of user u on item i. The goal of recommendation algorithms is to estimate the missing ratings in the rating matrix R. The model-based methods generate the predicted ratingr u,i of user u to item i as follows,r where f denotes the mapping function that maps the model input, e.g. the ratings of neighbor users or items, to the predicted rating of the corresponding user-item pair composed of user u and item i by utilizing the model parameters Θ [32].
The mapping function of DNNs-based CF inherits the nonlinear representation learning capability of DNNs, and thus it is able to learn the complex nonlinear relationships between users and items. However, due to the large number of trainable parameters involved, the complex structure and the continuous iterative training process, the DNNs-based models often suffer from high computational complexity, i.e., consuming very long training time and storing huge amount of trainable parameters. A recent work called BPAM [30] has shed light on mitigating the problem of training time consumption by combining attention mechanisms with the BP networks. However, the gradient-based optimization still takes some time. In this paper, instead of DNNs, a lightweight neural network called Broad Learning System (BLS) [33] is used as a mapping function to learn the complex nonlinear relationships between users and items, which can avoid the above issues while achieving very satisfactory recommendation performance.

B. Preliminaries
BLS is a lightweight neural network that can approximate any function [33], which has been widely used in many different applications [49], [50], [51], [52]. It is based on a Random Vector Functional Linked Neural Network (RVFLNN) [53]. In BLS, the original data are firstly mapped into the mapped features by random weights, which are stored in mapped feature nodes. Next, the mapped features are further mapped by random weights to obtain enhanced features, which are used for extensive scaling. Finally, the parameter normalization optimization problem is solved using the ridge regression approximation to obtain the final network weights.
The advantage of BLS is that it can use random hidden layer weights to map the original data points to a discriminative feature space tensed by these vectors. The parameters of the hidden layer nodes can be randomly generated according to any continuous probability distribution, the rationale of which has been theoretically proven. This random mechanism can quickly provide a fast training process for BLS. It solves the serious training time consuming problem suffered by the DNNs-based models. More importantly, BLS retains the powerful mechanism of randomly generating the weights of hidden layer nodes based on any continuous probability The LNI rating vector for item i X: distribution. Specifically, BLS can be updated incrementally when adding newly samples and hidden nodes, without the need of rebuilding the entire network from scratch. As a result, BLS requires a small number of parameters to be stored, which can solve the problem of huge storage requirements arising from the DNNs-based models. Most importantly, the feature layer to the output layer in BLS is directly connected, and the structure is very simple. Therefore, even without a large number of samples in the recommender system, the prediction performance can be ensured.

IV. BROAD COLLABORATIVE FILTERING
In this section, we will describe in detail the proposed Broad Collaborative Filtering (BroadCF) method. First of all, we will describe how to transform the original user-item rating data into the form of (Rating collaborative vector, Rating onehot vector) for each user-item pair, which will be taken as input and output to BLS. Then, we will describe the broad learning part. Finally, we will describe the rating prediction procedure and summarize the propose BroadCF method. For clarity, Figure 1 illustrates the main idea of the proposed BroadCF method.
A. Data Preprocessing 1) User-Item Rating Collaborative Vector: As shown in Eq.
(2), for a user-item pair (u, i), the model-based recommendation methods aim to establish a mapping function from the user-item input data to the user-item rating. A simple type of user-item input data is the direct concatenation of the user rating vector R u,: and the item rating vector R :,i . It has been widely adopted in the DNNs-based methods, i.e., the DNNsbased methods learn the latent factor vectors from the original user/item rating vectors. However, it does not work well in the case of BLS. This is because, different from the DNNs-based methods, which stack several hidden layers with decreasing layer sizes, BLS requires broadening the original input features into the mapped features and enhanced features, resulting in several-order magnitude larger dimension. In addition, directly utilizing extremely sparse user rating vector and item rating vector may cause the overfitting issue. Inspired by the previous work [30], [54], a user-item rating collaborative vector preprocessing is proposed to generate the low-dimensional user-item input data, which is able to harness quality judgments of the most similar users/items.
First of all, for each user u, a set of k nearest users (KNU) is obtained by calculating the cosine similarity between the rating vectors of user u and other users. Let n u = [n u 1 , n u 2 , · · · , n u k ] denote the KNU index vector of user u, i.e., the j-th nearest user of user u can be expressed as n u j , ∀j = 1, · · · , k. Then for each user-item pair composed of user u and item i, a KNU rating vector p u i ∈ R 1×k of user u on item i is obtained from the rating matrix R, where each entry p u i [j] is defined as follows, That is, p u i [j] is the rating value of user n u j to item i. In the above procedure, it is possible that some entries p u i [j] are zeros, i.e., user n u j has not yet rated item i. In [30], the mean value of the ratings of user n u j is used to fill the missing rating, which however, treats all the items equally while failing to utilize the rating of other similar users. To this end, we propose a new strategy that fills the missing rating with the rating of the nearest user of n u j to item i, i.e., where u * indicates the nearest user of user n u j who has rated item i.
Similarly, for each item i, a set of l nearest items (LNI) can be obtained by calculating the cosine similarity between the rating vectors of item i and other items. Let n i = [n i 1 , n i 2 , · · · , n i l ] denote the LNI index vector of item i, i.e., the j-th nearest item of item i can be expressed as n i j , ∀j = 1, · · · , l. Then for each user-item pair composed of user u and item i, a LNI rating vector q u i ∈ R 1×l of user u on item i is obtained from the rating matrix R, where each entry q u i [j] is defined as follows, That is, q u i [j] is the rating value of user u to item n i j . Like before, the following strategy is used to fill the missing entriesq where i * indicates the nearest item of item n i j rated by user u.
After obtainingp u i andq u i , they are concatenated to form the user-item rating collaborative vector, i.e., Notice that the dimension of the input data x u i , i.e. k + l, is relatively small compared with that of the direct concatenation of the user rating vector R u,: and the item rating vector R :,i , i.e. |U| + |V|.
2) User-Item Rating One-Hot Vector: In addition, for each user-item pair (u, i) with known rating in the training rating matrix, i.e. R u,i = 0, the user-item rating r u,i is transformed into a user-item rating one-hot vector y u i ∈ R 1×dy with where d y is the maximum rating, e.g., 5.
Finally, for each user-item pair (u, i) with known rating in the training rating matrix, the user-item rating collaborative vector x u i and the user-item rating one-hot vector y u i are taken as the input and output of a training sample (x u i , y u i ). That is, the training set of the proposed BroadCF method is

B. Broad Learning
In this subsection, we will describe the mapping function f that maps the rating collaborative vector x u i into the predicted rating one-hot vector y u i , which will be achieved by BLS. According to [33], BLS consists of three modules, namely mapped feature layer, enhanced feature layer, and output layer.
1) Mapped Feature Layer: Given the training set D = {(x u i , y u i )|R u,i = 0}, the input matrix of BLS is formed as where |D| is the number of training samples, i.e., there are |D| user-item pairs (u 1 , i 1 ), (u 2 , i 2 ), ..., (u |D| , i |D| ). The output matrix of BLS is formed as In the mapped feature layer, the input matrix X is transformed into the mapped feature matrix Z j ∈ R |D|×dz as follows where d z denotes the dimension of each mapped feature group, n denotes the number of the mapped feature groups, and φ j is the j-th nonlinear feature mapping function. In our experiments, ReLu is used as the nonlinear feature mapping function. In the above procedure, W zj ∈ R (k+l)×dz and β zj ∈ R |D|×dz are randomly generated matrices. In this way, the mapped feature matrices can be obtained, i.e., 2) Enhanced Feature Layer: After obtaining Z n , the enhanced feature matrix H j ∈ R |D|×d h can be calculated as follows, where d h denotes the dimension of each enhanced feature group, m denotes the number of the enhanced feature groups, and ξ j is the j-th nonlinear feature enhancement function. In our experiments, ReLu is used as the nonlinear feature enhancement function. In the above procedure, W hj ∈ R ndz×d h and β hj ∈ R |D|×d h are randomly generated matrices. In this way, the enhanced feature matrices can be obtained, i.e., 3) Output Layer: After obtaining the mapped feature matrices Z n and the enhanced feature matrices H m , the output matrix Y ∈ R |D|×dy can be predicted as where W ∈ R (ndz+md h )×dy is the trainable weight matrix that maps the concatenated mapped and enhanced features into the output Y.
In the training procedure, the only trainable weight matrix W can be easily solved by using the ridge regression approximation of pseudoinverse [Z n |H m ] + , i.e.,

C. Rating Prediction and Algorithm Summary
In the testing procedure, for each user-item pair (u, i) with unknown rating, the rating can be predicted by feeding the user-item rating collaborative vector x u i ∈ R 1×(k+l) into the broad learning procedure, which outputs the predicted useritem rating strength vectorŷ u i ∈ R 1×dy . Specifically,ŷ u i is a vector of length d y with each entryŷ u i [j] representing the strength of the corresponding rating j. In order to transform the predicted user-item rating strength vector into the predicted ratingr u,i of user u to item i, the following equation is adopted,r whereŷ u i [j] denotes the j-th entry of vectorŷ u i , and min(ŷ u i ) and max(ŷ u i ) denote the minimum and maximum values of vectorŷ u i . For clarity, the main procedure of BroadCF is summarized in Algorithm 1.

V. EXPERIMENTS
A. Experimental Settings 1) Datasets: The experiments are conducted on seven realworld publicly available datasets obtained from the following two main sources.
1) MovieLens 1 : The MovieLens dataset contains rating data of movies by users. In our experiment, the ml-latest dataset (abbr. ml-la) is adopted. 2) Amazon 2 : This dataset is an updated version of the 1 https://grouplens.org/datasets/movielens/ 2 http://jmcauley.ucsd.edu/data/amazon/ Amazon review dataset for 2018 [55], which contains reviews (ratings, text, helpful polls), product metadata (descriptions, category information, price, brand and image features) and links (also view/also buy charts). In particular, six datasets, namely A-Digital-Music, A-Grocery-and-Gourmet-Food, A-Patio-Lawnand-Garden, A-Automotive, A-Baby, and A-Instant-Video, are adopted. The statistics of the above seven datasets are summarized in Table II. From the table, it can be seen that one dataset (i.e. A-Instant-Video) is relatively very large. Each dataset is randomly split into the training set and the testing set with ratio 3:1 for each user. A quarter of the samples in the training set are randomly selected as the validation set to tune the appropriate hyper-parameters for all the methods.
2) Evaluation Measures: Two evaluation measures, i.e. Root Mean Square Error (RMSE) and Mean Absolute Error (MAE), are adopted to evaluate the performance of the prediction results. They are calculated as follows, wherer u,i denotes the predicted rating value, r u,i is the ground-truth rating, and T denotes the set of the tested ratings. Smaller values of RMSE and MAE indicate the better performance. When comparing the prediction performance of BroadCF with that of baselines, the improvement percent is calculated as That is, the error reduction percentage compared with the baselines. In addition, the running cost, including training time, testing time, and trainable parameter storage cost is also used as evaluation criteria.

1) Baselines:
We compare the proposed BroadCF approach with the following five state-of-the-art approaches.
• PMF 3 [40] is a classical CF approach that considers only latent factors and uses matrix decomposition to capture the linear relationship between users and items. • DMF 4 [27] uses a dual-path neural network instead of the linear embedding operation used in the conventional matrix decomposition. • NeuMF 5 [28] takes the connection of user embedding and item embedding as the input and uses the Multi-Layer Perceptron (MLP) model for prediction.    [30] is a neighborhood-based CF recommendation framework that captures the global influence of a target user's nearest users on their nearest target set of users by introducing a global attention matrix. The five state-of-the-art methods are tuned using the parameters suggested by the authors. For the PMF model, the number of factors for both users and items is set to 30. The regularization parameters for users and items are set to 0.001 and 0.0001, respectively. For the NeuMF model, the number of predictors for the generalized matrix decomposition part and the embedding sizes for users and items are set to 8 and 16, respectively. For the DMF model, the number of predictors for both users and items is set to 64. For the DeepCF model, the size of the MLP layer representing the learning part is set to [512,256,128,64], and the same settings as DMF are used in the matching function learning part. For these deep models, i.e., DMF, NeuMF, and DeepCF, the batch size is set to 256. For the BPAM model, we adjust the number of the nearest users and items in [3,5,7,9]. For the BroadCF algorithm, we set the number of both nearest users and nearest items as 5, i.e., k = l = 5, the number of both mapped feature groups and enhanced feature groups as 25, i.e., n = m = 25, and the mapped feature dimension and the enhanced feature dimension as 10 and 15 respectively, i.e. d z = 10, d h = 15. All experiments are implemented in Python and run on a server with an Intel Core i9-10900 CPU, GeForce RTX 3090, and 256GB of RAM. For the DNNs-based methods, including DMF, NeuMF and DeepCF, GPUs are used, while for the other methods, including PMF, BPAM and BroadCF, no GPU is used. The code of BroadCF is publicly available at https://github.com/BroadRS/BroadCF.

Methods ml-la A-Digital-Music A-Grocery-and-Gourmet-Food A-Patio-Lawn-and-Garden A-Automotive A-Baby
2) Comparison on Prediction Performance: The comparison results on the prediction performance measured by RMSE and MAE are shown in Table III and Table IV respectively. In this experiment, we run each algorithm 5 times on each dataset and report the mean and standard deviation (std. dev.) over the 5 runs. Out-of-memory errors occur when training the PMF, DMF and DeepCF models on the largest dataset, i.e. A-Instant-Video. This is because the three models require the user-item rating matrix as input data for the models, but for the A-Instant-Video dataset, the entire rating matrix takes up to |U| · |V| · 32 bits of memory, which is approximately equal to 308.64 GB, exceeding the 256 GB memory of the experimental machine. As a result, no result is reported in the corresponding entries of the comparison result tables (i.e. NA). According to the two tables, we have the following key observations.
Overall, the RMSE and MAE values obtained by the proposed BroadCF algorithm are much smaller than those by the other algorithms, including the classical CF method (PMF), three DNNs-based algorithms (DMF, NeuMF and DeepCF), and one BP neural network-based method (BPAM). In particular, compared with PMF, the proposed BroadCF algorithm achieves at least 20.31% and 35.92% improvements of RMSE and MAE, which is a relatively significant performance improvement. The main reason is that PMF only captures the linear latent factors, i.e. the linear relationship between users and items, while BroadCF is able to capture the nonlinear relationship between users and items. Compared with the three DNNs-based algorithms, BroadCF obtains at least 50.08% and 60.79% improvements of RMSE and MAE, which is a more significant performance improvement. The main reason may be that, although both the DNNs-based algorithms and BroadCF are able to capture the nonlinear relationship between users and items, the DNNs-based algorithms easily suffer from the overfitting issue, i.e., given the very large number of trainable parameters, the testing performance cannot be improved compared with the training performance. As a contrast, compared with BPAM, which is a lightweight neural network based method, the performance of BroadCF is still better than that of BPAM, although the   performance improvement is not such significant. As will be shown in the comparison on running cost, the number of trainable parameters in BPAM is relatively small compared with those of the DNNs-based algorithms, although still larger than that of BroadCF. Overall, the comparison results on the prediction performance have confirmed the effectiveness of the proposed BroadCF algorithm.

ml-la A-Digital-Music A-Grocery-and-Gourmet-Food A-Patio-Lawn-and-Garden A-Automotive
3) Comparison on Running Cost: Apart from the prediction performance, the proposed BroadCF algorithm has superiority on running cost. To this end, this subsection compares the running cost of BroadCF with the baselines, including the training time, testing time, and trainable parameter storage cost. Table V and Table VI report the training time and the testing time (in seconds) consumed by each algorithm on each dataset. Specifically, the training time and the testing time account for the time from feeding the preprocessed data into the model to outputting the results. According to the two tables, we can see that the proposed BroadCF algorithm is very efficient on running time. In particular, from Table V, BroadCF consumes several-magnitude shorter running time compared with the baselines. On the ml-la dataset, BroadCF is twice faster than the fastest baseline namely PMF, and it consumes about 23% running time by BPAM. Most importantly, compared with the three DNNs-based models, BroadCF consumes less than 2% running time on the ml-la dataset. On the six Amazon datasets, the four neural network based baselines namely NeuMF, DMF, DeepCF and BPAM, are faster than PMF. This is mainly due to that the neural network models take the rating vectors, which is relatively efficient in the case of relatively sparse dataset with small number of ratings. However, BroadCF is still much faster than the four neural network based baselines. This is mainly due to that the optimization problem of BroadCF is solved by using the ridge regression approximation of pseudoinverse without need of iterative training process. From Table VI, we can see that although BroadCF is not the fastest algorithm on testing time, it is very close to the fastest baseline namely PMF. This is mainly due to that, BroadCF requires calculating the mapped features and enhanced features, in addition to the multiplication by the trainable weight matrix, while PMF only needs to calculate the matching score of the user/item latent factors. Nevertheless, BroadCF is still much faster than the four neural network based baselines namely NeuMF, DMF, DeepCF and BPAM. The above comparison results on training time and testing time have confirmed the efficiency of the proposed BroadCF algorithm from the perspective of running time.
We also demonstrate the efficiency of the proposed BroadCF algorithm from the perspective of storage requirements. Following [54], Table VII reports the number of trainable parameters to be stored during the training procedure of each algorithm on each dataset. From the table, we can see that, the proposed BroadCF algorithm is several-magnitude more efficient than all the baselines. This is mainly due to that the only trainable parameters to be stored in BroadCF are the weight matrix W ∈ R (ndz+md h )×dy , which is independent of the input data size and dimension. On the contrary, all the baselines need to store much more trainable parameters, especially for the DNNs-based models. This result also confirms the fact that BroadCF requires several-magnitude less training parame-    ters, even less than the linear model namely PMF. Despite the relatively small number of trainable parameters, BroadCF can still well capture the nonlinear relationship between users and items and therefore generates much better results as shown in the prediction performance comparison. This is mainly due to the advantage achieved by mapping the original features into the mapped features and then into the enhanced features via random matrices plus nonlinear activation functions, which can be regarded as learning nonlinear representations from different views. Overall, the above comparison results on running cost have confirmed the efficiency of the proposed BroadCF algorithm from the perspective of trainable parameter storage requirement.

C. Hyper-Parameter Analysis
In this section, we will analyze the impact of six hyperparameters on the performance of the proposed BroadCF method, i.e., number of the nearest users k, number of the nearest items l, number of mapped feature groups n, mapped feature dimension d z , number of enhanced feature groups m, and enhanced feature dimension d h . When analyzing one parameter, the other parameters are fixed.
1) Number of the Nearest Users/Items: First of all, we will analyze the impact of the number of the nearest users/items, namely k and l, on the performance of the proposed BroadCF method. To this end, we run BroadCF by setting k and l in the range of [3,5,7,9,11], and report the prediction performance measured by RMSE and MAE in Fig. 2 and Fig. 3 respectively. From the figure, we can observe that a relatively stable performance is achieved when using different k and l on most datasets. That is, the variances of the RMSE and MAE values in the two figures are relatively small as shown in the heatmaps. However, a general trend is that when increasing k and l, the performance would slightly degenerate expect on the ml-la dataset. This is mainly due to the long-tail distribution, i.e., most of users/items have very few ratings. Setting a relatively large number of the nearest users/items would mistakenly introduce more noises, i.e., filling the missing entries by means of the nearest rating via Eq. (4) and Eq. (6). And the exception on the ml-la dataset has confirmed this analysis. That is, ml-la is a relatively dense dataset, in which the users/items contain more ratings. Considering the trade-off between the running efficiency and the accuracy, we set k and l to 5 in the experiments.
2) Hyper-Parameters in Feature Mapping: Secondly, we will analyze the impact of the hyper-parameters in feature mapping module, including the number of mapped feature groups n and the mapped feature dimension d z . In the proposed BroadCF algorithm, the feature mapping module plays the role of mapping the original input matrix composed of user-item collaborative vectors into the mapped feature matrix, which is the first step of capturing the nonlinear relationship between users and items. The two hyper-parameters would affect the performance of this mapping capability. To this end, we run BroadCF by setting n and d z in the ranges of [15,20,25,30,35] and [5,10,15,20,25] respectively, and report the RMSE and MAE values as a function of n and d z in Fig. 4 and Fig. 5 respectively. From the two figures, although the best values of n and d z vary from one dataset to another, the performance variation is relatively small, i.e. smaller than 0.01. This confirms the relatively insensitivity of the proposed BroadCF algorithm to the hyper-parameters in feature mapping. And in our experiments, we set n and d z to 25 and 10 respectively.
3) Hyper-Parameters in Feature Enhancement: Similar to the previous subsection, we will also analyze the impact of the hyper-parameters in feature enhancement module, including the number of enhanced feature groups m and the enhanced feature dimension d h . In the proposed BroadCF algorithm, the feature enhancement module plays the role of mapping the mapped feature matrices into the enhanced feature matrix, which is the second step of capturing the nonlinear relationship between users and items. The two hyper-parameters would affect the performance of this enhancement capability. Similarly, we run BroadCF by setting m and d h in the ranges of [15,20,25,30,35] and [5,10,15,20,25] respectively, and report the RMSE and MAE values as a function of m and d h in Fig. 6 and Fig. 7 respectively. From the two figures, although the best values of m and d h vary from one dataset to another, the performance variation is relatively small, i.e. smaller than 0.01. This confirms the relatively insensitivity of the proposed BroadCF algorithm to the hyper-parameters in  VI. CONCLUSIONS In this paper, we have proposed a new neural network based recommender system called Broad Collaborative Filtering (BroadCF). Compared with the existing DNNs-based recommendation algorithms, the proposed BroadCF algorithm is also able to capture the nonlinear relationship between users and items, and hence generate very satisfactory recommendation performance. However, the superiority of BroadCF is that it is very efficient compared with the DNNs-based methods, i.e., it consumes relatively very short training time and only requires relatively small amount of data storage, in particular trainable parameter storage. The main advantage lies in designing a data preprocessing procedure to convert the original rating data into the form of (Rating collaborative vector, Rating one-hot vector), which is then feed into the very efficient BLS for rating prediction. Extensive experiments conducted on seven benchmark datasets have confirmed the superiority of the proposed model, including both prediction performance and running cost.