home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / CLIPPER / MISC / AIE9003.ZIP / EXEC.ARI < prev    next >
Encoding:
Text File  |  1989-12-28  |  25.7 KB  |  779 lines
  1.  
  2. :- module exec.
  3.  
  4. /*
  5. This is the main part of the BNET neural network, implemented in
  6. Arity Prolog.  However, some of the I/O uses Instant Recall's Prolog
  7. Tools.  If you don't have these tools, here is how you can run this
  8. program:
  9.  
  10. 1.  Define trace_message either to trivially succeed, or so that
  11.     when its first argument succeeds, it writes out its last two
  12.     aarguments.
  13.  
  14. 2.  Define  getglobal / 2  and setglobal / 2  to set and get the
  15.     values of a global variable.
  16.  
  17. 3.  Comment out init_log_file and close_log_file.
  18.  
  19. 4.  Change the log_xxx predicates to simply xxx (e.g. log_write to write).
  20. */
  21.  
  22.  
  23.  
  24. :- extrn     trace_message / 3 : far.
  25. :- extrn      getglobal / 2  : far .
  26. :- extrn       setglobal / 2  : far .
  27. :- extrn     net_trace / 1 : interp .
  28. :- extrn     number_data_items / 1 : interp .
  29. :- extrn     learning_rate / 1 : interp .
  30. :- extrn     neuron_change / 3 : interp .
  31. :- extrn     input  / 3 : interp.
  32. :- extrn     output / 3 : interp.
  33. :- extrn     state  / 6 : interp.
  34. :- extrn     state  / 5 : interp.
  35. :- extrn     net_trace / 0       : interp.
  36. :- extrn     neuron_change / 4   : interp.
  37. :- extrn     neuron / 3          : interp.
  38. :- extrn       init_log_file / 0:far.
  39. :- extrn       close_log_file / 0 : far.
  40. :- extrn       log_put        / 1 : far.
  41. :- extrn       log_nl         / 0 : far.
  42. :- extrn       log_tab        / 1 : far.
  43. :- extrn       log_write      / 1 : far.
  44.  
  45. :- visible write_out_net_hlpr / 1.
  46.  
  47. :- public    main_hlpr  / 0 : far.
  48.  
  49. main_hlpr :-
  50.     signon,
  51.     init_log_file,
  52.     reconsult( $net.cfg$),
  53.     get_net,
  54.     !,
  55.     run_net,
  56.     close_log_file .
  57.  
  58. signon :-
  59.    MESSAGE = $
  60.  
  61.  
  62.              BAYSEAN OR OF ANDS NETWORK
  63.  
  64.              (C) Copyright 1989 by Instant Recall
  65.                  All rights reserved.
  66.  
  67.                   Instant Recall
  68.                   P.O. Box 30134
  69.                   Bethesda, Md. 20814
  70.                   (301) 530-0898
  71.  
  72.           Under the licence granted by Instant Recall you can
  73.           use this program non-commercially provided you
  74.           leave the copyright notice in all unchanged copies
  75.           of the program.  This program may not be used
  76.           commercially except by written permission of
  77.           Instant Recall.
  78.  
  79.  
  80. >> I agree to these conditions for use of the program ( y or n) :$,
  81.         cls,
  82.         log_write( MESSAGE),
  83.         get0_noecho( C ),
  84.         log_put( C ),
  85.         ( C == `y ; C == `Y ),
  86.         log_nl.
  87. get_net :-
  88.     write($Name of net : $),
  89.     flush,
  90.     read_string( 100, X),
  91.     reconsult( X ),
  92.     nl.
  93.  
  94.  
  95. get_cycles( CYCLES ) :-
  96.     write($Number of cycles : $),
  97.     flush,
  98.     read_string( 100, X),
  99.     int_text( CYCLES, X ),
  100.     nl.
  101.  
  102. run_net :-
  103.     get_cycles( CYCLES ),
  104.           trace_message( net_trace,
  105.                          $e run_net$,
  106.                          $$      ),
  107.      set_network_clock( 0 ),
  108.      repeat,
  109.      get_network_clock( TIME ),
  110.        cycle1( TIME ),
  111.       increment_network_clock( TIME1),
  112.        TIME1 = CYCLES,
  113.        save_net( CYCLES ).
  114.  
  115.  
  116. %%%%%%%%%%%%%%% cycle1 - run net at time T %%%%%%%%%%%%%%%%%%%%%%%%%%%
  117.  
  118. cycle1( TIME ) :-
  119.           trace_message( net_trace,
  120.                          $e cycle1, TIME =$,
  121.                          TIME      ),
  122.      clean_up( TIME  ),
  123.      find_data_key( TIME, KEY ),
  124.           trace_message( net_trace,
  125.                          $...KEY =$,
  126.                          KEY     ),
  127.      run1( TIME, KEY ),
  128.      report_performance( TIME, KEY ) ,
  129.      adjust( TIME, KEY ).
  130.  
  131. report_performance( TIME, KEY ) :-
  132.           log_write( $Errors at time $),
  133.           log_write( TIME ),
  134.           log_write( $ : $),
  135.           call( state( neuron,
  136.                        or    ,
  137.                        NEURON_NUMBER,
  138.                        TIME,
  139.                        ACTIVATION ) ),
  140.           call( output(  KEY, NEURON_NUMBER, DESIRED )),
  141.           ERROR is DESIRED - ACTIVATION,
  142.           log_write( NEURON_NUMBER ),
  143.           log_tab(1),
  144.           log_write( ERROR  ),
  145.           log_nl,
  146.           fail.
  147. report_performance( _ , _  ) :- !.
  148.  
  149.  
  150. net_output_error.
  151.  
  152.  
  153. save_net( TIME   ) :-
  154.    write($Net save file: $),
  155.    flush,
  156.    read_string( 12 , X),
  157.    write_out_net_hlpr( TIME   )  ,
  158.    stdout( X, write_out_net_hlpr( TIME   )  ).
  159.  
  160. write_out_net_hlpr( TIME   )  :-
  161.    listing( number_data_items ),
  162.    listing( input ),
  163.    listing( output ),
  164.    listing( neuron ),
  165.    write_out_edges( TIME   ) .
  166.  
  167. write_out_edges( TIME   )  :-
  168.      call( state( edge,
  169.                   KIND,
  170.                   INPUT_NEURON ,
  171.                   OUTPUT_NEURON,
  172.                   TIME,
  173.                   ACTIVATION)),
  174.      writeq( state( edge,
  175.                     KIND,
  176.                     INPUT_NEURON ,
  177.                     OUTPUT_NEURON,
  178.                     0   ,
  179.                     ACTIVATION)),
  180.       put(`.),
  181.       nl,
  182.       fail.
  183. write_out_edges( _      )  :- !.
  184.  
  185.  
  186.  
  187. :- mode increment_network_clock( - ).
  188.  
  189. increment_network_clock( TIME ) :-
  190.       getglobal( time, TIME0),
  191.       !,
  192.       TIME  is TIME0 +1,
  193.       setglobal( time, TIME ).
  194.  
  195. increment_network_clock( 0  ) :-
  196.       setglobal( time, 0 ).
  197.  
  198. set_network_clock( TIME ) :-
  199.       setglobal( time, TIME ).
  200.  
  201. get_network_clock( TIME ) :-
  202.       getglobal( time, TIME ).
  203.  
  204. run1( TIME , KEY ) :-
  205.           trace_message( net_trace,
  206.                          $e run1, TIME = $,
  207.                          TIME    ),
  208.      input_neuron_activations( TIME, KEY  ),
  209.      !,
  210.      not_neuron_activations( TIME , KEY  ),
  211.      !,
  212.      and_neuron_activations( TIME , KEY ),
  213.      !,
  214.      or_neuron_activations( TIME , KEY ),
  215.           trace_message( net_trace,
  216.                          $x run1, TIME = $,
  217.                          TIME    ),
  218.      trace_net_edges( TIME ),
  219.      !,
  220.      trace_net_activations( TIME ).
  221.  
  222. trace_net_activations( TIME ) :-
  223.           call( cycle_trace),
  224.           log_write( $Activations at $),
  225.           log_write( TIME ),
  226.           log_nl,
  227.           call( state( neuron,
  228.                        _     ,
  229.                        NEURON_NUMBER,
  230.                        TIME,
  231.                        ACTIVATION)),
  232.           log_write( NEURON_NUMBER ),
  233.           log_tab(1),
  234.           log_write( ACTIVATION ),
  235.           log_nl,
  236.           fail.
  237. trace_net_activations( _    ) :- !.
  238.  
  239. trace_net_edges( TIME ) :-
  240.           call( cycle_trace),
  241.           log_write( $Edges at $),
  242.           log_write( TIME ),
  243.           log_nl,
  244.           call( state( edge  ,
  245.                        _     ,
  246.                        INPUT_NUMBER,
  247.                        OUTPUT_NUMBER,
  248.                        TIME,
  249.                        ACTIVATION)),
  250.           log_write( INPUT_NUMBER ),
  251.           log_tab(1),
  252.           log_write( OUTPUT_NUMBER ),
  253.           log_tab(1),
  254.           log_write( ACTIVATION ),
  255.           log_nl,
  256.           fail.
  257. trace_net_edges( _    ) :- !.
  258.  
  259.  
  260. adjust( TIME  , KEY ) :-
  261.           trace_message( net_trace,
  262.                          $e adjust1, TIME = $,
  263.                          TIME    ),
  264.      adjust_or_edges( TIME , KEY ),
  265.      !,
  266.      adjust_and_edges( TIME , KEY ),
  267.           trace_message( net_trace,
  268.                          $x adjust1, TIME = $,
  269.                          TIME    ).
  270.  
  271.  
  272. clean_up( TIME )   :-
  273.           TIME2 is TIME - 2,
  274.          retractall(  neuron_change(  _, % KIND,
  275.                                       TIME2,
  276.                                       _ , % INPUT_NEURON,
  277.                                       _  /* TOTAL_CHANGE  */ )),
  278.          retractall( state( edge  ,
  279.                             _, % type
  280.                             _ , % INPUT_NEURON,
  281.                             _ , % OUTPUT_NEURON,
  282.                             TIME2,
  283.                             _  /* NEW  */  ) ),
  284.          retractall( state( neuron,
  285.                             _, % type
  286.                             _ , % number ,
  287.                             TIME2,
  288.                             _  /* NEW  */  ) ).
  289.  
  290. find_data_key( TIME, KEY ) :-
  291.          call( number_data_items( MOD ) ),
  292.          KEY is TIME mod  MOD .
  293.  
  294.  
  295.  
  296. %%%%%%%%%%%%%%% compute activations of neurons %%%%%%%%%%%%%%%%%%%%%%%
  297.  
  298. input_neuron_activations( TIME, KEY  ) :-
  299.        call( input(  KEY, NEURON_NUMBER, ACTIVATION) ),
  300.        asserta( state( neuron,
  301.                        input ,
  302.                        NEURON_NUMBER,
  303.                        TIME,
  304.                        ACTIVATION)),
  305.        fail.
  306. input_neuron_activations( _ , _   ).
  307.  
  308. not_neuron_activations( TIME , KEY  ) :-
  309.           trace_message( not_trace,
  310.                          $e not_neuron_activations, args = $,
  311.                          [ TIME , KEY  ]   ),
  312.        call( neuron(   not( NEURON_NUMBER2 ) , NEURON_NUMBER , _  )),
  313.           trace_message( not_trace,
  314.                          $...NEURON_NUMBER = $,
  315.                          NEURON_NUMBER    ),
  316.        call( input(  KEY, NEURON_NUMBER2, ACTIVATION) ),
  317.        ACTIVATION2 is 1 - ACTIVATION ,
  318.           trace_message( not_trace,
  319.                          $...ACTIVATION2 = $,
  320.                          ACTIVATION2    ),
  321.        asserta( state( neuron,
  322.                        input ,
  323.                        NEURON_NUMBER,
  324.                        TIME,
  325.                        ACTIVATION2) ),
  326.        fail.
  327. not_neuron_activations( _  , _    ) :-  !.
  328.  
  329. get_current_neuron_data( KIND, TIME , NUMBER, ACTIVATION ) :-
  330.        TIME > 0,
  331.        TIME0 is TIME - 1,
  332.        call(   state( neuron,
  333.                       KIND  ,
  334.                       NUMBER,
  335.                       TIME0 ,
  336.                       ACTIVATION ) ).
  337.  
  338. get_current_neuron_data( KIND, _    , NUMBER, ACTIVATION ) :-
  339.        call( neuron(   KIND , NUMBER , _  )),
  340.        (     KIND == and,
  341.              ACTIVATION = 0
  342.           ;
  343.              KIND == or,
  344.              ACTIVATION = 1
  345.        ).
  346.  
  347. and_neuron_activations( TIME , KEY ) :-
  348.           trace_message( and_trace,
  349.                          $e and_neuron_activations, TIME = $,
  350.                          TIME    ),
  351.        get_current_neuron_data( and, TIME , NUMBER, ACTIVATION ),
  352.           trace_message( and_trace,
  353.                          $...current activation : $,
  354.                          [  NUMBER, ACTIVATION  ]   ),
  355.        and_neuron_activation( TIME,
  356.                               KEY,
  357.                               NUMBER,
  358.                               ACTIVATION,
  359.                               NEW_ACTIVATION ),
  360.           trace_message( and_trace,
  361.                          $...new activation : $,
  362.                          [  NUMBER, NEW_ACTIVATION  ]   ),
  363.        fail.
  364. and_neuron_activations( _  , _   ) :- !.
  365.  
  366. or_neuron_activations( TIME , KEY ) :-
  367.           trace_message( or_trace,
  368.                          $e or_neuron_activations, TIME = $,
  369.                          TIME    ),
  370.        get_current_neuron_data( or , TIME , NUMBER, ACTIVATION ),
  371.        or_neuron_activation( TIME,
  372.                              KEY,
  373.                              NUMBER,
  374.                              ACTIVATION,
  375.                              _ /* NEW_ACTIVATION */ ),
  376.        fail.
  377. or_neuron_activations( _  , _   ) :- !.
  378.  
  379.  
  380. and_neuron_activation( TIME,
  381.                        _ , % KEY,
  382.                        NUMBER,
  383.                        _ , % ACTIVATION,
  384.                        _ /* NEW_ACTIVATION */ ) :-
  385.           trace_message( and_trace,
  386.                          $e and_neuron_activation, NUMBER = $,
  387.                          NUMBER    ),
  388.        setglobal( temp_and, 1 ),
  389.        call(      state( neuron,
  390.                          input,
  391.                          INPUT_NUMBER,
  392.                          TIME,
  393.                          INPUT_ACTIVATION ) ),
  394.           trace_message( and_trace,
  395.                          $.....INPUT_ACTIVATION = $,
  396.                          INPUT_ACTIVATION    ),
  397.        call(      state( edge  ,
  398.                          and ,
  399.                          INPUT_NUMBER ,
  400.                          NUMBER ,
  401.                          TIME  ,
  402.                          EDGE_ACTIVATION   )   ) ,
  403.            trace_message( and_trace,
  404.                           $.....EDGE_ACTIVATION = $,
  405.                           EDGE_ACTIVATION    ),
  406.        and_contribution( INPUT_ACTIVATION, EDGE_ACTIVATION, CONTRIBUTION ),
  407.            trace_message( and_trace,
  408.                           $.....CONTRIBUTION = $,
  409.                           CONTRIBUTION    ),
  410.        getglobal( temp_and, SO_FAR ),
  411.        NEW_SO_FAR is SO_FAR * CONTRIBUTION,
  412.            trace_message( and_trace,
  413.                           $.....NEW_SO_FAR  = $,
  414.                           NEW_SO_FAR     ),
  415.        setglobal( temp_and, NEW_SO_FAR ),
  416.        fail.
  417.  
  418. and_neuron_activation( TIME,
  419.                        _ , % KEY,
  420.                        NUMBER,
  421.                        _ , % ACTIVATION,
  422.                        NEW_ACTIVATION ) :-
  423.        getglobal( temp_and, NEW_ACTIVATION   ),
  424.        retractall( state( neuron, _  , NUMBER, TIME, _ )),
  425.        asserta(   state( neuron,
  426.                          and  ,
  427.                          NUMBER,
  428.                          TIME,
  429.                          NEW_ACTIVATION ) ),
  430.         !.
  431.  
  432. and_contribution( _ , %INPUT_ACTIVATION,
  433.                   EDGE_ACTIVATION,
  434.                   CONTRIBUTION ) :-
  435.             EDGE_ACTIVATION ==0,
  436.             CONTRIBUTION = 1,
  437.             !.
  438. and_contribution( INPUT_ACTIVATION, EDGE_ACTIVATION, CONTRIBUTION ) :-
  439.      power( INPUT_ACTIVATION, EDGE_ACTIVATION, CONTRIBUTION ) .
  440.  
  441. power( A, B , C ) :-
  442.       A > 0,
  443.       C is exp( ln( A ) * B ),
  444.       !.
  445. power( _, _ , 0 ) :- !.
  446.  
  447. or_neuron_activation( TIME,
  448.                       _ , % KEY,
  449.                       NUMBER,
  450.                       _ , % ACTIVATION,
  451.                       _ /* NEW_ACTIVATION */ ) :-
  452.           trace_message( or_trace,
  453.                          $e or_neuron_activation, NUMBER = $,
  454.                          NUMBER    ),
  455.        setglobal( temp_or , 0 ),
  456.        call(      state( neuron,
  457.                          and  ,
  458.                          INPUT_NUMBER,
  459.                          TIME,
  460.                          INPUT_ACTIVATION ) ),
  461.           trace_message( or_trace,
  462.                          $.....INPUT_ACTIVATION = $,
  463.                          INPUT_ACTIVATION    ),
  464.        call(      state( edge  ,
  465.                          or  ,
  466.                          INPUT_NUMBER ,
  467.                          NUMBER ,
  468.                          TIME  ,
  469.                          EDGE_ACTIVATION   )   ) ,
  470.           trace_message( or_trace,
  471.                          $.....EDGE_ACTIVATION = $,
  472.                          EDGE_ACTIVATION    ),
  473.        getglobal( temp_or , SO_FAR ),
  474.        CONTRIBUTION is EDGE_ACTIVATION
  475.                        * INPUT_ACTIVATION
  476.                        * ( 1 - SO_FAR ) ,
  477.            trace_message( or_trace,
  478.                           $.....CONTRIBUTION = $,
  479.                           CONTRIBUTION    ),
  480.        NEW_SO_FAR is SO_FAR + CONTRIBUTION ,
  481.            trace_message( or_trace,
  482.                           $.....NEW_SO_FAR  = $,
  483.                           NEW_SO_FAR     ),
  484.        setglobal( temp_or , NEW_SO_FAR ),
  485.        fail.
  486.  
  487. or_neuron_activation( TIME,
  488.                       _ , % KEY,
  489.                       NUMBER,
  490.                       _ , % ACTIVATION,
  491.                       NEW_ACTIVATION ) :-
  492.        getglobal( temp_or , NEW_ACTIVATION ),
  493.        retractall( state( neuron, _  , NUMBER, TIME, _ )),
  494.        asserta(   state( neuron,
  495.                          or   ,
  496.                          NUMBER,
  497.                          TIME,
  498.                          NEW_ACTIVATION ) ).
  499.  
  500.  
  501.  
  502. %%%%%%%%%%%%%%% adjust edge weights %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  503.  
  504.  
  505.  
  506. adjust_or_edges( TIME , KEY ) :-
  507.           trace_message( or_learn_trace,
  508.                          $e adjust_or_edges, TIME = $,
  509.                          TIME    ),
  510.         retract( state( edge  ,
  511.                         or,
  512.                         INPUT_NEURON,
  513.                         OUTPUT_NEURON,
  514.                         TIME,
  515.                         EDGE_ACTIVATION ) ),
  516.          adjust_or_hlpr( KEY,
  517.                          state( edge  ,
  518.                                 or,
  519.                                 INPUT_NEURON,
  520.                                 OUTPUT_NEURON,
  521.                                 TIME,
  522.                                 EDGE_ACTIVATION ) ) ,
  523.          fail.
  524. adjust_or_edges( _    , _   ) :- !.
  525.  
  526. adjust_or_hlpr( KEY,
  527.                 state( edge  ,
  528.                        or,
  529.                        INPUT_NEURON,
  530.                        OUTPUT_NEURON,
  531.                        TIME,
  532.                        EDGE_ACTIVATION ) )  :-
  533.           trace_message( or_learn_trace,
  534.                          $...updating $,
  535.                          [ INPUT_NEURON, OUTPUT_NEURON ] ),
  536.         call( output(  KEY,
  537.                        OUTPUT_NEURON,
  538.                        DESIRED_OUTPUT )) ,
  539.         !,
  540.           trace_message( or_learn_trace,
  541.                          $...DESIRED_OUTPUT = $,
  542.                          DESIRED_OUTPUT ),
  543.         call( state( neuron,
  544.                       or ,
  545.                       OUTPUT_NEURON,
  546.                       TIME,
  547.                       OUTPUT_ACTIVATION) ),
  548.         !,
  549.           trace_message( or_learn_trace,
  550.                          $...OUTPUT_ACTIVATION = $,
  551.                          OUTPUT_ACTIVATION ),
  552.         TIME1 is TIME + 1,
  553.         call( state( neuron,
  554.                       and  ,
  555.                       INPUT_NEURON,
  556.                       TIME,
  557.                       INPUT_ACTIVATION) ),
  558.         !,
  559.           trace_message( or_learn_trace,
  560.                          $... INPUT_ACTIVATION = $,
  561.                           INPUT_ACTIVATION ),
  562. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  563. %    Edges to output layer, Desired > actual                                %
  564. %       NEW := CURRENT                                                      %
  565. %              +( 1 -  CURRENT )  * ( DESIRED  - ACTUAL ) * LAYER_2_OUTPUT  %
  566. %    Edges to output layer, Desired < actual                                %
  567. %       NEW := CURRENT                                                      %
  568. %              -   CURRENT  * ( ACTUAL - DESIRED  ) * LAYER_2_OUTPUT        %
  569. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  570.          (       DESIRED_OUTPUT  >  OUTPUT_ACTIVATION ,
  571.                  NEW is EDGE_ACTIVATION
  572.                         +( 1 -  EDGE_ACTIVATION )
  573.                          * ( DESIRED_OUTPUT  - OUTPUT_ACTIVATION )
  574.                          * INPUT_ACTIVATION
  575.              ;
  576.                  DESIRED_OUTPUT  <  OUTPUT_ACTIVATION ,
  577.                  NEW is EDGE_ACTIVATION
  578.                         -   EDGE_ACTIVATION
  579.                         * ( OUTPUT_ACTIVATION - DESIRED_OUTPUT  )
  580.                          * INPUT_ACTIVATION
  581.              ;
  582.                  DESIRED_OUTPUT  == OUTPUT_ACTIVATION ,
  583.                  NEW is EDGE_ACTIVATION
  584.           ),
  585.         !,
  586.           trace_message( or_learn_trace,
  587.                          $... NEW = $,
  588.                          NEW ),
  589.         !,
  590.         CHANGE is NEW - EDGE_ACTIVATION ,
  591.           trace_message( or_learn_trace,
  592.                          $... CHANGE = $,
  593.                          CHANGE ),
  594.         !,
  595.           weighted_average( EDGE_ACTIVATION ,
  596.                             NEW,
  597.                             NEW_EDGE_ACTIVATION),
  598.           trace_message( or_learn_trace,
  599.                          $... NEW_EDGE_ACTIVATION = $,
  600.                          NEW_EDGE_ACTIVATION ),
  601.         retractall( state( edge,
  602.                            or,
  603.                         INPUT_NEURON,
  604.                         OUTPUT_NEURON,
  605.                         TIME,
  606.                         _    ) ),
  607.         !,
  608.         TIME1 is TIME + 1,
  609.         assertz( state( edge  ,
  610.                         or,
  611.                         INPUT_NEURON,
  612.                         OUTPUT_NEURON,
  613.                         TIME1,
  614.                         NEW_EDGE_ACTIVATION  ) ),
  615.         % now add component to change in input neuron
  616.         INPUT_NEURON_CHANGE is EDGE_ACTIVATION
  617.                                * ( DESIRED_OUTPUT  - OUTPUT_ACTIVATION ) ,
  618.         !,
  619.         update_input_neuron_change( and,
  620.                                     TIME,
  621.                                     INPUT_NEURON,
  622.                                     INPUT_NEURON_CHANGE ).
  623.  
  624. update_input_neuron_change( KIND,
  625.                             TIME,
  626.                             INPUT_NEURON,
  627.                             INPUT_NEURON_CHANGE ) :-
  628.         (  retract(  neuron_change(  KIND,
  629.                                      TIME,
  630.                                      INPUT_NEURON,
  631.                                      SOFAR  )),
  632.            !
  633.           ;
  634.            SOFAR = 0
  635.          ),
  636.          TOTAL_CHANGE is SOFAR + INPUT_NEURON_CHANGE,
  637.          asserta(  neuron_change(  KIND,
  638.                                    TIME,
  639.                                    INPUT_NEURON,
  640.                                    TOTAL_CHANGE )).
  641.  
  642.  
  643.  
  644. adjust_and_edges( TIME , _   ) :-
  645.           trace_message( and_learn_trace,
  646.                          $e adjust_or_edges, TIME = $,
  647.                          TIME    ),
  648.         retract( state( edge  ,
  649.                         and,
  650.                         INPUT_NEURON,
  651.                         OUTPUT_NEURON,
  652.                         TIME,
  653.                         EDGE_ACTIVATION ) ),
  654.          adjust_and_hlpr( state( edge  ,
  655.                                  and,
  656.                                  INPUT_NEURON,
  657.                                  OUTPUT_NEURON,
  658.                                  TIME,
  659.                                  EDGE_ACTIVATION ) ) ,
  660.          fail.
  661. adjust_and_edges( _    , _   ) :- !.
  662.  
  663. adjust_and_hlpr( state( edge  ,
  664.                         and,
  665.                         INPUT_NEURON,
  666.                         OUTPUT_NEURON,
  667.                         TIME,
  668.                         EDGE_ACTIVATION ) )  :-
  669.         call( backprop_to_and_edges( off )),
  670.         TIME1 is TIME + 1,
  671.         asserta( state( edge  ,
  672.                         and,
  673.                         INPUT_NEURON,
  674.                         OUTPUT_NEURON,
  675.                         TIME1,
  676.                         EDGE_ACTIVATION ) )  .
  677.  
  678. adjust_and_hlpr( state( edge  ,
  679.                         and,
  680.                         INPUT_NEURON,
  681.                         OUTPUT_NEURON,
  682.                         TIME,
  683.                         EDGE_ACTIVATION ) )  :-
  684.           call( backprop_to_and_edges( on  )),
  685.           trace_message( and_learn_trace,
  686.                          $...updating $,
  687.                          [ INPUT_NEURON, OUTPUT_NEURON ] ),
  688.           trace_message( and_learn_trace,
  689.                          $current EDGE_ACTIVATION = $,
  690.                          EDGE_ACTIVATION  ),
  691.           call(  neuron_change(  and ,
  692.                                  TIME,
  693.                                  OUTPUT_NEURON,
  694.                                  TOTAL_CHANGE )),
  695.         !,
  696.           trace_message( and_learn_trace,
  697.                          $...output neuron_change = $,
  698.                          TOTAL_CHANGE ),
  699.         call( state( neuron,
  700.                       input  ,
  701.                       INPUT_NEURON,
  702.                       TIME,
  703.                       INPUT_ACTIVATION) ),
  704.           trace_message( and_learn_trace,
  705.                          $...INPUT_ACTIVATION = $,
  706.                          INPUT_ACTIVATION ),
  707.         !,
  708.          (        TOTAL_CHANGE   >  0   ,
  709.                  NEW is EDGE_ACTIVATION
  710.                         +( 1 -  EDGE_ACTIVATION )
  711.                          *  TOTAL_CHANGE
  712.                          * INPUT_ACTIVATION
  713.              ;
  714.                   TOTAL_CHANGE   <  0  ,
  715.                  NEW is EDGE_ACTIVATION
  716.                         +   EDGE_ACTIVATION
  717.                         *  TOTAL_CHANGE
  718.                          * INPUT_ACTIVATION
  719.              ;
  720.                   TOTAL_CHANGE is 0.0,
  721.                  NEW is EDGE_ACTIVATION
  722.           ),
  723.           trace_message( and_learn_trace,
  724.                          $... NEW = $,
  725.                          NEW ),
  726.         CHANGE is NEW - EDGE_ACTIVATION ,
  727.           trace_message( and_learn_trace,
  728.                          $... CHANGE = $,
  729.                          CHANGE ),
  730.           weighted_average( EDGE_ACTIVATION ,
  731.                             NEW,
  732.                             NEW_EDGE_ACTIVATION),
  733.           trace_message( and_learn_trace,
  734.                          $... NEW_EDGE_ACTIVATION = $,
  735.                          NEW_EDGE_ACTIVATION ),
  736.         retractall( state( edge,
  737.                            and,
  738.                         INPUT_NEURON,
  739.                         OUTPUT_NEURON,
  740.                         TIME,
  741.                         _    ) ),
  742.         !,
  743.         TIME1 is TIME + 1,
  744.         assertz( state( edge  ,
  745.                         and,
  746.                         INPUT_NEURON,
  747.                         OUTPUT_NEURON,
  748.                         TIME1,
  749.                         NEW_EDGE_ACTIVATION  ) ).
  750.  
  751.  
  752. weighted_average( EDGE_ACTIVATION ,
  753.                   NEW,
  754.                   NEW_EDGE_ACTIVATION) :-
  755.            call( learning_rate( R )),
  756.            NEW_EDGE_ACTIVATION is ( 1 - R ) * EDGE_ACTIVATION
  757.                                   + R * NEW.
  758.  
  759.  
  760. /*************************************************************************/
  761. /********* retractall : retracts all instances of a goal *****************/
  762. /*************************************************************************/
  763.  
  764.        % mode revised by rk 9-28-89
  765. :- mode retractall( +  ).
  766.  
  767. retractall( Name / Arity) :-
  768.         integer(Arity),
  769.         !,
  770.         functor(Term, Name, Arity),
  771.         retractall( Term).
  772. retractall( X) :-
  773.         retract(X),
  774.         fail.
  775. retractall( _).
  776.  
  777.  
  778. %%%%%%%%%%%%%%%%%%%%%% eof %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  779.