Collaborate with strangers to find own preferences.
ABSTRACT Abstract We consider a model with n players and m objects. Each player has an unknown,grade for each object, modeled by a “preference vector” of length m. A player can learn his grade for an object by probing that object, but performing a probe incurs cost. The goal of the players is to learn their own evaluations of objects with minimal cost, by adopting the results of probes performed by other players. To facilitate communication, we assume that players collaborate by posting their grades for objects on a shared billboard: reading from the billboard is free. We consider players whose preference vectors are popular, i.e., players whose preferences are common to many other players. We present distributed and sequential algorithms to solve the problem with logarithmic cost overhead. Submitted as a regular presentation. Please consider as a brief announcement as well.

Conference Paper: Improved Collaborative Filtering.
Algorithms and Computation  22nd International Symposium, ISAAC 2011, Yokohama, Japan, December 58, 2011. Proceedings; 01/2011  SourceAvailable from: mit.edu
Conference Paper: Recommender systems with nonbinary grades.
[Show abstract] [Hide abstract]
ABSTRACT: We consider the interactive model of recommender systems, in which users are asked about just a few of their preferences, and in return the system outputs an approximation of all their preferences. The measure of performance is the probe complexity of the algorithm, defined to be the maximal number of answers any user should provide (probe complexity typically depends inversely on the number of users with similar preferences and on the quality of the desired approximation). Previous interactive recommendation algorithms assume that user preferences are binary, meaning that each object is either "liked" or "disliked" by each user. In this paper we consider the general case in which users may have a more refined scale of preference, namely more than two possible grades. We show how to reduce the nonbinary case to the binary one, proving the following results. For discrete grades with s possible values, we give a simple deterministic reduction that preserves the approximation properties of the binary algorithm at the cost of increasing probe complexity by factor s. Our main result is for the general case, where we assume that user grades are arbitrary real numbers. For this case we present an algorithm that preserves the approximation properties of the binary algorithm while incurring only polylogarithmic overhead.SPAA 2011: Proceedings of the 23rd Annual ACM Symposium on Parallelism in Algorithms and Architectures, San Jose, CA, USA, June 46, 2011 (Colocated with FCRC 2011); 01/2011  SourceAvailable from: Ran Giladi
Conference Paper: Distributed Weighted Stable Marriage Problem.
[Show abstract] [Hide abstract]
ABSTRACT: The Stable Matching problem was introduced by Gale and Shapley in 1962. The input for the stable matching problem is a complete bipartite K n,n graph together with a ranking for each node. Its output is a matching that does not contain a blocking pair, where a blocking pair is a pair of elements that are not matched together but rank each other higher than they rank their current mates. In this work we study the Distributed Weighted Stable Matching problem. The input to the Weighted Stable Matching problem is a complete bipartite K n,n graph and a weight function W. The ranking of each node is determined by W, i.e. node v prefers node u 1 over node u 2 if W((v,u 1)) > W((v, u 2)). Using this ranking we can solve the original Stable Matching problem. We consider two different communication models: the billboard model and the full distributed model. In the billboard model, we assume that there is a public billboard and each participant can write one message on it in each time step. In the distributed model, we assume that each node can send O(logn) bits on each edge of the K n,n . In the billboard model we prove a somewhat surprising tight bound: any algorithm that solves the Stable Matching problem requires at least n − 1 rounds. We provide an algorithm that meets this bound. In the distributed communication model we provide an algorithm named intermediation agencies algorithm, in short (IAA), that solves the Distributed Weighted Stable Marriage problem in O(Ön)O(\sqrt{n}) rounds. This is the first sublinear distributed algorithm that solves some subcase of the general Stable Marriage problem.Structural Information and Communication Complexity, 17th International Colloquium, SIROCCO 2010, Sirince, Turkey, June 711, 2010. Proceedings; 01/2010
Page 1
Collaborate With Strangers to Find Own Preferences∗
Extended Abstract
Baruch Awerbuch†
Yossi Azar‡
Zvi Lotker§
Boaz PattShamir¶
Mark R. Tuttle?
Abstract
We consider a model with n players and m objects. Each
player has a “preference vector” of length m that models
his grade for each object. The grades are unknown to the
players. A player can learn his grade for an object by
probing that object, but performing a probe incurs cost.
The goal of a player is to learn his preference vector with
minimal cost, by adopting the results of probes performed
by other players. To facilitate communication, we assume
that players collaborate by posting their grades for objects
on a shared billboard: reading from the billboard is free.
We consider players whose preference vectors are popular,
i.e., players whose preferences are common to many other
players. We present distributed and sequential algorithms
to solve the problem with logarithmic cost overhead.
Categories and Subject Descriptors
C.2.4 [ComputerCommunication Networks]: Dis
tributed Systems; F.2.2 [Analysis of Algorithms and
∗Research partly done in HP Cambridge Research Lab (CRL).
†Dept. of Computer Science, Johns Hopkins University.
Email: baruch@cs.jhu.edu. Supported by NSF grant ANIR
0240551 and NSF grant CCR0311795.
‡School of Computer Science, Tel Aviv University, Tel Aviv
69978, Israel. Email: azar@tau.ac.il.
in part by the GermanIsraeli Foundation and by the Israel
Science Foundation.
§Kruislaan 413 P.O. Box 94079, CWI, 1090 GB Amsterdam,
The Netherlands. Email: lotker@cwi.nl.
¶Dept. of Electrical Engineering, Tel Aviv University, Tel Aviv
69978, Israel. Email: boaz@eng.tau.ac.il.
ported in part by Israel Ministry of Science and Technology.
?HP Cambridge Research Lab, One Cambridge Center, Cam
bridge MA 02142, USA. Email: mark.tuttle@hp.com.
Research supported
Research sup
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee.
SPAA’05, July 18–20, 2005, Las Vegas, Nevada, USA.
Copyright 2005 ACM 1581139861/05/0007 ...$5.00.
Problem Complexity]: Nonnumerical Algorithms and
Problems
General Terms
Algorithms, Theory.
Keywords
recommendation systems, collaborative filtering, random
ized algorithms, electronic commerce, probes, billboard.
1.Introduction
Most people encounter recommendation systems on a
daily basis in many situations, such as buying a book,
renting a movie, choosing a restaurant, looking for a ser
vice provider etc. Recommendation systems are supposed
to help us make choices among the different alternatives
that are available to us. The introduction of the Inter
net had made recommendation systems even more criti
cal than ever, since entities (such as users and products)
on the Internet are typically virtual, and may be located
on the other side of the globe. As a result, a user may
have very little sideinformation to work with, and must
rely on computerized recommendation systems. The idea
in these systems is to take advantage of the existence of
many users with similar opinions: a set of users with sim
ilar preferences (called type) can collaborate by sharing
the load of searching the object space and identifying ob
jects they deem as good. However, players belonging to
the same type do not know of each other a priori, and
therefore, implicitly or explicitly, significant effort must
be directed into identifying potential collaborators (while
avoiding possible crooks).
Much of the extant research has concentrated on try
ing to find a good object for each user; in this paper we
address a more general question, where the goal of the
users is to try to find what are their opinions on all ob
jects. The advantage of having such an algorithm is that
it allows users to identify others who share their opinions,
which may be useful in the long range: When a new batch
of objects arrives, much effort can be saved by using the
opinions of users who have already been identified as be
longing to my own type. Moreover, as we show in this
Page 2
paper, the cost of finding the complete set of grades (and
hence identifying users with similar preferences) is com
parable with the cost of finding just one good object for
each user.
Roughly speaking, our model is as follows (formal def
initions are provided in Section 2). We assume that there
are n users and m objects, and that each user has an
unknown grade for each object, i.e., each user can be rep
resented by his preference vector. The goal is for each user
to find his complete preference vector.1The problem is
that players do not know what is their preference for an
object unless they probe it, but probing is a costly opera
tion (e.g., the user needs to buy the product). Neverthe
less, players would like to predict what is their preference
for items they did not probe. To facilitate this, the system
provides a shared “billboard,” on which players can post
the results of their probes, thus allowing players with sim
ilar preferences to split the probes among them and share
the results. The existence of a billboard does not immedi
ately solve the problem: the question now is which grades
should one adopt, since players may have arbitrarily dif
ferent preference vectors. To allow a nontrivial solution
to exist, we assume that some preference vectors are pop
ular, namely many players have them. Such players are
said to belong to the same type. Ideally, players of the
same type should share the work and the results among
them; however, it is not known who belongs to which type
when the algorithm starts.
Symmetric operation.
imposed on any reasonable solution is that it must be
symmetric, i.e., with high probability, all players execute
moreorless the same amount of work.
tion is lifted, it is easy to come up with simple asym
metric “committeestyle” solutions to the problem (see
Sec. 5.1). However, such algorithms, while possibly suit
able for centralized settings, seem unrealistic in the dis
tributed model, for the following reasons (see [5, 2] for
more discussion of the issue):
One important requirement
If this restric
• Lack of fairness: the number of objects may be
huge, and the tolerance of players for doing a lot
of work for others may be in short supply.
• Distrust of committees: smallsize committees are
prone to easy manipulation by adversaries (bribery,
intimidation, other forms of corruption) and thus
cannot be trusted to be objective judges on impor
tant matters.
1.1 Lower bounds
Before we state our results precisely, let us sketch two
trivial lower bounds on the cost. Consider first a nearly
ideal scenario, where all players in a given type T know the
identities of all other typeT players, but they don’t know
what is the typeT preference vector. Even if the players
coordinate perfectly to minimize their overall cost to find
the vector, each object must be probed at least once by
some typeT player. Therefore, a lower bound of Ω(m) on
1We arbitrarily write “he” for users, but it should be read as
“he or she.”
the total cost to the players of type T is unavoidable. Now
consider a second nearly ideal scenario, in which all type
vectors are common knowledge, and the only question a
player must answer is what type does he belong to. It
is not hard to see that if there are k possible types, Ω(k)
expected probes by each player are unavoidable. It follows
that the total cost of all players of a single type of size
Ω(n/k) is Ω(n). Combining the lower bounds from the
two scenarios above we conclude that no algorithm can
solve the problem is o(m + n) cost over all players of a
given type.
1.2Our results
In this paper we take another step toward understand
ing recommendation systems. Informally, we present al
gorithms (in the simplified model sketched above), which
demonstrate that if one’s unknown preferences are known
not to be esoteric (i.e., it is known that there are quite
a few other players with the same unknown preferences),
then one can find his own preferences without performing
more than a logarithmic number of probes. More specifi
cally, we present symmetric algorithms that approach the
above lower bound to within a logarithmic factor. The
algorithms are randomized, and they are guaranteed to
work with probability 1 − n−Ω(1). The algorithms rely
on knowing a lower bound on the popularity of the type
in question. Formally, the algorithms use a parameter
0 < α ≤ 1 such that there are at least αn players with
the preference vector we would like to output.
Our main result is a parallel algorithm called D, whose
running time is O
αn
tal number of probes done by users of any given type is
O ((n + m)logn). Our algorithm works for any set of user
preferences: only the running time depends on the type
size.
We also present a sequential algorithm which slightly
improves the total number of probes for large α, while
maintaining the crucial fairness property that all users
make approximately the same number of probes. The se
quential algorithm (called S1) ensures that the total num
ber of probes done collectively by players in any given type
is at most O
α
time of the latter algorithm may be high.
Detailed comparison with previous results is given in
Sec. 5, after the presentation of our algorithms. As a one
line summary, let us emphasize at this point that unlike
our algorithms, all previous solutions to this problem are
either asymmetric (i.e., some players do linear work), or
cannot deal with all inputs.
?log n
?m
??. This means that the to
?mlogn +n
?. Unfortunately, the running
Paper organization. The remainder of this paper is
organized as follows. In Section 2 we formalize the model.
In Section 3 we present our sequential algorithm, S1. In
Section 4 we present our parallel algorithm, D.
concluding remarks and open problems are presented in
Section 6. In Section 5 we describe existing work. In
section 6 we conclude with some open problems.
Some
Page 3
2.Model
Our model is formally defined as follows. There are
n players and m objects. For each object i ∈ {1,...,m}
and player j ∈ {1,...,n}, there exists a value vj
called the grade or value of object i to player j. The
vector vj
= (vj
player j. A type is a vector v ∈ {0,1}m. A player j is
said to belong to type v if his preference vector vjis equal
to v. We say that the popularity of a type is α, for some
0 ≤ α ≤ 1, if there are at least αn players of that type.
An execution is a sequence of steps, where in each step
some players move. A basic move of a player j is to reveal
his value vj
player j probed object i, and say that vj
i. Each player may probe one object in a step, but many
players may probe the same object simultaneously. The
players communicate by means of a shared billboard. To
model its existence, we assume that the results of all past
probes are freely available to all players.
An algorithm in our model is a function that decides
which player probes which object, based on past probe
results, and possibly using a tape of random bits. Al
gorithms are parametrized by the number of players and
objects (called n and m, respectively), a confidence para
meter (called c), and a lower bound α on the popularity of
the type whose vector the algorithm needs to output. The
individual or aggregate cost of an algorithm is the number
of probes incurred by either an individual player or by all
players of a given type, respectively. The running time of
an algorithm is the total number of parallel steps taken
since the start of the algorithm until all players (possibly
of a given type) have terminated.
By the end of an execution of an algorithm, each
player outputs a vector in {0,1}m. An algorithm is said to
be correct with probability p for players of type T if with
probability p, the output vector of each player of type
T is exactly the player’s preference vector. Probability
is taken over the tape of random bits. The algorithms
presented in this paper are correct with high probability,
meaning that the probability of failure is n−Ω(c), where c
is the confidence parameter of the algorithm.
We stress that the only way randomization is used by
algorithms in this paper is in assuming that the identities
of players and the identities of objects form random per
mutations of {1,...,n} and of {1,...,m}, respectively.
i∈ {0,1},
def
1,vj
2,...,vj
m) is the preference vector of
ifor some object i. In this case we say that
iis the vote of j on
3. Sequential Algorithm
In this section we present a simple algorithm called S1
with low cost, but high running time. We fix our attention
on a single type of popularity α > 0. Algorithm S1 works
for any value of 0 < α ≤ 1. Its cost is better than the
cost of Algorithm D (presented in Section 4) for α =
Ω(1/logn).
The algorithm works as follows (see Figure 1). The al
gorithm proceeds by determining the value of objects one
at a time. This is done by letting random players probe
the object until the players can conclude, with high prob
ability, what is the value of the object (Step 3). The high
probability test is based on the lower bound on the num
ber of players with the same type: if there are too few
players who think that the value of the object is v, then,
given the lower bound on the popularity of the type, the
value of that object to that type is not v . The thresh
old is computed in Step 2. It may be the case, however,
that the high probability test will never end with a single
value for the object (say when α < 1/2). In this case all
players might end up testing the object. Following this
strategy naively will lead to the trivial cost of nm probes.
To avoid that, we use the following simple idea. Each
player locally marks each other player as either “quali
fied” or “unqualified.” The interpretation of the marks is
that a player j?is marked “unqualified” by player j only
if there is evidence that j?does not belong to the type of
j. Initially, all players are marked “qualified” by every
one. The marks are updated by subroutine call: Once
an object value is determined, all players who voted for
another value are “disqualified” by the current player i.e.,
that player disregards them from that point and onward.
The important property of the algorithm is that all
players of the same type maintain a consistent view of
which players are qualified and which aren’t.
Lemma 3.1. For any object i, all players of type T ex
ecute call(i,v) with the same value v. Furthermore, they
all have the same set of qualified players.
Proof: By induction on the objects. For the basis of the
induction we have that all players of type T have the same
set of players as qualified when the algorithm starts, since
all players are qualified. For the induction step, consider
the point when an object is called. This happens either
in Step 3 or in Step 4b. In the former case, all players of
type T will call the same value because they do it based on
the same billboard and, by induction, they use the same
set of qualified players. In case an object is called in Step
4b, all players of type T have the same local value for the
object by definition of type. The agreement on the set of
qualified players follows in both cases.
Lemma 3.1, in conjunction with the following lemma,
implies correctness of the output.
Lemma 3.2. If a player j of a type whose popularity is
at least α executes call(i,v), then P
?vj
i= v
?< n−c.
Proof: If player j executes call(i,v) at Step 4b, then j
actually probed i, and vj
call(i,v) at Step 3, then we have that only the value v
received more than θi of the qi qualified votes. In this
case it is straightforward to bound the probability that
vj
versions of [10]). The voters are chosen at random (Step
4a), and therefore, by assumption on the popularity of the
type, the probability that a random vote is vj
α. Hence
i= v with certainty. If j executes
i= v using the Chernoff bound as follows (we use the
iis at least
P
?
vj
i= v
?
≤
<
<
P
?
vj
ireceived less than θi votes
?
e−αqi/8
e−c ln n= n−c.
The first inequality above follows from Step 3; the sec
ond inequality follows from Chernoff, since the expected
Page 4
Algorithm S1:
For each object i in turn do:
1. Let the number of votes of qualified players for object i be qi.
2. Let θi ←α
3. If there is only one value v with more than θi qualified votes, then execute call(i,v), and proceed to the next
object.
2(qi− 8clnn).(θi is a threshold)
4. Otherwise(multiple values pass threshold)
(a) If not all players have probed i, let a random player probe object i and go to Step 1.
(b) Otherwise (all players have already probed i), let v be the value seen by the local player. Execute call(i,v)
and proceed to the next object.
Subroutine call(i,v):
1. Output the value v for object i.
2. Mark all players whose vote on i is different than v as “unqualified.”
Figure 1: Pseudocode for Algorithm S1.
number of votes for vj
inequality follows from the fact that when call(i,v) is
executed, θi is strictly positive, and hence, by definition
of θi, we αqi > 8clnn at this point.
iis at least αqi > 2θi; and the last
We now bound the cost of S1. To do that, we count
the number of qualified votes, i.e., votes of players that
are considered qualified when Step 1 is executed (note
that some of the players who cast such votes may later be
disqualified).
Lemma 3.3. The
throughout the execution is at most O
total number ofqualifiedvotes
?mlnn +1−α
i denote the
αn
?.
Proof Sketch:
total number of qualified players who vote on i when
call(i,v) is executed. Obviously, the total number of
probes of typeT players is at most
iq?
one hand, each player may be disqualified at most once,
and hence the total number of disqualifications, through
out the execution, is at most (1 − α)n.
hand, note that whenever call(i,v) is executed, at least
α
2((q?
i was not called in the previous round, when there were
q?
α
2(q?
than v. It follows that
For each object i, let q?
?
iq?
i. We bound
?
iby counting the number of disqualified players. On
On the other
i−1)−8clnn) players are disqualified: this is because
i− 1 qualified votes, and therefore there were at least
i−1 − 8clnn) players who voted for a value different
(1 − α)n ≥
m
?
i=1
α
2
?q?
i− 1 − 8clnn
?
,
i.e.,
m
?
i=1
q?
i ≤ O
?
mlnn +1 − α
α
n
?
.
We summarize with the following theorem.
Theorem 3.4. Suppose that there are at least αn play
ers from a certain type, and that they all run Algorithm
S1. Then with probability 1 − n−Ω(1)they will all output
the correct vector, after executing O(mlogn +n
α) probes.
Since in Algorithm S1 only one player probes in each
round, its time complexity is equal to the number of
probes. It is easy to speed up the algorithm somewhat.
For example, we can have all players probe all objects
in parallel until there are O(log n) samples per object,
and then apply the algorithm only to the undetermined
objects. We do not elaborate any further on this idea,
since in the following section we present an algorithm with
nearly the best possible parallel time.
4. Parallel Algorithm
In this section we present our main result, a recur
sive parallel algorithm called D. This algorithm achieves
nearoptimal time complexity while maintaining the cost
modest.
The idea in Algorithm D is as follows (see Figure 2).
Given a set of players and a set of objects, we split the
players and objects into two subsets each, let each half
of the players recursively determine the values of half of
the objects, and then merge the results. Figure 3 gives a
visual representation of the situation after returning from
the recursive call. Merging results means filling in the
missing entries. Merging is done as follows. First, each
player finds the preference vectors that are sufficiently
popular in the other half (Step 4). This leaves only a
few candidate vectors the players needs to choose from
to complete his row. Testing objects with disputed val
ues (Steps 5–6), the player eliminates at least one vector
in each probe, and eventually, the player adopts the last
surviving vector.
In the algorithm, we assume that the partition of
sets of players and objects into halves is done by a fixed
function. For example, if the current set of players is
P = {j,j + 1,...,j + k − 1} and the current set of ob
jects is O = {i,i + 1,...,i + k?− 1}, then P?may be
Page 5
Algorithm D(P,O):
1. If min(P,O) <8c ln n
2. (Otherwise) Let P?be the half of P such that j ∈ P?, and let P??be the other half. Let O?be the half corresponding
to P?in O, let O??be the other half of O.
3. Execute D(P?,O?).
(upon returning, values for all objects in O?were output by all players in P?, and values for all objects in O??were
output by all players in P??)
4. Scan the billboard. Let V be a set of vectors for O??such that the each vector in V is voted for by at least α/2 of
the players in P??.
5. Let C ⊆ O??be the set of objects for which there are different votes in V .
(P is a set of players and O is a set of objects)
α
then probe all objects in O, output their values, and return.
(The partition of P and O is a fixed function of the IDs)
6. While C = ∅ do
(a) Choose an arbitrary object i ∈ C. Probe i, and let the probe result be denoted by v.
(b) Remove from V vectors whose value on i is not v.
(c) Update C to contain all objects on which surviving vectors in V differ.
7. Output the (unanimous) votes of surviving vectors in V for all objects in O??and return.
Figure 2: Pseudocode for Algorithm D as executed by player j. When The algorithm returns, the players in P have
output values for all objects in O.
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
v1
v2
...
vn?
1
1
v1
v2
...
vn?
2
2
...
...
...
...
v1
v2
m?
m?
...
12
vn?
m?
vn?+1
m?+1
vn?+2
m?+1
...
v2n?
m?+1
vn?+1
m?+2
vn?+2
m?+2
...
v2n?
m?+2
...
...
...
...
vn?+1
2m?
vn?+2
2m?
...
v2n?
2m?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Figure 3: Matrix representation of the results after Step
3 in Algorithm D. Each row represents a player, and each
column represents an object. P?is the top half of the rows,
and O?is the left half of the columns. P? = P?? = n?
and O? = O?? = m?. The entries in two quadrants of
the matrix are unknown.
defined by P?= {j,j + 1,...,j + k/2 − 1} and similarly
O?= {i,i + 1,...,i + k?/2 − 1}. The sets P??and O??are
defined to be the remainders P \ P?and O \ O??, respec
tively. Since we assume that the identities of players and
objects form a random permutation, these choices define
random partitions of P and O into two halves each (we
assume, for convenience, that n and m are powers of 2).
In the analysis, we focus our attention on a certain
type T with popularity α.
Lemma 4.1. Fix an invocation of D(P,O) with P ≥
8c ln n
α
. Then with probability at least 1−n−c, there are at
least αP/2 typeT players in P in that invocation.
Proof: The lemma follows from the fact that P is a ran
dom subset of the players, and hence the expected number
of typeT players in P is αP. Using Chernoff we get that
P
less than
2
typeT players in P
?
αP
?
<eαP/8
≤
n−c,
since P ≥8c ln n
α
.
Lemma 4.2. The total number of probes for a single
player in the execution of the algorithm is O
?log n
α
?m
n
??.
Proof Sketch: Step 1 is taken only once by a player.
If Step 1 is taken because P <
player set and the object set are halved in each recursive
call, we may conclude that when Step 1 is taken, O <
m·8c ln n
In any case, Step 1 incurs at most O(m log n
O(
n
The only other probes made by the algorithm are
made in Step 6a. In any given invocation of the algo
rithm, each player makes at most V  probes at Step 6a.
Since by Step 4 each member of V represents at least an
α/2 fraction of the players, we have that V  ≤
the depth of the recursion is log
have that the total number of probes done in Step 6a by
each player, throughout the execution of the algorithm, is
O
α
We summarize in the following theorem.
8c ln n
α
, then since the
αn. Otherwise, Step 1 is taken because O <8c lnn
α
.
αn
+
log n
α) =
?m
?log n
α) probes.
2
α. Since
n
8c ln n/α= O(logn), we
?log n
?. The result follows.
Theorem 4.3. Suppose that there are Θ(αn) players
from a certain type T, and that they all run Algorithm D.
Then with probability 1 − n−Ω(1)they will all output the
correct vector, after executing O((m + n)logn) probes in
O
αn
We note that both the total cost and the individual
running time of Algorithm D are the best possible, up to
a factor of O(logn).
?log n
?m
??rounds.
Page 6
5.Related work
Most prior research on recommendation systems fo
cused on a centralized, offline version of the single rec
ommendation problem, where the algorithm is presented
with a lot of historical preference data, and the task is
to generate a single recommendation that maximizes the
utility to the user. This is usually done by heuristically
identifying clusters of users [12] (or products [13]) in the
data set, and using past grades by users in a cluster to pre
dict future grades by other users in the same cluster. Sin
gular Value Decomposition (SVD) was also shown to be
an effective algebraic technique for the offline single rec
ommendation problem [14]. Some of these systems enjoy
industrial success, but they are known to perform poorly
when prior data is less than plentiful [15], and they are
quite vulnerable even to mild attacks [9, 11].
Algorithmic results. Theoretical studies of recommen
dation systems usually take the latent variable model ap
proach: a stochastic process is assumed to generate noisy
observations, and the goal of an algorithm is to approxi
mate some unknown parameters of the model. Kumar et
al. [8] study the offline problem for a model where pref
erences are identified with past choices (purchases). In
this model there are clusters of products. Each user has a
probability distribution over clusters; a user first chooses
a cluster by his distribution, and then chooses a product
uniformly at random from that cluster. The goal is to
recommended a product from the user’s most preferred
cluster. Kleinberg and Sandler [7] generalized this model
to the case where the choice within a cluster is governed
by an arbitrary probability distribution, and also consider
the mixture model, in which each cluster is a probability
distribution over all products.
Singular value decomposition approaches. Azar et
al. introduced in [3] the idea of using SVD to reconstruct
the unknown preference vectors. This idea was later used
by Drineas et al. [5]. The attractive feature of the SVD
method is its ability to deal with some noise. However,
SVD is inherently incapable of handling preference vec
tors that cannot be approximated by a low rank matrix.
By contrast, our algorithm requires only a bound on the
individual type size: what happens with other types is
completely irrelevant. As a result, our algorithms can deal
with any input, and the running time for a given type is
nearly optimal, while the correctness of SVDbased al
gorithms is dependent on players from other types. This
makes SVD an easy target even for weak adversaries (e.g.,
nonadaptive), against which our algorithms are immune.
Best value approaches. Much of the research on rec
ommendation systems concentrated on a passive model,
where the algorithm analyzes the data and is supposed
to make recommendations; the influence of the algorithm
on what data is collected, was ignored. An active model
of recommendation systems was introduced in [5] (called
“competitive recommendation systems” there). In this
model the objective is to find, for each user, at least one
object he rates as “good.” If preference vectors of differ
ent types are orthogonal (i.e., do not share objects they
both rate as “good”), then these algorithms can be used to
reconstruct the complete preference vectors of the users.
In fact, [5] uses SVD and works only if type orthogonality
holds; it is vulnerable to attacks by dishonest users. In [2],
it is shown that a simple committeebased algorithm (see
below) suffices to find a good recommended object with
out restricting the user preferences. Additionally, [2] give
a distributed peertopeer algorithm for picking a good
object, that can withstand any number of dishonest users
(the performance depends only logarithmically on the to
tal number of users).
Again, our algorithms find the complete preference
vectors without assumptions. We also note that finding
complete vectors is useful in the long run: as a byproduct,
our algorithms generate a classification of users into types,
which can be reused when coping with a new batch of
objects.
Learning relations.
learning model of Goldman et al. [6], where the algorithm
works for all inputs. The setting in [6] is that a central
ized algorithm needs to learn a binary relation: the rela
tion value for all (i,j) pairs must be output. In each step,
the algorithm predicts the value of the relation for some
pair i,j, and then the true value is revealed. The measure
of performance in this case is the number of errors com
mitted by the algorithm. For this model they consider a
few types of schedules, including the case where the algo
rithm chooses which entry to guess next, which is similar
to the online model we consider. However, there are a
few important differences between the learning model and
ours. First, since the true values become known while
the algorithm is running, the task is easier than the one
we consider, where almost all values remain unexposed
even after the algorithm has terminated. Formally, in our
model, revealing any true grade incurs cost, and hence
the cost of the algorithm of [6] in our model is linear, i.e.,
the worst possible. Second, the learning algorithms are
fundamentally centralized in the sense that some play
ers (possibly all) will probe all objects similarly to the
committeebased algorithms (see below).
Another related problem is the
5.1Asymmetric algorithms
One simplistic approach to solve the recommendation
problem is to use committees [5, 2]. In this case, a few
players are essentially charged with doing the work for all
others. Consider the following algorithm for our problem:
1. Choose K = O
?log n
α
?random players.
2. Let each player probe all objects.
3. Let all other players find the committee member
with whom they agree.
Step 3 can be implemented in K probes by each non
committee player (as done in Steps 5–6 of Algorithm D in
Section 4). The correctness of the algorithm follows from
the observation that with high probability, the commit
tee contains at least one member from each type whose
frequency is at least α. However, as mentioned in the
Page 7
introduction, committeebased algorithms are simply un
acceptable in a distributed setting, due to their inherent
unfairness, and to their vulnerability to malicious attacks.
6.Conclusion and Open Prob
lems
In this paper we showed that in a highly simplified
model, there exist very simple solutions to the impor
tant problem of lowcost preference reconstruction. Our
results allow us to hope that the considerable gaps be
tween the abstract model and real life can be bridged by
algorithmic solutions. In particular, we believe that the
following problems are important to solve.
• The algorithms in this paper are synchronous, i.e.,
players are assumed to proceed in lockstep fashion.
Finding an asynchronous algorithm would be a sig
nificant progress in making the algorithm practical.
• Another important aspect is that the algorithms
in this paper assume that all players of the same
type have identical preference vector. It would be
extremely useful to extend the algorithms to the
case where types are not sharply defined, i.e., to
allow some tolerance for deviation.
• The algorithms use random player and product
identities. It seems interesting to try to develop
an algorithm that lifts this assumption.
• The algorithms rely on knowing a lower bound on
α, the popularity of the type. We would like to find
an algorithm that adapts to any α.
Taste and honesty. One (post modern) interpretation for
taste is honesty. In this model, each object has a single
value (“truth”), independent of the player who probes it.
This model is applicable if the grades of objects reflect
some objectively defined predicate. In this case a player
who announces a value which is not the true value of the
object is simply lying. With this interpretation, our algo
rithms can be used to ensure that, with high probability,
each and every lie will eventually be uncovered. This cer
tainty may lead to the following intriguing consequence
(assuming that the penalty for getting caught lying is
larger than the gain): no rational player will ever lie, and
the overhead of enforcing honesty will be minimized, since
the algorithm will be invoked only in the rare cases of ir
rationality. Analyzing this scenario is beyond the scope
of the current paper.
Acknowledgment
We thank Avrim Blum for pointing the existence of [6] to
us.
References
[1] B. Awerbuch, B. PattShamir, D. Peleg, and
M. Tuttle. Collaboration of untrusting peers with
changing interests. In Proc. 5th ACM Conf. on
Electronic Commerce (EC), pages 112–119, May
2004.
[2] B. Awerbuch, B. PattShamir, D. Peleg, and
M. Tuttle. Improved recommendation systems. In
Proc. 16th ACMSIAM Symposium on Discrete
Algorithms (SODA), pages 1174–1183, January
2005.
[3] Y. Azar, A. Fiat, A. Karlin, F. McSherry, and
J. Saia. Spectral analysis of data. In Proc. 33rd
ACM Symp. on Theory of Computing (STOC),
pages 619–626, 2001.
[4] J. F. Canny. Collaborative filtering with privacy. In
IEEE Symposium on Security and Privacy, pages
45–57, 2002.
[5] P. Drineas, I. Kerenidis, and P. Raghavan.
Competitive recommendation systems. In Proc.
34th ACM Symp. on Theory oand that the identities
of objects form a random permutation off
Computing (STOC), pages 82–90, 2002.
[6] S. A. Goldman, R. L. Rivest, and R. E. Schapire.
Learning binary relations and total orders. SIAM J.
Computing, 22(5):1006–1034, October 1993.
[7] J. Kleinberg and M. Sandler. Convergent algorithms
for collaborative filtering. In Proc. 4th ACM Conf.
on Electronic Commerce (EC), pages 1–10, 2003.
[8] R. Kumar, P. Raghavan, S. Rajagopalan, and
A. Tomkins. Recommendation systems: A
probabilistic analysis. In Proc. IEEE Symp. on
Foundations of Computer Science (FOCS), pages
664–673, 1998.
[9] S. K. Lam and J. Riedl. Shilling recommender
systems for fun and profit. In 13th conference on
World Wide Web, pages 393–402. ACM Press, 2004.
[10] R. Motwani and P. Raghavan. Randomized
Algorithms. Cambridge University Press, 1995.
[11] M. P. OMahony, N. J. Hurley, and G. C. M.
Silvestre. Utilitybased neighbourhood formation for
efficient and robust collaborative filtering. In 5th
ACM conference on Electronic Commerce, pages
260–261, 2004.
[12] P. Resnick, N. Iacovou, M. Suchak, P. Bergstrom,
and J. Riedl. Grouplens: an open architecture for
collaborative filtering of netnews. In 1994 ACM
conference on Computer supported cooperative work,
pages 175–186. ACM Press, 1994.
[13] B. Sarwar, G. Karypis, J. Konstan, and J. Reidl.
Itembased collaborative filtering recommendation
algorithms. In 10th international conference on
World Wide Web, pages 285–295. ACM Press, 2001.
[14] B. Sarwar, G. Karypis, J. Konstan, and J. Riedl.
Analysis of recommendation algorithms for
ecommerce. In 2nd ACM conference on Electronic
Commerce, pages 158–167. ACM Press, 2000.
[15] A. I. Schein, A. Popescul, L. H. Ungar, and D. M.
Pennock. Methods and metrics for coldstart
recommendations. In 25th annual international
ACM SIGIR conference on Research and
development in information retrieval (SIGIR ’02),
pages 253–260, 2002.
View other sources
Hide other sources
 Available from Zvi Lotker · May 31, 2014
 Available from Zvi Lotker · May 31, 2014
 Available from psu.edu