HN 日本語サマリー

← 一覧へ戻る
プログラミング

LFortranとEnzymeによる微分可能なFortran

Differentiable Fortran with LFortran and Enzyme (docs.pasteurlabs.ai)

46 pointsby dionhaefner15 コメント

要約

この記事では、既存のFortran、C、C++のシミュレーションコードに対して、LFortranというFortranコンパイラとEnzymeという自動微分(AD)ツールを組み合わせることで、自動微分を可能にする手法を探求しています。これにより、長年使われてきた物理シミュレーションコードを、書き直すことなくJAXやPyTorchのような現代的な機械学習フレームワークに組み込み、高精度な微分可能物理エンジンとして利用できるようになります。このアプローチはLLVM IRレベルで動作するため、LLVMにコンパイル可能なあらゆるコードに対応可能ですが、実験的な段階であり、デバッグには手間がかかる場合があることが述べられています。

全文翻訳

LFortranとEnzymeによる微分可能なFortran¶

← Tesseract Blog

既存のFortran、C、またはC++のシミュレーションコードを通じてバックプロパゲーションを行い、それをJAXやtorchに埋め込み、高性能な微分可能な物理エンジンとして使用できたらどうなるでしょうか? 試してみる勇気があれば、それは可能です…

CFD、気候、航空宇宙、原子力分野における数十年にわたる検証済みの物理コードは、勾配を公開していないため、現代のMLパイプラインが越えられない壁の向こうにあります。通常の回答は、それらをすべてJAXやPyTorchで書き直すことです。ここで探求する代替案は、コードをそのままにして、LLVMレベルのいくつかのマジックのおかげで、それでも正確な勾配を得ることです。これは、EnzymeがLLVM IRレベルで自動微分を適用するため、LLVMにコンパイルされるあらゆるコードを微分できるからです!

必要なのは、LFortran、LLVM、およびEnzymeを組み合わせて、結果をFortranの熱ソルバーに向け、反対側から正確な勾配を得ることだけです。そこから、Tesseractは結果をカスタムJAXプリミティブとしてラップするため、Fortranソルバーは任意のJAXコード内の微分可能なレイヤーになります。

これらはすべてかなり実験的なものなので、NaNを返した勾配を追いかけたり、動作させるためにLLVM IRの差分を手動で比較したりするのに時間を費やす準備をしてください。しかし、労力を費やせば、解析的な答えと一致する多段階の時間ループ全体を通じて勾配を得ることができ、最も古く最も新しい技術を組み合わせたスタックがすべて一緒に機能できるというのは驚くべきことです。

しかし、最初から始めましょう。以下は、コンパイルパイプライン、私たちが遭遇した困難な点、そして(ADなしでは不可能だったであろう)挑戦的な逆問題への応用を含む、完全なストーリーです。

レガシーコードから勾配を取得する問題¶

科学計算に携わっているなら、この問題に遭遇したことがあるかもしれません。Fortran(またはC、C++)で書かれたシミュレーションがあり、今、誰かが勾配(シミュレーションの出力の入力に対する微分)を必要としています。最適化のためかもしれませんし、逆問題のためかもしれませんし、MLパイプラインにシミュレーションを組み込むためかもしれません。さて、あなたの選択肢は次のとおりです。

  • 手書きのアジョイント(adjoints)。 コードの各行の微分の手動実装に尽きます。これは専門家による数ヶ月の労力を意味します。エラーを起こしやすく、メンテナンスの悪夢であり、フォワードコードからゆっくりと同期がずれていきます。

  • 有限差分。 各入力を摂動させ、出力を差分します。遅い(n個のパラメータに対して(O(n))回の評価)、不正確で、スティッフな問題に対して条件が悪いです。

  • JAXまたはPyTorchで書き直し、自動微分を使用する。 もちろん、検証済みの数万行の物理コードを書き直したいのであれば。

ソースコードから自動的に微分をコンパイルできたらどうなるでしょうか? これが実際に試したときの様子です。

Fortran熱ソルバーの例¶

私たちのテスト対象は、この実験のために書いた約220行のプレーンなFortran 90のthermal_2d.f90です。これは、温度依存の伝導率を持つ2次元過渡熱伝導を解きます。

([\rho , c_p \frac{\partial T}{\partial t} = \nabla \cdot \big( k(T) , \nabla T \big) + Q])

伝導率 (k) は線形材料モデル (k(T) = k_0 + k_1 \cdot T) に従い、時間積分は n_steps ステップにわたる陽的オイラー法です。特に変わった点はありません。

以下に、サブルーチンシグネチャと内部ステンシルループの様子を示します。

! 微分するソルバー:プレーンなFortran 90での2D熱伝導ステップループ
subroutine thermal_2d_solve(n, nx, ny, n_steps, &
                            T_init, T_final, T_cur, T_new, &
                            k0, k1, rho, cp, &
                            h_conv, T_inf, T_hot, &
                            Q, Lx, Ly, dt)
  implicit none
  integer, intent(in) :: n, nx, ny, n_steps
  double precision, intent(in) :: T_init(n)
  double precision, intent(out) :: T_final(n)
  ! ... (ワーク配列、スカラー)

  ! 時間積分ループ
  do step = 1, n_steps
    do j = 2, ny - 1
      do i = 2, nx - 1
        idx = (j - 1) * nx + i

        T_c = T_cur(idx)
        T_e = T_cur(idx + 1)
        T_w = T_cur(idx - 1)
        T_nn = T_cur(idx + nx)
        T_s = T_cur(idx - nx)

        ! セル面間の調和平均伝導率
        kx_east = 2.0d0 * (k0 + k1*T_c) * (k0 + k1*T_e) &
                  / ((k0 + k1*T_c) + (k0 + k1*T_e))
        kx_west = 2.0d0 * (k0 + k1*T_c) * (k0 + k1*T_w) &
                  / ((k0 + k1*T_c) + (k0 + k1*T_w))
        ! ... (ky_north, ky_south も同様に)

        flux_x = (kx_east*(T_e - T_c) - kx_west*(T_c - T_w)) / (dx*dx)
        flux_y = (ky_north*(T_nn - T_c) - ky_south*(T_c - T_s)) / (dy*dy)

        T_new(idx) = T_c + dt/(rho*cp) * (flux_x + flux_y + Q(idx))
      end do
    end do
    ! ... (境界条件、T_cur <- T_new のスワップ)
  end do

境界条件は混合型です:ディリクレ(下部壁)、対流/ロビン(上部)、断熱/ノイマン(側面)。面は調和平均伝導率を使用しており、これは異なる (k) を持つセル間のフラックス連続性のための標準的なトリックです。

この設定では、勾配を取得する簡単な近道はありません。(k(T)) が非線形であるため、ステンシル係数は現在の温度場に依存し、ヤコビアンは各時間ステップで変化します。そのアジョイントを手書きでコーディングし、フォワードコードが変更されるたびに再導出することは、ADが存在する理由を削除するための作業です。

これはアノテーションやAD対応の構造がないプレーンなFortranですが、「プレーン」に到達するためでさえ、いくつかの調整が必要でした。LFortranでは、アロケータブル、配列組み込み関数、境界チェックはすべてランタイムコール(_lfortran_mallocなど)にコンパイルされ、Enzymeはそれらを透過できません。そのため、ここではそれらを避ける必要があります。代わりに、ワーク配列は事前にCから割り当てられて渡され、--no-array-bounds-checkingでコンパイルします。220行のソルバーであれば1時間程度の作業ですが、大規模なレガシーコードベースでは未解決の問題です。

Enzymeコンパイルパイプライン¶

ここから技術的になります。低レベルの詳細に興味がない場合は、次のセクションに進んで勾配のベンチマークを確認してください。

EnzymeはソースレベルではなくLLVM IR(中間表現)レベルで動作するため、LLVM IRにコンパイルされるもの(C、C++、Rust、Fortran)はすべて微分可能です。Fortranの場合、フロントエンドを選択する必要があります。明白な選択肢はLLVMの公式FortranコンパイラであるFlangですが、代わりにLFortranを使用します。これはEnzymeにとってずっと理解しやすいことが判明しました。フロントエンドが決まれば、チェーンは6回のopt/clang呼び出しで構成され、驚くほど簡単です(ただし、問題が発生した場合は、理由を見つけるためにIRを読むことになるでしょう)。

[画像: Compilation pipeline: Fortran → Enzyme AD → shared library]

Fortranソースから微分可能な共有ライブラリへの6ステップのコンパイルパイプライン。LFortranはソルバーをLLVM IRに低下させ、薄いCラッパーがリンクされ、Enzymeが派生コードを合成し、最終的な最適化パスがフォワード、JVP、VJPのエントリポイントを公開する単一の.soを出力します。チェーン全体はtesseract build中に約30秒で実行されます。¶

順序どおりの6つのステップ:

# コンパイルパイプライン:Fortranソース → 微分された共有ライブラリ

# 1. Fortran → LLVM IR(Enzymeがトレースするのに十分クリーン)
$ lfortran --show-llvm --no-array-bounds-checking thermal_2d.f90 > thermal_2d.ll

# 2. ADパス前の軽いクリーンアップ — -O1、意図的に-O3ではない(下記参照)
$ opt -O1 -S thermal_2d.ll -o thermal_2d_opt.ll

# 3. CラッパーをIRにコンパイル
$ clang -emit-llvm -S -O1 wrapper.c -o wrapper.ll

# 4. ソルバーとリンク
$ llvm-link wrapper.ll thermal_2d_opt.ll -S -o combined.ll

# 5. 微分を合成
$ opt --load-pass-plugin=LLVMEnzyme-19.so -passes=enzyme combined.ll -o ad.ll

# 6. 最終最適化と共有ライブラリのエクスポート
$ opt -O3 -S ad.ll -o ad_opt.ll && clang -shared -O3 ad_opt.ll -o thermal_2d.so -lm

これらのほとんどは配管作業です。実際に重要な3つは、ステップ1(LFortran IRダンプ)、ステップ2(Enzyme前の-O1クリーンアップ)、およびステップ5(Enzymeパス自体)であり、それぞれが詳しく説明する価値のある決定に対応します。

なぜLFortranなのか、Flangではない。最初のステップ(lfortran --show-llvm)は、LFortranが驚くほどクリーンなIRを出力するため、この全体が扱いやすい理由でもあります。配列は、Flang(明白なデフォルト)が生成するマルチフィールド記述子構造やランタイムコールではなく、Cに似たプレーンなポインタとして出力されます。これは非常に重要です。なぜなら、Enzymeはアクティブなものをすべて把握するためにすべてのメモリアクセスをトレースする必要があり、不透明なfir.box記述子よりもポインタ演算の方がはるかに扱いやすいからです。

では、LFortran IRが「クリーン」である理由は何でしょうか? 具体的には3つです。すべての配列参照は、プレーンなgetelementptr + load/storeにデコードされます。19引数のサブルーチンは、記述子構造でラップされていない19個のプレーンなptr引数を受け取ります。そして、モジュール全体にゼロ個の関数呼び出ししか含まれていません。_lfortran_malloc、ランタイムヘルパー、Enzymeがトレースする不透明なものは何もありません。以下は、LFortranがステンシル本体の開始部分で出力するIRで、ソースのidx = (j-1)*nx + iインデックスとT_c = T_cur(idx) / kx_east = ...行をカバーしています。

; LFortranがステンシル本体で出力するもの:プレーンなポインタ演算、記述子なし
; idx = (j - 1) * nx + i
%56 = sub i32 %55, 1                       ; j - 1
%58 = mul i32 %56, %57                      ; (j-1) * nx
%60 = add i32 %58, %59                      ; + i
store i32 %60, ptr %idx

; T_c = T_cur(idx)
%67 = getelementptr inbounds double, ptr %t_cur, i32 %65   ; &T_cur[idx]
%68 = load double, ptr %67                                 ; T_cur[idx]
store double %68, ptr %t_c

; kx_east = 2*(k0+k1*T_c)*(k0+k1*T_e) / ((k0+k1*T_c)+(k0+k1*T_e))
%110 = fmul double %108, %109              ; k1 * T_c
%111 = fadd double %107, %110              ; k0 + k1*T_c
%112 = fmul double 2.0, %111
; ... k0 + k1*T_e, 積、和 ...
%130 = fdiv double %118, %129              ; 調和平均
store double %130, ptr %kx_east

それだけです。配列アクセスはgetelementptr + loadであり、算術演算はFortranの行に1対1で対応するfmul/fadd/fdivのフラットなシーケンスです。対照的に、Flangは同じ配列を記述子構造でラップし、ランタイムヘルパーにアクセスしますが、Enzymeはそれらすべてを透過する必要があります。

ただし、LFortranはまだ成熟段階にあるため、コードはサポートされている範囲内に留める必要があります。

なぜ-O1なのか、-O3ではない。最初のパイプラインではここで-O3を使用しましたが、数時間を費やしました。フォワードパスは完璧でしたが、VJPは特定の入力でNaNを返しました。-O3では、LLVMの積極的なベクトル化とコード移動は、Enzymeがリバースモードで誤って処理するIRパターンを生成します。私たちのケースでは、隣接するセルの温度が等しい場合に問題が発生し、中間項がキャンセルされ、コンパイラによる並べ替えがゼロ除算に変わりました。修正は、ADパスの前に最適化を穏やかに保ち、ADパスの後に-O3を使用することです。

Cブリッジ。FortranとEnzymeの間には、Fortranのポインタ渡しABIをEnzymeが注釈付けできるCインターフェースにブリッジする薄いCラッパーがあります。これは数値的な作業を一切行いません。ワーク配列をヒープに割り当て(IR内の_lfortran_malloc呼び出しを回避)、Enzymeの組み込み関数を通じてどの引数がシャドウバッファを取得するかをマークします。このレシピはソルバーに固有ではなく汎用的であるため、Fortranは実際に変更されません。

// Cブリッジ:ワーク配列をヒープに割り当て、微分するものをEnzymeに指示
void thermal_2d_vjp(/* ... nx, ny, n_steps ... */)
{
    double* T_cur = calloc(n, sizeof(double));   // ヒープ、アロケータブルではない
    /* ... */
    __enzyme_autodiff((void*)thermal_2d_solve,
        enzyme_const, &nx_,                       // 微分しない
        enzyme_dup,   (double*)T_init, dT_init,   // 値 + シャドウバッファ
        enzyme_dup,   &k0_, dk0,
        /* ... */);
}

EnzymeによるADトレース。Enzymeパス(-passes=enzyme)は、実際のAD作業が行われる場所です。リンクされたIRを分析し、各時間ステップで中間値をキャッシュするストアオールテープ戦略を使用して、派生コードを合成します。機能する場合、時間ステップループ全体のアジョイントを無料で取得できます。機能しない場合は、午前2時にIR差分を読んでいます(次へを参照)。

最終的な-O3 + clang -sharedステップは、Pythonからctypes経由で呼び出し可能な3つのエントリポイント(フォワード、JVP、VJP)を持つ単一の.soを出力します。パイプライン全体はtesseract build中に実行され、エンドツーエンドで約30秒かかります。

EnzymeがIRに実際に行うこと¶

EnzymeがIRに何を行うか見てみましょう。この時点までに、クリーンなLFortran IRはCラッパーとリンクされ、単一モジュールになっており、これがEnzymeが消費するものです。Enzymeに入る前(ステップ4の出力)、VJPラッパーは通常の呼び出しです。__enzyme_autodiff組み込み関数にソルバーへのポインタと、各引数の前にenzyme_const/enzyme_dupマーカー(ここではグローバルからロードされる%50/%51)が渡されます。各dup引数は値/シャドウペアであり、その勾配を受け取るバッファはその直後に続きます。

; combined.ll — Enzymeパスの前
%50 = load i32, ptr @enzyme_const          ; enzyme_constマーカー
%51 = load i32, ptr @enzyme_dup            ; enzyme_dupマーカー
call void (ptr, ...) @__enzyme_autodiff(
    ptr nonnull @thermal_2d_solve,         ; 微分する関数
    i32 %50, ptr nonnull %33,              ; const:  n_steps  (シャドウなし)
    i32 %51, ptr %3, ptr %4,               ; dup:    T_init,  dT_init  (シャドウ)
    i32 %51, ptr %5, ptr %6,               ; dup:    k0,      dk0
    ; ... 15以上のdupペア ...
    i32 %51, ptr nonnull %43, ptr %28)

パスの後(ステップ5の出力)、その組み込み関数は削除され、__enzyme_autodiffは宣言(現在は未使用)を除いてモジュールにどこにも現れません。その代わりに、Enzymeがゼロから合成した関数@diffethermal_2d_solveがあります。そのシグネチャが手がかりです。元のソルバーの各アクティブな引数は、値とその直後に勾配を受け取る'で終わるシャドウが続きます。

; ad.ll — 合成された関数のシグネチャ
define internal void @diffethermal_2d_solve(
    ptr %n, ptr %nx, ptr %ny, ptr %n_steps,    ; 整数引数 — シャドウなし(非アクティブ)
    ptr %t_init, ptr %"t_init'",                ; T_init  +  そのシャドウ
    ptr %t_final, ptr %"t_final'",
    ptr %t_cur, ptr %"t_cur'",
    ptr %t_new, ptr %"t_new'",
    ptr %k0, ptr %"k0'",                        ; k0      +  そのシャドウ
    ptr %k1, ptr %"k1'" ...)                   ; ...アクティブな引数ごとに1ペア

名前付きシャドウ(`%