linear2d_layer: forgot a file

Author: OneAdder

src/nf/nf_linear2d_layer_submodule.f90

@@ -3,23 +3,22 @@
   implicit none
 contains
   module function linear2d_layer_cons(&
-      sequence_length, in_features, out_features, batch_size&
+      sequence_length, in_features, out_features&
   ) result(res)
-    integer, intent(in) :: batch_size, sequence_length, in_features, out_features
+    integer, intent(in) :: sequence_length, in_features, out_features
     type(linear2d_layer) :: res
 
     res % in_features = in_features
     res % out_features = out_features
     res % sequence_length = sequence_length
-    res % batch_size = batch_size
   end function linear2d_layer_cons
 
   module subroutine init(self, input_shape)
     class(linear2d_layer), intent(in out) :: self
     integer, intent(in) :: input_shape(:)
 
-    allocate(self % output(self % sequence_length, self % out_features, self % batch_size))
-    allocate(self % gradient(self % sequence_length, self % in_features, self % batch_size))
+    allocate(self % output(self % sequence_length, self % out_features))
+    allocate(self % gradient(self % sequence_length, self % in_features))
 
     allocate(self % weights(self % in_features, self % out_features))
     self % weights = 0.1
@@ -35,30 +34,26 @@ end subroutine init
 
   pure module subroutine forward(self, input)
     class(linear2d_layer), intent(in out) :: self
-    real, intent(in) :: input(:, :, :)
-    integer :: i, j
+    real, intent(in) :: input(:, :)
+    integer :: i
 
-    do concurrent(i = 1: self % batch_size)
-      self % output(:, :, i) = matmul(input(:, :, i), self % weights)
-    end do
-    do concurrent(i = 1: self % batch_size, j = 1: self % sequence_length)
-      self % output(j, :, i) = self % output(j, :, i) + self % biases
+    self % output(:, :) = matmul(input(:, :), self % weights)
+    do concurrent(i = 1: self % sequence_length)
+      self % output(i, :) = self % output(i, :) + self % biases
     end do
   end subroutine forward
 
   pure module subroutine backward(self, input, gradient)
     class(linear2d_layer), intent(in out) :: self
-    real, intent(in) :: input(:, :, :)
-    real, intent(in) :: gradient(:, :, :)
+    real, intent(in) :: input(:, :)
+    real, intent(in) :: gradient(:, :)
     real :: db(self % out_features)
     real :: dw(self % in_features, self % out_features)
     integer :: i
 
-    do concurrent(i = 1: self % batch_size)
-      self % dw = self % dw + matmul(transpose(input(:, :, i)), gradient(:, :, i))
-      self % db = self % db + sum(gradient(:, :, i), 1)
-      self % gradient(:, :, i) = matmul(gradient(:, :, i), transpose(self % weights))
-    end do
+    self % dw = self % dw + matmul(transpose(input(:, :)), gradient(:, :))
+    self % db = self % db + sum(gradient(:, :), 1)
+    self % gradient(:, :) = matmul(gradient(:, :), transpose(self % weights))
   end subroutine backward
 
   pure module function get_num_params(self) result(num_params)