🔰PyTorchでニューラルネットワーク基礎 #40 【GPT編・指示チューニング】

概要

個人的な備忘録を兼ねたPyTorchの基本的な解説とまとめです。GPTタイプ （自己回帰型の言語モデル）の事前学習の演習で学んだことをまとめてみました。実際に小型のGPTモデルで事前学習してみました。あえてTransformerブロックの自作をせず、PyTorchの関数を使いできるだけ簡単にGPTタイプを再現することを心がけました。

事前学習が終了した段階だと文章の続きを作文する能力しか身についていません。入力した指示内容に従って返答するように、返答の型を追加するチューニングが指示チューニングと呼ばれる教師ありファインチューニングのようです。

確認したい事項	達成度
指示に従った返答をしているか？	多分◯
学習データを使って意味のある文章を生成できるか？	△〜◯
指示チューニングのデータを再現しているか？	◎
学習分野外の内容から意味のある文章を生成できるか？	✕

図１：生成結果のサンプル

方針

1. できるだけ同じコード進行
2. できるだけ簡潔（細かい内容は割愛）

演習用のファイル

• トークナイザー: livedoor_homme_tokenizer_8k.json

  • livedoorニュースコーパスのHOMMEカテゴリーをデータとしてbytelevel BPEで学習した8Kトークナイザー

• 学習データ：livedoorニュースコーパスのHOMMEカテゴリー

• 事前学習済みモデル：homme_seq_512_bpe_8k.model

  • 系列長512のモデル。seq_len=512で動作します。このモデルにファインチューニングする形になります。

• 指示チューニング済みモデル：homme_seq_512_bpe_8k_it.model

  • 指示チューニングが終わったモデル

• コード: sample_40.ipynb

1. データ

指示チューニングなのでHuggingFaceで公開されているSFT (Supervised Fine Tuning) 用のデータセットを利用すれば良さそうです。しかし、公開されているSFT用データは事前学習の分野と異なる内容ばかりになるので学習がほとんど進みません。また、公開データは文字数も多いので第38回で事前学習したモデルでは、文章の切り詰めが必要となり、データを活用しきれないという問題が生じます。

そこで、第38回の事前学習で利用したlivedoorニュースコーパスのHOMMEカテゴリーの内容から質問応答のようなデータを強引に作成して演習用のSFTデータとします。ついでに、「おはようございます」や「こんにちは」などの簡単な挨拶文も追加してみました。

ライセンス的に改変したデータをアップロードできないのが残念 😓

前処理の手順

1. ローカルLLMを利用して、HOMMEカテゴリーのファイルごとに、本文から次のような一問一答形式の対を１個作成します。合計で500問くらい作成できます¹。忘れてしまいましたが作成までそこそこの時間かかりました。時間レベルです。

{input: 春先に似合うコーデを紹介してください。, output: ジャケットには...}

1. 挨拶文やちょっとした日常会話文を手動で追加しました。次のようなよくありそうな挨拶文の対を30個くらい作成

{input: こんにちは, output: こんにちは！}
{input: ありがとうございます, output: こちらこそ、いつもありがとうございます。}

1. 質問部分を"input"、応答部分を"output"としてJSONやCSVなどで保存します。

一つだけ注意点で、学習させるSFTデータのトークン数が事前学習で利用した最大トークン数を超過しないように短めにします。 挨拶文もローカルLLM使って生成することもできますよ。

2. トークナイザー

事前学習で利用したByteLevelのBPEによるトークナイザーを使います。色々追加した特殊トークンが今回活躍します😆

from tokenizers import Tokenizer

tokenizer_filename = "./tokenizer/livedoor_homme_tokenizer_8k.json"
# 利用するトークナイザー
tokenizer = Tokenizer.from_file(tokenizer_filename)

print("特殊トークンID:")
print(f"<pad>: {tokenizer.token_to_id('<pad>')}")
print(f"<eod>: {tokenizer.token_to_id('<eod>')}")
print(f"<system>: {tokenizer.token_to_id('<system>')}")
print(f"<assistant>: {tokenizer.token_to_id('<assistant>')}")
print(f"<user>: {tokenizer.token_to_id('<user>')}")
print(f"size: {tokenizer.get_vocab_size()}")

# 特殊トークンID:
# <pad>: 0
# <eod>: 1
# <system>: 2
# <assistant>: 3
# <user>: 4
# size: 8000

3. 学習データの作成

3.1 チャットテンプレート・プロンプトフォーマット

指示チューニングを調べていると2種類の形式をよく見かけます。「#」記号を利用して内容を分割する方法、<|im_start|>、<s>や</s>のような特殊トークンを利用して書き下す方法です。便宜上スタイル１、スタイル２としておきます。時々、Alpaca形式やphi-3形式と紹介しているものも見かけました。

スタイル１

スタイル１

### System:
あなたは親切なAIアシスタントです。
### Instruction:
富士山の高さは？
### Response:
富士山の標高は3,776メートルです。<|endoftext|>

スタイル１は直感的にわかりやすいのと、特殊トークンが事前に準備されていなくても指示チューニングできる利点があります。

スタイル２

スタイル２

<|im_start|>system
あなたは親切なAIアシスタントです。<|im_end|>
<|im_start|>user
富士山の高さは？<|im_end|>
<|im_start|>assistant
富士山の標高は3,776メートルです。<|im_end|>

スタイル２は事前に入念な設計が必要ですが、役割もコントロールできるので形式がうまく学習できそうです。なんとなく特殊トークンの自由度が高すぎるような気がします。

『つくりながら学ぶ！LLM自作入門』の練習問題7-1によると、どちらのテンプレートスタイルでもモデルの応答品質は同程度なようです。感覚的なのですが、スタイル２をよく見かける？気がするので、演習ではスタイル２の独自バージョンで試してみたいと思います²。ややスタイル１に寄せたスタイル２の形になります

演習利用スタイル

演習スタイルの例

<system>
あなたは親切なAIアシスタントです。
<user>
富士山の高さは？
<assistant>
富士山の標高は3,776メートルです。<eod>

3.2 テンプレートに合わせたデータ作成

私はJSONL形式で指示チューニング用のデータを保存しました。pandasを利用して、JSONLを読み込む予定なので、データフレームを引数に取るDatasetクラスを作成してテンプレートに合わせた学習データを作成していきます。

指示チューニングデータの例

{"input":"よろしくお願いします","output":"どうぞよろしくお願いします。"}
{"input":"お久しぶりです","output":"お久しぶりです！"}

Datasetクラスのカスタマイズは、特殊メソッドの__init__()、__len__()、__getitem__()を定義すればOKでした。dataはデータフレーム、configはネットワークや学習の設定となります。

Datasetクラス

class SFTDataset(Dataset):
    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.max_len = config.seq_len

        # 特殊トークンID
        self.system_id    = tokenizer.token_to_id("<system>")
        self.user_id      = tokenizer.token_to_id("<user>")
        self.assistant_id = tokenizer.token_to_id("<assistant>")
        self.eod_id       = tokenizer.token_to_id("<eod>")

    def __len__(self):
        return len(self.data)

    # (1)
    def _enc(self, text):
        return self.tokenizer.encode(text, add_special_tokens=False).ids

    # (2)
    def __getitem__(self, idx):
        item = self.data.iloc[idx]   # データフレームのindex行を取得したいので data.iloc[]を使う
        system      = "あなたはいずれ最強のAIです。次の要求を適切に満たす応答を書きなさい。"
        instruction = item["input"]
        response    = item["output"]

        # (3) プロンプト部分（損失を計算しない）
        prompt_ids = []
        prompt_ids += [self.system_id] + self._enc(system)
        prompt_ids += [self.user_id] + self._enc(instruction)
        prompt_ids += [self.assistant_id]   # ここまで与えて、続きを生成させる

        # (4) 応答部分（損失を計算する）。末尾に<eod>を付けて「停止」を学習させる
        response_ids = self._enc(response) + [self.eod_id]

        # (5)
        input_ids = prompt_ids + response_ids

        # (6) プロンプト部分はconfig.ignore_index=-100でマスク、応答部分だけ学習対象
        labels = [config.ignore_index] * len(prompt_ids) + response_ids

        # (7)
        # seq_lenで切り詰め（長すぎる応答は<eod>が切れる点に注意）
        input_ids = input_ids[: self.max_len]
        labels    = labels[: self.max_len]
        # (8) input_idsとlabelsで１トークンずれていない
        return {"input_ids": input_ids, "labels": labels}

説明メモ
input文・output文をチャットテンプレート

<system> system文のID列 <user> input文のID列 <assistant> output文のID列 <eod>

に合わせて入力データのID列と教師データのID列を出力させるのがDatasetクラスとなります。

• (1) _enc(text)関数はtokenizerを利用してtextをid列に変換する関数です。__getitem__でのみ利用します。関数化せず直接記述しても良かったかもしれません。逆に、もう少し関数化して__getitem__をスッキリとさせても良いかもしれません。好みに合わせて修正してください
• (2) __getitem__は、指定したインデックスに対応するデータに対して、チャットテンプレートに合わせたid列とマスク付きラベルを求める関数となります。system文ですが、例のように適当なものでも問題ありません³😆
• (3) チャットテンプレートに従って、ID列を作成します。
  • prompt_ids：input文までのID列
• (4) output文に終端記号の<eod>を追加してID列を作成します。
  • response_ids：output文<eod>のID列
• (5) チャットテンプレート全体像で prompt_ids + response_ids となります。
• (6) labelsは教師データです。prompt_idsまでのIDを -100 (config.ignore_index) として学習時に損失を計算しないように設定します⁴。
• (7) 系列長データで切り詰めます。設計時にトークンを短めに指定しているので演習上問題ないのですが地味に注意がいる部分⁵
• (8) 事前学習ではinput_idsとlabelsで１トークンずれたデータを準備しました。今回は、少しだけHuggingFaceっぽい雰囲気に寄せて、損失計算時に１トークンずらす形で対応してみたいと考えています😆

SFTDatasetクラスから作られるサンプル

例

dataset = SFTDataset(data=df, tokenizer=tokenizer, config=config)

len(dataset[0]["input_ids"]) # 115
dataset[0]["input_ids"]    # [2, 876, ... 273, 4, 3769, ..., 1073, 3, 3411, ..., 273, 1]
dataset[0]["labels"]       # [-100, -100, ..., -100, 3411, ...273, 1]

データ毎に系列長が異なります。DataLoaderクラスのcollate関数で等長化します。

• config.pad_token_id = 0: <pad>のID
• config.ignore_index = -100: 損失計算を考慮しない特殊ID列

この2点に注意しながらバッチサイズ毎に等長化するcollate関数を作成すればOKです。

collate関数

def padding_collate_fn(batch):
    # (1)
    max_len = max(len(b["input_ids"]) for b in batch)
    input_ids = []
    labels = []
    # (2)
    for b in batch:
        n_pad = max_len - len(b["input_ids"])
        input_ids.append(b["input_ids"]+ [config.pad_token_id] * n_pad)
        labels.append(b["labels"]      + [config.ignore_index] * n_pad)  # padは損失対象外
    # (3)
    return {
        "input_ids": torch.tensor(input_ids, dtype=torch.long),
        "labels":    torch.tensor(labels,    dtype=torch.long),
    }

説明メモ

• (1) 最大の系列長を探します。
• (2) バッチ毎に<pad>を挿入します。input_idsにはpad_token_idの「0」をそのまま追記、labelsのpad_token_id部分には損失計算対象外IDの「config.ignore_index (-100)」を追記します。
• (3) LongTensorとして値を出力します。

実際に学習に利用されるデータ

例

df = pd.read_json(data_filename, lines=True)
dataset = SFTDataset(data=df, tokenizer=tokenizer, config=config)

dataloader = DataLoader(
    dataset=dataset,
    batch_size=2
    shuffle=True,
    collate_fn=padding_collate_fn
)

dataloaderの値を確認してみます。

{'input_ids': 
 tensor([[   2,  876,..., 4,  543,..., 3,  733, ...,1],
         [   2,  876, ...,4, 1584,...,3, 4140 ..., 1, 0,...0]]),
 'labels': 
 tensor([[-100, -100,..., -100,  733, ..., 1],
         [-100, -100,..., -100, 4140,...,273,..., 1, -100, ...,-100]])}

ID番号が「３」の<assistant>まで、「-100」のラベル、文章後方の<pad>部分も「-100」ラベルとなります。次のようなテンプレート文に対して、

<system> system文のID列 <user> input文のID列 <assistant>

<assistant>以降のトークンを予測する形が指示チューニングの基本となります。

ID列をデコードすると

from tokenizers import decoders
tokenizer.decoder = decoders.ByteLevel()
decoded = tokenizer.decode(dataset[0]["input_ids"], skip_special_tokens=False)

print(decoded)
# '<system>あなたはいずれ最強のAIです。次の要求を適切に満たす応答を書きなさい。<user>フォーエバー21旗艦店が銀座に進出について<assistant>米国ロサンゼルス発のファストファッションチェーン「フォーエバー21」をオープンする。店舗は、松坂屋銀座店の本館1階5階の一部に入り、総面積約930坪という広大な売場で、通常の直営店よりも多くの商品バリエーションでメンズ、レディスのほか、日本初登場となるキッズまでのフルラインを展開する予定。<eod>'

4. モデル設定と学習

指示チューニングとはいえ、ファインチューニング。コードの流れも今までと同様にできるはず！

1. 準備 (4.1)
2. ネットワークモデルの定義と作成　(4.2)
3. データの読み込みとtorchテンソルへの変換　(4.3)
4. 誤差関数と誤差最小化の手法の選択　(4.4)
5. 変数更新のループ　(4.5)
6. 検証　(4.6)

4.1 準備

利用するライブラリーを読み込みます。

import pandas as pd
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from tokenizers import Tokenizer
from pathlib import Path


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"{device=}")

# シード固定の場合の設定
import random
import numpy as np

def set_seed(seed=55):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)   # CPU + 全CUDAデバイスをまとめて設定する
    print(f"seedを設定: {seed}")
set_seed()

シード固定は特に不要ですが今後の参考のために追加してみました。

利用するデータセットのディレクトリー、トークナイザー、学習したモデルの保存ファイル名を指定します。

data_filename = "./data/instruction_tuning_data.jsonl"    # これはlivedoor hommeからQA形式で作成してください
tokenizer_filename = "./tokenizer/livedoor_home_tokenizer_8k.json"
pretrain_filename = "model/seq_512_bpe_8k.model"
instruct_model_filename = "model/seq_512_bpe_8k_it.model"

# トークナイザー
tokenizer = Tokenizer.from_file(tokenizer_filename)
print(f"size: {tokenizer.get_vocab_size()}")        # size: 8000

• instruction_tuning_data.jsonlはhommeカテゴリーからQA形式を作成して作ったSFT用のデータセット。ついでに挨拶文も追加しています。ここは頑張って自作してください⁶
• トークナイザーはHOMMEカテゴリーで学習した語彙数8000のものです。

4.2 ネットワークモデルの定義と作成

ModelConfigクラスで、系列長、特殊トークンのID、バッチサイズなどの基本的な数値を定めます。DNNクラスでGPTタイプのネットワークモデルを構成します。事前学習のモデルに追加して学習する形なので、基本設定やネットワーク構造は同一となります。

class ModelConfig:
    def __init__(self, tokenizer):
        # モデル構造
        self.vocab_size = tokenizer.get_vocab_size()
        self.seq_len = 512   # 128トークンだとSFT時に少ない
        self.d_model = 256   # 512
        self.nhead = 8
        self.dim_feedforward = 4*self.d_model
        self.num_layers = 6
        self.dropout = 0.1
        
        # 特殊トークンID
        self.pad_token_id = tokenizer.token_to_id("<pad>")
        self.eod_token_id = tokenizer.token_to_id("<eod>")
        
       
        # 学習データに関する設定
        self.context_size = self.seq_len         # 学習できる長さ
        self.context_stride = self.context_size  # 重なり具合の調整

        # 学習設定
        self.batch_size = 128
        self.learning_rate = 0.001  # これだとデフォルトと変わらない
        self.num_epochs = 100
        self.max_grad_norm = 1.0
        self.ignore_index = -100

    # 属性を追加・更新するメソッドを追加 設定時のタイポに注意だぞ〜
    def update(self, **kwargs):
        """渡されたキーワード引数で設定を動的に追加・更新する"""
        for key, value in kwargs.items():
            setattr(self, key, value)


class DNN(nn.Module):
    def __init__(self, config: ModelConfig):
        super().__init__()
        self.config = config
        
        # 埋め込み層
        self.token_embedding = nn.Embedding(num_embeddings=config.vocab_size, embedding_dim=config.d_model, padding_idx=config.pad_token_id)
        self.pos_embedding = nn.Embedding(num_embeddings=config.seq_len, embedding_dim=config.d_model)
        self.dropout = nn.Dropout(config.dropout)

        # Transformer layers
        # TransformerEncoderだけど、右三角にmaskつけるのでマスク付き自己注意のタイプになる
        causal_transformer_layer = nn.TransformerEncoderLayer(
            d_model=config.d_model,
            nhead=config.nhead,
            dim_feedforward=config.dim_feedforward,
            dropout=config.dropout,
            activation="gelu",
            batch_first=True,
            norm_first=True     # 正規化の場所指定
        )
        self.transformer = nn.TransformerEncoder(causal_transformer_layer, num_layers=config.num_layers, enable_nested_tensor=False)
        
        # 最後の出力に向けた正規化とFC層　最終的に単語数になる
        self.layer_norm = nn.LayerNorm(config.d_model)
        self.fc = nn.Linear(config.d_model, config.vocab_size,bias=False)
        self.fc.weight = self.token_embedding.weight      # 重み共有
        self.apply(self._init_weights)     # 埋め込み部分の初期重み変更

    def _init_weights(self, module):
        if isinstance(module, nn.Linear):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)
            if module.bias is not None:
                nn.init.zeros_(module.bias)
        elif isinstance(module, nn.Embedding):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)

    def forward(self, x):
        seq_len = x.size(1)
        positions = torch.arange(seq_len,device=x.device)

        tok_emb = self.token_embedding(x)
        pos_emb = self.pos_embedding(positions).unsqueeze(0)
        x = tok_emb + pos_emb
        x = self.dropout(x)
        # nn.Transformer.generate_square_subsequent_mask を使ってマスクを生成
        causal_mask = nn.Transformer.generate_square_subsequent_mask(seq_len, dtype=torch.bool, device=x.device)

        # 自己回帰型 transformer (transformer decoder)
        x = self.transformer(x, mask=causal_mask, is_causal=True)
        x = self.layer_norm(x)
        
        # NTP：次のトークン予測
        logits = self.fc(x)
        return logits

DNN部分は第38回と同一なので、図２のようなネットワーク構造になります。

図２：GPTタイプのネットワーク構造

事前学習した重みを読み込み、指示チューニング用に必要な変数を上書きします。

updateを使って変数追加・上書き

checkpoint = torch.load(pretrain_filename, map_location=device)
config = ModelConfig(tokenizer)
config.__dict__.update(checkpoint["config"])

# configの追加設定と数値の変更
# update関数を使ってSFT向けに上書き
config.update(
    batch_size    = 128,
    learning_rate = 3e-4,
    num_epochs    = 60,
)

model = DNN(config).to(device)
model.load_state_dict(checkpoint["model_state_dict"])

説明メモ
ModelConfigに追加したupdate()メソッドを利用して、バッチサイズ、学習率、学習回数を変更します。

• learning_rate：学習率は事前学習で使った 1e-3よりも小さな値を指定すればOKです。
• num_epochs：エポック数で学習してみました。データ数少ないので秒レベルで終わります。回し過ぎに注意です😎

4.3 データの読み込みとtorchテンソルへの変換

SFTDatasetクラスで、inputとoutputをキーに持つデータをチャットテンプレートに適用していきます。DataLoaderでバッチごとに<pad>を挿入して系列長が等しくなるように整えていきます。ここは再掲ですね🍀

class SFTDataset(Dataset):
    def __init__(self, data, tokenizer, config):
        self.data = data
        self.tokenizer = tokenizer
        self.max_len = config.seq_len

        # 特殊トークンID
        self.system_id    = tokenizer.token_to_id("<system>")
        self.user_id      = tokenizer.token_to_id("<user>")
        self.assistant_id = tokenizer.token_to_id("<assistant>")
        self.eod_id       = tokenizer.token_to_id("<eod>")

    def __len__(self):
        return len(self.data)

    def _enc(self, text):
        return self.tokenizer.encode(text, add_special_tokens=False).ids

    def __getitem__(self, idx):
        item = self.data.iloc[idx]   # データフレームのindex行を取得したいので data.iloc[]を使う
        system      = "あなたはいずれ最強のAIです。次の要求を適切に満たす応答を書きなさい。"
        instruction = item["input"]
        response    = item["output"]

        # プロンプト部分（損失を計算しない）
        prompt_ids = []
        prompt_ids += [self.system_id] + self._enc(system)
        prompt_ids += [self.user_id] + self._enc(instruction)
        prompt_ids += [self.assistant_id]   # ここまで与えて、続きを生成させる

        # 応答部分（損失を計算する）。末尾に<eod>を付けて「停止」を学習させる
        response_ids = self._enc(response) + [self.eod_id]

        input_ids = prompt_ids + response_ids
        # プロンプト部分はconfig.ignore_index = -100でマスク、応答部分だけ学習対象
        labels = [config.ignore_index] * len(prompt_ids) + response_ids

        # seq_lenで切り詰め（長すぎる応答は<eod>が切れる点に注意）
        # seq_len=512なので多分大丈夫
        input_ids = input_ids[: self.max_len]
        labels    = labels[: self.max_len]

        return {"input_ids": input_ids, "labels": labels}

具体例

• input: "フォーエバー21旗艦店..."
• output: "米国ロサンゼルス発のファストファッションチェーン..."

チャットテンプレートに当てはめると、次のような形になります。 実際は改行なしの１行 になっています。

例

<system>
あなたはいずれ最強のAIです。次の要求を適切に満たす応答を書きなさい。
<user>
フォーエバー21旗艦店が銀座に進出について説明してください。
<assistant>
米国ロサンゼルス発のファストファッションチェーン「フォーエバー21」をオープンする。店舗は、松坂屋銀座店の本館1階5階の一部に入り、総面積約930坪という広大な売場で、通常の直営店よりも多くの商品バリエーションでメンズ、レディスのほか、日本初登場となるキッズまでのフルラインを展開する予定。
<eod>

上記の形式に変換された文をID化するのがSFTDatasetクラスの役割となります。等長化のためのcollate関数を定義します。ここも再掲です💦

DataLoaderによる等長化

def padding_collate_fn(batch):
    max_len = max(len(b["input_ids"]) for b in batch)
    input_ids = []
    labels = []
    for b in batch:
        n_pad = max_len - len(b["input_ids"])
        input_ids.append(b["input_ids"]+ [config.pad_token_id] * n_pad)
        labels.append(b["labels"]      + [config.ignore_index] * n_pad)  # padは損失対象外
    return {
        "input_ids": torch.tensor(input_ids, dtype=torch.long),
        "labels":    torch.tensor(labels,    dtype=torch.long),
    }

df = pd.read_json(data_filename, lines=True)
dataset = SFTDataset(data=df, tokenizer=tokenizer, config=config)

dataloader = DataLoader(
    dataset=dataset,
    batch_size=config.batch_size,  # メモリ足りない場合は小さくする
    shuffle=True,
    num_workers=0, # CPUの利用コア数みたいなものCPUコアの半分くらい？
    pin_memory=torch.cuda.is_available(), # GPU使う時True
    drop_last=True,
    collate_fn=padding_collate_fn
)

DataLoaderのcollate関数を利用してバッチごとに系列長の長さを揃えます。

具体例
next(iter(dataloader))によって中身を確認してみました。labelsのID部分、<assistant>まで、「-100」、<pad>を「-100」にしているので表示がわかりにくくなっています

dataloaderの中身

{'input_ids': tensor([[   2,  876, 2796,  ..., 337,  273,    1,    0],
         [   2,  876, 2796,  ...,  1139, 4841,  273,  1],
         ...,
         [   2,  876, 2796,  ...,273,  1,    0,...,    0]]),
  'labels': tensor([[-100,..., -100,  1047, 6405,...,   273,    1, -100],
         [-100,..., -100,  1629,  381,  266, ...  273,    1],
         ...,
         [-100,..., -100, 294,  528, ... 273,    1, -100,..., -100])}

4.4 誤差関数と誤差最小化の手法の選択

CrossEntropy損失とAdamWを使います。AdamWの重み減衰についても今後触れていく予定です。

criterion = nn.CrossEntropyLoss(ignore_index=config.ignore_index)   # 損失計算時にignore_index=-100を利用しない
optimizer = torch.optim.AdamW(model.parameters(),lr=config.learning_rate)

4.5 変数更新のループ

学習するデータ数も少ないのでepoch数で繰り返しました。事前学習時と同じ構成です。

注意点

• SFTDatasetのinput_idsとlabelsの作成方法に注意です。１トークンずれていません。
• GPTタイプなので次のトークンを予測するスタイルとなりますが、SFTDatasetの出力だと教師データのトークンが予測されるトークンと同じ位置になっています。
• 損失を計算するときに１トークンずらす必要があります⁷。

具体例
HuggingFaceライブラリーへの接続に向けて具体例で確認してみます。かなり冗長になります⁸

(1) IDの確認

• <pad>: 0
• <eod>: 1
• <system>: 2
• <assistant>: 3
• <user>: 4
• system本文: [10, 11]
• user文: [20, 21]
• assistant文（応答文）: [30, 31, 32]

(2) SFTDataset.__getitem__( )の出力
表のようにlabelsはinput_idsと同じ位置に並んでいます。

<system>から<assistant>までのID： [2, 10, 11] + [4, 20, 21] + [3]
応答のID： [30, 31, 32] + [1]

index	0	1	2	3	4	5	6	7	8	9	10
input_ids	2	10	11	4	20	21	3	30	31	32	1
labels	-100	-100	-100	-100	-100	-100	-100	30	31	32	1

(3) モデルの出力

logits = model(input_ids)   # (batch_size=1, seq_len=11, vocab_size=8000)

• logits[6]：位置6（<assistant>）の出力値。logits[6]の値がmaxになるIDは次のトークンである「30」=labels[7]であってほしい
• logits[7]：位置7（30）の出力値。logits[7]の値がmaxとなるIDは次のトークンである「31」=labels[8]であってほしい

つまり logits[t] が予測すべき正解はlabels[t+1] となります。

(4) 損失計算用にシフトさせて位置を合わせる

1トークンシフト

shift_logits = logits[:, :-1, :]   # 位置 0〜9  (10個)
shift_labels = labels[:, 1:]       # 位置 1〜10 (10個)

シフト後の損失計算用の対応が次の表のようになります。

位置番号	shift_logits の中身	shift_labels の中身	説明
0	logits[0]	labels[1] = -100	損失計算しない
︙	︙	︙	︙
5	logits[5]	labels[6] = -100	損失計算しない
6	logits[6]=<assistant>ID	labels[7] = 30	次のトークン（応答1トークン目）を予測
7	logits[7]=30	labels[8] = 31	次のトークンを予測
8	logits[8]=31	labels[9] = 32	次のトークンを予測
9	logits[9]=32	labels[10] = 4	<eod>を予測

損失が計算されるのは位置番号6〜9の4箇所だけです。

更新ループ
損失計算の前にlabelsを1トークンずらした形に変形しておくことが大事です。

logitsとlabelsのトークンずらしに注意

model.train()
use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()

for epoch in range(config.num_epochs):
    total_loss = 0.0
    for batch in dataloader:
        input_ids = batch["input_ids"].to(device, non_blocking=True)
        labels    = batch["labels"].to(device, non_blocking=True)
        optimizer.zero_grad()

        with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=use_bf16):
            logits = model(input_ids)
            # 次トークン予測のため1つずらす（ここが今回のポイント）
            shift_logits = logits[:, :-1, :]
            shift_labels = labels[:, 1:]
            loss = criterion(
                shift_logits.reshape(-1, config.vocab_size),
                shift_labels.reshape(-1),
            )

        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), config.max_grad_norm)
        optimizer.step()
        total_loss += loss.item()
    if (epoch+1)%10 == 0:
        print(f"Epoch {epoch+1}/{config.num_epochs} | Loss: {total_loss/len(dataloader):.4f}")

# 過学習してしまった orz
# Epoch 10/60 | Loss: 2.0750
# Epoch 20/60 | Loss: 1.1597
# Epoch 30/60 | Loss: 0.6753
# Epoch 40/60 | Loss: 0.4014
# Epoch 50/60 | Loss: 0.2654
# Epoch 60/60 | Loss: 0.1854

説明メモ

• shift_logits = logits[:, :-1, :]：（バッチサイズ、系列長−１、語彙数=8000）
• shift_labels = labels[:, 1:]：（バッチサイズ、系列長−１）

モデルの保存と復元はこれまでどおりです。まあ、学習時間も秒で終了なので保存しなくても良いような気がします。シードを固定しないと同じくらいの損失でも返答が変わってくるのが興味深かったかも🤔

# モデルの保存
torch.save({
        "model_state_dict": model.state_dict(),
        "config": config.__dict__,  # configも一緒に保存
        }, instruct_model_filename)

# モデルの復元
checkpoint = torch.load(instruct_model_filename)
config = ModelConfig(tokenizer)
config.__dict__.update(checkpoint["config"])
model = DNN(config).to(device)
model.load_state_dict(checkpoint["model_state_dict"])

4.6 検証

ここまで長かったですが、あと一息😉
文章生成となります。Greedyによる単純な方法で試してみました。これまでのGreedyによる生成の前段階として、入力文をチャットテンプレートに変更する必要があります。build_chat_promptという関数を作成してみました。

文章生成の関数

from tokenizers import decoders         # ByteLevelの時は利用する
tokenizer.decoder = decoders.ByteLevel()

# (1) 基本の文章生成関数　次のGreedyによってトークンを生成するだけ(これまでと同じ)
@torch.inference_mode()
def generate_text(
    model,
    input_ids,
    max_new_tokens=config.seq_len,
    eos_token_id=None,
):
    model.eval()
    generated = input_ids.to(device)
    seq_len = model.config.seq_len

    # greedyで単純に生成
    # eos_token_idで生成終了
    for _ in range(max_new_tokens):
        logits = model(generated[:, -seq_len:])
        next_token = logits[:, -1, :].argmax(dim=-1, keepdim=True)
        generated = torch.cat([generated, next_token], dim=1)

        if eos_token_id is not None and next_token.item() == eos_token_id:
            break

    return generated

# (2) チャットテンプレートに合わせる関数
def build_chat_prompt(tokenizer, instruction, system=None):
    ids = []
    ids += [tokenizer.token_to_id("<system>")] + tokenizer.encode(system, add_special_tokens=False).ids
    ids += [tokenizer.token_to_id("<user>")] + tokenizer.encode(instruction, add_special_tokens=False).ids
    ids += [tokenizer.token_to_id("<assistant>")]   # ここから先を生成
    return ids

# (3) 実際に入力文（prompt）から文章を表示する関数
def response(prompt):
    system_msg = "あなたはいずれ最強のAIです。次の要求を適切に満たす応答を書きなさい。"
    #system_msg = "以下は、タスクを説明する指示です。要求を適切に満たす応答を書きなさい。"

    prompt_ids = build_chat_prompt(tokenizer, prompt, system=system_msg)
    input_ids = torch.tensor([prompt_ids], dtype=torch.long).to(device)

    output_ids = generate_text(
        model=model, 
        input_ids=input_ids, 
        max_new_tokens=256, 
        eos_token_id=config.eod_token_id,   # <eod>で停止
    )

    # 応答部分だけ取り出す
    response_only = output_ids[0].tolist()[len(prompt_ids):]
    print(tokenizer.decode(response_only, skip_special_tokens=False))

説明メモ

• (1) generate_text()：input_idsに対する返答を生成する関数。greedyで１トークンごと生成していきます。
• (2) build_chat_prompt()：「<system>説明文<user>入力文<assistant>応答文」という形状に文を並び替えて、tokenizer.encodeでID化します。
• (3) response(prompt)：promptに対してbuild_chat_prompt(　)でチャットテンプレート後にID化、generate_text(　)で応答文生成となります。

prompt.csvファイルに記載されたサンプル文章に対しての返答となります。prompt.csvはHOMMEカテゴリーやSFT用のデータに記載されている内容に近い内容・実際に記載されている内容を選択しました。

csvファイルに記載された文章の返答

df = pd.read_csv("data/prompt.csv")
for num, prompt in enumerate(df["prompt"]):
    print(f"[{num+1}] > {prompt}")
    response(prompt)

返答の一部を記載しました。

• <eod>で文章が止まっていることから、指示に従った終端をしています。生成されている文章に意味があるのかという点だと、[5] はNGです。これ、学習データの本文中に類似の内容があるのですが、違う文章をつないでしまった印象。
• 学習データを使った文章を生成しているというのは、やや微妙な感じがします。[1]、[3]、[4] の応答が思ったよりも短すぎ😂
• 指示チューニングデータを再現しているかという観点から確認してみます。挨拶文となる[8]と[9]の返答は完全にコピー文になっていました。
• 完全な分野外だと、おかしな返答になります。同じ単語の繰り返しなどよく見かけるパターンです。
• [10]番目のように比較的近い内容でも試しました。意味不明瞭です。それらしく文章を書いているのもある意味すごい。

prompt.csvの返答文

### HOMMEカテゴリーをSFT用に変形した文章
[1] > 親が男の子に就かせたい職業のランキングで1位に挙げられたのはどの職業ですか。
公務員<eod>

[2] > ポール・スミスが発表したコレクションの全体的なコンセプトはどのようなものですか。
英国服の伝統を背景に、斬新なフォルムや素材でドレッシングを楽しむネオ・クラシックなものです。<eod>

[3] > ポール・スミスの「The City」というリストウォッチの価格はいくらですか？"
3万8,850円です。<eod>

[4] > 年収1000万円以上のビジネスパーソンが働いてみたいと思う国は？
シンガポール<eod>

[5] > 転職における市場価値をアップさせるための方法について解説してください。
「仕事が面白くない」・・・若手社会人の悩みは尽きないもの。そんな様々な悩みに辛口4姉妹がお答えします。<eod>

[6] > ノマド男子が持つ「ノマド」という言葉やイメージについて
「ノマド」という言葉だけが一人歩きしているように感じられる点や、SNS上では大きなビジネスをしているように見えがちだが、実際は人間関係が薄い場合がある点です。<eod>

[7] > トヨタ86が世間の注目を集める理由について
「86」という俗称に由来し、「AE86のようにユーザーから愛され、ユーザーが育てる車になって欲しい」という思いが込められているからです。<eod>

### SFT用データに追加した挨拶文 コピー文を返答しています
[8] > こんにちは
こんにちは!<eod>

[9] > どちらから来ましたか？
私は異世界から来ました。<eod>

### HOMMEにギリギリ重なっているIT分野の話題から出題
[10] > SNSでの魅力をアップさせるためのスキルと知識について
「Android」により、同社のアップデート制作知識を翡れ、Android搭載だけでなく、当サービスするなど、複数アプリが流れている。稼業の経験し、インターネットインターネット上で必要の出来事と、家庭に家庭はスマートフォンへを利用したり、インターネット上であなたのパソコンよりも必要必要必要があります。<eod>

それなりに意味のある文章を生成して<eod>で書き終えている点は評価したい！しかし！応答分が短いです。応答分の長さをもう少し調整すれば良かったかな。このあたりは比較検討したほうが良さそうだ。

生成される文についてですが、同じ文字の繰り返し、今回は、あまり見られませんでした。入力文によってはあり得ると思います。

１ターンの対話だけできるbotっぽい形で試してみました。正直、学習データを知らないと会話できない😂まさに古典的なエキスパートシステムや人工無能っぽい挙動だぞ😆

１ターンの対話bot

for i in range(5):
    prompt = input(f">")
    print(f"[{i+1}] > {prompt}")
    response(prompt)

対話例

[1] > こんにちは　　　コピー返答
こんにちは!<eod>

[2] > トヨタ86について説明して　　　事前学習データにある内容から返答
「86」という俗称に表れから愛され、ユーザーが育てる車になって欲しい。86のようにご存知れた車になって欲しい「86」という思いが愛され、ユーザーが育てる車になって欲しい」という思いが込められているからです。<eod>

[3] > 図解説明とは何でしょうか？　　　事前学習データに近い内容あるはずだけどNG
相変わっていくください。<eod>

[4] > スマートフォンの購入理由について教えてください。　　　SFT用に類似データあるタイプ一部を表示しているっぽい
「PCサイトを閲覧できるから」と「アプリが豊富」という意見でした。<eod>

[5] > ありがとうございました　　　コピー返答
こちらこそ、いつもありがとうございます。<eod>

小型ではありますがGPTタイプで学習！しかし！！これだと、本当に人工無能っぽいぞ〜。しかも返答の制御ができない人工無能😂

学習データとモデルサイズが超巨大になると突然能力が変わっていくのが非常に興味深い限りです。ゲームにあるようなレベルが極限まで上がって能力が覚醒するイメージなのかな🍀それとも事前に詰め込んだデータ量が多いだけなのか...もう少しモデルサイズやデータ量を増やして変化を楽しんでみたいものです。

次回

Transformer層を実装してGPTのLlama化に取り組んでみたいと考えています。たしか、RMSNorm、SwiGLU、RoPE、KVキャッシュあたりが必要になりそう。🌵「難」🌵

参考にした書籍とサイト

今回は論文ではなくて、解説本を中心に勉強しました。

• 斎藤 康毅 (2026)『ゼロから作るDeep Learning ❻ ―LLM編』オライリー・ジャパン
  • 多色刷りで図解が丁寧すぎ。指示チューニングの話題は code bot 例で序盤に掲載されています。これを参考に、挨拶文をSFTのデータに混ぜることにしました。
• Sebastian Raschka 巣籠悠輔 (監修), 株式会社クイープ 訳 (2025) 『つくりながら学ぶ！LLM 自作入門』マイナビ出版
  • こちらも有名。原著でも訳本でもOKかな。書籍の７章が指示チューニングに関する話題です。地味に練習問題とその解答が理解促進に役立ちました😆
• 機械学習と情報技術
  • いつもながら参考にしています。見るたび内容が増えている。
• ZennやQiitaの関連記事も参考にしました。沢山あるので掲載省略

目次ページ

注

1. 自分はGemma4でデータ生成を試みました。時々、「？」的な問題を作成していましたが、極端におかしくない場合は、そのまま利用しました。返答がNGなデータは面倒なので削除して500個ほどになりました。ローカルLLMのモデルサイズが大きいほうがなんとなくいい回答ではないかと感じます。VRAMや時間と相談しつつ決めてください。 ↩

2. トークナイザーの語彙数が限られているのでsystemやuserなどを１トークンとして認識していません。今回は<system>や<user>などのトークンを事前に準備して対応してみました。 ↩

3. system部分を固定せずに様々な役割を準備、対応する応答データも揃えることで、役割に応じた返答となります。 ↩

4. 「損失計算から除外する」≠「該当部分が学習されない」なので注意です。<assistant>以降だけでも条件付き生成規則を獲得できます。しかし！すべて損失計算したほうがいいという研究もあり少し調べたい内容でもあります。

   • Shi 他 (2024) "Instruction Tuning With Loss Over Instructions" Advances in Neural Information Processing Systems 37
   ↩

5. SFTのデータを作る際に返答部分が短めになりように意識しすぎたかも。長めの返答も面倒だし。SFT用のデータ構造が学習結果に反映されるのでしっかりと設計するするのが良いと感じました😆 ↩

6. SFTデータ面倒！確かに、そう思います。最悪、livedoorコーパスのタイトル文と本文の先頭2文を利用して、

   • 質問文：「タイトル文」について紹介してください
   • 応答文：「本文の先頭2文」

   という形でもSFT用のデータを作成しても形式を学習していそうという演習は可能でした。返答がややNGになります。 ↩

7. 第38回の事前学習で利用したRandomGPTDatasetでは１トークンずらした形でlabelsを作成してました。 ↩

8. 工夫してコンパクトにまとめられると思うのですが💦　冗長な上にわかりにくいかと思います。時間あるときにでも改変したいかも ↩