Add tests for Network

lib/layer.ml

@@ -3,6 +3,9 @@ module Layer = struct
     neurons : Neuron.Neuron.t list
   }
 
+  let parameters (layer: t) =
+    List.map Neuron.Neuron.parameters layer.neurons
+
   let create number_of_input_dimensions number_of_neurons is_non_linear =
     let neurons = List.init number_of_neurons (fun _ -> Neuron.Neuron.create number_of_input_dimensions is_non_linear) in
     { neurons = neurons }

lib/layer.mli

@@ -3,6 +3,9 @@
 module Layer : sig
     type t
 
+    (* getter for the parameters (aka weights and biases) of the layer *)
+    val parameters : t -> Neuron.Neuron.out_t list
+
     (* Constructor; constructs a layer of neurons *)
     val create : int -> int -> bool -> t
 

lib/network.ml

@@ -3,6 +3,9 @@ module Network = struct
     layers : Layer.Layer.t list;
   }
 
+  let parameters (network : t) =
+    List.map (fun x -> Layer.Layer.parameters x) network.layers
+
   (* the number of output parameters of a layer is the number of neurons in that layer *)
   (* important to understand that the input layer isn't truly a layer with weights and biases; just an abstraction *)
   let create number_of_input_dimensions number_of_neurons_per_layer =
@@ -11,7 +14,8 @@ module Network = struct
     let rec build_layers stacked_layers sizes =
       match sizes with
       | input :: output :: rest ->
-        let layer = Layer.Layer.create input output true in
+        let has_non_linear_activation_for_layer = (rest <> []) in
+        let layer = Layer.Layer.create input output has_non_linear_activation_for_layer in
 
         (* note how we are stacking the layers in reverse order *)
         build_layers (layer :: stacked_layers) (output :: rest)

lib/network.mli

@@ -2,6 +2,9 @@
 module Network : sig
     type t
 
+    (* getter for the parameters (aka weights and biases) of the entire network *)
+    val parameters : t -> Neuron.Neuron.out_t list list
+
     val create : int -> int list -> t
 
     val propagate_input : t -> Variable.Variable.t list -> Variable.Variable.t list

test/network_operations.ml

@@ -0,0 +1,23 @@
+open Smolgrad.Variable
+open Smolgrad.Network
+
+let test_neural_network_initialization () =
+  let nn = Network.create 3 [5; 2; 3] in
+
+  Alcotest.(check int)
+    "Network: Number of layers are expected"
+    3
+    (List.length (Network.parameters nn));
+;;
+
+let test_neural_network_propagation_of_input () =
+  let nn = Network.create 3 [5; 2; 6] in
+  let input_vector = [Variable.create 3.0; Variable.create 2.0; Variable.create 1.0] in
+  let output_vector = Network.propagate_input nn input_vector in
+
+  (* the dimension of the output vector should be equal to the number of neurons in the last layer *)
+  Alcotest.(check int)
+    "Network: Output vector has the expected number of dimensions"
+    6
+    (List.length output_vector);
+;;

test/neuron_operations.ml

@@ -1,5 +1,5 @@
-open Smolgrad.Neuron
 open Smolgrad.Variable
+open Smolgrad.Neuron
 
 let test_neuron_initialization () =
   let n = Neuron.create 5 true in

test/smolgrad_tests.ml

@@ -8,4 +8,8 @@ let () =
   (* unit tests for Neuron *)
   Neuron_operations.test_neuron_initialization ();
   Neuron_operations.test_neuron_weights_reacting_to_input ();
+
+  (* unit tests for Network *)
+  Network_operations.test_neural_network_initialization ();
+  Network_operations.test_neural_network_propagation_of_input ();
 ;;