1724 lines
88 KiB
HTML
1724 lines
88 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||
"http://www.w3.org/TR/html4/loose.dtd">
|
||
<html >
|
||
<head><title>cplint Manual</title>
|
||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||
<meta name="generator" content="TeX4ht (http://www.cse.ohio-state.edu/~gurari/TeX4ht/)">
|
||
<meta name="originator" content="TeX4ht (http://www.cse.ohio-state.edu/~gurari/TeX4ht/)">
|
||
<!-- html -->
|
||
<meta name="src" content="manual.tex">
|
||
<meta name="date" content="2013-09-17 13:02:00">
|
||
<link rel="stylesheet" type="text/css" href="manual.css">
|
||
</head><body
|
||
>
|
||
<div class="maketitle">
|
||
|
||
|
||
|
||
<h2 class="titleHead">cplint Manual</h2>
|
||
<div class="author" ><span
|
||
class="cmr-12">Fabrizio Riguzzi</span>
|
||
<br /><span
|
||
class="cmr-12">fabrizio.riguzzi@unife.it</span></div><br />
|
||
<div class="date" ><span
|
||
class="cmr-12">September 17, 2013</span></div>
|
||
</div>
|
||
<h3 class="sectionHead"><span class="titlemark">1 </span> <a
|
||
id="x1-10001"></a>Introduction</h3>
|
||
<!--l. 31--><p class="noindent" ><span
|
||
class="cmtt-10">cplint </span>is a suite of programs for reasoning with ICL <span class="cite">[<a
|
||
href="#XDBLP:journals/ai/Poole97">15</a>]</span>, LPADs <span class="cite">[<a
|
||
href="#XVenVer03-TR">24</a>, <a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span> and
|
||
CP-logic programs <span class="cite">[<a
|
||
href="#XVenDenBru-JELIA06">22</a>, <a
|
||
href="#XDBLP:journals/tplp/VennekensDB09">23</a>]</span>. It contains programs both for inference and
|
||
learning.
|
||
<!--l. 33--><p class="noindent" >
|
||
<h3 class="sectionHead"><span class="titlemark">2 </span> <a
|
||
id="x1-20002"></a>Installation</h3>
|
||
<!--l. 34--><p class="noindent" ><span
|
||
class="cmtt-10">cplint </span>is distributed in source code in the source code development tree of Yap. It
|
||
includes Prolog and C files. Download it by following the instruction in <a
|
||
href="http://www.dcc.fc.up.pt/~vsc/Yap/downloads.html" >
|
||
http://www.dcc.fc.up.pt/˜vsc/Yap/downloads.html </a>.
|
||
<!--l. 36--><p class="indent" > <span
|
||
class="cmtt-10">cplint </span>requires <a
|
||
href="http://vlsi.colorado.edu/~fabio/CUDD/" > CUDD </a>. You can download CUDD from <a
|
||
href="ftp://vlsi.colorado.edu/pub/cudd-2.5.0.tar.gz" >
|
||
ftp://vlsi.colorado.edu/pub/cudd-2.5.0.tar.gz </a>.
|
||
<!--l. 39--><p class="indent" > Compile CUDD:
|
||
<ol class="enumerate1" >
|
||
<li
|
||
class="enumerate" id="x1-2002x1">decompress cudd-2.4.2.tar.gz
|
||
</li>
|
||
<li
|
||
class="enumerate" id="x1-2004x2"><span
|
||
class="cmtt-10">cd cudd-2.4.2</span>
|
||
</li>
|
||
<li
|
||
class="enumerate" id="x1-2006x3">see the <span
|
||
class="cmtt-10">README </span>file for instructions on compilation</li></ol>
|
||
<!--l. 46--><p class="indent" > Install Yap together with <span
|
||
class="cmtt-10">cplint</span>: when compiling Yap following the instruction of
|
||
the <span
|
||
class="cmtt-10">INSTALL </span>file in the root of the Yap folder, use
|
||
|
||
<div class="verbatim" id="verbatim-1">
|
||
configure --enable-cplint=DIR
|
||
</div>
|
||
<!--l. 50--><p class="nopar" > where <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">DIR</span></span></span> is the directory where CUDD is, i.e., the directory ending with
|
||
<span
|
||
class="cmtt-10">cudd-2.5.0</span>. Under Windows, you have to use Cygwin (CUDD does not compile
|
||
under MinGW), so<br
|
||
class="newline" />
|
||
|
||
<div class="verbatim" id="verbatim-2">
|
||
configure --enable-cplint=DIR --enable-cygwin
|
||
</div>
|
||
<!--l. 55--><p class="nopar" >
|
||
<!--l. 57--><p class="indent" > After having performed <span
|
||
class="cmtt-10">make install </span>you can do <span
|
||
class="cmtt-10">make installcheck </span>that will
|
||
execute a suite of tests of the various programs. If no error is reported you have a
|
||
working installation of <span
|
||
class="cmtt-10">cplint</span>.
|
||
<!--l. 60--><p class="noindent" >
|
||
<h3 class="sectionHead"><span class="titlemark">3 </span> <a
|
||
id="x1-30003"></a>Syntax</h3>
|
||
<!--l. 62--><p class="noindent" >LPAD and CP-logic programs consist of a set of annotated disjunctive clauses.
|
||
Disjunction in the head is represented with a semicolon and atoms in the head are
|
||
separated from probabilities by a colon. For the rest, the usual syntax of Prolog is
|
||
used. For example, the CP-logic clause
|
||
<center class="math-display" >
|
||
<img
|
||
src="manual0x.png" alt="h1 : p1 ∨...∨ hn : pn ← b1,...,bm,<2C>c1,...,<2C>cl " class="math-display" ></center> is
|
||
represented by
|
||
|
||
<div class="verbatim" id="verbatim-3">
|
||
h1:p1 ; ... ; hn:pn :- b1,...,bm,\+ c1,....,\+ cl
|
||
</div>
|
||
<!--l. 69--><p class="nopar" > No parentheses are necessary. The <span
|
||
class="cmtt-10">pi </span>are numeric expressions. It is up to the user to
|
||
ensure that the numeric expressions are legal, i.e. that they sum up to less than
|
||
one.
|
||
<!--l. 72--><p class="indent" > If the clause has an empty body, it can be represented like this
|
||
|
||
<div class="verbatim" id="verbatim-4">
|
||
h1:p1 ; ... ;hn:pn.
|
||
</div>
|
||
<!--l. 75--><p class="nopar" > If the clause has a single head with probability 1, the annotation can be omitted and
|
||
the clause takes the form of a normal prolog clause, i.e.
|
||
|
||
<div class="verbatim" id="verbatim-5">
|
||
h1:- b1,...,bm,\+ c1,...,\+ cl.
|
||
</div>
|
||
<!--l. 79--><p class="nopar" > stands for
|
||
|
||
<div class="verbatim" id="verbatim-6">
|
||
h1:1 :- b1,...,bm,\+ c1,...,\+ cl.
|
||
</div>
|
||
<!--l. 83--><p class="nopar" >
|
||
<!--l. 85--><p class="indent" > The coin example of <span class="cite">[<a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span> is represented as (see file <span
|
||
class="cmtt-10">coin.cpl</span>)
|
||
|
||
<div class="verbatim" id="verbatim-7">
|
||
heads(Coin):1/2 ; tails(Coin):1/2:-
|
||
 <br />     toss(Coin),\+biased(Coin).
|
||
 <br />
|
||
 <br />heads(Coin):0.6 ; tails(Coin):0.4:-
|
||
 <br />     toss(Coin),biased(Coin).
|
||
 <br />
|
||
 <br />fair(Coin):0.9 ; biased(Coin):0.1.
|
||
 <br />
|
||
 <br />toss(coin).
|
||
</div>
|
||
<!--l. 96--><p class="nopar" > The first clause states that if we toss a coin that is not biased it has equal
|
||
probability of landing heads and tails. The second states that if the coin is biased it
|
||
has a slightly higher probability of landing heads. The third states that the coin is
|
||
fair with probability 0.9 and biased with probability 0.1 and the last clause states
|
||
that we toss a coin with certainty.
|
||
<!--l. 99--><p class="indent" > Moreover, the bodies of rules can contain the built-in predicates:
|
||
|
||
<div class="verbatim" id="verbatim-8">
|
||
is/2, >/2, </2, >=/2 ,=</2,
|
||
 <br />=:=/2, =\=/2, true/0, false/0,
|
||
 <br />=/2, ==/2, \=/2 ,\==/2, length/2
|
||
</div>
|
||
<!--l. 104--><p class="nopar" > The bodies can also contain the following library predicates:
|
||
|
||
<div class="verbatim" id="verbatim-9">
|
||
member/2, max_list/2, min_list/2
|
||
 <br />nth0/3, nth/3
|
||
</div>
|
||
<!--l. 110--><p class="nopar" > plus the predicate
|
||
|
||
<div class="verbatim" id="verbatim-10">
|
||
average/2
|
||
</div>
|
||
<!--l. 114--><p class="nopar" > that, given a list of numbers, computes its arithmetic mean.
|
||
<!--l. 117--><p class="indent" > The syntax of ICL program is the one used by the <a
|
||
href="http://www.cs.ubc.ca/~poole/aibook/code/ailog/ailog2.html" > AILog 2 </a> system.
|
||
<h3 class="sectionHead"><span class="titlemark">4 </span> <a
|
||
id="x1-40004"></a>Inference</h3>
|
||
<!--l. 119--><p class="noindent" ><span
|
||
class="cmtt-10">cplint </span>contains various modules for answering queries.
|
||
<!--l. 125--><p class="indent" > These modules answer queries using using goal-oriented procedures:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span
|
||
class="cmtt-10">lpadsld.pl</span>: uses the top-down procedure described in in <span class="cite">[<a
|
||
href="#XRig-AIIA07-IC">16</a>]</span> and <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span>. It
|
||
is based on SLDNF resolution and is an adaptation of the interpreter for
|
||
ProbLog <span class="cite">[<a
|
||
href="#XDBLP:conf/ijcai/RaedtKT07">11</a>]</span>.
|
||
<!--l. 130--><p class="noindent" >It was proved correct <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span> with respect to the semantics of LPADs for
|
||
range restricted acyclic programs <span class="cite">[<a
|
||
href="#XDBLP:journals/ngc/AptB91">1</a>]</span> without function symbols.
|
||
<!--l. 132--><p class="noindent" >It is also able to deal with extensions of LPADs and CP-logic: the clause
|
||
bodies can contain <span
|
||
class="cmtt-10">setof </span>and <span
|
||
class="cmtt-10">bagof</span>, the probabilities in the head may
|
||
be depend on variables in the body and it is possible to specify a uniform
|
||
distribution in the head with reference to a <span
|
||
class="cmtt-10">setof </span>or <span
|
||
class="cmtt-10">bagof </span>operator.
|
||
These extended features have been introduced in order to represent
|
||
CLP(BN) <span class="cite">[<a
|
||
href="#XSanPagQaz03-UAI-IC">21</a>]</span> programs and PRM models <span class="cite">[<a
|
||
href="#XGetoor+al:JMLR02">14</a>]</span>: <span
|
||
class="cmtt-10">setof </span>and <span
|
||
class="cmtt-10">bagof </span>allow to
|
||
express dependency of an attribute from an aggregate function of another
|
||
attribute, as in CLP(BN) and PRM, while the possibility of specifying a
|
||
uniform distribution allows the use of the reference uncertainty feature of
|
||
PRM.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">picl.pl</span>: performs inference on ICL programs <span class="cite">[<a
|
||
href="#XRig09-LJIGPL-IJ">18</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">lpad.pl</span>: uses a top-down procedure based on SLG resolution <span class="cite">[<a
|
||
href="#XDBLP:journals/jacm/ChenW96">9</a>]</span>. As a
|
||
consequence, it works for any sound LPADs, i.e., any LPAD such that
|
||
each of its instances has a two valued well founded model.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">cpl.pl</span>: uses a top-down procedure based on SLG resolution and moreover
|
||
checks that the CP-logic program is valid, i.e., that it has at least an
|
||
execution model.
|
||
</li>
|
||
<li class="itemize">Modules for approximate inference:
|
||
|
||
<ul class="itemize2">
|
||
<li class="itemize"><span
|
||
class="cmtt-10">deepit.pl </span>performs iterative deepening <span class="cite">[<a
|
||
href="#XBraRig10-ILP10-IC">8</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">deepdyn.pl </span>performs dynamic iterative deepening <span class="cite">[<a
|
||
href="#XBraRig10-ILP10-IC">8</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">bestk.pl </span>performs k-Best <span class="cite">[<a
|
||
href="#XBraRig10-ILP10-IC">8</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">bestfirst.pl </span>performs best first <span class="cite">[<a
|
||
href="#XBraRig10-ILP10-IC">8</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">montecarlo.pl </span>performs Monte Carlo <span class="cite">[<a
|
||
href="#XBraRig10-ILP10-IC">8</a>]</span>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">mcintyre.pl</span>: implements the algorithm MCINTYRE (Monte Carlo
|
||
INference wiTh Yap REcord) <span class="cite">[<a
|
||
href="#XRig11-CILC11-NC">19</a>]</span></li></ul>
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">approx/exact.pl </span>as <span
|
||
class="cmtt-10">lpadsld.pl </span>but uses SimplecuddLPADs, a modification
|
||
of the <a
|
||
href="http://dtai.cs.kuleuven.be/problog/download.html" > Simplecudd </a> instead of the <span
|
||
class="cmtt-10">cplint </span>library for building BDDs and
|
||
computing the probability.</li></ul>
|
||
<!--l. 149--><p class="indent" > These modules answer queries using the definition of the semantics of LPADs and
|
||
CP-logic:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span
|
||
class="cmtt-10">semlpadsld.pl</span>: given an LPAD <span
|
||
class="cmmi-10">P</span>, it generates all the instances of <span
|
||
class="cmmi-10">P</span>.
|
||
The probability of a query <span
|
||
class="cmmi-10">Q </span>is computed by identifying all the instances
|
||
where <span
|
||
class="cmmi-10">Q </span>is derivable by SLDNF resolution.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">semlpad.pl</span>: given an LPAD <span
|
||
class="cmmi-10">P</span>, it generates all the instances of <span
|
||
class="cmmi-10">P</span>. The
|
||
probability of a query <span
|
||
class="cmmi-10">Q </span>is computed by identifying all the instances where
|
||
<span
|
||
class="cmmi-10">Q </span>is derivable by SLG resolution.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">semlcpl.pl</span>: given an LPAD <span
|
||
class="cmmi-10">P</span>, it builds an execution model of <span
|
||
class="cmmi-10">P</span>, i.e.,
|
||
a probabilistic process that satisfy the principles of universal causation,
|
||
sufficient causation, independent causation, no deus ex machina events
|
||
and temporal precedence. It uses the definition of the semantics given in
|
||
<span class="cite">[<a
|
||
href="#XDBLP:journals/tplp/VennekensDB09">23</a>]</span>.</li></ul>
|
||
<!--l. 159--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">4.1 </span> <a
|
||
id="x1-50004.1"></a>Commands</h4>
|
||
<!--l. 161--><p class="noindent" >The LPAD or CP-logic program must be stored in a text file with extension <span
|
||
class="cmtt-10">.cpl</span>.
|
||
Suppose you have stored the example above in file <span
|
||
class="cmtt-10">coin.cpl</span>. In order to answer
|
||
queries from this program, you have to run Yap, load one of the modules (such as for
|
||
example <span
|
||
class="cmtt-10">lpad.pl</span>) by issuing the command
|
||
|
||
<div class="verbatim" id="verbatim-11">
|
||
use_module(library(lpad)).
|
||
</div>
|
||
<!--l. 166--><p class="nopar" > at the command prompt. Then you must parse the source file <span
|
||
class="cmtt-10">coin.cpl </span>with the
|
||
command
|
||
|
||
<div class="verbatim" id="verbatim-12">
|
||
p(coin).
|
||
</div>
|
||
<!--l. 171--><p class="nopar" > if <span
|
||
class="cmtt-10">coin.cpl </span>is in the current directory, or
|
||
|
||
<div class="verbatim" id="verbatim-13">
|
||
p(’path_to_coin/coin’).
|
||
</div>
|
||
<!--l. 175--><p class="nopar" > if <span
|
||
class="cmtt-10">coin.cpl </span>is in a different directory. At this point you can pose query to the
|
||
program by using the predicate <span
|
||
class="cmtt-10">s/2 </span>(for solve) that takes as its first argument a
|
||
conjunction of goals in the form of a list and returns the computed probability
|
||
as its second argument. For example, the probability of the conjunction
|
||
<span
|
||
class="cmtt-10">head(coin),biased(coin) </span>can be asked with the query
|
||
|
||
<div class="verbatim" id="verbatim-14">
|
||
s([head(coin),biased(coin)],P).
|
||
</div>
|
||
<!--l. 180--><p class="nopar" > For computing the probability of a conjunction given another conjunction you can
|
||
use the predicate <span
|
||
class="cmtt-10">sc/3 </span>(for solve conditional) that take takes as input the query
|
||
conjunction as its first argument, the evidence conjunction as its second argument
|
||
and returns the probability in its third argument. For example, the probability of the
|
||
query <span
|
||
class="cmtt-10">heads(coin) </span>given the evidence <span
|
||
class="cmtt-10">biased(coin) </span>can be asked with the
|
||
query
|
||
|
||
<div class="verbatim" id="verbatim-15">
|
||
sc([heads(coin)],[biased(coin)],P).
|
||
</div>
|
||
<!--l. 185--><p class="nopar" > After having parsed a program, in order to read in a new program you must restart
|
||
Yap when using <span
|
||
class="cmtt-10">semlpadsld.pl </span>and <span
|
||
class="cmtt-10">semlpad.pl</span>. With the other modules, you can
|
||
directly parse a new program.
|
||
<!--l. 189--><p class="indent" > When using <span
|
||
class="cmtt-10">lpad.pl</span>, the system can print the message “Uunsound program” in
|
||
the case in which an instance with a three valued well founded model is found.
|
||
Moreover, it can print the message “It requires the choice of a head atom from a non
|
||
ground head”: in this case, in order to answer the query, all the groundings of the
|
||
culprit clause must be generated, which may be impossible for programs with
|
||
function symbols.
|
||
<!--l. 191--><p class="indent" > When using <span
|
||
class="cmtt-10">semcpl.pl</span>, you can print the execution process by using the
|
||
command <span
|
||
class="cmtt-10">print. </span>after <span
|
||
class="cmtt-10">p(file). </span>Moreover, you can build an execution
|
||
process given a context by issuing the command <span
|
||
class="cmtt-10">parse(file)</span>. and then
|
||
<span
|
||
class="cmtt-10">build(context). </span>where <span
|
||
class="cmtt-10">context </span>is a list of atoms that are true in the context.
|
||
<span
|
||
class="cmtt-10">semcpl.pl </span>can print “Invalid program” in the case in which no execution process
|
||
exists.
|
||
<!--l. 196--><p class="indent" > When using <span
|
||
class="cmtt-10">cpl.pl </span>you can print a partial execution model including all the
|
||
clauses involved in the query issued with <span
|
||
class="cmtt-10">print. cpl.pl </span>can print the messages
|
||
“Uunsound program”, “It requires the choice of a head atom from a non ground
|
||
head” and “Invalid program”.
|
||
<!--l. 198--><p class="indent" > For <span
|
||
class="cmtt-10">approx/deepit.pl </span>and <span
|
||
class="cmtt-10">approx/deepdyn.pl </span>the command
|
||
|
||
<div class="verbatim" id="verbatim-16">
|
||
solve(GoalsList, ProbLow, ProbUp, ResTime, BddTime)
|
||
</div>
|
||
<!--l. 201--><p class="nopar" > takes as input a list of goals <span
|
||
class="cmtt-10">GoalsList </span>and returns a lower bound on the
|
||
probability <span
|
||
class="cmtt-10">ProbLow</span>, an upper bound on the probability <span
|
||
class="cmtt-10">ProbUp</span>, the CPU time spent
|
||
on performing resolution <span
|
||
class="cmtt-10">ResTime </span>and the CPU time spent on handling BDDs
|
||
<span
|
||
class="cmtt-10">BddTime</span>.
|
||
<!--l. 204--><p class="indent" > For <span
|
||
class="cmtt-10">approx/bestk.pl </span>the command
|
||
|
||
<div class="verbatim" id="verbatim-17">
|
||
solve(GoalsList, ProbLow,  ResTime, BddTime)
|
||
</div>
|
||
<!--l. 207--><p class="nopar" > takes as input a list of goals <span
|
||
class="cmtt-10">GoalsList </span>and returns a lower bound on the
|
||
probability <span
|
||
class="cmtt-10">ProbLow</span>, the CPU time spent on performing resolution <span
|
||
class="cmtt-10">ResTime </span>and the
|
||
CPU time spent on handling BDDs <span
|
||
class="cmtt-10">BddTime</span>.
|
||
<!--l. 210--><p class="indent" > For <span
|
||
class="cmtt-10">approx/bestfirst.pl </span>the command
|
||
|
||
<div class="verbatim" id="verbatim-18">
|
||
solve(GoalsList, ProbLow, ProbUp, Count, ResTime, BddTime)
|
||
</div>
|
||
<!--l. 213--><p class="nopar" > takes as input a list of goals <span
|
||
class="cmtt-10">GoalsList </span>and returns a lower bound on the
|
||
probability <span
|
||
class="cmtt-10">ProbLow</span>, an upper bound on the probability <span
|
||
class="cmtt-10">ProbUp</span>, the number of
|
||
BDDs generated by the algorithm <span
|
||
class="cmtt-10">Count</span>, the CPU time spent on performing
|
||
resolution <span
|
||
class="cmtt-10">ResTime </span>and the CPU time spent on handling BDDs <span
|
||
class="cmtt-10">BddTime</span>.
|
||
<!--l. 217--><p class="indent" > For <span
|
||
class="cmtt-10">approx/montecarlo.pl </span>the command
|
||
|
||
<div class="verbatim" id="verbatim-19">
|
||
solve(GoalsList, Samples, Time, Low, Prob, Up)
|
||
</div>
|
||
<!--l. 221--><p class="nopar" > takes as input a list of goals <span
|
||
class="cmtt-10">GoalsList </span>and returns the number of samples taken
|
||
<span
|
||
class="cmtt-10">Samples</span>, the time required to solve the problem <span
|
||
class="cmtt-10">Time</span>, the lower end of the
|
||
confidence interval <span
|
||
class="cmtt-10">Lower</span>, the estimated probability <span
|
||
class="cmtt-10">Prob </span>and the upper end of the
|
||
confidence interval <span
|
||
class="cmtt-10">Up</span>.
|
||
<!--l. 227--><p class="indent" > For <span
|
||
class="cmtt-10">mcintyre.pl</span>: the command
|
||
|
||
<div class="verbatim" id="verbatim-20">
|
||
solve(Goals, Samples, CPUTime, WallTime, Lower, Prob, Upper) :-
|
||
</div>
|
||
<!--l. 231--><p class="nopar" > takes as input a conjunction of goals <span
|
||
class="cmtt-10">Goals </span>and returns the number of samples taken
|
||
<span
|
||
class="cmtt-10">Samples</span>, the CPU time required to solve the problem <span
|
||
class="cmtt-10">CPUTime</span>, the wall time
|
||
required to solve the problem <span
|
||
class="cmtt-10">CPUTime</span>, the lower end of the confidence interval
|
||
<span
|
||
class="cmtt-10">Lower</span>, the estimated probability <span
|
||
class="cmtt-10">Prob </span>and the upper end of the confidence interval
|
||
<span
|
||
class="cmtt-10">Up</span>.
|
||
<!--l. 236--><p class="indent" > For <span
|
||
class="cmtt-10">approx/exact.pl </span>the command
|
||
|
||
<div class="verbatim" id="verbatim-21">
|
||
solve(GoalsList, Prob, ResTime, BddTime)
|
||
</div>
|
||
<!--l. 240--><p class="nopar" > takes as input a conjunction of goals <span
|
||
class="cmtt-10">Goals </span>and returns the probability <span
|
||
class="cmtt-10">Prob</span>, the
|
||
CPU time spent on performing resolution <span
|
||
class="cmtt-10">ResTime </span>and the CPU time spent on
|
||
handling BDDs <span
|
||
class="cmtt-10">BddTime</span>.
|
||
<!--l. 243--><p class="noindent" >
|
||
<h5 class="subsubsectionHead"><span class="titlemark">4.1.1 </span> <a
|
||
id="x1-60004.1.1"></a>Parameters</h5>
|
||
<!--l. 244--><p class="noindent" >The modules make use of a number of parameters in order to control their behavior.
|
||
They that can be set with the command
|
||
|
||
<div class="verbatim" id="verbatim-22">
|
||
set(parameter,value).
|
||
</div>
|
||
<!--l. 247--><p class="nopar" > from the Yap prompt after having loaded the module. The current value can be read
|
||
with
|
||
|
||
<div class="verbatim" id="verbatim-23">
|
||
setting(parameter,Value).
|
||
</div>
|
||
<!--l. 252--><p class="nopar" > from the Yap prompt. The available parameters are:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_parsing</span></span></span> (valid for all modules): if (1 - the sum of the
|
||
probabilities of all the head atoms) is smaller than <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_parsing</span></span></span> then
|
||
<span
|
||
class="cmtt-10">cplint </span>adds the null events to the head. Default value 0.00001
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">save_dot</span></span></span> (valid for all goal-oriented modules): if <span
|
||
class="cmtt-10">true </span>a graph representing the
|
||
BDD is saved in the file <span
|
||
class="cmtt-10">cpl.dot </span>in the current directory in dot format. The
|
||
variables names are of the form <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">Xn_m</span></span></span> where <span
|
||
class="cmtt-10">n </span>is the number of the multivalued
|
||
variable and <span
|
||
class="cmtt-10">m </span>is the number of the binary variable. The correspondence
|
||
between variables and clauses can be evinced from the message printed on the
|
||
screen, such as
|
||
|
||
<div class="verbatim" id="verbatim-24">
|
||
Variables: [(2,[X=2,X1=1]),(2,[X=1,X1=0]),(1,[])]
|
||
</div>
|
||
<!--l. 266--><p class="nopar" > where the first element of each couple is the clause number of the input file
|
||
(starting from 1). In the example above variable <span
|
||
class="cmtt-10">X0 </span>corresponds to clause <span
|
||
class="cmtt-10">2</span>
|
||
with the substitutions <span
|
||
class="cmtt-10">X=2,X1=1</span>, variable <span
|
||
class="cmtt-10">X1 </span>corresponds to clause <span
|
||
class="cmtt-10">2 </span>with the
|
||
substitutions <span
|
||
class="cmtt-10">X=1,X1=0 </span>and variable <span
|
||
class="cmtt-10">X2 </span>corresponds to clause <span
|
||
class="cmtt-10">1 </span>with the
|
||
empty substitution. You can view the graph with <a
|
||
href="http://www.graphviz.org" > <span
|
||
class="cmtt-10">graphviz </span></a> using the
|
||
command
|
||
|
||
<div class="verbatim" id="verbatim-25">
|
||
dotty cpl.dot &
|
||
</div>
|
||
<!--l. 275--><p class="nopar" >
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ground_body</span></span></span>: (valid for <span
|
||
class="cmtt-10">lpadsld.pl </span>and all semantic modules) determines how
|
||
non ground clauses are treated: if <span
|
||
class="cmtt-10">true</span>, ground clauses are obtained from a non
|
||
ground clause by replacing each variable with a constant, if <span
|
||
class="cmtt-10">false</span>, ground
|
||
clauses are obtained by replacing only variables in the head with a
|
||
constant. In the case where the body contains variables not in the
|
||
head, setting it to false means that the body represents an existential
|
||
event.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">min_error</span></span></span>: (valid for <span
|
||
class="cmtt-10">approx/deepit.pl</span>, <span
|
||
class="cmtt-10">approx/deepdyn.pl</span>,
|
||
<span
|
||
class="cmtt-10">approx/bestk.pl</span>, <span
|
||
class="cmtt-10">approx/bestfirst.pl</span>, <span
|
||
class="cmtt-10">approx/montecarlo.pl </span>and
|
||
<span
|
||
class="cmtt-10">mcintyre.pl</span>) is the threshold under which the difference between
|
||
upper and lower bounds on probability must fall for the algorithm to
|
||
stop.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">k</span></span></span>: maximum number of explanations for <span
|
||
class="cmtt-10">approx/bestk.pl </span>and
|
||
<span
|
||
class="cmtt-10">approx/bestfirst.pl </span>and number of samples to take at each iteration for
|
||
<span
|
||
class="cmtt-10">approx/montecarlo.pl </span>and <span
|
||
class="cmtt-10">mcintyre.pl</span>
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">prob_bound</span></span></span>: (valid for <span
|
||
class="cmtt-10">approx/deepit.pl</span>, <span
|
||
class="cmtt-10">approx/deepdyn.pl</span>,
|
||
<span
|
||
class="cmtt-10">approx/bestk.pl </span>and <span
|
||
class="cmtt-10">approx/bestfirst.pl</span>) is the initial bound on the
|
||
probability of explanations when iteratively building explanations
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">prob_step</span></span></span>: (valid for <span
|
||
class="cmtt-10">approx/deepit.pl</span>, <span
|
||
class="cmtt-10">approx/deepdyn.pl</span>,
|
||
<span
|
||
class="cmtt-10">approx/bestk.pl </span>and <span
|
||
class="cmtt-10">approx/bestfirst.pl</span>) is the increment on the
|
||
bound on the probability of explanations when iteratively building
|
||
explanations
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">timeout</span></span></span>: (valid for <span
|
||
class="cmtt-10">approx/deepit.pl</span>, <span
|
||
class="cmtt-10">approx/deepdyn.pl</span>, <span
|
||
class="cmtt-10">approx/bestk.pl</span>,
|
||
<span
|
||
class="cmtt-10">approx/bestfirst.pl </span>and <span
|
||
class="cmtt-10">approx/exact.pl</span>) timeout for builduing
|
||
BDDs</li></ul>
|
||
|
||
<!--l. 284--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">4.2 </span> <a
|
||
id="x1-70004.2"></a>Semantic Modules</h4>
|
||
<!--l. 285--><p class="noindent" >The three semantic modules need to produce a grounding of the program in order to
|
||
compute the semantics. They require an extra file with extension <span
|
||
class="cmtt-10">.uni </span>(for universe)
|
||
in the same directory where the <span
|
||
class="cmtt-10">.cpl </span>file is.
|
||
<!--l. 288--><p class="indent" > There are two ways to specify how to ground a program. The first consists in
|
||
providing the list of constants to which each variable can be instantiated. For
|
||
example, in our case the current directory will contain a file <span
|
||
class="cmtt-10">coin.uni </span>that is a
|
||
Prolog file containing facts of the form
|
||
|
||
<div class="verbatim" id="verbatim-26">
|
||
universe(var_list,const_list).
|
||
</div>
|
||
<!--l. 291--><p class="nopar" > where <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">var_list</span></span></span> is a list of variables names (each must be included in single quotes)
|
||
and <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">const_list</span></span></span> is a list of constants. The semantic modules generate the grounding
|
||
by instantiating in all possible ways the variables of <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">var_list</span></span></span> with the constants of
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">const_list</span></span></span>. Note that the variables are identified by name, so a variable with
|
||
the same name in two different clauses will be instantiated with the same
|
||
constants.
|
||
<!--l. 294--><p class="indent" > The other way to specify how to ground a program consists in using mode and
|
||
type information. For each predicate, the file <span
|
||
class="cmtt-10">.uni </span>must contain a fact of the
|
||
form
|
||
|
||
<div class="verbatim" id="verbatim-27">
|
||
mode(predicate(t1,...,tn)).
|
||
</div>
|
||
<!--l. 297--><p class="nopar" > that specifies the number and types of each argument of the predicate. Then, the list
|
||
of constants that are in the domain of each type <span
|
||
class="cmtt-10">ti </span>must be specified with a fact of
|
||
the form
|
||
|
||
<div class="verbatim" id="verbatim-28">
|
||
type(ti,list_of_constants).
|
||
</div>
|
||
<!--l. 302--><p class="nopar" > The file <span
|
||
class="cmtt-10">.uni </span>can contain both universe and mode declaration, the ones to be used
|
||
depend on the value of the parameter <span
|
||
class="cmtt-10">grounding</span>: with value <span
|
||
class="cmtt-10">variables</span>, the
|
||
universe declarations are used, with value <span
|
||
class="cmtt-10">modes </span>the mode declarations are
|
||
used.
|
||
<!--l. 305--><p class="indent" > With <span
|
||
class="cmtt-10">semcpl.pl </span>only mode declarations can be used.
|
||
<!--l. 308--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">4.3 </span> <a
|
||
id="x1-80004.3"></a>Extensions</h4>
|
||
<!--l. 309--><p class="noindent" >In this section we will present the extensions to the syntax of LPADs and CP-logic
|
||
programs that <span
|
||
class="cmtt-10">lpadsld </span>can handle.
|
||
<!--l. 311--><p class="indent" > When using <span
|
||
class="cmtt-10">lpadsld.pl</span>, the bodies can contain the predicates <span
|
||
class="cmtt-10">setof/3 </span>and
|
||
<span
|
||
class="cmtt-10">bagof/3 </span>with the same meaning as in Prolog. Existential quantifiers are allowed in
|
||
both, so for example the query
|
||
|
||
<div class="verbatim" id="verbatim-29">
|
||
setof(Z, (term(X,Y))^foo(X,Y,Z), L).
|
||
</div>
|
||
<!--l. 314--><p class="nopar" > returns all the instantiations of <span
|
||
class="cmtt-10">Z </span>such that there exists an instantiation of <span
|
||
class="cmtt-10">X </span>and <span
|
||
class="cmtt-10">Y</span>
|
||
for which <span
|
||
class="cmtt-10">foo(X,Y,Z) </span>is true.
|
||
<!--l. 317--><p class="indent" > An example of the use of <span
|
||
class="cmtt-10">setof </span>and <span
|
||
class="cmtt-10">bagof </span>is in the file <span
|
||
class="cmtt-10">female.cpl</span>:
|
||
|
||
<div class="verbatim" id="verbatim-30">
|
||
male(C):M/P ; female(C):F/P:-
|
||
 <br />    person(C),
|
||
 <br />    setof(Male,known_male(Male),LM),
|
||
 <br />    length(LM,M),
|
||
 <br />    setof(Female,known_female(Female),LF),
|
||
 <br />    length(LF,F),
|
||
 <br />    P is F+M.
|
||
 <br />
|
||
 <br />person(f).
|
||
 <br />
|
||
 <br />known_female(a).
|
||
 <br />known_female(b).
|
||
 <br />known_female(c).
|
||
 <br />known_male(d).
|
||
 <br />known_male(e).
|
||
</div>
|
||
<!--l. 334--><p class="nopar" > The disjunctive rule expresses the probability of a person of unknown sex of being
|
||
male or female depending on the number of males and females that are known. This
|
||
is an example of the use of expressions in the probabilities in the head that depend
|
||
on variables in the body. The probabilities are well defined because they always sum
|
||
to 1 (unless <span
|
||
class="cmtt-10">P </span>is 0).
|
||
<!--l. 338--><p class="indent" > Another use of <span
|
||
class="cmtt-10">setof </span>and <span
|
||
class="cmtt-10">bagof </span>is to have an attribute depend on an
|
||
aggregate function of another attribute, similarly to what is done in PRM and
|
||
CLP(BN).
|
||
<!--l. 340--><p class="indent" > So, in the classical school example (available in <span
|
||
class="cmtt-10">student.cpl</span>) you can find the
|
||
following clauses:
|
||
|
||
<div class="verbatim" id="verbatim-31">
|
||
student_rank(S,h):0.6 ; student_rank(S,l):0.4:-
|
||
 <br />    bagof(G,R^(registr_stu(R,S),registr_gr(R,G)),L),
|
||
 <br />    average(L,Av),Av>1.5.
|
||
 <br />
|
||
 <br />student_rank(S,h):0.4 ; student_rank(S,l):0.6:-
|
||
 <br />    bagof(G,R^(registr_stu(R,S),registr_gr(R,G)),L),
|
||
 <br />    average(L,Av),Av =< 1.5.
|
||
</div>
|
||
<!--l. 350--><p class="nopar" > where <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">registr_stu(R,S)</span></span></span> expresses that registration <span
|
||
class="cmtt-10">R </span>refers to student <span
|
||
class="cmtt-10">S </span>and
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">registr_gr(R,G)</span></span></span> expresses that registration <span
|
||
class="cmtt-10">R </span>reports grade <span
|
||
class="cmtt-10">G </span>which is a natural
|
||
number. The two clauses express a dependency of the rank of the student from the
|
||
average of her grades.
|
||
<!--l. 353--><p class="indent" > Another extension can be used with <span
|
||
class="cmtt-10">lpadsld.pl </span>in order to be able to represent
|
||
reference uncertainty of PRMs. Reference uncertainty means that the link structure
|
||
of a relational model is not fixed but is uncertain: this is represented by having the
|
||
instance referenced in a relationship be chosen uniformly from a set. For example,
|
||
consider a domain modeling scientific papers: you have a single entity, paper, and a
|
||
relationship, cites, between paper and itself that connects the citing paper to the
|
||
cited paper. To represent the fact that the cited paper and the citing paper are
|
||
selected uniformly from certain sets, the following clauses can be used (see file
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">paper_ref_simple.cpl</span></span></span>):
|
||
|
||
<div class="verbatim" id="verbatim-32">
|
||
uniform(cites_cited(C,P),P,L):-
|
||
 <br />    bagof(Pap,paper_topic(Pap,theory),L).
|
||
 <br />
|
||
 <br />uniform(cites_citing(C,P),P,L):-
|
||
 <br />    bagof(Pap,paper_topic(Pap,ai),L).
|
||
</div>
|
||
<!--l. 360--><p class="nopar" > The first clauses states that the paper <span
|
||
class="cmtt-10">P </span>cited in a citation <span
|
||
class="cmtt-10">C </span>is selected
|
||
uniformly from the set of all papers with topic theory. The second clauses
|
||
expresses that the citing paper is selected uniformly from the papers with topic
|
||
ai.
|
||
<!--l. 365--><p class="indent" > These clauses make use of the predicate
|
||
|
||
<div class="verbatim" id="verbatim-33">
|
||
uniform(Atom,Variable,List)
|
||
</div>
|
||
<!--l. 368--><p class="nopar" > in the head, where <span
|
||
class="cmtt-10">Atom </span>must contain <span
|
||
class="cmtt-10">Variable</span>. The meaning is the following:
|
||
the set of all the atoms obtained by instantiating <span
|
||
class="cmtt-10">Variable </span>of <span
|
||
class="cmtt-10">Atom </span>with a
|
||
term taken from <span
|
||
class="cmtt-10">List </span>is generated and the head is obtained by having a
|
||
disjunct for each instantiation with probability 1<span
|
||
class="cmmi-10">∕N </span>where <span
|
||
class="cmmi-10">N </span>is the length of
|
||
<span
|
||
class="cmtt-10">List</span>.
|
||
<!--l. 372--><p class="indent" > A more elaborate example is present in file <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">paper_ref.cpl</span></span></span>:
|
||
|
||
<div class="verbatim" id="verbatim-34">
|
||
uniform(cites_citing(C,P),P,L):-
|
||
 <br />    setof(Pap,paper(Pap),L).
|
||
 <br />
|
||
 <br />cites_cited_group(C,theory):0.9 ; cites_cited_group(C,ai):0.1:-
|
||
 <br />    cites_citing(C,P),paper_topic(P,theory).
|
||
 <br />
|
||
 <br />cites_cited_group(C,theory):0.01;cites_cited_group(C,ai):0.99:-
|
||
 <br />    cites_citing(C,P),paper_topic(P,ai).
|
||
 <br />
|
||
 <br />uniform(cites_cited(C,P),P,L):-
|
||
 <br />    cites_cited_group(C,T),bagof(Pap,paper_topic(Pap,T),L).
|
||
</div>
|
||
<!--l. 385--><p class="nopar" > where the cited paper depends on the topic of the citing paper. In particular, if the
|
||
topic is theory, the cited paper is selected uniformly from the papers about theory
|
||
with probability 0.9 and from the papers about ai with probability 0.1. if
|
||
the topic is ai, the cited paper is selected uniformly from the papers about
|
||
theory with probability 0.01 and from the papers about ai with probability
|
||
0.99.
|
||
<!--l. 388--><p class="indent" > PRMs take into account as well existence uncertainty, where the existence of
|
||
instances is also probabilistic. For example, in the paper domain, the total number of
|
||
citations may be unknown and a citation between any two paper may have a
|
||
probability of existing. For example, a citation between two paper may be more
|
||
probable if they are about the same topic:
|
||
|
||
<div class="verbatim" id="verbatim-35">
|
||
cites(X,Y):0.005 :-
|
||
 <br />    paper_topic(X,theory),paper_topic(Y,theory).
|
||
 <br />
|
||
 <br />cites(X,Y):0.001 :-
|
||
 <br />    paper_topic(X,theory),paper_topic(Y,ai).
|
||
 <br />
|
||
 <br />cites(X,Y):0.003 :-
|
||
 <br />    paper_topic(X,ai),paper_topic(Y,theory).
|
||
 <br />
|
||
 <br />cites(X,Y):0.008 :-
|
||
 <br />    paper_topic(X,ai),paper_topic(Y,ai).
|
||
</div>
|
||
<!--l. 401--><p class="nopar" > This is an example where the probabilities in the head do not sum up to one so the
|
||
null event is automatically added to the head. The first clause states that, if the topic
|
||
of a paper <span
|
||
class="cmtt-10">X </span>is theory and of paper <span
|
||
class="cmtt-10">Y </span>is theory, there is a probability of 0.005 that
|
||
there is a citation from <span
|
||
class="cmtt-10">X </span>to <span
|
||
class="cmtt-10">Y</span>. The other clauses consider the remaining cases for the
|
||
topics.
|
||
<!--l. 406--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">4.4 </span> <a
|
||
id="x1-90004.4"></a>Files</h4>
|
||
<!--l. 407--><p class="noindent" >In the directory where Yap keeps the library files (usually <span
|
||
class="cmtt-10">/usr/local/share/ Yap</span>)
|
||
you can find the directory <span
|
||
class="cmtt-10">cplint </span>that contains the files:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span
|
||
class="cmtt-10">testlpadsld</span><span
|
||
class="cmtt-10">_gbtrue.pl, testlpadsld</span><span
|
||
class="cmtt-10">_gbfalse.pl, testlpad.pl,</span>
|
||
<span
|
||
class="cmtt-10">testcpl.pl, testsemlpadsld.pl, testsemlpad.pl testsemcpl.pl</span>:
|
||
Prolog programs for testing the modules. They are executed when issuing
|
||
the command <span
|
||
class="cmtt-10">make installcheck </span>during the installation. To execute
|
||
them afterwords, load the file and issue the command <span
|
||
class="cmtt-10">t.</span>
|
||
</li>
|
||
<li class="itemize">Subdirectory <span
|
||
class="cmtt-10">examples</span>:
|
||
<ul class="itemize2">
|
||
<li class="itemize"><span
|
||
class="cmtt-10">alarm.cpl</span>: representation of the Bayesian network in Figure 2 of
|
||
<span class="cite">[<a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">coin.cpl</span>: coin example from <span class="cite">[<a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">coin2.cpl</span>: coin example with two coins.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">dice.cpl</span>: dice example from <span class="cite">[<a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span>.
|
||
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">twosideddice.cpl,</span><span
|
||
class="cmtt-10"> threesideddice.cpl</span></span></span> game with idealized dice
|
||
with two or three sides. Used in the experiments in <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">ex.cpl</span>: first example in <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">exapprox.cpl</span>: example showing the problems of approximate
|
||
inference (see <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span>).
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">exrange.cpl</span>: example showing the problems with non range
|
||
restricted programs (see <span class="cite">[<a
|
||
href="#XRig-RCRA07-IC">17</a>]</span>).
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">female.cpl</span>: example showing the dependence of probabilities in the
|
||
head from variables in the body (from <span class="cite">[<a
|
||
href="#XVenVer04-ICLP04-IC">25</a>]</span>).
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">mendel.cpl, mendels.cpl</span>: programs describing the Mendelian
|
||
rules of inheritance, taken from <span class="cite">[<a
|
||
href="#XBlo04-ILP04WIP-IC">7</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">paper_ref.cpl,</span><span
|
||
class="cmtt-10"> paper_ref_simple.cpl</span></span></span>: paper citations examples,
|
||
showing reference uncertainty, inspired by <span class="cite">[<a
|
||
href="#XGetoor+al:JMLR02">14</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">paper_ref_not.cpl</span></span></span>: paper citations example showing that negation
|
||
can be used also for predicates defined by clauses with <span
|
||
class="cmtt-10">uniform </span>in
|
||
the head.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">school.cpl</span>: example inspired by the example <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">school_32.yap</span></span></span> from
|
||
the source distribution of Yap in the <span
|
||
class="cmtt-10">CLPBN </span>directory.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">school_simple.cpl</span></span></span>: simplified version of <span
|
||
class="cmtt-10">school.cpl</span>.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">student.cpl</span></span></span>: student example from Figure 1.3 of <span class="cite">[<a
|
||
href="#XGetFri01-BC">13</a>]</span>.
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10">win.cpl, light.cpl, trigger.cpl, throws.cpl, hiv.cpl,</span><br
|
||
class="newline" /> <span
|
||
class="cmtt-10">invalid.cpl</span>: programs taken from <span class="cite">[<a
|
||
href="#XDBLP:journals/tplp/VennekensDB09">23</a>]</span>. <span
|
||
class="cmtt-10">invalid.cpl </span>is an example
|
||
of a program that is invalid but sound.</li></ul>
|
||
<!--l. 432--><p class="noindent" >The files <span
|
||
class="cmtt-10">*.uni </span>that are present for some of the examples are used by the
|
||
semantical modules. Some of the example files contain in an initial comment
|
||
some queries together with their result.
|
||
</li>
|
||
<li class="itemize">Subdirectory <span
|
||
class="cmtt-10">doc</span>: contains this manual in latex, html and pdf.</li></ul>
|
||
|
||
<!--l. 436--><p class="noindent" >
|
||
<h3 class="sectionHead"><span class="titlemark">5 </span> <a
|
||
id="x1-100005"></a>Learning</h3>
|
||
<!--l. 437--><p class="noindent" ><span
|
||
class="cmtt-10">cplint </span>contains the following learning algorithms:
|
||
<ul class="itemize1">
|
||
<li class="itemize">CEM (<span
|
||
class="cmtt-10">cplint </span>EM): an implementation of EM for learning parameters
|
||
that is based on <span
|
||
class="cmtt-10">lpadsld.pl </span><span class="cite">[<a
|
||
href="#XRigDiM11-ML-IJ">20</a>]</span>
|
||
</li>
|
||
<li class="itemize">RIB (Relational Information Bottleneck): an algorithm for learning
|
||
parameters based on the Information Bottleneck <span class="cite">[<a
|
||
href="#XRigDiM11-ML-IJ">20</a>]</span>
|
||
</li>
|
||
<li class="itemize">EMBLEM (EM over Bdds for probabilistic Logic programs Efficient
|
||
Mining): an implementation of EM for learning parameters that computes
|
||
expectations directly on BDDs <span class="cite">[<a
|
||
href="#XBelRig11-IDA">5</a>, <a
|
||
href="#XBelRig11-CILC11-NC">2</a>, <a
|
||
href="#XBelRig11-TR">3</a>]</span>
|
||
</li>
|
||
<li class="itemize">SLIPCASE (Structure LearnIng of ProbabilistiC logic progrAmS with
|
||
Em over bdds): an algorithm for learning the structure of programs by
|
||
searching directly the theory space <span class="cite">[<a
|
||
href="#XBelRig11-ILP11-IC">4</a>]</span>
|
||
</li>
|
||
<li class="itemize">SLIPCOVER (Structure LearnIng of Probabilistic logic programs by
|
||
searChing OVER the clause space): an algorithm for learning the structure
|
||
of programs by searching the clause space and the theory space separatery
|
||
<span class="cite">[<a
|
||
href="#XBelRig13-TPLP-IJ">6</a>]</span></li></ul>
|
||
<!--l. 446--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">5.1 </span> <a
|
||
id="x1-110005.1"></a>Input</h4>
|
||
<!--l. 447--><p class="noindent" >To execute the learning algorithms, prepare four files in the same folder:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span
|
||
class="cmtt-10"><stem>.kb</span>: contains the example interpretations
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10"><stem>.bg</span>: contains the background knowledge, i.e., knowledge valid for
|
||
all interpretations
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10"><stem>.l</span>: contains language bias information
|
||
</li>
|
||
<li class="itemize"><span
|
||
class="cmtt-10"><stem>.cpl</span>: contains the LPAD for you which you want to learn the
|
||
parameters or the initial LPAD for SLIPCASE. For SLIPCOVER, this file
|
||
should be absent</li></ul>
|
||
|
||
<!--l. 454--><p class="noindent" >where <span
|
||
class="cmtt-10"><stem> </span>is your dataset name. Examples of these files can be found in the dataset
|
||
pages.
|
||
<!--l. 456--><p class="indent" > In <span
|
||
class="cmtt-10"><stem>.kb </span>the example interpretations have to be given as a list of Prolog
|
||
facts initiated by <span
|
||
class="cmtt-10">begin(model(<name>)). </span>and terminated by <span
|
||
class="cmtt-10">end(model(<name>)).</span>
|
||
as in
|
||
|
||
<div class="verbatim" id="verbatim-36">
|
||
begin(model(b1)).
|
||
 <br />sameperson(1,2).
|
||
 <br />movie(f1,1).
|
||
 <br />movie(f1,2).
|
||
 <br />workedunder(1,w1).
|
||
 <br />workedunder(2,w1).
|
||
 <br />gender(1,female).
|
||
 <br />gender(2,female).
|
||
 <br />actor(1).
|
||
 <br />actor(2).
|
||
 <br />end(model(b1)).
|
||
</div>
|
||
<!--l. 470--><p class="nopar" > The interpretations may contain a fact of the form
|
||
|
||
<div class="verbatim" id="verbatim-37">
|
||
prob(0.3).
|
||
</div>
|
||
<!--l. 474--><p class="nopar" > assigning a probability (0.3 in this case) to the interpretations. If this is omitted, the
|
||
probability of each interpretation is considered equal to 1<span
|
||
class="cmmi-10">∕n </span>where <span
|
||
class="cmmi-10">n </span>is the total
|
||
number of interpretations. <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">prob/1</span></span></span> can be used to set different multiplicity for the
|
||
different interpretations.
|
||
<!--l. 477--><p class="indent" > In order for RIB to work, the input interpretations must share the Herbrand
|
||
universe. If this is not the case, you have to translate the interpretations in this was,
|
||
see for example the <span
|
||
class="cmtt-10">sp1 </span>files in RIB’s folder, that are the results of the conversion of
|
||
the first fold of the IMDB dataset.
|
||
<!--l. 479--><p class="indent" > <span
|
||
class="cmtt-10"><stem>.bg </span>can contain Prolog clauses that can be used to derive additional
|
||
conclusions from the atoms in the interpretations.
|
||
<!--l. 482--><p class="indent" > <span
|
||
class="cmtt-10"><stem>.l </span>contains the declarations of the input and output predicates, of the
|
||
unseen predicates and the commands for setting the algorithms’ parameters. Output
|
||
predicates are declared as
|
||
|
||
<div class="verbatim" id="verbatim-38">
|
||
output(<predicate>/<arity>).
|
||
</div>
|
||
<!--l. 486--><p class="nopar" > and define the predicates whose atoms in the input interpretations are used as the
|
||
goals for the prediction of which you want to optimize the parameters. Derivations
|
||
for these goals are built by the systems.
|
||
<!--l. 489--><p class="indent" > Input predicates are those for the predictions of which you do not want to
|
||
optimize the parameters. You can declare closed world input predicates
|
||
with
|
||
|
||
<div class="verbatim" id="verbatim-39">
|
||
input_cw(<predicate>/<arity>).
|
||
</div>
|
||
<!--l. 492--><p class="nopar" > For these predicates, the only true atoms are those in the interpretations, the
|
||
clauses in the input program are not used to derive atoms not present in the
|
||
interpretations.
|
||
<!--l. 495--><p class="indent" > Open world input predicates are declared with
|
||
|
||
<div class="verbatim" id="verbatim-40">
|
||
input(<predicate>/<arity>).
|
||
</div>
|
||
<!--l. 498--><p class="nopar" > In this case, if a subgoal for such a predicate is encountered when deriving the atoms
|
||
for the output predicates, both the facts in the interpretations and the clauses of the
|
||
input program are used.
|
||
<!--l. 502--><p class="indent" > For RIB, if there are unseen predicates, i.e., predicates that are present in the
|
||
input program but not in the interpretations, you have to declare them
|
||
with
|
||
|
||
<div class="verbatim" id="verbatim-41">
|
||
unseen(<predicate>/<arity>).
|
||
</div>
|
||
<!--l. 505--><p class="nopar" >
|
||
<!--l. 507--><p class="indent" > For SLIPCASE and SLIPCOVER, you have to specify the language bias by
|
||
means of mode declarations in the style of <a
|
||
href="http://www.doc.ic.ac.uk/~shm/progol.html" > Progol </a>.
|
||
|
||
<div class="verbatim" id="verbatim-42">
|
||
modeh(<recall>,<predicate>(<arg1>,...).
|
||
</div>
|
||
<!--l. 511--><p class="nopar" > specifies the atoms that can appear in the head of clauses, while
|
||
|
||
<div class="verbatim" id="verbatim-43">
|
||
modeb(<recall>,<predicate>(<arg1>,...).
|
||
</div>
|
||
<!--l. 515--><p class="nopar" > specifies the atoms that can appear in the body of clauses. <span
|
||
class="cmtt-10"><recall> </span>can be an
|
||
integer or <span
|
||
class="cmtt-10">* </span>(currently unused).
|
||
<!--l. 519--><p class="indent" > The arguments are of the form
|
||
|
||
<div class="verbatim" id="verbatim-44">
|
||
+<type>
|
||
</div>
|
||
<!--l. 522--><p class="nopar" > for specifying an input variable of type <span
|
||
class="cmtt-10"><type></span>, or
|
||
|
||
<div class="verbatim" id="verbatim-45">
|
||
-<type>
|
||
</div>
|
||
<!--l. 526--><p class="nopar" > for specifying an output variable of type <span
|
||
class="cmtt-10"><type></span>. or
|
||
|
||
<div class="verbatim" id="verbatim-46">
|
||
<constant>
|
||
</div>
|
||
<!--l. 530--><p class="nopar" > for specifying a constant.
|
||
<!--l. 533--><p class="indent" > SLIPCOVER also allows the arguments
|
||
|
||
<div class="verbatim" id="verbatim-47">
|
||
#<type>
|
||
</div>
|
||
<!--l. 536--><p class="nopar" > for specifying an argument which should be replaced by a constant of type <span
|
||
class="cmtt-10"><type> </span>in
|
||
the bottom clause but should not be used for replacing input variables of the
|
||
following literals or
|
||
|
||
<div class="verbatim" id="verbatim-48">
|
||
-#<type>
|
||
</div>
|
||
<!--l. 540--><p class="nopar" > for specifying an argument which should be replaced by a constant of type <span
|
||
class="cmtt-10"><type> </span>in
|
||
the bottom clause and that should be used for replacing input variables of
|
||
the following literals. <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">#</span></span></span> and <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">-#</span></span></span> differ only in the creation of the bottom
|
||
clause.
|
||
<!--l. 543--><p class="indent" > An example of language bias for the UWCSE domain is
|
||
|
||
<div class="verbatim" id="verbatim-49">
|
||
output(advisedby/2).
|
||
 <br />
|
||
 <br />input(student/1).
|
||
 <br />input(professor/1).
|
||
 <br />....
|
||
 <br />
|
||
 <br />modeh(*,advisedby(+person,+person)).
|
||
 <br />
|
||
 <br />modeb(*,professor(+person)).
|
||
 <br />modeb(*,student(+person)).
|
||
 <br />modeb(*,sameperson(+person, -person)).
|
||
 <br />modeb(*,sameperson(-person, +person)).
|
||
 <br />modeb(*,samecourse(+course, -course)).
|
||
 <br />modeb(*,samecourse(-course, +course)).
|
||
 <br />....
|
||
</div>
|
||
<!--l. 560--><p class="nopar" > SLIPCOVER also requires facts for the <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">determination/2</span></span></span> predicate that indicate
|
||
which predicates can appear in the body of clauses. For example
|
||
|
||
<div class="verbatim" id="verbatim-50">
|
||
determination(professor/1,student/1).
|
||
 <br />determination(student/1,hasposition/2).
|
||
</div>
|
||
<!--l. 566--><p class="nopar" > state that <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">student/1</span></span></span> can appear in the body of clauses for <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">professor/1</span></span></span> and that
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">hasposition/2</span></span></span> can appear in the body of clauses for <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">student/1</span></span></span>.
|
||
<!--l. 570--><p class="indent" > SLIPCOVER also allows mode declarations of the form
|
||
|
||
<div class="verbatim" id="verbatim-51">
|
||
modeh(<r>,[<s1>,...,<sn>],[<a1>,...,<an>],[<P1/Ar1>,...,<Pk/Ark>]).
|
||
</div>
|
||
<!--l. 573--><p class="nopar" > These mode declarations are used to generate clauses with more than two head
|
||
atoms. In them, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><s1>,...,<sn></span></span></span> are schemas, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><a1>,...,<an></span></span></span> are atoms such that
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><ai></span></span></span> is obtained from <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><si></span></span></span> by replacing placemarkers with variables, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><Pi/Ari></span></span></span> are
|
||
the predicates admitted in the body. <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><a1>,...,<an></span></span></span> are used to indicate which
|
||
variables should be shared by the atoms in the head. An example of such a mode
|
||
declaration is
|
||
|
||
<div class="verbatim" id="verbatim-52">
|
||
modeh(*,
|
||
 <br />  [advisedby(+person,+person),tempadvisedby(+person,+person)],
|
||
 <br />  [advisedby(A,B),tempadvisedby(A,B)],
|
||
 <br />  [professor/1,student/1,hasposition/2,inphase/2,
|
||
 <br />  publication/2,taughtby/3,ta/3,courselevel/2,yearsinprogram/2]).
|
||
</div>
|
||
<!--l. 583--><p class="nopar" >
|
||
<!--l. 587--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">5.2 </span> <a
|
||
id="x1-120005.2"></a>Parameters</h4>
|
||
<!--l. 588--><p class="noindent" >In order to set the algorithms’ parameters, you have to insert in <span
|
||
class="cmtt-10"><stem>.l </span>commands
|
||
of the form
|
||
|
||
<div class="verbatim" id="verbatim-53">
|
||
:- set(<parameter>,<value>).
|
||
</div>
|
||
<!--l. 591--><p class="nopar" > The available parameters are:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">depth</span></span></span> (values: integer or <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">inf</span></span></span>, default value: 3): depth of derivations if
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">depth_bound</span></span></span> is set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">true</span></span></span>
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">single_var</span></span></span> (values: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">{true,false}</span></span></span>, default value: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">false</span></span></span>, valid for CEM,
|
||
EMBLEM, SLIPCASE and SLIPCOVER): if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">true</span></span></span>, there is a
|
||
random variable for each clauses, instead of a separate random variable
|
||
for each grounding of a clause
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">sample_size</span></span></span> (values: integer, default value: 1000): total number of
|
||
examples in case in which the models in the <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">.kb</span></span></span> file contain a <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">prob(P).</span></span></span>
|
||
fact. In that case, one model corresponds to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">sample_size*P</span></span></span> examples
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_em</span></span></span> (values: real, default value: 0.1, valid for CEM, EMBLEM,
|
||
SLIPCASE and SLIPCOVER): if the difference in the log likelihood in
|
||
two successive EM iteration is smaller than <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_em</span></span></span>, then EM stops
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_em_fraction</span></span></span> (values: real, default value: 0.01, valid for
|
||
CEM, EMBLEM, SLIPCASE and SLIPCOVER): if the difference in
|
||
the log likelihood in two successive EM iteration is smaller than
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_em_fraction</span></span></span>*(-current log likelihood), then EM stops
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">iter</span></span></span> (values: integer, defualt value: 1, valid for EMBLEM, SLIPCASE and
|
||
SLIPCOVER): maximum number of iteration of EM parameter learning.
|
||
If set to -1, no maximum number of iterations is imposed
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">iterREF</span></span></span> (values: integer, defualt value: 1, valid for SLIPCASE and
|
||
SLIPCOVER): maximum number of iteration of EM parameter learning
|
||
for refinements. If set to -1, no maximum number of iterations is imposed.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">random_restarts_number</span></span></span> (values: integer, default value: 1, valid for
|
||
CEM, EMBLEM, SLIPCASE and SLIPCOVER): number of random
|
||
restarts of EM learning
|
||
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">random_restarts_REFnumber</span></span></span> (values: integer, default value: 1, valid for
|
||
SLIPCASE and SLIPCOVER): number of random restarts of EM learning
|
||
for refinements
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">setrand</span></span></span> (values: rand(integer,integer,integer)): seed for the random
|
||
functions, see Yap manual for allowed values
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">minimal_step</span></span></span> (values: [0,1], default value: 0.005, valid for RIB): minimal
|
||
increment of <span
|
||
class="cmmi-10">γ</span>
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">maximal_step</span></span></span> (values: [0,1], default value: 0.1, valid for RIB): maximal
|
||
increment of <span
|
||
class="cmmi-10">γ</span>
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">logsize_fraction</span></span></span> (values: [0,1], default value 0.9, valid for RIB): RIB
|
||
stops when <span
|
||
class="cmbx-10">I</span>(<span
|
||
class="cmmi-10">CH,T</span>;<span
|
||
class="cmmi-10">Y </span>) is above <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">logsize_fraction</span></span></span> times its maximum
|
||
value (log <span
|
||
class="cmsy-10">|</span><span
|
||
class="cmmi-10">CH,T</span><span
|
||
class="cmsy-10">|</span>, see <span class="cite">[<a
|
||
href="#XDBLP:journals/jmlr/ElidanF05">12</a>]</span>)
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">delta</span></span></span> (values: negative integer, default value -10, valid for RIB): value
|
||
assigned to log 0
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_fraction</span></span></span> (values: integer, default value 100, valid for RIB):
|
||
in the computation of the step, the value of <span
|
||
class="cmmi-10">ϵ </span>of <span class="cite">[<a
|
||
href="#XDBLP:journals/jmlr/ElidanF05">12</a>]</span> is obtained as
|
||
log <span
|
||
class="cmsy-10">|</span><span
|
||
class="cmmi-10">CH,T</span><span
|
||
class="cmsy-10">|×</span><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">epsilon_fraction</span></span></span>
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">max_rules</span></span></span> (values: integer, default value: 6000, valid for RIB and
|
||
SLIPCASE): maximum number of ground rules. Used to set the size of
|
||
arrays for storing internal statistics. Can be increased as much as memory
|
||
allows.
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">logzero</span></span></span> (values: negative real, default value log(0<span
|
||
class="cmmi-10">.</span>000001), valid for
|
||
SLIPCASE and SLIPCOVER): value assigned to log 0
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">examples</span></span></span> (values: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">atoms</span></span></span>,<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">interpretations</span></span></span>, default value <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">atoms</span></span></span>, valid for
|
||
SLIPCASE): determines how BDDs are built: if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">interpretations</span></span></span>,
|
||
a BDD for the conjunction of all the atoms for the target predicates in each
|
||
interpretations is built. If set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">atoms</span></span></span>, a BDD is built for the conjunction
|
||
of a group of atoms for the target predicates in each interpretations. The
|
||
number of atoms in each group is determined by the parameter <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">group</span></span></span>
|
||
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">group</span></span></span> (values: integer, default value: 1, valid for SLIPCASE): number of
|
||
target atoms in the groups that are used to build BDDs
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">nax_iter</span></span></span> (values: integer, default value: 10, valid for SLIPCASE and
|
||
SLIPCOVER): number of interations of beam search
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">max_var</span></span></span> (values: integer, default value: 1, valid for SLIPCASE and
|
||
SLIPCOVER): maximum number of distinct variables in a clause
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">verbosity</span></span></span> (values: integer in [1,3], default value: 1): level of verbosity of
|
||
the algorithms
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">beamsize</span></span></span> (values: integer, default value: 20, valid for SLIPCASE and
|
||
SLIPCOVER): size of the beam
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">megaex_bottom</span></span></span> (values: integer, default value: 1, valid for SLIPCOVER):
|
||
number of mega-examples on which to build the bottom clauses
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">initial_clauses_per_megaex</span></span></span> (values: integer, default value: 1, valid for
|
||
SLIPCOVER): number of bottom clauses to build for each mega-example
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">d</span></span></span> (values: integer, default value: 10000, valid for SLIPCOVER): number
|
||
of saturation steps when building the bottom clause
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">max_iter_structure</span></span></span> (values: integer, default value: 1, valid for
|
||
SLIPCOVER): maximum number of theory search iterations
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">background_clauses</span></span></span> (values: integer, default value: 50, valid for
|
||
SLIPCOVER): maximum numbers of background clauses
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">maxdepth_var</span></span></span> (values: integer, default value: 2, valid for SLIPCOVER):
|
||
maximum depth of variables in clauses (as defined in <span class="cite">[<a
|
||
href="#XDBLP:journals/ai/Cohen95">10</a>]</span>).
|
||
</li>
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">score</span></span></span> (values: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ll</span></span></span>, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">aucpr</span></span></span>, default value <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ll</span></span></span>, valid for SLIPCOVER):
|
||
determines the score function for refinement: if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ll</span></span></span>, log likelihood is
|
||
used, if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">aucpr</span></span></span>, the area under the precision-recall curve is used.</li></ul>
|
||
|
||
<!--l. 635--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">5.3 </span> <a
|
||
id="x1-130005.3"></a>Commands</h4>
|
||
<!--l. 636--><p class="noindent" >To execute CEM, load <span
|
||
class="cmtt-10">em.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-54">
|
||
?:- use_module(library(’cplint/em’)).
|
||
</div>
|
||
<!--l. 639--><p class="nopar" > and call:
|
||
|
||
<div class="verbatim" id="verbatim-55">
|
||
?:- em(stem).
|
||
</div>
|
||
<!--l. 643--><p class="nopar" > To execute RIB, load <span
|
||
class="cmtt-10">rib.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-56">
|
||
?:- use_module(library(’cplint/rib’)).
|
||
</div>
|
||
<!--l. 647--><p class="nopar" > and call:
|
||
|
||
<div class="verbatim" id="verbatim-57">
|
||
?:- ib_par(stem).
|
||
</div>
|
||
<!--l. 651--><p class="nopar" > To execute EMBLEM, load <span
|
||
class="cmtt-10">slipcase.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-58">
|
||
?:- use_module(library(’cplint/slipcase’)).
|
||
</div>
|
||
<!--l. 655--><p class="nopar" > and call
|
||
|
||
<div class="verbatim" id="verbatim-59">
|
||
?:- em(stem).
|
||
</div>
|
||
<!--l. 659--><p class="nopar" > To execute SLIPCASE, load <span
|
||
class="cmtt-10">slipcase.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-60">
|
||
?:- use_module(library(’cplint/slipcase’)).
|
||
</div>
|
||
<!--l. 663--><p class="nopar" > and call
|
||
|
||
<div class="verbatim" id="verbatim-61">
|
||
?:- sl(stem).
|
||
</div>
|
||
<!--l. 667--><p class="nopar" > To execute SLIPCOVER, load <span
|
||
class="cmtt-10">slipcover.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-62">
|
||
?:- use_module(library(’cplint/slipcover’)).
|
||
</div>
|
||
<!--l. 671--><p class="nopar" > and call
|
||
|
||
<div class="verbatim" id="verbatim-63">
|
||
?:- sl(stem).
|
||
</div>
|
||
<!--l. 675--><p class="nopar" >
|
||
<h4 class="subsectionHead"><span class="titlemark">5.4 </span> <a
|
||
id="x1-140005.4"></a>Testing</h4>
|
||
<!--l. 677--><p class="noindent" >To test the theories learned, load <span
|
||
class="cmtt-10">test.pl </span>with
|
||
|
||
<div class="verbatim" id="verbatim-64">
|
||
?:- use_module(library(’cplint/test’)).
|
||
</div>
|
||
<!--l. 680--><p class="nopar" > and call
|
||
|
||
<div class="verbatim" id="verbatim-65">
|
||
?:- main([<stem_fold1>,...,<stem_foldn>],[<testing_set_fold1>,...,
|
||
 <br />  <testing_set_foldn>]).
|
||
</div>
|
||
<!--l. 685--><p class="nopar" > For example, if you want to test the theory in <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ai_train.rules</span></span></span> on the set <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ai.kb</span></span></span>,
|
||
you can call
|
||
|
||
<div class="verbatim" id="verbatim-66">
|
||
?:- main([ai_train],[ai]).
|
||
</div>
|
||
<!--l. 689--><p class="nopar" > The testing program has the following parameter:
|
||
<ul class="itemize1">
|
||
<li class="itemize"><span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">neg_ex</span></span></span> (values: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">given</span></span></span>, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">cw</span></span></span>, default value: <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">cw</span></span></span>): if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">given</span></span></span>, the negative
|
||
examples are taken from <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10"><testing_set_foldi>.kb</span></span></span>, i.e., those example
|
||
<span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">ex</span></span></span> stored as <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">neg(ex)</span></span></span>; if set to <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">cw</span></span></span>, the negative examples are generated
|
||
according to the closed world assumption, i.e., all atoms for target
|
||
predicates that are not positive examples. The set of all atoms is obtained
|
||
by collecting the set of constants for each type of the arguments of the
|
||
target predicate.</li></ul>
|
||
<!--l. 696--><p class="noindent" >
|
||
<h4 class="subsectionHead"><span class="titlemark">5.5 </span> <a
|
||
id="x1-150005.5"></a>Learning Examples</h4>
|
||
<!--l. 697--><p class="noindent" >The subfolders <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">em</span></span></span>, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">rib</span></span></span>, <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">slipcase</span></span></span> and <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">slipcover</span></span></span> of the <span class="obeylines-h"><span class="verb"><span
|
||
class="cmtt-10">packages/cplint</span></span></span> folder in
|
||
Yap git distribution contain examples of input and output files for the learning
|
||
algorithms.
|
||
<!--l. 700--><p class="noindent" >
|
||
<h3 class="sectionHead"><span class="titlemark">6 </span> <a
|
||
id="x1-160006"></a>License</h3>
|
||
<!--l. 705--><p class="noindent" ><span
|
||
class="cmtt-10">cplint</span>, as Yap, follows the Artistic License 2.0 that you can find in Yap CVS root
|
||
dir. The copyright is by Fabrizio Riguzzi.
|
||
<!--l. 708--><p class="indent" > The modules in the approx subdirectory use SimplecuddLPADs, a modification of
|
||
the <a
|
||
href="http://dtai.cs.kuleuven.be/problog/download.html" > Simplecudd </a> library whose copyright is by Katholieke Universiteit Leuven and
|
||
that follows the Artistic License 2.0.
|
||
<!--l. 711--><p class="indent" > Some modules use the library <a
|
||
href="http://vlsi.colorado.edu/~fabio/" > CUDD </a> for manipulating BDDs that is included in
|
||
glu. For the use of CUDD, the following license must be accepted:
|
||
<!--l. 716--><p class="indent" > Copyright (c) 1995-2004, Regents of the University of Colorado
|
||
<!--l. 718--><p class="indent" > All rights reserved.
|
||
<!--l. 720--><p class="indent" > Redistribution and use in source and binary forms, with or without modification,
|
||
are permitted provided that the following conditions are met:
|
||
<ul class="itemize1">
|
||
<li class="itemize">Redistributions of source code must retain the above copyright notice, this
|
||
list of conditions and the following disclaimer.
|
||
|
||
</li>
|
||
<li class="itemize">Redistributions in binary form must reproduce the above copyright notice,
|
||
this list of conditions and the following disclaimer in the documentation
|
||
and/or other materials provided with the distribution.
|
||
</li>
|
||
<li class="itemize">Neither the name of the University of Colorado nor the names of its
|
||
contributors may be used to endorse or promote products derived from
|
||
this software without specific prior written permission.</li></ul>
|
||
<!--l. 737--><p class="noindent" >THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS <br
|
||
class="newline" />AND CONTRIBUTORS ”AS IS” AND ANY EXPRESS OR IMPLIED
|
||
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
||
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
INTERRUPTION) HOWEVER CAU-SED <br
|
||
class="newline" />AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
<!--l. 751--><p class="indent" > <span
|
||
class="cmtt-10">lpad.pl</span>, <span
|
||
class="cmtt-10">semlpad.pl </span>and <span
|
||
class="cmtt-10">cpl.pl </span>are based on the SLG system by Weidong
|
||
Chen and <a
|
||
href="http://www.cs.sunysb.edu/~warren/" > David Scott Warren </a>, Copyright (C) 1993 Southern Methodist University,
|
||
1993 SUNY at Stony Brook, see the file COYPRIGHT_SLG for detailed information
|
||
on this copyright.
|
||
<!--l. 1--><p class="noindent" >
|
||
<h3 class="likesectionHead"><a
|
||
id="x1-170006"></a>References</h3>
|
||
<!--l. 1--><p class="noindent" >
|
||
<div class="thebibliography">
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[1]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/ngc/AptB91"></a>K. R. Apt and M. Bezem. Acyclic programs. <span
|
||
class="cmti-10">New Gener. Comput.</span>,
|
||
9(3/4):335–364, 1991.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[2]<span class="bibsp">   </span></span><a
|
||
id="XBelRig11-CILC11-NC"></a>Elena Bellodi and Fabrizio Riguzzi. EM over binary decision diagrams
|
||
for probabilistic logic programs. In <span
|
||
class="cmti-10">Proceedings of the 26th Italian</span>
|
||
<span
|
||
class="cmti-10">Conference on Computational Logic (CILC2011), Pescara, Italy, 31 August</span>
|
||
<span
|
||
class="cmti-10">31-2 September, 2011</span>, 2011.
|
||
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[3]<span class="bibsp">   </span></span><a
|
||
id="XBelRig11-TR"></a>Elena Bellodi and Fabrizio Riguzzi. EM over binary decision
|
||
diagrams for probabilistic logic programs. Technical Report CS-2011-01,
|
||
Dipartimento di Ingegneria, Universit<69> di Ferrara, Italy, 2011.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[4]<span class="bibsp">   </span></span><a
|
||
id="XBelRig11-ILP11-IC"></a>Elena Bellodi and Fabrizio Riguzzi. Learning the structure of
|
||
probabilistic logic programs. In <span
|
||
class="cmti-10">Inductive Logic Programming, 21th</span>
|
||
<span
|
||
class="cmti-10">International Conference, ILP 2011, London, UK, 31 July-3 August, 2011</span>,
|
||
2011.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[5]<span class="bibsp">   </span></span><a
|
||
id="XBelRig11-IDA"></a>Elena Bellodi and Fabrizio Riguzzi. Expectation Maximization over
|
||
binary decision diagrams for probabilistic logic programs. <span
|
||
class="cmti-10">Intel. Data Anal.</span>,
|
||
16(6), 2012.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[6]<span class="bibsp">   </span></span><a
|
||
id="XBelRig13-TPLP-IJ"></a>Elena Bellodi and Fabrizio Riguzzi. Structure learning of probabilistic
|
||
logic programs by searching the clause space. <span
|
||
class="cmti-10">Theory and Practice of Logic</span>
|
||
<span
|
||
class="cmti-10">Programming</span>, 2013.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[7]<span class="bibsp">   </span></span><a
|
||
id="XBlo04-ILP04WIP-IC"></a>H. Blockeel. Probabilistic logical models for mendel’s experiments: An
|
||
exercise. In <span
|
||
class="cmti-10">Inductive Logic Programming (ILP 2004), Work in Progress</span>
|
||
<span
|
||
class="cmti-10">Track</span>, 2004.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[8]<span class="bibsp">   </span></span><a
|
||
id="XBraRig10-ILP10-IC"></a>Stefano Bragaglia and Fabrizio Riguzzi. Approximate inference for logic
|
||
programs with annotated disjunctions. In Paolo Frasconi and Francesca
|
||
Lisi, editors, <span
|
||
class="cmti-10">Inductive Logic Programming 20th International Conference,</span>
|
||
<span
|
||
class="cmti-10">ILP 2010, Florence, Italy, June 27-30, 2010. Revised Papers</span>, volume 6489
|
||
of <span
|
||
class="cmti-10">LNCS</span>, pages 30–37. Springer, 2011.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[9]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/jacm/ChenW96"></a>Weidong Chen and David Scott Warren. Tabled evaluation with
|
||
delaying for general logic programs. <span
|
||
class="cmti-10">Journal of the ACM</span>, 43(1):20–74, 1996.
|
||
</p>
|
||
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[10]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/ai/Cohen95"></a>William W. Cohen. Pac-learning non-recursive prolog clauses. <span
|
||
class="cmti-10">Artif.</span>
|
||
<span
|
||
class="cmti-10">Intell.</span>, 79(1):1–38, 1995.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[11]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:conf/ijcai/RaedtKT07"></a>L. De Raedt, A. Kimmig, and H. Toivonen. ProbLog: A probabilistic
|
||
Prolog and its application in link discovery. In <span
|
||
class="cmti-10">International Joint</span>
|
||
<span
|
||
class="cmti-10">Conference on Artificial Intelligence</span>, pages 2462–2467, 2007.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[12]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/jmlr/ElidanF05"></a>G. Elidan and N. Friedman. Learning hidden variable networks: The
|
||
information bottleneck approach. <span
|
||
class="cmti-10">Journal of Machine Learning Research</span>,
|
||
6:81–127, 2005.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[13]<span class="bibsp">   </span></span><a
|
||
id="XGetFri01-BC"></a>L. Getoor, N. Friedman, D. Koller, and A. Pfeffer. Learning
|
||
probabilistic relational models. In Saso Dzeroski and Nada Lavrac, editors,
|
||
<span
|
||
class="cmti-10">Relational Data Mining</span>. Springer-Verlag, Berlin, 2001.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[14]<span class="bibsp">   </span></span><a
|
||
id="XGetoor+al:JMLR02"></a>L. Getoor, N. Friedman, D. Koller, and B. Taskar. Learning
|
||
probabilistic models of relational structure. <span
|
||
class="cmti-10">Journal of Machine Learning</span>
|
||
<span
|
||
class="cmti-10">Research</span>, 3:679–707, December 2002.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[15]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/ai/Poole97"></a>David Poole. The independent choice logic for modelling multiple agents
|
||
under uncertainty. <span
|
||
class="cmti-10">Artificial Intelligence</span>, 94(1-2):7–56, 1997.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[16]<span class="bibsp">   </span></span><a
|
||
id="XRig-AIIA07-IC"></a>Fabrizio Riguzzi. A top down interpreter for LPAD and CP-logic. In
|
||
<span
|
||
class="cmti-10">Congress of the Italian Association for Artificial Intelligence</span>, volume 4733
|
||
of <span
|
||
class="cmti-10">LNAI</span>, pages 109–120. Springer, 2007.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[17]<span class="bibsp">   </span></span><a
|
||
id="XRig-RCRA07-IC"></a>Fabrizio Riguzzi. A top down interpreter for LPAD and CP-logic.
|
||
In <span
|
||
class="cmti-10">Proceedings of the 14th RCRA workshop Experimental Evaluation of</span>
|
||
<span
|
||
class="cmti-10">Algorithms for Solving Problems with Combinatorial Explosion</span>, 2007.
|
||
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[18]<span class="bibsp">   </span></span><a
|
||
id="XRig09-LJIGPL-IJ"></a>Fabrizio Riguzzi. Extended semantics and inference for the Independent
|
||
Choice Logic. <span
|
||
class="cmti-10">Logic Journal of the IGPL</span>, 17(6):589–629, 2009.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[19]<span class="bibsp">   </span></span><a
|
||
id="XRig11-CILC11-NC"></a>Fabrizio Riguzzi. MCINTYRE: A Monte Carlo algorithm for
|
||
probabilistic logic programming. In <span
|
||
class="cmti-10">Proceedings of the 26th Italian</span>
|
||
<span
|
||
class="cmti-10">Conference on Computational Logic (CILC2011), Pescara, Italy, 31</span>
|
||
<span
|
||
class="cmti-10">August-2 September, 2011</span>, 2011.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[20]<span class="bibsp">   </span></span><a
|
||
id="XRigDiM11-ML-IJ"></a>Fabrizio Riguzzi and Nicola Di Mauro. Applying the information
|
||
bottleneck to statistical relational learning. <span
|
||
class="cmti-10">Machine Learning</span>, 2011. To
|
||
appear.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[21]<span class="bibsp">   </span></span><a
|
||
id="XSanPagQaz03-UAI-IC"></a>V. Santos Costa, D. Page, M. Qazi, and J. Cussens. CLP(<span
|
||
class="cmsy-10"><img
|
||
src="cmsy10-42.png" alt="B" class="10x-x-42" /><img
|
||
src="cmsy10-4e.png" alt="N" class="10x-x-4e" /></span>):
|
||
Constraint logic programming for probabilistic knowledge. In <span
|
||
class="cmti-10">Uncertainty</span>
|
||
<span
|
||
class="cmti-10">in Artificial Intelligence</span>. Morgan Kaufmann, 2003.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[22]<span class="bibsp">   </span></span><a
|
||
id="XVenDenBru-JELIA06"></a>J. Vennekens, M. Denecker, and M. Bruynooghe. Representing causal
|
||
information about a probabilistic process. In <span
|
||
class="cmti-10">Proceedings of the 10th</span>
|
||
<span
|
||
class="cmti-10">European Conference on Logics in Artificial Intelligence</span>, LNAI. Springer,
|
||
September 2006.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[23]<span class="bibsp">   </span></span><a
|
||
id="XDBLP:journals/tplp/VennekensDB09"></a>J. Vennekens, Marc Denecker, and Maurice Bruynooghe. CP-logic:
|
||
A language of causal probabilistic events and its relation to logic
|
||
programming. <span
|
||
class="cmti-10">Theory Pract. Log. Program.</span>, 9(3):245–308, 2009.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[24]<span class="bibsp">   </span></span><a
|
||
id="XVenVer03-TR"></a>J. Vennekens and S. Verbaeten. Logic programs with annotated
|
||
disjunctions. Technical Report CW386, K. U. Leuven, 2003.
|
||
</p>
|
||
<p class="bibitem" ><span class="biblabel">
|
||
[25]<span class="bibsp">   </span></span><a
|
||
id="XVenVer04-ICLP04-IC"></a>J. Vennekens, S. Verbaeten, and M. Bruynooghe. Logic programs
|
||
with annotated disjunctions. In <span
|
||
class="cmti-10">International Conference on Logic</span>
|
||
<span
|
||
class="cmti-10">Programming</span>, volume 3131 of <span
|
||
class="cmti-10">LNCS</span>, pages 195–209. Springer, 2004.
|
||
|
||
</p>
|
||
</div>
|
||
|
||
</body></html>
|
||
|
||
|
||
|