slipcover

   16/*
   17
   18SLIPCOVER
   19
   20Copyright (c) 2016, Fabrizio Riguzzi and Elena Bellodi
   21
   22*/
   23:-module(liftcover,[set_lift/2,setting_lift/2,
   24  induce_lift/2,induce_par_lift/2,test_lift/7,
   25  filter_rules/2,filter_rules/3,sort_rules/2,
   26  remove_zero/2,
   27  op(500,fx,#),op(500,fx,'-#'),
   28  test_prob_lift/6,
   29  prob_lift/2,prob_lift/3,
   30  explain_lift/2,explain_lift/3,
   31  ranked_answers/3,
   32  ranked_answers/4,
   33  rank/3,
   34  rank_answer/3,
   35  rank_answer/4,
   36  hits_at_k/6,
   37  hits_at_k/7,
   38  rank_ex/3,
   39  rank_exs/4,
   40  inst_exs/4,
   41  induce_par_kg/2,
   42  induce_par_pos_kg/2,
   43  compute_stats_kg/2,
   44  compute_stats_pos_kg/2,
   45  compute_par_kg/3,
   46  write_rules_kg/1,
   47  write_rules_kg/2,
   48  write_rules_anyburl/2,
   49  read_rules_anyburl/2,
   50  rules_for_rel/3
   51  ]).   52:-use_module(library(auc)).   53:-use_module(library(lists)).   54:-use_module(library(random)).   55:-use_module(library(system)).   56:-use_module(library(terms)).   57:-use_module(library(ordsets)).   58:-use_module(library(apply)).   59:-use_module(library(settings)).   60:-use_module(library(clpfd), [transpose/2]).   61
   62:-use_module(library(dcg/basics)).   63:-absolute_file_name(library(lbfgs),F,[solutions(all)]),atomic_concat(F,'.pl',Fpl),exists_file(Fpl),use_module(library(lbfgs));true.   64%:-use_foreign_library(foreign(bddem),install).
   65:-set_prolog_flag(unknown,warning).   66
   67%:-multifile setting_lift/2.
   68%:-use_module(library(sandbox)).
   69
   70
   71:- dynamic lift_input_mod/1.   72
   73
   74:- thread_local v/3, lift_input_mod/1, local_setting/2, rule_lift_n/1.   75
   76:- meta_predicate induce_lift(:,-).   77:- meta_predicate induce_rules(:,-).   78:- meta_predicate induce_par_lift(:,-).   79:- meta_predicate induce_parameters(:,-).   80
   81
   82
   83:- meta_predicate test_lift(:,+,-,-,-,-,-).   84:- meta_predicate test_prob_lift(:,+,-,-,-,-).   85:- meta_predicate prob_lift(:,-).   86:- meta_predicate prob_lift(:,+,-).   87:- meta_predicate explain_lift(:,-).   88:- meta_predicate explain_lift(:,+,-).   89:- meta_predicate ranked_answers(:,-,-).   90:- meta_predicate ranked_answers(:,-,+,-).   91:- meta_predicate rank_answer(:,+,-).   92:- meta_predicate rank_answer(:,+,+,-).   93:- meta_predicate hits_at_k(:,+,+,+,-,-).   94:- meta_predicate hits_at_k(:,+,+,+,+,-,-).   95:- meta_predicate rank_ex(:,+,+).   96:- meta_predicate rank_exs(:,+,+,+).   97:- meta_predicate inst_exs(:,+,+,+).   98:- meta_predicate set_lift(:,+).   99:- meta_predicate setting_lift(:,-).  100:- meta_predicate filter_rules(:,-).  101
  102:- meta_predicate induce_par_kg(:,-).  103:- meta_predicate induce_par_pos_kg(:,-).  104:- meta_predicate compute_stats_kg(:,+).  105:- meta_predicate compute_stats_pos_kg(:,+).  106:- meta_predicate compute_par_kg(:,+,-).  107:- meta_predicate rules_for_rel(:,+,-).  108
  109
  110
  111:- setting(max_threads, integer, 256,
  112    'Maximum number of threads to use in scoring clause refinements and parameter learning').  113:- setting(allow_gpu, boolean, true,
  114    'Whether the use of GPU is allowed').  115
  116
  117
  118default_setting_lift(eps,0.0001).
  119default_setting_lift(eps_f,0.00001).
  120
  121
  122default_setting_lift(random_restarts_number,1). % number of random restarts of parameter learning
  123default_setting_lift(random_restarts_number_str_learn,1). % number of random restarts during structure learning of parameter learning for single clauses
  124default_setting_lift(iter,100).
  125default_setting_lift(d,1).
  126default_setting_lift(verbosity,1).
  127default_setting_lift(logzero,log(0.000001)).
  128default_setting_lift(megaex_bottom,1).
  129default_setting_lift(initial_clauses_per_megaex,1).
  130default_setting_lift(max_iter,10).
  131default_setting_lift(max_var,4).
  132default_setting_lift(maxdepth_var,2).
  133default_setting_lift(beamsize,100).
  134default_setting_lift(max_clauses,1000).
  135default_setting_lift(max_body_length,100).
  136default_setting_lift(neg_literals,false).
  137
  138default_setting_lift(specialization,bottom).
  139/* allowed values: mode,bottom */
  140
  141default_setting_lift(seed,rand(10,1231,3032)).
  142default_setting_lift(neg_ex,cw).
  143
  144
  145default_setting_lift(epsilon_parsing, 1e-5).
  146
  147
  148
  149
  150default_setting_lift(zero,0.000001).
  151default_setting_lift(minus_infinity,-1.0e20).
  152
  153default_setting_lift(regularization,l1). % regularization: no, l1, l2, bayesian 
  154default_setting_lift(gamma,10). % set the value of gamma for regularization l1 and l2
  155default_setting_lift(ab,[0,10]). % set the value of a and b for regularization baysian
  156default_setting_lift(min_probability,1e-5).  % Threshold of the probability under which the clause is dropped
  157default_setting_lift(parameter_learning,em). % parameter learning algorithm: em_python, em, lbfgs, gd_python, gd 
  158default_setting_lift(max_initial_weight,0.5). % initial weights of dphil in [-0.5 0.5]
  159
  160default_setting_lift(parameter_update,fixed_learning_rate). % values: fixed_learning_rate,adam
  161default_setting_lift(eta,0.01). % fixed learning rate
  162default_setting_lift(adam_params,[0.001,0.9,0.999,1e-8]). % default Adam hyper-pameters
  163default_setting_lift(processor,cpu). % where to run em_python and gd_python: cpu or gpu
  164default_setting_lift(threads,1). % number of threads to use in scoring clause refinements and parameter learning
  165default_setting_lift(single_var,false). %false:1 variable for every grounding of a rule; true: 1 variable for rule (even if a rule has more groundings),simpler.

 induce_lift(: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. /

  175induce_lift(TrainFolds,P):-
  176  induce_rules(TrainFolds,P0),
  177  rules2terms(P0,P).

 test_lift(: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 /

  188test_lift(P,TestFolds,LL,AUCROC,ROC,AUCPR,PR):-
  189  test_prob_lift(P,TestFolds,_NPos,_NNeg,LL,LG),
  190  compute_areas_diagrams(LG,AUCROC,ROC,AUCPR,PR).

 test_prob_lift(: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. /

  201test_prob_lift(M:P,TestFolds,NPos,NNeg,CLL,Results) :-
  202  write2(M,'Testing\n'),
  203  make_dynamic(M),
  204  process_clauses(P,M,PRules),
  205  generate_clauses(PRules,M,0,Prog),
  206  (M:bg(RBG0)->
  207    process_clauses(RBG0,M,RBG),
  208    generate_clauses_bg(RBG,ClBG),
  209    assert_all(ClBG,M,ClBGRef)
  210  ;
  211    true
  212  ),
  213  findall(Exs,(member(F,TestFolds),M:fold(F,Exs)),L),
  214  append(L,DB),
  215  test_no_area(DB,M,Prog,NPos,NNeg,CLL,Results),
  216  (M:bg(RBG0)->
  217    retract_all(ClBGRef)
  218  ;
  219    true
  220  ).
  221
  222induce_rules(M:Folds,R):-
  223  load_python_module(M),
  224  make_dynamic(M),
  225  M:local_setting(seed,Seed),
  226  setrand(Seed),
  227  findall(Exs,(member(F,Folds),M:fold(F,Exs)),L),
  228  append(L,DB),
  229  (M:bg(RBG0)->
  230    process_clauses(RBG0,M,RBG),
  231    generate_clauses_bg(RBG,ClBG),
  232    assert_all(ClBG,M,ClBGRef)
  233  ;
  234    true
  235  ),
  236  find_ex(DB,M,Pos,Neg,NPos,_Neg),
  237  M:local_setting(megaex_bottom, NumMB),
  238  (NPos >= NumMB ->
  239      true
  240    ;
  241      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", []),
  242      M:set_lift(megaex_bottom, NPos)
  243  ),
  244  statistics(walltime,[_,_]),
  245  (M:local_setting(specialization,bottom)->
  246    M:local_setting(megaex_bottom,MB),
  247    deduct(MB,M,DB,[],InitialTheory),
  248    remove_duplicates(InitialTheory,R1)
  249  ;
  250    get_head_atoms(O,M),
  251    generate_top_cl(O,M,R1)
  252  ),
  253  learn_struct(Pos,Neg,M,R1,R2,Score),
  254  sort_rules_int(R2,R),
  255  statistics(walltime,[_,WT]),
  256  WTS is WT/1000,
  257  write2(M,'\n\n'),
  258  format2(M,'/* Final score ~f~n',[Score]),
  259  format2(M,'Wall time ~f */~n',[WTS]),
  260  write_rules2(M,R,user_output),
  261  (M:bg(RBG0)->
  262    retract_all(ClBGRef)
  263  ;
  264    true
  265  ),
  266  retractall(M:ref_clause(_)),
  267  retractall(M:ref(_)).

 sort_rules(+RulesIn:list_of_rules, -RulesOut:list_of_rules) is det

The predicate sorts RulesIn according to the probability of the rules /

  274sort_rules(R0,R):-
  275  rules2terms(P0,R0),
  276  sort_rules_int(P0,P),
  277  rules2terms(P,R).
  278
  279sort_rules_int(P0,P):-
  280  maplist(to_pair,P0,P1),
  281  sort(1,@>=,P1,P2),
  282  maplist(to_pair,P,P2).
  283
  284to_pair(rule(N,[H:P|R],BL,Lit),P-rule(N,[H:P|R],BL,Lit)).
  285
  286
  287make_dynamic(M):-
  288  M:(dynamic int/1),
  289  findall(O,M:output(O),LO),
  290  findall(I,M:input(I),LI),
  291  findall(I,M:input_cw(I),LIC),
  292  findall(D,M:determination(D,_DD),LDH),
  293  findall(DD,M:determination(_D,DD),LDD),
  294  findall(DH,(M:modeh(_,_,_,LD),member(DH,LD)),LDDH),
  295  append([LO,LI,LIC,LDH,LDD,LDDH],L0),
  296  remove_duplicates(L0,L),
  297  maplist(to_dyn(M),L).
  298
  299to_dyn(M,P/A):-
  300  A1 is A+1,
  301  M:(dynamic P/A1),
  302  A2 is A1+1,
  303  M:(dynamic P/A2).
  304
  305
  306
  307learn_struct(Pos,Neg,Mod,Beam,R,Score):-  %+Beam:initial theory of the form [rule(NR,[h],[b]],...], -R:final theory of the same form, -CLL
  308  format2(Mod,"Clause search~n~n",[]),
  309  Mod:local_setting(max_iter,M),
  310  Mod:local_setting(beamsize,BS),
  311  Mod:local_setting(max_clauses,MC),
  312  cycle_beam(Beam,Mod,Pos,Neg,[],CL,0,M,BS,MC),
  313  maplist(get_cl,CL,LC,MIC,MINC),
  314  maplist(append,MIC,MIC1),
  315  transpose(MIC1,MI),
  316  append(MINC,MIN),
  317  length(LC,NumCL),
  318  write2(Mod,"Final parameter learning"),nl2(Mod),
  319  Mod:local_setting(random_restarts_number,RR),
  320  learn_param_int(MI,MIN,NumCL,Mod,RR,Par,Score),
  321  update_theory(LC,Par,Program1),
  322  remove_zero(Program1,R),
  323  format2(Mod,"Best target theory~n~n",[]),
  324  write_rules2(Mod,R,user_output).
  325
  326get_cl(c(_,C,[MI,MIN]),C,MI,MIN).
  327
  328pick_first(0,_,[]):-!.
  329
  330pick_first(_,[],[]):-!.
  331
  332pick_first(N,[(H,_S)|T],[H|T1]):-
  333  N1 is N-1,
  334  pick_first(N1,T,T1).
  335
  336remove_score([],[]).
  337
  338remove_score([(H,_S)|T],[H|T1]):-
  339  remove_score(T,T1).
  340
  341init_gd_par(0,_Max,[]):-!.
  342
  343init_gd_par(I,Max,[W|TW]):-
  344  I1 is I-1,
  345  W is -Max+random_float*2*Max,
  346  init_gd_par(I1,Max,TW).
  347
  348init_par(_Env,0):-!.
  349
  350init_par(Env,I):-
  351  I1 is I-1,
  352  optimizer_set_x(Env,I1,0.5),
  353  init_par(Env,I1).
  354
  355evaluate_L(Env,M,MIP,MI,L):-
  356  compute_likelihood_pos(MIP,Env,M,0,0,LP),
  357  compute_likelihood_neg(MI,Env,M,LN),
  358  compute_likelihood(LN,M,LP,L).
  359  
  360gen_initial_counts(0,[]):-!.
  361
  362gen_initial_counts(N0,[0|MIP0]):-
  363  N1 is N0-1,
  364  gen_initial_counts(N1,MIP0).
  365
  366evaluate(Env,L,_N,_Step,[M,MIP,MI]):-
  367%  M:mip(MIP),
  368%  M:mi(MI),
  369  compute_likelihood_pos(MIP,Env,M,0,0,LP),
  370  compute_likelihood_neg(MI,Env,M,LN),
  371  compute_likelihood(LN,M,LP,L),
  372  compute_grad(MIP,Env,M,0,MI,LN).
  373
  374compute_grad([],_Env,_M,_N,_MI,_LN):-!.
  375
  376compute_grad([HMIP|TMIP],Env,M,N0,MI,LN):-
  377  compute_sum_neg(MI,M,LN,N0,0,S),
  378  optimizer_get_x(Env,N0,P0),
  379  M:local_setting(zero,Zero),
  380  (P0=<0 ->
  381    PI=Zero
  382  ;
  383    (P0>=1.0->
  384       PI is 1.0-Zero
  385     ;
  386       PI=P0
  387     )
  388  ),
  389
  390 (PI=:= 1.0->
  391    G is 1.0/Zero
  392  ;
  393    G is (HMIP-S)/(1.0-PI)
  394  ),
  395  optimizer_set_g(Env,N0,G),
  396  N1 is N0+1,
  397  compute_grad(TMIP,Env,M,N1,MI,LN).
  398
  399compute_sum_neg([],_M,_LN,_I,S,S).
  400
  401compute_sum_neg([HMI|TMI],M,[HLN|TLN],I,S0,S):-
  402  nth0(I,HMI,MIR),
  403  Den is 1.0-exp(-HLN),
  404  M:local_setting(zero,Zero),
  405  (Den=<0.0->
  406    Den1 is Zero
  407  ;
  408    Den1 = Den
  409  ),
  410  S1 is S0+MIR*exp(-HLN)/Den1,
  411  compute_sum_neg(TMI,M,TLN,I,S1,S).
  412
  413compute_likelihood([],_M,L,L).
  414
  415compute_likelihood([HP|TP],M,L0,L):-
  416  A is 1.0-exp(-HP),
  417  M:local_setting(zero,Zero),
  418  (A=<0.0->
  419    A1 is Zero
  420  ;
  421    A1=A
  422  ),
  423  L1 is L0-log(A1),
  424  compute_likelihood(TP,M,L1,L).
  425
  426compute_likelihood_neg([],_Env,_M,[]).
  427
  428compute_likelihood_neg([HMI|TMI],Env,M,[HLN|TLN]):-
  429  compute_likelihood_pos(HMI,Env,M,0,0,HLN),
  430  compute_likelihood_neg(TMI,Env,M,TLN).
  431
  432compute_likelihood_pos([],_Env,_M,_,LP,LP).
  433
  434compute_likelihood_pos([HMIP|TMIP],Env,M,I,LP0,LP):-
  435  optimizer_get_x(Env,I,P0),
  436  M:local_setting(zero,Zero),
  437  (P0=<0.0 ->
  438    P=Zero
  439  ;
  440    (P0>=1.0->
  441       P is 1-Zero
  442     ;
  443       P=P0
  444     )
  445  ),
  446  LP1 is LP0-log(1-P)*HMIP,
  447  I1 is I+1,
  448  compute_likelihood_pos(TMIP,Env,M,I1,LP1,LP).
  449
  450progress(_Env,FX,X_Norm,G_Norm,Step,_N,Iteration,Ls,0,[M|_]) :-
  451  format4(M,'~d. Iteration :  f(X)=~4f  |X|=~4f
  452                |g(X)|=~4f  Step=~4f  Ls=~4f~n',
  453                [Iteration,FX,X_Norm,G_Norm,Step,Ls]).
  454
  455gen_par(NC,NC,[]):-!.
  456
  457gen_par(N0,NC,[[N0,[0.5,0.5]]|T]):-
  458  N1 is N0+1,
  459  gen_par(N1,NC,T).
  460
  461
  462logistic(X,Sigma_X):-
  463  Sigma_X is 1/(1+exp(-X)).
  464
  465
  466load_python_module(M):-
  467  M:local_setting(parameter_learning,PL),
  468  (PL=em_python;PL=gd_python; PL=em_torch),!,
  469  absolute_file_name(library('liftcover.pl'), F),
  470  file_directory_name(F,Dir),
  471  py_add_lib_dir(Dir),
  472  processor(M,Proc),
  473  M:local_setting(verbosity,Verb),
  474  py_call(liftcover:init(PL,Proc,Verb)).
  475
  476load_python_module(_).
  477
  478processor(M,Proc):-
  479  M:local_setting(processor,Proc0),
  480  (setting(allow_gpu,true)->
  481    Proc=Proc0
  482  ;
  483    Proc = cpu
  484  ).

 induce_par_lift(: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. /

  493induce_par_lift(Folds,ROut):-
  494  induce_parameters(Folds,R),
  495  rules2terms(R,ROut).
  496
  497induce_parameters(M:Folds,R):-
  498  load_python_module(M),
  499  make_dynamic(M),
  500  M:local_setting(seed,Seed),
  501  setrand(Seed),
  502  findall(Exs,(member(F,Folds),M:fold(F,Exs)),L),
  503  append(L,DB),
  504  statistics(walltime,[_,_]),
  505  (M:bg(RBG0)->
  506    process_clauses(RBG0,M,RBG),
  507    generate_clauses_bg(RBG,ClBG),
  508    assert_all(ClBG,M,ClBGRef)
  509  ;
  510    true
  511  ),
  512  M:in(R00),
  513  process_clauses(R00,M,R0),
  514  statistics(walltime,[_,_]),
  515  find_ex(DB,M,Pos,Neg,_NPos,_NNeg),
  516  M:local_setting(random_restarts_number,RR),
  517  number_of_threads(M,Th),
  518  learn_param(R0,M,Pos,Neg,RR,Th,R1,Score,_MI,_MIN),
  519  sort_rules_int(R1,R),
  520  statistics(walltime,[_,CT]),
  521  CTS is CT/1000,
  522  format2(M,'/* Final score ~f~n',[Score]),
  523  format2(M,'Wall time ~f */~n',[CTS]),
  524  write_rules2(M,R,user_output),
  525  (M:bg(RBG0)->
  526    retract_all(ClBGRef)
  527  ;
  528    true
  529  ).

 induce_par_kg(:P:probabilistic_program, -P1: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. /

  539induce_par_kg(M:R,R1):-
  540  load_python_module(M),
  541  compute_rel(R,Rels),
  542  assert(M:rules(R)),
  543  maplist(partition_rules(M),Rels),
  544  retract(M:rules(R)),
  545  (parallel(M)->
  546    concurrent_maplist(compute_statistics_kg(M),Rels,MI,MIN)
  547  ;
  548    maplist(compute_statistics_kg(M),Rels,MI,MIN)
  549  ),
  550  maplist(induce_parameters_kg(M),Rels,MI,MIN,Par),
  551  maplist(update_rules_rel(M),Rels,Par,R0),
  552  retractall(M:rules(_,_)),
  553  append(R0,R1).
  554
  555induce_par_pos_kg(M:R,R1):-
  556  load_python_module(M),
  557  compute_rel(R,Rels),
  558  assert(M:rules(R)),
  559  maplist(partition_rules(M),Rels),
  560  retract(M:rules(R)),
  561  (parallel(M)->
  562    concurrent_maplist(compute_statistics_pos_kg(M),Rels,MI,MIN)
  563  ;
  564    maplist(compute_statistics_pos_kg(M),Rels,MI,MIN)
  565  ),
  566  maplist(induce_parameters_kg(M),Rels,MI,MIN,Par),
  567  maplist(update_rules_rel(M),Rels,Par,R0),
  568  retractall(M:rules(_,_)),
  569  append(R0,R1).
  570
  571compute_stats_kg(M:R,File):-
  572  compute_rel(R,Rels),
  573  assert(M:rules(R)),
  574  maplist(partition_rules(M),Rels),
  575  retract(M:rules(R)),
  576  (parallel(M)->
  577    concurrent_maplist(compute_statistics_kg(M),Rels,MI,MIN)
  578  ;
  579    maplist(compute_statistics_kg(M),Rels,MI,MIN)
  580  ),
  581  retractall(M:rules(_,_)),
  582  open(File,write,S),
  583  writeln(S,m(MI,MIN)),writeln(S,'.'),
  584  close(S).
  585
  586compute_stats_pos_kg(M:R,File):-
  587  compute_rel(R,Rels),
  588  assert(M:rules(R)),
  589  maplist(partition_rules(M),Rels),
  590  retract(M:rules(R)),
  591  (parallel(M)->
  592    concurrent_maplist(compute_statistics_pos_kg(M),Rels,MI,MIN)
  593  ;
  594    maplist(compute_statistics_pos_kg(M),Rels,MI,MIN)
  595  ),
  596  retractall(M:rules(_,_)),
  597  open(File,write,S),
  598  writeln(S,m(MI,MIN)),writeln(S,'.'),
  599  close(S).
  600
  601compute_rel(R,Rels):-
  602  setof(Rel,(H,T,P,B,R)^member((tt(H,Rel,T): P :- B),R),Rels).
  603
  604compute_par_kg(M:R,FileStat,R1):-
  605  load_python_module(M),
  606  open(FileStat,read,S),
  607  read_term(S,m(MI,MIN),[]),
  608  close(S),
  609  assert(M:rules(R)),
  610  compute_rel(R,Rels),
  611  maplist(partition_rules(M),Rels),
  612  retract(M:rules(R)),
  613  maplist(induce_parameters_kg(M),Rels,MI,MIN,Par),
  614  flush_output,
  615  maplist(update_rules_rel(M),Rels,Par,R0),
  616  retractall(M:rules(_,_)),
  617  append(R0,R1).
  618
  619update_rules_rel(M,Rel,Par,R):-
  620  M:rules(Rel,R0),
  621  maplist(update_rule,R0,Par,R).
  622
  623parallel(M):-
  624  number_of_threads(M,Th),
  625  Th>1.
  626  
  627induce_parameters_kg(M,Rel,MI,MIN,Par):-
  628  format4(M,'Tuning parameters for relation ~w~n',[Rel]),
  629  M:local_setting(random_restarts_number,RR),
  630  length(MI,N),
  631  learn_param_int(MI,MIN,N,M,RR,Par,_LL).
  632
  633rules_for_rel(M:Rules,Rel,RulesRel):-
  634  assert(M:rules(Rules)),
  635  partition_rules(M,Rel),
  636  M:rules(Rel,RulesRel),
  637  retract(M:rules(_)),
  638  retract(M:rules(Rel,_)).
  639
  640
  641partition_rules(M,Rel):-
  642  M:rules(R),
  643  findall((tt(S,Rel,T): P :- Body),member((tt(S,Rel,T): P :- Body),R),RRel),
  644  assert(M:rules(Rel,RRel)).
  645
  646compute_statistics_kg(M,Rel,MI,MIN):-
  647  M:rules(Rel,R),
  648  length(R,N),
  649  format4(M,'Computing clause statistics for relation ~q, ~d clauses~n',[Rel,N]),
  650  find_ex_kg(Rel,M,Pos,Neg),
  651  length(Pos,NPos),
  652  length(Neg,NNeg),
  653  format4(M,'Pos ex ~d neg ex ~d~n',[NPos,NNeg]),
  654  clauses_statistics_kg(R,M,Rel,Pos,Neg,MI,MIN).
  655
  656compute_statistics_pos_kg(M,Rel,MI,MIN):-
  657  M:rules(Rel,R),
  658  length(R,N),
  659  format4(M,'Computing clause statistics for relation ~q, ~d clauses~n',[Rel,N]),
  660  find_pos_ex_kg(Rel,M,Pos),
  661  length(Pos,NPos),
  662  format4(M,'Pos ex ~d neg ex ~d~n',[NPos,0]),
  663  clauses_statistics_kg(R,M,Rel,Pos,[],MI,MIN).
  664
  665number_of_threads(M,Th):-
  666  M:local_setting(threads,Th0),
  667  current_prolog_flag(cpu_count,Cores),
  668  ((Th0=cpu;Th0>Cores)->
  669    Th1 = Cores
  670  ;
  671    Th1 = Th0
  672  ),
  673  setting(max_threads,ThMax),
  674  Th is min(Th1,ThMax).
  675
  676
  677update_rule((H:_ :- B),P,(H:P :- B)).
  678
  679find_ex_kg(Rel,M,Pos,Neg):-
  680  find_pos_ex_kg(Rel,M,Pos),
  681  findall(tt(S,Rel,T),(M:t(S,Rel1,T),Rel1 \= Rel,\+ M:t(S,Rel,T)),Neg).
  682
  683find_pos_ex_kg(Rel,M,Pos):-
  684  findall(tt(S,Rel,T),M:t(S,Rel,T),Pos).

 filter_rules(:RulesIn:list_of_rules, -RulesOut:list_of_rules) is det

The predicate removes the rules with a probability below or equal to the min_prob parmeter. /

  692filter_rules(M:R0,R):-
  693  M:local_setting(min_probability,Min_prob),
  694  filter_rules(R0,R,Min_prob).

 filter_rules(+RulesIn:list_of_rules, -RulesOut:list_of_rules, +Min_prob:float) is det

The predicate removes from the rules with a probability below or equal to Min_prob. /

  702filter_rules(R0,R,Min_prob):-
  703  (R0=[(_ :- _)|_]->
  704    rules2terms(R0At,R0),
  705    remove_clauses(R0At,Min_prob,RAt,_Num),
  706    rules2terms(RAt,R)
  707  ;
  708    remove_clauses(R0,Min_prob,R,_Num)  
  709  ).

 remove_zero(+RulesIn:list_of_rules, -RulesOut:list_of_rules) is det

The predicate removes the rules with a probability of 0.0. /

  716remove_zero(R0,R1):-
  717  filter_rules(R0,R1,0.0).
  718
  719
  720remove_clauses(Rules,Prob,RulesOut,Num):-
  721  remove_clauses_loop(Rules,Prob,0,Num,[],RulesOut).
  722
  723remove_clauses_loop([],_,Num,Num,Rules,Rules).
  724remove_clauses_loop([Rule|Rest],Prob,NumCur,Num,RulesCur,RulesOut):-
  725  Rule=rule(_N,[_Head:Par|_],_,_),
  726  Par =< Prob,!,
  727  NumCur1 is NumCur+1,
  728  remove_clauses_loop(Rest, Prob, NumCur1,Num,RulesCur, RulesOut).
  729
  730remove_clauses_loop([Rule|Rest],Prob,NumCur,Num,RulesCur,[Rule|RulesOut]):-
  731  remove_clauses_loop(Rest, Prob, NumCur,Num,RulesCur, RulesOut).
  732
  733
  734test_theory_neg_prob(Ex,M,Theory,MIP0,MIP):-
  735  (M:local_setting(single_var,false)->
  736    test_clause_prob(Theory,M,Ex,MIP0,MIP)
  737  ;
  738    test_clause_prob_sv(Theory,M,Ex,MIP0,MIP)
  739  ).
  740
  741test_clause_prob([],_M,_Exs,MIP,MIP).
  742
  743test_clause_prob([(H,B,V,_P)|Rest],M,Exs,[MIPH0|MIPT0],[MIPH|MIPT]):-
  744  maplist(test_ex(V,H,B,M),Exs,L),
  745  sum_list(L,MIP),
  746  MIPH is MIPH0+MIP,
  747  test_clause_prob(Rest,M,Exs,MIPT0,MIPT).
  748
  749test_ex(_V,H,B,M,E,N):-
  750  findall(1,(H=E,M:B),L),
  751  length(L,N).
  752
  753test_clause_prob_sv([],_M,_Exs,MIP,MIP).
  754
  755test_clause_prob_sv([(H,B,V,_P)|Rest],M,Exs,[MIPH0|MIPT0],[MIPH|MIPT]):-
  756  maplist(test_ex_sv(V,H,B,M),Exs,L),
  757  sum_list(L,MIP),
  758  MIPH is MIPH0+MIP,
  759  test_clause_prob_sv(Rest,M,Exs,MIPT0,MIPT).
  760
  761
  762test_ex_sv(_V,H,B,M,E,N):-
  763  (\+ (H=E,M:B)->
  764    N=0
  765  ;
  766    N=1
  767  ).  
  768
  769test_theory_pos_prob(Ex,M,Th,N,LMI):-
  770  (M:local_setting(single_var,false)->
  771    test_theory_pos_prob_mv(Ex,M,Th,N,LMI)
  772  ;
  773    test_theory_pos_prob_sv(Ex,M,Th,N,LMI)
  774  ).
  775
  776test_theory_pos_prob_mv([],_M,_Theory,_N,[]).
  777
  778test_theory_pos_prob_mv([Ex|Rest],M,Th,N,[MI|LMI]):-
  779  gen_initial_counts(N,MI0),
  780  test_clause_prob(Th,M,[Ex],MI0,MI),
  781  test_theory_pos_prob_mv(Rest,M,Th,N,LMI).
  782
  783test_theory_pos_prob_sv([],_M,_Theory,_N,[]).
  784
  785test_theory_pos_prob_sv([Ex|Rest],M,Th,N,[MI|LMI]):-
  786  gen_initial_counts(N,MI0),
  787  test_clause_prob_sv(Th,M,[Ex],MI0,MI),
  788  test_theory_pos_prob_sv(Rest,M,Th,N,LMI).
  789
  790
  791
  792test_theory_pos_kg(M,Rel,(H:_ :-B),MI):-
  793  M:pos(Rel,Ex),
  794  maplist(check_rule(H,B,M),Ex,MI).
  795
  796
  797check_rule(H1,B1,M,Ex,Cov):-
  798  copy_term((H1,B1),(H,B)),
  799  term_variables(B,Vars),
  800  ((H=Ex,M:B,oi(Vars))->
  801    Cov=1
  802  ;
  803    Cov=0
  804  ).
  805
  806test_theory_neg_kg(M,Rel,(H:_ :-B),MIN):-
  807  M:neg(Rel,Ex),
  808  foldl(update_min(H,B,M),Ex,0,MIN).
  809
  810update_min(H1,B1,M,Ex,MIN0,MIN):-
  811  copy_term((H1,B1),(H,B)),
  812  term_variables(B,Vars),
  813  ((H=Ex,M:B,oi(Vars))->
  814    MIN is MIN0+1
  815  ;
  816    MIN=MIN0
  817  ).
  818
  819oi(Vars):-
  820  sort(Vars,VarsOI),
  821  length(VarsOI,LOI),
  822  length(Vars,L),
  823  L=LOI.
  824
  825
  826
  827
  828learn_param([],M,_,_,_,_,[],MInf,[],[]):-!,
  829  M:local_setting(minus_infinity,MInf).
  830
  831learn_param(Program0,M,Pos,Neg,RR,Th,Program,LL,MI,MIN):-
  832  generate_clauses(Program0,M,0,Pr1),
  833  length(Program0,N),
  834  format4(M,'Computing clause statistics~n',[]),
  835  gen_initial_counts(N,MIN0),
  836  clauses_statistics(Pr1,N,M,Pos,Neg,MIN0,MI,MIN,Th),
  837  format4(M,'Updating parameters~n',[]),
  838  learn_param_int(MI,MIN,N,M,RR,Par,LL),
  839  update_theory(Program0,Par,Program1),
  840  remove_zero(Program1,Program).
  841
  842
  843clauses_statistics(Pr,N,M,Pos,Neg,MIN0,MI,MIN,Th):-
  844  (Th=1->
  845    test_theory_neg_prob(Neg,M,Pr,MIN0,MIN),
  846    test_theory_pos_prob(Pos,M,Pr,N,MI)
  847  ;
  848    current_prolog_flag(cpu_count,Cores),
  849    ((Th=cpu;Th>Cores)->
  850      Chunks = Cores
  851    ;
  852      Chunks = Th
  853    ),
  854    chunks(Pos,Chunks,PosC),
  855    chunks(Neg,Chunks,NegC),
  856    concurrent_maplist(test_theory_neg_prob_conc(Pr,M,MIN0),NegC,MINC),
  857    concurrent_maplist(test_theory_pos_prob_conc(Pr,M,N),PosC,MIC),
  858    append(MIC,MI),
  859    transpose(MINC,MINT),
  860    maplist(sum_list,MINT,MIN)
  861  ).
  862
  863test_theory_neg_prob_conc(Pr,M,MIN0,Neg,MIN):-
  864  test_theory_neg_prob(Neg,M,Pr,MIN0,MIN).
  865
  866test_theory_pos_prob_conc(Pr,M,N,Pos,MI):-
  867  test_theory_pos_prob(Pos,M,Pr,N,MI).
  868
  869
  870clauses_statistics_kg(Pr,M,Rel,Pos,Neg,MI,MIN):-
  871  assert(M:pos(Rel,Pos)),
  872  assert(M:neg(Rel,Neg)),
  873  maplist(test_theory_neg_kg(M,Rel),Pr,MIN),
  874  maplist(test_theory_pos_kg(M,Rel),Pr,MIT),
  875  transpose(MIT,MI),
  876  retract(M:pos(Rel,Pos)),
  877  retract(M:neg(Rel,Neg)).
  878
  879chunks(L,N,Chunks):-
  880  length(L,Len),
  881  LenChunks is round(Len/N),
  882  split_list(L,N,LenChunks,Chunks).
  883
  884split_list(L,1,_,[L]):-!.
  885
  886split_list(L0,N,NL,[H|L]):-
  887  N>1,
  888  N1 is N-1,
  889  length(H1,NL),
  890  (append(H1,T,L0)->
  891    H=H1,
  892    split_list(T,N1,NL,L)
  893  ;
  894    H=L0,
  895    L=[]
  896  ).
  897
  898% case of no rules
  899%learn_param_int(_MI,[],_N,_M,_NR,[],-inf):-!,
  900%  writeln("No rules").
  901
  902learn_param_int(MI,MIN,_N,M,NR,Par,LL):-
  903  M:local_setting(parameter_learning,em_torch),!,
  904  M:local_setting(eps,EA),
  905  M:local_setting(eps_f,ER),
  906  M:local_setting(iter,Iter),
  907  M:local_setting(regularization,Reg),
  908  M:local_setting(gamma,Gamma0),
  909  (Gamma0=relative(G)->
  910    length(MI,N),
  911    Gamma is G*N
  912  ;
  913    Gamma=Gamma0
  914  ),
  915  M:local_setting(zero,Zero),
  916  M:local_setting(ab,[A,B]),
  917  M:local_setting(verbosity,Verb),
  918  processor(M,Device),
  919  (NR=fixed(P) ->
  920    py_call(liftcover:fixed_initial_par(MI,MIN,Device,P,Iter,EA,ER,Reg,Zero,Gamma,A,B,Verb),-(Par,LL))
  921  ;
  922    py_call(liftcover:random_restarts_torch(MI,MIN,Device,NR,Iter,EA,ER,Reg,Zero,Gamma,A,B,Verb),-(Par,LL))
  923  ),
  924  format3(M,"Final LL ~f~n",[LL]).
  925
  926
  927learn_param_int(MI,MIN,N,M,NR,Par,LL):-
  928  M:local_setting(parameter_learning,em),!,
  929  random_restarts(0,NR,M,-1e20,LL,N,initial,Par,MI,MIN),
  930  format3(M,"Final LL ~f~n",[LL]).
  931
  932learn_param_int(MI,MIN,_N,M,NR,Par,LL):-
  933  M:local_setting(parameter_learning,em_python),!,
  934  M:local_setting(eps,EA),
  935  M:local_setting(eps_f,ER),
  936  M:local_setting(iter,Iter),
  937  M:local_setting(regularization,Reg),
  938  M:local_setting(gamma,Gamma),
  939  M:local_setting(zero,Zero),
  940  M:local_setting(ab,[A,B]),
  941  M:local_setting(verbosity,Verb),
  942  processor(M,Device),
  943  py_call(liftcover:random_restarts(MI,MIN,Device,NR,Iter,EA,ER,Reg,Zero,Gamma,A,B,Verb),-(Par,LL)),
  944  format3(M,"Final LL ~f~n",[LL]).
  945
  946learn_param_int(MI,MIN,N,M,NR,Par,LL):-
  947  M:local_setting(parameter_learning,gd),!,
  948  random_restarts_gd(0,NR,M,-1e20,PLL,N,initial,ParR,MI,MIN),  %computes new parameters Par
  949  maplist(logistic,ParR,Par),
  950  LL is -PLL,
  951  format3(M,"Final LL ~f~n",[LL]).
  952
  953
  954learn_param_int(MI,MIN,_N,M,NR,Par,LL):-
  955  M:local_setting(parameter_learning,gd_python),!,
  956  M:local_setting(verbosity,Verb),
  957  M:local_setting(parameter_update,UpdateMethod),
  958  M:local_setting(iter,Iter),
  959  M:local_setting(eps,Eps),
  960  M:local_setting(adam_params,[Eta,Beta1,Beta2,Epsilon]),
  961  M:local_setting(eta,LearningRate),
  962  M:local_setting(gamma,Gamma),
  963  M:local_setting(regularization,Reg),
  964  M:local_setting(zero,Zero),
  965  processor(M,Device),
  966  (NR=fixed(P) ->
  967    py_call(liftcover:gd_fixed_par(MIN,MI,Device,P,Iter,Eps,UpdateMethod,Reg,Gamma,LearningRate,Eta,
  968      -(Beta1,Beta2),Epsilon,Zero,Verb),-(Par,LL))
  969  ;
  970    py_call(liftcover:random_restarts_gd(MI,MIN,Device,NR,UpdateMethod,
  971    Iter,Eps,Reg,Gamma,LearningRate,Eta,-(Beta1,Beta2),Epsilon,Zero,Verb),-(Par,LL))
  972  ),
  973  format3(M,"Final LL ~f~n",[LL]).
  974
  975
  976learn_param_int(MI,MIN,N,M,_,Par,LL):-
  977  M:local_setting(parameter_learning,lbfgs),
  978  optimizer_initialize(N,liftcover,evaluate,progress,[M,MIN,MI],Env),
  979  init_par(Env,N),
  980  evaluate_L(Env,M,MIN,MI,L),
  981% parte da modificare fine
  982  IL is -L,
  983  format4(M,"~nInitial L ~f~n",[IL]),
  984  optimizer_run(Env,_LL,Status),
  985  format4(M,"Status ~p~n",[Status]),
  986  new_pars_lbfgs(Env,M,0,N,Par),
  987  evaluate_L(Env,M,MIN,MI,NewL),
  988  LL is -NewL,
  989  optimizer_finalize(Env).
  990
  991
  992new_pars_lbfgs(_Env,_M,N,N,[]):-!.
  993
  994new_pars_lbfgs(Env,M,N,NMax,[P|Rest1]):-
  995    optimizer_get_x(Env,N,P0),
  996    M:local_setting(zero,Zero),
  997    (P0=<0.0->
  998      P=Zero
  999    ;
 1000      (P0>=1.0->
 1001        P is 1.0-Zero
 1002      ;
 1003        P=P0
 1004      )
 1005    ),
 1006    N1 is N+1,
 1007    new_pars_lbfgs(Env,M,N1,NMax,Rest1).
 1008
 1009
 1010random_restarts(N,N,_M,Score,Score,_N,Par,Par,_MI,_MIN):-!.
 1011
 1012random_restarts(N,NMax,M,Score0,Score,NR,Par0,Par,MI,MIN):-
 1013  N1 is N+1,
 1014  format3(M,"Restart number ~d~n~n",[N1]),
 1015  length(Par1,NR),
 1016  maplist(random,Par1),
 1017  M:local_setting(eps,EA),
 1018  M:local_setting(eps_f,ER),
 1019  M:local_setting(iter,Iter),
 1020  em(EA,ER,0,Iter,M,NR,Par1,-1e20,MI,MIN,ParR,ScoreR),
 1021  format3(M,"Random_restart: Score ~f~n",[ScoreR]),
 1022  (ScoreR>Score0->
 1023    random_restarts(N1,NMax,M,ScoreR,Score,NR,ParR,Par,MI,MIN)
 1024  ;
 1025    random_restarts(N1,NMax,M,Score0,Score,NR,Par0,Par,MI,MIN)
 1026  ).
 1027
 1028random_restarts_gd(N,N,_M,Score,Score,_N,Par,Par,_MI,_MIN):-!.
 1029
 1030random_restarts_gd(N,NMax,M,_Score0,Score,NR,_Par0,Par,MI,MIN):-
 1031  N1 is N+1,
 1032  format3(M,"Restart number ~d~n~n",[N1]),
 1033  M:local_setting(max_initial_weight,Max),
 1034  init_gd_par(NR,Max,Par1),
 1035  evaluate_L_gd(M,MIN,MI,Par1,L),
 1036  ScoreIn is -L,
 1037  format3(M,"GD Random_restart: initial score ~f~n",[ScoreIn]),
 1038  M:local_setting(eps,EA),
 1039  M:local_setting(eps_f,ER),
 1040  M:local_setting(iter,Iter),
 1041  (M:local_setting(parameter_update,adam)->
 1042    findall(0,between(1,NR,_),M0),
 1043    findall(0,between(1,NR,_),M1),
 1044    gd_adam(EA,ER,0,Iter,M,NR,Par1,M0,M1,-1e20,MI,MIN,ParR,ScoreR)
 1045  ;
 1046    gd(EA,ER,0,Iter,M,NR,Par1,-1e20,MI,MIN,ParR,ScoreR)
 1047  ),
 1048  format3(M,"GD Random_restart: Score ~f~n",[ScoreR]),
 1049  random_restarts_gd(N1,NMax,M,ScoreR,Score,NR,ParR,Par,MI,MIN).
 1050
 1051
 1052gd(_EA,_ER,MaxIter,MaxIter,_M,_NR,Par,Score,_MI,_MIP,Par,Score):-!.
 1053
 1054gd(EA,ER,Iter0,MaxIter,M,NR,Par0,Score0,MI,MIP,Par,Score):-
 1055  compute_gradient_gd(MIP,MI,M,Par0,G,LL),
 1056  Score1 is -LL,
 1057  Iter is Iter0+1,
 1058  format4(M,"GD Iteration ~d LL ~f~n",[Iter,Score1]),
 1059  Diff is Score1-Score0,
 1060  Fract is -Score1*ER,
 1061  (( Diff<EA;Diff<Fract)->
 1062    Score=Score1,
 1063    Par=Par0
 1064  ;
 1065    M:local_setting(eta,Eta),
 1066    M:local_setting(gamma,Gamma),
 1067    (M:local_setting(regularization,l2)->
 1068      maplist(l2,Par0,Reg)
 1069    ;
 1070      (M:local_setting(regularization,l1)->
 1071        maplist(l1,Par0,Reg)
 1072      ;
 1073        findall(0,between(1,NR,_),Reg)
 1074      )
 1075    ),
 1076    maplist(update_par(Eta,Gamma),Par0,Reg,G,Par1),
 1077    gd(EA,ER,Iter,MaxIter,M,NR,Par1,Score1,MI,MIP,Par,Score)
 1078  ).
 1079
 1080gd_adam(_EA,_ER,Iter,Iter,_M,_NR,Par,_M0,_M1,Score,_MI,_MIP,Par,Score):-!.
 1081
 1082gd_adam(EA,ER,Iter0,MaxIter,M,NR,Par0,M00,M10,Score0,MI,MIP,Par,Score):-
 1083  compute_gradient_gd(MIP,MI,M,Par0,G,LL),
 1084  Score1 is -LL,
 1085  Iter is Iter0+1,
 1086  format4(M,"Iteration ~d LL ~f~n",[Iter,Score1]),
 1087  Diff is Score1-Score0,
 1088  Fract is -Score1*ER,
 1089  (( Diff<EA;Diff<Fract)->
 1090    Score=Score1,
 1091    Par=Par0
 1092  ;
 1093    M:local_setting(gamma,Gamma),
 1094    M:local_setting(adam_params,[Eta,Beta1,Beta2,Epsilon]),
 1095    (M:local_setting(regularization,l2)->
 1096      maplist(l2,Par0,Reg)
 1097    ;
 1098      (M:local_setting(regularization,l1)->
 1099        maplist(l1,Par0,Reg)
 1100      ;
 1101        findall(0,between(1,NR,_),Reg)
 1102      )
 1103    ),
 1104    maplist(update_grad(Gamma),G,Reg,G1),
 1105    maplist(update_M0(Beta1),M00,G1,M0),
 1106    maplist(update_M1(Beta2),M10,G1,M1),
 1107    EtaIter is Eta*sqrt(1-Beta2^Iter)/(1-Beta1^Iter),
 1108    maplist(update_par_adam(EtaIter,Epsilon),Par0,M0,M1,Par1),
 1109    gd_adam(EA,ER,Iter,MaxIter,M,NR,Par1,M0,M1,Score1,MI,MIP,Par,Score)
 1110  ).
 1111
 1112update_par_adam(EtaIter,Epsilon,Par0,M0,M1,Par1):-
 1113  Par1 is Par0-EtaIter*M0/(sqrt(M1)+Epsilon).
 1114
 1115
 1116update_M0(Beta1,M00,G,M0):-
 1117  M0 is Beta1*M00+(1-Beta1)*G.
 1118
 1119update_M1(Beta2,M10,G,M1):-
 1120  M1 is Beta2*M10+(1-Beta2)*G^2.
 1121
 1122update_grad(Gamma,G,Reg,G1):-
 1123  G1 is G+Gamma*Reg.
 1124
 1125
 1126l1(W,R):-
 1127  logistic(W,S),
 1128  R is S*(1-S).
 1129
 1130l2(W,R):-
 1131  logistic(W,S),
 1132  R is 2*S^2*(1-S).
 1133
 1134update_par(Eta,Gamma,Par0,Reg,G,Par1):-
 1135  Par1 is Par0-Eta*(G+Gamma*Reg).
 1136
 1137
 1138
 1139evaluate_L_gd(M,MIP,MI,Par,L):-
 1140  maplist(logistic,Par,Prob),
 1141  compute_likelihood_pos_gd(MIP,Prob,M,0,LP),
 1142%  write(lpos),nl,
 1143  compute_likelihood_neg_gd(MI,Prob,M,LN),
 1144%  write(lneg),nl,
 1145  compute_likelihood_gd(LN,M,LP,L).
 1146
 1147
 1148
 1149compute_gradient_gd(MIP,MI,M,Par,G,L):-
 1150  maplist(logistic,Par,Prob),
 1151  compute_likelihood_pos_gd(MIP,Prob,M,0,LP),
 1152  compute_likelihood_neg_gd(MI,Prob,M,LN),
 1153  compute_likelihood_gd(LN,M,LP,L),
 1154  compute_grad_gd(MIP,Prob,M,0,MI,LN,G).
 1155%  write(grad),nl.
 1156
 1157compute_likelihood_neg_gd([],_Prob,_M,[]).
 1158
 1159compute_likelihood_neg_gd([HMI|TMI],Prob,M,[HLN|TLN]):-
 1160  compute_likelihood_pos_gd(HMI,Prob,M,0,HLN),
 1161  compute_likelihood_neg_gd(TMI,Prob,M,TLN).
 1162
 1163compute_likelihood_pos_gd([],[],_M,LP,LP).
 1164
 1165compute_likelihood_pos_gd([HMIP|TMIP],[P|TP],M,LP0,LP):-
 1166  LP1 is LP0-log(1-P)*HMIP,
 1167  compute_likelihood_pos_gd(TMIP,TP,M,LP1,LP).
 1168
 1169
 1170compute_likelihood_gd([],_M,L,L).
 1171
 1172compute_likelihood_gd([HP|TP],M,L0,L):-
 1173  A is 1.0-exp(-HP),
 1174  (A=:=0.0->
 1175    M:local_setting(logzero,LZ),
 1176    L1 is L0-LZ
 1177  ;
 1178    L1 is L0-log(A)
 1179  ),
 1180  compute_likelihood_gd(TP,M,L1,L).
 1181
 1182
 1183compute_grad_gd([],[],_M,_N,_MI,_LN,[]):-!.
 1184
 1185compute_grad_gd([HMIP|TMIP],[P|TP],M,N0,MI,LN,[G|TG]):-
 1186%  write(prima_comp_grad),nl,
 1187  compute_sum_neg(MI,M,LN,N0,0,S),
 1188%  write(opt),nl,
 1189  G is (HMIP-S)*P,
 1190  N1 is N0+1,
 1191  compute_grad_gd(TMIP,TP,M,N1,MI,LN,TG).
 1192
 1193compute_sum_neg_gd([],_M,_LN,_I,S,S).
 1194
 1195compute_sum_neg_gd([HMI|TMI],M,[HLN|TLN],I,S0,S):-
 1196%  write(HMI),write(hmi),nl,
 1197%  write(I),write('I'),nl,
 1198  nth0(I,HMI,MIR),
 1199%  write(MIR),write(mir),nl,
 1200%  write(HLN),write(hln),nl,
 1201  Den is 1.0-exp(-HLN),
 1202  S1 is S0+MIR*exp(-HLN)/Den,
 1203  compute_sum_neg_gd(TMI,M,TLN,I,S1,S).
 1204
 1205
 1206em(_EA,_ER,MaxIter,MaxIter,_M,_NR,Par,Score,_MI,_MIN,Par,Score):-!.
 1207
 1208em(EA,ER,Iter0,MaxIter,M,NR,Par0,Score0,MI,MIN,Par,Score):-
 1209  length(Eta0,NR),
 1210  expectation_quick(Par0,M,MI,MIN,Eta0,Eta,Score1),
 1211  Iter is Iter0+1,
 1212  format4(M,"Iteration ~d LL ~f~n",[Iter,Score1]),
 1213  maximization_quick(Eta,M,Par1),
 1214  Diff is Score1-Score0,
 1215  Fract is -Score1*ER,
 1216  (( Diff<EA;Diff<Fract)->
 1217    Score=Score1,
 1218    Par=Par1
 1219  ;
 1220    em(EA,ER,Iter,MaxIter,M,NR,Par1,Score1,MI,MIN,Par,Score)
 1221  ).
 1222
 1223expectation_quick(Par,M,MI,MIN,Eta0,Eta,Score):-
 1224 /* LLO is the negative examples contribution in the LL*/
 1225  M:local_setting(logzero,LogZero),
 1226  foldl(llm(LogZero),Par,MIN,0,LL0),
 1227  maplist(eta0,MIN,Eta0),
 1228  /* positive examples contibution in LL*/
 1229  scan_pos(MI,M,Par,LL0,Eta0,Score,Eta).
 1230
 1231maximization_quick(Eta,M,Par):-
 1232  (M:local_setting(regularization,l1)->
 1233    maplist(maximize_L1(M),Eta,Par)
 1234  ;
 1235    (M:local_setting(regularization,l2)->
 1236      maplist(maximize_L2(M),Eta,Par)
 1237  ;
 1238      (M:local_setting(regularization,bayesian)->
 1239        maplist(maximize_bayesian(M),Eta,Par)
 1240      ;
 1241        maplist(maximize(M),Eta,Par)
 1242  )
 1243    )
 1244  ).
 1245
 1246maximize(_M,[Eta0,Eta1],Par):-
 1247  (Eta0+Eta1=:=0.0->
 1248    Par=0.0
 1249  ;
 1250    Par is Eta1/(Eta0+Eta1)  
 1251  ).
 1252
 1253
 1254maximize_L1(M,[Eta0,Eta1],Par):-
 1255  M:local_setting(gamma,Gamma),
 1256/*(((Eta0+Eta1)^2+Gamma^2+2*Gamma*(Eta0-Eta1))<0 ->
 1257writeln((Eta0+Eta1)^2+Gamma^2+2*Gamma*(Eta0-Eta1)),
 1258  Par is 4*Eta1/(2*(Gamma+Eta0+Eta1))
 1259;((2*(Gamma+Eta0+Eta1+sqrt((Eta0+Eta1)^2+Gamma^2+2*Gamma*(Eta0-Eta1)))=:=0.0)->
 1260writeln((2*(Gamma+Eta0+Eta1+sqrt((Eta0+Eta1)^2+Gamma^2+2*Gamma*(Eta0-Eta1)))))
 1261
 1262;*/
 1263  Par is 4*Eta1/(2*(Gamma+Eta0+Eta1+sqrt((Eta0+Eta1)^2+Gamma^2+2*Gamma*(Eta0-Eta1))))
 1264%)
 1265  %)
 1266  .
 1267
 1268maximize_L2(M,[Eta0,Eta1],Par):-
 1269  M:local_setting(gamma,Gamma),
 1270  Sum is 3*Eta0+3*Eta1+Gamma,
 1271  Arccos is acos(sqrt(Gamma/Sum)*(9*Eta0/2-9*Eta1+Gamma)/(3*Eta0+3*Eta1+Gamma)),
 1272  Par is 2*sqrt(Sum/Gamma)*cos(Arccos/3-2*pi/3)/3+1/3.
 1273
 1274maximize_bayesian(M,[Eta0,Eta1],Par):-
 1275  M:local_setting(ab,[A,B]),
 1276  Par is (Eta1+A)/(Eta0+Eta1+A+B).
 1277
 1278/*....scan_pos predicate..... */
 1279
 1280scan_pos([],_M,_Par,LL,Eta,LL,Eta).
 1281
 1282scan_pos([MIH|MIT],M,Par,LL0,Eta0,LL,Eta):-
 1283  M:local_setting(logzero,LogZero),
 1284  foldl(rule_contrib,MIH,Par,1,Prod),
 1285  ProbEx is 1-Prod,
 1286  (ProbEx=:=0.0->
 1287    LLCurrent is LL0+LogZero
 1288   ;
 1289    LLCurrent is LL0+log(ProbEx)
 1290  ),
 1291  maplist(update_eta(ProbEx,M),Eta0,Par,MIH,EtaCurrent),
 1292  scan_pos(MIT,M,Par,LLCurrent,EtaCurrent,LL,Eta).
 1293
 1294
 1295update_eta(ProbEx,M,[Etai00,Etai10],Pi,MIR,[Etai0,Etai1]):-
 1296  M:local_setting(zero,Zero),
 1297  ( ProbEx=:=0.0->
 1298    CondP is Pi/Zero
 1299  ;
 1300    CondP is Pi/ProbEx
 1301  ),
 1302  OCondP0 is 1-CondP,
 1303  ( OCondP0 <0.0->
 1304    OCondP = 0.0
 1305  ;
 1306    OCondP = OCondP0
 1307  ),
 1308  Etai0 is Etai00+MIR*OCondP,
 1309  Etai1 is Etai10+MIR*CondP.
 1310
 1311rule_contrib(MIR,Pi,P0,P):-
 1312  P is P0*(1-Pi)^MIR.
 1313
 1314llm(LogZero,Pi,MI,LL0,LL):-
 1315  ((1-Pi)=:=0.0 ->
 1316
 1317    ( MI==0 ->
 1318      LL is LL0
 1319     ;
 1320       LL is LL0+MI*LogZero
 1321    )
 1322   ;
 1323    ( MI==0 ->
 1324       LL is LL0
 1325     ;
 1326       LL is LL0+MI*log(1-Pi)
 1327    )
 1328
 1329  ).
 1330
 1331eta0(MIN,[MIN,0]).
 1332
 1333
 1334update_theory([],_N,[]):-!.
 1335
 1336update_theory([rule(Name,[H:_,_],B,L)|Rest],[P|T],[rule(Name,[H:P,'':PN],B,L)|Rest1]):-
 1337    PN is 1-P,
 1338    update_theory(Rest,T,Rest1).
 1339
 1340
 1341
 1342cycle_beam([],_Mod,_Pos,_Neg,CL,CL,_M0,_M,_BS,_MC):-!.
 1343
 1344cycle_beam(_Beam,_Mod,_Pos,_Neg,CL,CL,M,M,_BS,_MC):-!.
 1345
 1346cycle_beam(Beam,Mod,Pos,Neg,CL0,CL,M0,M,BS,MC):-
 1347  M1 is M0+1,%decreases the number of max_iter M
 1348  format2(Mod,"Clause iteration ~d~n~n",[M1]),
 1349  /*write('\n\ncurrent beam\n\n'),
 1350  write(Beam),
 1351  write('\n\n'),*/
 1352  cycle_clauses(Beam,Mod,Pos,Neg,[],NB0,CL0,CL1),
 1353  (length(NB,BS),append(NB,_,NB0)->
 1354    true
 1355  ;
 1356   NB=NB0 
 1357  ),
 1358  (MC=:= inf ->
 1359    CL2=CL1
 1360  ;
 1361    (length(CL2,MC),append(CL2,_,CL1)->
 1362      true
 1363    ;
 1364      CL2=CL1
 1365    )
 1366  ),
 1367  cycle_beam(NB,Mod,Pos,Neg,CL2,CL,M1,M,BS,MC).
 1368
 1369cycle_clauses([],_M,_Pos,_Neg,NB,NB,CL,CL):-!.
 1370
 1371cycle_clauses([c(_ScoreH,RH,_)|T],M,Pos,Neg,NB0,NB,CL0,CL):-
 1372%  write3('\n\nRevising clause\n'),
 1373%  write_rules3([RH],user_output),
 1374%  RH=rule(_,H,B,Lits),
 1375%  write3(H),write3(' '),write3(B),
 1376%  write3('\n'),write3(Lits),write3('\n'),
 1377  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
 1378  length(LR,NR),
 1379  write3(M,'Number of revisions '),write3(M,NR),write3(M,'\n'),
 1380  score_clause_refinements(LR,M,Pos,Neg,NB0,NB1,CL0,CL1),
 1381  cycle_clauses(T,M,Pos,Neg,NB1,NB,CL1,CL).
 1382
 1383
 1384score_clause_refinements(LR,M,Pos,Neg,NB0,NB,CL0,CL):-  %scans the list of revised theories
 1385  number_of_threads(M,Th),
 1386  (Th=1->
 1387     score_clause_refinements_int(M,1,Pos,Neg,LR,NB1,CL1),
 1388     list_to_ord_set(NB1,NB1OS),
 1389     ord_union(NB1OS,NB0,NB),
 1390     list_to_ord_set(CL1,CL1OS),
 1391     ord_union(CL1OS,CL0,CL)
 1392  ;
 1393    chunks(LR,Th,LRC),
 1394    concurrent_maplist(score_clause_refinements_int(M,1,Pos,Neg),LRC,NBs,CLs),
 1395    merge_ordsets(NBs,NB0,NB),
 1396    merge_ordsets(CLs,CL0,CL)
 1397  ).
 1398
 1399merge_ordsets([],OS,OS).
 1400
 1401merge_ordsets([H|T],OS0,OS):-
 1402  list_to_ord_set(H,HOS),
 1403  ord_union(HOS,OS0,OS1),
 1404  merge_ordsets(T,OS1,OS).
 1405
 1406
 1407score_clause_refinements_int(_M,_N,_Pos,_Neg,[],[],[]):-!.
 1408
 1409score_clause_refinements_int(M,Nrev,Pos,Neg,[R1|T],[c(Score,R3,_)|NB],CL):-  %scans the list of revised theories
 1410  already_scored_clause(R1,R3,M,Score),!,
 1411  format3(M,'Score ref.  ~d~n',[Nrev]),
 1412  write3(M,'Already scored, updated refinement\n'),
 1413  write_rules3(M,[R3],user_output),
 1414  write3(M,'Score '),write3(M,Score),write3(M,'\n\n\n'),
 1415  Nrev1 is Nrev+1,
 1416  score_clause_refinements_int(M,Nrev1,Pos,Neg,T,NB,CL).
 1417
 1418score_clause_refinements_int(M,Nrev,Pos,Neg,[R1|T],NB,CL):-
 1419  format3(M,'Score ref.  ~d~n',[Nrev]),
 1420  write_rules3(M,[R1],user_output),
 1421  M:local_setting(random_restarts_number_str_learn,NR),
 1422  learn_param([R1],M,Pos,Neg,NR,1,NewR,Score,MI,MIN),
 1423  write3(M,'Updated refinement\n'),
 1424  write_rules3(M,NewR,user_output),
 1425  write3(M,'Score (CLL) '),write3(M,Score),write3(M,'\n\n\n'),
 1426  (NewR=[R3]->
 1427    NB=[c(Score,R3,_)|NB0],
 1428    (range_restricted(R3)->
 1429      CL=[c(Score,R3,[MI,MIN])|CL0]
 1430    ;
 1431      CL=CL0
 1432    ),
 1433    format2(M,"Added a target clause~n",[]),
 1434    store_clause_refinement(R1,R3,M,Score),
 1435    Nrev1 is Nrev+1
 1436  ;
 1437    NB=NB0,
 1438    CL=CL0,
 1439    Nrev1=Nrev+1
 1440  ),
 1441  score_clause_refinements_int(M,Nrev1,Pos,Neg,T,NB0,CL0).
 1442
 1443range_restricted(rule(_N,HL,BL,_Lit)):-
 1444  term_variables(HL,VH),
 1445  term_variables(BL,VB),
 1446  sublisteq(VH,VB).
 1447
 1448sublisteq([],_).
 1449
 1450sublisteq([H|T],L):-
 1451  member_eq(H,L),
 1452  sublisteq(T,L).
 1453
 1454target(R,M):-
 1455  get_output_preds(R,O),
 1456  member(T,O),
 1457  M:output(T),!.
 1458
 1459get_output_preds(rule(_N,HL,_BL,_Lit),O):-
 1460  scan_head(HL,[],O).
 1461
 1462scan_head(['':_],O,O):-!.
 1463scan_head([],O,O):-!.
 1464scan_head([H:_P|T],O0,O):-
 1465  functor(H,F,N),
 1466  (member(F/N,O0)->
 1467    O1=O0
 1468  ;
 1469    O1=[F/N|O0]
 1470  ),
 1471  scan_head(T,O1,O).
 1472
 1473
 1474store_clause_refinement(Ref,RefP,M,Score):-
 1475  elab_clause_ref(Ref,Ref1),
 1476  assert(M:ref_clause(r(Ref1,RefP,Score))).
 1477
 1478store_refinement(Ref,RefP,M,Score):-
 1479  elab_ref(Ref,Ref1),
 1480  assert(M:ref(r(Ref1,RefP,Score))).
 1481
 1482already_scored_clause(R,R1,M,Score):-
 1483  elab_ref([R],[rule(H,B)]),
 1484  M:ref_clause(r(rule(H,B1),R1,Score)),
 1485  permutation(B,B1).
 1486
 1487already_scored(R,R1,M,Score):-
 1488  elab_ref(R,RR),
 1489  M:ref(r(RR,R1,Score)).
 1490
 1491
 1492elab_clause_ref(rule(_NR,H,B,_Lits),rule(H1,B1)):-
 1493  copy_term((H,B),(H1,B1)).
 1494
 1495elab_ref([],[]).
 1496
 1497elab_ref([rule(_NR,H,B,_Lits)|T],[rule(H1,B1)|T1]):-!,
 1498  copy_term((H,B),(H1,B1)),
 1499  numbervars((H1,B1),0,_N),
 1500  elab_ref(T,T1).
 1501
 1502elab_ref([def_rule(H,B,_Lits)|T],[rule(H1,B1)|T1]):-
 1503  copy_term((H,B),(H1,B1)),
 1504  numbervars((H1,B1),0,_N),
 1505  elab_ref(T,T1).
 1506
 1507%insertion in the beam
 1508insert_in_order([],C,BeamSize,[C]):-
 1509  BeamSize>0,!.
 1510
 1511insert_in_order(Beam,_New,0,Beam):-!.
 1512
 1513insert_in_order([[Th1,Heuristic1|Rest1]|RestBeamIn],[Th,Heuristic|Rest],BeamSize,BeamOut):-
 1514  Heuristic>Heuristic1,!,
 1515  % larger heuristic, insert here
 1516  NewBeam=[[Th,Heuristic|Rest],[Th1,Heuristic1|Rest1]|RestBeamIn],
 1517  length(NewBeam,L),
 1518  (L>BeamSize->
 1519    nth1(L,NewBeam,_Last,BeamOut)
 1520  ;
 1521    BeamOut=NewBeam
 1522  ).
 1523
 1524insert_in_order([[Th1,Heuristic1|Rest1]|RestBeamIn],[Th,Heuristic|Rest],BeamSize,
 1525[[Th1,Heuristic1|Rest1]|RestBeamOut]):-
 1526  BeamSize1 is BeamSize -1,
 1527  insert_in_order(RestBeamIn,[Th,Heuristic|Rest],BeamSize1,
 1528  RestBeamOut).
 1529
 1530
 1531
 1532remove_int_atom_list([],[]).
 1533
 1534remove_int_atom_list([\+ A|T],[\+ A1|T1]):-!,
 1535  A=..[F,_|Arg],
 1536  A1=..[F|Arg],
 1537  remove_int_atom_list(T,T1).
 1538
 1539remove_int_atom_list([A|T],[A1|T1]):-
 1540  A=..[F,_|Arg],
 1541  A1=..[F|Arg],
 1542  remove_int_atom_list(T,T1).
 1543
 1544
 1545
 1546remove_int_atom(\+ A,\+ A1):-!,
 1547  A=..[F,_|T],
 1548  A1=..[F|T].
 1549
 1550remove_int_atom(A,A1):-
 1551  A=..[F,_|T],
 1552  A1=..[F|T].
 1553
 1554
 1555get_heads([],[]).
 1556
 1557get_heads([_-H|T],[H|TN]):-
 1558  get_heads(T,TN).
 1559
 1560randomize([],[]):-!.
 1561
 1562randomize([rule(N,V,NH,HL,BL,LogF)|T],[rule(N,V,NH,HL1,BL,LogF)|T1]):-
 1563  length(HL,L),
 1564  Int is 1.0/L,
 1565  randomize_head(Int,HL,0,HL1),
 1566  randomize(T,T1).
 1567
 1568randomize_head(_Int,['':_],P,['':PNull1]):-!,
 1569  PNull is 1.0-P,
 1570  (PNull>=0.0->
 1571    PNull1 =PNull
 1572  ;
 1573    PNull1=0.0
 1574  ).
 1575
 1576randomize_head(Int,[H:_|T],P,[H:PH1|NT]):-
 1577  PMax is 1.0-P,
 1578  random(0,PMax,PH1),
 1579  P1 is P+PH1,
 1580  randomize_head(Int,T,P1,NT).
 1581
 1582
 1583
 1584update_head([],[],_N,[]):-!.
 1585
 1586update_head([H:_P|T],[PU|TP],N,[H:P|T1]):-
 1587  P is PU/N,
 1588  update_head(T,TP,N,T1).
 1589
 1590/* utilities */
 1591
 1592
 1593rules2terms(R,T):-
 1594  maplist(rule2term,R,T).
 1595
 1596rule2term(rule(_N,HL,BL,_Lit),(H:-B)):-!,
 1597  list2or(HL,H),
 1598  list2and(BL,B).
 1599
 1600rule2term(def_rule(H,BL,_Lit),((H:1.0):-B)):-
 1601  list2and(BL,B).
 1602
 1603
 1604and2list((A,B),[A|L]):-
 1605  !,
 1606  and2list(B,L).
 1607
 1608and2list(A,[A]).
 1609
 1610write_rules_anyburl(R,File):-
 1611  open(File,write,S),
 1612  maplist(print_rule(S),R),
 1613  close(S).
 1614
 1615print_rule(S, (H:P :- true) ):-!,
 1616  copy_term(H,H1),
 1617  triple_to_atom(H1,HA),
 1618  numbervars(HA,23,_),
 1619  Supp is round(1000000*P),
 1620  format(S,"1000000\t~w\t~w\t~w <= ~n",[Supp,P,HA]).
 1621
 1622print_rule(S, (H:P :- B) ):-
 1623  copy_term((H,B),(H1,B1)),
 1624  triple_to_atom(H1,HA),
 1625  numbervars(HA,23,_),
 1626  and2list(B1,BL),
 1627  maplist(triple_to_atom,BL,BLA),
 1628  numbervars(BLA,0,_),
 1629  Supp is round(1000000*P),
 1630  format(S,"1000000\t~w\t~w\t~w <= ",[Supp,P,HA]),
 1631  write_body_ab(S,BLA).
 1632
 1633triple_to_atom(H,HA):-
 1634  H=..[_,S,R,T],
 1635  (R=i(RR)->
 1636    HA=..[RR,T,S]
 1637  ;
 1638    HA=..[R,S,T]
 1639  ).
 1640
 1641write_body_ab(S,[A]):-!,
 1642  write(S,A),nl(S).
 1643
 1644write_body_ab(S,[A|T]):-
 1645  write(S,A),write(S,', '),
 1646  write_body_ab(S,T).
 1647
 1648
 1649
 1650
 1651write_rules_kg(R,File):-
 1652  open(File,write,S),
 1653  writeln(S,'out(['),
 1654  write_clauses_kg(R,S),
 1655  writeln(S,']).'),
 1656  close(S).
 1657
 1658
 1659write_rules_kg(R):-
 1660  maplist(write_clause_kg_screen,R).
 1661
 1662write_clause_kg_screen(Cl):-
 1663  write_clause_kg(user_output,Cl),
 1664  writeln('.').
 1665
 1666write_clauses_kg([Cl],S):-!,
 1667  write(S,'('),
 1668  write_clause_kg(S,Cl),
 1669  writeln(S,')').
 1670
 1671write_clauses_kg([ClH|ClT],S):-
 1672  write(S,'('),
 1673  write_clause_kg(S,ClH),
 1674  writeln(S,'),'),
 1675  write_clauses_kg(ClT,S).
 1676
 1677write_clause_kg(S,(H :- true)):-!,
 1678  copy_term(H,H1),
 1679  numbervars(H1,0,_),
 1680  write_head_kg(H1,S),
 1681  format(S,' :-',[]),
 1682  write_body_kg([],S).
 1683
 1684write_clause_kg(S,(H:-B)):-
 1685  copy_term((H,B),(H1,B1)),
 1686  numbervars((H1,B1),0,_),
 1687  write_head_kg(H1,S),
 1688  format(S,' :-',[]),
 1689  and2list(B1,L),
 1690  write_body_kg(L,S).
 1691
 1692write_head_kg(A:P,S):-
 1693  format(S,"~q:~g",[A,P]).
 1694
 1695write_body_kg([],S):-!,
 1696  format(S,'  true',[]).
 1697
 1698write_body_kg([A],S):-!,
 1699  format(S,'  ~q',[A]).
 1700
 1701write_body_kg([A|T],S):-
 1702  format(S,'  ~q,',[A]),
 1703  write_body_kg(T,S).
 1704
 1705
 1706read_rules_anyburl(File,R):-
 1707  phrase_from_file(rules(R),File).
 1708
 1709
 1710rules([H|T])-->
 1711  rule(H),!,
 1712  rules(T).
 1713
 1714rules([])--> blanks_to_nl,[].
 1715
 1716rule(((tt(X,R,Y):C):-BC))-->
 1717  integer(_SB),
 1718  "\t",
 1719  integer(_S),
 1720  "\t",
 1721  float(C),
 1722  "\t",
 1723  atm(t(X,R,Y),[],V),
 1724  " <= ",
 1725  body(B,V,_),
 1726  {list2and(B,BC)}.
 1727
 1728atm(A,V0,V)-->
 1729  string_without("\n\t(",P),
 1730  {atom_string(PA,P)},
 1731  "(",
 1732  param(Par1,V0,V1),
 1733  ",",
 1734  param(Par2,V1,V),
 1735  ")",
 1736  {A=t(Par1,PA,Par2)}.
 1737
 1738body([],V,V)-->
 1739  "\n",!.
 1740
 1741body([A],V0,V)-->
 1742  atm(A,V0,V),"\n",!.
 1743
 1744body([A|T],V0,V)-->
 1745  atm(A,V0,V1),
 1746  ", ",!,
 1747  body(T,V1,V).
 1748
 1749
 1750
 1751param(Var,V0,V)-->
 1752  prolog_var_name(P),
 1753  {atom_length(P,1),!,find_var(P,V0,V,Var)}.
 1754
 1755param(PA,V,V)-->
 1756  string_without(",)",P),
 1757  {atom_string(PA,P)}.
 1758
 1759find_var(VN,V0,V0,V):-
 1760  member(VN:V,V0),!.
 1761
 1762find_var(VN,V0,[VN:V|V0],V).
 1763
 1764
 1765
 1766
 1767
 1768write_rules([],_S).
 1769
 1770write_rules([rule(_N,HL,BL,Lit)|T],S):-!,
 1771  copy_term((HL,BL,Lit),(HL1,BL1,Lit1)),
 1772  numbervars((HL1,BL1,Lit1),0,_M),
 1773  write_disj_clause(S,(HL1:-BL1)),
 1774  write_rules(T,S).
 1775
 1776write_rules([def_rule(H,BL,Lit)|T],S):-
 1777  copy_term((H,BL,Lit),(H1,BL1,Lit1)),
 1778  numbervars((H1,BL1,Lit1),0,_M),
 1779  write_disj_clause(S,([H1:1.0]:-BL1)),
 1780  write_rules(T,S).
 1781
 1782
 1783new_par([],[],[]).
 1784
 1785new_par([HP|TP],[Head:_|TO],[Head:HP|TN]):-
 1786  new_par(TP,TO,TN).
 1787
 1788
 1789
 1790write_disj_clause(S,(H:-[])):-!,
 1791  write_head(S,H),
 1792  format(S,".~n~n",[]).
 1793
 1794write_disj_clause(S,(H:-B)):-
 1795  write_head(S,H),
 1796  format(S,' :-',[]),
 1797  nl(S),
 1798  write_body(S,B).
 1799
 1800
 1801write_head(S,[A:1.0|_Rest]):-!,
 1802  format(S,"~q:1.0",[A]).
 1803
 1804write_head(S,[A:P,'':_P]):-!,
 1805  format(S,"~q:~g",[A,P]).
 1806
 1807write_head(S,[A:P]):-!,
 1808  format(S,"~q:~g",[A,P]).
 1809
 1810write_head(S,[A:P|Rest]):-
 1811  format(S,"~q:~g ; ",[A,P]),
 1812  write_head(S,Rest).
 1813
 1814write_body(S,[]):-!,
 1815  format(S,"  true.~n~n",[]).
 1816
 1817write_body(S,[A]):-!,
 1818  format(S,"  ~q.~n~n",[A]).
 1819
 1820write_body(S,[A|T]):-
 1821  format(S,"  ~q,~n",[A]),
 1822  write_body(S,T).