ChatGPTに文章を書かせるとき、モデルは「文章全体」をいきなり出力しているわけではありません。1トークンずつ、それまでに書いた内容だけを手がかりに、次の1語を予測することを繰り返しています。この「過去だけを見て次を当てる」という制約こそが、Transformer Decoderの設計の出発点です。
Transformer Decoderは、系列を自己回帰的に生成するためのアーキテクチャで、GPTシリーズをはじめとする大規模言語モデル（LLM）の基盤となっています。
Decoderの特徴は、Masked Self-Attentionによって未来の情報を遮断しながら、過去の文脈のみから次のトークンを予測する点にあります。この仕組みを理解しておくと、次のような場面で役に立ちます。
- GPT系モデルの挙動を追える: なぜLLMは「次の1語」を出すことしかできないのに、長い文章を一貫して書けるのかが分かる
- 翻訳・要約モデルの内部を読める: Cross-Attentionが原文のどこを見て単語を生成しているかを理解できる
本記事の内容
- Decoderの役割と自己回帰生成の仕組み
- Masked Self-Attentionの数式と必要性
- Cross-Attention（Encoder-Decoder Attention）の仕組み
- Decoder層の構成要素
- 学習時（Teacher Forcing）と推論時の違い
- 学習させたDecoderの注意パターンの可視化
- PyTorchでの完全実装
前提知識
この記事を読む前に、以下の記事を読んでおくと理解が深まります。
Decoderの役割 — 自己回帰生成
自己回帰とは、過去に生成した出力を入力として、次の出力を順次生成していく方式です。
上の図のように、「私」「は」「犬」「が」まで生成できたら、Decoderはその4トークンだけを条件に「好き」「嫌い」といった次のトークンの確率分布を計算します。文全体を一度に出すのではなく、この予測を1トークンずつ繰り返すことで文章全体を組み立てるのが自己回帰生成です。
この過程を数式にすると、文全体の確率は次のように分解できます。
$$ P(\bm{y}) = \prod_{t=1}^{T} P(y_t \mid y_1, y_2, \dots, y_{t-1}) $$
これを連鎖律（chain rule）による分解と呼びます。「文全体が正しい確率」という捉えどころのない量を、「直前までの文脈を踏まえて次の1語が正しい確率」という扱いやすい単位に分解しているわけです。この分解が成立するためには、Decoderが「過去だけ」を見て「未来」を見ない構造になっている必要があります。次にその仕組みを見ます。
Masked Self-Attentionの仕組み
なぜマスクが必要か
Decoderでは、各位置 $t$ のトークンは位置 $t+1, t+2, \dots$ の情報を参照してはいけません。推論時には未来のトークンはまだ生成されていないからです。
図は6トークンの系列に対する参照可能性を表しています。下三角（自分自身を含む過去）だけが○（参照可）で、右上の三角（未来）はすべて×（参照禁止）です。この制約があるからこそ、学習時に「未来の正解をカンニングして次を当てる」というズルができなくなり、推論時と同じ条件で学習できます。
因果マスクの数式
$$ \text{MaskedAttention}(\bm{Q}, \bm{K}, \bm{V}) = \text{softmax}\left(\frac{\bm{Q}\bm{K}^\top}{\sqrt{d_k}} + \bm{M}\right)\bm{V} $$
マスク行列 $\bm{M}$ は：
$$ M_{ij} = \begin{cases} 0 & \text{if } j \le i \\ -\infty & \text{if } j > i \end{cases} $$
$-\infty$ の位置はsoftmax後に確率0になります。
図の3×3の例で見ると、左のスコア行列に中央のマスク行列を足すことで、右のように未来を参照するマスの値が $-\infty$ に潰れます。指数関数 $e^{-\infty} = 0$ なので、softmaxを取れば該当マスの重みは厳密にゼロになります。単に大きな負の数を足すのではなく理論上の $-\infty$ を使うのは、この「確実にゼロにする」という保証を得るためです。
このマスクが実際に学習された注意パターンにどう現れるかは、後ほど実験で確認します。まずはDecoderのもう1つの特徴、Cross-Attentionを見ておきましょう。
Cross-Attention
Encoder-Decoder構造において、DecoderはEncoderの出力を参照します。
| 成分 | 由来 | 役割 |
|---|---|---|
| Query ($\bm{Q}$) | Decoderの前層出力 | 「何を知りたいか」 |
| Key ($\bm{K}$) | Encoderの最終出力 | 「どこに情報があるか」 |
| Value ($\bm{V}$) | Encoderの最終出力 | 「具体的な情報内容」 |
Self-Attentionとの決定的な違いは、QueryとKey・Valueの出どころが別の系列である点です。Masked Self-AttentionがDecoder内部だけで完結するのに対し、Cross-AttentionはDecoder側の「いま何を生成しようとしているか（Query）」と、Encoder側の「原文にはどんな情報があるか（Key・Value）」を橋渡しします。翻訳タスクなら、生成中の単語が原文のどの単語に対応するかを、このCross-Attentionが決めていることになります。
実際にどんな対応関係が学習されるのか、翻訳のイメージで見てみましょう。
英語の “I love dogs” を日本語「私は犬が好き」に訳す場面を想定した重みの例です。「犬」を生成するときは原文の “dogs” に、「好き」を生成するときは “love” に、それぞれ強く注目しています。このように、Cross-Attentionは生成する単語ごとに原文中の対応する部分を動的に探し当てる役割を担います。
3つのサブレイヤーが出そろったので、Decoder層全体の構成を整理します。
Decoder層の構成要素
各Decoderブロックは3つのサブレイヤーで構成されます：
- Masked Self-Attention
- Cross-Attention（Encoder-Decoder Attention）
- Feed-Forward Network
図のように、生成済みトークンはまずMasked Self-Attentionで「これまで自分が書いた内容」を整理し、次にCross-Attentionで「原文のどこを見るべきか」を問い合わせ、最後にFFNで各位置の表現を仕上げます。各サブレイヤーには（Encoderと同様に）残差接続とLayer Normalizationが適用されます。
EncoderとDecoderを並べて比較すると、両者の役割の違いがより明確になります。
Encoderは双方向のSelf-AttentionとFFNだけで構成されるシンプルな構造ですが、Decoderはそこに「過去だけを見るMasked Self-Attention」と「Encoderの出力を参照するCross-Attention」という2つの制約・接続が加わります。Decoderの複雑さは、すべて「自己回帰生成」という目的から要請されたものです。
理屈を積み上げてきたので、実際にDecoderを学習させて、Masked Self-Attentionが本当に因果的なパターンを学ぶのかを確認します。
学習後のMasked Self-Attentionパターンを確認する
前半4トークンがランダム、後半4トークンが前半と同じ内容の繰り返しになっている系列を使い、小さなDecoderに「次のトークンを予測する」タスクを学習させます。前半は初出のトークンなので本質的に予測不可能（チャンスレベル）ですが、後半は「4つ前と同じ」という規則を掴めれば完全に予測できるはずです。
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
torch.manual_seed(0)
rng = np.random.default_rng(0)
V = 15
class TinyDecoder(nn.Module):
def __init__(self, d=32, h=2, L=8):
super().__init__()
self.emb = nn.Embedding(V, d)
self.pos = nn.Parameter(torch.randn(1, L, d) * 0.02)
self.attn = nn.MultiheadAttention(d, h, batch_first=True)
self.norm = nn.LayerNorm(d)
self.head = nn.Linear(d, V)
def forward(self, x, need_weights=False):
L = x.size(1)
z = self.emb(x) + self.pos[:, :L]
mask = torch.triu(torch.ones(L, L, dtype=torch.bool), diagonal=1)
out, w = self.attn(z, z, z, attn_mask=mask, need_weights=need_weights, average_attn_weights=True)
z = self.norm(z + out)
return self.head(z), w
model = TinyDecoder()
opt = torch.optim.Adam(model.parameters(), lr=8e-3)
def make_batch(B=64, L=8):
# 前半4トークンはランダム(初出=予測不可能)、後半4トークンは前半の繰り返し(コピー可能)
base = torch.from_numpy(rng.integers(0, V, size=(B, L // 2))).long()
x = torch.cat([base, base], dim=1)
return x
for _ in range(1500):
x = make_batch()
logits, _ = model(x)
loss = F.cross_entropy(logits[:, :-1].reshape(-1, V), x[:, 1:].reshape(-1))
opt.zero_grad()
loss.backward()
opt.step()
model.eval()
x_test = make_batch(256)
with torch.no_grad():
logits, _ = model(x_test)
pred = logits[:, :-1].argmax(-1)
target = x_test[:, 1:]
acc_first = (pred[:, :3] == target[:, :3]).float().mean().item()
acc_second = (pred[:, 3:] == target[:, 3:]).float().mean().item()
print(f"前半(ランダム初出)精度: {acc_first:.3f}")
print(f"後半(コピー可能)精度: {acc_second:.3f}")
実行結果：
前半(ランダム初出)精度: 0.068
後半(コピー可能)精度: 1.000
前半の精度0.068は語彙数15のランダム推測（$1/15 \approx 0.067$）とほぼ一致しており、「初出のトークンは原理的に予測不可能」という予想どおりの結果です。一方、後半は精度1.000——「4つ前と同じトークンをコピーすればよい」という規則を完全に学習できています。
学習後のAttentionパターンを可視化してみましょう。
図から2つのことが読み取れます。1つ目は、右上が完全にゼロであること——因果マスクが理論どおりに機能し、未来の情報が漏れていないことが確認できます。2つ目は、後半の位置（4〜7）が、それぞれ4つ前の位置（0〜3）に強く注目していることです。学習によって、Attentionが「コピー元」を正確に探し当てるパターンを自然に獲得しています。
最後に、学習時と推論時でDecoderの動かし方が異なる点にも触れておきます。
Teacher Forcingと推論時の違い
学習時、正解の系列（教師データ）はあらかじめ全体が分かっています。このとき、1トークンずつ逐次的に予測させるのではなく、正解の系列をそのまま並列に入力し、因果マスクで未来を隠しながら全位置を1回の順伝播でまとめて処理するのが一般的です。これをTeacher Forcingと呼びます。
左の学習時は、正解トークン列をまるごと入力し、因果マスクのおかげで各位置が正しく「それより前」だけを見ながら並列に学習が進みます。右の推論時は、正解が存在しないため、生成した1トークンを次のステップの入力に足し戻すという逐次処理にならざるを得ません。学習が高速に進む一方で、推論は原理的に系列長に比例した回数のステップが必要になる——この非対称性は、DecoderベースのLLMの推論コストを理解するうえで重要なポイントです。
理論と実験がそろったので、最後にPyTorchで完全な実装を組み立てます。
PyTorchでの完全実装
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
def generate_causal_mask(size):
"""因果マスクを生成する"""
mask = torch.triu(torch.ones(size, size), diagonal=1)
mask = mask.masked_fill(mask == 1, float('-inf'))
return mask
class MaskedMultiHeadSelfAttention(nn.Module):
def __init__(self, d_model, num_heads, dropout=0.1):
super().__init__()
assert d_model % num_heads == 0
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask=None):
batch_size, seq_len, _ = x.size()
Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if mask is not None:
scores = scores + mask
attn_weights = F.softmax(scores, dim=-1)
attn_weights = self.dropout(attn_weights)
context = torch.matmul(attn_weights, V)
context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
output = self.W_o(context)
return output, attn_weights
class MultiHeadCrossAttention(nn.Module):
def __init__(self, d_model, num_heads, dropout=0.1):
super().__init__()
assert d_model % num_heads == 0
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, dec_hidden, enc_output, enc_mask=None):
batch_size, tgt_len, _ = dec_hidden.size()
src_len = enc_output.size(1)
Q = self.W_q(dec_hidden).view(batch_size, tgt_len, self.num_heads, self.d_k).transpose(1, 2)
K = self.W_k(enc_output).view(batch_size, src_len, self.num_heads, self.d_k).transpose(1, 2)
V = self.W_v(enc_output).view(batch_size, src_len, self.num_heads, self.d_k).transpose(1, 2)
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if enc_mask is not None:
scores = scores.masked_fill(enc_mask == 0, float('-inf'))
attn_weights = F.softmax(scores, dim=-1)
attn_weights = self.dropout(attn_weights)
context = torch.matmul(attn_weights, V)
context = context.transpose(1, 2).contiguous().view(batch_size, tgt_len, self.d_model)
output = self.W_o(context)
return output, attn_weights
class TransformerDecoderBlock(nn.Module):
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super().__init__()
self.masked_self_attn = MaskedMultiHeadSelfAttention(d_model, num_heads, dropout)
self.norm1 = nn.LayerNorm(d_model)
self.cross_attn = MultiHeadCrossAttention(d_model, num_heads, dropout)
self.norm2 = nn.LayerNorm(d_model)
self.ffn = nn.Sequential(
nn.Linear(d_model, d_ff), nn.ReLU(), nn.Dropout(dropout),
nn.Linear(d_ff, d_model), nn.Dropout(dropout)
)
self.norm3 = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, enc_output, tgt_mask=None, enc_mask=None):
attn_out, _ = self.masked_self_attn(x, tgt_mask)
x = self.norm1(x + self.dropout(attn_out))
cross_out, _ = self.cross_attn(x, enc_output, enc_mask)
x = self.norm2(x + self.dropout(cross_out))
ffn_out = self.ffn(x)
x = self.norm3(x + ffn_out)
return x
class PositionalEncoding(nn.Module):
def __init__(self, d_model, max_len=5000, dropout=0.1):
super().__init__()
self.dropout = nn.Dropout(dropout)
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float) * (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
self.register_buffer('pe', pe)
def forward(self, x):
x = x + self.pe[:, :x.size(1), :]
return self.dropout(x)
class TransformerDecoder(nn.Module):
def __init__(self, vocab_size, d_model=512, num_heads=8, d_ff=2048, num_layers=6, dropout=0.1, max_len=5000):
super().__init__()
self.d_model = d_model
self.embedding = nn.Embedding(vocab_size, d_model)
self.pos_encoding = PositionalEncoding(d_model, max_len, dropout)
self.layers = nn.ModuleList([
TransformerDecoderBlock(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)
])
self.output_projection = nn.Linear(d_model, vocab_size)
def forward(self, tgt, enc_output, tgt_mask=None, enc_mask=None):
x = self.embedding(tgt) * math.sqrt(self.d_model)
x = self.pos_encoding(x)
if tgt_mask is None:
tgt_mask = generate_causal_mask(tgt.size(1)).to(tgt.device)
for layer in self.layers:
x = layer(x, enc_output, tgt_mask, enc_mask)
logits = self.output_projection(x)
return logits
# 動作確認
vocab_size = 10000
d_model = 512
decoder = TransformerDecoder(vocab_size=vocab_size, d_model=d_model)
tgt = torch.randint(0, vocab_size, (2, 15))
enc_output = torch.randn(2, 20, d_model) # Encoder側の出力を模したダミーデータ
logits = decoder(tgt, enc_output)
print(f"Decoder入力形状: {tgt.shape}")
print(f"Encoder出力形状: {enc_output.shape}")
print(f"出力形状: {logits.shape}")
実行結果：
Decoder入力形状: torch.Size([2, 15])
Encoder出力形状: torch.Size([2, 20, 512])
出力形状: torch.Size([2, 15, 10000])
Decoder側の系列長は15、Encoder側は20と異なっていても問題なく動きます。Cross-Attentionでは Query が Decoder（長さ15）、Key・Value が Encoder（長さ20）由来なので、両者の系列長が一致している必要がないことが、この動作確認からも分かります。最終的な出力形状 (2, 15, 10000) は「各位置・各語彙に対するスコア」で、これをsoftmaxに通せば次トークンの確率分布になります。
まとめ
本記事では、Transformer Decoderの構造とMasked Self-Attentionの仕組みについて解説しました。
- 自己回帰生成: Decoderは連鎖律に基づき、過去のトークンを条件として次のトークンの確率分布を予測する
- Masked Self-Attention: 因果マスクにより未来の情報を遮断し、学習時でも並列計算を可能にする。$-\infty$ を加算することでsoftmax後に確実にゼロにする仕組み
- Cross-Attention: Encoder-Decoder構造において、DecoderがEncoderの出力を参照するための機構。QueryはDecoder側、Key・ValueはEncoder側から来る
- Decoder層の構成: Masked Self-Attention、Cross-Attention、FFNの3つのサブレイヤー
- 学習実験: 前半ランダム・後半コピー可能な系列で学習させたところ、前半はチャンスレベル（0.068）、後半は完全（1.000）の精度を達成し、因果マスクが理論どおり機能していることを確認した
- Teacher Forcingと推論の非対称性: 学習時は正解を並列に処理できるが、推論時は1トークンずつ逐次生成せざるを得ない
次のステップとして、以下の記事も参考にしてください。