2013 IEEE International Conference on Cloud Engineering
Distributed Collaborative Filtering on a Single Chip Cloud Computer Aalap Tripathy, Atish Patra, Suneil Mohan, Rabi Mahapatra Department of Computer Science & Engineering Texas A&M University College Station, TX, USA
[email protected],
[email protected],
[email protected],
[email protected]
A multitude of recommendation techniques involving content-based and collaborative filtering have been developed in literature and this remains an active area of work. All of these techniques are useful only with several thousand GB’s of training data and involve large-scale dataintensive computations to determine similarity between users and items, make predictions and recommendations. To be scalable or effective, they are today deployed in cloud infrastructures using distributed computing runtimes such as Apache Hadoop [4] and Mahout [5].
Abstract—Many-cores on chip have now become a reality. They necessitate the revisit of several layers of a cloud infrastructure. For this to happen, parallel programming runtimes need to be designed for many-cores on chip as the target architecture. In this paper, we show that MapReduce programming paradigm can be adapted to run on Intel’s experimental single chip cloud computer (SCC) with 48-cores on chip. We demonstrate this using a Collaborative Filtering (CF) recommender system as an application. CF is widely used in e-commerce deployments to predict user’s preference towards an unknown item from their past ratings. We address scalability with data partitioning, combining and sorting algorithms, maximize data locality to minimize communication cost within the SCC cores. We demonstrate ~2x speedup, ~94% lower power consumption for benchmark workloads as compared to a distributed cluster multi-processor nodes in use today. KeywordsRecommendation system; Collaborative Filtering; Many-core; Single Computer; Scalability; personalization
I.
Mapreduce; Chip Cloud
INTRODUCTION
The amount of digital information created, captured or replicated worldwide has been estimated to reach 3500 exabytes by 2020 [1]. This rate of information growth (~10x) makes information retrieval (search) difficult, resourceintensive and often inefficient. Consequently, it is now widely acknowledged that the web is leaving the era of “search” and entering one of “recommendations” [2]. It is no longer sufficient to provide semantically accurate query results; users expect to be provided a somewhat intelligent choice of items based on their previously expressed (explicit or implicit) preferences and those of “similar” users. This situation has led to the development of recommendation systems [3], which learn about a user’s preference and figure out the most relevant information for them and deliver them to devices on the cloud. Driven by sophisticated algorithms, recommenders help consumers by selecting products they will probably like and might buy based on their past browsing, searches, purchases, and preferences. Almost all online e-commerce platforms deploy them to boost sales, drive and retain traffic; recommenders are already a huge and growing business.
978-0-7695-4945-3/13 $26.00 © 2013 IEEE DOI 10.1109/IC2E.2013.42
Figure 1. Many-core processors as compute nodes in a cloud
These frameworks split the computation into small partitions (key-value pairs), which can then execute independently on multiple nodes in parallel. A programmer has only to specify the serial parts necessary in transforming one key-value pair to another. An underlying parallel runtime is responsible for ensuring parallelization, intermachine communication and failure-recovery. Chip manufacturers on the other hand have determined that it is only possible to scale out by adding more cores to a chip; rather than increase clock-speeds. New challenges arise when a compute node is a many-core system; in itself capable of running a distributed computing run-time for best performance. This requires a rethink of the platform layer runtime and the algorithm for data-intensive applications on the cloud (shown with red boxes in Fig. 1). In this paper, we 140
rating) - a single triple describes a single interaction of a user with unique id userID, on an item with id itemID in the form of a utility function rating. (2) The second stage involves calculation of similarity between all pairs of items (item-item [7]) or all pairs of users (user-user [8]). When calculating user-user similarity, (2a) we first find all the items that a pair of users has rated in common. Next a correlation metric is computed for this pair (2b). For example, if users “Tom” and “Jerry” have seen a common item (say the movie “Air Force One”) and have rated it equally – say (3,3); their distance is zero (they are very similar), whereas if (Tom, Jerry) have given it (5,0); their distance increases (they are dissimilar). On the other hand, if calculating item-item similarity, (2a’) we first find all the users who have rated a pair of items in common. (2b’) A similarity metric can then be computed for a pair of items (as earlier); such that if the common users for an item pair tend to agree with each other they are more similar. (3) Predictions are made per user based on the items already rated and the calculated similarity of those items to all other items in the dataset. (4) The top “k” predicted items are presented as recommendations. This workflow can be described mathematically as follows. Suppose there exist a set of m distinct users; U = {u1,u2, …, um} who have rated one or more of n distinct items; I= {i1,i2, …, in}. Each user u ∈ U provides a rating rui for a subset of
make the following contributions: (1) we design a multistage run-time based on MapReduce for a many-core system, (2) build an algorithmic framework to perform scalable neighborhood-based recommendation on this run-time. To the best of our knowledge, this is the first work on distributed collaborative filtering on a many-core system. This paper is organized as follows: we give a brief introduction into collaborative filtering and its computational model in Section II.A, we next discuss the architectural features of typical many-core systems with specific reference to Intel’s experimental single chip cloud computer (SCC), which is our target platform in Section II.B. In Section III, we describe the design of a run-time system for MapReduce on this platform and in Section IV we discuss the formulation of a multi-stage algorithm, which breaks down the collaborative filtering problem into discrete Mapreduce stages. In Section V, we present and discuss experiments using our algorithmic framework and run-time on synthetic and real-world datasets and compare our results with those from a contemporary cloud-based distributed system. In Section VI, we discuss related work in this area. We conclude in Section VII summarizing our work so far and identifying future areas of work in this direction. BACKGROUND
A. Collaborative Filtering in Recommendation Systems Recommendation systems (RS) [2, 3] today use one or more likely a hybrid of either (1) content based, (2) userlinkage based (collaborative), (3) knowledge based approaches to predict new items to users. Content & knowledge based systems operate on pre-created item and user profiles to make recommendations. On the other hand, collaborative filtering treats any two items as being related based on the fact that a large number of users who have seen, rated or expressed a high preference for one have also done the same for the other. Therefore, collaborative filtering (CF) can be defined as – “a method of making automatic predictions by (filtering) interests of a user based on information from other users”. Collaborative filtering [6] is domain-independent and can mine past user behavior (ratings, preferences, likes, votes etc.) to obtain new useritem associations. We focus on collaborative filtering in this paper as it is the most widely used approach in recommendation systems today.
Capture user preference
Calculate All-Pairs Similarity
Calculate Predictions for a user
items in I (Iu ⊆ I). These ratings can be represented as an item-user matrix R (nxm). Matrix R is sparse since most users will not have rated all items. A row vector from R (Ri) is sufficient to describe an item i’s interaction history (i.e. all user ratings made for it) whereas a column vector (Ru) describes a user u’s interaction history (i.e. all item ratings made by him). Users (u) v u
Items (i)
R 1 2 1 2
m
i j n Non-Rated
n
sji
i sji
j n
Item-User Matrix Rated
Items (i) j i
S 1 2 1 2 Items (i)
II.
Common Users rated items i & j
Similarity Matrix
Figure 3. Calculation of item-item all-pairs similarity
1) Calculation of Item-Item all pairs similarity (sij) Fig. 3 shows an item-user matrix Rnxm where T (
