This paper focuses on the incorporation of the Markov Logic Network (MLN) formalism as a plug-in for UnBBayes, a Java framework for probabilistic reasoning based on graphical models. MLN is a formalism for probabilistic reasoning which combines the capacity of dealing with uncertainty tolerating imperfections and contradictory knowledge based a Markov Network (MN) with the expressiveness of First Order Logic. A MLN provides a compact language for specifying very large MNs and the ability to incorporate, in modular form, large domain of knowledge (expressed in First Order Logic sentences) inside itself. A Graphical User Interface for the software Tu y was implemented into UnBBayes to facilitate the creation, and inference of MLN models. Tu y is a Java open source MLN engine.
In the past decade, several languages have been proposed to deal with complex
knowledge representation problems that also need to deal with uncertainty. A
frequent approach is to combine both logic and probabilistic formalisms resulting
in a powerful model for knowledge representation and treatment of uncertainty.
Some examples of these approaches were build and have been improved
every day as Markov Logic Networks (MLN) [
Markov Logic Network (MLN) is a principled formalism which combines
First-Order Logic (FOL) with Markov network (MN). An MLN, basically, is
a rst-order knowledge base where a weight is assigned to each formula. The
weight of a formula indicates how strong the formula is as a constraint. Together
with a nite set of constants, an MLN can be grounded as a Markov network.
This way, a MLN can be seen as a template for building Markov networks [
There are a few implementations for MLN like Alchemy [
This paper presents an implementation of a Java tool that consists of a GUI to
facilitate the task of making inferences, creating, and editing MLN models. This
tool was developed at the University of Brasilia (UnB) and uses the software
Tu y as a library. Its current features include GUIs for modeling terms of a
knowledge base into a tree structure and for searching them in order to help the
user nd terms easily in large models. Moreover, it is also possible to edit and to
persist these structures as a standard MLN le (compatible with both Tu y and
Alchemy). Besides that, every parameter that can be set on Tu y can be easily
set in the GUI. It even supports the addition in the GUI of new parameters that
might be present in future versions of Tu y using only a con guration le. This
tool was implemented as a plug-in for UnBBayes, a Java open source software
developed at UnB that is capable of modeling, making inferences and learning
probabilistic networks [
This paper is structured as follows. Section 2 presents the MLN. Section 3 overviews some implementations of MLN and presents the major reasons for choosing Tu y as the application programming interface (API) behind this plugin. Section 4 introduces the GUI developed as a plug-in for UnBBayes. 2
A knowledge base of First-Order Logic (FOL) can be viewed as a set of
constraints on possible worlds. Each formula has an associated weight that re ects
how strong this formula is as a constraint [
Maximum a Posteriori (MAP) inference (i.e. nding the most likely state of the world consistent with some evidence) and marginal inference (i.e. computing arbitrary conditional probabilities) are common approaches to making inferences in MLN. Learning algorithms are used to build, from historic data, models that represent a problem to be treated. For this formalism, learning methods are used to construct or re ne a MLN. Two types of learning are speci ed: weight learning (i.e. which tries to nd the weights of the speci ed formulas that maximize the likelihood or conditional likelihood of a relational database) and the harder technique of structure learning (i.e. which tries to learn the formulas themselves).
More details on MLN can be found in [
With the intent of building a GUI for MLN, the rst step is to implement or
nd an existing implementation of the formalism. So, pros and cons of some
implementations have to be analyzed. If no implementation had compatibility with
UnBBayes, it would be necessary to create a new one. Fortunately it was not
the case. The pros and cons of the more common implementations are presented
below. As our goal was to build a plug-in for UnBBayes, the programming
language had a larger weight than the features available on the tool. UnBBayes [
Alchemy is the reference for other implementations of MLN and is the most complete of them. It covers MAP Inference, marginal inference, weight learning, structure learning and other features from each of the mentioned topics. Alchemy is an open source software developed in C/C++. It does not have a GUI and it works only in Linux or Linux shell emulator. Alchemy was the rst option to extend, but its programing language is not easily integrated with Java. 3.2
TheBeast [
ProbCog is an open source software for Statistical Relational Learning that supports learning and inference for relational domains. Merged to ProbCog, is PyMLN, a toolbox and a software library for learning and reasoning in MLN. It has a GUI for MLN but it, seemingly, shows the necessary les for inference and the main parameters to be more easily selected, but nothing beyond the basic. Most of the code of ProgCog is developed in Java, although its MLN tool is developed in Python. 3.4
Tu y Tu y is an open source Markov Logic Network engine. It is developed in Java and makes use of a PostgreSQL database. Tu y is in version 0.3 and is capable of MRF partitioning, MAP inference, marginal inference and weight learning. Since Tu y has many similar features to Alchemy, as weel as the same structure for input les, it has no GUI, and it is implemented in the same programming language as UnBBayes, it ended up being the most suitable MLN implementation to be used in the MLN GUI plug-in. 4
The GUI for MLN There are several helpful easy to use GUI tools for Bayesian networks. However, this is not true to MLN yet. For most of them, the only way to make it work is to set command line parameters and then enter commands through a console. Sometimes you must memorize a bunch of commands if you want to realize a task fast, while you could just press buttons and choose options with some clicks in a more easy to use GUI interface. Creating a GUI to simplify this process of designing and using MLNs was the main motivation of this research. The following paragraphs describe the main features of a proposed GUI for MLN.
This project of a GUI for MLN into UnBBayes was built as a JPF plug-in. The plug-in structure provides a way to run a new project inside the running environment of UnBBayes. The bind between the new plug-in and the core of UnBBayes happens in a way that no changes are needed in the core structure.
Basically, building new plug-in implementations for UnBBayes is really
simple, since a stub implementation is available in [
Figure 1 presents the GUI divided in numbered parts. Each part is described bellow.
The Tu y input les are: a MLN le (.mln), an evidence le (.db) and a query le (.db). The last one can be replaced passing its content through command line. Figure 1 Part 1 shows the possibility to load this three les and the possibility to send the query predicates through a text eld.
When the MLN le and the evidence le are loaded, their terms (i.e. predicates, weighted formulas and evidences) are separated and organized in a tree structure as shown in Figure 1 Part 5. This tree structure gives a great gain of visualization and di erences between structures into the MLN.
Figure 1 Part 2 presents a very useful search tool. It searches dynamically predicates, formulas, and evidence that match the inputted string. This feature is useful when working with very large MLNs.
The GUI also presents a way to add and remove predicates, formulas and evidence. This feature is shown in Figure 1 Part 3. Lots of terms can be directly inputted into the correct classi cation. The deletion is made from a drop down list which brings to the user all the existing terms. Every change made through this feature is persisted in the original le. This feature makes it easier for the user to include or remove terms in a MLN model.
Figure 1 Part 4 allows the user to choose what inference method to use and the button to trigger the inference process, which will be executed by Tu y in the background. Tu y is embedded into UnBBayes and used as a library through its API.
Figure 1 Part 7 is displayed when the "inference" tab is chosen. It presents the output in a text area, the same way that it is presented in the output le in Tu y.
Figure 1 Part 6 presents the parameters of Tu y in an easy way to set and save. The parameters of Tu y were parameterized by type that they represent (e.g. integer, oat, boolean and string). This allows the parameters to be loaded to the interface from a con guration le and new parameters added in new versions of Tu y can be easily incorporated to UnBBayes without the need to change any programming code. The dynamic values of the parameters are de ned in another con guration le. 5
This paper presents a GUI for Tu y, a Java Markov Logic Network inference engine. As shown, this GUI facilitates the task of creating MLNs models and reasoning with them. This GUI was implemented as a JFP plug-in for the UnBBayes software. UnBBayes and this plug-in1 is available from http:// unbbayes.sourceforge.net/ under GPL license. 1 This plug-in can only be downloaded from the SVN repository. Soon a distribution will be released for simple download and installation.