https://huggingface.co/collections/pfnet/plamo-3

どのようなモデルなのかはPFNのブログのほうに書かれています。

簡単にPLaMo 3がどういうモデルか説明すると、PLaMo 2のときと同様、日本語のデータを大量にいれつつ、PLaMo 3では海外勢のLLMと差が大きかった学術的な部分の知識を増やすような取り組みをして、精度が上がったよというモデルになっています。

まだ、小規模モデルの検証段階のモデルが公開されているだけですが、最終的なモデルはもっとよくなる（はず）。

今回はPLaMo 2のとき少し面倒だった推論環境構築がPLaMo 3になったことで簡単になったので、2Bを使ってGoogle Colabで簡単に推論できる例を示そうと思います。

PLaMo 3は高速な推論が可能なvLLMでも簡単に動かせる仕組みが用意されているので、今回はhugging faceの仕組みを使った推論に加えて、vLLMによる推論の例も示します。

コードに関してはgithub上に置いてあります。コード全体を見たい方はこちらをご覧ください。

https://github.com/shu65/plamo-3-inference/blob/main/plamo_3_hf_inference_example.ipynb

https://github.com/shu65/plamo-3-inference/blob/main/plamo_3_vllm_inference_example.ipynb

注意点としては、事前学習を触ろうと思っている人ならご存じだと思いますが、精度が高いモデルでも事前学習モデルは結構めちゃくちゃなことを言います。このため、めちゃくちゃな推論結果でも事前学習モデルならそうだよね、という感じで流してもらえればと思います。ある程度指示を聞くようにするSFTのやり方も後日公開予定です。指示をちゃんと聞かせたいという方はそちらもご覧ください。

PLaMo 3を使うための事前準備

PLaMo 3はダウンロードする前にライセンスに承認が必要になります。今回例で示す、PLaMo 3の2Bモデルである「PLaMo 3 NICT 2B Base」だと初めてアクセスする場合は以下のような画面になっています。

こちらHugging Faceにログインし、ライセンスを確認のうえ、acceptをおしてください。

次にGoogle Colabで使うランタイムを変更します。

Google Colabでnotebookを開いたあと、右上の下矢印をクリックすると以下のようなメニューがでてきます。

このうち、「ランタイムのタイプを変更」をクリックしてください。するとこのようなポップアップが出てきます。

私の画面では有料のクレジットがある状態なので、T4以外にもL4が選択できるようになっていますが、無料の方は選択できないようになっていると思います。Hugging Faceのみの推論を試す場合は、無料で使えるT4で、vLLMを試したい方はL4にしてください。

ランタイムの設定が終わればここからはHugging FaceとvLLMで少し違うので個別に説明していきます。

PLaMo 3の推論 Hugging Face編

Hugging Faceの仕組みで実行するのはすごく簡単で、Google Colabで必要なパッケージはデフォルトで入っているので、基本的にpipインストールなどは必要ありません。ただ、Hugging Faceはすごい勢いで後方互換を壊していくので、最新のHugging Faceのtransformersなどのバージョンでは動かないということが発生する可能性があります。その時はnotebookにあるtransformers==4.57.1 にしてみるなど試してみてください。

pipインストールが必要ないので、まずはHugging Faceにアクセスするためのトークンを設定します。やり方としては以下のコマンドをnotebook上でたたきます。

!hf auth login

これをたたくとtokenを生成するページのURLが表示されるので、サイトにアクセスして、tokenを作り、tokenを入力するということをしてください。

tokenを入力したら、Hugging Faceからモデルをダウンロードができるようになります。やり方は以下の通りです。

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("pfnet/plamo-3-nict-2b-base", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("pfnet/plamo-3-nict-2b-base", trust_remote_code=True)

ここでエラーがでたらモデルの承認ができていない、Google Colab上でHagging Faceのtokenが指定できてないなどが考えられますので、戻って確認してください。

ダウンロードできれば以下のように推論することが可能です。

text = "これからの人工知能技術は"
input_ids = tokenizer(text, return_tensors="pt").input_ids
generated_tokens = model.generate(
    inputs=input_ids,
    max_new_tokens=32,
    do_sample=True,
    top_k=50,
    top_p=0.95,
    temperature=1.0,
)[0]
generated_text = tokenizer.decode(generated_tokens)
print(generated_text)

出力としてはこのようなものが出てくると思います。

<|plamo:bos|>これからの人工知能技術はAIの進化系であり、音声の文字起こしや翻訳といった従来の用途の枠を超えた、全く新しい可能性を切り拓いていくことでしょう。
10年以上、ディープラーニング

これでHugging FaceのAPIを使ったPLaMo 3の推論ができました。

PLaMo 3の推論 vLLM編

次にPLaMo 3のvLLMを使った推論のやり方を示します。vLLMを使う場合はまずは以下のようにPLaMo 3用のvLLMのpluginをインストールします。

!pip install --no-cache git+https://github.com/pfnet-research/vllm-plamo3-plugin.git

ここで--no-cache を付けないと、Google Colabのイメージに変なキャッシュがあるのか、pipインストールでエラーがでるので注意してください。

インストールが終わったらHugging Face編と同じようにHugging Faceのtokenを設定するために以下のようにコマンドをたたきます。

!hf auth login

その後、出力されたtokenの生成サイトに行き、tokenを作ったあとできたtokenを入力するということをします。

次にvLLMでモデルをダウンロードしてロードします。コードとしては以下の通りです。

import vllm
model = vllm.LLM("pfnet/plamo-3-nict-2b-base", trust_remote_code=True)

ダウンロードできればあとは以下のように推論することができます。

response = model.generate(
    prompts=["これからの人工知能技術は"],
    sampling_params=vllm.SamplingParams(
        n=1,
        max_tokens=32,
        top_k=50,
        top_p=0.95,
        temperature=1.0,
    ),
)[0]
generated_text = response.outputs[0].text
print(generated_text)

出力例としては以下の通り。

AIによる画像認識が主流になるといわれている。自動運転などはすでに実用化されている自動車が事故にあわない為の技術として人工知能が使われている。 例えば自動車が障害物を

これでvLLMを使った推論もすることができました。

終わりに

今回はPLaMo 3の推論方法にのみ注目して紹介しました。ただ、最初に述べたように今回のモデルは事前学習モデルなので、そのままで使うことは難しいと思っています。このため、簡単にSFTする方法も後日紹介できればと思っています。

The post PLaMo 3 の事前学習モデルを推論させてみる 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 まったり勉強ノート.

このモデルは事前学習モデルなので、そのままではChataGPTなどの普通の人が良く使うLLMと違ってうまく指示を聞くようになっていませんがSFTなどの事後学習を行えばいろいろなタスクをこなせるようにすることが可能です。

この記事では、このような事後学習のやり方の一つとしてGoogle Colabで比較的安く使えるL4というGPUを使って、LoRAという方法で学習するやり方を紹介します。

今回紹介するコードは以下のところにありますので、参考にしてください。

https://github.com/shu65/plamo-2-8b-lora-sft-example/blob/main/PLaMo_2_8B_LoRA_SFT.ipynb

LoRAとは

LoRAとは「Low-Rank Adaptation」の略で、大規模言語モデルのような大きなモデルの学習を、メモリが小さいGPU１枚など小規模な計算機環境で学習するために提案された手法です。

具体的にはモデルの一部のLayerに対して低ランクの行列を導入し、低ランクの行列のみ学習することでモデル全体を学習するのと比べて非常に少ないメモリで学習できるようにしています。

このLoRAを使った学習はライブラリがそろっていることもあり、簡単なものはかなり短いコードで書くことができます。

PLaMo 2 8B のLoRA

ここからPLaMo 2 8BでLoRAを使って学習する方法を説明していきます。

PLaMo 2 8B 利用規約への同意

先ほども説明した通りPLaMo 2 8Bは特殊なライセンスということもあり、事前に同意しておく必要があります。

これにはまず、Hugging FaceのサイトのPLaMo 2 8Bのページに行きます。URLは以下の通りです。

https://huggingface.co/pfnet/plamo-2-8b

このページに行くとまだライセンスに同意していない場合は以下のようにライセンスの一部が表示されていると思います。

この場合はライセンスを確認の上、同意してください。同意すると以下のような表示になります。

これでPLaMo 2 8Bを使う準備ができました。

Google ColabのランタイムでL4を使うようにする

次に、Google ColabでL4を使う準備をします。Google ColabでL4が使えるように課金が必要になりますので、まずは課金をします。

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

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

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

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

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

必要パッケージのインストール

次に今回の学習で必要なパッケージをインストールします。コマンドとしては以下の通りです。

!pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu124
!pip install trl numba>=0.60.0 mamba-ssm>=2.2.2 causal-conv1d>=1.4.0 transformers>=4.44.2

最初にPytorchのバージョンを少し下げていますが、これはPLaMo 2の中で使われているライブラリの一部が最新のPyTorchに対応させるのが結構大変なため、簡単に実行できるようにするために少し古いPyTorchを入れています。

上記のコマンドを実行したあとは、以下のバージョンになっていました。

causal-conv1d                      1.5.0.post8
mamba-ssm                          2.2.4
numba                              0.60.0
numba-cuda                         0.2.0
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.50.0

LoRAのコード

パッケージをインストールしたら次は以下のようにHugging Faceにログインします。

from huggingface_hub import login

login()

これを実行するとHugging Faceのtoken を聞かれますのでHugging Faceのtokeを入力してください。

次に各パッケージをimportしておきます。

from transformers import AutoModelForCausalLM
from transformers import AutoTokenizer
import datasets
import string
from trl import DataCollatorForCompletionOnlyLM
from trl import SFTConfig, SFTTrainer
from peft import LoraConfig
import torch

そして、PLaMo 2 8Bのモデルとtokenizerを以下のようにロードします。

model_name = "pfnet/plamo-2-8b"
model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True, torch_dtype=torch.bfloat16).to("cuda")
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

「PLaMo 2 8B 利用規約への同意」の部分の手順ができていなかったり、Hugging Faceのログインがうまくできていないと、この部分でエラーがでると思われます。その場合は利用規約の同意ができているかや、正しくHugging Faceのログインができているかなどを確認してください。

次に今回使うinstructionデータをダウウンロードして、前処理します。今回はkunishou/databricks-dolly-15k-ja のinputがないデータだけを取り出して利用します。

dataset = datasets.load_dataset("kunishou/databricks-dolly-15k-ja")
train_dataset = dataset["train"].filter(lambda data: "instruction" in data and "output" in data and data["input"] == "").select(range(2000))

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

次にLoRAとSFTの引数を指定します。PLaMo 2特有の部分としてLoraConfig でLoRAを使って学習するレイヤーを指定するtarget_modules という引数があります。ここでLLaMa系のようなTransformerの場合、AttensionのQeury, Keyを作るLinearレイヤーをLoRAで学習することが多い印象なので、PLaMo 2でも同じようにAttensionのQueryとKeyを作るLinearレイヤーをLoRAで学習するようにします。PLaMo 2の場合は、Qeury, Key、Valueを作るLinearレイヤーをすべてまとめたqkv_proj というLinearレイヤーがありますので、このqkv_proj をtarget_modules に指定しています。

peft_config = LoraConfig(
    task_type="CAUSAL_LM",
    target_modules=[
        "qkv_proj",
    ],
)

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=1.0,
    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,
)

あとはデータのサンプルに対してフォーマットに合わせて１つのテキストを生成するformatting_func を定義します。今回は以下のようなものを使います。

INSTRUCTION_TEMPLATE = string.Template(
    """### Question:
{input} ### Answer:
{response}<|plamo:eos|>
"""
)

def formatting_func(example):
  text = INSTRUCTION_TEMPLATE.substitute(input=example["instruction"], response=example["output"])
  return text

最後に、ここまで用意したものをSFTTrainer に渡して学習を開始します。

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

trainer.train()
trainer.save_model()
     

今回の設定では500イテレーション回ることになるはずです。私が試した限りは15分程度で処理が完了しました。

できたモデルの出力が正しいかは以下のコードで確認できます。

import torch

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

# 推論の実行
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
generated_tokens = trainer.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|>

終わりに

いかがだったでしょうか？今回はPLaMo 2 8Bに対してLoRAによって学習する方法を紹介しました。LoRAを使えばメモリが少ないL4のようなGPUでも8Bモデル程度で学習することができます。今回のコードを使えば事後学習が簡単にできると思われますので、みなさんもいろいろ試していただければと思っています。無料枠で使えるGPUのT4でも量子化などを頑張れば8Bモデルも学習できる気がしますが、うまくできそうであればそちらも記事にしようと思います。

この他にもPLaMoを含めたLLMの技術も紹介できればと思っています。

The post PFNの最新LLM PLaMo 2 8BをGoogle ColabでLoRAで学習してみる 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 まったり勉強ノート.

私自身、開発にかかわっているメンバーの一人です。このモデルは1Bという小さいサイズで手軽に動かすことができます。このため、今回はGoogle Colabの無料枠の範囲で簡単に使う方法を紹介します。

ちなみに今回紹介するGoogle Colabのコードはこちらにあげてあります。
https://github.com/shu65/plamo-2-1b-examples/blob/main/plamo_2_1b_inference_example_google_colab_t4.ipynb

コードだけ見たいという方はこちらをご覧ください。動作に関しては2025/02/11現在のGoogle Colabで動くことは確認してありますが、時間がたつと動かなくなる可能性があるので注意してください。

そもそもPLaMo 2 1Bとはどういうモデルか？

まず、このモデルがどういうモデルか知っておくと、いろいろトラブルに対処する心構えができると思ったので、簡単にこのモデルについて説明します。

このLLMは、LLaMaなどに代表されるような、よくあるオープンな他のLLMとは違い、独自路線を突っ走っているモデルです。一番際立って違う点として、状態空間モデル（Sate Space Model, SSM）とSliding Window Attensionを組み合わせたSambaで提案されたアーキテクチャベースのモデルになっています。知っている人からすると「マジで？」と思うかもしれませんが、マジです。詳しくはこちらをご覧ください。（アーキテクチャパートはこの辺いろいろ頑張ってくれてたPFEメンバーの力作の説明になっています）

これ以外にも際立って違う部分としてTokenizerがあります。こちらも特に既存のモデルと違う点として、トークン効率を上げるために英語でもスペース区切りをやめている点などがあります。私も最初「スペース区切りやめます！」って言われた時は「マジかよ」って思いましたが、マジで採用しました。これ以外の工夫も開発した方が熱い思いを記事にしていますので興味がある人はご覧ください。

さて、ここでいろいろ既存のモデルと違うということが伝わったかと思いますが、このようにいろいろ独自な部分があり、面白いモデルになっていると思いますが、一方で他のLLMの感覚で使っているとハマる部分があるので、ここからはPLaMo 2 1Bの推論するやり方に焦点を絞って説明していきます。

PLaMo 2 1BをGoogle Colabの無料枠で使う

Google Colabでの使い方に関してはすでにあげてくれている方もいます。記事にしていただきありがとうございます。

https://qiita.com/autotaker1984/items/32109944a6a058161eee

こちらを見ると、有料でしか使えないL4というGPUでのみ動作確認が取れたと報告をいただきました。私も同じように試したところ、L4での動作は確認できたのですが、いろいろな人に使ってもらうためにはやはり無料枠の範囲で試せるほうが良いだろうと思っています。

このため、ここからは無料で使えるT4というGPUでPLaMo 2 1Bを動かす手順を紹介します。

まず、Google ColabでT4が使えるようにメニューバーから「ランタイム」→「ランタイムのタイプを変更」をクリックして、T4 GPUを選択しておいてください。

そして、まずは最初にPyTorchのバージョンを以下のように2.4系に落とします。

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

T4でPLaMo 2 1Bを動かすにはこのPyTorchのバージョンを落とすということが重要でした。

この後は以下のように他に必要なパッケージをインストールするだけになります。

!pip install transformers>=4.44.2 numba>=0.60.0 causal-conv1d==1.4.0 mamba-ssm==2.2.2

2025/02/11現在Googel Colab上で上記のコマンドを叩くと以下のようなバージョンのパッケージが入りました。

causal-conv1d                      1.4.0
mamba-ssm                          2.2.2
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

インストールが終わればあとは簡単で、PLaMo 2 1BのREADMEにある通りに実行するだけになります。実行コードの例としては以下の通りです。

from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("pfnet/plamo-2-1b", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("pfnet/plamo-2-1b", trust_remote_code=True)

text = "これからの人工知能技術は"
input_ids = tokenizer(text, return_tensors="pt").input_ids
generated_tokens = model.generate(
    inputs=input_ids,
    max_new_tokens=32,
    do_sample=True,
    top_k=50,
    top_p=0.95,
    temperature=1.0,
)[0]
generated_text = tokenizer.decode(generated_tokens)
print(generated_text)

私が実行した際は以下のように出力されました。

<|plamo:bos|>これからの人工知能技術は人間の脳機能をコンピュータに取り入れ、私たちの生活に様々な影響を与えると言われています。人工知能技術の進化により、社会に混乱が生じる可能性があり、AIの規制に関して議論

入力で与えた文章の続きとして問題ない文章がちゃんと出力できていると思われます。

このようにT4でも問題なくPLaMo 2 1Bを動かすことができました。

終わりに

この記事ではGoogle ColabのPLaMo 2 1BをGoogle Colabで動かす手順を紹介しました。おそらくGoogle Colabじゃなくてもcausal-conv1dとmamba-ssm がサポートされている環境であれば動作すると思われます。逆に言えばこの二つがサポートしてない環境では使うのにいろいろ魔改造が必要な可能性があります。

この辺りはハマる人が多いと思われるので、知見がたまったらまた記事にしようと思います。

この記事を参考にみなさんもPLaMo 2 1Bで遊んでもらえればと思います。

PLaMo 2 1BをSupervised Fine-Tuning（SFT）するコードに関しても準備中で、動作確認は済んだので今週中にあげようと思いますのでお楽しみに！

The post 小型LLM PLaMo 2 1BをGoogle Colabの無料枠の範囲で使ってみる first appeared on まったり勉強ノート.

このPLaMo PrimeはChatのWeb UIもありますが、APIを利用してプログラムから簡単に利用することができるようになっています。Pythonの場合はOpenAIのChatGPTと同じ`openai`というPythonパッケージをほぼ同じように使えば利用することができるので、ChatGPTをAPIで叩いたことがある人はすぐに使えると思っています。

そんなわけで、今回の記事では試しにAPI keyを取得して、PLaMoを使ってみたので、使い方を記事にまとめました。

ちなみに私自身はPFNでPLaMoの開発をしているメンバーなので、感想などについてはある程度バイアスが入った意見を書いているんだろうなーと思いつつ読んでいただければ幸いです。

アカウント作成

まず以下のサイトにアクセスしてアカウントを作ります

https://plamo.preferredai.jp/api

アクセスしたら下で赤で示した「今すぐ登録」のボタンをクリックします。

すると以下のように「同意事項確認」というページに移動します。ここで日本国内の居住者かどうかなどの確認事項にチェックや利用規約等に問題がないかなどをチェックします。利用規約とプライバシーポリシーはリンクを開かないとチェックできないしようになっています。

チェックが終わると次はクレジットカード登録になります。

クレジットカードの登録が終わればアカウントの作成完了です。アカウントができて、ログインすると以下のようなプロジェクト管理ページに飛びます。

利用上限設定

この手のLLMのAPIは気を抜くとすごいリクエストを送りまくって、とんでもない額になるということが時々あります。これを防ぐためにPLaMo APIでも利用上限設定が設定できるようになっています。少なくとも個人で使う場合は意図せず高額請求が来ないように自分に合った額に設定しておくことがおすすめです。

設定する際は以下の①のところの「利用上限設定」をクリックして、②の「…」をクリックして「設定」をクリックします。自分の経験上、使うときは本当に一気に使われるのでアラームではなくハードリミットを1000円に設定しておくということをしておいています。この部分は使いながら調節して無理のない額に調整していく感じになるかと思います。

API key取得

次にAPI Keyを取得します。API Keyを取得する際は以下のように①の「プロジェクト管理」をクリックし、デフォルトで設定されているプロジェクトの「Default」をクリックしてDefaultのAPI Keyを取得します。

プロジェクトを開くと以下のような画面になります。今すでにAPI Keyが一つ入っていますが、最初は何もないと思います。新しくAPI Keyを追加する場合は右の赤枠の「API キーを追加する」をクリックし、APIキー名を適当につけて「作成」を押すと新しいAPI keyが作成されます。

API Keyが作成がされると以下のようにAPI Keyのシークレットが表示されるので、メモしておきます。

これでAPI Keyの取得までできたので、次は実際にPLaMoの出力を取得する流れを説明します。

PLaMo Primeの出力をPythonで取得する

PLaMo Primeを使う方法はいくつかありますが、今回は openai というパッケージを使ってPLaMo Primeを使います。

他の利用方法も含め、使い方はこちらにまとまっています。

https://docs.plamo.preferredai.jp/ja/getting-started

また、今回紹介するコードは手軽に試せるようにGoogle Colabで動作させることを前提に説明していきます。コード全体はこちらにありますので参考にしてください。

https://github.com/shu65/plamo_api_examples/blob/main/plamo_api_example.ipynb

環境セットアップ

Google ColabでPLaMo Primeを使うにあたり、環境をセットアップします。必要なパッケージとしてはPLaMo Primeを使うのに必要なopenai とAPI Keyの読み込みにpython-dotenv を利用します。

インストールするには以下のようにします。

!pip install openai python-dotenv

次にdotenv を利用してAPI Keyを環境変数にセットします。dotenv で読み込むファイルは予めGoogle Driveに置いておきます。今回はcolab_env/plamo_api_env に以下の内容のファイルを置いてある前提で説明します。

OPENAI_API_KEY="取得したAPI Key"

上のファイルの「取得したAPI Key」の部分は先ほど取得したAPI Keyをコピペしてください。

Googel Driveにこのファイルを設置できたら、以下のコードをGoogle Colab上で実行します。

from google.colab import drive
from dotenv import load_dotenv

drive.mount('/content/drive')
load_dotenv(dotenv_path="/content/drive/MyDrive/colab_env/plamo_api_env")

drive.mount() を実行するとGoogle Driveに接続していいかの確認メッセージがでますので、許可してください。

許可されるとplamo_api_env が読み込まれ、OPENAI_API_KEYという環境変数にAPI Keyがセットされます。

これであとは以下のようにリクエストを送るとPLaMo Primeから回答が返ってきます。

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://platform.preferredai.jp/api/completion/v1",
    # other params...,
)

completion = client.chat.completions.create(
    model="plamo-1.0-prime",
    messages=[
        {"role": "system", "content": "あなたは旅行アドバイザーです"},
        {"role": "user", "content": "金沢で朝から夕方まで1日のおすすめの観光ルートを教えて下さい"},
    ],
)
     

OpenAIのモデルを使うときとPLaMo Primeを使うときで明確に違う点としてbase_url の指定があります。これが適切なものを指定されていないとPLaMo Primeにリクエストが飛ばないので注意してください。

今回はリファレンスのexampleにある「金沢で朝から夕方まで1日のおすすめの観光ルートを教えて下さい」というリクエストに対する回答をPLaMo Primeに返してもらうコードになっています。

回答結果は以下のように出力することができます。

print(completion.choices[0].message.content)

私が実行したときは以下のように返ってきました。

金沢で朝から夕方までのおすすめの観光ルートを以下にご紹介いたします。


【午前】

金沢駅からスタートし、金沢の台所と呼ばれる近江町市場で朝食をとります。海鮮丼やお寿司などの金沢グルメをお楽しみください。

近江町市場（お食事）

↓（徒歩5分）

金沢の城下町を再現した長町武家屋敷跡を散策します。土塀の続く街並みを眺めながら、のんびりとお散歩をお楽しみください。

長町武家屋敷跡（散策）

↓（徒歩10分）

金沢市民の台所として親しまれている、金沢の三大市場のひとつ、「金沢市民の台所」として親しまれている、金沢の三大市場のひとつ、「金沢エムザ」でお土産を購入します。

金沢エムザ（お土産購入）


【午後】

兼六園周辺へ移動し、金沢で最も古い神社である石浦神社を参拝します。

石浦神社（参拝）

↓（徒歩5分）

日本三名園のひとつである兼六園を見学します。

兼六園（見学）

↓（徒歩5分）

金沢城公園を散策します。

金沢城公園（散策）

↓（徒歩10分）

尾山神社を参拝します。

尾山神社（参拝）


以上、朝から夕方までのおすすめの観光ルートをご紹介いたしました。

なお、各スポットの営業時間や、その他のご希望などございましたら、お知らせください。お客様のご希望に沿ったプランをご提案いたします。

一応、提案されている場所が本当に金沢にあるかは調べて、確かにあることまでは確認しました。プランとしても一度金沢に行ったとき確か提案された場所を友達と回った記憶があるので、素人目からするとそこまで変なプランを提案されているわけではない印象を持っています。

終わりに

今回はPLaMo Primeがリリースされたということで使い方のまとめの記事を書きました。仕事ではPLaMoを結構叩いているので、他にもいつくか便利な使い方の記事は書いていこうかと思っています。

また、PLaMoに関して技術的な紹介の記事がいくつかすでに公開されているので、興味がある方はそちらもご覧ください。メインの3本は参考に下に示しておきます。

The post PFNが開発した国産LLM PLaMo Primeを使ってみる first appeared on まったり勉強ノート.

LangChainについてご存じないという方のために一言で説明するとLangChainはChatGPTの内部で使われているLLMを扱いやすい形でwarpしたライブラリになります。紹介記事を以前書きましたので、詳しく知りたい方はこちらをご覧ください。

LangChainのexampleを見ると多くの場合OpenAIのAPIを使うことが多いように感じます。ただ、OpenAIのモデルは精度が良いのですが、一方で長文の生成をしようとするとかなりの額のお金が必要になります。このため、遊びで使うには勇気がいるケースがあります。

このため、懐に優しい形でLangChainを扱えないか？ということで、有名どころのモデルが大体おいてあるHugging Faceを利用してLangChainで使う方法を調べました。

調べるにあたって作ったコードはここに置いてあります。コード全体が見たいかたはこちらをご覧ください。

https://github.com/shu65/langchain_examples/blob/main/langchain_hugging_face_example.ipynb

Hugging Faceとは？

ここ最近、Hugging Faceは良く目にしますが、念のため説明しておきます。Hugging Faceは様々な機械学習のライブラリを開発している企業で、モデルやデータセットなどを共有するプラットフォームも提供しています。

たとえば、こちらの紹介記事を書いたTransformersはHugging Faceが作っているものになります。

ここ最近の公開されている有名どころのモデルは大体Hugging Faceからダウンロードできるようになっているので、既存のモデルを試したいというときは非常に便利です。

今回はHugging Faceが運営しているプラットフォームにおいてあるモデルをLangChainで使う方法について説明します。

Hugging FaceにおいてあるモデルをLangChainで使う

Hugging FaceのモデルをLangChainで使う方法としていくつか用意されています。今回はこの中の以下の二つについて紹介します。

1. Hugging Face APIを利用する方法
2. Hugging Faceからモデルをダウンロードしてきて手元の計算機でLLMを動かす方法

それぞれ順番に説明していきます。

Hugging Face APIを利用する方法

Hugging Face上においてあるモデルは制約はありますが、API経由で利用することができます。

APIのトークンの取得に関しては公式のチュートリアルを参考にしてください。

https://huggingface.co/docs/api-inference/quicktour

LangChainで利用する場合はHUGGINGFACEHUB_API_TOKENという環境変数に上で取得したトークンを入れておく必要があります。

今回のコードではnotebookを公開する都合上、トークンの中身がコードにでてこないようにdotenv を利用して環境変数の設定をしています。手元で動かす際は以下のようにすれば十分です

export HUGGINGFACEHUB_API_TOKEN=XXXX

あとは以下のようにHugging Face APIを利用したLLMのインスタンスを用意します。

from langchain import HuggingFaceHub

repo_id = "google/flan-t5-xl" 

llm = HuggingFaceHub(repo_id=repo_id, model_kwargs={"temperature":0, "max_length":64})

ここではモデルとしてGoogleのFlan-T5のXLというサイズのモデルを利用しています。model_kwargs はモデルごとに指定できるものが違うので注意してください。ここではtemperature と max_length を指定しています。

LLMが用意できればあとはOpenAIのモデルのときと同じ感覚で利用することができます。ここでは簡単にLangChainを使って以下のように質問して答えてもらいます

Who won the FIFA World Cup in the year 1994? 

コードとしては以下の通りです。

template = """Question: {question}

Answer: Let's think step by step."""
prompt = PromptTemplate(template=template, input_variables=["question"])
llm_chain = LLMChain(prompt=prompt, llm=llm)

question = "Who won the FIFA World Cup in the year 1994? "

llm_chain.run(question)

このコードは以下のように出力されました。

The FIFA World Cup is a football tournament that is played every 4 years. The year 1994 was the 44th FIFA World Cup. The final answer: Brazil.

調べてみると1994年は確かにブラジルが優勝しているので正しい回答が得られているようです。

Hugging Faceからモデルをダウンロードしてきて手元の計算機でLLMを動かす方法

次にHugging Faceのモデルを手元にダウンロードしてきてLangChainで利用する方法を説明していきます。

まず、LLMの準備ですが以下のようにします。

from langchain.llms import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

model_id = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
pipe = pipeline(
    "text-generation", model=model, tokenizer=tokenizer, max_new_tokens=64
)
llm = HuggingFacePipeline(pipeline=pipe)

Google Colabで動かす都合上、小さめのモデルということでここではGPT-2を利用しています。

基本的な使い方としては良くあるHugging Faceの使い方である AutoTokenizer と AutoModelForCausalLM を利用してtokenizerとmodelを用意します。その後LangChainが用意している HuggingFacePipeline を使ってLangChainで使えるLLMのインスタンスを作ります。

あとは先ほどと同様にすればLangChainでHugging Faceのモデルを利用することができます。コードはAPIのときと同じため省略します。またGPT-2ということもあり、結果はめちゃくちゃなので、出力結果も省略します。

終わりに

今回はLangChainでHugging Faceのモデルを利用する方法について調べたのでそのまとめを書きました。

LangChainのほうで思った以上に簡単に使えるように整備されている印象で、どの関数を使えばわかっていればすぐに使うことはできました。今回は紹介しませんでしたが他にもHugging Faceのモデルを動かす方法は用意されているようなので興味のある方は調べてみてください。

この記事が他の方の参考になれば幸いです。

The post Hugging FaceのモデルをLangChainで使う方法を調べた first appeared on まったり勉強ノート.

https://blog.langchain.dev/improving-document-retrieval-with-contextual-compression/

ちょうどこういう機能があったらいいなぁと思っていたところだったので、この機能について調べてみました。今回はそのまとめ記事になります。

今回の記事を書くにあたり、動作チェックをした際のnotebookはここにあげておきました。コードを見たい方はこちらをご覧ください。

https://github.com/shu65/langchain_examples/blob/main/LangChain_Contextual_Compression.ipynb

また、LangChainがどういうものかご存じない方は以前LangChainの紹介記事を書きましたので、こちらをご覧ください。

Contextual Compressionとは？

LLMを使ったQAシステムでは関連するドキュメントを見つけてきて、質問と関連ドキュメントをLLMに入れて質問に答えるという形のものがあります。この際、以下のような問題点があります。

1. 質問と関連してないドキュメントが含まれるケースがある
2. 関連ドキュメントの文字数が多いとLLMに入力できる文字数を圧迫する

この問題を解決する方法の手段の一つとしてこの「Contextual Compression」があります。

このContextual Compressionでは関連ドキュメントを見つけたあと、質問により関連している情報だけを抽出します。この抽出された情報と質問をLLMに入れてより的確な質問に答えられるようにするというものです。

LangChainではContextual Compressionの機能としていくつか用意されています。その中でもぱっと見て動作が分かりずらいLLMを使ったものに関して今回はどういうpromptになっているのかを調べたので順番に紹介していきます。

LLMChainExtractor

まず一つ目が「LLMChainExtractor」です。これは関連するドキュメントを見つけたあとLLMによって質問に関連する部分だけを抽出するものになっています。

LLMChainExtractorを使う前の以下のコードは以下の通りです。

from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import TextLoader
from langchain.vectorstores import FAISS

documents = TextLoader('./state_of_the_union.txt').load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
retriever = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever()

docs = retriever.get_relevant_documents("What did the president say about Ketanji Brown Jackson")

このコードの出力は以下のようになります。

Document 1:

Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. 

Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. 

One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. 

And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.
----------------------------------------------------------------------------------------------------
Document 2:

A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. 

And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. 

We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  

We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  

We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. 

We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.
----------------------------------------------------------------------------------------------------
Document 3:

And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. 

As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. 

While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. 

And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. 

So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together.  

First, beat the opioid epidemic.
----------------------------------------------------------------------------------------------------
Document 4:

Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. 

And as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up.  

That ends on my watch. 

Medicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. 

We’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. 

Let’s pass the Paycheck Fairness Act and paid leave.  

Raise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. 

Let’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges.

それでは次にLLMChainExtractorを使った場合の結果を見てみます。コードとしては以下の通りです。

from langchain.llms import OpenAI
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

llm = OpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever)

compressed_docs = compression_retriever.get_relevant_documents("What did the president say about Ketanji Jackson Brown")

compressed_docsの中身を見てみると以下の通りです。

Document 1:

"One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. 

And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence."
----------------------------------------------------------------------------------------------------
Document 2:

"A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans."

先ほど変わってドキュメント数が減っているのと、Document 1のほうを見ると出力されている内容もたしかに関連したところだけ残っている感じがしています。この時、どのようなpromtpでLLMを実行されていたかというと、以下のようなテンプレートを使ってpromptを作ってLLMに入力していました。

"""Given the following question and context, extract any part of the context *AS IS* that is relevant to answer the question. If none of the context is relevant return {no_output_str}. 

Remember, *DO NOT* edit the extracted parts of the context.

> Question: {{question}}
> Context:
>>>
{{context}}
>>>
Extracted relevant parts:"""

{{question}}と{{context}}がそれぞれ入力した質問と関連ドキュメントとして見つけたドキュメントの内容を入れる部分です。

templateを見ると、関連ドキュメントの中から質問に回答と関連すると思われるところを抜き出してくるというものになっています。また、関連していなければ{no_output_str}、実際にはNO_OUTPUTという文字列を返すようになっています。

これにより、見つけてきたドキュメントが関係ないものであればはじくということができるようになっています。

LLMChainFilter

次に「LLMChainFilter」です。これは先ほどの「LLMChainExtractor」と同じようにLLMを使うものになっていますが、見つけたドキュメントが質問に関連するものかどうかだけを判断し、関連しないものであればはじくということだけをするものになっています。つまり、「LLMChainExtractor」であった質問に関連する部分を抽出するという処理がなくなったバージョンという感じかと思います。

LLMChainFilterを利用するコードは以下のようになっています。

from langchain.retrievers.document_compressors import LLMChainFilter

_filter = LLMChainFilter.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(base_compressor=_filter, base_retriever=retriever)

compressed_docs = compression_retriever.get_relevant_documents("What did the president say about Ketanji Jackson Brown")

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

Document 1:

Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. 

Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. 

One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. 

And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.

オリジナルのコードでは4つ関連ドキュメントがでていましたが、今回は一つだけになっています。

これを実現するためにLLMChainFilterはLLMには以下のようなテンプレートのpromptをLLMに入力しています。

"""Given the following question and context, return YES if the context is relevant to the question and NO if it isn't.

> Question: {question}
> Context:
>>>
{context}
>>>
> Relevant (YES / NO):"""

{question}と{context}がそれぞれ入力した質問と関連ドキュメントとして見つけたドキュメントの内容を入れる部分です。

テンプレートを見ればわかる通り、質問と関連するドキュメントかどうかを聞き、YESかNOを返すようにLLMにお願いするpromptになっていることがわかります。

それ以外のContextual Compressionの機能

今回はLLMを利用しているContextual Compressionのみに注目して紹介しましたが、これ以外にも以下のようなものがあります。

1. EmbeddingsFilter: Embeddingによって質問と関連するドキュメントかどうかを判断してフィルタリングするもの。LLMを利用しないので、高速に動作する
2. DocumentCompressorPipeline: 複数の前処理との組み合わせることができるContextual Compressionの仕組み

実際にこれらを使った例は公式のこちらのnotebookにありますので気になる方はご覧ください。

https://python.langchain.com/en/latest/modules/indexes/retrievers/examples/contextual-compression.html

終わりに

今回はContextual Compressionについて調べたのでまとめを書きました。LangChainを使った例としてQAシステムはよく見るのですが、自分でやってみると関連ドキュメントを見つけてくるドキュメントが微妙ということがよくあるので、このような仕組みがあったらいいな、と思っていました。このため、今回は個人的には非常に勉強になりました。

今後もまたLLMをどう扱えばいいのか？の勉強でいろいろ調べたらまとめようと思います。

この記事が皆様のお役に立てれば幸いです。

The post LangChainのContextual Compressionのいくつかの機能がどのように実現されているかを確認してみた first appeared on まったり勉強ノート.

今回のコードは以下のところにあるので、全体としてどうなっているのか見たい方はこちらをご覧ください。

https://github.com/shu65/langchain_examples/blob/main/LangChain_Pandas_Dataframe_Agent.ipynb

LangChainのPandas Dataframe Agentとは

LLMを使いやすくwrapしてくれるLangChainにはいくつかAgentというLLMとToolと呼ばれるものを組み合わせて実行する仕組みが用意されています。この中でもPandas Dataframe Agentは名前の通りpandasのDataframeに対する操作をLLMにやらせるための仕組みです。

どういうことができるかはこちらのnotebookをご覧ください。

https://python.langchain.com/en/latest/modules/agents/toolkits/examples/pandas.html

この記事では、上のnotebookの実行例の一つを取り上げてどのようにLLMなどと連携しているのかを説明していきたいと思います。

実行例

今回は機械学習でお馴染みのタイタニックのデータを使います。データはここから持ってきました。

https://web.stanford.edu/class/archive/cs/cs109/cs109.1166/problem12.html

どういうデータか詳しく知りたい方は上のページの説明をご覧ください。

また、今回は以下のことをLLMに聞いたときのLLMなどを含めた一連の流れがどうなっているのかを説明していきます。

from langchain.llms import OpenAI
from langchain.agents import create_pandas_dataframe_agent
import pandas as pd

df = pd.read_csv('titanic.csv')
agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True)
agent.run("whats the square root of the average age?")

最後の行がLLMでpandasのDataFrameを操作する部分になっています。やらせたいことは読んで分かる通り、年齢の平均を取って、それのルートを取るという計算をした結果を得るということです。

それではこの後これがどのように実行されるかを見ていきます。

実行の流れ

Pandas Dataframe Agentの大まかな実行の流れは以下の通りです。

1. zero-shot-react-description と同じAgentクラスに対し、promptを少し変えたAgentを作成
2. できたAgentがどのようなコードを実行するかを考える
3. 考えに従ってコードを生成
4. 生成されたコードを実行
5. 実行した結果に基づいて再度考える。以降はこの繰り返して最終結果を得る

このような「考える」と「行動」（LangChain的にはTool）を交互に繰り返すやり方はReActと呼ばれる方法で、以下の論文で提案されています。

Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. ArXiv, abs/2210.03629.

zero-shot-react-description に関しては以前記事を書きましたので、動作について詳しく知りたい方はこちらも併せてご覧ください。

ここからはさきほどの例の場合、LLMと連携してどのような手順で処理をしていくかを見ていきます。

一番最初のpromptに関して

一番最初のpromptは以下のようになっています。

You are working with a pandas dataframe in Python. The name of the dataframe is `df`.
You should use the tools below to answer the question posed of you:

python_repl_ast: A Python shell. Use this to execute python commands. Input should be a valid python command. When using this tool, sometimes output is abbreviated - make sure it does not look abbreviated before using it in your answer.

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [python_repl_ast]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question


This is the result of `print(df.head())`:
   Survived  Pclass                                               Name  \
0         0       3                             Mr. Owen Harris Braund   
1         1       1  Mrs. John Bradley (Florence Briggs Thayer) Cum...   
2         1       3                              Miss. Laina Heikkinen   
3         1       1        Mrs. Jacques Heath (Lily May Peel) Futrelle   
4         0       3                            Mr. William Henry Allen   

      Sex   Age  Siblings/Spouses Aboard  Parents/Children Aboard     Fare  
0    male  22.0                        1                        0   7.2500  
1  female  38.0                        1                        0  71.2833  
2  female  26.0                        0                        0   7.9250  
3  female  35.0                        1                        0  53.1000  
4    male  35.0                        0                        0   8.0500  

Begin!
Question: whats the square root of the average age?

一番最初のpromptが一番大事な部分なので、丁寧に説明していきます。

You are working with a pandas dataframe in Python. The name of the dataframe is `df`.

この部分はzero-shot-react-description とは違う部分の一つです。最初にpandasのDataFrameを使うことと、その変数名がdfであることをLLMに伝えます。

次にこの部分についてです。

You should use the tools below to answer the question posed of you:

python_repl_ast: A Python shell. Use this to execute python commands. Input should be a valid python command. When using this tool, sometimes output is abbreviated - make sure it does not look abbreviated before using it in your answer.

この部分はToolの説明です。Pandas Dataframe Agentの場合はpython_repl_astを使うため、このToolがどういうものかをLLMに伝えています。

次にこの部分です。

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [python_repl_ast]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

この部分はzero-shot-react-descriptionと同じでLLMにReAct的な動きをしてもらうための説明のところです。

そして次はこの部分です。

This is the result of `print(df.head())`:
   Survived  Pclass                                               Name  \
0         0       3                             Mr. Owen Harris Braund   
1         1       1  Mrs. John Bradley (Florence Briggs Thayer) Cum...   
2         1       3                              Miss. Laina Heikkinen   
3         1       1        Mrs. Jacques Heath (Lily May Peel) Futrelle   
4         0       3                            Mr. William Henry Allen   

      Sex   Age  Siblings/Spouses Aboard  Parents/Children Aboard     Fare  
0    male  22.0                        1                        0   7.2500  
1  female  38.0                        1                        0  71.2833  
2  female  26.0                        0                        0   7.9250  
3  female  35.0                        1                        0  53.1000  
4    male  35.0                        0                        0   8.0500  

ここではDataFrameの一部を出力させてどういうデータであるかをLLMに伝えている部分です。

最後にこの部分です。

Begin!
Question: whats the square root of the average age?
Thought: 

動作の開始の合図と、「Question:」から先が実際にAgentを使ってやりたいことをLLMに伝えます。そして、「Thought:」までLLMに入力させて、LLMに何をするべきか考えさせます。

ここから先はLLMの出力と出力されたPythonコードを実行して得られた結果を受け取ってさらにLLMに考えさせるという動作を繰り返していきます。これを順番に説明していきます。

LLMが考えて、Pythonのコードを生成する部分(1回目)

先ほどのpromptをLLMに入力すると以下のような出力が返ってきます。これを順番に見ていきます。

I need to calculate the average age first
Action: python_repl_ast
Action Input: df['Age'].mean()

1行目が先ほどの「Thought:」の続きで、LLMがどのようなことをするべきか考えた部分です。最初は年齢の平均を計算しようと考えて、それを行うためのコードを「Action Input:」から先に出力しています。

このコードを今度は実際に実行します。

Pythonコードの実行

先ほどのPythonのコードをどのように実行するかを説明していきます。実際に実行している部分は、この記事を書いている現在のバージョンではLangChainのここになります。

https://github.com/hwchase17/langchain/blob/72b7d76d79b0e187426787616d96257b64292119/langchain/tools/python/tool.py#L67-L92

これは以下のような手順でPythonコードを実行しています。

1. LLMの生成したPythonコードを受け取りきれいに整える
2. Pythonコードの抽象構文木を生成
3. Pythonコードの最後から一つ手前までのコードを実行
4. Pythonコードの最後の部分を実行して出力結果、もしくはエラーを得る

3と4でなぜ分けて実行しているかというとToolの説明にある通り、途中の出力は省略して最後だけ得るためであると考えています。

このような流れでPythonコードを実行すると以下の結果が得られえます。

Observation: 29.471443066516347

ここから次に何をするべきかさらに考えて実行していきます。

LLMが考えてPythonのコードを生成し、実行する部分(2回目)

次にLLMの出力とPythonコードの実行は以下のようになります。

 I now need to calculate the square root of the average age
Action: python_repl_ast
Action Input: math.sqrt(df['Age'].mean())
Observation: name 'math' is not defined

1行目は先ほどと同じように次に何をするべきかLLMに考えさせた結果の部分です。ここでは年齢の平均のルートを計算するということを考えてコードを生成しています。

このコードを実行すると以下のようなエラーが出力されます。

name 'math' is not defined

まだmath がインポートされてないので、その部分でエラーがでています。たしかに現状のコードではどこもmath をインポートしてないので、このエラーがでるのは当然です。

ここからさらにLLMに考えさせます。

LLMが考えてPythonのコードを生成し、実行する部分(3回目)

次にLLMの出力とPythonのコードを実行した結果は以下のようになります。

 I need to import the math library
Action: python_repl_ast
Action Input: import math
Observation: 

1行目は先ほどと同じように次に何をするべきかLLMに考えさせた結果の部分です。今度はちゃんとmath をインポートするように考えて、その通りのコードを生成しています。

このコードはインポートだけなので出力はなしです。

LLMが考えてPythonのコードを生成し、実行する部分(4回目)

ここからさらにLLMに考えさせます。

 I now need to calculate the square root of the average age
Action: python_repl_ast
Action Input: math.sqrt(df['Age'].mean())
Observation: 5.42876073026951

LLMの考えていることは1行目にでていて、これは2回目のときと同じものになっています。コードも2回目と同じです。

一方、先ほどmathをインポートしたので、今度はエラーが出ずに正しい計算ができています。

以上がPandas Dataframe Agentの中身になります。

終わりに

今回はLangChainのPandas Dataframe Agentの中身がどうなっているのかを調べたのでまとめを書きました。DataFrameの中の情報をどうやって教えているのか疑問だったのですが、その辺もわかってよかったです。

また、Pythonのastまわりを知らなかったのでそれについてもいい勉強になりました。

この記事が少しでも他の方の役にたったら幸いです。

The post LLMに表データの解析を手伝ってもらえるLangChainのPandas Dataframe Agentの中身がどうなっているのか調べた first appeared on まったり勉強ノート.

今回はLangChainのテキストをまとめるSummarizationまわりについて調べたのでそのまとめになります。

LangChainって何？ってなった方はこちらに紹介の記事がありますので、ご覧ください。

LangChainのSummarizationとは？

LangChainのSummarizationとは与えられたテキストデータから要約されたテキストを作る機能になります。

LangChainにはChatGPTのようなサンプル以外にも様々な例が紹介されています。その中の一つがSummarizationです。

Summarizationは他の機能よりも説明が少なく、また、少し長い論文の要約をさせようとすると動かないことがあるので、どのような処理をさせているのか？を理解したくて調査しました。

ちなみに参考にしたのはこのnotebookです。

https://python.langchain.com/en/latest/modules/chains/index_examples/summarize.html

ここから基本的には要約したいDocumentのリストを引数にとるload_summarize_chain()を使って実行した場合の例について説明していきます。

load_summarize_chainによるSummarizationの３つの方法

load_summarize_chain()Summarizationとして以下の３つがあります。

1. stuff
2. map_reduce
3. refine 

それぞれについて説明していきます。

stuff

おそらくSummarizationという機能から一番最初に想像するのがこれです。与えられたDocumentのリストを受け取って、すべてつなげた一つのテキストにします。それをLLMに投げて要約させます。defaultのPromptのテンプレートとしては以下のようなものになっています。

"""Write a concise summary of the following:


"{text}"


CONCISE SUMMARY:"""

ここで、{text}のところに１つにつなげたテキストに置き換えてLLMに入力します。LLMはCONCISE SUMMARY:の続きを生成するので、{text}の部分に基づいて要約した文章を生成することになります。

CONCISE SUMMARY: から先はLLMに生成させるようにすることで要約をえることができるようになっています。

ただ、これの問題点としては与えrるDocumentのリストの合計のテキストの長さが長すぎるとLLMのコンテキストサイズを超えて実行できないケースが発生するので注意してください。

map_reduce

次にmap_reduce に関してです。名前の通りで、リストで与えられたDocumentを一度要約し、その要約されたものを組み合わせてさらに要約するというのを繰り返し行い、最終的な要約を得るものになります。

最初の要約の部分とその後の要約されたものからさらに要約をする部分の２種類のステップがありますが、どちらもデフォルトでは以下のpromptのテンプレートを使います。

"""Write a concise summary of the following:


"{text}"


CONCISE SUMMARY:"""

いろいろ試しましたが、特に論文のような長い文章の場合はこれが一番まともな要約をしてくれる印象でした。

refine

最後にrefine です。これも名前の通りですが、与えられたDocumentのリストの最初の要約を作り、そのごその要約と次のDocumentの要約を作ります。これを繰り返して最終的な要約を得ます。

これは二種類のプロンプトを使い分けて実行されます。まず最初の要約を作る部分は今までと同じように以下のプロンプトが使われます。

"""Write a concise summary of the following:


"{text}"


CONCISE SUMMARY:"""

そして、それまでの要約と新しいDocumentを組み合わせて新しい要約を作る部分のプロンプトは以下のようになります。

    "Your job is to produce a final summary\n"
    "We have provided an existing summary up to a certain point: {existing_answer}\n"
    "We have the opportunity to refine the existing summary"
    "(only if needed) with some more context below.\n"
    "------------\n"
    "{text}\n"
    "------------\n"
    "Given the new context, refine the original summary"
    "If the context isn't useful, return the original summary."

refine を使ってみた感想としては最後のほうのDocumentに影響されて、それほど情報量のないにも関わらず、最後のほうのDocumentの内容が要約に含まれていました。このため、要約の品質としてはmap_reduce のほうがよいかもしれないと思っています。

終わりに

今回はLangChainのSummarizationについて調べたのでまとめを書きました。

長い文章の要約に使えないか？と思って調べたのですが、実際にやってみると期待したほどすごい要約がでてくるという感じではない印象です。

このため、個人的には使いどころが悩ましいなぁというと思っています。

ただ、いろいろ工夫すればいいものができそうな気もするので、少し文章の要約というかまとめは工夫できないかチャレンジしようと思います。

The post LangChainのSummarizationについて調べたまとめ first appeared on まったり勉強ノート.