Merge main

Author: milancurcic

CMakeLists.txt

@@ -30,6 +30,8 @@ add_library(neural-fortran
   src/nf/nf_flatten_layer_submodule.f90
   src/nf/nf_input1d_layer.f90
   src/nf/nf_input1d_layer_submodule.f90
+  src/nf/nf_input2d_layer.f90
+  src/nf/nf_input2d_layer_submodule.f90
   src/nf/nf_input3d_layer.f90
   src/nf/nf_input3d_layer_submodule.f90
   src/nf/nf_layer_constructors.f90

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2024 neural-fortran contributors
+Copyright (c) 2018-2025 neural-fortran contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -29,12 +29,12 @@ Read the paper [here](https://arxiv.org/abs/1902.06714).
 
 | Layer type | Constructor name | Supported input layers | Rank of output array | Forward pass | Backward pass |
 |------------|------------------|------------------------|----------------------|--------------|---------------|
-| Input | `input` | n/a | 1, 3 | n/a | n/a |
+| Input | `input` | n/a | 1, 2, 3 | n/a | n/a |
 | Dense (fully-connected) | `dense` | `input1d`, `flatten` | 1 | ✅ | ✅ |
 | Dropout | `dropout` | Any | 1 | ✅ | ✅ |
 | Convolutional (2-d) | `conv2d` | `input3d`, `conv2d`, `maxpool2d`, `reshape` | 3 | ✅ | ✅(*) |
 | Max-pooling (2-d) | `maxpool2d` | `input3d`, `conv2d`, `maxpool2d`, `reshape` | 3 | ✅ | ✅ |
-| Flatten | `flatten` | `input3d`, `conv2d`, `maxpool2d`, `reshape` | 1 | ✅ | ✅ |
+| Flatten | `flatten` | `input2d`, `input3d`, `conv2d`, `maxpool2d`, `reshape` | 1 | ✅ | ✅ |
 | Reshape (1-d to 3-d) | `reshape` | `input1d`, `dense`, `flatten` | 3 | ✅ | ✅ |
 
 (*) See Issue [#145](https://github.com/modern-fortran/neural-fortran/issues/145) regarding non-converging CNN training on the MNIST dataset.

fpm.toml

@@ -2,7 +2,7 @@ name = "neural-fortran"
 version = "0.19.0"
 license = "MIT"
 author = "Milan Curcic"
-maintainer = "[email protected]"
+maintainer = "[email protected]"
 copyright = "Copyright 2018-2025, neural-fortran contributors"
 
 [preprocess]

src/nf/nf_flatten_layer.f90

@@ -18,7 +18,8 @@ module nf_flatten_layer
     integer, allocatable :: input_shape(:)
     integer :: output_size
 
-    real, allocatable :: gradient(:,:,:)
+    real, allocatable :: gradient_2d(:,:)
+    real, allocatable :: gradient_3d(:,:,:)
     real, allocatable :: output(:)
 
   contains
@@ -40,23 +41,23 @@ end function flatten_layer_cons
   interface
 
     pure module subroutine backward(self, input, gradient)
-      !! Apply the backward pass to the flatten layer.
-      !! This is a reshape operation from 1-d gradient to 3-d input.
+      !! Apply the backward pass to the flatten layer for 2D and 3D input.
+      !! This is a reshape operation from 1-d gradient to 2-d and 3-d input.
       class(flatten_layer), intent(in out) :: self
         !! Flatten layer instance
-      real, intent(in) :: input(:,:,:)
+      real, intent(in) :: input(..)
         !! Input from the previous layer
       real, intent(in) :: gradient(:)
         !! Gradient from the next layer
     end subroutine backward
 
     pure module subroutine forward(self, input)
-      !! Propagate forward the layer.
+      !! Propagate forward the layer for 2D or 3D input.
       !! Calling this subroutine updates the values of a few data components
       !! of `flatten_layer` that are needed for the backward pass.
       class(flatten_layer), intent(in out) :: self
         !! Dense layer instance
-      real, intent(in) :: input(:,:,:)
+      real, intent(in) :: input(..)
         !! Input from the previous layer
     end subroutine forward
 

src/nf/nf_flatten_layer_submodule.f90

@@ -17,16 +17,30 @@ end function flatten_layer_cons
 
   pure module subroutine backward(self, input, gradient)
     class(flatten_layer), intent(in out) :: self
-    real, intent(in) :: input(:,:,:)
+    real, intent(in) :: input(..)
     real, intent(in) :: gradient(:)
-    self % gradient = reshape(gradient, shape(input))
+    select rank(input)
+      rank(2)
+        self % gradient_2d = reshape(gradient, shape(input))
+      rank(3)
+        self % gradient_3d = reshape(gradient, shape(input))
+      rank default
+        error stop "Unsupported rank of input"
+    end select
   end subroutine backward
 
 
   pure module subroutine forward(self, input)
     class(flatten_layer), intent(in out) :: self
-    real, intent(in) :: input(:,:,:)
-    self % output = pack(input, .true.)
+    real, intent(in) :: input(..)
+    select rank(input)
+      rank(2)
+        self % output = pack(input, .true.)
+      rank(3)
+        self % output = pack(input, .true.)
+      rank default
+        error stop "Unsupported rank of input"
+    end select
   end subroutine forward
 
 
@@ -37,8 +51,13 @@ module subroutine init(self, input_shape)
     self % input_shape = input_shape
     self % output_size = product(input_shape)
 
-    allocate(self % gradient(input_shape(1), input_shape(2), input_shape(3)))
-    self % gradient = 0
+    if (size(input_shape) == 2) then
+      allocate(self % gradient_2d(input_shape(1), input_shape(2)))
+      self % gradient_2d = 0
+    else if (size(input_shape) == 3) then
+      allocate(self % gradient_3d(input_shape(1), input_shape(2), input_shape(3)))
+      self % gradient_3d = 0
+    end if
 
     allocate(self % output(self % output_size))
     self % output = 0

src/nf/nf_input2d_layer.f90

@@ -0,0 +1,48 @@
+module nf_input2d_layer
+
+  !! This module provides the `input2d_layer` type.
+
+  use nf_base_layer, only: base_layer
+  implicit none
+
+  private
+  public :: input2d_layer
+
+  type, extends(base_layer) :: input2d_layer
+    real, allocatable :: output(:,:)
+  contains
+    procedure :: init
+    procedure :: set
+  end type input2d_layer
+
+  interface input2d_layer
+    pure module function input2d_layer_cons(output_shape) result(res)
+      !! Create a new instance of the 2-d input layer.
+      !! Only used internally by the `layer % init` method.
+      integer, intent(in) :: output_shape(2)
+        !! Shape of the input layer
+      type(input2d_layer) :: res
+        !! 2-d input layer instance
+    end function input2d_layer_cons
+  end interface input2d_layer
+
+  interface
+
+    module subroutine init(self, input_shape)
+      !! Only here to satisfy the language rules
+      !! about deferred methods of abstract types.
+      !! This method does nothing for this type and should not be called.
+      class(input2d_layer), intent(in out) :: self
+      integer, intent(in) :: input_shape(:)
+    end subroutine init
+
+    pure module subroutine set(self, values)
+      class(input2d_layer), intent(in out) :: self
+        !! Layer instance
+      real, intent(in) :: values(:,:)
+        !! Values to set
+    end subroutine set
+
+  end interface
+
+end module nf_input2d_layer 

src/nf/nf_input2d_layer_submodule.f90

@@ -0,0 +1,23 @@
+submodule(nf_input2d_layer) nf_input2d_layer_submodule
+  implicit none
+contains
+
+  pure module function input2d_layer_cons(output_shape) result(res)
+    integer, intent(in) :: output_shape(2)
+    type(input2d_layer) :: res
+    allocate(res % output(output_shape(1), output_shape(2)))
+    res % output = 0
+  end function input2d_layer_cons
+
+  module subroutine init(self, input_shape)
+    class(input2d_layer), intent(in out) :: self
+    integer, intent(in) :: input_shape(:)
+  end subroutine init
+
+  pure module subroutine set(self, values)
+    class(input2d_layer), intent(in out) :: self
+    real, intent(in) :: values(:,:)
+    self % output = values
+  end subroutine set
+
+end submodule nf_input2d_layer_submodule 

src/nf/nf_layer.f90

@@ -35,12 +35,14 @@ module nf_layer
 
     ! Specific subroutines for different array ranks
     procedure, private :: backward_1d
+    procedure, private :: backward_2d
     procedure, private :: backward_3d
     procedure, private :: get_output_1d
+    procedure, private :: get_output_2d
     procedure, private :: get_output_3d
 
-    generic :: backward => backward_1d, backward_3d
-    generic :: get_output => get_output_1d, get_output_3d
+    generic :: backward => backward_1d, backward_2d, backward_3d
+    generic :: get_output => get_output_1d, get_output_2d, get_output_3d
 
   end type layer
 
@@ -59,6 +61,19 @@ pure module subroutine backward_1d(self, previous, gradient)
         !! Array of gradient values from the next layer
     end subroutine backward_1d
 
+    pure module subroutine backward_2d(self, previous, gradient)
+      !! Apply a backward pass on the layer.
+      !! This changes the internal state of the layer.
+      !! This is normally called internally by the `network % backward`
+      !! method.
+      class(layer), intent(in out) :: self
+        !! Layer instance
+      class(layer), intent(in) :: previous
+        !! Previous layer instance
+      real, intent(in) :: gradient(:, :)
+        !! Array of gradient values from the next layer
+    end subroutine backward_2d
+
     pure module subroutine backward_3d(self, previous, gradient)
       !! Apply a backward pass on the layer.
       !! This changes the internal state of the layer.
@@ -95,6 +110,14 @@ pure module subroutine get_output_1d(self, output)
         !! Output values from this layer
     end subroutine get_output_1d
 
+    pure module subroutine get_output_2d(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_2d
+
     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)

src/nf/nf_layer_constructors.f90

@@ -35,10 +35,10 @@ module function input1d(layer_size) result(res)
         !! Resulting layer instance
     end function input1d
 
-    module function input3d(layer_shape) result(res)
-      !! 3-d input layer constructor.
+    module function input2d(dim1, dim2) result(res)
+      !! 2-d input layer constructor.
       !!
-      !! This layer is for inputting 3-d data to the network.
+      !! This layer is for inputting 2-d data to the network.
       !! Currently, this layer must be followed by a conv2d layer.
       !! An input layer must be the first layer in the network.
       !!
@@ -50,10 +50,29 @@ module function input3d(layer_shape) result(res)
       !! ```
       !! use nf, only :: input, layer
       !! type(layer) :: input_layer
-      !! input_layer = input([28, 28, 1])
+      !! input_layer = input(28, 28)
+      !! ```
+      integer, intent(in) :: dim1, dim2
+        !! First and second dimension sizes
+      type(layer) :: res
+        !! Resulting layer instance
+    end function input2d
+
+    module function input3d(dim1, dim2, dim3) result(res)
+      !! 3-d input layer constructor.
+      !!
+      !! This is a specific function that is available
+      !! under a generic name `input`.
+      !!
+      !! Example:
+      !!
+      !! ```
+      !! use nf, only :: input, layer
+      !! type(layer) :: input_layer
+      !! input_layer = input(28, 28, 1)
       !! ```
-      integer, intent(in) :: layer_shape(3)
-        !! Shape of the input layer
+      integer, intent(in) :: dim1, dim2, dim3
+        !! First, second and third dimension sizes
       type(layer) :: res
         !! Resulting layer instance
     end function input3d