Sebastian Schaffert

I recently summarised the different means of reasoning on the Semantic Web in a discussion on the Apache Stanbol mailinglist. I thought I might also share my views publicly in my blog

I think that large parts of the Semantic Web community lost track of the actual (practical) goals of reasoning. Please think of actual, practical use cases. The actual kind of reasoning employed is then derived from this goal – not the other way round. In the following, I summarise the three different possible approaches to reasoning:

schema validation

This is the typical reasoning applied in the Semantic Web domain. I always found its usefulness very limited and therefore this is only mildly interesting to me. How often will you really need to check whether a model is consistent? Usually only during development, if at all. Even worse: when operating on the World Wide Web you will *inevitably* have inconsistencies, so it is better to simply live with them and not care too much about consistent schemas, it will only drive you crazy (see below).

For schema validation, you will probably use some of the existing OWL and description logics reasoners like Hermit, FaCT, Racer, … but be aware that they are all rather complex and inefficient when dealing with bigger datasets, as you identified as a problem yourself.

instance classification

Instance classification means, informmaly, to figure out the type of a resource based on the existance of a schema or ontology for the data. Now this is at least *a bit* more interesting than schema validation, because it provides you with actual new information that you can make use of. It allows you to treat a Blog Post as a Document, a Meeting as a Location, etc. On the other hand, every programmer can implement you this kind of reasoning in a couple of hours in Java without any need of a reasoner.

For instance classification you can in the most simple case use an RDFS reasoner (very efficient). OWL reasoners are obviously also capable of this, but usually in practice not much better than RDFS reasoners so it is not worth the added complexity. Instance classification can furthermore be considered a specific case of implicit/rule-based knowledge.

implicit/rule-based knowledge

In this case, you extend your factual, static knowledge base (i.e. triples) by rules that represent implicit knowledge (e.g. “if a meeting M is located in a place P and P has coordinates X and Y, then M also has coordinates X and Y). This kind of reasoning is the classical way of representing knowledge in knowledge based systems and adds, in my opinion, real additional value to the information, because much human knowledge is actually rule-based. I consider this kind of reasoning the most interesting in an information system. Rule-based reasoners can cover instance classification as a special case and with a few extensions even most parts of consistency checking.

Rule-based reasoning is currently still a bit esoteric in the Semantic Web domain (Jena only uses it for implementing RDFS/OWL reasoning), as the reasoning topic has been “hijacked” by the Description Logics people. I often criticised this because of its impracticality, but noone would really listen There is the RuleML initiative which resulted in the specification of SWRL, but SWRL is seen as an extension of DL reasoning and thus suffers from the inefficiency of these reasoners. Outside the Semantic Web, the most successful rule-based reasoning system is probably Prolog and Datalog, both highly efficient systems but unfortunately not really present in the Java and RDF world.

Inside the “Linked Media Framework”, which we intend to integrate with Apache Stanbol, I have implemented a Datalog-style rule-based reasoner over RDF triples that can be evaluated very efficiently (see the link I sent above for the specification). Even though this reasoner has a quite restricted expressivity, it is still sufficient to cover many useful scenarios.

 On the usefulness of consistency checking for the Semantic Web

1. Why do logics people care about consistency?

The whole topic of consistency checking is rooted in classical logics. It is founded in the “ex falsum quodlibet” rule of first order predicate logic, which basically says “if you have an inconsistency in your model, you can derive everything”. Maybe you still know the rule from your logics lectures

“false => A” is equivalent to “not false or A” is equivalent to “true”, regardless of A.

For example, in a strictly classical model sense, if you have a knowledge base saying “the car is red” and “the car is green” and “green is not red”, then you could derive that “the moon is made of green cheese and inhabited by small fur balls constantly discussing about how to best cook spaghetti”. Which is of course completey stupid, but completely valid in classical logic.

In a model in classical logics, this is a severe problem, because it means that you cannot derive anything useful at all even if you have just a small inconsistency.

2. Why is inconsistency irrelevant in many cases?

Inconsistency is only a problem in the ideal world of classical logics. Real-world implementations will never have the same kind of problems described above, how should they get the idea that the moon is made of green cheese based on the facts that the car is green and red at the same time? Software implementations are maybe constructive, but based on existing facts and not making up facts out of the blue sky.

The worst case that can happen is that the software will show some error behaviour. Instead of trying to enforce consistency (which in many cases you cannot), one challenge is to isolate the error as much as possible and keep it from spreading. Another challenge is to explain to the user why some unexpected behaviour takes place and how she can prevent it from happening.

The rule-based reasoner implemented in the LMF is completely ignorant to inconsistencies. It does not care at all about them. If you say the car is red and the car is green, then it will maybe derive that it should be tagged with “green” and with “red”. The error spreads maybe a bit, but the reasoner will never claim that the moon is made of green cheese. But maybe you were even right that the car is red and green at the same time (striped car)?

The rule-based reasoner implemented in the LMF will also display you explanations why it has inferred certain knowledge. If the car is tagged with red and tagged with green and you as the user wonder how this could be, you can hover the mouse over the tag and the reasoner will explain you that this is because someone said the car is green and someone said the car is red.

3. Why is dealing with inconsistency even desirable?

The world is full of inconsistencies. And the Web in particular. Neglecting this is the number one problem of the Semantic Web DL community. Accepting this is the number one success factor of the Linked Data initiative. Why is the Web so full of inconsistencies?

• people can have differing opinions about the world: you say “it is cold”, I say “it is warm”, and we are both right
• different cultural conceptions: Spanish has one word for “snow”, Icelandic has 16 different words for “snow”
• uncertainties: most circumstances do not fit into the ideal world of logics because of unknown or uncertain knowledge; a document might be concerned with a topic only to 30%, or the Stanbol entity recognition might only have a confidence of “15%” that “San Juan” is a person, “30%” that it is a city, … ; if you say “all ravens are black”, this is entirely based on observation and not on fact, there might be a white raven somewhere, you just don’t know it

Last week was another milestone in the ongoing KiWi dissemination activities: the KiWi, John, Thomas and I went to Vienna by car to present the KiWi system and demo in the Vienna Semantic Web Winter Meetup to Semantic Web developers and then at the ESTC2010 to business oriented people.

The Semantic Web Winter Meetup took place on 1st December at a nice location for cultural events. KiWi was sponsoring the event, and we had both, a KiWi presentation there and a stand where Thomas could show the KiWi system in action. About 60 people attended, and since the meetup was co-located with ESTC and other meetings, there were quite a number of international attendees as well. The picture shows Andreas Blumauer, myself and Leo Sauermann as the three speakers at the end of the event:

And here is the KiWi demo stand mainly supervised by Thomas. We have one laptop running the demo in VirtualBox and powering three big screens at the same time, very nice:

We had a number of nice contacts and discussions at the event and I think it was really worthwhile to attend it. Especially since the audience were mostly practical development oriented and technologically very savy people that might join the KiWi community at some point.

On the 2nd and 3rd of December, we were sponsoring the European Semantic Technologies Conference (ESTC2010) also taking place in Vienna. This gave us the opportunity to again present KiWi in a invited presentation and a demo stand to interested audience, this time primarily industry people with a professional interest in Semantic Technologies. The following picture shows me and the KiWi waiting to give our presentation:

The presentation itself  was well attended (40-50 people) given the fact that many people were participating only the first day of ESTC and that there was a STI International general assembly in parallel. This picture shows the KiWi and me during the presentation:

The KiWi demo stand was also a well visited place on both days. Thomas gave many demonstrations to interested people and I think we left a quite good impression with most of the ESTC participants. In the following picture I have a discussion with Mark Greaves from Vulcan, Inc. in the US:

Even at ESTC we had many interesting discussions, particularly also with venture capitalists, startups and other funding agencies that might take up the KiWi technology. Altogether also a worthwhile event for the KiWi team, and a good opportunity to demonstrate what the KiWi team has achieved in the last years.

With ISWC2010 in Shanghai just over, here are my first random impressions. Positive things first: the conference was very well organised (except Internet, as always), the rooms were comfortable and there were many power sockets, the presentation equipment very good. The demo session was a bit chaotic, though, but as I have already written, we were able to improvise to our benefit. The general setup was also very good, a mixture of research, applications and a bit of industry, workshops and tutorials as always, and also the doctoral consortium, the demo session and the lightning talks – the three things I really like at conferences. Highlights of the conference for me were also the invited talks by mc schraefel and from Facebook and the NYT.

About many other things I was not very happy. First, I found the quality of the presented work often rather low, many presentations were really boring and repeating the same things the community has been working on the last 10 years – someone used the term “least publishable unit”, and I had the impression this holds for many presentations. I cannot really believe that with the low acceptance rate of ISWC there are still so many low-quality papers. But perhaps my notion of low-quality is different than the one of the rest of the community. After 10 years of ISWC, I would have expected more application-oriented results to be presented. Application-oriented in the sense of “solving real-world problems with semantic technologies”. But such papers were only few, even in the in-use track of the conference.

Second, I have the impression that the community is now divided into two large fractions: the “ontologists” and the “linked data people”, and some outsiders like the Social Semantic Web people. When I exaggerate a bit I would say that the ontologists still try to model all the world in schemas, preferrably description logics, ignoring all instance data, and the linked data people only care about instance data, ignoring most schema and ontology work. Even worse, both communities are now facing problems that the others have already addressed, but at least partly ignore the outcomes of the other communities. And both groups behave a bit arrogantly towards each other (and everyone outside). And again, neither of the two is really concerned with solving real-world problems. Which is ok for some time. But after 10 years …

Third, I found the selection of best paper and expecially of the winner of the Semantic Web Challenge really a bit strange. But maybe this is again my different perception of what is a good work (problem driven) and what is not… I would have voted for the Saffron explorer developed by the colleagues at DERI, because it is a useful application with a nice and simple user interface.

And finally, I find the way standardisation is carried out a bit strange (referring to both, RDF 1.1 and RIF). Most of the process is “design by committee”, which only rarely leads to an optimal outcome. Also, problems are only addressed when there is someone interested in solving them, and not because they are important problems that need to be solved. A very academic approach, because I think for the Semantic Web to take of we would also need to address the problems that nobody wants to work on, not only those that are fun.

Enough criticism. Otherwise I really enjoyed the conference, there were many nice presentations as well, many old friends, and many interesting discussions. And I am looking forward to ISWC2011 in Koblenz, particularly to the “Semantic Web Persona Challenge” proclaimed by mc schraefel

After the successful KiWi release party in Vienna, the KiWi has now started its tour around the world: current stop is Shanghai, China, at the ISWC2010 conference, where Thomas and I are representing the project. After several days of workshops, yesterday evening (Shanghai time) finally was our opportunity to present KiWi for the first time outside Europe at the conference’s demo session. Since the convention centre is apparently not prepared for demo and poster sessions, we had to improvise a bit in the beginning (carrying around tables and chairs), which in the end resulted in an even better demo booth than we usually have. A table full of KiWi dissemination material!

Many guests attended our demo, so that we were really happy that we both went to Shanghai instead of sending only one person. Since we had a large table, we could give the KiWi demo at two laptops in parallel! We had many interesting discussions, and I think that we could get quite a lot of people interested in the project. KiWi has so much to offer that there is something in it for almost all conference attendees. I didn’t check the download figures yet, but I am sure they are going to increase. Just a pity that we only had 3 hours (2 were planned) to give the demo …

Tags: kiwiknows

Last thursday was the big day for the KiWi project: after more than 2 and a half years, we have been able to proudly present the version 1.0 of our KiWi platform! And the location was very fitting for a research project that tries to bring new and innovative ideas into the public: the “Planetarium” in Vienna, a place where people usually look into the sky and the stars, can dream of places far away, …

As always, the KiWi release was a “just-in-time” job. We uploaded the final KiWi version to Google Code at 11:05, left the office for the train at 11:15, and then built up an ad-hoc network in the Railjet to Vienna to prepare the remaining issues: copying USB sticks, preparing the demonstration, preparing the booths, etc. We definately had much fun on the train. And luckily, when we arrived, almost everything was already prepared by Julia, John, and the Semantic Web Company people in Vienna.

The release party itself was a great event: after an inspiring keynote talk by Ross Gardler of the Apache Software Foundation, it was my turn to presented the demonstration that Thomas had prepared in the last days. I must say the system we were able to present is now something that is nice to present, rather stable to use (for a research prototype) and interesting to see.

After the presentations, we continued the evening with drinks and nice food at the bar – a nice opportunity to talk with interesting people. We also had several booths where the KiWi team offered to try out KiWi and helped in installing the system on the laptops of the guests who were interested. We had around 100 guests altogether at the release party, a good mixture of IT people, researchers and journalists. I am really looking forward to working with the interesting contacts we made…. The video gives a good  impression of the release party:

And finally, here is the collection of the most important pictures of the release party …

[Mit PicLens anzeigen]