Read kernel and bias data for Conv2D layer from Keras; tranpose values in the HDF5 reader

Author: milancurcic

src/nf/io/nf_io_hdf5.f90

@@ -45,6 +45,16 @@ module subroutine get_hdf5_dataset_real32_2d(filename, object_name, values)
         !! Array to store the dataset values into
     end subroutine get_hdf5_dataset_real32_2d
 
+    module subroutine get_hdf5_dataset_real32_4d(filename, object_name, values)
+      !! Read a 4-d real32 array from an HDF5 dataset.
+      character(*), intent(in) :: filename
+        !! HDF5 file name
+      character(*), intent(in) :: object_name
+        !! Object (dataset) name
+      real(real32), allocatable, intent(in out) :: values(:,:,:,:)
+        !! Array to store the dataset values into
+    end subroutine get_hdf5_dataset_real32_4d
+
   end interface get_hdf5_dataset
 
 end module nf_io_hdf5

src/nf/io/nf_io_hdf5_submodule.f90

@@ -99,6 +99,53 @@ module subroutine get_hdf5_dataset_real32_2d(filename, object_name, values)
     call f % read(object_name, values)
     call f % close()
 
+    ! Transpose the array to get from C to Fortran order
+    values = transpose(values)
+
   end subroutine get_hdf5_dataset_real32_2d
 
+
+  module subroutine get_hdf5_dataset_real32_4d(filename, object_name, values)
+
+    character(*), intent(in) :: filename
+    character(*), intent(in) :: object_name
+    real(real32), allocatable, intent(in out) :: values(:,:,:,:)
+
+    type(hdf5_file) :: f
+    integer(int64), allocatable :: dims(:)
+
+    call f % open(filename, 'r')
+    call f % shape(object_name, dims)
+
+    ! If values is already allocated, re-allocate only if incorrect shape
+    if (allocated(values)) then
+      if (.not. all(shape(values) == dims)) then
+        deallocate(values)
+        allocate(values(dims(1), dims(2), dims(3), dims(4)))
+      end if
+    else
+      allocate(values(dims(1), dims(2), dims(3), dims(4)))
+    end if
+
+    call f % read(object_name, values)
+    call f % close()
+
+    ! Transpose the array to get from C to Fortran order
+    values = reverse_dim_order(values)
+
+  end subroutine get_hdf5_dataset_real32_4d
+
+
+  pure function reverse_dim_order(x) result(res)
+    real, intent(in) :: x(:,:,:,:)
+    real, allocatable :: res(:,:,:,:)
+    integer :: dims(4)
+    integer :: i, j, k, l
+    dims = shape(x)
+    allocate(res(dims(4), dims(3), dims(2), dims(1)))
+    do concurrent(i = 1:dims(1), j = 1:dims(2), k = 1:dims(3), l = 1:dims(4))
+      res(l,k,j,i) = x(i,j,k,l)
+    end do
+  end function reverse_dim_order
+
 end submodule nf_io_hdf5_submodule

src/nf/nf_network_submodule.f90

@@ -1,9 +1,11 @@
 submodule(nf_network) nf_network_submodule
 
+  use nf_conv2d_layer, only: conv2d_layer
   use nf_dense_layer, only: dense_layer
   use nf_flatten_layer, only: flatten_layer
   use nf_input1d_layer, only: input1d_layer
   use nf_input3d_layer, only: input3d_layer
+  use nf_maxpool2d_layer, only: maxpool2d_layer
   use nf_io_hdf5, only: get_hdf5_dataset
   use nf_keras, only: get_keras_h5_layers, keras_layer
   use nf_layer, only: layer
@@ -131,6 +133,17 @@ module function network_from_keras(filename) result(res)
 
       select type(this_layer => res % layers(n) % p)
 
+        type is(conv2d_layer)
+          ! Read biases from file
+          object_name = '/model_weights/' // layer_name // '/' &
+            // layer_name // '/bias:0'
+          call get_hdf5_dataset(filename, object_name, this_layer % biases)
+
+          ! Read weights from file
+          object_name = '/model_weights/' // layer_name // '/' &
+            // layer_name // '/kernel:0'
+          call get_hdf5_dataset(filename, object_name, this_layer % kernel)
+
         type is(dense_layer)
 
           ! Read biases from file
@@ -143,12 +156,13 @@ module function network_from_keras(filename) result(res)
             // layer_name // '/kernel:0'
           call get_hdf5_dataset(filename, object_name, this_layer % weights)
 
-          ! TODO Multidimensional arrays are stored in HDF5 in C-order.
-          ! TODO Here we transpose the array to get to the Fortran order.
-          ! TODO There may be a way to do this without re-allocating.
-          ! TODO It probably doesn't matter much since we do this once.
-          ! TODO Figure it out later.
-          this_layer % weights = transpose(this_layer % weights)
+        type is(flatten_layer)
+          ! Nothing to do
+          continue
+
+        type is(maxpool2d_layer)
+          ! Nothing to do
+           continue
 
         class default
           error stop 'Internal error in network_from_keras(); ' &

test/test_cnn_from_keras.f90

@@ -16,4 +16,51 @@ program test_cnn_from_keras
 
   net = network(test_data_path)
 
+  block
+
+    use nf, only: load_mnist, label_digits
+
+    real, allocatable :: training_images(:,:), training_labels(:)
+    real, allocatable :: validation_images(:,:), validation_labels(:)
+    real, allocatable :: testing_images(:,:), testing_labels(:)
+    real :: acc
+
+    call load_mnist(training_images, training_labels, &
+                    validation_images, validation_labels, &
+                    testing_images, testing_labels)
+
+    acc = accuracy(net, reshape(testing_images, shape=[1,28,28,10000]), label_digits(testing_labels))
+    print *, acc
+
+    if (acc < 0.94) then
+      write(stderr, '(a)') &
+        'Pre-trained network accuracy should be > 0.94.. failed'
+      ok = .false.
+    end if
+
+  end block
+
+  if (ok) then
+    print '(a)', 'test_cnn_from_keras: All tests passed.'
+  else
+    write(stderr, '(a)') &
+      'test_cnn_from_keras: One or more tests failed.'
+    stop 1
+  end if
+
+contains
+
+  real function accuracy(net, x, y)
+    type(network), intent(in out) :: net
+    real, intent(in) :: x(:,:,:,:), y(:,:)
+    integer :: i, good
+    good = 0
+    do i = 1, size(x, dim=2)
+      if (all(maxloc(net % output(x(:,:,:,i))) == maxloc(y(:,i)))) then
+        good = good + 1
+      end if
+    end do
+    accuracy = real(good) / size(x, dim=2)
+  end function accuracy
+
 end program test_cnn_from_keras