Make conv2d layer API consistent with Keras (filters, kernel_size)

Author: milancurcic

src/nf_conv2d_layer.f90

@@ -13,7 +13,7 @@ module nf_conv2d_layer
     integer :: width
     integer :: height
     integer :: channels
-    integer :: window_size
+    integer :: kernel_size
     integer :: filters
 
     real, allocatable :: biases(:) ! size(filters)
@@ -29,10 +29,11 @@ module nf_conv2d_layer
   end type conv2d_layer
 
   interface conv2d_layer
-    pure module function conv2d_layer_cons(window_size, filters, activation) result(res)
+    pure module function conv2d_layer_cons(filters, kernel_size, activation) &
+      result(res)
       !! `conv2d_layer` constructor function
-      integer, intent(in) :: window_size
       integer, intent(in) :: filters
+      integer, intent(in) :: kernel_size
       character(*), intent(in) :: activation
       type(conv2d_layer) :: res
     end function conv2d_layer_cons

src/nf_conv2d_layer_submodule.f90

@@ -6,13 +6,13 @@
 
 contains
 
-  pure module function conv2d_layer_cons(window_size, filters, activation) result(res)
+  pure module function conv2d_layer_cons(filters, kernel_size, activation) result(res)
     implicit none
-    integer, intent(in) :: window_size
     integer, intent(in) :: filters
+    integer, intent(in) :: kernel_size
     character(*), intent(in) :: activation
     type(conv2d_layer) :: res
-    res % window_size = window_size
+    res % kernel_size = kernel_size
     res % filters = filters
     call res % set_activation(activation)
   end function conv2d_layer_cons
@@ -24,21 +24,21 @@ module subroutine init(self, input_shape)
     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
+    self % width = input_shape(2) - self % kernel_size + 1
+    self % height = input_shape(3) - self % kernel_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))
+                           self % kernel_size, self % kernel_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
+                          self % kernel_size, self % kernel_size) &
+                  / self % kernel_size**2 !TODO kernel_width * kernel_height
 
     allocate(self % biases(self % filters))
     self % biases = 0
@@ -54,7 +54,6 @@ pure module subroutine forward(self, input)
     integer :: istart, iend
     integer :: jstart, jend
     integer :: i, j, n
-    integer :: ii, jj
     integer :: iws, iwe, jws, jwe
     integer :: half_window
 
@@ -64,23 +63,23 @@ pure module subroutine forward(self, input)
     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
+    half_window = self % kernel_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
+    istart = half_window + 1 ! TODO kernel_width
+    jstart = half_window + 1 ! TODO kernel_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
+      iws = i - half_window ! TODO kernel_width
+      iwe = i + half_window ! TODO kernel_width
+      jws = j - half_window ! TODO kernel_height
+      jwe = j + half_window ! TODO kernel_height
 
       ! This computes the inner tensor product, sum(w_ij * x_ij), for each
       ! filter, and we add bias b_n to it.

src/nf_layer_constructors.f90

@@ -84,7 +84,7 @@ pure module function dense(layer_size, activation) result(res)
         !! Resulting layer instance
     end function dense
 
-    pure module function conv2d(window_size, filters, activation) result(res)
+    pure module function conv2d(filters, kernel_size, activation) result(res)
       !! 2-d convolutional layer constructor.
       !!
       !! This layer is for building 2-d convolutional network.
@@ -98,13 +98,13 @@ pure module function conv2d(window_size, filters, activation) result(res)
       !! ```
       !! use nf, only :: conv2d, layer
       !! type(layer) :: conv2d_layer
-      !! conv2d_layer = dense(window_size=3, filters=32)
-      !! conv2d_layer = dense(window_size=3, filters=32, activation='relu')
+      !! conv2d_layer = dense(filters=32, kernel_size=3)
+      !! conv2d_layer = dense(filters=32, kernel_size=3, activation='relu')
       !! ```
-      integer, intent(in) :: window_size
-        !! Width of the convolution window, commonly 3 or 5
       integer, intent(in) :: filters
         !! Number of filters in the output of the layer
+      integer, intent(in) :: kernel_size
+        !! Width of the convolution window, commonly 3 or 5
       character(*), intent(in), optional :: activation
         !! Activation function (default 'sigmoid')
       type(layer) :: res

src/nf_layer_constructors_submodule.f90

@@ -51,9 +51,9 @@ pure module function dense(layer_size, activation) result(res)
   end function dense
 
 
-  pure module function conv2d(window_size, filters, activation) result(res)
-    integer, intent(in) :: window_size
+  pure module function conv2d(filters, kernel_size, activation) result(res)
     integer, intent(in) :: filters
+    integer, intent(in) :: kernel_size
     character(*), intent(in), optional :: activation
     type(layer) :: res
 
@@ -67,7 +67,7 @@ pure module function conv2d(window_size, filters, activation) result(res)
 
     allocate( &
       res % p, &
-      source=conv2d_layer(window_size, filters, res % activation) &
+      source=conv2d_layer(filters, kernel_size, res % activation) &
     )
 
   end function conv2d

test/test_conv2d_layer.f90

@@ -7,12 +7,12 @@ program test_conv2d_layer
   implicit none
 
   type(layer) :: conv_layer, input_layer
-  integer, parameter :: window_size = 3, filters = 32
+  integer, parameter :: filters = 32, kernel_size=3
   real, allocatable :: sample_input(:,:,:), output(:,:,:)
   real, parameter :: tolerance = 1e-7
   logical :: ok = .true.
 
-  conv_layer = conv2d(window_size, filters)
+  conv_layer = conv2d(filters, kernel_size)
 
   if (.not. conv_layer % name == 'conv2d') then
     ok = .false.
@@ -52,7 +52,7 @@ program test_conv2d_layer
   sample_input = 0
 
   input_layer = input([1, 3, 3])
-  conv_layer = conv2d(window_size, filters)
+  conv_layer = conv2d(filters, kernel_size)
   call conv_layer % init(input_layer)
 
   select type(this_layer => input_layer % p); type is(input3d_layer)

test/test_conv2d_network.f90

@@ -12,8 +12,8 @@ program test_conv2d_network
   ! 3-layer convolutional network
   net = network([ &
     input([3, 32, 32]), &
-    conv2d(window_size=3, filters=16), &
-    conv2d(window_size=3, filters=32) &
+    conv2d(filters=16, kernel_size=3), &
+    conv2d(filters=32, kernel_size=3) &
   ])
 
   if (.not. size(net % layers) == 3) then
@@ -33,9 +33,9 @@ program test_conv2d_network
   end if
 
   if (ok) then
-    print '(a)', 'test_dense_network: All tests passed.'
+    print '(a)', 'test_conv2d_network: All tests passed.'
   else
-    write(stderr, '(a)') 'test_dense_network: One or more tests failed.'
+    write(stderr, '(a)') 'test_conv2d_network: One or more tests failed.'
     stop 1
   end if