原論文から解き明かす生成AI

著:菊田 遥平

Amazon

楽天市場

ポチップ

どんな内容の本か？

ChatGPTをはじめとしたいろいろな生成AIが出てきている中、どのような仕組みで動いているか？をみなさんどの程度理解しているでしょうか？
私自身、生成AIはいろいろな要素が組み合わさっているため、1つ１つは知っているけど、全部を網羅的に理解するというのはかなり難しいと感じています。しかも、発展のスピードが速く関連論文が毎日のように数十本公開されたりしています。
このような現状を受けて、この本では重要な原論文をベースに生成AIの基礎を紹介し、かつ、論文を独力で読み解く技術を解説し、自分で論文を読む際の役に立つ技術を紹介している本になります。
生成AIといってもいろいろありますが、この本ではChatGPTをはじめとするテキストを中心に画像生成にも触れられている本になっています。
このため、テキストと画像に関する基礎部分は大体抑えられる印象です。

どんな人にお勧めか？

以下のような人にお勧めな本かと思っています。

1. 生成AIを勉強したいけど何から手を出したらいいかわかってない人
2. 論文の読み方について他の人がどうやっているかを知りたい人

各論文の解説記事はいろいろwebに公開されている一方、資料がバラバラなのと、生成AIの知識が浅い人にとってはどの論文が重要なのか調べるのも大変な印象です。このため、重要な論文だけに焦点を当ててくれているこの本をまず読むのは最初の手としては良いと感じました。
また、論文の読み方は研究室などで他の人のやり方をたまに聞く程度で、他の人がどのように読んでいるかを知る機会はそれほど多くないと思っています。
この本では最初に１章かけてこの論文の読み方を解説していて、私のように他の人がどう読んでいるかを知る機会がなかった人には良い参考情報になるのではないかと思っています。

個人的に良かった点

個人的には以下の点が良かったです。

1. 他の人の論文の読み方を知ることができた
2. 生成AIで抜けていた技術について知ることができた

1は先ほどお勧めの人で書いた通り、この本では論文の読み方を１章かけて紹介しており、他の人がどう読んでいるか知る機会がなかった自分にとっては非常に有用でした。
また、これに加えて、生成AIは要素が本当にいろいろあり、私自身、さらっとしか知らなかった部分がいくつかあるのですが、その部分についても深く知ることができてよい機会になりました。

終わりに

今回は献本でいただいた「原論文から解き明かす生成AI」の紹介記事でした。生成AIに関する本はいろいろありますが、深く理解したいと思っている人には非常に良い本だと感じました。
定期的にこのように本の紹介記事を書いてます。もし興味があれば他の本の記事も見ていただければ幸いです。

The post [書評] 原論文から解き明かす生成AI ー 話題のAIを深く理解したいと思ったら読む一冊 first appeared on まったり勉強ノート.

改訂 独習Pythonバイオ情報解析　生成AI時代に活きるJupyter、NumPy、pandas、Matplotlib、Scanpyの基礎を身につけ、シングルセル、RNA-Seqデータ解析を自分の手で

著:先進ゲノム解析研究推進プラットフォーム

Amazon

楽天市場

ポチップ

どんな内容の本か？

年度が変わり、新しい研究室に入ったり、就職した方で「このバイオのデータを解析して」って言われたらどうしますか？
私は今の会社に入った最初、いきなりヒトのとあるテーブルデータを渡されて解析の仕事をすることになり、「困ったぞ」となった記憶があります。
そんな私のような「困ったぞ」となったと思った人にお勧めなのが「独習Pythonバイオ情報解析」で、Pythonを使って特にテーブルデータを扱う人は共通して使える知識が詰まった本になっています。

特に改訂版になってLLMを使った解析の流れの説明や注意点などが増えていて、これから初めて解析をするぞという人は読んでおくとよさそうなことがいろいろ書いてあります。
一方、この本に向かない人はどんな人かというと、テーブルデータではない解析、例えば最近ありそうなのはタンパク質の立体構造系の話などはこの本はあまり参考にならないと思うので別の本を読んだほうが良いかと思います。
例えば最近私もこの辺では以下の本を読んで勉強しています。

どんな人にお勧めか？

今回は以下のような人にお勧めかと思います。

1. Pythonがわからないというプログラム初心者
2. テーブルデータ解析の注意点がわからないという人

この本ではPythonに関して、かなり初級者向けに詳しく紹介してくれています。このため、プログラムが初心者という人が最初に読むにはちょうどよさそうに感じます。また、後半ではsingle cellデータを対象にテーブルデータを解析する上で使いそうな検定の話やクラスタリングの話などが出てきます。このような技術はただ使うのであれば大した知識もなく使えるのですが、結果をちゃんと解釈するとなると、今回のケースで適切な検定方法なのかや、適切なパラメータが使われているのかなど、幅広いことを考える必要があります。
このようなことが今回の本ではちゃんと書いてある印象なので、この辺を詳しくないという人は一度読んでみることをお勧めします。

個人的に良かった点

個人的に良かった点としては以下の点です。

1. 改訂版になってLLMを使った例が最初に入っていて参考になった
2. 忘れがちな解析の注意点を思い出せた

特に良かったのが1が個人的には良かったです。第２章のLLMを使った章を書いた東君のXを時々見て、そんな使い方できるだーというのは飛び飛びで知ってたのですが、今回ちゃんと本にまとめてくれたおかげで、理解しやすかった印象です。
また、後半の検定やクラスタリングなど私自身最近使ってないので、忘れてたことが多かったのですが、そういえばこういう注意点があったということが思い出せたので良かったです。

終わりに

今回は「改訂独習Pythonバイオ情報解析」が出たので紹介の記事を書きました。バイオインフォマティクス周りは変化が激しく、古い本では知識が古くて使い物にならないケースもあるのですが、今回のように改訂版がでて、ちゃんと新しい知識が増えた本がでて非常にうれしく思います。
定期的にこのように本の紹介記事を書いてます。もし興味があれば他の本の記事も見ていただければ幸いです。

The post [書評] 改訂独習Pythonバイオ情報解析 ー バイオのテーブルデータ解析することになったら読む一冊 first appeared on まったり勉強ノート.

Google Colabの無料枠で推論を回す方法は前回記事にしましたので、そもそもPLaMo 2 1Bって何と思った方や推論を回してみたいという方はそちらをご覧ください。

また、今回説明に使うコードはこちらに置いてありますので、適宜参照してください。

https://github.com/shu65/plamo-2-1b-sft-example

Google Colabにおける一連の実行に関してはJupyter Notebookにまとめてありますので、細かい実行方法がわからないという方はこちらをご覧ください

https://github.com/shu65/plamo-2-1b-sft-example/blob/main/run_sft_google_colab.ipynb

Supervised Fine-Tuning(SFT)とは？

SFTを知らない方に簡単に説明すると、SFTは指示と想定されている回答のペアを用意し、LLMに対して学習を行い、指示に従いやすいモデルを作る方法になります。

特にPLaMo 2 1Bのような事前学習モデルでは、特に指示に従うように学習されていないケースもあり、そのまま利用した際、余計なことをだらだらと出力し続けたり、頓珍漢な回答が返ってきたりという問題が発生することがあります。

このため指示に適切にこたえてもらうための技術がいろいろあるのですが、そのうちの一つにSFTというものがあります。

Google ColabでPLaMo 2 1BをSFTする

それでは本題のGoogle ColabでPLaMo 2 1BをSFTする方法について説明します。今回はGPUメモリの関係上、おそらく無料で使えるT4だと無改造では実行できない気がするのでL4を使った説明をします。

L4 GPUの利用

まず、Google ColabでL4が使えるように、課金が必要になります。

課金についてはこちらをご覧ください。

https://colab.research.google.com/signup?hl=ja

今回のコードを動かすだけであれば「Pay As You Go」で100 コンピューティング ユニットを購入すれば十分です。この記事を執筆時点では1200円に満たない程度で購入できます。

課金が済んだら、メニューバーから「ランタイム」→「ランタイムのタイプを変更」をクリックします。すると無料枠では選択できないL4 GPUが選択できるようになっていると思うので、L4 GPUを選択します。

これでGPUを使う準備ができました。

実行環境準備

L4を利用するようにしたら、実行するコードのダウンロードやPythonパッケージのインストールを行います。

まずGithubよりコードをcloneしてきます

!git clone https://github.com/shu65/plamo-2-1b-sft-example.git

次に、PyTorchのバージョンを現在の最新版よりも前の以下のものに変更します。

!pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu124

この後は以下のようにPyTorch以外のPLaMo 2 1Bの実行に必要なパッケージやSFTに必要なパッケージなどをインストールします。

!pip install -r plamo-2-1b-sft-example/requirements.txt

ここまで実行すると2025/02/12現在以下のようなバージョンがインストールされました。

causal-conv1d                      1.5.0.post8
fastrlock                          0.8.3
mamba-ssm                          2.2.4
numba                              0.61.0
numba-cuda                         0.0.17.1
sentence-transformers              3.4.1
torch                              2.4.1+cu124
torchaudio                         2.4.1+cu124
torchsummary                       1.5.1
torchvision                        0.19.1+cu124
transformers                       4.48.2
trl                                0.14.0

これであとはSFTのコードを実行すれば、SFTをすることができます。このSFTの中身に関しては次で紹介していきます。

PLaMo 2 1BをSFTする

SFTをする部分はsft.py　というスクリプトにまとめてあります。このスクリプトの重要な部分について簡単にですが説明していきます。

まず、今回はすぐに実行が終わるように少量の質問と回答のペアのデータを用います。

今回は日本語の指示学習でよく使われるkunishou/databricks-dolly-15k-jaというデータセットのうち、input がなくinstruction とoutput のペアになっているデータのみを取り出しその一部だけを利用します。一つ例を見せると以下のようなデータを利用します。

{
  "output": "イコクエイラクブカ",
  "input": "",
  "index": "1",
  "category": "classification",
  "instruction": "魚の種類はどっち？イコクエイラクブカとロープ"
}

一部だけ取り出すコードは以下の通りです。

    dataset = datasets.load_dataset("kunishou/databricks-dolly-15k-ja")
    train_dataset = dataset["train"].filter(lambda data: data["input"] == "")

次にSFTConfig というSFTの実行の設定のクラスのインスタンスを用意します。具体的には以下の通りです。

    sft_args = SFTConfig(
        output_dir="./outputs",
        evaluation_strategy="no",
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        learning_rate=5e-5,
        num_train_epochs=0.1,
        lr_scheduler_type="cosine",
        warmup_ratio=0.3,
        logging_steps=10,
        save_strategy="epoch",
        report_to="tensorboard",
        bf16=True,
        max_seq_length=1024,
        gradient_checkpointing=True,
        deepspeed='./deepspeed_config.json',
    )

重要なこととして、今回はGPUのメモリが少ないため、DeepSpeedのStage 3という学習時に一部のデータをCPU側に置いておくモードを利用します。

これによりGPUメモリが少ない環境でもSFTを回すことができます。

DeepSpeed周りの設定はdeepspeed_config.json に書いてありますので気になる方はご覧ください。

また、今回は学習データの10%だけを利用するようにしています。これはこの学習を早く終わらせるためであり、本来はもっと回す必要があると考えられますので、本気でSFTをする場合は注意してください。

次にデータをどのようなフォーマットでLLMに入力するかを指定するformatting_func という関数を用意します。今回は以下のようにしました。

INSTRUCTION_TEMPLATE = string.Template(
    """### Question:
${input}

### Answer:
${response}<|plamo:eos|>
"""
)


def formatting_func(examples):
    output_texts = []
    for i in range(len(examples['instruction'])):
        text = INSTRUCTION_TEMPLATE.substitute(input=examples['instruction'][i], response=examples['output'][i])
        output_texts.append(text)
    return output_texts

INSTRUCTION_TEMPLATE が今回のフォーマットで、### Question:\n の後に指示、### Answer:\n のあとに回答が続き、最後にend of sequenceである<|plamo:eos|> が来るようになっています。

また、学習時には回答部分だけを学習してほしいので、どこからが回答かがわかるように‎DataCollatorForCompletionOnlyLM のインスタンスも用意します。これは以下の通りです。

    data_collator = DataCollatorForCompletionOnlyLM(
        response_template=tokenizer.encode(" Answer:\n", add_special_tokens=False),
        tokenizer=tokenizer
    )

response_template のところで回答前の部分がどのようなtoken idになるかを指定する部分があるので、上記のように指定します。前後の文字の影響で指定したtoken idが出現しないケースがあるので、その時はいろいろresponse_template に指定する文字列を調整してみてください。

最後にSFTを実行するためのクラスの‎SFTTrainer を以下のように用意します。

    trainer = SFTTrainer(
        model=model,
        args=sft_args,
        data_collator=data_collator,
        train_dataset=train_dataset,
        tokenizer=tokenizer,
        formatting_func=formatting_func,
    )

そして、以下のように実行し、結果を保存します。

    trainer.train()
    trainer.save_model()

これで学習が終わるとSFTConfig のoutput_dir で指定した./outputs に結果が出力されます。試しに私がGoogle Colabで実行した際は13分程度で学習が終わりました。コンピューティングユニットとしてはパッケージなどのインストールも含めて4だけ消費しました。

SFTされたモデルで推論してみる

最後にSFTされたモデルで推論するというのを行います。

これはPLaMo 2 1Bのexampleとほぼ同じでpromptだけ少し変えたものを例として用います。コードとしては以下の通りです。

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch


model_name = "./plamo-2-1b-sft-example/outputs"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True)


# プロンプトの準備
prompt = "### Question:\n埼玉の県庁所在地は何市？\n\n### Answer:\n"

# 推論の実行
inputs = tokenizer(prompt, return_tensors="pt")
generated_tokens = model.generate(
    **inputs,
    max_new_tokens=64,
    pad_token_id=tokenizer.pad_token_id,
)[0]
generated_text = tokenizer.decode(generated_tokens)
print(generated_text)

出力結果は以下のようになります。

<|plamo:bos|>### Question:
埼玉の県庁所在地は何市？

### Answer:
埼玉県の県庁所在地はさいたま市です。<|plamo:eos|>

ちゃんと学習で指定されたように### Answer:\n の後に質問に対する回答をし、その後<|plamo:eos|> を出力するということができています。

ちなみにSFTしていないモデルではどうなるかというと、以下のように余計なことを出力するうえ、出力が止まらないという状態になっています。

<|plamo:bos|>### Question:
埼玉の県庁所在地は何市？

### Answer:
さいたま市

### 解説
「県庁所在地」とは、都道府県庁が置かれている都市のことです。
「さいたま市」は埼玉県の県庁所在地です。

### 関連記事
### 取り急ぎお知らせ
「埼玉の県庁所在地は何市？」の解説は以上です。
「埼玉の県庁所在地は何市？」の解説は以上です。

このため、SFTでうまくフォーマットに従うよう学習できたと考えられます。

終わりに

今回はPLaMo 2 1Bを使ってSFTをする例を示しました。今回示したように簡単なSFTなら十分Google Colabで実行することができます。みなさんもぜひいろいろ試していただければと思います。

The post 小型LLM PLaMo 2 1BをGoogle ColabでSFTしてみる first appeared on まったり勉強ノート.

AlphaFold時代の構造バイオインフォマティクス実践ガイド〜今日からできる！構造データの基本操作から相互作用の推定、タンパク質デザインまで (実験医学別冊　最強のステップUPシリーズ)

羊土社

Amazon

楽天市場

ポチップ

どんな内容の本か？

みなさん、「構造バイオインフォマティクス」を勉強しようと思って挫折した経験はないでしょうか？私は何度もあります。
私自身、元々バイオインフォマティクスをやってた人間なこともあり、「構造バイオインフォマティクス」は一度はちゃんと勉強したいと常々思っています。
ただ、構造バイオインフォマティクスは分野としては幅広く、またAlphaFoldが出たおかげで急速に分野が発展している印象もあり、勉強するといっても何から手をつけていいのかよくわからないと思っていました。

そこに出たのがこの「AlphaFold時代の構造バイオインフォマティクス実践ガイド」です。この本は構造バイオインフォマティクスと聞いて思い浮かべる内容が網羅されているだけでなく、各タスクにおいて有名なツールや出てきた結果について具体的に教えてくれる本となっています。
なので、手を動かして「構造バイオインフォマティクス」を勉強したいと思ったら、今なら一番良い本だと思っています。

どんな人にお勧めか？

個人的には以下のような人におすすめかと思います。

1. 独学で手を動かしながら構造バイオインフォマティクスを勉強したい人
2. 構造バイオインフォマティクスがどういうことをやる分野なのか知りたい人

特に私のような１の人は特にお勧めかと思います。多くの章で有名なツールとそのツールの具体的な実行方法が載っているので、自分でも試したい！と思ったら試せるようになっているので非常に良かったです。

また、昨年AlphaFoldがノーベル賞を取ったこともあり、この辺の分野知りたいと思っている人もいるかと思います。その際、手っ取り早く網羅的にこの辺の分野を知りたいのであればこの本をパラ読みするのが今はちょうどよいかもと思っています。

個人的に良かった点

個人的に良かった点は以下のところです。

1. 各ツールの使い方が結構細かく書いてある
2. 各ツールの結果として、メトリックの説明と解釈についていろいろ書いてある

今まで構造バイオインフォマティクスについて勉強したいと思った際、ツールの使い方がよくわからない、または出てきた結果をどう解釈していいのかわからないという状況になりました。この結果、仕事の片手間に勉強するのは難しく何度も挫折してきました。このため、1や2が詳しく書いてある本があればと思っていたので、この本は非常に良い本だと思い、今年こそ頑張れそうな気がしています。

終わりに

今日は「AlphaFold時代の構造バイオインフォマティクス実践ガイド　今日からできる！構造データの基本操作から相互作用の推定、タンパク質デザインまで」を読んで非常によかったので紹介記事を書きました。
定期的にこのように本の紹介記事を書いてます。もし興味があれば他の本の記事も見ていただければ幸いです。

The post [書評] AlphaFold時代の構造バイオインフォマティクス実践ガイド ー 構造バイオインフォマティクスを勉強したい人におすすめな１冊 first appeared on まったり勉強ノート.

生成ＡＩのしくみ　〈流れ〉が画像・音声・動画をつくる (岩波科学ライブラリー)

岡野原 大輔

Amazon

楽天市場

Amazon Kindle

ポチップ

どんな内容の本か？

皆さん、生成AIのニュースが毎日のようにでている気がしますが画像や動画などのデータを生成する仕組みを簡単に説明することができるでしょうか？私は、自分の親にこれらの仕組みを説明できるほど分かりやすい説明はできないと思っていますが、この本はそんなAIについて詳しくない人向けに画像や動画などをどのようにAIが作っているか、技術の進化の歴史を交えて分かりやすく説明した本です。

この本の特徴としては普通の人が挫折せずに読めるように数式が一切出てこず、分かりにくい英語の専門用語も極力日本語訳をあてて、難しいところはイラストを使って分かりやすく説明されているのを感じました。
一方、これらの影響で私のような専門に近ければ近いほど、日本語訳に馴染みがなくて、これがどの論文の話をいっているのかぱっと分かりにくいところがあるうえに、数式が何もないこともあり、細かい部分が全くわからない本にもなっています。

このため、詳しく知りたい人は別の本、例えば同じ著者のこちらの本を読むほうが良いと思います。

どんな人にお勧めか？

おそらく以下のような人にお勧めかなと思っています。

1. 生成AIについて知りたいが数式が得意ではない人
2. 生成AIの発展の歴史を知りたい人

特にお勧めなのが1の人で、生成AIについて技術的な説明をしている本やすごい軽く説明している本はいくつかありますが、その中間くらいの数式は苦手だけどどのような仕組みで動いているのか知りたい人にはちょうどよい印象の本です。

また、これまで生成AIの取り組みはいろいろあったのですが、その発展の歴史を知りたいと思った人にもお勧めかと思います。
この本ではノーベル賞で話題になったホップフィールドネットワークの話題から生成AIへの流れを順番に説明されいて、ノーベル賞と生成AIがどうつながっているのかもわかるようになると思います。

個人的に良かった点

個人的に良かった点としては以下の通りです。

1. 生成AIの歴史について飛び飛びの部分を補完できた
2. 人に生成AIを説明するときどういう言い回しがいいのかの参考になった

特に1に関しては私も専門分野とはいえ、2017年くらいから深層学習の技術開発を始めた関係で、それよりも前の部分は人に説明できるような状態ではなかったのですが、そのあたりの歴史について知ることができたのは良かったです。

また、2に関して、生成AIは人に説明が難しいところが多いのですが、それをどういう風に説明すれば良いか少し分かった気がするので、その点も良かったです。

終わりに

今回は「生成ＡＩのしくみ　〈流れ〉が画像・音声・動画をつくる」という本を紹介しました。最初のほうにも書きましたが、この本は普通の人向けの本であり、技術的な詳細を知りたい方は例えば同じ著者の「拡散モデル データ生成技術の数理」や手を動かして勉強できる「ゼロから作るDeep Learning ❺ ―生成モデル編」が良いかと思っています。
「拡散モデル データ生成技術の数理」の方は紹介記事を書いたので参考にしてください。

定期的にこのような書評を書いているので、もし興味があれば他の本の記事も見ていただければ幸いです。

The post [書評] 生成ＡＩのしくみ ー 生成AIの進化の歴史が分かる一冊 first appeared on まったり勉強ノート.

どんな内容の本か？

ソフトウェアを開発していればテストが大事なのは百も承知だと思いますが、「機械学習のテストってどうやるの？」と思ったことはないでしょうか。この本ではそんな機械学習のテストをどうやればいいのかについてまとめた本です。

この本では最初に一般的なソフトウェアテストの方法から入りその後、データセットの品質、深層学習のテストなどを説明しています。
機械学習といってもいろいろなモデルがありますが、この本では深層学習多めですが、一部に関しては他のモデルでも使えると思っています。
注意点として2020年の本で深層学習を扱っているので、進歩がすごい速い深層学習界隈からすると情報が古い感じがありますので、最新の情報がほしいという場合は研究論文をあたるほうが良いかもしれません。

どんな人にお勧めか？

個人的には以下のような人におすすめかと思っています。

1. 機械学習の品質について勉強したい方
2. 企業で機械学習の品質をどう保証すればよいか悩んでる方

私自身、企業で機械学習を使ったサービス開発をしていることもあり、2の立場でどうすればよいか悩むことが多いです。このためこの本を通して何を気にするべきかのまとめを知ることができたので、今後サービスを開発する上で参考にできそうだと思っています。

個人的に良かった点

個人的に良かったこととしては以下の通りです。

1. 今後機械学習サービス開発で注意すべきことのまとめを知ることができた。
2. 一般的なソフトウェアのテストの基本も学ぶことができた

1に関しては先ほども書いた通りです。2に関しては3章で気保温的なソフトウェアのテストについて書かれていて、期待してなかったですが、この部分が意外にも勉強になることが多かったです。私自身はunittestのような簡単なテスト手法については書籍などで勉強をしたことがある程度だったので、この本で紹介されていたメタモルフィックテスティングという方法を知りませんでした。（正確にはメタモルフィックテスティングという名前がついているということを知らずに似たようなことをしていた）このようにソフトウェアのテストの基礎も勉強できたので良かったです。

終わりに

今回は「ソフトウェア工学から学ぶ 機械学習の品質問題」を読んだので紹介しました。テストは難しい
今回は隔週でこのように本の紹介記事を書いてます。もし興味があれば他の本の記事も観ていただければ幸いです。

The post [書評] ソフトウェア工学から学ぶ機械学習の品質問題 ー 機械学習のテストをどうすればよいか悩んだら読む一冊 first appeared on まったり勉強ノート.

どんな内容の本か？

ChatGPTをいろいろなところで目にしますが、そもそもChatGPTってどういう仕組みなんだろう、今までの機械学習のモデルとは何が違うんだろう？と思ったことはないでしょうか？

ChatGPTが流行り始めたとき、そのような内容のblogをよく見ましたが、この本では一般的な人向けに、利点やリスク、今後どう付き合っていくべきか？などに加えて、どうしてChatGPTみたいなものが生まれたのかという点について時系列でどのような研究があったのかを紹介しています。

専門家じゃない人は突然ChatGPTみたいなものができるようになったように思いがちかもしれませんが、着実な進歩の上に成り立っている技術であることがわかると思います。

どんな人にお勧めか？

個人的には以下のような人にお勧めかと思います。

1. ChatGPTにはどのような利点やリスクがあるのかを知りたい方
2. AIの専門家ではないが、ChatGPTに関係する研究の流れなどを知りたい方
3. 言語モデルについて何も知りたいから勉強したい方

普通の社会人の方は1の方が多いと思いますが、この本は一般人向けに書かれているので、難しい話はほとんどなくサクサク読めるのでお勧めです。また、言語モデルの専門家ではない人が軽くChatGPTがどういうものかを知りたい場合も良い本かと思います。

一方、専門家の方はおそらくよく知った内容が多いと思われます。このため物足りない内容になっていると思うので、そういう方はあまりお勧めはしません。
また、ChatGPTについての具体的な使い方や使いこなすコツみたいなものは書かれてないので、そのあたりが知りたい方も注意してください。

個人的に良かった点

個人的には以下の点が良かったです。

1. ChatGPTについて幅広い内容を押さえていて、まずこれを読むといいという本になっている
2. 利点やリスク、今後どうChatGPTに付き合っていくべきかの作者の考えているのかの一端が分かる

ChatGPTについてはいろいろなblog記事や本がでています。その中でも「どんな内容の本か？」で述べた点については１冊にまとまっていて分かりやすかった印象です。
また、実は作者は直属の上司で、普段話していて利点やリスク等についての考えの概要みたいなものは知っていました。ただ、このような本になっていると話しているだけではわからない細かいつながりも理解できて良かったと思いました。

終わりに

今回は「大規模言語モデルは新たな知能か――ChatGPTが変えた世界」を読んだのでその書評回です。
他にも毎週１冊は本の書評の記事を書いていますので、本が好きな方は他の記事も見ていただけると幸いです。

The post [書評] 大規模言語モデルは新たな知能か ー 専門家じゃない人がChatGPTの技術的なことを知りたいと思ったら最適な一冊 first appeared on まったり勉強ノート.

その第3弾として「2.3 デノイジング拡散確率モデル」で説明されているデノイジング拡散確率モデル（DDPM）の学習とそれを使ったサンプリングについてPython(深層学習部分はPytorch)でコードを書いて試したのでそのまとめになります。今回の記事ではDDPMの細かい数式を説明すると記事の量がすごいことになりそうなので、重要な部分だけ説明していきます。

また、この本を買うか迷っている方は私が読んだ感想をこちらの記事に書いてますので参考にしてみてください。

また、この記事で紹介したコードは以下にあげてありますので、コード全体を確認したい方はこちらをご覧ください。

https://github.com/shu65/diffusion-model-book/blob/main/diffusion_model_book_2_3_ddpm.ipynb

デノイジング拡散確率モデルとは

デノイジング拡散確率モデル（DDPM）はデータに対して徐々にノイズを加えていく拡散過程を逆向きに辿っていく逆拡散過程によってデータ生成を行います。図でみると分かりやすいと思うので拡散過程と逆拡散過程の関係図を以下に示します。

まずは上の図の上段の拡散過程についてです。ここでは\(\boldsymbol{x}_0\)がオリジナルのデータで、これに徐々にノイズを加えていき、\(\boldsymbol{x}_1, \boldsymbol{x}_2, \boldsymbol{x}_3, …, \boldsymbol{x}_T\)といいうデータを作っていきます。これを確率密度関数で表すと以下のようになります。

$$ \begin{align*}
q(\boldsymbol{x}_{1:T}|\boldsymbol{x}_0) :=& \prod_{t=1}^T q(\boldsymbol{x}_t|\boldsymbol{x}_{t-1}) \tag{2.1.1} \\
q(\boldsymbol{x}_{t}|\boldsymbol{x}_{t-1}) :=& \mathcal{N}(\boldsymbol{x}_t; \sqrt{\alpha_t}\boldsymbol{x}_{t-1}, \beta_t \boldsymbol{I}) \tag{2.1.2} \\
\end{align*} $$

ここで\(\beta_t\) は分散の大きさを制御するパラメータで、\(0<\beta_1<\beta_2<…<\beta_T<1\)です。また、\(\alpha_t := 1 – \beta_t\) で、\(\alpha_t, \beta_t\)を合わせてノイズスケジュールと呼びます。

ここで、\(\mathcal{N}(\boldsymbol{x}_t; \sqrt{\alpha_t}\boldsymbol{x}_{t-1}, \beta_t \boldsymbol{I})\) について詳しく見ていきます。この拡散過程を繰り返していくと、\(\beta_t\) は徐々に大きくなります。結果として、ノイズ成分は大きくなっていきます。

一方、\(\beta_t\)が大きくなるということは\(\alpha_t := 1 – \beta_t\) なので\(\boldsymbol{x}_{t-1}\)の係数の\(\sqrt{\alpha_t}\)はどんどん小さくなっていきます。結果として、拡散過程を繰り返していくと任意の\(\boldsymbol{x}_{0}\)に対して、以下のような近似ができるようになります。

$$ \begin{align*}
q(\boldsymbol{x}_{T}|\boldsymbol{x}_{0}) :=& \mathcal{N}(\boldsymbol{x}_T; 0, \boldsymbol{I}) \tag{2.1.3} \\
\end{align*} $$

次に、図の下段の逆拡散過程です。これは\(\mathcal{N}(\boldsymbol{x}_T; 0, \boldsymbol{I}) \)からスタートして拡散過程を逆向きに辿っていく処理になります。

この逆拡散過程の各ステップを正規分布で表し、この正規分布の平均と共分散行列を一つ前のステップの変数\(\boldsymbol{x}_{t}\)と時刻\(t\)を入力としてパラメータ\(\theta\)を使ったモデル(\(\mu_{\theta}(\boldsymbol{x}_{t}, t), \Sigma(\boldsymbol{x}_{t}, t))\))として表します。これを使うと逆拡散過程は以下のような式で表すことができます。

$$ \begin{align*}
p_{\theta}(\boldsymbol{x}_{0:T}) :=& p(\boldsymbol{x}_T)\prod_{t=1}^T p_{\theta}(\boldsymbol{x}_t-1|\boldsymbol{x}_{t}) \tag{2.1.4} \\
p_{\theta}(\boldsymbol{x}_{t-1}|\boldsymbol{x}_{t}) :=& \mathcal{N}(\boldsymbol{x}_{t-1}; \mu_{\theta}(\boldsymbol{x}_{t}, t), \Sigma_{\theta}(\boldsymbol{x}_{t}, t)) \tag{2.1.5} \\
p(\boldsymbol{x}_{T}) =& \mathcal{N}(\boldsymbol{x}_T; 0, \boldsymbol{I}) \tag{2.1.6}
\end{align*} $$

この\(\mu_{\theta}(\boldsymbol{x}_{t}, t), \Sigma_{\theta}(\boldsymbol{x}_{t}, t)\)は後ほど示す通りニューラルネットワークなどを使ってモデル化します。これによって逆拡散過程を実現しています。

では次から実際にこのモデルのパラメータ\(\theta\)の学習方法とそれを使ったサンプリングを見ていきます。

デノイジング拡散確率モデルの学習

デノイジング拡散確率モデルのモデルの学習方法の説明を本来はしたいのですが、この説明はすごく長いものになります。このため、詳しい説明は本を見ていただくとして、ここでは学習を回すうえで重要な変数と式に関する簡単な説明にとどめておきます。

まず、先ほど示した式(2.1.2)などを利用すると以下の式が導けます。

$$ \begin{align*}
q(\boldsymbol{x}_{t}|\boldsymbol{x}_{0}) :=& \mathcal{N}(\boldsymbol{x}_t; \sqrt{\bar{\alpha}_t}\boldsymbol{x}_{0}, \bar{\beta}_t \boldsymbol{I}) \tag{2.1.7} \\
\bar{\alpha}_t := \prod_{s=1}^t \alpha_s \tag{2.1.8} \\
\bar{\beta}_t := 1 – \bar{\alpha}_t \tag{2.1.9} \\
\end{align*} $$

式(2.1.7)から式(2.1.9)の導出の証明に関しては本の式(2.1)の下に証明がありますので詳しく知りたい方はそちらをご覧ください。

これにより、わざわざ式(2.1.2)に従って、\(\boldsymbol{x}_{0}\)から徐々に\(t\)を大きくして\(\boldsymbol{x}_{t}\)を生成しなくても、式(2.1.7)を使うことで正規分布のサンプリングを１度すれば任意の\(t\)の\(\boldsymbol{x}_{t}\)のデータを生成できることになります。学習ではこれを利用して高速にランダムな\(t\)のデータを生成して学習に利用します。

次にデノイジング拡散確率モデルの学習で用いるロス関数についてです。これに関しては前の記事でも紹介したスコアベースモデルと同じようにデノイジングスコアマッチングを利用します。また、ロス関数の導出は先ほど説明した通り、ちゃんと説明しようとするとすごく長いので本で示されている最終的な結果を以下に示します。

$$ \begin{align*}
L_{\gamma}(\theta) =& \sum_{t=1}^T w_t E_{\boldsymbol{x}_0, \epsilon} \left\{ \left\| \epsilon – \epsilon_{\theta}(\sqrt{\bar{\alpha}_t}\boldsymbol{x}_0 + \sqrt{\bar{\beta}_t}\epsilon, t) \right\|^2 \right\} \tag{2.1.10} \\
\gamma =& \left\{ w_1, w_2, …, w_T \right\} \tag{2.1.11}
\end{align*} $$

この式の\(w_t\)に関しては本によると\(w_t = 1\) がよくつかわれるとのことなので、このあとの実装のコードでも\(w_t = 1\)としています。

ここで、式の導出を省略して関係が分かりにくくなっていため、逆拡散過程の説明で出てきた式(2.1.5)の中の\(\mu_{\theta}(\boldsymbol{x}_{t}, t), \Sigma_{\theta}(\boldsymbol{x}_{t}, t)\)と式(2.1.10)の中で出てきている\(\epsilon_{\theta}(\sqrt{\bar{\alpha}_t}\boldsymbol{x}_0 + \sqrt{\bar{\beta}_t}\epsilon, t)\) との関係を説明しておきます。

逆拡散過程を行う上で\(\mu_{\theta}(\boldsymbol{x}_{t}, t), \Sigma_{\theta}(\boldsymbol{x}_{t}, t)\)のパラメータ\(\theta\)を学習する必要があります。ここで、本の説明によると\(\Sigma_{\theta}(\boldsymbol{x}_{t}, t)\)に関してはパラメータ\(\theta\)に依存しない固定の\(\Sigma_{\theta}(\boldsymbol{x}_{t}, t)) = \sigma_t^2 \boldsymbol{I}\)を使うことが多いそうです。先ほど示したロス関数も\(\Sigma_{\theta}(\boldsymbol{x}_{t}, t)) = \sigma_t^2 \boldsymbol{I}\)として式変形しています。

次に\(\mu_{\theta}(\boldsymbol{x}_{t}, t)\)の部分です。こちらはロス関数の導出の過程で結局は\(t\)の時点で加えられたノイズを予測できるモデルに置き換えることができます。このため、\(\mu_{\theta}(\boldsymbol{x}_{t}, t)\)ではなく、ノイズを予測する\(\epsilon_{\theta}(\boldsymbol{x}_{t}, t)\)がロス関数の中で登場しています。

また、\(\boldsymbol{x}_{t}\) は式(2.1.7)から以下のようになります。

$$ \begin{align*}
\boldsymbol{x}_{t} =& \sqrt{\bar{\alpha}_t}\boldsymbol{x}_0 + \sqrt{\bar{\beta}_t}\epsilon \\
\epsilon \sim& \mathcal{N}(0, \boldsymbol{I}) \\
\tag{2.1.12}
\end{align*} $$

本のほうには丁寧にこのロス関数の導出が書かれているので詳細を知りたい方はぜひ本を読んでください。

この式(2.1.10)をロス関数として利用したデノイジング拡散確率モデルの学習の疑似コードは以下の通りです。(「拡散モデル　データ生成技術の数理」Algorithm 2.2の引用)

1. repeat
2. \(\quad \boldsymbol{x}_0 \sim p_{\text{data}}(\boldsymbol{x}_0)\)
3. \(\quad t \sim \text{Uniform}({1, …, T})\)
4. \(\quad \epsilon \sim \mathcal{N}(0, \boldsymbol{I})\)
5. \(\quad g := \nabla_{\theta} w_t \left\| \epsilon – \epsilon_{\theta}(\sqrt{\bar{\alpha_t}} \boldsymbol{x}_0 + \sqrt{\bar{\beta_{t}}} \epsilon, t)\right\|^2 \)
6. \(\quad \theta := \theta – \alpha g \)
7. until converged

ここで本では特に説明されてないですが、式(2.1.10)の最初の\(\sum_{t=1}^T\)の部分は少し変更して、\(t=1\)から\(t=T\)ランダムに\(t\)を選んで使用するように変更されています。

このアルゴリズムでは、まず最初にデータ\(\boldsymbol{x}_0 \)と\(t\)を選び、それらを用いて式(2.1.10)のロス関数を計算します。その後、勾配を計算してパラメータのアップデートをするということを繰り返します。6行目の勾配を使ったパラメータのアップデートは深層学習の基本的なパラメータ更新の確率的勾配降下法を利用したコードになっています。この部分は確率的勾配降下法以外のもの、例えばAdamなどでも問題ありません。

この疑似コードを基にPyTorchで実装するとこのようになります。

batch_size = 512
n_steps = 100000

dataloader = torch.utils.data.DataLoader(dataset, batch_size=512, shuffle=True, num_workers=0)
dataloader_iter = iter(dataloader)

model = Model().to(device)

optimizer = torch.optim.Adam(model.parameters())
lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.001, total_steps=n_steps)
loss_func = torch.nn.MSELoss(reduction="none")

for i in range(n_steps):
  try:
    x0 = next(dataloader_iter)[0]
  except StopIteration:
    dataloader_iter = iter(dataloader)
    x0 = next(dataloader_iter)[0]
  x0 = x0.to(device)

  optimizer.zero_grad()

  noise = torch.randn_like(x0)
  t = torch.randint(0, len(x0), (x0.shape[0],), device=device)
  x = torch.sqrt(alpha_bars[t])[:, None] * x0 + torch.sqrt(beta_bars[t])[:, None] * noise
  noise_pred = model(x, t)
  w = 1.0
  losses = w * loss_func(noise_pred, noise)
  loss = losses.mean()

  loss.backward()
  optimizer.step()
  lr_scheduler.step()

基本的には疑似コードとほぼ同じですが、ロス関数周りで違うところがあるので、簡単に説明します。まず、深層学習なのでミニバッチを使った学習に置き換えています。このため、\(\boldsymbol{x}_0 \)も一つだけでなく、バッチサイズ分ランダムに選んでいます。これに伴って、\(t\)もバッチサイズ分ランダムに選んで利用します。そして、最終的には各データ点のロス関数の値の平均を計算して勾配を計算するという形に置き換えています。

また、パラメータの最適化の部分は確率勾配降下法ではなくAdamを利用しています。

デノイジング拡散確率モデルを使ったサンプリング

ここから先ほど紹介した方法で学習したモデルを利用してどのようにサンプリングしていくか、について説明します。

基本的には式(2.1.5)に従って逆拡散過程のステップを繰り返すことで実現します。

ここで、説明を省略してしまいましたが、式(2.1.5)の中にでてくる\(\mu_{\theta}(\boldsymbol{x}_{t}, t)\)を学習したノイズを予測するモデル\(\epsilon_{\theta}(\boldsymbol{x}_{t}, t)\)を使って表すと以下のようになります。

$$ \begin{align*}
\mu_{\theta}(\boldsymbol{x}_{t}, t) =& \frac{1}{\sqrt{\bar{\alpha}}} \left( \boldsymbol{x}_{t} – \frac{\beta_t}{\sqrt{\bar{\beta_t}}} \epsilon_{\theta}(\boldsymbol{x}_{t}, t) \right) \tag{2.1.13}
\end{align*} $$

また、一方、\(\Sigma_{\theta}(\boldsymbol{x}_{t}, t))\)は先ほど説明した通り、\(\Sigma_{\theta}(\boldsymbol{x}_{t}, t)) = \sigma_t^2 \boldsymbol{I}\)です。

これらと式(2.1.5)に従ったサンプリングの疑似コードは以下の通りです。(「拡散モデル　データ生成技術の数理」Algorithm 2.3の引用)

1. \(\boldsymbol{x}_T \sim \mathcal{N}(0, \boldsymbol{I})\)
2. for \(t=T, …, 1\) do
3. \(\quad \boldsymbol{u}_t \sim \mathcal{N}(0, \boldsymbol{I})\)
4. \(\quad\) if \(t=1\) then \(\boldsymbol{u}_t := 0\)
5. \(\quad \boldsymbol{x}_{t-1} := \frac{1}{\sqrt{\bar{\alpha}}} \left\{ \boldsymbol{x}_{t} – \frac{\beta_t}{\sqrt{\bar{\beta_t}}} \epsilon_{\theta}(\boldsymbol{x}_{t}, t) \right\} + \sigma_t \boldsymbol{u}_t \)
6. end for
7. return \(\boldsymbol{x}_0\)

基本的には徐々にノイズを取り除くことで目的のデータをサンプリングするという流れです。

PyTorchのコードとしては以下のようになります。

def ddpm_sample(n_samples, model, alphas, betas, beta_bars):
    xt = torch.randn(n_samples, 2)
    T = len(alphas)
    for t in range(T -1, -1, -1):
      print(f"t:{t}")
      ut = torch.randn(n_samples, 2)
      if t == 0:
        ut[:, :] = 0.0
      with torch.no_grad():
        noise_pred = model(xt, t*torch.ones(n_samples, dtype=xt.dtype))
        sigma_t = torch.sqrt(betas[t])
        xt = 1 / torch.sqrt(alphas[t]) * (xt - betas[t]/torch.sqrt(beta_bars[t])*noise_pred) + sigma_t*ut
    return xt

ここで、n_samplesがサンプリングするサンプル数、modelが\(\epsilon_{\theta}(\boldsymbol{x}_{t}, t)\)、alphas、betas, beta_barsがそれぞれ\(\alpha_t, \beta_t, \bar{\beta}_t\) のリストです。

実行例

先ほど紹介したPythonコードを実際に動かした例も示しておきます。参考例として入力となる\(\boldsymbol{x}\)のサンプリングする分布の確率密度関数は以下のように平均が違うガウス分布二つの混合分布とし、サンプリングしたデータを正規化して使用します。

n_samples = int(1e6)
sigma = 0.01

dist0 = torch.distributions.MultivariateNormal(torch.tensor([-2, -2], dtype=torch.float).to(device), sigma*torch.eye(2, dtype=torch.float).to(device))
samples0 = dist0.sample(torch.Size([n_samples//2]))
    
dist1 = torch.distributions.MultivariateNormal(torch.tensor([2, 2], dtype=torch.float).to(device), sigma*torch.eye(2, dtype=torch.float).to(device))
samples1 = dist1.sample(torch.Size([n_samples//2]))
samples = torch.vstack((samples0, samples1))

mean = torch.mean(samples, dim=0)
std = torch.std(samples, dim=0)

normalized_samples = (samples - mean[None, :])/std[None, :]

使用する\(\boldsymbol{x}\)を2Dのヒストグラムで可視化すると以下のようになります。

このデータを再現できるようにデノイジング拡散確率モデルを学習します。コードとしては先ほど示した通りです。

学習が終わったら次は以下のようにサンプリングを行います。

samples_pred = ddpm_sample(n_samples=100000, model=model, alphas=alphas, betas=betas, beta_bars=beta_bars)

サンプリングされたデータの2Dのヒストグラムは以下の通りです。

可視化結果をみると元の分布の平均の近くにデータが集中しているので、うまくいっていると考えられます。

終わりに

今回は「拡散モデル　データ生成技術の数理」の2.3のデノイジング拡散確率モデルの簡単な説明とコードを書いたのでそのまとめの記事になります。先日スコアベースモデルのコードを用意したことで、そのコードを参考に今回のデノイジング拡散確率モデルをすぐに作ることができたのですが、説明はすごい大変でした。

スコアベースモデルのほうも気になるという方はこちらをご覧ください。

今後、3章で紹介されている連続時間化拡散モデルのVE-SDEのほうも紹介予定です。コードは昨日できました。ただ、思ったよりも説明が大変そうなので、記事を書くのに時間がかかると思います。

この記事が少しでもみなさんの理解の助けになれば幸いです。

参考文献

1. Ho, J., Jain, A., & Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. ArXiv, abs/2006.11239.
2. https://github.com/hojonathanho/diffusion

The post [勉強ノート] 「拡散モデル　データ生成技術の数理」 2.3 デノイジング拡散確率モデル first appeared on まったり勉強ノート.

その第2弾として「2.2 スコアベースモデル」で説明されているスコアベースモデルの学習とそれを使ったサンプリングについてPython(深層学習部分はPytorch)でコードを書いて試したのでそのまとめになります。

また、この本を買うか迷っている方は私が読んだ感想をこちらの記事に書いてますので参考にしてみてください。

また、この記事で紹介したコードは以下にあげてありますので、コード全体を確認したい方はこちらをご覧ください。

https://github.com/shu65/diffusion-model-book/blob/main/diffusion_model_book_2_2_score_based_model.ipynb

スコアベースモデルとは

１章で紹介されているデノイジングスコアマッチングは以下の２つの問題点があると本では紹介されています。

1. デノイジングスコアマッチングで推定されたスコア関数はデータ分布の密度が小さい領域で不正確
2. データ分布が多峰性を持つ場合、あるモード（確率が大きい領域）から他のモードに移る際、確率が小さい領域を通過するために非常に多くのステップを必要とする

これらの問題を解決するためにスコアベースモデル（SBM）[1, 2] では複数の異なる強度のノイズによって攪乱した攪乱後分布を用意して、それらの攪乱後分布上のスコアを求めるようにしています。

スコアベースモデルの学習

スコア関数 \(s_{\theta}(\boldsymbol{x}, \sigma_t)\) を学習する際は以下のロス関数を使います。

$$ \begin{align*}
L_{\text{SBM}}(\theta) := \sum_{t=1}^T w_t E_{p_{\sigma_t}}(\tilde{\boldsymbol{x}}) \left\{ \left\| \nabla_{\tilde{\boldsymbol{x}}} \log p_{\sigma_t}(\tilde{\boldsymbol{x}}) – s_{\theta}(\tilde{\boldsymbol{x}}, \sigma_t) \right\|^2 \right\} \tag{2.2.1}
\end{align*} $$

ここで\(\sigma_t \) はノイズの強さを表す変数で\( \sigma_{min} = \sigma_1 < \sigma_2 <… < \sigma_T = \sigma_{max}\)の合計\(T\)個をスコアベースモデルでは利用します。そして、\(p_{\sigma_t}(\tilde{\boldsymbol{x}}) \) \(x\)は\(x\)の分布\(p(x)\)を\(\sigma_t\)の強さで攪乱したあとの分布を表しています。

この式(2.2.1)を本の1.5.5の「デノイジングスコアマッチング」で説明されている通り、デノイジングスコアマッチングを使って式を書き換えると以下のようになります。

$$ \begin{align*}
L_{\text{DSM-SBM}}(\theta) := \sum_{t=1}^T w_t E_{\boldsymbol{x} \sim p_{data}(\boldsymbol{x}),\tilde{\boldsymbol{x}} \sim \mathcal{N}(\boldsymbol{x}, \sigma_t^2\boldsymbol{I})} \left\{ \left\| \frac{\boldsymbol{x} – \tilde{\boldsymbol{x}}}{\sigma_t^2} – s_{\theta}(\tilde{\boldsymbol{x}}, \sigma_t) \right\|^2 \right\} \tag{2.2.2}
\end{align*} $$

詳細は本にわかりやすくかいてあるので本を参照してください。

ここで本の式(1.9)のデノイジングスコアマッチングの式において最初に\(1/2\)があるのに式(2.2.2)ではそれが省略されています。これに関して本にはちゃんと書いてない気がしますが、おそらくこれは\(w_t\)の中に\(1/2\)が含まれているから、もしくは\(1/2\)は定数であり、最適化の際にパラメータが移動する方向は\(1/2\)のありなしで変わらないということで省略しているのではないかと思っています。

ここから２章にはちゃんと書いてないですが、Pythonで実装するためにさらに式変形していきます。\(\tilde{\boldsymbol{x}} \sim \mathcal{N}(\boldsymbol{x}, \sigma_t^2\boldsymbol{I})\)なので、\(\tilde{\boldsymbol{x}}\)を\(\epsilon \sim \mathcal{N}(0, \sigma_t^2 \boldsymbol{I})\)を使って表すと以下のようになります。

$$ \begin{align*}
\tilde{\boldsymbol{x}} = \boldsymbol{x} + \epsilon \tag{2.2.3}
\end{align*} $$

この式(2.2.3)を使って式(2.2.2)を式変形すると以下の通りです。

$$ \begin{align*}
L_{\text{DSM-SBM}}(\theta) :=& \sum_{t=1}^T w_t E_{\boldsymbol{x} \sim p_{data}(\boldsymbol{x}),\tilde{\boldsymbol{x}} \sim \mathcal{N}(\boldsymbol{x}, \sigma_t^2\boldsymbol{I})} \left\{ \left\| \frac{\boldsymbol{x} – \tilde{\boldsymbol{x}}}{\sigma_t^2} – s_{\theta}(\tilde{\boldsymbol{x}}, \sigma_t) \right\|^2 \right\} \\
=& \sum_{t=1}^T w_t E_{\boldsymbol{x} \sim p_{data}(\boldsymbol{x}),\epsilon \sim \mathcal{N}(\boldsymbol{x}, \sigma_t \boldsymbol{I})} \left\{ \left\| \frac{-\epsilon}{\sigma_t^2} – s_{\theta}(\tilde{\boldsymbol{x}}, \sigma_t) \right\|^2 \right\} \tag{2.2.4}
\end{align*} $$

この式を見たときに\(t=1\)から\(t=T\)までの和をとっている部分、\(T\)のサイズによっては計算量がすごいことにならないか？ということを思いました。このため、何か実装するときに工夫があるのかも？ということで[2]著者実装である[3]を見にいきました。すると2023/03/03時点では\(t=1\)から\(t=T\)ランダムに\(t\)を選び、その平均をとるということをしていました。

Pythonのコードのほうが分かりやすいと思うので、以下にPythonのコードも示しておきます。

def dsm_loss(score_model, samples, sigmas):
  t = torch.randint(0, len(sigmas), (samples.shape[0],), device=sigmas.device)
  used_sigmas = sigmas[t].view(samples.shape[0], *([1] * len(samples.shape[1:])))
  noise = torch.randn_like(samples) * used_sigmas
  perturbed_samples = samples + noise
  target = - 1 / (used_sigmas ** 2) * noise
  scores = score_model(perturbed_samples, used_sigmas)
  target = target.view(target.shape[0], -1)
  scores = scores.view(scores.shape[0], -1)
  w = used_sigmas.squeeze(-1) ** 2
  loss = ((scores - target) ** 2).sum(dim=-1) * w
  return loss.mean()

ここでscore_modelがスコア関数 \(s_{\theta}(\boldsymbol{x}, \sigma_t )\) 、samplesが\(\boldsymbol{x}\)、sigmasが\(\{\sigma_1,…,\sigma_T\}\)の配列となっています。また、\(w_t\)は本にならって\(w_t=\sigma_t^2\)を使っています。

この関数では最初にランダムに\(t\)を選び、それに従ってノイズを生成し、\(\tilde{\boldsymbol{x}}\)を作ります。その後、スコア関数のscore_modelを使ってスコアを計算し、式(2.2.4)を使ってロス関数を計算します。

このロス関数を使ってスコア関数のパラメータを学習していきます。

ここで１つ、スコア関数のモデルに関して注意点があります。スコア関数は\(s_{\theta}(\boldsymbol{x}, \sigma_t) \)は\(\boldsymbol{x}\)だけでなく\(\sigma_t\)も引数にとります。このため、モデルの中でどうにかして\(\sigma_t \)と\(\boldsymbol{x}\)の入力を組み合わせる必要があります。これに関して今回のコードでは[3]の実装にならって、以下のようにして\(\boldsymbol{x}\)だけを入力として受け取るスコア関数\(s_{\theta}^{\prime}(\boldsymbol{x})\)の出力を\(\sigma_t\)で割るという形にしています。

$$ \begin{align*}
s_{\theta}(\boldsymbol{x}, \sigma_t) = s_{\theta}^{\prime}(\boldsymbol{x}) / \sigma_t \tag{2.2.5}
\end{align*} $$

また、後ほど示しますが、今回は２つのガウス分布の混合分布を入力とします。この分布はシンプルな分布なため、今回は簡単なMLPをスコア関数のモデル使用します。コードとては以下のようになります。

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

class ScoreModel(nn.Module):
  def __init__(self, n_channels=2):
    super(ScoreModel, self).__init__()

    self.model = nn.Sequential(
        nn.Linear(n_channels, 2*n_channels),
        nn.ELU(),
        nn.Linear(2*n_channels, 16*n_channels),
        nn.ELU(),
        nn.Linear(16*n_channels, 2*n_channels),
        nn.ELU(),
        nn.Linear(2*n_channels, n_channels),
    )

  def forward(self, x, sigma):
    y = self.model(x)
    return y/sigma

スコアベースモデルを使ったサンプリング

ここから学習済みのスコア関数\(s_{\theta}(\boldsymbol{x}, \sigma_t) \)を使ったサンプリングについて説明していきます。

スコアベースモデルを使ったサンプリング１章で紹介されたランジュバン・モンテカルロ法をベースにしています。ランジュバン・モンテカルロ法の部分についてはこちらに解説しています。

詳細は上の記事にかいてありますが、ランジュバン・モンテカルロ法は最初、ランダムに\(\boldsymbol{x}_0\)を生成後、以下のランジュバン・モンテカルロ法の更新則を\(K\)回繰り返すことで\(p(\boldsymbol{x})\)からサンプリングしたようなデータを作ります。

$$ \begin{align*}
\boldsymbol{x}_k := \boldsymbol{x}_{k-1} + \alpha \nabla_\boldsymbol{x} \log p(\boldsymbol{x}_{k-1}) + \sqrt{2\alpha}\boldsymbol{u}_k \tag{2.2.6}
\end{align*} $$

スコアベースモデルのサンプリングでは更新則のスコア（\(\nabla_\boldsymbol{x} \log p(\boldsymbol{x}_{k-1})\)）を学習したスコア関数に置き換えた以下の更新則を利用します。

$$ \begin{align*}
\boldsymbol{x}_{t, k} := \boldsymbol{x}_{t, k-1} + \alpha_t s_{\theta}(\boldsymbol{x}_{t, k-1}, \sigma_t)+ \sqrt{2\alpha_t}\boldsymbol{u}_k \tag{2.2.7}
\end{align*} $$

この更新則を用いたスコアベースモデルのサンプリングの疑似コードは以下の通りです。(「拡散モデル　データ生成技術の数理」Algorithm 2.1の引用)

1. \(\boldsymbol{x}_0\)を初期化(\(\boldsymbol{x}_0 \sim \mathcal{N}(0, \sigma_T^2 \boldsymbol{I})\))
2. for \(t=1,…,T\) do
3. \(\quad \alpha_t := \alpha \sigma_t^2\/\sigma_T^2)\
4. \(\quad\) for \(k=1,…,K\) do
5. \(\qquad \boldsymbol{u}_k \sim \mathcal{N}(0, \boldsymbol{I})\)
6. \(\qquad\) if \(t=1\) and \(k=K\) then \(\boldsymbol{u}_k := 0\)
7. \(\qquad \boldsymbol{x}_{t, k} := \boldsymbol{x}_{t, k-1} + \alpha_t s_{\theta}(\boldsymbol{x}_{t, k-1}, \sigma_t)+ \sqrt{2\alpha_t}\boldsymbol{u}_k \)
8. \(\quad\) end for
9. \(\quad \boldsymbol{x}_{t-1, 0} := \boldsymbol{x}_{t, K}\)
10. end for
11. return \(\boldsymbol{x}_{0, 0}\)

ここで\(\alpha\)はステップ幅のスケール、\(K\)はステップ回数です。アルゴリズムを見て分かる通り、ノイズの強度を変えながらランジュバン・モンテカルロ法を使って少しずつ\(\boldsymbol{x}_{t, k}\)を変化させています。また、７行目にある通り、各ノイズの強度の最後のステップではデノイジングのみを行うことでサンプリングの品質を向上させています。

この疑似コードをPythonのコードにするとこのようになります。

def sbm_sample(n_samples, score_model, sigmas, alpha=0.1):
    sigma_T = sigmas[-1]
    x_0 = torch.randn(n_samples, 2)*sigma_T
    x_tk = x_0
    K = 200
    for t in range(len(sigmas) -1, -1, -1):
      sigma_t = sigmas[t]
      alpha_t = alpha*(sigma_t**2)/(sigma_T**2)
      print(f"t:{t}, sigma_t:{sigma_t}, alpha_t:{alpha_t}")
      for k in range(K+1):
        u_k = torch.randn(n_samples, 2)
        if (k == K) and t == 0:
          u_k[:, :] = 0.0
        with torch.no_grad():
          score = score_model(x_tk, sigma_t)
          x_tk = x_tk + alpha_t * score + np.sqrt(2 * alpha_t) * u_k
    return x_tk

n_samplesが生成するサンプル数、score_modelがスコア関数、sigmasがノイズ強度の配列、alphaがステップ幅のスケールになっています。

実行例

先ほど紹介したPythonコードを実際に動かした例も示しておきます。参考例として入力となる\(\boldsymbol{x}\)のサンプリングする分布の確率密度関数は以下のように平均が違うガウス分布二つの混合分布とし、サンプリングしたデータを正規化して使用します。

n_samples = int(1e6)
sigma = 0.01

dist0 = torch.distributions.MultivariateNormal(torch.tensor([-2, -2], dtype=torch.float).to(device), sigma*torch.eye(2, dtype=torch.float).to(device))
samples0 = dist0.sample(torch.Size([n_samples//2]))
    
dist1 = torch.distributions.MultivariateNormal(torch.tensor([2, 2], dtype=torch.float).to(device), sigma*torch.eye(2, dtype=torch.float).to(device))
samples1 = dist1.sample(torch.Size([n_samples//2]))
samples = torch.vstack((samples0, samples1))

mean = torch.mean(samples, dim=0)
std = torch.std(samples, dim=0)

normalized_samples = (samples - mean[None, :])/std[None, :]

使用する\(\boldsymbol{x}\)を2Dのヒストグラムで可視化すると以下のようになります。

このデータを再現できるようにスコア関数を学習します。学習コードは以下の通りです。

import torch

batch_size = 512
n_steps = 100000

dataset = torch.utils.data.TensorDataset((normalized_samples))
dataloader = torch.utils.data.DataLoader(dataset, batch_size=512, shuffle=True, num_workers=0)
dataloader_iter = iter(dataloader)

score_model = ScoreModel().to(device)

optimizer = torch.optim.Adam(score_model.parameters())
lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.001, total_steps=n_steps)

for i in range(n_steps):
  try:
    x = next(dataloader_iter)[0]
  except StopIteration:
    dataloader_iter = iter(dataloader)
    x = next(dataloader_iter)[0]
  x = x.to(device)

  optimizer.zero_grad()
  loss = dsm_loss(score_model, x, sigmas)
  loss.backward()
  optimizer.step()
  lr_scheduler.step()
  if (i % 1000) == 0:
    print(f"{i} steps loss:{loss}")

学習が終わったら、以下のようにして学習したモデルを利用してサンプリングします。

samples_pred = sbm_sample(n_samples=100000, score_model=score_model, sigmas=sigmas)

サンプリングされたデータの2Dのヒストグラムは以下の通りです。

可視化結果をみると元の分布の平均の近くにデータが集中しているので、うまくいっていると考えられます。

ただ、やってみるとわかるのですがちゃんとした結果を得るために人手で決めないといけないハイパーパラメータの選択が難しい印象です。この結果もかなり試行錯誤してなんとかこの結果を作ることができたというイメージです。

終わりに

今回は「拡散モデル　データ生成技術の数理」の2.2のスコアベースモデルの説明の部分のコードを書いたのでそのまとめの記事になります。最初、MNISTのデータでやろうとして、MNISTのデータを学習できるコードを説明するのは結構大変、ということでシンプルな混合ガウス分布にしました。ただ、それでも結構な分量になった印象です。ちなみに次のDDPMも紹介用のコードはできているので、近日中に記事を書いて公開しようと思います。

この記事が少しでもみなさんの理解の助けになれば幸いです。

参考文献

1. Song, Y., & Ermon, S. (2019). Generative Modeling by Estimating Gradients of the Data Distribution. ArXiv, abs/1907.05600.
2. Song, Y., & Ermon, S. (2020). Improved Techniques for Training Score-Based Generative Models. ArXiv, abs/2006.09011.
3. https://github.com/ermongroup/ncsnv2

The post [勉強ノート] 「拡散モデル　データ生成技術の数理」 2.2 スコアベースモデル first appeared on まったり勉強ノート.

どんな本か？

ビジネスに機械学習のモデルを導入したり、ビジネスで利用している既存のモデルの性能は向上したのに、そのモデルを使おうとするとなぜかビジネスのKPIが改善しないという問題がたびたび発生します。この本ではこのようなことが起きる要因としてモデルを評価したときの評価指標が原因である場合について詳しく説明し、どう考えればこのようなことが起きないか？を解説している本になります。

前半ではこの問題が発生しないようにKPIを意識した評価指標の決定について詳しく書いてあります。

例えば、実際に使われそうなKPIを例にして、KPIをさらに細かい要素に分解し、機械学習の評価指標とKPIとの関係性をわかりやすく説明してくれています。この説明の例としては売り上げをKPIとし、「クーポンを配る相手を機械学習で決める」際、機械学習モデルの精度が変化するとどのようにKPIが変化するかなどが出てきます。

そして後半は機械学習で使える評価指標としてどういうものがあるかとPythonではどう計算するかを示しています。

1つ注意点としては後半部分は結構コードに関する説明が多い印象です。このため、この部分はプログラミングが得意ではない人にとっては難しく感じる部分かもしれません。ただ、コードで書いてある内容は日本語でもちゃんと説明されているので、プログラミングが得意ではない方は一旦コードの部分を無視するというような読み方のほうがいいかもしれません。

どんな人におすすめか？

個人的には以下のような人にはおすすめだと思います。

1. ビジネスに機械学習を使うか検討している人
2. ビジネスとして機械学習モデルを開発している人

ただし、先ほど注意点として述べたように後半はPythonのコードを使った説明が多いので、１の人でプログラミングしない人はコードの部分は無視しながら読むような感じがよいかと思います。

一方、２の人にとっては前半部分を参考に今のビジネスのKPIを分解し、評価指標とKPIの関係を深堀したあと、さらにもっと適切な評価指標がないか、後半を読みながら考えるというような使い方がよいかと思います。

個人的によかった点

個人的に読んで良かったと思った点としては以下の通りです。

1. KPIと評価指標の関係性を明確に意識できるようになった
2. 機械学習を使おうとしている方にこういう考え方が重要ということを伝えやすくなった

1に関しては今までもKPIを意識して評価指標をこうしようということを考えていました。ただ、漠然としたイメージで止まっていたので、この本によってKPIを分解していく流れを体験できたので、今後自分でも似たような流れで考えていけそうだなという感触を得ることができました。

また、お客様とお話していて、機械学習を使うことを検討しているというとき、お客様のほうからKPIがどういうものか？までは伝えてくれないことが多い印象です。なので、どういうビジネスを考えていてKPIとしてどういうものを考えているかまで詳しく聞いていく必要があります。そのとき、どうしてKPIまで意識して機械学習モデルを作る必要があるのか？の一例としてこの本で示されている説明に使えそうだなと思いました。

終わりに

今回は先日読んだ「評価指標入門〜データサイエンスとビジネスをつなぐ架け橋」について紹介する記事を書きました。個人的には期待以上にビジネスで役立ちそうな印象で読んで良かったと思っています。

この記事がこの本を読もうか悩んでいる方の参考になれば幸いです。

また、今後は読んで面白かった本の紹介を毎週月曜日にしようと思いますので、今後ともよろしくお願いします。

The post [書評] 評価指標入門〜データサイエンスとビジネスをつなぐ架け橋 ー ビジネスに機械学習を使いたいと思ったら読んでほしい1冊 first appeared on まったり勉強ノート.