On 01.10.2015 00:13, Daniel Kinzler wrote:
Am 30.09.2015 um 23:38 schrieb Peter F.
I would argue that inference-making bots should
be considered only as a
stop-gap measure, and that a different mechanism should be considered for
making inferences in Wikidata. I am not arguing for Inference done Just Right
(tm). It is not necessary to get inference perfect the first time around.
All that is required is an inference mechanism that is examinable and maybe
To do that, you would have to bake the inference rules into software in the
backend software, out of community control, maintained by a small group of
people. It's contrary to the idea of letting the community define and maintain
the ontology and semantics.
We are actually experimenting with something in that direction -- checking
constraints defined on-wiki using rules written into software on the backend,
hard-coding rules that were defined by the community. It's conceivable that we
might end up doing something like that for inference, too, but it's a lot
harder, and the slippery slope away from the community model seems much steeper
When I started to think about, and work on, wikidata/wikibase, I believed doing
inference on the server would be a very useful. The longer I work on the
project, the more convinced I become that we have to be very careful with this.
Wikidata is a "social machine", cutting the community out of the loop is
detrimental in the long run, even if it would make some processes more efficient.
As you already said, it would be a bad idea to hardcode rules in the
backend, out of community control. But the solution to this is obvious
and already partially realised for constraints: the rules (ontology) can
be part of the user-edited data, and the software would only need a
mechanism for interpreting them. This is still *very* far away from what
I would consider the core tasks of Wikibase development now -- better
get a snappy UI first -- but it is conceivable in the long run. The path
towards this will be via third-party tools, which may also deploy bots
(but maybe one "reasoning" bot rather than an army of them for all kinds
of different inferences).
The first step is to design the rule/ontology language and to provide a
scalable implementation to compute the resulting inferences. We have
started discussion on the Wikiproject:Reasoning, and I am looking into
the technical aspects, but please give me a few more months to get a
proper infrastructure set up there. It would not start with bots that
import anything -- rather one would at first just produce inferences,
display them somewhere, and let the community get a feeling of what
could be worth importing there. It is also possible to add inferences to
a query service/data dump only, avoiding all editing-related questions.
I believe that the community cannot really start writing useful
inference rules without tool support that allows you to preview the
(global) consequences of such rules. I have some initial components for
this, but Wikidata integration is only at its beginning. The goal would
be to set up a public demonstrator this year, which proposes a format
for inference rules and a machine to efficiently compute all of their