In Web 2.0 systems tagging has become one of the most popular techniques to allow users (and entire user communities) to categorize content autonomously. But, current tagging systems have their ipsides, though: synonyms and polysems lead to littered tag spaces making it di cult for users to nd relevant content. Users su er from retrieving content actually not being of interest or, vice versa, from not retrieving content that actually would be of interest when exploring the tag space. Moreover, in current tagging systems no relations between tags are modeled. Thus, recommending related tags (or content) is not possible. In this paper we present an approach allowing users, i.e. the community, to collaboratively model relations between tags. We provide UI components allowing to model these relations which are then stored in a SKOS-based ontology which can be leveraged for content recommendations. Giving the community the power to consolidate tags and to relate tags to each other and, at the same time, storing these relations in ontologies is our Web 3.0 approach to solve tag space littering problems and to issue tag-based recommendations.
The concepts presented are being prototypically implemented within IBM's WebSphere Portal and can be presented in a live demo at the workshop.
ods]: Predicate logic,Relation systems,Semantic networks;
The recent popularity of collaboration techniques on the Internet, particularly tagging and rating, provides new means for both semantically describing web content as well as for reasoning about users' interests, preferences and contexts. It can add valuable meta information and even lightweight semantics to web resources. Tagging allows non-expert users to develop folksonomies that categorize content available in the system.
Unfortunately most current tagging systems have two main
drawbacks:
First, synonyms and polysems cannot be easily detected
automatically and thus litter the tag space. Synonyms lead
to multiple tags that all can have the same meaning, either
because they are only a morphological variation (apple vs.
apples) or semantically similar (baby vs. infant ). Polysems
lead to single tags that can have multiple meanings
(apple can refer to the fruit or to the company Apple). From
a user perspective the two problems might manifest
themselves as follows: A user Alice and a user Bob might both
apply the tag apple to some resources, but Alice might refer
to the fruit whereas Bob might refer to the computer
manufacturer. When Bob is later doing information retrieval
by selecting the tag apple he receives a lot of "irrelevant
noise" as he is also presented resources that have to do with
the computer manufacturer. This problem is referred to as
low precision problem. In the second scenario both users
might want to tag resources providing information about
the United States. Alice might tag these resources with
USA, Bob with United States. When doing information
retrieval Alice, might miss the resources tagged by Bob and
Bob might miss the resources tagged by Alice just because
the semantic relatedness of these tags remains invisible for
the system. This problem is referred to as low recall
problem. Current approaches to solve these problems include the
application of normalization and stemming algorithms (cp.
e.g. [
In this paper we present a Web 3.0 approach for solving the problems just mentioned. First, we allow users, i.e. the community, to augment tags to make them less ambiguous. Second, we allow users to collaboratively model relations between tags which can then be leveraged for content recommendations. We provide the community with UI components to model these relations which are then stored in a SKOS-based ontology. Giving the community the power to consolidate tags and to relate tags to each other and, at the same time, storing these relations in ontologies is our Web 3.0 approach to solve tag space littering problems and to issue tag-based recommendations.
Several approaches aim to improve tagging systems by
using semantically rich tags instead of at keywords. We will
refer to these systems as semantic tagging systems. These
approaches can be split into two groups based on the
strategies they use:
1. Semantifying already existing tags of a tagging system
2. Enabling a community to annotate resources with
semantically rich tags instead of at keywords
With the rst strategy at keywords of existing tagging
systems (like del.icio.us) are enriched with semantics. This is
often an automatic process in which tags are mapped to
concepts from an ontology or relations between tags are
derived from the folksonomy structure. The system TagOnto
proposed in [
SemKey - a semantic collaborative tagging system described
in [
keywords used for tagging while the actual tags then
refer to Wikipedia pages. The social bookmarking website
Faviki enables the annotation of bookmarks with DBpedia2
concepts. The entity describer 3 is an add-on to the
tagging system of Connotea4 where tags refer to entities from
the freebase5 ontology. In [
With the second type, the tag ontology is created by the
same community that uses it for tagging. That way, the
semantic data is tailored to a tagging community and kept as
small as necessary. In [
In this section we describe our approach for solving the problems of tagging systems by combining Semantic Web technology with Web 2.0 interface components. Section 3.1 describes our ontology design and how users can provide semantic relations between tags. In Section 3.2 we give a brief overview over the web interface and its components. Section 3.3 shows the current system architecture of our prototype.
We rely on Semantic Web technology regarding the storage
of tags and relations. SKOS (Simple Knowledge
Organization System, [
Roy Lachica states in [
This is achieved by giving each user the opportunity to structure and label his tags the way he wants. Additionally, a user can map any of his tags to tags from other private models if both tags refer to the same concept from the real world. This mapping is stored as skos:exactMatch property in the ontology. Everyone in the community can have the bene ts of the collective knowledge model if he wants, but is also allowed to stay within his own model. Every user has a concept scheme (skos:ConceptScheme) which contains all tags created by him. Concept schemes in SKOS were designed to aggregate concepts when dealing with data from di erent knowledge organization systems - in our case the di erent mental models of the users. Since the skos:exactMatch property is symmetric and transitive the separate knowledge islands are quickly connected to a big network. If e.g. Bob links his tag Semantic Web in his model to Alice's tag Web 3.0 in her model he is able to exploit parts of her knowledge model as well. If Alice has previously linked her tag Web 3.0 to a tag in Carl's model, Bob can exploit Carl's model as well and vice versa (Figure 1).
The simplicity and exibility of folksonomies is one of the main reasons for the success of social tagging systems today. Specifying the semantics of a tag can solve some of the problems of tagging systems and therefore improve user experience. But it also means having to extend the tagging process which results in a work overhead for the user. In order to keep this overhead small, we tried to design a user interface that allows the community to perform the necessary tasks fast and easily. One aspect of Web 2.0 is the improved usability provided by Rich Internet Applications (RIA) using AJAX technology and a more desktop-like look and feel. Our web interface consists of several widgets built with the Dojo Toolkit8 which interact with the web services of our system.
Tags can be found by typing a term into a type-ahead enabled combo box which in turn displays a list of tags with matching labels. The user can then navigate through that list and obtain additional information like the tag de nition to disambiguate tags with similar or identical labels. For an even faster disambiguation on rst sight one of the broader tags is displayed in brackets (Figure 2). This process helps the user to locate a suitable tag for her intends and lets her specify the exact meaning of the tag she applies to a resource. If no suitable tag can be found the user is free to create a tag in her private model by providing a preferred label and a de nition. Optionally, other tags that are broader or narrower than or related to the new tag can be declared, integrating the new tag directly into the taxonomy.
Within the user interface the semantic tags always have the same visual representation and can be dragged and dropped to perform certain actions. If one tag is dropped onto another tag a context menu appears and the user can add a semantic relation between these two tags. For instance, if a user nds a tag from another user that refers to exactly the same concept as her tag but with a slightly di erent label, she can map these two tags using the context menu (see Figure 3). After annotating a resource, the semantic tagging application con rms the tagging and displays semantic tags other users have previously applied to this resource. If the user notices that a tag another user has applied is related to or about the same thing as one of her tags she can quickly provide this semantic relation using drag and drop and the context menu. This was one of our main objectives: Modeling semantics should be embedded in the tagging process.
Furthermore, tags can be dropped into tag bags which are visual representations of containers that hold a set of tags (e.g. a user can put his favorite tags into one single tag bag).
In several scenarios it would be valuable to browse the taxonomy and relations de ned in the tag ontology. For instance, when selecting semantic tags from the ontology in order to tag a resource, the most speci c tag should be used instead of the most general. By exploring the tag model taxonomy and drilling down into narrower tags the user is able to select the most speci c semantic tags for a resource. With the help of our browsing widget users can explore a visualization of the tag model. In the current prototype, the hierarchical relations of a tag can be explored with a tree view (Figure 4). Narrower tags are shown as child nodes in the tree while broader tags are visualized as parent nodes. Unfortunately, the tree visualization has obvious drawbacks; multiple broader tags can not directly be visualized and related tags aren't displayed at all. In our current implementation this information can be looked up by right-clicking on a tree node where related and broader tags are listed in a context menu. Therefore, we are experimenting with di erent methods of tag model visualization. A conceivable replacement for the tree view could be a simple graph visualization (Figure 5). Tags are displayed as nodes and straight lines between the nodes depict semantic relations where each semantic relation has its own color. By clicking on a node all semantic relations to directly related tags could be dynamically loaded and visualized. In that way a user can explore the tag space visually until she nds the information she needs. Since this is a rather uncommon type of interface user experience and acceptance are still to be evaluated.
Finally, leveraging the knowledge about relations between tags (and, implicitly, about resources) we can also automatically recommend users with related content as outlined before.
The current system prototype is being implemented on IBM WebSphere Portal technology with a separate component containing the knowledge base. The whole system architecture is loosely coupled using web services to access the individual components. Our choice regarding the semantic repository fell on openRDF sesame9 since we considered it to be one of the most mature non-commercial RDF repositories. To enable OWL inferencing (which is necessary for the SKOS properties we use), swiftOWLIM10 was integrated with sesame as Storage And Inference Layer (SAIL). A web service layer on top of the RDF repository adds convenient and simpli ed access to the semantic data which is used by the user interface widgets. Additional, customized SPARQL queries can be run against the repository making it possible for other applications to use the stored semantics. Tags and their semantic relations are kept in the repository while the tagging system just stores URI references to the tags. The loose coupling makes it possible to swap the underlying tagging system or tagging API which takes care of annotating resources and retrieving resources by tag reference.
In this paper we have described a Web 3.0 approach to collaboratively modeling semantic relations among tags. Our approach solves a number of problems associated with the traditional tagging approach that leverages at lists of unrelated tags. First, users are enabled to create tag hierarchies 9http://openrdf.org 10http://ontotext.com/owlim/ that t their mental models, hence better organize content of their interest. Second, the semantic relations among tags can be used for improving the information retrieval process and recommending related content. Finally, our approach solves the tag disambiguation and tag space littering problems.
The ideas presented in this paper are being prototypically implemented in IBM's WebSphere Portal. Upon completion of implementation, we plan to evaluate usability of the proposed tagging process as well as the value of improvements that the collaboratively created tag ontologies provide for content recommendation. Also in the future we plan to extend our approach to let users collaboratively create more semantically rich OWL ontologies.
IBM and WebSphere are trademarks of International Business Machines Corporation in the United States, other countries or both. Other company, product and service names may be trademarks or service marks of others.