D4.2 Recommendations Engine Offline Version

ViSTA-TV: Video Stream Analytics for Viewers in the TV Industry

FP7 STREP ICT-296126 | 296126 co-funded by the European CommissionICT-2011-SME-DCL | SME Initiative on Digital Content and Languages

D4.2 Recommendations Engine Offline Version

Thomas Scharrenbach (UZH),Yamuna Krishnamurthy (TUDo),Christian Bockermann (TUDo),

Jörg-Uwe Kietz (UZH)

Project start date: June 1st, 2012 Project duration: 24 monthsDocument identifier: ViSTA-TV/2013/D4.2 Version: v1.0Date due: 31 May 2013 Final: FinalSubmission date: 31 May 2013 Distribution: PU

www.vista-tv.eu

ViSTA-TV Consortium

This document is part of a collaborative research project funded by the FP7 ICT Programme of the Commissionof the European Communities, grant number 296126. The following partners are involved in the project:

University of Zurich (UZH) - CoordinatorDynamic and Distributed Information Systems Group (DDIS)Binzmühlstrasse 148050 Zürich, SwitzerlandContact person: Abraham BernsteinE-mail: [email protected]

Techniche Universität Dortmund (TUDo)Computer Science VIII: Artificial Intelligence UnitD-44221 Dortmund, GermanyContact person: Katharina MorikE-mail: [email protected]

Rapid-I GmbH (RAPID-I)Stockumer Strasse 47544227 Dortmund, GermanyContact person: Ingo MierswaE-mail: [email protected]

Zattoo Europa AG (Zattoo)Eggbühlstrasse 28CH-8050 Zürich, SwitzerlandContact person: Bea KnechtE-mail: [email protected]

Vrije Universiteit Amsterdam (VUA)Web & Media Group, Department of Computer Science, Faculty of Sciences (FEW)De Boelelaan 1081aNL-1081 HV Amsterdam, The NetherlandsContact person: Guus SchreiberE-mail: [email protected]

The British Broadcasting Corporation (BBC)56 Wood Lane / Centre HouseLondon W12 7SB, United KingdomContact person: Chris NewellE-mail: [email protected]

Copyright © 2013 The ViSTA-TV Consortium

D4.2 Recommendations Engine Offline Version 3

Executive Overview

This document reports about the work done for achieving the second and third challenge for the DeliverableD4.2, “Recommendations Engine Offline Version”. Based on our work for the dummy recommendations enginefor Deliverable D4.1 [33] we built a version that comprises all necessary components in a version that is able toperform the processing in a streaming manner, yet not optimized for hard real-time processing. The latter willbe subject to the following project period.

4 ViSTA-TV

Contents

1 Introduction 5

2 Setting 6

2.1 Objectives Complex Event Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Objectives Recommendations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Complex Event Processing 8

3.1 The UZH CEP Engine Katts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.2 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.2.1 Seven Commandments for Benchmarking Semantic Flow Processing Systems . . . . . . 9

3.2.2 Eviction Strategies - The better alternative to load-shedding . . . . . . . . . . . . . . . 9

3.2.3 Workload Balancing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4 Feature Selection 11

4.1 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.2 Data Quality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

5 Show User Model 12

5.1 Tag Clustering Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

5.1.1 Genres as Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

5.1.2 Credits as Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5.1.3 Genre and Gender as Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

5.1.4 Generating User Show Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6 Recommendations 21

6.1 Show User Mapping Based Recommendation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.2 Model-based Collaborative Filtering Recommendations . . . . . . . . . . . . . . . . . . . . . . 21

6.2.1 The Vista-TV Recommendation Problem . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.2.2 The Recommendation Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6.2.3 Scalability of Model-building and Quality of the Model . . . . . . . . . . . . . . . . . . 23

6.2.4 Outlook on current and future work . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

7 Conclusion 25


1 Introduction

The EU FP7 project ViSTA-TV gathers consumers’ anonymized viewing behavior and the actual video streamsfrom broadcasters/IPTV-transmitters to combine them with enhanced electronic program guide informationas the input for a holistic live-stream data mining analysis: the basis for an SME-driven market-place for TVviewing-behavior information. First, ViSTA-TV employs the gathered information via a stream-analytics processto generate a high-quality linked open dataset (LOD) describing live TV programming. Second, combining theLOD with the behavioral information gathered, ViSTA-TV is in the position to provide highly accurate marketresearch information about viewing behavior that can be used for a variety of analyses of high interest to allparticipants in the TV-industry. This generates a novel, SME-driven market place for TV viewing-behaviordata and analyses. Third, to gather anonymized behavioral information about viewers not using our IPTV-streams ViSTA-TV employs the gathered information to build a recommendation service that exploits bothusage information and personalized feature extraction in conjunction with existing meta-information to providereal-time viewing recommendations.

This document reports about the work done for achieving the second and third challenge for the DeliverableD4.2, “Recommendations Engine Offline Version”. Based on our work for the dummy recommendations enginefor Deliverable D4.1 [33] we built a version that comprises all necessary components in a version that is able toperform the processing in a streaming manner, yet not optimized for hard real-time processing. The latter willbe subject to the following project period.

Note that the project will be demonstrated at the International Broadcasting Convention (IBC) in September2013 at Amsterdam. To this end, the focus was more laid on making the components real-time ready. Thisprocedure allowed us to perform actual research earlier and adding more functionality on-the-go. As a resultwe were able to perform several scientific studies submitted to the major conferences in the Semantic Web. Allcomponents were built in compliance with the ERC Grant Agreement—Annex I—Description of work (DOW).

Outline

We start with giving an overview in Section 2 over the work done within the ViSTA-TV project as described inAnnex I, Description of Work (DOW). In Section 3 we describe the efforts and achievements for Complex Eventprocessing. Section 4 provides an overview over our work on determining features for giving recommendationsfollowed by an application of such features to a hierarchical clustering of users and shows in Section 5. Itsapplication to the ViSTA-TV stream engine is subject to Section 6. We conclude our report in Section 7 andgiving directions for future work.

6 ViSTA-TV

2 Setting

The following sections provide an overview over the role of the recommendation engine within the ViSTA-TVproject as described in the ERC Grant Agreement—Annex I—Description of work (DOW). The main objectivesof the ViSTA-TV recommendations engine are:

1. Develop recommendation engine that gives real-time recommendations.

2. Probabilistic model for matching complex events on streams of RDF-triples.

3. Hybrid profiling of users and shows on streams of RDF triples.

2.1 Objectives Complex Event Processing

This section repeats the the statements of the ERC Grant Agreement—Annex I—Description of work (DOW),Part B, Section B 1.2, “Progress beyond the state of the art”. It is provided to help creating the setting for thepresent report.

(3) ViSTA-TV will build novel quasi real-time stream processing approaches for complex event processing andfeature construction. The feature extraction process will generate tag streams that describe shows or simpleusage events such as “user Jon Doe watches Sports Today”. Apart from their direct usage these tags providethe basis for constructing more complex events as aggregated/constructed features (e.g., the complex eventafter-work-TV-night could be characterized as watching the sequence: ‘sports’→ ‘news’→ ‘weather’→ ‘crime’show), which in turn serve as the input for the recommendations, the LOD tags, and behavioral characterizations.To construct aggregated tags ViSTA-TV will need a mechanism that efficiently detects complex event patternon tag (or RDF-triple) streams.

State-of-the-art event processing frameworks such as SASE+ [16] or TelegraphCQ [13] are defined on a relationaldata model. The relational model, however, makes it difficult to incorporate background knowledge, efficiently.Linked Data was designed to overcome this limitation of the relational models. EP-SPARQL [6] was presented,recently, for defining and querying complex events on streams of Linked Data or, more specifically, RDF. Yet,EP-SPARQL does not make assumptions on real-time processing or complex time constraints as do automatabased approaches like SASE+. An extension of the relational stream querying language CSQL [7] is C-SPARQL[9]. Both approaches perform processing triples/tuples within a fixed window, which can be based on time-intervals, number of data triples, or partitions based on aggregates. C-SPARQL considers the triples in thewindow as a static knowledge base. An extension for making this approach work more dynamic was proposed,recently [25]. However, complex events whose components may go beyond the window limits (such as long-termTV usage behavior) are not yet taken into account. Progress beyond the state of the art: Real-time complexevent matching requires efficient and effective methods for pruning the current matching hypotheses. Currentapproaches prune by implementing memory eviction schemes such as first-in-first-out (essentially a time window)or least-recently-used (i.e., keeping only active patterns not the most useful one). These schemes essentiallyintroduce a time-window though the backdoor.

ViSTA-TV, in contrast, will employ the SASE+ automata based model and the EP-SPARQL querying capabili-ties but develop methods for estimating the probabilities of automata (representing complex event patterns) tomatch or not. Hence, this novel approach will base its eviction decision based on inherent data statistics, whichis expected to minimize the number of false-positives and false-negatives. Consequently, ViSTA-TV will providenovel methods for matching time-window agnostic complex events on streams of Linked Data in real-time,which will be used for feature/tag construction.

2.2 Objectives Recommendations

This section repeats the the statements of the ERC Grant Agreement—Annex I—Description of work (DOW),Part B, Section B 1.2, “Progress beyond the state of the art”. It is provided to help creating the setting for thepresent report.

ViSTA-TV will be the first to use recommender systems techniques on mostly new items and apply it in thequasi real-time setting of TV-recommendation. Recommender systems have long been in the focus of the e-commerce – the famous NetFlix challenge for movie recommendation is a good example here. The techniques


for recommender systems are generally categorized as content-based, collaborative filtering, or hybrid methods.Content-based methods focus on recommending objects that are similar to the ones a user has previously chosen[31].

Methods based on collaborative filtering identify recommendable items based on user similarity [21, 17, 29].Hybrid approaches combine content-based and collaborative methods and have been reported to raise theaccuracy on recommendations [28]. Another distinction made in the recommender system literature is memory-versus model-based approaches. Memory based approaches work directly on the user/content data and producerecommendation based on the k nearest neighbors. Hence, every new user or item needs to be comparedto all existing users/items – a computational cost unacceptable for our setting. More recently model-basedapproaches, which try to model the relation between users and content mathematically, have been shown to notonly speedup the recommendation process, but may even improve accuracy (e.g., matrix factorization techniqueshave outperformed neighboring based methods in the NetFlix challenge [22]). Furthermore, tensor and matrixfactorization technique that also recently gained interest in social network analysis [4, 8, 27] are supporting thistrend. Unfortunately, however, these model-based techniques are still computationally intensive and, therefore,do not fit the scenario of online recommendation of shows and movies as intended by ViSTA-TV.

Progress Beyond the state of the art: Ensure real-time recommendations by addressing computationalcomplexity of current approaches whilst improving recommendation quality through personalized models: Whilesome work on simple events, none of the state-of-the art recommender systems operates on complex events.ViSTA-TV will make it possible to use complex events for the actual recommendations. This has not beeninvestigated so far – in particular not for real-time processing. In addition, current recommendation approacheswork with handcrafted and manually selected features to describe items. In contrast, ViSTA-TV will integratedynamic feature extraction and selection within the recommendation process.

To address the computational effort of current approaches we intend to take a two-pronged approach. First,TUDo and UZH will not use the recommendation-algorithms on the actual video/audio-streams but rather onthe tag streams extracted in WP2 (see also progress above). This will massively reduce the dimensionality ofthe streams. Second, we will use a personalized heterogeneous clustering approach developed by TUDo thatexploits frequent term set clustering [32, 18]. To speed it up, TUDo will combine this approach with online itemset mining [14]. The combination will result in a novel approach for reducing the computational complexityof recommendation systems, which has the added benefit of providing improved recommendations due to itsunderlying personalized clustering.

Addressing the large-scale cold-start problem of collaborative filtering: new items are not being recommended asnot enough users have rated them and they do not get ratings as they are not recommended. Both hybrid andmodel-based approaches have been shown to reduce the cold-start problem [35]—still recommender-systemshave been mostly used where new content is the exception and not the rule. In the broadcasting TV world ofViSTA-TV many shows on TV are first time transmissions.

Hence, TUDo and UZH will explore a novel hybrid 2-way clustering approach: based on available contentdescriptions (WP1) and external data (WP6) (e.g. this movie is a TV-premiere, but it is already rated ascinema-movie) on one side as well as user viewing information on the other side clusters of shows and usersare discovered in a mutually reinforcing process. Once these clusters are available the recommendation can beviewed as a prediction task [11] using techniques such as Bayesian classifiers, decision trees or artificial neuralnetworks. Since the recommendations are now based not only on single shows but also on show-clusters newshows can “simply” be assigned to a cluster based on its content characteristics and then recommended alongwith other similar shows overcoming the cold-start problem.

8 ViSTA-TV

3 Complex Event Processing

Information processing systems increasingly add capabilities for answering queries on flows (aka streams) ofdata. Information Flow Processing (IFP) systems emerged in the last decade, mainly based on a relational datamodel [15]. With the advent of the Semantic Web flow processing systems emerged which used RDF as theirdata model. This enables them to define rich semantics for their data and hence we refer to them as SemanticFlow Processing (SFP) systems.

We roughly distinguish IFP and SFP between Data Stream Management (DSM) systems and Complex EventProcessing (CEP) systems. DSM systems have a static query matching engine working on finite subsets ofthe stream, also referred to as windows. CEP systems, in contrast, maintain a set of yet incomplete variablebindings and try to complete them while data is flowing into the system. We note that there exist hybridsystems, which combine features of both these approaches. In the scope of the ViSTA-TV project we decidedto use an CEP execution model to better cope with the dynamic nature of the data. It furthermore providesmore flexibility for learning interesting patterns on the data which can be used for recommendations. We maysimulate a DSM system by a CEP system by executing queries on windows.

3.1 The UZH CEP Engine Katts

For performing experiments on semantic flows we developed an own CEP engine at UZH, i.e. the Katts.1 Theengine follows the approach of the CQUELS engine developed at DERI, Ireland [25], i.e., implementing thesingle algebra operators as independent processing units. While CQELS was not flexible enough for distributingit on a Storm cluster, we decided to implement an own CEP engine.

Katts currently implements joins which may contain temporal constraints. It further provides an implementationfor aggregates and filters. All operators can be configured using an Xml configuration file, and each operatorwill be compiled to a Storm processing bolt. Katts allows defining different parallelization strategies to optimallydistribute workload for each processor.

In the scope of the ViSTA-TV project, the following components were developed for Katts:

� n-tuple input processor and

� a compiler for TEF-SPARQL to Katts.

As a fall-back solution we also did an implementation of the most relevant operators for the IBC showcase inEsper.2 Esper is a shared-source implementation of CEP operators in Java. It is available under GPL, version2. In the scope of ViSTA-TV we implemented a module that integrates instances of the Esper CEP engine asprocessors in the streams framework ([24, 3]).

It turned out that for the milestone MS3 (May 31, 2013) we will have to use Esper instead of Katts. The Kattsengine implemented a heartbeat for synchronizing its processors. It turned out that this on the one hand causedan overhead of at least 25% more messages sent over the network. In addition to that, it turned out that theintegration of that heartbeat into the ViSTA-TV stream processing engine would have required changes toocostly for all other processing components (e.g. feature extraction). Note that the components for Katts whichwere developed with funding from the ViSTA-TV project have either already been integrated into the Esperprocessing component or are under development for being integrated.

Nevertheless, the Katts engine proved handy for experiments for probabilistic pruning (we refer to as eviction)and workload distribution. This resulted in two scientific papers submitted to the International Semantic WebConference 2013. Both papers are currently under review. We summarize our findings on these two aspects inmore detail in Section 3.2.

3.2 Evaluation

We performed research on making CEP processing scalable. To that end we developed a method for system-atically defining stress tests for benchmarking Semantic Flow Processing systems—CEP systems that perform

1KATTS is a recursive acronym for Katts is A Triple Torrent Sieve and is accessible via GitHub athttps://github.com/lorenzfischer/katts

2http://esper.codehaus.org


query matching on streams of Linked Data. We also performed experiments with the Katts engine regardingtwo aspects: First, we are interested in performing complex event processing on semantic data without havingto limit ourselves to a scope like, for example, a fixed time window. Second, we found out that a uniformscheduler is not the best option for distributing the workload, i.e., the tasks of distributed data-flow processingsystems to the available computing machines.

3.2.1 Seven Commandments for Benchmarking Semantic Flow Processing Systems

Several studies found that computer science people rather invent novel systems than evaluating them in de-tail [36, 38]. Based on these findings benchmarks were developed for testing Semantic Flow Processing (SFP)systems [39, 26]. It turned out that these benchmarks are not yet ready to be able to test SFP systems withrespect to other key performance indicators than throughput. In addition to that the queries they define arestill rather limited.

In a collaboration of UZH, VU Amsterdam, and Politecnico di Milano we developed the PCKS method,3, whichwe published at the Extended Semantic Web Conference ESWC 2013 [34]. Following these rules (we referredto as commandments) we can systematically stress test SFP systems according to different key performanceindicators (KPIs) for different challenges. Our studies on large-scale stream processing are governed by thePCKS paradigm.

3.2.2 Eviction Strategies - The better alternative to load-shedding

Complex Event Processing systems have to define a scope for each of the operations they perform on the stream.Such operations are usually joins and aggregates (e.g. sum, average). The streaming nature of the data causesthe amount of data relevant for such an operation to be unknown a priori. As such, Complex Event Processingengines limit the scope of the operators to windows. These put constraints on the data which are consideredin-scope. An example was a window that constrains the number of data items considered to a certain movingtime interval. Results produced with data items that are no longer contained in that window are consideredout-of-scope and hence deleted. We refer to this process as garbage collection.

In case of bursts, however, windows have to either limit the number of data items directly or they have to dropdata items. In the first case the constraints may cause the recall (i.e. the number of correct results the systemfinds in relation to the total number of results) to drop dramatically. Assume, for example, a query that countsall those people who switched to channel x within the last two minutes. If we have, e.g. in the case of suddenbursts in the data, to limit the scope such that only data within a time window of a minute can be consideredwe will find no match at all.

Another solution to overcome this problem is load shedding. Following this strategy we have to drop data itemsat the input of the CEP system. We believe that this is an unnecessarily strong interference. Instead we proposeto drop variable bindings. These variable bindings are produced by every operator and sent to the followingoperator in the query tree. As such we hence propose to drop intermediate results, namely those that that areunlikely to lead to a match. We refer to the process of dropping variable bindings instead of data items aseviction as an alternative to load-shedding.4

We believe that eviction (and load-shedding, too) should depend on the matching likelihood of the variablebindings that are candidates for deletion. We therefore define a transactional closure which allows us tracingback all variable bindings a result emerged from. Based on these counts we can define a matching likelihoodfor each variable binding. We then drop those variable bindings that have lowest matching probability. Weapply this in different scenarios, considering purely locally decisions up to adding global constraints on thevariable bindings. Local strategies assume that each operator has a fixed number of variable bindings it canstore whereas global constraints allow to share memory between different operators.

First experiments on synthetic data and ViSTA-TV viewership data are encouraging. We found that for localeviction our likelihood-based approach always outperformed the deterministic alternative fifo (a first-in-first-out queue). The detailed report on our findings is currently under review for publication at the InternationalSemantic Web Conference 2013, the top-meeting for research in the Semantic Web.

3PCKS stands for Properties-Challenges-KPI-Stresstest4We can also consider eviction as a special case of load shedding, namely when dropping variable bindings for the input

components of the CEP engine. However, we prefer to distinguish between load-shedding and eviction, since they express twodifferent philosophies of dropping information.

10 ViSTA-TV

3.2.3 Workload Balancing

Systems that scale horizontally distribute their workload over several machines. The assignment of processingtasks to machines is referred to as scheduling. In terms of CEP we implement each algebra expression of thequery tree as a process of its own and execute several copies of such a process in parallel. Each of these copiesis executed on a separate task.

The tasks communicate to each other over channels. The topology of the tasks that implement a parallelprocessing of the algebra operations of a query is determined by two factors: First, the structure of the queryitself imposes constraints. For each two connected algebra expressions each task of the one has to be connectedto at least one task of the other and vice versa. Second, the data flow between processes may be partitioned byapplying grouping strategies. A selective grouping strategy, for example, partitions the data such that for twoconnected processes each task only sends data to exactly one task of the other process. Each connection hencehas a heavy but bundled workload. In contrast to that a random grouping strategy connects each task of theone process to each of the other. Each connection has a small workload as it is distributed over more channels.

In a distributed system, it is most desirable to send as little as possible messages over the network but sendas much messages as possible over the machines’ memory. Sending data over the network is slower due tolatency. As network channels are unreliable it further requires either a transactional data processing model orto be robust against transmission error such as missing data.

Using the Katts engine we performed a study on the SR Bench and the OpenGovernment datasets trying tominimize the number of messages sent between any two machines by applying graph partitioning. We foundthat in both cases the data flow was strongly partitioned. Applying a selective grouping strategy we found thatdistributing the workload by applying graph partitioning on the topology of tasks and processes it turned outthat we could reduce the number of messages sent over the network by 40% to 90%. As an surprising butwelcome side-effect the workload turned out the be evenly distributed over the machines. The detailed reporton our findings is currently under review for publication at the International Semantic Web Conference 2013,the top-meeting for research in the Semantic Web.

Future work will include experiments on the ViSTA-TV datasets based on the findings of the rules learning onthe features extracted from the input data. Since the experiments are in principle independent from the actualCEP engine used we also plan to implement a working scheduler for the Storm realtime processing frameworkin the scope of the project. This shall make the ViSTA-TV stream engine better scalable.


4 Feature Selection

For giving proper recommendations based on the EPG and user data we have to select the appropriate features.Based on these features we can then compute a model for predicting the users’ behavior. In close collaborationwith TUDo we therefore performed a preliminary study at UZH [12]. It had the following objectives:

� investigate the user and EPG data with regards to data formats and completeness,

� determine promising features that can be defined on the data, and

� test TUDo’s software for accessing data from Zattoo and the BBC.

4.1 Features

The primary goal of the study was to analyze features defined on the viewership and the EPG data. Thosefeatures include user sessions showing channel switching behavior, demographic information about the users, aswell as program-related information (EPG). Using Data Mining techniques, we derived models and found rulesand patterns in the dataset. In this project, we put special focus on the question which features can be used toexplain the success of a show in terms of popularity among the audience.

4.2 Data Quality

The data analysis is based on a dataset provided by Zattoo that encompasses user sessions and programinformation from the entire month of March 2012. Such features include for example the name of a program,its genre, the moment it was broadcasted, the number of spectators it has, the age of the users, the number ofminutes a user spent watching a program, etc. Those features were being extracted using a feature extractionsoftware developed at the Technical University of Dortmund (TUDo). For data analysis purposes, we used DataMining techniques (such as classification, subgroup analysis, etc.) and Data Minig software (RapidMiner).Initial investigations in the direction of multimedia feature analysis were dropped after disappointing results;the focus remained on textual features.

The results indicate that the features extracted from the datasets are indeed suited to assess the popularity of aTV program. The models and rules we derived from the dataset clearly indicate which features should be takenin account in order to build a recommendation engine. Besides, we were able—in cooperation with TUDo—tosuccessfully put into operation their newly developed streams framework for feature extraction on streams ofdata. Note that the actual feature extraction process (also for audio/video data) for the ViSTA-TV streamengine is described in deliverable report D2.2 in more detail [24].

12 ViSTA-TV

5 Show User Model

Discovering relationships between users and shows is key to recommendation and prediction. We would like todiscover the show groups that each user is associated with and likewise also discover the user groups associatedwith each show. The common methodology to achieve this is to use user ratings of programs and do somecollaborative filtering. Unfortunately, we do not yet have the user ratings for the shows. Hence, TUDo took adifferent approach to determine the user-show model which is detailed in Section 5.1.

5.1 Tag Clustering Model

Our experiments on finding frequent term sets (FTS), described in [23], though insightful were not sufficientby themselves. This is because FTS algorithms have two shortcomings:

1. They optimize criteria that lead to very bushy navigation structures.

2. The criteria in FTS clustering are fixed, implicit, and produce only one solution

In order to address these shortcomings we instead used the multi-objective frequent term set (MOFTS) or TagClustering (TaCl) approach introduced in [32]. This approach expresses the desired properties of FTS in termsof objective functions. In general, these objective functions are conflicting. This leads to the formulation ofFTS clustering as a multi-objective optimizaton problem. The optimization is solved by a genetic algorithm.The result is a set of Pareto-optimal solutions. TaCl uses the tags associated with the resources to generate theclusters. These tags are usually user provided. For example, in social bookmarking the users attach arbitrarytags to the urls, they are bookmarking, which are the resources.

The TaCl approach first uses known FTS algorithms like Apriori [5] or FP-Growth [20] to efficiently find the setof frequent sets that have a support, which exceeds a given minimal support. This frequent part is taken as astarting point for the clustering. The clusters formed are further optimized using multi-objective optimization.

In the ViSTA-TV context we have treated the shows as the resources. We then use the list of genres, bag ofwords from synopsis, people associated with each of the show or gender as the tags. Each user is associatedwith the union of set of all tags for all shows he has watched.

We have used the MOFTS implementation in RapidMiner [30]. The RapidMiner operator set up is shown inFigure 1.

Figure 1: RapidMiner Tag Clustering and Multi-Objective Optimization Setup

5.1.1 Genres as Tags

Our first experiment uses genres as tags. The inputs to the experiment are:


1. Genre tags per user as shown in Figure 2. That is, each row corresponds to one user. The tags in eachrow are generated by collating all the genres of all the shows that the corresponding user has watched forthe specific period for which the experiment is conducted.

Figure 2: Tags per User Data

2. Genre tags per show as shown in Figure 3. First column is show id, second column is show descriptionand the third column onwards are the tags. The tags are nothing but the genres that are associated withthe corresponding show.

Figure 3: Tags per Show Data

Figure 4 shows the Pareto front generated by the TaCl optimizer. Each red point on the Pareto front correspondsto a different cluster optimized for either child count or overlap.

Figure 4: Pareto front

Figures 5 and 6 show two clusters selected from the Pareto front. One cluster, shown in Figure 5, is chosenfrom the left side of the Pareto front curve which is optimized for higher child count. The other cluster, shownin Figure 6, is chosen from the middle of the Pareto front, which is optimized both for child count and overlap.

14 ViSTA-TV

Figure 5: Cluster optimized for higher child count and lower overlap

Figure 6: Cluster optimized for both child count and overlap

5.1.2 Credits as Tags

We then continued the experiment using persons associated with the show as tags. These persons could beactors in a movie or hosts of a talk show. The inputs to the experiment are:

1. Person tags per user as shown in Figure 7. That is, each row again corresponds to one user. The tags ineach row are generated by collating all the persons associated with all the shows that the correspondinguser has watched for the specific period for which the experiment is conducted.



2. Person tags per show as shown in Figure 8. First column is show id, second column is show descriptionand the third column onwards are the tags. The tags are nothing but the persons associated with thecorresponding show.


Figure 9 shows the Pareto front generated by the TaCl optimizer.


16 ViSTA-TV

Figures 10 and 11 show two clusters selected from the Pareto front. One cluster, shown in Figure 10, is chosenfrom the left side of the Pareto front curve which is optimized for higher child count and lower overlap. Theother cluster, shown in Figure 11, is chosen from the middle of the Pareto front, which is optimized both forchild count and overlap.

Figure 10: Cluster optimized for higher child count and lower overlap

Figure 11: Cluster optimized for both child count and overlap

5.1.3 Genre and Gender as Tags

We then continued the experiment using both the genre and gender associated with the show as tags. Theinputs to the experiment are:

1. Combined genre and gender tags per user as shown in Figure 12. That is, each row again corresponds toone user. The tags in each row are generated by collating all the genre and gender tags associated withall the shows that the corresponding user has watched for the specific period for which the experiment isconducted.



2. Genre and gender tags per show as shown in Figure 13. First column is show id, second column is showdescription and the third column onwards are the tags. The tags are nothing but the genre and genderassociated with the corresponding show. Since gender is inherently an attribute of the user here we haveassociated the gender with the show based on the genders of the users that watch the show.


Figure 14 shows the Pareto front generated by the TaCl optimizer.


Figure 15 shows clusters selected from the Pareto front for max child count.

18 ViSTA-TV

Figure 15: Genre Gender Clusters

From Figures 14 and 15 we see that the result is quite noisy. This is because there are more tags and hencemore frequent item sets. However, quite a few of the frequent item sets are redundant. MOFTS does notrecognize and handle the redundant frequent item sets. Hence, we used Krimp algorithm [37], which prunesfrequent item sets to select an optimal subset of orginal frequent items sets, that are guaranteed to cover thesame data.

Figure 16 shows the RapidMiner process that additionally uses the Krimp operator, implemented by TUDo(which is currently available as a plugin), for tag clustering.

Figure 16: RapidMiner Tag Clustering and Multi-Objective Optimization Setup with Krimp Frequent Item SetsPruning

Figures 17 and 18 show the tag clustering results after applying the Krimp operator. We can see that theredundancy in the results is substantially reduced.


Figure 17: Pareto Front with Krimp

Figure 18: Genre Gender Clusters with Krimp

5.1.4 Generating User Show Mapping

The nodes of the resulting clusters for all the optimal clusters on the Pareto front are written to a file by thePareto Front Writer operator shown in Figures 1 and 16. Figure 19 shows the Pareto front clusters file whereeach line corresponds to a cluster on the Pareto front for the genre and gender experiment. Note that only theleaf nodes of the cluster tree are written to the Pareto file, as they inherently include the parent nodes. So thefirst line of Figure 19 corresponds to the leaf nodes of the cluster shown in Figure 18.

20 ViSTA-TV

Figure 19: Pareto Front File Output

The nodes of the cluster, for example the cluster in Figure 18, are the tags by which the programs can begrouped together. Since we are interested in the maximum coverage of all the tags we take the Pareto frontcluster corresponding to the highest child count. All programs that contain the corresponding tags in eachcluster group, of the selected Pareto front cluster, fall in the same group or sub group. Once such programgroups have been formed we can use the user tag data to associate each user to these program groups.

The SUMEngine class in package ch.uzh.ifi.ddis.vistatv.streamengine.sum, is the show user mapping gener-ating process. It can be configured to any specific model by deriving the specific model from the commoninterface ShowUserModel, in package ch.uzh.ifi.ddis.vistatv.streamengine.sum. The TACLModel, in packagech.uzh.ifi.ddis.vistatv.streamengine.sum, implementing the tag clustering model described in this section, is onesuch specific model which derives from ShowUserModel. The SUMEngine simply runs the configured show usermodel.

The TACLModel, first generates the model when its init method is called. The model is generated by executingthe RapidMiner process TaclExperiment.xml which executes the process illustrated in Figure 16, including theKrimp operator, as a batch processs. The resulting model, that is, the Pareto cluster groups that are outputto the Pareto front file by the Pareto Front Writer operator are stored in the Cassandra [1] key value storageprovided by Rapid-I.

TUDo has written a client KeyValueStorage, in package ch.uzh.ifi.ddis.vistatv.streamengine.sum, that used theNetflix Cassandra Client [2], to read and write to the apache Cassandra database.

Once the model is generated the TACLModel can generate user↔show maps by first generating the programgroups based on the tags that form the model, and then associating the users to the program groups using thesame tags. Similarly, the user groups can be created from the tags and the programs associated with the usergroups using the common groups of tags.

Each day, the SUMEngine, loads the current day and the next weeks program schedule from the data warehouse.The next weeks schedule of programs is made available through the data warehouse, detailed in deliverableD3.2, by VUA. It then generates the user↔show mappings for all current users and the current and next weeksprograms based on the user↔show model generated by the TACLModel. The generated user↔show mappingsare also stored in the Cassandra database for use by the recommendation engine described in Section 6.


6 Recommendations

6.1 Show User Mapping Based Recommendation

TUDo has implemented a simple recommendations engine that is based on the availability of user↔showmappings. Currently the user↔show mappings are generated by the TACLModel in the SUMEngine, describedin Section 5.

The RecommendationsEngine class, in the package ch.uzh.ifi.ddis.vistatv.streamengine.rec, implements thesimple recommendations engine. The recommendations engine subscribes to the live program and viewershipdata. When a user logs in, the recommendation engine looks up the program mappings, from the Cassandradatabase, for that user that was generated by the SUMEngine. It then recommends these programs.

Similarly, when a program starts, the recommendations engine accesses the user groups who would be interestedin that program from the user↔show mappings. It can then recommend this program to those users.

6.2 Model-based Collaborative Filtering Recommendations

Beside the Tag Clustering Model, be also want to use a 2-way hierarchical agglomerative clustering method forrecommendations.

The method is based on the well-known agglomerative hierarchical clustering method, but also contains someinnovations roughly described below.

6.2.1 The Vista-TV Recommendation Problem

In ViSTA-TV we do not have ratings of shows by user so far. We only have viewing behavior. Therefore, wehave to estimate a rating from the viewing behavior.

In a first version we built the rates of a viewer for a show based on the percentage of the show she saw, i.e. ifa user saw 70% of a show this is taken as a rating 7 on a 1− 10 scale. If a user did not watch anything of (notzapped through) a show, this is taken as unknown.

For the future we will also try the following rules to improve the estimates:

� A viewer who continues seeing a show from the moment she switches in till the end of a show, likes theshow more than a viewer who views a higher percentage of the show but switches away before it ends.

� All shows transmitted while a user is online, that are not visited by this user get a "less liked" than anyshow visited (i.e. assuming a perfectly informed user).

� Only shows transmitted while a user is offline get an unknown rating.

Beside the ratings computed from the past viewing behavior we also have some background information aboutusers and (partially) quite detailed background information about shows. This is essential to overcome the cold-start problem for new shows and to a lesser extent for new users. For shows handling the cold-start problemis essential, as repetitions in TV are not the rule, but the exception, especially for non-movies. We have torecommend a show before or at the start of its transmission and not when it is finished.

This leads to a matrix sketched in Figure 20 as the base for model-learning. uA1, ... uAm represents them attributes of available user background knowledge, e.g. age, sex, country. iA1, ... iAl represents the lattributes of available show (item) background knowledge, e.g. the type of the show with values like Soap-Opera, Documentary, . . .. The 0.9 in the item1/user1 cell tells us that user1 saw 905 of show1.

22 ViSTA-TV

Our Recommendation Problem!•  User saw (or not) x% of a show!•  There is background knowledge about users (age, sex, loc., …)!•  There is background knowledge about shows (class, series, repeat)!⇒ Which users and which shows are (not) similar!⇒ Which user wants to see which new show!

Tree Talk: 21. Mar. 2013 2 Jörg-Uwe Kietz

item_1' item_2' ...' ...' ...' item_k'Soap' Crime' News' Docu' Nature' Talk' iA_1''' '' '' '' '' '' iA_2''' '' '' '' '' '' ...''' '' '' '' '' '' ...'

uA_1' uA_2' ...' ...' uA_m' '' '' '' '' '' '' iA_l'user_1' 35'm' D' '' '' 0.9''' '' '' '' 0.1'user_2' 25'f' CH' '' '' '' '' '' '' '' ''user_3' 75''' A' '' '' 0.1''' '' '' '' ''...' '' '' D' '' '' '' '' '' '' '' ''...' '' '' '' '' '' '' '' '' '' '' ''...' '' '' '' '' '' '' '' '' '' '' ''...' '' '' '' '' '' '' '' '' '' '' ''user_n' '' '' '' '' '' '' '' '' '' '' ''

Figure 20: The recommendation Problem

6.2.2 The Recommendation Model

An agglomerative hierarchical clustering method builds a model as shown in Figure 21. In 2-way clusteringsuch a model is built for users as well as for shows. Such a model-based recommendation method has a clearrecommendation-time speed advantage over the standard k-nearest neighbor method. Instead of having tocompare the current item to all n instances, a top-down classification of an item into a leaf only needs d ∗ bcomparisons. Usually d is much smaller than n for a balanced tree it is only d ≈ logbn, i.e. the hierarchicalclustering model serves as a logarithmic similarity-index over the instances.

Building a model not only has a speed advantage at recommendation time, it also used more of the availableinformation to recommend "cold-start"-items, e.g. new shows. A new show has by definition no ratings, assuch any similarity measure used by k-NN, cannot use any of the ratings known for previous shows, when ittries to find the most similar previous shows. The k found nearest neighbors are therefore most likely verydivergent on their rating (nothing enforces them to be similar). However when a cluster is built this cluster isbuilt on all available information, shows in a cluster are therefore not only similar with respect to the backgroundinformation, but also similar with respect to the ratings. If a new show is classified into a cluster, it thereforegets a more similar rating-set and not a divergent one.

Hierachical Clustering for Scalability!

Tree Talk: 21. Mar. 2013 Jörg-Uwe Kietz 4

7/30/2009

16

Interpreting Dendrograms

The TREE Procedure

The TREE procedure produces a tree diagram, also known as a dendrogram or phenogram usingalso known as a dendrogram or phenogram, using a data set created by the CLUSTER or VARCLUS procedure. The CLUSTER and VARCLUS procedures create output data sets that contain the results of hierarchical clustering as a tree structure. Th TREE d th t t d t t tThe TREE procedure uses the output data set to produce a diagram of the tree structure in the style of Johnson(1967), with the root at the top.

A hierarchical Clustering is a similarity index over the instances Query time inference drops from n to d*b per user

d

n Ideally n >> d, i.e. for a balanced clustering d = logb n

b

Figure 21: Hierarchical clustering

TV has developed into many channels with 24/7 program and people can watch only a small amount of it.Therefore the rating matrix is sparsely populated. To counter this sparsity we used a unique possibility ofagglomerative clustering. When agglomerative clustering found two clusters to merge it does this and for e.g.


geometric distance the result would look like shown in Figure 22. This merged cluster has a reduced sparsitycompared to the original clusters. In 2-way clustering the examples of one way are the attributes of the otherway. The main innovation of our method is that we are able to switch the way (user/shows) after each merge. Ifwe merged two users during user clustering and then switch to show-clustering we not only reduced the numberof attributes we also gained a less sparse user-attribute for show clustering. After we merged two shows andswitch to user clustering we gained a less sparse show attribute.

2-way Agglomerative Clustering for Sparsity!•  Whenever items are clustered together they are

replaced by their merged item!•  Whenever users are clustered together they are

replaced by the merged user!•  Alternate the agglomeration of users and items!⇒ Sparsity is reduced!⇒ This seems to be a new idea (not found in

literatur)!

Tree Talk: 21. Mar. 2013 Jörg-Uwe Kietz 6

Sparsity'itemC1' 8.0''' 7.0''' 9.0' 0.0''' '' 8.0' 8.0''' 8.0''' '' '' '' 1.0' 42.11%'itemC2' 7.0' 5.0' 6.0' 6.0''' 1.0' 3.0' 3.0''' '' '' '' '' 9.0''' '' '' 42.11%'

merged' 7.5' 5.0' 6.5' 6.0' 9.0' 0.5' 3.0' 3.0' 8.0' 8.0''' 8.0''' 9.0''' '' 1.0' 68.42%'

i1' i2' mCi'1' 1' 1'

'' 2' 2'2' 2' 2'

'' 2' 2'3''' 3'4''' 4'

'' 2' 2''' 2' 2''' '' '''' '' '''' '' '''' '' '''' '' '''' '' ''

Figure 22: Use of clusters to merge attributes

There are many well-know similarity measures, but not many can deal well with mixed nominal and numericattributes and not many can deal well with sparse data. One of the few measures that can be used in bothcases is the combined COBWEB/CLASSIT Category Utility [19]. Category Utility is designed for clustering andoptimizes the predictive power of all attributes given class membership. For nominal attributes it is defined as

UCo =

I∑i=1

Ji∑j=1

P (Ai = Vij)2.

Here I is the number of nominal attributes, Ji is the number of different values for attribute Ai and Vij arethe different values, P (Ai = Vij) is the probability that Ai has the value Vij for the members of the class. Fornumeric attributes it is defined as

UCl =

K∑i=1

1

σi.

Here K is the number of numeric attributes and σi is the standard deviation of the ith attribute and 1σi

isproportional to the error of the average value as prediction for this attribute (assuming normal distribution).

6.2.3 Scalability of Model-building and Quality of the Model

The main problem of agglomerative clustering is the effort of model-building. In general it needs n2 comparisonsto find the best two clusters to merge for each step and there are n steps. The n2 comparisons however canbe cached and easily updated for each step. This is a little bit more effort with the attribute update at eachswitch between user and show clustering, but still it saves a lot of comparisons. In [10] the authors show thatfor large sparse datasets clever indexing can lead to nearly constant effort proposing the most similar pairs thatshould be clustered. We combined these two approaches and produced a clustering that in first experiments ongrouplens data produced a linear scale on larger datasets (see Fig 23).5

5http://www.grouplens.org/node/12

http://www.grouplens.org/node/12

24 ViSTA-TV

Klassenbildung sinnvolle Ergebnisse ausgibt. Es können Personen-Klassen gefunden wer-den, die Zuschauer mit ähnlichen Berufen oder ähnlichem Alter verbinden, aber auchFilm-Klassen, die ähnliche Filme zusammenfassen. Mittels einer systematischen Unter-suchung mithilfe von Versuchspersonen könnten weitere Aussagen über die Güte derEmpfehlungen gemacht werden.

4.3. Laufzeitverhalten der KlassengenerierungUm die Skalierbarkeit des präsentierten Klassengenerierungverfahrens abzuschätzen wur-de die benötigte Laufzeit (Echtzeit) der Klassengenerierung für unterschiedlich grosseDatensätze mit dem Unix-Kommando time gemessen (siehe Abbildung 5). Während dieLaufzeiten für Datensätze im Grössenbereich von 1000 bis 100’000 Bewertungen nicht li-near ansteigen, werden die Messungen für die Datensätze im Grössenbereich von 100’000bis 1 Mio. Bewertungen mit einer linearen Regression sehr exakt erklärt (R2 = 0.9998).

A

!B

!

y"="0.0217x"*"116.38"R²"="0.98449"

y"="9E*08x2"+"0.013x"+"12.421"R²"="0.99861"

0"

500"

1000"

1500"

2000"

2500"

0" 20" 40" 60" 80" 100" 120"

#me&ne

eded

&for&clustering&

[sec]&

y"="0.0013x"*"95.026"R²"="0.9998"

0"

200"

400"

600"

800"

1000"

1200"

1400"

0" 200" 400" 600" 800" 1000" 1200"

#me&ne

eded

&for&clustering&

[min]&

number&of&ra#ngs&(in&thousands)&

Abbildung 5: A: Laufzeitverhalten des Klassengenerierungalgorithmus. Verwendete Sys-teme: (A) Prozessor: 2.4 Ghz Core i5, DualCore, 4 Threads; Arbeitsspei-cher: 8 GB 1067 MHz DDR3. (B) Prozessor: 3.07 Ghz Core i7, QuadCore,8 Threads; Arbeitsspeicher: 8 GB 1333 Mhz DDR3.

5. Fazit und AusblickWir präsentierten ein Empfehlungssystem basierend auf einem hierarchischen, agglome-rativen Klassenbildungsverfahren das die Cobweb-Algorithmen und das Ähnlichkeits-mass der Category Utility verwendet. Die implementierte Update-Funktionalität (2-wayclustering) führte zu besseren Ergebnissen, als die Klassenbildung ohne Übertragung vonKlasseninformationen. Die zwei generierten Klassenhierarchien ermöglicht ausserdem so-wohl eine Benutzer- als auch Inhalts-fokusierte Empfehlungsgenerierung. Die Evaluati-

14

Figure 23: Scalability of the clustering method

In Figure 24 we compared the quality of ratings produced by our method to the well known recommenderapproaches of k-NN and Slope in the standard setting for this data set, i.e. no cold-start items. As a preliminaryresult we can note that our method produces comparable results even in a setting it was not designed for andupdating of attributes during the 2-way clustering improves the quality of recommendations.

Approach MAE RSMERandom 3.762 4.605Global Average 2.066 2.462AggloRec without Updater 1.981 2.525AggloRec with Updater 1.794 2.266K-Nearest-Neighbour (k=60, user-k-nn) 1.602 2.033Slope One 1.518 1.929

Figure 24: Recommendation Error (Mean Absolute Error and Root Mean Squared Error) for 1 − 10 ratedgroup-lens data set

6.2.4 Outlook on current and future work

Experiments with the ViSTA-Data have just been started. For the summer we plan a project-meeting of UZH andTUDo to reach a stronger integration with the SUM model. We expect that the method is able to demonstrateits strength in the cold-start setting and we also expect qualitative interesting clusters for our content partners.


7 Conclusion

Based on the work done for the dummy recommendations engine we implemented the three components ofthe recommendations engine: (1) the Complex Event Processing engine, (2) the Show-User Model, and (3)the actual Recommender Engine. All components work in a streaming manner but are not yet fully optimizedfor working in real-time. All of them were built in compliance with the ERC Grant Agreement—Annex I—Description of work (DOW).

The focus on research for making components more suited for real-time resulted in one paper published atESWC 2013. We were able to submit two further papers to ISWC 2013. All papers focused on Complex EventProcessing. We are confident that the ongoing studies which base on the aforementioned ones will result infurther high-quality publications at scientific conferences and/or journals.

Research on recommendations is still ongoing and we intend to publish our findings early in the following projectperiod. The focus on the IBC showcase caused the recommendations to be available in the engine but not asthe most prominent feature. This will change in the following project period at the end of which we will havethe recommendations engine a first-class citizen among the viewership statistics component.

26 ViSTA-TV

References

[1] Apache Cassandra.

[2] Netflix Cassandra Client.

[3] ViSTA-TV D3.2 - Integrated Stream Engine. Technical report, The ViSTA-TV Consortium, 2013.

[4] Evrim Acar, Seyit Çamtepe, and Bülent Yener. Collective Sampling and Analysis of High Order Tensorsfor Chatroom Communications. In Sharad Mehrotra, Daniel Zeng, Hsinchun Chen, Bhavani Thuraising-ham, and Fei-Yue Wang, editors, Intelligence and Security Informatics, volume 3975 of Lecture Notes inComputer Science, pages 213–224. Springer Berlin / Heidelberg, 2006.

[5] R Agrawal and Srikant R. Fast Algorithms for Mining Association Rules. In Proceedings of the internationalconference on very large data bases, 1994.

[6] Darko Anicic, Paul Fodor, Sebastian Rudolph, and Nenad Stojanovic. EP-SPARQL: a unified languagefor event processing and stream reasoning. In Sadagopan Srinivasan, Krithi Ramamritham, Arun Kumar,M. P. Ravindra, Elisa Bertino, and Ravi Kumar, editors, Proceedings of the 20th international conferenceon World wide web - WWW ’11, pages 635–644, New York, NY, USA, 2011. ACM.

[7] Arvind Arasu, Shivnath Babu, and Jennifer Widom. The CQL continuous query language: semanticfoundations and query execution. The VLDB Journal, 15(2):121–142, July 2005.

[8] Arindam Banerjee, S Basu, and S Merugu. Multi-way clustering on relation graphs. SDM. SIAM, 2007.

[9] Davide Francesco Barbieri, Daniele Braga, Stefano Ceri, Emanuele Della Valle, and Michael Grossniklaus.C-SPARQL: A Continuous Query Language for RDF Data Streams. International Journal of SemanticComputing, 4(1):3–25, 2010.

[10] Roberto J. Bayardo, Yiming Ma, and Ramakrishnan Srikant. Scaling up all pairs similarity search. InProceedings of the 16th International Conference on World Wide Web, pages 131–140, Banff, Canada,2007.

[11] Daniel Billsus and Michael J Pazzani. Learning Collaborative Information Filters. In ICML ’98 Proceedingsof the Fifteenth International Conference on Machine Learning, pages 46 – 54, 1998.

[12] Kevin Caluser and Priscila Rey. Analyzing Audience Measurements on Streams of IPTV Meta Data.Technical report, Universtiy of Zurich, Department of Informatics, 2012.

[13] Sirish Chandrasekaran, Owen Cooper, Amol Deshpande, Michael J. Franklin, Joseph M. Hellerstein, WeiHong, Sailesh Krishnamurthy, Sam Madden, Vijayshankar Raman, Fred Reiss, and Mehul A. Shah. Tele-graphCQ : Continuous Dataflow Processing for an Uncertain World +. In Michael Stonebraker, Jim Gray,and David DeWitt, editors, CIDR 2003, First Biennial Conference on Innovative Data Systems Research,Asilomar, CA, USA, January 5-8, 2003, Online Proceedings. www.crdrdb.org, 2003.

[14] Graham Cormode and Marios Hadjieleftheriou. Methods for finding frequent items in data streams. TheVLDB Journal, 19(1):3–20, December 2010.

[15] Gianpaolo Cugola and Alessandro Margara. Processing flows of information. ACM Computing Surveys,44(3):1–62, June 2012.

[16] Yanlei Diao, Neil Immerman, and Daniel Gyllstrom. Sase+: An agile language for kleene closure over eventstreams. Technical report, University of Massachusetts Amherst, Department of Computer Science, 2008.

[17] Oliver Flasch, Andreas Kaspari, Katharina Morik, and Michael Wurst. Aspect-based tagging for collabora-tive media organization. In From Web to Social Web: . . . . 2007.

[18] BCM Fung, Ke Wang, and Martin Ester. Hierarchical document clustering using frequent itemsets. InProc. SIAM International Conference on Data Mining 2003 (SDM 2003), 2003.

[19] John H. Gennari, Pat Langley, and Doug Fisher. Models of incremental concept formation. ArtificialIntelligence, 40(1-3):11–61, 1989.


[20] J Han, J Pei, and Y Yin. Mining Frequent Patterns Without Candidate Generation. In Proceedings of theACM SIGMOD international conference on management of data, 2000.

[21] Thomas Hofmann. Latent semantic models for collaborative filtering. ACM Transactions on InformationSystems, 22(1):89–115, January 2004.

[22] Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems.Computer, pages 42–49, 2009.

[23] Yamuna Krishnamurthy. Frequent Item Sets. Website, 2012.

[24] Yamuna Krishnamurthy and Christian Bockermann. ViSTA-TV D2.2 - Offline Feature Extraction, 2012.

[25] Danh Le-phuoc, Minh Dao-tran, Josiane Xavier Parreira, and Manfred Hauswirth. A Native and AdaptiveApproach for Unified Processing of Linked Streams and Linked Data. In Lora Aroyo, Chris Welty, HarithAlani, Jamie Taylor, Abraham Bernstein, Lalana Kagal, Natasha Noy, and Eva Blomqvist, editors, TheSemantic Web – ISWC 2011: 10th International Semantic Web Conference, Bonn, Germany, October23-27, 2011, Proceedings, Part I, volume 7031 of Lecture Notes in Computer Science, pages 370–388.Springer Berlin / Heidelberg, 2011.

[26] Danh Le-phuoc, Minh Dao-tran, and Minh-duc Pham. Linked Stream Data Processing Engines : Factsand Figures. In The Semantic Web - ISWC 2012: 11th International Semantic Web Conference, ISWC2012, Boston, MA, USA, Nov 12-14, 2012, Proceedings, volume 1380, pages 1–12, 2012.

[27] YR Lin, J Sun, and P Castro. Metafac: community discovery via relational hypergraph factorization. InKDD ’09 Proceedings of the 15th ACM SIGKDD international conference on Knowledge discovery anddata mining, pages 527–536, 2009.

[28] Prem Melville, Raymond J Mooney, and Ramadass Nagarajan. Content-Boosted Collaborative Filter-ing for Improved Recommendations. In Proceedings of the Eighteenth National Conference on ArtificialIntelligence(AAAI-2002), Edmonton, Canada, July 2002, number July, pages 187–192, 2002.

[29] Ingo Mierswa, Katharina Morik, and Michael Wurst. Collaborative Use of Features in a Distributed Systemfor the Organization of Music Collections. In Shephard Shen and Liu Cui, editors, Intelligent MusicInformation Systems: Tools and Methodologies, pages 147–176. Idea Group Publishing, 2007.

[30] Ingo Mierswa, Michael Wurst, Ralf Klinkenberg, Martin Scholz, and Timm Euler. YALE: Rapid Prototypingfor Complex Data Mining Tasks. In Lyle Ungar, Mark Craven, Dimitrios Gunopulos, and Tina Eliassi-Rad,editors, KDD ’06: Proceedings of the 12th ACM SIGKDD international conference on Knowledge discoveryand data mining, pages 935–940, New York, NY, USA, August 2006. ACM.

[31] Raymond J Mooney and Loriene Roy. Content-Based Book Recommending Using Learning for Text Cate-gorization. In Proceedings of the Fifth ACM Conference on Digital Libraries, San Antonio, TX, June 2000,number June, pages 195–240, 2000.

[32] Katharina Morik, Andreas Kaspari, Michael Wurst, and Marcin Skirzynski. Multi-objective frequent termsetclustering. Knowledge and Information Systems, 30(3):715–738, July 2011.

[33] Thomas Scharrenbach and Christian Bockermann. ViSTA-TV D4.1 - Recommendations Engine DummyVersion. Technical report, The ViSTA-TV Consortium, 2012.

[34] Thomas Scharrenbach, Jacopo Urbani, Alessandro Margara, Emanuele Della Valle, and Abraham Bernstein.Seven Commandments for Benchmarking Semantic Flow Processing Systems. In Proc.ESWC 2013 (toappear), number 296126, pages 1–15, 2013.

[35] Andrew I Schein, Alexandrin Popescul, Lyle H Ungar, and David M Pennock. Methods and Metrics forCold-Start Recommendations. In Proceedings of the 25th Annual International ACM SIGIR Conference onResearch and Development in Information Retrieval (SIGIR 2002)., 2002.

[36] Walter F Tichy, Paul Lukowicz, Lutz Prechelt, and Ernst A Heinz. A Quantitative Evaluation Study inComputer Science :. Journal of Systems and Software, 28(1):9–18, 1995.

[37] Jilles Vreeken, Matthijs Leeuwen, and Arno Siebes. Krimp: mining itemsets that compress. Data Min.Knowl. Discov., 23(1):169–214, 2011.

28 ViSTA-TV

[38] Jacques Wainer, Claudia G. Novoa Barsottini, Danilo Lacerda, and Leandro Rodrigues Magalhães deMarco. Empirical evaluation in Computer Science research published by ACM. Information and SoftwareTechnology, 51(6):1081–1085, June 2009.

[39] Ying Zhang, Pham Minh Duc, Oscar Corcho, and Jean-paul Calbimonte. SRBench : A Streaming RDF/ SPARQL Benchmark. In Philippe Cudré-Mauroux, Jeff Heflin, Evren Sirin, Tania Tudorache, JérômeEuzenat, Manfred Hauswirth, Josiane Xavier Parreira, Jim Hendler, Guus Schreiber, Abraham Bernstein,and Eva Blomqvist, editors, The Semantic Web - ISWC 2012: 11th International Semantic Web Conference,ISWC 2012, Boston, MA, USA, Nov 12-14, 2012, Proceedings, volume 7649 of Lecture Notes in ComputerScience, 2012.

D4.2 Recommendations Engine Offline Version

Documents

Transcript of D4.2 Recommendations Engine Offline Version