In order to make current Web resources understandable by computers and make possible the Semantic Web vision, we need to add semantic metadata to such Web resources. In this paper we describe the SQAPS system, which aims at providing a mean of exploiting for semantic annotation the e®ort of users who every day look for information on the Web. We also describe how we can take bene¯t of the information generated and maintained by Web Communities as Wikipedia in order to achieve our goal.
In order to make current Web resources understandable by computers and make
possible the Semantic Web vision [
As the current Web has a huge number of heterogeneous resources, semantic
annotation can be seen as one of the core challenges for building the Semantic
Web [
So, in [
One of the main drawbacks of the system described in [
In this paper, we want to consider a more dynamic approach. Instead of using
a static lexicon, we want to explore the possibility of using as knowledge source
the evolutive information produced and maintained by a Web community. We
will show how information from Wikipedia community [
The rest of this paper is organized as follows: next section introduces the SQAPS system in order to make the paper self-contained. It describes brie°y the SQAPS architecture (2.1) and working model (2.2). Section 3 explains how Web Communities, and particulary Wikipedia Community, can be used in our bene¯t in the context of SQAPS. Section 4 brie°y describes some related works from the world of semantic annotation. Section 5 introduces, with discussion purposes, a set of issues related with SQAPS system. Concluding remarks in section 6 ¯nalize this paper. 2
In this section, we brie°y introduce the SQAPS system. This description has been
included in order to make the paper self-contained. More information about the
system, in particular, a detailed description of SQAPS ontology can be found in
[
Query Analysis Its main purpose is to allow the annotation of a keywordbased query by the user. In order to do so, the Query Analysis component divides the query into candidate terms, each of which consisting of a word or sequence of words of the query, which can represent at least a unit of meaning. In order to associate terms and meanings, and decide what are the pairs [term,meaning] interesting for the user purposes, the Query Analysis component uses the information of a Semantic Source, and asks to the user about his interests.
Semantic Source Intended to provide concrete meanings to terms. In our context, a Semantic Source should provide at least a list of terms, and for each term, a set of possible meanings with their human-readable descriptions. A unique identi¯er for each pair [term, meaning] should also be provided. Knowledge Repository It stores the semantic annotations de¯ned by the user, and also a part of the annotations that other users have de¯ned and shared (a part of the DHT). This Knowledge Repository can be accessed by the local user, but also by other peers in the SQAPS P2P network. It also can access remote repositories of other peers.
Query Execution Receives as input the annotated user query and looks for relevant resources in the Knowledge Repository. If results are found, these are shown to the user, which can decide to look for more information or not. If no results are found, or the user requires more information, this module takes the keywords from the annotated query and sends such keywords to a classical Web search engine. The results are shown to the user, who can annotate a resource by clicking on a button. By doing so, the user states that the resource is relevant for the annotated query and a pair [URL, RDF document representing the semantic query], is inserted into the Knowledge Repository and into the annotation sharing P2P network.
P2P Network Main functionality of SQAPS system is semantic annotation
creation and sharing. For this purpose, the basic functionality of the P2P
network will be to allow annotation sharing. In our system, annotations are
associations of URLs representing Web resources and RDF documents
representing the semantic annotations of such resources. With these requirements,
we have decided to rely on Distributed Hash Table (DHT) P2P networks,
which o®er good performance both in scalability and response time [
In order to clarify the purposes and operation model of all the SQAPS
architecture components, we provide a basic example of the intended annotation process
of our application. Figure 2 shows the main steps in this annotation process.
These are:
1. The process starts with a user writing a keyword-based query. For instance,
let us assume that the user is looking for information about Caml
programming language, and he types as a query Caml programming language. This
textual user query is sent to the Query Analysis block, which divides such
query into candidate terms. For instance, the candidate terms originated in
the analysis of our example query are Caml, programming, language, Caml
programming, Caml language, programming language and Caml programming
language. Sections of query between quotes are treated as a single term and
not divided. As some studies suggest, typical user queries are not too long
(only a 25% with three or more words) [
If we assume that the user is a computer scientist that usually looks for information about programming languages, it is possible that he had used the term programming with the second sense in past queries/annotations. In such a case, this pair [term, sense] should already be in the Knowledge Repository. Then, the senses of the term programming would be ordered so that the ¯rst one to be shown to the user would be the one most related to the expected user's interests. Once the list of possible meanings of each term is sorted, the system displays to the user the possible interpretations of the found terms.
Given the list of possible terms and meanings, the user selects the combination that better re°ects his intention, annotating the query. Several possibilities may arise here: { None of the terms appears in the Semantic Source, or the senses included there are not good to re°ect user intentions. In such a case, the user can simply decide not to annotate the query. This unannotated query is sent to the Query Execution component, which simply forwards the query to a classical Web search engine and returns the results. As in this case we can not generate an annotation, we have not included this situation in ¯gure 2. { Part of the terms are found, and the other ones are not found, or the meanings in the Semantic Source do no re°ect user intentions. Then the result will be a partially annotated query. A problem which might arise in this situation, is that it could give origin to alternative query interpretations. For instance, let's assume that the user has typed the query Caml Light programming language. The term programming language is found in the Semantic Source and the user annotates it, but he tells nothing about the other query components. Then the problem comes from the fact that the system can interpret the rest of the query in two di®erent ways: as having two di®erent terms, Caml and Light, or as having only one, Caml Light. At the moment the approach we are following is to use the information as provided by the user: if he has typed Caml and Light as di®erent words, they are interpreted as di®erent terms, and if he has typed "Caml Light" a single term will be generated. Other approaches, like for example analyzing the textual contents of the resource being annotated, in order to ¯nd which of the interpretations is the most frequent in such contents, might be explored in the future. Another aspect which should be noted here, is that, though some of the terms of the query are annotated and some others not, we will store all the terms in the ¯nal annotation. The reason for such decision is that we expect that human users can view annotations of resources, and we think that removing unannotated terms could produce a loss of context information, which could be useful for such users.
{ All the terms are found and annotated by the user.
In the last two cases, the result will be an annotated query. Let us assume that this is our situation, and the user has generated an annotated query composed by terms Caml (not annotated) and programming language. Following steps show how this annotated query is handled to generate a Web resource annotation. 4. The annotated query is sent to the Query Execution system. This system ¯rst looks into the Knowledge Repository in order to ¯nd possible useful resources for user's interests. The Knowledge Repository component looks for information in its local contents and results are shown to the user as a URL list (may be empty). Currently only local contents of Knowledge Repository are explored. Of course we can think on the possibility of sending queries to other SQAPS peers implementing a kind of P2P Semantic Web Search engine facility. But, at the moment, the main functionality of SQAPS system is semantic annotation, so this facility is left for future work. 5. If no results are found, or the user requires more information, the Knowledge Repository takes the keywords from the annotated query (that is, the sequence of words Caml programming language in our example) and sends them to a classical Web search engine. The results of this engine are shown to the user as a list of URLs (may be empty). 6. If the list of results is not empty, the user can click on a URL, visualize a resource and, using a button in the GUI, he can associate the last semantic query to the resource being displayed. As a result, an RDF annotation is generated and inserted into the Knowledge Repository, which also inserts the annotation inside the SQAPS network in order to share it with other peers. As the only way to include an annotation is by clicking on the button, the user can decide at any moment the information to be shared, minimizing privacy problems. 3
In section 2.1 we have introduced the Semantic Source component of the SQAPS system. This Semantic Source should provide at least a list of terms, and for each term, a set of possible meanings with their human-readable descriptions. A unique identi¯er for each pair [term, meaning] should also be provided. The purpose of this information is to help the human user in query term annotation.
As we have said, in the ¯rst version of SQAPS, we proposed the usage of WordNet as Semantic Source. As we have also said, the problem with that approach comes from the fact that we use a static Semantic Source and knowledge is evolutive in nature: new concepts appear, others can change their meanings, etc.
Of course, new versions of WordNet can appear with time, and we can think on just updating the WordNet version of all SQAPS peers. But, from our point of view, this approach has three limitations: { Updating the software of big amounts of distributed peers could be a problematic issue. { We should rely in WordNet providers to get new Semantic Source versions. { Knowledge evolves faster than new Semantic Source versions appear.
In order to address these di±culties we can think on allowing users to add new concepts to their own Semantic Sources. So, if a user is interested on a new concept, he can add it to his Semantic Source as soon as it appears. A possible problem with this approach is that di®erent SQAPS peers will have di®erent Semantic Sources, because personal user entries may di®er from one peer to another. If we want annotations de¯ned using personal concepts to be useful for other users, we need to de¯ne mappings between all those personal entries, which is a problematic issue.
The situation that we have just described is not a particular problem of
WordNet. We can have the same problem if we use other ontologies or knowledge
bases in the state of the art as Semantic Sources: we need to update their contents
as knowledge evolves. Taking this into account, in this paper we want to explore
a di®erent approach: use the information generated and maintained by Web
Communities as knowledge source for the query annotation process. In particular
we have decided to use the information on Wikipedia [
The Wikipedia project began on 2001 with the objective of producing a free
content encyclopedia that could be edited by anyone. It has several interesting
properties which make it attractive for our purposes:
Active community As is described in [
Quality of contents As indicated in [
In order to take advantage of the information in Wikipedia, we plan to use its information as our Semantic Source. In ¯gure 3 we can see the SQAPS resultant system architecture. As can be seen, we will make use of wrappers to automatically process Wikipedia HTML pages. This is possible because such pages have a similar structure, which eases their automatic processing.
The objective of our wrappers is to obtain the information required for our purposes, which basically consist of: { The term, the Wikipedia entry name. { A description of its meaning in natural language, which will be an snippet automatically extracted from the beginning of the Wikipedia page. { An identi¯er, which in our case will consist of the Wikipedia page URL.
In order to implement the wrappers which will allow us to extract information
from Wikipedia pages, we are using a extended version of the WebL language
[
import Str, Files, Forms, XPath; var params = Rest(ARGS); var lang = First(params); var words = Rest(params); var query = ""; every word in words do if query == "" then
query = word; else
query = query + "_" + word; end; end; try var url = "http://" + lang + ".wikipedia.org/wiki/" + query; var Page = GetURL(url); var Header = Select(Elem(Page,"h1"), fun(a) a.class == "firstHeading" ? false end)[0]; var Div = Select(Elem(Page,"div"), fun(a) a.id == "bodyContent" ? false end)[0]; var P = Elem(Div,"p")[0]; var text = Select(Text(P), 0, Str_IndexOf(".", Text(P))); var term = Text(Header); PrintLn("Identifier=" + url); PrintLn("Term=" + term);
PrintLn("Description=" + text + "..."); catch E on true do
PrintLn(E.type); end;
Of course this is just a simple script version, used to show the possible
aspect of a WebL-based wrapper. The example script does not take into account
things as the existence of disambiguation pages like [
Apart from semantic annotation tools, collaborative bookmarking systems
as [
As far as we know, the main di®erences of SQAPS approach with respect to all these works are: { These systems do not exploit the annotation of keyword-based user queries in annotating Web resources, as proposed by SQAPS system. { Exploiting the information maintained by Web communities, like Wikipedia, as knowledge source for the annotation process is also not suggested by these works. 5
The approach that we have introduced in previous sections is still a work in
progress. From our point of view it has some negative aspects which are described
in this section for discussion purposes:
{ The semantics o®ered by Wikipedia is not very formal. Wikipedia can not
be currently seen as an ontology or knowledge base. Basically it o®ers the
semantics of a semantic network of linked topics, being such links between
topics untyped. From our point of view, we have here a tradeo® between the
degree of formalization of our Semantic Source and the easiness of modifying
it: the more formal the Semantic Source, the richer the semantics that it
o®ers, but the more di±cult is to maintain that knowledge. In any case,
we can ¯nd in the state of the art proposals for making Wikipedia a more
formal source without making much more di±cult the edition process [
This could be a way of addressing this limitation. { If the structure of Wikipedia pages changes, we need to update our wrappers, so software maintenance is still required. But, from our point of view, knowledge evolves faster than Wikipedia pages structure, so the updating process in this case seems less critical than in the WordNet one. { We have not a local Semantic Source, but a remote one. We need Web connection and the Wikipedia being operative in order to search our new Semantic Source. But, given that we also need Web connection and a Web search engine being operative in order to be able to annotate a Web page, we consider that this is not a critical drawback. 6
In this paper we have described the SQAPS, Semantic Query-based Annotation, P2P Sharing, system. The main idea behind this system is to exploit keywordbased user queries in semantic annotation of Web resources. Instead of annotating directly Web resources, as most of current systems in the state of the art suggest, we have proposed a system in which users annotate their queries. In order to share these keyword-based semantic annotations with other SQAPS users, a DHT P2P infrastructure is used.
From our point of view, this alternative approach to annotation of Web resources has the advantage that can exploit the e®ort of the millions of users who every day look for information on the Web. Additionally it supports the annotation of di®erent kinds of resources. This is so because in the context of the SQAPS system, an annotation is an association of a certain URL, representing a Web resource, and a semantic query. As resources can be multimedia ¯les and not only text or HTML, in principle the annotation of multimedia items is supported, but, of course, only in the case that those items can be retrieved using a keyword-based query and a classical Web search engine.
An additional feature of the SQAPS system version introduced here is that it exploits the information generated and maintained by Wikipedia Web community for the annotation process. This has the advantage that the source of knowledge evolves with time instead of being static, as it was in the former SQAPS version. Additionally, we are planing as future line to integrate the Wikipedia edition process with SQAPS, so as soon as a user detects that some of the terms in his query are not included in Wikipedia he can have the possibility of adding the new contents by himself.
On the negative side, one of the main drawbacks of our system is the dependence on user collaboration. In relation with this, from our point of view, integrating the annotation activities with habitual user actions, such as Web search, should be a point in favor. Moreover, if we take into account that queries are not too long, and that query processing is partly done by the system, we expect that the work ¯nally done by the users will imply a low overhead compared to classical keyword-based search.
In any case, we need to test the concept behind our system and its usability. In
order to do so we are currently working on a ¯rst basic prototype of the SQAPS
system. It is being developed as a standalone Java application, using Jena [
This work has been partially funded by the Ministerio de Educacio¶n y Ciencia de Espan~a, as part of the Info°ex Project, TIC2003-07208.