Category Archives: Software

Ontology Game: Humans Matching Concepts

A new “ontology game” has recently been announced, as a “game with a purpose” to help get humans to categorize objects properly according to a formal ontology.

How it Works

The game operates in a way that’s similar to Google’s image tagging application; pairs of users who do not know one another are presented with the abstract from a Wikipedia page, and they have to choose categories in an upper ontology that accurately describe the article. (E.g. does it correspond to an abstract concept? An agent? A happening?) Users get points when both users choose the same answer to categorize an article. As the game goes on, the categorization gets more and more specific until it “bottoms out” in the upper ontology. At that point, you jump to a new article and start the process over again.

Gameplay

In terms of gameplay, it feels a little bit rough in part because the game doesn’t choose the articles very intelligently. (In one case, I got the same article twice in a row) Also, after you tag 5-6 different articles, the player has a good working knowledge of the taxonomy of the upper ontology, and it becomes less fun as the game devolves into categorization along lines you’ve seen many times before. The key difference here from Google’s image tagging game is that in Google’s game, people enter free-form words, so your input is almost limitless. Oh, and one other thing – in order to categorize properly, you have to read the 2-3 sentence descriptions of what the categories mean, which can take some time the first time around when you have 6-7 categories to choose from.

These don’t appear to me though to be fatal problems for the game, just teething problems. It could be fun if the data set was widened substantially, and the category choice perhaps narrowed a bit. And of course in the background, they’re building an interesting data set mapping Wikipedia articles to high-level concepts of what they represent.

Background

Here’s the original announcement email from Martin Hepp at DERI

We are proud to release the first one in our series of online computer
games that turn core tasks of weaving the Semantic Web into challenging
and interesting entertainment – check it out today athttp://www.ontogame.org/

A very early paper written in late Summer is in Springer LNCS Vol.
4806, 2007, pp. 1222-1232 [1].

A complete Technical Report including our quantitative evidence and video footage will be released shortly on our project Web page at http://www.ontogame.org/

The next series of games for other tasks of building the Semantic Web is already in the pipeline, so please stay tuned ūüôā

Please subscribe to our OntoGame mailing list if you want to be informed once new gaming scenarios or results are available. See [2] for details on how to subscribe.

What is it good for?
====================
Despite significant advancement in technology and tools, building ontologies, annotating data, and aligning multiple ontologies remain tasks that highly depend on human intelligence, both as a source of domain expertise and for making conceptual choices. This means that people need to contribute time, and sometimes other resources, to this endeavor.

As a novel solution, we have proposed to masquerade core tasks of weaving the Semantic Web behind on-line, multi-player game scenarios, in order to create proper incentives for humans to contribute. Doing so, we adopt the findings from the already famous “games with a purpose” by von Ahn, who has shown that presenting a useful task, which requires human intelligence, in the form of an on-line game can motivate a large amount of people to work heavily on this task, and this for free.

Since our first experiments in May 2007, we have gained preliminary evidence that (1) users are willing to dedicate a lot of time to those games, (2) are able to produce high-quality conceptual choices, and, by doing so, (3) can unknowingly weave the Semantic Web.

Acknowledgments: OntoGame is possible only thanks to the hard work of the OntoGame team – special thanks to Michael Waltl, Werner Huber, Andreas Klotz, Roberta Hart-Hiller, and David Peer for their dedication and continuous contributions! The work on OntoGame has been funded in part by the Austrian BMVIT/FFG under the FIT-IT Semantic Systems project myOntology (grant no. 812515/9284), http://www.myontology.org, which we gratefully acknowledge.

And now…. play and enjoy!

Best wishes

Martin Hepp and Katharina Siorpaes

Work progressing on Ontrospect…

As I posted about before, I have a little project I’m working on.¬† Over the past couple of days, I managed to implement annotations in the system, which is basically the ability to add an arbitrary RDF triple to a separate model that “describes” another model.¬† For example, take the pizza ontology.¬† Of course this file is read-only because it’s on someone else’s site.¬† Annotations in Ontrospect would allow you to add extra triples to another model (let’s call it “Annotations: Pizza”) that make statements about resources in the pizza ontology.

The annotation could be a regular OWL or RDF assertion (such as indicating the type of a resource, or claiming that something is a subclass of something else) but it could also be a comment, a text tag, or more importantly a link to a completely different ontology.

I’m interested in this as a prototype system for building mappings between ontologies.¬† Hypothetically, you could for example take two upper ontologies and create links between them using these annotations.¬† For example, load the SUMO ontology into the program, and then link specific classes in SUMO to classes within DOLCE-lite.¬† (It could be something as simple as owl:sameAs, but would probably need to be something more sophisticated)

Where this becomes useful is when you union multiple models together with their annotation models.¬† You can then use that as a basis for reasoning across multiple ontologies, allowing you to work with mixed data.¬† An interesting other consequence is that it (hopefully) could make the semantic web read/write, instead of just read only.¬† The pizza ontology is out there, and you can’t change it.¬† What you can do is create your own set of annotations, and then publish a new model that is the pizza ontology union’d with your annotations – in effect a different model.

Prototype screenshots: Ontrospect 0.01 alpha

Here are some screenshots of the model view, the class view, and the query view respectively.

This stuff is basically a thin web wrapper around the normal functionality that Jena provides.  Click the thumbnails for a full-size screenshot.

Screenshot 1

Screenshot 2

Screenshot 3

This query screen shot shows off Jena’s support for the SPARQL query language, which is nice.¬† Database persistence in this example is provided by Derby, the Apache Foundation’s all-java RDBMS.

Experimentation with Jena & prototyping

Over the past few weeks, I have been experimenting with a prototype application written using the Jena framework. Jena is a fairly decent library that supports RDF, OWL, and DAML+OIL ontologies, as well as reasoning across those models.

The basic prototype that I’ve built allows you to view and navigate individual models, as well as perform some basic set operations on those models, such as inspecting their union and difference. Most of what the prototype does right now is just an effort to teach myself the functionality of Jena rather than to build an application that does anything revolutionary.

The prototype itself might have a useful life as an Internet-accessible service to browse ontologies that would otherwise be opaque XML files. I’m not really as interested in the browser functionality right now though.

Where I’d really like to take the application is to be able to make it a feed generator for all things semantic web. For example, let’s say there are two ontologies, A and B, hosted on two different sites. What I’d really like is a system that:

  • Allowed users to subscribe to an RSS feed that contained changes or updates to those ontologies over time
  • Allowed users to subscribe to a feed that corresponded to the union (or difference) of those two models
  • Provided a facility for arbitrary external annotation of those ontologies.
    • Allow users to specify which classes in A are equivalent to which classes in B
    • Associate comments or additional text or properties to classes in A, but have those assertions be stored outside of A’s serialization. (I.e. “add-ons” for A’s ontology, but not actually stored in the file that is A’s content

I’m running into the same problem with this application prototype as I have with many others in the past. I have reached the point with development that in order to make substantial steps towards the goal functionality requires learning loads and loads of things that aren’t as interesting, in order to know how implementation can happen. Examples of what I mean would include database persistence for ontologies, how to get around jena memory management issues, RSS libraries in java, and existing annotation standards on the web. Learning that stuff requires a substantial time investment that goes beyond the bounds of what I can accomplish in a “spare time” prototype.

Then again, there’s always an application for research funding. If I could articulate the idea a bit more, maybe it could grow legs.