Bug fixed; Added conv1d; Conv1d and maxpool backward still not working

Author: Riccardo231

CMakeLists.txt

@@ -18,6 +18,8 @@ add_library(neural-fortran
   src/nf.f90
   src/nf/nf_activation.f90
   src/nf/nf_base_layer.f90
+  src/nf/nf_conv1d_layer.f90
+  src/nf/nf_conv1d_layer_submodule.f90
   src/nf/nf_conv2d_layer.f90
   src/nf/nf_conv2d_layer_submodule.f90
   src/nf/nf_cross_attention_layer.f90

example/cnn_mnist_1d.f90

@@ -1,4 +1,4 @@
-program cnn_mnist
+program cnn_mnist_1d
 
     use nf, only: network, sgd, &
       input, conv2d, maxpool1d, maxpool2d, flatten, dense, reshape, reshape2d, locally_connected_1d, &
@@ -63,5 +63,5 @@ real function accuracy(net, x, y)
       accuracy = real(good) / size(x, dim=2)
     end function accuracy
 
-  end program cnn_mnist
+  end program cnn_mnist_1d
 

src/nf.f90

@@ -3,16 +3,8 @@ 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, maxpool1d, maxpool2d, reshape, reshape2d, locally_connected_1d
-    conv2d, &
-    dense, &
-    dropout, &
-    flatten, &
-    input, &
-    linear2d, &
-    maxpool2d, &
-    reshape, &
-    self_attention
+    conv1d, conv2d, dense, dropout, flatten, input, linear2d, locally_connected_1d, &
+    maxpool1d, maxpool2d, reshape, reshape2d, self_attention
   use nf_loss, only: mse, quadratic
   use nf_metrics, only: corr, maxabs
   use nf_network, only: network

src/nf/nf_conv1d_layer.f90

@@ -0,0 +1,119 @@
+module nf_conv1d_layer
+    !! This modules provides a 1-d convolutional `conv1d` type.
+  
+    use nf_activation, only: activation_function
+    use nf_base_layer, only: base_layer
+    implicit none
+  
+    private
+    public :: conv1d_layer
+  
+    type, extends(base_layer) :: conv1d_layer
+  
+      integer :: width
+      integer :: height
+      integer :: channels
+      integer :: kernel_size
+      integer :: filters
+  
+      real, allocatable :: biases(:) ! size(filters)
+      real, allocatable :: kernel(:,:,:) ! filters x channels x window x window
+      real, allocatable :: output(:,:) ! filters x output_width * output_height
+      real, allocatable :: z(:,:) ! kernel .dot. input + bias
+  
+      real, allocatable :: dw(:,:,:) ! weight (kernel) gradients
+      real, allocatable :: db(:) ! bias gradients
+      real, allocatable :: gradient(:,:)
+  
+      class(activation_function), allocatable :: activation
+  
+    contains
+  
+      procedure :: forward
+      procedure :: backward
+      procedure :: get_gradients
+      procedure :: get_num_params
+      procedure :: get_params
+      procedure :: init
+      procedure :: set_params
+  
+    end type conv1d_layer
+  
+    interface conv1d_layer
+      module function conv1d_layer_cons(filters, kernel_size, activation) &
+        result(res)
+        !! `conv1d_layer` constructor function
+        integer, intent(in) :: filters
+        integer, intent(in) :: kernel_size
+        class(activation_function), intent(in) :: activation
+        type(conv1d_layer) :: res
+      end function conv1d_layer_cons
+    end interface conv1d_layer
+  
+    interface
+  
+      module subroutine init(self, input_shape)
+        !! Initialize the layer data structures.
+        !!
+        !! This is a deferred procedure from the `base_layer` abstract type.
+        class(conv1d_layer), intent(in out) :: self
+          !! A `conv1d_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 `conv1d` layer.
+        class(conv1d_layer), intent(in out) :: self
+          !! A `conv1d_layer` instance
+        real, intent(in) :: input(:,:)
+          !! Input data
+      end subroutine forward
+  
+      pure module subroutine backward(self, input, gradient)
+        !! Apply a backward pass on the `conv1d` layer.
+        class(conv1d_layer), intent(in out) :: self
+          !! A `conv1d_layer` instance
+        real, intent(in) :: input(:,:)
+          !! Input data (previous layer)
+        real, intent(in) :: gradient(:,:)
+          !! Gradient (next layer)
+      end subroutine backward
+  
+      pure module function get_num_params(self) result(num_params)
+        !! Get the number of parameters in the layer.
+        class(conv1d_layer), intent(in) :: self
+          !! A `conv1d_layer` instance
+        integer :: num_params
+          !! Number of parameters
+      end function get_num_params
+  
+      module function get_params(self) result(params)
+        !! Return the parameters (weights and biases) of this layer.
+        !! The parameters are ordered as weights first, biases second.
+        class(conv1d_layer), intent(in), target :: self
+          !! A `conv1d_layer` instance
+        real, allocatable :: params(:)
+          !! Parameters to get
+      end function get_params
+  
+      module function get_gradients(self) result(gradients)
+        !! Return the gradients of this layer.
+        !! The gradients are ordered as weights first, biases second.
+        class(conv1d_layer), intent(in), target :: self
+          !! A `conv1d_layer` instance
+        real, allocatable :: gradients(:)
+          !! Gradients to get
+      end function get_gradients
+  
+      module subroutine set_params(self, params)
+        !! Set the parameters of the layer.
+        class(conv1d_layer), intent(in out) :: self
+          !! A `conv1d_layer` instance
+        real, intent(in) :: params(:)
+          !! Parameters to set
+      end subroutine set_params
+  
+    end interface
+
+end module nf_conv1d_layer

src/nf/nf_conv1d_layer_submodule.f90

@@ -0,0 +1,187 @@
+submodule(nf_conv1d_layer) nf_conv1d_layer_submodule
+
+  use nf_activation, only: activation_function
+  use nf_random, only: random_normal
+
+  implicit none
+
+contains
+
+  module function conv1d_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
+    type(conv1d_layer) :: res
+
+    res % kernel_size = kernel_size
+    res % filters = filters
+    res % activation_name = activation % get_name()
+    allocate( res % activation, source = activation )
+  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(:)
+
+    self % channels = input_shape(1)
+    self % width = input_shape(2) - self % kernel_size + 1
+
+    ! Output of shape: filters x width
+    allocate(self % output(self % filters, self % width))
+    self % output = 0
+
+    ! Kernel of shape: filters x channels x kernel_size
+    allocate(self % kernel(self % filters, self % channels, self % kernel_size))
+    call random_normal(self % kernel)
+    self % kernel = self % kernel / real(self % kernel_size**2)
+
+    allocate(self % biases(self % filters))
+    self % biases = 0
+
+    allocate(self % z, mold=self % output)
+    self % z = 0
+
+    allocate(self % gradient(input_shape(1), input_shape(2)))
+    self % gradient = 0
+
+    allocate(self % dw, mold=self % kernel)
+    self % dw = 0
+
+    allocate(self % db, mold=self % biases)
+    self % db = 0
+
+  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 :: j, n
+    integer :: iws, iwe, half_window
+
+    input_channels = size(input, dim=1)
+    input_width    = size(input, dim=2)
+    half_window = self % kernel_size / 2
+
+    ! Loop over output positions.
+    do j = 1, self % width
+      ! Compute the input window corresponding to output index j.
+      ! In forward: center index = j + half_window, so window = indices j to j+kernel_size-1.
+      iws = j
+      iwe = j + self % kernel_size - 1
+
+      ! For each filter, compute the convolution (inner product over channels and kernel width).
+      do concurrent (n = 1:self % filters)
+        self % z(n, j) = sum(self % kernel(n, :, :) * input(:, iws:iwe))
+      end do
+
+      ! Add the bias for each filter.
+      self % z(:, j) = self % z(:, j) + self % biases
+    end do
+
+    ! Apply the activation function.
+    self % output = self % activation % eval(self % z)
+  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)
+    real, intent(in) :: input(:,:)
+    real, intent(in) :: gradient(:,:)
+
+    integer :: input_channels, input_width, output_width
+    integer :: j, n, k
+    integer :: iws, iwe, half_window
+    real :: gdz_val
+
+    ! Local arrays to accumulate gradients.
+    real :: gdz(self % filters, self % width)  ! local gradient (dL/dz)
+    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)
+    output_width   = self % width    ! Note: output_width = input_width - kernel_size + 1
+
+    half_window = self % kernel_size / 2
+
+    !--- Compute the local gradient gdz = (dL/dy) * sigma'(z) for each output.
+    do j = 1, output_width
+       gdz(:, j) = gradient(:, j) * self % activation % eval_prime(self % z(:, j))
+    end do
+
+    !--- Compute bias gradients: db(n) = sum_j gdz(n, j)
+    do n = 1, self % filters
+       db_local(n) = sum(gdz(n, :))
+    end do
+
+    !--- Initialize weight gradient and input gradient accumulators.
+    dw_local = 0.0
+    self % gradient = 0.0
+
+    !--- Accumulate gradients over each output position.
+    ! In the forward pass the window for output index j was:
+    !   iws = j,  iwe = j + kernel_size - 1.
+    do n = 1, self % filters
+       do j = 1, output_width
+          iws = j
+          iwe = j + self % kernel_size - 1
+          do k = 1, self % channels
+             ! Weight gradient: accumulate contribution from the input window.
+             dw_local(n, k, :) = dw_local(n, k, :) + input(k, iws:iwe) * gdz(n, j)
+             ! Input gradient: propagate gradient back to the input window.
+             self % gradient(k, iws:iwe) = self % gradient(k, iws:iwe) + self % kernel(n, k, :) * gdz(n, j)
+          end do
+       end do
+    end do
+
+    !--- Update stored gradients.
+    self % dw = self % dw + dw_local
+    self % db = self % db + db_local
+
+  end subroutine backward
+
+  pure module function get_num_params(self) result(num_params)
+    class(conv1d_layer), intent(in) :: self
+    integer :: num_params
+    num_params = product(shape(self % kernel)) + size(self % biases)
+  end function get_num_params
+
+  module function get_params(self) result(params)
+    class(conv1d_layer), intent(in), target :: self
+    real, allocatable :: params(:)
+    real, pointer :: w_(:) => null()
+    w_(1:size(self % kernel)) => self % kernel
+    params = [ w_, self % biases ]
+  end function get_params
+
+  module function get_gradients(self) result(gradients)
+    class(conv1d_layer), intent(in), target :: self
+    real, allocatable :: gradients(:)
+    real, pointer :: dw_(:) => null()
+    dw_(1:size(self % dw)) => self % dw
+    gradients = [ dw_, self % db ]
+  end function get_gradients
+
+  module subroutine set_params(self, params)
+    class(conv1d_layer), intent(in out) :: self
+    real, intent(in) :: params(:)
+
+    if (size(params) /= self % get_num_params()) then
+      error stop 'conv1d_layer % set_params: Number of parameters does not match'
+    end if
+
+    self % kernel = reshape(params(:product(shape(self % kernel))), shape(self % kernel))
+    associate(n => product(shape(self % kernel)))
+      self % biases = params(n + 1 : n + self % filters)
+    end associate
+
+  end subroutine set_params
+
+end submodule nf_conv1d_layer_submodule

src/nf/nf_layer_constructors.f90

@@ -9,6 +9,7 @@ module nf_layer_constructors
 
   private
   public :: &
+    conv1d, &
     conv2d, &
     dense, &
     dropout, &
@@ -152,6 +153,34 @@ module function flatten() result(res)
         !! Resulting layer instance
     end function flatten
 
+    module function conv1d(filters, kernel_size, activation) result(res)
+      !! CHANGE THE COMMENTS
+      !! 2-d convolutional layer constructor.
+      !!
+      !! This layer is for building 2-d convolutional network.
+      !! Although the established convention is to call these layers 2-d,
+      !! the shape of the data is actuall 3-d: image width, image height,
+      !! and the number of channels.
+      !! A conv2d layer must not be the first layer in the network.
+      !!
+      !! Example:
+      !!
+      !! ```
+      !! use nf, only :: conv2d, layer
+      !! type(layer) :: conv2d_layer
+      !! conv2d_layer = dense(filters=32, kernel_size=3)
+      !! conv2d_layer = dense(filters=32, kernel_size=3, activation='relu')
+      !! ```
+      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
+      class(activation_function), intent(in), optional :: activation
+        !! Activation function (default sigmoid)
+      type(layer) :: res
+        !! Resulting layer instance
+    end function conv1d
+
     module function conv2d(filters, kernel_size, activation) result(res)
       !! 2-d convolutional layer constructor.
       !!