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

  173induce_lift(TrainFolds,P):-
  174  induce_rules(TrainFolds,P0),
  175  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 /

  186test_lift(P,TestFolds,LL,AUCROC,ROC,AUCPR,PR):-
  187  test_prob_lift(P,TestFolds,_NPos,_NNeg,LL,LG),
  188  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. /

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

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

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

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

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

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

  671filter_rules(M:R0,R):-
  672  M:local_setting(min_probability,Min_prob),
  673  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. /

  681filter_rules(R0,R,Min_prob):-
  682  (R0=[(_ :- _)|_]->
  683    rules2terms(R0At,R0),
  684    remove_clauses(R0At,Min_prob,RAt,_Num),
  685    rules2terms(RAt,R)
  686  ;
  687    remove_clauses(R0,Min_prob,R,_Num)  
  688  ).

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

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

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