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

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.

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

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 …

• Reasoning. This is the first release to include KiWi’s rule-based reasoner. The reasoner applies rules to triples in the triple store and allows to infer new triples based on this information. Rules can currently only be specified by developers (in a file called rules.txt), but we intend to open this to advanced users of the KiWi system. Evaluation is currently forward chaining with reason maintenance. Reason maintenance can also be used to “explain” to the user why certain triples have been inferred. This is for example visible in the “References” widget of the wiki when hovering the mouse over an inferred relation. The reasoning component has been implemented by Jakub Kotowski at the University of Munich.
• Querying. The 0.7 KiWi release also for the first time features the new and innovative querying component called “KWQL”. KWQL is an advanced query language that can be used as a replacement for the normal KiWi semantic search. It allows advanced query constructs for querying the structure of KiWi content in a simple-to-use language. KWQL also offers a visual query editor for composing queries. KWQL can be accessed by issuing an ordinary search and then clicking on “KWQL” besides the search input field. KWQL has been implemented by Klara Weiand and Steffen Hausmann at the University of Munich.
• Information Extraction. The 0.7 release of KiWi has also included a variety of different information extraction technologies (and more to come!) based on GATE and Semantic Vectors. For the moment, information extraction can be used for tag recommendation and recommendation of related articles. Using GATE, English or German texts can be analyzed and more precise tag recommendations can be made. Information extraction has been integrated by Marek Schmidt at the Technical University of Brno.
• Personalized Search. KiWi also now includes an option to personalize the search results based on the previous tagging activity of the user and the tags associated with the search results. To access personalized search, simply click on the “personalized search” checkbox in the search interface. Note that personalized search requires that you already have some information in your user profile (primarily  tagging behavious). Personalized Search has been implemented by Nilay Coskun and Fred Durao at the University of Aalborg.
• Community Equity. Release 0.7 is also the first KiWi version to have Sun’s Community Equity algorithm integrated in the system. Community Equity is an algorithm that tries to determin the “social value” of information in a collaborative system by tracking how much interest is generated about a certain item. Community Equity is pretty sophisticated, featuring also an aging algorithm that avoids reputation being built up ad infinitum. Community Equity has been implemented by the Community Equity team at Sun (Josef, Dimitri, Max) and integrated by Mihai Radulescu at Salzburg Research.
• Optimistic Locking. KiWi 0.7 switched the data and transaction model to more error-proof optimistic locking; this also makes the system more reliable in concurrent situations, i.e. if two users change the same content. Optimistic Locking has been implemented by Stephanie Stroka at Salzburg Research.
• Simplified Setup. When starting for the first time, users are now guided through a semi-automatic setup process that makes configuring KiWi much simpler than it used to be. The setup process has been implemented by myself, and Mihai is now working on making it even more simpler, allowing users also to configure database and path settings via the Web-based interface.
• TagIT2. The TagIT application has been completely reimplemented and is scheduled for beta-testing starting January. New features are a completely new user interface, the possibility to display users in addition to news and blog posts, and many usability improvements. TagIT2 has mostly been implemented by Thomas Kurz at Salzburg Research.

There have been many smaller enhancements that I cannot mention here in detail (Exhbit support, Facebook integration, FOAF+SSL integration, …) and even more bug fixes. Thanks a lot to all project members for their participation!

Availability

As usual, the KiWi release is available at the following locations:

• binary download (bundled with JBoss, ready-to-run): http://kenai.com/projects/kiwi/downloads/download/kiwi-jboss-0.7.zip (250 MB)
• source download: please use the KiWi Subversion repository at https://svn.salzburgresearch.at/svn/kiwi/KiWi/trunk (latest revision) or https://svn.salzburgresearch.at/svn/kiwi/KiWi/tags/0.7 (0.7 release)
• showcase/demo: the latest KiWi version can also be tried out at our showcase installation at http://showcase.kiwi-project.eu/KiWi/ ; be aware that the showcase is erased regularly and we don’t have much content in it currently (note: the showcase has been shut down over Christmas because vandals are misusing it for distributing their spam links and I don’t have the nerve to look at it over Christmas!)
• issue tracking: please use the KiWi Jira at http://wiki.kiwi-project.eu/atlassian-jira/browse/KIWI to report any issues you encounter
• help: please use either the KiWi developer mailinglist (kiwi-devel@kiwi-project.eu) or the issue tracking for the moment; we are currently also in the process of setting up a wiki for the project

Road Map

Undoubtedly, version 0.7 still contains many bugs. In the weeks after Christmas, we will therefore likely release minor updates improving the stability and reliability of the system. These will be numbered 0.7.x.

Version 0.8 of KiWi is scheduled for end of February 2010. It will have improved Community Equity support, first draft of permission management, and Semantic Forms support. Version 0.9 is scheduled for end of May and will feature an improved user interface and widget support based on SmartGWT. Version 1.0 (final) is scheduled for end of August, with one month of testing.

A KiWi handbook will be written starting September 2010. It will contain not only instructions on how to use the KiWi system but also practical examples and best practices on how it can be used.

Currently, there are several trends on the Internet, which I’ll in the following call “Linked People”, “Linked Content”, and “Linked Data”:

• Linked Content is the most simple to explain; it describes basically the current state of the Web where content can be linked using hyperlinks. It is important to note that this content is meant primarily for human consumption, i.e. human-readable text, images, or other media files.
• Linked Data in contrast describes linking of data that is designed for machine consumption. At the base of Linked Data lies RDF as data exchange format. The people working on Linked Data are organised on the Linked Data website.
• Linked People now is the connection of individuals through the Internet using social networking platforms like Facebook, LinkedIn or Xing. “Linked People” is one of the most exciting developments of the last years and one of the pillars of the ongoing revolution that changes our society.

Many applications follow one of these strands: most traditional Websites are “Linked Content”, most social networking platforms “Linked People”, and there are quite some interesting applications emerging based on “Linked Data”. There are even some applications that combine two of these lines (e.g. Facebook combines Linked People with Linked Content).

What is mostly missing though is a connection of all three strands in one application. Such an application would allow people to connect with each other and share content, but would also expose its data in structured form to the Linked Data cloud (Linked Data Server) to be used by other applications and consume data from the Linked Data cloud (Linked Data Client) to enrich the user experience of the application itself. Our project KiWi with its flexible platform for Semantic Social Software does the first steps into this direction. Henry Story’s FOAF+SSL is also an interesting approach in this area, if combined with social software applications. I believe that in the future we might see many more such applications – at least this is the direction that we will most likely be heading …

KiWi Core System and Collaboration with INSEMTIVES

On Thursday morning, we started with a general presentation of the current state of the KiWi system, mainly showing the demonstration given in Heraklion at ESWC09 (which won us the ESWC Best Demo Award) and in Luxemburg at the KiWi Review. Furthermore, Marek showed the prototype for information extraction and annotation, and Klara a prototypical visual editor for her rule-based query language.

Besides the KiWi core system, Tobias Bürger from STI Innsbruck presented the ideas behind the FP7 INSEMTIVES project to the KiWi consortium as a first step towards collaboration between INSEMTIVES and KiWi (he also blogged about it). We see possibilities for collaboration at several levels: dissemination (i.e. joint organisation of events, joint publications), research (INSEMTIVES results could improve Community Equity) and technology (KiWi platform could be used in INSEMTIVES). We will further investigate a possible collaboration at the INSEMTIVES meeting in Innsbruck next week, where we are invited to present KiWi in turn.

Enabling Technologies

On Thursday afternoon, we took a look at the four KiWi enabling technologies and how they integrate with the rest of the KiWi system. Jakub started with presenting ideas for a rule-based language capable of reasoning over tags and RDF structures (after Klara already presented her work in the morning). We had a lively discussion on the different aspects of the rule languages, how they might be unified and fit together, and how they might serve the other parts of the KiWi system. We decided that what we would need as a first step would be a simple rule-language with forward chaining based on RDF, on top of which more complex ideas would be evaluated.

Next came a discussion on information extraction, based on what Marek presented in the morning. It was agreed that information extraction would be used (1) in the editor to support the user in semi-automatic annotation, and (2) in the importing functionality to automatically extract metadata and perform annotations. The information extraction component works by incremental training with positive and negative examples.

We concluded the afternoon session with a discussion on personalisation. Personalisation in KiWi means primarily recommendations, and secondarily user interface customisation. Peter introduced us into the multifactor recommendation algorithm the group in Aalboarg has been working on in the last year, and we discussed the different factors that might be used, including Sun’s Community Equity. We also discussed where recommendations might be useful.

Logica Use Case

Friday morning started with a presentation of the current state of the Logica use case by Karsten. Karsten introduced into a “formalisation cycle” that moved from collaboratively created unstructured text in the KiWi system to structured data in the Logica Risk Management system and from there back to unstructured text in KiWi. What is currently already implemented is the export from the Logica system to KiWi using a custom templating mechanism. We discussed that we should try to replace this templating mechanism by RDFa only and that we should also investigate RDFa for forms (e.g. RDForms). The connection between unstructured text and forms will then be realised using the RDFa annotation mechanism implemented by Marek.

SunSpace Use Case

The second half of Friday was dedicated to discussing the Sun Use Case, and the technologies and services we would need to integrate there to support the already existing SunSpace intranet. We agreed that it was unreasonable and unrealistic to expect that Sun would replace the existing Confluence installation in favor of KiWi, because the aim of KiWi cannot be to create yet another Wiki engine that competes with what is already there. Instead, in the SunSpace use case, the KiWi system will be more like an intelligent index that integrates content and data from already existing sources and offers additional value in the form of advanced services (e.g. search, tagging, …) and widgets that can be included on the user interface level (e.g. recommendations, tagging, metadata, …). The data integration will make use of existing technologies like Linked (Open) Data. We decided that we would contribute particularly to the update mechanism of Linked Data since this seems to be an issue that is yet not resolved.

A second major point of discussion was the integration of Sun’s Community Equity (CE) with KiWi. We decided that we would head for a rather tight integration at the EJB level rather than at the Web Service level, because then we will be able to use CE more easily for e.g. recommendation and search. This integration will take place until end of August.

Finally, we briefly discussed single sign on for KiWi and correspondingly, Henry‘s suggestion for FOAF+SSL, which Steffi has already mostly implemented in KiWi. Also, an issue still to be solved for the SunSpace Use Case is how to handle permission management in KiWi.

We closed the meeting on Friday afternoon. Most said it was the most productive KiWi meeting we had yet and that we have moved much forward. I just hope that we can also hold the pace.:-)

Note: I will upload figures and pictures as soon as I have them.

Of course, the session was also one of the premier parts of the conference for presenting our KiWi results. We had three posters presented by Klara, Steffi and Thomas, which have apparently attracted a lot of attention. And I was giving the KiWi Demo myself, demonstrating the outcomes of our work in the last 15 months. I cannot write much about the posters (because I didn’t have any time to look there), but the KiWi Demo was definately a huge success. I think I talked more than 3,5 hours non-stop during the demo session, and had many interesting discussions and feedback.

[Mit PicLens anzeigen]

P.S.: I’ll add some photos to this post as soon as the Internet is working a bit more reliably.:-)

The KiWi project was very present at the workshop, being one of the few big efforts in the area:

• Pavel and Marek started with presenting their ideas and prototype on information extraction; it is really nice to see how results get better and better in this area:-)
• Rolf then discussed various approaches to synchronisation of data repositories that are used in the KiWi backend (relational database, triple store, SOLR index)
• Fred and Peter presented different recommendation algorithms that they experiment with in the course of KiWi
• and finally I did a rather short presentation of the KiWi platform, which I then demonstrated in the afternoon’s Open Space session

The star of the workshop, though, was our cute toy kiwi which you’ll likely see on many photos on Flickr & Co. Again, with minimal effort we have generated more awareness than by sponsoring a reception… Here is one such photo showing the SemWiki organisation team with the KiWi: