Erlang/OTP Forums

   ann:connect(X1_pid, H1_pid),
   ann:connect(X1_pid, H2_pid),

convert_to_keys(Tuple_list) ->
   lists:map(fun(Tup) ->
               {Key, _} = Tup,
               Key
            end,
            Tuple_list).

1> ann:run().
<0.47.0> output connected to <0.49.0>: [<0.49.0>]
<0.48.0> output connected to <0.49.0>: [<0.49.0>]
<0.49.0> inputs connected to <0.47.0>: [{<0.47.0>,0.5}]
<0.50.0> inputs connected to <0.47.0>: [{<0.47.0>,0.5}]
<0.51.0> inputs connected to <0.49.0>: [{<0.49.0>,0.5}]
<0.49.0> inputs connected to <0.48.0>: [{<0.48.0>,0.5},{<0.47.0>,0.5}]
<0.50.0> inputs connected to <0.48.0>: [{<0.48.0>,0.5},{<0.47.0>,0.5}]
<0.51.0> inputs connected to <0.50.0>: [{<0.50.0>,0.5},{<0.49.0>,0.5}]
<0.49.0> output connected to <0.51.0>: [<0.51.0>]
<0.50.0> output connected to <0.51.0>: [<0.51.0>]
{pass,1.3}

=ERROR REPORT==== 5-Aug-2008::10:51:08 ===
Error in process <0.47.0> with exit value: {{badmatch,<0.49.0>},[{ann,'-convert_to_keys/1-fun-0-',1},{ann,perceptron,3}]}


=ERROR REPORT==== 5-Aug-2008::10:51:08 ===
Error in process <0.48.0> with exit value: {{badmatch,<0.49.0>},[{ann,'-convert_to_keys/1-fun-0-',1},{ann,perceptron,3}]}

-module(ann).
-export([run/0, perceptron/3, connect/2]).

feed_forward(Func, Weights, Inputs) ->
   Func(dot_prod(Weights, Inputs)).

% like map, but with two lists instead.
vector_map(Func, [], []) ->
   [];
vector_map(Func, [Xh | Xt], [Yh | Yt]) ->
   [Func(Xh, Yh) | vector_map(Func, Xt, Yt)].

% Calculates the dot product of two lists
dot_prod(X, Y) ->
   lists:foldl(fun(E, Sum) -> E + Sum end, 0,
      vector_map(fun(Ex, Ey) -> Ex * Ey end, X, Y)).

perceptron(Weights, Inputs, Sensitivities) ->

   Sigmoid =    fun(X) ->
               1 / (1 + math:exp(-X))
            end,

   Sigmoid_deriv =   fun(X) ->
                  math:exp(-X) / (1 + math:exp(-2 * X))
               end,

   receive
      {learn, Backprop} ->
         Learning_rate = 0.5,

         % Calculate the correct sensitivities
         New_sensitivities = add_sensitivity(Sensitivities, Backprop),
         Output_value = feed_forward(Sigmoid, Weights, convert_to_values(Inputs)),
         Derv_value = feed_forward(Sigmoid_deriv, Weights, convert_to_values(Inputs)),
         Sensitivity = calculate_sensitivity(Backprop, Inputs, New_sensitivities,
                                    Output_value, Derv_value),
         io:format("(~w) New Sensitivities: ~w~n", [self(), New_sensitivities]),
         io:format("(~w) Calculated Sensitivity: ~w~n", [self(), Sensitivity]),

         % Adjust all the weights
         Weight_adjustments = lists:map(fun(Input) ->
                                       Learning_rate * Sensitivity * Input
                                 end,
                                 convert_to_values(Inputs)),
         New_weights = vector_map(fun(W, D) -> W + D end, Weights, Weight_adjustments),
         io:format("(~w) Adjusted Weights: ~w~n", [self(), Weights]),

         % propagate sensitivities and associated weights back to the previous layer
         vector_map(fun(Weight, Input_PID) ->
                        Input_PID ! {learn, {self(), Sensitivity * Weight}}
                  end,
                  New_weights,
                  convert_to_keys(Inputs)),
           
         perceptron(New_weights, Inputs, New_sensitivities);


      {stimulate, Input} ->
         New_inputs = replace_input(Inputs, Input),
         Output_value = feed_forward(Sigmoid, Weights, convert_to_values(New_inputs)),
         if Sensitivities =/= [] ->
               % My output's connected to at least one perceptron:
               lists:foreach(fun(Output_PID) ->
                              Output_PID ! {stimulate, {self(), Output_value}}
                           end,
                           convert_to_keys(Sensitivities));
            Sensitivities =:= [] ->
               % My output's connected to no one:
               io:format("~w outputs: ~w~n", [self(), Output_value]),
               % Call a trainer here instead and
               self() ! {learn, {self(), 1}}
         end,
         perceptron(Weights, New_inputs, Sensitivities);


      {connect_to_output, Receiver_PID} ->
         Combined_output = [Receiver_PID | convert_to_keys(Sensitivities)],
         io:format("~w output connected to ~w: ~w~n", [self(), Receiver_PID, Combined_output]),
         perceptron(Weights, Inputs, Combined_output);

      {connect_to_input, Sender_PID} ->
         Combined_input = [{Sender_PID, 0.5} | Inputs],
         io:format("~w inputs connected to ~w: ~w~n", [self(), Sender_PID, Combined_input]),
         perceptron([0.5 | Weights], Combined_input, convert_to_keys(Sensitivities));

      {pass, Input_value} ->
         lists:foreach(fun(Output_PID) ->
                        io:format("Stimulating ~w with ~w~n", [Output_PID, Input_value]),
                        Output_PID ! {stimulate, {self(), Input_value}}
                     end,
                     convert_to_keys(Sensitivities))
   end.

connect(Sender_PID,  Receiver_PID) ->
   Sender_PID ! {connect_to_output, Receiver_PID},
   Receiver_PID ! {connect_to_input, Sender_PID}.

replace_input(Inputs, Input) ->
   {Input_PID, _} = Input,
   lists:keyreplace(Input_PID, 1, Inputs, Input).

convert_to_values(Tuple_list) ->
   lists:map(fun(Tup) ->
               {_, Val} = Tup,
               Val
            end,
            Tuple_list).

convert_to_keys(Tuple_list) ->
   lists:map(fun(Tup) ->
               {Key, _} = Tup,
               Key
            end,
            Tuple_list).

% adds the propagating sensitivity to the Sensitivities Hash
add_sensitivity(Sensitivities, Backprop) when Sensitivities =/= [] ->
   replace_input(Sensitivities, Backprop);
add_sensitivity(Sensitivities, Backprop) when Sensitivities =:= [] ->
   [].

% Calculates the sensitivity of this particular node
calculate_sensitivity(Backprop, Inputs, Sensitivities, Output_value, Derv_value)
   when Sensitivities =/= [], Inputs =:= [] -> % When the node is an input node:
      null;
calculate_sensitivity(Backprop, Inputs, Sensitivities, Output_value, Derv_value)
   when Sensitivities =:= [], Inputs =/= [] -> % When the node is an output node:
      {_, Training_value} = Backprop,
      (Training_value - Output_value) * Derv_value;
calculate_sensitivity(Backprop, Inputs, Sensitivities, Output_value, Derv_value)
   when Sensitivities =/= [], Inputs =/= [] -> % When the node is a hidden node:
   Derv_value * lists:foldl(fun(E, T) -> E + T end, 0, convert_to_values(Sensitivities)).

run() ->
   X1_pid = spawn(ann, perceptron, [[],[],[]]),
   X2_pid = spawn(ann, perceptron, [[],[],[]]),
   H1_pid = spawn(ann, perceptron, [[],[],[]]),
   H2_pid = spawn(ann, perceptron, [[],[],[]]),

   O_pid = spawn(ann, perceptron,  [[],[],[]]),

   % Connect input node X1 to hidden nodes H1 and H2
   ann:connect(X1_pid, H1_pid),
   ann:connect(X1_pid, H2_pid),
   
   % Connect input node X2 to hidden nodes H1 and H2
   ann:connect(X2_pid, H1_pid),
   ann:connect(X2_pid, H2_pid),

   % Connect input node H1 and H2 to output node O
   ann:connect(H1_pid, O_pid),
   ann:connect(H2_pid, O_pid),

   X1_pid ! {status},
   X2_pid ! {status},
   H1_pid ! {status},
   H2_pid ! {status},
   O_pid ! {status},

   X1_pid ! {pass, 1.8},
   X2_pid ! {pass, 1.3}.

1> ann:run().
<0.47.0> output connected to <0.49.0>: [<0.49.0>]
<0.48.0> output connected to <0.49.0>: [<0.49.0>]
<0.49.0> inputs connected to <0.47.0>: [{<0.47.0>,0.5}]
<0.50.0> inputs connected to <0.47.0>: [{<0.47.0>,0.5}]
<0.51.0> inputs connected to <0.49.0>: [{<0.49.0>,0.5}]
<0.47.0> output connected to <0.50.0>: [<0.50.0>,<0.49.0>]
<0.48.0> output connected to <0.50.0>: [<0.50.0>,<0.49.0>]
<0.49.0> inputs connected to <0.48.0>: [{<0.48.0>,0.5},{<0.47.0>,0.5}]
<0.50.0> inputs connected to <0.48.0>: [{<0.48.0>,0.5},{<0.47.0>,0.5}]
<0.51.0> inputs connected to <0.50.0>: [{<0.50.0>,0.5},{<0.49.0>,0.5}]
Stimulating <0.50.0> with 1.8
Stimulating <0.50.0> with 1.3
<0.49.0> output connected to <0.51.0>: [<0.51.0>]
<0.50.0> output connected to <0.51.0>: [<0.51.0>]
Stimulating <0.49.0> with 1.8
Stimulating <0.49.0> with 1.3
{pass,1.3}

=ERROR REPORT==== 6-Aug-2008::12:57:38 ===
Error in process <0.50.0> with exit value: {{badmatch,<0.51.0>},[{ann,'-convert_to_keys/1-fun-0-',1},{ann,perceptron,3}]}


=ERROR REPORT==== 6-Aug-2008::12:57:38 ===
Error in process <0.49.0> with exit value: {{badmatch,<0.51.0>},[{ann,'-convert_to_keys/1-fun-0-',1},{ann,perceptron,3}]}

{connect_to_output, Receiver_PID} ->
  Combined_output = [Receiver_PID | Sensitivities],

{connect_to_output, Receiver_PID} ->
  Combined_output = [{Receiver_PID, n} | Sensitivities],