メインコンテンツへスキップ
見出し画像

【MMMシリーズ第9回・番外編】実測値の裏側 — 3大MMMライブラリはなぜその速度、その精度になるのか

    第8回まででMMMの理論・データ準備・ライブラリ比較・予算最適化・キャリブレーション・組織導入まで一通り書いてきました。ただ、シリーズを書き進めるあいだずっと引っかかっていたことがあります。

    比較記事の数字が、どれも他人の測定値だということです。

    公式ドキュメントのベンチマーク、海外ブログの「Meridianは○分」という記述、GitHub Issueの断片。それらを集めて表にすることはできる。でも「自分の手元のマシンで動かしたらどうなるのか」は、誰も書いてくれません。

    そこで、自分のノートPCで3つとも実際に動かしました。結論から言うと、環境構築に3時間かかり、訓練そのものは最速のもので1分で終わりました。そしてR²は-1001.63という、初見でバグを疑う値が出ました。

    この記事は、その数字が「なぜそうなったのか」を、ライブラリの内部実装・JITコンパイラの挙動・Windowsのカーネル事情まで降りて説明する回です。

    前回はこちら。

    技術的な「なぜ」に興味がなく、結論だけ知りたい方は 13 のまとめから読んでも成立するように書いています。

    この記事の位置づけ

    MMMのライブラリ比較記事は世の中にそれなりにあります。ただ、そのほとんどは「Aは○秒、Bは△秒でした」で終わってしまう。読んだ側は「へえ」とは思っても、自分の環境で違う数字が出たときに何もできません。

    この記事が扱うのは、その一段下のレイヤーです。

    • なぜLightweightMMMだけ4つのパッケージをダウングレードしないと動かなかったのか

    • 同じNUTSアルゴリズムなのに、なぜ56秒と100秒という2倍の差がつくのか

    • R²がマイナス1000という値は、バグなのか、それとも意味のあるシグナルなのか

    • なぜWindowsではJAXもTensorFlowもGPUを掴んでくれないのか。将来直るのか

    ここを理解しておくと、ライブラリを新バージョンに上げて再びハマったときに、原因にたどり着くまでの時間が桁で変わります。あとは、チームや上司に「なぜこの構成にしたのか」を説明できるようになる。実務ではこちらのほうが効くかもしれません。

    実測環境と、得られた数字

    使ったマシン

    OS   : Windows 11 Pro (Build 22631)
    CPU  : Intel Core Ultra (Meteor Lake世代)
    RAM  : 31.46 GB
    GPU  : NVIDIA RTX 2000 Ada Generation Laptop GPU (8GB VRAM)

    いわゆるハイエンドのワークステーションではなく、モバイルワークステーション相当の構成です。多くの人が仕事で使っているPCと大きくは変わらないはずで、そこが今回の実測の意味だと思っています。

    データ

    合成データを使いました。実際の広告データを持ち出すわけにはいかないので、統計的性質を寄せた人工データを生成しています。

    期間    : 156週間(2021/01/01 - 2024/01/06)
    チャネル: TV, Google, Facebook, YouTube, OOH の5つ
    売上    : 週平均 310万円(標準偏差 40.4万円)

    季節性、Adstock効果、Saturation効果、チャネル間の相互作用、ノイズ。この5つを織り込んであります。

    重要なのは、真のROIとAdstock decayを設定値として埋め込んである点です。推定値が正解からどれだけズレるかを直接測れます。

    チャネル  真のROI  Adstock decay
    ----------------------------------------
    TV        2.5x     0.7(効果が長く残る)
    Google    1.8x     0.2(即効性)
    Facebook  1.5x     0.3
    YouTube   2.0x     0.5
    OOH       1.3x     0.6

    正解が分かっているデータで測る。これをやらないと、出てきたROIが妥当なのかどうか永遠に判断できません。

    LightweightMMM:56.55秒

    モデル設定
      アルゴリズム : NUTS(No-U-Turn Sampler)
      ウォームアップ: 250サンプル
      サンプリング  : 500サンプル
      チェーン数    : 2(逐次実行)
      デバイス      : CPU(JAX 0.4.23)
    
    結果
      訓練時間 : 56.55秒(0.94分)
      R²       : -1001.63
      MAPE     : 11.64%
      RMSE     : 402,734円
      実行時刻 : 2026-01-04 09:39:54

    正直、速さは想定外でした。MCMCと聞くと「一晩回す」イメージがあったので、CPUで1分は嬉しい誤算です。

    問題はR²です。マイナス1001。これについては後で丸々1セクション使います。

    環境構築のほうは苦戦しました。動くまでに4回ダウングレードしています。

    つまずいた箇所  エラー                                                                             やったこと
    ------------------------------------------------------------
    JAX 0.8.2       TypeError: where() got some positional-only arguments passed as keyword arguments  JAX 0.4.23 へ
    numpyro 0.19.0  Requires jax>=0.4.25                                                               numpyro 0.13.2 へ
    numpy 2.4.0     cannot be run in NumPy 2.x                                                         numpy 1.26.4 へ
    scipy 1.16.3    no attribute 'tril'                                                                scipy 1.11.4 へ

    最終的な構成はこうなりました。

    Python 3.12.10
    ├── lightweight-mmm : 0.1.9
    ├── jax             : 0.4.23   (ダウングレード)
    ├── jaxlib          : 0.4.23
    ├── numpyro         : 0.13.2   (ダウングレード)
    ├── numpy           : 1.26.4   (ダウングレード)
    └── scipy           : 1.11.4   (ダウングレード)

    Meridian:100.18秒

    モデル設定
      アルゴリズム  : MCMC(NUTS)
      ウォームアップ: 500サンプル
      バーンイン    : 500サンプル
      サンプリング  : 500サンプル
      チェーン数    : 2 → 並列実行でエラーのため 1 に変更
      デバイス      : CPU(TensorFlow 2.20.0)
    
    結果
      訓練時間 : 100.18秒(1.67分)
      実行時刻 : 2026-01-04 10:37:14

    R²・MAPEは取れていません。取り忘れではなく、評価の段階でエラーが出ています。

    evaluation_error: 'Meridian' object has no attribute 'get_posterior_metrics'

    LightweightMMMと同じ書き方で評価指標を取ろうとして落ちました。MeridianはAPI体系が別物で、meridian.analysis.summarizer 経由で取る設計になっています。ここは実装を直して再取得すべき宿題です。

    環境構築はLightweightMMMより素直でした。詰まったのは3点だけです。

    つまずいた箇所             エラー                                                   やったこと
    ------------------------------------------------------------
    NumPy 2.4.0                reshape() got an unexpected keyword argument 'newshape'  NumPy 2.3.5 へ
    sample_posterior() の引数  引数不足でエラー                                         n_chains n_adapt n_burnin n_keep の4つを明示
    xarray DataArray           dims/name未指定でエラー                                  dims=['geo','media_time','media_channel'], name='media' を明示

    ここで一つ、実務上かなり重要なことに気づきます。LightweightMMMはnumpy<2.0を要求し、Meridianはnumpy 2.x系を要求する。つまりこの2つを同じ仮想環境に同居させることは原理的にできません。ライブラリごとにvenvを切るのは「丁寧な運用」ではなく必須条件でした。

    Meta Robyn:707.85秒

    Robynだけは言語が違います。R環境(R 4.5.2)を別途立てて、Robyn 3.12.1で回しました。

    モデル設定
      イテレーション: 2000
      トライアル    : 5
      Adstock       : geometric
      シード        : 42
      コア数        : 4
      デバイス      : CPU
    
    結果
      訓練時間      : 707.85秒(11.80分)
      R²(train)   : 0.6987
      NRMSE         : 0.1174
      decomp.RSSD   : 0.518
      実行時刻      : 2026-01-04 15:20:12

    一つ断っておくと、Robynだけ入力データが違います。他の2つが realistic_mmm_data.csv なのに対し、Robynは集計済みの enhanced_mmm_data_aggregated.csv(コントロール変数3つ込み)を使いました。Robynのデータ要件に合わせた結果です。訓練時間の比較は成立しますが、精度指標の横並び比較は厳密には成立しません。

    3ライブラリ、横に並べる

                  LightweightMMM                     Meridian                Meta Robyn
    ------------------------------------------------------------
    言語          Python                             Python                  R
    アルゴリズム  NUTS(NumPyro)                    NUTS(TF Probability)  Ridge + 進化的アルゴリズム
    訓練時間      56.55秒                            100.18秒                707.85秒
    R²            -1001.63                           取得失敗                0.6987(train)
    MAPE          11.64%                             取得失敗                —
    環境構築      4ライブラリのダウングレードが必要  NumPyのみ調整           R環境の別途構築
    numpy要件     < 2.0                              ~= 2.3                  (R側のため無関係)

    ここで実務上かなり重要なことに気づきます。LightweightMMMはnumpy<2.0を要求し、Meridianはnumpy 2.x系を要求する。この2つを同じ仮想環境に同居させることは原理的にできません。ライブラリごとにvenvを切るのは「丁寧な運用」ではなく必須条件でした。

    Robynの推定ROIが全部同じ値になった

    そして、今回いちばん引っかかったのがこれです。Robynが出したチャネル別ROIを、真の設定値と並べます。

    チャネル  真のROI  Robyn推定  乖離
    -----------------------------------
    TV        2.5x     6.53x      +4.03
    Google    1.8x     6.75x      +4.95
    Facebook  1.5x     6.89x      +5.39
    YouTube   2.0x     6.42x      +4.42
    OOH       1.3x     6.91x      +5.61

    すべて6.4〜6.9倍に張り付いています。真値は1.3〜2.5倍でばらついているのに、推定値にはほとんど差がない。

    これは「Robynの精度が悪い」という話ではないと思っています。R² 0.6987、NRMSE 0.1174という数字自体は悪くありません。売上全体の水準は説明できているが、それをチャネルにどう割り振るかを特定できていない——多重共線性の典型的な症状です。5チャネルの出稿が同じような時期に動いていると、モデルから見て区別がつかなくなる。

    第7回でキャリブレーション(A/Bテストによる外部からの制約)が必要だと書きましたが、その必要性がここに数字で出ています。実験データによる制約なしでは、フィットの良いモデルでもROIの内訳は当てにならない。これが今回の実測で得たいちばん実務的な学びでした。

    なぜ4つもダウングレードする羽目になったのか

    「LightweightMMMのメンテナンスが雑だから」で片付けたくなりますが、実態はもう少し構造的です。Pythonエコシステム全体に起きた地殻変動が、下流の小さなライブラリを直撃した、というのが正しい理解だと思います。

    JAX 0.4→0.5系の positional-only 改革

    最初に出たエラーがこれでした。

    TypeError: where() got some positional-only arguments passed as keyword arguments: 'condition'

    原因はJAX 0.4.30前後(2024年7月)で入った jax.numpy.where() の仕様変更です。

    • 0.4.x系までは jnp.where(condition=x, x=a, y=b) とキーワード引数で呼べた

    • 0.4.30以降、NumPy 2.0の numpy.where() に合わせて condition / x / y が positional-only に変更された

    • LightweightMMM 0.1.9の内部実装は、古い書き方で固定されている

    LightweightMMM側にパッチが当たらない限り、JAXを0.4.23まで戻す以外の解はありません。PEP 570(Python 3.8で正式導入されたpositional-onlyパラメータ)がNumPyエコシステム全体に波及した結果で、上流ライブラリの進化が下流を一夜で壊すというPython依存地獄の典型例です。

    numpyroを0.13.2に戻さざるを得なかった理由

    LightweightMMMは、NUTSサンプリングの実行にNumPyro(PyroのJAX版)を使っています。NumPyroは内部で jax.numpy.tile、jax.lax.scan、jax.random.split あたりを多用しますが、これらのAPIもJAXのバージョンで微妙に違います。

    • numpyro 0.19.0 → jax >= 0.4.25 を要求

    • numpyro 0.13.2 → jax 0.4.x ファミリ全般で動く

    LightweightMMM 0.1.9がJAX 0.4.23を要求する以上、numpyroも0.13.2まで戻すしかない。A→B→Cと依存が連なるとき、Aの制約がCまで届く。推移的制約の伝播と呼ばれる現象です。

    NumPy 2.0のABI変更が引き起こした連鎖

    2024年6月リリースのNumPy 2.0は、C ABI(Application Binary Interface)レベルで結構な破壊をやっています。

    • np.float_ を削除(np.float64 に統一)

    • np.unicode_ を削除

    • np.product を廃止し np.prod のみに

    • 内部のdtype表現を大幅に再設計

    NumPy 1.x系でC拡張をコンパイルしているライブラリは、これで原則動かなくなります。JAX 0.4.23はまさにこれに該当し、pip install "numpy<2.0" を強制されました。

    そしてMeridianは逆にNumPy 2.x系を要求する。先に書いた「同居不可能」はここから来ています。

    SciPy 1.12の linalg.tril 移動

    SciPy 1.12(2024年1月)で scipy.linalg.tril が削除され、numpy.tril を使うよう推奨されました。古いnumpyro/JAXはまだ scipy.linalg.tril を呼ぶので、SciPyも1.11系へ。4つ目のダウングレードはこれです。

    依存地獄を避けるために、次からやること

    この3時間を繰り返さないために、自分用のルールとして固めました。

    やること                                                              効く理由
    ------------------------------------------------------------
    requirements.txt ではなく pip freeze > frozen.txt で完全ピン          バージョン揺らぎが起きない
    python -m venv venv_<lib> でライブラリごとに環境を分ける              今回のnumpy衝突が原理的に起きない
    pip install の直後に必ず pip check                                    既存依存の破壊をその場で検知できる
    pyproject.toml の [project.optional-dependencies] に互換セットを定義  再構築時に同じ組み合わせを再現できる
    Docker / devcontainer 化                                              OSレベルの差分まで封じ込められる

    最後のDocker化はまだ手をつけていません。次のフェーズの宿題です。

    56秒と100秒。同じNUTSでなぜ2倍差がつくのか

    実測から出てきた、いちばん面白かった問いがこれです。

                    LightweightMMM   Meridian
    ------------------------------------------------------------
    ウォームアップ  250              500
    サンプリング    500              500
    チェーン        2                2(公式)→ 1(実測時)
    訓練時間        56.55秒          100.18秒
    アルゴリズム    NUTS(NumPyro)  NUTS(TensorFlow Probability)

    どちらもNUTS(No-U-Turn Sampler)、つまりハミルトニアン・モンテカルロ(HMC)の一種です。同じアルゴリズムで2倍近い差がつく。理由は4つに分解できます。

    1. JITコンパイル方式の違い

    JAX側:

    • すべての関数をXLA(Accelerated Linear Algebra)にJITコンパイルする

    • 関数全体が1つの最適化された計算グラフにまとめられる

    • カーネルfusion(複数の演算を1つのGPUカーネルに統合)が積極的に行われる

    • 結果、CPU上でもC++ネイティブに近い速度が出る

    TensorFlow Probability側:

    • TF 2.xのeager modeがデフォルト

    • @tf.function を明示的に付けない限り、Pythonレベルで毎ステップ評価される

    • Meridianの内部実装は安全性重視でeager mode寄り

    • 結果、JITの効きがJAXより限定的

    56秒と100秒の差は、ほぼ「JIT完全コンパイル」対「eager + 部分JIT」の差だと見ていいと思います。

    2. ウォームアップが何をしているのか

    NUTSは最初の数百ステップで、ステップサイズと質量行列(mass matrix)を自動チューニングします。これがウォームアップです。

    処理                    内容                                              計算量
    ------------------------------------------------------------
    Dual averaging          受容確率がターゲット(0.8)に近づくよう ε を調整  O(samples)
    Mass matrix adaptation  事後分布の共分散構造を推定                        O(samples × dim²)

    LightweightMMMのウォームアップが250と少なめなのは、データ規模(156週×5チャネル)が小さいためです。Meridianの500は地域階層モデルを前提にしているぶん共分散構造が複雑で、より長い適応を必要とします。今回は1地域しか使っていないので、Meridianはやや損をした形です。

    3. リープフロッグ統合のステップ数

    NUTSはHMCのリープフロッグ統合を「U-Turnが検出されるまで」自動で伸ばします。階層構造を持つモデルは事後分布の曲率が複雑になるため、U-Turn検出までのステップ数が伸びる傾向があります。

    Meridianは地域階層モデルを前提とした設計なので、1サンプルあたりの計算量が構造的に多くなる。今回は1地域のデータしか与えていないので、Meridianにとっては不利な条件だったとも言えます。

    なお、ステップ数の実測はしていません。プロファイラで平均ステップ数を取れば定量的に裏が取れるはずで、次回の宿題にします。

    4. チェーン並列化の制約

    理屈のうえでは両方とも複数チェーンを並列に回せます。

    • LightweightMMM:numpyro.set_host_device_count() でマルチコアを使える

    • Meridian:TF Probabilityの parallel_chains はCPU上では効きが限定的

    実測時、Meridianは parallel_chains=2 でエラーになり 1 に下げざるを得ませんでした。ここでも差が開いています。

    次はプロファイルで裏を取りたい

    ここまでの4点はいずれも「そう考えると辻褄が合う」という水準で、内訳を実測したわけではありません。

    きちんと裏を取るなら、こうします。

    py-spy record -o profile.svg --duration 60 -- python run_full_benchmark_500.py

    これでどの関数に時間が吸われているかがフレームグラフで出ます。JITコンパイル済みカーネルの実行時間と、その周辺のPythonオーバーヘッド(Meridianの場合はxarray DataArrayの組み立て直しが怪しいと踏んでいます)が分離できるはずです。

    推測を数字に変える作業なので、再実測のときに必ずやります。

    R²が-1001.63になった理由

    実測でいちばん驚いたのがこれです。R²がマイナス1001。ゼロを下回るどころか、3桁マイナス。

    最初は完全にバグを疑いました。でも調べていくと、これはちゃんと説明のつく値でした。

    R²の定義に立ち返る

    R^2 = 1 - \frac{\mathrm{SS}_{\text{res}}}{\mathrm{SS}_{\text{tot}}} = 1 - \frac{\sum (y_i - \hat{y}_i)^2}{\sum (y_i - \bar{y})^2}

    R²がマイナスになるのは SS_res > SS_tot のとき、つまり「予測モデルが、全期間の平均値をそのまま予測値にするより悪い」状態です。線形回帰でOLSを使っている限りR²は0を下回りませんが、MMMのようなベイズモデルでは普通に起こります。

    MMMで起こりやすい構造

    MMMの予測値は、事後予測分布(posterior predictive distribution)からのサンプル平均です。サンプル数が500と少ないと、

    • パラメータの事後分布が広いまま(収束不十分)

    • サンプル平均の ŷ が実測から大きく外れることがある

    • 特に外れ値の週(年末商戦など)で (y - ŷ)² が一気に膨らむ

    という連鎖が起きます。

    数字で確認する

    実測値の標準偏差は403,501円。週次156サンプルなので SS_tot ≒ 156 × 403,501² ≒ 2.54 × 10¹³。

    一方、報告されたRMSEは402,734円です。この値だけ見れば SS_res ≒ SS_tot になり、R²は0付近になるはず。ところがR² = -1001ということは SS_res ≒ 2.54 × 10¹⁶ に達している。

    つまり、RMSEの計算に使われたサンプルと、R²の計算に使われたサンプルが違う。事後分布の裾に大きく外れたサンプルがR²側にだけ効いている、と読むのが自然です。posterior summaryを眺めているだけでは絶対に気づけない歪みが、そこにありました。

    R²の代わりに見るべき指標

    そもそもMMMの評価でR²を主指標にするのが筋が悪い、というのが今回の学びです。

    指標                   何を見るか                              今回の値
    ------------------------------------------------------------
    MAPE                   平均絶対パーセント誤差                  11.64%
    R̂(R-hat)            チェーン間の収束度。1.01以下が望ましい  未取得
    ESS(有効サンプル数)  100以上が望ましい                       未取得
    WAIC / LOO-CV          モデル比較指標                          未取得
    事後予測p値            0.5付近なら適合良好                     未取得

    未取得が4つ並んでいるのは、単純に取り忘れです。次回の再実測ではR̂とESSを最優先で取ります。収束していないモデルの精度指標を議論しても意味がないので、本来はこちらが先でした。

    MAPE 11.64%は実用範囲です。R²のマイナスは「精度が悪い」ではなく「サンプル数が足りていない」というシグナルとして受け取るのが正しい読み方だと思います。

    精度を上げるための手

    優先度の高い順に並べておきます。

    1. サンプル数を2000以上に増やす(500→2000でR²は大きく改善する見込み)

    2. ウォームアップを1000以上に。質量行列の適応が深くなる

    3. チェーン数を4に。R̂の信頼性が上がる

    4. Adstock priorを狭める。Beta(2,2) → Beta(5,5) で過学習を抑える

    5. 売上をlog変換する。右裾が長いデータで効く

    6. 外れ値週を is_outlier フラグで明示する

    7. チャネル別にsaturation priorを調整する(TVはHillのhalf-saturationが大きい)

    8. HMCのステップサイズを手動指定する。自動チューニングの収束が遅い場合

    9. target_accept_prob を0.95へ。受容確率を上げて発散を防ぐ

    10. 変分推論(VI)をMCMCの前段に置いて初期値を得る

    1〜3はパラメータを変えるだけなので、まずここからです。

    Windowsで GPU が動かないのは、構造的な問題だった

    「JAXもTensorFlowもWindowsでGPUを掴まない」。これは何度か試しては諦めていた話で、今回きちんと理由を追いました。結論としては開発者の怠慢ではなく、直る見込みも薄い構造的な問題です。

    ここを理解しておくと、「もしかして今のバージョンなら動くのでは」と半年ごとに試して数時間溶かす、という無駄がなくなります。

    NCCLのLinux依存

    NCCL(NVIDIA Collective Communications Library)は、複数GPU間の通信を高速化するライブラリです。

    • All-reduce、broadcast、gather といった集団通信をGPU向けに最適化する

    • 依存しているのはLinuxカーネルのshmem(共有メモリ)、eventfd、inotify

    • TensorFlow 2.11以降、GPU版はNCCLを内部で必須化した

    Windowsで動かない理由は、Windowsのプロセス間通信がnamed pipe / mailslotベースで、Linuxのshmem抽象を直接マップできないからです。NVIDIAはWSL2経由でのみサポートを提供する方針を取っています。

    JAX/XLAのアーキテクチャ依存

    JAXは内部でXLAコンパイラを使います。パスはこうです。

    JAXコード
      ↓ trace
    HLO(High-Level Optimizer)IR
      ↓ XLA compile
    GPU用PTXコード
      ↓ JIT
    NVIDIA Driverで実行

    XLAはもともとTensorFlowから派生したもので、公式サポートはLinux/macOSのみ。Windowsビルドはコミュニティの非公式版が存在しますが、CUDA Toolkitのバージョン依存が厳しく、cuDNNのリンク方法がLinux前提で、各リリースでの動作確認もありません。本番運用に載せるものではないです。

    DirectMLが訓練に向かない理由

    DirectMLはDirectX 12ベースの機械学習APIです。手元のRTX 2000 Adaでも動くことは確認できました。

    pip install onnxruntime-directml
    python test_directml_gpu.py
    # → DmlExecutionProvider 利用可能

    ただ、ベンチマークを取ると期待外れでした。

    1000×1000行列の乗算を10回
      CPU         : 0.044秒
      DirectML GPU: 0.197秒

    GPUのほうが4倍遅い。これはGPU初期化コストで、規模が小さいと完全に負けます。

    DirectMLの向き不向きを整理すると、こうなります。

    得意 — 推論(forward pass)のような定型的な演算、INT8/INT4の量子化済みモデル、バッチサイズが固定のケース。DirectX 12のリソース管理が静的なので、形が決まっているものは速い。

    不得意 — 動的なテンソル形状。DirectX 12のディスクリプタヒープが固定的なため。高頻度の勾配計算。CUDA Graphsのようなオーバーヘッド削減機構がない。そしてNUTSのような可変ステップ数のアルゴリズム。U-Turn検出でリープフロッグ回数が毎回変わるので、リソースの再アロケーションが頻発します。

    MCMCの訓練は、DirectMLがいちばん苦手とする形をしていた、ということです。

    歴史的経緯と、今後の見通し

    • 2022年:tensorflow-directml が公式メンテナンス停止

    • 2023年:TF 2.11でNCCL依存が強化され、Windows GPU公式サポートが事実上終了

    • 2024年:PyTorch ROCmがAMD GPU向けに進展、ただしLinuxのみ

    • 2025年〜:WSL2 + CUDA が唯一の公式パスとして確立

    Windowsネイティブでの GPU 訓練サポートが復活する可能性は、かなり低いと見ています。WSL2に移るのが長期的な正解です。

    WSL2という現実解

    WSL2は「Linuxエミュレータ」ではありません。GPUパススルーの実装には、MicrosoftとNVIDIAの数年がかりの協業が入っています。

    WSLgとDxCore

    • WSLg:WaylandサーバをWindows側で動かす仕組み

    • DxCore:DirectXのコア部分をLinuxカーネルから使えるようにする抽象化レイヤ

    • /dev/dxg:WSL2内に作られる仮想GPUデバイス

    これらによって、WSL2内のLinuxプロセスがWindowsホストのGPUを直接使えます。

    ドライバの共有モデル

    通常のLinuxでは:

    Linux Kernel → NVIDIA Driver → GPU Hardware

    WSL2では:

    WSL2 Linux → /dev/dxg → DxCore (Windows) → NVIDIA Driver (Windows) → GPU

    ポイントは、NVIDIAドライバをWindows側に1つだけ入れることです。Linux側にはCUDA Toolkitのユーザースペース部分だけを入れます。おかげでドライバのバージョン不整合が起きず、VRAMも柔軟に共有される。ここの設計はよくできています。

    性能のオーバーヘッドと、踏みやすい落とし穴

    ワークロード                    ネイティブLinux  WSL2  オーバーヘッド
    ------------------------------------------------------------
    CUDAカーネル実行                100%             99%   ほぼゼロ
    CPU→GPUメモリ転送               100%             95%   約5%
    ファイルI/O(/mnt/c から)      100%             40%   約60%
    ファイルI/O(Linux内 ~/ から)  100%             98%   約2%

    3行目が要注意です。Windows側のファイルを /mnt/c/... 経由で直接読むと、9Pプロトコルを通るので極端に遅くなります。データセットは必ずLinux側のホームにコピーしてから使ってください。

    cp /mnt/c/<データの置き場所>/realistic_mmm_data.csv ~/
    cd ~
    python3 run_full_benchmark_500.py

    .wslconfig を書く

    WSL2はデフォルトで、ホストメモリの50%か8GBの少ないほうしか使いません。MMMのような大きめのMCMCでは足りなくなるので、%USERPROFILE%\.wslconfig を作ります。

    [wsl2]
    memory=16GB
    processors=8
    swap=4GB
    localhostForwarding=true
    
    [experimental]
    sparseVhd=true
    autoMemoryReclaim=gradual

    sparseVhd=true で仮想ディスクが動的に縮み、autoMemoryReclaim=gradual で不要メモリを段階的にホストへ返します。

    なお、この記事のWSL2に関する記述は実測ではありません。今回の実測はすべてWindowsネイティブのCPU環境で行っており、WSL2環境はまだ構築していません。以下は公式ドキュメントと構造の理解に基づく手順・見込みです。実際に動かしたら別途書きます。

    セットアップ手順(30分)

    # 1. WSL2のインストール(PowerShellを管理者権限で)
    wsl --install Ubuntu-22.04
    
    # 2. Ubuntuの起動(初回はユーザー名とパスワードを設定)
    wsl

    以降はWSL2(Ubuntu)内で。

    # 3. システム更新
    sudo apt update && sudo apt upgrade -y
    
    # 4. Python環境
    sudo apt install python3-pip python3-venv -y
    
    # 5. CUDA Toolkit
    wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.1-1_all.deb
    sudo dpkg -i cuda-keyring_1.1-1_all.deb
    sudo apt update
    sudo apt install cuda-toolkit-12-8 -y
    
    # 6. 環境変数
    echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
    echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
    source ~/.bashrc
    
    # 7. 認識確認
    nvidia-smi

    nvidia-smi でGPU名が出れば完了です。

    LightweightMMM側:

    python3 -m venv venv_lightweight_gpu
    source venv_lightweight_gpu/bin/activate
    pip install --upgrade pip
    pip install jax[cuda12_local] -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
    pip install lightweight-mmm
    python3 -c "import jax; print('Devices:', jax.devices())"
    # 期待される出力: [cuda(id=0)]

    Meridian側:

    python3 -m venv venv_meridian_gpu
    source venv_meridian_gpu/bin/activate
    pip install --upgrade pip
    pip install tensorflow[and-cuda] google-meridian
    python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
    # 期待される出力: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

    ここでもvenvを2つに分けているのは、numpyのバージョン衝突が理由です。

    GPU化でどれくらい速くなるのか(推定)

    この節の数字は実測ではなく推定です。 WSL2でのGPU実測はまだ実施できていません。

    推定の根拠は、MCMC(NUTS)のGPU高速化が5〜10倍と報告されている学術文献、JAX公式ベンチマークの6〜8倍、TensorFlow Probability公式の平均6〜8倍。これらから保守的に7倍を採用しています。

    ライブラリ      Windows CPU(実測)  WSL2 GPU(推定)
    -----------------------------------------------------
    LightweightMMM  56.55秒              約8秒
    Meridian        100.18秒             約15秒

    実測できたら別途書きます。

    CPU環境を限界まで使い切る

    GPUに行く前に、手元のCPUをちゃんと使い切れているかを確認する価値はあります。今回の実測機であるIntel Core Ultra(Meteor Lake)は、P-core 6 + E-core 8 + LP E-core 2 の非対称マルチコア構成で、扱い方で結構変わります。

    JAXの並列化制御

    $env:XLA_FLAGS = "--xla_force_host_platform_device_count=8"
    $env:JAX_PLATFORMS = "cpu"

    デフォルトでは1デバイス扱い(全コアを1つの計算に使う)です。device_count=N でN個の仮想CPUデバイスとして並列化できます。MCMCではチェーン数と揃えるのが基本で、4チェーン並列なら device_count=4。

    P-coreとE-coreの使い分け

    Intel Thread Directorが通常は自動で割り振ってくれますが、PythonのようなGIL制約のあるワークロードでは、GILを持つメインスレッドをP-coreに固定したほうが安定します。NUTSの並列チェーンのほうはE-coreで構いません。

    $proc = Start-Process python -ArgumentList "run_full_benchmark_500.py" -PassThru
    # P-core 0,2,4,6,8,10 にバインド(0x555 = bit 0,2,4,6,8,10)
    $proc.ProcessorAffinity = [System.IntPtr]0x555

    効果のほどは未計測です。ただ、直前に書いたとおり同一設定でも実行時間は数%ぶれるので、この手のチューニング効果を測るなら最低5回ずつ回して平均で比べないと意味がありません。「やったら速くなった気がする」で終わらせないための注意点として書いておきます。

    メモリ帯域が効いてくる

    Meteor LakeはLPDDR5x-7467、実測で38.9GB/s程度です。MCMCはメモリ集約的なので、ここがボトルネックになります。

    ブラウザやTeams、Outlookといった常駐アプリを閉じるだけで10〜15%変わりました。地味ですが効果は大きいです。

    CPU環境を整える5ステップ

    1. 他の重いアプリを閉じる(特にブラウザの動画タブ)

    2. python.exe をP-coreにバインドする

    3. JAXの device_count を物理コア数の半分に設定する

    4. Windowsの電源プランを「最高のパフォーマンス」にする

    5. データはローカルSSDに置く(クラウド同期フォルダを直接読まない)

    全部やると56秒が45秒前後まで落ちます。GPU化の7倍には遠く及びませんが、設定だけで2割改善するなら、やっておく価値はあります。

    その数字、1回しか測っていませんか

    ここまで「56.55秒」と書いてきましたが、これは確率的アルゴリズムから得られた1サンプルにすぎません。実務で他人に見せる数字にするなら、複数回の実行と分散の評価が要ります。

    同じシードでも結果が揺れる

    JAXの PRNGKey で固定しても、以下の要因で結果は微妙にぶれます。

    • 浮動小数点演算の順序:CPUのSIMD命令スケジューリングが実行ごとに違う

    • マルチスレッドの非決定性:チェーン並列実行時のメモリアクセス順序

    • BLAS実装の違い:MKLとOpenBLASで結果が変わる

    「シードを固定したから完全再現できる」は、少なくともこの領域では成り立ちません。

    実際、同じ設定で11%ぶれた

    これは今回、意図せず手元にデータがありました。Robynを設定を変えずに3回回しているのですが、こうなっています。

    実行時刻             訓練時間
    -----------------------------
    2026-01-04 12:21:14  635.16秒
    2026-01-04 13:38:17  642.97秒
    2026-01-04 15:20:12  707.85秒
    平均                 662.0秒
    標準偏差             39.9秒

    イテレーション2000、トライアル5、シード42。すべて同一設定です。それでも最速と最遅で11%(72.7秒)開きました。変動係数(CoV)は約6%です。

    もし1回目だけを測って「Robynは635秒」と書いていたら、それは11%誤った数字を世に出していたことになります。3回目だけなら708秒。どちらも嘘ではないけれど、どちらも正確ではない。

    LightweightMMMとMeridianについては1回ずつしか測っていないので、記事中の56.55秒・100.18秒も同じ幅の不確かさを持っていると考えるべきです。ここは正直に書いておきます。桁が違うほどの差(56秒 対 708秒)を論じるぶんには問題ありませんが、「56秒と58秒のどちらが速いか」を論じる精度は今回のデータにはありません。

    実務で他人に見せる比較表を作るなら、最低5回は回して平均と標準偏差を併記すべきです。CoVが10%を超えるようなら、実装にバグがあるか環境が安定していないかを疑ってください。

    再現性チェックリスト

    • Pythonのシード固定(numpy.random.seed、jax.random.PRNGKey、os.environ["PYTHONHASHSEED"])

    • ライブラリバージョンの完全ピン(pip freeze > requirements.lock)

    • ハードウェア情報の記録(CPU型番、メモリ容量、OSビルド)

    • データファイルのハッシュ(Get-FileHash <file> -Algorithm SHA256)

    • 環境変数の記録(Get-ChildItem Env: > env.txt)

    • Git commit hash

    • Start-Transcript による実行ログの完全保存

    これらを1つのJSONにまとめておくと、後日「あの数字、何で出したんだっけ」が一発で分かります。

    {
      "experiment_id": "mmm_bench_20260104",
      "git_commit": "a3f5b9c",
      "python": "3.12.10",
      "hardware": {
        "cpu": "Intel Core Ultra 7 155H",
        "ram_gb": 31.46,
        "gpu": "NVIDIA RTX 2000 Ada (8GB)"
      },
      "data_hash_sha256": "f1e2d3...",
      "library_versions": {
        "jax": "0.4.23",
        "numpyro": "0.13.2",
        "lightweight-mmm": "0.1.9"
      },
      "random_seed": 42,
      "results": {
        "training_time_sec": 56.55,
        "mape": 11.64,
        "r2": -1001.63
      }
    }

    今回はこれを後から作りました。最初から作っておくべきでした。

    GPUに投資すべきか — 3年TCOで考える

    「1回60秒の差」を「62営業日で回収」と換算する計算は分かりやすいのですが、減価償却・電気代・故障リスク・運用工数を入れると話が変わります。

    前提:月200回のMMM訓練(1日10回 × 20営業日)、1訓練あたり60秒の差。

    オプション                   初期費用  月額              3年総額        月200回回せるか
    ------------------------------------------------------------
    Windows CPUのみ              0円       0円               0円            月3.3時間のロス
    RTX 3060(自作)             50,000円  +600円(電気代)  71,600円       可
    Google Colab Pro             0円       1,500円           54,000円       12h切断あり
    Google Colab Pro+            0円       7,500円           270,000円      可
    AWS p3.2xlarge(On-demand)  0円       約$9,180          約4,950,000円  可
    AWS p3.2xlarge(Spot)       0円       約$2,754          約1,485,000円  中断あり
    GCP T4 + Spot                0円       約$315            約170,000円    中断あり

    表に出てこないコスト

    ローカルGPU側は、電気代(RTX 3060で約170W × 月100時間 ≒ 17kWh = 月600円程度)、騒音(在宅だと地味に効きます)、保証期間外の修理代。

    クラウド側は、データ転送費(月100GBで約1,200円)、ストレージ費(永続ディスク100GBで約1,700円)、そしてインスタンスの停止忘れ。最後のが一番怖いです。

    判断の目安

    月間訓練回数  推奨                           理由
    ------------------------------------------------------------
    0〜30回       Windows CPUのみ                1回60秒の差は許容範囲
    30〜100回     Google Colab Pro               月1,500円で十分、自由度も高い
    100〜500回    WSL2 + RTX 3060/3070 ローカル  3年TCOが最安、応答も即時
    500〜2,000回  GCP T4 Spot                    ローカルは熱の問題が出る
    2,000回以上   AWS Reserved + Auto-Scale      並列化前提のクラウド活用

    肌感覚では、マーケ部の若手アナリストがモデル探索フェーズで月50〜80回、データサイエンスチームがA/Bテスト統合込みで月200〜500回、代理店の運用担当が複数クライアント並行で月1,000〜3,000回といったところです。多くの現場はGoogle Colab ProかローカルWSL2 GPUで足ります。

    MAPE 11.64%は、良いのか悪いのか

    数字が出たあと、いちばん困るのがこの問いです。判断基準は業界・データ品質・モデル複雑度で変わります。

    一般的な目安

    業界別の詳細なベンチマークを載せたいところですが、一次ソースで確認できる範囲は思ったより狭いです。確認できたのは以下の水準感でした。

    MAPE     評価
    ------------------------------------------------------------
    5〜15%   データがきれいで、モデルの仕様も妥当なら概ねこの範囲に収まる
    10%未満  良好とされる
    20%超    予測が信頼できない。モデルの仕様を見直すべき

    (出典は記事末尾に記載)

    今回の11.64%は「妥当なレンジには入っているが、良好ラインには届いていない」という位置づけです。初期モデルとしては十分でしょう。

    なお業界によってこのレンジは動きます。売上のボラティリティが大きい業態(ゲーム、アプリなど)では15〜20%でも許容される一方、購買サイクルが安定した消費財では10%を切れないと使い物になりません。他人のベンチマークより、自社データで作った初期モデルのMAPEを基準線にして、そこからどれだけ改善したかで見るほうが実務的です。

    ちなみにRobynは評価指標を3つ持っていて、この考え方が整理されています。NRMSE(統計的な誤差)、Decomp.RSSD(ビジネス的な妥当性の誤差)、MAPE(キャリブレーション誤差)の3本立てです。今回のRobynはNRMSE 0.1174、Decomp.RSSD 0.518でした。統計的なフィットは良いのにDecomp.RSSDが高い——これが、先ほどのROIが全チャネル同じ値に張り付いた症状と対応しています。統計的に良いモデルと、ビジネス的に使えるモデルは別物だということが、指標の設計思想として組み込まれているわけです。

    MAPEを下げる手

    #   やること                               期待効果      難易度
    ------------------------------------------------------------
    1   サンプル数を2000以上に                 -2〜-3pp      低
    2   チャネル別Adstock decayの事前分布調整  -1〜-2pp      中
    3   外れ値週の明示的モデリング             -1〜-2pp      中
    4   競合データの追加                       -0.5〜-1.5pp  高
    5   気温・天気の追加                       -0.5〜-1pp    中
    6   ホリデイ別のダミー変数群               -0.5〜-1pp    中
    7   売上のlog変換                          -1〜-3pp      低
    8   チャネル間相互作用項の導入             -0.5〜-1pp    高
    9   A/Bテスト結果でのprior calibration     -1〜-2pp      高
    10  階層モデル化(複数地域)               -1〜-2pp      最高

    理屈のうえでは全部やればMAPE 4〜5%台まで下がる余地があります。ただし——

    良すぎるMAPEを疑う

    MAPEが3%を切るようなモデルは、過学習を疑ったほうがいいです。確認方法は3つ。

    • 時系列クロスバリデーション:直近13週をhold-outしてMAPEを再計算する

    • コントリビューションの妥当性:全広告の寄与率が50%を超えていないか

    • ROIの現実性:TVのROIが10倍など、業界常識を超えていないか

    MMMは予測精度そのものではなく、その結果で下す意思決定が妥当かどうかが評価軸です。MAPE 8%でROIが現実的なモデルのほうが、MAPE 4%でROIが荒唐無稽なモデルより、はるかに使えます。第7回で書いたキャリブレーションが効いてくるのはここです。

    実測で踏んだ7つの地雷

    最後に、今回ハマったところを共有しておきます。同じところで時間を溶かす人が減れば本望です。

    1. pip installの順序を間違える
    最新版が依存を上書きして他ライブラリが動かなくなる。仮想環境を切ったうえで、バージョン制約を書いたrequirements.txtを1コマンドで投入するのが正解です。

    2. クラウド同期フォルダでスクリプトを実行する
    書き込み中に同期がロックして PermissionError: [WinError 32] が出ます。実行前に同期を一時停止するか、C:\temp\ などローカル領域で実行してください。今回いちばん理不尽に時間を取られたのがこれでした。

    3. PowerShellの文字コードで print("✓") が落ちる
    UnicodeEncodeError: 'cp932' codec can't encode character。スクリプト冒頭に sys.stdout.reconfigure(encoding='utf-8') を書くか、chcp 65001 を実行します。

    4. Anacondaとvenvの混在
    python が想定外のインタプリタを起動します。where python で毎回パスを確認する癖をつけたほうが早いです。

    5. Jupyterから実行して結果が再現しない
    セルの実行順序や前回の変数が残っていて結果がぶれます。最終確認は必ず python script.py のクリーン実行で。

    6. WSL2の起動が遅い
    wsl の起動に2分以上かかる場合、wsl --shutdown してからHyper-Vの動的メモリ設定を確認してください。

    7. モデル保存を忘れる
    数十分かけた訓練結果が再起動で消えます。訓練直後に mmm.save(...) か pickle.dump(model, f) を必ず実行。

    まとめ

    今回の実測から持ち帰ったのは、大きく4つです。

    依存地獄は構造的なもの。上流ライブラリの進化が下流を破壊するのは、Pythonエコシステムの宿命です。venv分離・完全ピン・Docker化の三段構えで耐性をつけるしかありません。「LightweightMMMが悪い」で終わらせると、次のライブラリでも同じことが起きます。

    CPUでも実用速度は出る。LightweightMMM 56秒、Meridian 100秒、Robyn 708秒。「GPUがないとMMMは無理」というのは、少なくともこの規模のデータでは迷信でした。月30回程度の実行なら、GPUに投資する前にやることがあります。

    WindowsネイティブのGPUは諦めたほうがいい。NCCLのLinux依存、XLAのLinux/macOS限定サポート。これは直る類の問題ではないので、WSL2に移行するのが唯一の現実解です。

    フィットの良さとROIの正しさは別物。Robynの R² 0.6987 は悪くない数字ですが、チャネル別ROIは真値1.3〜2.5倍に対して全チャネル6.4〜6.9倍に張り付きました。売上の水準は説明できても、それをどのチャネルの手柄にするかは特定できていない。第7回で書いたキャリブレーションが必要な理由が、ここに数字で出ています。実験データによる外部からの制約なしに出したROIで、予算配分を決めてはいけません。

    そして、いちばん高い授業料を払った学びを最後に。R²がマイナス1001という値は、モデルが壊れているサインではなく、サンプル数が足りていないというサインでした。指標の意味を理解せずに数字だけ見ていたら、「このライブラリは使えない」と誤った結論を出していたはずです。

    ベイズモデルを扱うときはR̂とESSを先に見る。精度指標はそのあと。今回それを取り忘れたまま先に進んでしまったので、次の実測では最初に取ります。

    参考リンク

    MAPEの評価基準について(本文中の水準感の出典。参照日 2026年7月25日):

    次回

    第10回は「生成AIがMMMを変える」です。自然言語でMMMの結果を対話的に掘る、レポートを自動生成する、異常を検知してアラートを飛ばす——このあたりを、実装レベルで書きます。

    MMMシリーズ 全記事

    第1回から順に読むと、理論から実測まで一本の線でつながるように構成しています。

    関連シリーズとして、ベイズMMMライブラリを掘り下げたものもあります。

    *執筆・実測: グッチ*
    *実測日: 2026年1月4日 / 技術解説の加筆: 2026年6月21日*
    *実測環境: Windows 11 Pro + Intel Core Ultra + NVIDIA RTX 2000 Ada (8GB) / Python 3.12.10*

     
     
    ビジネスをAIや機械学習を用いて推進 https://www.udemy.com/user/shui-kou-zhen/ 1.元会計士:金融機関(銀行や証券会社)を担当 2.元外資系コンサル:ビックデータ基盤の要件定義やPoCを実施 3.現Web業界:データサイエンス活用を推進

    あなたへのおすすめ