サーバーレス GPU の Modal でコールドスタートを計測する

2026-05-17T00:00:00+00:00
はじめに</h2>
Modal</a> というサービスをご存知だろうか。Modal はサーバーレス GPU を提供している PaaS の一つである。有名どころでは Substack が SageMaker から移行したという事例を載せており</a>、今非常に勢いがある企業の一つだ。サーバーレス GPU というのは要は AWS Lambda の GPU 版である。
サーバーレス GPU を使いたいのはどんな時だろうか？たとえばアイテムに対する埋め込み計算やタグづけなど、アイテムが新しく追加された時だけ実行すれば良いような計算で、かつその頻度がそこまで高くないようなものは、常時 GPU サーバーを確保しておくとアイドル時間ばかりでお金が無駄になる。そういう時はバッチやイベント駆動のワークフロー中でサーバーレス GPU 上の ML モデルを呼べると実際の推論分にしか課金されず便利だろう。
サーバーレスのサービスではしばしばコールドスタートにかかる時間が問題になる。GPU を使ったモデル推論ではこの問題がさらに顕著で、GPU 用の Docker イメージは大抵サイズが非常に大きいのでインスタンスを確保してイメージを pull して立ち上げるだけで時間がかかるし、さらにその上にモデルのウェイトをロードしなければならない。汎用的なサービスでやると分単位でかかるのが普通である。
Modal などのサーバーレス GPU 業者は独自の最適化技術でこのコールドスタートを非常に短く抑えていることを売りにしている。そこで今回はいくつかのシナリオでこのコールドスタートの時間を簡単に計測してみようと思う。

Modal には training や notebook インスタンスなどいくつかのサービスがあるがここでは inference について簡単に紹介する。以下は公式ページのトップに載っているコード例</a>である。
import</span> modal</span></span>
</span>
MODEL_NAME</span> =</span> "</span>black-forest-labs/FLUX.1-schnell</span>"</span></span>
image</span> =</span> (</span></span>
    modal</span>.</span>Image</span>.</span>from_registry</span>(</span>"</span>nvidia/cuda:12.4.0-devel-ubuntu22.04</span>"</span>)</span></span>
    .</span>pip_install</span>(</span>"</span>torch</span>"</span>,</span> "</span>transformers</span>"</span>,</span> "</span>diffusers</span>"</span>,</span> ...</span>)</span></span>
)</span></span>
volume</span> =</span> modal</span>.</span>Volume</span>.</span>from_name</span>(</span>"</span>flux-lora-models</span>"</span>)</span></span>
</span>
@</span>app</span>.</span>cls</span>(</span>gpu</span>=</span>"</span>H100</span>"</span>,</span> image</span>=</span>image</span>,</span> volumes</span>=</span>{</span>"</span>/loras</span>"</span>:</span> volume</span>}</span>)</span></span>
class</span> FluxWithLoRA</span>:</span></span>
    @</span>modal</span>.</span>enter</span>(</span>)</span></span>
    def</span> setup</span>(</span>self</span>)</span>:</span></span>
        self</span>.</span>pipeline</span> =</span> FluxPipeline</span>.</span>from_pretrained</span>(</span>MODEL_NAME</span>)</span>.</span>to</span>(</span>"</span>cuda</span>"</span>)</span></span>
        self</span>.</span>pipeline</span>.</span>load_and_fuse_lora</span>(</span>)</span></span>
</span>
    @</span>modal</span>.</span>method</span>(</span>)</span></span>
    def</span> generate_image</span>(</span>self</span>,</span> prompt</span>:</span> str</span>)</span>:</span></span>
        return</span> self</span>.</span>pipeline</span>(</span>prompt</span>)</span>.</span>images</span>[</span>0</span>]</span></span>
</span>
flux</span> =</span> FluxWithLoRA</span>(</span>)</span></span>
flux</span>.</span>generate_image</span>.</span>remote</span>(</span>"</span>"</span>)</span></span></code></pre>
見ての通り、ベースの Docker イメージ・インストールする Python ライブラリ・GPU タイプのような設定を全て Python コードとして記述できる。@app.cls</code> にそれらインフラ設定を書き、@modal.enter()</code> でアプリケーションの初期化、@modal.method()</code> で実際に呼び出す関数を実装する。デプロイもコマンドラインから modal deploy app.py</code> を実行するだけで良い。GPU や CUDA が絡むイメージのビルドは落とし穴も多く、一回のビルドにも時間がかかるので個人的には苦痛を伴う作業だったが、Modal 側がある程度テンプレ化してくれているおかげでハマりづらい。</p>
上記の例は SDK 経由のアクセスを想定しているが、後述のように一般的な Web エンドポイントも容易に作成可能である。</p>
セットアップ</h2>
今回は以下の三つのセットアップで、cl-nagoya/ruri-v3-30m</code> と cl-nagoya/ruri-v3-310m</code> による文埋め込み計算をするエンドポイントを用意した。いずれも L4 GPU 上にデプロイし、proxy auth</a> で認証を設定している。</p>


  
  
  
    
      Note</strong>
  </p>
  
    ビルドスクリプト・計測スクリプトは Claude Code と Codex に書いてもらった。</p>

  </div>
  
</blockquote>

1. sentence-transformers</code> + FastAPI</h3>
FastAPI 内で sentence-transformers</code> モデルによる埋め込み計算を行なってレスポンスするシンプルな方法。一応 flash-attn</code> も入れている。</p>
import</span> modal</span></span>
</span>
app</span> =</span> modal</span>.</span>App</span>(</span>"</span>ruri-coldstart-st-cold</span>"</span>)</span></span>
model_volume</span> =</span> modal</span>.</span>Volume</span>.</span>from_name</span>(</span>"</span>ruri-weights</span>"</span>,</span> create_if_missing</span>=</span>True</span>)</span></span>
</span>
</span>
def</span> _prefetch_30m</span>(</span>)</span>:</span></span>
    from</span> huggingface_hub</span> import</span> snapshot_download</span></span>
</span>
    snapshot_download</span>(</span></span>
        repo_id</span>=</span>"</span>cl-nagoya/ruri-v3-30m</span>"</span>,</span></span>
        local_dir</span>=</span>"</span>/cache/hf/models/ruri-v3-30m</span>"</span>,</span></span>
        cache_dir</span>=</span>"</span>/cache/hf/hub</span>"</span>,</span></span>
    )</span></span>
    model_volume</span>.</span>commit</span>(</span>)</span></span>
</span>
</span>
@</span>app</span>.</span>cls</span>(</span></span>
    image</span>=</span>(</span></span>
        modal</span>.</span>Image</span>.</span>debian_slim</span>(</span>python_version</span>=</span>"</span>3.11</span>"</span>)</span></span>
        .</span>uv_pip_install</span>(</span></span>
            "</span>torch==2.6.0</span>"</span>,</span></span>
            "</span>https://github.com/Dao-AILab/flash-attention/releases/download/v2.7.4.post1/flash_attn-2.7.4.post1+cu12torch2.6cxx11abiFALSE-cp311-cp311-linux_x86_64.whl</span>"</span>,</span></span>
            "</span>sentence-transformers>=3.3</span>"</span>,</span></span>
            "</span>transformers>=4.48</span>"</span>,</span></span>
            "</span>fastapi[standard]>=0.115</span>"</span>,</span></span>
        )</span></span>
        .</span>env</span>(</span></span>
            {</span></span>
                "</span>HF_HOME</span>"</span>:</span> "</span>/cache/hf</span>"</span>,</span></span>
                "</span>HF_HUB_CACHE</span>"</span>:</span> "</span>/cache/hf/hub</span>"</span>,</span></span>
                "</span>HUGGINGFACE_HUB_CACHE</span>"</span>:</span> "</span>/cache/hf/hub</span>"</span>,</span></span>
                "</span>TRANSFORMERS_CACHE</span>"</span>:</span> "</span>/cache/hf/transformers</span>"</span>,</span></span>
                "</span>SENTENCE_TRANSFORMERS_HOME</span>"</span>:</span> "</span>/cache/hf/sentence-transformers</span>"</span>,</span></span>
                "</span>ENABLE_SNAPSHOT</span>"</span>:</span> "</span>0</span>"</span>,</span></span>
            }</span></span>
        )</span></span>
        .</span>run_function</span>(</span>_prefetch_30m</span>,</span> volumes</span>=</span>{</span>"</span>/cache/hf</span>"</span>:</span> model_volume</span>}</span>)</span></span>
    )</span>,</span></span>
    gpu</span>=</span>"</span>L4</span>"</span>,</span></span>
    scaledown_window</span>=</span>60</span>,</span></span>
    max_containers</span>=</span>1</span>,</span></span>
    volumes</span>=</span>{</span>"</span>/cache/hf</span>"</span>:</span> model_volume</span>}</span>,</span></span>
    enable_memory_snapshot</span>=</span>False</span>,</span></span>
)</span></span>
class</span> STRuri30m</span>:</span></span>
    @</span>modal</span>.</span>enter</span>(</span>)</span></span>
    def</span> load</span>(</span>self</span>)</span>:</span></span>
        import</span> os</span></span>
</span>
        os</span>.</span>environ</span>[</span>"</span>HF_HUB_OFFLINE</span>"</span>]</span> =</span> "</span>1</span>"</span></span>
</span>
        import</span> torch</span></span>
        from</span> sentence_transformers</span> import</span> SentenceTransformer</span></span>
</span>
        self</span>.</span>model</span> =</span> SentenceTransformer</span>(</span></span>
            "</span>/cache/hf/models/ruri-v3-30m</span>"</span>,</span></span>
            device</span>=</span>"</span>cuda</span>"</span>,</span></span>
            model_kwargs</span>=</span>{</span></span>
                "</span>attn_implementation</span>"</span>:</span> "</span>flash_attention_2</span>"</span>,</span></span>
                "</span>torch_dtype</span>"</span>:</span> torch</span>.</span>bfloat16</span>,</span></span>
            }</span>,</span></span>
            local_files_only</span>=</span>True</span>,</span></span>
            trust_remote_code</span>=</span>True</span>,</span></span>
        )</span></span>
        self</span>.</span>model</span>.</span>encode</span>(</span>[</span>"</span>ウォームアップ</span>"</span>]</span>,</span> normalize_embeddings</span>=</span>True</span>)</span></span>
</span>
    @</span>modal</span>.</span>asgi_app</span>(</span>requires_proxy_auth</span>=</span>True</span>)</span></span>
    def</span> web</span>(</span>self</span>)</span>:</span></span>
        from</span> fastapi</span> import</span> FastAPI</span></span>
</span>
        api</span> =</span> FastAPI</span>(</span>)</span></span>
</span>
        @</span>api</span>.</span>post</span>(</span>"</span>/embed</span>"</span>)</span></span>
        def</span> embed</span>(</span>req</span>:</span> dict</span>)</span>:</span></span>
            inputs</span> =</span> req</span>.</span>get</span>(</span>"</span>inputs</span>"</span>,</span> [</span>]</span>)</span></span>
            if</span> not</span> isinstance</span>(</span>inputs</span>,</span> list</span>)</span>:</span></span>
                inputs</span> =</span> [</span>inputs</span>]</span></span>
            embs</span> =</span> self</span>.</span>model</span>.</span>encode</span>(</span></span>
                inputs</span>,</span></span>
                normalize_embeddings</span>=</span>True</span>,</span></span>
            )</span>.</span>tolist</span>(</span>)</span></span>
            return</span> {</span>"</span>embeddings</span>"</span>:</span> embs</span>,</span> "</span>dim</span>"</span>:</span> len</span>(</span>embs</span>[</span>0</span>]</span>)</span> if</span> embs</span> else</span> 0</span>}</span></span>
</span>
        return</span> api</span></span></code></pre>
イメージビルド時に、_prefetch_30m</code> でついでにモデルを Modal の Volume に保存し、実際に使う際にネットワーク越しからモデルウェイトをダウンロードするのを回避しているのがポイント。FastAPI のエンドポイントは @modal.asgi_app</code> で作成できる。</p>


  
  
  
    
      Tip</strong>
  </p>
  
    ビルドや起動を高速化するために、モデルウェイトは Modal Volume においてコンテナにマウントするのがベストプラクティス</a>である。</p>

  </div>
  
</blockquote>

2. sentence-transformers</code> + FastAPI + Memory Snapshots</h3>
まだアルファ版だが、Modal には Memory Snapshots</a> という、コンテナの初期化処理をキャッシュしてくれるような機能がある。PyTorch の読み込みなどは結構時間がかかるので、これを使うと立ち上がりがより速くなるらしい。</p>
@</span>app</span>.</span>cls</span>(</span></span>
    image</span>=</span>(</span></span>
        modal</span>.</span>Image</span>.</span>debian_slim</span>(</span>python_version</span>=</span>"</span>3.11</span>"</span>)</span></span>
        ...</span></span>
        .</span>env</span>(</span></span>
            {</span></span>
                "</span>ENABLE_SNAPSHOT</span>"</span>:</span> "</span>1</span>"</span>,</span></span>
                ...</span></span>
            }</span></span>
        )</span></span>
        .</span>run_function</span>(</span>_prefetch_30m</span>,</span> volumes</span>=</span>{</span>"</span>/cache/hf</span>"</span>:</span> model_volume</span>}</span>)</span></span>
    )</span>,</span></span>
    enable_memory_snapshot</span>=</span>True</span>,</span></span>
    experimental_options</span>=</span>{</span>"</span>enable_gpu_snapshot</span>"</span>:</span> True</span>}</span>,</span></span>
    ...</span></span>
)</span></span>
class</span> STRuri30m</span>:</span></span>
    @</span>modal</span>.</span>enter</span>(</span>snap</span>=</span>True</span>)</span></span>
    def</span> load</span>(</span>self</span>)</span>:</span></span>
        ...</span></span></code></pre>3. Text Embeddings Inference (TEI)</h3>
三つ目は FastAPI を立てるのではなく、Rust 製の高速な埋め込み推論サーバーである Text Embeddings Inference (TEI)</a> を利用する。このような場合には、バックグラウンドでサーバープロセスを起動し、Modal では @modal.web_server</code> によってリクエストをそのままプロキシするのがスタンダードなようである。1</a></sup></p>
import</span> socket</span></span>
import</span> subprocess</span></span>
import</span> time</span></span>
</span>
import</span> modal</span></span>
</span>
app</span> =</span> modal</span>.</span>App</span>(</span>"</span>ruri-coldstart-tei</span>"</span>)</span></span>
model_volume</span> =</span> modal</span>.</span>Volume</span>.</span>from_name</span>(</span>"</span>ruri-weights</span>"</span>,</span> create_if_missing</span>=</span>True</span>)</span></span>
</span>
PORT</span> =</span> 8000</span></span>
</span>
</span>
def</span> spawn_server</span>(</span>model_id</span>:</span> str</span>)</span> -></span> subprocess</span>.</span>Popen</span>:</span></span>
    proc</span> =</span> subprocess</span>.</span>Popen</span>(</span></span>
        [</span></span>
            "</span>text-embeddings-router</span>"</span>,</span></span>
            "</span>--model-id</span>"</span>,</span></span>
            model_id</span>,</span></span>
            "</span>--huggingface-hub-cache</span>"</span>,</span></span>
            "</span>/cache/hf/hub</span>"</span>,</span></span>
            "</span>--port</span>"</span>,</span></span>
            str</span>(</span>PORT</span>)</span>,</span></span>
            "</span>--hostname</span>"</span>,</span></span>
            "</span>0.0.0.0</span>"</span>,</span></span>
        ]</span></span>
    )</span></span>
    deadline</span> =</span> time</span>.</span>monotonic</span>(</span>)</span> +</span> 300</span></span>
    while</span> time</span>.</span>monotonic</span>(</span>)</span> <</span> deadline</span>:</span></span>
        try</span>:</span></span>
            socket</span>.</span>create_connection</span>(</span>(</span>"</span>127.0.0.1</span>"</span>,</span> PORT</span>)</span>,</span> timeout</span>=</span>1</span>)</span>.</span>close</span>(</span>)</span></span>
            return</span> proc</span></span>
        except</span> (</span>OSError</span>,</span> ConnectionRefusedError</span>)</span>:</span></span>
            if</span> proc</span>.</span>poll</span>(</span>)</span> is</span> not</span> None</span>:</span></span>
                raise</span> RuntimeError</span>(</span></span>
                    f</span>"</span>text-embeddings-router exited with code </span>{</span>proc</span>.</span>returncode</span>}</span>"</span></span>
                )</span></span>
            time</span>.</span>sleep</span>(</span>0.5</span>)</span></span>
    proc</span>.</span>terminate</span>(</span>)</span></span>
    raise</span> RuntimeError</span>(</span>"</span>text-embeddings-router did not become ready within 300s</span>"</span>)</span></span>
</span>
</span>
def</span> _prefetch_30m</span>(</span>)</span>:</span></span>
    spawn_server</span>(</span>"</span>cl-nagoya/ruri-v3-30m</span>"</span>)</span>.</span>terminate</span>(</span>)</span></span>
</span>
</span>
@</span>app</span>.</span>cls</span>(</span></span>
    image</span>=</span>(</span></span>
        modal</span>.</span>Image</span>.</span>from_registry</span>(</span></span>
            "</span>ghcr.io/huggingface/text-embeddings-inference:89-1.9.3</span>"</span>,</span></span>
            add_python</span>=</span>"</span>3.11</span>"</span>,</span></span>
        )</span></span>
        .</span>dockerfile_commands</span>(</span>"</span>ENTRYPOINT []</span>"</span>)</span></span>
        .</span>env</span>(</span></span>
            {</span></span>
                "</span>HF_HOME</span>"</span>:</span> "</span>/cache/hf</span>"</span>,</span></span>
                "</span>HF_HUB_CACHE</span>"</span>:</span> "</span>/cache/hf/hub</span>"</span>,</span></span>
                "</span>HUGGINGFACE_HUB_CACHE</span>"</span>:</span> "</span>/cache/hf/hub</span>"</span>,</span></span>
                "</span>TRANSFORMERS_CACHE</span>"</span>:</span> "</span>/cache/hf/transformers</span>"</span>,</span></span>
                "</span>SENTENCE_TRANSFORMERS_HOME</span>"</span>:</span> "</span>/cache/hf/sentence-transformers</span>"</span>,</span></span>
            }</span></span>
        )</span></span>
        .</span>run_function</span>(</span></span>
            _prefetch_30m</span>,</span></span>
            gpu</span>=</span>"</span>L4</span>"</span>,</span></span>
            volumes</span>=</span>{</span>"</span>/cache/hf</span>"</span>:</span> model_volume</span>}</span>,</span></span>
        )</span></span>
    )</span>,</span></span>
    gpu</span>=</span>"</span>L4</span>"</span>,</span></span>
    scaledown_window</span>=</span>60</span>,</span></span>
    max_containers</span>=</span>1</span>,</span></span>
    volumes</span>=</span>{</span>"</span>/cache/hf</span>"</span>:</span> model_volume</span>}</span>,</span></span>
)</span></span>
class</span> TEIRuri30m</span>:</span></span>
    @</span>modal</span>.</span>enter</span>(</span>)</span></span>
    def</span> boot</span>(</span>self</span>)</span>:</span></span>
        self</span>.</span>proc</span> =</span> spawn_server</span>(</span>"</span>cl-nagoya/ruri-v3-30m</span>"</span>)</span></span>
</span>
    @</span>modal</span>.</span>exit</span>(</span>)</span></span>
    def</span> shutdown</span>(</span>self</span>)</span>:</span></span>
        self</span>.</span>proc</span>.</span>terminate</span>(</span>)</span></span>
</span>
    @</span>modal</span>.</span>web_server</span>(</span>port</span>=</span>8000</span>,</span> requires_proxy_auth</span>=</span>True</span>,</span> startup_timeout</span>=</span>300</span>)</span></span>
    def</span> serve</span>(</span>self</span>)</span>:</span></span>
        pass</span></span></code></pre>計測結果</h2>
上記の三種類に大きさの異なるモデルを二種類使って計6パターンのエンドポイントを作成し、コールドスタートにかかる時間を計測してみた。なお Memory Snapshots を使う場合は事前にリクエストを送ってスナップショットが作られるようにしてから計測した。2</a></sup>
以下はコンテナ0の状態からリクエストを投げて返ってくるまでの時間を何回か測ったうちの一つであり、各回で数秒のぶれくらいは普通にあると思って見て頂きたい。</p>
パターン</th> モデル</th> コールドスタート(秒)</th></tr></thead>

sentence-transformers</td> ruri-v3-30m</td> 16.25</td></tr>
sentence-transformers</td> ruri-v3-310m</td> 18.29</td></tr>
sentence-transformers (Memory Snapshotsあり)</td> ruri-v3-30m</td> 5.27</td></tr>
sentence-transformers (Memory Snapshotsあり)</td> ruri-v3-310m</td> 8.32</td></tr>
TEI</td> ruri-v3-30m</td> 7.38</td></tr>
TEI</td> ruri-v3-310m</td> 7.48</td></tr>
</tbody></table>
今回の計測では、TEI と Memory Snapshots ありの sentence-transformers が同程度に速かった。TEI は Python ライブラリ読み込みのオーバーヘッドが無いため高速に起動している。Memory Snapshots が使われた場合もオーバーヘッドがなくなるので同等レベルの速さが出ていた。モデルウェイトはコンテナにマウントしたボリュームから読み込んでいるので、今回使った小型のモデルであればサイズによる差は小さかった。また GPU で推論しているので、どの場合でも埋め込み計算自体は50-100ms 程度と高速に完了していた。</p>
さいごに</h2>
GPU コンテナが数秒で起動するというのはすごい技術だなと思う。今回の検証に使ったコードは以下。



  



  



  



  
    
      
      yng87/modal-measure-coldstart</div>
      
      Modal 上で ruri-v3 の cold start を TEI / Sentence Transformers / snapshot on-off で測る実験用リポジトリ。</div>
      
      
      Python</div>
      
    </div>
  </a>
</div>
</p>

^{1</sup>
TEI の--model-id</code>には好きな local path を設定できるため、Volume 上のモデルを適当な場所にマウントしてそのパスを指定すればリモートからのモデルダウンロードなしに起動できる。しかし --model-id</code>に HF 上の model_id を指定した上で、HUGGINGFACE_HUB_CACHE</code>にマウントした Volume からモデルをロードする方が明確に起動が速かった。何かしら最適化がされているのかもしれない。</p>
</div>}^{2</sup>
ただし、リクエストを送った先でスナップショットが利用可能になっているとは限らず（インスタンスタイプごとに必要だったりするようで、事前に作っても使われないことがある）、その場合はスナップショットの作成が走ってしまうので逆に遅くなってしまう。ここに載せた数値はスナップショットから復元が行われた場合の計測結果。</p>
</div>}
『データ分析失敗事例集』を再読したが改めてデータサイエンスに関わる全ての人が読むべき本だと思った
2026-01-24T00:00:00+00:00
様々なデータ分析現場での失敗事例をまとめた『データ分析失敗事例集』という本を数年ぶりに再読したのだが、生成 AI が流行してそれを使った PoC 施策がますます発生しがちな昨今、改めてデータサイエンスに関わる全員が読むべき価値のある本だと思ったので紹介したい。</p>

  



  



  



  



  



  



  




  
    
      
      
      
    </div>

    
      
      Book</div>
      

      データ分析失敗事例集</div>

      
      尾花山和哉編著ほか / 共立出版</div>
      

      
      失敗から学び、成功を手にする。</div>
      

      
      2023/08/03発売 / ISBN 9784320125674</div>
      
    </div>
  </a>
</div>

世の中で光が当たるのは大抵成功事例で、自分もニュースレターや技術ブログなどをフォローして、有名な企業の事例をよく読んでいる。ただ、その裏には表に出てこない失敗事例が多くあるのは現場で働いているみなさんならご存知の通りで、しかしそういう話はイベントの懇親会で近くの人と話すとかそういう機会でもないとなかなか入手できない。そのような影に葬られがちな話を収集し（匿名化して）扱っている点で、本書は非常に稀有である。</p>
成功というのは運の要素が多くあり、またそのプロダクト特有の事情に左右されたりもするため、なかなか再現できないものである。一方で失敗は、結構限られたパターンに落ち着くことが多い。本書はそうした失敗事例を20個以上集めており、そのどれもが思い当たる節があったり、自分も同じ現場にいたら同じような判断をしてしまいそう、と感じるものになっている。</p>
例えばロット単位でしか発注できない商品に対して個数単位の予測精度を向上させようと頑張ってしまう事例が紹介されている。自分も小売ではないが、予測結果がどう使われるかを意識しないモデリングをやってしまったことがある。</p>
最近は AI の性能向上が凄まじく、とりあえず PoC してみよう、とりあえず作って動かしてみよう、というプロダクトアウト的な動きが強くなっているように感じる。個人的にはそれ自体は悪いことではないと思っているが、作って試していろいろやってみても、結局それがユーザーにとって価値がなければ、ビジネスとしては成功しない。</p>
本書にはいろいろな失敗の形が出てくるが、そこから得られる教訓を一言で言うと「ビジネスとして意味のあることをやろう」という話だと理解している。</p>
関係者全員がビジネスとして意味のある方向を向いていれば成功…とまでは行かずとも、想定外の分析結果が出てきた際にも軟着陸できる可能性がある。その一方で、誰かが技術的なことにしか興味を持たなかったり、自分の成果がどう使われるかを想像できなかったり、自分の発言を後から覆せなかったりすると失敗していくのだろう。また、自分の立場だけで物事を判断してしまうことも、失敗につながりやすい。</p>
本書では、受託分析のように、複数の会社が関わるケースの失敗事例が多く出てくる。会社間でのコミュニケーションがどうしても取りづらかったり、納期がかっちり決まっていたり、クライアントサイドが IT に投資していないせいでデータが不完全だったりという構造的な要因が多いのだろうと察せられる。一方、自分の経験の範囲では、事業会社内の施策でも似たような失敗事例や失敗まで行かずとも、これって本当に意味のあることやってるのか？これだけリソースを費やして得られる利益が釣り合っているのか？と首を捻りたくなる事例は少なくない。</p>
ここ数年で一気に高性能な学習済みモデルが使えるようになり、自然言語処理や画像処理は自分でモデルを作る方が今や少数派である。だからこそ、ML エンジニアやデータサイエンティストも、単に技術に詳しいだけではなく、それをどうビジネスとして意味のあるものにするかを考えなければならない時代になっている。</p>
結局のところ、ビジネスとして役に立っているか・ユーザーの課題を解決できているか・会社の利益につながっているか、そういう観点を持ち続けることが重要で、この時代に改めて読むととても身につまされる本である。</p>


ベースライン的なレコメンドモデルを作るのに RecTools が便利そう
2025-08-31T00:00:00+00:00
レコメンド用のツールについて</h2>
レコメンド界隈はみんなが使っている定番のライブラリというものがないように思う。例えば、自然言語処理では（色々と文句を言われることもあるが）Hugging Face が標準的に使われるようになっている。それに比べると、レコメンドはとりあえずこれ使っておけ、と言えるものが思い浮かばない。</p>
ロジック/モデル部分中心のものであれば implicit</a> や RecBole</a> などポピュラーなライブラリはいくつかあるが、それに与えるデータの前処理とか結果のオフライン評価に関しては、それぞれの現場で固有のツールやライブラリが作られがちな気がしている。</p>
大規模サービスを運営していて KPI を0.1%でも向上させることに意味があるようなテック企業を除けば、一般的な協調フィルタリングや評価指標を実装すればまずは十分だろうし、そうなると中核となるデータの処理方法も概ね共通してくる。</p>
その割にはその辺まで含めたレコメンドシステムの構築を一通りカバーしているライブラリってないなと思っていたのだけど、最近知った RecTools はこの領域で有用なライブラリなのではないかと思ったので触ってみた。1</a></sup></p>



  



  



  



  
    
      
      MobileTeleSystems/RecTools</div>
      
      RecTools - library to build Recommendation Systems easier and faster than ever before</div>
      
      
      Python</div>
      
    </div>
  </a>
</div>
RecTools について</h2>
RecTools はロシアでクラウドサービスを提供している MWS という会社が開発している OSS である。ドキュメントには</p>

RecTools is an easy-to-use Python library which makes the process of building recommendation systems easier, faster and more structured than ever before. The aim is to collect ready-to-use solutions and best practices in one place to make processes of creating your first MVP and deploying model to production as fast and easy as possible.</p>
</blockquote>
と書かれており、レコメンドシステムを構築するプロセス全体をカバーするようなライブラリとして作成されているのがわかる。</p>
RecTools での学習・推論・評価パイプラインは以下のようになる。</p>
import</span> pandas</span> as</span> pd</span></span>
</span>
from</span> rectools</span> import</span> Columns</span></span>
from</span> rectools</span>.</span>dataset</span> import</span> Dataset</span></span>
from</span> rectools</span>.</span>models</span> import</span> SASRecModel</span></span>
from</span> rectools</span>.</span>metrics</span> import</span> NDCG</span>,</span> Recall</span>,</span> Serendipity</span>,</span> calc_metrics</span></span>
from</span> rectools</span>.</span>models</span> import</span> load_model</span></span>
</span>
#</span> Interaction データの用意</span></span>
#</span> カラムが (user_id, item_id, weight, datetime) となる pandas dataframe を渡す</span></span>
dataset</span> =</span> Dataset</span>.</span>construct</span>(</span>interaction</span>)</span></span>
</span>
#</span> 学習</span></span>
model</span> =</span> SASRecModel</span>(</span>...</span>)</span></span>
model</span>.</span>fit</span>(</span>dataset</span>)</span></span>
model</span>.</span>save</span>(</span>"</span>model.pkl</span>"</span>)</span></span>
</span>
#</span> 推論</span></span>
model</span> =</span> load_model</span>(</span>"</span>model.pkl</span>"</span>)</span></span>
recommendations</span> =</span> model</span>.</span>recommend</span>(</span></span>
    users</span>=</span>interaction</span>[</span>Columns</span>.</span>User</span>]</span>.</span>unique</span>(</span>)</span>,</span></span>
    dataset</span>=</span>dataset</span>,</span></span>
    k</span>=</span>10</span>,</span></span>
    filter_viewed</span>=</span>True</span>,</span></span>
)</span></span>
</span>
#</span> 評価</span></span>
metrics</span> =</span> {</span></span>
    "</span>NDCG@10</span>"</span>:</span> NDCG</span>(</span>k</span>=</span>10</span>,</span> divide_by_achievable</span>=</span>True</span>)</span>,</span></span>
    "</span>Recall@10</span>"</span>:</span> Recall</span>(</span>k</span>=</span>10</span>)</span>,</span></span>
    "</span>Serendipity@10</span>"</span>:</span> Serendipity</span>(</span>k</span>=</span>10</span>)</span>,</span></span>
}</span></span>
</span>
metric_values</span> =</span> calc_metrics</span>(</span></span>
    metrics</span>,</span></span>
    reco</span>=</span>recommendations</span>,</span></span>
    interactions</span>=</span>interactions_test</span>,</span> #</span> 評価データ (pandas dataframe)</span></span>
    catalog</span>=</span>interaction</span>[</span>Columns</span>.</span>Item</span>]</span>.</span>unique</span>(</span>)</span>,</span></span>
)</span></span></code></pre>
学習には (user, item) の interaction データセットを pandas データフレームとして用意する。一部のモデルではさらに追加で特徴量を与えることもできる。</p>
推薦モデルを作るときは生のユーザー・アイテム ID（外部 ID）を、0から始まる整数の ID（内部 ID）に変換する処理をよく実行するが、そのようなよくある前処理は全て Dataset</code> クラスが受け持ってくれるため自分で実装する必要がない。</p>
また使えるモデルも ItemkNN など基本のものから、implicit や LightFM などの定番ライブラリのラッパー、SASRec や BERT4Rec などのニューラル系列推薦モデルまで基本的なものは一通り揃っており、またそれらが共通のインターフェースで使える。BPR など単純な (user, item) interaction を学習するモデルにも、系列推薦をするモデルにも同じ形式のデータセットを与えれば学習・推論・評価ができるのは便利である。</p>
評価指標についても基本の Recall@K や NDCG@K から、serendipity などの beyond accuracy 指標、さらにバイアス除去系のオプションまで揃っているので困ることはなさそうである。</p>
RecTools で実務でやるような学習・推論パイプラインが組めるか？</h2>
概要は上に紹介したので、ここからは実際に実務でモデルを作るのに必要な機能があるか調べていこうと思う。</p>
データ分割</h3>
実務でのレコメンドでは、系列推薦モデルを使っていなくても、train/test のデータ分割を時系列で行うことは多い。サービスで使う以上モデルに持たせたい能力は未来予測だからだ。RecTools では interaction データの最後の N 個を評価用に分割するための LastNSplitter</code>、決まった時間幅のデータを評価用に分割するための TimeRangeSplitter</code> が用意されており、時系列に沿った分割が簡単にできる。</p>
以下はユーザーごとに行動を時系列で並べ、最後の一個を評価用に、それ以前を学習用に分割する例である</p>
from</span> rectools</span>.</span>dataset</span> import</span> Dataset</span></span>
from</span> rectools</span>.</span>model_selection</span> import</span> LastNSplitter</span></span>
</span>
ds</span> =</span> Dataset</span>.</span>construct</span>(</span>df</span>)</span> #</span> pandas -> `Dataset`</span></span>
</span>
splitter</span> =</span> LastNSplitter</span>(</span></span>
    n</span>=</span>1</span>,</span>  #</span> leave-last-one-out</span></span>
    n_splits</span>=</span>1</span>,</span>  #</span> train/test</span></span>
    filter_cold_items</span>=</span>False</span>,</span></span>
    filter_cold_users</span>=</span>False</span>,</span></span>
    filter_already_seen</span>=</span>True</span>,</span></span>
)</span></span>
</span>
iterator</span> =</span> splitter</span>.</span>split</span>(</span>ds</span>.</span>interactions</span>)</span></span>
train_idx</span>,</span> test_idx</span>,</span> _</span> =</span> next</span>(</span>iterator</span>)</span></span>
</span>
ds_train</span> =</span> ds</span>.</span>filter_interactions</span>(</span>train_idx</span>)</span></span>
ds_test</span> =</span> ds</span>.</span>filter_interactions</span>(</span>test_idx</span>)</span></span></code></pre>
n_splits</code> を増やすことで cross validation 用に複数 fold を生成できる。</p>
カスタム Trainer の利用</h3>
ニューラルネットワーク系のモデルは内部的には pytorch と pytorch lightning で実装されている。何も指定しなくても内部でデフォルトの Trainer インスタンスを生成してくれるが、学習の制御のためカスタマイズしたいことは多い。そのような場合は、モデルのコンストラクタに Trainer を返す関数を与える。</p>
SASRec モデルを例とすると以下のように書ける</p>
from</span> rectools</span>.</span>models</span> import</span> SASRecModel</span></span>
from</span> pytorch_lightning</span> import</span> Trainer</span></span>
</span>
def</span> get_trainer</span>(</span>checkpoint_dir</span>:</span> str</span>)</span> -></span> Trainer</span>:</span></span>
    ...</span></span>
</span>
model</span> =</span> SASRecModel</span>(</span></span>
    get_trainer_func</span>=</span>get_trainer</span>,</span></span>
    get_trainer_func_kwargs</span>=</span>{</span>"</span>checkpoint_dir</span>"</span>:</span> checkpoint_dir</span>}</span>,</span></span>
)</span></span></code></pre>
get_trainer</code> の引数は別途 get_trainer_func_kwargs</code> で渡す必要がある。</p>
Early stopping やチェックポイント</h3>
これもニューラルネットワーク系のモデルの場合だが、学習時に validation セットにおけるメトリクスを監視して early stopping をしたり、途中経過をチェックポイントとして残したいことは多い。</p>
その場合、ドキュメントの Transformer Models Advanced Training Guide</a> にあるように、まずは毎エポック validation メトリクスを計算する callback を実装する必要がある。</p>

  Validation メトリクスを計算する callback</span></summary>
  from</span> pytorch_lightning</span>.</span>callbacks</span> import</span> Callback</span></span>
</span>
class</span> ValidationMetrics</span>(</span>Callback</span>)</span>:</span></span>
    def</span> __init__</span>(</span>self</span>,</span> top_k</span>:</span> int</span>,</span> val_metrics</span>:</span> dict</span>,</span> verbose</span>:</span> int</span> =</span> 0</span>)</span> -></span> None</span>:</span></span>
        self</span>.</span>top_k</span> =</span> top_k</span></span>
        self</span>.</span>val_metrics</span> =</span> val_metrics</span></span>
        self</span>.</span>verbose</span> =</span> verbose</span></span>
</span>
        self</span>.</span>epoch_n_users</span>:</span> int</span> =</span> 0</span></span>
        self</span>.</span>batch_metrics</span>:</span> list</span>[</span>dict</span>[</span>str</span>,</span> float</span>]</span>]</span> =</span> [</span>]</span></span>
</span>
    def</span> on_validation_batch_end</span>(</span></span>
        self</span>,</span></span>
        trainer</span>:</span> Trainer</span>,</span></span>
        pl_module</span>:</span> LightningModule</span>,</span></span>
        outputs</span>:</span> dict</span>[</span>str</span>,</span> torch</span>.</span>Tensor</span>]</span>,</span></span>
        batch</span>:</span> dict</span>[</span>str</span>,</span> torch</span>.</span>Tensor</span>]</span>,</span></span>
        batch_idx</span>:</span> int</span>,</span></span>
        dataloader_idx</span>:</span> int</span> =</span> 0</span>,</span></span>
    )</span> -></span> None</span>:</span></span>
        logits</span> =</span> outputs</span>[</span>"</span>logits</span>"</span>]</span></span>
        if</span> logits</span> is</span> None</span>:</span></span>
            logits</span> =</span> pl_module</span>.</span>torch_model</span>.</span>encode_sessions</span>(</span>batch</span>,</span> pl_module</span>.</span>item_embs</span>)</span>[</span></span>
                :</span>,</span> -</span>1</span>,</span> :</span></span>
            ]</span></span>
        _</span>,</span> sorted_batch_recos</span> =</span> logits</span>.</span>topk</span>(</span>k</span>=</span>self</span>.</span>top_k</span>)</span></span>
</span>
        batch_recos</span> =</span> sorted_batch_recos</span>.</span>tolist</span>(</span>)</span></span>
        targets</span> =</span> batch</span>[</span>"</span>y</span>"</span>]</span>.</span>tolist</span>(</span>)</span></span>
</span>
        batch_val_users</span> =</span> list</span>(</span></span>
            itertools</span>.</span>chain</span>.</span>from_iterable</span>(</span></span>
                itertools</span>.</span>repeat</span>(</span>idx</span>,</span> len</span>(</span>recos</span>)</span>)</span></span>
                for</span> idx</span>,</span> recos</span> in</span> enumerate</span>(</span>batch_recos</span>)</span></span>
            )</span></span>
        )</span></span>
</span>
        batch_target_users</span> =</span> list</span>(</span></span>
            itertools</span>.</span>chain</span>.</span>from_iterable</span>(</span></span>
                itertools</span>.</span>repeat</span>(</span>idx</span>,</span> len</span>(</span>targets</span>)</span>)</span></span>
                for</span> idx</span>,</span> targets</span> in</span> enumerate</span>(</span>targets</span>)</span></span>
            )</span></span>
        )</span></span>
</span>
        batch_recos_df</span> =</span> pd</span>.</span>DataFrame</span>(</span></span>
            {</span></span>
                Columns</span>.</span>User</span>:</span> batch_val_users</span>,</span></span>
                Columns</span>.</span>Item</span>:</span> list</span>(</span>itertools</span>.</span>chain</span>.</span>from_iterable</span>(</span>batch_recos</span>)</span>)</span>,</span></span>
            }</span></span>
        )</span></span>
        batch_recos_df</span>[</span>Columns</span>.</span>Rank</span>]</span> =</span> (</span></span>
            batch_recos_df</span>.</span>groupby</span>(</span>Columns</span>.</span>User</span>,</span> sort</span>=</span>False</span>)</span>.</span>cumcount</span>(</span>)</span> +</span> 1</span></span>
        )</span></span>
</span>
        interactions</span> =</span> pd</span>.</span>DataFrame</span>(</span></span>
            {</span></span>
                Columns</span>.</span>User</span>:</span> batch_target_users</span>,</span></span>
                Columns</span>.</span>Item</span>:</span> list</span>(</span>itertools</span>.</span>chain</span>.</span>from_iterable</span>(</span>targets</span>)</span>)</span>,</span></span>
            }</span></span>
        )</span></span>
</span>
        prev_interactions</span> =</span> pl_module</span>.</span>data_preparator</span>.</span>train_dataset</span>.</span>interactions</span>.</span>df</span></span>
        catalog</span> =</span> prev_interactions</span>[</span>Columns</span>.</span>Item</span>]</span>.</span>unique</span>(</span>)</span></span>
</span>
        batch_metrics</span> =</span> calc_metrics</span>(</span></span>
            self</span>.</span>val_metrics</span>,</span> batch_recos_df</span>,</span> interactions</span>,</span> prev_interactions</span>,</span> catalog</span></span>
        )</span></span>
</span>
        batch_n_users</span> =</span> batch</span>[</span>"</span>x</span>"</span>]</span>.</span>shape</span>[</span>0</span>]</span></span>
        self</span>.</span>batch_metrics</span>.</span>append</span>(</span></span>
            {</span>metric</span>:</span> value</span> *</span> batch_n_users</span> for</span> metric</span>,</span> value</span> in</span> batch_metrics</span>.</span>items</span>(</span>)</span>}</span></span>
        )</span></span>
        self</span>.</span>epoch_n_users</span> +=</span> batch_n_users</span></span>
</span>
    def</span> on_validation_epoch_end</span>(</span></span>
        self</span>,</span> trainer</span>:</span> Trainer</span>,</span> pl_module</span>:</span> LightningModule</span></span>
    )</span> -></span> None</span>:</span></span>
        epoch_metrics</span> =</span> dict</span>(</span>sum</span>(</span>map</span>(</span>Counter</span>,</span> self</span>.</span>batch_metrics</span>)</span>,</span> Counter</span>(</span>)</span>)</span>)</span></span>
        epoch_metrics</span> =</span> {</span></span>
            metric</span>:</span> value</span> /</span> self</span>.</span>epoch_n_users</span></span>
            for</span> metric</span>,</span> value</span> in</span> epoch_metrics</span>.</span>items</span>(</span>)</span></span>
        }</span></span>
</span>
        self</span>.</span>log_dict</span>(</span></span>
            epoch_metrics</span>,</span> on_step</span>=</span>False</span>,</span> on_epoch</span>=</span>True</span>,</span> prog_bar</span>=</span>self</span>.</span>verbose</span> ></span> 0</span></span>
        )</span></span>
</span>
        self</span>.</span>batch_metrics</span>.</span>clear</span>(</span>)</span></span>
        self</span>.</span>epoch_n_users</span> =</span> 0</span></span></code></pre>
</details>
そしてこの callback を上の方法で Trainer に設定する</p>
from</span> pytorch_lightning</span>.</span>callbacks</span> import</span> EarlyStopping</span>,</span> ModelCheckpoint</span></span>
from</span> rectools</span>.</span>metrics</span> import</span> NDCG</span></span>
from</span> pytorch_lightning</span> import</span> Trainer</span></span>
</span>
def</span> get_trainer</span>(</span>checkpoint_dir</span>:</span> str</span>)</span> -></span> Trainer</span>:</span></span>
    metrics</span> =</span> {</span>"</span>val_NDCG@10</span>"</span>:</span> NDCG</span>(</span>k</span>=</span>10</span>,</span> divide_by_achievable</span>=</span>True</span>)</span>}</span></span>
</span>
    val_metrics_callback</span> =</span> ValidationMetrics</span>(</span></span>
        top_k</span>=</span>10</span>,</span> val_metrics</span>=</span>metrics</span>,</span> verbose</span>=</span>1</span></span>
    )</span></span>
</span>
    best_ndcg_ckpt</span> =</span> ModelCheckpoint</span>(</span></span>
        dirpath</span>=</span>checkpoint_dir</span>,</span></span>
        monitor</span>=</span>"</span>val_NDCG@10</span>"</span>,</span></span>
        mode</span>=</span>"</span>max</span>"</span>,</span></span>
        filename</span>=</span>"</span>{epoch}</span>-</span>{val_NDCG@10:.4f}</span>"</span>,</span></span>
    )</span></span>
</span>
    early_stopping_callback</span> =</span> EarlyStopping</span>(</span></span>
        monitor</span>=</span>"</span>val_NDCG@10</span>"</span>,</span></span>
        mode</span>=</span>"</span>max</span>"</span>,</span></span>
    )</span></span>
</span>
    return</span> Trainer</span>(</span></span>
        enable_checkpointing</span>=</span>True</span>,</span></span>
        callbacks</span>=</span>[</span>val_metrics_callback</span>,</span> early_stopping_callback</span>,</span> best_ndcg_ckpt</span>]</span>,</span></span>
        ...</span></span>
    )</span></span></code></pre>
また validation 用のデータを作るため学習データをさらに分割する必要があるが、これは LastNSplitter</code> などを使わず、学習データのうちどこが validation かを表すマスクを渡すことが想定されているようである。以下は学習データのなかで各ユーザーごとに最後のアイテムを validation として使う例。</p>
from</span> rectools</span> import</span> Columns</span></span>
</span>
def</span> get_val_mask_func</span>(</span>interactions</span>:</span> pd</span>.</span>DataFrame</span>)</span> -></span> np</span>.</span>ndarray</span>:</span></span>
    rank</span> =</span> (</span></span>
        interactions</span>.</span>sort_values</span>(</span>Columns</span>.</span>Datetime</span>,</span> ascending</span>=</span>False</span>,</span> kind</span>=</span>"</span>stable</span>"</span>)</span></span>
        .</span>groupby</span>(</span>Columns</span>.</span>User</span>,</span> sort</span>=</span>False</span>)</span></span>
        .</span>cumcount</span>(</span>)</span></span>
    )</span></span>
    val_mask</span> =</span> rank</span> ==</span> 0</span></span>
    return</span> val_mask</span>.</span>values</span></span>
</span>
model</span> =</span> SASRecModel</span>(</span></span>
    get_val_mask_func</span>=</span>get_val_mask_func</span>,</span></span>
    ...</span></span>
)</span></span></code></pre>
以上の準備をして model.fit(ds_train)</code> をすれば、指定したメトリクスに基づいた early stopping が実行され、その過程のチェックポイントを残すことができる。</p>
RecTools が向いていないこと</h2>
以上見てきたようにベースライン的なモデルであればそれなりの柔軟性を持ちつつ簡単に学習から評価まで回せそうである。一つ難点を挙げるとすれば、基本的にデータセットを pandas のデータフレームとして扱うため、一度にメモリに乗り切らないような大規模データを扱うことは向いていない。あくまで小〜中規模のデータセットに対してサクッとベースライン性能を持つレコメンドシステムを作るためのツールだと思うのが良さそうである。</p>

^1</sup>Bluesky で Aki Ariga さん</a>がコントリビュートしているのを見たことで知った。</p>
</div>


Claude Code で RSS/Atom フィードリーダーを作ってみた感想
2025-07-05T00:00:00+00:00
最近世の中の人々が熱狂している Claude Code で自分も遊んでみようと思い、とりあえずネタとして RSS/Atom のフィードリーダーを作らせてみたので感想を書く。</p>
作ったもの</h2>

</p>

RSS/Atom フィードの購読をするための Web アプリを作った

自分は普段 RSS で技術的な情報収集や趣味の合う人のフォローをしているが、既存のツールではなく自分用にチューニングされたものを作ってみたかった</li>
自分でコードはほぼ書かず Claude Code に指示をするだけという純正の vibe coding をした</li>
Pro プランで利用したため、2,3時間使うと制限がかかり元に戻るのに数時間かかった</li>
休日や平日の夜に少しずつ作り、一週間くらいかけて概ねクラウドの VM 上でまともに動くものができた</li>
</ul>
</li>
作った機能は

フィードをフォローし、新着記事の取得と既読管理を行う機能</li>
AI による要約を自動生成する機能</li>
記事をベクトル化し semantic search できる機能。また検索結果の AI による要約機能

これはまだ全然作りこめていなくてあまり良い結果が返ってこない</li>
</ul>
</li>
</ul>
</li>
</ul>
技術的な中身</h2>

Next.js でフロントエンドを、FastAPI でバックエンドを作成</li>
DB には PostgreSQL を、バックグラウンドタスクには Celery を使い、メッセージ broker には redis を採用</li>
PostgreSQL は pgvector</a> を使いベクトル検索ができるようにしている</li>
個人用の小規模なアプリケーションでスケーラビリティとか高可用性とかそういうものは要らないので、全て docker compose で起動して、一つの VM 上で動かしている</li>
</ul>
作ってみた感想</h2>
Claude Code のすごいところ</h3>

概ね期待した通りに動作するアプリケーションが爆速でできる。色々とすごいところはあるがここに尽きる</li>
RDB 周りの設計など、古典的な技術は強く、一発でそれなりのものが出てくる</li>
フロントエンドも曖昧な指示をちゃんと良い感じの UI に変換してくれる

フロントエンドの知識が皆無なので、今まで一人でこの手のアプリケーションを作ることができなかったが、Calude Code によってハードルがぐっと下がった</li>
</ul>
</li>
Claude Code が自分で docker compose up -d</code> をしてログを見て自力で修正するというのが結構上手くまわる</li>
作り直しが容易

最初はあまり深いことを考えずローカルで sqlite で DB を作って、ベクトル検索は適当に duckdb を使い、ある程度固まったら Cloud Run で動かしていた。しかし、DB のファイルを GCS に置いて fuse マウントしていたため write で不整合が出たりして使い物にならなかったのでやめた</li>
そのタイミングで一から設計を練り直すという指示を出し、とりあえず VM 一個で作れる安い構成ということで上記を採用した</li>
自分でコードを書いていないから捨てやすいし、新しい構成で書く時もなんとなく動くまでが早いので助かる</li>
</ul>
</li>
</ul>
Claude Code の微妙なところ</h3>

基本的にコード品質が低い

設計が雑で、DB や外部 API に接続するクライアントをいたるところで生で触っている。Repository クラスなどに包んで抽象化してくれと頼むとその場ではやってくれるがすぐに忘れてしまう。

まあ AI しか読まないならこれでも良いのかもしれない</li>
</ul>
</li>
FastAPI で同期と非同期が無秩序に混在する API を書いていた</li>
ロジックの内部の深いところですぐに例外を握りつぶしてくる</li>
ログメッセージが過度に装飾的（✅のような絵文字が大量に入ってくる）</li>
</ul>
</li>
クラウド環境にデプロイするのは詰まりがちだった

IAM の権限に原因があるのに一向に辿り着けていなかったり</li>
</ul>
</li>
フロントエンドのバグ修正はブラウザの操作が必要なので結構難航する

これは TIL: Using Playwright MCP with Claude Code</a> のように、MCP を上手く使えば解決する問題かもしれない</li>
</ul>
</li>
</ul>
まとめ</h2>
Claude Code は趣味で何か便利なものを作ったり、業務でもチーム内だけで触る程度のデモアプリを作るのにはかなり役立ちそう。普段仕事ではバックエンドしか触らず知識もそこに偏っているので、ちゃんとブラウザで動くものを自分一人で作れるようになるというのは体験として印象的。</p>
技術の進歩で、楽器を買ってメンバーを集めてスタジオで録音して CD に焼いたりすることなく音楽が発表できるようになったのと同じように、個人開発者の創造性を高めるツールだと思う。</p>
しかし、長くメンテしていくようなコードベースを一から書かせるということにはまだ使えない。この辺りはモデルの進歩を待つとともに、 CLAUDE.md</code> で指示を作り込んだり、MCP サーバーとうまく連携させたりしていくことが必要そう。</p>
多少の開発の知識があれば自分専用のアプリを簡単に作れる時代になってきているなぁと思う。人々が紹介している tips を取り入れてもっと遊んでみたい。</p>


SageMaker Training にジョブを投げる君を作った
2025-06-01T00:00:00+00:00
プライベートで機械学習実験をする際、特に一時的に大量のメモリや GPU が必要な場合、皆さんはどんな環境を使っているだろうか？Google colaboratory や Kaggle のような構築済みのノートブック環境を使う人もいれば、AWS・Google Cloud や RunPod のような何らかのクラウド環境にインスタンスを自前で立てている人もいるだろう。リッチな人は自宅に GPU の乗った強いマシンを持っているかもしれない。</p>
自分は最近そのような用途に AWS の SageMaker Training</a> が便利だなと思っている。</p>
SageMaker Training は機械学習の実験ジョブを AWS 上で実行するサービスである。ただし実態としては、指定したコンテナ上で任意の Python スクリプトを実行できるサービスと言うのが正しい。起動するインスタンスの種類や動かすコンテナイメージを指定し、実験スクリプトをアップロードすると、SageMaker が自動でインスタンスを立て、そこにスクリプトをダウンロードして実行する。成果物は S3 などの外部ストレージに保存してくれる。終了後はインスタンスを勝手に落としてくれるので、消し忘れで高額請求が来るような心配はない。AWS なので RunPod などに比べると GPU は高いが、一応スポットインスタンスも使えるので安めに済ませることもできる。</p>
コンテナをバッチ的に実行してくれるサービスであれば、AWS Batch や Vertex Pipelines など色々な選択肢がある。その中でも SageMaker Training が使いやすいのは以下の点にあると思う</p>

コンテナイメージの指定と Python ライブラリの指定を分離できる。実験スクリプトと一緒に requirements.txt</code> を入れておくと、SageMaker がコンテナを起動した後に自動で必要なライブラリをインストールしてくれる。ライブラリを追加・変更するたびに、docker build して push するというようなことをしなくて良い。</li>
同様なことは Vertex AI のカスタムトレーニングでもできる</a>が、以前試した感じだとこちらは使えるイメージに縛りがあったりして思ったほど柔軟ではなかった。SageMaker Training は SDK が入ったイメージであれば基本何でも良いので便利。</li>
必要なクラウドリソースは AWS 上の S3 バケットと SageMaker の実行ロールくらいなので準備が簡単。例えば AWS Batch は事前に ECS クラスタ（コンピューティング環境）を作る必要があり、その辺の適切な IAM ロールを準備するのが結構面倒。</li>
</ul>
欠点はドキュメントがわかりづらく、入出力データのパスの渡し方などの独特の convention に慣れるのに時間がかかること。この点に関しては以下の資料が参考になった。</p>
Amazon SageMaker Training (座学編) - 機械学習のモデル開発の試行錯誤を簡単にする</a></p>
SageMaker Training を使う際は基本的には Python SDK を経由するのが便利。そこで最近は SDK をラップしたシンプルな CLI を作ってジョブを投げている。</p>



  



  



  



  
    
      
      yng87/smt</div>
      
      SageMaker Training のジョブ投入を簡単にするためのシンプルな CLI ラッパー。</div>
      
      
      Python</div>
      
    </div>
  </a>
</div>
開発のワークフローとしては以下のような感じになる</p>

SageMaker Training に必要なリソース（S3 バケット・IAM ロール・Docker イメージ）を準備する。</li>
ローカルで実験スクリプトを開発する。小規模なデータセットを用いてローカルで動作確認をする。依存管理には uv</code> を使う。</li>
使用するライブラリに変更があった場合は、uv export -o requirements.txt --no-hashes</code> で requirements.txt</code> を作る。</li>
上記 CLI smt</code> を実行する。するとカレントディレクトリが tar.gz</code> が固められて S3 にアップロードされ、 SageMaker Training のジョブがキックされる。</li>
</ol>
ローカルで開発したスクリプトをそのままリモートのコンテナ環境で実行できるので結構便利な仕組みだと思っている。</p>


なぜ機械学習システムの評価をするのか/評価駆動開発について
2025-05-02T00:00:00+00:00
はじめに</h2>
ここ最近フォローしている人々が機械学習、特に LLM を使ったシステム開発における評価について話しているのでまとめておきたいと思う。主に参考にしたのは以下の記事やブログ：</p>

The Batch Issue 297</a></li>
An LLM‑as‑Judge Won't Save The Product—Fixing Your Process Will | eugeneyan</a></li>
AI Engineering | Chip Huyen</a></li>
</ul>
ここで「評価」という言葉で指すのはオフラインにおける自動化された評価であって、人間の専門家によるアノテーションや、オンライン A/B テストのような実行コストが高いもののことではないということをはじめに断っておく。</p>
なぜ評価が必要か</h2>
上に挙げた記事はどれも皆、自動評価は機械学習を使ったアプリケーションを開発する際のイテレーションを高速化するための手段だと言っている。あらかじめ開発フローに評価を組み込んでおき、評価値の良し悪しを見て試行錯誤を繰り返して高速にシステムを改善していくわけである。このやり方を最近は評価駆動開発と呼んだりもしている。</p>
評価駆動開発は言葉としては新しいものの、実務で機械学習を使ったサービス開発に携わってきた人にとっては身近な考え方だと思う。例えば、推薦システムや検索システムでは出力例を人間がいくつか見たところで1</a></sup> 良し悪しを判断するのは難しいので、何らかのオフライン評価指標を設定してそれを最適化するように試行錯誤したのち、AB テストなどでユーザーからのフィードバックを得るのが一般的である。</p>
また、個人的には自動評価はシステムのメンテナンス性のためにも重要だと思っている。担当者が離れた後で、なんのオフライン評価もされていない機械学習システムが残っていると、そこで使われているモデルを変更するコストが跳ね上がる。特に LLM を使っている場合は発展のスピードが速いので、変更容易性を担保するのはより重要である。</p>
評価は何ではないか</h2>
最近は LLM-as-judge という手法も広まっており、これまでは難しかった観点に関してもある程度評価値を算出することができるようになっている。しかし、現在の LLM の性能で人間の介入を排した完全な自動評価を実現できると考えている人は少ないように見える。</p>
またシステムによる自動評価はあくまで相対評価として役立つものであって、システムの性能の絶対的なレベルを測定するものだと捉えることは少ないように思う。この点については Andrew Ngが以下のように述べている</a>。</p>

To me, a successful eval meets the following criteria. Say, we currently have system A, and we might tweak it to get a system B:</p>

If A works significantly better than B according to a skilled human judge, the eval should give A a significantly higher score than B.</li>
If A and B have similar performance, their eval scores should be similar.</li>
</ul>
</blockquote>
オフライン評価はあくまで開発高速化のための安価な proxy なので、真の良し悪しとの大雑把な順序相関があれば十分ということである。2</a></sup></p>
この辺の評価に対する態度は分野によっても異なっていて、特にバイアスのないデータセットを集めるのが難しい推薦や検索のような分野では、モデルの学習が期待通り進んだかどうかというヘルスチェック程度にしか扱われないこともある。3</a></sup></p>
評価をどのように開発サイクルに組み込むか</h2>
冒頭の記事では、評価の構築それ自体も iterative な process であり、人手による評価を時々挟むことで、自動評価と人手の評価の相関をより良くするように継続的に改善していくことが必要だと述べられている。本当のゴールはユーザーにとって良いものを作ることであり、自動評価はあくまでそのためのツールなので、真のゴールを達成できるように指標やデータセットを調整していくということである。この点は実務と機械学習コンペの大きな違いだと思う。</p>
また、システムの failure mode を把握することも重要である。無闇にトップダウンで指標を設定するのではなく、実際のシステムの挙動やユーザーからのフィードバックなどのデータを見て失敗箇所を把握し、それを定量化するために評価を導入するのが良い。特定の課題を念頭に置かずシステムを包括的に評価してくれるような銀の弾丸はない。</p>
最後に</h2>
AI Engineering</a> は評価駆動開発をかなり推しているが、その一方で、評価しやすい指標にばかり目を向けると真に革新的なアイデアを見落とすという、街頭効果</a>に警鐘を鳴らしてもいる。ゲームチェンジャーとなるようなアイディアは容易に評価できないかもしれないので、評価一辺倒になりすぎないようにもすべきである。</p>

^{1</sup>
最近はこういうやり方を vibe check と呼ぶらしい。</p>
</div>}^2</sup>同様の議論は評価指標入門</a>という本にも載っている。</p>
</div>
^3</sup>評価指標入門</a>で取り上げられている Booking.com の事例。</p>
</div>


テーブルデータの前処理を何でやるか
2025-02-17T00:00:00+00:00
最近読んだ、The Rise of Single-Node Processing: Challenging the Distributed-First Mindset</a> という記事に最近考えていたことが書いてあったので便乗して自分の考えを書き留めておく。</p>
元記事ではかつては大規模なデータの処理というと何はともあれ分散システムであり、Spark や BigQuery などを導入するのが当然であったが、近年は DuckDB</a> や Polars</a> などシングルノードでも高速にテーブルデータを処理できる技術が登場してきたことで必ずしも分散システムは必要ではないよねという風潮に変わってきた、ということが述べられている。コスト面でもクラウドを使うのであれば、小さいインスタンスをいくつも立てて分散処理するのと、合計して同程度の vCPU や RAM を持つ一つの大きなインスタンスを立てて処理するのとで料金が劇的に変わるわけではないため、オーバーヘッドの少ないシングルノードを選択するのが理にかなっているとのこと。</p>
もちろんそもそもシングルノードには絶対に乗らないような規模のデータを扱う組織もあるとは思うが、何年か前に Big Data is Dead</a> という BigQuery の開発者の記事で指摘されていたように、実はそういう組織はそこまで多くない。大規模データを持っている企業が限られるし、持っていたとしても大抵の分析案件は直近データだけクエリすれば十分なことが多いからだ。</p>
以上の話はおおむね分析やそのためのデータマート構築の視点で書かれていると思うが、機械学習モデルを作る際のテーブルデータの前処理についても同様のことが当てはまると思っている。</p>
自分がこの業界に入り最初に入社した会社では、BigQuery 上に DWH が構築されており、データサイエンティストは SQL を書いてモデルの学習に必要なデータを抽出していた。BigQuery の真っ当なユースケースとしては上に述べたような分析・データマート構築というところになると思うが、その強力なスケーラビリティから機械学習モデリングのワークフローに組み込まれ、生ログの整形・ラベリング・計算された特徴量の GCS への出力まで担う場面も（自分の観測してきた範囲では）非常に多い。当時所属していたチームでも、テーブルデータの前処理は BigQuery でやるのがベストプラクティスとされていた。</p>
今の会社に移ってからも当初はそのようなやり方でテーブルデータを扱っていたのだが、主に以下の二点が理由で最近は BigQuery でデータを処理しすぎないほうが良いと感じる場面が増えてきた</p>

Polars のように、シングルノードでも大規模なデータを簡単に高速に処理できるライブラリが登場した</li>
ソフトウェアエンジニアリングの経験を積んだことで、コードや ML パイプラインの品質をより重視するようになった</li>
</ol>
一点目に関しては数年前から散々話題になっていると思うが、やはり Polars が性能面で非常に優れていて、適当にクエリを書いて Pandas の 1/10 くらいの時間で処理できるのだからもう Pandas には戻れない。また Pandas の API は歴史的な経緯で荒れ果てていると個人的に思っているが、Polars は新興のライブラリのこともあってその辺は綺麗に保たれていると感じる。</p>
二点目については、SQL で凝った処理を書くととても見通しが悪いし、処理を小さな関数に分けて使い回せないし、何よりユニットテストを気軽に書くということが難しい。大体は SQL をコンソールに貼って実行して結果を目で確認して意図通りっぽいかということを調べていくことになる。過去の現場でテストの書かれていない複雑なデータセット生成用 SQL をいくつも見てきて非常に辛い思いをしたが、当時はそれは仕方のないことだと思っていたし、自分もそのような SQL をいくつも生成してしまっていた。ユニットテストを書くのは大事だ。機械学習の実験フェーズにおいてもデータパイプラインに最低限のテストを書いておくと早めにバグやリークを潰せるし、本番移行のためにリファクタリングをするぞとなったときもひとまずそのテストを信頼して移植することが出来る。</p>
以上の点を踏まえての個人的なベストプラクティスとしては、</p>

DWH に SQL でクエリする際にはあまり複雑なロジックを入れず、where</code> で指定できるフィルタや、ちょっとしたメタデータの join に留める</li>
集約特徴量などの複雑になりがちな計算は Polars で書いてユニットテストをちゃんとつける</li>
シングルノードでの処理がメモリや実行時間的に厳しい場合は上の縛りを緩める</li>
</ul>
という感じだ。</p>
それから話の前提として、チームにはメモリや CPU を柔軟に指定できるリモートのジョブ実行環境がすでにあるとしている。たとえば AWS Batch や Google Cloud の Vertex Pipelines のようなイメージで、Polars のジョブはそこに投げる。これがない場合はそもそも実験の試行錯誤がスケールしないので、まずはそちらを整備したほうが良いだろう。</p>


XGBoost と LightGBM に実装されているポジションバイアス除去を試してみた
2024-08-08T00:00:00+00:00
はじめに</h2>
以前も記事にしたが</a>、ウェブ上のユーザーの行動ログを使って推薦システムを開発している自分のような ML エンジニアにとって、ランキング学習におけるポジションバイアスの除去は重要なテーマである。サービスのログは通常様々なバイアスに塗れており、特にリストの上位に表示されたアイテムほどクリックが集まりやすくなってしまうポジションバイアスは非常に厄介だ。アカデミアではこの手のテーマはだいぶ研究が進んでいるものの、これまでは論文や書籍で手法が紹介されるだけで、手軽にパッと使えるライブラリは存在しなかった。</p>
しかしどうやら最近になって XGBoost や LightGBM という多くの人が使う強力な GBDT ライブラリにポジションバイアスを除去する機能が実装されたらしく、これが使い物になるのであれば実務で利用するハードルがグッと下がると思い、実験して性能を検証してみた。</p>
検証に使うデータセット</h2>
ここではランキング学習の評価では定番である MSLR-WEB30K</a> を加工してポジションバイアスのあるクリックデータセットを作成した。具体的なポジションの付与方法や、クリックラベルの生成方法は以前書いた記事</a>と同様なのでそちらを参照してほしい。</p>
このデータセットでは、ポジションと（バイアスのない真の）relevance との交絡度合いをパラメータ $w$ によって調整している。$w=0$ であれば、ポジションの値は relevance とは関係なく決まり、$w=1$ であれば relevance によって完全に決まる（最も relevance の高いアイテムを一番上に配置する）ようになっている。そしてサービスのログとして得られるクリックは、(ユーザーにそのアイテムが表示される確率)×(ユーザーがその表示されたアイテムを気に入る確率) によって発生する。</p>
我々が本当にモデリングしたいのは、後者の「ユーザーがその表示されたアイテムを気に入る確率」であるが、クリックログからはそれを単独で切り出すことができないというのがこの問題の難しいところである。</p>
ポジションバイアス除去の実装方法</h2>
XGBoost</h3>
XGBoostでは version 2.0.0 からポジションバイアスに対処できる手法である Unbiased LambdaMART が実装された</a>。このアルゴリズム自体は以下の ByteDance の論文で提案されており、傾向スコアベースの手法になっている。論文ではこれまで提案されてきた pointwise 損失に対する IPW 法を pairwise 損失に拡張し、また傾向スコアを前もって求めるのではなく木の学習と同時に推定する手法を提案している。そして実際のサービス上で AB テストを実施して有効性を確かめたということまで書かれている。1</a></sup></p>
[1809.05818] Unbiased LambdaMART: An Unbiased Pairwise Learning-to-Rank Algorithm</a></p>
実際のコード例は XGBoostのドキュメント</a> に一応あるが非常にわかりづらい。サンプルコード内でデータセットを用意するのに使われている sort_ltr_samples</code> という関数の実装を読みに行くと、各クエリグループの中でポジションの昇順にソートしているようである。なので例えば pandas でデータセットを作成する際には以下のような感じでソートする必要がある。</p>
df_train</span> =</span> df_train</span>.</span>sort_values</span>(</span>by</span>=</span>[</span>"</span>query</span>"</span>,</span> "</span>position</span>"</span>]</span>)</span></span>
X_train</span> =</span> df_train</span>[</span>features</span>]</span></span>
y_train</span> =</span> df_train</span>[</span>'</span>click</span>'</span>]</span></span>
group_train</span> =</span> df_train</span>[</span>'</span>group</span>'</span>]</span></span></code></pre>
モデル学習時には、lambdarank_unbiased</code> で unbiased LambdaMART を使うよう指定する。また lambdarank_bias_norm</code> で傾向スコア部分に対する正則化度合いを調整できる。</p>
import</span> xgboost</span> as</span> xgb</span></span>
</span>
model</span> =</span> xgb</span>.</span>XGBRanker</span>(</span></span>
    lambdarank_unbiased</span>=</span>True</span>,</span></span>
    lambdarank_bias_norm</span>=</span>1</span>,</span></span>
)</span></span>
model</span>.</span>fit</span>(</span></span>
    X_train</span>,</span></span>
    y_train</span>,</span></span>
    qid</span>=</span>group_train</span>,</span></span>
    eval_set</span>=</span>[</span></span>
        (</span>X_train</span>,</span> y_train</span>)</span>,</span></span>
        (</span>X_val</span>,</span> y_val</span>)</span>,</span></span>
    ]</span>,</span></span>
    eval_qid</span>=</span>[</span>group_train</span>,</span> group_val</span>]</span>,</span></span>
)</span></span></code></pre>LightGBM</h3>
LightGBM でも最近ポジションバイアスに対処する機能が実装されている</a>。IPW を採用していた XGBoost とは異なり、LightGBM では一般化加法モデルベースの手法を採用している。これは学習時には $s(x, pos) = f(x) + g(pos)$ という和の形でデータをフィットし ($x$ はポジションを含まないモデルの特徴量)、ポジションの効果を $g$ に押し付けた上で推論時には $f$ だけを利用してスコアリングするという手法である。例えば以下の論文などではニューラルネットワークモデルでこのアイディアを実装して有効性を示している。</p>
[2212.13937] Towards Disentangling Relevance and Bias in Unbiased Learning to Rank</a></p>
この手法については以前も記事にした</a>のでそちらも参照してほしい。</p>
こちらもドキュメントがわかりづらいが、要はデータセットを作る際にポジションの値を array として渡せばそれでバイアス除去がオンになるようである。</p>
import</span> lightgbm</span> as</span> lgb</span></span>
</span>
ds_train</span> =</span> lgb</span>.</span>Dataset</span>(</span></span>
    X_train</span>,</span></span>
    label</span>=</span>y_train</span>,</span></span>
    group</span>=</span>group_train</span>,</span></span>
    position</span>=</span>position_train</span>,</span></span>
)</span></span>
model</span> =</span> lgb</span>.</span>train</span>(</span>model_params</span>,</span> ds_train</span>,</span>...</span>)</span></span></code></pre>
また、lambdarank_position_bias_regularization</code> というパラメータでポジションバイアス因子（上の $g$）の強さを調整できる</a>。</p>
実験結果</h2>
上で MSLR-WEB30K から作成したデータセットに対して、普通の XGBoost・LightGBM とそのポジションバイアス除去版の性能を比較した。評価指標は NDCG@5 で、学習はバイアスのあるクリックラベルについて行い、評価時は真に予測したい unbiased な relevance ラベルについて評価した。</p>
$w$</th> XGBoost</th> Debiased XGBoost</th> LightGBM</th> Debiased LightGBM</th></tr></thead>

0</td> 0.2683</td> 0.2881</td> 0.2748</td> 0.3115</strong></td></tr>
0.2</td> 0.2964</td> 0.2783</td> 0.3047</td> 0.3212</strong></td></tr>
0.6</td> 0.3057</td> 0.2963</td> 0.3179</td> 0.3362</strong></td></tr>
0.8</td> 0.3124</td> 0.2782</td> 0.2997</td> 0.3414</strong></td></tr>
1</td> 0.2927</td> 0.2905</td> 0.3025</td> 0.3414</strong></td></tr>
</tbody></table>
これを見ると、一貫して LightGBM のポジション除去機能が高い性能を示していることがわかった。</p>
コードは以下。</p>



  



  



  



  
    
      
      yng87/unbiased-ltr</div>
      
      Reproduction scripts for unbiased learning-to-rank methods</div>
      
      
      Python</div>
      
    </div>
  </a>
</div>
おわりに</h2>
今回の結果はあくまで人工的にポジションを生成したデータセットにおけるもので、現実のデータではポジションバイアスがもっと複雑な入り方をしている場合もあるので注意が必要ではあるだろう。それでも LightGBM に position を記録した array を渡すだけで手軽に利用できるのはとてもありがたく、これまでよりも気軽に実装して AB テスト等にかけることができそうだ。</p>

^{1</sup>
ByteDance なので TikTok かと思ったが、Toutiao というニュースプラットフォームでの AB テストらしい。</p>
</div>}
NetflixのSequential ABテスト論文を読む
2024-05-05T00:00:00+00:00
最近 Netflix のテックブログを読んでいたら sequential AB testing についての話題があった。</p>

Sequential A/B Testing Keeps the World Streaming Netflix Part 1: Continuous Data | by Netflix Technology Blog | Netflix TechBlog</a></li>
Sequential A/B Testing Keeps the World Streaming Netflix Part 2: Counting Processes | by Netflix Technology Blog | Netflix TechBlog</a></li>
</ul>
Sequential AB testing というのは、実験中に継続的にメトリクスを監視し、treatment と control で有意差が出た瞬間に実験を停止しようというものだ。もちろん、普通の t 検定やカイ二乗検定を実行すると大変な多重検定になるので、有意差が出やすくなってしまう (Type I error が増加してしまう)。</p>
そこで、実験のどの時刻でも Type I error が適切な制御下にあるような検定統計量を定義し、それに基づいて実験の早期打ち切りをできるようにしたというのが、冒頭のブログの趣旨である。これは論文になっていて、NeurIPS に採択もされたらしい。</p>
[2011.03567] Anytime-Valid Inference for Multinomial Count Data</a></p>
「有意差が出た瞬間に実験を打ち切って良い」というのは実務家としてはとても便利な性質なので、この論文をざっくり理解してみようと思い、このブログ記事を書いてみた。</p>
検定統計量</h2>
今回対象とするのは離散的な「カウント」データである。例えば、EC サイトに何か新施策を実装してそれを treatment 群のユーザにだけ見えるようにし、サイトに訪問したユーザーが商品を購入したら、所属する群の conversion カウントが1インクリメントされるというような状況をイメージして欲しい。各時刻 $t$ で $\boldsymbol{n}_t = (n_{t,1}, n_{t,2}, \dots, n_{t,d}) $ という整数値のデータが得られる ($d$ は群の数で $n_{t,i}$ が群 $i$ でコンバージョンしたユーザー数)。</p>
通常の AB テストであれば、あらかじめ必要なサンプルサイズを見積り期間を定めて実験し、実験終了後に一度だけ検定を行う。今回のカウントデータであれば、カイ二乗検定がよく使われるだろう。1</a></sup></p>
しかしここでは各時刻で毎回検定を行いたいのであった。上記論文に倣い、そのための検定統計量を構成しよう。</p>
まず、帰無仮説 $M_0$ として以下のような多項分布から独立に生成される確率変数 $\boldsymbol{x}_i$ を考える
$$\begin{aligned}
\tag{1}
\boldsymbol{x}_1, \boldsymbol{x}_2, \dots | M_0 \sim \mathrm{Multinomial(\boldsymbol\theta_0)}
\end{aligned}$$
$\boldsymbol{x}_i$ は one-hot ベクトル形式であり、$\sim$ は i.i.d であるとする。$\boldsymbol{x}_i$ を足すと上のカウント $\boldsymbol{n}_t$ になると思ってもらえれば良い。</p>
次に対立仮説 $M_1$ を設定する。ここでは両側検定をすることにし $\boldsymbol\theta \neq \boldsymbol\theta_0$ となる生成過程として以下を考える
$$\begin{aligned}
\tag{2}
\boldsymbol{x}_1, \boldsymbol{x}_2, \dots |\boldsymbol\theta ,M_1 &\sim \mathrm{Multinomial(\boldsymbol\theta)}\\ \notag
\boldsymbol\theta &\sim \mathrm{Dirichlet}(\boldsymbol\alpha_0)
\end{aligned}$$
Dirchlet 分布は連続値の分布であり、特定の $\boldsymbol\theta=\boldsymbol\theta_0$ を取る確率はゼロなので、対立仮説になっている。</p>
そして以下のベイズファクターを定義しよう2</a></sup></p>
$$\begin{aligned}
O_n(\boldsymbol\theta_0)=BF_{10}(\boldsymbol{x}_{1:n})=\frac{p(\boldsymbol{x}_{1:n}|M_1)}{p(\boldsymbol{x}_{1:n}|M_0)}
\end{aligned}$$</p>
ベイズファクターはベイズ統計の枠組みで検定を行う手法の一つであり、以前も記事にした</a>ので参照してほしい。
このベイズファクターを解析的に扱える形にしよう。周辺尤度の計算は初等的な積分をすればよく $\boldsymbol{x}_i$ の各成分を足したものを $S^n_i=\sum_{j=1}^nx_{j,i}$, $\boldsymbol{S}_n = (S^n_1, \dots, S^n_d)$ と書くと</p>
$$\begin{aligned}
\tag{3}
O_n(\boldsymbol\theta_0)=\frac{\mathrm{Beta}(\boldsymbol{\alpha}_0 + \boldsymbol{S}_n)}{\mathrm{Beta}(\boldsymbol{\alpha_0})}
\frac{1}{\boldsymbol\theta_0^{\boldsymbol{S}_n}}
\end{aligned}$$</p>
となることがわかる。$\mathrm{Beta}$ は $d$ 次元のベータ関数で、$\boldsymbol\theta_0^{\boldsymbol{S}_n}$ は成分ごとに冪乗して成分間で積を取った量である。</p>
このベイズファクター $O_n(\boldsymbol\theta_0)$ は逐次検定をするのに望ましい性質を持っている。詳しい証明は自分の能力を超えるので書けないが、冒頭の論文によると $O_n(\boldsymbol\theta_0)$ が nonnegative supermartingale になることを利用すると以下の性質を示すことができるらしい:</p>
性質</strong>: $O_n(\boldsymbol\theta_0) \geq 1/u$ となる $n$ が存在する確率は $u$ 以下である ($0\leq u \leq 1$)</p>
そこでこのベイズファクターを利用した sequential p-value</strong> を</p>
$$\begin{aligned}
p_n = \mathrm{min}(p_{n-1}, 1/O_n(\boldsymbol{\theta}_0)),\text{ w/ } p_0=1
\end{aligned}$$</p>
として定義すると</p>
性質</strong>: $p_n\leq u$となる $n$ が存在する確率は $u$ 以下である ($0\leq u \leq 1$)</p>
を持つことがわかる。</p>
確かにこれは直感的に「普通の」p-value の拡張と思える。もし、ある時刻 $n$ で $p_n > u$ になったとすれば、それは帰無仮説の下では確率 $u$ 以下でしか起こらない稀な事象が起こったということであり、検定の文脈では背理法的に帰無仮説を棄却することになる。</p>
ベルヌーイ過程などへの応用</h2>
以上は多項分布を生成する過程 (1) や (2) の話なので、一見すると使い道は限られるが、冒頭に述べた例のようにメトリクスをカウントデータとして読み替えることができれば広く適用できる。</p>
もう少し具体的に、はじめに述べたコンバージョン有無を集計する AB テストを考えよう。$\boldsymbol{x}_n$ を $n$ 番目のコンバージョンがどの群で発生したかを表すものとする。例えば $\boldsymbol{x}_3 = (0, 1, 0)$ であれば3番目のコンバージョンが群2で発生したということである。群 $i$ におけるコンバージョン確率を $p_i$, また各ユーザーの群 $i$ への割り当て確率を $\rho_i$ とすると、次のコンバージョンがどの群で起こるかを表す確率は</p>
$$\begin{aligned}
\theta_i = \frac{\rho_i p_i}{\sum_{j=1}^d \rho_i p_i}
\end{aligned}$$
とかける。帰無仮説は群ごとのコンバージョン確率 $p_i$ が全て等しいとするので、結局 $\boldsymbol\theta_0=\boldsymbol\rho$ として、上の話を適用すれば良いことになる。ポアソン過程についても同様に考えられるので、冒頭の論文を読んでほしい。</p>
ちなみにこの表式から、$p_i$ が群の割り当てと独立な時間依存性を持っていても問題なく適用できることがわかる。Netflix の実験では、コンバージョン確率が実験中に時間変化することがあると報告されている。</p>
シミュレーション</h2>
ベルヌーイ過程をシミュレーションして上記の手法を適用してみよう。実験に使ったノートブックは以下に上げた。</p>
sequential_ab_testing.ipynb</a></p>
Sequential p-value の計算はシンプルで、各時刻のカウントデータに対して式 (3) で $\boldsymbol\theta_0=\boldsymbol\rho$ としたものを計算していくだけである。ただし prior のパラメータ $\boldsymbol{\alpha}_0$ には自由度がある。論文では、帰無仮説からズレるとしてもそのズレは小さいだろうとして、$\boldsymbol{\alpha}_0 = k \boldsymbol{\theta}_0$ を採用している ($k$ は大きい正の数）。3</a></sup></p>
Python で書くと以下のようになる 4</a></sup></p>
from</span> scipy</span>.</span>special</span> import</span> loggamma</span>,</span> xlogy</span></span>
import</span> numpy</span> as</span> np</span></span>
</span>
def</span> sequential_p_value</span>(</span>counts</span>,</span> assignment_probabilities</span>,</span> k</span>=</span>100</span>)</span>:</span></span>
    counts</span> =</span> np</span>.</span>array</span>(</span>counts</span>)</span></span>
    assignment_probabilities</span> =</span> np</span>.</span>array</span>(</span>assignment_probabilities</span>)</span></span>
    dirichlet_alpha</span> =</span> k</span> *</span> assignment_probabilities</span></span>
</span>
    log_bf</span> =</span> (</span></span>
        loggamma</span>(</span>dirichlet_alpha</span> +</span> counts</span>)</span>.</span>sum</span>(</span>)</span> -</span> loggamma</span>(</span>(</span>dirichlet_alpha</span> +</span> counts</span>)</span>.</span>sum</span>(</span>)</span>)</span></span>
        -</span> loggamma</span>(</span>dirichlet_alpha</span>)</span>.</span>sum</span>(</span>)</span> +</span> loggamma</span>(</span>dirichlet_alpha</span>.</span>sum</span>(</span>)</span>)</span></span>
        -</span> np</span>.</span>sum</span>(</span>xlogy</span>(</span>counts</span>,</span> assignment_probabilities</span>)</span>)</span></span>
    )</span></span>
</span>
    return</span> min</span>(</span>1</span>,</span> np</span>.</span>exp</span>(</span>-</span>log_bf</span>)</span>)</span></span></code></pre>
ベータ関数はガンマ関数を使ってかけるのと、値が大きくなるのでできるだけ対数で計算しておくことがポイント。</p>
二群の AA テスト ($\boldsymbol{p} = (0.5. 0.5)$) をして p-value の分布を見てみる。各群に割り当てられる確率は同じ ($\boldsymbol\rho=(0.5,0.5)$) とする。$n=4000$ まで取るシミュレーションを1000回繰り返し、上記の sequential p-value とカイ二乗検定を逐次行った結果を比較する。カイ二乗検定は各時刻で p-value を計算して最小値を保持するという、わざと不適切なやり方で行なった。</p>
以下はその分布である。カイ二乗検定は明らかに p-value が0に寄ってしまっているのに対し、sequential p-value は概ね理想である一様に近い（少し1に偏っているのが気になるが…）。</p>
</p>
両者の Type I error の割合を有意水準 $0.05$ で計算してみると</p>

カイ二乗検定: 0.032</li>
Sequential p-value: 0.41</li>
</ul>
となり、カイ二乗検定は明らかに多重検定で Type I error が増幅されているのに対し、sequential p-value では適切に制御されていることがわかる。Sequential p-value の $p_n \leq u$ という性質はあくまで不等式なので、ピッタリ0.05 にはなっていないようだ。</p>
上記の結果だけみると非常に便利で普通の検定より便利なのではと思ってしまうが、多重検定に対して頑健ということは、逆に検出力は低いのではないかという懸念が生じる。そこで $\boldsymbol{p} = (0.54. 0.5)$ と二群に差があるケースで同様にシミュレーションしてみた。ただし今回は多重検定にならないよう、カイ二乗検定では $n=4000$ で一回だけ p-value 計算をしている。この時、有意 ($p < 0.05$) になったものの割合は</p>

カイ二乗検定: 0.715</li>
Sequential p-value: 0.202</li>
</ul>
となった。やはり、検出力は低くなる傾向にあるようだ。</p>
その他、実務の AB テストではゼロイチの統計量ではなく連続値に対して t 検定を行うこともよくあるが、その場合には使えないし、カウントに対するモデリングになっているので単純な拡張も難しそうだと思う。</p>

^{1</sup>
この場合、コンバージョンしなかったユーザーの数も必要でここではそれも取得できていると想定している。</p>
</div>}^{2</sup>
Prior odds は1とする。</p>
</div>}^{3</sup>
この時 Dirichlet 分布の期待値は $\boldsymbol\theta_{0}$、分散は $\sim 1/k$ である。</p>
</div>}^{4</sup>
著者が gist</a> にコードを上げているが、少し冗長な形になっている。</p>
</div>}


トリガーを設定してABテストの感度を上げる
2024-02-08T00:00:00+00:00
AB テスト実践ガイドには AB テストの感度を上げるためのトリガーの設定（AB テスト対象者の定義の仕方）について書かれている。</p>

  



  



  



  



  



  



  




  
    
      
      
      
    </div>

    
      
      Book</div>
      

      A/B テスト実践ガイド真のデータドリブンへ至る信用できる実験とは</div>

      
      Ron Kohavi / Diane Tang / Ya Xu / 大杉直也訳 / KADOKAWA</div>
      

      

      
      2021-03-23発売 / ISBN 9784048930796</div>
      
    </div>
  </a>
</div>

例えば EC サイトの商品ページで AB テストをするとしよう。商品ページ内の購入導線の変更や、そこに表示される関連アイテム推薦アルゴリズムの変更をテストしたいというような場合である。この時 AB テストの分析時に対象者として含めるユーザーの定義には次のようなものが考えられる</p>

サイト訪問者全体</li>
サイト訪問者全体のうち、商品ページを一度でも閲覧したユーザー</li>
</ul>
単に AB テストをしてデータを集めてメトリクスについて検定するだけであればどちらでも良い。しかしより感度の良い実験、つまり同じ人数でより小さいメトリクスの差まで検出できるような AB テストをしたいのであれば、後者を選択すべきである、と AB テスト実践ガイドには書かれている。</p>
これは直感的に納得いくものだと思う。というのも、サイト訪問者のうち、商品ページに辿り着かなかったユーザーは、対象としている変更を一度も目にすることがないので、純粋なノイズになるからだ。これ以上の説明が不要なのであれば、以下を読む必要はない。</p>
今回はこの事実をあえて数式を使って考えてみたいと思う。これは単にその方が自分が納得しやすいからだ。</p>
上の問題を定式化しよう。まず以下のように変数を用意する</p>

$y$ : テスト対象のメトリック。例えば、ユーザー一人当たりの商品購入金額など。</li>
$z$ : ユーザーがテスト対象の変更があったページを閲覧したかどうかを表す二値変数。例えば、商品ページの訪問有無。</li>
</ul>
すると $y$ の分布は
$$\begin{aligned}
p(y)
&= \sum_{z=0,1}p(y|z)p(z) \notag \\
&= p_zp(y|z=1) + (1-p_z)p(y|z=0)
\end{aligned}$$
とかける。ここで $z$ はベルヌーイ分布に従うとし、$z=1$ の確率を $p_z$ とした。また問題設定から、$p(y|z=0)$ は確率1で $y=0$ となる分布である。</p>
この分布の平均値と分散を考えよう。まず条件付き分布の平均と分散を
$$\begin{aligned}
\mu_{y|z} &\equiv \mathbb{E}[Y|Z=1]\\
\sigma^2_{y|z} &\equiv \mathrm{Var}[Y|Z=1]
\end{aligned}$$
と定義すると、少し計算することで周辺分布での平均は
$$\begin{aligned}
\mu_{y}
\equiv \mathbb{E}[Y]
= p_z \mu_{y|z}
\end{aligned}$$
分散は
$$\begin{aligned}
\sigma_{y}^2
\equiv \mathrm{Var}[Y]
= p_z \sigma_{y|z}^2 + p_z(1-p_z)\mu_{y|z}^2
\end{aligned}$$
となることがわかる。</p>
AB テストの感度は、サンプルサイズ $n$ を固定した時どこまで小さいメトリクスの差まで検出できるかで定式化できる。有意水準5%・検出力80%の場合には以前記事にもした</a>ように、以下の式で近似できる1</a></sup>
$$\begin{aligned}
\delta^2 = \frac{16\sigma^2}{n}
\end{aligned}$$</p>
まずトリガーを設定せず、サイト訪問者全員をテスト対象者とした場合
$$\begin{aligned}
\delta_y^2 = 16\frac{p_z \sigma_{y|z}^2 + p_z(1-p_z)\mu_{y|z}^2}{n}
\end{aligned}$$
となる。トリガーを設定し、テスト対象のページの訪問者のみを考慮する場合は、サンプルサイズを $p_z\times n$ とすれば良いので
$$\begin{aligned}
\delta_{y|z}^2 = 16\frac{\sigma_{y|z}^2}{p_z n}
\end{aligned}$$
となる。あとは両者の比を取れば良いのだが、$\delta_{y|z}$ はそもそもトリガーされてないユーザー（例えば商品ページに辿り着かなかったユーザー ＝ 必ず $y=0$ となるユーザー）を考慮していないので、$\delta_y$ と比較するには $p_z$ をかける必要がある。ということで今見たい量は
$$\begin{aligned}
\frac{\delta_y^2}{p_z^2\delta_{y|z}^2}
=1 + (1-p_z)\left(\frac{\mu_{y|z}}{\sigma_{y|z}}\right)^2
\end{aligned}$$
である。これは（$p_z<1$ なら）1より大きいので $p_z\delta_{y|z} < \delta_y$ である。2</a></sup> つまり一般的に、トリガーを設定した方がより小さいメトリクスの差まで検出できるようになる</strong>ということを示すことができた。</p>
またこの式から平均が分散に比べて大きいほど、トリガーの効果が大きく、逆の場合はトリガーの影響は軽微であることがわかる。これは分布がどれだけ $y=0$ 付近に密度を持っているかどうかを反映している。</p>
まあ当たり前の関係なのだが、算数で明確に示すとすっきりする。</p>

^{1</sup>
この式が成立するには $n$ が十分大きく正規分布で諸々が近似できるというような状況が必要だが、ここでは典型的な Web での AB テストを考えているのでこの仮定は満たされているとして進める。</p>
</div>
^{2</sup>
$\mu_{y|z}$ はコンバージョン率や購入金額など、正の量だと仮定している。</p>
</div>}}


ランキングモデルのポジションバイアスに対処する
2024-01-13T00:00:00+00:00
はじめに</h2>
最近KDD2023の論文を読んでいた</a>のですが、その中で以下の論文が目に留まりました。</p>
Towards Disentangling Relevance and Bias in Unbiased Learning to Rank</a></p>
Learning to rank におけるポジションバイアスに対処する手法の提案で、特に著者達が click modeling と呼ぶアプローチを発展させたものになっています。</p>
今回はこの論文をベースにいくつかポジションバイアス除去系のモデルを実装して比較してみました。</p>

ポジションバイアスの除去</h2>
推薦や検索ではユーザーがサービスを使う間に自然に発生するクリックなどのイベントを、機械学習のラベルとして用いることがよくあります。しかしこのようなイベントの発生は、単純なユーザーの嗜好だけではなく、そもそもサービス上でユーザーがそのアイテムを目にする機会があったかどうかにも左右されます。嗜好が同程度のアイテムであれば上位に表示された方がクリックされやすくなるため、ポジションの影響を考慮に入れないとモデルの推論結果にバイアスが乗ってしまうことになります。</p>
バイアス除去の二つの方法</h3>
ランキング学習におけるポジションバイアスの除去はここ数年ホットな話題となっており、多くの論文が書かれているようです。冒頭の論文ではこれまで提案されてきた手法を大きく以下の二つに分類していました</p>

Counterfactual アプローチ</strong>: 傾向スコアによる重み付けを使うなど、counterfactual な分析手法の応用</li>
Click modeling アプローチ</strong>: アイテムのクリック確率を、アイテムの観測確率と、観測された上でクリックされる確率（CTR）に分解しモデリングする方法</li>
</ul>
Counterfactual アプローチでは傾向スコアを別途何らかの方法で入手・推定する必要があり、手間やコストがかかります。一方 click modeing アプローチは、サービスのログデータを使って通常のモデリングプロセスの枠内で実装できます。そのような手のつけやすさから産業界ではこちらがよく採用されるらしく、実際例えば Airbnb は click modeling アプローチを採用して実装したモデルの有効性を報告しています</a>。</p>
Click modeling のアイディア</h3>
Click modeling のアイディアはシンプルです。推薦や検索でユーザーにアイテムのリストを表示するような状況を念頭に起きます。ユーザー・アイテムペアを表す識別子を $i$ として変数を以下のように定義します。</p>

$c_i$: ユーザーがアイテムをクリックしたかを表す二値変数</li>
$o_i$: ユーザーがアイテムを観測したかを表す二値変数</li>
$\vec x_i$: ユーザー・アイテムの特徴量</li>
</ul>
一般にクリック確率は
$$\begin{aligned}
\tag{1}
P(c_i=1|\vec x_i) = P(c_i=1|\vec x_i, o_i=1)\times P(o_i=1|\vec x_i)
\end{aligned}$$</p>
と分解できます。ここで、$o_i=0$ ならば必ず $c_i=0$ になるとしました。</p>
さらに特徴量 $\vec x_i$ が、以下のように分離できると仮定しましょう</p>

$\vec x_i^R$: ユーザーのアイテムに対する嗜好 (以下 relevance とも言います) のみに関係する特徴量。</li>
$\vec x_i^P$: アイテムの観測有無にのみ関係する特徴量。例えば、表示位置やデバイス情報。</li>
</ul>
つまり、式 (1) が以下のように書けるとします
$$\begin{aligned}
\tag{2}
P(c_i=1|\vec x_i) = P(c_i=1|\vec x_i^R, o_i=1)\times P(o_i=1|\vec x_i^P)
\end{aligned}$$</p>
このようにクリック確率を、アイテムの観測確率と観測されたという条件付きでのクリック確率の積として表し、それぞれを異なる特徴量を持つ別のモデルとして表現するのが click modeling アプローチです。ユーザーの嗜好は第一項の $P(c_i=1|\vec x_i^R, o_i=1)$ で表されており、推論時にはこちらだけを使います。</p>
PAL</h3>
PAL</a> は click modeling アプローチの走りで、$P(c_i=1|\vec x_i^R, o_i=1)$ と $P(o_i=1|\vec x_i^P)$ をそれぞれニューラルネットワーク $r(\vec x_i^R)$ と $o(\vec x_i^P)$ で表し、以下のようなロス関数を使って学習することを提案しました
$$\begin{aligned}
\tag{3}
L &= \frac{1}{N}\sum_{i=1}^N l(c_i, \psi_i) \\
\psi_i &= r(\vec x_i^R)o(\vec x_i^P)\notag
\end{aligned}$$
ここで $l$ はクロスエントロピーです。推論時には $r(\vec x_i^R)$ だけを用いることで、ポジションの影響を取り除いたユーザーの嗜好を予測することができます。</p>
式 (2) を見ると上記の積の形が自然に思えますが、冒頭の論文で引用されている様子を見ると $\psi_i=\mathrm{sigmoid}(r(\vec x_i^R)+o(\vec x_i^P))$ という和の形を採用することもあるようです。1</a></sup></p>
また冒頭の論文ではこのようなモデルを two tower model、 $r(\vec x_i^R)$ を relevance tower, $o(\vec x_i^P)$ を observation tower と呼んでいます。2</a></sup></p>
Relevance による交絡</h3>
PAL はポジションの影響を $o(\vec x_i^P)$ だけに押し付けるという発想ですが、式 (3) のように単に特徴量を分割して積や和の形にモデルを書いただけでそう都合よくバイアスが緩和できるものなのでしょうか。</p>
冒頭の論文では、PAL のような手法がうまくいくのはデータの観測構造が下図 (a) のようになっている時だと指摘しました（冒頭の論文より。$D$ が $\vec x^R$, $B$ が $o$, $P$ が $\vec x^P$ と思ってください）。</p>
</p>
観測有無はポジションによってのみ決まり、relevance の影響は受けないという仮定になっています。</p>
しかし実務では多くの場合、ログデータは過去のモデルの推論結果から生成されており、そのモデルはやはり relevance を学習しているため、(b) のように relevance がポジションとクリック両方の原因（交絡因子）になります。するとそのようなデータで学習したモデルは、relevance の学習のためにポジションを shortcut</strong> として利用できるようになってしまい、relevance tower にポジションの影響が入り込んでバイアスの除去を妨げてしまいます。</p>
上記論文ではこの shortcut を緩和する手法として以下二つを提案していました。</p>
Observation Dropout</h4>
これはその名の通り、observation tower $o(\vec x^P)$ に dropout を導入して、ポジションの shortcut を緩和します。ロス関数はこれまでと同じ式 (3) です。</p>
Gradient Reversal</h4>
この方法では、observation tower $o(\vec x^P)$ から relevance を unlearn</strong> します。具体的には式 (3) に以下のロス関数を加えて joint で学習します。
$$\begin{aligned}
L_{rev}=\sum_i\left(y_i - \mathrm{Dense}(\mathrm{GradRev}(o(\vec x^P_i)))\right)^2
\end{aligned}$$
ここで $\mathrm{GradRev}$ は勾配の符号を反転させるレイヤーです (forward では何もしません）。$y_i$ は relevance のラベルで、ユーザーの真の嗜好を表しますが、通常は利用可能でないのでクリックラベルで代用したり、$r(\vec x^R)$ を使ったりすることが提案されています。</p>
実験</h2>
冒頭の論文の提案手法も含めて、click modeling アプローチの効果を確かめる実験を行いました。基本的には論文に記載の手順に従いましたが、詳細が書かれていない部分も多くその場合は適当に想像して補っています。実装は以下に置いておきました。</p>



  



  



  



  
    
      
      yng87/unbiased-ltr</div>
      
      Reproduction scripts for unbiased learning-to-rank methods</div>
      
      
      Python</div>
      
    </div>
  </a>
</div>
クリックデータセットの生成</h3>
バイアス除去に関する実験をするには、バイアスの乗った学習データと、バイアスのないテストデータが必要になります。ここでは論文にならって、MSLR-WEB30K</a> を加工してそのようなデータセットを作ることにします。MSLR-WEB30K は Bing の検索から作った learning-to-rank 用のデータセットで、各クエリ・ドキュメントのペアに対して、136次元の特徴量ベクトルと、0-4 の relevance ラベル $y_i$ が付けられています。この $y_i$ をバイアスのない ground truth ラベルとします。</p>
このデータセットにクリックの有無を表す二値ラベルを、以下の手順で人工的に付与します。</p>
1. クエリごとにドキュメントのポジションを生成</h4>
各ドキュメントに以下で表されるスコア $s_i$ を生成し、クエリごとにその降順をドキュメントのポジション $p_i$ とします。
$$\begin{aligned}
s_i = wy_i + (1 - w)n_i,\text{  where } n_i \sim \mathrm{Uniform(0,4)}
\end{aligned}$$</p>
スコアは relevance $y_i$ とランダムノイズの重み付き和で決まります。$w=1$ の時は完全に relevance によって決まり上で述べた交絡が強く発生しているという状況になります。逆に $w=0$ の時はポジションは relevance によらずランダムに決まり、交絡はありません。</p>
2. ポジションに応じた人工クリックの生成</h4>
ポジションが上になるほど表示確率が高いという状況を
$$\begin{aligned}
P(o_i=1|p_i) = \frac{1}{p_i}
\end{aligned}$$</p>
と表現することにします。そして、$o_i=1$ の下でのクリック確率を
$$\begin{aligned}
P(c_i=1|y_i, o_i=1)=\epsilon + (1-\epsilon)\frac{2^{y_i}-1}{2^{y_{\mathrm{max}}}-1}
\end{aligned}$$</p>
とします。Relevance が高いほどクリックしやすく、また一定値のノイズ $\epsilon$ も付与されるという設定です。ここでは元論文にならい $\epsilon=0.1$ に固定します。</p>
トータルのクリック確率はこの二つの積</p>
$$
P(c_i=1|y_i,p_i)=P(c_i=1|y_i, o_i=1)\times P(o_i=1|p_i)
$$</p>
になります。MSLR-WEB30K の各データに対して $P(c_i=1|y_i,p_i)$ に基づくベルヌーイ分布からサンプリングを行いました。</p>
なお、この方法でクリックを生成すると正例 ($c_i=1$) が1%以下と不均衡が大きくなるため、以下の実験では負例を10%にダウンサンプリングして学習の効率化を図っています。</p>
比較用のベースライン</h3>
比較のために、以下のベースラインを用意しました。</p>
Linear model</h4>
目的変数を $c_i$ とする二値分類を、正則化項つきのロジスティック回帰で解きます。実装には scikit-learn を用いました。</p>
またポジションバイアスを除去するため、学習時にポジションも特徴量として使い、推論時には一定値 ($p_i=1$) に固定するという方法も試しました (Debiased Linear)。これはGoogleのRules of machine learning</a>にも紹介されている古典的なテクニックです。</p>
GBDT</h4>
XGBoost の objective="rank:ndcg"</code> でランキングモデルを作ります。またロジスティック回帰と同様に、ポジション特徴量を推論時に固定する方法も試しました（Debiased XGBoost）。3</a></sup></p>
Single Tower</h4>
目的変数を $c_i$ とする二値分類を MLP で解くモデルです。公平な比較をするため、two tower 系のモデルの relevance tower のパラメータ数は、この single tower と等しくなるようにしています。</p>
Validation の方法</h3>
モデルのハイパーパラメータチューニングや early stopping などは、生成した人工クリックに基づく validation データを通して行いました。このクリックは本来最適化したい relevance に対してバイアスがあるわけですが、現実的な設定にしようと思うと多少バイアスが乗っていてもこれを使うしかありません（冒頭の論文にはこの辺の手法の詳細は書かれていませんでした）。</p>
なお手元の計算リソースの都合上、パラメータチューニングといっても適当に手動で何パターンか試して良さそうなものに固定する、という程度のことしかしていません。</p>
実験結果</h2>
以下に test データの relevance ラベルにおける、NDCG@5 を示します。バイアスのある人工クリックと異なり、これは真に評価したい unbiased な指標になります。</p>
w</th> linear</th> debiased_linear</th> xgboost</th> debiased_xgboost</th> single_tower</th> two_tower</th> obs_dropout</th> grad_rev</th></tr></thead>

0</td> 0.2787</td> 0.3145</td> 0.2683</td> 0.1828</td> 0.2658</td> 0.3465</strong></td> 0.2860</td> 0.3382</td></tr>
0.2</td> 0.2851</td> 0.3157</td> 0.2964</td> 0.1737</td> 0.2983</td> 0.3437</strong></td> 0.2984</td> 0.3432</td></tr>
0.6</td> 0.2935</td> 0.3227</td> 0.3057</td> 0.2426</td> 0.2436</td> 0.3255</td> 0.3434</strong></td> 0.3341</td></tr>
0.8</td> 0.2957</td> 0.3246</td> 0.3124</td> 0.1768</td> 0.2924</td> 0.3532</strong></td> 0.3163</td> 0.3439</td></tr>
1</td> 0.2880</td> 0.3189</td> 0.2927</td> 0.1599</td> 0.3075</td> 0.3401</strong></td> 0.2976</td> 0.3399</td></tr>
</tbody></table>
この結果から次のことがわかりました。</p>

ロジスティック回帰（Linear）は position 特徴量の利用で大きく指標が向上する

逆に XGBoost ではこの手法は有効ではない</li>
</ul>
</li>
ニューラルネットワークを使った手法では、バイアスを考慮しない single tower に比べて、バイアスを考慮したモデルが強い。</li>
論文の主張であった、two tower モデル (PAL) は $w$ が大きい（relevance の交絡が強い）と性能が落ちるという点は再現できなかった。

そもそも他の結果も元論文とは数字がかなり異なる。論文では人工クリックの生成・モデルの実装・ハイパーパラメータについて何も共有されていないのでこの辺りは仕方ない（もちろん自分の実装にバグがある可能性もある）。</li>
</ul>
</li>
</ul>
なお、Debaised XGBoost は非常に悪い結果となりましたが、自分はこの方法が上手くいく場面を実務で見たことがあるので、データセットとの相性も大きいのではないかと思います。直感的には今回はポジションの影響が $1/p_i$ の形で入ってくるのでほとんどポジションで学習できてしまい、relevance 特徴をうまく学習できていないのだと思います。</p>
さいごに</h2>
次は counterfactual 系の実用的な手法を調べて比較してみたいです。実装にバグを見つけたら、リポジトリで報告をして頂けると助かります。</p>

^{1</sup>
自分で実験したところ、和の形の方が少しだけ性能が良かったです。</p>
</div>
^{2</sup>
推薦の retrieval で使われる two-tower モデルとは異なります。</p>
</div>
^{3</sup>
XGBoostには最近ポジションバイアス除去のオプションが追加された</a>らしく、lambdarank_unbiased=True</code> で使えるようですが、試してみたところあまり効果はなかったです。ちゃんと内容を理解していないので比較対象からは抜いています。</p>
</div>


KDD2023の読んだ論文まとめ (3)
2023-12-05T00:00:00+00:00
前回</a>、前々回</a>の続きで、KDD2023の読んだ論文に対する感想を書いていく。
これで読みたいと思ってリストアップしたものは全部一通り目を通せた。</p>
TransAct: Transformer-based Realtime User Action Model for Recommendation at Pinterest</a></h2>
毎度お馴染み Pinterest の推薦に関する論文。今回はランキングでユーザーの短期と長期の興味をそれぞれ別の形で取り込むモデルを紹介している。
本筋のモデル構造の話よりも、学習データの作り方として、ターゲットの時刻の直前 T 秒の系列は使わないという、time window mask アプローチが参考になった。
直前のアイテムの情報が使えないと、推薦に多様性が出るらしい。タスクとしても難易度が高くなるので良さそうな気がする。</p>
RankFormer: Listwise Learning-to-Rank Using Listwide Labels</a></h2>
Amazon からの論文で、ランキングモデルの学習において普通は捨ててしまう、ユーザーのフィードバックが一つもつかなかった推薦リストも学習に使おうというアイディア。
Transformer ベースの neural ranking model を用い、アイテム系列に [CLS]</code> トークンを付与してそれをリスト全体としてクリックがあったかどうかのラベル学習に用いる。
実際 Amazon の AB テストでも良い成績だったらしいが、そこでは実装の都合上直接このモデルを用いず、知識蒸留した GBDT を使ったとのこと。</p>
Balancing Approach for Causal Inference at Scale</a></h2>
因果推論の balancing approach のスケールするアルゴリズムを提案した論文。
そもそも balancing approach というのを知らなかったが、IPW などの単純な方法では共変量のバランスチェックをする必要があり、大規模なデータセットでは試行錯誤するのが大変らしい。
そこで propensity を使わず各ユニットの重みを、共変量バランスを満たすという制約のもとで直接推定する手法 (balancing approach) が採用されるとのこと。
この研究の貢献は、single machine でしか使えない既存手法を改善して、大規模な問題でもスケールする分散アルゴリズムを提案した点。</p>
Towards Disentangling Relevance and Bias in Unbiased Learning to Rank</a></h2>
Google research の unbiased learning-to-rank (LtR) に関する論文。
Unbiased LtR には大きく二流派あり、IPS のようなものを使う counterfatual 的アプローチと、モデルを position bias を受ける部分と受けない部分の二つに分ける click modeling アプローチがある。
産業界では後者の click modeling アプローチが主流とのこと（知らなかった）。
Click modeling では、バイアスを受けづらい特徴量を使う relevance tower と、position やデバイス情報などのバイアスを受けやすい特徴量を使う observation tower の二つを用意する two-tower モデルがよく使われる。
しかし、実際のサービスでは position などはモデルの推論結果から生成される。そのモデルは以前の relevance を学習するので、実は交絡は解消できていないという点を指摘している。
これを解決するために二つのシンプルな方法を提案し、オンラインテストの結果も載せている。
KDD2023で一番勉強になった。</p>
Optimizing Airbnb Search Journey with Multi-task Learning</a></h2>
Airbnb の検索ランキングモデル改善論文。
サービスの特徴として、宿を予約するまでのユーザージャーニーが非常に長く（数週間のオーダー）、既存のモデルではその中で最終的に予約された宿に関するクリックシグナルしか使えていないという課題があったとのこと。
提案手法の中では、$P(uncancelled\ booking) = P(uncancelled\ booking|booking)\times P(booking)$ のようなビジネス指標の分解をそのままモデルとロスの構造に反映させている部分が面白かった。
ただオンライン実験結果はポジティブとはいえ、ここまでやった割に上昇幅は渋いなぁという感想。
まあプラットフォームが成熟しているとメトリクスの大幅な改善は難しいのだろう。</p>
Multi-Label Learning to Rank through Multi-Objective Optimization</a></h2>
GBDT における multi-label LtR モデルの学習アルゴリズムのトレードオフを整理した論文。
Multi-objective 用のアルゴリズムはいろいろ提案されているらしいが、それを整理してパレートフロントのどの点に収束できてどの点にできないかを見るフレームワークを導入したのが貢献のよう。</p>
Improving Training Stability for Multitask Ranking Models in Recommender Systems</a></h2>
YouTube で使われているランキングモデルの training stability 改善手法についての論文。
推薦では複数の目的関数を持つ DNN モデルが使われるが、学習が不安定で loss が発散することが多い。
学習の安定化のために、gradient clipping や warmup などのテクニックが開発されていて他の分野では成功しているが、multi-objective ランキングモデルには不十分な傾向がある。
この原因として、sequential training を行うためデータの分布変化が激しく loss が steep になりやすい、モデルサイズが大きい、multi-objective モデルは一つのタスクの不安定性が全体に伝播しやすいという点を挙げている。
提案手法は、AdaGrad の安定性を向上させるための新しい gradient clipping。
YouTube のデータを使った実験では良い成績とのことで、特に learning rate をそこまで小さくせずとも済むのが嬉しい模様。
あとはそもそも YouTube では複数の candidate generation と multi-objective を使ったランキングで構成されているという点が勉強になった。</p>


KDD2023の読んだ論文まとめ (2)
2023-11-26T00:00:00+00:00
前回</a>の続きで、KDD2023の読んだ論文に対する感想をつらつら書いていく。</p>
Multi-factor Sequential Re-ranking with Perception-Aware Diversification</a></h2>
Alibaba のリランキングにおける accuracy と diversity の両立に関する論文。ユーザーが上から順にアイテムフィードを見ていくような場面で、それまで見たアイテムを考慮して次に提示するアイテムを決めるような文脈を考えている。</p>
既存の Determinantal point process (DPP) という手法をベースに、ユーザー $u$ に推薦するアイテムの集合 $S$ を、$h(u, S) = \sum_{i\in S}g(u,i|S) + \alpha \log\mathrm{det}(D^u_S)$ を最大化するものとして選ぶとしている。$g(u,i|S)$ がユーザー $u$ のアイテム $i$ に対する選好度で、$D^u_S$ が $S$ に含まれるアイテムの、ユーザー $u$ への推薦という文脈を考慮した類似度行列。類似度がユーザー依存性を持っているのがポイントで、多様性を考慮する重要度をユーザーに応じて変えられるのが良いらしい。こういう定式化があるのかと勉強になった。</p>
Controllable Multi-Objective Re-ranking with Policy Hypernetworks</a></h2>
これも Alibaba の論文で、multi-objective の各目的関数間の相対的な重みの変更に強いランキングアルゴリズムを作ろうという提案。セールや季節性などの影響で、時々重みを変えたくなるが、毎回それに適したモデルをスクラッチで学習させるのはコストが高いというのが背景にある。正しく読めているか怪しいが、大雑把にいうとモデルの最後の数層（MLP など）のパラメータを生成する hypernetwork を別に用意し、それ以外のパラメータは固定の上で、multi-objective の重みが変わったらこの数層だけを取り替えるというような提案をしている。</p>
Joint Optimization of Ranking and Calibration with Contextualized Hybrid Model</a></h2>
ランキング能力の最適化と、calibration を同時に実現する方法の提案。通常二値分類の logit は一次元だが、これを二次元に拡張し (positive probability, negative probability) 両方に対して用意する。ロスが二値分類の cross entropy のみであれば、この差しか学習できいが、ranking loss を追加することで両方学習できるようにしている。理論的には energy based model とみなせるとも書いてあって面白かったが、実質的には普通の listwise loss に比べて負例同士の比較部分にしか差がなさそうで、そんなに既存手法と変わるのだろうかという疑問がある。</p>
あとこれは自分が知識不足なだけだが、線形でない複雑なモデルの場合も cross entropy で学習させれば必ず calibration されるのだっけ。Negative downsampling とかをせずデータセットの正例・負例のバランスを壊さなければ良いのだろうか。</p>
Fresh Content Needs More Attention: Multi-funnel Fresh Content Recommendation</a></h2>
Google のレコメンドに関する論文で、interaction の少ないアイテムの推薦を増やしてカバレッジを増やしつつ、エンゲージメントも落としたくないというのがモチベーション。通常の推薦枠の一つを fresh content 用の枠に置き換えて新規アイテムのデータを取得しているらしい。またこの枠の推薦では、アイテム ID などは使わずできるだけ汎化しやすい特徴量のみを利用し、fresh content のデータの溜まり具合に応じて使うモデルを変えたりしているらしい。なんとなく全体的に要領を得ないというか、ポイントが絞られていない論文だった。</p>
Empowering Long-tail Item Recommendation through Cross Decoupling Network (CDN)</a></h2>
これも Google の論文で、long-tail アイテムの推薦を改善する手法を提案している。普通の協調フィルタリング的手法では tail のアイテムの評価が悪く、かといって既存手法に倣って全データで学習したあと、tail のアイテム中心のデータで再学習するなどすると head のアイテムの性能が落ちる（最初の学習内容の忘却が起こる）。そこで、head アイテムの性能を維持しつつ tail でも良い性能を得るため、アイテム特徴量の分離と tail アイテムデータセットによる正則化を導入した。特徴量の分離というのは、アイテム ID のような暗記が中心の埋め込みと、カテゴリ ID のように複数アイテム間で汎化させることが目的の埋め込みを別に集約し、アイテムの frequency に応じたゲートに通して足し合わせるというもの。なかなか面白かった。</p>
Counterfactual Video Recommendation for Duration Debiasing</a></h2>
ByteDance の推薦におけるバイアス除去に関する論文。動画推薦では、短い動画の方が視聴完了率が高い = positive feedback が得やすいため、推薦にも表示されやくすなってしまう（duration bias が強い）。そこで、動画を見終わったかどうかでなく、何割まで見たかという閾値を定義して二クラスに分けるようにしたとのこと。分け方は、クラス内分散を小さく、クラス間分散を大きくなるように決めている。また DAG に基づいた因果推論をして、total indirect effect を計算し推薦に用いている。</p>


KDD2023の読んだ論文まとめ (1)
2023-11-19T00:00:00+00:00
最近は KDD2023の Applied Data Science Track で気になった論文を少しずつ読んでいるので、簡単にメモを残そうと思う。</p>
Variance Reduction Using In-Experiment Data: Efficient and Targeted Online Measurement for Sparse and Delayed Outcomes</a></h2>
A/B テストの感度を上げるために、実験中のデータも使ってメトリクスの分散を下げようという提案。Airbnb で実際に有効に機能しているらしい。この話題だと、CUPED のように実験前のデータを使って分散の小さいメトリクスを構成するアイディアがよく知られているが、実験中にライブでその値をアップデートしていくのが新しい。</p>
CTR のような単純なメトリクスは分散が小さく実験で白黒付けやすいことが多い一方で、本当に上げたい LTV 的指標は検出力が低いという状況は、実際にサービスの改善に携わるとよく経験する。</p>
Multi-channel Integrated Recommendation with Exposure Constraints</a></h2>
Alibaba のホームフィードに掲載するアイテム配置の最適化に関する論文。ホーム面には複数のチャネルからの出稿があり、それぞれ独立に評価値がついている。ホーム面 utility を最大化したいが、その一方で、それぞれのチャネルの露出量に対する上限下限のビジネス制約もある。提案としては、utility 最大化のための主問題と、制約を満たすための双対問題を iterative に解くという形。</p>
CT4Rec: Simple yet Effective Consistency Training for Sequential Recommendation</a></h2>
系列推薦モデルの精度向上のための正則化手法の提案。ベースのモデルは埋め込みの類似度を利用するものであればなんでもよく、異なる dropout で2回 forward 計算をし、得られた同一のユーザーベクトル同士が近くなるようにする。具体的には、二つのベクトル間の KL divergence と、バッチ内での他のユーザーベクトルとの類似度分布に対する KL divergence の二つを導入している。アイディアはシンプルなので、機会があったら実装してみたい。</p>
An Empirical Study of Selection Bias in Pinterest Ads Retrieval</a></h2>
Pinterest の広告推薦モデルにおける retrieval ステージのバイアス除去に関する論文。Retrieval の推論時の candidate pool は targeting された全広告だが、学習は ranker がスコアをつけたものしかなく、バイアスが生じる原因となっている。結果を見ると、提案手法のドメイン適応も結構良いが、普通に in-batch negative sampling でも十分良さそうに見えてしまう。</p>


このサイトのホスト先を GitHub Pages から Cloudflare Pages へ移行した
2023-11-11T00:00:00+00:00
タイトルの通り、このサイトのホスティング先を Cloudflare Pages</a> へ移行した。
これまで使っていた GitHub Pages だと無料でプライベートリポジトリをホストできないのが地味に不満だった。書きかけの記事が見えてしまうし、個人情報を後で消そうとしてもコミット履歴が残ってしまう（まあ誰も訪問していないようなサイトだとは思うが）。
それから、Google domains が売却されるので、ドメインを Cloudflare に移管したのだが、良い機会なのでホスティング先も見直そうと思ったのもある。
選択肢としては他にも netlify とか色々あると思うが、更新頻度も訪問数も非常に小さいサイトなので正直どこを選んでも同じな気がする。</p>
移行は驚くほどスムーズで、ドキュメントをちゃんと読まずとも、コンソールに従ってリポジトリを登録するだけでデプロイできた。このサイトは Zola</a> でビルドしているので、以下のような設定をすれば良い</a></p>

Build command: zola build</code></li>
Build directory: public</code></li>
環境変数: ZOLA_VERSION=<好きな Zola version></code></li>
</ul>
一点はまったのはマシンタイプ。Latest である version 2 の Production build system には zola</code> バイナリが入っていないので、version 1 を選択する必要がある</a>。</p>
色々新しくすると気分も一新するので、もうちょっと気楽にブログを更新していきたいところ。</p>


使える電池を選ぶための最小の試行回数を求める
2023-06-30T00:00:00+00:00
The return of the graphs (and an interesting puzzle)</a> というブログ記事に載っていた問題が面白かったので紹介したい。日本語訳 (by DeepL) をすると</p>

あなたは8個の電池を与えられ、そのうち4個は良品、4個は消耗品であるが、見た目には違いがない。 あなたは懐中電灯を持っており、その懐中電灯を作動させるためには良品の電池2個が必要である。 あなたは懐中電灯を作動させたい。最悪の場合、懐中電灯が確実に作動するために、2本の電池を懐中電灯に入れる回数は何回必要か。</p>
</blockquote>
電池は全部で8個あり、そこから2つ選ぶ方法は28通りで、良品の4つから選ぶのは6通りなので、何も考えず懐中電灯に入れていっても23回目には確実に動作させることができる。</p>
が、もちろんもっと少ない試行回数で済ませることが可能で、正解は7だ。</p>
7回で十分なことはすぐにわかる。1から8までの番号を振った電池を、{1, 2, 3}</code>, {4, 5, 6}</code>, {7, 8}</code> の3グループに分けると、どこかのグループには少なくとも二つの良品が入る。なので、各グループ内で全ペアを試していけばよく、その回数は $3+3+1=7$ だ。</p>
6回では不十分なことの証明は少しややこしいので、冒頭のブログを見てほしい。</p>
面白いのはこの問題は、グラフの問題としてもアプローチできることだ。ノード数8のグラフを用意し、ノード $i$ と $j$ の間にエッジがあるとき、対応する電池を懐中電灯に入れると考える。</p>
例えば、7回の比較でうまくいくパターンは以下のようなグラフとして表現できる。</p>
  1      4    7</span></span>
 / \    / \   |</span></span>
2---3  5---6  8</span></span></code></pre>
そうすると、考えるべき問題は「ノードが8個、エッジが $E$ 本の無向グラフにおいて、ノードの部分集合でその間にエッジがないもの (independent set と呼ぶ) の最大サイズを3以下にすることができるか？」になる。もしサイズ4以上の independent set があれば、良品が全てそこに入った場合、良品ペアを発見できないことになる。逆にどんな independent set もサイズが3以下になるなら条件を満たせる。</p>
例えばエッジ7本でも</p>
  1      4    7</span></span>
 / \    / \</span></span>
2---3--5---6  8</span></span></code></pre>
のようなグラフを作ってしまうと、{1, 4, 7, 8}</code> がサイズ4の independent set になり、これらが良品の場合に発見できないことになる。</p>
このような問題に帰着できればあとは計算機の力でゴリ押して解くことができる。エッジの本数ごとにありうるグラフをすべて列挙して条件を満たすかを調べれば良い。具体的には、エッジが0本のグラフから初めて以下の手順を繰り返す：</p>

エッジ $E$ 本のグラフにあらゆるパターンでエッジを一本加えてエッジ $E+1$ 本のグラフをすべて列挙する。同型なグラフは一つにまとめる</li>
各グラフについてノードの independent set の最大サイズを求める</li>
エッジ $E+1$ 本のグラフ全体におけるこの最大サイズの最小値を求める</li>
この最小値が3以下になれば終了</li>
</ol>
ブログに載っていた Julia コードが自分の環境で動かなかったので、以下に Rust に書き直したものを貼っておく</p>
Graphs puzzle</a></p>


モデルが生成したデータを学習に繰り返し使うとどうなるか
2023-06-28T00:00:00+00:00
The Curse of Recursion: Training on Generated Data Makes Models Forget</a> という論文が Import AI で紹介されていて</a>面白かったのでざっくり自分でも確かみてみた。</p>
内容としては、モデルが生成したデータを別のモデルの学習に使うということを繰り返していくと、次第に分布の tail の情報が失われていって、出力の範囲が狭まってしまうという指摘。特に生成 AI の結果がインターネットに溢れ始めた昨今では重要になってくるはず。</p>
論文では混合ガウス分布等を例に取って、理論解析と数値解析をしており、この現象を model collapse と呼んでいる。数値解析の方は簡単にできそうだったので自分でも実装してみた。</p>
Python 実装</h2>
やりたいことは、一次元の混合ガウス分布のパラメータフィットをして、フィットされた分布から新しくデータを生成し、それを元に分布を再びフィットするということを何度も繰り返すことだ。</p>
具体的には、第 $i$ ステップの学習データがある時に、以下三つを混ぜて第 $i+1$ ステップの学習データを構成する</p>

第 $i$ ステップにおける学習データ</li>
第 $i$ ステップの学習データを使ってフィットした混合ガウス分布からのサンプル</li>
真の分布からのサンプル</li>
</ul>
$i=0$ では真の混合ガウス分布からのサンプルとし、三つのデータの比率は適当に変えて良い。Python で実装すると、以下の sample_next_gen</code> 関数のようになる:</p>
from</span> collections</span> import</span> namedtuple</span></span>
import</span> numpy</span> as</span> np</span></span>
import</span> matplotlib</span>.</span>pyplot</span> as</span> plt</span></span>
from</span> sklearn</span>.</span>mixture</span> import</span> GaussianMixture</span></span>
from</span> tqdm</span> import</span> tqdm</span></span>
</span>
GaussianMixtureParams</span> =</span> namedtuple</span>(</span>'</span>GaussianMixtureParams</span>'</span>,</span> (</span>'</span>mus</span>'</span>,</span> '</span>sigmas</span>'</span>,</span> '</span>mixture_ratio</span>'</span>)</span>)</span></span>
</span>
def</span> sample_from_gaussian_mixture</span>(</span>gm_params</span>,</span> num_samples</span>)</span>:</span></span>
    mus</span> =</span> np</span>.</span>array</span>(</span>gm_params</span>.</span>mus</span>)</span></span>
    sigmas</span> =</span> np</span>.</span>array</span>(</span>gm_params</span>.</span>sigmas</span>)</span></span>
</span>
    num_mixture</span> =</span> len</span>(</span>gm_params</span>.</span>mixture_ratio</span>)</span></span>
    mixture_idx</span> =</span> np</span>.</span>random</span>.</span>choice</span>(</span>num_mixture</span>,</span> size</span>=</span>num_samples</span>,</span> p</span>=</span>gm_params</span>.</span>mixture_ratio</span>)</span></span>
    standard_normal_noises</span> =</span> np</span>.</span>random</span>.</span>normal</span>(</span>size</span>=</span>num_samples</span>)</span></span>
    samples</span> =</span> mus</span>[</span>mixture_idx</span>]</span> +</span> standard_normal_noises</span> *</span> sigmas</span>[</span>mixture_idx</span>]</span></span>
</span>
    return</span> samples</span></span>
</span>
def</span> fit_gaussian_mixture</span>(</span>samples</span>,</span> n_components</span>,</span> random_state</span>=</span>0</span>)</span>:</span></span>
    gm</span> =</span> GaussianMixture</span>(</span>n_components</span>=</span>n_components</span>,</span> random_state</span>=</span>random_state</span>)</span>.</span>fit</span>(</span>samples</span>.</span>reshape</span>(</span>-</span>1</span>,</span>1</span>)</span>)</span></span>
</span>
    mus</span> =</span> gm</span>.</span>means_</span>.</span>reshape</span>(</span>-</span>1</span>)</span></span>
    sorted_idx</span> =</span> np</span>.</span>argsort</span>(</span>mus</span>)</span></span>
</span>
    gm_params</span> =</span> GaussianMixtureParams</span>(</span></span>
        gm</span>.</span>means_</span>.</span>reshape</span>(</span>-</span>1</span>)</span>[</span>sorted_idx</span>]</span>,</span></span>
        np</span>.</span>sqrt</span>(</span>gm</span>.</span>covariances_</span>)</span>.</span>reshape</span>(</span>-</span>1</span>)</span>[</span>sorted_idx</span>]</span>,</span></span>
        gm</span>.</span>weights_</span>[</span>sorted_idx</span>]</span></span>
    )</span></span>
</span>
    return</span> gm_params</span></span>
</span>
</span>
def</span> sample_next_gen</span>(</span>gm_params_org</span>,</span> gm_params_fitted</span>,</span> samples_current_gen</span>,</span> ratio_org</span>,</span> ratio_fitted</span>,</span> num_samples</span>)</span>:</span></span>
    #</span> オリジナルの分布、フィットされた分布、最新のサンプルからのサンプリングを使う</span></span>
    num_samples_org</span> =</span> int</span>(</span>num_samples</span> *</span> ratio_org</span>)</span></span>
    num_samples_fitted</span> =</span> int</span>(</span>num_samples</span> *</span> ratio_fitted</span>)</span></span>
    num_samples_current</span> =</span> num_samples</span> -</span> num_samples_org</span> -</span> num_samples_fitted</span></span>
    if</span> num_samples_current</span> <</span> 0</span>:</span></span>
        raise</span> ValueError</span>(</span>"</span>Invalid ratio</span>"</span>)</span></span>
</span>
    samples_org</span> =</span> sample_from_gaussian_mixture</span>(</span>gm_params_org</span>,</span> num_samples_org</span>)</span></span>
    samples_fitted</span> =</span> sample_from_gaussian_mixture</span>(</span>gm_params_fitted</span>,</span> num_samples_fitted</span>)</span></span>
    samples_current</span> =</span> np</span>.</span>random</span>.</span>choice</span>(</span>samples_current_gen</span>,</span> size</span>=</span>num_samples_current</span>,</span> replace</span>=</span>False</span>)</span></span>
</span>
    return</span> np</span>.</span>concatenate</span>(</span>[</span>samples_org</span>,</span> samples_fitted</span>,</span> samples_current</span>]</span>)</span></span></code></pre>結果</h2>
各回 $N=10000$ のサンプリングを合計2000ステップ実行してみた。真の混合ガウス分布は component 二つでパラメータは</p>

$\boldsymbol \mu = (-2, 2)$</li>
$\boldsymbol \sigma = (1, 1)$</li>
混合比 1:1</li>
</ul>
とした。簡単のため、学習データは全て前回ステップでフィットした分布から生成した。</p>
num_samples</span> =</span> 10000</span></span>
num_gen</span> =</span> 2000</span></span>
</span>
gm_params_org</span> =</span> GaussianMixtureParams</span>(</span>[</span>-</span>2</span>,</span> 2</span>]</span>,</span> [</span>1</span>,</span> 1</span>]</span>,</span> [</span>0.5</span>,</span> 0.5</span>]</span>)</span></span>
samples</span> =</span> sample_from_gaussian_mixture</span>(</span>gm_params_org</span>,</span> num_samples</span>)</span></span>
</span>
for</span> _</span> in</span> tqdm</span>(</span>range</span>(</span>num_gen</span>)</span>)</span>:</span></span>
    gm_params_fitted</span> =</span> fit_gaussian_mixture</span>(</span>samples</span>,</span> 2</span>)</span></span>
    samples</span> =</span> sample_next_gen</span>(</span>gm_params_org</span>,</span> gm_params_fitted</span>,</span> samples</span>,</span> 0.0</span>,</span> 1.0</span>,</span> num_samples</span>)</span></span></code></pre>
フィットされた分散の推移をプロットしてみると

となり確かにより狭い分布に向かっている様子がわかる。</p>
また初回のヒストグラムと、2000ステップ目でのヒストグラムを比較してみると、混合比も片方の山に偏っていっているように見える。
</p>
ただ、乱数シードを変えて何回か繰り返したところフィットされた分布がより広い方向に向かうこともあったし、三種類のデータの混合比によって model collapse の速度も変わったりした。どれくらい現実の LLM などに当てはまる結果なのかはわからない。</p>
ノートブックへのリンクはこちら</a>。間違いがあったら教えてください。</p>


ベイズファクターによる仮説検定
2023-05-03T00:00:00+00:00
ベイズ統計に基づく仮説検定の手法として、ベイズファクターと呼ばれる量を用いるものがある。頻度論による検定の問題を克服する手段としてベイズが挙げられるときは、ベイズファクターのような手法を想定している場面が多いと思う。仕事ではこれまで頻度論による検定で間に合ってしまう場面が多くあまり触れてこなかったが、最近になってようやく勉強したので、簡単にまとめておきたい。</p>

仮説検定の方法</h2>
ベイズファクターによる検定を理解するために、古典的な頻度論による手法や、ベイズ信用区間を利用したものとの比較をしてみる。解析的に計算可能な例を持ち出すのがわかりやすいと思うので、単純なコイン投げ実験を考えてみよう。コインを $N$ 回投げて、表が $m$ 回でたとき、このコインに歪みがないかどうかを判定したいとする。表の出る確率を $\mu$ とすると、</p>

帰無仮説 ($H_0$): $\mu = 0.5$</li>
対立仮説 ($H_1$): $\mu \neq 0.5$</li>
</ul>
のどちらを選ぶかという問題になる。</p>
頻度論の仮説検定</h3>
まずは頻度論による検定を簡単にまとめてみる。頻度論では $H_0$ のもとで検定統計量の従う確率分布を求め、観測値が得られる確率 (p-value</em>) を計算する。コイン投げの場合、二項検定</a>やカイ二乗検定</a>を実行すればよいだろう。P-value を計算し、それが事前に決めた基準値より小さい場合に、背理法的に $H_0$ を棄却する。</p>
頻度論による検定の特徴を挙げてみる:</p>

通常、統計量の従う分布が解析的に計算できる場合を扱う。そうでないときもサンプル数が多ければ、中心極限定理を介して適用できることもある。そのため、軽い数値計算で分析できることが多い。</li>
帰無仮説を棄却することはできても採択することはできない。頻度論の検定は背理法と同様の構造なので、「矛盾があるから仮定が偽」と結論することはできるが、積極的に帰無仮説が真と主張することはできない。</li>
（今回は深入りしないが）尤度原理</a>に反する。</li>
</ul>
次にベイズ統計を使った方法の一つである、信用区間を使った検定について見ていこう。</p>
ベイズ信用区間</h3>
ベイズ統計を使った検定方法の一つに、信用区間を利用するものがある。これは統計モデルのパラメータ推定の結果を検定に応用する手法である。</p>
ここではコイン投げ実験を二項分布でモデリングすることにしよう。表の出る確率 $\mu$ の事前分布はベータ分布に設定する
$$
\begin{aligned}
m &\sim \mathrm{B}(N, \mu), \\
\mu &\sim \mathrm{Beta}(a, b).
\end{aligned}
$$</p>
ここで $a$, $b$ はハイパーパラメータである。よく知られているように、ベータ分布は二項分布に対する共役事前分布になっており、事後分布が解析的に計算できる:
$$
\mu \sim \mathrm{Beta}(m+a, N-m+b).
$$</p>
仮説検定として使う際は、事後分布で $\mu$ が高い確率で含まれている区間（信用区間</a>）を計算し、そこに帰無仮説が含まれているかどうかを見る。今回の例では帰無仮説は $\mu=0.5$ であり、この値が信用区間の外にあれば帰無仮説を棄却することができる。逆に区間の内側にあれば、データが積極的に対立仮説を支持するとは言えないということになる。</p>
この信用区間を使った方法には以下の特徴がある</p>

$\mu$ の確率分布を計算できる。そのため得られた信用区間を「パラメータがある確率で含まれる区間」と素直に解釈できる。頻度論では $\mu$ は確率変数ではなかったので、分布を計算することはできない。頻度論でも同様の概念として信頼区間があるが、$\mu$ が確率変数ではないので解釈に注意する必要がある。</li>
一般的に、サンプル数が大きくなるほど、事前分布の影響が減少していく。上の例では $m, N-m \gg a, b$ であれば、結果は $a, b$ の選択に鈍感になる。</li>
事後分布を得るには、一般的には MCMC などの重い数値計算が必要となる。</li>
帰無仮説と対立仮説を対等に扱っているわけではない。上の例では、帰無仮説は $\mu=0.5$ という一点であるが、事後分布 $\mathrm{Beta}(m+a, N-m+b)$ のもとで $\mu$ がこの値を取る確率は常にゼロである。そのため帰無仮説を採択できるかどうかが焦点になるようなケースには向かないらしい。この点に関しては、Rouder, Haaf and Vandekerckhove (2018)</a> で詳しく論じられている。</li>
</ul>
ベイズファクター</h3>
概要</h4>
信用区間を使った方法は、ベイズ統計を使っているとはいえ、実質は確率分布のパラメータ推定だった。頻度論よりも得られた区間推定の結果が解釈しやすいなどの特徴はあるが、帰無仮説を積極的に採択する用途には向かないという事情は同じであった。</p>
一方、ベイズファクターはベイズ統計のモデル比較の考え方を用いる手法であり、この困難を克服する事ができる。</p>
我々が本当に評価したいのは、データ $\mathcal{D}$ が与えられた下での、仮説 $H$ の事後確率 $p(H|\mathcal{D})$ である。ベイズでは仮説は統計モデルで表す必要がある。ここではそれを $\mathcal{M}$ としよう。ベイズの定理を用いるとモデル $\mathcal{M}$ の事後確率は
$$
p(\mathcal{M}|\mathcal{D}) = \frac{p(\mathcal{D}|\mathcal{M})p(\mathcal{M})}{p(\mathcal{D})}
$$
とかける。帰無仮説と対立仮説でこの量の比を取ると</p>
$$
\frac{p(\mathcal{M}_1|\mathcal{D})}{p(\mathcal{M}_0|\mathcal{D})}
= \frac{p(\mathcal{D}|\mathcal{M}_1)}{p(\mathcal{D}|\mathcal{M}_0)}
\times \frac{p(\mathcal{M}_1)}{p(\mathcal{M}_0)}
$$
となる。この右辺第一項
$$
BF_{10} = \frac{p(\mathcal{D}|\mathcal{M}_1)}{p(\mathcal{D}|\mathcal{M}_0)}
$$
がベイズファクターと呼ばれる量であり、marginal likelihood $p(\mathcal{D}|\mathcal{M})$ の比になっている。$p(\mathcal{M}_1)/p(\mathcal{M}_0)$ はそれぞれのモデルに対する事前の信念の比であり、ベイズファクターが計算できると、このオッズをデータで更新できるということだ。</p>
特に、事前オッズを 1 にすれば、ベイズファクターが1からどれだけ離れているかで、仮説を検定できる。1 より十分大きければ対立仮説を採択し、逆に1より十分小さければ帰無仮説を採択する。これまでの手法はいわばヒューリスティックなのだが、ベイズファクターはモデルの事後確率を、確率の法則に従って自然に評価しているという点で、理論的には素直で気持ちが良い。</p>
ベイズファクターも検定である以上、値がいくつ以上なら仮説を採択・棄却するのかは業界や現場で基準を決める必要がある。例えば Kass and Raftery (1995)</a> によく使われる基準がいくつかまとめられている。</p>
Marginal likelihood</h4>
ベイズファクターで肝になるのは、marginal likelihood である。コイン投げの例を使ってこれを計算してみよう。信用区間の場合と同様に、コイン投げを二項分布でモデルすると、$\mathcal{M}_0$ のもとでは $\mu=1/2$ なので
$$
p(\mathcal{D}|\mathcal{M}_0) = \binom{N}{m}2^{-N}
$$
となる。</p>
一方、$\mathcal{M}_1$ の場合は話が少々複雑になる。$\mu \neq 1/2$ は連続量なので、以下の積分を実行しなければならない:
$$
p(\mathcal{D}|\mathcal{M}_1) = \int_0^1d\mu\ p(\mathcal{D}|\mathcal{M}_1, \mu)p(\mu|\mathcal{M}_1).
$$</p>
尤度 $p(\mathcal{D}|\mathcal{M}_1, \mu)$ には前と同様二項分布
$$
p(\mathcal{D}|\mathcal{M}_1, \mu) = \binom{N}{m}\mu^m(1-\mu)^{N-m},
$$
を採用し、$\mu$ の事前分布 $p(\mu|\mathcal{M}_1)$ にはベータ分布 $\mathrm{Beta}(a, b)$ を仮定してみよう。ベータ分布の密度関数は
$$
p(\mu|\mathcal{M}_1) = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)}\mu^{a-1}(1-\mu)^{b-1}
$$
である。すると marginal likelihood は解析的に計算できて
$$
p(\mathcal{D}|\mathcal{M}_1) = \frac{N!}{m!(N-m)!}\cdot\frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)}\cdot\frac{\Gamma(m+a)\Gamma(N-m+b)}{\Gamma(a+b+N)}
$$
となることがわかる。特に $m, N-m \gg a, b$ の場合は
$$
\ln p(\mathcal{D}|\mathcal{M}_1) \simeq \ln\left(\frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)}\right) +(a-1)\ln m+(b-1)\ln(N-m)-(a+b-1)\ln N,
$$
が得られる。</p>
事前分布への依存</h4>
この式を見ると分かる通り、marginal likelihood は、$\mu$ の事前分布 $p(\mu|\mathcal{M}_1)$ に依存する。特に、サンプル数が大きくなっても事前分布の影響が残り続ける</a>。もちろん事前分布としてベータ分布以外のものを選んでも良いので、この式で表されるよりもさらに大きい自由度がある。</p>
ベイズ信用区間の場合、サンプル数を増やしていくと事前分布の影響は減衰する傾向にあった。一方 marginal likelihood は尤度に事前分布をかけて積分した量なので、事前分布が狭すぎても広すぎても小さな値になってしまう。1</a></sup> そのため、例えば安易に無情報な分布を用いると、対立仮説の marginal likelihood が小さく評価され、帰無仮説がより支持されるようになる。</p>
このような性質があるため、ベイズファクターを仮説検定に用いる際には、事前分布の設計にドメイン知識を活用したり、コミュニティでの合意が取れているような分布を利用したりというのが大事になる。また事前分布の選択に関する sensitivity analysis も必要となる。一応この負担を軽減するために default prior と呼ばれる分布が設計されているらしいが、それらを盲目的に使うことへの批判</a>もある。Reddit</a> にも色々と事前分布に関する議論があるし、もう少し実務に近いところだと、BingのA/Bテストの事例</a>でも、過去の実験結果を使って事前分布を構成することの重要性が主張されている。</p>
その他の特徴</h4>
事前分布への敏感性以外に、ベイズファクターの特徴をまとめてみよう</p>

ベイズファクターでは、帰無仮説を採択することができる。これは、帰無仮説と対立仮説を対等に扱っているからである。</li>
信用区間の場合と同様、一般に積分を解析的に実行することはできないので何らかの数値計算が必要となる。R には、このための BayesFactor</a> というパッケージがある。</li>
任意の2つの仮説を比較できる。頻度論やベイズ信用区間の場合、帰無仮説と対立仮説のコイン投げ分布は同じ二項分布で、そのパラメータ $\mu$ の値がどうなるかを調べていたが、ベイズファクターでは全く異なる分布を持つようなモデル同士の比較も可能。</li>
</ul>
まとめ</h2>
以上の内容を表にまとめてみた</p>
手法</th> 帰無仮説の採択</th> 任意の仮説同士の比較</th> Prior への依存</th> 計算コスト</th></tr></thead>

頻度論</td> 不可</td> 不可</td> -</td> 小</td></tr>
ベイズ信用区間</td> 不可</td> 不可</td> 小</td> 一般に大</td></tr>
ベイズファクター</td> 可</td> 可</td> 大</td> 一般に大</td></tr>
</tbody></table>
個人的には、計算や sensitivity analysis の大変さを考慮すると、実用上ベイズファクターを使うのは、帰無仮説を採択したいなど他の手法では分析ができないケースに限られそうという印象。</p>
よくある RCT の効果検証であれば、効果量とサンプルサイズ設計をしっかりした上で頻度論の仮説検定を使うのが楽だと思う。</p>
References</h2>

Bayesian inference for psychology, part IV  parameter estimation and Bayes factors</a></li>
Chapter 15 Bayes factors | An Introduction to Bayesian Data Analysis for Cognitive Science</a></li>
Bayes factor</a></li>
仮説検定の手法ごとに結論がどれほど変わるか比べてみた | Blogicoffee</a></li>
ベイズ統計の仮説検定 - Qiita</a></li>
ベイズファクターによる心理学的仮説・モデルの評価</a></li>
</ul>

^{1</sup>
例えば PRML の三章に直感的な説明がある。</p>
</div>}
Python の型ヒントを理解したい
2023-01-13T00:00:00+00:00
仕事で漫然と Python に型ヒントをつけていると、type checker の警告を理解できないことがある。実際に遭遇したケースの一つをかなり単純化して書いてみよう</p>
x</span>:</span> list</span>[</span>float</span>]</span> =</span> [</span>1.0</span>]</span></span>
y</span>:</span> list</span>[</span>int</span>]</span> =</span> [</span>2</span>]</span></span>
x</span> =</span> y</span></span></code></pre>
これを mypy にチェックさせると1</a></sup></p>
main.py:3: error: Incompatible types in assignment (expression has type "List[int]", variable has type "List[float]")  [assignment]</span></span>
main.py:3: note: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance</span></span>
main.py:3: note: Consider using "Sequence" instead, which is covariant</span></span>
Found 1 error in 1 file (checked 1 source file)</span></span></code></pre>
という、型の不整合を示すエラーが出る。int</code> は float</code> に代入できるので、当然 list[int]</code> は list[float]</code> に代入できるのでは…？と思ってしまうのだが実はそうではないということらしい。2</a></sup>
エラーメッセージを読むと、"List" is invariant</code> や Consider using "Sequence" instead, which is covariant</code> とあるが、なんだそれとなってしまった。</p>
流石にこれは良くないと思ったので、読むべきとされていそうな資料を一通り読んでみた。具体的にはこの辺り</p>

PEP 483 – The Theory of Type Hints | peps.python.org</a></li>
PEP 484 – Type Hints | peps.python.org</a></li>
Variance of generic types - mypy 0.991 documentation</a></li>
Invariance vs covariance - mypy 0.991 documentation</a></li>
</ul>
これらに目を通すと分かるのだが、Python の型チェックでは、部分的に型がついているプログラムの解析をうまくやる必要があるという点で事情が多少複雑で、そのために gradual typing などという概念が発明されたりしている。しかし今回はそういう深い話には踏み込まず、冒頭の例がなぜダメなのかと言う点に絞って書こうと思う。</p>

なぜエラーが出るのか？</h2>
結論から話すと、冒頭のコードで mypy がエラーを出すのは、list[int]</code> が list[float]</code> の subtype ではない</strong>からだ。Subtype は文字通り型の間のヒエラルキーを表すもので、PEP 483 では、 second_type</code> という型が first_type</code> の subtype であることを以下のように定めている</p>


every value from second_type</code> is also in the set of values of first_type</code>; and</li>
every function from first_type</code> is also in the set of functions of second_type</code>.</li>
</ul>
</blockquote>
一つ目の条件は代入先の型が、代入元の値を持っていなければならないというもので、 int</code> と float</code> の関係を思い出せばわかりやすいだろう。3</a></sup> 冒頭に述べた list[int]</code> と list[float]</code> の例もこの条件は満たしている。</p>
問題になるのは二つ目だ。リストの場合これは、list[float]</code> に作用する関数は、list[int]</code> にも作用できなければならないということを言っている。つまり、代入元に作用する関数は、代入先にも作用できなければいけないということだ。しかし、例えば x.append(1.0)</code> という操作を考えてみると、これは list[float]</code> には行えるが、list[int]</code> には行えない。もちろん Python ランタイムでエラーが出るわけではないが、整数型リストに浮動小数を append すると、もはやそれは整数型のリストではなくなる、という意味で不正な処理となる。</p>
よって、冒頭の例は、"list[int]</code> は list[float]</code> の subtype ではないのでエラーが出る"ということになる。</p>
Generic type と variance</h2>
この話は generic type とその variance という概念と関係がある。</p>
PEP 483では、型を引数にとって別の具体型を返すもののことを generic type と定義している。これは難しい話ではなく、例えば list</code> は int</code> を取って、list[int]</code> を返すので generic type である。他にも dict</code> や tuple</code>, Union</code> なども馴染みのある generic type だと思う。</p>
型 t2</code> が型 t1</code> の subtype であるとし、また GenType</code> を好きな generic type であるとしよう。PEP 483 では、GenType[t1]</code> と GenType[t2]</code> の subtype 関係によって、generic type を以下のように分類している</p>


Covariant, if GenType[t2]</code> is a subtype of GenType[t1]</code> for all such t1</code> and t2</code>.</li>
Contravariant, if GenType[t1]</code> is a subtype of GenType[t2]</code> for all such t1</code> and t2</code>.</li>
Invariant, if neither of the above is true.</li>
</ul>
</blockquote>
これを型の variance と呼ぶ。Covariant なら t1</code>, t2</code> と同じ subtype 関係を、contravariant なら逆の subtype 関係を持ち、そのような綺麗な関係がない場合は invariant となる。</p>
この用語を使うと冒頭のリストのエラー例の原因は、"list</code> は invariant だから"と表現することもできる。これが mypy のメッセージ、 "List" is invariant</code> だ。</p>
冒頭の問題の解決法</h2>
Python のリストが invariant である根本原因はリストがミュータブルであることである。要素の置換や追加ができてしまうので、subtype の二つ目の条件が満たせない。</p>
冒頭の例では、個別の要素を操作しようとはしていないので、イミュータブルな配列としてアノテートすれば十分である。そのような用途として使える型に（mypy が suggest している）collections.abc</code> の Sequence</code> という型がある</p>
#</span> 以下は mypy のエラーが出ない</span></span>
x</span>:</span> Sequence</span>[</span>float</span>]</span> =</span> [</span>1.0</span>]</span></span>
y</span>:</span> Sequence</span>[</span>int</span>]</span> =</span> [</span>2</span>]</span></span>
x</span> =</span> y</span></span></code></pre>
この辺の事情は dict</code> のような他のミュータブルなコンテナ型でも同様で、要素の型の親子関係をそのまま引き継ぐことはできない（invariant である）。dict</code> のイミュータブル版が必要なら、Mapping</code> を使う。この手の情報はどこを参照すれば良いのかあまりわかっていないが、collections.abc のドキュメント</a>を見ると、コンテナ型の抽象基底クラスが列挙されている。</p>
Python は duck typing の精神を持つ言語なので、関数の引数には具体型をつけるより、所望のインターフェースを持つ抽象基底クラスを使う方が良いのだろう。4</a></sup></p>
また、Sequence</code> ではなく、あくまでリストとして扱いたければ、参照ではなくコピーを渡したり</p>
x</span>:</span> list</span>[</span>float</span>]</span> =</span> [</span>1.0</span>]</span></span>
y</span>:</span> list</span>[</span>int</span>]</span> =</span> [</span>2</span>]</span></span>
x</span> =</span> list</span>(</span>y</span>)</span></span></code></pre>
x</code> を Union</code> で表したり</p>
x</span>:</span> Union</span>[</span>list</span>[</span>float</span>]</span>,</span> list</span>[</span>int</span>]</span>]</span> =</span> [</span>1.0</span>]</span></span>
y</span>:</span> list</span>[</span>int</span>]</span> =</span> [</span>2</span>]</span></span>
x</span> =</span> y</span></span></code></pre>
という手段も考えられる（後者の例が subtype の条件を満たしていることはすぐ確認できる）。</p>
おまけ</h2>
Subtype や variance は Wikipedia にもページがあるくらいなので、Python に限った話ではなく、コンピュータ・サイエンス一般の概念なのだろう。
例えば Julia でも</p>
julia</span>></span> Int</span> <:</span> Real</span></span>
true</span></span></code></pre>
であるが（Julia では構造体の親子関係の判定に <:</code> というオペレーターが使える）</p>
julia</span>></span> Vector</span>{</span>Int</span>}</span> <:</span> Vector{Real}</span></span>
false</span></span></code></pre>
である。これはまさに Vector</code> が invariant だということだ。</p>
ちなみに Julia では Real</code> の子を要素に持つようなベクトルの集合を Vector{<:Real}</code> と書ける。そのため以下は true になる。</p>
julia</span>></span> Vector</span>{</span>Int</span>}</span> <:</span> Vector{<:Real}</span></span>
true</span></span></code></pre>
おそらく Python でいう Union[list[int], list[float]]</code> のようなものを表現しているのだろう。</p>

^1</sup>https://mypy-play.net</a> でブラウザから試せる。</p>
</div>
^{2</sup>
もちろんこれは mypy のような static type checker が出すエラーの話であって、冒頭のコードは普通の Python のコードとしては何も問題なく動作する。</p>
</div>}^3</sup>という言い方は多分不正確で、stack overflow</a> で指摘されているように、float</code> が持つ、is_integer()</code> などを int</code> は持っていない。そのため、上の定義に照らすと、int</code> は float</code> の subtype ではない。実際、PEP 484 - The numeric tower</a> では float</code> とアノテーションがついたオブジェクトには、int</code> が代入できるよう "shortcut" を導入しようと言っている。同じことが Mypy では duck type compatibility</a> として説明されている。その一方で、PEP 483 では、説明のしやすさのためなのか、int</code> は float</code> の subtype であるかのような書き振りになっている。ここでもそれにならって、あまり厳密にならず、int</code> は float</code> の subtype であるとして話を進めていこうと思う。</p>
</div>
^{4</sup>
実際 PEP 483 には関数の type annotation について "choose the most general type for every argument, and the most specific type for the return value." とある</p>
</div>}


Rust 製の静的サイトジェネレータ Zola を使ってみる
2023-01-07T00:00:00+00:00
年末年始にこのブログの SSG を Zola</a> に移行してみた。</p>
Zola は Rust 製の SSG で、シングルバイナリなので依存関係の管理が不要だったり、ビルドが高速であったりということを売りにしているよう。</p>
このブログは今まで Julia 製の SSG である Franklin.jl</a> で作っていた。Franklin の一番のメリットは数式の記述が楽というところにある。他のツールを使っていると、HTML と LaTeX の文法が競合して思った通りに表示されず、原因を探して適宜エスケープを追加するというような泥臭いプロセスが付き物だった。しかし、Franklin のパーサーはよくできていて、.tex</code> ファイルに書いたような数式をそのまま移行してくることができる。数式中心のシンプルな文章を書く SSG としては優れていると思う。</p>
一方で色々触っていると Franklin ではブログらしい機能を実装するのがなかなか難しいということもわかってきた。例えば pagination や "read more" リンク・多言語対応などを追加してみたかったが、どうすれば良いかわからなかった。きっとできるんじゃないかとは思うが、ドキュメントや例が見つからず、かと言って自分で実装を読むにはちょっと重い。</p>
そう言う事情もあって別の SSG を使ってみようと思って Zola を試してみたらなかなか使い勝手が良かったので、メモを残しておこうと思う。</p>

Zola のインストール</h2>
ドキュメント</a> にあるように、バイナリが配布されているので適当に落としてくる。Mac であれば brew install zola</code> で入る。</p>
基本的な使い方</h2>
基本的な使い方はドキュメントの overview</a> を見てほしい。Zola の標準的なディレクトリ構成を引用しておく。</p>
├── config.toml</span></span>
├── content/</span></span>
│   └── blog/</span></span>
│       ├── _index.md</span></span>
│       ├── first.md</span></span>
│       └── second.md</span></span>
├── sass/</span></span>
├── static/</span></span>
├── templates/</span></span>
│   ├── base.html</span></span>
│   ├── blog-page.html</span></span>
│   ├── blog.html</span></span>
│   └── index.html</span></span>
└── themes/</span></span></code></pre>Section と page</h3>
Zola の基本的な構成要素として、section と page というものがある。おおむね、</p>

section: 記事を一覧にしてまとめるページ</li>
page: 個別記事のページ</li>
</ul>
というような理解で良いと思う。</p>
コンテンツは /content/</code> 以下に配置する。上に書いた例では blog という section があり、section ページの設定が /content/blog/_index.md</code>、個別の page 内容が /content/blog/first.md</code> などに入っている。</p>
テンプレート</h3>
ブログのデザインは /templates/</code> 以下の html ファイルと sass で指定する。これらの html では、config.toml</code> などで定義されたパラメータが使用でき、Rust 製のテンプレートエンジンである Tera</a> で処理される。この辺はドキュメントがあまりまとまっていないため、何か実装したい機能があれば公開されているテーマ</a>から似たようなものを探して実装を見てみるのが手っ取り早いと思う。</p>
参考記事</h3>
ここではこれ以上 Zola の細かい説明はしないが、公式のドキュメント以外にも、以下のブログ記事が参考になったので貼っておく</p>

Rust 製スタティックサイトジェネレーター Zola をつかう | hiromasa.another :o)</a></li>
</ul>
こんな時どうする？</h2>
ここでは自分が必要になった個別の機能の実装方法について、備忘録も兼ねて紹介する。</p>
Pagination を入れたい</h3>
ドキュメント</a> に pagination のやり方が書いてあるが、少し不親切だと思う。</p>
Paginate したいセクションがある場合は、まず _index.md</code> ファイルの paginate_by</code> 変数を正の値にする。例えばブログ記事を日付順に、ページあたり10記事表示したいなら、/content/blog/_index.md</code> の front matter を以下のようにする。</p>
+++</span></span>
sort_by = "date"</span></span>
paginate_by = 10</span></span>
+++</span></span>
...</span></span></code></pre>
これでテンプレート内で paginator</code> が使えるようになる。例えばトップページに記事へのリンクを貼るには /templates/index.html</code> に以下を追加すれば良い。</p>
...</span></span>
{% for page in paginator.pages %}</span></span>
<</span>ul</span>></span></span>
    <</span>li</span>></span></span>
        <</span>a</span> href</span>=</span>"</span>{{ page.permalink | safe }}</span>"</span>></span>{{ page.title }}</span></</span>a</span>></span></span>
    </</span>li</span>></span></span>
</</span>ul</span>></span></span>
{% endfor %}</span></span></code></pre>言語ごとにリンク先を切り替えたい</h3>
日本語ページを見ているときに、"About" をクリックすると、日本語の About ページへ、英語で見ているときは英語の About へ移動するようにしたい。そのような場合は、get_url</code> に lang</code> パラメータを与える。</p>
<</span>div</span> class</span>=</span>"</span>site_title</span>"</span>></span></span>
    <</span>div</span> class</span>=</span>"</span>menu</span>"</span>></span></span>
      <</span>a</span> href</span>=</span>"</span>{{ get_url(path=</span>"</span>@</span>/about/_index.md",</span> lang</span>=</span>lang)</span> }}</span>"</span>></span>{{ trans(key="about", lang=lang) }}</span></</span>a</span>></span></span>
    </</span>div</span>></span></span>
</</span>div</span>></span></span></code></pre>セクションのディレクトリ構造に階層を設けたい</h3>
/content/</code> に以下のような階層を設けたい場合、</p>
├── content/</span></span>
│   └── blog/</span></span>
│       ├── 2022/</span></span>
│       │    ├── _index.md</span></span>
│       │    ├── first.md</span></span>
│       │    └── second.md</span></span>
│       ├── 2023/</span></span>
│       │    ├── _index.md</span></span>
│       │    ├── first.md</span></span>
│       │    └── second.md</span></span>
│       ├── index.md</span></span></code></pre>
子階層の /content/2022/_index.md</code> などに transparent=true</code> を設定する。</p>
+++</span></span>
transparent = true</span></span>
+++</span></span></code></pre>リダイレクトを設定したい</h3>
他のブログサービスや SSG から乗り換える場合、パスの構造が変わってしまうのでリダイレクトを設定する必要がある。これはページの aliases</code> で設定可能</p>
+++</span></span>
title</span> =</span> "</span>タイトル</span>"</span></span>
aliases</span> =</span> [</span>"</span>/old/path/to/this/article</span>"</span>,</span> "</span>/old/path/to/this/article/2</span>"</span>]</span></span>
+++</span></span>
...</span></span></code></pre>脚注表示のバグを直したい</h3>
この issue</a> に上がっている通り、現在 footnote 機能にいくつかバグがある。まだ完全には解決されていないようで、issue 内では javascript を使った一時的な workaround が紹介されている。</p>
Javascript ファイルを static/footnote.js</code> などとして保存し、テンプレート html に <script type="text/javascript" src="/footnote.js"></script></code> を追加すると良い。</p>
目次を好きな位置に表示したい</h3>
Zola 標準の機能で生成できる目次は、ページ内の好きな位置に挿入することができない。ちょっと面倒だが、以下で紹介されているマクロを用いる</p>
Choose table of content position - Zola</a></p>
このブログでは少し修正して</p>
{%- macro toc(toc, level, depth) %}</span></span>
{%- if level == 1 %}</span></span>
<</span>div</span> class</span>=</span>"</span>toc</span>"</span>></span></span>
<</span>h3</span>></span>Table of contents</span></</span>h3</span>></span></span>
{%- endif %}</span></span>
<</span>ul</span> class</span>=</span>"</span>h{{ level }}</span>"</span>></span></span>
{%- for h in toc %}</span></span>
    <</span>li</span>></span></span>
        <</span>a</span> href</span>=</span>"</span>{{ h.permalink | safe }}</span>"</span>></span>{{ h.title }}</span></</span>a</span>></span></span>
        {% if h.children and level </span><</span> depth -%}</span></span>
            {{ self::toc(toc=h.children, level=level+1, depth=depth, heading=false) }}</span></span>
        {%- endif %}</span></span>
    </</span>li</span>></span></span>
    {%- endfor %}</span></span>
{%- if level != 1 %}</span></span>
</</span>ul</span>></span></span>
{%- endif %}</span></span>
{%- if level == 1 %}</span></span>
</</span>div</span>></span></span>
{%- endif %}</span></span>
{%- endmacro %}</span></span>
</span>
</span>
{# =================== #}</span></span>
{# === replace toc === #}</span></span>
{# =================== #}</span></span>
{%- macro format_content(resource) %}</span></span>
 {%- set content = resource.content %}</span></span>
 {%- if content is containing("</span><!--</span> toc </span>--></span>") %}</span></span>
  {%- set content = content | replace(from="</span><!--</span> toc </span>--></span>", to=self::toc(toc=resource.toc, level=1, depth=resource.extra.toc_depth | default(value=1))) %}</span></span>
 {%- endif -%}</span></span>
 {{ content | safe }}</span></span>
{%- endmacro %}</span></span></code></pre>
という形で使っている。これでマークダウン中に <!-- toc --></code> と書くと、その部分に目次を挿入してくれる。</p>
GHA でカスタムドメインを使ってデプロイしたい</h3>
README</a> にこっそり書いてあるように、/static/CNAME</code> というテキストファイルを作ってドメイン名を書いておくと、自動で処理してくれる。</p>
まとめ</h2>
Zola で一通りブログを書き換えてみたが、求めている機能が十分あり、ドキュメントや example を漁ればそんなに詰まることなく実装できて今のところ満足している。Franklin を使っているときは、毎回 Julia のランタイムを起動する必要があったりするのも地味に面倒だったが、バイナリを一つインストールすれば使えるというのもシンプルで良い。</p>
一方数式の記述については Mathjax を普通に使うだけになったので、Franklin 時代に比べ多少面倒になった。以前書いた記事の数式も結構書き換える必要があった。</p>
今後しばらくは使い倒していきたい。</p>


Julia/Lux.jl で拡散モデルを実装する
2022-12-14T00:00:00+00:00
この記事は JuliaLang Advent Calendar 2022</a> 14日目の記事である。</p>
最近趣味で、Lux.jl</a> という Julia 製のニューラルネットのフレームワークを使って拡散モデルを実装していた。</p>



  



  



  



  
    
      
      yng87/DDIM.jl</div>
      
      Lux.jl implementation of Denoising Diffusion Implicit Models.</div>
      
      
      Julia</div>
      
    </div>
  </a>
</div>
学習データには Oxford 102 flowers dataset</a> という花のデータセットを使っていて、うまく学習できると以下のような画像が生成できる</p>
</p>
使える計算リソースのせいであまり解像度の高いものは作れないが、それでもそれっぽい画像は生成できるようになった。</p>
それで作ったものを適当に twitter に貼ったり、（@MathSorcerer さんの勧めで）Julia discourse に投げたり</a>していたら、最終的に Lux.jl の公式 example</a> にコミットすることになり、先日無事マージされた。</p>
Julia は個人的に良い言語だとずっと思っているのだけど、機械学習分野では python エコシステムの圧倒的な物量の前にいまいち目立たない存在となっている。それでも最近は、GPU を使った深層学習までできるくらいには色々揃ってきているよう。</p>
今回は拡散モデルという題材で、 Lux.jl やその周辺のエコシステムを使って深層学習モデルを実装する方法を紹介したい。Julia の深層学習関連の記事は日本語でもいくつかあるが、自分でレイヤーをカスタマイズしないといけないようなそれなりに複雑なネットワークを構築している例は少ない。この記事が実践的な深層学習モデルを実装する例として参考になれば良いと思う。</p>
Disclaimer だが、自分の Julia の経験は、博士課程の研究で使った＋趣味で時々触っている程度なので、内容に間違いがあったらコメントしてほしい。あと、タイトルに拡散モデルと書きながら、拡散モデルについての話題はほとんど出てこないのも許してほしい。</p>

拡散モデルについて</h2>
拡散モデルは目下大流行中の深層生成モデルで、ランダムな入力から少しずつノイズを除去することで高品質の画像を得ることができる。ググってもらえれば英語でも日本語でも記事はたくさんヒットすると思うので、ここで詳しくは説明しない。一応自分が書いた記事</a>もある。</p>
今回は Keras の example</a> を Julia で再実装した。</p>
ここで扱っているのは Denoising Diffusion Implicit Models (DDIM)</a> というもので、それ以前の DDPM などの拡散モデルからの生成をより高速に行えるように改良したものになっている。</p>
また Jax での実装（daigo0927/jax-ddim</a>）もあったので参考にしている。</p>
Julia の深層学習関連のパッケージ</h2>
Flux と Lux</h3>
Julia にはいくつかニューラルネットワーク用のパッケージが存在するが、中でも最も有名なのは Flux.jl</a> だろう。これは立ち位置としては TensorFlow や PyTorch に近い。これらが、モデルをクラスで定義するのと同様に、Flux では NN レイヤーを trainable パラメータを持った構造体で定義する。またデータローダーや activation function も搭載している（実際には NNlib.jl や MLUtils.jl を re-export している）。</p>
一方今回扱う Lux.jl は python でいうと Jax/Haiku</a> などのフレームワークに近い。Lux が提供するのはレイヤーの管理機能のみであり、その他の機能は外部のパッケージと連携する必要がある。また、Lux でのレイヤー構造体はモデルの構造を決めるための情報（例えば入力と出力の次元数）だけを保持しており、内部に trainable なパラメータを持たない。Lux のドキュメント</a>には</p>


Functional Design – Pure Functions and Deterministic Function Calls.</li>
No more implicit parameterization.</li>
Compiler and AD-friendly Neural Networks</li>
</ul>
</blockquote>
とあり、Jax 周りのフレームワークと同様に pure function を志向していることがわかる。</p>
このような設計を採用した理由についてはドキュメントの Why use Lux over Flux?</a> によくまとまっていて、かいつまんでまとめると、パラメーターを explicit に扱う方が（Julia の機械学習界隈で盛んな）Neural ODE などとの相性が良くなるかららしい。</p>
深層学習のエコシステム</h3>
Julia のエコシステムには composability 1</a></sup> と呼ばれる設計思想のようなものがあって、独立した小さなパッケージをユーザーが自由に組み合わせて開発することが良しとされている。上で書いたように Lux.jl 単独では深層学習はできず、データローダーであったりオプティマイザであったり、はたまた画像や言語処理用の機能は別のパッケージを利用して実装する必要がある。この辺りは、TensorFlow や PyTorch とは対照的であると思う。</p>
ということで、ここでは Julia でニューラルネットを実装するときによく使うパッケージをリストアップする</p>

Zygote.jl</a>: Backward の自動微分のデファクトスタンダード。TensorFlow や PyTorch ではそれぞれ独自の tensor 型を定義してその上で微分を行うが、Zygote は Julia の標準の配列などを使ってそのまま微分ができるのが特徴。</li>
NNlib.jl</a>: Activation function などが実装されている。先述のように Zygote を使えば自分で好きに定義した関数で微分ができるのだが、同じ関数でも実装方法によって numerical stability に差が出ることもあるので、NNlib に存在するものは積極的に利用した方が良い。</li>
MLUtils.jl</a>: データローダーなどの utility が実装されている。PyTorch のデータローダーのように、スレッド並列でデータを読み込む機能もついている。</li>
Optimisers.jl</a>: 名前の通りオプティマイザの実装がある。</li>
</ul>
Lux.jl でニューラルネットワークを実装する</h2>
前置きが長くなってしまったが、DDIM の実装を通して、Lux の使い方を見ていこう。なお DDIM やそのバックボーンである UNet などの内容はとても説明しきれないので、上に貼った Keras の example やリポジトリの実装を参考にしてほしい。ここでは Lux を使う上でのキーポイントに絞って記すことにする。</p>
モデルの定義</h3>
実装済みのレイヤーを利用する</h4>
UNet アーキテクチャの部品の一つである residual_block</code> の定義を見てみよう。これは入力と出力の画像のチャネル数をもとに、レイヤーを返す関数である。</p>
function</span> residual_block</span>(</span>in_channels</span>::</span>Int</span>,</span> out_channels</span>::</span>Int</span>)</span></span>
    if</span> in_channels </span>==</span> out_channels</span></span>
        first_layer </span>=</span> NoOpLayer</span>(</span>)</span></span>
    else</span></span>
        first_layer </span>=</span> Conv</span>(</span>(</span>3</span>,</span> 3</span>)</span>,</span> in_channels </span>=></span> out_channels</span>;</span> pad</span>=</span>SamePad</span>(</span>)</span>)</span></span>
    end</span></span>
</span>
    return</span> Chain</span>(</span>first_layer</span>,</span></span>
                 SkipConnection</span>(</span>Chain</span>(</span>BatchNorm</span>(</span>out_channels</span>;</span> affine</span>=</span>false</span>,</span> momentum</span>=</span>0.99</span>)</span>,</span></span>
                                      Conv</span>(</span>(</span>3</span>,</span> 3</span>)</span>,</span> out_channels </span>=></span> out_channels</span>;</span> stride</span>=</span>1</span>,</span></span>
                                           pad</span>=</span>(</span>1</span>,</span> 1</span>)</span>)</span>,</span> swish</span>,</span></span>
                                      Conv</span>(</span>(</span>3</span>,</span> 3</span>)</span>,</span> out_channels </span>=></span> out_channels</span>;</span> stride</span>=</span>1</span>,</span></span>
                                           pad</span>=</span>(</span>1</span>,</span> 1</span>)</span>)</span>)</span>,</span> +</span>)</span>)</span></span>
end</span></span></code></pre>
畳み込みやバッチ正規化などよく使うレイヤーは、Conv</code> や BatchNorm</code> として Lux に実装済み。現状実装されているレイヤーはドキュメント</a>を参照してほしい。</p>
Lux ではレイヤーを直列に繋げる場合、Chain</code> を使う。Keras の Sequential</code> のようなイメージ。また SkipConnection(some_layer, +)</code> で $\boldsymbol x + f(\boldsymbol x)$ 型のスキップコネクションが定義できる。</p>
今回は、入力チャネル数 in_channel</code> と出力チャネル数 out_channel</code> が異なる場合のみ、チャネル数を揃えるための畳み込み層を追加しているが、このような分岐は if</code> と NoOpLayer</code> を Chain</code> と組み合わせて実現できる。</p>
Keras の functional API や PyTorch-like なモデルの定義をするには、以下で説明するようなカスタムレイヤーを実装する必要がある。</p>
カスタムレイヤーを実装する</h4>
単純な構造のモデルは上のように実装すれば良いが、今回使う UNet はダウンサンプリング・ブロックとアップサンプリング・ブロックとの間でスキップコネクションが発生し、単純に Chain</code> と SkipConnection</code> を組み合わせるだけで実装するのは難しい。また DDIM は入力画像にノイズを付与して UNet を呼び出すというような処理が必要になる。このようなケースでは自前でレイヤーを定義して柔軟な処理を実装する方が良いだろう。今回実装した DenoisingDiffusionImplicitModel</code> もカスタムレイヤーを使用しており、概略を示すと以下のようになる。</p>
struct</span> DenoisingDiffusionImplicitModel</span>{</span>T</span> <:</span> AbstractFloat</span>}</span> <</span>:</span></span>
       Lux</span>.</span>AbstractExplicitContainerLayer</span>{</span>(</span>:unet</span>,</span> :batchnorm</span>)</span>}</span></span>
    unet</span>::</span>UNet</span></span>
    batchnorm</span>::</span>BatchNorm</span></span>
    min_signal_rate</span>::</span>T</span></span>
    max_signal_rate</span>::</span>T</span></span>
end</span></span>
</span>
#</span> コンストラクタ</span></span>
function</span> DenoisingDiffusionImplicitModel</span>(</span>image_size</span>::</span>Tuple{Int, Int}</span>;</span></span>
                                         channels</span>=</span>[</span>32</span>,</span> 64</span>,</span> 96</span>,</span> 128</span>]</span>,</span> block_depth</span>=</span>2</span>,</span></span>
                                         min_freq</span>=</span>1.0f0</span>,</span> max_freq</span>=</span>1000.0f0</span>,</span></span>
                                         embedding_dims</span>=</span>32</span>,</span> min_signal_rate</span>=</span>0.02f0</span>,</span></span>
                                         max_signal_rate</span>=</span>0.95f0</span>)</span></span>
    unet </span>=</span> UNet</span>(</span>...</span>)</span></span>
    batchnorm </span>=</span> BatchNorm</span>(</span>...</span>)</span></span>
</span>
    return</span> DenoisingDiffusionImplicitModel</span>(</span>unet</span>,</span> batchnorm</span>,</span> min_signal_rate</span>,</span></span>
                                           max_signal_rate</span>)</span></span>
end</span></span>
</span>
#</span> モデル呼び出し</span></span>
function</span> (</span>ddim</span>::</span>DenoisingDiffusionImplicitModel{T}</span>)</span>(</span>x</span>::</span>Tuple</span>{</span>AbstractArray</span>{</span>T</span>,</span> 4</span>}</span>,</span></span>
                                                             AbstractRNG</span>}</span>,</span> ps</span>,</span></span>
                                                    st</span>::</span>NamedTuple</span>)</span> where</span> {</span></span>
                                                                           T </span><</span>:</span></span>
                                                                           AbstractFloat</span>}</span></span>
    images</span>,</span> rng </span>=</span> x</span></span>
    #</span> noises を生成し、images + noises から pred_noises, pred_image を得る</span></span>
    ...</span></span>
    return</span> (</span>noises</span>,</span> images</span>,</span> pred_noises</span>,</span> pred_images</span>)</span>,</span> st</span></span>
end</span></span>
</span></code></pre>
Lux のレイヤーは全て Lux.AbstractExplicitLayer</code> の subtype になる。レイヤーが内部に別のレイヤーを含んでいる場合は、Lux.AbstractExplicitContainerLayer</code> の subtype にする。さらに (:unet, :batchnorm)</code> のようにパラメータを与えることで、モデルパラメータの追跡を容易にできる。この辺の書き方は少し面倒かもしれない。カスタムレイヤーについて詳しくはドキュメント</a>を参照してほしい。</p>
DDIM 呼び出しの入力となっている ps</code> はモデルの trainable なパラメータ、st</code> はバッチ正規化レイヤーの statitics 情報など、レイヤーの状態を表す trainable でない変数である。Lux のレイヤーはこの例のように、(data, model parameter, model state)</code> の三つ組をレイヤーの入力とし、(result, updated state)</code> を返すように実装する。ps</code> や st</code> の初期化についてはこの後説明する。</p>
ロス関数</h3>
上で述べたように、Zygote は好きな Julia の関数を微分してくれるので、モデルの出力を使ってロスを好きに定義する。ここではモデル ddim</code> と共にパラメータ ps</code> と状態 st</code> を明示的に受け取る次のような関数を定義した。</p>
function</span> compute_loss</span>(</span>ddim</span>::</span>DenoisingDiffusionImplicitModel{T}</span>,</span> images</span>::</span>AbstractArray{T, 4}</span>,</span></span>
                      rng</span>::</span>AbstractRNG</span>,</span> ps</span>,</span> st</span>::</span>NamedTuple</span>)</span> where</span> {</span>T</span> <:</span> AbstractFloat</span>}</span></span>
    (</span>noises</span>,</span> images</span>,</span> pred_noises</span>,</span> pred_images</span>)</span>,</span> st </span>=</span> ddim</span>(</span>(</span>images</span>,</span> rng</span>)</span>,</span> ps</span>,</span> st</span>)</span></span>
    noise_loss </span>=</span> mean</span>(</span>abs</span>.</span>(</span>pred_noises </span>-</span> noises</span>)</span>)</span></span>
    image_loss </span>=</span> mean</span>(</span>abs</span>.</span>(</span>pred_images </span>-</span> images</span>)</span>)</span></span>
    loss </span>=</span> noise_loss </span>+</span> image_loss</span></span>
    return</span> loss</span>,</span> st</span></span>
end</span></span></code></pre>学習</h3>
データローダー</h4>
データローダーは MLUtils.jl の DataLoader</code> を使うのが便利。以下のようにデータセットと、バッチ化のオプションを渡す。</p>
ds </span>=</span> ImageDataset</span>(</span>dataset_dir</span>,</span> x </span>-></span> preprocess_image</span>(</span>x</span>,</span> image_size</span>)</span>,</span> true</span>)</span></span>
data_loader </span>=</span> DataLoader</span>(</span>ds</span>;</span> batchsize</span>=</span>batchsize</span>,</span> partial</span>=</span>false</span>,</span> collate</span>=</span>true</span>,</span></span>
                            parallel</span>=</span>true</span>,</span> rng</span>=</span>rng</span>,</span> shuffle</span>=</span>true</span>)</span></span></code></pre>
DataLoader</code> に渡すデータセットは Julia の構造体で、以下の二つのメソッドを備えていればなんでも良い</p>

length(ds::ImageDataset)</code>: データセットのサイズ</li>
getindex(ds::ImageDataset, i::Int)</code>: i</code> 番目のデータの取得</li>
</ul>
そのため RAM に乗り切らないデータはディスクから読むというような状況にも対応できる。PyTorch のデータローダーを意識して設計されている気がする。</p>
初期化</h4>
モデルの初期化は Lux.setup</code> で、オプティマイザの初期化は Optimisers.setup</code> で行う。</p>
rng </span>=</span> Random</span>.</span>MersenneTwister</span>(</span>)</span></span>
</span>
ddim </span>=</span> DenoisingDiffusionImplicitModel</span>(</span>(</span>image_size</span>,</span> image_size</span>)</span>;</span> channels</span>=</span>channels</span>,</span></span>
                                        block_depth</span>=</span>block_depth</span>,</span> min_freq</span>=</span>min_freq</span>,</span></span>
                                        max_freq</span>=</span>max_freq</span>,</span> embedding_dims</span>=</span>embedding_dims</span>,</span></span>
                                        min_signal_rate</span>=</span>min_signal_rate</span>,</span></span>
                                        max_signal_rate</span>=</span>max_signal_rate</span>)</span></span>
ps</span>,</span> st </span>=</span> Lux</span>.</span>setup</span>(</span>rng</span>,</span> ddim</span>)</span> .|</span>></span> gpu</span></span>
</span>
opt </span>=</span> AdamW</span>(</span>learning_rate</span>,</span> (</span>9.0f-1</span>,</span> 9.99f-1</span>)</span>,</span> weight_decay</span>)</span></span>
opt_st </span>=</span> Optimisers</span>.</span>setup</span>(</span>opt</span>,</span> ps</span>)</span> |></span> gpu</span></span></code></pre>
|> gpu</code> でパラメータ達を GPU に転送する。なお GPU が利用可能でないときは gpu</code> は何もせず入力をそのまま返すので、デバイスに合わせて gpu</code>, cpu</code> を書き換える必要はない。</p>
学習ループ</h4>
学習ループの概略は以下のような感じ。</p>
function</span> train_step</span>(</span>ddim</span>::</span>DenoisingDiffusionImplicitModel{T}</span>,</span> images</span>::</span>AbstractArray{T, 4}</span>,</span></span>
                    rng</span>::</span>AbstractRNG</span>,</span> ps</span>,</span> st</span>::</span>NamedTuple</span>,</span></span>
                    opt_st</span>::</span>NamedTuple</span>)</span> where</span> {</span>T</span> <:</span> AbstractFloat</span>}</span></span>
    (</span>loss</span>,</span> st</span>)</span>,</span> back </span>=</span> Zygote</span>.</span>pullback</span>(</span>p </span>-></span> compute_loss</span>(</span>ddim</span>,</span> images</span>,</span> rng</span>,</span> p</span>,</span> st</span>)</span>,</span> ps</span>)</span></span>
    gs </span>=</span> back</span>(</span>(</span>one</span>(</span>loss</span>)</span>,</span> nothing</span>)</span>)</span>[</span>1</span>]</span></span>
    opt_st</span>,</span> ps </span>=</span> Optimisers</span>.</span>update</span>(</span>opt_st</span>,</span> ps</span>,</span> gs</span>)</span></span>
    return</span> loss</span>,</span> ps</span>,</span> st</span>,</span> opt_st</span></span>
end</span></span>
...</span></span>
rng_gen </span>=</span> Random</span>.</span>MersenneTwister</span>(</span>)</span></span>
Random</span>.</span>seed!</span>(</span>rng_gen</span>,</span> 0</span>)</span></span>
...</span></span>
for</span> epoch </span>in</span> 1</span>:</span>epochs</span></span>
    losses </span>=</span> [</span>]</span></span>
    iter </span>=</span> ProgressBar</span>(</span>data_loader</span>)</span></span>
</span>
    st </span>=</span> Lux</span>.</span>trainmode</span>(</span>st</span>)</span></span>
    for</span> images </span>in</span> iter</span></span>
        images </span>=</span> images </span>|></span> gpu</span></span>
        loss</span>,</span> ps</span>,</span> st</span>,</span> opt_st </span>=</span> train_step</span>(</span>ddim</span>,</span> images</span>,</span> rng</span>,</span> ps</span>,</span> st</span>,</span> opt_st</span>)</span></span>
        push!</span>(</span>losses</span>,</span> loss</span>)</span></span>
        set_description</span>(</span>iter</span>,</span> "</span>Epoch: </span>$</span>(</span>epoch</span>)</span> Loss: </span>$</span>(</span>mean</span>(</span>losses</span>)</span>)</span>"</span>)</span></span>
    end</span></span>
</span>
    #</span> 各エポックでの推論例の保存</span></span>
    st </span>=</span> Lux</span>.</span>testmode</span>(</span>st</span>)</span></span>
    generated_images</span>,</span> _ </span>=</span> generate</span>(</span>ddim</span>,</span> Lux</span>.</span>replicate</span>(</span>rng_gen</span>)</span>,</span> #</span> to get inference on the same noises</span></span>
                                    (</span>image_size</span>,</span> image_size</span>,</span> 3</span>,</span> 10</span>)</span>,</span> val_diffusion_steps</span>,</span></span>
                                    ps</span>,</span> st</span>)</span></span>
    ...</span></span>
end</span></span></code></pre>
Zygote.pullback</code> が自動微分の部分で、ラムダ関数を使って、モデルパラメータ ps</code> の微分のみを計算できるようにするのがポイント。</p>
今回のモデルはバッチ正規化を使っており、このレイヤーは学習と推論で別の動作をする。この切り替えは Lux.trainmode/Lux.testmode</code> で行う。</p>
乱数について注意点がある。今回のモデルではその性質上乱数生成を多用する。例えば学習でも推論でも、randn(rng, ...)</code> のようにしてガウシアンノイズを生成しているが、この randn</code> は乱数シード rng</code> を mutate する。特に推論時には毎回同じ乱数シードについて評価したいので、ここでは Lux.replicate</code> で元の乱数シードのコピーを渡している。</p>
モデルの保存と読み込み</h4>
Lux では ps</code>, st</code>, opt_st</code> の三つを与えることでスナップショットが決まる。これらは普通の Julia のオブジェクトなので、適当なライブラリでシリアライズして保存することができる。例えば BSON.jl</a> を使うと</p>
function</span> save_checkpoint</span>(</span>ps</span>,</span> st</span>,</span> opt_st</span>,</span> output_dir</span>,</span> epoch</span>)</span></span>
    path </span>=</span> joinpath</span>(</span>output_dir</span>,</span> @sprintf</span>(</span>"</span>checkpoint_%.4d.bson</span>"</span>,</span> epoch</span>)</span>)</span></span>
    return</span> bson</span>(</span>path</span>,</span> Dict</span>(</span>:ps</span> =></span> cpu</span>(</span>ps</span>)</span>,</span> :st</span> =></span> cpu</span>(</span>st</span>)</span>,</span> :opt_st</span> =></span> cpu</span>(</span>opt_st</span>)</span>)</span>)</span></span>
end</span></span></code></pre>
となる。これをロードするときも普通に、</p>
function</span> load_checkpoint</span>(</span>path</span>)</span></span>
    d </span>=</span> BSON</span>.</span>load</span>(</span>path</span>)</span></span>
    return</span> d</span>[</span>:ps</span>]</span>,</span> d</span>[</span>:st</span>]</span>,</span> d</span>[</span>:opt_st</span>]</span></span>
end</span></span></code></pre>
とすれば良い。</p>
この辺の取り回しの良さは、パラメータや状態を明示的に扱うことの利点だと感じる。</p>
実装全体は冒頭にリンクを貼ったリポジトリを見てほしい。</p>
まとめ</h2>
今回の実装を通して、拡散モデルというそれなりに複雑なニューラルネットワークモデルも Julia でそれほど苦もなく実装できることがわかった。Lux は明示的にパラメータを扱うため、自分が何をしているか把握しやすく、見通しが良い。この辺は Jax に通じるものがある。</p>
多くの人が気になるのは python に対して優位性があるのかという点だろう。個人的に Julia で深層学習をするメリットとしては</p>

JIT があり、気軽に for</code> ループが書けるので、カスタムで書いたロスやデータの前処理が高速になる。特に numpy でベクトル化することが難しいような処理は Julia を使うと高速化できるはず。</li>
型を付けられるので、型の解析によってバグを減らすことができる。</li>
</ul>
あたりだと感じる。</p>
一方でフレームワークが提供する API を使って簡単に書けるモデルなら TensorFlow や PyTorch で十分だと思うし、プロダクション化のサポートやクラウドサービスとの連携は python の方が圧倒的に強い。2</a></sup> 速度に関しても、結局 GPU 上の計算はどちらでもあまり変わらないと思うので、CPU での処理がボトルネックでない限りは Julia が優位ということもない気がする。また、Julia は俗に TTFX</a> と呼ばれる JIT のオーバーヘッドが存在するので、コードを書いてスクリプトを実行してデバッグというプロセスに関しては、python の方が体験として良い。</p>
個人的には SciML</a> で取り組まれているような、ニューラルネットワークと微分方程式の合わせ技に興味があって、その分野では Julia が優位らしいのでもう少し掘ってみたいと思っている。</p>

^1</sup>一方でこのせいで色々なパッケージを組み合わせると、各パッケージ開発者が想定していなかったようなバグが生じることがあり、時々批判的なスレッドが生えたりして話題になることがある。例えばこれ</a>とか。</p>
</div>
^{2</sup>
特にインダストリーでは大規模な分散学習をすることもあると思うが、Julia でそこまで対応できるのかは調べていない。</p>
</div>}


ブログに独自ドメインを設定した
2022-12-02T00:00:00+00:00
このブログは github pages でデプロイしている。
そのため今まではデフォルトの yng87.github.io というドメイン名だったが、自身に帰属感を持たせ記事執筆のモチベを上げるため、独自ドメインを導入してみた。</p>
ドメインの取得</h2>
ドメインをどこで購入するのが良いのかよく知らないので、まあ Google なら大丈夫だろうと思って、Google Domains を利用した。</p>
購入は非常に簡単だった。ドメイン名は yng87.page を選択（年間約 1200円）。</p>
GitHub Pages の設定</h2>
以下のブログを参考にした。</p>
How to setup google domain for github pages</a></p>
手順としては</p>

GitHub Pages の settings から custom domain を登録</li>
Google Domain > マイドメイン > DNS > リソース レコード > カスタム レコード で以下を設定する

apex domain を設定</a></li>
www サブドメインを設定</a></li>
</ul>
</li>
</ul>
今回取得したドメインは HTTPS を利用する必要があるので、GitHub Pages の settings で Enforce HTTPS にチェックを入れた。諸々のタイムラグがあるようで、GitHub 上で何回か DNS レコードの再確認をする必要があった。</p>
まとめ</h2>
無事独自ドメインが設定できたので、もう少し頻繁に記事を書きたい。</p>
そういえば今日 100 Days To Offload</a> というものがあるのを知ったが、</p>

Posts don’t need to be long-form, deep, meaningful, or even that well written. If there are spelling and grammar mistakes, or even if there’s no real point to the post, so what?</p>
</blockquote>
はそうだよねと思った。どうせ誰も見ていない個人ブログなので、もっと気楽に日記や未完成の Tech を書いていきたい。</p>


CS:APP を読んだ
2022-06-15T00:00:00+00:00
Computer Systems: A Programmer's Perspective という本を読んだので読書メモ。</p>

  



  



  



  



  



  



  




  
    
      
      
      
    </div>

    
      
      Book</div>
      

      Computer Systems: A Programmer's Perspective</div>

      
      Randal E. Bryant / David R. O'Hallaron / Pearson</div>
      

      

      
    </div>
  </a>
</div>

どんな本?</h2>
プログラムが CPU やメモリをどのように扱うかという、低レイヤーの概観を与えてくれる本。
タイトルに"A Programmer's Perspective"とあるように、職業プログラマー向けの本であって、低レイヤーのハードウェア・ソフトウェアを作る専門家向けの本ではない。
プログラムを実行する時に under the hood で何が起きているかという mental model を獲得することで、より速いコードやよりメモリ効率の良いコードを書けるようになるのが目的とのこと。</p>
僕は大学・大学院でずっと物理学ばかりやっていて、コンピュータ・サイエンスをまともに学んでいないのが悩みだったが、この本を読んである程度雰囲気は掴めるようになったと思う。
読んだきっかけは、Teach Yourself Computer Science</a> というサイト。他にも CS の勉強に良さそうな資料が色々挙げられている。</p>
必要な前提知識</h2>
プログラミング経験は当然必要。また解説用のコードは基本的に C なので、C の読み書きができる必要がある。ポインタとか malloc</code> とかは知っていないと読むのは辛いと思う。ポインタがオブジェクトが格納されているメモリのアドレスだってことは知ってるけど、それって具体的に CPU やメモリはどう扱っているの?というレベルの人1</a></sup> が読むとちょうど良い気がする。</p>
内容</h2>
Part I: Program Structure and Execution</h3>
整数や浮動小数点数の二進法表現を詳細に解説し、x86-64の命令セットについて学ぶ。C のコードをアセンブリ言語に変換して、元のコードと対応づけて読めるようになるということを目指している。また、x86-64に似せた独自の Y86-64というプロセッサーの設計を通して、CPU のパイプライン処理についても勉強する。</p>
僕は今まで、コードをテキストファイルに書いてコンパイルすると謎の仕組みで謎のバイナリが吐き出されるという認識しか持っていなかったが、アセンブリがなんとなく読めるようになることで C のコードがどう変換されてマシン語になるのか雰囲気がわかるようになった。</p>
また、これまでに学んだ知識をベースにしたプログラムの最適化も行う。オーダーの改善ではなく、CPU を最大限効率よく使うことによる $\mathcal O(1)$ の改善をしているのが面白かった。「カリカリにチューンする」というのはこういうことか。</p>
Part II: Running Programs on a System</h3>
リンク・例外・仮想メモリについて学ぶ。例外の章で初めてプロセスという概念が出てくる。</p>
例外の章ではコントロールフローの制御の仕方を学び、ちょっとしたシェルを作成する。普段多用しているシェルという道具の仕組みがわかって楽しかった。</p>
仮想メモリはこの本の集大成の一つで、ハードウェアと OS が協調してメモリを管理していることを学ぶ。
また malloc</code> 等も掘り下げて説明されている。自分は今まで malloc</code> したら要求したメモリ分だけヒープが消費されるみたいな雑な感覚しか持っていなかったが、実際には fragmentation を抑えて効率的にメモリを扱えるように OS が大変な努力をしていることがわかった。実際に簡単なメモリアロケーション・プログラムを作成してちゃんと動くことが確認できるのも面白かった。</p>
Part III: Interaction and Communication between Programs</h3>
Part III ではより進んで、I/O・ネットワーク・concurrency について学ぶ。
C で小さい WEB サーバーを作成し、それを multi-process, multiplex, multi-thread それぞれで並行に実行する方法を学ぶ。</p>
特にネットワークに関しては今までどうやって動いているのか全くイメージが持てていなかったので、ソケットというディスクリプタの読み書きをしているということがわかって勉強になった。</p>
この part は Linux のシステムコールを多用するが、それぞれの解説は浅いので、コードを写経して動きをなんとなく理解するという感じになってしまった。深く理解するには別の書籍等が必要だと思う。</p>
まとめ</h2>
特に後半は説明が雑になってくるので、それぞれを深く学ぶことはできないが、自分のような非情報系の専攻の人にとっては良い本だと思う。
難点は分量で、（英語で読んだので）1000ページくらいあって、読むのに3ヶ月くらいかかった。しかし、時間をかけただけの価値はあったと思う。</p>

^{1</sup>
この本を読む前の自分のこと</p>
</div>}


Diffusion model を理解するためのノート
2022-06-14T00:00:00+00:00
ぼんやりと過ごしているうちに、世間では DALL·E 2</a> や Imagen</a> のような高性能の生成モデルが話題になっていました。いつの間にか生成部分に GAN ではなく、diffusion model というものが使われるようになっていたのも知りました。</p>
このままでは時代に取り残されてしまうと思い diffusion model の草分けと思われる論文の一つarXiv:2006.11239</a> を理解しようと読み始めたのですが、式の導出が思ったより大変だったので過程をまとめておきたい、というのがこの記事の趣旨です。</p>
目標は arXiv:2006.11239</a> で提案された diffusion model の損失関数</p>
$$\begin{aligned}
L_{\mathrm{simple}}(\theta) = \mathbb{E}_{t,\boldsymbol{x}_0,\boldsymbol{\epsilon}}
\left[\left|
\boldsymbol{\epsilon} - \boldsymbol{\epsilon}_\theta(\sqrt{\bar\alpha_t} \boldsymbol{x}_0 + \sqrt{1-\bar\alpha_t}\boldsymbol{\epsilon},t)
\right|^2\right]
\end{aligned}$$</p>
を導出することです。</p>
Diffusion model とは？というところや、具体的な式の導出については以下のブログにも詳しく書かれています。</p>
What are Diffusion Models? | Lil'Log</a></p>
日本語訳もされている</a>ので、そもそも diffusion model って何？という人はそちらを見ると良いと思います。</p>
また上記論文でも appendix や引用文献を詳しく読めばわかるようにはなっています。以下では、それらを読む中で多少ギャップを感じた部分を埋めたり、期待値の定義が曖昧に書かれている部分を explicit にしたりということをしていきます。</p>

問題のセットアップ</h2>
$\boldsymbol{x}_0$ をデータ、$\boldsymbol{x}_T$ は $p(\boldsymbol{x}_T) = \mathcal{N}(\boldsymbol{x}_T; \boldsymbol{0},\mathbf{I})$ から生成される正規乱数とします。学習時にはデータ $\boldsymbol{x}_0$ に少しずつノイズを加えて $\boldsymbol{x}_T$ が得られるようにモデルを学習し (diffusion process</em>) 、推論時には逆に $\boldsymbol{x}_T$ を少しずつ denoize することで (reverse process</em>) 学習データ分布からの生成を実現します。</p>
Diffusion process</h3>
Diffusion process は以下のようなマルコフ過程とします
$$\begin{aligned}
\boldsymbol x_0 &\sim q(\boldsymbol x_0),\notag \\
\boldsymbol x_t &\sim q(\boldsymbol x_t | \boldsymbol x_{t-1}) = \mathcal{N}(\boldsymbol x_t;\sqrt{1-\beta_t}\boldsymbol x_{t-1},\beta_t)\quad (t=1,2,\dots,T).
\end{aligned}$$
元々のデータ $\boldsymbol x_0$ を生成する分布を $q(\boldsymbol x_0)$ としています。時刻 $t=0$ から初めて $t=1,2 \dots,T$ で少しずつノイズを加えていく様子を記述しています。$\beta_t$ は $t$ に対して単調増加な関数に選んで、徐々に加えるノイズが大きくなり、より分布の中心がゼロに近づくようにしています。1</a></sup></p>
Reverse process</h3>
Reverse process は以下のようなマルコフ過程とします
$$\begin{aligned}
\boldsymbol x_T &\sim p(\boldsymbol x_T) = \mathcal{N}(\boldsymbol{x}_T; \boldsymbol{0},\mathbf{I}),\notag\\
\boldsymbol x_{t-1} &\sim p_\theta(\boldsymbol x_{t-1} | \boldsymbol x_t) = \mathcal{N}(\boldsymbol x_{t-1};\boldsymbol\mu_\theta(\boldsymbol x_t, t), \boldsymbol\Sigma_\theta(\boldsymbol x_t, t))\quad (t=T-1,\dots,0) .\tag{1}
\end{aligned}$$
ここで $\theta$ は学習パラメータです。Reverse process は正規乱数 $\boldsymbol x_T$ から始まり、これからノイズを除去して、学習データ分布からのサンプルに近づくように学習します。</p>
学習では以下の negative log likelihood を最小にします2</a></sup>
$$\begin{aligned}
\tag{2}
\mathbb{E}_{\boldsymbol x_0}[-\log p_\theta(\boldsymbol x_0)]
&= -\int d\boldsymbol x_0 q(\boldsymbol x_0)\log\left[\int d\boldsymbol x_{1:T} p_\theta(\boldsymbol x_{0:T})\right],\\
\mathrm{where}\quad p_\theta(\boldsymbol x_{0:T}) &= p(\boldsymbol x_T)\prod_{t=1}^Tp_\theta(\boldsymbol x_{t-1} | \boldsymbol x_t).\notag
\end{aligned}$$
データ $\boldsymbol x_0$ の確率ができるだけ高くなるように、$\theta$ を調整することになります。$\boldsymbol x_0 \sim q(\boldsymbol x_0)$ としたので、期待値は $q(\boldsymbol x_0)$ に関する積分になります。</p>
Variational bound を導出する</h2>
式 (2) を学習に便利なように変形していきます。</p>
Jensen の不等式から</p>
$$\begin{aligned}
-\log p_\theta(\boldsymbol x_0)
&=
-\log\left[\int d\boldsymbol x_{1:T} p_\theta(\boldsymbol x_{0:T})\right]\notag\\
&=
-\log\left[\int d\boldsymbol x_{1:T} q(\boldsymbol x_{1:T}|\boldsymbol x_0)
\frac{p_\theta(\boldsymbol x_{0:T})}{q(\boldsymbol x_{1:T}|\boldsymbol x_0)}\right]\notag\\
&\leq
-\int d\boldsymbol x_{1:T} q(\boldsymbol x_{1:T}|\boldsymbol x_0)\log\left[\frac{p_\theta(\boldsymbol x_{0:T})}{q(\boldsymbol x_{1:T}|\boldsymbol x_0)}\right].
\end{aligned}$$</p>
なので</p>
$$\begin{aligned}
\mathbb{E}_{\boldsymbol x_0}[-\log p_\theta(\boldsymbol x_0)]
&\leq
-\int d\boldsymbol x_{0:T} q(\boldsymbol x_{0:T})\log\left[\frac{p_\theta(\boldsymbol x_{0:T})}{q(\boldsymbol x_{1:T}|\boldsymbol x_0)}\right]\notag\\
&=\int d\boldsymbol x_{0:T} q(\boldsymbol x_{0:T})
\left[-\log p(\boldsymbol x_T) - \sum_{t=1}^T\log\frac{p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t)}{q(\boldsymbol x_t|\boldsymbol x_{t-1})}\right]\notag\\
&= \mathbb{E}_q\left[-\log p(\boldsymbol x_T) - \sum_{t=1}^T\log\frac{p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t)}{q(\boldsymbol x_t|\boldsymbol x_{t-1})}\right]\notag\\
&=:L.
\end{aligned}$$</p>
$\mathbb{E}_q$ は $q(\boldsymbol x_{0:T})$ の下での平均としました。変分法でよくある式変形だと思います。以降は式 (2) の上限である $L$ を最小化することにします。</p>
天下りですが、$q(\boldsymbol x_t|\boldsymbol x_{t-1})$ を以下のように分解します
$$\begin{aligned}
q(\boldsymbol x_t|\boldsymbol x_{t-1})
=q(\boldsymbol x_t|\boldsymbol x_{t-1}, \boldsymbol x_0)
=q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)\frac{q(\boldsymbol x_t|\boldsymbol x_0)}{q(\boldsymbol x_{t-1}|\boldsymbol x_0)}.
\end{aligned}$$</p>
これを $L$ の中の和の $t>1$ の部分に適用すると</p>
$$\begin{aligned}
L
&=
\mathbb{E}_q\left[
-\log p(\boldsymbol x_T) - \sum_{t=2}^T\log\frac{p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t)}{q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)}
+ \sum_{t=2}^T\log\frac{q(\boldsymbol x_t|\boldsymbol x_0)}{q(\boldsymbol x_{t-1}|\boldsymbol x_0)}
- \log\frac{p_\theta(\boldsymbol x_0|\boldsymbol x_1)}{q(\boldsymbol x_1|\boldsymbol x_0)}
\right]\notag\\
&=
\mathbb{E}_q\left[
-\log\frac{p(\boldsymbol x_T)}{q(\boldsymbol x_T|\boldsymbol x_0)}
- \sum_{t=2}^T\log\frac{p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t)}{q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)}
- \log p_\theta(\boldsymbol x_0|\boldsymbol x_1)
\right]\notag\\
&\equiv L_T + \sum_{t=2}^T L_{t-1} + L_0.
\end{aligned}$$
以下で見るように、この形にすることで $L$ を tractable な形で書くことができるようになります。</p>
なお、この式の第一項 $L_T$ は学習パラメータを含まないため、考える必要はありません。以下では第二項、第三項を見ていきます。</p>
$L_{t-1}$ の計算</h3>
$L_{t-1}$ を計算するには、$q(\boldsymbol x_t|\boldsymbol x_0)$ と $q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)$ の関数形を求める必要があります。</p>
$q(\boldsymbol x_t|\boldsymbol x_0)$ の計算</h4>
任意の時刻 $t$ での diffusion の分布 $q(\boldsymbol x_t|\boldsymbol x_0)$ は、単なる Gaussian noise の合成なので、解析的に計算できます</p>
$$\begin{aligned}
q(\boldsymbol x_t|\boldsymbol x_0)
&=
\int d\boldsymbol x_{1:t-1}\prod_{s=1}^{t}q(\boldsymbol x_s|\boldsymbol x_{s-1})\notag\\
&=
\int d\boldsymbol x_{1:t-1}\prod_{s=1}^{t} \frac{1}{\sqrt{2\pi}\beta_s}
\exp\left[-\frac{1}{2\beta_s}\left|\boldsymbol x_s - \sqrt{1-\beta_s}\boldsymbol x_{s-1}\right|^2\right].
\end{aligned}$$
まず $\boldsymbol x_{t-1}$ による積分を考えます。関連する項だけ抜き出すと</p>
$$\begin{aligned}
\int d\boldsymbol x_{t-1}
\exp\left[
-\frac{1}{2(1-\alpha_t)}\left|\boldsymbol x_t - \sqrt{\alpha_t}\boldsymbol x_{t-1}\right|^2
-\frac{1}{2(1-\alpha_{t-1})}\left|\boldsymbol x_{t-1} - \sqrt{\alpha_{t-1}}\boldsymbol x_{t-2}\right|^2
\right]
\end{aligned}$$
となります。論文にならって $\alpha_t = 1-\beta_t$ としました。$\boldsymbol x_{t-1} = \sqrt{\alpha_{t-1}}\boldsymbol x_{t-2} + \sqrt{1-\alpha_{t-1}}\boldsymbol z_{t-1}$ と変数変換し $\boldsymbol z_{t-1}$ について平方完成して積分すると
$$\begin{aligned}
&\int d\boldsymbol z_{t-1}
\exp\left[
-\frac{1}{2(1-\alpha_t)}\left|\sqrt{\alpha_t(1-\alpha_{t-1})}\boldsymbol z_{t-1} - (\boldsymbol x_t - \sqrt{\alpha_t\alpha_{t-1}}\boldsymbol x_{t-2})\right|^2
-\frac{1}{2}\boldsymbol z_{t-1}^2
\right]\notag\\
&\propto
\exp\left(-\frac{1}{2(1-\alpha_t\alpha_{t-1})}|\boldsymbol x_t - \sqrt{\alpha_t\alpha_{t-1}}\boldsymbol x_{t-2}|^2\right)
\end{aligned}$$
となるので、これを繰り返すと
$$\begin{aligned}
q(\boldsymbol x_t|\boldsymbol x_0)
&\propto
\exp\left(-\frac{1}{2(1-\bar\alpha_t)}|\boldsymbol x_t - \sqrt{\bar\alpha_t}\boldsymbol x_0|^2\right),
\mathrm{where}\quad \bar\alpha_t = \prod_{s=1}^t\alpha_t
\end{aligned}$$
つまり
$$\begin{aligned}
\tag{3}
q(\boldsymbol x_t|\boldsymbol x_0)
=\mathcal{N}(\boldsymbol x_t; \sqrt{\bar\alpha_t}\boldsymbol x_0, (1-\bar\alpha_t)\mathbf{I})
\end{aligned}$$
となることがわかります。</p>
$q(\boldsymbol x_{t-1}|\boldsymbol x_t,\boldsymbol x_0)$ の計算</h4>
式 (3) を使うことで
$$\begin{aligned}
q(\boldsymbol x_{t-1}|\boldsymbol x_t,\boldsymbol x_0)
&=\frac{q(\boldsymbol x_t|\boldsymbol x_{t-1})q(\boldsymbol x_{t-1}|\boldsymbol x_0)}{q(\boldsymbol x_t|\boldsymbol x_0)} \notag\\
&\propto
\exp\left[
-\frac{1}{2}\left(
\frac{1}{1-\alpha_t}|\boldsymbol x_t - \sqrt{\alpha_t}\boldsymbol x_{t-1}|^2
+\frac{1}{1-\bar\alpha_{t-1}}|\boldsymbol x_{t-1} - \sqrt{\bar\alpha_{t-1}}\boldsymbol x_0|^2
\right)
\right]\notag\\
&\propto
\exp\left[
-\frac{1}{2}\left(
\frac{1-\bar\alpha_t}{(1-\alpha_t)(1-\bar\alpha_{t-1})}\boldsymbol x_{t-1}^2
-2\left(\frac{\sqrt{\alpha_t}}{1-\alpha_t}\boldsymbol x_t + \frac{\sqrt{\bar\alpha_{t-1}}}{1-\bar\alpha_{t-1}}\boldsymbol x_0\right)\boldsymbol x_{t-1}
\right)
\right],
\end{aligned}$$
となります。$\boldsymbol x_{t-1}$ について二次なので Gaussian です。
$q(\boldsymbol x_{t-1}|\boldsymbol x_t,\boldsymbol x_0) = \mathcal{N}(\boldsymbol x_{t-1}|\tilde{\boldsymbol\mu}_t(\boldsymbol x_t, \boldsymbol x_0), \tilde\beta_t\mathbf{I})$ とおくと</p>
$$\begin{aligned}
\tilde{\boldsymbol\mu}_t(\boldsymbol x_t, \boldsymbol x_0)
&=\frac{(1-\alpha_t)(1-\bar\alpha_{t-1})}{1-\bar\alpha_t}
\left(
\frac{\sqrt{\alpha_t}}{1-\alpha_t}\boldsymbol x_t + \frac{\sqrt{\bar\alpha_{t-1}}}{1-\bar\alpha_{t-1}}\boldsymbol x_0
\right)\notag\\
&=
\frac{(1-\alpha_t)\sqrt{\bar\alpha_{t-1}}}{1-\bar\alpha_t}\boldsymbol x_0
+\frac{(1-\bar\alpha_{t-1})\sqrt\alpha_t}{1-\bar\alpha_t}\boldsymbol x_t\notag\\
\tilde\beta_t
&=\frac{(1-\alpha_t)(1-\bar\alpha_{t-1})}{1-\bar\alpha_t}
\end{aligned}$$
となります。</p>
Variational bound の計算</h4>
論文にならって $\Sigma_\theta(\boldsymbol x_t, t) = \sigma^2_t\mathbf{I}$ という ansatz をおくと</p>
$$\begin{aligned}
L_{t-1}
&=-\mathbb{E}_q\left[\log\frac{p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t)}{q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)}\right]\notag\\
&=-\int d\boldsymbol x_0 d\boldsymbol x_{t-1}d\boldsymbol x_t q(\boldsymbol x_0)q(\boldsymbol x_t|\boldsymbol x_0)q(\boldsymbol x_{t-1}| \boldsymbol x_0, \boldsymbol x_t)
\log p_\theta(\boldsymbol x_{t-1}|\boldsymbol x_t) + \mathrm{const.}\notag\\
&=\int d\boldsymbol x_0 d\boldsymbol x_{t-1}d\boldsymbol x_t q(\boldsymbol x_0)q(\boldsymbol x_t|\boldsymbol x_0)q(\boldsymbol x_{t-1}| \boldsymbol x_0, \boldsymbol x_t)
\frac{1}{2\sigma^2_t}|\boldsymbol x_{t-1} - \boldsymbol\mu_\theta(\boldsymbol x_t, t)|^2 + \mathrm{const.}\notag\\
&=\int d\boldsymbol x_0 d\boldsymbol x_t q(\boldsymbol x_0)q(\boldsymbol x_t|\boldsymbol x_0)
\frac{1}{2\sigma^2_t}|\tilde{\boldsymbol\mu}_t(\boldsymbol x_t, \boldsymbol x_0)  - \boldsymbol\mu_\theta(\boldsymbol x_t, t)|^2 + \mathrm{const.}
\end{aligned}$$
$\mathrm{const.}$ は学習パラメータ $\theta$ を含まないという意味です。$\sigma^2_t$ の関数形は任意性があります。詳しくは元論文を見てください。</p>
この式のままでも良いのですが、実用上は以下のようなリパラメトライゼーションをするとより性能がよくなるそうです。</p>
式 (3) を思い出すと、$\boldsymbol x_t$ は $\boldsymbol\epsilon \sim \mathcal{N}(\boldsymbol\epsilon;\boldsymbol 0,\mathbf{I})$ によって $\boldsymbol x_t=\sqrt{\bar\alpha_t}\boldsymbol x_0 + \sqrt{1-\bar\alpha_t}\boldsymbol\epsilon$ とパラメトライズでき、これにより $\tilde{\boldsymbol\mu}_t = (\boldsymbol x_t - \beta_t/\sqrt{1-\bar\alpha_t}\boldsymbol\epsilon) / \sqrt{\alpha_t}$ と書けます。よって $\boldsymbol\mu_\theta(\boldsymbol x_t, t)$ も同様に
$$\begin{aligned}
\tag{4}
\boldsymbol\mu_\theta(\boldsymbol x_t, t)
= \frac{1}{\sqrt{\alpha_t}}
\left(
\boldsymbol x_t - \frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\boldsymbol\epsilon_\theta(\boldsymbol x_t, t)
\right)
\end{aligned}$$
とパラメトライズすると</p>
$$\begin{aligned}
L_{t-1}
&=\int d\boldsymbol x_0 d\boldsymbol\epsilon q(\boldsymbol x_0)\mathcal{N}(\boldsymbol\epsilon;\boldsymbol 0,\mathbf{I})
\frac{\beta^2_t}{2\sigma^2_t\alpha_t(1-\bar\alpha_t)}|\boldsymbol\epsilon  - \boldsymbol\epsilon_\theta(\boldsymbol x_t, t)|^2 + \mathrm{const.}\notag\\
&=\mathbb{E}_{\boldsymbol x_0, \boldsymbol\epsilon}
\left[
\frac{\beta^2_t}{2\sigma^2_t\alpha_t(1-\bar\alpha_t)}
\left|\boldsymbol\epsilon  - \boldsymbol\epsilon_\theta(\sqrt{\bar\alpha_t}\boldsymbol x_0 + \sqrt{1-\bar\alpha_t}\boldsymbol\epsilon, t)\right|^2
\right]
+ \mathrm{const.} \tag{5}
\end{aligned}$$</p>
となります。各学習データ $\boldsymbol x_0$ に対して、標準正規分布から乱数 $\boldsymbol\epsilon$ を生成し、モデル $\boldsymbol\epsilon_\theta$ に入力した結果が元の乱数 $\boldsymbol\epsilon$ を再現するように学習することになります。</p>
$L_0$ の計算</h3>
$L_0=\mathbb{E}_q[-\log p_\theta(\boldsymbol x_0|\boldsymbol x_1)]$ は denoizing の最終レイヤーであり、デコーダの役割を果たします。ここだけさらに複雑なモデルを設定することもできるらしいですが、論文では単に independent discrete decoder、つまり $\boldsymbol\mu_\theta(\boldsymbol x_1,1)$ をそのまま $\boldsymbol x_0$ として使うようなデコーダを考えています。</p>
論文では画像データの生成を考えているので各ピクセルは $0, 1, \dots, 255$ の離散値を取り、$x_0$ の各成分はそれを $[-1, 1]$ へ線形にスケールしたものとしています。なので、取りうる値は $-1, -1+2/255, -1 + 4/255, \dots, 1$ であり、$2/255$ ずつになっています。</p>
論文では以下のような likelihood を設定しています</p>
$$\begin{aligned}
\tag{6}
p_\theta(\boldsymbol x_0|\boldsymbol x_1)
= \prod_{i=1}^D\int_{\delta_-(x_0^i)}^{\delta_+(x_0^i)} dx\mathcal{N}(x;\mu_\theta^i(\boldsymbol x_1, 1), \sigma_1^2),
\end{aligned}$$</p>
$$\begin{aligned}
\delta_+(x) =
\begin{cases}
\infty\quad(x = 1)\\
x + 1/255\quad(x<1)
\end{cases}\quad
\delta_-(x) =
\begin{cases}
-\infty\quad(x = -1)\\
x - 1/255\quad(x>-1)
\end{cases}
\end{aligned}$$</p>
直観的には、データの値 $x_0^i$ の $\pm 1/255$ の区間に $\mu_\theta^i$ が入ると likelihood が高くなるということです。また $x_0^i=+1$ $(-1)$ の時は、上 (下) に外す分には構わないという式になっています。</p>
式 (6) のままでは扱いづらいので、$x_0^i=\pm1$ のコーナーケースを無視し、積分を区間の長さ $2/255$ が短いと思って近似してみます。すると</p>
$$\begin{aligned}
-\log p_\theta(\boldsymbol x_0|\boldsymbol x_1)
\simeq
\frac{1}{2\sigma_1^2}|\boldsymbol x_0 - \boldsymbol\mu_\theta(\boldsymbol x_1, 1)|^2
+\mathrm{const.}
\end{aligned}$$</p>
と書けるので</p>
$$\begin{aligned}
\tag{7}
L_0 =
\mathbb{E}_{\boldsymbol x_0, \boldsymbol\epsilon}\left[
\frac{1-\alpha_1}{2\sigma_1^2\alpha_1}
\left|\boldsymbol\epsilon - \boldsymbol\epsilon_\theta(\sqrt{\bar\alpha_1}\boldsymbol x_0 + \sqrt{1-\bar\alpha_1}\boldsymbol\epsilon, 1)\right|^2
\right]
+\mathrm{const.}
\end{aligned}$$</p>
となり、$L_{t-1}$ に $t=1$ を代入した結果と一致することがわかります。</p>
目的関数の簡略化</h3>
実用上は式 (5) と (7) の二乗誤差の前の係数は無視しても良いらしいです。$t$ についての和も、$[1,T]$ からの一様サンプリングに置き換えることにすると、損失関数は結局</p>
$$\begin{aligned}
\tag{8}
L_{\mathrm{simple}}(\theta)
= \mathbb{E}_{t,\boldsymbol{x}_0,\boldsymbol{\epsilon}}
\left[\left|
\boldsymbol{\epsilon} - \boldsymbol{\epsilon}_\theta(\sqrt{\bar\alpha_t} \boldsymbol{x}_0 + \sqrt{1-\bar\alpha_t}\boldsymbol{\epsilon},t)
\right|^2\right]
\end{aligned}$$</p>
で良くなります。これは各時刻における重みを変えていることになります。</p>
式 (5) のままではノイズの分散が小さい small $t$ における損失の weight が大きくなります。式 (8) のように取り直すことで、より難しい、large $t$ における学習にフォーカスできるようになるらしいです。</p>
実際に学習する際には、まず $\boldsymbol{\epsilon}_\theta$ に使うモデルを決め、データ $\boldsymbol x_0$ と乱数 $t$, $\boldsymbol \epsilon$ を使って、式 (8) を損失関数とした optimize を行います。推論ではまず正規乱数 $\boldsymbol x_T$ をサンプルします。そして学習済みのモデル $\boldsymbol{\epsilon}_\theta$ を使って式 (4) から $\boldsymbol\mu_\theta$ を計算、式 (1) を使って $\boldsymbol x_{t-1}$ をサンプリング、というステップを $t=0$ まで繰り返すことでデータ生成を行います。</p>
実装</h2>
著者の tensorflow 実装が存在します。</p>
hojonathanho/diffusion: Denoising Diffusion Probabilistic Models</a></p>
また pytorch による再現実装が存在します。</p>
lucidrains/denoising-diffusion-pytorch: Implementation of Denoising Diffusion Probabilistic Model in Pytorch</a></p>
実装では、$\boldsymbol\epsilon_\theta$ のモデルとして U-Net が使われています。</p>
Pytorch の方を CIFAR-10で1時間程度動かしてみたのですが、ステップ数が足りず品質の低い画像しか生成されませんでした。issue</a> を見ても、この10倍くらいは時間をかける必要がありそうです。Diffusion model は学習に時間がかかる……</p>
</p>
自分のノートブック</a></p>
まとめ</h2>
とりあえず目的であった diffusion model の損失関数の導出については理解できました。勉強のためにも自分で再現実装したいところです。</p>

^{1</sup>
論文ではこれを学習パラメータにすることもできると書かれています。</p>
</div>
^{2</sup>
$q(\boldsymbol x_0)$ と $p_\theta(\boldsymbol x_0)$ の KL divergence を最小にすると言っても良いと思います。</p>
</div>}}


実務でレコメンドをやっているのでKaggle H&Mコンペに参加しました
2022-05-14T00:00:00+00:00
最近 Kaggle で開催されていた、H&M 主催のファッション推薦コンペに参加しました。自分はファッション EC 企業でレコメンドシステムの構築に関わっており、このコンペはまさに自分が扱っている技術・ドメインの問題です。腕試しと技術研鑽のため、参加することにしました。</p>
結果は25位という、なんとも言えない悔しい結果になってしまいましたが (gold が欲しかった)、色々学びがあったので記録を残しておきます。1</a></sup></p>
H&M Personalized Fashion Recommendations | Kaggle</a></p>
自分の解法は以下の discussion に上げています。</p>
25th place solution</a></p>
なお一口に業務のレコメンドと言っても、バッチで1日一回だけ計算をすれば良いのか、オンラインでリアルタイムに推論するのか、組織の ML インフラが整っているのか等によって使う技術や考慮事項は変わってくるはずです。ここで書くことはそのようなレコメンドという広い領域の一部を経験した者からの主観的な感想です。</p>
コンペの概要</h2>
詳細はコンペのページ</a>を見てください。</p>
データセット</h3>
H&M から以下のようなデータが提供されました</p>

2年分の購買トランザクション</li>
ユーザーのメタデータ</li>
アイテムのメタデータ</li>
</ul>
これをもとに、ユーザーの将来7日間の購買予測をするコンペです。アイテムの情報として、カテゴリや価格のデータだけでなく、画像や商品説明文もあるのが特徴でした。アイテムのユニーク数は約10万、ユーザーのユニーク数は約100万で、比較的規模の大きいデータセットになっていました。</p>
基本的には（画像や説明文を除けば）テーブルデータのタスクなのですが、与えられたデータに正例・負例のラベルがついているわけではありません。あくまでユーザーがいつ何を買ったかというデータがあるだけで、負例は存在しません。いわゆる implicit feedback の問題です。実務ではあるあるの設定なので、経験者はアドバンテージがあったと思います。</p>
実務のデータと比較して</h3>
データの形式としては比較的実務に近いと思います。一つ大きな違いはユーザーの行動履歴が購買しかないことでした。通常 EC サイトを運営していれば、購買以外にも様々な行動のログが落ちているはずで、以下のような情報が有用なはずです。</p>

ユーザーのアイテム閲覧行動（購買行動よりはるかに数が多い）</li>
セッションにおけるアイテム閲覧系列</li>
e.t.c.</li>
</ul>
行動情報が限られているのは</p>

H&M には実店舗もあるので、実店舗を中心に使うユーザーと EC サイト中心に行動するユーザーとの扱いが公平になる</li>
そもそも閲覧ログのデータ量は購買より桁で多いので、コンペで使うには大きすぎる</li>
</ul>
という事情があるのだと想像しています。</p>
解法</h2>
2-stage レコメンド</h3>
人気 discussion</a>で紹介されていたこともあり、2-stage レコメンドを採用する人が多かったと思います。2-stage レコメンドは、まず粗い方法でアイテムコーパスから少数の関連アイテムを抽出し (1st stage, candidate generation)、その後高精度なモデルで結果を並び替える (2nd stage, reranking) 手法を指します。最初から高精度な 2nd stage モデルでスコアをつけられれば良いのですが、ユーザー・アイテムの数がある程度多くなると、計算量的に厳しくなります。そのような場合によく取られる手法だと思います。自分も同じ方針でモデリングしました。</p>
なお、2-stage レコメンドは多くのテック企業で事例があります。パッと思いつくだけでも</p>

YouTube</a></li>
twitter</a></li>
Pinterest</a></li>
</ul>
などがあります。実応用もされているレコメンドの strategy を学ぶという意味で良いコンペだったと思います。</p>
上位の解法</h3>
コンペ終了後上位の解法に目を通しましたが、どれも大枠では似通っていました。</p>

1st stage: 質の高い複数の candidate generation をする</li>
2nd stage: GBDT で reranking</li>
</ul>
パッと見る限り、2nd stage に使う特徴量はどのチームも似たような感じでした。ただ 3rd place solution</a> では BPR で作った user2item similarity が有効だったと報告されており、特徴量の作り込みが大事なことには変わりないようです。</p>
スコアに大きな差を生むのは 1st stage の質だったように感じました。ここで色々な可能性を探索して recall が上がるように調整できたかどうかが重要でした。多くの解法に共通しているのは</p>

再購入: ユーザーの過去購入と同じアイテム、もしくは同じ product code の商品（色違いなど）を推薦する</li>
アイテムベース協調フィルタリング</li>
人気アイテム</li>
</ul>
です。再購入の重要度が高いのは面白く、ベーシックなアイテムが安価に購入できる H&M ならではの特徴なのかもしれません。</p>
ここでの解法をそのまま実務に応用できるかは組織のインフラによるわけですが、個人的には candidate generation の質の重要性を改めて確認できたという意味で勉強になりました。</p>
ニューラルネットワークの有効性</h3>
またニューラルネットワークを使った解法が少なかったことも面白かったです。上位解法では、「NN 試したけど微妙だった」というコメントがいくつかありました。例えば 1st place solution</a> には</p>

I tried FM for recall and MLP,transformer for rank,didn't work.Luckily I gave up soon to focus on GBDT.</p>
</blockquote>
とあり、また 2nd place solution</a> には</p>

Deep learning models - I tried several recbole models but they weren't so good.</p>
</blockquote>
とありました。2</a></sup> ちなみに自分は時間がなかったこともあり、そもそも NN を深くは検討しませんでした。</p>
一方、産業界ではレコメンドでも NN にシフトしていく動きが多いように思います。例えば最近出ていた Netflix の論文</a> では、彼らがなぜ NN 系の技術を選択するようになったかが説明されています。エコシステムが充実しておりエンジニアリング観点のメリットが大きい、様々なソースからの heterogeneous な特徴量を使うことによる性能向上が大きいという内容です。NN の方が分散学習させやすかったり、ベクトル近傍探索で candidate generation ができたりするので、規模が大きくなるほどメリットも増すように思います。</p>
まとめ</h2>
機械学習コンペに初めて参加しましたが、公開ノートブックや discussion によって高速で学べることは素晴らしかったです。明確に順位がつくので自分のスキルを客観視することができました。特に、上位解法を見ると、あの部分をもう少し深掘りしていれば…という悔しい気持ちになります。</p>
一方コンペはあくまでコンペなので、切り分けは当然必要です。特に、実務のレコメンドでは真に改善したいオンラインのメトリクスと、オフラインで試行錯誤して最適化するメトリクスがきちんと相関するかが大きな課題になります。3</a></sup> そのためオフラインでの改善だけでなく、高速に AB テストを回してオンラインでの仮説検証をすることも重要なように思います。</p>

^{1</sup>
Kaggle 初参加で取り組んだ期間も実質一ヶ月だったので、そこそこ健闘したと思いたい。</p>
</div>}^2</sup>RecBole</a> はレコメンドアルゴリズムのライブラリの一つ。NN 系が多い。</p>
</div>
^{3</sup>
例えば Netflix の報告でも、オフラインとオンラインのメトリクスの乖離が課題に挙げられています。</p>
</div>}


t検定で必要なサンプルサイズを求める方法
2021-10-09T00:00:00+00:00
A/B テスト実践ガイドという本を読んでいたら、有意水準5%、検出力80%のt検定に必要なサンプルサイズ</strong>を求める公式として以下のようなものが書かれていました</p>

  



  



  



  



  



  



  




  
    
      
      
      
    </div>

    
      
      Book</div>
      

      A/B テスト実践ガイド真のデータドリブンへ至る信用できる実験とは</div>

      
      Ron Kohavi / Diane Tang / Ya Xu / 大杉直也訳 / KADOKAWA</div>
      

      

      
    </div>
  </a>
</div>

$$n = \frac{16\sigma^2}{\delta^2}.$$</p>
ここで$\sigma$は分散（両群で等しいとする）、 $\delta$ は検出したい二群の平均の差です。この式がどこから出てくるのかパッとわからなかったので考えました。</p>
用語ですが</p>

有意水準5%とは、帰無仮説が真である時に帰無仮説を棄却する誤りを犯す確率が5%</li>
検出力80%とは、帰無仮説が偽である時に帰無仮説を棄却できる確率が80%</li>
</ul>
ということです。両者はトレードオフの関係にあります。実験を設定する時には、検出したい差の大きさ $\delta$ を検出できる（差が$\delta$の時に高い確率で帰無仮説を棄却できる）ようなサンプルサイズを確保することが求められます。この辺をちゃんと分析していないと、A/B テストをやってみて有意差が出なかったが、それが本当に差がなかったからなのか、単にサンプルサイズが足りなかったからなのかという点が区別できません。なので実験前に期待される差の大きさと分散から必要なサンプルサイズを見積もっておく必要があるわけです。</p>
上の式の話に戻ります。二群の平均の差に関する t 検定なので</p>
$$ t = \frac{\delta}{\sigma}\sqrt{\frac{n}{2}}$$</p>
を考えることになります。サンプル数は両群で等しいとします。有意水準5%で帰無仮説を棄却できないのは $|t|<1.96$ となるときです。
帰無仮説が偽 ($ \delta \cancel= 0 $) のときに得られた $t$ がこの領域に入ってしまうと、「帰無仮説が偽であるときに帰無仮説を棄却しない」誤りを犯すことになります。
検出力80%という意味はこの誤りの確率を20%以下にするということです。標準正規分布の上側20%点は0.84なので、</p>
$$ t = \frac{\delta}{\sigma}\sqrt{\frac{n}{2}} > 1.96 + 0.84 $$</p>
であれば求める検出力を達成できることになります。図にすると以下のような感じです
</p>
多くのケースでは検出したい差の大きさ（効果量）$\delta$ を定めて必要な $n$ を計算することになると思います。なので必要なサンプルサイズは最低でも</p>
$$ n = 2(1.96 + 0.84)^2\frac{\sigma^2}{\delta^2} \simeq \frac{16\sigma^2}{\delta^2} $$</p>
となります。</p>}}}
『データ分析失敗事例集』を再読したが改めてデータサイエンスに関わる全ての人が読むべき本だと思った

ベースライン的なレコメンドモデルを作るのに RecTools が便利そう

Claude Code で RSS/Atom フィードリーダーを作ってみた感想

作ってみた感想</h2>

SageMaker Training にジョブを投げる君を作った

なぜ機械学習システムの評価をするのか/評価駆動開発について

テーブルデータの前処理を何でやるか

XGBoost と LightGBM に実装されているポジションバイアス除去を試してみた

NetflixのSequential ABテスト論文を読む

トリガーを設定してABテストの感度を上げる

ランキングモデルのポジションバイアスに対処する

比較用のベースライン</h3>
比較のために、以下のベースラインを用意しました。</p>

GBDT</h4>
XGBoost の `objective="rank:ndcg"</code> でランキングモデルを作ります。またロジスティック回帰と同様に、ポジション特徴量を推論時に固定する方法も試しました（Debiased XGBoost）。3</a></sup></p>`

KDD2023の読んだ論文まとめ (3)

KDD2023の読んだ論文まとめ (2)

KDD2023の読んだ論文まとめ (1)

このサイトのホスト先を GitHub Pages から Cloudflare Pages へ移行した

使える電池を選ぶための最小の試行回数を求める

モデルが生成したデータを学習に繰り返し使うとどうなるか

ベイズファクターによる仮説検定

ベイズファクター</h3>

Python の型ヒントを理解したい

Rust 製の静的サイトジェネレータ Zola を使ってみる

こんな時どうする？</h2>
ここでは自分が必要になった個別の機能の実装方法について、備忘録も兼ねて紹介する。</p>

Julia/Lux.jl で拡散モデルを実装する

モデルの定義</h3>

学習</h3>

ブログに独自ドメインを設定した

CS:APP を読んだ

Diffusion model を理解するためのノート

$L_{t-1}$ の計算</h3>
$L_{t-1}$ を計算するには、$q(\boldsymbol x_t|\boldsymbol x_0)$ と $q(\boldsymbol x_{t-1}|\boldsymbol x_t, \boldsymbol x_0)$ の関数形を求める必要があります。</p>

実務でレコメンドをやっているのでKaggle H&Mコンペに参加しました

コンペの概要</h2>
詳細は コンペのページ</a>を見てください。</p>

解法</h2>

t検定で必要なサンプルサイズを求める方法

loglog()

サーバーレス GPU の Modal でコールドスタートを計測する

loglog()

サーバーレス GPU の Modal でコールドスタートを計測する

さいごに</h2> GPU コンテナが数秒で起動するというのはすごい技術だなと思う。今回の検証に使ったコードは以下。 </path></svg> </div>

Claude Code で RSS/Atom フィードリーダーを作ってみた感想

作ったもの</h2> </p>

作ってみた感想</h2>

Claude Code のすごいところ</h3> 概ね期待した通りに動作するアプリケーションが爆速でできる。色々とすごいところはあるがここに尽きる</li> RDB 周りの設計など、古典的な技術は強く、一発でそれなりのものが出てくる</li>

SageMaker Training にジョブを投げる君を作った

なぜ機械学習システムの評価をするのか/評価駆動開発について

はじめに</h2> ここ最近フォローしている人々が機械学習、特に LLM を使ったシステム開発における評価について話しているのでまとめておきたいと思う。主に参考にしたのは以下の記事やブログ：</p>

テーブルデータの前処理を何でやるか

XGBoost と LightGBM に実装されているポジションバイアス除去を試してみた

シミュレーション</h2> ベルヌーイ過程をシミュレーションして上記の手法を適用してみよう。実験に使ったノートブックは以下に上げた。</p>

トリガーを設定してABテストの感度を上げる

ランキングモデルのポジションバイアスに対処する

KDD2023の読んだ論文まとめ (3)

KDD2023の読んだ論文まとめ (2)

KDD2023の読んだ論文まとめ (1)

このサイトのホスト先を GitHub Pages から Cloudflare Pages へ移行した

使える電池を選ぶための最小の試行回数を求める

モデルが生成したデータを学習に繰り返し使うとどうなるか

結果</h2> 各回 $N=10000$ のサンプリングを合計2000ステップ実行してみた。真の混合ガウス分布は component 二つでパラメータは</p>

ベイズファクターによる仮説検定

ベイズファクター</h3>

Python の型ヒントを理解したい

おまけ</h2> Subtype や variance は Wikipedia にもページがあるくらいなので、Python に限った話ではなく、コンピュータ・サイエンス一般の概念なのだろう。 例えば Julia でも</p>

Rust 製の静的サイトジェネレータ Zola を使ってみる

Section と page</h3> Zola の基本的な構成要素として、section と page というものがある。おおむね、</p>

こんな時どうする？</h2> ここでは自分が必要になった個別の機能の実装方法について、備忘録も兼ねて紹介する。</p>

セクションのディレクトリ構造に階層を設けたい</h3> /content/</code> に以下のような階層を設けたい場合、</p>

リダイレクトを設定したい</h3> 他のブログサービスや SSG から乗り換える場合、パスの構造が変わってしまうのでリダイレクトを設定する必要がある。これはページの aliases</code> で設定可能</p>

Julia/Lux.jl で拡散モデルを実装する

モデルの定義</h3>

実装済みのレイヤーを利用する</h4> UNet アーキテクチャの部品の一つである residual_block</code> の定義を見てみよう。これは入力と出力の画像のチャネル数をもとに、レイヤーを返す関数である。</p>

学習</h3>

データローダー</h4> データローダーは MLUtils.jl の DataLoader</code> を使うのが便利。以下のようにデータセットと、バッチ化のオプションを渡す。</p>

初期化</h4> モデルの初期化は Lux.setup</code> で、オプティマイザの初期化は Optimisers.setup</code> で行う。</p>

ブログに独自ドメインを設定した

GitHub Pages の設定</h2> 以下のブログを参考にした。</p>

まとめ</h2> 無事独自ドメインが設定できたので、もう少し頻繁に記事を書きたい。</p>

CS:APP を読んだ

こんな時どうする？</h2>
ここでは自分が必要になった個別の機能の実装方法について、備忘録も兼ねて紹介する。</p>
