Facilitating machine learning in Fortran with FTorch

Jack Atkinson

Senior Research Software Engineer
ICCS - University of Cambridge

Joe Wallwork

Senior Research Software Engineer
ICCS - University of Cambridge

2025-12-18

Precursors

Slides and Materials

To access links or follow on your own device these slides can be found at:
joewallwork.com/pwp/slides/ftorch/2025-12-18_DLR-Seminar

Licensing

Except where otherwise noted, these presentation materials are licensed under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) License.

Vectors and icons by SVG Repo under CC0(1.0) or FontAwesome under SIL OFL 1.1

Motivation

Weather and Climate Models

Large, complex, many-part systems.

Hybrid Modelling

Neural Net by 3Blue1Brown under fair dealing.
Pikachu © The Pokemon Company, used under fair dealing.

2 approaches: * emulation, or * data-driven.

Additional challenges: * Physical compatibility * Physics-based models have conservation laws
Required for accuracy and stability * Language interoperation

Challenges

• Reproducibility
  • Ensure net functions the same in-situ
• Re-usability
  • Make ML parameterisations available to many models
  • Facilitate easy re-training/adaptation
• Language Interoperation

Language interoperation

Many large scientific models are written in Fortran (or C, or C++).
Much machine learning is conducted in Python.

Mathematical Bridge by cmglee used under CC BY-SA 3.0
PyTorch, the PyTorch logo and any related marks are trademarks of The Linux Foundation.”
TensorFlow, the TensorFlow logo and any related marks are trademarks of Google Inc.

Emulation and data-driven is a focus of several of our projects. CALIPSO, M2LInES, DataWave, etc.
Models typically in Fortran
ML typically in Python

Some possible solutions

• Implement a NN in Fortran (e.g., fiats, neural-fortran)
  • Advantages: avoids language inter-operation problem
  • Disadvantages: reproducibility issues, hard for complex architectures

• Implement NN inference in Fortran (e.g., ENNUF)
  • Advantages: lower maintenace overhead
  • Disadvantages: inference only

• Interface with Python ML via Forpy
  • Advantages: easy integration
  • Disadvantages: harder to use with ML and HPC, GPL, barely-maintained

• Interface with Python ML via SmartSim
  • Advantages: generic, two-way coupling, versatile, HPC-friendly
  • Disadvantages: steep (human) learning curve, data copying

• Fortran-Keras Bridge
  • Advantages: two-way coupling
  • Disadvantages: Keras only, abandonware

Efficiency

We consider 2 types:

Computational

Developer

In research both have an effect on ‘time-to-science’.
Especially when extensive research software support is unavailable.

1. No re-writing net after you have already done and trained
2. For scientists doing science, not compsci
3. Run on HPC environments so minimal additional
4. Easily keep up to date
5. Simple to learn and deploy
6. Needs to be as efficient as possible

FTorch

Approach

• PyTorch has a C++ backend and provides an API.
  
• Binding Fortran to C is straightforward¹ from 2003 using iso_c_binding.

We will:

• Save the PyTorch models in a portable Torchscript format
  • to be run by libtorch C++
• Provide a Fortran API
  • wrapping the libtorch C++ API
  • abstracting complex details from users

TorchScript is a statically typed subset of Python

1. A dangerous word, rather, ‘well supported’?

Approach

Python
env

Python
runtime

xkcd #1987 by Randall Munroe, used under CC BY-NC 2.5

Highlights - Developer

• Easy to clone and install
  • CMake, supported on linux/unix and Windows™

• Easy to link

  • Build using CMake,

  • or link via Make like NetCDF (instructions included)
    

    FCFLAGS += -I<path/to/install>/include/ftorch
    LDFLAGS += -L<path/to/install>/lib64 -lftorch

Find it on :

/Cambridge-ICCS/FTorch

Highlights - Developer

• User tools
  • pt2ts.py aids users in saving PyTorch models to Torchscript

• Examples suite
  • Take users through full process from trained net to Fortran inference

• Full API documentation online at
  cambridge-iccs.github.io/FTorch

• FOSS
  • licensed under MIT
  • contributions from users via GitHub welcome

Find it on :

/Cambridge-ICCS/FTorch

Highlights - Computation

• Use framework’s implementations directly
  • feature and future support, and reproducible

• Make use of the Torch backends for GPU offload
  • CUDA, HIP, MPS, and XPU enabled

• Indexing issues and associated reshape¹ avoided with Torch strided accessor.
• No-copy access in memory (on CPU).

Find it on :

/Cambridge-ICCS/FTorch

1. Or, the great row-major, column-major headache.

Highlights - Computation

• Indexing issues and associated reshape¹ avoided with Torch strided accessor.
• No-copy access in memory (on CPU).

Find it on :

/Cambridge-ICCS/FTorch

1. Or, the great row-major, column-major headache.

Some code

Model - Saving from Python

import torch
import torchvision

# Load pre-trained model and put in eval mode
model = torchvision.models.resnet18(weights="IMAGENET1K_V1")
model.eval()

# Create dummmy input
dummy_input = torch.ones(1, 3, 224, 224)

# Save to TorchScript
if trace:
    ts_model = torch.jit.trace(model, dummy_input)
elif script:
    ts_model = torch.jit.script(model)
frozen_model = torch.jit.freeze(ts_model)
frozen_model.save("/path/to/saved_model.pt")

TorchScript

• Statically typed subset of Python
• Read by the Torch C++ interface (or any Torch API)
• Produces intermediate representation/graph of NN, including weights and biases
• trace for simple models, script more generally

Fortran

 use ftorch
 
 implicit none
 
 real, dimension(5), target :: in_data, out_data  ! Fortran data structures
 
 type(torch_tensor), dimension(1) :: input_tensors, output_tensors  ! Set up Torch data structures
 type(torch_model) :: torch_net
 integer, dimension(1) :: tensor_layout = [1]
 
 in_data = ...  ! Prepare data in Fortran
 
 ! Create Torch input/output tensors from the Fortran arrays
 call torch_tensor_from_array(input_tensors(1), in_data, torch_kCPU)
 call torch_tensor_from_array(output_tensors(1), out_data, torch_kCPU)
 
 call torch_model_load(torch_net, 'path/to/saved/model.pt', torch_kCPU)  ! Load ML model
 call torch_model_forward(torch_net, input_tensors, output_tensors)      ! Infer
 
 call further_code(out_data)  ! Use output data in Fortran immediately
 
 ! Cleanup
call torch_delete(model)
call torch_delete(in_tensors)
call torch_delete(out_tensor)

GPU Acceleration

Cast Tensors to GPU in Fortran:

! Load in from Torchscript
call torch_model_load(torch_net, 'path/to/saved/model.pt', torch_kCUDA, device_index=0)

! Cast Fortran data to Tensors
call torch_tensor_from_array(in_tensor(1), in_data, torch_kCUDA, device_index=0)
call torch_tensor_from_array(out_tensor(1), out_data, torch_kCPU)

FTorch supports NVIDIA CUDA, AMD HIP, Intel XPU, and AppleSilicon MPS hardwares.

Use of multiple devices supported.

Effective HPC simulation requires MPI_Gather() for efficient data transfer.

Through developing a nice library it behaves as you would expect it to!
Familiar to pytorch users.
Pointer slinging is largely hidden from users.
Data transposition is taken care of by us (but options available for users to handle).

Publication & tutorials

FTorch is published in JOSS!

Atkinson et al. (2025)
FTorch: a library for coupling PyTorch models to Fortran.
Journal of Open Source Software, 10(107), 7602,
doi.org/10.21105/joss.07602

Please cite if you use FTorch!

In addition to the comprehensive examples in the FTorch repository we provide an online workshop at /Cambridge-ICCS/FTorch-workshop

Applications and Case Studies

MiMA - proof of concept

• The origins of FTorch
  • Emulation of existing parameterisation
  • Coupled to an atmospheric model using forpy in Espinosa et al. (2022)¹
  • Prohibitively slow and hard to implement
  • Asked for a faster, user-friendly implementation that can be used in future studies.

• Follow up paper using FTorch: Uncertainty Quantification of a Machine Learning Subgrid-Scale Parameterization for Atmospheric Gravity Waves (Mansfield and Sheshadri 2024)
  • “Identical” offline networks have very different behaviours when deployed online.

Model of an idealised Moist Atmosphere online at /DataWaveProject/MiMA-machine-learning

1. Originally written in TensorFlow…

ICON

• Icosahedral Nonhydrostatic Weather and Climate Model
  • Developed by DKRZ (Deutsches Klimarechenzentrum)
  • Used by the DWD and Meteo-Swiss

• Interpretable multiscale Machine Learning-Based Parameterizations of Convection for ICON (Heuer et al. 2023)¹
  • Train U-Net convection scheme on high-res simulation
  • Deploy in ICON via FTorch coupling
  • Evaluate physical realism (causality) using SHAP values
  • Online stability improved when non-causal relations are eliminated from the net

Running on JUWELS at the Jülich Supercomputing Centre; ICON Model is now available at gitlab.dkrz.de/icon/icon-model

1. Work without direct involvement of ICCS - success on ‘ease of use’ of FTorch

ICON

Slide from the Cambridge Hybrid Modelling Workshop courtesy of Julien Savre

CESM coupling

• The Community Earth System Model
• Part of CMIP (Coupled Model Intercomparison Project)
• Make it easy for users
  • FTorch integrated into the build system (CIME)
    • /Cambridge-ICCS/cime_je
  • libtorch is included on the software stack on Derecho
    • Improves reproducibility

Derecho by NCAR

Work done with Will Chapman and Jim Edwards of NCAR.
CIME with FTorch is available with instructions /Cambridge-ICCS/cime_je

Others

• To replace a BiCGStab bottleneck in the GloSea6 Seasonal Forecasting model
  (Park and Chung 2025).
• Bias correction of CESM through learning model biases compared to ERA5
  (Chapman and Berner 2025)
• Implementation of nonlinear interactions in the WaveWatch III model
  (Ikuyajolu et al. 2025).
• Stable embedding of a convection resolving parameterisation in E3SM
  (Hu et al. 2025).

• ClimSim Convection scheme in ICON for stable 20-year AMIP run
  (Heuer et al. 2025) (preprint)
• Review paper of hybrid modelling approaches
  (Zheng et al. 2025) (preprint)
• Implementation of a new convection trigger in the CAM model.
  Miller et al. In Preparation.
• Embedding of ML schemes for gravity waves in the CAM model.
  ICCS & DataWave.

FTorch: Future work

• 6-month resource allocation January-June 2026.
  • (Finally) merge online training.
  • Properly expose batching of tensors.
  • General maintenance.
  • Benchmarking experiments.
  • Comparison study against similar tools (e.g., TorchFort, SmartSim, fiats).
  • Applications.

Join the FTorch mailing list for updates!

FTorch: Summary

• Use of ML within traditional numerical models
  • A growing area that presents challenges
• Language interoperation
  • FTorch provides a solution for scientists implementing torch models in Fortran
  • Designed for computational and developer efficiency
  • Has helped deliver science in climate research and beyond
    see Heuer et al. (2023), Mansfield and Sheshadri (2024) and more.
  • Built into CESM to allow the userbase access
• Lots of improvements to come in 2026!

Thanks for Listening

Get in touch:

 Jack Atkinson

 jackatkinson.net

 jwa34[AT]cam.ac.uk

 jatkinson1000

 @jatkinson1000@hachyderm.io

 Joe Wallwork

 joewallwork.com

 jw2423[AT]cam.ac.uk

 joewallwork

Thanks to Tom Metlzer, Elliott Kasoar, Niccolò Zanotti
and the rest of the FTorch team.

The ICCS received support from

FTorch has been supported by

/Cambridge-ICCS/FTorch

References

Atkinson, Jack, Athena Elafrou, Elliott Kasoar, Joseph G. Wallwork, Thomas Meltzer, Simon Clifford, Dominic Orchard, and Chris Edsall. 2025. “FTorch: A Library for Coupling PyTorch Models to Fortran.” Journal of Open Source Software 10 (107): 7602. https://doi.org/10.21105/joss.07602.

Chapman, William E, and Judith Berner. 2025. “Improving Climate Bias and Variability via CNN-Based State-Dependent Model-Error Corrections.” Geophysical Research Letters 52 (6): e2024GL114106. https://doi.org/10.1029/2024GL114106.

Espinosa, Zachary I, Aditi Sheshadri, Gerald R Cain, Edwin P Gerber, and Kevin J DallaSanta. 2022. “Machine Learning Gravity Wave Parameterization Generalizes to Capture the QBO and Response to Increased CO2.” Geophysical Research Letters 49 (8): e2022GL098174.

Heuer, Helge, Tom Beucler, Mierk Schwabe, Julien Savre, Manuel Schlund, and Veronika Eyring. 2025. “Beyond the Training Data: Confidence-Guided Mixing of Parameterizations in a Hybrid AI-Climate Model.” arXiv Preprint arXiv:2510.08107. https://doi.org/10.48550/arXiv.2510.08107.

Heuer, Helge, Mierk Schwabe, Pierre Gentine, Marco A Giorgetta, and Veronika Eyring. 2023. “Interpretable Multiscale Machine Learning-Based Parameterizations of Convection for ICON.” arXiv Preprint arXiv:2311.03251.

Hu, Zeyuan, Akshay Subramaniam, Zhiming Kuang, Jerry Lin, Sungduk Yu, Walter M Hannah, Noah D Brenowitz, Josh Romero, and Michael S Pritchard. 2025. “Stable Machine-Learning Parameterization of Subgrid Processes in a Comprehensive Atmospheric Model Learned from Embedded Convection-Permitting Simulations.” Journal of Advances in Modeling Earth Systems 17 (7): e2024MS004618.

Ikuyajolu, Olawale James, Luke P Van Roekel, Steven R Brus, and Erin E Thomas. 2025. “NLML: A Deep Neural Network Emulator for the Exact Nonlinear Interactions in a Wind Wave Model.” Authorea Preprints. https://doi.org/10.22541/essoar.174366388.80605654/v1.

Mansfield, Laura A, and Aditi Sheshadri. 2024. “Uncertainty Quantification of a Machine Learning Subgrid-Scale Parameterization for Atmospheric Gravity Waves.” Authorea Preprints.

Park, Hyesung, and Sungwook Chung. 2025. “Utilization of a Lightweight 3D u-Net Model for Reducing Execution Time of Numerical Weather Prediction Models.” Atmosphere 16 (1): 60.

Zheng, Tian, Subashree Venkatasubramanian, Shuolin Li, Amy Braverman, Xinyi Ke, Zhewen Hou, Peter Jin, and Samarth Sanjay Agrawal. 2025. “Machine Learning Workflows in Climate Modeling: Design Patterns and Insights from Case Studies.” arXiv Preprint arXiv:2510.03305. https://doi.org/10.48550/arXiv.2510.03305.