Coupling Framework Links Artificial Intelligence Models Seamlessly to Earth System Simulations

Computational scientists have established a coupler-based framework that integrates machine learning algorithms directly into traditional Earth System Models while maintaining the computational throughput required for long-term climate projections. Described in a technical paper by Alexis Barge, Julien Le Sommer, Andrea Storto, and Sophie Valcke, the software architecture combines the established OASIS3-MCT coupling library with a dedicated Python library designated as Eophis. Earth System Models, which track the continuous evolution of geophysical fluid dynamics across global oceans and atmospheres, traditionally rely on dense Fortran codebases tuned specifically for massively parallel central processing units. Conversely, modern scientific machine learning libraries rely on dynamic, Python-based frameworks tailored for graphics processing units. The integration of data-driven parameterizations into legacy climate simulators has historically required labor-intensive Fortran reimplementations, brittle foreign function bindings, or deeply customized wrappers. By taking advantage of existing model-coupling infrastructure, the team demonstrated that external machine learning components can exchange physical fields with numerical climate simulations dynamically across independent computing processes without imposing prohibitive execution delays.

The central hurdle in bridging data-driven inference with physical climate simulators stems from a fundamental structural asymmetry between how conventional models and neural networks operate. In standard geophysical setups, couplers such as OASIS3-MCT coordinate multi-component Earth System Models by managing time-synchronized exchanges, spatial interpolations, and domain decompositions across distinct physical domains, such as the atmosphere and the ocean. Conventional coupled components possess internal time-stepping routines, generate their own spatial grids, and independently orchestrate distributed parallel communications via Message Passing Interface layers. Machine learning components, in contrast, function as passive computational routines that merely ingest physical fields provided by a host simulator and return inferred tendencies or diagnostic fields. Because machine learning tools do not independently advance time or generate native discretization meshes, forcing them into traditional coupler interfaces has routinely introduced excessive configuration complexity. Climate modelers have previously had to hand-craft synchronization loops, manually manage distributed memory buffers, and build custom data pipelines for every newly tested parameterization.

To overcome these integration barriers, the researchers developed Eophis, an open-source Python library structured around three primary abstractions called the Tunnel, the Router, and the Time-stepping mechanism. The Tunnel abstracts the low-level Message Passing Interface operations and memory partitioning required by the OASIS3-MCT Python application programming interface, automatically configuring grid distributions from global two-dimensional longitude and latitude dimensions. At the beginning and conclusion of each coupling interval, the Tunnel receives incoming fields from the geophysical model and dispatches calculated outputs back into the simulation stream. Internally, the Router defines the computational wiring between the incoming variables and the parameter requirements of imported Python functions, mapping the model fields directly into the neural network architecture. Meanwhile, the runtime Time-stepping mechanism mirrors the temporal advancement of the host simulator, executing a synchronized background loop that coordinates data exchanges at user-specified frequencies. Together, these modular components allow researchers to treat complex neural networks as portable standalone functions that can be swapped without reconfiguring the underlying Fortran solver.

A critical technical capability engineered into Eophis is automated halo reconstruction, which supports spatial operations and modern neural architectures such as Convolutional Neural Networks across distributed domains. In high-performance ocean and atmosphere simulations, physical domains are partitioned across dozens or hundreds of computing ranks, requiring local grid blocks to share peripheral edge values known as halos with adjacent ranks to evaluate spatial gradients. While conventional Earth System Models maintain private internal communication layers to reconstruct halos between real computational cells, passive Python inference scripts lack such internal machinery. To address this limitation without adding complex communication code to user scripts, Eophis programs the OASIS3-MCT partition topology during initialization to communicate overlapping boundary cells multiple times. During runtime execution, Eophis reconstructs the incoming distributed fields into complete, grid-aware arrays augmented with the required halo bands and specified boundary conditions. Once convolutional feature processing finishes, the Tunnel automatically strips away the auxiliary halo strips before returning updated physical fields back to the primary Fortran model ranks.

The research team evaluated the runtime scalability and resource allocation of the framework using the Nucleus for European Modelling of the Ocean framework, specifically testing NEMO version 4.2.1 within a quarter-degree global ocean configuration containing 75 vertical depth levels. Benchmarking experiments were executed on an HPE SGI 8600 supercomputer hosted at the IDRIS JeanZay facility in France, utilizing compute nodes featuring 40 Intel Xeon Gold central processing unit cores and four NVIDIA Tesla V100 graphics processing units linked via high-speed interconnects. The primary investigation examined two contrasting hybrid cases to assess operational trade-offs across distinct computational workloads. The first benchmark evaluated a two-dimensional subgrid parameterization of mixed-layer eddy vertical buoyancy fluxes driven by a Convolutional Neural Network. In this implementation, the ocean model computed three-dimensional transport fields internally while passing only the required two-dimensional surface layer variables to the Python model. The second benchmark evaluated a three-dimensional deterministic density correction based on the TEOS-10 Gibbs SeaWater oceanographic toolbox, requiring the transfer of all 75 vertical levels of temperature, salinity, and density fields across every coupling interval.

Initial benchmarks examined a synchronous execution scheme, designated with an -S suffix, wherein the NEMO solver pauses after dispatching variables until the external Python script completes execution and transmits the updated fields back through the coupler. The primary ocean model ran on a dedicated allocation of 999 Message Passing Interface processes, while the resources assigned to the Python scripts were increased in power-of-two increments to measure performance recovery against an uncoupled baseline. For the two-dimensional neural network running exclusively on central processing unit cores, matching simulation speed required allocating additional Python processes equal to roughly 30 percent of the ocean solver allocation, or slightly more than 256 supplementary cores. Transitioning the neural network inference to graphics processing units significantly relieved this computational bottleneck, requiring only 64 central processing unit cores and two graphics processing units to approach baseline performance. Conversely, the three-dimensional density calculation imposed steep data-transfer and calculation overheads, requiring over 2048 additional processes to approach uncoupled speeds without ever fully overcoming synchronous waiting times.

To overcome the inherent delays of sequential execution, the team implemented an asynchronous coupling strategy, denoted with an -A suffix, that fundamentally reorganized the operational sequence within each simulated time step. Under this asynchronous regime, the NEMO solver dispatches input fields to Eophis at the earliest possible stage in its algorithmic loop, proceeding with independent intermediate physical calculations while the Python script executes concurrently across its dedicated hardware. Provided the ocean model does not encounter operations requiring the updated tendencies before the Python computation completes, the simulator experiences zero idle waiting time. Crucially, although calculations occur asynchronously across physical processors, mathematical synchrony is maintained within model time, ensuring that exchanged inputs and outputs correspond strictly to the exact same numerical time step. Mathematical runtime analyses revealed that as soon as the execution duration of the Python routine fell below the duration of the preceding independent Fortran routines, the ocean solver achieved its maximum uncoupled execution rate.

The throughput improvements achieved through asynchronous execution substantially lowered the computational resources required to maintain production simulation speeds. For the two-dimensional parameterization utilizing graphics processing unit acceleration, the supplementary resource requirement dropped to eight Message Passing Interface processes and a single graphics processing unit, representing less than one percent of the 999 processes dedicated to NEMO. Running the two-dimensional model on central processing units under asynchronous execution reduced required extra processes to 64 cores, representing a fivefold resource reduction compared to synchronous coupling. In the demanding three-dimensional test case, asynchronous scheduling reduced the required allocation from over 2048 processes down to 256 processes, representing roughly 25 percent of the host ocean model allocation. Across all test cases, the additional processing resources required to sustain target speeds decreased by factors between eight and 18. Furthermore, comparative error assessments between the synchronous and asynchronous implementations showed a normalized root-mean-square error of just 0.4 percent for time-averaged density fields, confirming high operational consistency.

The study also benchmarked OASIS3-MCT and Eophis against established hybrid modeling strategies, focusing on a one-degree global ocean configuration, ORCA1, utilizing NEMO version 4.0.7. The team reproduced an air-sea heat flux parameterization originally developed as a native Fortran neural network, comparing it against the Infero Fortran library executing a TensorFlow runtime and an Eophis deployment. At low process allocations, the throughput of the Eophis implementation matched that of Infero, while scaling the Python process count allowed the coupled system to fully recover the performance of an uncoupled ocean simulation. Discrepancies in the root-mean-square error of surface heat flux corrections were observed primarily along coastlines, which detailed tracking linked to structural differences between NEMO binaries compiled with and without OASIS3-MCT rather than defects in the neural network bridge. Recompiling the baseline Fortran code with OASIS3-MCT libraries reduced the differences to the same magnitude observed between the standalone Fortran and Infero implementations, highlighting the role of compilation environments in reproducible modeling.

While the coupler framework offers notable modularity and flexibility, the authors highlighted explicit operational boundaries, noting that the architecture is optimized specifically for online inference rather than online model training. The high-volume data streams needed to continuously backpropagate gradients across coupled simulations would stress the messaging architecture of OASIS3-MCT, making specialized streaming frameworks or in-situ analytics engines more appropriate for dynamic retraining tasks. Additionally, for long-term operational climate forecasting systems running fixed parameterizations for years, embedding models directly into Fortran via optimized libraries may prove easier to maintain by removing external coupling layers. Nevertheless, for scientific exploration and rapid prototyping, coupler-driven architectures eliminate the need to manually rewrite Python machine learning components into low-level languages. To promote reproducible scientific practices across the geoscientific community, the investigators packaged the complete experimental configurations, build options, neural network weights, and containerized runtime environments within an open-access GitHub organization named Morays-Community, establishing standardized templates for hybrid climate modeling workflows.

Subject of Research: Coupler-based deployment of machine learning components in Earth System Models using OASIS3-MCT and Eophis

Article Title: Deploying machine learning components coupled to Earth System Models with OASIS3-MCT (v6) and Eophis (v1.1)

Article References: Barge, A., Le Sommer, J., Storto, A., & Valcke, S. (2026). Deploying machine learning components coupled to Earth System Models with OASIS3-MCT (v6) and Eophis (v1.1). Geoscientific Model Development, 19(21), 10345-10363. https://doi.org/10.5194/gmd-19-10345-2026

Image Credits: AI Generated

DOI: 10.5194/gmd-19-10345-2026

Keywords: Earth System Modeling, Machine Learning, Scientific Computing, OASIS3-MCT, Eophis, NEMO Ocean Model, Coupled Models, High Performance Computing, Deploying, machine, learning, components