=Paper=
{{Paper
|id=Vol-1430/paper9
|storemode=property
|title=RAPS: A Recommender Algorithm Based on Pattern Structures
|pdfUrl=https://ceur-ws.org/Vol-1430/paper9.pdf
|volume=Vol-1430
|dblpUrl=https://dblp.org/rec/conf/ijcai/IgnatovK15
}}
==RAPS: A Recommender Algorithm Based on Pattern Structures==
https://ceur-ws.org/Vol-1430/paper9.pdf
RAPS: A Recommender Algorithm Based on Pattern
Structures
Dmitry I. Ignatov1 and Denis Kornilov1
National Research University Higher School of Economics
dignatov@hse.ru
http://www.hse.ru
Abstract. We propose a new algorithm for recommender systems with numeric
ratings which is based on Pattern Structures (RAPS). As the input the algorithm
takes rating matrix, e.g., such that it contains movies rated by users. For a target
user, the algorithm returns a rated list of items (movies) based on its previous rat-
ings and ratings of other users. We compare the results of the proposed algorithm
in terms of precision and recall measures with Slope One, one of the state-of-the-
art item-based algorithms, on Movie Lens dataset and RAPS demonstrates the
best or comparable quality.
Keywords: Formal Concept Analysis, Pattern Structures, Recommender Sys-
tems, Collaborative Filtering, RAPS, Slope One
1 Introduction and related work
Formal Concept Analysis (FCA)[1] is a powerful algebraic framework for knowledge
representation and processing [2,3]. However, in its original formulation it deals with
mainly Boolean data. Even though original numeric data can be represented by so called
multi-valued context, it requires concept scaling to be transformed to a plain context
(i.e. a binary object-attribute table). There are several extensions of FCA to numeric
setting like Fuzzy Formal Concept Analysis [4,5]. In this paper, to recommend partic-
ular user items of interest we use Pattern Structures, an extension of FCA to deal with
data that have ordered descriptions. In fact, we use interval pattern structures that were
proposed in [6] and successfully applied, e.g., in gene expression data analysis [7].
The task of recommending items to users according to their preferences expressed
by ratings of previously used items became extremely popular during the last decade
partially because of famous NetFlix 1M$ competition [8]. Numerous algorithms were
proposed to this end. In this paper we will mainly study item-based approaches. Our
main goal is to see whether FCA-based approaches are directly applicable to the set-
ting of recommender systems with numeric data. Previous approaches used concept
lattices for navigation through the recommender space and allowed to recommend rel-
evant items faster than online computation in user-based approach, however it requires
expensive offline computations and a substantial storage space [9]. Another approach
tries to effectively use Boolean factorisation based on formal concepts and follows user-
based k-nearest neighbours strategy [10]. A parameter-free approach that exploits a
neighbourhood of the object concept for a particular user also proved its effectiveness
[11] but it has a predecessor based on object-attribute biclusters [12] that also capture
the neighbourhood of every user and item pair in an input formal context. However, it
seems that within FCA framework item-based techniques for data with ratings have not
been proposed so far. So, the paper bridges the gap.
The paper is organised as follows. In Section 2, basic FCA definitions and interval
pattern structures are introduced. Section 3 describes SlopeOne [13] and RAPS with
examples. In Section 4, we provide the results of experiments with time performance
and precision-recall evaluation for MovieLens dataset. Section 5 concludes the paper.
2 Basic definitions
Formal Concept Analysis. First, we recall several basic notions of Formal Concept
Analysis (FCA) [1]. Let G and M be sets, called the set of objects and attributes, respec-
tively, and let I be a relation I ⊆ G × M: for g ∈ G, m ∈ M, gIm holds iff the object g has
the attribute m. The triple K = (G, M, I) is called a (formal) context. If A ⊆ G, B ⊆ M
are arbitrary subsets, then the Galois connection is given by the following derivation
operators:
A0 = {m ∈ M | gIm for all g ∈ A},
(1)
B0 = {g ∈ G | gIm for all m ∈ B}.
The pair (A, B), where A ⊆ G, B ⊆ M, A0 = B, and B0 = A is called a (formal)
concept (of the context K) with extent A and intent B (in this case we have also A00 = A
and B00 = B).
The concepts, ordered by (A1 , B1 ) ≥ (A2 , B2 ) ⇐⇒ A1 ⊇ A2 form a complete lattice,
called the concept lattice B(G, M, I).
Pattern Structures. Let G be a set of objects and D be a set of all possible object descrip-
tions. Let u be a similarity operator. It helps to work with objects that have non-binary
attributes like in traditional FCA setting, but those that have complex descriptions like
intervals or graphs. Then (D, u) is a meet-semi-lattice of object descriptions. Mapping
δ : G → D assigns an object g the description d ∈ (D, u).
A triple (G, (D, u), δ ) is a pattern structure. Two operators (·) define Galois con-
nection between (2G , ⊆) and (D, u):
l
A = δ (g) for A ⊆ G (2)
g∈A
d = {g ∈ G|d v δ (g)} for d ∈ (D, u), where (3)
d v δ (g) ⇐⇒ d u δ (g) = d.
For a set of objects A operator 2 returns the common description (pattern) of all
objects from A. For a description d operator 3 returns the set of all objects that contain
d.
A pair (A, d) such that A ⊆ G and d ∈ (D, u) is called a pattern concept of the
pattern structure (G, (D, u), δ ) iff A = d and d = A. In this case A is called a pattern
extent and d is called a pattern intent of a pattern concept (A, d). Pattern concepts are
partially ordered by (A1 , d1 ) ≤ (A2 , d2 ) ⇐⇒ A1 ⊆ A2 ( ⇐⇒ d2 v d1 ). The set of all
pattern concepts forms a complete lattice called a pattern concept lattice.
Intervals as patterns. It is obvious that similarity operator on intervals should fulfill
the following condition: two intervals should belong to an interval that contains them.
Let this new interval be minimal one that contains two original intervals. Let [a1 , b1 ]
and [a2 , b2 ] be two intervals such that a1 , b1 , a2 , b2 ∈ R, a1 ≤ b1 and a2 ≤ b2 , then their
similarity is defined as follows:
[a1 , b1 ] u [a2 , b2 ] = [min(a1 , a2 ), max(b1 , b2 )].
Therefore
[a1 , b1 ] v [a2 , b2 ] ⇐⇒ [a1 , b1 ] u [a2 , b2 ] = [a1 , b1 ]
⇐⇒ min(a1 , a2 ), max(b1 , b2 ) = [a1 , b1 ]
⇐⇒ a1 ≤ a2 and b1 ≥ b2 ⇐⇒ [a1 , b1 ] ⊇ [a2 , b2 ]
Note that a ∈ R can be represented by [a, a].
Interval vectors as patterns. Let us call p-adic vectors of intervals as interval vectors.
In this case for two interval vectors of the same dimension e = h[ai , bi ]ii∈[1,p] and f =
h[ci , di ]ii∈[1,p] we define similarity operation via the intersection of the corresponding
components of interval vectors, i.e.:
e u f = h[ai , bi ]ii∈[1,p] u h[ci , di ]ii∈[1,p] ⇐⇒ e u f = h[ai , bi ] u [ci , di ]ii∈[1,p]
Note that interval vectors are also partially ordered:
e v f ⇐⇒ h[ai , bi ]ii∈[1,p] v h[ci , di ]ii∈[1,p] ⇐⇒ [ai , bi ] v [ci , di ]
for all i ∈ [1, p].
3 Recommender Algorithms
3.1 Slope One
Slope One is one of the common approaches to recommedations based on collaborative
filtering. However, it demonstrates comparable quality with more complex and resource
demanding algorithms [13]. As it was shown in [14], SlopeOne has the highest recall on
MovieLens and Netflix datasets and acceptable level of precision: “Overall, the algo-
rithms that present the best results with these metrics are SVD techniques, tendencies-
based and slope one (although its precision is not outstanding).”
We use this algorithm for comparison purposes.
Slope One deals with rating matrices as input data. In what follows the data contains
movies ratings by different users. That is M = {m1 , m2 , . . . , mn } is a set of movies,
U = {u1 , u2 , . . . , uk } is a set of users. The rating matrix can be represented by many-
valued formal context (U, M, R, I), where R = {1, 2, 3, 4, 5, ∗} is a set of possible ratings
and a triple (u, m, r) ∈ I means that the user u marked by the rating r the movie m.
Whenever it is suitable we also use ri j notation for rating of movie m j by user ui .
In case a user u has not rated a movie m, we use m(u) = r = ∗, i.e. missing rating.
Let us describe the algorithm step by step.
1. The algorithm takes a many valued context of all users’ ratings, the target user ut for
which it generates recommendations. It also requires le f t_border and right_border
for acceptable level of ratings, i.e. if one wants to receive all movies with ratings
between 4 and 5, then left and right borders should be 4 and 5 respectively. The last
pair of parameters: one needs to set up minimal and maximal scores (min_border
and max_border) that are acceptable for our data. It means that if the algorithm
predicts rating 6.54 as a score and maximal score is bounded by 5, then 6.54 should
be treated as 5.
2. The algorithm finds the set of all movies evaluated by the target user S(ut ).
3. For every non-evaluated movie m j ∈ M \ S(ut ) by ut execute step 4), and by so
doing calculate the predicted rating for the movie m j . After that go to step 5).
4. For every evaluated movie mi ∈ S(ut ) by ut calculate S j,i (U \ {ut }), the set of users
that watched and evaluated movies mi and m j . In case S j,i (U \ {ut }) is non-empty,
rk, j −rk,i
that is |S j,i (U \{ut })| > 0, calculate the deviation: dev j,i = ∑ |S j,i (U\{ut })|
uk ∈S j,i (U\{ut })
and add i to R j .
After all current deviations found, calculate the predicted rating: P(ut ) j = |R1j | ∑ (dev j,i +
i∈R j
rt,i ), where R j = {i|mi ∈ S(ut ), i 6= j, |S j,i (U \ {ut })| > 0}. In case R j is empty, the
algorithm cannot make a prediction.
5. By this step Slope One found all predicted ratings P(ut ) for movies from M \ S(ut ).
The algorithm recommends all movies with predicted ratings in the preferred range
le f t_border ≤ P(ut ) j ≤ right_border, taking into account minimal and maximal
allowed values.
If one needs top-N ranked items, she can sort the predicted scores from the resulting
set in decreasing order and select first N corresponding movies.
Example 1.
Consider execution of Slope One on the dataset from Table 1.
Table 1. Example of data for Slope One
user\movie m1 m2 m3
u1 5 3 2
u2 3 4 *
u3 * 2 5
Let us try to predict the rating for u3 and movie m1 .
1. Let le f t_border = 4, right_border = 5, min_border = 1, and max_border = 5.
2. We find S(u3 ) = {m2 , m3 }, the set of evaluated movies by the target user.
3. M \ S(u3 ) = {m1 }
4. S1,2 (U \ {u3 }) = {u1 , u2 }
(r −r1,2 )+(r2,1 −r2,2 )
dev1,2 = 1,1 (|{u = ((5 − 3) + (3 − 4))/2 = 0.5
1 ,u2 }|)
S1,3 (U \ {u3 }) = {u1 }
dev1,3 = (r1,1 − r1,3 )/(|{u1 }|) = (5 − 2)/1 = 3
R1 = {2, 3}
P(u3 )1 = 1/|R j |(dev1,2 + r3,2 + dev1,3 + r3,3 ) = 1/2(0.5 + 2 + 3 + 5) = 5.25
5. Taking into account the maximal rating boundary, the algorithm predicts 5 for
movie m1 , and therefore recommends user u3 to watch it.
3.2 RAPS
Our approach, RAPS (Recommender Algorithm based on Pattern Structures), works
with the same many valued context as Slope One.
Let us describe the algorithm.
1. It takes the context (U, M, R, I) with all ratings, and a target user ut . It also re-
quires le f t_border and right_border for preferred ratings, i.e. if one wants to get
all movies rated in range from 4 to 5, then le f t_border = 4 and right_border = 5.
2. Define the set of movies Mt = {mt1 , . . . , mtq } that the target user ut liked, i.e. the
ones that she evaluated in the range [le f t_border, right_border].
3. For each movie mti ∈ Mt apply eq. 3. and find the set of users that liked the movie
Ati = [le f t_border, right_border] mti for 1 ≤ i ≤ q. As a result one has the set of user
subsets: {At1 , . . . , Atq }.
4. For each Ati , 1 ≤ i ≤ q apply eq. 2 to find its description; in our case it is a vector
of intervals dti = Ati = h[at1i , bt1i ], . . . , [atni , btni ]i for 1 ≤ i ≤ q. Note that, in case a
particular user ux from Ati has not rated my , i.e. rx,y = ∗, then the algorithm does
not take it into account.
5. At the last step compute the vector r = (R1 , . . . , Rn ) ∈ Nn (or Rn in general case),
where
R j = |{i|1 ≤ i ≤ q, [atji , btji ] ⊆ [le f t_border, right_border]}| , i.e.
for each movie m j the algorithm counts how many of its descriptions [atji , btji ] are in
[le f t_border, right_border]. If R j > 0, then the algorithm recommends watching
the movie.
Top-N movies with the highest ratings can be selected in similar way.
Let us shortly discuss the time computational complexity. Step 2 requires O(|M|)
operations, steps 3, 4 and 5 perform within O(|M||U|) each. Therefore, the algorithm
time complexity is bounded by O(|M||U|).
Example 2
Consider execution of RAPS on the tiny dataset from Table 2.
Let us find a recommendation for user u7 .
Table 2. Example of data for RAPS
user\movie m1 m2 m3 m4 m5 m6
u1 5 3 1 3 5 3
u2 4 4 1 5 4 3
u3 5 * * 3 * 4
u4 * 3 4 * 2 4
u5 4 * 4 5 4 *
u6 3 4 5 5 * 3
u7 5 4 2 * * *
1. The input of the algorithm: t = 7, le f t_border = 4 and right_border = 5.
2. M7 = {m1 , m2 }
3. A1 = [4, 5]
m1 = {u1 , u2 , u3 , u5 }
A2 = [4, 5]
m2 = {u2 , u6 }
4.
d1 = A 1 1 1 1 1 1 1 1 1 1 1 1
1 = h[a1 , b1 ], [a2 , b2 ], [a3 , b3 ], [a4 , b4 ], [a5 , b5 ], [a6 , b6 ]i =
= h[4, 5], [3, 4], [1, 4], [3, 5], [4, 5], [3, 4]i
For example, interval [a16 , b16 ] is found as follows:
[a16 , b16 ] = [min(r1,6 , r2,6 , r3,6 , r5,6 ), max(r1,6 , r2,6 , r3,6 , r5,6 )] =
= [min(3, 3, 4, ∗), max(3, 3, 4, ∗)] = [min(3, 3, 4), max(3, 3, 4)] = [3, 4].
The rest intervals are found in similar way.
d2 = A
2 = h[3, 4], [4, 4], [1, 5], [5, 5], [4, 4], [3, 3]i
5. Taking into account the left and right bounds, the algorithm recommends movies
m1 and m5 from d1 and m2 , m4 and m5 from d2 . Therefore R = (1, 1, 0, 1, 2, 0), i.e.
without already assessed movies by u7 , we recommend her to watch m4 and m5 .
4 Experimental evaluation
4.1 Data
For our experimentation we have used freely available data from MovieLens website1 .
The data collection was gathered within The GroupLens Research Project of Minnesota
University in 1997–1998. The data contains 100000 ratings for 1682 movies by 943
different users. Each user rated no less than 20 movies. That is we have 100000 tuples
in the form:
user id | item id | rating | timestamp.
Each tuple shows user id, movie id, the rating she gave to the movie and time when
it happened.
1 http://grouplens.org/datasets/movielens/
4.2 Quality assessment
Firstly, for quality assessment of Slope One and RAPS we used precision and recall
measures. Note that we cannot use Mean Absolute Error (MAE) directly, since RAPS
actually assume a whole interval like [4,5] for a particular movie, not a number. We
select 20% of users to form our test set and for each test user we split her rated movies
into two parts: the visible set and the hidden set. The first set consists of 80% rated
movies, and the second one contains the remaining 20%. Moreover, to make the com-
parison more realistic, movies from the first set were evaluated earlier than those from
the second one. It means that first we sort all ratings of a given user by timestamp and
then perform splitting.
There is a more general testing scheme based on bimodal cross-validation from [15],
which seems to us the most natural and realistic: users from the test set keep only x% of
their rated movies, and the remaining y% of their ratings are hidden. Thus, by consid-
ering each test user in this way, we model a real user whose ratings to other movies are
not yet clear, but at the same time we have all ratings’ information about the training set
of users. In other words, we hide only rectangle of size x% of test users by y% of hidden
items. One can vary x and y during the investigation of the behaviour of methods under
comparison, where the size of top-N recommended list is set to be equal to y%. The
part of hidden items can be selected randomly or by timestamp (preferably for realistic
scenario). Note that there is no a gold standard approach to test recommender systems,
however, there are validated sophisticated schemes [16]. The main reason is the fol-
lowing: with only off-line data in hands we cannot verify whether the user will like a
not yet seen movie irrespective of assumption that she has seen our recommendation.
However, for real systems there is a remedy such as A/B testing, which is applicable
only in online setting [17].
The adjusted precision and recall are defined below:
|{relevant movies} ∩ {retrieved movies} ∩ {test movies}|
precision = (4)
|{retrieved movies} ∩ {test movies}|
|{relevant movies} ∩ {retrieved movies} ∩ {test movies}|
recall = (5)
|{relevant movies} ∩ {test movies}|
These measures allow us to avoid the uncertainty since we do not know how actually
a particular user would assess a recommended movie. However, in real recommender
system, we would rather ask a user whether the recommendation was relevant, but in
our off-line quality assessment scheme we cannot do that. In other words, we assume
that for a test user at the moment of assessment there are no movies except the training
and test ones.
Another issue, which is often omitted in papers on recommender systems, is how
to avoid uncertainty when denominators in Precision and Recall are equal to zero (not
necessarily simultaneously).
To define the mesaures precisely based on the peculiarities of recommendation task
and common sense, we use two types of the definitions for cases when the sets of
retrieved and relevant movies for particular user and recommender are empty.
Precision and Recall of the first type are defined as follows:
– If the sets of relevant movies and retrieved ones are empty, then Precision = 0 and
Recall = 1.
– If the set of relevant movies is empty, but the set of retrieved ones is not, then
Precision = 0 and Recall = 1.
– If we have the non-empty set of relevant movies, but the set of retrieved movies is
empty, then Precision = 0 and Recall = 0.
Precision of the second type is less tough, but Recall remains the same:
– If the sets of relevant movies and retrieved ones are empty, then Precision = 1 (since
we should not recommend any movie and the recommender has not recommended
anything).
– If the set of relevant movies is empty, but the set of retrieved ones is not, then
Precision = 0.
– If we have the non-empty set of relevant movies, but the set of retrieved movies is
empty, then Precision = 1 (since the recommender has not recommended anything,
its output does not contain any non-relevant movie).
4.3 Results
We have performed three series of tests:
1. A movie is worth to watch if its predicted mark is 5 (i.e. it is [5,5]).
2. A mark is good if it is from [4,5].
3. Any mark from [3,5] is good.
All the tests are performed in OS X 10.9.3 with Intel Core i7 2.3 GHz and 8 Gb
of memory. The algorithm were implemented in MATLAB – R2013a. The results are
presented in Table 3. Note that the reported Precision and Recall are of the first type.
Table 3. RAPS vs Slope One Results
Algorithm Preference Average Average Average F1-measure
name Interval time, s precision recall
RAPS [5,5] 3.62 19.42 50.52 28.06
Slope One [5,5] 18.90 1.57 23.41 2.94
RAPS [4,5] 18.23 55.61 63.33 59.22
Slope One [4,5] 18.90 53.99 30.39 38.89
RAPS [3,5] 32.98 80.11 83.65 81.84
Slope One [3,5] 18.90 83.81 81.88 82.83
The criteria are average execution time in seconds, average precision and recall.
From the table one can see RAPS is drastically better than Slope One by the whole set of
criteria in [5,5]. For [4,5] interval both approaches have comparable time and precision,
but Slope One has two times lower recall. For [3,5] interval the algorithms demonstrate
similar values of precision and recall but RAPS 1.5 times slower on average.
However, since the compared approaches are different from the output point view
(RAPS provides the user with an interval of possible ratings but SlopeOne does it by
a single real number), we perform thorough comparison varying the lower bound of
acceptable recommendations and using both types of the adjusted precision and recall
measures.
From Fig. 1 one can conclude that RAPS dominates SlopeOne in most cases by
Recall. As for Precision, even though for [5,5] interval RAPS is significantly better,
after lower bound of 4.4 SlopeOne shows comparable but slightly better Precision in
most cases.
0.9
SlopeOne
0.8
RAPS
0.7
0.6
Precision
0.5
0.4
0.3
0.2
0.1
0
3 3.5 4 4.5 5
Lower bound
0.9
SlopeOne
0.8 RAPS
0.7
Recall
0.6
0.5
0.4
0.3
0.2
3 3.5 4 4.5 5
Lower bound
Fig. 1. Precision and Recall of the first type for RAPS and SlopeOne for the varying lower bound
From Fig. 2 one can see that SlopeOne is significantly better in terms of preci-
sion. Only on the interval [3,5] the difference between SlopeOne and RAPS is negli-
gible (the lower bound value equals 3). The reasonable explanations is as follows: for
1
0.9 SlopeOne
0.8 RAPS
Precision 0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
3 3.5 4 4.5 5
Lower bound
Fig. 2. Precision of the second type for RAPS and SlopeOne for the varying lower bound
SlopeOne there are more cases when {retrieved movies} = 0/ irrespective of the size
of {relevant movies}. Remember that in such cases Precision of the second type is
equal to 1. In other words SlopeOne is really more precise (or even concise): in such
cases it just does not recommend anything. However, it can be hardly judged in movie
recommendation domain that a recommender is good when it does not recommend.
We can conclude that the proposed recommender technique based on pattern struc-
tures has its right to be used. Since the Slope One algorithm was exploited in real
recommender systems [13], we can suggest our technique for usage as well.
5 Conclusion and further work
In this paper we proposed the technique for movie recommendation based on Pattern
Structures (RAPS). Even though this algorithm is oriented to movie recommendations,
it can be easily used in other recommender domains where users evaluate items.
The performed experiments (RAPS vs Slope One) showed that recommender sys-
tem based on Pattern Structures demonstrates acceptable precision, better recall in most
cases and reasonable execution time.
Of course, in future RAPS should be compared with other recommender techniques
to make a final conclusion about its applicability. An interplay between interval-based
recommendations and regression-like ones deserves a more detailed treatment as well.
The further work can be continued in the following directions:
1. Further modification and adjustment of RAPS.
2. Development of the second variant of Pattern Structures based recommender. There
is a conjecture that for the second derivation operation (operator Galois from eq.3)
being applied to more than one movie with high marks we may obtain relevant
predictions as well.
3. Comparison with existing popular techniques, e.g. SVD and SVD++.
Acknowledgments We would like to thank Mehdi Kaytoue, Sergei Kuznetsov and
Sergei Nikolenko for their comments, remarks and explicit and implicit help during
the paper preparations. The first author has been supported by the Russian Foundation
for Basic Research grants no. 13-07-00504 and 14-01-93960 and made a contribution
within the project “Data mining based on applied ontologies and lattices of closed de-
scriptions” supported by the Basic Research Program of the National Research Univer-
sity Higher School of Economics. We also deeply thank the reviewers for their com-
ments and remarks that helped.
References
1. Ganter, B., Wille, R.: Formal Concept Analysis: Mathematical Foundations. 1st edn.
Springer-Verlag New York, Inc., Secaucus, NJ, USA (1999)
2. Poelmans, J., Ignatov, D.I., Kuznetsov, S.O., Dedene, G.: Formal concept analysis in knowl-
edge processing: A survey on applications. Expert Syst. Appl. 40(16) (2013) 6538–6560
3. Poelmans, J., Kuznetsov, S.O., Ignatov, D.I., Dedene, G.: Formal concept analysis in knowl-
edge processing: A survey on models and techniques. Expert Syst. Appl. 40(16) (2013)
6601–6623
4. Belohlávek, R.: What is a fuzzy concept lattice? II. In Kuznetsov, S.O., Slezak, D., Hepting,
D.H., Mirkin, B., eds.: Rough Sets, Fuzzy Sets, Data Mining and Granular Computing - 13th
International Conference, RSFDGrC 2011, Moscow, Russia, June 25-27, 2011. Proceedings.
Volume 6743 of Lecture Notes in Computer Science., Springer (2011) 19–26
5. Poelmans, J., Ignatov, D.I., Kuznetsov, S.O., Dedene, G.: Fuzzy and rough formal concept
analysis: a survey. Int. J. General Systems 43(2) (2014) 105–134
6. Ganter, B., Kuznetsov, S.: Pattern structures and their projections. In Delugach, H., Stumme,
G., eds.: Conceptual Structures: Broadening the Base. Volume 2120 of Lecture Notes in
Computer Science. Springer Berlin Heidelberg (2001) 129–142
7. Kaytoue, M., Kuznetsov, S.O., Napoli, A., Duplessis, S.: Mining gene expression data with
pattern structures in formal concept analysis. Information Sciences 181(10) (2011) 1989 –
2001 Special Issue on Information Engineering Applications Based on Lattices.
8. Bell, R.M., Koren, Y.: Lessons from the netflix prize challenge. SIGKDD Explorations 9(2)
(2007) 75–79
9. du Boucher-Ryan, P., Bridge, D.: Collaborative recommending using formal concept analy-
sis. Knowledge-Based Systems 19(5) (2006) 309 – 315
10. Ignatov, D.I., Nenova, E., Konstantinova, N., Konstantinov, A.V.: Boolean matrix factorisa-
tion for collaborative filtering: An fca-based approach. In Agre, G., Hitzler, P., Krisnadhi,
A.A., Kuznetsov, S.O., eds.: Artificial Intelligence: Methodology, Systems, and Applications
- 16th International Conference, AIMSA 2014, Varna, Bulgaria, September 11-13, 2014.
Proceedings. Volume 8722 of Lecture Notes in Computer Science., Springer (2014) 47–58
11. Alqadah, F., Reddy, C., Hu, J., Alqadah, H.: Biclustering neighborhood-based collabora-
tive filtering method for top-n recommender systems. Knowledge and Information Systems
(2014) 1–17
12. Ignatov, D.I., Kuznetsov, S.O., Poelmans, J.: Concept-based biclustering for internet adver-
tisement. In Vreeken, J., Ling, C., Zaki, M.J., Siebes, A., Yu, J.X., Goethals, B., Webb, G.I.,
Wu, X., eds.: 12th IEEE International Conference on Data Mining Workshops, ICDM Work-
shops, Brussels, Belgium, December 10, 2012, IEEE Computer Society (2012) 123–130
13. Lemire, D., Maclachlan, A.: Slope one predictors for online rating-based collaborative filter-
ing. In: Proceedings of the 2005 SIAM International Conference on Data Mining. 471–475
14. Cacheda, F., Carneiro, V., Fernández, D., Formoso, V.: Comparison of collaborative filtering
algorithms: Limitations of current techniques and proposals for scalable, high-performance
recommender systems. ACM Trans. Web 5(1) (February 2011) 2:1–2:33
15. Ignatov, D.I., Poelmans, J., Dedene, G., Viaene, S.: A new cross-validation technique to
evaluate quality of recommender systems. In Kundu, M.K., Mitra, S., Mazumdar, D., Pal,
S.K., eds.: Perception and Machine Intelligence - First Indo-Japan Conference, PerMIn 2012,
Kolkata, India, January 12-13, 2012. Proceedings. Volume 7143 of Lecture Notes in Com-
puter Science., Springer (2012) 195–202
16. Cremonesi, P., Koren, Y., Turrin, R.: Performance of recommender algorithms on top-n
recommendation tasks. In: Proceedings of the Fourth ACM Conference on Recommender
Systems. RecSys ’10, New York, NY, USA, ACM (2010) 39–46
17. Radlinski, F., Hofmann, K.: Practical online retrieval evaluation. In Serdyukov, P.,
Braslavski, P., Kuznetsov, S.O., Kamps, J., Rüger, S.M., Agichtein, E., Segalovich, I., Yil-
maz, E., eds.: Advances in Information Retrieval - 35th European Conference on IR Re-
search, ECIR 2013, Moscow, Russia, March 24-27, 2013. Proceedings. Volume 7814 of
Lecture Notes in Computer Science., Springer (2013) 878–881