Resolve conflicts with main

Author: milancurcic

src/nf/nf_conv1d_layer_submodule.f90

@@ -22,7 +22,6 @@ module function conv1d_layer_cons(filters, kernel_size, activation, stride) resu
   end function conv1d_layer_cons
 
   module subroutine init(self, input_shape)
-    implicit none
     class(conv1d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
@@ -58,14 +57,12 @@ module subroutine init(self, input_shape)
   end subroutine init
 
   pure module subroutine forward(self, input)
-    implicit none
     class(conv1d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:)
-    integer :: input_channels, input_width
+    integer :: input_width
     integer :: j, n
     integer :: iws, iwe
 
-    input_channels = size(input, dim=1)
     input_width = size(input, dim=2)
 
     ! Loop over output positions.
@@ -89,7 +86,6 @@ pure module subroutine forward(self, input)
   end subroutine forward
 
   pure module subroutine backward(self, input, gradient)
-    implicit none
     class(conv1d_layer), intent(in out) :: self
     ! 'input' has shape: (channels, input_width)
     ! 'gradient' (dL/dy) has shape: (filters, output_width)
@@ -105,8 +101,6 @@ pure module subroutine backward(self, input, gradient)
     real :: db_local(self % filters)
     real :: dw_local(self % filters, self % channels, self % kernel_size)
 
-    ! Determine dimensions.
-    input_channels = size(input, dim=1)
     input_width = size(input, dim=2)
 
     !--- Compute the local gradient gdz = (dL/dy) * sigma'(z) for each output.
@@ -126,7 +120,6 @@ pure module subroutine backward(self, input, gradient)
       do j = 1, self % width
         iws = self % stride * (j-1) + 1
         iwe = min(iws + self % kernel_size - 1, input_width)
-
         do k = 1, self % channels
           ! Weight gradient: accumulate contribution from the input window.
           dw_local(n,k,1:iwe-iws+1) = dw_local(n,k,1:iwe-iws+1) + input(k,iws:iwe) * gdz(n,j)

src/nf/nf_conv2d_layer_submodule.f90

@@ -68,7 +68,6 @@ end subroutine init
 
 
   pure module subroutine forward(self, input)
-    implicit none
     class(conv2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:,:)
     integer :: input_width, input_height, input_channels
@@ -121,7 +120,6 @@ end subroutine forward
 
 
   pure module subroutine backward(self, input, gradient)
-    implicit none
     class(conv2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:,:)
     real, intent(in) :: gradient(:,:,:)

src/nf/nf_locally_connected2d_layer_submodule.f90

@@ -8,7 +8,6 @@
 contains
 
   module function locally_connected2d_layer_cons(filters, kernel_size, activation) result(res)
-    implicit none
     integer, intent(in) :: filters
     integer, intent(in) :: kernel_size
     class(activation_function), intent(in) :: activation
@@ -21,7 +20,6 @@ module function locally_connected2d_layer_cons(filters, kernel_size, activation)
   end function locally_connected2d_layer_cons
 
   module subroutine init(self, input_shape)
-    implicit none
     class(locally_connected2d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
@@ -52,16 +50,11 @@ module subroutine init(self, input_shape)
   end subroutine init
 
   pure module subroutine forward(self, input)
-    implicit none
     class(locally_connected2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:)
-    integer :: input_channels, input_width
     integer :: j, n
     integer :: iws, iwe
 
-    input_channels = size(input, dim=1)
-    input_width    = size(input, dim=2)
-
     do j = 1, self % width
       iws = j
       iwe = j + self % kernel_size - 1
@@ -73,27 +66,21 @@ pure module subroutine forward(self, input)
   end subroutine forward
 
   pure module subroutine backward(self, input, gradient)
-    implicit none
     class(locally_connected2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:)
     real, intent(in) :: gradient(:,:)
-    integer :: input_channels, input_width, output_width
     integer :: j, n, k
     integer :: iws, iwe
     real :: gdz(self % filters, self % width)
     real :: db_local(self % filters, self % width)
     real :: dw_local(self % filters, self % width, self % channels, self % kernel_size)
 
-    input_channels = size(input, dim=1)
-    input_width    = size(input, dim=2)
-    output_width   = self % width
-
-    do j = 1, output_width
+    do j = 1, self % width
        gdz(:, j) = gradient(:, j) * self % activation % eval_prime(self % z(:, j))
     end do
 
     do n = 1, self % filters
-       do j = 1, output_width
+       do j = 1, self % width
           db_local(n, j) = gdz(n, j)
        end do
     end do
@@ -102,7 +89,7 @@ pure module subroutine backward(self, input, gradient)
     self % gradient = 0.0
 
     do n = 1, self % filters
-       do j = 1, output_width
+       do j = 1, self % width
           iws = j
           iwe = j + self % kernel_size - 1
           do k = 1, self % channels

src/nf/nf_maxpool1d_layer_submodule.f90

@@ -5,7 +5,6 @@
 contains
 
   pure module function maxpool1d_layer_cons(pool_size, stride) result(res)
-    implicit none
     integer, intent(in) :: pool_size
     integer, intent(in) :: stride
     type(maxpool1d_layer) :: res
@@ -15,7 +14,6 @@ end function maxpool1d_layer_cons
 
 
   module subroutine init(self, input_shape)
-    implicit none
     class(maxpool1d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
@@ -34,7 +32,6 @@ module subroutine init(self, input_shape)
   end subroutine init
 
   pure module subroutine forward(self, input)
-    implicit none
     class(maxpool1d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:)
     integer :: input_width
@@ -70,7 +67,6 @@ pure module subroutine forward(self, input)
   end subroutine forward
 
   pure module subroutine backward(self, input, gradient)
-    implicit none
     class(maxpool1d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:)
     real, intent(in) :: gradient(:,:)

src/nf/nf_maxpool2d_layer_submodule.f90

@@ -5,7 +5,6 @@
 contains
 
   pure module function maxpool2d_layer_cons(pool_size, stride) result(res)
-    implicit none
     integer, intent(in) :: pool_size
     integer, intent(in) :: stride
     type(maxpool2d_layer) :: res
@@ -15,7 +14,6 @@ end function maxpool2d_layer_cons
 
 
   module subroutine init(self, input_shape)
-    implicit none
     class(maxpool2d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
@@ -39,7 +37,6 @@ end subroutine init
 
 
   pure module subroutine forward(self, input)
-    implicit none
     class(maxpool2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:,:)
     integer :: input_width, input_height
@@ -86,7 +83,6 @@ end subroutine forward
 
 
   pure module subroutine backward(self, input, gradient)
-    implicit none
     class(maxpool2d_layer), intent(in out) :: self
     real, intent(in) :: input(:,:,:)
     real, intent(in) :: gradient(:,:,:)

test/CMakeLists.txt

@@ -1,3 +1,5 @@
+add_library(tuff tuff.f90)
+
 foreach(execid
   input1d_layer
   input2d_layer
@@ -27,7 +29,7 @@ foreach(execid
   metrics
   )
   add_executable(test_${execid} test_${execid}.f90)
-  target_link_libraries(test_${execid} PRIVATE neural-fortran ${LIBS})
+  target_link_libraries(test_${execid} PRIVATE tuff neural-fortran ${LIBS})
 
   add_test(NAME test_${execid} COMMAND test_${execid})
 endforeach()

test/test_dense_layer.f90

@@ -1,58 +1,23 @@
 program test_dense_layer
-  use iso_fortran_env, only: stderr => error_unit
-  use nf, only: dense, layer
-  use nf_activation, only: relu
+  use nf, only: dense, layer, relu
+  use tuff, only: test, test_result
   implicit none
-  type(layer) :: layer1, layer2
-  logical :: ok = .true.
+  type(layer) :: layer1, layer2, layer3
+  type(test_result) :: tests
 
   layer1 = dense(10)
-
-  if (.not. layer1 % name == 'dense') then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer has its name set correctly.. failed'
-  end if
-
-  if (.not. all(layer1 % layer_shape == [10])) then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer is created with requested size.. failed'
-  end if
-
-  if (layer1 % initialized) then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer should not be marked as initialized yet.. failed'
-  end if
-
-  if (.not. layer1 % activation == 'sigmoid') then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer is defaults to sigmoid activation.. failed'
-  end if
-
-  layer1 = dense(10, activation=relu())
-
-  if (.not. layer1 % activation == 'relu') then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer is created with the specified activation.. failed'
-  end if
-
-  layer2 = dense(20)
-  call layer2 % init(layer1)
-
-  if (.not. layer2 % initialized) then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer should now be marked as initialized.. failed'
-  end if
-
-  if (.not. all(layer2 % input_layer_shape == [10])) then
-    ok = .false.
-    write(stderr, '(a)') 'dense layer should have a correct input layer shape.. failed'
-  end if
-
-  if (ok) then
-    print '(a)', 'test_dense_layer: All tests passed.'
-  else
-    write(stderr, '(a)') 'test_dense_layer: One or more tests failed.'
-    stop 1
-  end if
+  layer2 = dense(10, activation=relu())
+  layer3 = dense(20)
+  call layer3 % init(layer1)
+
+  tests = test("test_dense_layer", [ &
+    test("layer name is set", layer1 % name == 'dense'), & 
+    test("layer shape is correct", all(layer1 % layer_shape == [10])), &
+    test("layer is initialized", layer3 % initialized), &
+    test("layer's default activation is sigmoid", layer1 % activation == 'sigmoid'), &
+    test("user set activation works", layer2 % activation == 'relu'), &
+    test("layer initialized after init", layer3 % initialized), &
+    test("layer input shape is set after init", all(layer3 % input_layer_shape == [10])) &
+  ])  
 
 end program test_dense_layer

test/test_dense_network.f90

@@ -1,33 +1,40 @@
 program test_dense_network
   use iso_fortran_env, only: stderr => error_unit
-  use nf, only: dense, input, network
-  use nf_optimizers, only: sgd
+  use nf, only: dense, input, network, sgd
+  use tuff, only: test, test_result
   implicit none
   type(network) :: net
-  logical :: ok = .true.
+  type(test_result) :: tests
 
   ! Minimal 2-layer network
   net = network([ &
     input(1), &
     dense(1) &
   ])
 
-  if (.not. size(net % layers) == 2) then
-    write(stderr, '(a)') 'dense network should have 2 layers.. failed'
-    ok = .false.
-  end if
+  tests = test("test_dense_network", [ &
+    test("network has 2 layers", size(net % layers) == 2), &
+    test("network predicts 0.5 for input 0", all(net % predict([0.]) == 0.5)), &
+    test(simple_training), &
+    test(larger_network_size) &
+  ])
 
-  if (.not. all(net % predict([0.]) == 0.5)) then
-    write(stderr, '(a)') &
-      'dense network should output exactly 0.5 for input 0.. failed'
-    ok = .false.
-  end if
+contains
 
-  training: block
+  type(test_result) function simple_training() result(res)
     real :: x(1), y(1)
     real :: tolerance = 1e-3
     integer :: n
-    integer, parameter :: num_iterations = 1000 
+    integer, parameter :: num_iterations = 1000
+    type(network) :: net 
+
+    res % name = 'simple training'
+
+    ! Minimal 2-layer network
+    net = network([ &
+      input(1), &
+      dense(1) &
+    ])
 
     x = [0.123]
     y = [0.765]
@@ -39,32 +46,25 @@ program test_dense_network
       if (all(abs(net % predict(x) - y) < tolerance)) exit
     end do
 
-    if (.not. n <= num_iterations) then
-      write(stderr, '(a)') &
-        'dense network should converge in simple training.. failed'
-      ok = .false.
-    end if
+    res % ok = n <= num_iterations
 
-  end block training
+  end function simple_training
 
-  ! A bit larger multi-layer network
-  net = network([ &
-    input(784), &
-    dense(30), &
-    dense(20), &
-    dense(10) &
-  ])
+  type(test_result) function larger_network_size() result(res)
+    type(network) :: net 
+
+    res % name = 'larger network training'
+
+    ! A bit larger multi-layer network
+    net = network([ &
+      input(784), &
+      dense(30), &
+      dense(20), &
+      dense(10) &
+    ])
 
-  if (.not. size(net % layers) == 4) then
-    write(stderr, '(a)') 'dense network should have 4 layers.. failed'
-    ok = .false.
-  end if
+    res % ok = size(net % layers) == 4
 
-  if (ok) then
-    print '(a)', 'test_dense_network: All tests passed.'
-  else
-    write(stderr, '(a)') 'test_dense_network: One or more tests failed.'
-    stop 1
-  end if
+  end function larger_network_size
 
-end program test_dense_network
+end program test_dense_network