🔰PyTorchでニューラルネットワーク基礎 #38【GPT編・事前学習】

概要

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

確認したい事項	達成度
学習データの再現・意味のある文章を生成しているか？	◎
学習データに類似の文からの意味のある文章を生成できるか？	△〜○
学習分野外の内容から文章を生成できるか？	✕

次のような感じの文章となります。

図：生成結果のサンプル

扱う内容

1. GPTタイプの事前学習
2. Datasetクラスのカスタマイズ
3. Flash Attention
4. 日本語データでの学習

方針

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

演習用のファイル

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

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

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

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

  • 系列長512のモデル。seq_len=512で動作します。

• コード: sample_38.ipynb

1. データ

livedoorニュースコーパスのhommeカテゴリーに分類されているテキストデータを使います。

• すでにある程度の前処理が行われており、非常に使いやすい点
• ニュース記事なので、きれいな文章になっている点
• 同分野がまとまっている点
• ファイルごとに内容がまとまっている点

livedoorのニュースコーパスは9つの分野に分かれていると思いますが、他の分野も混ぜると、学習時間もかかりますし、１分野固定がお気楽😆

前処理

• 文頭から3行のURL、日付、タイトルの削除 (演習はこの状態で事前学習しました)
• ライセンス的に改変したデータをアップロードできないのが残念 😓😓

前処理の追加編の参考例
ローカルLLMを利用して加工すると好みの文体に統一できると思います。

• 文体を「です・ます」調に調整
• 体言止もできる限り、文になるように調整

2. トークナイザー

トークナイザーも自作します¹。ByteLevelのBPEで、前処理済みデータを利用してトークン数8,000で学習してみました。特殊トークンは、文章の区切りを表す<|endoftext|>的なものが一つあれば事前学習と文章生成までできるのですが、指示チューニングも視野に入れて、いろいろ追加しています😆

【クリックで展開】トークナイザー生成コードの全体像となります。

import glob
from tokenizers import Tokenizer, models, trainers, pre_tokenizers, normalizers

tokenizer_filename = "./tokenizer/livedoor_homme_tokenizer_8k.json"  # tokenizerのファイル名
data_dir = "./data/homme"          # 学習データの保存ディレクトリー
vocab_size = 8_000                 # 語彙数


tokenizer = Tokenizer(models.BPE())       # (1) BPE
tokenizer.normalizer = normalizers.NFKC() # (2) 正規化
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False) # (3) ByteLevel

# (4) Trainer
trainer = trainers.BpeTrainer(
    vocab_size=vocab_size,
    special_tokens=["<pad>", "<eod>", "<system>", "<assistant>", "<user>"],
    min_frequency=2,
    initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
)

# (5) data_dirディレクトリ内のtxtファイルを取得
data_files = sorted(glob.glob(f"{data_dir}/*.txt"))

# (6) 複数のtxtファイルを順番に読み込む
def iterator(filenames):
    for filename in filenames:
        with open(filename, "rt", encoding="utf-8") as f:
            for line in f:
                yield line

# (7) 学習
tokenizer.train_from_iterator(
    iterator(data_files),
    trainer=trainer
)

# (8) 保存
tokenizer.save(tokenizer_filename)
print("学習終了")

学習したトークナイザーの特殊トークンと語彙数を確認しておきましょう。語彙数が6,000〜10,000くらいならきれいに文章を生成できたかな😆

from tokenizers import Tokenizer

tokenizer_filename = "./tokenizer/livedoor_home_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

トークナイズの例
さすがByteLevelのBPE！学習データに存在しない絵文字もちゃんと復元されています。

入力 : 😀 こんにちは🐈
ID : [177, 258, 251, 227, 225, 298, 300, 270, 379, 282, 177, 258, 243, 235]
復元 : 😀 こんにちは🐈

全角英数記号は半角化してトークナイズ。正規化もうまく機能しているようです。

入力 : ＡＢＣ＆１２３％ English
ID : [37, 38, 39, 10, 1877, 23, 9, 3458, 82, 75, 80, 77, 87, 76]
復元 : ABC&123% English

もしかして、記号の％がフォントの都合で全角っぽく表示されているかもしれませんが、半角になっています

次にデータをID化する部分についてです。

3. 学習データの作成

前処理済みの日本語データとtokenizerを利用してid化していきます。データサイズが大きくなると事前にid化した方がいろいろ効率的なようです。今回は文字数が70万文字くらいなのでDatasetクラス内でid化していきます²。tokenizerをいろいろ変更して試したいという理由もあります。

ただし、データ量がギガクラスになると他の方法を使わないと完全にお手上げ🤷‍♀

Datasetクラスのカスタマイズ

カスタムDatasetクラスは特殊メソッドの__init__()、__len__()、__getitem__()を定義すれば完成です。データファイルではなくて、テキストデータのディレクトリーを引数とします。

確認用のランダム化なしバージョンDatasetクラス

import torch
from torch.utils.data import Dataset # カスタムDataset作成
from pathlib import Path

class GPTtypeDataset(Dataset):
    # (1) tokenizer.encode(text).idsがtextのID列
    def __init__(self, data_dir, tokenizer, context_size=8, stride=2):
        self.context_size = context_size
        eod_id = tokenizer.token_to_id("<eod>")

        filenames = sorted(Path(data_dir).glob("*.txt"))     # ファイル一覧
       
        # (2) textに相当するものを作成
        all_ids = []
        for filename in filenames:
            text = filename.read_text(encoding="utf-8")
            document_ids = tokenizer.encode(text, add_special_tokens=False).ids
            all_ids.extend(document_ids)   # 文章の追記
            all_ids.append(eod_id)         # 各ファイルの末尾に<eod>

        # (3) ID列を保持する
        self.ids = torch.tensor(all_ids, dtype=torch.long)
        # (4) 各サンプルの開始位置をあらかじめ計算
        self.starts = range(0, len(self.ids) - context_size, stride)    
    
    # (5) データ数
    def __len__(self):
        return len(self.starts)

    # (6)
    # startからcontext_sizeまでが入力データ
    # start+1からcontext_sizeまでが次のトークン予測のラベルデータ
    def __getitem__(self, idx):
        # 入力とターゲットのペアを作成
        start = self.starts[idx]
        x = self.ids[start:start + self.context_size]
        y = self.ids[start + 1:start + self.context_size + 1]
        return {"ids": x, "labels": y}

説明メモ

• (1) __init__()の引数

  • context_size：文章の長さ
  • stride：移動幅

  filenamesは利用するtxtファイルのPathオブジェクトのリストになっています。変数名はfilepathsの方がいいのかもしれません。

• (2) filenamesのテキストファイル毎に、テキストの読み込み (Path.read_text())、ids化 (tokenizer.encode)、all_idsリストへids+eod_idを追加します。

• eod_idはファイルの末尾に追加される特殊IDです。ファイルごとに内容が大きく変わるので、文章の大きな区切りを表すために<eod>を使います。

• (3) all_idsをLongTensorへ変換。文字データが長〜いid列として保管されています。40万トークンほどになります³。

• (4) idsを「strideの大きさで移動しつつ、context_sizeごとに分割」するための準備。開始位置だけをstartsとして保管します。rangeを利用してcontext_size毎に分割するための開始位置番号を求めます。stride毎にずれるのもrangeを使えば簡単に求まります。これがデータのindexに相当します。

• (5) __len__()はcontext_sizeに区切られたデータ数、つまり、開始位置番号の個数と等しくなります。

• (6) 入力ID列と教師データID列を作成する部分です。入力IDは、開始位置からcontext_sizeまでの系列長、教師データID列は、１トークンずらした長さcontext_sizeのID列となります。

具体例
雰囲気を確認するために、

• context_sizeの長さに調整 context_size=8
• strideでデータ重なり具合を調整 stride=2

として表示してみましょう😆

data_dir = "./data/homme"           # 学習用データのディレクトリ
config = ModelConfig(tokenizer=tokenizer)
dataset = GPTtypeDataset(data_dir, tokenizer, context_size=8, stride=2)

• ids、labels：系列長８
• idsとlabelsは１トークンずれ
• dataset[0]とdataset[1]で２トークン (stride分) ずれているはず

idsとlabelsは１トークンずれ、dataset[0]とdataset[1]で２トークン違いになるはずです。

dataset[0]
{'ids':   tensor([3411,  593,  438,  407, 6871, 6903, 527, 265]),
'labels': tensor([ 593,  438,  407, 6871, 6903, 527, 265, 3068])}

dataset[1]
 {'ids':   tensor([ 438,  407, 6871, 6903,  527, 265, 3068, 5911]),
 'labels': tensor([ 407, 6871, 6903,  527, 265, 3068, 5911, 2630])}

実際の学習場面では、開始位置が固定されてしまうという問題を避けるためGPTtypeDatasetの開始位置をランダム化したRandomGPTDatasetクラスを作成します。

4. モデル設定と学習

GPTタイプの学習は、「次の単語予測問題」を解くことです。コードの流れも今までと同様にできるはず！

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

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

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

import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader # カスタムDataset作成
from tokenizers import Tokenizer
from pathlib import Path


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

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

data_dir = "./data/homme/"         # 学習用データのディレクトリ
tokenizer_filename = "tokenizer/livedoor_home_tokenizer_8k.json"  
pretrain_filename = "model/homme_seq_512_bpe_8k.model"

GPTtypeDatasetクラスをランダム化したDatasetクラスになります。
開始位置を固定せずに、torch.randint()を使って開始位置をランダムにしただけですが

class RandomGPTDataset(Dataset):
    # (1) 初期化部分
    def __init__(
        self,
        data_dir,
        tokenizer,
        context_size=256,
        samples_per_epoch=10_000,
    ):
        self.context_size = context_size
        self.samples_per_epoch = samples_per_epoch
        eod_id = tokenizer.token_to_id("<eod>")
        filenames = sorted(Path(data_dir).glob("*.txt"))

        # (2) textを読み込み、id化
        all_ids = []
        for filename in filenames:
            text = filename.read_text(encoding="utf-8")
            document_ids = tokenizer.encode(text, add_special_tokens=False).ids
            all_ids.extend(document_ids)
            all_ids.append(eod_id)
        
        # (3) IDをLongTensorへ
        self.ids = torch.tensor(all_ids, dtype=torch.long)

    # (4) データ数
    def __len__(self):
        # 1 epochあたりに何個のランダム窓を学習するか
        # 10,000個（回？）がデフォルト値
        return self.samples_per_epoch

    # (5) idxは使わず、毎回ランダムな開始位置を選ぶ
    def __getitem__(self, idx):
        start = torch.randint(
            low=0,
            high=len(self.ids) - self.context_size,
            size=(1,),
        ).item()

        x = self.ids[start:start + self.context_size]
        y = self.ids[start + 1:start + self.context_size + 1]

        return {"ids": x, "labels": y}

# (6) トークナイザー呼び出し
tokenizer = Tokenizer.from_file(tokenizer_filename)

# (7) datasetの作成、実際はconfigのあとに利用します。
dataset = RandomGPTDataset(
    data_dir=data_dir,
    tokenizer=tokenizer,
    context_size=512,         # config.context_size,
    samples_per_epoch=10_000, # config.samples_per_epoch
)

既出のGPTtypeDatasetクラスをランダム開始位置に変更しただけなので大枠に変更はありません。しかし、開始位置をランダム化することで、さまざまな文書の書き出しを学習するはず！という意図があります。

説明メモ

• (1) 開始位置がランダムに選択されるので stride という概念がなくなります。変わりに、開始位置の個数を指定します。
• (2) pathlib使って取得したtxtファイル一覧のfilenamesからファイルを抽出して、テキストデータをtextとします。tokenizer.encodeを使いID列に変換します。１ファイルごとに終端IDの<eod>を追加します。
• (3) all_idsというID列をLongTensorへ変換します。
• (4) データの個数を表す__len__()は、ランダムに抽出される個数なのでsamples_per_epochそのものです。
• (5) torch.randint()を利用して、開始位置を取得します。__getitem__()の引数であるidxに無関係に、ランダムにID列を選択するようにします。

今までの流れに合わせたので、この位置にデータ取得が来ていますが、context_sizeやsamples_per_epochをモデル設定クラスに記載する形のほうがスマートに見えます。本来的にはもう少し後半にデータ取得を記載したほうが見やすいと感じます

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

ModelConfigクラスで、系列長、特殊トークンのID、バッチサイズなどの基本的な数値を定めます。DNNクラスでGPTタイプのネットワークモデルを構成します。

4.2.1 モデルの設定

class ModelConfig:
    def __init__(self, tokenizer):
        # モデル構造
        self.vocab_size = tokenizer.get_vocab_size()
        self.seq_len = 512   # VRAM足りない場合は128へ、SFTを考えると256は必要
        self.d_model = 256   # 512 モデル学習がうまく行かない場合512にする。VRAMも増えるので注意
        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.samples_per_epoch=10_000            # 1epochのデータ数、ランダム開始位置の個数

        # 学習設定
        self.batch_size = 128       # VRAM見ながらseq_lenと合わせて調整 
        self.learning_rate = 0.001  # これだとデフォルトと変わらない
        self.num_steps = 5500       # 繰り返しステップ数
        self.max_grad_norm = 1.0

ModelConfigクラスといっても、数値を並べてるだけのクラスです。系列長を表すseq_lenには注意が必要です。小さすぎると文章をうまく生成することができませんし、大きな数値だと、消費されるVRAMも巨大化します。簡易的な、指示チューニングまで考慮すると、256トークン以上は必要と思われます。事前学習して文章の生成結果を確認するだけなら、系列長のseq_len=128として、10分程度 (Colab T4) で学習も終了します。

4.2.2 GPTタイプのネットワークモデル

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

GPTタイプのネットワークモデルは、大まかに、「埋め込み層、causalマスク付きのtransformer層、全結合層で次の単語予測」という形になります。各トークンごとに「次に来るトークン」を予測する自己回帰モデルとなります。

小型GPTタイプ

class DNN(nn.Module):
    def __init__(self, config: ModelConfig):
        super().__init__()
        self.config = config
        
        # (1) 埋め込み層 pad id 学習しない(今回存在しないはず)
        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)

        # (2) 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)
        
        # (3) 最後の出力に向けた正規化とFC層　最終的に単語数になる
        self.layer_norm = nn.LayerNorm(config.d_model)
        self.fc = nn.Linear(config.d_model, config.vocab_size,bias=False)
        self.apply(self._init_weights)                # 埋め込み部分の初期重み変更
        self.fc.weight = self.token_embedding.weight  # (4) 全結合層と埋め込み層の重み共有

    # (5)
    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:          # fc は bias=False なのでスキップ
                nn.init.zeros_(module.bias)
        elif isinstance(module, nn.Embedding):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)
            if module.padding_idx is not None:   #  は None なのでスキップ
                with torch.no_grad():
                    module.weight[module.padding_idx].zero_()
        

    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)
        # (6) nn.Transformer.generate_square_subsequent_mask を使ってマスクを生成
        causal_mask = nn.Transformer.generate_square_subsequent_mask(seq_len, dtype=torch.bool, device=x.device)

        # (7) 自己回帰型 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

説明メモ

• (1) トークンをベクトル化する token_embedding と、位置情報をベクトル化する pos_embeddingを足し合わせます。
• (2) PyTorchでの名前がTransformerEncoderLayerなので注意する部分。causal mask(右上三角のマスク)を付けて通します。ここが重要なポイント！TransformerEncoderLayer を使っているのに「未来のトークンを見せない」ことで、実質デコーダ(自己回帰)として動作させています。
• (3)LayerNorm → fc で vocab_size 次元に射影。これが各位置での次トークンのスコア(logits)となります。

注意点

• (2) Pre-LNと呼ばれる置き方。norm_first=Trueオプションを利用することで、正規化を各サブ層の前に置くGPT-2以降のPre Layer Normalizationとなります。深いモデルでも勾配が安定しやすくなります。今回は浅いですがね
• (4) 重み共有 (weight tying) と呼ばれる手法です。入力埋め込みと出力射影の重みを共有しています。パラメータ削減と性能向上が狙いで、全結合層fcのバイアス項をbias=Falseとして共有に合わせています。2026年現在、重み共有しない高性能モデルも登場しており、賛否両論の状態？！このレベル感では全く無意味ですが
• (5) GPT-2式の初期化。今回導入するか迷った方法です。std=0.02 の正規分布で初期化するのはどうもGPTタイプの定番設定のようなので、やはり導入しました
  2つあるif文ですが、biasやpadも使っていないので、事実上機能していないのですが、慣例っぽいのでつけてしまった。
• (6) Encoder + causal mask = decoder化による自己回帰モデルの実装。
  nn.TransformerEncoderはBERTタイプでも利用したようにマスクなしの双方向モデルとなります。しかし！generate_square_subsequent_mask で作った因果マスクを渡すことで、位置 i が参照できるのを 0〜i だけに制限できます。これで次トークン予測が正しく成立します。boolマスクなので True の位置(未来側)が「見ない」 という意味になります。
• (7) is_causal=True
  マスクを渡しつつこのフラグを立てるのは、「このマスクは因果マスクだ」という最適化のヒントとなります。自動的に因果マスクが作成されるわけではないので要注意です。

モデルの確認
tokenizerを指定して、ModelConfigを使って設定を読み込みます。ModelConfigもモデル関連の部分と学習関連の部分に分割したほうが良さそうですね🐾

config = ModelConfig(tokenizer)
model = DNN(config).to(device)

torchinfoで大まかな構造とパラメータ数を確認しました。

from torchinfo import summary
summary(model)

summary部分にひと工夫すれば、入出力形状も表示されるようです。

==========================================================================================
Layer (type:depth-idx)                                            Param #
==========================================================================================
DNN                                                               --
├─Embedding: 1-1                                                  2,048,000
├─Embedding: 1-2                                                  131,072
├─Dropout: 1-3                                                    --
├─TransformerEncoder: 1-4                                         --
│    └─ModuleList: 2-1                                            --
│    │    └─TransformerEncoderLayer: 3-1                          789,760
│    │    └─TransformerEncoderLayer: 3-2                          789,760
│    │    └─TransformerEncoderLayer: 3-3                          789,760
│    │    └─TransformerEncoderLayer: 3-4                          789,760
│    │    └─TransformerEncoderLayer: 3-5                          789,760
│    │    └─TransformerEncoderLayer: 3-6                          789,760
├─LayerNorm: 1-5                                                  512
├─Linear: 1-6                                                     2,048,000
==========================================================================================
Total params: 8,966,144
Trainable params: 8,966,144
Non-trainable params: 0
==========================================================================================

🤔900万パラメータとなります🤔 モデルサイズが9M、心配なくらい小さいです

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

初回からあまり変わっていません。

optimizer = torch.optim.AdamW(model.parameters(),lr=config.learning_rate)
criterion = nn.CrossEntropyLoss()

AdamWを使っているので、重み減衰 (weight decay)がかかっています。このあたりも検討の余地あり

4.4 変数更新のループ

いよいよ学習ループです。RandomGPTDatasetクラス部分で入力されるデータは毎回シャッフルされます。DataLoaderでのシャッフルはFalseでOKです。ステップ数でループの管理をします。

学習ループ

# datasetの作成
dataset = RandomGPTDataset(
    data_dir=data_dir,
    tokenizer=tokenizer,
    context_size=config.context_size,
    samples_per_epoch=config.samples_per_epoch
)

dataloader = DataLoader(
    dataset=dataset,
    batch_size=config.batch_size,  # メモリ足りない場合は小さくする
    shuffle=False,   # shuffleはDatasetクラスで行われている
    drop_last=True,
    num_workers=0,   # 遅い場合は２や４？
    pin_memory=torch.cuda.is_available(), # GPU使う時True
)


# step数で管理するためのデータローダー関数
def infinite_loader(dataloader):
    while True:
        for batch in dataloader:
            yield batch

data_iter = infinite_loader(dataloader)  # epochではなく、step数で計測

# ---- 学習ループの設定　tqdmを使わないほうがシンプル
from tqdm import tqdm               # tqdmを使い進捗状況表示をしてみた
max_iters = config.num_steps        # step数
total_token = 0                     # 累積トークン数を初期化
pbar = tqdm(range(max_iters))
use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()  # flash attentionを利用の判定

# ---- ここから学習ループ
model.train()                       # trainモードを明示
for step in pbar:
    batch = next(data_iter)
    input_ids = batch["ids"].to(device, non_blocking=True)
    labels = batch["labels"].to(device, non_blocking=True)
    optimizer.zero_grad()
    # GPUが対応している場合は、bf16へ変更してflash attentionを使う
    with torch.autocast(device_type=device.type, dtype=torch.bfloat16, enabled=use_bf16):
        outputs = model(input_ids)                 # [batch, seq_len, vocab_size]
        loss = criterion(
            outputs.view(-1, config.vocab_size),   # [batch * seq_len, vocab_size]
            labels.view(-1),                       # [batch * seq_len]
        )
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=config.max_grad_norm)  # 勾配クリップ
    optimizer.step()

    # このstepのトークン数 （バッチサイズ×系列長）を加算
    total_token += input_ids.shape[0] * input_ids.shape[1]

    # set_postfixは辞書が引数になる
    pbar.set_postfix({"loss": f"{loss.item():.4f}", "tokens": f"{total_token/1e6:.2f}M"})
    if (step+1) % 500 == 0:
        tqdm.write(f"{step+1}-step:\tloss:{loss.item():.3f}\ttokens:{total_token:,}") 

表示用の設定と形状変更で、複雑に見えますが、基本構造は初回から変わっていません

基本構造

for ループ
    input_ids, labels：入力データと教師データ
    optimizer_zero_grad()
    outputs = model(input_ids)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

lossが1を下回るくらいになるまで頑張って学習させます。学習データやモデル、語彙サイズの関係からなのか詳細は不明ですが、lossは0.5程度を下回ると思います。文章を全暗記するレベル感です⁴。ここ個人的に「ポイント！」と思う部分です。GPTモデルの事前学習演習だと、モデルの構造に重点が置かれているので、少し変だけど日本語っぽい文章が生成されるという内容で終わることが多い印象があります。学習データのコピーに近い内容であってもしっかりした文章が表示されるとモチベーション・テンションも上がるのは私だけかな😆

メモリーが足りないというときは系列長やバッチサイズを環境に合わせて調整してください。15分程度で終了になると思います。今回は学習率固定ですが、「warmup + cosine decay」というのがこの分野の定番のようです。

説明メモ

• (1) Flash Attentionを使えるGPUのときは使うという分岐となります。Colab T4の場合は 残念ながらFlash Attention 使えない (T_T)

• nn.TransformerEncoderLayer を利用している時点で、scaled_dot_product_attentionが内部で働いています。特にモデルの部分で、データの型をFlash Attentionが選択されるための条件であるbf16に変更すれば、可能ならばFlash Attentionが適用されるはず⁵。

• lossは現在学習中にバッチに対しての損失となります。表示されるlossも同様です。たまたま損失が小さいということもありえます。

4.5 検証

学習で力尽きる😢
文章生成の関数は、最大確率となるトークンを繋いでいく素朴なGreedyタイプです。top_〜風、少し先まで見てからみたいなビームサーチも割愛しましたこのあたりもすこし調べてみたいな

文章生成の関数 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　or　max_new_tokensまでで生成終了
    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)       # 予測idを追記
        # 終了判定
        if eos_token_id is not None and next_token.item() == eos_token_id:
            break

    return generated

id化された文字列input_idsを入力して、modelを使い、次のトークンを予測して、トークン追加を繰り返すだけです。文章生成終端IDのeos_token_idが予測されたら文章生成終了となります。eos_tokenとして、<eod>を利用します。

from tokenizers import decoders
tokenizer.decoder = decoders.ByteLevel()

# 次の単語に続きやすい文を入力　単純に並べてしまった(笑)
prompt = "ヨーロッパ最大のフィットネスマシンメーカー"
#prompt = "テレビのバラエティ番組などで笑いを巻き起こすお笑い芸人"
#prompt = "デュアルクラッチA/T「アルファTCT」"
#prompt = "転職における市場価値をアップさせるためのスキル、知識、ノウハウ"
#prompt = "新卒市場における価値をアップさせるためのスキル、知識、ノウハウ"
#prompt = "SNSでの魅力をアップさせるためのスキルと知識"  # NG
#prompt = "図で考える力によって、問題を整理・分析"

model_input = tokenizer.encode(prompt, add_special_tokens=False)
input_ids = torch.tensor([model_input.ids], dtype=torch.long, device=device)

output_ids = generate_text(
    model=model,
    input_ids=input_ids,
    max_new_tokens=256,
    eos_token_id=config.eod_token_id,
)

# 全文をデコード
print("--- 生成結果 ---")
generated_text = tokenizer.decode(output_ids[0].tolist(), skip_special_tokens=False)
print(generated_text)

学習データにある書き出しだと、ほぼ学んだ文を出力すると思います。異なる内容だと、まるでダメな文章となります。

生成結果の例１

• 入力文：「ヨーロッパ最大のフィットネスマシンメーカー」

学習データに類似の文章（異なる文章）からです。

--- 生成結果 ---
ヨーロッパ最大のフィットネスマシンメーカー「テクノジム」社は、「2010 FIFAワールドカップ南アフリカ大会」のフィットネスマシンのオフィシャル・サプライヤーに選定されました。

同大会では、テクノジム社が、出場32ヶ国中16ヶ国の各チームのベースキャンプや国際メディアセンター、そして、史上初となる審判員施設の全18ヶ所のトレーニング施設にフィットネスマシンを設置します。

テクノジムの本社があるイタリアをはじめ、フランス、ブラジル、イギリス、アルゼンチンの強豪チャンピオン候補チームのほか、開催国の南アフリカ、日本の選手たちも含め、テクノジムのマシンでトレーニングを行い、試合に挑むことになります。

各トレーニングセンターに導入される製品は以下の通りです。

・KINESIS:筋力、バランス力、柔軟性を同時に鍛えることができるマシン。サッカーにおける特定の動きのトレーニングも可能です。
・FLEXabilility:怪我の予防に欠かせないストレッチを素早く的確に行えるマシン。
・VARIO:垂直なステップ動作から大きなストライド動作まで、自由な動きが可能な新感覚のエリプ

途中から学習データと同一の出力になっています。ある意味狙い通りです。

生成結果の例２

• 入力文：「デュアルクラッチA/T「アルファTCT」

<eod>で文章生成が止まります。

--- 生成結果 ---
デュアルクラッチA/T「アルファTCT」社のパートロファT」、さらにアイドリングストップシステムを搭載した仕様が導入される予定です。

今回、会場に展示されたのは、最高出力235ps/5500rpm、最大トルク34.6kg-m/1900rpmの1.75リッター直噴ガソリンターボエンジンと6速M/Tを搭載する最上級モデル「1750 TBi」です。レザー内装やクアドリフォリオヴェルデエンブレム、18インチアルミホイールなどが注目を集めました。<eod>

パートロファT」の末尾にある括弧が気になりますが、きれいな文章を生成しています。

生成結果の例３

• 入力文：「こんにちは」

学習データに存在しない書き出しだと、変な出力になります。途中から、なにかのコピー文へ移ります。このあたりが過学習した影響です。何事もなかったかのように、途中から学習した文章を出力するのが興味深いですよね🤔

--- 生成結果 ---
こんにちは、家族を大事に変わってきたんでしょうか」と、イマドキ家族への好感度を語りました。

今回のフルモデルチェンジで2代目となる新ラクティスは、全長4メートルのコンパクトボディながら、ゆとりのある室内空間と低燃費を実現した「コンパクト2BOX」です。扱いやすい5ナンバーサイズを維持しつつ、走行燃費を20km/Lというエコカー減税対象内に設定するなど、ユーザーへの配慮が感じられる点もポイントです。

また、ゆとりのある後部座席の足元スペースや、デッキボードの高さを2段階に調整できるアジャスタブルデッキボードの採用など、多用途で複数人での使用を前提とした設計がなされている点も、ファミリーユーザーを強く意識していることが感じられます。

エンジンサイズは1.3リットルと1.5リットルと1.5リットルの2タイプで、4WD車もラインアップされます。販売価格は144万5000円からです。

【ラクティス1.3L 主要スペック】
全長×全幅×全高:3995×1695×1585
ホイールベース:1485/1475
車両重量:1090
乗車定員:5
駆動方式:F

生成結果の例４

• 入力文：「昨夜の台風は10年に一度の規模だった」

学習データと全く無関係の入力文です。なにかのインタビュー？のような出力結果となりました。無理やり学習データの内容に合わせている感があります

--- 生成結果 ---
昨夜の台風は10年に一度の規模だったんですよね?

金子:今までの幅に入った話ではないけど、手段を選ばない手段を選ばないで、極めて一般的なスタイルは言う、そのスタイルは言うコットニックなですよね。今では、そのスタイルは昔仕事でセレクトさんなんかが恥ずかしく思える点や色の話が進んで帰ってきたと言って見えます。逆に、その中でも「テールファッション」でオリジナルブランドが恥ずかしく思えるだけでも高いかもしれません。特に一般的な点では、ファッション面でも高いかもしれません。

「オリジナルブランドの利益率は、どのくらいですか?」
Wさん:セレクトショップにもよるってゆくにはロット数を増やすことは利益率も高いですからね。逆に、その良いんですよ。逆に、助を“キャンプインが、今では、今では、機能も高いかもしれません。

Wさん:昔だったら、セレクトショップがオリジナルがオリジナルブランドや品質化してゆくには足りないですから、ファストファッションのまな自宅や価格といった面でも掲載される必要があると思います。

「そういったズレが出てきている現状でオリジナルブランドでオリジナルブランドで戦ってゆくには?」
Tさん:例えば、「ベーシックなデザインに強い」「ニットに強い」というように、それぞれにセレクトショップさんごとに特徴はあると思うんですよ。だから、その特徴を今まで以上に打ち出し

GPTタイプ、構造は単純なのですが、なかなか難しい〜。加えて、データの収集と整形が思いの外面倒だった

次回

事前学習した重みを利用して、分類問題や指示チューニングなどもやってみたい。

参考にした書籍とサイト

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

• 斎藤 康毅 (2026)
  『ゼロから作るDeep Learning ❻ ―LLM編』オライリー・ジャパン

  • とてもわかり易い。しかも多色刷りで図解が丁寧すぎ😆掲載されているコードもエディターのように色分けされていて、驚き

• Sebastian Raschka 巣籠悠輔 (監修), 株式会社クイープ 訳 (2025)
  『つくりながら学ぶ！LLM 自作入門』マイナビ出版

  • こちらも有名。原著・訳本いずれもOKかな。「ゼロから〜」の前にお世話になりました。地味に練習問題とその解答が理解促進に役立ちました😆

• クジラ飛行机 （2025）
  『Pythonでまなぶ ローカルLLMの訓練と使いこなし』ソシム

  • ローカルLLMの書籍なのですが、実はGPTタイプの事前学習についても触れられています。内容も満載😆 書籍が重たい？

• 機械学習と情報技術

  • 式の展開もあり、いつもながら参考にしています。見るたび内容が増えている。

目次ページ

注

1. 第25回のトークナイズ編・BPEに従って作成しました。 ↩

2. 第33回のDatasetクラスのカスタマイズについてを利用して、tokenizerに応じた形でid列を作成するDatasetクラスを作成します。 ↩

3. 70万文字が40万トークンになりますので、半分より多めという感じ。 ↩

4. lossが１を下回ると、パープレキシティは、2〜3の間になってきます。2〜3トークンから次の単語を予測できるレベル感なので、ほぼ丸暗記状態に近くなってきます。 ↩

5. たぶん自動的に変わるはずなのですが、Flash Attentionについてはほとんど理解していません。そのうち勉強しようと思いつつなかなか進まない ↩