Exploiting the rich traces of users' Web interaction promises to enable cross-application user modeling techniques, which is in particular interesting for applications that have a small user population or that are used infrequently. In this paper we present a framework for the e ective interchange of user pro les. In addition to derivation rules for user pro le reasoning, the framework employs exible mash-ups of RSS-based user data streams for combining heterogeneous user data in a Web 2.0 environment.
With the increased use of search engines, e-commerce systems and social
networking sites { with famous examples such as Amazon, Facebook, Flickr,
Delicious and Google { user modeling and Web personalization has evolved from a
rather marginal activity to a mature technology that is exposed to the majority
of Web users on a daily basis. Most techniques are based on collaborative
ltering and social network analysis [
Apart from the major players in the eld, many systems cannot boast on a large user base. These systems vary from startups to well-established sites that serve a specialized audience. As an example, e-learning systems inherently have a limited audience, in particular if the system is speci cally used by one institution. For these stakeholders, it would be bene cial to have user pro le information from other applications. Recent research suggests that, if carefully designed and tested, heterogeneous types of data can be used for reliably classifying users [3, ?]. Other motivations for cross-application user modeling include the synchronization of recommendations and user interaction between applications and better support of user migration.
Obviously, the idea of cross-application user modeling is not new. In the
1990s several generic user modeling servers have been developed, to be used by
a wide range of applications (for example [
New trends from the Web 2.0 as well as the related work, as will be discussed in Section 2, motivate an infrastructure for cross-application user modeling. This infrastructure, which we introduce in Section 3, is heavily inspired by social networking approaches and is based on the assumption that adaptive systems (or rather the system administrators) themselves are the ones who know best what the system needs. The infrastructure relies on the brokerage of user models, with system administrators searching, discussing, adopting, rating and recommending third parties' user models. Section 4 outlines how to use the framework to reason on distributed user pro les and demonstrates how user pro les can be mashed-up by combining RSS feeds in so-called user pipes. 2
As described in Tim O'Reilly's Web 2.0 design patterns [
For the exchange and interpretation of user pro le data, common semantics
user pro le statements are needed [
As a further development, we can see a shift from author-prede ned
adaptation rules to collaborative ltering techniques and the use of Web 2.0 interaction
mechanisms [
In essence, there are two ways to ensure interoperability between two adaptive
systems and their user models. The rst approach involves a lingua franca, an
agreement between all parties on a common representation and semantics [
user model servers have never gained wide acceptance. An alternative approach, which is more exible, involves conversion between the di erent systems' user models.
Conversion allows for exible and extensible user models, and for systems to
join into a platform. Moreover, in contrast to a xed lingua franca approach,
conversion is suitable for `open-world user modeling', which is not restricted to
one speci c set of systems [
As pointed out by [
Results from the preceding section provide support for the exchange of user models between applications. From the related work we have seen that incorporating user pro le information from other contexts is not a straightforward process, though. The poor take-up of the generic user modeling servers, developed in the 1990s, suggests that a centralized approach, with prede ned ontologies, does not cater the needs of the multitude of adaptive systems, which are very heterogeneous in nature.
Based on the above, we designed a framework that facilitates the brokerage of user pro le information and user model representations. This framework, which we call the Grapple User Modeling Framework (GUMF), is designed to meet the following requirements. First, various types of systems should be able to connect to the framework. Further, the framework should provide a exible user model format that allows for new types of statements and derivation rules. Su cient metadata should be given to indicate its origin, contents and validity. The browsing and searching of user data or model extensions, provided by the connected systems, should be supported by rating mechanisms. As several systems may provide competing models of, for example, user interests, and as the quality of these models can vary signi cantly it is important that a system
Add-On
Functionality Adaptive System 1
Adaptive System 2
Core Ontology
Universal Reasoners
Event
Loggers UM 1
User Modeling Broker manage explore
providdaeta UM 2 ery ta qu da Third-Party UM
UM 3
Registered Systems Available UM Data Ontology Extensions
User Events
UM Editors Browsing, Rating administrator (i.e. a user of the framework) can take a motivated decision which alternative is most suitable for his personalization purposes.
The core element of the framework can be considered a broker, which provides the means for other systems to share and make use of their user data. In this section we provide an overview of the elements that are needed for setting up this framework.
In Figure 1, a generic overview of the GUMF architecture is depicted. The central element of the framework is the Grapple User Modeling Broker (GUMB), which manages the communication between the connected systems. The broker keeps track of the registered systems, the available user model data and ontology extensions. Further, it keeps a centralized repository of user events. The framework provides Web-based administrative interfaces for managing the system con guration and for exploring the available user data streams, reasoning mechanisms and ontology extensions. The target audience of these interfaces consists of the administrators and programmers of client (adaptive) systems, in order to nd and incorporate suitable user data streams and to o er their own data streams. For most mapping, merging and reasoning tasks, administrators can utilize generic reasoning plugins (cf. Section 4) and hence generate user prole data in a format that perfectly t their applications' needs. For more speci c reasoning tasks, administrator can create own reasoning plugins an provide them to the GUMF community. Once con gured, the client systems can exchange user data without human intervention. The provision of data takes place in the form of statements, of which the structure is explained in more detail in Section 3.2.
The querying of user data { summarized in statements { is realized through three alternative interfaces. The RESTful interface provides a light-weight querying approach for retrieving statements that match a certain simple pattern. A more elaborate interface is provided by a SOAP interface, which is more exible, property description
ID The globally unique ID of the statement.
In the current version of the UM ontology we di erentiate between gc:Statement, type which is a basic user pro le statement, and gc:Observation, which is a specialization of gc:Statement and models a (user) observation made in some application. subject The entity (usually the user) the statement is about.
Refers to a property (of a domain ontology) that either characterizes the subject predicate (e.g. foaf:interest or k:hasKnowledge) or describes some action the subject has performed (e.g. nop:hasBookmarked or nop:hasClicked). object The value of the predicate (e.g. \ItalianFood" or dbpedia:semantic web). created Speci es when the statement was created. creator Refers to the entity that created the statement. In case of a gc:Observation it identi es the entity that reported the observation. temporal Allows to de ne temporal constraints on the validity of the statement. evidence If a statement was produced by a reasoning process then evidence can be used to show how the statement was deduced.
rating The rating of a statement indicates the level of trust in the statement. at the cost of a more complicated syntax and communication costs. A third interface allows applications to subscribe to an RSS-based data stream that matches a query, to be noti ed upon changes. The latter interface is particularly useful for event-driven personalization mechanisms, which depend on events in other
The GUMF architecture is inspired by the Personal Reader Framework [
The Grapple User Modeling Ontology speci es the lingua franca for exchanging
user pro le information and user observations in a User Modeling 2.0
infrastructure. It follows the approach of the General User Model Ontology [
In the example above, the subject (gc:user), predicate, and object refer to
entities that are not part of the Grapple Core ontology. gc:user identi es the user
Peter by referring to his FOAF pro le, which is a separate document located
at "http://www.peter.de/foaf.rdf". The value of the predicate is "foaf:interest".,
which is a property de ned in the FOAF ontology [
The de nition of "foaf:interest" gives us the actual meaning of the Grapple statement. The comment describes the semantics of the predicate, to be read by people that want to use the property. Making use of the de nitions of the domain and range, we can deduce that "http://www.peter.de/foaf.rdf#me" is of the type "foaf:Person", that "http://en.wikipedia.org/wiki/Italy" is a "foaf:Document" and that the predicate "foaf:interest" re ects `A page about a topic of interest to this person'. 4
The Grapple User Modeling Framework allows to dynamically utilize reasoning plugins to enable user pro le reasoning. In this section we present two generic solutions that can be utilized directly by the GUMF client applications: (1) a rather classical rule-based approach and (2) a novel approach, which we call User Pipes, that allows user pro le reasoning by mashing up di erent user prole data streams. However, client administrators can also create own reasoning plugins and share them with the community. A user interface within the client administrator backend allows to search for and publish own reasoning plugins. 4.1
Reasoning plugins are software components that can be integrated into the Grapple User Modeling Framework (GUMF). In general, they deduce new information about a user based on existing user pro le data or based on some observations. Reasoning plugins can come in di erent avors. For example, a plugin might gather and align user data from di erent social networking services in order to create a more comprehensive user pro le.
The rst generic reasoning plugin is rule-based and applies derivation rules, which can be de ned and adjusted by client applications. These derivation rules enable GUMF to generate new Grapple statements. Rules allow to express simple 2 More precisely, the ontology that is identi ed via foaf = http://xmlns.com/foaf/0.1/ types of inference in terms of premise-conclusion rules that derive new statements from the existence of other statements. These rules can, for example, (i) infer statements that embody new knowledge, (ii) they can be used to map between di erent ontologies or (iii) they describe how to solve problems where statements or rules con ict with each other. A simple derivation rule that infers new knowledge about a user might express the following: If a user has bookmarked a website that has topic t then the user is interested in t. Such a rule can, for example, simply be formulated as a SPARQL query: PREFIX foaf: <http://xmlns.com/foaf/0.1/> PREFIX gc: <http://www.grapple-project.org/grapple-core/> PREFIX gnop: <http://www.grapple-project.org/nop/> CONSTRUCT { gc:derivedStatement gc:derivedStatement gc:derivedStatement gc:user ?user . gc:predicate foaf:interest .
gc:object ?topic } WHERE { ?originalStatement ?originalStatement ?originalStatement ?document gc:user ?user gc:predicate gnop:hasBookmarked . gc:object ?document .
foaf:topic ?topic . }
A mapping rule could simply map one value to another value or it can compose a new value from other values or decompose one value in di erent separate values. Con ict resolution rules can be used to de ne preferences among di erent types of statements or preferences among di erent rules. 4.2
In addition to the rule-based approach described in the section above, GUMF enables deduction of user pro les also by mashing up di erent (user pro le) data streams in RDF or RSS-format by utilizing Semantic Web Pipes3 or Yahoo Pipes4. In this chapter, we focus on the processing of RSS data by utilizing Yahoo pipes as this enables the usage of a huge amount of structured data on the web. Di erent RSS streams are syndicated to so-called User Pipes.
How this works is shown by our GUMF demonstrator5. A speci c pro le stream searchedFor of the user fabian can be retrieved by requesting /user/fabian/predicate/searchedFor. An extract of the data stream is given as follows. <?xml version="1.0" encoding="UTF-8"?> <rdf:RDF ...> <channel rdf:about="http://semweb.kbs.uni-hannover.de:8082/grapple-umf/user/fabian"> <title>GUMF data stream matching the query 'user = fabian'</title> <link>http://semweb.kbs.uni-hannover.de:8082/grapple-umf/user/fabian</link> <items> <rdf:Seq> <rdf:li rdf:resource="http://semweb.kbs.uni-hannover.de:8082/grapple-umf/62715"/> <rdf:li rdf:resource="http://semweb.kbs.uni-hannover.de:8082/grapple-umf/63526"/> ...
</rdf:Seq> </items> </channel>
This data stream can be combined with other data streams to deduce new user pro le information. For example, it can be combined with information from the feed /user/fabian/predicate/interest to deduce whether the user's interests and search activities are thematically similar or it can even be mashed up with other RSS feeds from the Web.
To demonstrate how meaningful streams can be created by embedding pro le data from social networking sites, we created a simple user pipe6 that combines the search activity stream listed above with the latest bookmarks that the user created at Delicious7. Figure 2 shows the editor view of the user pipe. The given user pipe detects those keywords that a user applied for both search and tagging of his latest bookmarks, which is expressed via the following YQL query. SELECT title, link, description, subject, predicate, object FROM rss WHERE url in 6 Available at http://pipes.yahoo.com/userpipes/gumf showcase 7 http://feeds.delicious.com/v2/rss/fabianabel ('http://semweb.kbs.uni-hannover.de:8082/grapple-umf/user/fabian/predicate/searchedFor') AND object in (select category from rss where url in ('http://feeds.delicious.com/v2/rss/fabianabel') )
The result of the YQL query is then passed to a component that tries to map the detected keywords to Wikipedia articles that further explain the concepts that are referred by the keywords. In the last stage, an Item Builder component is used to generate new Grapple statements. Similar to the example in Section 3.2, the above item makes use of the FOAF vocabulary (foaf:interest ) to express that the user is interested in http://en.wikipedia.org/wiki/Trento (cf. bottom of Fig. 2): <?xml version="1.0" encoding="UTF-8"?> ... <item rdf:about="http://www.grapple-project.org/umf/1215715049-14264674241239174361456"> <title>http://en.wikipedia.org/wiki/Trento</title> <gc:subject>http://fabian.myopenid.com</gc:subject> <gc:predicate>http://xmlns.com/foaf/0.1/interest</gc:predicate> <gc:object>http://en.wikipedia.org/wiki/Trento</gc:object> <gc:creator>http://pipes.yahoo.com/userpipes/gumf_showcase</gc:creator> </item> ...
The bene t of the user pipe approach is that user pipes result in user pro le streams that can again be used by other pro le reasoners, which allows for exible and extensible user pro le reasoning. For publicly available data streams it is also possible to directly use the Yahoo Pipe editor, which provides an easy dragand-drop user interface to process, combine, and perform various operations on data streams. This means that not only programmers or experts familiar with SPARQL or rule-based languages are enabled to create pro le reasoners, but also leisure user as they can create such reasoners (user pipes) visually.
The critical point of this approach is the immensely huge amount of RSS
data on the Web that could slow down the processing of a pipe. Therefore, we
are going to explore caching strategies (e.g. the precompute pipes regulary and
deliever the cached results) as proposed in [
In this paper we motivated and introduced a framework for cross-application user modeling. Based on several pieces of earlier work, the framework provides a domain-independent, decentralized approach for combining several user models. In a collaborative manner, the connected systems can create, share, select, mashup, adopt and rate their user models, supported by a basic infrastructure that includes search and browse facilities, editors and universal reasoning mechanisms.
Although the framework provides the basic infrastructure for cross-application modeling, its success depends on the take-up by a critical mass and the availability of the necessary tools. In the GRAPPLE project, we are currently integrating the framework, to be used by a number of di erent e-learning systems. By evaluation and experimentation, we expect to nd additional requirements and success factors for building an ecology of adaptive systems that exchange parts of their user models. Acknowledgements The work presented in this paper has been sponsored by the EU FP7 STREP Project GRAPPLE.