LLM(大規模言語モデル)の基本原理

LLM（Large Language Model：大規模言語モデル）とは、大量の文章データを用いて学習された人間の言語を理解・生成するための人工知能モデルです。文章を単語やトークンと呼ばれる最小単位に分解し、それらの並び方の統計的な傾向を学習することで「次に来そうな語」を高い精度で予測します。この仕組みにより、質問応答/文章要約/翻訳/プログラム生成など、幅広いタスクを一つのモデルで柔軟にこなせる点が特徴です。

chatGPT(Generative Pre-trained Transformer)では、内部でTransformerと呼ばれるニューラルネットワーク構造が用いられ、 Self-Attention機構によって文脈全体を考慮しながら処理を行うのが特徴です。

■LLMの基本構造

BPE（Byte Pair Encoding）
BPEは元々データ圧縮のために考案された手法ですが、現在では大規模言語モデルにおいて、テキストをトークンに分割するための代表的な方法として用いられています。 BPEではまず文章を文字単位に分解しコーパス全体の中で最も頻繁に出現する文字のペアを統計的に抽出します。次に、その頻出ペアを一つの新しい記号として結合し語彙に追加します。この操作を語彙数があらかじめ定めた上限に達するまで繰り返すことで、文字・語幹・単語の中間的な単位であるサブワードが自動的に生成されます。 BPEの大きな特徴は未知語が出現した場合でも必ず既存のサブワード列に分解できる点にあります。そのため辞書に依存する形態素解析とは異なり、言語や表記体系への依存が小さく、英語だけでなく日本語や記号、プログラムコードなども同一の仕組みで扱うことができます。この性質によりBPEは大規模言語モデルのトークナイザとして広く利用されています。

Embedding + positioning
Embeddingとは、単語やトークンといった離散的な記号を連続値を持つ数値ベクトルに変換する処理のことです。Embeddingの手法の一つにWord2Vecがありますが、ここではニューラルネットワークを用いて、意味的に近い値を学習できるようにします。
positioningとは、語順を考慮してベクトルに変換する処理のことで、例えば「犬が人を噛む」と「人が犬を噛む」のような語順の違いを区別できるようになります。

Self-Attention
Self-Attentionは、Transformerなどの深層学習モデルの中核を担う技術であり、「データ内の要素同士の関連性を、自分自身の中で計算し、重要な部分を強調する仕組み」です。各トークンはQuery・Key・Valueという3つのベクトルに変換され、あるトークンのQueryと、他のトークンのKeyとの類似度を計算することで重みが決まります。この重みをValueに掛け合わせて加算することで、文脈全体を考慮した新しい表現が得られます。

・Query（クエリ）：何を探しているか、どの情報に注目したいかを表す
・Key（キー）：自分がどのような情報を持っているかを示す照合用の手がかり
・Value（バリュー）：実際に受け渡される情報の中身

自己回帰型の言語モデルでは、このSelf-Attentionに加えてcausal mask（因果マスク）が用いられます。 Causal maskは、ある位置のトークンが未来のトークンを参照できないように制約をかける仕組みです。具体的には、Attentionの重みを計算する際に、未来のトークンに対応するスコアを無効化し、過去および現在のトークンのみに注意を向けさせます。これにより「これまでの文脈から次の単語を予測する」という因果的な生成構造が保たれ、自然で一貫した文章生成が可能になります。

FFN（Feed Forward Network）
FFN（Feed Forward Network）は、Self-Attentionの後に各トークンごと独立に適用される全結合ニューラルネットワークです。一般に2層構成で「線形変換 → 非線形関数（ReLUやGELU）→ 線形変換」という形を取ります。 Self-Attentionが「トークン間の関係性」を処理するのに対し、FFNは各トークンの表現を非線形に変換し、特徴をより豊かにする役割を担います。 Self-Attentionを「周囲との関係性を確認する会議」とするならば、FFNは「会議の結果を持ち帰り、自分の知識を整理・更新する個人作業」に例えられます。 Transformerでは、Self-AttentionとFFNを交互に重ねることで、「文脈の統合」と「特徴変換」を段階的に洗練させています。

■LLM理解のための最小コード

上記構造を再現したコードが以下となります。ただしBPEは含まれてません。
python Ver3.12で動作確認。

import torch
import torch.nn as nn
import torch.nn.functional as F

### Vocabulary ###
vocab = ["I", "love", "powerful", "AI", "it", "too", ""]
token_to_id = {w: i for i, w in enumerate(vocab)}
id_to_token = {i: w for w, i in token_to_id.items()}
vocab_size = len(vocab)

def encode(text):
    return torch.tensor([token_to_id[w] for w in text.split()], dtype=torch.long)

def decode(ids):
    return " ".join(id_to_token[i] for i in ids)

### Model parameters ###
d_model = 32
d_ff = 128
max_len = 32
token_embedding = nn.Embedding(vocab_size, d_model)
pos_embedding = nn.Embedding(max_len, d_model)
ln1 = nn.LayerNorm(d_model)
ln2 = nn.LayerNorm(d_model)
W_Q = nn.Linear(d_model, d_model)
W_K = nn.Linear(d_model, d_model)
W_V = nn.Linear(d_model, d_model)
ffn_1 = nn.Linear(d_model, d_ff)
ffn_2 = nn.Linear(d_ff, d_model)
lm_head = nn.Linear(d_model, vocab_size)

### GPT Forward ###
def gpt_forward(x):
    B, T = x.size()
    pos = torch.arange(T, device=x.device)
    h = token_embedding(x) + pos_embedding(pos)

    # ---- Self-Attention ----
    h_norm = ln1(h)
    Q = W_Q(h_norm)
    K = W_K(h_norm)
    V = W_V(h_norm)

    scores = (Q @ K.transpose(-2, -1)) / (d_model ** 0.5)
    causal_mask = torch.tril(torch.ones(T, T, device=x.device))
    scores = scores.masked_fill(causal_mask == 0, -1e9)
    attn = F.softmax(scores, dim=-1)
    h = h + attn @ V

    # ---- FFN ----
    h_norm = ln2(h)
    ffn_out = ffn_2(F.relu(ffn_1(h_norm)))
    h = h + ffn_out
    logits = lm_head(h)
    return logits

### Training data ###
train_sentence = "I love powerful AI I love it too "
train_ids = encode(train_sentence)
x_train = train_ids[:-1].unsqueeze(0)
y_train = train_ids[1:].unsqueeze(0)

### Optimizer & Loss ###
params = (
    list(token_embedding.parameters()) +
    list(pos_embedding.parameters()) +
    list(ln1.parameters()) +
    list(ln2.parameters()) +
    list(W_Q.parameters()) +
    list(W_K.parameters()) +
    list(W_V.parameters()) +
    list(ffn_1.parameters()) +
    list(ffn_2.parameters()) +
    list(lm_head.parameters()))

optimizer = torch.optim.Adam(params, lr=0.01)
loss_fn = nn.CrossEntropyLoss()

### Training loop ###
for epoch in range(10):
    optimizer.zero_grad()

    logits = gpt_forward(x_train)
    loss = loss_fn(logits.view(-1, vocab_size), y_train.view(-1))

    loss.backward()
    optimizer.step()

    if epoch % 50 == 0:
        print(f"epoch {epoch}, loss {loss.item():.4f}")

### Autoregressive generation ###
def generate(prompt, max_tokens=10):
    prompt_ids = encode(prompt)
    ids = prompt_ids.unsqueeze(0)

    for _ in range(max_tokens):
        logits = gpt_forward(ids)
        next_id = torch.argmax(logits[0, -1]).item()
        ids = torch.cat([ids, torch.tensor([[next_id]])], dim=1)

        if id_to_token[next_id] == "":
            break

    generated_ids = ids[0][len(prompt_ids):].tolist() # prompt 部分を除外してデコード
    return decode(generated_ids)

### Run ###
prompt = "I love powerful AI"
print("Prompt:", prompt)
print("Bot:", generate(prompt))

サブチャンネルあります。⇒ 何かのお役に立てればと