Parsing Input and Dense layers and their sizes from Keras h5 works

Author: milancurcic

src/nf/nf_keras.f90

@@ -6,7 +6,7 @@ module nf_keras
   implicit none
 
   private
-  public :: get_keras_h5_layers
+  public :: get_keras_h5_layers, keras_layer
 
   type :: keras_layer
     !! Intermediate container to convey the Keras layer information

src/nf/nf_keras_submodule.f90

@@ -0,0 +1,69 @@
+submodule(nf_keras) nf_keras_submodule
+
+  use json_module, only: json_core, json_value
+  use nf_io_hdf5, only: get_h5_attribute_string
+
+  implicit none
+
+contains
+
+  module function get_keras_h5_layers(filename) result(res)
+    character(*), intent(in) :: filename
+    type(keras_layer), allocatable :: res(:)
+
+    character(:), allocatable :: model_config_string
+
+    type(json_core) :: json
+    type(json_value), pointer :: &
+      model_config_json, layers_json, layer_json, layer_config_json
+
+    real, allocatable :: tmp_array(:)
+    integer :: n, num_layers, num_elements
+    logical :: found
+
+    model_config_string = get_h5_attribute_string(filename, '.', 'model_config')
+
+    call json % parse(model_config_json, model_config_string)
+    call json % get(model_config_json, 'config.layers', layers_json)
+
+    num_layers = json % count(layers_json)
+
+    allocate(res(num_layers))
+
+    ! Iterate over layers
+    layers: do n = 1, num_layers
+
+      ! Get pointer to the layer
+      call json % get_child(layers_json, n, layer_json)
+
+      ! Get type of layer as a string
+      call json % get(layer_json, 'class_name', res(n) % type)
+
+      ! Get pointer to the layer config
+      call json % get(layer_json, 'config', layer_config_json)
+
+      ! Get size of layer and activation if applicable;
+      ! Instantiate neural-fortran layers at this time.
+      if (res(n) % type == 'InputLayer') then
+        
+        call json % get(layer_config_json, 'batch_input_shape', tmp_array)
+        res(n) % num_elements = [tmp_array(2)]
+      
+      else if (res(n) % type == 'Dense') then
+        
+        call json % get(layer_config_json, 'units',  num_elements, found)
+        res(n) % num_elements = [num_elements]
+
+        call json % get(layer_config_json, 'activation', res(n) % activation)
+      
+      else
+        
+        error stop 'This layer is not supported'
+      
+      end if
+
+    end do layers
+
+  end function get_keras_h5_layers
+
+end submodule nf_keras_submodule

test/test_parse_keras_model.f90

@@ -2,76 +2,53 @@ program test_parse_keras_model
 
   use iso_fortran_env, only: stderr => error_unit
   use nf_datasets, only: download_and_unpack, keras_model_dense_mnist_url
-  use nf_io_hdf5, only: get_h5_attribute_string
+  use nf_keras, only: get_keras_h5_layers, keras_layer
   use nf, only: layer, network, dense, input
-  use json_module
 
   implicit none
 
   character(:), allocatable :: model_config_string
   character(*), parameter :: test_data_path = 'keras_dense_mnist.h5'
-  type(json_core) :: json
-  type(json_value), pointer :: &
-    model_config, layer_list, this_layer, layer_config
-  character(:), allocatable :: class_name, layer_type, activation
-  real, allocatable :: tmp_array(:)
+
+  type(keras_layer), allocatable :: keras_layers(:)
 
   type(layer), allocatable :: layers(:)
   type(network) :: net
 
-  logical :: found
-  integer :: n, num_layers, num_elements
+  integer :: n
   logical :: file_exists
   logical :: ok = .true.
 
   inquire(file=test_data_path, exist=file_exists)
   if (.not. file_exists) call download_and_unpack(keras_model_dense_mnist_url)
 
-  model_config_string = &
-    get_h5_attribute_string(test_data_path, '.', 'model_config')
-
-  call json % parse(model_config, model_config_string)
-  call json % get(model_config, 'config.layers', layer_list)
-
-  num_layers = json % count(layer_list)
-
-  layers = [layer ::]
-
-  ! Iterate over layers
-  do n = 1, num_layers
+  keras_layers = get_keras_h5_layers(test_data_path)
 
-    ! Get pointer to the layer
-    call json % get_child(layer_list, n, this_layer)
-
-    ! Get type of layer as a string
-    call json % get(this_layer, 'class_name', layer_type)
-
-    ! Get pointer to the layer config
-    call json % get(this_layer, 'config', layer_config)
+  if (size(keras_layers) /= 3) then
+    ok = .false.
+    write(stderr, '(a)') 'Keras dense MNIST model has 3 layers.. failed'
+  end if
 
-    ! Get size of layer and activation if applicable;
-    ! Instantiate neural-fortran layers at this time.
-    if (layer_type == 'InputLayer') then
-      call json % get(layer_config, 'batch_input_shape', tmp_array, found)
-      num_elements = tmp_array(2)
-      layers = [layers, input(num_elements)]
-    else if (layer_type == 'Dense') then
-      call json % get(layer_config, 'units', num_elements, found)
-      call json % get(layer_config, 'activation', activation, found)
-      layers = [layers, dense(num_elements, activation)]
-    else
-      error stop 'This layer is not supported'
-    end if
+  if (keras_layers(1) % type /= 'InputLayer') then
+    ok = .false.
+    write(stderr, '(a)') 'Keras first layer should be InputLayer.. failed'
+  end if
 
-    print *, n, layer_type, num_elements, activation
-  end do
+  if (.not. all(keras_layers(1) % num_elements == [784])) then
+    ok = .false.
+    write(stderr, '(a)') 'Keras first layer should have 784 elements.. failed'
+  end if
 
-  net = network(layers)
-  call net % print_info()
+  if (allocated(keras_layers(1) % activation)) then
+    ok = .false.
+    write(stderr, '(a)') &
+      'Keras first layer activation should not be allocated.. failed'
+  end if
 
-  if (.not. num_layers == 3) then
+  if (.not. keras_layers(2) % type == 'Dense') then
     ok = .false.
-    write(stderr, '(a)') 'Keras dense MNIST model has 3 layers.. failed'
+    write(stderr, '(a)') &
+      'Keras second and third layers should be dense.. failed'
   end if
 
   if (ok) then