This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/packages/ProbLog/problog.yap
Vítor Santos Costa ed0d3f6cae Latest ProbLog
2012-01-11 14:44:59 +00:00

3687 lines
118 KiB
Prolog

%%% -*- Mode: Prolog; -*-
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% $Date: 2011-12-08 16:20:16 +0100 (Thu, 08 Dec 2011) $
% $Revision: 6775 $
%
% This file is part of ProbLog
% http://dtai.cs.kuleuven.be/problog
%
% ProbLog was developed at Katholieke Universiteit Leuven
%
% Copyright 2008, 2009, 2010
% Katholieke Universiteit Leuven
%
% Main authors of this file:
% Angelika Kimmig, Vitor Santos Costa, Bernd Gutmann,
% Theofrastos Mantadelis, Guy Van den Broeck
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Artistic License 2.0
%
% Copyright (c) 2000-2006, The Perl Foundation.
%
% Everyone is permitted to copy and distribute verbatim copies of this
% license document, but changing it is not allowed. Preamble
%
% This license establishes the terms under which a given free software
% Package may be copied, modified, distributed, and/or
% redistributed. The intent is that the Copyright Holder maintains some
% artistic control over the development of that Package while still
% keeping the Package available as open source and free software.
%
% You are always permitted to make arrangements wholly outside of this
% license directly with the Copyright Holder of a given Package. If the
% terms of this license do not permit the full use that you propose to
% make of the Package, you should contact the Copyright Holder and seek
% a different licensing arrangement. Definitions
%
% "Copyright Holder" means the individual(s) or organization(s) named in
% the copyright notice for the entire Package.
%
% "Contributor" means any party that has contributed code or other
% material to the Package, in accordance with the Copyright Holder's
% procedures.
%
% "You" and "your" means any person who would like to copy, distribute,
% or modify the Package.
%
% "Package" means the collection of files distributed by the Copyright
% Holder, and derivatives of that collection and/or of those files. A
% given Package may consist of either the Standard Version, or a
% Modified Version.
%
% "Distribute" means providing a copy of the Package or making it
% accessible to anyone else, or in the case of a company or
% organization, to others outside of your company or organization.
%
% "Distributor Fee" means any fee that you charge for Distributing this
% Package or providing support for this Package to another party. It
% does not mean licensing fees.
%
% "Standard Version" refers to the Package if it has not been modified,
% or has been modified only in ways explicitly requested by the
% Copyright Holder.
%
% "Modified Version" means the Package, if it has been changed, and such
% changes were not explicitly requested by the Copyright Holder.
%
% "Original License" means this Artistic License as Distributed with the
% Standard Version of the Package, in its current version or as it may
% be modified by The Perl Foundation in the future.
%
% "Source" form means the source code, documentation source, and
% configuration files for the Package.
%
% "Compiled" form means the compiled bytecode, object code, binary, or
% any other form resulting from mechanical transformation or translation
% of the Source form.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Permission for Use and Modification Without Distribution
%
% (1) You are permitted to use the Standard Version and create and use
% Modified Versions for any purpose without restriction, provided that
% you do not Distribute the Modified Version.
%
% Permissions for Redistribution of the Standard Version
%
% (2) You may Distribute verbatim copies of the Source form of the
% Standard Version of this Package in any medium without restriction,
% either gratis or for a Distributor Fee, provided that you duplicate
% all of the original copyright notices and associated disclaimers. At
% your discretion, such verbatim copies may or may not include a
% Compiled form of the Package.
%
% (3) You may apply any bug fixes, portability changes, and other
% modifications made available from the Copyright Holder. The resulting
% Package will still be considered the Standard Version, and as such
% will be subject to the Original License.
%
% Distribution of Modified Versions of the Package as Source
%
% (4) You may Distribute your Modified Version as Source (either gratis
% or for a Distributor Fee, and with or without a Compiled form of the
% Modified Version) provided that you clearly document how it differs
% from the Standard Version, including, but not limited to, documenting
% any non-standard features, executables, or modules, and provided that
% you do at least ONE of the following:
%
% (a) make the Modified Version available to the Copyright Holder of the
% Standard Version, under the Original License, so that the Copyright
% Holder may include your modifications in the Standard Version. (b)
% ensure that installation of your Modified Version does not prevent the
% user installing or running the Standard Version. In addition, the
% modified Version must bear a name that is different from the name of
% the Standard Version. (c) allow anyone who receives a copy of the
% Modified Version to make the Source form of the Modified Version
% available to others under (i) the Original License or (ii) a license
% that permits the licensee to freely copy, modify and redistribute the
% Modified Version using the same licensing terms that apply to the copy
% that the licensee received, and requires that the Source form of the
% Modified Version, and of any works derived from it, be made freely
% available in that license fees are prohibited but Distributor Fees are
% allowed.
%
% Distribution of Compiled Forms of the Standard Version or
% Modified Versions without the Source
%
% (5) You may Distribute Compiled forms of the Standard Version without
% the Source, provided that you include complete instructions on how to
% get the Source of the Standard Version. Such instructions must be
% valid at the time of your distribution. If these instructions, at any
% time while you are carrying out such distribution, become invalid, you
% must provide new instructions on demand or cease further
% distribution. If you provide valid instructions or cease distribution
% within thirty days after you become aware that the instructions are
% invalid, then you do not forfeit any of your rights under this
% license.
%
% (6) You may Distribute a Modified Version in Compiled form without the
% Source, provided that you comply with Section 4 with respect to the
% Source of the Modified Version.
%
% Aggregating or Linking the Package
%
% (7) You may aggregate the Package (either the Standard Version or
% Modified Version) with other packages and Distribute the resulting
% aggregation provided that you do not charge a licensing fee for the
% Package. Distributor Fees are permitted, and licensing fees for other
% components in the aggregation are permitted. The terms of this license
% apply to the use and Distribution of the Standard or Modified Versions
% as included in the aggregation.
%
% (8) You are permitted to link Modified and Standard Versions with
% other works, to embed the Package in a larger work of your own, or to
% build stand-alone binary or bytecode versions of applications that
% include the Package, and Distribute the result without restriction,
% provided the result does not expose a direct interface to the Package.
%
% Items That are Not Considered Part of a Modified Version
%
% (9) Works (including, but not limited to, modules and scripts) that
% merely extend or make use of the Package, do not, by themselves, cause
% the Package to be a Modified Version. In addition, such works are not
% considered parts of the Package itself, and are not subject to the
% terms of this license.
%
% General Provisions
%
% (10) Any use, modification, and distribution of the Standard or
% Modified Versions is governed by this Artistic License. By using,
% modifying or distributing the Package, you accept this license. Do not
% use, modify, or distribute the Package, if you do not accept this
% license.
%
% (11) If your Modified Version has been derived from a Modified Version
% made by someone other than you, you are nevertheless required to
% ensure that your Modified Version complies with the requirements of
% this license.
%
% (12) This license does not grant you the right to use any trademark,
% service mark, tradename, or logo of the Copyright Holder.
%
% (13) This license includes the non-exclusive, worldwide,
% free-of-charge patent license to make, have made, use, offer to sell,
% sell, import and otherwise transfer the Package with respect to any
% patent claims licensable by the Copyright Holder that are necessarily
% infringed by the Package. If you institute patent litigation
% (including a cross-claim or counterclaim) against any party alleging
% that the Package constitutes direct or contributory patent
% infringement, then this Artistic License to you shall terminate on the
% date that such litigation is filed.
%
% (14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT
% HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED
% WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
% PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT
% PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT
% HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT,
% INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE
% OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ProbLog inference
%
% assumes probabilistic facts as Prob::Fact and clauses in normal Prolog format
%
% provides following inference modes (16/12/2008):
% - approximation with interval width Delta (IJCAI07): problog_delta(+Query,+Delta,-Low,-High,-Status)
% - bounds based on single probability threshold: problog_threshold(+Query,+Threshold,-Low,-High,-Status)
% - as above, but lower bound only: problog_low(+Query,+Threshold,-Low,-Status)
% - lower bound based on K most likely proofs: problog_kbest(+Query,+K,-Low,-Status)
% - explanation probability (ECML07): problog_max(+Query,-Prob,-FactsUsed)
% - exact probability: problog_exact(+Query,-Prob,-Status)
% - sampling: problog_montecarlo(+Query,+Delta,-Prob)
%
%
% angelika.kimmig@cs.kuleuven.be
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
:- module(problog, [problog_koptimal/3,
problog_koptimal/4,
problog_delta/5,
problog_threshold/5,
problog_low/4,
problog_kbest/4,
problog_kbest_save/6,
problog_max/3,
problog_kbest_explanations/3,
problog_exact/3,
problog_all_explanations/2,
problog_all_explanations_unsorted/2,
problog_exact_save/5,
problog_montecarlo/3,
problog_dnf_sampling/3,
problog_answers/2,
problog_kbest_answers/3,
problog_table/1,
clear_retained_tables/0,
problog_neg/1,
get_fact_probability/2,
set_fact_probability/2,
get_continuous_fact_parameters/2,
set_continuous_fact_parameters/2,
get_fact/2,
tunable_fact/2,
tunable_continuous_fact/2,
continuous_fact/1,
non_ground_fact/1,
export_facts/1,
problog_help/0,
problog_version/0,
show_inference/0,
problog_dir/1,
set_problog_flag/2,
problog_flag/2,
problog_flags/0,
problog_flags/1,
reset_problog_flags/0,
problog_assert/1,
problog_assert/2,
problog_retractall/1,
problog_statistics/2,
problog_statistics/0,
grow_atom_table/1,
problog_exact_nested/3,
problog_tabling_negated_synonym/2,
problog_control/2,
build_trie/2,
build_trie/3,
problog_infer/2,
problog_infer/3,
problog_infer_forest/2,
write_bdd_struct_script/3,
problog_bdd_forest/1,
require/1,
unrequire/1,
bdd_files/2,
delete_bdd_forest_files/1,
recover_grounding_id/2,
grounding_is_known/2,
grounding_id/3,
decision_fact/2,
reset_non_ground_facts/0,
'::'/2,
probabilistic_fact/3,
continuous_fact/3,
init_problog/1,
problog_call/1,
problog_infer_forest_supported/0,
problog_bdd_forest_supported/0,
problog_real_kbest/4,
op( 550, yfx, :: ),
op( 550, fx, ?:: ),
op(1149, yfx, <-- ),
op( 1150, fx, problog_table ),
in_interval/3,
below/2,
above/2]).
:- style_check(all).
:- yap_flag(unknown,error).
% general yap modules
:- use_module(library(lists), [append/3,member/2,memberchk/2,reverse/2,select/3,nth1/3,nth1/4,nth0/4,sum_list/2]).
:- use_module(library(terms), [variable_in_term/2,variant/2] ).
:- use_module(library(random), [random/1]).
:- use_module(library(system), [tmpnam/1,shell/2,delete_file/1]).
:- use_module(library(ordsets), [list_to_ord_set/2, ord_insert/3, ord_union/3]).
%Joris
:- use_module(library(lineutils)).
%Joris
% problog related modules
:- use_module('problog/variables').
:- use_module('problog/extlists').
:- use_module('problog/gflags').
:- use_module('problog/flags').
:- use_module('problog/print').
:- use_module('problog/os').
:- use_module('problog/ptree', [init_ptree/1,
delete_ptree/1,
member_ptree/2,
enum_member_ptree/2,
insert_ptree/2,
delete_ptree/2,
edges_ptree/2,
count_ptree/2,
prune_check_ptree/2,
empty_ptree/1,
merge_ptree/2,
merge_ptree/3,
bdd_ptree/3,
bdd_struct_ptree/3,
bdd_ptree_map/4,
bdd_struct_ptree_map/4,
traverse_ptree/2, %theo
print_ptree/1, %theo
statistics_ptree/0, %theo
print_nested_ptree/1, %theo
trie_to_bdd_trie/5, %theo
trie_to_bdd_struct_trie/5,
nested_trie_to_bdd_trie/5, %theo
nested_trie_to_bdd_struct_trie/5,
ptree_decomposition/3,
ptree_decomposition_struct/3,
nested_ptree_to_BDD_script/3, %theo
nested_ptree_to_BDD_struct_script/3,
ptree_db_trie_opt_performed/3,
bdd_vars_script/1]).
:- use_module('problog/tabling').
:- use_module('problog/sampling').
:- use_module('problog/intervals').
:- use_module('problog/mc_DNF_sampling').
:- use_module('problog/timer').
:- use_module('problog/utils').
:- use_module('problog/ad_converter').
:- catch(use_module('problog/variable_elimination'),_,true).
% op attaching probabilities to facts
:- op( 550, yfx, :: ).
:- op( 550, fx, ?:: ).
%%%%%%%%%%%%%%%%%%%%%%%%
% control predicates on various levels
%%%%%%%%%%%%%%%%%%%%%%%%
% global over all inference methods, internal use only
:- dynamic(problog_predicate/2).
:- dynamic(problog_continuous_predicate/3).
% global over all inference methods, exported
:- dynamic(tunable_fact/2).
:- dynamic(non_ground_fact/1).
:- dynamic(continuous_fact/1).
% global, manipulated via problog_control/2
:- dynamic(up/0).
:- dynamic(limit/0).
:- dynamic(mc/0).
:- dynamic(remember/0).
:- dynamic(exact/0). % Theo tabling
:- dynamic(find_decisions/0).
:- dynamic(internal_strategy/0).
% local to problog_delta
:- dynamic(low/2).
:- dynamic(up/2).
:- dynamic(stopDiff/1).
% local to problog_kbest
:- dynamic(current_kbest/3).
% local to problog_max
:- dynamic(max_probability/1).
:- dynamic(max_proof/1).
% local to problog_montecarlo
:- dynamic(mc_prob/1).
% local to problog_answers
:- dynamic(answer/1).
% to keep track of the groundings for non-ground facts
:- dynamic(grounding_is_known/2).
% for decisions
:- dynamic(decision_fact/2).
% for fact where the proabability is a variable
:- dynamic(dynamic_probability_fact/1).
:- dynamic(dynamic_probability_fact_extract/2).
% for storing continuous parts of proofs (Hybrid ProbLog)
:- dynamic([hybrid_proof/3, hybrid_proof/4]).
:- dynamic(hybrid_proof_disjoint/4).
% local to problog_koptimal
:- dynamic optimal_proof/2.
:- dynamic current_prob/1.
:- dynamic possible_proof/2.
:- dynamic impossible_proof/1.
:- table conditional_prob/4.
% ProbLog files declare prob. facts as P::G
% and this module provides the predicate X::Y to iterate over them
:- multifile('::'/2).
:- multifile(user:term_expansion/1).
% directory where problogbdd executable is located
% automatically set during loading -- assumes it is in same place as this file (problog.yap)
:- getcwd(PD), set_problog_path(PD).
%%%%%%%%%%%%
% iterative deepening on minimal probabilities (delta, max, kbest):
% - first threshold (not in log-space as only used to retrieve argument for init_threshold/1, which is also used with user-supplied argument)
% - last threshold to ensure termination in case infinite search space (saved also in log-space for easy comparison with current values during search)
% - factor used to decrease threshold for next level, NewMin=Factor*OldMin (saved also in log-space)
%%%%%%%%%%%%
:- initialization((
problog_define_flag(first_threshold, problog_flag_validate_indomain_0_1_open, 'starting threshold iterative deepening', 0.1, inference),
problog_define_flag(last_threshold, problog_flag_validate_indomain_0_1_open, 'stopping threshold iterative deepening', 1.0E-30, inference, flags:last_threshold_handler),
problog_define_flag(id_stepsize, problog_flag_validate_indomain_0_1_close, 'threshold shrinking factor iterative deepening', 0.5, inference, flags:id_stepsize_handler)
)).
%%%%%%%%%%%%
% prune check stops derivations if they use a superset of facts already known to form a proof
% (very) costly test, can be switched on/off here (This is obsolete as it is not included in implementation)
%%%%%%%%%%%%
:- initialization(
problog_define_flag(prunecheck, problog_flag_validate_switch, 'stop derivations including all facts of known proof', off, inference)
).
%%%%%%%%%%%%
% max number of calls to probabilistic facts per derivation (to ensure termination)
%%%%%%%%%%%%
:- initialization(
problog_define_flag(maxsteps, problog_flag_validate_posint, 'max. number of prob. steps per derivation', 1000, inference)
).
%%%%%%%%%%%%
% BDD timeout in seconds, used as option in BDD tool
% files to write BDD script and pars
% bdd_file overwrites bdd_par_file with matching extended name
% if different name wanted, respect order when setting
% save BDD information for the (last) lower bound BDD used during inference
% produces three files named save_script, save_params, save_map
% located in the directory given by problog_flag dir
%%%%%%%%%%%%
:- initialization((
% problog_define_flag(bdd_path, problog_flag_validate_directory, 'problogbdd directory', '.',bdd),
problog_define_flag(bdd_time, problog_flag_validate_posint, 'BDD computation timeout in seconds', 60, bdd),
problog_define_flag(save_bdd, problog_flag_validate_boolean, 'save BDD files for (last) lower bound', false, bdd),
problog_define_flag(dynamic_reorder, problog_flag_validate_boolean, 'use dynamic re-ordering for BDD', true, bdd),
problog_define_flag(bdd_static_order, problog_flag_validate_boolean, 'use a static order', false, bdd)
)).
%%%%%%%%%%%%
% Storing the calculated BDD for later reuse in koptimal
% - nodedump bdd of the last constructed bdd
% - nodedump bdd file where the nodedump should be stored
%%%%%%%%%%%%
:- initialization((
problog_define_flag(nodedump_bdd, problog_flag_validate_boolean, 'store the calculated BDD', false, bdd),
problog_define_flag(nodedump_file, problog_flag_validate_file, 'file to store the nodedump of the BDD', nodedump_bdd, bdd)
)).
%%%%%%%%%%%%
% determine whether ProbLog outputs information (number of proofs, intermediate results, ...)
% default was true, as otherwise problog_delta won't output intermediate bounds
% default is false now, as dtproblog will flood the user with verbosity
%%%%%%%%%%%%
:- initialization(
problog_define_flag(verbose, problog_flag_validate_boolean, 'output intermediate information', false,output)
).
%%%%%%%%%%%%
% determine whether ProbLog outputs proofs when adding to trie
% default is false
%%%%%%%%%%%%
:- initialization(
problog_define_flag(show_proofs, problog_flag_validate_boolean, 'output proofs', false,output)
).
%%%%%%%%%%%%
% Trie dump parameter for saving a file with the trie structure in the directory by problog_flag dir
%%%%%%%%%%%%
:- initialization(
problog_define_flag(triedump, problog_flag_validate_boolean, 'generate file: trie_file containing the trie structure', false,output)
).
%%%%%%%%%%%%
% Default inference method
%%%%%%%%%%%%
:- initialization(problog_define_flag(inference, problog_flag_validate_dummy, 'default inference method', exact, inference)).
%%%%%%%%%%%%
% Tunable Facts
%%%%%%%%%%%%
:- initialization(problog_define_flag(tunable_fact_start_value,problog_flag_validate_dummy,'How to initialize tunable probabilities',uniform(0.1,0.9),learning_general,flags:learning_prob_init_handler)).
problog_dir(PD):- problog_path(PD).
%%%%%%%%%%%%%%%%%%%%%%%%
% initialization of global parameters
%%%%%%%%%%%%%%%%%%%%%%%%
init_global_params :-
grow_atom_table(1000000), % this will reserve us some memory, there are cases where you might need more
%%%%%%%%%%%%
% working directory: all the temporary and output files will be located there
% it assumes a subdirectory of the current working dir
% on initialization, the current dir is the one where the user's file is located
% should be changed to use temporary folder structure of operating system
%%%%%%%%%%%%
tmpnam(TempFolder),
atomic_concat([TempFolder, '_problog'], TempProblogFolder),
problog_define_flag(dir, problog_flag_validate_directory, 'directory for files', TempProblogFolder, output),
problog_define_flag(bdd_par_file, problog_flag_validate_file, 'file for BDD variable parameters', example_bdd_probs, bdd, flags:working_file_handler),
problog_define_flag(bdd_result, problog_flag_validate_file, 'file to store result calculated from BDD', example_bdd_res, bdd, flags:working_file_handler),
problog_define_flag(bdd_file, problog_flag_validate_file, 'file for BDD script', example_bdd, bdd, flags:bdd_file_handler),
problog_define_flag(static_order_file, problog_flag_validate_file, 'file for BDD static order', example_bdd_order, bdd, flags:working_file_handler),
problog_define_flag(map_file, problog_flag_validate_file, 'the file to output the variable map', map_file, output, flags:working_file_handler),
%%%%%%%%%%%%
% montecarlo: recalculate current approximation after N samples
% montecarlo: write log to this file
%%%%%%%%%%%%
problog_define_flag(mc_logfile, problog_flag_validate_file, 'logfile for montecarlo', 'log.txt', mcmc, flags:working_file_handler),
check_existance('problogbdd').
% parameter initialization to be called after returning to user's directory:
:- initialization(init_global_params).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% internal control flags
% if on
% - up: collect stopped derivations to build upper bound
% - limit: iterative deepening reached limit -> should go to next level
% - mc: using problog_montecarlo, i.e. proving with current sample instead of full program
% - remember: save BDD files containing script, params and mapping
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_control(on,X) :-
call(X),!.
problog_control(on,X) :-
assertz(X).
problog_control(off,X) :-
retractall(X).
problog_control(check,X) :-
call(X).
reset_control :-
problog_control(off,up),
problog_control(off,mc),
problog_control(off,limit),
% problog_control(off,exact),
problog_control(off,remember).
:- initialization(reset_control).
grow_atom_table(N):-
generate_atoms(N, 0),
garbage_collect_atoms.
generate_atoms(N, N):-!.
generate_atoms(N, A):-
NA is A + 1,
atomic_concat([theo, A], _Atom),
generate_atoms(N, NA).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% nice user syntax Prob::Fact
% automatic translation to internal hardware access format
%
% probabilities =1 are dropped -> normal Prolog fact
%
% internal fact representation
% - prefixes predicate name with problog_
% - adds unique ID as first argument
% - adds logarithm of probability as last argument
% - keeps original arguments in between
%
% for each predicate appearing as probabilistic fact, wrapper clause is introduced:
% - head is most general instance of original fact
% - body is corresponding version of internal fact plus call to add_to_proof/2 to update current state during proving
% example: edge(A,B) :- problog_edge(ID,A,B,LogProb), add_to_proof(ID,LogProb).
%
% dynamic predicate problog_predicate(Name,Arity) keeps track of predicates that already have wrapper clause
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% converts annotated disjunctions
term_expansion_intern((Head<--Body), Module, C):-
term_expansion_intern_ad((Head<--Body), Module,inference, C).
% converts ?:: prefix to ? :: infix, as handled by other clause
term_expansion_intern((Annotation::Fact), Module, ExpandedClause) :-
Annotation == '?',
term_expansion_intern((? :: Fact :- true), Module, ExpandedClause).
% handles decision clauses
term_expansion_intern((Annotation :: Head :- Body), Module, problog:ExpandedClause) :-
(
Annotation == '?' ->
% It's a decision with a body
(decision_fact(_,Head) ->
throw(error('New decision unifies with already defined decision!', (Head))) ; true
),
copy_term((Head,Body),(HeadCopy,_BodyCopy)),
functor(Head, Functor, Arity),
atomic_concat([problog_,Functor],LongFunctor),
Head =.. [Functor|Args],
append(Args,[LProb],LongArgs),
probclause_id(ID),
ProbFactHead =.. [LongFunctor,ID|LongArgs],
assertz(decision_fact(ID,Head)),
ExpandedClause = (ProbFactHead :-
user:Body,
(problog_control(check,internal_strategy) ->
dtproblog:strategy_log(ID,Head,LProb)
;
LProb = '?'
)
),
assertz(dynamic_probability_fact(ID)),
assertz((dynamic_probability_fact_extract(HeadCopy,P_New) :-
dtproblog:strategy(ID,HeadCopy,P_New)
)),
(ground(Head) ->
true
;
assertz(non_ground_fact(ID))
),
problog_predicate(Functor, Arity, LongFunctor, Module)
;
% If it has a body, it's not supported
(Body == true ->
% format('Expanding annotated fact ~q :: ~q :- ~q in other clause.~n',[Annotation,Head,Body]),
fail
;
throw(error('Please use an annoted disjunction P :: Head <-- Body instead of the annated clause.', (Annotation :: Head :- Body)))
)
).
% handles continuous facts
term_expansion_intern(Head :: Goal,Module,problog:ProbFact) :-
nonvar(Head),
Head=(X,Distribution),
!,
(
Distribution=gaussian(Mu,Sigma)
->
true;
( throw(unknown_distribution)
)
),
(
variable_in_term_exactly_once(Goal,X)
->
true;
(
throw(variable)
)
),
% bind_the_variable
X=Distribution,
% find position in term
Goal=..[Name|Args],
once(nth1(Pos,Args,Distribution)),
length(Args,Arity),
atomic_concat([problogcontinuous_,Name],ProblogName),
probclause_id(ID),
% is it a tunable fact?
(
(number(Mu),number(Sigma))
->
NewArgs=Args;
(
Mu_Random is 0.1, % random*4-2,
Sigma_Random is 0.4, % random*2+0.5,
nth1(Pos,Args,_,KeepArgs),
nth1(Pos,NewArgs,gaussian(Mu_Random,Sigma_Random),KeepArgs),
assertz(tunable_fact(ID,gaussian(Mu,Sigma)))
)
),
ProbFact =.. [ProblogName,ID|NewArgs],
(
ground(Goal)
->
true;
assertz(non_ground_fact(ID))
),
assertz(continuous_fact(ID)),
problog_continuous_predicate(Name, Arity, Pos,ProblogName,Module).
% handles probabilistic facts
term_expansion_intern(P :: Goal,Module,problog:ProbFact) :-
copy_term((P,Goal),(P_Copy,Goal_Copy)),
functor(Goal, Name, Arity),
atomic_concat([problog_,Name],ProblogName),
Goal =.. [Name|Args],
append(Args,[LProb],L1),
probclause_id(ID),
ProbFact =.. [ProblogName,ID|L1],
(
(nonvar(P), P = t(TrueProb))
->
(
assertz(tunable_fact(ID,TrueProb)),
sample_initial_value_for_tunable_fact(Goal,LProb)
);
(
ground(P)
->
EvalP is P, % allows one to use ground arithmetic expressions as probabilities
LProb is log(P),
assert_static(prob_for_id(ID,EvalP,LProb)); % Prob is fixed -- assert it for quick retrieval
(
% Probability is a variable... check wether it appears in the term
(
variable_in_term(Goal,P)
->
true;
(
format(user_error,'If you use probabilisitic facts with a variable as probabilility, the variable has to appear inside the fact.~n',[]),
format(user_error,'You used ~q in your program.~2n',[P::Goal]),
throw(non_ground_fact_error(P::Goal))
)
),
LProb=log(P),
assertz(dynamic_probability_fact(ID)),
assertz(dynamic_probability_fact_extract(Goal_Copy,P_Copy))
)
)
),
(
ground(Goal)
->
true;
assertz(non_ground_fact(ID))
),
problog_predicate(Name, Arity, ProblogName,Module).
sample_initial_value_for_tunable_fact(Goal,LogP) :-
problog_flag(tunable_fact_start_value,Initializer),
(
Initializer=uniform(Low,High)
->
(
Spread is High-Low,
random(Rand),
P1 is Rand*Spread+Low,
% security check, to avoid log(0)
(
P1>0
->
P=P1;
P=0.5
)
);
(
number(Initializer)
->
P=Initializer
;
atom(Initializer)
->
call(user:Initializer,Goal,P)
;
throw(unkown_probability_initializer(Initializer))
)
),
LogP is log(P).
%
% introduce wrapper clause if predicate seen first time
problog_continuous_predicate(Name, Arity,ContinuousArgumentPosition,_,_) :-
problog_continuous_predicate(Name, Arity,OldContinuousArgumentPosition),
!,
(
ContinuousArgumentPosition=OldContinuousArgumentPosition
->
true;
(
format(user_error,'Continuous predicates of the same name and arity must ',[]),
format(user_error,'have the continuous argument all at the same position.~n',[]),
format(user_error,'Your program contains the predicate ~q/~q. There are ',[]),
format(user_error,'atoms which have the continuous argument at position ',[]),
format(user_error,'~q and other have it at ~q.',[Name,Arity,OldContinuousArgumentPosition,ContinuousArgumentPosition]),
throw(continuous_argument(not_unique_position))
)
).
problog_continuous_predicate(Name, Arity, ContinuousArgumentPosition, ProblogName,Module) :-
LBefore is ContinuousArgumentPosition-1,
LAfter is Arity-ContinuousArgumentPosition,
length(ArgsBefore,LBefore),
length(ArgsAfter,LAfter),
append(ArgsBefore,[(ID,ID2,GaussianArg)|ArgsAfter],Args),
append(ArgsBefore,[GaussianArg|ArgsAfter],ProbArgs),
OriginalGoal =.. [Name|Args],
ProbFact =.. [ProblogName,ID|ProbArgs],
assertz( (Module:OriginalGoal :- ProbFact,
% continuous facts always get a grounding ID, even when they are actually ground
% this simplifies the BDD script generation
non_ground_fact_grounding_id(ProbFact,Ground_ID),
atomic_concat([ID,'_',Ground_ID],ID2),
add_continuous_to_proof(ID,ID2)
)),
assertz(problog_continuous_predicate(Name, Arity,ContinuousArgumentPosition)),
ArityPlus1 is Arity+1,
dynamic(problog:ProblogName/ArityPlus1).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% predicates for the user to manipulate continuous facts
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
in_interval(ID,Low,High) :-
var(ID),
throw(error(instantiation_error,in_interval(ID,Low,High))).
in_interval(ID,Low,High) :-
var(Low),
throw(error(instantiation_error,in_interval(ID,Low,High))).
in_interval(ID,Low,High) :-
var(High),
throw(error(instantiation_error,in_interval(ID,Low,High))).
in_interval(ID,Low,High) :-
\+ number(Low),
throw(error(type_error(number,Low),in_interval(ID,Low,High))).
in_interval(ID,Low,High) :-
\+ number(High),
throw(error(type_error(number,High),in_interval(ID,Low,High))).
in_interval(ID,Low,High) :-
Low<High,
interval_merge(ID,interval(Low,High)).
below(ID,X) :-
var(ID),
throw(error(instantiation_error,below(ID,X))).
below(ID,X) :-
var(X),
throw(error(instantiation_error,below(ID,X))).
below(ID,X) :-
\+ number(X),
throw(error(type_error(number,X),below(ID,X))).
below(ID,X) :-
interval_merge(ID,below(X)).
above(ID,X) :-
var(ID),
throw(error(instantiation_error,above(ID,X))).
above(ID,X) :-
var(X),
throw(error(instantiation_error,above(ID,X))).
above(ID,X) :-
\+ number(X),
throw(error(type_error(number,X),above(ID,X))).
above(ID,X) :-
interval_merge(ID,above(X)).
interval_merge((_ID,GroundID,_Type),Interval) :-
atomic_concat([interval,'_',GroundID],Key),
b_getval(Key,OldInterval),
intervals_merge(OldInterval,Interval,NewInterval),
NewInterval \= none,
NewInterval \= interval(Bound,Bound),
b_setval(Key,NewInterval).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% assert/retract for probabilistic facts
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_assert(P::Goal) :-
problog_assert(user,P::Goal).
problog_assert(Module, P::Goal) :-
term_expansion_intern(P::Goal,Module,problog:ProbFact),
assertz(problog:ProbFact).
problog_retractall(Goal) :-
Goal =.. [F|Args],
append([_ID|Args],[_Prob],Args2),
atomic_concat(['problog_',F],F2),
ProbLogGoal=..[F2|Args2],
retractall(problog:ProbLogGoal).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% introduce wrapper clause if predicate seen first time
problog_predicate(Name, Arity, _,_) :-
problog_predicate(Name, Arity), !.
problog_predicate(Name, Arity, ProblogName,Mod) :-
functor(OriginalGoal, Name, Arity),
OriginalGoal =.. [_|Args],
append(Args,[Prob],L1),
ProbFact =.. [ProblogName,ID|L1],
assertz( (Mod:OriginalGoal :-
ProbFact,
grounding_id(ID,OriginalGoal,ID2),
prove_problog_fact(ID,ID2,Prob)
)),
assertz( (Mod:problog_not(OriginalGoal) :-
ProbFact,
grounding_id(ID,OriginalGoal,ID2),
prove_problog_fact_negated(ID,ID2,Prob)
)),
assertz(problog_predicate(Name, Arity)),
ArityPlus2 is Arity+2,
dynamic(problog:ProblogName/ArityPlus2).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Generating and storing the grounding IDs for
% non-ground probabilistic facts
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
:- multifile(user:problog_user_ground/1).
user:problog_user_ground(Goal) :-
ground(Goal).
non_ground_fact_grounding_id(Goal,ID) :-
user:problog_user_ground(Goal), !,
(grounding_is_known(Goal,ID) ->
true
;
(
nb_getval(non_ground_fact_grounding_id_counter,ID),
ID2 is ID+1,
nb_setval(non_ground_fact_grounding_id_counter,ID2),
assertz(grounding_is_known(Goal,ID))
)
).
non_ground_fact_grounding_id(Goal,_) :-
format(user_error,'The current program uses non-ground facts.~n', []),
format(user_error,'If you query those, you may only query fully-grounded versions of the fact.~n',[]),
format(user_error,'Within the current proof, you queried for ~q which is not ground.~2n', [Goal]),
throw(error(non_ground_fact(Goal))).
reset_non_ground_facts :-
required(keep_ground_ids),
!.
reset_non_ground_facts :-
nb_setval(non_ground_fact_grounding_id_counter,0),
retractall(grounding_is_known(_,_)).
:- initialization(reset_non_ground_facts).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Getting the ID for any kind of ground fact
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
grounding_id(ID,Goal,ID2) :-
(non_ground_fact(ID)->
non_ground_fact_grounding_id(Goal,G_ID),
atomic_concat([ID,'_',G_ID],ID2)
;
ID2=ID
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% What to do when prolog tries to prove a problog fact
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
prove_problog_fact(ClauseID,GroundID,Prob) :-
(problog_control(check,find_decisions) ->
signal_decision(ClauseID,GroundID)
;
(Prob = '?' ->
add_to_proof(GroundID,0) % 0 is log(1)!
;
% Checks needed for LeDTProbLog
(Prob = always ->
% Always true, do not add to trie
true
;
(Prob = never ->
% Always false, do not add to trie
fail
;
% something in between, add to proof
ProbEval is Prob,
add_to_proof(GroundID,ProbEval)
)
)
)
).
prove_problog_fact_negated(ClauseID,GroundID,Prob) :-
(problog_control(check,find_decisions) ->
signal_decision(ClauseID,GroundID)
;
(Prob = '?' ->
add_to_proof_negated(GroundID,-inf) % 0 is log(1)!
;
% Checks needed for LeDTProbLog
(Prob = always ->
% Always true, do not add to trie
fail
;
(Prob = never ->
% Always false, do not add to trie
true
;
% something in between, add to proof
ProbEval is Prob,
add_to_proof_negated(GroundID,ProbEval)
)
)
)
).
% generate next global identifier
:- initialization(nb_setval(probclause_counter,0)).
probclause_id(ID) :-
nb_getval(probclause_counter,ID), !,
C1 is ID+1,
nb_setval(probclause_counter,C1), !.
% backtrack over all probabilistic facts
% must come before term_expansion
Prob::Goal :-
probabilistic_fact(Prob,Goal,_ID).
(V,Distribution)::Goal :-
continuous_fact((V,Distribution),Goal,_ID).
% backtrack over all probabilistic facts
probabilistic_fact(Prob,Goal,ID) :-
ground(Goal),
!,
Goal =.. [F|Args],
atomic_concat('problog_',F,F2),
append([ID|Args],[LProb],Args2),
Goal2 =..[F2|Args2],
length(Args2,N),
current_predicate(F2/N),
Goal2,
number(LProb),
Prob is exp(LProb).
probabilistic_fact(Prob,Goal,ID) :-
get_internal_fact(ID,ProblogTerm,_ProblogName,_ProblogArity),
ProblogTerm =.. [F,_ID|Args],
append(Args2,[LProb],Args),
name(F,[_p,_r,_o,_b,_l,_o,_g,_|F2Chars]),
name(F2,F2Chars),
Goal =.. [F2|Args2],
(
dynamic_probability_fact(ID)
->
Prob=p;
Prob is exp(LProb)
).
continuous_fact((V,Distribution),Goal,ID) :-
get_internal_continuous_fact(ID,ProblogTerm,ProblogName,_ProblogArity,ContinuousPos),
% strip away problog_continuous
ProblogTerm=..[ProblogName,ID|Arguments],
nth1(ContinuousPos,Arguments,Distribution,Rest),
nth1(ContinuousPos,Arguments2,V,Rest),
atomic_concat(problogcontinuous_,Name,ProblogName),
% Build final term
Goal=..[Name|Arguments2].
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% proof_id(-ID) generates a new ID for a proof
% reset_proof_id resets the ID counter to 0
%
% this ID is used by Hybrid ProbLog to identify proofs
% and later for disjoining them
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
proof_id(ID) :-
nb_getval(problog_proof_id,ID),
ID2 is ID+1,
nb_setval(problog_proof_id,ID2).
reset_proof_id :-
nb_setval(problog_proof_id,0).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% access/update the probability of ID's fact
% hardware-access version: naively scan all problog-predicates (except if prob is recorded in static database),
% cut choice points if ID is ground (they'll all fail as ID is unique),
% but not if it isn't (used to iterate over all facts when writing out probabilities for learning)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% using a dummy for the static prob database is more efficient than checking for current_predicate
prob_for_id(dummy,dummy,dummy).
get_fact_probability(A, Prob) :-
ground(A),
\+ number(A),
name(A, A_Codes),
once(append(Part1, [95|Part2], A_Codes)), % 95 = '_'
number_codes(ID, Part1), !,
% let's check whether Part2 contains an 'l' (l=low)
\+ memberchk(108,Part2),
number_codes(Grounding_ID, Part2),
(
dynamic_probability_fact(ID)
->
grounding_is_known(Goal, Grounding_ID),
dynamic_probability_fact_extract(Goal, Prob)
;
get_fact_probability(ID, Prob)
),
!.
get_fact_probability(ID,Prob) :-
ground(ID),
prob_for_id(ID,Prob,_),
!.
get_fact_probability(ID,Prob) :-
(
ground(ID) ->
get_internal_fact(ID,ProblogTerm,_ProblogName,ProblogArity),!
;
get_internal_fact(ID,ProblogTerm,_ProblogName,ProblogArity)
),
arg(ProblogArity,ProblogTerm,Log),
(Log = '?' ->
throw(error('Why do you want to know the probability of a decision?')) %fail
; ground(Log) ->
Prob is exp(Log)
;
Prob = p
).
get_fact_log_probability(ID,Prob) :-
ground(ID),
prob_for_id(ID,_,Prob),!.
get_fact_log_probability(ID,Prob) :-
(
ground(ID) ->
get_internal_fact(ID,ProblogTerm,_ProblogName,ProblogArity),!
;
get_internal_fact(ID,ProblogTerm,_ProblogName,ProblogArity)
),
arg(ProblogArity,ProblogTerm,Prob),
Prob \== '?'.
get_fact_log_probability(ID,Prob) :-
get_fact_probability(ID,Prob1),
Prob is log(Prob1).
set_fact_probability(ID,Prob) :-
get_internal_fact(ID,ProblogTerm,ProblogName,ProblogArity),
retract(ProblogTerm),
ProblogTerm =.. [ProblogName|ProblogTermArgs],
nth1(ProblogArity,ProblogTermArgs,_,KeepArgs),
NewLogProb is log(Prob),
nth1(ProblogArity,NewProblogTermArgs,NewLogProb,KeepArgs),
NewProblogTerm =.. [ProblogName|NewProblogTermArgs],
assertz(NewProblogTerm).
get_internal_fact(ID,ProblogTerm,ProblogName,ProblogArity) :-
problog_predicate(Name,Arity),
atomic_concat([problog_,Name],ProblogName),
ProblogArity is Arity+2,
functor(ProblogTerm,ProblogName,ProblogArity),
arg(1,ProblogTerm,ID),
call(ProblogTerm).
get_continuous_fact_parameters(ID,Parameters) :-
(
ground(ID) ->
get_internal_continuous_fact(ID,ProblogTerm,_ProblogName,ProblogArity,ContinuousPos),!
;
get_internal_continuous_fact(ID,ProblogTerm,_ProblogName,ProblogArity,ContinuousPos)
),
InternalPos is ContinuousPos+1,
arg(InternalPos,ProblogTerm,Parameters).
get_internal_continuous_fact(ID,ProblogTerm,ProblogName,ProblogArity,ContinuousPos) :-
problog_continuous_predicate(Name,Arity,ContinuousPos),
atomic_concat([problogcontinuous_,Name],ProblogName),
ProblogArity is Arity+1,
functor(ProblogTerm,ProblogName,ProblogArity),
arg(1,ProblogTerm,ID),
call(ProblogTerm).
set_continuous_fact_parameters(ID,Parameters) :-
get_internal_continuous_fact(ID,ProblogTerm,ProblogName,_ProblogArity,ContinuousPos),
retract(ProblogTerm),
ProblogTerm =.. [ProblogName|ProblogTermArgs],
nth0(ContinuousPos,ProblogTermArgs,_,KeepArgs),
nth0(ContinuousPos,NewProblogTermArgs,Parameters,KeepArgs),
NewProblogTerm =.. [ProblogName|NewProblogTermArgs],
assertz(NewProblogTerm).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% writing all probabilistic and continuous facts to Filename
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
export_facts(Filename) :-
open(Filename,'write',Handle),
%compiled ADs
forall((current_predicate(user:ad_intern/3),user:ad_intern(Original,ID,Facts)),
print_ad_intern(Handle,Original,ID,Facts)
),
nl(Handle),
% probabilistic facts
% but comment out auxiliary facts stemmig from
% compiled ADs
forall(P::Goal,
(
is_mvs_aux_fact(Goal)
->
format(Handle,'% ~10f :: ~q.~n',[P,Goal]);
format(Handle,'~10f :: ~q.~n',[P,Goal])
)
),
nl(Handle),
% continuous facts (Hybrid ProbLog)
forall(continuous_fact(ID),
(
get_continuous_fact_parameters(ID,Param),
format(Handle,'~q. % ~q~n',[Param,ID])
)
),
close(Handle).
is_mvs_aux_fact(A) :-
functor(A,B,_),
atomic_concat(mvs_fact_,_,B).
% code for printing the compiled ADs
print_ad_intern(Handle,(Head<--Body),_ID,Facts) :-
print_ad_intern(Head,Facts,0.0,Handle),
format(Handle,' <-- ~q.~n',[Body]).
print_ad_intern((A1;B1),[A2|B2],Mass,Handle) :-
once(print_ad_intern_one(A1,A2,Mass,NewMass,Handle)),
format(Handle,'; ',[]),
print_ad_intern(B1,B2,NewMass,Handle).
print_ad_intern(_::Fact,[],Mass,Handle) :-
P2 is 1.0 - Mass,
format(Handle,'~10f :: ~q',[P2,Fact]).
print_ad_intern(P::A1,[A2],Mass,Handle) :-
once(print_ad_intern_one(P::A1,A2,Mass,_NewMass,Handle)).
print_ad_intern_one(_::Fact,_::AuxFact,Mass,NewMass,Handle) :-
% ask problog to get the fact_id
once(probabilistic_fact(P,AuxFact,_FactID)),
P2 is P * (1-Mass),
NewMass is Mass+P2,
format(Handle,'~10f :: ~q',[P2,Fact]).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% recover fact for given id
% list version not exported (yet?)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ID of ground fact
get_fact(ID,OutsideTerm) :-
get_internal_fact(ID,ProblogTerm,ProblogName,ProblogArity),
!,
ProblogTerm =.. [_Functor,ID|Args],
atomic_concat('problog_',OutsideFunctor,ProblogName),
Last is ProblogArity-1,
nth1(Last,Args,_LogProb,OutsideArgs),
OutsideTerm =.. [OutsideFunctor|OutsideArgs].
% ID of instance of non-ground fact: get fact from grounding table
get_fact(ID,OutsideTerm) :-
recover_grounding_id(ID,GID),
grounding_is_known(OutsideTerm,GID).
recover_grounding_id(Atom,ID) :-
name(Atom,List),
reverse(List,Rev),
recover_number(Rev,NumRev),
reverse(NumRev,Num),
name(ID,Num).
recover_number([95|_],[]) :- !. % name('_',[95])
recover_number([A|B],[A|C]) :-
recover_number(B,C).
get_fact_list([],[]).
get_fact_list([ID|IDs],[Fact|Facts]) :-
(ID=not(X) -> Fact=not(Y); Fact=Y, ID=X),
get_fact(X,Y),
get_fact_list(IDs,Facts).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% ProbLog inference, core methods
%
% state of proving saved in two backtrackable global variables
% - problog_current_proof holds list of IDs of clauses used
% - problog_probability holds the sum of their log probabilities
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% called "inside" probabilistic facts to update current state of proving
% if number of steps exceeded, fail
% if fact used before, succeed and keep status as is
% if not prunable, calculate probability and
% if threshold exceeded, add stopped derivation to upper bound and fail
% else update state and succeed
%
% do not maintain gloabl variables in montecarlo mode
add_to_proof(ID, _LogProb) :-
problog_control(check, mc),
!,
montecarlo_check(ID).
add_to_proof(ID, LogProb) :-
b_getval(problog_steps,MaxSteps),
MaxSteps>0,
b_getval(problog_probability, CurrentLogProb),
nb_getval(problog_threshold, CurrentThreshold),
b_getval(problog_current_proof, IDs),
% check whether negation of this fact is already used in proof
\+ open_end_memberchk(not(ID),IDs),
( % check whether this fact is already used in proof
open_end_memberchk(ID, IDs)
->
true;
(
open_end_add(ID, IDs, NIDs),
NewLogProb is CurrentLogProb+LogProb,
(
NewLogProb < CurrentThreshold
->
(
upper_bound(NIDs),
fail
);
(
b_setval(problog_probability, NewLogProb),
b_setval(problog_current_proof, NIDs)
)
)
)
),
Steps is MaxSteps - 1,
b_setval(problog_steps, Steps).
add_to_proof_negated(ID, _) :-
problog_control(check, mc),
!,
% the sample has to fail if the fact is negated
\+ montecarlo_check(ID).
add_to_proof_negated(ID, LogProb) :-
b_getval(problog_steps, MaxSteps),
MaxSteps>0,
b_getval(problog_probability, CurrentLogProb),
nb_getval(problog_threshold, CurrentThreshold),
b_getval(problog_current_proof, IDs),
% check whether unnegated fact is already used in proof
\+ open_end_memberchk(ID, IDs),
( % check wether negation of this fact is already used in proof
open_end_memberchk(not(ID), IDs)
->
true;
(
open_end_add(not(ID), IDs, NIDs),
NewLogProb is CurrentLogProb + log(1-exp(LogProb)),
(
NewLogProb < CurrentThreshold
->
(
upper_bound(NIDs),
fail
);
(
b_setval(problog_probability, NewLogProb),
b_setval(problog_current_proof, NIDs)
)
)
)
),
Steps is MaxSteps - 1,
b_setval(problog_steps, Steps).
%Hybrid
add_continuous_to_proof(ID,GroundID) :-
b_getval(problog_continuous_facts_used,Facts),
(
memberchk((ID,GroundID),Facts)
->
true;
(
b_setval(problog_continuous_facts_used,[(ID,GroundID)|Facts]),
atomic_concat([interval,'_',GroundID],Key),
b_setval(Key,all)
)
).
% if in monte carlo mode ...
% (a) for ground facts (ID is number): check array to see if it can be used
montecarlo_check(ID) :-
number(ID),
!,
array_element(mc_sample,ID,V),
(
V == 1 -> true
;
V == 2 -> fail
;
new_sample(ID)
).
% (b) for non-ground facts (ID is FactID_GroundingID): check database of groundings in current sample
montecarlo_check(ComposedID) :-
% split_grounding_id(ComposedID,ID,GID),
recorded(mc_true,problog_mc_id(ComposedID),_),
!.
montecarlo_check(ComposedID) :-
% split_grounding_id(ComposedID,ID,GID),
recorded(mc_false,problog_mc_id(ComposedID),_),
!,
fail.
% (c) for unknown groundings of non-ground facts: generate a new sample (decompose the ID first)
montecarlo_check(ID) :-
name(ID,IDN),
recover_number(IDN,FactIDName),
name(FactID,FactIDName),
new_sample_nonground(ID,FactID).
% sampling from ground fact: set array value to 1 (in) or 2 (out)
new_sample(ID) :-
get_fact_probability(ID,Prob),
problog_random(R),
R<Prob,
!,
update_array(mc_sample,ID,1).
new_sample(ID) :-
update_array(mc_sample,ID,2),
fail.
% sampling from ground instance of non-ground fact: set database value for this grounding to true or false
new_sample_nonground(ComposedID,ID) :-
(dynamic_probability_fact(ID) ->
get_fact(ID,Fact),
split_grounding_id(ComposedID,ID,GID),
grounding_is_known(Fact,GID),
dynamic_probability_fact_extract(Fact,Prob)
;
get_fact_probability(ID,Prob)
),
problog_random(R),
(R < Prob ->
recorda(mc_true,problog_mc_id(ComposedID),_)
;
recorda(mc_false,problog_mc_id(ComposedID),_),
fail
).
% new_sample_nonground(ComposedID,_ID) :-
% recorda(mc_false,problog_mc_id(ComposedID),_),
% fail.
split_grounding_id(Composed,Fact,Grounding) :-
name(Composed,C),
split_g_id(C,F,G),
name(Fact,F),
name(Grounding,G).
split_g_id([95|Grounding],[],Grounding) :- !.
split_g_id([A|B],[A|FactID],GroundingID) :-
split_g_id(B,FactID,GroundingID).
% if threshold reached, remember this by setting limit to on, then
% if up is on, store stopped derivation in second trie
%
% List always length>=1 -> don't need []=true-case for tries
upper_bound(List) :-
problog_control(on, limit),
problog_control(check, up),
nb_getval(problog_stopped_proofs, Trie_Stopped_Proofs),
open_end_close_end(List, R),
% (prune_check(R, Trie_Stopped_Proofs) -> true; insert_ptree(R, Trie_Stopped_Proofs)).
insert_ptree(R, Trie_Stopped_Proofs).
% this is called by all inference methods before the actual ProbLog goal
% to set up environment for proving
% it resets control flags, method specific values to be set afterwards!
init_problog(Threshold) :-
reset_proof_id,
reset_non_ground_facts,
reset_control,
LT is log(Threshold),
b_setval(problog_probability, 0.0),
b_setval(problog_current_proof, []),
nb_setval(problog_threshold, LT),
problog_flag(maxsteps,MaxS),
init_tabling,
problog_var_clear_all,
b_setval(problog_steps, MaxS),
b_setval(problog_continuous_facts_used,[]),
retractall(hybrid_proof(_,_,_)),
retractall(hybrid_proof(_,_,_,_)),
retractall(hybrid_proof_disjoint(_,_,_,_)),
% reset all timers in case a query failed before
timer_reset(variable_elimination_time),
timer_reset(bdd_script_time),
timer_reset(bdd_generation_time),
timer_reset(script_gen_time_naive),
timer_reset(bdd_gen_time_naive),
timer_reset(script_gen_time_builtin),
timer_reset(bdd_gen_time_builtin),
timer_reset(script_gen_time_dec),
timer_reset(bdd_gen_time_dec),
timer_reset(sld_time),
timer_reset(build_tree_low).
% idea: proofs that are refinements of known proof can be pruned as they don't add probability mass
% note that current ptree implementation doesn't provide the check as there's no efficient method known so far...
prune_check(Proof, Trie) :-
problog_flag(prunecheck, on),
prune_check_ptree(Proof, Trie).
% to call a ProbLog goal, patch all subgoals with the user's module context
% (as logical part is there, but probabilistic part in problog)
problog_call(Goal) :-
yap_flag(typein_module, Module),
%%% if user provides init_db, call this before proving goal
(current_predicate(_,Module:init_db) -> call(Module:init_db); true),
put_module(Goal,Module,ModGoal),
call(ModGoal).
put_module((Mod:Goal,Rest),Module,(Mod:Goal,Transformed)) :-
!,
put_module(Rest,Module,Transformed).
put_module((Goal,Rest),Module,(Module:Goal,Transformed)) :-
!,
put_module(Rest,Module,Transformed).
put_module((Mod:Goal),_Module,(Mod:Goal)) :-
!.
put_module(Goal,Module,Module:Goal).
% end of core
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% evaluating a DNF given as trie using BDD
% input: Trie the trie to be used
% output: probability and status (to catch potential failures/timeouts from outside)
%
% with internal BDD timeout (set using problog flag bdd_time)
%
% bdd_ptree/3 constructs files for problogbdd from the trie
%
% if calling ProblogBDD doesn't exit successfully, status will be timeout
%
% writes number of proofs in trie and BDD time to standard user output
%
% if remember is on, input files for problogbdd will be saved
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
:- initialization((
problog_var_define(sld_time, times, time, messages('SLD resolution', ':', ' ms')),
problog_var_define(bdd_script_time, times, time, messages('Generating BDD script', ':', ' ms')),
problog_var_define(bdd_generation_time, times, time, messages('Constructing BDD', ':', ' ms')),
problog_var_define(trie_statistics, memory, untyped, messages('Trie usage', ':', '')),
problog_var_define(probability, result, number, messages('Probabilty', ' = ', '')),
problog_var_define(bdd_script_time(Method), times, time, messages('Generating BDD script '(Method), ':', ' ms')),
problog_var_define(bdd_generation_time(Method), times, time, messages('Constructing BDD '(Method), ':', ' ms')),
problog_var_define(probability(Method), result, number, messages('Probabilty '(Method), ' = ', '')),
problog_var_define(trie_statistics(Method), memory, untyped, messages('Trie usage '(Method), ':', '')),
problog_var_define(dbtrie_statistics(Method), memory, untyped, messages('Depth Breadth Trie usage '(Method), ':', '')),
problog_var_define(db_trie_opts_performed(Method), memory, untyped, messages('Optimisations performed '(Method), ':', '')),
problog_var_define(variable_elimination_time, times, time, messages('Variable Elimination', ':', ' ms')),
problog_var_define(variable_elimination_stats, memory, untyped, messages('Variable Elimination', ':', ''))
)).
problog_statistics(Stat, Result):-
problog_var_defined(Stat),
problog_var_is_set(Stat),
problog_var_get(Stat, Result).
generate_order_by_prob_fact_appearance(Order, FileName):-
open(FileName, 'write', Stream),
forall(member(PF, Order), (
ptree:get_var_name(PF, Name),
format(Stream, "@~w~n", [Name])
)),
close(Stream).
get_order(Trie, Order):-
findall(List, ptree:traverse_ptree(Trie, List), Proofs),
flatten(Proofs, ProbFacts),
remove_duplicates(ProbFacts, Order).
eval_dnf(OriTrie1, Prob, Status) :-
% Check whether we use Hybrid ProbLog
(
hybrid_proof(_,_,_)
->
( % Yes! run the disjoining stuff
retractall(hybrid_proof_disjoint(_,_,_,_)),
disjoin_hybrid_proofs,
init_ptree(OriTrie), % use this as tmp ptree
%%%%%%%%%%%%%%%%%%%%%
( % go over all stored proofs
enum_member_ptree(List,OriTrie1),
(
List=[_|_]
->
Proof=List;
Proof=[List]
),
(
select(continuous(ProofID),Proof,Rest)
->
(
% this proof is using continuous facts
all_hybrid_subproofs(ProofID,List2),
append(Rest,List2,NewProof),
insert_ptree(NewProof,OriTrie)
);
insert_ptree(Proof,OriTrie)
),
fail;
true
)
%%%%%%%%%%%%%%%%%%%%%
) ;
% Nope, just pass on the Trie
OriTrie=OriTrie1
),
((problog_flag(variable_elimination, true), nb_getval(problog_nested_tries, false)) ->
timer_start(variable_elimination_time),
trie_check_for_and_cluster(OriTrie),
timer_stop(variable_elimination_time,Variable_Elimination_Time),
problog_var_set(variable_elimination_time, Variable_Elimination_Time),
trie_replace_and_cluster(OriTrie, Trie),
variable_elimination_stats(Clusters, OrigPF, CompPF),
problog_var_set(variable_elimination_stats, compress(Clusters, OrigPF, CompPF)),
clean_up
;
Trie = OriTrie
),
(problog_flag(bdd_static_order, true) ->
get_order(Trie, Order),
problog_flag(static_order_file, SOFName),
convert_filename_to_working_path(SOFName, SOFileName),
generate_order_by_prob_fact_appearance(Order, SOFileName)
;
true
),
ptree:trie_stats(Memory, Tries, Entries, Nodes),
(nb_getval(problog_nested_tries, false) ->
ptree:trie_usage(Trie, TEntries, TNodes, TVirtualNodes),
problog_var_set(trie_statistics, tries(memory(Memory), tries(Tries), entries(TEntries), nodes(TNodes), virtualnodes(TVirtualNodes)))
;
problog_var_set(trie_statistics, tries(memory(Memory), tries(Tries), entries(Entries), nodes(Nodes)))
),
(problog_flag(triedump, true) ->
convert_filename_to_working_path(trie_file, TrieFile),
tell(TrieFile),
print_nested_ptree(Trie),
flush_output,
told,
tell(user_output)
;
true
),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
((Trie = Trie_Completed_Proofs, problog_flag(save_bdd, true)) ->
problog_control(on, remember)
;
problog_control(off, remember)
),
problog_flag(bdd_file, BDDFileFlag),
convert_filename_to_working_path(BDDFileFlag, BDDFile),
problog_flag(bdd_par_file, BDDParFileFlag),
convert_filename_to_working_path(BDDParFileFlag, BDDParFile),
% old reduction method doesn't support nested tries
((problog_flag(use_old_trie, true), nb_getval(problog_nested_tries, false)) ->
timer_start(bdd_script_time),
(problog_control(check, remember) ->
bdd_ptree_map(Trie, BDDFile, BDDParFile, Mapping),
convert_filename_to_working_path(save_map, MapFile),
tell(MapFile),
format('mapping(~q).~n', [Mapping]),
flush_output,
told
;
bdd_ptree(Trie, BDDFile, BDDParFile)
),
timer_stop(bdd_script_time,BDD_Script_Time),
problog_var_set(bdd_script_time, BDD_Script_Time),
timer_start(bdd_generation_time),
execute_bdd_tool(BDDFile, BDDParFile, Prob_old, Status_old),
timer_stop(bdd_generation_time,BDD_Generation_Time),
(Status_old == ok ->
problog_var_set(bdd_generation_time, BDD_Generation_Time),
problog_var_set(probability, Prob_old)
;
problog_var_set(bdd_generation_time, fail),
problog_var_set(probability, fail)
)
;
true
),
% naive method with nested trie support but not loops
((problog_flag(use_naive_trie, true); (problog_flag(use_old_trie, true), nb_getval(problog_nested_tries, true))) ->
timer_start(script_gen_time_naive),
BDDFile = BDDFile_naive,
nested_ptree_to_BDD_script(Trie, BDDFile_naive, BDDParFile),
timer_stop(script_gen_time_naive,Script_Gen_Time_Naive),
problog_var_set(bdd_script_time(naive), Script_Gen_Time_Naive),
timer_start(bdd_gen_time_naive),
execute_bdd_tool(BDDFile_naive, BDDParFile, Prob_naive, Status_naive),
timer_stop(bdd_gen_time_naive,BDD_Gen_Time_Naive),
(Status_naive == ok ->
problog_var_set(bdd_generation_time(naive),BDD_Gen_Time_Naive),
problog_var_set(probability(naive), Prob_naive)
;
problog_var_set(bdd_generation_time(naive), fail),
problog_var_set(probability(naive), fail)
)
;
true
),
% reduction method with depth_breadth trie support
problog_flag(db_trie_opt_lvl, ROptLevel),
problog_flag(db_min_prefix, MinPrefix),
(problog_flag(compare_opt_lvl, true) ->
generate_ints(0, ROptLevel, Levels)
;
Levels = [ROptLevel]
),
forall(member(OptLevel, Levels), (
(problog_flag(use_db_trie, true) ->
tries:trie_db_opt_min_prefix(MinPrefix),
timer_start(script_gen_time_builtin),
BDDFile = BDDFile_builtin,
(nb_getval(problog_nested_tries, false) ->
trie_to_bdd_trie(Trie, DBTrie, BDDFile_builtin, OptLevel, BDDParFile)
;
nested_trie_to_bdd_trie(Trie, DBTrie, BDDFile_builtin, OptLevel, BDDParFile)
),
atomic_concat(['builtin_', OptLevel], Builtin),
ptree:trie_stats(DBMemory, DBTries, DBEntries, DBNodes),
FM is DBMemory - Memory,
FT is DBTries - Tries,
FE is DBEntries - Entries,
FN is DBNodes - Nodes,
problog_var_set(dbtrie_statistics(Builtin), tries(memory(FM), tries(FT), entries(FE), nodes(FN))),
delete_ptree(DBTrie),
timer_stop(script_gen_time_builtin,Script_Gen_Time_Builtin),
problog_var_set(bdd_script_time(Builtin), Script_Gen_Time_Builtin),
timer_start(bdd_gen_time_builtin),
execute_bdd_tool(BDDFile_builtin, BDDParFile, Prob_builtin, Status_builtin),
timer_stop(bdd_gen_time_builtin,BDD_Gen_Time_Builtin),
ptree_db_trie_opt_performed(LVL1, LVL2, LV3),
problog_var_set(db_trie_opts_performed(Builtin), opt_perform(LVL1, LVL2, LV3)),
(Status_builtin == ok ->
problog_var_set(bdd_generation_time(Builtin), BDD_Gen_Time_Builtin),
problog_var_set(probability(Builtin), Prob_builtin)
;
problog_var_set(bdd_generation_time(Builtin), fail),
problog_var_set(probability(Builtin), fail)
)
;
true
)
)),
% decomposition method
(problog_flag(use_dec_trie, true) ->
BDDFile = BDDFile_dec,
timer_start(script_gen_time_dec),
ptree_decomposition(Trie, BDDFile_dec, BDDParFile),
timer_stop(script_gen_time_dec,Script_Gen_Time_Dec),
problog_var_set(bdd_script_time(dec), Script_Gen_Time_Dec),
timer_start(bdd_gen_time_dec),
execute_bdd_tool(BDDFile_dec, BDDParFile, Prob_dec, Status_dec),
timer_stop(bdd_gen_time_dec,BDD_Gen_Time_Dec),
(Status_dec == ok ->
problog_var_set(bdd_generation_time(dec), BDD_Gen_Time_Dec),
problog_var_set(probability(dec), Prob_dec)
;
problog_var_set(bdd_generation_time(dec), fail),
problog_var_set(probability(dec), fail)
)
;
true
),
(problog_control(check, remember) ->
convert_filename_to_working_path('save_script', SaveBDDFile),
copy_file(BDDFile, SaveBDDFile),
convert_filename_to_working_path('save_params', SaveBDDParFile),
copy_file(BDDParFile, SaveBDDParFile)
;
true
),
problog_control(off, remember),
(var(Status_old)->
(var(Status_naive)->
(var(Status_dec) ->
atomic_concat('builtin_', ROptLevel, ProbStat),
problog_statistics(probability(ProbStat), ProbB),
(ProbB = fail ->
Status = timeout
;
Prob = ProbB,
Status = ok
)
;
Prob = Prob_dec,
Status = Status_dec
)
;
Prob = Prob_naive,
Status = Status_naive
)
;
Prob = Prob_old,
Status = Status_old
),
(Trie =\= OriTrie ->
delete_ptree(Trie)
;
true
).
generate_ints(End, End, [End]).
generate_ints(Start, End, [Start|Rest]):-
Start < End,
Current is Start + 1,
generate_ints(Current, End, Rest).
execute_bdd_tool(BDDFile, BDDParFile, Prob, Status):-
problog_flag(bdd_time, BDDTime),
problog_flag(bdd_result, ResultFileFlag),
(problog_flag(nodedump_bdd,true) ->
problog_flag(nodedump_file,NodeDumpFile),
convert_filename_to_working_path(NodeDumpFile, SONodeDumpFile),
atomic_concat([' -sd ', SONodeDumpFile],ParamB)
;
ParamB = ''
),
(problog_flag(dynamic_reorder, true) ->
ParamD = ParamB
;
atomic_concat([ParamB, ' -dreorder'], ParamD)
),
(problog_flag(bdd_static_order, true) ->
problog_flag(static_order_file, FileName),
convert_filename_to_working_path(FileName, SOFileName),
atomic_concat([ParamD, ' -sord ', SOFileName], Param)
;
Param = ParamD
),
convert_filename_to_problog_path('problogbdd', ProblogBDD),
convert_filename_to_working_path(ResultFileFlag, ResultFile),
atomic_concat([ProblogBDD, Param,' -l ', BDDFile, ' -i ', BDDParFile, ' -m p -t ', BDDTime, ' > ', ResultFile], Command),
shell(Command, Return),
(Return =\= 0 ->
Status = timeout
;
see(ResultFile),
read(probability(Prob)),
seen,
catch(delete_file(ResultFile),_, fail),
Status = ok
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% different inference methods
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% approximate inference: bounds based on single probability threshold
% problog_threshold(+Goal,+Threshold,-LowerBound,-UpperBound,-Status)
%
% use backtracking over problog_call to get all solutions
%
% trie 1 collects proofs, trie 2 collects stopped derivations, trie 3 is used to unit them for the upper bound
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_threshold(Goal, Threshold, _, _, _) :-
init_problog_threshold(Threshold),
problog_control(on,up),
problog_call(Goal),
add_solution,
fail.
problog_threshold(_, _, LP, UP, Status) :-
compute_bounds(LP, UP, Status).
init_problog_threshold(Threshold) :-
init_ptree(Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
init_ptree(Trie_Stopped_Proofs),
nb_setval(problog_stopped_proofs, Trie_Stopped_Proofs),
init_problog(Threshold).
add_solution :-
% get the probabilistic facts used in this proof
b_getval(problog_current_proof, IDs),
(IDs == [] -> R = []; open_end_close_end(IDs, R)),
% get the continuous facts used in this proof
% (Hybrid ProbLog
b_getval(problog_continuous_facts_used,Cont_IDs),
(
Cont_IDs == []
->
Continuous=[];
(
proof_id(ProofID),
collect_all_intervals(Cont_IDs,ProofID,AllIntervals),
(
AllIntervals==[]
->
Continuous=[];
(
Continuous=[continuous(ProofID)],
assertz(hybrid_proof(ProofID,Cont_IDs,AllIntervals))
)
)
)
),
% we have both, no add it to the trie
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
append(R,Continuous,Final),
(
Final==[]
->
insert_ptree(true, Trie_Completed_Proofs);
insert_ptree(Final, Trie_Completed_Proofs)
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
collect_all_intervals([],_,[]).
collect_all_intervals([(ID,GroundID)|T],ProofID,[Interval|T2]) :-
atomic_concat([interval,'_',GroundID],Key),
b_getval(Key,Interval),
Interval \= all, % we do not need to store continuous
% variables with domain [-oo,oo] (they have probability 1)
!,
assertz(hybrid_proof(ProofID,ID,GroundID,Interval)),
collect_all_intervals(T,ProofID,T2).
collect_all_intervals([_|T],ProofID,T2) :-
collect_all_intervals(T,ProofID,T2).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
all_hybrid_subproofs(ProofID,List) :-
findall((ID,GroundID,Intervals),hybrid_proof_disjoint(ProofID,ID,GroundID,Intervals),All),
generate_all_proof_combinations(All,List).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
generate_all_proof_combinations([],[]).
generate_all_proof_combinations([(_ID,GroundID,Intervals)|T],Result) :-
member((Interval,Tail),Intervals),
intervals_encode(Interval,IntervalEncoded),
atomic_concat([GroundID,IntervalEncoded],FullID),
encode_tail(Tail,GroundID,TailEncoded),
append([FullID|TailEncoded],T2,Result),
generate_all_proof_combinations(T,T2).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
encode_tail([],_,[]).
encode_tail([A|T],ID,[not(FullID)|T2]) :-
intervals_encode(A,AEncoded),
atomic_concat([ID,AEncoded],FullID),
encode_tail(T,ID,T2).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
disjoin_hybrid_proofs :-
% collect all used continuous facts
findall(GroundID,hybrid_proof(_,_,GroundID,_),IDs),
sort(IDs,IDsSorted),
disjoin_hybrid_proofs(IDsSorted).
disjoin_hybrid_proofs([]).
disjoin_hybrid_proofs([GroundID|T]) :-
findall(Interval,hybrid_proof(_,_,GroundID,Interval),Intervals),
intervals_partition(Intervals,Partition),
% go over all proofs where this fact occurs
forall(hybrid_proof(ProofID,ID,GroundID,Interval),
(
intervals_disjoin(Interval,Partition,PInterval),
assertz(hybrid_proof_disjoint(ProofID,ID,GroundID,PInterval))
)
),
disjoin_hybrid_proofs(T).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% End Hybrid
compute_bounds(LP, UP, Status) :-
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
nb_getval(problog_stopped_proofs, Trie_Stopped_Proofs),
eval_dnf(Trie_Completed_Proofs, LP, StatusLow),
(StatusLow \== ok ->
Status = StatusLow
;
merge_ptree(Trie_Completed_Proofs, Trie_Stopped_Proofs, Trie_All_Proofs),
nb_setval(problog_all_proofs, Trie_All_Proofs),
eval_dnf(Trie_All_Proofs, UP, Status)),
delete_ptree(Trie_Completed_Proofs),
delete_ptree(Trie_Stopped_Proofs),
delete_ptree(Trie_All_Proofs).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% approximate inference: lower bound based on all proofs above probability threshold
% problog_low(+Goal,+Threshold,-LowerBound,-Status)
%
% same as problog_threshold/5, but lower bound only (no stopped derivations stored)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_low(Goal, Threshold, _, _) :-
init_problog_low(Threshold),
problog_control(off, up),
timer_start(sld_time),
problog_call(Goal),
add_solution,
fail.
problog_low(_, _, LP, Status) :-
timer_stop(sld_time,SLD_Time),
problog_var_set(sld_time, SLD_Time),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
%print_nested_ptree(Trie_Completed_Proofs),
eval_dnf(Trie_Completed_Proofs, LP, Status),
(problog_flag(verbose, true)->
problog_statistics
;
true
),
delete_ptree(Trie_Completed_Proofs),
(problog_flag(retain_tables, true) -> retain_tabling; true),
clear_tabling.
init_problog_low(Threshold) :-
init_ptree(Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
init_problog(Threshold).
% generalizing problog_max to return all explanations, sorted by non-increasing probability
problog_all_explanations(Goal,Expl) :-
problog_all_explanations_unsorted(Goal,Unsorted),
keysort(Unsorted,Decreasing),
reverse(Decreasing,Expl).
problog_all_explanations_unsorted(Goal, _) :-
init_problog_low(0.0),
problog_control(off, up),
timer_start(sld_time),
problog_call(Goal),
add_solution,
fail.
problog_all_explanations_unsorted(_,Expl) :-
timer_stop(sld_time,SLD_Time),
problog_var_set(sld_time, SLD_Time),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
explanations_from_trie(Trie_Completed_Proofs,Expl).
% catch basecases
explanations_from_trie(Trie,[]) :-
empty_ptree(Trie),!.
explanations_from_trie(Trie,[1.0-[]]) :-
traverse_ptree(Trie,[true]),!.
explanations_from_trie(Trie_Completed_Proofs,Expl) :-
findall(Prob-Facts,
(traverse_ptree(Trie_Completed_Proofs,L),
findall(P,(member(A,L),get_fact_log_probability(A,P)),Ps),
sum_list(Ps,LS),
Prob is exp(LS),
get_fact_list(L,Facts)
),Expl).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% approximate inference: bounds by iterative deepening up to interval width Delta
% problog_delta(+Goal,+Delta,-LowerBound,-UpperBound,-Status)
%
% wraps iterative deepening around problog_threshold, i.e.
% - starts with threshold given by first_threshold flag
% - if Up-Low >= Delta, multiply threshold by factor given in id_stepsize flag and iterate
% (does not use problog_threshold as trie 1 is kept over entire search)
%
% local dynamic predicates low/2, up/2, stopDiff/1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_delta(Goal, Delta, Low, Up, Status) :-
problog_flag(first_threshold,InitT),
init_problog_delta(InitT,Delta),
problog_control(on,up),
problog_delta_id(Goal,Status),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
nb_getval(problog_stopped_proofs, Trie_Stopped_Proofs),
delete_ptree(Trie_Completed_Proofs),
delete_ptree(Trie_Stopped_Proofs),
(retract(low(_,Low)) -> true; true),
(retract(up(_,Up)) -> true; true).
init_problog_delta(Threshold,Delta) :-
retractall(low(_,_)),
retractall(up(_,_)),
retractall(stopDiff(_)),
init_ptree(Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
init_ptree(Trie_Stopped_Proofs),
nb_setval(problog_stopped_proofs, Trie_Stopped_Proofs),
assertz(low(0,0.0)),
assertz(up(0,1.0)),
assertz(stopDiff(Delta)),
init_problog(Threshold).
problog_delta_id(Goal, _) :-
problog_call(Goal),
add_solution, % reused from problog_threshold
fail.
problog_delta_id(Goal, Status) :-
evaluateStep(Ans,StatusE),
problog_flag(last_threshold_log,Stop),
nb_getval(problog_threshold,Min),
(StatusE \== ok ->
Status = StatusE
;
(
Ans = 1 ->
Status = ok
;
Min =< Stop ->
Status = stopreached
;
problog_control(check,limit) ->
problog_control(off,limit),
problog_flag(id_stepsize_log,Step),
New is Min+Step,
nb_setval(problog_threshold,New),
problog_delta_id(Goal, Status)
;
true
)).
% call the dnf evaluation where needed
evaluateStep(Ans,Status) :- once(evalStep(Ans,Status)).
evalStep(Ans,Status) :-
stopDiff(Delta),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
nb_getval(problog_stopped_proofs, Trie_Stopped_Proofs),
count_ptree(Trie_Completed_Proofs, NProofs),
count_ptree(Trie_Stopped_Proofs, NCands),
format_if_verbose(user,'~w proofs, ~w stopped derivations~n',[NProofs,NCands]),
eval_lower(NProofs,Low,StatusLow),
(
StatusLow \== ok
->
Status = StatusLow;
up(_, OUP),
IntDiff is OUP-Low,
((IntDiff < Delta; IntDiff =:= 0) ->
Up = OUP,
StatusUp = ok
;
eval_upper(NCands, Up, StatusUp),
delete_ptree(Trie_Stopped_Proofs),
init_ptree(New_Trie_Stopped_Proofs),
nb_setval(problog_stopped_proofs, New_Trie_Stopped_Proofs)
),
(StatusUp \== ok ->
Status = StatusUp
;
Diff is Up-Low,
format_if_verbose(user,'difference: ~6f~n',[Diff]),
((Diff < Delta; Diff =:= 0) -> Ans = 1; Ans = 0),
Status = ok
)
).
% no need to re-evaluate if no new proofs found on this level
eval_lower(N,P,ok) :-
low(N,P).
% evaluate if there are proofs
eval_lower(N,P,Status) :-
N > 0,
low(OldN,_),
N \= OldN,
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
eval_dnf(Trie_Completed_Proofs,P,Status),
(Status == ok ->
retract(low(_,_)),
assertz(low(N,P)),
format_if_verbose(user,'lower bound: ~6f~n',[P])
;
true).
% if no stopped derivations, up=low
eval_upper(0,P,ok) :-
retractall(up(_,_)),
low(N,P),
assertz(up(N,P)).
% else merge proofs and stopped derivations to get upper bound
% in case of timeout or other problems, skip and use bound from last level
eval_upper(N,UpP,ok) :-
N > 0,
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
nb_getval(problog_stopped_proofs, Trie_Stopped_Proofs),
merge_ptree(Trie_Completed_Proofs,Trie_Stopped_Proofs,Trie_All_Proofs),
nb_setval(problog_all_proofs, Trie_All_Proofs),
eval_dnf(Trie_All_Proofs,UpP,StatusUp),
delete_ptree(Trie_All_Proofs),
(StatusUp == ok ->
retract(up(_,_)),
assertz(up(N,UpP))
;
format_if_verbose(user,'~w - continue using old up~n',[StatusUp]),
up(_,UpP)
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% explanation probability - returns list of facts used or constant 'unprovable' as third argument
% problog_max(+Goal,-Prob,-Facts)
%
% uses iterative deepening with samw parameters as bounding algorithm
% threshold gets adapted whenever better proof is found
%
% uses local dynamic predicates max_probability/1 and max_proof/1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_max(Goal, Prob, Facts) :-
problog_flag(first_threshold,InitT),
init_problog_max(InitT),
problog_control(off,up),
problog_max_id(Goal, Prob, FactIDs),% theo todo
( FactIDs = [_|_] -> get_fact_list(FactIDs, Facts);
Facts = FactIDs).
init_problog_max(Threshold) :-
retractall(max_probability(_)),
retractall(max_proof(_)),
assertz(max_probability(-999999)),
assertz(max_proof(unprovable)),
init_problog(Threshold).
update_max :-
b_getval(problog_probability, CurrP),
max_probability(MaxP),
CurrP>MaxP,
b_getval(problog_current_proof, IDs),
open_end_close_end(IDs, R),
retractall(max_proof(_)),
assertz(max_proof(R)),
nb_setval(problog_threshold, CurrP),
retractall(max_probability(_)),
assertz(max_probability(CurrP)).
problog_max_id(Goal, _Prob, _Clauses) :-
problog_call(Goal),
update_max,
fail.
problog_max_id(Goal, Prob, Clauses) :-
max_probability(MaxP),
nb_getval(problog_threshold, LT),
problog_flag(last_threshold_log, ToSmall),
((MaxP >= LT; \+ problog_control(check, limit); LT < ToSmall) ->
((max_proof(unprovable), problog_control(check,limit), LT < ToSmall) ->
problog_flag(last_threshold, Stopping),
Clauses = unprovable(Stopping)
;
max_proof(Clauses)
),
Prob is exp(MaxP)
;
problog_flag(id_stepsize_log, Step),
NewLT is LT + Step,
nb_setval(problog_threshold, NewLT),
problog_control(off, limit),
problog_max_id(Goal, Prob, Clauses)
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% lower bound using k best proofs
% problog_kbest(+Goal,+K,-Prob,-Status)
%
% does iterative deepening search similar to problog_max, but for k(>=1) most likely proofs
% afterwards uses BDD evaluation to calculate probability (also for k=1 -> uniform treatment in learning)
%
% uses dynamic local predicate current_kbest/3 to collect proofs,
% only builds trie at the end (as probabilities of single proofs are important here)
%
% note: >k proofs will be used if the one at position k shares its probability with others,
% as all proofs with that probability will be included
%
% version with _save at the end renames files for problogbdd to keep them
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_kbest_save(Goal, K, Prob, Status, BDDFile, ParamFile) :-
problog_flag(dir, InternWorkingDir),
problog_flag(bdd_file, InternBDDFlag),
problog_flag(bdd_par_file, InternParFlag),
split_path_file(BDDFile, WorkingDir, BDDFileName),
split_path_file(ParamFile, _WorkingDir, ParamFileName),
flag_store(dir, WorkingDir),
flag_store(bdd_file, BDDFileName),
flag_store(bdd_par_file, ParamFileName),
problog_kbest(Goal, K, Prob, Status),
flag_store(dir, InternWorkingDir),
flag_store(bdd_file, InternBDDFlag),
flag_store(bdd_par_file, InternParFlag).
% ( Status=ok ->
% problog_flag(bdd_file,InternBDDFlag),
% problog_flag(bdd_par_file,InternParFlag),
% convert_filename_to_working_path(InternBDDFlag, InternBDD),
% convert_filename_to_working_path(InternParFlag, InternPar),
% rename_file(InternBDD,BDDFile),
% rename_file(InternPar,ParamFile)
% ;
% true).
problog_kbest(Goal, K, Prob, Status) :-
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
problog_control(off,up),
problog_kbest_id(Goal, K),
retract(current_kbest(_,ListFound,_NumFound)),
build_prefixtree(ListFound),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
eval_dnf(Trie_Completed_Proofs,Prob,Status),
delete_ptree(Trie_Completed_Proofs).
% generalizes problog_max to return the k best explanations
problog_kbest_explanations(Goal, K, Explanations) :-
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
problog_control(off,up),
problog_kbest_id(Goal, K),
retract(current_kbest(_,ListFound,_NumFound)),
to_external_format_with_reverse(ListFound,Explanations).
problog_real_kbest(Goal, K, Prob, Status) :-
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
problog_control(off,up),
problog_kbest_id(Goal, K),
retract(current_kbest(_,RawListFound,NumFound)),
% limiting the number of proofs is not only needed for fast SLD resolution but also for fast BDD building.
% one can't assume that kbest is called for the former and not for the latter
take_k_best(RawListFound,K,NumFound,ListFound),
build_prefixtree(ListFound),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
eval_dnf(Trie_Completed_Proofs,Prob,Status),
delete_ptree(Trie_Completed_Proofs).
init_problog_kbest(Threshold) :-
retractall(current_kbest(_,_,_)),
assertz(current_kbest(-999999,[],0)), %(log-threshold,proofs,num_proofs)
init_ptree(Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
init_problog(Threshold).
problog_kbest_id(Goal, K) :-
problog_call(Goal),
update_kbest(K),
fail.
problog_kbest_id(Goal, K) :-
current_kbest(CurrentBorder,_,Found),
nb_getval(problog_threshold, Min),
problog_flag(last_threshold_log,ToSmall),
((Found>=K ; \+ problog_control(check,limit) ; Min < CurrentBorder ; Min < ToSmall) ->
true
;
problog_flag(id_stepsize_log,Step),
NewLT is Min+Step,
nb_setval(problog_threshold, NewLT),
problog_control(off,limit),
problog_kbest_id(Goal, K)).
update_kbest(K) :-
b_getval(problog_probability,NewLogProb),
current_kbest(LogThreshold,_,_),
NewLogProb>=LogThreshold,
b_getval(problog_current_proof,RevProof),
open_end_close_end(RevProof,Proof),
update_current_kbest(K,NewLogProb,Proof).
update_current_kbest(_,NewLogProb,Cl) :-
current_kbest(_,List,_),
memberchk(NewLogProb-Cl,List),
!.
update_current_kbest(K,NewLogProb,Cl) :-
retract(current_kbest(OldThres,List,Length)),
sorted_insert(NewLogProb-Cl,List,NewList),
NewLength is Length+1,
(NewLength < K ->
assertz(current_kbest(OldThres,NewList,NewLength))
;
(NewLength>K ->
First is NewLength-K+1,
cutoff(NewList,NewLength,First,FinalList,FinalLength)
; FinalList=NewList, FinalLength=NewLength),
FinalList=[NewThres-_|_],
nb_setval(problog_threshold,NewThres),
assertz(current_kbest(NewThres,FinalList,FinalLength))).
sorted_insert(A,[],[A]).
sorted_insert(A-LA,[B1-LB1|B], [A-LA,B1-LB1|B] ) :-
A =< B1.
sorted_insert(A-LA,[B1-LB1|B], [B1-LB1|C] ) :-
A > B1,
sorted_insert(A-LA,B,C).
% keeps all entries with lowest probability, even if implying a total of more than k
cutoff(List,Len,1,List,Len) :- !.
cutoff([P-L|List],Length,First,[P-L|List],Length) :-
nth1(First,[P-L|List],PF-_),
PF=:=P,
!.
cutoff([_|List],Length,First,NewList,NewLength) :-
NextFirst is First-1,
NextLength is Length-1,
cutoff(List,NextLength,NextFirst,NewList,NewLength).
build_prefixtree([]).
build_prefixtree([_-[]|_List]) :-
!,
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
insert_ptree(true,Trie_Completed_Proofs).
build_prefixtree([LogP-L|List]) :-
(
problog_flag(show_proofs,true)
->
get_fact_list(L,ListOfFacts),
P is exp(LogP),
format(user,'~q ~q~n',[P,ListOfFacts])
;
true
),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
insert_ptree(L,Trie_Completed_Proofs),
build_prefixtree(List).
take_k_best(In,K,OutOf,Out) :-
(
K>=OutOf
->
In = Out;
In = [_|R],
OutOf2 is OutOf-1,
take_k_best(R,K,OutOf2,Out)
).
to_external_format_with_reverse(Intern,Extern) :-
to_external_format_with_reverse(Intern,[],Extern).
to_external_format_with_reverse([],Extern,Extern).
to_external_format_with_reverse([LogP-FactIDs|Intern],Acc,Extern) :-
Prob is exp(LogP),
( FactIDs = [_|_] -> get_fact_list(FactIDs, Facts);
Facts = FactIDs),
to_external_format_with_reverse(Intern,[Prob-Facts|Acc],Extern).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% exact probability
% problog_exact(+Goal,-Prob,-Status)
%
% using all proofs = using all proofs with probability > 0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_exact(Goal,Prob,Status) :-
problog_control(on, exact),
problog_low(Goal,0,Prob,Status),
problog_control(off, exact).
problog_exact_save(Goal,Prob,Status,BDDFile,ParamFile) :-
problog_flag(dir, InternWorkingDir),
problog_flag(bdd_file, InternBDDFlag),
problog_flag(bdd_par_file, InternParFlag),
split_path_file(BDDFile, WorkingDir, BDDFileName),
split_path_file(ParamFile, _WorkingDir, ParamFileName),
flag_store(dir, WorkingDir),
flag_store(bdd_file, BDDFileName),
flag_store(bdd_par_file, ParamFileName),
problog_control(on, exact),
problog_low(Goal,0,Prob,Status),
problog_control(off, exact),
flag_store(dir, InternWorkingDir),
flag_store(bdd_file, InternBDDFlag),
flag_store(bdd_par_file, InternParFlag).
% (
% Status==ok
% ->
% (
% problog_flag(bdd_file,InternBDDFlag),
% problog_flag(bdd_par_file,InternParFlag),
% problog_flag(dir,DirFlag),
% atomic_concat([DirFlag,InternBDDFlag],InternBDD),
% atomic_concat([DirFlag,InternParFlag],InternPar),
% rename_file(InternBDD,BDDFile),
% rename_file(InternPar,ParamFile)
% );
% true
% ).
problog_collect_trie(Goal):-
problog_call(Goal),
add_solution,
fail.
problog_collect_trie(_Goal).
problog_save_state(State):-
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
nb_getval(problog_current_proof, IDs),
recordz(problog_stack, store(Trie_Completed_Proofs, IDs), State),
init_ptree(Sub_Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Sub_Trie_Completed_Proofs),
nb_setval(problog_current_proof, []).
problog_restore_state(State):-
recorded(problog_stack, store(Trie_Completed_Proofs, IDs), State),
erase(State),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
nb_setval(problog_current_proof, IDs).
problog_exact_nested(Goal, Prob, Status):-
problog_save_state(State),
problog_collect_trie(Goal),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
/* writeln(Goal),
print_nested_ptree(Trie_Completed_Proofs),*/
eval_dnf(Trie_Completed_Proofs, Prob, Status),
delete_ptree(Trie_Completed_Proofs),
problog_restore_state(State).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% probability by sampling:
% running another N samples until 95percentCI-width<Delta
% lazy sampling using three-valued array indexed by internal fact IDs for ground facts,
% internal database keys mc_true and mc_false for groundings of non-ground facts (including dynamic probabilities)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_montecarlo(Goal,Delta,Prob) :-
retractall(mc_prob(_)),
nb_getval(probclause_counter,ID), !,
C is ID+1,
static_array(mc_sample,C,char),
problog_control(off,up),
problog_flag(mc_batchsize,N),
problog_flag(mc_logfile,File1),
convert_filename_to_working_path(File1, File),
montecarlo(Goal,Delta,N,File),
retract(mc_prob(Prob)),
close_static_array(mc_sample).
montecarlo(Goal,Delta,K,File) :-
clean_sample,
problog_control(on,mc),
open(File,write,Log),
format(Log,'# goal: ~q~n#delta: ~w~n',[Goal,Delta]),
format(Log,'# num_programs prob low high diff time~2n',[]),
close(Log),
timer_reset(monte_carlo),
timer_start(monte_carlo),
format_if_verbose(user,'search for ~q~n',[Goal]),
montecarlo(Goal,Delta,K,0,File,0),
timer_stop(monte_carlo,_Monte_Carlo_Time),
problog_control(off,mc).
% calculate values after K samples
montecarlo(Goal,Delta,K,SamplesSoFar,File,PositiveSoFar) :-
SamplesNew is SamplesSoFar+1,
SamplesNew mod K =:= 0,
!,
copy_term(Goal,GoalC),
(
mc_prove(GoalC)
->
Next is PositiveSoFar+1;
Next=PositiveSoFar
),
Prob is Next/SamplesNew,
timer_elapsed(monte_carlo,Time),
problog_convergence_check(Time, Prob, SamplesNew, Delta, _Epsilon, Converged),
(
(Converged == true; Converged == terminate)
->
format_if_verbose(user,'Runtime ~w ms~2n',[Time]),
assertz(mc_prob(Prob))
;
montecarlo(Goal,Delta,K,SamplesNew,File,Next)
).
% continue until next K samples done
montecarlo(Goal,Delta,K,SamplesSoFar,File,PositiveSoFar) :-
SamplesNew is SamplesSoFar+1,
copy_term(Goal,GoalC),
(mc_prove(GoalC) -> Next is PositiveSoFar+1; Next=PositiveSoFar),
montecarlo(Goal,Delta,K,SamplesNew,File,Next).
mc_prove(A) :- !,
(get_some_proof(A) ->
clean_sample
;
clean_sample,fail
).
clean_sample :-
reset_static_array(mc_sample),
eraseall(mc_true),
eraseall(mc_false),
reset_non_ground_facts,
% problog_abolish_all_tables.
problog_tabled(P),
problog_abolish_table(P),
fail.
clean_sample.
% find new proof -- need to reset control after init
get_some_proof(Goal) :-
init_problog(0),
problog_control(on,mc),
problog_call(Goal).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% exact probability of all ground instances of Goal
% output goes to File
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_answers(Goal,File) :-
set_problog_flag(verbose,false),
retractall(answer(_)),
% this will not give the exact prob of Goal!
problog_exact((Goal,ground(Goal),\+problog:answer(Goal),assertz(problog:answer(Goal))),_,_),
open(File,write,_,[alias(answer)]),
eval_answers,
close(answer).
eval_answers :-
retract(answer(G)),
problog_exact(G,P,_),
format(answer,'answer(~q,~w).~n',[G,P]),
fail.
eval_answers.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% find k most likely different answers (using their explanation prob as score)
% largely copied+adapted from kbest, uses same dynamic predicate
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_kbest_answers(Goal,K,ResultList) :-
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
delete_ptree( Trie_Completed_Proofs), % this is just because we reuse init from kbest and don't need the tree
problog_control(off,up),
problog_kbest_answers_id(Goal, K),
retract(current_kbest(_,LogResultList,_NumFound)),
transform_loglist_to_result(LogResultList,ResultList).
problog_kbest_answers_id(Goal, K) :-
problog_call(Goal),
copy_term(Goal,GoalCopy), % needed?
update_kbest_answers(GoalCopy,K),
fail.
problog_kbest_answers_id(Goal, K) :-
current_kbest(CurrentBorder,_,Found),
nb_getval(problog_threshold, Min),
problog_flag(last_threshold_log,ToSmall),
((Found>=K ; \+ problog_control(check,limit) ; Min < CurrentBorder ; Min < ToSmall) ->
true
;
problog_flag(id_stepsize_log,Step),
NewLT is Min+Step,
nb_setval(problog_threshold, NewLT),
problog_control(off,limit),
problog_kbest_answers_id(Goal, K)).
update_kbest_answers(Goal,K) :-
b_getval(problog_probability,NewLogProb),
current_kbest(LogThreshold,_,_),
NewLogProb>=LogThreshold,
update_current_kbest_answers(K,NewLogProb,Goal).
update_current_kbest_answers(_,NewLogProb,Goal) :-
current_kbest(_,List,_),
update_prob_of_known_answer(List,Goal,NewLogProb,NewList),
!,
keysort(NewList,SortedList),%format(user_error,'updated variant of ~w~n',[Goal]),
retract(current_kbest(K,_,Len)),
assertz(current_kbest(K,SortedList,Len)).
update_current_kbest_answers(K,NewLogProb,Goal) :-
retract(current_kbest(OldThres,List,Length)),
sorted_insert(NewLogProb-Goal,List,NewList),%format(user_error,'inserted new element ~w~n',[Goal]),
NewLength is Length+1,
(NewLength < K ->
assertz(current_kbest(OldThres,NewList,NewLength))
;
(NewLength>K ->
First is NewLength-K+1,
cutoff(NewList,NewLength,First,FinalList,FinalLength)
; FinalList=NewList, FinalLength=NewLength),
FinalList=[NewThres-_|_],
nb_setval(problog_threshold,NewThres),
assertz(current_kbest(NewThres,FinalList,FinalLength))).
% this fails if there is no variant -> go to second case above
update_prob_of_known_answer([OldLogP-OldGoal|List],Goal,NewLogProb,[MaxLogP-OldGoal|List]) :-
variant(OldGoal,Goal),
!,
MaxLogP is max(OldLogP,NewLogProb).
update_prob_of_known_answer([First|List],Goal,NewLogProb,[First|NewList]) :-
update_prob_of_known_answer(List,Goal,NewLogProb,NewList).
transform_loglist_to_result(In,Out) :-
transform_loglist_to_result(In,[],Out).
transform_loglist_to_result([],Acc,Acc).
transform_loglist_to_result([LogP-G|List],Acc,Result) :-
P is exp(LogP),
transform_loglist_to_result(List,[P-G|Acc],Result).
%%%%%%%%%%%%%%%%%%%%%%%%%
% koptimal
%%%%%%%%%%%%%%%%%%%%%%%%%
problog_koptimal(Goal,K,Prob) :-
problog_flag(last_threshold, InitT),
problog_koptimal(Goal,K,InitT,Prob).
problog_koptimal(Goal,K,Theta,Prob) :-
init_problog_koptimal,
problog_koptimal_it(Goal,K,Theta),
nb_getval(problog_completed_proofs,Trie_Completed_Proofs),
optimal_proof(_,Prob),
set_problog_flag(save_bdd, false),
set_problog_flag(nodedump_bdd, false),
delete_ptree(Trie_Completed_Proofs),
nb_getval(dtproblog_completed_proofs,DT_Trie_Completed_Proofs),
delete_ptree(DT_Trie_Completed_Proofs),
clear_tabling.
init_problog_koptimal :-
%Set the reuse flag on true in order to retain the calculated bdd's
set_problog_flag(save_bdd, true),
set_problog_flag(nodedump_bdd, true),
%Initialise the trie
init_ptree(Trie_Completed_Proofs),
nb_setval(problog_completed_proofs, Trie_Completed_Proofs),
init_ptree(Trie_DT_Completed_Proofs),
nb_setval(dtproblog_completed_proofs,Trie_DT_Completed_Proofs),
problog_control(off,up),
%Initialise the control parameters
retractall(possible_proof(_,_)),
retractall(impossible_proof(_)).
problog_koptimal_it(Goal,K,Theta) :-
K > 0,
init_problog_koptimal_it(Theta),
%add optimal proof, this fails when no new proofs can be found
(add_optimal_proof(Goal,Theta) -> Knew is K - 1; Knew = 0),!,
problog_koptimal_it(Goal,Knew,Theta).
problog_koptimal_it(_,0,_).
init_problog_koptimal_it(Theta) :-
%Clear the tables
abolish_table(conditional_prob/4),
%initialise problog
init_problog(Theta),
%retract control parameters for last iteration
retractall(optimal_proof(_,_)),
retractall(current_prob(_)),
%calculate the bdd with the additional found proof
nb_getval(problog_completed_proofs,Trie_Completed_Proofs),
eval_dnf(Trie_Completed_Proofs,PCurr,_),
%set the current probability
assert(current_prob(PCurr)),
assert(optimal_proof(unprovable,PCurr)),
%use the allready found proofs to initialise the threshold
findall(Proof-MaxAddedP,possible_proof(Proof,MaxAddedP),PossibleProofs),
sort_possible_proofs(PossibleProofs,SortedPossibleProofs),
initialise_optimal_proof(SortedPossibleProofs,Theta).
sort_possible_proofs(List,Sorted):-sort_possible_proofs(List,[],Sorted).
sort_possible_proofs([],Acc,Acc).
sort_possible_proofs([H|T],Acc,Sorted):-
pivoting(H,T,L1,L2),
sort_possible_proofs(L1,Acc,Sorted1),sort_possible_proofs(L2,[H|Sorted1],Sorted).
pivoting(_,[],[],[]).
pivoting(Pivot-PPivot,[Proof-P|T],[Proof-P|G],L):-P=<PPivot,pivoting(Pivot-PPivot,T,G,L).
pivoting(Pivot-PPivot,[Proof-P|T],G,[Proof-P|L]):-P>PPivot,pivoting(Pivot-PPivot,T,G,L).
initialise_optimal_proof([],_).
initialise_optimal_proof([Proof-MaxAdded|Rest],Theta) :-
optimal_proof(_,Popt),
current_prob(Pcurr),
OptAdded is Popt - Pcurr,
(MaxAdded > OptAdded ->
calculate_added_prob(Proof, P,ok),
%update the maximal added probability
retractall(possible_proof(Proof,_)),
AddedP is P - Pcurr,
(AddedP > Theta ->
%the proof can still add something
assert(possible_proof(Proof,AddedP)),
%Check whether to change the optimal proof
(P > Popt ->
retractall(optimal_proof(_,_)),
assert(optimal_proof(Proof,P)),
NewT is log(AddedP),
nb_setval(problog_threshold,NewT)
;
true
)
;
%the proof cannot add anything anymore
assert(impossible_proof(Proof))
),
initialise_optimal_proof(Rest,Theta)
;
%The rest of the proofs have a maximal added probability smaller then the current found optimal added probability
true
).
add_optimal_proof(Goal,Theta) :-
problog_call(Goal),
update_koptimal(Theta).
add_optimal_proof(_,_) :-
optimal_proof(Proof,_),
((Proof = unprovable) ->
%No possible proof is present
fail
;
%We add the found to the trie
remove_decision_facts(Proof, PrunedProof),
nb_setval(problog_current_proof, PrunedProof-[]),
(PrunedProof = [] -> true ; add_solution),
nb_getval(dtproblog_completed_proofs,DT_Trie_Completed_Proofs),
insert_ptree(Proof, DT_Trie_Completed_Proofs),
retract(possible_proof(Proof,_)),
assert(impossible_proof(Proof))
).
update_koptimal(Theta) :-
%We get the found proof and the already found proofs
b_getval(problog_current_proof, OpenProof),
open_end_close_end(OpenProof, Proof),
((possible_proof(Proof,_); impossible_proof(Proof)) ->
%The proof is already treated in the initialization step
fail
;
%The proof isn't yet treated
calculate_added_prob(Proof,P,ok),
optimal_proof(_,Popt),
current_prob(PCurr),
AddedP is P - PCurr,
(AddedP > Theta ->
assert(possible_proof(Proof,AddedP))
;
%The proof has an additional probability smaller than theta so gets blacklisted
assert(impossible_proof(Proof)),
fail
),
(P > Popt ->
%We change the curret optimal proof with the found proof
retractall(optimal_proof(_,_)),
assert(optimal_proof(Proof,P)),
NewT is log(AddedP),
nb_setval(problog_threshold,NewT),
fail
;
%The proof isn't better then the current optimal proof so we stop searching
fail
)
).
remove_decision_facts([Fact|Proof], PrunedProof) :-
remove_decision_facts(Proof,RecPruned),
catch((get_fact_probability(Fact,_),PrunedProof = [Fact|RecPruned]),_,PrunedProof = RecPruned).
remove_decision_facts([],[]).
calculate_added_prob([],P,ok) :-
current_prob(P).
calculate_added_prob(Proof,P,S) :-
Proof \= [],
remove_decision_facts(Proof,PrunedProof),
remove_used_facts(PrunedProof,Used,New),
bubblesort(Used,SortedUsed),
calculate_added_prob(SortedUsed,New,[],PAdded,S),
round_added_prob(PAdded,P).
calculate_added_prob([],[],_,1,ok).
calculate_added_prob([UsedFact|UsedProof],[],Conditions,P,S) :-
calculate_added_prob(UsedProof,[],[UsedFact|Conditions],Prec,Srec),
problog_flag(nodedump_file,NodeDumpFile),
convert_filename_to_working_path(NodeDumpFile, SONodeDumpFile),
convert_filename_to_working_path('save_params', ParFile),
negate(UsedFact,NegatedFact),
conditional_prob(SONodeDumpFile,ParFile,[NegatedFact|Conditions],Pcond,Scond),
( Srec = ok ->
( Scond = ok ->
S = ok,
get_fact_probability(UsedFact,Pfact),
P is Pfact*Prec + (1 - Pfact)*Pcond
;
S = Scond
)
;
S = Srec
).
calculate_added_prob(UsedProof,[NewFact|NewFacts],[],P,S) :-
calculate_added_prob(UsedProof,NewFacts,[],Prec,S),
( S = ok ->
get_fact_probability(NewFact,Pfact),
current_prob(Pcurr),
P is Pfact*Prec + (1 - Pfact)*Pcurr
;
true
).
bubblesort(List,Sorted):-
swap(List,List1),!,
bubblesort(List1,Sorted).
bubblesort(Sorted,Sorted).
swap([X,Y|Rest], [Y,X|Rest]):- bigger(X,Y).
swap([Z|Rest],[Z|Rest1]):- swap(Rest,Rest1).
bigger(not(X), X) :-
!.
bigger(not(X), not(Y)) :-
!,
bigger(X,Y).
bigger(not(X),Y) :-
!,
bigger(X,Y).
bigger(X, not(Y)) :-
!,
bigger(X,Y).
bigger(X,Y) :-
split_grounding_id(X,IDX,GIDX),
split_grounding_id(Y,IDY,GIDY),!,
(
IDX > IDY
;
IDX == IDY,
GIDX > GIDY
).
bigger(X,Y) :-
split_grounding_id(X,IDX,_),!,
IDX > Y.
bigger(X,Y) :-
split_grounding_id(Y,IDY,_),!,
X > IDY.
bigger(X,Y) :-
X > Y.
round_added_prob(P,RoundedP) :-
P < 1,
Pnew is P*10,
round_added_prob(Pnew,RoundedPnew),
RoundedP is RoundedPnew/10.
round_added_prob(P,RoundedP) :-
P >= 1,
RoundedP is round(P*1000000)/1000000.
negate(not(Fact),Fact).
negate(Fact,not(Fact)) :-
Fact \= not(_).
remove_used_facts([],[],[]).
remove_used_facts([Fact|Rest],Used,New) :-
remove_used_facts(Rest,RecUsed,RecNew),
used_facts(Facts),
(member(Fact,Facts) ->
Used = [Fact|RecUsed],
New = RecNew
;
Used = RecUsed,
New = [Fact|RecNew]
).
used_fact(Fact) :-
used_facts(Facts),
member(Fact,Facts).
used_facts(Facts) :-
convert_filename_to_working_path('save_map', MapFile),
see(MapFile),
read(mapping(L)),
findall(Var,member(m(Var,_,_),L),Facts),
seen.
conditional_prob(_,_,[],P,ok) :-
current_prob(P).
conditional_prob(NodeDump,ParFile,Conditions,P,S) :-
problog_flag(save_bdd,Old_Save),
problog_flag(nodedump_bdd,Old_File),
set_problog_flag(save_bdd, false),
set_problog_flag(nodedump_bdd, false),
convert_filename_to_working_path('temp_par_file', ChangedParFile),
change_par_file(ParFile,Conditions,ChangedParFile),
execute_bdd_tool(NodeDump,ChangedParFile,P,S),
%delete_file(ChangedParFile),
set_problog_flag(save_bdd,Old_Save),
set_problog_flag(nodedump_bdd,Old_File).
change_par_file(ParFile,[],ChangedParFile) :-
%atomic_concat(['cp ', ParFile, ' ', ChangedParFile],Command),
%statistics(walltime,[T1,_]),
%shell(Command,_),
copy_file(ParFile,ChangedParFile).
%statistics(walltime,[T2,_]),
%T is T2 - T1,
%format("copy time: ~w\n",[T]).
change_par_file(ParFile,[ID|Rest],ChangedParFile) :-
ID \= not(_),
change_par_file(ParFile,Rest,ChangedParFile),
open(ChangedParFile,'append',S),
tell(S),
format('@x~w\n1\n',[ID]),
told.
change_par_file(ParFile,[not(ID)|Rest],ChangedParFile) :-
change_par_file(ParFile,Rest,ChangedParFile),
open(ChangedParFile,'append',S),
tell(S),
format('@x~w\n0\n',[ID]),
told.
% Copies a file
copy_file(From,To) :-
file_filter(From,To,copy_aux).
copy_aux(In,In).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% GENERAL PURPOSE PREDICATES FOR DTPROBLOG
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Do inference of a single goal, using the default inference method
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_infer(Goal,Prob) :-
problog_flag(inference,Method),
problog_infer(Method,Goal,Prob).
problog_infer(exact,Goal,Prob) :-
problog_exact(Goal,Prob,ok).
problog_infer(atleast-K-best,Goal,Prob) :-
problog_kbest(Goal,K,Prob,ok).
problog_infer(K-best,Goal,Prob) :-
problog_real_kbest(Goal,K,Prob,ok).
problog_infer(montecarlo(Confidence),Goal,Prob) :-
problog_montecarlo(Goal,Confidence,Prob).
problog_infer(delta(Width),Goal,Prob) :-
problog_delta(Goal,Width,Bound_low,Bound_up,ok),
Prob is 0.5*(Bound_low+Bound_up).
problog_infer(low(Threshold),Goal,Prob) :-
problog_low(Goal,Threshold,Prob,ok).
problog_infer(threshold(Threshold),Goal,Prob) :-
problog_threshold(Goal,Threshold,Bound_low,Bound_up,ok),
Prob is 0.5*(Bound_low+Bound_up).
problog_infer(K-optimal,Goal,Prob) :-
problog_koptimal(Goal,K,Prob).
problog_infer(K-T-optimal,Goal,Prob) :-
problog_koptimal(Goal,K,T,Prob).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Do inference of a set of queries, using the default inference method
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_infer_forest([],[]) :- !.
problog_infer_forest(Goals,Probs) :-
(problog_infer_forest_supported ->
problog_bdd_forest(Goals),
length(Goals,N),
eval_bdd_forest(N,Probs,ok)
;
throw(error('Flag settings not supported by problog_infer_forest/1.'))
).
problog_infer_forest_supported :- problog_bdd_forest_supported.
eval_bdd_forest(N,Probs,Status) :-
bdd_files(BDDFile,BDDParFile),
writeln(BDDFile),
problog_flag(bdd_time,BDDTime),
(problog_flag(dynamic_reorder, true) ->
ParamD = ''
;
ParamD = ' -dreorder'
),
(problog_flag(bdd_static_order, true) ->
problog_flag(static_order_file, FileName),
convert_filename_to_working_path(FileName, SOFileName),
atomic_concat([ParamD, ' -sord ', SOFileName], Param)
;
Param = ParamD
),
convert_filename_to_problog_path('problogbdd', ProblogBDD),
problog_flag(bdd_result,ResultFileFlag),
convert_filename_to_working_path(ResultFileFlag, ResultFile),
atomic_concat([ProblogBDD, Param,' -l ', BDDFile, ' -i ', BDDParFile, ' -m p -t ', BDDTime, ' > ', ResultFile], Command),
statistics(walltime,_),
shell(Command,Return),
(Return =\= 0 ->
Status = timeout
;
statistics(walltime,[_,E3]),
format_if_verbose(user,'~w ms BDD processing~n',[E3]),
see(ResultFile),
read_probs(N,Probs),
seen,
Status = ok,
% cleanup
% TODO handle flag for keeping files
(problog_flag(save_bdd,true) ->
true
;
catch(delete_file(BDDFile),_, fail),
catch(delete_file(BDDParFile),_, fail),
catch(delete_file(ResultFile),_, fail),
delete_bdd_forest_files(N)
)
).
read_probs(N,Probs) :-
(N = 0 ->
Probs = []
;
Probs = [Prob|Rest],
read(probability(Prob)),
N2 is N-1,
read_probs(N2,Rest)
).
delete_bdd_forest_files(N) :-
(N=0 ->
true
;
bdd_forest_file(N,BDDFile),
catch(delete_file(BDDFile),_, fail),
N2 is N-1,
delete_bdd_forest_files(N2)
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Build a trie using the default inference method
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
build_trie(Goal, Trie) :-
(build_trie_supported ->
problog_flag(inference,Method),
once(build_trie(Method, Goal, Trie))
;
throw(error('Flag settings not supported by build_trie/2.'))
).
build_trie_supported :- problog_flag(inference,exact).
build_trie_supported :- problog_flag(inference,low(_)).
build_trie_supported :- problog_flag(inference,atleast-_-best).
build_trie_supported :- problog_flag(inference,_-best).
build_trie_supported :- problog_flag(inference,_-optimal).
build_trie_supported :- problog_flag(inference,_-_-optimal).
build_trie(exact, Goal, Trie) :-
problog_control(on, exact),
build_trie(low(0), Goal, Trie),
problog_control(off, exact).
build_trie(low(Threshold), Goal, _) :-
number(Threshold),
init_problog_low(Threshold),
problog_control(off, up),
timer_start(build_tree_low),
problog_call(Goal),
add_solution,
fail.
build_trie(low(Threshold), _, Trie) :-
number(Threshold),
timer_stop(build_tree_low,Build_Tree_Low),
problog_var_set(sld_time, Build_Tree_Low),
nb_getval(problog_completed_proofs, Trie).
% don't clear tabling; tables can be reused by other query
build_trie(atleast-K-best, Goal, Trie) :-
number(K),
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
problog_control(off,up),
problog_kbest_id(Goal, K),
retract(current_kbest(_,ListFound,_NumFound)),
build_prefixtree(ListFound),
nb_getval(problog_completed_proofs, Trie),
clear_tabling. % clear tabling because tables cannot be reused by other query
build_trie(K-best, Goal, Trie) :-
number(K),
problog_flag(first_threshold,InitT),
init_problog_kbest(InitT),
problog_control(off,up),
problog_kbest_id(Goal, K),
retract(current_kbest(_,RawListFound,NumFound)),
% limiting the number of proofs is not only needed for fast SLD resolution but also for fast BDD building.
% one can't assume that kbest is called for the former and not for the latter
% thus, we take EXACTLY k proofs
take_k_best(RawListFound,K,NumFound,ListFound),
build_prefixtree(ListFound),
nb_getval(problog_completed_proofs, Trie),
clear_tabling. % clear tabling because tables cannot be reused by other query
build_trie(K-optimal, Goal, Trie) :-
number(K),
init_problog_koptimal,
problog_flag(last_threshold, InitT),
problog_koptimal_it(Goal,K,InitT),
set_problog_flag(save_bdd, false),
set_problog_flag(nodedump_bdd, false),
nb_getval(problog_completed_proofs,Trie_Completed_Proofs),
delete_ptree(Trie_Completed_Proofs),
nb_getval(dtproblog_completed_proofs,Trie),
clear_tabling.
build_trie(K-T-optimal, Goal, Trie) :-
number(K),
init_problog_koptimal,
problog_koptimal_it(Goal,K,T),
set_problog_flag(save_bdd, false),
set_problog_flag(nodedump_bdd, false),
nb_getval(problog_completed_proofs,Trie_Completed_Proofs),
delete_ptree(Trie_Completed_Proofs),
nb_getval(dtproblog_completed_proofs,Trie),
clear_tabling.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Write BDD structure script for a trie and list all variables used
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
write_bdd_struct_script(Trie,BDDFile,Variables) :-
(
hybrid_proof(_,_,_) % Check whether we use Hybrid ProbLog
->
(
% Yes! run the disjoining stuff
retractall(hybrid_proof_disjoint(_,_,_,_)),
disjoin_hybrid_proofs,
init_ptree(OriTrie), % use this as tmp ptree
forall(enum_member_ptree(List,OriTrie1), % go over all stored proofs
(
(
List=[_|_]
->
Proof=List;
Proof=[List]
),
(
select(continuous(ProofID),Proof,Rest)
->
(
% this proof is using continuous facts
all_hybrid_subproofs(ProofID,List2),
append(Rest,List2,NewProof),
insert_ptree(NewProof,OriTrie)
);
insert_ptree(Proof,OriTrie)
)
)
)
);
% Nope, just pass on the Trie
OriTrie=OriTrie1
),
((problog_flag(variable_elimination, true), nb_getval(problog_nested_tries, false)) ->
statistics(walltime, _),
trie_check_for_and_cluster(OriTrie),
statistics(walltime, [_, VariableEliminationTime]),
trie_replace_and_cluster(OriTrie, Trie),
problog_var_set(variable_elimination_time, VariableEliminationTime),
variable_elimination_stats(Clusters, OrigPF, CompPF),
problog_var_set(variable_elimination_stats, compress(Clusters, OrigPF, CompPF)),
clean_up
;
Trie = OriTrie
),
(problog_flag(bdd_static_order, true) ->
get_order(Trie, Order),
problog_flag(static_order_file, SOFName),
convert_filename_to_working_path(SOFName, SOFileName),
generate_order_by_prob_fact_appearance(Order, SOFileName)
;
true
),
ptree:trie_stats(Memory, Tries, Entries, Nodes),
(nb_getval(problog_nested_tries, false) ->
ptree:trie_usage(Trie, TEntries, TNodes, TVirtualNodes),
problog_var_set(trie_statistics, tries(memory(Memory), tries(Tries), entries(TEntries), nodes(TNodes), virtualnodes(TVirtualNodes)))
;
problog_var_set(trie_statistics, tries(memory(Memory), tries(Tries), entries(Entries), nodes(Nodes)))
),
(problog_flag(triedump, true) ->
convert_filename_to_working_path(trie_file, TrieFile),
tell(TrieFile),
print_nested_ptree(Trie),
flush_output,
told,
tell(user_output)
;
true
),
nb_getval(problog_completed_proofs, Trie_Completed_Proofs),
((Trie = Trie_Completed_Proofs, problog_flag(save_bdd, true)) ->
problog_control(on, remember)
;
problog_control(off, remember)
),
% old reduction method doesn't support nested tries
((problog_flag(use_old_trie, true), nb_getval(problog_nested_tries, false)) ->
statistics(walltime, _),
(problog_control(check, remember) ->
bdd_struct_ptree_map(Trie, BDDFile, Variables, Mapping),
convert_filename_to_working_path(save_map, MapFile),
tell(MapFile),
format('mapping(~q).~n', [Mapping]),
flush_output,
told
;
bdd_struct_ptree(Trie, BDDFile, Variables)
),
statistics(walltime, [_, ScriptGenerationTime]),
problog_var_set(bdd_script_time, ScriptGenerationTime)
% omitted call to execute_bdd_tool
;
true
),
% naive method with nested trie support but not loops
((problog_flag(use_naive_trie, true); (problog_flag(use_old_trie, true), nb_getval(problog_nested_tries, true))) ->
statistics(walltime, _),
atomic_concat([BDDFile, '_naive'], BDDFile_naive),
nested_ptree_to_BDD_struct_script(Trie, BDDFile_naive, Variables),
statistics(walltime, [_, ScriptGenerationTime_naive]),
problog_var_set(bdd_script_time(naive), ScriptGenerationTime_naive)
% omitted call to execute_bdd_tool
;
true
),
% reduction method with depth_breadth trie support
problog_flag(db_trie_opt_lvl, ROptLevel),
problog_flag(db_min_prefix, MinPrefix),
(problog_flag(compare_opt_lvl, true) ->
generate_ints(0, ROptLevel, Levels)
;
Levels = [ROptLevel]
),
% Removed forall here, because it hides 'Variables' from what comes afterwards
memberchk(OptLevel, Levels),
(
(problog_flag(use_db_trie, true) ->
tries:trie_db_opt_min_prefix(MinPrefix),
statistics(walltime, _),
(nb_getval(problog_nested_tries, false) ->
trie_to_bdd_struct_trie(Trie, DBTrie, BDDFile, OptLevel, Variables)
;
nested_trie_to_bdd_struct_trie(Trie, DBTrie, BDDFile, OptLevel, Variables)
),
atomic_concat(['builtin_', OptLevel], Builtin),
ptree:trie_stats(DBMemory, DBTries, DBEntries, DBNodes),
FM is DBMemory - Memory,
FT is DBTries - Tries,
FE is DBEntries - Entries,
FN is DBNodes - Nodes,
problog_var_set(dbtrie_statistics(Builtin), tries(memory(FM), tries(FT), entries(FE), nodes(FN))),
delete_ptree(DBTrie),
statistics(walltime, [_, ScriptGenerationTime_builtin]),
problog_var_set(bdd_script_time(Builtin), ScriptGenerationTime_builtin)
% omitted call to execute_bdd_tool
;
true
)
),
% decomposition method
(problog_flag(use_dec_trie, true) ->
atomic_concat([BDDFile, '_dec'], BDDFile_dec),
timer_start(script_gen_time_dec),
ptree_decomposition_struct(Trie, BDDFile_dec, Variables),
timer_stop(script_gen_time_dec,Script_Gen_Time_Dec),
problog_var_set(bdd_script_time(dec), Script_Gen_Time_Dec)
% omitted call to execute_bdd_tool
;
true
),
(Trie =\= OriTrie ->
delete_ptree(Trie)
;
true
),
(var(Variables) -> throw(error('novars')) ; true).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Building a forest of BDDs
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
problog_bdd_forest(Goals) :-
(problog_bdd_forest_supported ->
require(keep_ground_ids),
once(write_bdd_forest(Goals,[],Vars,1)),
unrequire(keep_ground_ids),
reset_non_ground_facts,
bdd_par_file(BDDParFile),
% format('Vars: ~w~n',[Vars]),
tell(BDDParFile),
bdd_vars_script(Vars),
flush_output, % isnt this called by told/0?
told,
% false,
length(Goals,L),
length(Vars,NbVars),
write_global_bdd_file(NbVars,L),
(problog_flag(retain_tables, true) -> retain_tabling; true),
clear_tabling
;
throw(error('Flag settings not supported by problog_bdd_forest/1.'))
).
problog_bdd_forest_supported :- build_trie_supported.
% Iterate over all Goals, write BDD scripts and collect variables used.
write_bdd_forest([],AtomsTot,AtomsTot,_).
write_bdd_forest([Goal|Rest],AtomsAcc,AtomsTot,N) :-
build_trie(Goal, Trie),
write_nth_bdd_struct_script(N, Trie, Vars),
(problog_flag(verbose, true)->
problog_statistics
;
true
),
delete_ptree(Trie),
N2 is N+1,
% map 'not id' to id in Vars
findall(ID,(member((not ID),Vars)) ,NegativeAtoms),
findall(ID,(member(ID,Vars),ID \= (not _)),PositiveAtoms),
% format('PositiveAtoms: ~w~n',[PositiveAtoms]),
% format('NegativeAtoms: ~w~n',[NegativeAtoms]),
append(PositiveAtoms,NegativeAtoms,Atoms),
list_to_ord_set(Atoms,AtomsSet),
ord_union(AtomsAcc,AtomsSet,AtomsAcc2),
once(write_bdd_forest(Rest,AtomsAcc2,AtomsTot,N2)).
% Write files
write_nth_bdd_struct_script(N,Trie,Vars) :-
bdd_forest_file(N,BDDFile),
write_bdd_struct_script(Trie,BDDFile,Vars).
write_global_bdd_file(NbVars,L) :-
bdd_file(BDDFile),
open(BDDFile,'write',BDDFileStream),
format(BDDFileStream,'@BDD2~n~w~n~w~n~w~n',[NbVars,0,L]),
write_global_bdd_file_line(1,L,BDDFileStream),
write_global_bdd_file_query(1,L,BDDFileStream),
close(BDDFileStream).
write_global_bdd_file_line(I,Max,_Handle) :-
I>Max,
!.
write_global_bdd_file_line(I,Max,Handle) :-
bdd_forest_file(I,BDDFile),
format(Handle,'L~q = <~w>~n',[I,BDDFile]),
I2 is I+1,
write_global_bdd_file_line(I2,Max,Handle).
write_global_bdd_file_query(Max,Max,Handle) :-
!,
format(Handle,'L~q~n',[Max]).
write_global_bdd_file_query(I,Max,Handle) :-
format(Handle,'L~q,',[I]),
I2 is I+1,
write_global_bdd_file_query(I2,Max,Handle).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Filename specifications
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
bdd_forest_file(N,BDDFile) :-
problog_flag(bdd_file,BDDFileFlag),
atomic_concat([BDDFileFlag,'_',N],BDDFileFlagWithN),
convert_filename_to_working_path(BDDFileFlagWithN, BDDFile).
bdd_files(BDDFile,BDDParFile) :-
bdd_file(BDDFile),
bdd_par_file(BDDParFile).
bdd_file(BDDFile) :-
problog_flag(bdd_file, BDDFileFlag),
convert_filename_to_working_path(BDDFileFlag, BDDFile).
bdd_par_file(BDDParFile) :-
problog_flag(bdd_par_file, BDDParFileFlag),
convert_filename_to_working_path(BDDParFileFlag, BDDParFile).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Persistent Ground IDs
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
require(Feature) :-
atom(Feature),
atomic_concat(['problog_required_',Feature],Feature_Required),
atomic_concat([Feature_Required,'_',depth],Feature_Depth),
(required(Feature) ->
b_getval(Feature_Depth,Depth),
Depth1 is Depth+1,
b_setval(Feature_Depth,Depth1)
;
b_setval(Feature_Required,required),
b_setval(Feature_Depth,1)
%,format("starting to require ~q~n",[Feature])
).
unrequire(Feature) :-
atom(Feature),
atomic_concat(['problog_required_',Feature],Feature_Required),
atomic_concat([Feature_Required,'_',depth],Feature_Depth),
b_getval(Feature_Depth,Depth),
(Depth=1 ->
nb_delete(Feature_Required),
nb_delete(Feature_Depth)
%,format("stopped keeping ground id's~n",[])
;
Depth1 is Depth-1,
b_setval(Feature_Depth,Depth1)
).
required(Feature) :-
atom(Feature),
atomic_concat(['problog_required_',Feature],Feature_Required),
catch(b_getval(Feature_Required,Val),error(existence_error(variable,Feature_Required),_),fail),
Val == required.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
format_if_verbose(H,T,L) :-
problog_flag(verbose,true),
!,
format(H,T,L).
format_if_verbose(_,_,_).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Should go to dtproblog.yap
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
signal_decision(ClauseID,GroundID) :-
(decision_fact(ClauseID,_) ->
bb_get(decisions,S),
ord_insert(S, GroundID, S2),
bb_put(decisions,S2)
;
true
).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Term Expansion for user predicates
% Must come after clauses for '::'/2 and term_expansion_intern/3
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
user:term_expansion(Term,ExpandedTerm) :-
Term \== end_of_file,
prolog_load_context(module,Mod),
problog:term_expansion_intern(Term,Mod,ExpandedTerm).