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  M:in(R00),
  457  process_clauses(R00,M,[],_,[],R0),
  458  statistics(walltime,[_,_]),
  459  learn_params(DB,M,R0,R,Score),
  460  statistics(walltime,[_,CT]),
  461  CTS is CT/1000.0,
  462  format2(M,'/* EMBLEM Final score ~f~n',[Score]),
  463  format2(M,'Wall time ~f */~n',[CTS]),
  464  write_rules2(M,R,user_output),
  465  set_sc(M:compiling,off),
  466  (M:bg(RBG0)->
  467    retract_all(ThBGRef),
  468    retract_all(ClBGRef)
  469  ;
  470    true
  471  ),
  472  clean_up_db(M).
  473
  474clean_up_db(M):-
  475  retract(M:rule_sc_n(_)),
  476  assert(M:rule_sc_n(0)),
  477  retract(M:rule_ng_sc_n(_)),
  478  assert(M:rule_ng_sc_n(0)),
  479  retractall(M:v(_,_,_)),
  480  retractall(M:database(_)).
  481
  482get_rule_info(M,RI-Info):-
  483  M:rule(R,HL,_BL,_Lit,Tun),
  484  R\= ng(_,_),
  485  (R=g(RI)->
  486    true
  487  ;
  488    RI=R
  489  ),
  490  length(HL,N),
  491  ((Tun=tunable;Tun=initial)->
  492    Info=N
  493  ;
  494    Info=[N]
  495  ).
  496
  497get_rule_info_rand(M,RI-Info):-
  498  M:rule(R,HL,_BL,_Lit,Tun),
  499  R\= ng(_,_),
  500  (R=g(RI)->
  501    true
  502  ;
  503    RI=R
  504  ),
  505  length(HL,N),
  506  (Tun=tunable->
  507    Info=N
  508  ;
  509    get_probs(HL,Info0),
  510    (Tun=initial->
  511      Info=Info0
  512    ; % fixed parameters
  513      Info=[Info0]
  514    )
  515  ).

 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. /

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

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

 1144list2or([],true):-!.
 1145
 1146list2or([X],X):-
 1147    X\=;(_,_),!.
 1148
 1149list2or([H|T],(H ; Ta)):-!,
 1150    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 /

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