From d9b4070e59d52b7af085fa456916684f51e6157b Mon Sep 17 00:00:00 2001
From: Riccardo Orsi <riccardoorsi@icloud.com>
Date: Sun, 16 Mar 2025 21:17:32 +0100
Subject: [PATCH] Integrated new features into environment
---
CMakeLists.txt | 8 ++
src/nf.f90 | 4 +
src/nf/nf_avgpool1d_layer.f90 | 66 +++++++++
src/nf/nf_avgpool1d_layer_submodule.f90 | 87 ++++++++++++
src/nf/nf_avgpool2d_layer.f90 | 66 +++++++++
src/nf/nf_avgpool2d_layer_submodule.f90 | 94 +++++++++++++
src/nf/nf_avgpool3d_layer.f90 | 67 +++++++++
src/nf/nf_avgpool3d_layer_submodule.f90 | 102 ++++++++++++++
src/nf/nf_layer_constructors.f90 | 92 +++++++++++++
src/nf/nf_layer_constructors_submodule.f90 | 119 ++++++++++++++++
src/nf/nf_layer_submodule.f90 | 149 +++++++++++++++++++++
src/nf/nf_maxpool3d_layer.f90 | 79 +++++++++++
src/nf/nf_maxpool3d_layer_submodule.f90 | 114 ++++++++++++++++
13 files changed, 1047 insertions(+)
create mode 100644 src/nf/nf_avgpool1d_layer.f90
create mode 100644 src/nf/nf_avgpool1d_layer_submodule.f90
create mode 100644 src/nf/nf_avgpool2d_layer.f90
create mode 100644 src/nf/nf_avgpool2d_layer_submodule.f90
create mode 100644 src/nf/nf_avgpool3d_layer.f90
create mode 100644 src/nf/nf_avgpool3d_layer_submodule.f90
create mode 100644 src/nf/nf_maxpool3d_layer.f90
create mode 100644 src/nf/nf_maxpool3d_layer_submodule.f90
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 667b5d73..c892a494 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,12 @@ include(cmake/compilers.cmake)
add_library(neural-fortran
src/nf.f90
src/nf/nf_activation.f90
+ src/nf/nf_avgpool1d_layer.f90
+ src/nf/nf_avgpool1d_layer_submodule.f90
+ src/nf/nf_avgpool2d_layer.f90
+ src/nf/nf_avgpool2d_layer_submodule.f90
+ src/nf/nf_avgpool3d_layer.f90
+ src/nf/nf_avgpool3d_layer_submodule.f90
src/nf/nf_base_layer.f90
src/nf/nf_conv1d_layer.f90
src/nf/nf_conv1d_layer_submodule.f90
@@ -55,6 +61,8 @@ add_library(neural-fortran
src/nf/nf_maxpool1d_layer_submodule.f90
src/nf/nf_maxpool2d_layer.f90
src/nf/nf_maxpool2d_layer_submodule.f90
+ src/nf/nf_maxpool3d_layer.f90
+ src/nf/nf_maxpool3d_layer_submodule.f90
src/nf/nf_metrics.f90
src/nf/nf_multihead_attention.f90
src/nf/nf_multihead_attention_submodule.f90
diff --git a/src/nf.f90 b/src/nf.f90
index f644826d..f04bd2f0 100644
--- a/src/nf.f90
+++ b/src/nf.f90
@@ -3,6 +3,9 @@ module nf
use nf_datasets_mnist, only: label_digits, load_mnist
use nf_layer, only: layer
use nf_layer_constructors, only: &
+ avgpool1d, &
+ avgpool2d, &
+ avgpool3d, &
conv1d, &
conv2d, &
dense, &
@@ -15,6 +18,7 @@ module nf
locally_connected1d, &
maxpool1d, &
maxpool2d, &
+ maxpool3d, &
reshape, &
self_attention
use nf_loss, only: mse, quadratic
diff --git a/src/nf/nf_avgpool1d_layer.f90 b/src/nf/nf_avgpool1d_layer.f90
new file mode 100644
index 00000000..631f4895
--- /dev/null
+++ b/src/nf/nf_avgpool1d_layer.f90
@@ -0,0 +1,66 @@
+module nf_avgpool1d_layer
+ !! This module provides the 1-d average pooling layer.
+
+ use nf_base_layer, only: base_layer
+ implicit none
+
+ private
+ public :: avgpool1d_layer
+
+ type, extends(base_layer) :: avgpool1d_layer
+ integer :: channels
+ integer :: width ! Length of the input along the pooling dimension
+ integer :: pool_size
+ integer :: stride
+
+ ! 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 avgpool1d_layer
+
+ interface avgpool1d_layer
+ pure module function avgpool1d_layer_cons(pool_size, stride) result(res)
+ !! `avgpool1d` constructor function.
+ integer, intent(in) :: pool_size
+ !! Width of the pooling window.
+ integer, intent(in) :: stride
+ !! Stride of the pooling window.
+ type(avgpool1d_layer) :: res
+ end function avgpool1d_layer_cons
+ end interface avgpool1d_layer
+
+ interface
+ module subroutine init(self, input_shape)
+ !! Initialize the `avgpool1d` layer instance with an input shape.
+ class(avgpool1d_layer), intent(in out) :: self
+ !! `avgpool1d_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 `avgpool1d` layer.
+ class(avgpool1d_layer), intent(in out) :: self
+ !! `avgpool1d_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 `avgpool1d` layer.
+ class(avgpool1d_layer), intent(in out) :: self
+ !! `avgpool1d_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_avgpool1d_layer
+
\ No newline at end of file
diff --git a/src/nf/nf_avgpool1d_layer_submodule.f90 b/src/nf/nf_avgpool1d_layer_submodule.f90
new file mode 100644
index 00000000..8e022fbf
--- /dev/null
+++ b/src/nf/nf_avgpool1d_layer_submodule.f90
@@ -0,0 +1,87 @@
+submodule(nf_avgpool1d_layer) nf_avgpool1d_layer_submodule
+ implicit none
+
+contains
+
+ pure module function avgpool1d_layer_cons(pool_size, stride) result(res)
+ implicit none
+ integer, intent(in) :: pool_size
+ integer, intent(in) :: stride
+ type(avgpool1d_layer) :: res
+
+ res % pool_size = pool_size
+ res % stride = stride
+ end function avgpool1d_layer_cons
+
+
+ module subroutine init(self, input_shape)
+ implicit none
+ class(avgpool1d_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 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(avgpool1d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:)
+ integer :: input_width
+ integer :: i, n
+ integer :: ii, iend
+ integer :: iextent
+
+ 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)
+
+ ! Compute the average over the pooling region.
+ self % output(n, ii) = sum(input(n, i:iend)) / (iend - i + 1)
+ end do
+ end subroutine forward
+
+
+ pure module subroutine backward(self, input, gradient)
+ implicit none
+ class(avgpool1d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:)
+ real, intent(in) :: gradient(:,:)
+ integer :: channels, pooled_width
+ integer :: i, n, j, istart, iend
+ real :: scale_factor
+
+ channels = size(gradient, dim=1)
+ pooled_width = size(gradient, dim=2)
+
+ ! The gradient for average pooling is distributed evenly over the pooling window.
+ do concurrent (n = 1:channels, i = 1:pooled_width)
+ istart = (i - 1) * self % stride + 1
+ iend = min(istart + self % pool_size - 1, size(input, dim=2))
+ scale_factor = 1.0 / (iend - istart + 1)
+
+ do j = istart, iend
+ self % gradient(n, j) = gradient(n, i) * scale_factor
+ end do
+ end do
+ end subroutine backward
+
+end submodule nf_avgpool1d_layer_submodule
\ No newline at end of file
diff --git a/src/nf/nf_avgpool2d_layer.f90 b/src/nf/nf_avgpool2d_layer.f90
new file mode 100644
index 00000000..fcf8b970
--- /dev/null
+++ b/src/nf/nf_avgpool2d_layer.f90
@@ -0,0 +1,66 @@
+module nf_avgpool2d_layer
+ !! This module provides the 2-d average pooling layer.
+
+ use nf_base_layer, only: base_layer
+ implicit none
+
+ private
+ public :: avgpool2d_layer
+
+ type, extends(base_layer) :: avgpool2d_layer
+ integer :: channels
+ integer :: height ! Height of the input
+ integer :: width ! Width of the input
+ integer :: pool_size ! Pooling window size (height, width)
+ integer :: stride ! Stride (height, width)
+
+ ! Gradient for the input (same shape as the input: channels, height, width).
+ real, allocatable :: gradient(:,:,:)
+ ! Output after pooling (dimensions: (channels, new_height, new_width)).
+ real, allocatable :: output(:,:,:)
+ contains
+ procedure :: init
+ procedure :: forward
+ procedure :: backward
+ end type avgpool2d_layer
+
+ interface avgpool2d_layer
+ pure module function avgpool2d_layer_cons(pool_size, stride) result(res)
+ !! `avgpool2d` constructor function.
+ integer, intent(in) :: pool_size
+ !! Pooling window size (height, width).
+ integer, intent(in) :: stride
+ !! Stride (height, width).
+ type(avgpool2d_layer) :: res
+ end function avgpool2d_layer_cons
+ end interface avgpool2d_layer
+
+ interface
+ module subroutine init(self, input_shape)
+ !! Initialize the `avgpool2d` layer instance with an input shape.
+ class(avgpool2d_layer), intent(in out) :: self
+ !! `avgpool2d_layer` instance.
+ integer, intent(in) :: input_shape(:)
+ !! Array shape of the input layer, expected as (channels, height, width).
+ end subroutine init
+
+ pure module subroutine forward(self, input)
+ !! Run a forward pass of the `avgpool2d` layer.
+ class(avgpool2d_layer), intent(in out) :: self
+ !! `avgpool2d_layer` instance.
+ real, intent(in) :: input(:,:,:)
+ !! Input data (output of the previous layer), with shape (channels, height, width).
+ end subroutine forward
+
+ pure module subroutine backward(self, input, gradient)
+ !! Run a backward pass of the `avgpool2d` layer.
+ class(avgpool2d_layer), intent(in out) :: self
+ !! `avgpool2d_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_height, pooled_width).
+ end subroutine backward
+ end interface
+
+end module nf_avgpool2d_layer
diff --git a/src/nf/nf_avgpool2d_layer_submodule.f90 b/src/nf/nf_avgpool2d_layer_submodule.f90
new file mode 100644
index 00000000..3029b826
--- /dev/null
+++ b/src/nf/nf_avgpool2d_layer_submodule.f90
@@ -0,0 +1,94 @@
+submodule(nf_avgpool2d_layer) nf_avgpool2d_layer_submodule
+ implicit none
+
+contains
+
+ pure module function avgpool2d_layer_cons(pool_size, stride) result(res)
+ implicit none
+ integer, intent(in) :: pool_size
+ integer, intent(in) :: stride
+ type(avgpool2d_layer) :: res
+
+ res % pool_size = pool_size
+ res % stride = stride
+ end function avgpool2d_layer_cons
+
+
+ module subroutine init(self, input_shape)
+ implicit none
+ class(avgpool2d_layer), intent(in out) :: self
+ integer, intent(in) :: input_shape(:)
+ ! input_shape is expected to be (channels, width, height)
+
+ self % channels = input_shape(1)
+ self % width = input_shape(2) / self % stride
+ self % height = input_shape(3) / self % stride
+
+ ! Allocate the gradient array corresponding to the input dimensions.
+ allocate(self % gradient(input_shape(1), input_shape(2), input_shape(3)))
+ self % gradient = 0
+
+ ! Allocate the output array (after pooling).
+ allocate(self % output(self % channels, self % width, self % height))
+ self % output = 0
+ end subroutine init
+
+
+ pure module subroutine forward(self, input)
+ implicit none
+ class(avgpool2d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:)
+ integer :: input_width, input_height
+ integer :: i, j, n
+ integer :: ii, jj, iend, jend
+ integer :: iextent, jextent
+
+ input_width = size(input, dim=2)
+ input_height = size(input, dim=3)
+
+ ! Ensure we only process complete pooling regions.
+ iextent = input_width - mod(input_width, self % stride)
+ jextent = input_height - mod(input_height, 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, j = 1:jextent:self % stride, n = 1:self % channels)
+ ii = (i - 1) / self % stride + 1
+ jj = (j - 1) / self % stride + 1
+
+ iend = min(i + self % pool_size - 1, input_width)
+ jend = min(j + self % pool_size - 1, input_height)
+
+ ! Compute the average over the pooling region.
+ self % output(n, ii, jj) = sum(input(n, i:iend, j:jend)) / ((iend - i + 1) * (jend - j + 1))
+ end do
+ end subroutine forward
+
+
+ pure module subroutine backward(self, input, gradient)
+ implicit none
+ class(avgpool2d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:)
+ real, intent(in) :: gradient(:,:,:)
+ integer :: channels, pooled_width, pooled_height
+ integer :: i, j, n, x, y, istart, iend, jstart, jend
+ real :: scale_factor
+
+ channels = size(gradient, dim=1)
+ pooled_width = size(gradient, dim=2)
+ pooled_height = size(gradient, dim=3)
+
+ ! The gradient for average pooling is distributed evenly over the pooling window.
+ do concurrent (n = 1:channels, i = 1:pooled_width, j = 1:pooled_height)
+ istart = (i - 1) * self % stride + 1
+ iend = min(istart + self % pool_size - 1, size(input, dim=2))
+ jstart = (j - 1) * self % stride + 1
+ jend = min(jstart + self % pool_size - 1, size(input, dim=3))
+ scale_factor = 1.0 / ((iend - istart + 1) * (jend - jstart + 1))
+
+ do concurrent (x = istart:iend, y = jstart:jend)
+ self % gradient(n, x, y) = gradient(n, i, j) * scale_factor
+ end do
+ end do
+ end subroutine backward
+
+end submodule nf_avgpool2d_layer_submodule
diff --git a/src/nf/nf_avgpool3d_layer.f90 b/src/nf/nf_avgpool3d_layer.f90
new file mode 100644
index 00000000..580547e1
--- /dev/null
+++ b/src/nf/nf_avgpool3d_layer.f90
@@ -0,0 +1,67 @@
+module nf_avgpool3d_layer
+ !! This module provides the 3-d average pooling layer.
+
+ use nf_base_layer, only: base_layer
+ implicit none
+
+ private
+ public :: avgpool3d_layer
+
+ type, extends(base_layer) :: avgpool3d_layer
+ integer :: channels
+ integer :: depth ! Depth of the input
+ integer :: height ! Height of the input
+ integer :: width ! Width of the input
+ integer :: pool_size(3) ! Pooling window size (depth, height, width)
+ integer :: stride(3) ! Stride (depth, height, width)
+
+ ! Gradient for the input (same shape as the input).
+ real, allocatable :: gradient(:,:,:,:)
+ ! Output after pooling (dimensions: (channels, new_depth, new_height, new_width)).
+ real, allocatable :: output(:,:,:,:)
+ contains
+ procedure :: init
+ procedure :: forward
+ procedure :: backward
+ end type avgpool3d_layer
+
+ interface avgpool3d_layer
+ pure module function avgpool3d_layer_cons(pool_size, stride) result(res)
+ !! `avgpool3d` constructor function.
+ integer, intent(in) :: pool_size(3)
+ !! Depth, height, and width of the pooling window.
+ integer, intent(in) :: stride(3)
+ !! Stride of the pooling window (depth, height, width).
+ type(avgpool3d_layer) :: res
+ end function avgpool3d_layer_cons
+ end interface avgpool3d_layer
+
+ interface
+ module subroutine init(self, input_shape)
+ !! Initialize the `avgpool3d` layer instance with an input shape.
+ class(avgpool3d_layer), intent(in out) :: self
+ !! `avgpool3d_layer` instance.
+ integer, intent(in) :: input_shape(:)
+ !! Array shape of the input layer, expected as (channels, depth, height, width).
+ end subroutine init
+
+ pure module subroutine forward(self, input)
+ !! Run a forward pass of the `avgpool3d` layer.
+ class(avgpool3d_layer), intent(in out) :: self
+ !! `avgpool3d_layer` instance.
+ real, intent(in) :: input(:,:,:,:)
+ !! Input data (output of the previous layer), with shape (channels, depth, height, width).
+ end subroutine forward
+
+ pure module subroutine backward(self, input, gradient)
+ !! Run a backward pass of the `avgpool3d` layer.
+ class(avgpool3d_layer), intent(in out) :: self
+ !! `avgpool3d_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_depth, pooled_height, pooled_width).
+ end subroutine backward
+ end interface
+
+end module nf_avgpool3d_layer
diff --git a/src/nf/nf_avgpool3d_layer_submodule.f90 b/src/nf/nf_avgpool3d_layer_submodule.f90
new file mode 100644
index 00000000..f2bd09dd
--- /dev/null
+++ b/src/nf/nf_avgpool3d_layer_submodule.f90
@@ -0,0 +1,102 @@
+submodule(nf_avgpool3d_layer) nf_avgpool3d_layer_submodule
+ implicit none
+
+contains
+
+ pure module function avgpool3d_layer_cons(pool_size, stride) result(res)
+ implicit none
+ integer, intent(in) :: pool_size(3)
+ integer, intent(in) :: stride(3)
+ type(avgpool3d_layer) :: res
+
+ res % pool_size = pool_size
+ res % stride = stride
+ end function avgpool3d_layer_cons
+
+
+ module subroutine init(self, input_shape)
+ implicit none
+ class(avgpool3d_layer), intent(in out) :: self
+ integer, intent(in) :: input_shape(:)
+ ! input_shape is expected to be (channels, depth, height, width)
+
+ self % channels = input_shape(1)
+ self % depth = input_shape(2) / self % stride(1)
+ self % height = input_shape(3) / self % stride(2)
+ self % width = input_shape(4) / self % stride(3)
+
+ ! Allocate the gradient array corresponding to the input dimensions.
+ allocate(self % gradient(input_shape(1), input_shape(2), input_shape(3), input_shape(4)))
+ self % gradient = 0
+
+ ! Allocate the output array (after pooling).
+ allocate(self % output(self % channels, self % depth, self % height, self % width))
+ self % output = 0
+ end subroutine init
+
+
+ pure module subroutine forward(self, input)
+ implicit none
+ class(avgpool3d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:,:)
+ integer :: input_depth, input_height, input_width
+ integer :: i, j, k, n
+ integer :: ii, jj, kk, iend, jend, kend
+ integer :: kdepth, jheight, kwidth
+
+ input_depth = size(input, dim=2)
+ input_height = size(input, dim=3)
+ input_width = size(input, dim=4)
+
+ ! Ensure we only process complete pooling regions.
+ kdepth = input_depth - mod(input_depth, self % stride(1))
+ jheight = input_height - mod(input_height, self % stride(2))
+ kwidth = input_width - mod(input_width, self % stride(3))
+
+ ! Loop over the input with a step size equal to the stride and over all channels.
+ do concurrent (i = 1:kdepth:self % stride(1), j = 1:jheight:self % stride(2), k = 1:kwidth:self % stride(3), n = 1:self % channels)
+ ii = (i - 1) / self % stride(1) + 1
+ jj = (j - 1) / self % stride(2) + 1
+ kk = (k - 1) / self % stride(3) + 1
+
+ iend = min(i + self % pool_size(1) - 1, input_depth)
+ jend = min(j + self % pool_size(2) - 1, input_height)
+ kend = min(k + self % pool_size(3) - 1, input_width)
+
+ ! Compute the average over the pooling region.
+ self % output(n, ii, jj, kk) = sum(input(n, i:iend, j:jend, k:kend)) / ((iend - i + 1) * (jend - j + 1) * (kend - k + 1))
+ end do
+ end subroutine forward
+
+
+ pure module subroutine backward(self, input, gradient)
+ implicit none
+ class(avgpool3d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:,:)
+ real, intent(in) :: gradient(:,:,:,:)
+ integer :: channels, pooled_depth, pooled_height, pooled_width
+ integer :: i, j, k, n, x, y, z, istart, iend, jstart, jend, kstart, kend
+ real :: scale_factor
+
+ channels = size(gradient, dim=1)
+ pooled_depth = size(gradient, dim=2)
+ pooled_height = size(gradient, dim=3)
+ pooled_width = size(gradient, dim=4)
+
+ ! The gradient for average pooling is distributed evenly over the pooling window.
+ do concurrent (n = 1:channels, i = 1:pooled_depth, j = 1:pooled_height, k = 1:pooled_width)
+ istart = (i - 1) * self % stride(1) + 1
+ iend = min(istart + self % pool_size(1) - 1, size(input, dim=2))
+ jstart = (j - 1) * self % stride(2) + 1
+ jend = min(jstart + self % pool_size(2) - 1, size(input, dim=3))
+ kstart = (k - 1) * self % stride(3) + 1
+ kend = min(kstart + self % pool_size(3) - 1, size(input, dim=4))
+ scale_factor = 1.0 / ((iend - istart + 1) * (jend - jstart + 1) * (kend - kstart + 1))
+
+ do concurrent (x = istart:iend, y = jstart:jend, z = kstart:kend)
+ self % gradient(n, x, y, z) = gradient(n, i, j, k) * scale_factor
+ end do
+ end do
+ end subroutine backward
+
+end submodule nf_avgpool3d_layer_submodule
diff --git a/src/nf/nf_layer_constructors.f90 b/src/nf/nf_layer_constructors.f90
index d3f06ca3..7c4c42b0 100644
--- a/src/nf/nf_layer_constructors.f90
+++ b/src/nf/nf_layer_constructors.f90
@@ -9,6 +9,9 @@ module nf_layer_constructors
private
public :: &
+ avgpool1d, &
+ avgpool2d, &
+ avgpool3d, &
conv1d, &
conv2d, &
dense, &
@@ -19,6 +22,7 @@ module nf_layer_constructors
locally_connected1d, &
maxpool1d, &
maxpool2d, &
+ maxpool3d, &
reshape, &
self_attention, &
embedding, &
@@ -179,6 +183,72 @@ module function flatten() result(res)
!! Resulting layer instance
end function flatten
+ module function avgpool1d(pool_size, stride) result(res)
+ !! 1-d avgpooling layer constructor.
+ !!
+ !! This layer is for downscaling other layers, typically `conv1d`.
+ !!
+ !! Example:
+ !!
+ !! ```
+ !! use nf, only :: avgpool1d, layer
+ !! type(layer) :: avgpool1d_layer
+ !! avgpool1d_layer = avgpool1d(pool_size=2)
+ !! avgpool1d_layer = avgpool1d(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 avgpool1d
+
+ module function avgpool2d(pool_size, stride) result(res)
+ !! 2-d avgpooling layer constructor.
+ !!
+ !! This layer is for downscaling other layers, typically `conv2d`.
+ !!
+ !! Example:
+ !!
+ !! ```
+ !! use nf, only :: avgpool2d, layer
+ !! type(layer) :: avgpool2d_layer
+ !! avgpool2d_layer = avgpool2d(pool_size=2)
+ !! avgpool2d_layer = avgpool2d(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 avgpool2d
+
+ module function avgpool3d(pool_size, stride) result(res)
+ !! 3-d avgpooling layer constructor.
+ !!
+ !! This layer is for downscaling other layers, typically `conv3d`.
+ !!
+ !! Example:
+ !!
+ !! ```
+ !! use nf, only :: avgpool3d, layer
+ !! type(layer) :: avgpool3d_layer
+ !! avgpool3d_layer = avgpool3d(pool_size=2)
+ !! avgpool3d_layer = avgpool3d(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 avgpool3d
+
module function conv1d(filters, kernel_size, activation) result(res)
!! 1-d convolutional layer constructor.
!!
@@ -304,6 +374,28 @@ module function maxpool2d(pool_size, stride) result(res)
!! Resulting layer instance
end function maxpool2d
+ module function maxpool3d(pool_size, stride) result(res)
+ !! 3-d maxpooling layer constructor.
+ !!
+ !! This layer is for downscaling other layers, typically `conv3d`.
+ !!
+ !! Example:
+ !!
+ !! ```
+ !! use nf, only :: maxpool3d, layer
+ !! type(layer) :: maxpool3d_layer
+ !! maxpool3d_layer = maxpool3d(pool_size=2)
+ !! maxpool3d_layer = maxpool3d(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 maxpool3d
+
module function linear2d(out_features) result(res)
!! Rank-2 (sequence_length, out_features) linear layer constructor.
!! sequence_length is determined at layer initialization, based on the
diff --git a/src/nf/nf_layer_constructors_submodule.f90 b/src/nf/nf_layer_constructors_submodule.f90
index 1665d38a..d6e05cc2 100644
--- a/src/nf/nf_layer_constructors_submodule.f90
+++ b/src/nf/nf_layer_constructors_submodule.f90
@@ -1,6 +1,9 @@
submodule(nf_layer_constructors) nf_layer_constructors_submodule
use nf_layer, only: layer
+ use nf_avgpool1d_layer, only: avgpool1d_layer
+ use nf_avgpool2d_layer, only: avgpool2d_layer
+ use nf_avgpool3d_layer, only: avgpool3d_layer
use nf_conv1d_layer, only: conv1d_layer
use nf_conv2d_layer, only: conv2d_layer
use nf_dense_layer, only: dense_layer
@@ -12,6 +15,7 @@
use nf_locally_connected1d_layer, only: locally_connected1d_layer
use nf_maxpool1d_layer, only: maxpool1d_layer
use nf_maxpool2d_layer, only: maxpool2d_layer
+ use nf_maxpool3d_layer, only: maxpool3d_layer
use nf_reshape2d_layer, only: reshape2d_layer
use nf_reshape3d_layer, only: reshape3d_layer
use nf_linear2d_layer, only: linear2d_layer
@@ -140,6 +144,92 @@ module function flatten() result(res)
end function flatten
+ module function avgpool1d(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 avgpool1d 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 avgpool1d layer'
+
+ res % name = 'avgpool1d'
+
+ allocate( &
+ res % p, &
+ source=avgpool1d_layer(pool_size, stride_) &
+ )
+
+ end function avgpool1d
+
+ module function avgpool2d(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 avgpool2d 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 avgpool2d layer'
+
+ res % name = 'avgpool2d'
+
+ allocate( &
+ res % p, &
+ source=avgpool2d_layer(pool_size, stride_) &
+ )
+
+ end function avgpool2d
+
+
+ module function avgpool3d(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 avgpool3d 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 avgpool3d layer'
+
+ res % name = 'avgpool3d'
+
+ allocate( &
+ res % p, &
+ source=avgpool3d_layer(pool_size, stride_) &
+ )
+
+ end function avgpool3d
+
+
module function input1d(layer_size) result(res)
integer, intent(in) :: layer_size
type(layer) :: res
@@ -229,6 +319,35 @@ module function maxpool2d(pool_size, stride) result(res)
end function maxpool2d
+ module function maxpool3d(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 maxpool3d 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 maxpool3d layer'
+
+ res % name = 'maxpool3d'
+
+ allocate( &
+ res % p, &
+ source=maxpool3d_layer(pool_size, stride_) &
+ )
+
+ end function maxpool3d
+
+
module function reshape2d(dim1, dim2) result(res)
integer, intent(in) :: dim1, dim2
type(layer) :: res
diff --git a/src/nf/nf_layer_submodule.f90 b/src/nf/nf_layer_submodule.f90
index eebedaa9..0d3bd573 100644
--- a/src/nf/nf_layer_submodule.f90
+++ b/src/nf/nf_layer_submodule.f90
@@ -1,6 +1,9 @@
submodule(nf_layer) nf_layer_submodule
use iso_fortran_env, only: stderr => error_unit
+ use nf_avgpool1d_layer, only: avgpool1d_layer
+ use nf_avgpool2d_layer, only: avgpool2d_layer
+ use nf_avgpool3d_layer, only: avgpool3d_layer
use nf_conv1d_layer, only: conv1d_layer
use nf_conv2d_layer, only: conv2d_layer
use nf_dense_layer, only: dense_layer
@@ -12,6 +15,7 @@
use nf_locally_connected1d_layer, only: locally_connected1d_layer
use nf_maxpool1d_layer, only: maxpool1d_layer
use nf_maxpool2d_layer, only: maxpool2d_layer
+ use nf_maxpool3d_layer, only: maxpool3d_layer
use nf_reshape2d_layer, only: reshape2d_layer
use nf_reshape3d_layer, only: reshape3d_layer
use nf_linear2d_layer, only: linear2d_layer
@@ -54,6 +58,14 @@ pure module subroutine backward_1d(self, previous, gradient)
! Upstream layers permitted: input2d, input3d, conv1d, conv2d, locally_connected1d, maxpool1d, maxpool2d
select type(prev_layer => previous % p)
+ type is(maxpool3d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool3d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(input2d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(locally_connected1d_layer)
@@ -141,6 +153,8 @@ pure module subroutine backward_2d(self, previous, gradient)
select type(prev_layer => previous % p)
type is(maxpool1d_layer)
call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(reshape2d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(input2d_layer)
@@ -156,6 +170,8 @@ pure module subroutine backward_2d(self, previous, gradient)
select type(prev_layer => previous % p)
type is(maxpool1d_layer)
call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(reshape2d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(input2d_layer)
@@ -171,6 +187,25 @@ pure module subroutine backward_2d(self, previous, gradient)
select type(prev_layer => previous % p)
type is(maxpool1d_layer)
call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(reshape2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(locally_connected1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(input2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(conv1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ end select
+
+ type is(avgpool1d_layer)
+
+ select type(prev_layer => previous % p)
+ type is(maxpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool1d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(reshape2d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(locally_connected1d_layer)
@@ -208,6 +243,8 @@ pure module subroutine backward_3d(self, previous, gradient)
select type(prev_layer => previous % p)
type is(maxpool2d_layer)
call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(input3d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(conv2d_layer)
@@ -224,6 +261,24 @@ pure module subroutine backward_3d(self, previous, gradient)
call this_layer % backward(prev_layer % output, gradient)
type is(maxpool2d_layer)
call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(input3d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(reshape3d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ end select
+
+ type is(avgpool2d_layer)
+
+ ! Upstream layers permitted: conv2d, input3d, maxpool2d, reshape3d
+ select type(prev_layer => previous % p)
+ type is(conv2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(maxpool2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
+ type is(avgpool2d_layer)
+ call this_layer % backward(prev_layer % output, gradient)
type is(input3d_layer)
call this_layer % backward(prev_layer % output, gradient)
type is(reshape3d_layer)
@@ -356,6 +411,36 @@ module subroutine forward(self, input)
call this_layer % forward(prev_layer % output)
end select
+ type is(avgpool1d_layer)
+
+ ! Upstream layers permitted: input1d, locally_connected1d, maxpool1d, reshape2d
+ select type(prev_layer => input % p)
+ type is(input2d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(locally_connected1d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(maxpool1d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(reshape2d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(conv1d_layer)
+ call this_layer % forward(prev_layer % output)
+ end select
+
+ type is(avgpool2d_layer)
+
+ ! Upstream layers permitted: input3d, conv2d, maxpool2d, reshape3d
+ select type(prev_layer => input % p)
+ type is(input3d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(conv2d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(maxpool2d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(reshape3d_layer)
+ call this_layer % forward(prev_layer % output)
+ end select
+
type is(flatten_layer)
! Upstream layers permitted: input2d, input3d, conv2d, maxpool1d, maxpool2d, reshape2d, reshape3d, locally_connected2d
@@ -374,6 +459,14 @@ module subroutine forward(self, input)
call this_layer % forward(prev_layer % output)
type is(maxpool2d_layer)
call this_layer % forward(prev_layer % output)
+ type is(maxpool3d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(avgpool1d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(avgpool2d_layer)
+ call this_layer % forward(prev_layer % output)
+ type is(avgpool3d_layer)
+ call this_layer % forward(prev_layer % output)
type is(reshape2d_layer)
call this_layer % forward(prev_layer % output)
type is(reshape3d_layer)
@@ -481,6 +574,8 @@ pure module subroutine get_output_2d(self, output)
allocate(output, source=this_layer % output)
type is(maxpool1d_layer)
allocate(output, source=this_layer % output)
+ type is(avgpool1d_layer)
+ allocate(output, source=this_layer % output)
type is(locally_connected1d_layer)
allocate(output, source=this_layer % output)
type is(conv1d_layer)
@@ -518,6 +613,8 @@ pure module subroutine get_output_3d(self, output)
allocate(output, source=this_layer % output)
type is(maxpool2d_layer)
allocate(output, source=this_layer % output)
+ type is(avgpool2d_layer)
+ allocate(output, source=this_layer % output)
type is(reshape3d_layer)
allocate(output, source=this_layer % output)
class default
@@ -563,6 +660,14 @@ impure elemental module subroutine init(self, input)
self % layer_shape = shape(this_layer % output)
type is(maxpool2d_layer)
self % layer_shape = shape(this_layer % output)
+ type is(maxpool3d_layer)
+ self % layer_shape = shape(this_layer % output)
+ type is(avgpool1d_layer)
+ self % layer_shape = shape(this_layer % output)
+ type is(avgpool2d_layer)
+ self % layer_shape = shape(this_layer % output)
+ type is(avgpool3d_layer)
+ self % layer_shape = shape(this_layer % output)
end select
self % input_layer_shape = input % layer_shape
@@ -617,6 +722,14 @@ elemental module function get_num_params(self) result(num_params)
num_params = 0
type is (maxpool2d_layer)
num_params = 0
+ type is (maxpool3d_layer)
+ num_params = 0
+ type is (avgpool1d_layer)
+ num_params = 0
+ type is (avgpool2d_layer)
+ num_params = 0
+ type is (avgpool3d_layer)
+ num_params = 0
type is (flatten_layer)
num_params = 0
type is (reshape2d_layer)
@@ -662,6 +775,14 @@ module function get_params(self) result(params)
! No parameters to get.
type is (maxpool2d_layer)
! No parameters to get.
+ type is (maxpool3d_layer)
+ ! No parameters to get.
+ type is (avgpool1d_layer)
+ ! No parameters to get.
+ type is (avgpool2d_layer)
+ ! No parameters to get.
+ type is (avgpool3d_layer)
+ ! No parameters to get.
type is (flatten_layer)
! No parameters to get.
type is (reshape2d_layer)
@@ -707,6 +828,14 @@ module function get_gradients(self) result(gradients)
! No gradients to get.
type is (maxpool2d_layer)
! No gradients to get.
+ type is (maxpool3d_layer)
+ ! No gradients to get.
+ type is (avgpool1d_layer)
+ ! No gradients to get.
+ type is (avgpool2d_layer)
+ ! No gradients to get.
+ type is (avgpool3d_layer)
+ ! No gradients to get.
type is (flatten_layer)
! No gradients to get.
type is (reshape2d_layer)
@@ -783,6 +912,26 @@ module subroutine set_params(self, params)
! No parameters to set.
write(stderr, '(a)') 'Warning: calling set_params() ' &
// 'on a zero-parameter layer; nothing to do.'
+
+ type is (maxpool3d_layer)
+ ! No parameters to set.
+ write(stderr, '(a)') 'Warning: calling set_params() ' &
+ // 'on a zero-parameter layer; nothing to do.'
+
+ type is (avgpool1d_layer)
+ ! No parameters to set.
+ write(stderr, '(a)') 'Warning: calling set_params() ' &
+ // 'on a zero-parameter layer; nothing to do.'
+
+ type is (avgpool2d_layer)
+ ! No parameters to set.
+ write(stderr, '(a)') 'Warning: calling set_params() ' &
+ // 'on a zero-parameter layer; nothing to do.'
+
+ type is (avgpool3d_layer)
+ ! No parameters to set.
+ write(stderr, '(a)') 'Warning: calling set_params() ' &
+ // 'on a zero-parameter layer; nothing to do.'
type is (linear2d_layer)
call this_layer % set_params(params)
diff --git a/src/nf/nf_maxpool3d_layer.f90 b/src/nf/nf_maxpool3d_layer.f90
new file mode 100644
index 00000000..b4815efe
--- /dev/null
+++ b/src/nf/nf_maxpool3d_layer.f90
@@ -0,0 +1,79 @@
+module nf_maxpool3d_layer
+
+ !! This module provides the 3D maxpooling layer.
+
+ use nf_base_layer, only: base_layer
+ implicit none
+
+ private
+ public :: maxpool3d_layer
+
+ type, extends(base_layer) :: maxpool3d_layer
+
+ integer :: channels
+ integer :: depth
+ integer :: width
+ integer :: height
+ integer :: pool_size
+ integer :: stride
+
+ ! Locations (as input matrix indices) of the maximum values
+ ! in the depth (z), width (x), and height (y) dimensions
+ integer, allocatable :: maxloc_x(:,:,:,:)
+ integer, allocatable :: maxloc_y(:,:,:,:)
+ integer, allocatable :: maxloc_z(:,:,:,:)
+
+ real, allocatable :: gradient(:,:,:,:)
+ real, allocatable :: output(:,:,:,:)
+
+ contains
+
+ procedure :: init
+ procedure :: forward
+ procedure :: backward
+
+ end type maxpool3d_layer
+
+ interface maxpool3d_layer
+ pure module function maxpool3d_layer_cons(pool_size, stride) result(res)
+ !! `maxpool3d` constructor function
+ integer, intent(in) :: pool_size
+ !! Depth, width, and height of the pooling window
+ integer, intent(in) :: stride
+ !! Stride of the pooling window
+ type(maxpool3d_layer) :: res
+ end function maxpool3d_layer_cons
+ end interface maxpool3d_layer
+
+ interface
+
+ module subroutine init(self, input_shape)
+ !! Initialize the `maxpool3d` layer instance with an input shape.
+ class(maxpool3d_layer), intent(in out) :: self
+ !! `maxpool3d_layer` instance
+ integer, intent(in) :: input_shape(:)
+ !! Array shape of the input layer
+ end subroutine init
+
+ pure module subroutine forward(self, input)
+ !! Run a forward pass of the `maxpool3d` layer.
+ class(maxpool3d_layer), intent(in out) :: self
+ !! `maxpool3d_layer` instance
+ real, intent(in) :: input(:,:,:,:)
+ !! Input data (output of the previous layer)
+ end subroutine forward
+
+ pure module subroutine backward(self, input, gradient)
+ !! Run a backward pass of the `maxpool3d` layer.
+ class(maxpool3d_layer), intent(in out) :: self
+ !! `maxpool3d_layer` instance
+ real, intent(in) :: input(:,:,:,:)
+ !! Input data (output of the previous layer)
+ real, intent(in) :: gradient(:,:,:,:)
+ !! Gradient from the downstream layer
+ end subroutine backward
+
+ end interface
+
+ end module nf_maxpool3d_layer
+
\ No newline at end of file
diff --git a/src/nf/nf_maxpool3d_layer_submodule.f90 b/src/nf/nf_maxpool3d_layer_submodule.f90
new file mode 100644
index 00000000..e5cf2bad
--- /dev/null
+++ b/src/nf/nf_maxpool3d_layer_submodule.f90
@@ -0,0 +1,114 @@
+submodule(nf_maxpool3d_layer) nf_maxpool3d_layer_submodule
+
+ implicit none
+
+contains
+
+ pure module function maxpool3d_layer_cons(pool_size, stride) result(res)
+ implicit none
+ integer, intent(in) :: pool_size
+ integer, intent(in) :: stride
+ type(maxpool3d_layer) :: res
+ res % pool_size = pool_size
+ res % stride = stride
+ end function maxpool3d_layer_cons
+
+
+ module subroutine init(self, input_shape)
+ implicit none
+ class(maxpool3d_layer), intent(in out) :: self
+ integer, intent(in) :: input_shape(:)
+
+ self % channels = input_shape(1)
+ self % depth = input_shape(2) / self % stride
+ self % width = input_shape(3) / self % stride
+ self % height = input_shape(4) / self % stride
+
+ allocate(self % maxloc_x(self % channels, self % depth, self % width, self % height))
+ allocate(self % maxloc_y(self % channels, self % depth, self % width, self % height))
+ allocate(self % maxloc_z(self % channels, self % depth, self % width, self % height))
+ self % maxloc_x = 0
+ self % maxloc_y = 0
+ self % maxloc_z = 0
+
+ allocate(self % gradient(input_shape(1), input_shape(2), input_shape(3), input_shape(4)))
+ self % gradient = 0
+
+ allocate(self % output(self % channels, self % depth, self % width, self % height))
+ self % output = 0
+
+ end subroutine init
+
+
+ pure module subroutine forward(self, input)
+ implicit none
+ class(maxpool3d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:,:)
+ integer :: input_depth, input_width, input_height
+ integer :: i, j, k, n
+ integer :: ii, jj, kk
+ integer :: iend, jend, kend
+ integer :: iextent, jextent, kextent
+ integer :: maxloc_xyz(3)
+
+ input_depth = size(input, dim=2)
+ input_width = size(input, dim=3)
+ input_height = size(input, dim=4)
+
+ kextent = input_depth - mod(input_depth, self % stride)
+ iextent = input_width - mod(input_width, self % stride)
+ jextent = input_height - mod(input_height, self % stride)
+
+ do concurrent( &
+ k = 1:kextent:self % stride, &
+ i = 1:iextent:self % stride, &
+ j = 1:jextent:self % stride &
+ )
+
+ kk = k / self % stride + 1
+ ii = i / self % stride + 1
+ jj = j / self % stride + 1
+
+ kend = k + self % pool_size - 1
+ iend = i + self % pool_size - 1
+ jend = j + self % pool_size - 1
+
+ do concurrent(n = 1:self % channels)
+ maxloc_xyz = maxloc(input(n, k:kend, i:iend, j:jend))
+ self % maxloc_x(n,kk,ii,jj) = maxloc_xyz(1) + k - 1
+ self % maxloc_y(n,kk,ii,jj) = maxloc_xyz(2) + i - 1
+ self % maxloc_z(n,kk,ii,jj) = maxloc_xyz(3) + j - 1
+
+ self % output(n,kk,ii,jj) = &
+ input(n,self % maxloc_x(n,kk,ii,jj),self % maxloc_y(n,kk,ii,jj),self % maxloc_z(n,kk,ii,jj))
+ end do
+
+ end do
+
+ end subroutine forward
+
+
+ pure module subroutine backward(self, input, gradient)
+ implicit none
+ class(maxpool3d_layer), intent(in out) :: self
+ real, intent(in) :: input(:,:,:,:)
+ real, intent(in) :: gradient(:,:,:,:)
+ integer :: gradient_shape(4)
+ integer :: channels, depth, width, height
+ integer :: i, j, k, n
+
+ gradient_shape = shape(gradient)
+ channels = gradient_shape(1)
+ depth = gradient_shape(2)
+ width = gradient_shape(3)
+ height = gradient_shape(4)
+
+ do concurrent(n = 1:channels, k = 1:depth, i = 1:width, j = 1:height)
+ associate(ii => self % maxloc_x(n,k,i,j), jj => self % maxloc_y(n,k,i,j), kk => self % maxloc_z(n,k,i,j))
+ self % gradient(n,ii,jj,kk) = gradient(n,k,i,j)
+ end associate
+ end do
+
+ end subroutine backward
+
+end submodule nf_maxpool3d_layer_submodule
\ No newline at end of file