2:-module(slipcover,[set_sc/2,setting_sc/2,
    3  induce/2,induce_par/2,test/7,list2or/2,list2and/2,
    4  sample/4,learn_params/5,
    5  op(500,fx,#),op(500,fx,'-#'),
    6  test_prob/6,rules2terms/2,
    7  get_sc_var_n/6,
    8  process_clauses/6,
    9  generate_clauses/6,
   10  generate_clauses_bg/2,
   11  generate_body/3,
   12  make_dynamic/1,
   13  extract_fancy_vars/2,
   14  linked_clause/3,
   15  banned_clause/3,
   16  take_var_args/3,
   17  remove_duplicates/2,
   18  extract_type_vars/3,
   19  delete_one/3,
   20  get_next_rule_number/2,
   21  tab/3,
   22  zero_clause/3,
   23  member_eq/2,
   24  retract_all/1,assert_all/3,
   25  write2/2,write3/2,format2/3,format3/3,
   26  write_rules2/3,write_rules3/3,
   27  nl2/1,nl3/1]).

   45/*
   46
   47SLIPCOVER
   48
   49Copyright (c) 2016, Fabrizio Riguzzi and Elena Bellodi
   50
   51*/
   52:-reexport(library(bddem)).   53:-use_module(library(auc)).   54:-use_module(library(lists)).   55:-use_module(library(random)).   56:-use_module(library(system)).   57:-use_module(library(terms)).   58:-use_module(library(apply)).   59:-use_module(cplint_util).   60:-set_prolog_flag(unknown,warning).   61
   62
   63:- dynamic db/1.   64
   65:- dynamic sc_input_mod/1.   66
   67:- thread_local  sc_input_mod/1.   68
   69:- meta_predicate induce(:,-).   70:- meta_predicate induce_rules(:,-).   71:- meta_predicate induce_par(:,-).   72:- meta_predicate induce_parameters(:,-).   73:- meta_predicate test(:,+,-,-,-,-,-).   74:- meta_predicate test_prob(:,+,-,-,-,-).   75:- meta_predicate set_sc(:,+).   76:- meta_predicate setting_sc(:,-).   77
   78default_setting_sc(epsilon_em,0.0001).
   79default_setting_sc(epsilon_em_fraction,0.00001).
   80default_setting_sc(eps,0.0001).
   81default_setting_sc(eps_f,0.00001).
   82
   83/* if the difference in log likelihood in two successive em iteration is smaller
   84than epsilon_em, then EM stops */
   85default_setting_sc(epsilon_sem,2).
   86
   87/* number of random restarts of em */
   88default_setting_sc(random_restarts_REFnumber,1).
   89default_setting_sc(random_restarts_number,1).
   90default_setting_sc(iterREF,-1).
   91default_setting_sc(iter,-1).
   92default_setting_sc(examples,atoms).
   93default_setting_sc(group,1).
   94default_setting_sc(d,1).
   95default_setting_sc(verbosity,1).
   96default_setting_sc(logzero,log(0.000001)).
   97default_setting_sc(megaex_bottom,1).
   98default_setting_sc(initial_clauses_per_megaex,1).
   99default_setting_sc(max_iter,10).
  100default_setting_sc(max_iter_structure,10000).
  101default_setting_sc(max_var,4).
  102default_setting_sc(max_rules,10).
  103default_setting_sc(maxdepth_var,2).
  104default_setting_sc(beamsize,100).
  105default_setting_sc(max_body_length,100).
  106default_setting_sc(neg_literals,false).
  107default_setting_sc(background_clauses,50).
  108
  109default_setting_sc(specialization,bottom).
  110/* allowed values: mode,bottom */
  111default_setting_sc(specialize_head,false).
  112
  113default_setting_sc(seed,seed(3032)).
  114default_setting_sc(c_seed,21344).
  115default_setting_sc(score,ll).
  116/* allowed values: ll aucpr */
  117default_setting_sc(neg_ex,cw).
  118
  119
  120default_setting_sc(epsilon_parsing, 1e-5).
  121default_setting_sc(tabling,auto).
  122/* values:
  123  auto
  124  explicit
  125*/
  126
  127default_setting_sc(bagof,false).
  128/* values: false, intermediate, all, extra */
  129
  130default_setting_sc(compiling,off).
  131
  132
  133default_setting_sc(depth_bound,true).  %if true, it limits the derivation of the example to the value of 'depth'
  134default_setting_sc(depth,2).
  135default_setting_sc(single_var,true). %false:1 variable for every grounding of a rule; true: 1 variable for rule (even if a rule has more groundings),simpler.
  136
  137default_setting_sc(prob_approx,false). %if true, it limits the number of different solutions found when computing the probability
  138default_setting_sc(approx_value,100).
  139
  140default_setting_sc(alpha,0.0).
  141% Sets the type of parameter initialization for EM on Environment:
  142% if alpha is 0.0, it uses a truncated Dirichlet process
  143% if alpha is a float > 0.0, it uses a symmetric Dirichlet distribution
  144% with that value as parameter

 induce(:TrainFolds:list_of_atoms, -P:probabilistic_program) is det

The predicate performs structure learning using the folds indicated in TrainFolds for training. It returns in P the learned probabilistic program.

  153induce(M:TrainFolds,P):-
  154  must_be(list,TrainFolds),
  155  must_be(var,P),
  156  induce_rules(M:TrainFolds,P0),
  157  rules2terms(P0,P).

 test(:P:probabilistic_program, +TestFolds:list_of_atoms, -LL:float, -AUCROC:float, -ROC:dict, -AUCPR:float, -PR:dict) is det

The predicate takes as input in P a probabilistic program, tests P on the folds indicated in TestFolds and returns the log likelihood of the test examples in LL, the area under the Receiver Operating Characteristic curve in AUCROC, a dict containing the points of the ROC curve in ROC, the area under the Precision Recall curve in AUCPR and a dict containing the points of the PR curve in PR

  169test(M:P,TestFolds,LL,AUCROC,ROC,AUCPR,PR):-
  170  must_be(nonvar,P),
  171  must_be(list,TestFolds),
  172  must_be(var,LL),
  173  must_be(var,AUCROC),
  174  must_be(var,ROC),
  175  must_be(var,AUCPR),
  176  must_be(var,PR),
  177  test_prob(M:P,TestFolds,_NPos,_NNeg,LL,LG),
  178  compute_areas_diagrams(LG,AUCROC,ROC,AUCPR,PR).

 test_prob(:P:probabilistic_program, +TestFolds:list_of_atoms, -NPos:int, -NNeg:int, -LL:float, -Results:list) is det

The predicate takes as input in P a probabilistic program, tests P on the folds indicated in TestFolds and returns the number of positive examples in NPos, the number of negative examples in NNeg, the log likelihood in LL and in Results a list containing the probabilistic result for each query contained in TestFolds.

  189test_prob(M:P,TestFolds,NPos,NNeg,CLL,Results) :-
  190  must_be(nonvar,P),
  191  must_be(list,TestFolds),
  192  must_be(var,NNeg),
  193  must_be(var,CLL),
  194  must_be(var,NPos),
  195  must_be(var,Results),
  196  write2(M,'Testing\n'),
  197  findall(Exs,(member(F,TestFolds),M:fold(F,Exs)),L),
  198  append(L,TE),
  199  reset_next_rule_number(M),
  200  set_sc(M:compiling,on),
  201  process_clauses(P,M,[],_,[],PRules),
  202  generate_clauses(PRules,M,RuleFacts,0,[],Th),
  203  assert_all(Th,M,ThRef),
  204  assert_all(RuleFacts,M,RFRef),
  205  (M:bg(RBG0)->
  206    process_clauses(RBG0,M,[],_,[],RBG),
  207    generate_clauses(RBG,M,_RBGRF,0,[],ThBG),
  208    generate_clauses_bg(RBG,ClBG),
  209    assert_all(ClBG,M,ClBGRef),
  210    assert_all(ThBG,ThBGRef)
  211  ;
  212    true
  213  ),
  214  set_sc(M:compiling,off),
  215  test_no_area([TE],M,NPos,NNeg,CLL,Results),
  216  (M:bg(RBG0)->
  217    retract_all(ThBGRef),
  218    retract_all(ClBGRef)
  219  ;
  220    true
  221  ),
  222  retract_all(ThRef),
  223  retract_all(RFRef).
  224
  225induce_rules(M:Folds,R):-
  226  set_sc(M:compiling,on),
  227  M:local_setting(seed,Seed),
  228  set_random(Seed),
  229  M:local_setting(c_seed,CSeed),
  230  rand_seed(CSeed),
  231  findall(Exs,(member(F,Folds),M:fold(F,Exs)),L),
  232  append(L,DB),
  233  assert(M:database(DB)),
  234  (M:bg(RBG0)->
  235    process_clauses(RBG0,M,[],_,[],RBG),
  236    generate_clauses(RBG,M,_RBG1,0,[],ThBG),
  237    generate_clauses_bg(RBG,ClBG),
  238    assert_all(ThBG,M,ThBGRef),
  239    assert_all(ClBG,M,ClBGRef)
  240  ;
  241    true
  242  ),
  243  length(DB,NMegaEx),
  244  M:local_setting(megaex_bottom, NumMB),
  245  (NMegaEx >= NumMB ->
  246      true
  247    ;
  248      format2(M,"~nWARN: Number of required bottom clauses is greater than the number of training examples!~n. The number of required bottom clauses will be equal to the number of training examples", []),
  249      set_sc(M:megaex_bottom, NMegaEx)
  250  ),
  251
  252  statistics(walltime,[_,_]),
  253  (M:local_setting(specialization,bottom)->
  254    M:local_setting(megaex_bottom,MB),
  255    deduct(MB,M,DB,[],InitialTheory),
  256    length(InitialTheory,_LI),
  257    remove_duplicates(InitialTheory,R1)
  258  ;
  259    get_head_atoms(O,M),
  260    generate_top_cl(O,M,R1)
  261  ),
  262  learn_struct(DB,M,R1,R2,Score2),
  263  learn_params(DB,M,R2,R,Score),
  264  format2(M,"~nRefinement score  ~f - score after EMBLEM ~f~n",[Score2,Score]),
  265  statistics(walltime,[_,WT]),
  266  WTS is WT/1000.0,
  267  write2(M,'\n\n'),
  268  format2(M,'/* SLIPCOVER Final score ~f~n',[Score]),
  269  format2(M,'Wall time ~f */~n',[WTS]),
  270  write_rules2(M,R,user_output),
  271  set_sc(M:compiling,off),
  272  (M:bg(RBG0)->
  273    retract_all(ThBGRef),
  274    retract_all(ClBGRef)
  275  ;
  276    true
  277  ),
  278  clean_up_db_structure(M).
  279
  280clean_up_db_structure(M):-
  281  retractall(M:ref(_)),
  282  retractall(M:ref_clause(_)),
  283  clean_up_db(M).

 make_dynamic(+Module:atom) is det

Makes the predicates required for learning dynamic.

  290make_dynamic(M):-
  291  M:(dynamic int/1),
  292  findall(O,M:output(O),LO),
  293  findall(I,M:input(I),LI),
  294  findall(I,M:input_cw(I),LIC),
  295  findall(D,M:determination(D,_DD),LDH),
  296  findall(DD,M:determination(_D,DD),LDD),
  297  findall(DH,(M:modeh(_,_,_,LD),member(DH,LD)),LDDH),
  298  append([LO,LI,LIC,LDH,LDD,LDDH],L0),
  299  remove_duplicates(L0,L),
  300  maplist(to_dyn(M),L).
  301
  302to_dyn(M,P/A):-
  303  A1 is A+1,
  304  M:(dynamic P/A1),
  305  A2 is A1+2,
  306  M:(dynamic P/A2),
  307  A3 is A2+1,
  308  M:(dynamic P/A3).
  309
  310
  311
  312gen_fixed([],_M,[]).
  313
  314gen_fixed([(H,B,BL)|T],M,[rule(R,H,B,BL,tunable)|T1]):-
  315  get_next_rule_number(M,R),
  316  gen_fixed(T,M,T1).
  317
  318
  319learn_struct(DB,Mod,R1,R,Score):-   %+R1:initial theory of the form [rule(NR,[h],[b]],...], -R:final theory of the same form, -CLL
  320  format2(Mod,"Clause search~n~n",[]),
  321  Mod:local_setting(max_iter,M),
  322  Mod:local_setting(depth_bound,DepthB),
  323  set_sc(Mod:depth_bound,false),
  324  findall((H,B,BL),Mod:fixed_rule(H,B,BL),LF),
  325  length(LF,LLF),
  326  gen_fixed(LF,Mod,LFR),
  327  format2(Mod,"Scoring fixed clauses: ~d clauses~n~n",[LLF]),
  328  score_clause_refinements(LFR,Mod,1,LLF,DB,[],NB1,[],CL0,[],CLBG0),
  329  append(NB1,R1,Beam),
  330  cycle_beam(Beam,Mod,DB,CL0,CL,CLBG0,BG,M),
  331  learn_params(DB,Mod,[],REmpty,S),
  332  set_sc(Mod:depth_bound,DepthB),
  333  format2(Mod,"Theory search~n~n",[]),
  334  Mod:local_setting(max_iter_structure,MS),
  335  cycle_structure(CL,Mod,REmpty,S,-1e20,DB,R2,Score,MS),
  336  format2(Mod,"Best target theory~n~n",[]),
  337  write_rules2(Mod,R2,user_output),
  338  Mod:local_setting(background_clauses,NBG1),
  339  length(BG,NBG),
  340  format2(Mod,"Background search: ~d of ~d clauses~n~n",[NBG1,NBG]),
  341  pick_first(NBG1,BG,BG1),
  342  remove_score(BG,BG2),
  343  write_rules2(Mod,BG2,user_output),
  344  write2(Mod,'\n'),
  345  append(R2,BG1,R).
  346
  347pick_first(0,_,[]):-!.
  348
  349pick_first(_,[],[]):-!.
  350
  351pick_first(N,[(H,_S)|T],[H|T1]):-
  352  N1 is N-1,
  353  pick_first(N1,T,T1).
  354
  355remove_score([],[]).
  356
  357remove_score([(H,_S)|T],[H|T1]):-
  358  remove_score(T,T1).
  359
  360cycle_structure([],_Mod,R,S,_SP,_DB,R,S,_I):-!.  %empty beam
  361
  362cycle_structure(_CL,_Mod,R,S,_SP,_DB,R,S,0):-!.  %0 iterations
  363
  364cycle_structure([(RH,_CLL)|RT],Mod,R0,S0,SP0,DB,R,S,M):-
  365  already_scored(Mod,[RH|R0],R3,Score),!,
  366  format2(Mod,"Theory iteration ~d~n~n",[M]),
  367  write3(Mod,'Already scored, updated refinement\n'),
  368  write_rules3(Mod,R3,user_output),
  369  write3(Mod,'Score '),write3(Mod,Score),write3(Mod,'\n\n\n'),
  370  (Score>S0->
  371    R4=R3,
  372    S4=Score,
  373    SP1=S0
  374  ;
  375    R4=R0,
  376    S4=S0,
  377    SP1=SP0
  378  ),
  379  M1 is M-1,
  380  cycle_structure(RT,Mod,R4,S4,SP1,DB,R,S,M1).
  381
  382cycle_structure([(RH,_Score)|RT],Mod,R0,S0,SP0,DB,R,S,M):-
  383  format2(Mod,"Theory iteration ~d~n~n",[M]),
  384  reset_next_rule_number(Mod),
  385  generate_clauses([RH|R0],Mod,R2,0,[],Th1),
  386  format3(Mod,"Initial theory~n~n",[]),
  387  write_rules3(Mod,[RH|R0],user_output),
  388  assert_all(Th1,Mod,Th1Ref),
  389  assert_all(R2,Mod,R2Ref),!,
  390  init_em(ExData),
  391  retractall(Mod:v(_,_,_)),
  392  length(DB,NEx),
  393  abolish_all_tables,
  394  (Mod:local_setting(examples,atoms)->
  395    Mod:local_setting(group,G),
  396    derive_bdd_nodes_groupatoms(DB,Mod,ExData,NEx,G,[],Nodes,0,CLL0,LE,[]),!   % 1 BDD per example if G=1
  397  ;
  398    derive_bdd_nodes(DB,Mod,ExData,NEx,[],Nodes,0,CLL0),! % 1 BDD per model
  399  ),
  400  Mod:local_setting(random_restarts_number,N),
  401  format3(Mod,"~nInitial CLL ~f~n~n",[CLL0]),
  402  random_restarts(N,Mod,ExData,Nodes,CLL0,Score,initial,Par,LE),   %output:CLL,Par
  403  format3(Mod,"Score after EMBLEM = ~f~n",[Score]),
  404  retract_all(Th1Ref),
  405  retract_all(R2Ref),!,
  406  end_ex(ExData),
  407  update_theory(R2,Par,R3),
  408  write3(Mod,'Updated Theory\n'),
  409  write_rules3(Mod,R3,user_output),   %definite rules without probabilities in the head are not written
  410  (Score>S0->
  411    R4=R3,
  412    S4=Score,
  413    SP1=S0,
  414    write3(Mod,'New best score\n')
  415  ;
  416    R4=R0,
  417    S4=S0,
  418    SP1=SP0
  419  ),
  420  store_refinement(Mod,[RH|R0],R3,Score),
  421  M1 is M-1,
  422  cycle_structure(RT,Mod,R4,S4,SP1,DB,R,S,M1).

 induce_par(:TrainFolds:list_of_atoms, -P:probabilistic_program) is det

The predicate learns the parameters of the program stored in the in/1 fact of the input file using the folds indicated in TrainFolds for training. It returns in P the input program with the updated parameters.

  431induce_par(M:Folds,ROut):-
  432  must_be(list,Folds),
  433  must_be(var,ROut),
  434  induce_parameters(M:Folds,R),
  435  rules2terms(R,ROut).
  436
  437induce_parameters(M:Folds,R):-
  438  set_sc(M:compiling,on),
  439  M:local_setting(seed,Seed),
  440  set_random(Seed),
  441  M:local_setting(c_seed,CSeed),
  442  rand_seed(CSeed),
  443  findall(Exs,(member(F,Folds),M:fold(F,Exs)),L),
  444  append(L,DB),
  445  assert(M:database(DB)),
  446  statistics(walltime,[_,_]),
  447  (M:bg(RBG0)->
  448    process_clauses(RBG0,M,[],_,[],RBG),
  449    generate_clauses(RBG,M,_RBG1,0,[],ThBG),
  450    generate_clauses_bg(RBG,ClBG),
  451    assert_all(ClBG,M,ClBGRef),
  452    assert_all(ThBG,ThBGRef)
  453  ;
  454    true
  455  ),
  456  set_sc(M:compiling,off),
  457  M:in(R00),
  458  set_sc(M:compiling,on),
  459  process_clauses(R00,M,[],_,[],R0),
  460  statistics(walltime,[_,_]),
  461  learn_params(DB,M,R0,R,Score),
  462  statistics(walltime,[_,CT]),
  463  CTS is CT/1000.0,
  464  format2(M,'/* EMBLEM Final score ~f~n',[Score]),
  465  format2(M,'Wall time ~f */~n',[CTS]),
  466  write_rules2(M,R,user_output),
  467  set_sc(M:compiling,off),
  468  (M:bg(RBG0)->
  469    retract_all(ThBGRef),
  470    retract_all(ClBGRef)
  471  ;
  472    true
  473  ),
  474  clean_up_db(M).
  475
  476clean_up_db(M):-
  477  retract(M:rule_sc_n(_)),
  478  assert(M:rule_sc_n(0)),
  479  retract(M:rule_ng_sc_n(_)),
  480  assert(M:rule_ng_sc_n(0)),
  481  retractall(M:v(_,_,_)),
  482  retractall(M:database(_)).
  483
  484get_rule_info(M,RI-Info):-
  485  M:rule(R,HL,_BL,_Lit,Tun),
  486  R\= ng(_,_),
  487  (R=g(RI)->
  488    true
  489  ;
  490    RI=R
  491  ),
  492  length(HL,N),
  493  ((Tun=tunable;Tun=initial)->
  494    Info=N
  495  ;
  496    Info=[N]
  497  ).
  498
  499get_rule_info_rand(M,RI-Info):-
  500  M:rule(R,HL,_BL,_Lit,Tun),
  501  R\= ng(_,_),
  502  (R=g(RI)->
  503    true
  504  ;
  505    RI=R
  506  ),
  507  length(HL,N),
  508  (Tun=tunable->
  509    Info=N
  510  ;
  511    get_probs(HL,Info0),
  512    (Tun=initial->
  513      Info=Info0
  514    ; % fixed parameters
  515      Info=[Info0]
  516    )
  517  ).

 learn_params(+DB:list_of_atoms, +M:atom, +R0:probabilistic_program, -P:probabilistic_program, -Score:float) is det

The predicate learns the parameters of the program R0 and returns the updated program in R and the score in Score. DB contains the list of interpretations ids and M the module where the data is stored.

  529learn_params(DB,M,R0,R,Score):-  %Parameter Learning
  530  reset_next_rule_number(M),
  531  reset_next_nonground_rule_number(M),
  532  generate_clauses(R0,M,R1,0,[],Th0),
  533  format2(M,"Initial theory~n",[]),
  534  write_rules2(M,R1,user_output),
  535  assert_all(Th0,M,Th0Ref),
  536  assert_all(R1,M,R1Ref),!,
  537  init_em(ExData),
  538  retractall(M:v(_,_,_)),
  539  length(DB,NEx),
  540  abolish_all_tables,
  541  (M:local_setting(examples,atoms)->
  542    M:local_setting(group,G),
  543    derive_bdd_nodes_groupatoms(DB,M,ExData,NEx,G,[],Nodes,0,CLL0,LE,[]),!
  544  ;
  545    derive_bdd_nodes(DB,M,ExData,NEx,[],Nodes,0,CLL0),!
  546  ),
  547  format3(M,"Initial score ~f~n",[CLL0]),
  548  M:local_setting(random_restarts_number,N),
  549  random_restarts(N,M,ExData,Nodes,-1e20,Score,initial,Par,LE),  %computes new parameters Par
  550  end_ex(ExData),
  551  update_theory_par(M,R1,Par,R),
  552  retract_all(Th0Ref),
  553  retract_all(R1Ref),!,
  554  retractall(M:rule(_,_,_,_,_)).
  555
  556
  557update_theory_par(M,OldR,Par,Rules):-
  558   findall(def_rule(H,B,L),member(def_rule(H,B,L),OldR),DefRules0),
  559   findall((H:-B),member((H:-B),OldR),DefRules1),
  560   new_rules(Par,M,DisjRules0),
  561   sort(DisjRules0,DisjRules),
  562   append([DefRules0,DefRules1,DisjRules],Rules).
  563
  564new_rules([],_M,[]).
  565
  566new_rules([[_N,[1.0|_]]|T],M,R):-!,
  567  new_rules(T,M,R).
  568
  569
  570new_rules([[N,P]|T],M,[rule(N,H1,B,L,Tun)|R]):-
  571  reverse(P,P1),
  572  (M:rule(N,H,B,L,Tun);M:rule(g(N),H,B,L,Tun)),
  573  update_head_par(H,P1,H1),
  574  new_rules(T,M,R).
  575
  576
  577update_theory(R,initial,R):-!.
  578
  579update_theory([],_Par,[]).
  580
  581update_theory([def_rule(H,B,L)|T0],Par,[def_rule(H,B,L)|T]):-!,
  582  update_theory(T0,Par,T).
  583
  584update_theory([(H:-B)|T0],Par,[(H:-B)|T]):-!,
  585  update_theory(T0,Par,T).
  586
  587update_theory([rule(N,H,B,L,Tun)|T0],Par,[rule(N,H1,B,L,Tun)|T]):-
  588  member([N,P],Par),!,
  589  reverse(P,P1),
  590  update_head_par(H,P1,H1),
  591  update_theory(T0,Par,T).
  592
  593update_head_par([],[],[]).
  594
  595update_head_par([H:_P|T0],[HP|TP],[H:HP|T]):-
  596  update_head_par(T0,TP,T).
  597
  598cycle_beam([],_Mod,_DB,CL,CL,CLBG,CLBG,_M):-!.
  599
  600cycle_beam(_Beam,_Mod,_DB,CL,CL,CLBG,CLBG,0):-!.
  601
  602cycle_beam(Beam,Mod,DB,CL0,CL,CLBG0,CLBG,M):-
  603  format2(Mod,"Clause iteration ~d~n~n",[M]),
  604  cycle_clauses(Beam,Mod,DB,[],NB,CL0,CL1,CLBG0,CLBG1),
  605  M1 is M-1,%decreases the number of max_iter M
  606  cycle_beam(NB,Mod,DB,CL1,CL,CLBG1,CLBG,M1).
  607
  608cycle_clauses([],_M,_DB,NB,NB,CL,CL,CLBG,CLBG):-!.
  609
  610cycle_clauses([(RH,_ScoreH)|T],M,DB,NB0,NB,CL0,CL,CLBG0,CLBG):-
  611  findall(RS,specialize_rule(RH,M,RS,_L),LR),!,   %-LR:list of lists, each one correponding to a different revised theory; specialize_rule defined in revise.pl
  612  length(LR,NR),
  613  write3(M,'Number of revisions '),write3(M,NR),write3(M,'\n'),
  614  score_clause_refinements(LR,M,1,NR,DB,NB0,NB1,CL0,CL1,CLBG0,CLBG1),
  615  cycle_clauses(T,M,DB,NB1,NB,CL1,CL,CLBG1,CLBG).
  616
  617score_clause_refinements([],_M,_N,_NR,_DB,NB,NB,CL,CL,CLBG,CLBG).
  618
  619score_clause_refinements([R1|T],M,Nrev,NRef,DB,NB0,NB,CL0,CL,CLBG0,CLBG):-  %scans the list of revised theories
  620  already_scored_clause(M,R1,R3,Score),!,
  621  format3(M,'Score ref.  ~d of ~d~n',[Nrev,NRef]),
  622  write3(M,'Already scored, updated refinement\n'),
  623  write_rules3(M,[R3],user_output),
  624  write3(M,'Score '),write3(M,Score),write3(M,'\n\n\n'),
  625  M:local_setting(beamsize,BS),
  626  insert_in_order(NB0,(R3,Score),BS,NB1),
  627  Nrev1 is Nrev+1,
  628  score_clause_refinements(T,M,Nrev1,NRef,DB,NB1,NB,CL0,CL,CLBG0,CLBG).
  629
  630score_clause_refinements([R1|T],M,Nrev,NRef,DB,NB0,NB,CL0,CL,CLBG0,CLBG):-
  631  format3(M,'Score ref.  ~d of ~d~n',[Nrev,NRef]),
  632  write_rules3(M,[R1],user_output),
  633  generate_clauses_cw([R1],M,[R2],0,[],Th1),
  634  assert_all(Th1,M,Th1Ref),
  635  assert_all([R2],M,[R2Ref]),!,
  636  init_em(ExData),
  637  retractall(M:v(_,_,_)),
  638  length(DB,NEx),
  639  get_output_preds(R1,O),
  640  abolish_all_tables,
  641  (M:local_setting(examples,atoms)->
  642    M:local_setting(group,G),
  643    derive_bdd_nodes_groupatoms_output_atoms(DB,M,ExData,O,NEx,G,[],Nodes,0,CLL0,LE,[]),!
  644  ;
  645    derive_bdd_nodes(DB,M,ExData,NEx,[],Nodes,0,CLL0),!
  646  ),
  647  format3(M,"Initial CLL ~f~n",[CLL0]),
  648  M:local_setting(random_restarts_REFnumber,N),
  649  random_restarts_ref(N,M,ExData,Nodes,CLL0,Score,initial,Par,LE),
  650  end_ex(ExData),
  651  update_theory([R2],Par,[R3]),
  652  write3(M,'Updated refinement\n'),
  653  write_rules3(M,[R3],user_output),
  654  write3(M,'Score (CLL) '),write3(M,Score),write3(M,'\n\n\n'),
  655  retract_all(Th1Ref),
  656  retract_all([R2Ref]),!,
  657  M:local_setting(beamsize,BS),
  658  insert_in_order(NB0,(R3,Score),BS,NB1),
  659  (target(R3,M)->
  660    insert_in_order(CL0,(R3,Score),+1e20,CL1),
  661    length(CL1,LCL1),
  662    format2(M,"N. of target clauses ~d~n~n",[LCL1]),
  663    CLBG1=CLBG0
  664  ;
  665    (range_restricted(R3)->
  666      insert_in_order(CLBG0,(R3,Score),+1e20,CLBG1),
  667      length(CLBG1,LCL1),
  668      format2(M,"N. of background clauses ~d~n~n",[LCL1]),
  669      CL1=CL0
  670    ;
  671      format2(M,"Not range restricted~n~n",[]),
  672      CL1=CL0,
  673      CLBG1=CLBG0
  674    )
  675  ),
  676  store_clause_refinement(M,R1,R3,Score),
  677  Nrev1 is Nrev+1,
  678  score_clause_refinements(T,M,Nrev1,NRef,DB,NB1,NB,CL1,CL,CLBG1,CLBG).
  679
  680range_restricted(rule(_N,HL,BL,_Lit,_Tun)):-
  681  term_variables(HL,VH),
  682  term_variables(BL,VB),
  683  sublisteq(VH,VB).
  684
  685sublisteq([],_).
  686
  687sublisteq([H|T],L):-
  688  member_eq(H,L),
  689  sublisteq(T,L).
  690
  691target(R,M):-
  692  get_output_preds(R,O),
  693  member(T,O),
  694  M:output(T),!.
  695
  696get_output_preds(rule(_N,HL,_BL,_Lit,_Tun),O):-
  697  scan_head(HL,[],O).
  698
  699scan_head(['':_],O,O):-!.
  700scan_head([],O,O):-!.
  701scan_head([H:_P|T],O0,O):-
  702  functor(H,F,N),
  703  (member(F/N,O0)->
  704    O1=O0
  705  ;
  706    O1=[F/N|O0]
  707  ),
  708  scan_head(T,O1,O).
  709
  710
  711
  712store_clause_refinement(M,Ref,RefP,Score):-
  713  elab_clause_ref(Ref,Ref1),
  714  assert(M:ref_clause(r(Ref1,RefP,Score))).
  715
  716store_refinement(M,Ref,RefP,Score):-
  717  elab_ref(Ref,Ref1),
  718  assert(M:ref(r(Ref1,RefP,Score))).
  719
  720already_scored_clause(M,R,R1,Score):-
  721  elab_ref([R],[rule(H,B)]),
  722  M:ref_clause(r(rule(H,B1),R1,Score)),
  723  permutation(B,B1).
  724
  725already_scored(M,R,R1,Score):-
  726  elab_ref(R,RR),
  727  M:ref(r(RR,R1,Score)).
  728
  729
  730elab_clause_ref(rule(_NR,H,B,_Lits,_Tun),rule(H1,B1)):-
  731  copy_term((H,B),(H1,B1)).
  732
  733elab_ref([],[]).
  734
  735elab_ref([rule(_NR,H,B,_Lits,_Tun)|T],[rule(H1,B1)|T1]):-!,
  736  copy_term((H,B),(H1,B1)),
  737  numbervars((H1,B1),0,_N),
  738  elab_ref(T,T1).
  739
  740elab_ref([def_rule(H,B,_Lits)|T],[rule(H1,B1)|T1]):-
  741  copy_term((H,B),(H1,B1)),
  742  numbervars((H1,B1),0,_N),
  743  elab_ref(T,T1).
  744
  745% insertion in the beam
  746insert_in_order([],C,BeamSize,[C]):-
  747  BeamSize>0,!.
  748
  749insert_in_order(Beam,_New,0,Beam):-!.
  750
  751insert_in_order([(Th1,Heuristic1)|RestBeamIn],(Th,Heuristic),BeamSize,BeamOut):-
  752  Heuristic>Heuristic1,!,
  753  % larger heuristic, insert here
  754  NewBeam=[(Th,Heuristic),(Th1,Heuristic1)|RestBeamIn],
  755  length(NewBeam,L),
  756  (L>BeamSize->
  757    nth1(L,NewBeam,_Last,BeamOut)
  758  ;
  759    BeamOut=NewBeam
  760  ).
  761
  762insert_in_order([(Th1,Heuristic1)|RestBeamIn],(Th,Heuristic),BeamSize,
  763[(Th1,Heuristic1)|RestBeamOut]):-
  764  BeamSize1 is BeamSize -1,
  765  insert_in_order(RestBeamIn,(Th,Heuristic),BeamSize1,
  766  RestBeamOut).
  767
  768
  769
  770remove_int_atom_list([],[]).
  771
  772remove_int_atom_list([\+ A|T],[\+ A1|T1]):-!,
  773  A=..[F,_|Arg],
  774  A1=..[F|Arg],
  775  remove_int_atom_list(T,T1).
  776
  777remove_int_atom_list([A|T],[A1|T1]):-
  778  A=..[F,_|Arg],
  779  A1=..[F|Arg],
  780  remove_int_atom_list(T,T1).
  781
  782
  783
  784remove_int_atom(\+ A,\+ A1):-!,
  785  A=..[F,_|T],
  786  A1=..[F|T].
  787
  788remove_int_atom(A,A1):-
  789  A=..[F,_|T],
  790  A1=..[F|T].
  791
  792
  793get_heads([],[]).
  794
  795get_heads([_-H|T],[H|TN]):-
  796
  797  get_heads(T,TN).
  798
  799derive_bdd_nodes([],_M,_ExData,_E,Nodes,Nodes,CLL,CLL).
  800
  801derive_bdd_nodes([H|T],M,ExData,E,Nodes0,Nodes,CLL0,CLL):-
  802  get_output_atoms(O,M),
  803  generate_goal(O,M,H,[],GL),
  804  (M:'$prob'(H,P)->
  805    CardEx is P*E
  806
  807  ;
  808    CardEx is 1.0
  809  ),
  810  init_ex(ExData,Env),
  811  one(Env,One),
  812  get_node_list(GL,M,Env,One,BDD,CardEx),
  813  ret_prob(Env,BDD,HP),
  814  (HP=:=0.0->
  815    setting_sc(logzero,LZ),
  816    CLL1 is CLL0+LZ*CardEx
  817  ;
  818    CLL1 is CLL0+log(HP)*CardEx
  819  ),
  820  end_ex(ExData),
  821  append(Nodes0,[[BDD,CardEx]],Nodes1),
  822  derive_bdd_nodes(T,M,ExData,E,Nodes1,Nodes,CLL1,CLL).
  823
  824
  825get_node_list([],_M,_Env,BDD,BDD,_CE).
  826
  827
  828get_node_list([H|T],M,Env,BDD0,BDD,CE):-
  829  get_node(H,M,Env,BDD1),
  830  and(Env,BDD0,BDD1,BDD2),
  831  get_node_list(T,M,Env,BDD2,BDD,CE).
  832
  833
  834derive_bdd_nodes_groupatoms_output_atoms([],_M,_ExData,_O,_E,_G,Nodes,Nodes,CLL,CLL,LE,LE).
  835
  836derive_bdd_nodes_groupatoms_output_atoms([H|T],M,ExData,O,E,G,Nodes0,Nodes,CLL0,CLL,LE0,LE):-
  837  generate_goal(O,M,H,[],GL),
  838  length(GL,NA),
  839  (M:'$prob'(H,P)->
  840    CardEx is P*E/NA
  841  ;
  842    CardEx is 1.0
  843  ),
  844  get_node_list_groupatoms(GL,M,ExData,BDDs,CardEx,G,CLL0,CLL1,LE0,LE1),
  845  append(Nodes0,BDDs,Nodes1),
  846  derive_bdd_nodes_groupatoms_output_atoms(T,M,ExData,O,E,G,Nodes1,Nodes,CLL1,CLL,LE1,LE).
  847
  848
  849derive_bdd_nodes_groupatoms([],_M,_ExData,_E,_G,Nodes,Nodes,CLL,CLL,LE,LE).
  850
  851derive_bdd_nodes_groupatoms([H|T],M,ExData,E,G,Nodes0,Nodes,CLL0,CLL,LE0,LE):-
  852  get_output_atoms(O,M),
  853  generate_goal(O,M,H,[],GL),
  854  length(GL,NA),
  855  (M:'$prob'(H,P)->
  856    CardEx is P*E/NA
  857  ;
  858    CardEx is 1.0
  859  ),
  860  get_node_list_groupatoms(GL,M,ExData,BDDs,CardEx,G,CLL0,CLL1,LE0,LE1),
  861  append(Nodes0,BDDs,Nodes1),
  862  derive_bdd_nodes_groupatoms(T,M,ExData,E,G,Nodes1,Nodes,CLL1,CLL,LE1,LE).
  863
  864get_node_list_groupatoms([],_M,_ExData,[],_CE,_Gmax,CLL,CLL,LE,LE).
  865
  866get_node_list_groupatoms([H|T],M,ExData,[[BDD,CE1]|BDDT],CE,Gmax,CLL0,CLL,LE0,LE):-
  867  init_ex(ExData,Env),
  868  one(Env,One),
  869  get_bdd_group([H|T],M,Env,T1,Gmax,G,One,BDD,CE,LE0,LE1),  %output:BDD,CLL
  870  CE1 is CE*(Gmax-G),
  871  ret_prob(Env,BDD,HP),
  872  end_ex(ExData),
  873  (HP =:=0.0->
  874    M:local_setting(logzero,LZ),
  875    CLL2 is CLL0+LZ*CE1
  876  ;
  877    CLL2 is CLL0+log(HP)*CE1
  878  ),
  879  get_node_list_groupatoms(T1,M,ExData,BDDT,CE,Gmax,CLL2,CLL,LE1,LE).
  880
  881
  882get_bdd_group([],_M,_Env,[],G,G,BDD,BDD,_CE,LE,LE):-!.
  883
  884get_bdd_group(T,_M,_Env,T,0,0,BDD,BDD,_CE,LE,LE):- !.
  885
  886get_bdd_group([H|T],M,Env,T1,Gmax,G1,BDD0,BDD,CE,[H|LE0],LE):-
  887  get_node(H,M,Env,BDD1),		%creates the BDD for atom H
  888  and(Env,BDD0,BDD1,BDD2),
  889  G is Gmax-1,
  890  get_bdd_group(T,M,Env,T1,G,G1,BDD2,BDD,CE,LE0,LE).
  891
  892get_arg(_-A,A).
  893
  894/* EM start */
  895random_restarts(0,_M,_ExData,_Nodes,Score,Score,Par,Par,_LE):-!.
  896
  897random_restarts(N,M,ExData,Nodes,Score0,Score,Par0,Par,LE):-
  898  M:local_setting(random_restarts_number,NMax),
  899  Num is NMax-N+1,
  900  format3(M,"Restart number ~d~n~n",[Num]),
  901  findall(R-Info,get_rule_info_rand(M,R-Info),L),
  902  keysort(L,LS),
  903  maplist(get_arg,LS,LS1),
  904  M:local_setting(epsilon_em,EA),
  905  M:local_setting(epsilon_em_fraction,ER),
  906  M:local_setting(iter,Iter),
  907  M:local_setting(alpha,Alpha),
  908  initial_values(ExData,Alpha),
  909  em(ExData,LS1,Nodes,EA,ER,Iter,CLL,Par1,ExP),
  910  score(M,LE,ExP,CLL,ScoreR),
  911  format3(M,"Random_restart: Score ~f~n",[ScoreR]),
  912  N1 is N-1,
  913  (ScoreR>Score0->
  914    random_restarts(N1,M,ExData,Nodes,ScoreR,Score,Par1,Par,LE)
  915  ;
  916    random_restarts(N1,M,ExData,Nodes,Score0,Score,Par0,Par,LE)
  917  ).
  918
  919random_restarts_ref(0,_M,_ExData,_Nodes,Score,Score,Par,Par,_LE):-!.
  920
  921random_restarts_ref(N,M,ExData,Nodes,Score0,Score,Par0,Par,LE):-
  922  M:local_setting(random_restarts_REFnumber,NMax),
  923  Num is NMax-N+1,
  924  format3(M,"Restart number ~d~n~n",[Num]),
  925  findall(R-Info,get_rule_info_rand(M,R-Info),L),
  926  keysort(L,LS),
  927  maplist(get_arg,LS,LS1),
  928  M:local_setting(epsilon_em,EA),
  929  M:local_setting(epsilon_em_fraction,ER),
  930  M:local_setting(iterREF,Iter),
  931  M:local_setting(alpha,Alpha),
  932  initial_values(ExData,Alpha),
  933  em(ExData,LS1,Nodes,EA,ER,Iter,CLLR,Par1,ExP),
  934  score(M,LE,ExP,CLLR,ScoreR),
  935  format3(M,"Random_restart: Score ~f~n",[ScoreR]),
  936  N1 is N-1,
  937  (ScoreR>Score0->
  938    random_restarts_ref(N1,M,ExData,Nodes,ScoreR,Score,Par1,Par,LE)
  939  ;
  940    random_restarts_ref(N1,M,ExData,Nodes,Score0,Score,Par0,Par,LE)
  941  ).
  942
  943
  944score(M,_LE,_ExP,CLL,CLL):-
  945  M:local_setting(score,ll),!.
  946
  947score(_M,LE,ExP,_CLL,Score):-
  948  compute_prob(LE,ExP,LPU,0,Pos,0,Neg),
  949  keysort(LPU,LPO),
  950  reverse(LPO,LP),
  951  compute_aucpr(LP,Pos,Neg,Score).
  952
  953
  954compute_prob([],[],[],Pos,Pos,Neg,Neg).
  955
  956compute_prob([\+ HE|TE],[HP|TP],[P- (\+ HE)|T],Pos0,Pos,Neg0,Neg):-!,
  957  P is 1.0-HP,
  958  Neg1 is Neg0+1,
  959  compute_prob(TE,TP,T,Pos0,Pos,Neg1,Neg).
  960
  961compute_prob([ HE|TE],[HP|TP],[HP-  HE|T],Pos0,Pos,Neg0,Neg):-
  962  Pos1 is Pos0+1,
  963  compute_prob(TE,TP,T,Pos1,Pos,Neg0,Neg).
  964
  965
  966compute_aucpr(L,Pos,Neg,A):-
  967  L=[P_0-E|TL],
  968  (E= (\+ _ )->
  969    FP=1,
  970    TP=0,
  971    FN=Pos,
  972    TN is Neg -1
  973  ;
  974    FP=0,
  975    TP=1,
  976    FN is Pos -1,
  977    TN=Neg
  978  ),
  979  compute_curve_points(TL,P_0,TP,FP,FN,TN,Points),
  980  Points=[R0-P0|_TPoints],
  981  (R0=:=0,P0=:=0->
  982    Flag=true
  983  ;
  984    Flag=false
  985  ),
  986  area(Points,Flag,Pos,0,0,0,A).
  987
  988compute_curve_points([],_P0,TP,FP,_FN,_TN,[1.0-Prec]):-!,
  989  Prec is TP/(TP+FP).
  990
  991compute_curve_points([P- (\+ _)|T],P0,TP,FP,FN,TN,Pr):-!,
  992  (P<P0->
  993    Prec is TP/(TP+FP),
  994    Rec is TP/(TP+FN),
  995    Pr=[Rec-Prec|Pr1],
  996    P1=P
  997  ;
  998    Pr=Pr1,
  999    P1=P0
 1000  ),
 1001  FP1 is FP+1,
 1002  TN1 is TN-1,
 1003  compute_curve_points(T,P1,TP,FP1,FN,TN1,Pr1).
 1004
 1005compute_curve_points([P- _|T],P0,TP,FP,FN,TN,Pr):-!,
 1006  (P<P0->
 1007    Prec is TP/(TP+FP),
 1008    Rec is TP/(TP+FN),
 1009    Pr=[Rec-Prec|Pr1],
 1010    P1=P
 1011  ;
 1012    Pr=Pr1,
 1013    P1=P0
 1014  ),
 1015  TP1 is TP+1,
 1016  FN1 is FN-1,
 1017  compute_curve_points(T,P1,TP1,FP,FN1,TN,Pr1).
 1018
 1019area([],_Flag,_Pos,_TPA,_FPA,A,A).
 1020
 1021area([R0-P0|T],Flag,Pos,TPA,FPA,A0,A):-
 1022 TPB is R0*Pos,
 1023  (TPB=:=0->
 1024    A1=A0,
 1025    FPB=0
 1026  ;
 1027    R_1 is TPA/Pos,
 1028    (TPA=:=0->
 1029      (Flag=false->
 1030        P_1=P0
 1031      ;
 1032        P_1=0.0
 1033      )
 1034    ;
 1035      P_1 is TPA/(TPA+FPA)
 1036    ),
 1037    FPB is TPB*(1.0-P0)/P0,
 1038    N is TPB-TPA+0.5,
 1039    interpolate(1,N,Pos,R_1,P_1,TPA,FPA,TPB,FPB,A0,A1)
 1040  ),
 1041  area(T,Flag,Pos,TPB,FPB,A1,A).
 1042
 1043interpolate(I,N,_Pos,_R0,_P0,_TPA,_FPA,_TPB,_FPB,A,A):-I>N,!.
 1044
 1045interpolate(I,N,Pos,R0,P0,TPA,FPA,TPB,FPB,A0,A):-
 1046  R is (TPA+I)/Pos,
 1047  P is (TPA+I)/(TPA+I+FPA+(FPB-FPA)/(TPB-TPA)*I),
 1048  A1 is A0+(R-R0)*(P+P0)/2,
 1049  I1 is I+1,
 1050  interpolate(I1,N,Pos,R,P,TPA,FPA,TPB,FPB,A1,A).
 1051
 1052
 1053
 1054update_head([],[],_N,[]):-!.
 1055
 1056update_head([H:_P|T],[PU|TP],N,[H:P|T1]):-
 1057  P is PU/N,
 1058  update_head(T,TP,N,T1).
 1059
 1060
 1061/* EM end */
 1062
 1063
 1064/* utilities */

 rules2terms(:R:list_of_rules, -T:tern) is det

The predicate translates a list of rules from the internal representation format (rule/4 and def_rule/3) to the LPAD syntax.

 1072rules2terms(R,T):-
 1073  maplist(rule2term,R,T).
 1074
 1075rule2term(rule(_N,HL,BL,_Lit,_Tun),(H:-B)):-
 1076  list2or(HL,H),
 1077  list2and(BL,B).
 1078
 1079rule2term(def_rule(H,BL,_Lit),((H:1.0):-B)):-
 1080  list2and(BL,B).
 1081
 1082
 1083write_rules([],_S).
 1084
 1085write_rules([rule(_N,HL,BL,Lit,_Tun)|T],S):-!,
 1086  copy_term((HL,BL,Lit),(HL1,BL1,Lit1)),
 1087  numbervars((HL1,BL1,Lit1),0,_M),
 1088  write_disj_clause(S,(HL1:-BL1)),
 1089  write_rules(T,S).
 1090
 1091write_rules([def_rule(H,BL,Lit)|T],S):-
 1092  copy_term((H,BL,Lit),(H1,BL1,Lit1)),
 1093  numbervars((H1,BL1,Lit1),0,_M),
 1094  write_disj_clause(S,([H1:1.0]:-BL1)),
 1095  write_rules(T,S).
 1096
 1097
 1098new_par([],[],[]).
 1099
 1100new_par([HP|TP],[Head:_|TO],[Head:HP|TN]):-
 1101  new_par(TP,TO,TN).
 1102
 1103
 1104
 1105write_disj_clause(S,(H:-[])):-!,
 1106  write_head(S,H),
 1107  format(S,".~n~n",[]).
 1108
 1109write_disj_clause(S,(H:-B)):-
 1110  write_head(S,H),
 1111  format(S,' :-',[]),
 1112  nl(S),
 1113  write_body(S,B).
 1114
 1115
 1116write_head(S,[A:1.0|_Rest]):-!,
 1117  format(S,"~q:1.0",[A]).
 1118
 1119write_head(S,[A:P,'':_P]):-!,
 1120  format(S,"~q:~g",[A,P]).
 1121
 1122write_head(S,[A:P]):-!,
 1123  format(S,"~q:~g",[A,P]).
 1124
 1125write_head(S,[A:P|Rest]):-
 1126  format(S,"~q:~g ; ",[A,P]),
 1127  write_head(S,Rest).
 1128
 1129write_body(S,[]):-!,
 1130  format(S,"  true.~n~n",[]).
 1131
 1132write_body(S,[A]):-!,
 1133  format(S,"  ~q.~n~n",[A]).
 1134
 1135write_body(S,[A|T]):-
 1136  format(S,"  ~q,~n",[A]),
 1137  write_body(S,T).

 list2or(+List:list, -Or:term) is det

list2or(-List:list, +Or:term) is det

The predicate succeeds when Or is a disjunction (using the ; operator) of the terms in List

 1146list2or([],true):-!.
 1147
 1148list2or([X],X):-
 1149    X\=;(_,_),!.
 1150
 1151list2or([H|T],(H ; Ta)):-!,
 1152    list2or(T,Ta).

 list2and(+List:list, -And:term) is det

list2and(-List:list, +And:term) is det

The predicate succeeds when And is a conjunction (using the , operator) of the terms in List

 1162list2and([],true):-!.
 1163
 1164list2and([X],X):-
 1165    X\=(_,_),!.
 1166
 1167list2and([H|T],(H,Ta)):-!,
 1168    list2and(T,Ta).
 1169
 1170
 1171deduct(0,_Mod,_DB,Th,Th):-!.
 1172
 1173deduct(NM,Mod,DB,InTheory0,InTheory):-
 1174  get_head_atoms(O,Mod),
 1175  sample(1,DB,Sampled,DB1),
 1176  (Sampled=[M]->
 1177    generate_head(O,M,Mod,[],HL),
 1178    NM1 is NM-1,
 1179    ( HL \== [] ->
 1180       (generate_body(HL,Mod,InTheory1),
 1181	append(InTheory0,InTheory1,InTheory2),
 1182	deduct(NM1,Mod,DB1,InTheory2,InTheory)
 1183       )
 1184      ;
 1185       deduct(NM1,Mod,DB1,InTheory0,InTheory)
 1186    )
 1187  ;
 1188    InTheory=InTheory0
 1189  ).
 1190
 1191
 1192get_head_atoms(O,M):-
 1193  findall(A,M:modeh(_,A),O0),
 1194  findall((A,B,D),M:modeh(_,A,B,D),O1),
 1195  append(O0,O1,O).
 1196
 1197generate_top_cl([],_M,[]):-!.
 1198
 1199generate_top_cl([A|T],M,[(rule(R,[A1:0.5,'':0.5],[],true,tunable),-1e20)|TR]):-
 1200  A=..[F|ArgM],
 1201  keep_const(ArgM,Arg),
 1202  A1=..[F|Arg],
 1203  get_next_rule_number(M,R),
 1204  generate_top_cl(T,M,TR).
 1205
 1206
 1207generate_head([],_M,_Mod,HL,HL):-!.
 1208
 1209generate_head([(A,G,D)|T],M,Mod,H0,H1):-!,
 1210  generate_head_goal(G,M,Goals),
 1211  findall((A,Goals,D),(member(Goal,Goals),call(Mod:Goal),ground(Goals)),L),
 1212  Mod:local_setting(initial_clauses_per_megaex,IC),   %IC: represents how many samples are extracted from the list L of example
 1213  sample(IC,L,L1),
 1214  append(H0,L1,H2),
 1215  generate_head(T,M,Mod,H2,H1).
 1216
 1217generate_head([A|T],M,Mod,H0,H1):-
 1218  functor(A,F,N),
 1219  functor(F1,F,N),
 1220  F1=..[F|Arg],
 1221  Pred1=..[F,M|Arg],
 1222  A=..[F|ArgM],
 1223  keep_const(ArgM,Arg),
 1224  findall((A,Pred1),call(Mod:Pred1),L),
 1225  Mod:local_setting(initial_clauses_per_megaex,IC),
 1226  sample(IC,L,L1),
 1227  append(H0,L1,H2),
 1228  generate_head(T,M,Mod,H2,H1).
 1229
 1230generate_head_goal([],_M,[]).
 1231
 1232generate_head_goal([H|T],M,[H1|T1]):-
 1233  H=..[F|Arg],
 1234  H1=..[F,M|Arg],
 1235  generate_head_goal(T,M,T1).
 1236
 1237keep_const([],[]).
 1238
 1239keep_const([- _|T],[_|T1]):-!,
 1240  keep_const(T,T1).
 1241
 1242keep_const([+ _|T],[_|T1]):-!,
 1243  keep_const(T,T1).
 1244
 1245keep_const([-# _|T],[_|T1]):-!,
 1246  keep_const(T,T1).
 1247
 1248keep_const([H|T],[H1|T1]):-
 1249  H=..[F|Args],
 1250  keep_const(Args,Args1),
 1251  H1=..[F|Args1],
 1252  keep_const(T,T1).