An Ocean Model Ported by a Large Language Model: Experience and Lessons from FESOM2 (Fortran to C to C++/Kokkos)

Questo articolo dimostra che un modello linguistico di grandi dimensioni agente, guidato da esperti di dominio attraverso un rigoroso processo di traduzione in due fasi e una validazione severa, ha portato con successo il modello oceanico Fortran FESOM2 di 74.000 righe in C++/Kokkos, preservandone la fisica e ottenendo significativi guadagni di prestazioni sulle GPU.

L'essenziale

Immagina di avere una ricetta massiccia, incredibilmente complessa e di grande successo per un piatto da 5 stelle. Questa ricetta è stata scritta in un linguaggio molto antico e specializzato (chiamiamolo "Fortran") che solo pochi maestri chef comprendono. È stata testata per decenni e tutti sanno che funziona perfettamente. Tuttavia, la cucina sta cambiando: i nuovi forni (supercomputer moderni con potenti GPU) non parlano più "Fortran". Parlano "C++".

Il problema? Tradurre questa ricetta di 74.000 righe dall'antico linguaggio al nuovo linguaggio ad alta velocità è come cercare di tradurre un romanzo mentre si ricostruisce contemporaneamente la casa in cui è scritto. Se commetti anche un solo piccolo errore nel calcolo, il piatto potrebbe trasformarsi in veleno o la cucina potrebbe prendere fuoco. Di solito, questo richiede a un team di esperti umani anni di lavoro.

Questo articolo descrive un nuovo esperimento: Un'IA (un Large Language Model) può svolgere questo lavoro di traduzione per noi, e può farlo senza rovinare la ricetta?

Ecco come l'hanno fatto, usando analogie semplici:

1. La strategia di traduzione in due fasi

Invece di chiedere all'IA di passare direttamente dall' "Antico Linguaggio" al "Nuovo Linguaggio ad Alta Velocità", il team l'ha costretta a fare una deviazione.

• Fase 1: La "Copia Pulita" (Fortran → C): Per prima cosa, hanno chiesto all'IA di tradurre la ricetta in un linguaggio intermedio più semplice chiamato "C".

  • La Regola: All'IA era severamente vietato "migliorare" la ricetta. Non poteva scambiare gli ingredienti per renderli "migliori" o cambiare i tempi di cottura per renderli più efficienti. Doveva essere una copia letterale, parola per parola.
  • L'Obiettivo: Assicurarsi che il sapore (la fisica) rimanesse esattamente lo stesso. Hanno eseguito questa nuova versione in "C" per cinque anni di tempo simulato. Aveva un sapore identico alla versione originale in "Fortran", con differenze così piccole da essere paragonabili a un granello di sale in un oceano.

• Fase 2: L'aggiornamento di velocità (C → C++/Kokkos): Una volta che la versione "C" è stata dimostrata perfetta, hanno chiesto all'IA di tradurre quella in il moderno linguaggio "C++", che è costruito per girare su forni super veloci (GPU).

  • La Rete di Sicurezza: Poiché la versione "C" era già perfetta, l'IA poteva ora concentrarsi sulla velocità. Hanno controllato ogni singolo passaggio del processo di cottura per garantire che la nuova versione in "C++" producesse esattamente gli stessi numeri della versione "C" su computer standard.

2. Il sistema di controllo "Gemello"

Come hanno fatto a sapere che l'IA non avesse infilato un errore? Hanno usato un sistema di "Gemelli".

Immaginate di avere un maestro chef (il codice originale) e uno studente chef (il nuovo codice). Ogni volta che lo studente chef taglia una cipolla, deve mostrare al maestro chef il risultato immediatamente.

• Il Test del "Gemello": Per ogni singolo passaggio della cottura, il computer esegue il nuovo codice e il vecchio codice fianco a fianco. Se i numeri differiscono anche solo di una frazione infinitesima, il sistema urla "Stop!" e dice all'IA: "Hai sbagliato questo specifico passaggio".
• La trappola dell' "Halo Stantio": Un errore comune che l'IA ha commesso è stato dimenticare di aggiornare i bordi dei dati (come dimenticare di lavare il tagliere tra un taglio e l'altro). Il team ha costruito una "sonda" speciale che controlla specificamente i bordi per catturare questi errori invisibili.

3. I Risultati: Velocità e Accuratezza

L'esperimento è stato un successo. Ecco cosa è successo:

• Accuratezza: Il nuovo codice è scientificamente affidabile. Durante cinque anni di simulazione, le temperature oceaniche e la salinità della nuova versione erano quasi indistinguibili da quelle dell'originale. Sui nuovi supercomputer GPU, i risultati erano "statisticamente vicini", il che significa che le minuscole differenze erano dovute solo al modo in cui il computer esegue i calcoli matematici, non perché la fisica fosse errata.
• Velocità: Il nuovo codice gira sulle moderne GPU (come la NVIDIA A100) ed è da 1,6 a 3,7 volte più veloce del vecchio codice eseguito su CPU standard.
• Portabilità: La parte migliore? Hanno scritto il codice una volta e questo gira su diversi tipi di supercomputer (NVIDIA, AMD e altri) senza bisogno di essere riscritto. È come un adattatore universale che si adatta a qualsiasi presa.

4. Cosa è andato storto (e come lo hanno risolto)

L'IA non è perfetta. Ha cercato di "aiutare" semplificando le cose, il che ha quasi rotto la fisica.

• La trappola della "Semplificazione": L'IA voleva arrotondare i numeri o cambiare un valore costante perché sembrava "più pulito". Il team ha dovuto vietarlo severamente. Hanno detto all'IA: "Se l'originale dice 0,1, scrivi 0,1. Non tirare a indovinare".
• La trappola del "Commento": L'IA a volte leggeva un commento nel codice che diceva "Il valore è 5", ma il codice effettivo diceva "Il valore è 10". L'IA si fidava del commento. Il team ha risolto il problema costringendo l'IA a controllare la riga di codice effettiva ogni singola volta.

In sintesi

Questo articolo dimostra che, con le giuste regole e una rigorosa "scala di sicurezza" di controlli, un'IA può tradurre un modello scientifico massiccio e complesso da un vecchio linguaggio a uno nuovo e super veloce in poche settimane.

Non si è limitata a copiare il codice; ha preservato la scienza. Il modello oceanico si comporta ancora esattamente come l'oceano reale, ma ora gira abbastanza velocemente da aiutarci a prevedere il clima futuro sui computer più potenti del mondo. La chiave non è stata solo l'IA; è stata la disciplina degli umani che l'hanno guidata: regole rigide, traduzione letterale e controllo costante.

Sommario tecnico

Sintesi Tecnica: Un modello oceanico trasposto da un Large Language Model

Problema
Le proiezioni climatiche richiedono sempre più risoluzioni oceaniche su scala chilometrica, rendendo necessaria la migrazione di modelli consolidati di circolazione generale oceanica (GCM) in Fortran su larga scala verso l'hardware moderno, in particolare le GPU. Tuttavia, questi modelli, spesso sviluppati nel corso di decenni per cluster CPU a memoria distribuita, affrontano barriere significative alla trasposizione: una scarsità di competenze umane nella conoscenza del dominio, nella portabilità e nell'ottimizzazione delle prestazioni, oltre alla difficoltà di mantenere la fedeltà scientifica durante la traduzione. Sebbene i Large Language Models (LLM) abbiano dimostrato successo nella traduzione di segmenti di codice più piccoli o singole funzioni, non era ancora stabilito se un LLM potesse trasporre un intero modello geofisico di produzione in un linguaggio e un framework differenti (specificamente per l'accelerazione tramite GPU) senza degradare la sua fisica o la sua accuratezza numerica.

Metodologia
Gli autori hanno trasposto FESOM2, un modello oceano-ghiaccio marino a volume finito con mesh non strutturata (circa 74.000 righe di codice Fortran core), utilizzando un assistente alla programmazione basato su un LLM agente (Claude Code con il modello Opus 4.7) sotto la direzione di esperti del dominio. Il processo di trasposizione è stato strutturato attorno a tre pratiche critiche per garantirne l'affidabilità:

1. Traduzione in due fasi: La trasposizione è stata suddivisa in due fasi distinte per separare la correttezza numerica dal parallelismo.

   • Fase 1 (da Fortran a C): Il modello è stato tradotto in un riferimento C pulito e single-threaded. Questa fase ha collassato il codice Fortran altamente configurabile nella specifica configurazione utilizzata per l'esecuzione, risolvendo le ambiguità relative alle opzioni di compilazione attive e ai valori predefiniti a runtime. La traduzione è stata strettamente letterale, proibendo all'LLM di "migliorare" o semplificare il codice.
   • Fase 2 (da C a C++/Kokkos): Il riferimento C è stato poi avvolto in C++ utilizzando lo strato di portabilità delle prestazioni Kokkos per mirare sia alle CPU che alle GPU. Questa fase si è concentrata sulla parallelizzazione preservando l'aritmetica del riferimento C.

2. Traduzione letterale rigorosa: L'LLM ha ricevuto l'istruzione di eseguire una traduzione riga per riga, convertendo l'indicizzazione da 1-based a 0-based, adattando l'archiviazione da column-major a row-major e convertendo le variabili globali USE in passaggio di struct. Non sono state ammesse modifiche semantiche. Ciò ha garantito che qualsiasi divergenza dal riferimento fosse un bug di trasposizione piuttosto che una modifica della fisica.

3. Scala di validazione a livelli: Una rigorosa struttura di validazione è stata applicata ad ogni fase:

   • Da Fortran a C: Validata tramite accordo statistico a lungo termine (integrazioni di 5 anni) piuttosto che tramite uguaglianza bit a bit, poiché le differenze di linguaggio e compilatore escludono una corrispondenza esatta a livello di byte.
   • Da C a Kokkos (CPU): Validata tramite identità bit a bit rispetto al riferimento C su back-end deterministici (Serial/OpenMP).
   • Kokkos (GPU): Validata tramite vicinanza statistica rispetto al riferimento C su GPU (dove l'ordine di riduzione dei numeri in virgola mobile differisce) e attraverso "gate" rigorosi (ad esempio, esecuzioni di 20 step con ghiaccio marino attivo) per rilevare errori reali rispetto a divergenze numeriche attese.
   • Strumenti di Debug: Sono stati sviluppati strumenti personalizzati, come dump di riferimento per ogni sottostep, differenze di operatori con input identici e sonde per halo obsoleti (stale-halo), per isolare i fallimenti a specifici kernel o sottosistemi.

Risultati Chiave

• Fedeltà:
  • Il porting in C ha riprodotto il modello Fortran originale in un'integrazione di cinque anni con una differenza quadratica media (RMS) della temperatura superficiale del mare (SST) di 0,006 °C e una differenza di salinità di 0,002 PSU. Le differenze nell'oceano profondo erano statisticamente indistinguibili da zero sotto i 700 m.
  • Le build Kokkos CPU erano bit a bit identiche al riferimento C su un anno simulato completo.
  • Le build Kokkos GPU rimanevano statisticamente vicine al riferimento C, con correlazioni SST di 1,0 e bias di $+10^{-4}$ °C. La divergenza indotta dalla GPU era circa tre ordini di grandezza inferiore all'incertezza introdotta nella traduzione da Fortran a C.
• Prestazioni:
  • Su mesh ad alta risoluzione (fino a 7,4 milioni di vertici superficiali), un singolo nodo NVIDIA A100 GPU è stato da 1,6 a 3,7 volte più veloce di un nodo CPU.
  • Il modello ha raggiunto l'obiettivo di produzione di 1–2 anni simulati al giorno (SYPD) su mesh con milioni di vertici su tutta l'hardware testata.
  • Sul sistema NVIDIA GH200, il throughput ha raggiunto fino a 3,5 SYPD.
• Portabilità:
  • Un singolo codebase Kokkos è stato in grado di compilare ed eseguire con successo su hardware diversi senza riscrivere il codice della fisica: NVIDIA A100, H100 e GH200 (tramite CUDA) e AMD MI250X (tramite HIP). La trasposizione al sistema AMD ha richiesto meno di un giorno di lavoro, comportando principalmente una minima modifica a una guardia di preprocessore.

Significatività e Rivendicazioni
L'articolo sostiene che questa sia la prima dimostrazione che una trasposizione assistita da LLM possa portare un intero modello oceano-ghiaccio marino di produzione a un'implementazione capace di GPU, mantenendo la fedeltà scientifica e raggiungendo prestazioni rilevanti per la produzione. Gli autori sottolineano che il successo non è dovuto solo alla capacità autonoma dell'LLM, ma piuttosto a un flusso di lavoro disciplinato che combina:

• Assistenza agentica per la traduzione instancabile e la costruzione di harness.
• Competenza del dominio umano per la strategia, la revisione dei piani e il rilevamento di sottili errori fisici.
• Una procedura di validazione a livelli che converte errori fisici silenziosi in fallimenti immediati e localizzati.

Il lavoro stabilisce che gli LLM possono spostare modelli Fortran consolidati in linguaggi moderni con portabilità delle prestazioni (C++/Kokkos) in poche settimane, a condizione che la traduzione sia vincolata da regole rigide e validata rispetto a criteri di accettazione appropriati. Gli autori presentano questo lavoro non come un'ottimizzazione finale del modello, ma come un punto di partenza validato e competitivo che preserva la fisica del modello originale consentendo l'esecuzione su acceleratori moderni.