Merge branch 'conv2d-forward-pass' into maxpool-layer

Author: milancurcic

CMakeLists.txt

@@ -68,6 +68,7 @@ add_library(neural
   src/nf_base_layer.f90
   src/nf_base_layer_submodule.f90
   src/nf_conv2d_layer.f90
+  src/nf_conv2d_layer_submodule.f90
   src/nf_datasets_mnist.f90
   src/nf_datasets_mnist_submodule.f90
   src/nf_dense_layer.f90
@@ -99,7 +100,7 @@ string(REGEX REPLACE "^ | $" "" LIBS "${LIBS}")
 
 # tests
 enable_testing()
-foreach(execid input1d_layer dense_layer dense_network)
+foreach(execid input1d_layer dense_layer conv2d_layer dense_network)
   add_executable(test_${execid} test/test_${execid}.f90)
   target_link_libraries(test_${execid} neural ${LIBS})
   add_test(test_${execid} bin/test_${execid})

src/nf.f90

@@ -1,6 +1,6 @@
 module nf
   use nf_datasets_mnist, only: label_digits, load_mnist
   use nf_layer, only: layer
-  use nf_layer_constructors, only: dense, input
+  use nf_layer_constructors, only: conv2d, dense, input
   use nf_network, only: network
 end module nf

src/nf_conv2d_layer.f90

@@ -1,7 +1,6 @@
 module nf_conv2d_layer
 
-  !! This is a placeholder module that will later define a concrete conv2d
-  !! layer type.
+  !! This modules provides a 2-d convolutional `conv2d_layer` type.
 
   use nf_base_layer, only: base_layer
   implicit none
@@ -17,9 +16,9 @@ module nf_conv2d_layer
     integer :: window_size
     integer :: filters
 
-    real, allocatable :: biases(:) ! as many as there are filters
-    real, allocatable :: kernel(:,:,:,:)
-    real, allocatable :: output(:,:,:)
+    real, allocatable :: biases(:) ! size(filters)
+    real, allocatable :: kernel(:,:,:,:) ! filters x channels x window x window
+    real, allocatable :: output(:,:,:) ! filters x output_width * output_height
 
   contains
 
@@ -30,55 +29,45 @@ module nf_conv2d_layer
   end type conv2d_layer
 
   interface conv2d_layer
-    module procedure :: conv2d_layer_cons
+    pure module function conv2d_layer_cons(window_size, filters, activation) result(res)
+      !! `conv2d_layer` constructor function
+      integer, intent(in) :: window_size
+      integer, intent(in) :: filters
+      character(*), intent(in) :: activation
+      type(conv2d_layer) :: res
+    end function conv2d_layer_cons
   end interface conv2d_layer
 
-contains
-
-  pure function conv2d_layer_cons(window_size, filters, activation) result(res)
-    integer, intent(in) :: window_size
-    integer, intent(in) :: filters
-    character(*), intent(in) :: activation
-    type(conv2d_layer) :: res
-    res % window_size = window_size
-    res % filters = filters
-    call res % set_activation(activation)
-  end function conv2d_layer_cons
-
-
-  subroutine init(self, input_shape)
-    class(conv2d_layer), intent(in out) :: self
-    integer, intent(in) :: input_shape(:)
-
-    self % width = input_shape(1) - self % window_size + 1
-    self % height = input_shape(2) - self % window_size + 1
-    self % channels = input_shape(3)
-
-    allocate(self % output(self % width, self % height, self % filters))
-    self % output = 0
-
-    allocate(self % kernel(self % window_size, self % window_size, &
-                           self % channels, self % filters))
-    self % kernel = 0 ! TODO 4-d randn
-
-    allocate(self % biases(self % filters))
-    self % biases = 0
-
-  end subroutine init
-
-
-  subroutine forward(self, input)
-    class(conv2d_layer), intent(in out) :: self
-    real, intent(in) :: input(:,:,:)
-    print *, 'Warning: conv2d forward pass not implemented'
-  end subroutine forward
-
-
-  subroutine backward(self, input, gradient)
-    class(conv2d_layer), intent(in out) :: self
-    real, intent(in) :: input(:,:,:)
-    real, intent(in) :: gradient(:,:,:)
-    print *, 'Warning: conv2d backward pass not implemented'
-  end subroutine backward
+  interface
+
+    module subroutine init(self, input_shape)
+      !! Initialize the layer data structures.
+      !!
+      !! This is a deferred procedure from the `base_layer` abstract type.
+      class(conv2d_layer), intent(in out) :: self
+        !! A `conv2d_layer` instance
+      integer, intent(in) :: input_shape(:)
+        !! Input layer dimensions
+    end subroutine init
+
+    pure module subroutine forward(self, input)
+      !! Apply a forward pass on the `conv2d` layer.
+      class(conv2d_layer), intent(in out) :: self
+        !! A `conv2d_layer` instance
+      real, intent(in) :: input(:,:,:)
+        !! Input data
+    end subroutine forward
+
+    module subroutine backward(self, input, gradient)
+      !! Apply a backward pass on the `conv2d` layer.
+      class(conv2d_layer), intent(in out) :: self
+        !! A `conv2d_layer` instance
+      real, intent(in) :: input(:,:,:)
+        !! Input data (previous layer)
+      real, intent(in) :: gradient(:,:,:)
+        !! Gradient (next layer)
+    end subroutine backward
+
+  end interface
 
 end module nf_conv2d_layer

src/nf_conv2d_layer_submodule.f90

@@ -0,0 +1,112 @@
+submodule(nf_conv2d_layer) nf_conv2d_layer_submodule
+
+  use nf_random, only: randn
+
+  implicit none
+
+contains
+
+  pure module function conv2d_layer_cons(window_size, filters, activation) result(res)
+    implicit none
+    integer, intent(in) :: window_size
+    integer, intent(in) :: filters
+    character(*), intent(in) :: activation
+    type(conv2d_layer) :: res
+    res % window_size = window_size
+    res % filters = filters
+    call res % set_activation(activation)
+  end function conv2d_layer_cons
+
+
+  module subroutine init(self, input_shape)
+    implicit none
+    class(conv2d_layer), intent(in out) :: self
+    integer, intent(in) :: input_shape(:)
+
+    self % channels = input_shape(1)
+    self % width = input_shape(2) - self % window_size + 1
+    self % height = input_shape(3) - self % window_size + 1
+
+    ! Output of shape filters x width x height
+    allocate(self % output(self % filters, self % width, self % height))
+    self % output = 0
+
+    ! Kernel of shape filters x channels x width x height
+    allocate(self % kernel(self % filters, self % channels, &
+                           self % window_size, self % window_size))
+
+    ! Initialize the kernel with random values with a normal distribution.
+    self % kernel = randn(self % filters, self % channels, &
+                          self % window_size, self % window_size) &
+                  / self % window_size**2 !TODO window_width * window_height
+
+    allocate(self % biases(self % filters))
+    self % biases = 0
+
+  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
+    integer :: istart, iend
+    integer :: jstart, jend
+    integer :: i, j, n
+    integer :: ii, jj
+    integer :: iws, iwe, jws, jwe
+    integer :: half_window
+
+    ! Input dimensions are channels x width x height
+    input_channels = size(input, dim=1)
+    input_width = size(input, dim=2)
+    input_height = size(input, dim=3)
+
+    ! Half-window is 1 for window size 3; 2 for window size 5; etc.
+    half_window = self % window_size / 2
+
+    ! Determine the start and end indices for the width and height dimensions
+    ! of the input that correspond to the center of each window.
+    istart = half_window + 1 ! TODO window_width
+    jstart = half_window + 1 ! TODO window_height
+    iend = input_width - istart + 1
+    jend = input_height - jstart + 1
+
+    convolution: do concurrent(i = istart:iend, j = jstart:jend)
+
+      ! Start and end indices of the input data on the filter window
+      ! iws and jws are also coincidentally the indices of the output matrix
+      iws = i - half_window ! TODO window_width
+      iwe = i + half_window ! TODO window_width
+      jws = j - half_window ! TODO window_height
+      jwe = j + half_window ! TODO window_height
+
+      ! This computes the inner tensor product, sum(w_ij * x_ij), for each filter,
+      ! and we add bias b_n to it.
+      inner_product: do concurrent(n = 1:self % filters)
+        self % output(n,iws,jws) = &
+          sum(self % kernel(n,:,:,:) * input(:,iws:iwe,jws:jwe)) &
+          + self % biases(n)
+      end do inner_product
+
+      ! TODO We may need to store self % output before we activate it for the backward
+      ! TODO pass, just like we do for the dense layer.
+
+      ! Activate
+      self % output(:,iws,jws) = self % activation(self % output(:,iws,jws))
+
+    end do convolution
+
+  end subroutine forward
+
+
+  module subroutine backward(self, input, gradient)
+    implicit none
+    class(conv2d_layer), intent(in out) :: self
+    real, intent(in) :: input(:,:,:)
+    real, intent(in) :: gradient(:,:,:)
+    print *, 'Warning: conv2d backward pass not implemented'
+  end subroutine backward
+
+end submodule nf_conv2d_layer_submodule

src/nf_layer.f90

@@ -26,11 +26,17 @@ module nf_layer
 
     procedure :: backward
     procedure :: forward
-    procedure :: get_output
     procedure :: init
     procedure :: print_info
     procedure :: update
 
+    ! Specific output subroutines for different array ranks,
+    ! available via generic `get_output`.
+    procedure, private :: get_output_1d
+    procedure, private :: get_output_3d
+
+    generic :: get_output => get_output_1d, get_output_3d
+
   end type layer
 
   interface
@@ -59,13 +65,22 @@ pure module subroutine forward(self, input)
         !! Input layer instance
     end subroutine forward
 
-    pure module subroutine get_output(self, output)
+    pure module subroutine get_output_1d(self, output)
       !! Returns the output values (activations) from this layer.
       class(layer), intent(in) :: self
         !! Layer instance
       real, allocatable, intent(out) :: output(:)
         !! Output values from this layer
-    end subroutine get_output
+    end subroutine get_output_1d
+
+    pure module subroutine get_output_3d(self, output)
+      !! Returns the output values (activations) from a layer with a 3-d output
+      !! (e.g. input3d, conv2d)
+      class(layer), intent(in) :: self
+        !! Layer instance
+      real, allocatable, intent(out) :: output(:,:,:)
+        !! Output values from this layer
+    end subroutine get_output_3d
 
     impure elemental module subroutine init(self, input)
       !! Initialize the layer, using information from the input layer,

src/nf_layer_submodule.f90

@@ -39,7 +39,6 @@ pure module subroutine forward(self, input)
 
     select type(this_layer => self % p)
 
-      ! Only dense layer is supported for now
       type is(dense_layer)
 
         ! Input layers permitted: input1d, dense
@@ -50,12 +49,20 @@ pure module subroutine forward(self, input)
             call this_layer % forward(prev_layer % output)
         end select
 
+      type is(conv2d_layer)
+
+        ! Input layers permitted: input3d
+        select type(prev_layer => input % p)
+          type is(input3d_layer)
+            call this_layer % forward(prev_layer % output)
+        end select
+
     end select
 
   end subroutine forward
 
 
-  pure module subroutine get_output(self, output)
+  pure module subroutine get_output_1d(self, output)
     class(layer), intent(in) :: self
     real, allocatable, intent(out) :: output(:)
 
@@ -65,16 +72,39 @@ pure module subroutine get_output(self, output)
         allocate(output, source=this_layer % output)
       type is(dense_layer)
         allocate(output, source=this_layer % output)
+      class default
+        error stop '1-d output can only be read from an input1d or dense layer.'
 
     end select
 
-  end subroutine get_output
+  end subroutine get_output_1d
+
+
+  pure module subroutine get_output_3d(self, output)
+    class(layer), intent(in) :: self
+    real, allocatable, intent(out) :: output(:,:,:)
+
+    select type(this_layer => self % p)
+
+      type is(input3d_layer)
+        allocate(output, source=this_layer % output)
+      type is(conv2d_layer)
+        allocate(output, source=this_layer % output)
+      class default
+        error stop '3-d output can only be read from an input3d or conv2d layer.'
+
+    end select
+
+  end subroutine get_output_3d
 
 
   impure elemental module subroutine init(self, input)
     class(layer), intent(in out) :: self
     class(layer), intent(in) :: input
 
+    if (self % initialized) &
+      error stop self % name // ' layer is already initialized.'
+
     select type(this_layer => self % p); class default
       call this_layer % init(input % layer_shape)
     end select