Ontologies and tagging systems are two different ways to organize the knowledge present in Web. The first one has a formal fundamental that derives from descriptive logic and artificial intelligence. The other one is simpler and it integrates heterogeneous contents, and it is based on the collaboration of users in the Web 2.0. In this paper we propose a method to model tagging systems like folksonomies using ontologies. In our proposal, structured information (ontologies) can be extracted from knowledge built in a simple and collaborative way (folksonomies). Furthermore, we provide an analytical expression to evaluate the system requirements to store the derived ontology.
Capturing knowledge by using markup techniques and by supporting semantic annotations is a major technique for creating metadata. Currently, in the WWW, folksonomies are more extended as tagging system due to its easy use. Folksonomies allow the integration of heterogeneous resources and the collaboration of users in the resource tagging process. However, it is difficult to work with such information because it has not any structure and it is user dependent. On other hand, ontologies provide a framework to handle structured information and to extract conclusions from such structured information. It is very interesting to provide mechanisms to turn existing syntactic resources into knowledge structures and therefore, modeling folksonomies with ontologies is an important issue.
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.
Conference’04, Month 1–2, 2004, City, State, Country.
Copyright 2004 ACM 1-58113-000-0/00/0004…$5.00.
Folksonomies and ontologies are two different ways to organize the knowledge present in the current Web.
A folksonomy [
Folksonomies are the result of a collaborative annotation process. A folksonomy is composed of text labels, called tags, and a set of resources associated to those tags. A priori, in the annotation process there is not any restriction and, therefore, there is not any predefined hierarchy or restriction to define the tags, and it relies upon users criteria. In the last years, folksonomies have been used in different social networks like Flickr1 and del.icio.us2, where users annotate images and links respectively. In these social networks, metadata is assigned (or knowledge captured) following a decentralized process. Another interesting characteristic of
folksonomies is collaboration due to the fact that users can interact with the resources provided by others adding notes on them. Therefore, folksonomies contain a view of contents and knowledge wider than the contents they represent.
One usual example of folksonomy is del.ici.ous, a social network where users store URLs and annotate them. In this case, users can annotate all URLs present in the system and each URL can be located by means of tags assigned to it. Therefore users can access to any web resource annotated by any user. In this case, users can also collaborate to assign tags. Hence, the semantic of the resources and the used tags are included in a collaborative way.
Another example of social network, similar to del.ici.ous, is Flickr. In this case, tags can be used by different users, but each user annotates only its own resources (photos, images, etc.). In this way, the annotation process is individual. The semantic of the tags corresponds with the different resources that have been labeled by different users.
In the above examples and similar ones, the navigation process is
based on clouds of words, called tag clouds, avoiding the
taxonomic organization of tags. In Figure 1, we show an example
of a tag clouds obtained with the most used tags in del.ici.ous in a
particular date. Depending on its popularity (that is, the number of
resources annotated with such tag), each word has a different size.
Similarly, different colors indicate that tags are shared with other
users.
The knowledge captured with folksonomies has some drawbacks,
(polysemy, synonymy, granularity) which are similar to the ones
present in other classification systems like taxonomies or
thesaurus [
Another problem specific of Folksonomies is the semantic of the
tags. Although one can expect that tags are directly related with
the information, it is not always the case. The flexibility of
folksonomies allows users to assign tags based on their relation to
the information. That is, when users define a tag they take into
account not only the information to be annotated but also the
purpose of the tag. Consequently, different tag types can be
identified depending on its purpose [
Identify “what about and who”. These tags are used to identify what and who is the content about.
Identify “what it is”. These tags indicate the type of the annotated resource: blog, book, etc.
Identify “the proprietary”. These tags are used to establish who is the author or the proprietary of the 4. 5. 6. 7.
content.
Categories. Some users use particular tags to simulate hierarchies.
Identify “characteristics of the content”. These tags are usually adjectives (funny, bored, etc.) representing the opinion of the user that annotates the content.
Self reference. Such tags represent the relationship of the user with the content. Usually they begin with “my”. For example, mythings, myjob, mycomments, etc.
Organize tasks. Such tags are used to simulate content classification in order to organize, for example, the work. Tags that fit into this class are toread, todo, search-work, etc.
Another additional problem present in Folksonomies arises from its collaborative philosophy. The direct implication of the final user in the construction of the knowledge structure, makes such structure very sensible to SPAM. That is, the uncontrolled action of malicious users providing for instance several wrong tags, can derive into poor knowledge models.
The problems we have described above refer to the annotation
process. However, there are also some other problems related
with the navigation for searching and accessing contents.
Navigation problems can be grouped in two blocks [
In Folksonomies, navigation is a very simple and intuitive process that allows finding out interesting contents. There are two basic ways of navigation through the tag space: a) search and refine, b) use visualization tools of the tag space like the cloud of words. However, as we explain below, such mechanisms are not effective enough.
Search and refine is based on the selection or the search of a tag followed by a posterior refinement of the results. For example, when we look for the word “book” in del.ici.ous, we obtain a result similar to the one shown in Figure 2. This figure contains the set of web pages labelled with the word “book”, and the set of related tags that can be used to extend the searching process. The related tags provide a very basic way to continue the searching process or to refine the search. However, some generic related tags, e.g. those that identify personal aspects like to:order or wishlist, are not useful in practice. Many times it is better to access to the returned links to refine the search in them. The other navigation method, that is, the use of visualization tools of the tag space, is the one used most frequently. The cloud of words belongs to this class (see example in Figure 1). In this case, the size of words is used to indicate the tag’s frequency of use visually.
Though this navigation mechanism seems to be a good method of
exploration, its utility decreases as the number of contents and
tags increase [
taking into account the relationship between them.
of view of some users. Therefore, one of the most interesting characteristic of Folksonomies, namely the integration of diverse points of view, is reduced.
In [
However, ontologies have some drawbacks due to its difficulty to be built and used. If we consider ECM (Enterprise Content Management) systems, based on Web technologies, it is very difficult, for example, to represent a priori the whole scope of the domain for any enterprise. It is also difficult to anticipate the whole domain and the complete set of point of views of all possible users. Thus, ECM system deployments are continuously delayed because the domain is very frequently changed trying to consider all the possibilities. Usually such systems consider only a reduced version of the complete set of information. In addition, most users are simply information providers and they are not familiar with ontologies. Consequently, the insertion of new contents is a very difficult process for most users, because several criteria must be taken into account, and users neither are familiar with these criteria nor with the tools to work with ontologies. Another difficulty is that the structure of the information can vary with time and, therefore, it is necessary a monitoring process to update the structure of the information and the classification criteria. In conclusion, ontologies are difficult to maintain, mainly in changing environments.
Ontologies are based on a solid formal model like the Descriptive Logic and an explicit, formal and shared representation of knowledge domain. On the other hand, folksonomies are based on a collaborative classification system, very simple to use and to implement. It produces a representation of the knowledge domain that emerges from the collaboration between the users with respect not only to the information annotated but also to the tags used. Although both techniques have their strong points, they have also theirs disadvantages.
In folksonomies, the collaborative way of classifying information
in such an anarchical way, trying to extract patterns of order from
certain chaos, has the important disadvantage that when the
volume of information is high, or when the number of tags
increase, the quality of the system decrease dramatically [
The main problem of classification systems and ontologies in
general, and OWL-DL in particular, comes from the expressivity
power and their formalism, that usually makes it very complicated
to create and use ontologies. Although in many situations it is
convenient or even indispensable the creation of classification
information, it can be expensive to implement and presents
important problems of scalability [
The above analysis suggests that it would be convenient that current information web systems could take advantage of the best of both worlds, offering the possibility of structuring the knowledge on a formal way using ontologies, but without losing the dynamism that folksonomies offer. Since ontologies allow the representation of knowledge in a formal way, it seems reasonable to try to model folksonomies with them, incorporating these models to the structure of knowledge of the current information web systems based on semantic technologies.
On the one hand, this would allow having a common vocabulary referring to folksonomies that guarantees the interoperability between different applications, as the creation of common tools and libraries. On the other hand, this modeling could also be used to try to solve or to reduce the inherent folksonomies disadvantages, directly from the model, using the inference capabilities of reasoners over ontologies, or using external tools. 1.4
Once folksonomies and ontologies have been analyzed, we remark that the success of folksonomies is the easy of use. However, knowledge structured in ontologies can be processed in a more efficient way allowing more elaborated conclusions due to the use of reasoners. In this paper, we propose a method to model folksonomies with ontologies, the first one to our knowledge. The method is composed of, on one side, a generic ontology structure that represents any folksonomy, and, on the other side, an algorithm to integrate the information contained in the folksonomy with the generic ontology. Thus, we provide an algorithm to obtain an ontology that contains the tagged information from the folksonomy. In addition, in this paper we provide a measure of the ontology size generated by our algorithm. This measure allows analyzing the system requirements before the transformation.
The main advantage of the proposed method is that it captures transparently the knowledge. The user annotates the content, resources, documents, etc., and dynamically and without user intervention, the proposed modelling method stores the information in the ontology. In addition, the method allows resolving two typical problems of folksonomies: (i) tag variability (for example, blog, blogs, blogging) and (ii) tags defined in terms of the objective of the tag and not on the content (for example, toread, whislist, etc.).
Gruber, in his article “Ontology of Folksonomy: a mash-up of
Apples and Oranges” [
In his proposal, Gruber considers tagging as the activity in which some user annotates some content with one or more tags.
Tagging(object, tag, tagger) Gruber also considers two more characteristics, a first one centred in the sharing of taggings between different sources or applications, and a second one oriented to indicate the polarity (positive or negative) of each tagging, in an attempt to reduce problems derived from spam or incorrect taggings.
Tagging(object, tag, tagger, source, + or -) The work of Gruber presents the basic concepts involved in folksonomies and offers a starting point for the creation of a method for modelling folksonomies with ontologies. However, in order to create this method, it is necessary to detail more explicitly the characteristics of folksonomies and to do it in a stricter way, using some knowledge representation language like OWL DL. These languages offer the power and formalism of descriptive logics and allow the expressivity needed to model the different characteristics. 2.1
The model consists on an ontology3 designed in OWL language
using the tool Protégé [
Source: as proposed by Gruber, it represents the sources or applications that use or feed the folksonomy. Resource: it represents any resource susceptible to be annotated. It has been renamed from the class “object”, as Gruber uses in his article, to get a broader meaning. In an application of the ontology to a concrete domain this class could be specialized to represent documents, pictures, urls or whatever other thing. User: the aim of this class is to represent the users who do the tagging. Tag: it represents the tag concept. This class has several properties associated that are used to represent with a unique instance several tag variations like syntactic variations, incorrect spellings, or even synonyms. Two subclasses are also created: TagPersonal and TagCommon. Its objective is to be able to classify the existing tags according to their type, separating the ones of personal type, like those related to the planning of personal tasks or self-reference tags (TagPersonal), from the rest of tags (TagCommon). Annotation: it represents the action by which a user assigns a set of tags to a resource. Unlike the proposal of Gruber, who bases each annotation on the relationship of a tag with an object, this class represents better the habitual behaviour of users, consisting of assigning several tags to the annotated resources. AnnotationTag: as the Annotation class represents a set of assigned tags to a resource, this new class has been created to allow the relationship of each annotation to the assigned tags. Polarity: this class represents the polarity of each annotation, negative or positive. This polarity is associated to the instances of AnnotationTag. Therefore, it is possible to represent the assignation of several tags to a resource, and the polarity associated to each one of the assigned tags.
The ontology also contains a series of properties in the model. In Table 1, these properties are described indicating their name, domain, range, and a brief description.
It is necessary to explain more in depth some of these properties, specially hasAltLabel, hasHiddenLabel and last, hasPosition. With respect to the two first, hasAltLabel and hasHiddenLabel, their objective is to represent the different variations of a tag, including singular and plurals, verbal tenses, synonyms, misspellings, incorrect syntactic forms, etc., from the tag’s
preferred representation. For example, the tag with preferred value “rubyonrails”, could have associated to hasAltLabel the strings “ror”, “ruby”, and to hasHiddenLabel the strings “rubi”, “rubyonrials”, etc.
Property hasPrefLabel
hasRelatedResource
hasResource hasDateTime
Tag variations or synonyms of a tag, related to hasPrefLabel.
Tag variations or incorrect spellings of a tag, that should be hidden.
It relates a Tag to the Resources that represents. This direct relation is created for efficiency with respect to the existing one through AnnotationTag and Annotation.
It relates one annotation with the AnnotationTags instances that represent the tags assigned.
It relates each AnnotationTag with the corresponding tag.
It relates each AnnotationTag with the real text used by the user to tag the resource. This is necessary because hasTag associates one AnnotationTag instace with one Tag instance, but this can contain different representations among its hasPrefLabel, hasAltLabel and hasHiddenLabel properties. This property must correspond to one of those values.
It relates an AnnotationTag with the polarity (Negative o Positive) associated to the tag.
It relates each AnnotationTag with the position of the tag in the set of tags assigned to the resource in the Annotation.
With respect to hasPosition property, the convenience of this
property is determined by the existence of studies that indicate
that when a user assigns a series of tags to a resource, the order in
which he does it, is not accidental, and that different annotations
made by different users, agree more frequently in the first tags
that in the last ones [
To represent the implicit order of the different tags in an
annotation, the most convenient solution would have been to
define each Annotation like an ordered set of AnnotationTag
instances. However, this is not possible with the actual
specification of OWL. The reason is that it does not exist any
explicit mechanism in OWL to define ordered lists of elements,
and, although some work exists in the literature representing
sequences of elements as linked lists of elements [
The considered approach produces that this ordenation is not
directly accessible from a model based on OWL using a reasoner,
but simplifies the usual requirements of recovering the tags
assigned to a resource, or the resources tagged with a tag, using
SPARQL [
The proposed method is completed with a set of restrictions (Table 2) applied to the classes and properties described, that help to represent the knowledge contained in the folksonomy, and allow to validate the information generated in the ontology.
Class
With the described model it is possible to have a complete representation of any folksonomy. However, it is necessary to specify a method that allows the transformation of existing folksonomies into the described model. On the other hand, it is necessary to consider that a folksonomy is not a static classification system because it evolves as users create new annotations on resources. Therefore, these annotations must be incorporated to the model. With the aim of solving both situations, namely, the transformation of a folksonomy to the described model and its evolution in time, an algorithm is proposed. This algorithm contains the set of actions necessary to model the annotations made by the users and creates a set of elements in the ontology. Figure 3 shows the algorithm of the method that models in the ontology an annotation made by a user.
Aiming at comparing our model with other ones based on ontologies, it is necessary to have some type of measure that allows us to estimate the amount of resources used. This measure can be based for example on the amount of information that the model contains.
This volume of information will be function of the existing instances at every moment in the modelled folksonomy, formed by the number of sources, users, resources, tags and annotations. Since the information represented in ontologies based in OWL is stored as RDF triplets or statements, the number of triplets represented by an ontology can be considered as a good measure of the necessary resources.
From the proposed method it is possible to define two formulas that allow us to get the number of instances represented in the model and the number of triplets contained in the ontology. They are based on a set of variables that define the state of the folksonomy, like the number of sources, users, resources, tags and annotations. Figure 4 shows both formulas. Observe that they do not considerer the use of any reasoner on the model that could produce the deduction of new triplets.
Figure 4 shows both formulas. They correspond to the calculation of the number of instances and the number of triplets of the ontology, without the use of a reasoner applied on the model that could produce the deduction of new triplets. s: number of sources r: number of resources u: number of users t: number of tags a: number of annotations α: average number of tags by annotation β: average number of tags assigned to a resource Number of instances = s + u + r + t + (1+α)a Number of statements = 2(s+u+r) + (2+β)t + (5+6α)a
Figure 4. Size of the resulting ontology
Two averaged values are used in these formulas, namely, the
average number of tags used by annotation and the average
number of tags assigned collaboratively to a resource. These
values depend on several things, such as the possibilities of the
user interface where the annotations are created, the type of users,
or the concrete field where the folksonomy is being applied.
These issues can be studied in different papers (see [
To test the above formulas, some information has been captured for 48 hours from del.icio.us through the RSS channel offered by the web site. This information has been stored initially in a SQL database, getting 27.462 users, 50.728 resources, 30.412 tags and 53.698 annotations. This initial set of data has been reduced, taking only those resources with a minimum of 10 annotations. In this way we have obatained a data subset of 439 resources, 979 users, 1.219 tags and 1.069 annotations. Next, this subset has been transformed into ontology in OWL language, through the application of the transformation algorithm described in our method.
To get the values of the variables α and β, the computations have been done over the initial set of data. In this way, the values obtained are α=2.55 and β=3.54.
An application in Java, using the semantic web framework Jena
[
Several queries in SPARQL language have been designed to validate the proposed method against the searching and exploration problems in folksonomies with regard to tag variations, tag objectives or tag types used by the users. With respect to the problem of tag variations, the model proposes the use of several properties associated to instances of the Tag class, like hasPrefLabel, to represent the preferred text of the tag; hasAltLabel, to represent different syntactic variations or even synonyms; and hasHiddenLabel, to represent incorrect variations that should not be shown. Consequently, one instance of Tag class is able to represent several text variations of a tag. In Table 3 we show the results we have got with a reduced dataset obtained from del.icio.us. We see how a user should make 4 different searches in del.icio.us, with different results each one, to get all the data on the programming language RubyOnRails. These 4 searches correspond to the different variations used usually by users to refer to this language, like “Ruby”, “Ror”, “Rails” and “Rubyonrails”. However, with the proposed model, all this variations would be grouped in a unique Tag class instance, having one of them as preferred text, and the others as alternative or hidden variations. Hence, with the proposed model, it would be sufficient to make only one search with any of the tag variations, to get all the associated results. A second characteristic of our model is that the grouping of the different variations of a tag in a unique Tag class instance decreases the number of instances of the Tag class with regard to the initial number of tags existing in the dataset obtained from del.icio.us. Table 4 shows that the reduced dataset obtained from del.icio.us has 1.210 tags whereas the number of Tag class instances in the proposed model, after the grouping, is only 886 (that is, 324 less). With respect to the problem of objective or type tags used by users, the proposed model has two subclasses wich are specializations of Tag class. The aim of these subclasses is to divide the existent tags into two different subgroups. One of them (TagPersonal), correspons to tags that have a personal objective, like self-reference tags or task-planning tags. The other one (TagCommon), corresponds to tags that have a meaning and semantic common for all users.
The 886 tags existent in the ontology have been distributed in these two subclasses, obtaining a total of 61 tags in the TagPersonal class and 825 in the TagCommon class, as is shown in the following table (Table 5).
In Table 5 we show how the 886 tags in the ontology have been distributed in these two subclasses: a total of 61 tags fit in the class TagPersonal whereas 825 tags fit in the TagCommon class.
61 825 This division offers the possibility of improving the habitual browsing mechanism used in folksonomies, as clouds of tags, showing only the common tags (TagCommon), and discarding the personal tags that usually are not interesting in a general browsing. Furthermore, this reduction in the number of tags by grouping different tag variations in only one Tag class instance, also improves the quality and utility of these clouds of tags because it reduces the number of some of the problems detected in them, and allows the inclusion of some tags that would have remained hidden.
A new method for modelling folksonomies with ontologies has been proposed. This method consists of: (1) an ontology able to be used to represent any kind of folksonomy, and (2) an algorithm to transform folksonomies into the proposed ontology and to update the resulting ontology as the folksonomy evolves in time. Estimation on the size of the ontology has also been proposed that allows knowing the system requirements before the transformation.
The representation model proposed in the ontology allows to solve two of the main problems identified in folksonomies in relation to searches and browsing limitations, namely (1) tag variations like plurals, verb tenses, synonyms, misspellings, etc., and (2) the different objective or type of the tags used by users, considering a separation between personal and common tags. The proposed method has been verified with a dataset obtained from del.icio.us, obtaining the expected improvement in the searching and browsing process.
The representation model proposed here also offers a base for
proposing solutions to other existing problems in folksonomies,
like the deficiency of relations or structure between the existent
tags [
Research partially supported by the Spanish Research Council TIN2006-14738-C02-02