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 まったり勉強ノート.

このモデルは事前学習モデルなので、そのままでは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 まったり勉強ノート.

さて、新年一発目の記事はAIを使ったソフトウェア開発の本を3冊読んだのでまとめて紹介しようと思います。

2024年はAIの実応用が様々な分野で出始めてきた印象を持っています。その中でもソフトウェア開発は、使い方のノウハウや各種ツールがいろいろリリースされて、これからどんどんAIを使ってソフトウェア開発がされていくんだろうなと誰もが思っているかと思います。

ただ、みなさん、実際にAIを使ってソフトウェア開発をどれくらいしているでしょうか？私も昨年末までは簡単にはGitHub Copilotを仕事や趣味で簡単に使っている程度でAIを使いこなしてソフトウェア開発をしている！と自信を持っていえる状態ではありませんでした。

このため、年末年始の休みはいい機会ということで、AIを活用したソフトウェア開発について学べる本をいくつか読みました。今回は読んだ本のうち３冊をまとめて紹介しようと思います。

生成AI時代の新プログラミング実践ガイド Pythonで学ぶGPTとCopilotの活用ベストプラクティス

生成AI時代の新プログラミング実践ガイド Pythonで学ぶGPTとCopilotの活用ベストプラクティス

著:松本直樹

Amazon

楽天市場

ポチップ

GitHub Copilot以外にもChatGPTやOpenAI API、LangChainなど、幅広いAI活用法について紹介している本で、GitHub Copilot部分に関しては実際にwebアプリケーション開発の例なんかも載っていてわりと活用イメージをすぐに持てる本です。

この本の特徴を簡単にまとめると以下の通りです。

• GitHub Copilot以外の内容も充実
  ChatGPTやOpenAI API、LangChainなどの使い方も説明されていて、AI全般に関する知識を獲得できます。ただ、GitHub Copilotだけを詳しく知りたいと思っている場合は思っていたものと違うという印象をもつかもしれません。
• GitHub CopilotとChatGPTを使った開発例がいい
  例としてGitHub Copilotの簡単な機能紹介だけではなく、ChatGPTを使った要件定義から、実際にCopilotでコードを書き上げる流れまで一連のプロセスが１章分かけて分かりやすく紹介されていました。この部分は読めばすぐにでもChatGPTとGitHub Copilotを使った開発の手順がイメージできたので、個人的に非常に良かったです。

コード×AI ー ソフトウェア開発者のための生成AI実践入門

コード×AIーソフトウェア開発者のための生成AI実践入門

著:服部 佑樹

Amazon

楽天市場

ポチップ

先ほどの本（「生成AI時代の新プログラミング実践ガイド」）が「ChatGPTとGitHub Copilotを使ってすぐに開発する手順」が分かりやすくまとまっていたのに対して、こちらの本は「AIとは何か」「ソフトウェア開発にどう活かすか」という 概念的な解説 が多い印象でした。

この本の特徴を簡単にまとめると以下の通りです。

• 特定のツールに依存しない汎用的な説明
  Promptの改善の仕方など、概念ベースの解説が多いため、すぐに知識が陳腐化してしまうリスクは少なそうです。一方で、具体的なツールの使い方に重点を置いていないため、「これを読んですぐにAI開発ができる！」という即効性はあまり感じませんでした。
• 実践するには練習が必要
  提示されているPrompt例はあくまでベースであり、こういう時どうすればいいのかについての深い言及は少なめな印象でした。このため、ただ読むだけでは活かせない知識が多く、この本で得た知識を使いこなすにはしばらくいろいろ手を動かしてみる必要があると思いました。

AIエディタCursor完全ガイド　やりたいことを伝えるだけでできる新世代プログラミング

AIエディタCursor完全ガイド ―やりたいことを伝えるだけでできる新世代プログラミング―

著:木下雄一朗

Amazon

楽天市場

ポチップ

普段VSCodeを使っている身として、「最近よくきくCursorって、使い心地はどうなんだろう？」と気になり手に取った一冊です。この本は初心者でも分かりやすく、実践的な使い方が豊富に紹介されているので、「こんなことまでできるのか！」を体感しながら読める内容でした。

この本の特徴を簡単にまとめると以下の通りです。

• エディタとしてのCursor活用例が充実
  単純な画像変換やPDF結合など、ちょっとしたスクリプトでできそうな作業から、iOSアプリ開発にまで踏み込んだ事例が取り上げられており、やりたいことに合わせてCursorを使いこなすイメージがつかみやすかったです。
• すぐに試してみたくなる
  手順が丁寧かつ実用的なため、読みながら「すぐにでもこれを試してみたい！」と思えるものが多く、Cursorでいろいろ試しながら読み進めていました。

こういう人にお勧め

今回読んだ3冊は、意図せず全然違う３冊でした。それぞれどういう人にお勧めかを簡単にまとめると

1. すぐに開発に導入してみたいなら
   「生成AI時代の新プログラミング実践ガイド」が、ChatGPTとGitHub Copilotを連携させてコード生成まで行う流れを具体的に解説してくれるので、実践的な入門書として最適に感じました。
2. 概念から学びたいなら
   「コード×AI ー ソフトウェア開発者のための生成AI実践入門」は、AI全般の仕組みやPromptの考え方など基礎がしっかり学べます。ただし、即戦力というよりは理解を深めるための本といった印象です。
3. 新しいAIエディタを試してみたいなら
   「AIエディタCursor完全ガイド」は、Cursorというエディタの便利機能を豊富な事例とともに紹介してくれるので、今までVSCodeなどを使っていた方にも新鮮な発見がありそうです。

終わりに

それぞれの本を読んだことで、AIを開発に取り入れる際のイメージが具体的になりました。ツールやフレームワークの選択肢は多く、一長一短がありますが、まずは自分が取り組んでいるプロジェクトや学習スタイルに合ったものを試してみるのが大切だと思いました。これからもAIを活用したソフトウェア開発の動向や事例を追いかけつつ、積極的に活用していきたいと考えています。

またこれまでもいろいろ本の紹介記事を書いていますので、他にも興味がある本がありましたら是非読んで見てください。

The post AIを使ったソフトウェア開発の書籍まとめ(2025/1版) 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 まったり勉強ノート.

どんな内容の本か？

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 まったり勉強ノート.

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 まったり勉強ノート.

どんな内容の本か？

この本を一言でまとめると「Transformersを使った推論、学習など幅広くまとめた本」という感じかと思います。
「Transformer”s”」って何?という方向けに説明すると、ChatGPTなどで使われているTrasnfomerというモデルを扱いやすくしたPythonライブラリです。おそらく、この記事を執筆している現在、自然言語系のタスク向けにTransfomerのモデルを使って学習したり、推論したりしようと思ったら多分使うことになるライブラリかと思います。

このTransformersについて開発しているHugging Faceの人たちが自ら解説した本がこの本になります。扱っているテーマは幅広く、Transformerの仕組みから、Transformersを使ったテキスト分類などいくつかの応用タスクを実際に実行する方法、Transformersの高速化、学習などが書かれています。Transformersについて知りたいと思ったら、このを本をまず読んでみると全体を俯瞰できてよいかと思います。

どんな人にお勧めか？

この本は以下のような人に向いている本かなと思っています。

1. Transformerの自然言語応用について幅広く勉強したい人
2. Transformersを使ったコードについていろいろ知りたい人

特にTransformerの自然言語応用について知りたい方はちょうどよい本かと思います。一方、Transfomerの言語以外の応用、例えば画像なんかについては簡単な紹介はありますが、詳しくは書かれていません。このため、自然言語以外について知りたい人には向かない本だと思います。

個人的に良かった点

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

1. Transformersを使ったpretrainingについてちゃんと書いてある
2. 備考的なことについてもいろいろ言及があり、しかも参考文献がしっかりついているので、詳しく知りたい場合は論文にあたりやすい

Transformers + 自然言語については最近話題なこともあり、何冊か本が出ています。私自身、数冊読んだのですが、どれも応用よりなことが多く、pretrainingなどまで書いてない、もしくは書いてあったとしてもちょっとしかないみたいな本が多い印象です。この点、この本はpretrainingのやり方までちゃんと具体例を示しながら説明してあって良かったです。

また、単純にTransformersの使い方の説明にとどまらず、例えばデータセットの課題やTokenizerごとの違いについても簡単な言及がちゃんと書かれています。また、これらにちゃんとどの論文に書かれているのか示されているので、より詳しく知りたい場合は論文を読んで勉強するということができるようになっています。

終わりに

今回はTransfomrersについて書かれた「機械学習エンジニアのためのTransformers ―最先端の自然言語処理ライブラリによるモデル開発」について紹介する記事を書きました。

今後もこのように読んだ本の紹介を毎週月曜日に投稿しようと思いますので、興味がある方は見に来てみてください。

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

The post [書評] 機械学習エンジニアのためのTransformers ー 自然言語のTransformerについてより知りたい人向けな一冊 first appeared on まったり勉強ノート.