Knowledge-based Recommender Systems suggest to users items of their interest, on the basis of some understanding of both items' characteristics and users' pro les. In order to properly work, this kind of recommender systems need a thorough modeling of items and users; the usual barrier to their development is, therefore, the availability of the necessary knowledge and its maintenance over time. With this respect, Semantic Web technologies can be of great help: not only knowledge technologies and languages can be employed to build the knowledge base, but the large availability of open and linked data about a growing variety of elds and topics, published on the Web of Data, further simpli es the modeling step for recommender systems. In this paper, we present our concept of Semantic Web-enabled Recommender System, based on the retrieval from the linked data Web of the necessary pieces of knowledge about items and users. We illustrate the general structure of this new family of Knowledge-based Recommender Systems and we explain how we concretely followed this approach to develop a tool to recommend Web services in the context of the SOA4All project. We also o er our considerations about the strengths, the current limitations and the possible extensions of our proposal.
Additionally, another category of systems, the Hybrid Recommender Systems [
Knowledge-based Recommender Systems o ers some advantages with respect to the other techniques. First, they need a minimal amount of users, i.e. they do not require a huge amount of data to compute recommendations, di erently from other classes of Recommender Systems; moreover, they do not su er the so-called cold start problem: when a new user/item is added with its description, the system is immediately able to compute recommendations for the new user/item; nally, by their very nature, they are able to generate proofs for the recommendations, i.e. they are able to \explain" the motivation behind an item proposal on the basis of the user/item modeling at disposal.
The main drawback of Knowledge-based Recommender Systems, however, consists in the modeling, building and maintenance of the knowledge base: a correct and up-to-date description of items to be recommended, as well as of users to which provide suggestions must be ensured, in order to guarantee a high level of recall and precision of the generated recommendations. Several elements can change over time: new users and new items can be added, old users and old items can require an updated description, the domain knowledge can evolve or be modi ed to take into consideration new features, the set of policies de ned to compute recommendations can be revised to better meet users' needs and requirements, and so on.
This knowledge base creation and maintenance require a lot of e ort, with a heavy human intervention. A special attention must also be given to assure the consistency, quality and reliability of the modeled knowledge. Therefore, in this context, it is quite natural to think about applying technologies and tools coming from the Semantic Web community to help and support this phase. Some e orts in this directions were already explored (as we report in Section 5); still, a comprehensive work to design a Semantic Web-enabled Knowledge-based Recommender System is missing.
In this paper, we present a holistic approach to apply Semantic Web
technologies and the knowledge coming from the Web of Data to support and enhance the
knowledge base modeling as well as all other phases of the recommender life
cycle. Indeed, we believe that the recent availability of large amounts of linked data
can de nitely o er new opportunities to build innovative and enriched
recommender systems. Moreover, the widespread uptake of Semantic Web standards
{ RDF [
The rest of the paper is structured as follows: in Section 2 we describe our concept for a Semantic Web-enabled Recommender System and we introduce the scenario in which we applied our proposed approach to recommend Web services, in the context of the SOA4All project. The details of our approach are o ered in Section 3, in which we explain how the Web of Data can be leveraged to build a knowledge base, and in Section 4, where we illustrate how Semantic Web technologies can help in computing recommendations; those sections include also the description of the actual realization of our conceptual approach in the Web service recommendation scenario. Finally, in Section 5, we introduce some previous works to combine Semantic Web technologies with Recommender Systems and in Section 6 we conclude with our considerations about open issues and current limitations and we provide hints for future extensions. 2
For the last years, the Semantic Web community has been working to realize
the Web of Data, i.e. to publish structured information and datasets on the
Web and interlinking them. Thanks to the popularity of Tim Berners-Lee linked
data meme [
We believe that the Web of Data should be considered as an interesting source of information to be used by Knowledge-based Recommender Systems. The LOD Cloud is a huge public source where information can be found to describe several kinds of items, users and domains. Accessing and exploiting the Web of Data can allow the partial automation of the knowledge base creation and maintenance, simplifying the modeling and pro ling of items and users. Furthermore, the computation tasks to generate recommendations, operating on the knowledge base, can be performed and enhanced by the use of Semantic Web tools like SPARQL processors, reasoners or rule-based systems.
In this paper we propose a holistic approach to design and to realize a Knowledge-based Recommender System using Semantic Web technologies. In Section 2.1 we explain the high level architecture of such a system, which will be detailed in Sections 3 and 4. The scenario in which we demonstrate the applicability of our approach is introduced in Section 2.2; we will use this application scenario also in the following sections to explain how we realized in practice a prototype of our Semantic Web-enabled Recommender System.
A recommender system is usually part of a more complex application (like a Web site), so it exchanges data with other components. It provides its functionalities to a set of known users about a prede ned set of items; both those sets can be modi ed over time (users and items can be removed or added).
Our concept of recommender system processes information from both private and public sources. We call private data the information about users and items generated by other parts of the application; with public data we identify the data published and freely accessible on the Web of Data.
Semantic Web‐enabled Recommender System Users Items
Model Builder
Private data
Model of Recommendation Recommendations users and Engine items
Public data (Web of Data) The Model Builder is related to the knowledge base building and maintenance; its goal is to create a model containing the descriptions of items' and users' pro les. Additionally, this model should contain information about how users (and their interests) are related to items (and their features). In order to build such a model, this component queries and interacts with the available data sources, both private and public ones, and identi es the knowledge \bits" useful to describe the items to be recommended and the users. For what regards the items, the Model Builder should look for available descriptions, categorizations and classi cations, reviews and ratings, related entities, etc.; it should also reconstruct the users' pro les by retrieving useful information about their tastes and their preferences.
The second component, the Recommendation Engine, is devoted to the computation of item suggestions; it receives as input the model generated by the Model Builder and analyzes this knowledge to nd semantic connections between users and items. The assumption is that, if a user pro le can be connected to an item description by a set of semantic links, this means that that item is a good candidate for recommendation. Still, the component should also check for speci c characteristics of those connection \paths" in order to compute a score { the so-called utility value { that represents the system's degree of con dence in the usefulness of such recommendation for the user. 2.2
SOA4All2 is a European research project aimed to provide a comprehensive framework that integrates SOA, context management, Web principles, Web 2.0 and semantic technologies into a service delivery platform. SOA4All tools can be used by developers to discover, compose and reuse services in order to build a new application. In this scenario, the users of the system are developers looking
for services, which are the items to be recommended. For example, a developer who wants to build an e-commerce website is interested in nding pre-existing services to be reused, like a shopping cart manager or a payment service.
Within the SOA4All project, we applied the approach sketched above to realize a Semantic Web-enabled Recommender System3 to suggest developers (users) services of their interest (recommended items). Developers are identi ed by their OpenID, which is an unambiguous Web identi er; by using this identier, the Model Builder retrieves a user description from the Web of Data which complements the \private" data about the user. Moreover, the services to be recommended have their own URIs to identify them and are semantically annotated with a categorization ontology; this lets the Model Builder nd related information. Finally, the Recommendation Engine processes the SOA4All users' pro les and the services' description to nd if and how they are semantically connected; if such connections exist, the engine computes their utility values in order to detect which services can be interesting for the system users.
It is worth noting that, since our Recommender System is a Semantic Web
application that accesses distributed linked data sources, we developed it on top
of LarKC4 [
The Model Builder creates a model containing users' pro les and items' descriptions by processing the available data sources, both private and public data. This component can be further divided in three parts, as depicted in Figure 2: the User Pro ler, the Item Pro ler and the Linker.
Users
Items Private data Public data
Model Builder
User Profiler Item Profiler
Linker
Model of users and items The User Pro ler and the Item Pro ler respectively build a description of the users and a description of the items; the main task of the Linker is to connect
the users to the items, adding the missing data to complete the \paths" between users, their tastes and interests on the one hand, and items and their features on the other hand. 3.1
Since both User and Item Pro lers aim at building a semantic description of a user/item respectively, to better clarify their role, we rstly describe a generic Entity Pro ler. Then, in Sections 3.2 and 3.3, we detail the speci cities of those two components within the Model Builder.
An Entity Pro ler can be characterized by the entities to be described and by some speci cation of the desired description of those entities, e.g. in terms of the requested entity attributes. To reconstruct the entity description, the Entity Pro ler accesses both the private sources and the public data published on the Web of Data; the Entity Pro ler queries and traverses those knowledge sources and retrieves the needed data; in case, it interlinks the gathered data to reconstruct a complete model of the entities to be described.
We assume that the entities to pro le can be identi ed by URIs; this kind of identi er can be used to retrieve more information from the Web. We also consider that the entity pro le will be expressed in terms of RDF triples and RDF links to external sources. In order to build such a pro le, the Entity Pro ler can be con gured to specify what kind of pro le data should be fetched; the basic assumption is a SPARQL query in the form DESCRIBE <entity-URI>, but con guring this component could mean de ning a detailed CONSTRUCT query. In the latter case, the CONTRUCT clause could be used to transform the original retrieved data into a common format that is more suitable for the subsequent elaborations. When the entity description is fetched from several heterogeneous sources, this transformation is needed to homogenize the di erent pieces of data.
For what regards the data sources, the Entity Pro ler should rst search in
the application private data; then it should look for additional data from external
sources. Those public sources can either be manually identi ed or dynamically
discovered; in the former case, the Entity Pro ler can be con gured with a list
of known data sources (to be used, for example, in the FROM clause of SPARQL
queries), while, in the latter case, the component should query a Semantic Web
search engine service (like Sindice5 [
A nal note about the \storage" of entity pro les: the most natural approach would be to store all the reconstructed pro les locally; this is also the most common approach in existing recommender systems. Growing the amount of data gathered from public sources, however, this could be unfeasible. Being the Web of Data distributed by nature, moving from a dataset to a connected one is always possible by following RDF links. A Semantic Web-enabled Recommender System could therefore have a local knowledge base for the RDF links to external
public datasets, leaving in their original locations a large part of the public data. Incorporating only the links to the remote locations lets the system keep its knowledge base small and manageable, without hindering the possibility to access the public data on the Web. Of course, a pragmatic solution could include partial local caching of remote data.
The User Pro ler is the instantiation of the generic Entity Pro ler with the goal of reconstructing the user pro le. Usually, recommender systems adopt two di erent strategies to derive a user pro le: by analyzing implicit user feedbacks and by processing explicit user inputs.
The implicit feedbacks analysis [
Our concept of Semantic Web-enabled Recommender System does not require the adoption of either speci c technique. The User Pro ler addresses the challenge of complementing a user description, derived via implicit/explicit techniques, with additional public information from the Web of Data. Therefore, the following considerations are valid in both scenarios.
The Web of Data allows for a relevant enrichment of the pro les, through
the discovery of di erent kinds of information. Not only the User Pro ler can
look for speci c information about users and their tastes; it can also enrich the
description of users' needs, by retrieving more detailed descriptions of interest
topics. The availability of such information is due to the growing success of
social networks; Web users are more and more accustomed to describe their
pro le on a multitude of di erent platforms and the Semantic Web community
has investigated how to automatically derive a structured user pro le from the
social Web (e.g. extracting users' interests from their Facebook pages [
In particular, we refer to FOAF 7 [
recommendation introduced in Section 2.2, system users are developers identi ed by their OpenID. In this context, therefore, we used this identi er to nd an available FOAF pro le, since FOAF speci cation de nes the inverse functional property foaf:openid. If such a pro le is found, we retrieve foaf:interests, thus collecting the useful hints to understand users' preferences.
Since we want to build a pro le that lets the recommender system provide
useful service suggestions, we do not limit the developers' pro ling to their FOAF
description. Starting from the values of the foaf:interest property, we try to
identify related DBpedia resources [
foaf:interest dbp:ClassicalMusic .
Finally, the retrieved pro le data are converted into a common format expressed by the Weighted Interest Ontology8; this data model lets us keep track of the di erent interest degree of a user with regards to a topic. Moreover, this ontology could be used to tell apart the di erent \contexts" of a user's pro le: a person could be interested in books in his private life and in music for professional reasons. The example above should therefore be converted as follows: <user-uri> foaf:openid <user-openid> ; wi:preference [ rdf:type wi:WeightedInterest ; wi:topic dbp:ClassicalMusic ; wi:weight "1" ; wi:context "professional life"
As the User Pro ler builds users' description, the Item Pro ler performs similar actions on the recommendable items. The goal of this component is to reconstruct a description of the items, collecting their relevant features and properties.
Since an item is any entity that could be recommended to the user, the speci c kind of information to be retrieved strongly depends on the concrete scenario and cannot be generalized. Nonetheless, in the following we o er some hints on how Semantic Web technologies can help this component. In particular, we focus on enriching the \private data" about items with additional details from the Web of Data; as with users' pro les, we assume each item can be identi ed by a URI to let the Item Pro ler search for related information.
For what regards the data sources to be queried, it is of course hard to indicate a source that can prove useful in any possible case. As explained in
Section 3.1, the location of data sources of interest can be reached through the use of a Semantic Web search engine, by looking for information directly related to the item or relevant with respect to some domain-speci c concept or entity.
It can also be advisable, however, to retrieve information from the most
common generic sources, like the already cited DBpedia { \the crystallization point
for the Web of Data" [
sawsdl:modelReference sfcat:Music .
As illustrated for user pro ling, service description could be turned in a common format suitable for recommendation computing. A possible expressive model is o ered by the Service-Finder ontology12 as follows: <service-uri> rdf:type sf:Service ; sf:hasCategoryAnnotation [ sf:hasCategory sfcat:Music ; sf:strength "1"
The output of the two pro lers consists of two RDF graphs (Figure 3), one
containing users' pro les and one describing recommendable items and their
features. As described in Section 4, computing recommendations is the process of
analyzing the relations between users and items, thus, the goal of the Linker is to
supply the additional RDF triples describing the relations between users (or their
interests) and items (or their features). Some of these connections could already
be part of items/users pro les; otherwise, the Linker should look for the missing
links. In [
To discover useful connections, the Linker could perform two operations on the Web of Data: inference and RDF paths search. Applying inference on User
and Catalog Knowledge, the Linker could nd hidden relations among the described entities. In addition, inference could improve the RDF path search by adding new \starting points" to the data discovery.
Users’ model
Items’ model Web of Data The RDF path search consists in the discovery of the missing links between users' and items' pro les on the Web of data. This means that, if additional connections exist, they could as well be published on the Web of Data. In literature, some works to perform RDF path search on the LOD Cloud already exist.
RelFinder13 [
SCARLET [
The idea behind SCARLET could be extended from concepts to generic entities. The Linker could act in a similar way: given the two resources for which a connection should be found, it should rstly identify the datasets potentially containing the RDF paths; then, traversing the datasets by following a speci c policy (for example using only a set of prede ned properties), it should try to nd the connections. It is worth noting that an exhaustive search for paths is not an issue, since the Linker's aim is to nd useful paths for the computation of the recommendations.
Linking services to SOA4All users. As explained above, services are
annotated by the use of the Service-Finder Category ontology. Those categories are
13 RelFinder http://relfinder.dbpedia.org/.
mapped to DBpedia categories14, by the use of SKOS [
Moreover, DBpedia categories constitute a taxonomy, in which categories are related via the skos:broader mapping property. DBpedia topics are then related to DBpedia categories by a skos:subject predicate. Thus, the Linker can nd a path between user interests (expressed as DBpedia topics) and service categorizations (mapped to DBpedia categories). The following triples complete the path between the user and the item of the previous listings: dbp:ClassicalMusic skos:subject dbpcat:ClassicalMusic skos:broader dbpcat:MusicGenre skos:broader dbpcat:ClassicalMusic . dbpcat:MusicGenre .
dbpcat:Music . 4
The last element in our vision for a Semantic Web Recommender System is of course the component to generate suggestions of interesting items to the users: the Recommendation Engine. On the basis of the RDF graph that connects users to items as computed by the Model Builder, this component must derive a list of recommendations, i.e. a list of user-item pairs quali ed by a utility value which represents the con dence in the predicted user/item correlation.
The approach of our Recommendation Engine is oriented to nd meaningful relations between users and items in the descriptive graph. The rst step is thus identifying the relevant path(s) { in terms of RDF triples { that connects a user with an item within the graph reconstructed by the Linker. It is possible that no path exists to connect a user to an item: in this case, the Engine does not produce any recommendation for that pair; on the other hand, when multiple paths exist, all paths or only a subset of them can be considered. In any case, each path must be evaluated and given a score.
In order to judge if an item can be of interest for a user, the bare existence of a path between them is not enough; indeed, the path should contain evidence of the recommendation \utility". To this end, Semantic Web technologies can play again an important role: the RDF path in fact is not only a route connecting two points in a graph, but it consists in a \semantic" description of the reasons why the user and the item are linked.
Under this perspective, the Recommendation Engine must check the \content" of the user-item connection path, to identify signs of potential utility. For 14 Cf. http://www.service-finder.eu/ontologies/SFC2DBpedia. example, it could verify if the path contains triples that express interest, liking or importance (e.g. the user likes a topic which is related to the item); on the contrary, it should make sure that the path does not contain expressions of disapproval or distaste (e.g. the user dislikes a subject to which the item refers). Finally, it could take into account the user \context" or \role" to give higher scores to paths relevant for the current user needs. Therefore, the Recommendation Engine should verify a set of constraints within the RDF path(s); the satisfaction of each constraint leads to the attribution of a score and the combination of all scores constitutes the utility value for the user-item pair.
Pragmatically, those constraints to be veri ed can be expressed in a
number of di erent ways using Semantic Web technologies, including SWRL [
Moreover, when suggesting those recommendations to the user, the Recommendation Engine could also provide a proof for its choice, i.e. the path connecting the user to the recommended item. This proof lets the user understand the \semantics" of the recommendation and check its validity; in turn, this could enable the possibility to gather feedbacks from the user about the soundness of a recommendation, thus paving the way for an improvement of the user/item model (e.g. the user could add/modify his interests in order to get more tailored suggestions).
Computing service recommendations scores. In our service recommendation scenario, we compute the utility value by analyzing the paths. On the one hand, we rely on the knowledge about users and items: user interests are \weighted" as exempli ed before and service annotations have a \strength" representing how much the employed automatic annotator software is con dent about the categorization. On the other hand, the RDF path connecting a user to a service contains other information, like the DBpedia topics and categories.
For each user-service couple, the system computes a correlation value out of all the paths connecting them. Given a path, a rst utility value is computed considering speci c characteristics of the RDF path, like the number of skos:broader relations between DBpedia categories (the fewer relations, the higher the score) and the presence of DBpedia \top" categories (if present, the connection path is probably not very meaningful). Then, this value is combined with the interest's weight and the categorization's strength, in order to compute a global utility value for the path.
Semantic Web and Recommender Systems are two research elds with several
points of contact: in literature, it is possible to nd several works related to the
study of their interaction [
A rst way to use Semantic Web technologies in recommender systems is
to describe users' pro les and items' features. Middleton, Alani and De Roure
in [
Regarding the use of Semantic Web tools for the generation of
recommendations, Abel et al. in [
In [
Another way Semantic Web could help to build a Knowledge-based
Recommender System is to build recommendations' proof. Passant and Decker in [
Finally, Semantic Web technologies can be successfully employed to integrate
data from heterogeneous sources. Passant and Raimond in [
Another example of Semantic Web-based integration can be found in [
In this paper we presented our vision of how a Knowledge based Recommender System could be based on and exploit all the capabilities of Semantic Web technologies. We explained how the model of users and items can be enriched with the knowledge from the Web of Data and how Semantic Web tools can be employed to elaborate data and support generating recommendations. We designed the structure and the main modules that compose such a system at a conceptual level, giving hints on how this can be realized in practice; additionally, we illustrated how we concretely built a demonstrator of such a Semantic Web-enabled Recommender System in the context of service recommendations in the SOA4All project.
Our main goal with this paper was to present several opportunities to leverage the results of the Semantic Web community in the Recommender Systems eld; we hope that other researchers can take our concept and analysis as reference for further investigations on the possible interplay of the two \worlds".
The pure adoption of Semantic Web technologies, however, does not solve
some existing open issues in building a Knowledge-based Recommender System.
In particular, since the quality of recommendations is directly correlated with
the quality of data, relying on the knowledge in the LOD Cloud means
trusting the quality of its contents. To dispel the concerns about the quality of data
and the level of \trust" of the linked data sources on the Web, the Semantic
Web community is putting a lot of e ort in the de nition and standardization of
\provenance" descriptions15 [
In an open and inclusive environment such as the Web, information is often contradictory or questionable; the distributed and redundant nature of the Web puts at risk not only the consistency of knowledge, but also its completeness and reliability. To overcome those problems, usually people make trust judgments based on what they know about the data provenance. However, when provenance information is not available or is not enough, the problem of managing inconsistency remains open. This, in turn, has a direct consequence on the possibility to evaluate the generated recommendations, e.g. in terms of precision and recall. On the other hand, the employment of semantic descriptions paves the way to a recommendation evaluation based on the meaning of data.
All in all, our proposed approach is far from being complete. Our future work
will be devoted to extend and improve the current proof of concept, to evaluate
it and to detail the lessons learned from the adoption of our approach. In our
roadmap, we would like to investigate in the direction of deriving user pro les
from implicit knowledge (as in our previous work [
This research has been partially supported by the SOA4All (FP7-IST-215219), LarKC (FP7-IST-215535) and Service-Finder (FP7-IST-215876) EU co-funded projects.