linear2d_layer: add flatten2d layer

Author: OneAdder

src/nf/nf_flatten2d_layer.f90

@@ -0,0 +1,75 @@
+module nf_flatten2d_layer
+
+  !! This module provides the concrete flatten2d layer type.
+  !! It is used internally by the layer type.
+  !! It is not intended to be used directly by the user.
+
+  use nf_base_layer, only: base_layer
+
+  implicit none
+
+  private
+  public :: flatten2d_layer
+
+  type, extends(base_layer) :: flatten2d_layer
+
+    !! Concrete implementation of a flatten2d (2-d to 1-d) layer.
+
+    integer, allocatable :: input_shape(:)
+    integer :: output_size
+
+    real, allocatable :: gradient(:,:)
+    real, allocatable :: output(:)
+
+  contains
+
+    procedure :: backward
+    procedure :: forward
+    procedure :: init
+
+  end type flatten2d_layer
+
+  interface flatten2d_layer
+    elemental module function flatten2d_layer_cons() result(res)
+      !! This function returns the `flatten2d_layer` instance.
+      type(flatten2d_layer) :: res
+        !! `flatten2d_layer` instance
+    end function flatten2d_layer_cons
+  end interface flatten2d_layer
+
+  interface
+
+    pure module subroutine backward(self, input, gradient)
+      !! Apply the backward pass to the flatten2d layer.
+      !! This is a reshape operation from 1-d gradient to 2-d input.
+      class(flatten2d_layer), intent(in out) :: self
+        !! flatten2d layer instance
+      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.
+      !! Calling this subroutine updates the values of a few data components
+      !! of `flatten2d_layer` that are needed for the backward pass.
+      class(flatten2d_layer), intent(in out) :: self
+        !! Dense layer instance
+      real, intent(in) :: input(:,:)
+        !! Input from the previous layer
+    end subroutine forward
+
+    module subroutine init(self, input_shape)
+      !! Initialize the layer data structures.
+      !!
+      !! This is a deferred procedure from the `base_layer` abstract type.
+      class(flatten2d_layer), intent(in out) :: self
+        !! Dense layer instance
+      integer, intent(in) :: input_shape(:)
+        !! Shape of the input layer
+    end subroutine init
+
+  end interface
+
+end module nf_flatten2d_layer

src/nf/nf_flatten2d_layer_submodule.f90

@@ -0,0 +1,48 @@
+submodule(nf_flatten2d_layer) nf_flatten2d_layer_submodule
+
+  !! This module provides the concrete flatten2d layer type.
+  !! It is used internally by the layer type.
+  !! It is not intended to be used directly by the user.
+
+  use nf_base_layer, only: base_layer
+
+  implicit none
+
+contains
+
+  elemental module function flatten2d_layer_cons() result(res)
+    type(flatten2d_layer) :: res
+  end function flatten2d_layer_cons
+
+
+  pure module subroutine backward(self, input, gradient)
+    class(flatten2d_layer), intent(in out) :: self
+    real, intent(in) :: input(:,:)
+    real, intent(in) :: gradient(:)
+    self % gradient = reshape(gradient, shape(input))
+  end subroutine backward
+
+
+  pure module subroutine forward(self, input)
+    class(flatten2d_layer), intent(in out) :: self
+    real, intent(in) :: input(:,:)
+    self % output = pack(input, .true.)
+  end subroutine forward
+
+
+  module subroutine init(self, input_shape)
+    class(flatten2d_layer), intent(in out) :: self
+    integer, intent(in) :: input_shape(:)
+
+    self % input_shape = input_shape
+    self % output_size = product(input_shape)
+
+    allocate(self % gradient(input_shape(1), input_shape(2)))
+    self % gradient = 0
+
+    allocate(self % output(self % output_size))
+    self % output = 0
+
+  end subroutine init
+
+end submodule nf_flatten2d_layer_submodule

src/nf/nf_layer_constructors.f90

@@ -8,7 +8,7 @@ module nf_layer_constructors
   implicit none
 
   private
-  public :: conv2d, dense, flatten, input, maxpool2d, reshape, linear2d
+  public :: conv2d, dense, flatten, flatten2d, input, maxpool2d, reshape, linear2d
 
   interface input
 
@@ -125,6 +125,25 @@ module function flatten() result(res)
         !! Resulting layer instance
     end function flatten
 
+    module function flatten2d() result(res)
+      !! Flatten (2-d -> 1-d) layer constructor.
+      !!
+      !! Use this layer to chain layers with 2-d outputs to layers with 2-d
+      !! inputs.
+      !!
+      !! A flatten layer must not be the first layer in the network.
+      !!
+      !! Example:
+      !!
+      !! ```
+      !! use nf, only :: flatten, layer
+      !! type(layer) :: flatten_layer
+      !! flatten_layer = flatten()
+      !! ```
+      type(layer) :: res
+        !! Resulting layer instance
+    end function flatten2d
+
     module function conv2d(filters, kernel_size, activation) result(res)
       !! 2-d convolutional layer constructor.
       !!

src/nf/nf_layer_constructors_submodule.f90

@@ -4,6 +4,7 @@
   use nf_conv2d_layer, only: conv2d_layer
   use nf_dense_layer, only: dense_layer
   use nf_flatten_layer, only: flatten_layer
+  use nf_flatten2d_layer, only: flatten2d_layer
   use nf_input1d_layer, only: input1d_layer
   use nf_input2d_layer, only: input2d_layer
   use nf_input3d_layer, only: input3d_layer
@@ -72,6 +73,13 @@ module function flatten() result(res)
   end function flatten
 
 
+  module function flatten2d() result(res)
+    type(layer) :: res
+    res % name = 'flatten2d'
+    allocate(res % p, source=flatten2d_layer())
+  end function flatten2d
+
+
   module function input1d(layer_size) result(res)
     integer, intent(in) :: layer_size
     type(layer) :: res

test/test_flatten2d_layer.f90

@@ -0,0 +1,89 @@
+program test_flatten2d_layer
+
+  use iso_fortran_env, only: stderr => error_unit
+  use nf, only: dense, flatten2d, input, layer, network
+  use nf_flatten2d_layer, only: flatten2d_layer
+  use nf_input2d_layer, only: input2d_layer
+
+  implicit none
+
+  type(layer) :: test_layer, input_layer
+  type(network) :: net
+  real, allocatable :: gradient(:,:)
+  real, allocatable :: output(:)
+  logical :: ok = .true.
+
+  test_layer = flatten2d()
+
+  if (.not. test_layer % name == 'flatten2d') then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer has its name set correctly.. failed'
+  end if
+
+  if (test_layer % initialized) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer is not initialized yet.. failed'
+  end if
+
+  input_layer = input(1, 2)
+  call test_layer % init(input_layer)
+
+  if (.not. test_layer % initialized) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer is now initialized.. failed'
+  end if
+
+  if (.not. all(test_layer % layer_shape == [2])) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer has an incorrect output shape.. failed'
+  end if
+
+  ! Test forward pass - reshaping from 2-d to 1-d
+
+  select type(this_layer => input_layer % p); type is(input2d_layer)
+    call this_layer % set(reshape(real([1, 2, 3, 4]), [2, 2]))
+  end select
+
+  call test_layer % forward(input_layer)
+  call test_layer % get_output(output)
+
+  if (.not. all(output == [1, 2, 3, 4])) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer correctly propagates forward.. failed'
+  end if
+
+  ! Test backward pass - reshaping from 1-d to 2-d
+
+  ! Calling backward() will set the values on the gradient component
+  ! input_layer is used only to determine shape
+  call test_layer % backward(input_layer, real([1, 2, 3, 4]))
+
+  select type(this_layer => test_layer % p); type is(flatten2d_layer)
+    gradient = this_layer % gradient
+  end select
+
+  if (.not. all(gradient == reshape(real([1, 2, 3, 4]), [2, 2]))) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer correctly propagates backward.. failed'
+  end if
+
+  net = network([ &
+    input(28, 28), &
+    flatten2d(), &
+    dense(10) &
+  ])
+
+  ! Test that the output layer receives 784 elements in the input
+  if (.not. all(net % layers(3) % input_layer_shape == [784])) then
+    ok = .false.
+    write(stderr, '(a)') 'flatten2d layer correctly chains input2d to dense.. failed'
+  end if
+
+  if (ok) then
+    print '(a)', 'test_flatten2d_layer: All tests passed.'
+  else
+    write(stderr, '(a)') 'test_flatten2d_layer: One or more tests failed.'
+    stop 1
+  end if
+
+end program test_flatten2d_layer