Merge branch 'master' of github.com:tacgomes/yap6.3

packages/CLPBN/clpbn/horus_ground.yap

@@ -31,24 +31,16 @@
            get_dist_params/2
           ]).
 
-:- use_module(library('clpbn/ground_factors'),
-          [generate_network/5
-          ]).
-
 :- use_module(library('clpbn/display'),
           [clpbn_bind_vals/3]).
 
-:- use_module(library('clpbn/aggregates'),
-          [check_for_agg_vars/2]).
-
 :- use_module(library(clpbn/numbers)).
 
 :- use_module(library(charsio),
           [term_to_atom/2]).
 
 :- use_module(library(pfl),
-          [skolem/2
+          [skolem/2]).
-          ]).
 
 :- use_module(library(maplist)).
 
@@ -60,33 +52,39 @@
 
 
 call_horus_ground_solver(QueryVars, QueryKeys, AllKeys, Factors, Evidence, Output) :-
-	call_horus_ground_solver_for_probabilities([QueryKeys], AllKeys, Factors, Evidence, Solutions),
+  init_horus_ground_solver(QueryKeys, AllKeys, Factors, Evidence, State),
-	clpbn_bind_vals([QueryVars], Solutions, Output).
+  run_solver(State, [QueryKeys], Solutions),
+  clpbn_bind_vals([QueryVars], Solutions, Output),
+  finalize_horus_ground_solver(State).
 
-call_horus_ground_solver_for_probabilities(QueryKeys, AllKeys, Factors, Evidence, Solutions) :-
+
+init_horus_ground_solver(QueryKeys, AllKeys, Factors, Evidence, state(Network,Hash4,Id4)) :-
   get_factors_type(Factors, Type),
   keys_to_numbers(AllKeys, Factors, Evidence, Hash4, Id4, FactorIds, EvidenceIds),
- 	%writeln(evidence:Evidence), writeln(''),
- 	%writeln(evidenceIds:EvidenceIds), writeln(''),
- 	%writeln(factorIds:FactorIds), writeln(''),
   cpp_create_ground_network(Type, FactorIds, EvidenceIds, Network),
+  %writeln(network:(Type, FactorIds, EvidenceIds, Network)), writeln(''),
   maplist(get_var_information, AllKeys, StatesNames),
   maplist(term_to_atom, AllKeys, KeysAtoms),
-	%writeln(s1:KeysAtoms:KeysAtoms:StatesNames),
+  cpp_set_vars_information(KeysAtoms, StatesNames).
-	cpp_set_vars_information(KeysAtoms, StatesNames),
+
- 	%writeln(network:(Type, FactorIds, EvidenceIds, Network)), writeln(''),
+
-	run_solver(ground(Network,Hash4,Id4), QueryKeys, Solutions),
+run_horus_ground_solver(_QueryVars, Solutions, horus(GKeys, Keys, Factors, Evidence), Solver) :- 
+  set_solver(Solver),
+  call_horus_ground_solver_for_probabilities(GKeys, Keys, Factors, Evidence, Solutions).
+
+
+% TODO this is not beeing called!
+finalize_horus_ground_solver(state(Network,_Hash,_Id)) :-
   cpp_free_ground_network(Network).
 
 
-run_solver(ground(Network,Hash,Id), QueryKeys, Solutions) :-
+run_solver(state(Network,Hash,Id), QueryKeys, Solutions) :-
   %get_dists_parameters(DistIds, DistsParams),
   %cpp_set_factors_params(Network, DistsParams),
   lists_of_keys_to_ids(QueryKeys, QueryIds, Hash, _, Id, _),
-        %writeln(queryKeys:QueryKeys), writeln(''),
- %       writeln(queryIds:QueryIds), writeln(''),
   cpp_run_ground_solver(Network, QueryIds, Solutions).
 
+
 get_factors_type([f(bayes, _, _)|_], bayes) :- ! .
 get_factors_type([f(markov, _, _)|_], markov) :- ! .
 
@@ -97,47 +95,8 @@ get_var_information(Key, Domain) :-
     skolem(Key, Domain).
 
 
-finalize_horus_ground_solver(bp(Network, _)) :-
+%get_dists_parameters([],[]).
-  cpp_free_ground_network(Network).
+%get_dists_parameters([Id|Ids], [dist(Id, Params)|DistsInfo]) :-
-finalize_horus_ground_solver(horus(_, _, _, _)).
+%  get_dist_params(Id, Params),
-
+%  get_dists_parameters(Ids, DistsInfo).
-%
-% QVars: all query variables?
-% 
-% 
-init_horus_ground_solver(QueryKeys, AllKeys, Factors, Evidence, horus(QueryKeys, AllKeys, Factors, Evidence)).
-
-%
-% just call horus solver.
-%
-run_horus_ground_solver(_QueryVars, Solutions, horus(GKeys, Keys, Factors, Evidence) , Solver) :- 
-    set_solver(Solver),
-    call_horus_ground_solver_for_probabilities(GKeys, Keys, Factors, Evidence, Solutions).
-
-%bp([[]],_,_) :- !.
-%bp([QueryVars], AllVars, Output) :-
-%  init_horus_ground_solver(_, AllVars, _, Network),
-%  run_horus_ground_solver([QueryVars], LPs, Network),
-%  finalize_horus_ground_solver(Network),
-%  clpbn_bind_vals([QueryVars], LPs, Output).
-%
-%init_horus_ground_solver(_, AllVars0, _, bp(BayesNet, DistIds)) :-
-%  %check_for_agg_vars(AllVars0, AllVars),
-%  get_vars_info(AllVars0, VarsInfo, DistIds0),
-%  sort(DistIds0, DistIds),
-%  cpp_create_ground_network(VarsInfo, BayesNet),
-%  true.
-%
-%
-%run_horus_ground_solver(QueryVars, Solutions, bp(Network, DistIds)) :-
-%  get_dists_parameters(DistIds, DistsParams),
-%  cpp_set_factors_params(Network, DistsParams),
-%  vars_to_ids(QueryVars, QueryVarsIds),
-%  cpp_run_ground_solver(Network, QueryVarsIds, Solutions).
-
-
-get_dists_parameters([],[]).
-get_dists_parameters([Id|Ids], [dist(Id, Params)|DistsInfo]) :-
-  get_dist_params(Id, Params),
-  get_dists_parameters(Ids, DistsInfo).
 

packages/CLPBN/clpbn/horus_lifted.yap

@@ -1,8 +1,10 @@
 /*******************************************************
 
  Interface to Horus Lifted Solvers. Used by:
-   - Lifted Variable Elimination
+   - Generalized Counting First-Order Variable Elimination (GC-FOVE)
    - Lifted First-Order Belief Propagation
+   - Lifted First-Order Knowledge Compilation
+
 ********************************************************/
 
 :- module(clpbn_horus_lifted,
@@ -33,24 +35,35 @@
           ]).
 
 
-call_horus_lifted_solver([[]], _, _) :- !.
+call_horus_lifted_solver(QueryVars, AllVars, Output) :-
-call_horus_lifted_solver([QueryVars], AllVars, Output) :-
+  init_horus_lifted_solver(_, AllVars, _, State),
-  init_horus_lifted_solver(_, AllVars, _, ParfactorList),
+  run_horus_lifted_solver(QueryVars, Solutions, State),
-  run_horus_lifted_solver([QueryVars], LPs, ParfactorList),
+  clpbn_bind_vals(QueryVars, Solutions, Output),
-  finalize_horus_lifted_solver(ParfactorList),
+  finalize_horus_lifted_solver(State).
-  clpbn_bind_vals([QueryVars], LPs, Output).
 
 
-init_horus_lifted_solver(_, AllAttVars, _, fove(ParfactorList, DistIds)) :-
+init_horus_lifted_solver(_, AllVars, _, state(ParfactorList, DistIds)) :-
   get_parfactors(Parfactors),
   get_dist_ids(Parfactors, DistIds0),
   sort(DistIds0, DistIds),
-  get_observed_vars(AllAttVars, ObservedVars),
+  get_observed_vars(AllVars, ObservedVars),
   %writeln(parfactors:Parfactors:'\n'),
   %writeln(evidence:ObservedVars:'\n'),
   cpp_create_lifted_network(Parfactors, ObservedVars, ParfactorList).
 
 
+run_horus_lifted_solver(QueryVars, Solutions, state(ParfactorList, DistIds)) :-
+  get_query_keys(QueryVars, QueryKeys),
+  get_dists_parameters(DistIds, DistsParams),
+  %writeln(dists:DistsParams), writeln(''),
+  cpp_set_parfactors_params(ParfactorList, DistsParams),
+  cpp_run_lifted_solver(ParfactorList, QueryKeys, Solutions).
+
+
+finalize_horus_lifted_solver(state(ParfactorList, _)) :-
+  cpp_free_lifted_network(ParfactorList).
+
+
 :- table get_parfactors/1.
 
 %
@@ -116,16 +129,16 @@ get_observed_vars(V.AllAttVars, ObservedVars) :-
   get_observed_vars(AllAttVars, ObservedVars).
 
 
-get_query_vars([], []).
+get_query_keys([], []).
-get_query_vars(E1.L1, E2.L2) :-
+get_query_keys(E1.L1, E2.L2) :-
-  get_query_vars_2(E1,E2),
+  get_query_keys_2(E1,E2),
-  get_query_vars(L1, L2).
+  get_query_keys(L1, L2).
 
 
-get_query_vars_2([], []).
+get_query_keys_2([], []).
-get_query_vars_2(V.AttVars, [RV|RVs]) :-
+get_query_keys_2(V.AttVars, [RV|RVs]) :-
   clpbn:get_atts(V,[key(RV)]), !,
-  get_query_vars_2(AttVars, RVs).
+  get_query_keys_2(AttVars, RVs).
 
 
 get_dists_parameters([], []).
@@ -133,16 +146,3 @@ get_dists_parameters([Id|Ids], [dist(Id, Params)|DistsInfo]) :-
   get_pfl_parameters(Id, Params),
   get_dists_parameters(Ids, DistsInfo).
 
-
-run_horus_lifted_solver(QueryVarsAtts, Solutions, fove(ParfactorList, DistIds)) :-
-  get_query_vars(QueryVarsAtts, QueryVars),
-  %writeln(queryVars:QueryVars), writeln(''),
-  get_dists_parameters(DistIds, DistsParams),
-  %writeln(dists:DistsParams), writeln(''),
-  cpp_set_parfactors_params(ParfactorList, DistsParams),
-  cpp_run_lifted_solver(ParfactorList, QueryVars, Solutions).
-
-
-finalize_horus_lifted_solver(fove(ParfactorList, _)) :-
-  cpp_free_lifted_network(ParfactorList).
-

packages/CLPBN/horus/LiftedCircuit.cpp

@@ -18,11 +18,6 @@ AndNode::weight (void) const
 {
   double lw = leftBranch_->weight();
   double rw = rightBranch_->weight();
-  if (Globals::logDomain) {
-//    cout << "andw1 = " << std::exp(lw + rw) << endl;
-  } else {
-//    cout << "andw2 = " << lw * rw << endl;
-  }
   return Globals::logDomain ? lw + rw : lw * rw;
 }
 
@@ -251,10 +246,6 @@ LiftedCircuit::compile (
     return;
   }
 
-  if (tryGrounding (follow, clauses)) {
-    return;
-  }
-
   // assert (false);
   *follow = new CompilationFailedNode (clauses);
 }
@@ -266,11 +257,8 @@ LiftedCircuit::tryUnitPropagation (
     CircuitNode** follow,
     Clauses& clauses)
 {
-  // cout << "ALL CLAUSES:" << endl;
-  // Clause::printClauses (clauses);
   for (size_t i = 0; i < clauses.size(); i++) {
     if (clauses[i].isUnit()) {
-      // cout << clauses[i] << " is unit!" << endl;
       Clauses newClauses;
       for (size_t j = 0; j < clauses.size(); j++) {
         if (i != j) {
@@ -557,36 +545,6 @@ LiftedCircuit::tryAtomCounting (
 
 
 
-bool
-LiftedCircuit::tryGrounding (
-    CircuitNode**,
-    Clauses&)
-{
-  return false;
-  /*
-  size_t bestClauseIdx = 0;
-  size_t bestLogVarIdx = 0;
-  unsigned minNrSymbols = Util::maxUnsigned();
-  for (size_t i = 0; i < clauses.size(); i++) {
-    LogVarSet lvs = clauses[i].constr().logVars();
-    ConstraintTree ct = clauses[i].constr();
-    for (unsigned j = 0; j < lvs.size(); j++) {
-      unsigned nrSymbols = ct.nrSymbols (lvs[j]);
-      if (nrSymbols < minNrSymbols) {
-        minNrSymbols = nrSymbols;
-        bestClauseIdx = i;
-        bestLogVarIdx = j;
-      }
-    }
-  }
-  LogVar bestLogVar = clauses[bestClauseIdx].constr().logVars()[bestLogVarIdx];
-  ConstraintTrees cts = clauses[bestClauseIdx].constr().ground (bestLogVar);
-  return true;
-  */
-}
-
-
-
 void
 LiftedCircuit::shatterCountedLogVars (Clauses& clauses)
 {

packages/CLPBN/horus/LiftedCircuit.h

@@ -234,8 +234,6 @@ class LiftedCircuit
 
     bool tryAtomCounting (CircuitNode** follow, Clauses& clauses);
 
-    bool tryGrounding (CircuitNode** follow, Clauses& clauses);
-
     void shatterCountedLogVars (Clauses& clauses);
 
     bool shatterCountedLogVarsAux (Clauses& clauses);