Tidy up

Author: milancurcic

example/linear2d.f90

@@ -4,14 +4,14 @@ program linear2d_example
   implicit none
 
   type(network) :: net
-  type(mse) :: loss
+  type(mse) :: loss = mse()
   real :: x(3, 4) = reshape( &
     [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.11, 0.12, 0.13], &
     [3, 4])
   real :: y(3) = [0.12, 0.1, 0.2]
   real :: preds(3)
   real :: loss_value
-  integer, parameter :: num_iterations = 500
+  integer, parameter :: num_iterations = 10000
   integer :: n
 
   net = network([ &
@@ -21,19 +21,22 @@ program linear2d_example
   ])
 
   call net % print_info()
-  loss = mse()
 
   do n = 1, num_iterations
+
     call net % forward(x)
     call net % backward(y, loss)
     call net % update(optimizer=sgd(learning_rate=0.01))
+
     preds = net % predict(x)
-    print '(i4,3(3x,f8.6))', n, preds
+    print '(i5,3(3x,f9.6))', n, preds
+
     loss_value = loss % eval (y, preds)
-    if (loss_value < 0.01) then
+    if (loss_value < 1e-4) then
       print *, 'Loss: ', loss_value
       return
     end if
+
   end do
 
 end program linear2d_example

src/nf/nf_linear2d_layer_submodule.f90

@@ -2,20 +2,23 @@
   use nf_base_layer, only: base_layer
   use nf_random, only: random_normal
   implicit none
+
 contains
+
   module function linear2d_layer_cons(out_features) result(res)
     integer, intent(in) :: out_features
     type(linear2d_layer) :: res
 
     res % out_features = out_features
   end function linear2d_layer_cons
 
+
   module subroutine init(self, input_shape)
     class(linear2d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
     if (size(input_shape) /= 2) then
-      error stop "Linear2D Layer accepts 2D input"
+      error stop "linear2d layer requires 2D input."
     end if
     self % sequence_length = input_shape(1)
     self % in_features = input_shape(2)
@@ -30,40 +33,45 @@ module subroutine init(self, input_shape)
     call random_normal(self % biases)
 
     allocate(self % dw(self % in_features, self % out_features))
-    self % dw = 0.0
+    self % dw = 0
     allocate(self % db(self % out_features))
-    self % db = 0.0
+    self % db = 0
+
   end subroutine init
 
+
   pure module subroutine forward(self, input)
     class(linear2d_layer), intent(in out) :: self
     real, intent(in) :: input(:, :)
     integer :: i
 
-    self % output(:, :) = matmul(input(:, :), self % weights)
-    do concurrent(i = 1: self % sequence_length)
-      self % output(i, :) = self % output(i, :) + self % biases
+    self % output(:,:) = matmul(input(:,:), self % weights)
+    do concurrent(i = 1:self % sequence_length)
+      self % output(i,:) = self % output(i,:) + self % biases
     end do
+
   end subroutine forward
 
+
   pure module subroutine backward(self, input, gradient)
     class(linear2d_layer), intent(in out) :: self
-    real, intent(in) :: input(:, :)
-    real, intent(in) :: gradient(:, :)
+    real, intent(in) :: input(:,:)
+    real, intent(in) :: gradient(:,:)
     real :: db(self % out_features)
     real :: dw(self % in_features, self % out_features)
     integer :: i
 
-    self % dw = self % dw + matmul(transpose(input(:, :)), gradient(:, :))
-    self % db = self % db + sum(gradient(:, :), 1)
-    self % gradient(:, :) = matmul(gradient(:, :), transpose(self % weights))
+    self % dw = self % dw + matmul(transpose(input(:,:)), gradient(:,:))
+    self % db = self % db + sum(gradient(:,:), 1)
+    self % gradient(:,:) = matmul(gradient(:,:), transpose(self % weights))
   end subroutine backward
 
+
   pure module function get_num_params(self) result(num_params)
     class(linear2d_layer), intent(in) :: self
     integer :: num_params
 
-    ! Number of weigths times number of biases
+    ! Number of weights times number of biases
     num_params = self % in_features * self % out_features + self % out_features
 
   end function get_num_params
@@ -122,4 +130,5 @@ module subroutine set_params(self, params)
     end associate
 
   end subroutine set_params
+
 end submodule nf_linear2d_layer_submodule