Creating maxpool1d

Author: Riccardo231

CMakeLists.txt

@@ -40,6 +40,8 @@ add_library(neural-fortran
   src/nf/nf_locally_connected_1d_submodule.f90
   src/nf/nf_loss.f90
   src/nf/nf_loss_submodule.f90
+  src/nf/nf_maxpool1d_layer.f90
+  src/nf/nf_maxpool1d_layer_submodule.f90
   src/nf/nf_maxpool2d_layer.f90
   src/nf/nf_maxpool2d_layer_submodule.f90
   src/nf/nf_metrics.f90

example/cnn_mnist_1d.f90

@@ -1,7 +1,7 @@
 program cnn_mnist
 
     use nf, only: network, sgd, &
-      input, conv2d, maxpool2d, flatten, dense, reshape, reshape_generalized, locally_connected_1d, &
+      input, conv2d, maxpool1d, maxpool2d, flatten, dense, reshape, reshape_generalized, locally_connected_1d, &
       load_mnist, label_digits, softmax, relu
 
     implicit none
@@ -20,11 +20,11 @@ program cnn_mnist
 
     net = network([ &
       input(784), &
-      reshape([1,28,28]), &
+      reshape_generalized([1,784]), &
       locally_connected_1d(filters=8, kernel_size=3, activation=relu()), &
-      maxpool2d(pool_size=2), &
+      maxpool1d(pool_size=2), &
       locally_connected_1d(filters=16, kernel_size=3, activation=relu()), &
-      maxpool2d(pool_size=2), &
+      maxpool1d(pool_size=2), &
       dense(10, activation=softmax()) &
     ])
 

src/nf.f90

@@ -3,7 +3,7 @@ module nf
   use nf_datasets_mnist, only: label_digits, load_mnist
   use nf_layer, only: layer
   use nf_layer_constructors, only: &
-    conv2d, dense, flatten, input, maxpool2d, reshape, reshape_generalized, locally_connected_1d
+    conv2d, dense, flatten, input, maxpool1d, maxpool2d, reshape, reshape_generalized, locally_connected_1d
   use nf_loss, only: mse, quadratic
   use nf_metrics, only: corr, maxabs
   use nf_network, only: network

src/nf/nf_layer_constructors.f90

@@ -8,7 +8,7 @@ module nf_layer_constructors
   implicit none
 
   private
-  public :: conv2d, dense, flatten, input, locally_connected_1d, maxpool2d, reshape, reshape_generalized
+  public :: conv2d, dense, flatten, input, locally_connected_1d, maxpool1d, maxpool2d, reshape, reshape_generalized
 
   interface input
 
@@ -133,6 +133,29 @@ module function conv2d(filters, kernel_size, activation) result(res)
         !! Resulting layer instance
     end function conv2d
 
+    module function maxpool1d(pool_size, stride) result(res)
+      !! CHANGE THE COMMENTS !!! 
+      !! 1-d maxpooling layer constructor.
+      !!
+      !! This layer is for downscaling other layers, typically `conv2d`.
+      !!
+      !! Example:
+      !!
+      !! ```
+      !! use nf, only :: maxpool2d, layer
+      !! type(layer) :: maxpool2d_layer
+      !! maxpool2d_layer = maxpool2d(pool_size=2)
+      !! maxpool2d_layer = maxpool2d(pool_size=2, stride=3)
+      !! ```
+      integer, intent(in) :: pool_size
+        !! Width of the pooling window, commonly 2
+      integer, intent(in), optional :: stride
+        !! Stride of the pooling window, commonly equal to `pool_size`;
+        !! Defaults to `pool_size` if omitted.
+      type(layer) :: res
+        !! Resulting layer instance
+    end function maxpool1d
+
     module function maxpool2d(pool_size, stride) result(res)
       !! 2-d maxpooling layer constructor.
       !!
@@ -156,6 +179,7 @@ module function maxpool2d(pool_size, stride) result(res)
     end function maxpool2d
 
     module function locally_connected_1d(filters, kernel_size, activation) result(res)
+      !! CHANGE THE COMMENTS !!! 
       !! 2-d convolutional layer constructor.
       !!
       !! This layer is for building 2-d convolutional network.

src/nf/nf_layer_constructors_submodule.f90

@@ -7,6 +7,7 @@
   use nf_input1d_layer, only: input1d_layer
   use nf_input3d_layer, only: input3d_layer
   use nf_locally_connected_1d_layer, only: locally_connected_1d_layer
+  use nf_maxpool1d_layer, only: maxpool1d_layer
   use nf_maxpool2d_layer, only: maxpool2d_layer
   use nf_reshape_layer, only: reshape3d_layer
   use nf_reshape_layer_generalized, only: reshape_generalized_layer
@@ -116,7 +117,34 @@ module function locally_connected_1d(filters, kernel_size, activation) result(re
     )
 
   end function locally_connected_1d
-    
+  
+  module function maxpool1d(pool_size, stride) result(res)
+    integer, intent(in) :: pool_size
+    integer, intent(in), optional :: stride
+    integer :: stride_
+    type(layer) :: res
+
+    if (pool_size < 2) &
+      error stop 'pool_size must be >= 2 in a maxpool1d layer'
+
+    ! Stride defaults to pool_size if not provided
+    if (present(stride)) then
+      stride_ = stride
+    else
+      stride_ = pool_size
+    end if
+
+    if (stride_ < 1) &
+      error stop 'stride must be >= 1 in a maxpool1d layer'
+
+    res % name = 'maxpool1d'
+
+    allocate( &
+      res % p, &
+      source=maxpool1d_layer(pool_size, stride_) &
+    )
+
+  end function maxpool1d
 
   module function maxpool2d(pool_size, stride) result(res)
     integer, intent(in) :: pool_size

src/nf/nf_layer_submodule.f90

@@ -44,8 +44,6 @@ pure module subroutine backward_1d(self, previous, gradient)
             call this_layer % backward(prev_layer % output, gradient)
           type is(conv2d_layer)
             call this_layer % backward(prev_layer % output, gradient)
-          type is(locally_connected_1d_layer)
-            call this_layer % backward(prev_layer % output, gradient)
           type is(maxpool2d_layer)
             call this_layer % backward(prev_layer % output, gradient)
         end select
@@ -54,7 +52,6 @@ pure module subroutine backward_1d(self, previous, gradient)
 
   end subroutine backward_1d
 
-
   pure module subroutine backward_3d(self, previous, gradient)
     implicit none
     class(layer), intent(in out) :: self
@@ -75,8 +72,6 @@ pure module subroutine backward_3d(self, previous, gradient)
             call this_layer % backward(prev_layer % output, gradient)
           type is(conv2d_layer)
             call this_layer % backward(prev_layer % output, gradient)
-          type is(locally_connected_1d_layer)
-            call this_layer % backward(prev_layer % output, gradient)
           type is(reshape3d_layer)
             call this_layer % backward(prev_layer % output, gradient)
         end select
@@ -91,8 +86,6 @@ pure module subroutine backward_3d(self, previous, gradient)
             call this_layer % backward(prev_layer % output, gradient)
           type is(input3d_layer)
             call this_layer % backward(prev_layer % output, gradient)
-          type is(locally_connected_1d_layer)
-            call this_layer % backward(prev_layer % output, gradient)
           type is(reshape3d_layer)
             call this_layer % backward(prev_layer % output, gradient)
         end select
@@ -141,8 +134,6 @@ pure module subroutine forward(self, input)
             call this_layer % forward(prev_layer % output)
           type is(conv2d_layer)
             call this_layer % forward(prev_layer % output)
-          type is(locally_connected_1d_layer)
-            call this_layer % forward(prev_layer % output)
           type is(maxpool2d_layer)
             call this_layer % forward(prev_layer % output)
           type is(reshape3d_layer)
@@ -157,8 +148,6 @@ pure module subroutine forward(self, input)
             call this_layer % forward(prev_layer % output)
           type is(conv2d_layer)
             call this_layer % forward(prev_layer % output)
-          type is(locally_connected_1d_layer)
-            call this_layer % forward(prev_layer % output)
           type is(maxpool2d_layer)
             call this_layer % forward(prev_layer % output)
           type is(reshape3d_layer)
@@ -173,8 +162,6 @@ pure module subroutine forward(self, input)
             call this_layer % forward(prev_layer % output)
           type is(conv2d_layer)
             call this_layer % forward(prev_layer % output)
-          type is(locally_connected_1d_layer)
-            call this_layer % forward(prev_layer % output)
           type is(maxpool2d_layer)
             call this_layer % forward(prev_layer % output)
           type is(reshape3d_layer)
@@ -218,6 +205,21 @@ pure module subroutine get_output_1d(self, output)
 
   end subroutine get_output_1d
 
+  pure module subroutine get_output_2d(self, output)
+    implicit none
+    class(layer), intent(in) :: self
+    real, allocatable, intent(out) :: output(:,:)
+
+    select type(this_layer => self % p)
+
+      type is(locally_connected_1d_layer)
+        allocate(output, source=this_layer % output)
+      class default
+        error stop '2d output can only be read from a locally_connected_1d layer'
+    
+    end select
+
+  end subroutine get_output_2d
 
   pure module subroutine get_output_3d(self, output)
     implicit none
@@ -230,8 +232,6 @@ pure module subroutine get_output_3d(self, output)
         allocate(output, source=this_layer % output)
       type is(conv2d_layer)
         allocate(output, source=this_layer % output)
-      type is(locally_connected_1d_layer)
-        allocate(output, source=this_layer % output)
       type is(maxpool2d_layer)
         allocate(output, source=this_layer % output)
       type is(reshape3d_layer)

src/nf/nf_maxpool1d_layer.f90

@@ -0,0 +1,69 @@
+module nf_maxpool1d_layer
+  !! This module provides the 1-d maxpooling layer.
+
+  use nf_base_layer, only: base_layer
+  implicit none
+
+  private
+  public :: maxpool1d_layer
+
+  type, extends(base_layer) :: maxpool1d_layer
+      integer :: channels
+      integer :: width      ! Length of the input along the pooling dimension
+      integer :: pool_size
+      integer :: stride
+
+      ! Location (as input matrix indices) of the maximum value within each pooling region.
+      ! Dimensions: (channels, new_width)
+      integer, allocatable :: maxloc(:,:)
+
+      ! Gradient for the input (same shape as the input).
+      real, allocatable :: gradient(:,:)
+      ! Output after pooling (dimensions: (channels, new_width)).
+      real, allocatable :: output(:,:)
+  contains
+      procedure :: init
+      procedure :: forward
+      procedure :: backward
+  end type maxpool1d_layer
+
+  interface maxpool1d_layer
+      pure module function maxpool1d_layer_cons(pool_size, stride) result(res)
+          !! `maxpool1d` constructor function.
+          integer, intent(in) :: pool_size
+              !! Width of the pooling window.
+          integer, intent(in) :: stride
+              !! Stride of the pooling window.
+          type(maxpool1d_layer) :: res
+      end function maxpool1d_layer_cons
+  end interface maxpool1d_layer
+
+  interface
+      module subroutine init(self, input_shape)
+          !! Initialize the `maxpool1d` layer instance with an input shape.
+          class(maxpool1d_layer), intent(in out) :: self
+              !! `maxpool1d_layer` instance.
+          integer, intent(in) :: input_shape(:)
+              !! Array shape of the input layer, expected as (channels, width).
+      end subroutine init
+
+      pure module subroutine forward(self, input)
+          !! Run a forward pass of the `maxpool1d` layer.
+          class(maxpool1d_layer), intent(in out) :: self
+              !! `maxpool1d_layer` instance.
+          real, intent(in) :: input(:,:)
+              !! Input data (output of the previous layer), with shape (channels, width).
+      end subroutine forward
+
+      pure module subroutine backward(self, input, gradient)
+          !! Run a backward pass of the `maxpool1d` layer.
+          class(maxpool1d_layer), intent(in out) :: self
+              !! `maxpool1d_layer` instance.
+          real, intent(in) :: input(:,:)
+              !! Input data (output of the previous layer).
+          real, intent(in) :: gradient(:,:)
+              !! Gradient from the downstream layer, with shape (channels, pooled width).
+      end subroutine backward
+  end interface
+
+end module nf_maxpool1d_layer

src/nf/nf_maxpool1d_layer_submodule.f90

@@ -0,0 +1,93 @@
+submodule(nf_maxpool1d_layer) nf_maxpool1d_layer_submodule
+  implicit none
+
+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
+
+    res % pool_size = pool_size
+    res % stride    = stride
+  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(:)
+    ! input_shape is expected to be (channels, width)
+
+    self % channels = input_shape(1)
+    ! The new width is the integer division of the input width by the stride.
+    self % width    = input_shape(2) / self % stride
+
+    ! Allocate storage for the index of the maximum element within each pooling region.
+    allocate(self % maxloc(self % channels, self % width))
+    self % maxloc = 0
+
+    ! Allocate the gradient array corresponding to the input dimensions.
+    allocate(self % gradient(input_shape(1), input_shape(2)))
+    self % gradient = 0
+
+    ! Allocate the output array (after pooling).
+    allocate(self % output(self % channels, self % width))
+    self % output = 0
+  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
+    integer :: i, n
+    integer :: ii, iend
+    integer :: iextent
+    integer :: max_index  ! Temporary variable to hold the local index of the max
+    integer :: maxloc_temp(1)  ! Temporary array to hold the result of maxloc
+
+    input_width = size(input, dim=2)
+    ! Ensure we only process complete pooling regions.
+    iextent = input_width - mod(input_width, self % stride)
+
+    ! Loop over the input with a step size equal to the stride and over all channels.
+    do concurrent (i = 1:iextent: self % stride, n = 1:self % channels)
+      ! Compute the index in the pooled (output) array.
+      ii = (i - 1) / self % stride + 1
+      ! Determine the ending index of the current pooling region.
+      iend = min(i + self % pool_size - 1, input_width)
+
+      ! Find the index (within the pooling window) of the maximum value.
+      maxloc_temp = maxloc(input(n, i:iend))
+      max_index = maxloc_temp(1) + i - 1  ! Adjust to the index in the original input
+
+      ! Store the location of the maximum value.
+      self % maxloc(n, ii) = max_index
+      ! Set the output as the maximum value from this pooling region.
+      self % output(n, ii) = input(n, max_index)
+    end do
+  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(:,:)
+    integer :: channels, pooled_width
+    integer :: i, n
+
+    channels    = size(gradient, dim=1)
+    pooled_width = size(gradient, dim=2)
+
+    ! The gradient for max-pooling is nonzero only at the input locations
+    ! that were the maxima during the forward pass.
+    do concurrent (n = 1:channels, i = 1:pooled_width)
+      self % gradient(n, self % maxloc(n, i)) = gradient(n, i)
+    end do
+  end subroutine backward
+
+end submodule nf_maxpool1d_layer_submodule