Over the last years adaptive Web personalization has become a widespread service and all the major players of the WWW are providing it in various forms. Ephemeral personalization, in particular, deals with short time interests which are often tacitly entailed from user browsing behaviour or contextual information. Such personalization can be found almost anywhere in the Web in several forms, ranging from targeting advertising to automatic language localisation of content. In order to present personalized content a user model is typically built and maintained at server-side by collecting, explicitly or implicitly, user data. In the case of ephemeral personalization this means storing at server-side a huge amount of user behaviour data, which raises severe privacy concerns. The evolution of the semantic Web and the growing availability of semantic metadata embedded in Web pages allow a role reversal in the traditional personalization scenario. In this paper we present a novel approach towards ephemeral Web personalization consisting in a clientside semantic user model built by aggregating RDF data encountered by the user in his/her browsing activity and enriching them with triples extracted from DBpedia. Such user model is then queried by a server application via SPARQL to identify a user stereotype and nally address personalized content.
Personalization is one of the leading trends in Web technology today and is rapidly becoming ubiquitous on the Web. Most of the times the process is evident, for instance when web sites require their users to sign in and ask for their preferences in order to maintain accessible and persistent user pro les. But in other cases personalization is more subtle and it is hidden to the user.
Ephemeral personalization [
In this work, we propose another way to address ephemeral Web personalization. Our approach consists in collecting semantic metadata contained in visited web pages in order to build a client-side user model. Such model is then queried by content providers to identify a user stereotype and consequently recommend content. By doing this the user has total control over his/her user model and the content provider does not need to save and maintain user pro les, therefore privacy risks are signi cantly reduced.
Before proceeding forth into the technical matter we would like to point out that our approach heavily relies on the availability of semantic metadata embedded in Web pages: the more metadata available, the more detailed the user pro le, vice versa, if visited pages do not contain metadata, no user pro le can be built. Luckily, a huge number of Web sites actually provides semantic annotations, consisting of Microformats, Microdata, or RDFa data, mostly conformed to vocabularies such as Facebook's Open Graph protocol, hCard, and Schema.org.
The rest of the paper is organized as follows: in Section 2 we brie y introduce some related works; in Section 3 we present the proposed system; in Section 4 we illustrate our data model; in Section 5 we discuss some experimental results and, nally, in Section 6 we conclude the paper.
Several authors have already addressed the problem of generating,
parsing, and interpreting structured metadata embedded in Web sites.
Several metadata formats aimed at enriching Web pages with semantic data
have been proposed and adopted by a wide range of Web authors.
Microformats1 such as hCard, proposed in 2004, extend HTML markup with
structured data aimed at describing the content of the document they
are included in. Although similar under several aspects, Microformats are
not compliant with the RDF data model, which can be fully exploited
by using RDFa data. Facebook's Open Graph Protocol 2, is an RDFa
vocabulary proposed in 2010 and has become extremely widespread on
the Web due to the fact that it makes possible establishing connections
between Web contents and any Facebook user's social graph. However,
it also caused many concerns about its privacy and service-dependency
issues [19]. Another relevant format is schema.org 3, proposed in 2011
and supported by several major search engines such as Google, Yahoo,
Yandex, and Bing. Schema.org data can be expressed as RDFa or
Microdata, an HTML speci cation aimed at expressing structured metadata
in a simpler way than the one provided by Microfomats and RDFa.
The authors of [
Automatic metadata generation has been widely explored and can be
achieved in many ways: extracting entities from text [
Other authors have discussed how Semantic Web tools, such as
ontologies and RDF, can be used to model users' behaviours and preferences
in Recommender Systems [
and [
The problem of preserving users' privacy while providing personalized
content, presented in [16] and recently extensively surveyed in [
In order to support our claims, we developed an experimental system consisting in a client and a server module built using well-known open source tools such as Apache Jena and Semargl. Figure 1 shows the workow of the system. The basic idea behind our work is that user interests can be identi ed by observing browsing activity and by analysing the content of visited Web sites, thus our goal is to exploit the user himself as an intelligent Web crawler to provide meaningful data for building his/her personal pro le, therefore the project was named Users As Crawlers (herein UAC ). A compact OWL2 ontology, herein referred as UAC ontology, was developed as well in order to introduce new modelling primitives and to support classi cation of Web pages. Among others, the primitives de ned in the UAC ontology are: relatedTo, which associates Web pages with DBpedia entities named in the metadata, nextInStream, which associates a page with the next one visited by the user, and previousInStream, which is the inverse of nextInStream.
The client module handles user modelling: it includes three modules, a Metadata Parser, a Data Linker, a Reasoner, and a compact triplestore. The Matadata Parser reads the header sections of the visited web pages and extracts RDF triples from available RDFa metadata. Due
to its large availability, the preferred metadata format is OpenGraph RDFa, however other formats are allowed as well, as long as they can be converted into RDF. The Data Linker receives the collected triples as input and adds new triples by linking visited pages with DBpedia entities. This task is accomplished by both expanding URIs pointed by object properties and by analysing the content of datatype properties such as tag, title, and description in order to nd possible matches with DBpedia entries. A list of stopwords and a POS Tagger are used by the Data Linker to identify meaningful sequences of words to be matched against DBpedia. Finally, the augmented set of triples is processed by a Reasoner module, performing logic entailments in order to classify visited pages according to the Oper Graph protocol, the DBpedia ontology, and the UAC ontology. In our prototype the reasoning task is performed by the OWL Lite Reasoner that comes bundled with Apache Jena, but any other OWL Lite or DL reasoner (e.g: Pellet) could t as well. The result of this process is a RDF user model, built incrementally as the user visits Web pages, in which visited pages are classi ed by rdf:type properties and have a hopefully high number of semantic properties linking them each other and to DBpedia. In our prototype system the client is a standalone application, however, in a production scenario it could be a Web browser plug-in, in order to incrementally build the user pro les as pages are downloaded by the Web browser. Since the client contains the user model, it also allows control over it: the user can decide which pages to be included in the model and whether to maintain crawled data or not between di erent browsing sessions. Moreover, the user model can be exported at any time to a RDF-XML le to be inspected; though currently the client has no user model visualization module, several visualization and editing tools are available, such as Protege5. The server part of the system is designed to simulate a content provider scenario and consists in two modules, a Semantic Recommender, a User Inquirer, and a content repository. The goal of the server is to identify a user stereotype in order to suggest to the user a relevant content, but instead of maintaining user pro les in a repository, it just \asks" to connected clients if their user models have some characteristics, much like the Guess Who game. Since all the user modelling duties are left to the client, the server module is particularly lightweight and, therefore, we de ned it a thin server to emphasize the role reversal with respect to the traditional Web personalization approach. We assume each content to be addressed towards a speci c user stereotype, which is a realistic assumption since many e-commerce companies already perform market segmentation analysis. We exploit such knowledge in order to map user characteristics into a speci c stereotype and therefore contents to be recommended. More speci cally, in our current experimental system we use a decision tree for classifying the user, as shown in Figure 2. Each node is associated with a speci c SPARQL query and each arc corresponds to a possible answer to the parent node's query. Stereotypes are identi ed on the leaves of the tree. When a client connects, it receives the SPARQL
query associated with the root node in order to check whether a speci c 5 http://protege.stanford.edu/ characteristic is present in the user model. The Semantic Recommender module handles the client's answer to the query and when it receives a positive answer fetches content or, if the answer is negative, further queries are proposed until a user stereotype can be identi ed. Due to the hierarchical nature of the decision tree, we expect the number of queries to be asked to the client to be very small: indeed, in our experimental setting in the worst case six queries were needed. In order to preserve users' privacy, the server does not have full access to user RDF data: though any SPARQL query is allowed, the client returns only the number of Web pages matching the query, therefore their URIs are unknown to the server. 4
In order to better present our user modelling technique, in this section we are showing a step-by-step example of what the proposed system does when a Web page is visited. In this example we are considering a randomly chosen Rottentomatoes.com page and in Figures 3, 5, and 6 extracted and inferred data are shown in the RDF-XML syntax. As the page is loaded, the Metadata Parser retrieves the available RDFa matadata. Metadata commonly embedded in Web pages actually provide a very shallow description of the page's content: the Open Graph protocol itself speci es only four properties as mandatory (title, image, type, and url ) and six object classes (video, music, article, book, pro le, and website). However, these information constitutes a good starting point, especially when a few additional, but optional, properties (e.g.: description, video:actor, and article:tag ) are also speci ed, which can provide URIs of other entities or possible \hooks" to more descriptive ontologies. In Figure 3 is shown the metadata available in the Web page, including both mandatory and optional Open Graph properties. The next modelling step, performed by the Data Linker module, aims at enriching such data by linking the visited page to possibly related ontology entities. This step needs a reference ontology and we adopted a general purpose and freely available reference ontology, i.e. DBpedia. This choice is motivated by three factors: (i) in a realistic scenario it is impossible to restrict users' Web usage to a particular domain, (ii) authors may describe their contents in ways non compliant to a single taxonomy crafted by a domain expert, therefore, the ontology needs to be the result of a collaborative e ort, and (iii) since the modelling task is to be accomplished at clientside, we need a freely accessible ontology.
The Data Linker analyses the RDF data extracted from the pages in order to discover \hooks" to DBpedia, that are named entities present in DBpedia mentioned in the body of properties such as title or description. Such properties are analysed by means of stopwords removal and POS tagging to nd possible candidate entities; candidate entities are then matched against DBpedia entries to get the actual ontology entities. As shown in Figure 4, in our example the association between the value of the title property and the Mad Max DBpedia entity is trivial, since the value of the title property and the one of the rdfs:label property of the DBpedia entity are the same string. However there may be more complex cases: for instance the title \Annual Open Source Development Survey" can provide a hook for the Open Source entity.
Once these entities have been identi ed, they are linked to the Web page RDF representation with a relatedTo property, de ned in the UAC Ontology. An additional UAC property, prevInStream, containing a link to the page that precedes the considered one in the navigation stream, is added to the page data as shown in Figure 5. All the rdf:type, dc:subject, and db:type attributes of the linked DBpedia entity are then imported into the RDF user model, in order to provide further information about the contents of the page and to support the classi cation task. The nal step of the modelling activity is the classi cation performed asynchronously by the Reasoner, which integrates the data gathered in the previous steps with class and property axioms provided by the Open Graph protocol and by the UAC ontology. Due to its asynchronous nature, the Reasoner can also link a page to the one subsequently visited using the nextInStream property. The result, as shown in Figure 6, is, aside from the nextInStream property, a series of rdf:type properties which provide a classi cation of the visited page. For instance, in our example the entailed properties state that the URI http://www.rottentomatoes.com/ m/mad max/ corresponds to a Website, a Work (as de ned in DBpedia), and a Film. Such type properties are added to the RDF representation of the Web page, along with the crawled data and the DBpedia data generated in the previous steps, and stored in the user model.
The user model is built incrementally as Web pages are visited and can be queried at any time using the SPARQL query language. This choice allows the server to formulate an extremely wide range of queries, from very generic to utterly speci c, and to achieve an arbitrary level of detail in user stereotyping. For instance, the content provider may be interested in recommending just movies rather than books and, by asking for the Web pages with a rdf:type property set to \Film", it will detect, in our example, that the user visited a page about a movie. In another scenario, the content provider may be interested in determining exactly which kind of movie to recommend and by asking for all the Web pages related to a DBpedia entity with a dcterms:subject property set to \Road Movie" it will detect that the user visited a page about a road movie. Countless other examples are possible: for instance a content provider might be interested in knowing if the user has visited sequentially a given number of sites dealing with the same topic or if he/she has ever visited a page dealing with multiple given topics. 5
Formative tests were performed in order to evaluate the accuracy of the proposed method. In our experiment, we asked a number of volunteers (mostly university students) to let us use their browsing histories, in order to have real-world data. To avoid biases, browsing data was extracted only form sessions occurred in the ve days before the test was performed. All test subjects were completely unaware of the real purpose of the experiment. After supplying the data, volunteers were asked to review their own browsing history in order to identify di erent sessions and to point out what they were actually looking for. At the end of the interviews we were able to identify six user stereotypes, much like market analysts do when performing segmentation analysis. Since we had no real content to provide in this experiment, we only classi ed users. The six identi ed stereotypes are: (i) people mostly interested in economics (nicknamed business ), (ii) mostly interested in courses, seminars, summer schools, and other educational events (student ), (iii) mostly interested in lms and tv series (moviegoer ), (iv) mostly interested in music (musician), (v) mostly interested in videogames (gamer ), and, nally, (vi) people whose main interests are hardware, programming, and technology in general (techie). Four iterations of the data gathering and testing process were performed, each time with di erent volunteers, in order to incrementally build a data set and to evaluate our approach with di erent users with di erent browsing habits and di erent size of the training set. In the rst iteration 36 browsing sessions were collected and labelled, in the second 49, in the third 69, and in the fourth 82.
All RDFa data included in the Web pages visited by our test users was considered and used by our test prototype to build a RDF user model for each browsing session. Over the three iterations, the average number of Web sites visited in a single browsing session was 31.5 and the average number of RDF triples extracted from a browsing session after the Data Linker performed its task was 472.8, that is an average 15 triples per page, which actually provides a signi cant amount of data to work on.
During each iteration of the evaluation, the rdf:type properties of the visited Web pages were considered as features and used to train a Decision Tree. In this experiment the J48 algorithm [15] was used; in Figure 7 we show an example of a generated tree, built during the third iteration. The nodes of the tree were then replaced with SPARQL queries and then this structure was used to classify a number of user models. Due to the shortage of test data, a ten-fold cross validation approach was used to esteem the accuracy of the system. Table 1 shows the results of the classi cation over the four iterations of the data set. Our system was compared with the ZeroR predictor, which always returns the most frequent class in the training set in order to have a baseline. For this formative experiment, only the precision metric (de ned as the number of correctly classi ed sessions over the total number) was considered. Though precision values are not very high, it is important to point out two limitations of the performed tests: the number of considered browsing sessions is extremely low, due to the fact that only a handful of volunteers let us analyse and use freely their browsing history data; in fact many volunteers dropped out as soon as they realized that their actual browsing history and not some laboratory activity was needed. Secondly, these results were obtained by considering only the rdf:type attribute as feature when building the decision tree. Evaluation and development are ongoing and further experiments, with more test users, more stereotypes, and a richer RDF vocabulary are planned. 6
In this paper we presented a new approach towards ephemeral personalization on the Web, relying on semantic metadata available on the web and, even though the presented results are still preliminary, the overall outcome is very promising. With the growth of the Web of Data, we expect in the next few years to be able to raise the average number of extracted triples from a browsing session and therefore build more detailed user pro les.
In our opinion this approach could t particularly well to the
application domain of targeted advertising because of three major advantages
over the actual cookie-based techniques: (i) our approach can recommend
novel contents related to current browsing context, rather than associate
a user with a set of already visited (and potentially disliked) contents,
(ii) the explicit decision model of the decision tree can easily be reviewed
by domain experts, supporting market analysis and knowledge
engineering, and (iii) by deploying the user model at client side, the user has
total control over his/her own data, addressing many privacy concerns.
However, the proposed approach has one major drawback: in order to
receive personalized contents, users have to install a client, which may be
either a browser plug in or a standalone application. Anyway, this seems
to be necessary for providing real privacy and also other works aimed at
addressing the privacy issues of online advertising have stated the need
of a software agent [