Merge pull request #79 from milancurcic/hdf5-reader

Support for loading Keras models

Author: milancurcic

.gitignore

@@ -2,5 +2,6 @@
 *.o
 *.mod
 *.dat
+*.h5
 build
 doc

CMakeLists.txt

@@ -1,66 +1,24 @@
-# cmake version, project name, language
-cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
-project(neural-fortran Fortran)
+# CMake version, project name, language
+cmake_minimum_required(VERSION 3.20)
 
-# set output paths for modules, archives, and executables
-set(CMAKE_Fortran_MODULE_DIRECTORY ${PROJECT_BINARY_DIR}/include)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-
-# if build type not specified, default to release
+# If build type not specified, default to release
 if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "release")
-endif()
-
-if(SERIAL)
-  message(STATUS "Configuring build for serial execution")
-else()
-  message(STATUS "Configuring build for parallel execution")
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Default build Release")
 endif()
 
-# compiler flags for gfortran
-if(CMAKE_Fortran_COMPILER_ID MATCHES GNU)
-
-  if(SERIAL)
-    message(STATUS "Configuring to build with -fcoarray=single")
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fcoarray=single")
-  endif()
-
-  if(BLAS)
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fexternal-blas ${BLAS}")
-    set(LIBS "${LIBS} blas")
-    message(STATUS "Configuring build to use BLAS from ${BLAS}")
-  endif()
-    
-  set(CMAKE_Fortran_FLAGS_DEBUG "-O0 -g -fcheck=bounds -fbacktrace")
-  set(CMAKE_Fortran_FLAGS_RELEASE "-Ofast -fno-frontend-optimize")
-endif()
-
-# compiler flags for ifort
-if(CMAKE_Fortran_COMPILER_ID MATCHES Intel)
-
-  if(SERIAL)
-    message(STATUS "Configuring to build with -coarray=single")
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -coarray=single")
-  endif()
+project(neural-fortran
+LANGUAGES C Fortran
+)
 
-  set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -assume byterecl")
-  set(CMAKE_Fortran_FLAGS_DEBUG "-O0 -g -C -traceback")
-  set(CMAKE_Fortran_FLAGS_RELEASE "-O3")
+enable_testing()
 
-  if(NOT SERIAL)
-    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -coarray=shared")
-  endif()
+include(FetchContent)
 
-endif()
+include(cmake/options.cmake)
+include(cmake/compilers.cmake)
 
-# compiler flags for Cray ftn
-if(CMAKE_Fortran_COMPILER_ID MATCHES Cray)
-  set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -h noomp")
-  set(CMAKE_Fortran_FLAGS_DEBUG "-O0 -g")
-  set(CMAKE_Fortran_FLAGS_RELEASE "-O3")
-endif()
+include(cmake/h5fortran.cmake)
+include(cmake/json.cmake)
 
 # library to archive (libneural.a)
 add_library(neural
@@ -70,6 +28,8 @@ add_library(neural
   src/nf/nf_base_layer_submodule.f90
   src/nf/nf_conv2d_layer.f90
   src/nf/nf_conv2d_layer_submodule.f90
+  src/nf/nf_datasets.f90
+  src/nf/nf_datasets_submodule.f90
   src/nf/nf_datasets_mnist.f90
   src/nf/nf_datasets_mnist_submodule.f90
   src/nf/nf_dense_layer.f90
@@ -80,8 +40,8 @@ add_library(neural
   src/nf/nf_input1d_layer_submodule.f90
   src/nf/nf_input3d_layer.f90
   src/nf/nf_input3d_layer_submodule.f90
-  src/nf/nf_io.f90
-  src/nf/nf_io_submodule.f90
+  src/nf/nf_keras.f90
+  src/nf/nf_keras_submodule.f90
   src/nf/nf_layer_constructors.f90
   src/nf/nf_layer_constructors_submodule.f90
   src/nf/nf_layer.f90
@@ -97,20 +57,22 @@ add_library(neural
   src/nf/nf_parallel_submodule.f90
   src/nf/nf_random.f90
   src/nf/nf_random_submodule.f90
+  src/nf/io/nf_io_binary.f90
+  src/nf/io/nf_io_binary_submodule.f90
+  src/nf/io/nf_io_hdf5.f90
+  src/nf/io/nf_io_hdf5_submodule.f90
 )
+target_link_libraries(neural PRIVATE h5fortran::h5fortran HDF5::HDF5 jsonfortran::jsonfortran)
+
+install(TARGETS neural)
 
 # Remove leading or trailing whitespace
 string(REGEX REPLACE "^ | $" "" LIBS "${LIBS}")
 
-# tests
-enable_testing()
-foreach(execid input1d_layer input3d_layer dense_layer conv2d_layer maxpool2d_layer flatten_layer dense_network conv2d_network)
-  add_executable(test_${execid} test/test_${execid}.f90)
-  target_link_libraries(test_${execid} neural ${LIBS})
-  add_test(test_${execid} bin/test_${execid})
-endforeach()
-  
-foreach(execid cnn mnist simple sine)
-  add_executable(${execid} example/${execid}.f90)
-  target_link_libraries(${execid} neural ${LIBS})
-endforeach()
+if(${PROJECT_NAME}_BUILD_TESTING)
+  add_subdirectory(test)
+endif()
+
+if(${PROJECT_NAME}_BUILD_EXAMPLES)
+  add_subdirectory(example)
+endif()

README.md

@@ -41,10 +41,22 @@ git clone https://github.com/modern-fortran/neural-fortran
 cd neural-fortran
 ```
 
-Dependencies:
+### Dependencies
 
-* Fortran 2018-compatible compiler
-* OpenCoarrays (optional, for parallel execution, GFortran only)
+Required dependencies are:
+
+* A Fortran compiler
+* [HDF5](https://www.hdfgroup.org/downloads/hdf5/)
+  (must be provided by the OS package manager or your own build from source)
+* [h5fortran](https://github.com/geospace-code/h5fortran),
+  [json-fortran](https://github.com/jacobwilliams/json-fortran)
+  (both handled by neural-fortran's build systems, no need for a manual install)
+* [fpm](https://github.com/fortran-lang/fpm) or
+  [CMake](https://cmake.org) for building the code
+
+Optional dependencies are:
+
+* OpenCoarrays (for parallel execution with GFortran)
 * BLAS, MKL (optional)
 
 Compilers tested include:
@@ -131,12 +143,21 @@ cafrun -n 4 bin/mnist # run MNIST example on 4 cores
 #### Building with a different compiler
 
 If you want to build with a different compiler, such as Intel Fortran,
-specify `FC` when issuing `cmake`:
+set the `HDF5_ROOT` environment variable to the root path of your
+Intel HDF5 build, and specify `FC` when issuing `cmake`:
 
 ```
 FC=ifort cmake ..
 ```
 
+for a parallel build of neural-fortran, or
+
+```
+FC=ifort cmake .. -DSERIAL=1
+```
+
+for a serial build.
+
 #### Building with BLAS or MKL
 
 To use an external BLAS or MKL library for `matmul` calls,
@@ -180,6 +201,8 @@ examples, in increasing level of complexity:
   dataset
 4. [cnn](example/cnn.f90): Creating and running forward a simple CNN using
   `input`, `conv2d`, `maxpool2d`, `flatten`, and `dense` layers.
+5. [mnist_from_keras](example/mnist_from_keras.f90): Creating a pre-trained
+  model from a Keras HDF5 file.
 
 The examples also show you the extent of the public API that's meant to be
 used in applications, i.e. anything from the `nf` module.

cmake/compilers.cmake

@@ -0,0 +1,55 @@
+# compiler flags for gfortran
+if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+
+  if(SERIAL)
+    message(STATUS "Configuring to build with -fcoarray=single")
+    add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-fcoarray=single>")
+  else()
+    add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-fcoarray=lib>")
+  endif()
+
+  if(BLAS)
+    add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-fexternal-blas;${BLAS}>")
+    list(APPEND LIBS "blas")
+    message(STATUS "Configuring build to use BLAS from ${BLAS}")
+  endif()
+
+  add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Debug>>:-fcheck=bounds;-fbacktrace>")
+  add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Release>>:-Ofast;-fno-frontend-optimize;-fno-backtrace>")
+
+elseif(CMAKE_Fortran_COMPILER_ID MATCHES "^Intel")
+  # compiler flags for ifort
+
+  if(SERIAL)
+    message(STATUS "Configuring to build with -coarray=single")
+    if(WIN32)
+      add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:/Qcoarray:single>")
+      add_link_options("$<$<COMPILE_LANGUAGE:Fortran>:/Qcoarray:single>")
+    else()
+      add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-coarray=single>")
+      add_link_options("$<$<COMPILE_LANGUAGE:Fortran>:-coarray=single>")
+    endif()
+  else()
+    if(WIN32)
+      add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:/Qcoarray:shared>")
+      add_link_options("$<$<COMPILE_LANGUAGE:Fortran>:/Qcoarray:shared>")
+    else()
+      add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-coarray=shared>")
+      add_link_options("$<$<COMPILE_LANGUAGE:Fortran>:-coarray=shared>")
+    endif()
+  endif()
+
+  if(WIN32)
+    string(APPEND CMAKE_Fortran_FLAGS " /assume:byterecl")
+  else()
+    string(APPEND CMAKE_Fortran_FLAGS " -assume byterecl")
+  endif()
+  add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Debug>>:-check;-traceback>")
+  # add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Release>>:-O3>")
+
+elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "Cray")
+  # compiler flags for Cray ftn
+  string(APPEND CMAKE_Fortran_FLAGS " -h noomp")
+  add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Debug>>:-O0;-g>")
+  add_compile_options("$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Release>>:-O3>")
+endif()

cmake/h5fortran.cmake

@@ -0,0 +1,15 @@
+set(h5fortran_BUILD_TESTING false)
+
+FetchContent_Declare(h5fortran
+  GIT_REPOSITORY https://github.com/geospace-code/h5fortran
+  GIT_TAG v4.6.3
+  GIT_SHALLOW true
+)
+
+FetchContent_MakeAvailable(h5fortran)
+
+file(MAKE_DIRECTORY ${h5fortran_BINARY_DIR}/include)
+
+
+list(APPEND CMAKE_MODULE_PATH ${h5fortran_SOURCE_DIR}/cmake/Modules)
+find_package(HDF5 COMPONENTS Fortran REQUIRED)

cmake/json.cmake

@@ -0,0 +1,35 @@
+# use our own CMake script to build jsonfortran instead of jsonfortran/CMakelists.txt
+
+FetchContent_Declare(jsonfortran
+  GIT_REPOSITORY https://github.com/jacobwilliams/json-fortran
+  GIT_TAG 8.3.0
+  GIT_SHALLOW true
+)
+
+FetchContent_Populate(jsonfortran)
+
+SET(JSON_REAL_KIND "REAL64")
+SET(JSON_INT_KIND "INT32")
+
+set(_src ${jsonfortran_SOURCE_DIR}/src)
+
+set (JF_LIB_SRCS
+${_src}/json_kinds.F90
+${_src}/json_parameters.F90
+${_src}/json_string_utilities.F90
+${_src}/json_value_module.F90
+${_src}/json_file_module.F90
+${_src}/json_module.F90
+)
+
+add_library(jsonfortran ${JF_LIB_SRCS})
+target_compile_definitions(jsonfortran PRIVATE ${JSON_REAL_KIND} ${JSON_INT_KIND})
+target_include_directories(jsonfortran PUBLIC
+$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
+$<INSTALL_INTERFACE:include>
+)
+
+add_library(jsonfortran::jsonfortran INTERFACE IMPORTED GLOBAL)
+target_link_libraries(jsonfortran::jsonfortran INTERFACE jsonfortran)
+
+install(TARGETS jsonfortran)

cmake/options.cmake

@@ -0,0 +1,30 @@
+option(SERIAL "Serial execution")
+option(${PROJECT_NAME}_BUILD_TESTING "build ${PROJECT_NAME} tests" true)
+option(${PROJECT_NAME}_BUILD_EXAMPLES "build ${PROJECT_NAME} examples" true)
+
+# Set output paths for modules, archives, and executables
+set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/include)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+if(SERIAL)
+  message(STATUS "Configuring build for serial execution")
+else()
+  message(STATUS "Configuring build for parallel execution")
+endif()
+
+# --- Generally useful CMake project options
+
+# Rpath options necessary for shared library install to work correctly in user projects
+set(CMAKE_INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/lib)
+set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/lib)
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH true)
+
+# Necessary for shared library with Visual Studio / Windows oneAPI
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS true)
+
+# --- auto-ignore build directory
+if(NOT EXISTS ${PROJECT_BINARY_DIR}/.gitignore)
+  file(WRITE ${PROJECT_BINARY_DIR}/.gitignore "*")
+endif()

example/CMakeLists.txt

@@ -0,0 +1,4 @@
+foreach(execid cnn mnist mnist_from_keras simple sine)
+  add_executable(${execid} ${execid}.f90)
+  target_link_libraries(${execid} PRIVATE neural h5fortran::h5fortran jsonfortran::jsonfortran ${LIBS})
+endforeach()

example/mnist_from_keras.f90

@@ -0,0 +1,51 @@
+program mnist_from_keras
+
+  ! This example demonstrates loading a pre-trained MNIST model from Keras
+  ! from an HDF5 file and running an inferrence on the testing dataset.
+
+  use nf, only: network, label_digits, load_mnist
+  use nf_datasets, only: download_and_unpack, keras_model_dense_mnist_url
+
+  implicit none
+
+  type(network) :: net
+  real, allocatable :: training_images(:,:), training_labels(:)
+  real, allocatable :: validation_images(:,:), validation_labels(:)
+  real, allocatable :: testing_images(:,:), testing_labels(:)
+  character(*), parameter :: test_data_path = 'keras_dense_mnist.h5'
+  logical :: file_exists
+
+  inquire(file=test_data_path, exist=file_exists)
+  if (.not. file_exists) call download_and_unpack(keras_model_dense_mnist_url)
+
+  call load_mnist(training_images, training_labels, &
+                  validation_images, validation_labels, &
+                  testing_images, testing_labels)
+
+  print '("Loading a pre-trained MNIST model from Keras")'
+  print '(60("="))'
+
+  net = network(test_data_path)
+
+  call net % print_info()
+
+  if (this_image() == 1) &
+    print '(a,f5.2,a)', 'Accuracy: ', accuracy( &
+      net, testing_images, label_digits(testing_labels)) * 100, ' %'
+
+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 mnist_from_keras