PyTorch 2.0 チュートリアル : テキスト : nn.Transformer と TorchText による言語モデリング (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/06/2023 (2.0.0)
* 本ページは、PyTorch 2.0 Tutorials の以下のページを翻訳した上で適宜、補足説明したものです：
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。
クラスキャット 人工知能 研究開発支援サービス
◆ クラスキャット は人工知能・テレワークに関する各種サービスを提供しています。お気軽にご相談ください :
- 人工知能研究開発支援
- 人工知能研修サービス(経営者層向けオンサイト研修)
- テクニカルコンサルティングサービス
- 実証実験(プロトタイプ構築)
- アプリケーションへの実装
- 人工知能研修サービス
- PoC(概念実証)を失敗させないための支援
◆ 人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。スケジュール。
- お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
◆ お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。
- 株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
- sales-info@classcat.com ; Website: www.classcat.com ; ClassCatJP
PyTorch 2.0 チュートリアル : テキスト : nn.Transformer と TorchText による言語モデリング
これは nn.Transformer モジュールを使用する sequence-to-sequence モデルをどのように訓練するかについてのチュートリアルです。
PyTorch 1.2 リリースはペーパー Attention is All You Need に基づく標準的な transformer モジュールを含みます。transformer モデルはより並列化可能である一方で多くの sequence-to-sequence 問題のために質的に優れていることが証明されています。nn.Transformer モジュールは入力と出力間のグローバルな依存性を引き出すためにアテンション・メカニズム (もう一つのモジュールは nn.MultiheadAttention として最近実装されました) に完全に依存しています。nn.Transformer モジュールは今では高度にモジュール化されています、その結果 (このチュートリアルの nn.TransformerEncoder のような) 単一のコンポーネントが容易に適合/構成できます。
モデルを定義する
このチュートリアルでは、言語モデリング・タスク上で nn.TransformerEncoder モデルを訓練します。言語モデリング・タスクは単語のシークエンスに続く与えられた単語 (or 単語のシークエンス) の尤度の確率を割り当てます。トークンのシークエンスが最初に埋め込み層に渡されて、単語の順序を説明するための位置エンコーディング層が続きます (詳細については次のパラグラフを見てください)。nn.TransformerEncoder は nn.TransformerEncoderLayer の複数の層から成ります。入力シークエンスとともに、square アテンション・マスクが必要です、何故ならば nn.TransformerEncoder の self アテンション層はシークエンスの早い位置に注意を向けることが可能にされるだけだからです。言語モデリング・タスクのためには、未来の位置 (= future position) 上の任意のトークンはマスクされるべきです。実際の単語を持つために、nn.TransformerEncoder モデルの出力は最後の線形層に送られ、これに log-Softmax 関数が続きます。
import math
import os
from tempfile import TemporaryDirectory
from typing import Tuple
import torch
from torch import nn, Tensor
import torch.nn.functional as F
from torch.nn import TransformerEncoder, TransformerEncoderLayer
from torch.utils.data import dataset
class TransformerModel(nn.Module):
def __init__(self, ntoken: int, d_model: int, nhead: int, d_hid: int,
nlayers: int, dropout: float = 0.5):
super().__init__()
self.model_type = 'Transformer'
self.pos_encoder = PositionalEncoding(d_model, dropout)
encoder_layers = TransformerEncoderLayer(d_model, nhead, d_hid, dropout)
self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)
self.encoder = nn.Embedding(ntoken, d_model)
self.d_model = d_model
self.decoder = nn.Linear(d_model, ntoken)
self.init_weights()
def init_weights(self) -> None:
initrange = 0.1
self.encoder.weight.data.uniform_(-initrange, initrange)
self.decoder.bias.data.zero_()
self.decoder.weight.data.uniform_(-initrange, initrange)
def forward(self, src: Tensor, src_mask: Tensor) -> Tensor:
"""
Arguments:
src: Tensor, shape ``[seq_len, batch_size]``
src_mask: Tensor, shape ``[seq_len, seq_len]``
Returns:
output Tensor of shape ``[seq_len, batch_size, ntoken]``
"""
src = self.encoder(src) * math.sqrt(self.d_model)
src = self.pos_encoder(src)
output = self.transformer_encoder(src, src_mask)
output = self.decoder(output)
return output
def generate_square_subsequent_mask(sz: int) -> Tensor:
"""Generates an upper-triangular matrix of ``-inf``, with zeros on ``diag``."""
return torch.triu(torch.ones(sz, sz) * float('-inf'), diagonal=1)
PositionalEncoding モジュールはシークエンスのトークンの相対的あるいは絶対的位置についてのある情報を注入します。位置エンコーディングは埋め込みと同じ次元を持ちますので、二つは合計できます。ここでは、異なる頻度のサインとコサイン関数を使用します。
class PositionalEncoding(nn.Module):
def __init__(self, d_model: int, dropout: float = 0.1, max_len: int = 5000):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
position = torch.arange(max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
pe = torch.zeros(max_len, 1, d_model)
pe[:, 0, 0::2] = torch.sin(position * div_term)
pe[:, 0, 1::2] = torch.cos(position * div_term)
self.register_buffer('pe', pe)
def forward(self, x: Tensor) -> Tensor:
"""
Arguments:
x: Tensor, shape ``[seq_len, batch_size, embedding_dim]``
"""
x = x + self.pe[:x.size(0)]
return self.dropout(x)
データをロードしてバッチ処理する
このチュートリアルは Wikitext-2 データセットを生成するために torchtext を利用します。torchtext データセットにアクセスするため、https://github.com/pytorch/data の手順に従って torchdata をインストールしてください。
%%bash
pip install torchdata
vocab オブジェクトは訓練データセットに基づいて構築されてトークンをテンソルに数値化するために使用されます。Wikitext-2 は rare トークンを <unk> として表します。
1-D ベクトルのシーケンシャルデータが与えられたとき、batchify() はデータを batch_size カラムに配置します。データが batch_size カラムに分割されない場合にはデータは収まるようにトリムされます。例えば、データとしてのアルファベット (26 の合計長) と batch_size=4 により、アルファベットを長さ 6 の 4 シークエンスに分割するでしょう :
\[
\begin{split}\begin{bmatrix}
\text{A} & \text{B} & \text{C} & \ldots & \text{X} & \text{Y} & \text{Z}
\end{bmatrix}
\Rightarrow
\begin{bmatrix}
\begin{bmatrix}\text{A} \\ \text{B} \\ \text{C} \\ \text{D} \\ \text{E} \\ \text{F}\end{bmatrix} &
\begin{bmatrix}\text{G} \\ \text{H} \\ \text{I} \\ \text{J} \\ \text{K} \\ \text{L}\end{bmatrix} &
\begin{bmatrix}\text{M} \\ \text{N} \\ \text{O} \\ \text{P} \\ \text{Q} \\ \text{R}\end{bmatrix} &
\begin{bmatrix}\text{S} \\ \text{T} \\ \text{U} \\ \text{V} \\ \text{W} \\ \text{X}\end{bmatrix}
\end{bmatrix}\end{split}
\]
バッチ処理はより並列化可能な処理を有効にします。けれども、バッチ処理はモデルが各カラムを独立に扱うことを意味します ; 例えば、上の例では G と F の依存性は学習できません。
from torchtext.datasets import WikiText2
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
train_iter = WikiText2(split='train')
tokenizer = get_tokenizer('basic_english')
vocab = build_vocab_from_iterator(map(tokenizer, train_iter), specials=[''])
vocab.set_default_index(vocab[''])
def data_process(raw_text_iter: dataset.IterableDataset) -> Tensor:
"""Converts raw text into a flat Tensor."""
data = [torch.tensor(vocab(tokenizer(item)), dtype=torch.long) for item in raw_text_iter]
return torch.cat(tuple(filter(lambda t: t.numel() > 0, data)))
# ``train_iter`` was "consumed" by the process of building the vocab,
# so we have to create it again
train_iter, val_iter, test_iter = WikiText2()
train_data = data_process(train_iter)
val_data = data_process(val_iter)
test_data = data_process(test_iter)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
def batchify(data: Tensor, bsz: int) -> Tensor:
"""Divides the data into ``bsz`` separate sequences, removing extra elements
that wouldn't cleanly fit.
Arguments:
data: Tensor, shape [N]
bsz: int, batch size
Returns:
Tensor of shape ``[N // bsz, bsz]``
"""
seq_len = data.size(0) // bsz
data = data[:seq_len * bsz]
data = data.view(bsz, seq_len).t().contiguous()
return data.to(device)
batch_size = 20
eval_batch_size = 10
train_data = batchify(train_data, batch_size) # shape ``[seq_len, batch_size]``
val_data = batchify(val_data, eval_batch_size)
test_data = batchify(test_data, eval_batch_size)
入力とターゲット・シークエンスを生成する関数
get_batch() 関数は transformer モデルのために入力とターゲット・シークエンスを生成します。それはソースデータを長さ bptt のチャンクに部分分割します。言語モデリング・タスクのためには、モデルは Target として次の単語を必要とします。例えば、2 の bptt 値で、i = 0 のために次の 2 つの Variable を得るでしょう :
チャンクは次元 0 に沿い、Transformer モデルの S 次元と一貫していることは注意されるべきでしょう。バッチ次元 N は次元 1 に沿います。
bptt = 35
def get_batch(source: Tensor, i: int) -> Tuple[Tensor, Tensor]:
"""
Args:
source: Tensor, shape ``[full_seq_len, batch_size]``
i: int
Returns:
tuple (data, target), where data has shape ``[seq_len, batch_size]`` and
target has shape ``[seq_len * batch_size]``
"""
seq_len = min(bptt, len(source) - 1 - i)
data = source[i:i+seq_len]
target = source[i+1:i+1+seq_len].reshape(-1)
return data, target
インスタンスを初期化する
モデルは下のハイパーパラメータでセットアップされます。vocab サイズは vocab オブジェクトの長さに等しいです。
ntokens = len(vocab) # size of vocabulary
emsize = 200 # embedding dimension
d_hid = 200 # dimension of the feedforward network model in ``nn.TransformerEncoder``
nlayers = 2 # number of ``nn.TransformerEncoderLayer`` in ``nn.TransformerEncoder``
nhead = 2 # number of heads in ``nn.MultiheadAttention``
dropout = 0.2 # dropout probability
model = TransformerModel(ntokens, emsize, nhead, d_hid, nlayers, dropout).to(device)
モデルを実行する
CrossEntropyLoss は損失を追跡するために適用されて SGD は optimizer として確率的勾配降下法を実装しています。初期学習率は 5.0 に設定されます。StepLR はエポックを通して学習率を調整するために適用されます。訓練の間、(勾配) 爆発を防ぐために総ての勾配を一緒にスケールするために nn.utils.clip_grad_norm_ 関数を使用します。
import copy
import time
criterion = nn.CrossEntropyLoss()
lr = 5.0 # learning rate
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.95)
def train(model: nn.Module) -> None:
model.train() # turn on train mode
total_loss = 0.
log_interval = 200
start_time = time.time()
src_mask = generate_square_subsequent_mask(bptt).to(device)
num_batches = len(train_data) // bptt
for batch, i in enumerate(range(0, train_data.size(0) - 1, bptt)):
data, targets = get_batch(train_data, i)
seq_len = data.size(0)
if seq_len != bptt: # only on last batch
src_mask = src_mask[:seq_len, :seq_len]
output = model(data, src_mask)
loss = criterion(output.view(-1, ntokens), targets)
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
total_loss += loss.item()
if batch % log_interval == 0 and batch > 0:
lr = scheduler.get_last_lr()[0]
ms_per_batch = (time.time() - start_time) * 1000 / log_interval
cur_loss = total_loss / log_interval
ppl = math.exp(cur_loss)
print(f'| epoch {epoch:3d} | {batch:5d}/{num_batches:5d} batches | '
f'lr {lr:02.2f} | ms/batch {ms_per_batch:5.2f} | '
f'loss {cur_loss:5.2f} | ppl {ppl:8.2f}')
total_loss = 0
start_time = time.time()
def evaluate(model: nn.Module, eval_data: Tensor) -> float:
model.eval() # turn on evaluation mode
total_loss = 0.
src_mask = generate_square_subsequent_mask(bptt).to(device)
with torch.no_grad():
for i in range(0, eval_data.size(0) - 1, bptt):
data, targets = get_batch(eval_data, i)
seq_len = data.size(0)
if seq_len != bptt:
src_mask = src_mask[:seq_len, :seq_len]
output = model(data, src_mask)
output_flat = output.view(-1, ntokens)
total_loss += seq_len * criterion(output_flat, targets).item()
return total_loss / (len(eval_data) - 1)
エポックに渡りループします。検証損失がそこまでに見た最善であればモデルをセーブします。各エポックの後学習率を調整します。
best_val_loss = float('inf')
epochs = 3
with TemporaryDirectory() as tempdir:
best_model_params_path = os.path.join(tempdir, "best_model_params.pt")
for epoch in range(1, epochs + 1):
epoch_start_time = time.time()
train(model)
val_loss = evaluate(model, val_data)
val_ppl = math.exp(val_loss)
elapsed = time.time() - epoch_start_time
print('-' * 89)
print(f'| end of epoch {epoch:3d} | time: {elapsed:5.2f}s | '
f'valid loss {val_loss:5.2f} | valid ppl {val_ppl:8.2f}')
print('-' * 89)
if val_loss < best_val_loss:
best_val_loss = val_loss
torch.save(model.state_dict(), best_model_params_path)
scheduler.step()
model.load_state_dict(torch.load(best_model_params_path)) # load best model states
| epoch 1 | 200/ 2928 batches | lr 5.00 | ms/batch 32.09 | loss 8.14 | ppl 3414.90 | epoch 1 | 400/ 2928 batches | lr 5.00 | ms/batch 22.55 | loss 6.89 | ppl 982.17 | epoch 1 | 600/ 2928 batches | lr 5.00 | ms/batch 22.46 | loss 6.46 | ppl 636.76 | epoch 1 | 800/ 2928 batches | lr 5.00 | ms/batch 22.48 | loss 6.31 | ppl 551.13 | epoch 1 | 1000/ 2928 batches | lr 5.00 | ms/batch 22.46 | loss 6.19 | ppl 487.25 | epoch 1 | 1200/ 2928 batches | lr 5.00 | ms/batch 22.49 | loss 6.16 | ppl 473.84 | epoch 1 | 1400/ 2928 batches | lr 5.00 | ms/batch 22.50 | loss 6.11 | ppl 452.44 | epoch 1 | 1600/ 2928 batches | lr 5.00 | ms/batch 22.43 | loss 6.11 | ppl 448.87 | epoch 1 | 1800/ 2928 batches | lr 5.00 | ms/batch 22.46 | loss 6.02 | ppl 412.61 | epoch 1 | 2000/ 2928 batches | lr 5.00 | ms/batch 22.45 | loss 6.02 | ppl 412.27 | epoch 1 | 2200/ 2928 batches | lr 5.00 | ms/batch 22.47 | loss 5.90 | ppl 364.23 | epoch 1 | 2400/ 2928 batches | lr 5.00 | ms/batch 22.46 | loss 5.97 | ppl 390.13 | epoch 1 | 2600/ 2928 batches | lr 5.00 | ms/batch 22.43 | loss 5.95 | ppl 385.20 | epoch 1 | 2800/ 2928 batches | lr 5.00 | ms/batch 22.44 | loss 5.88 | ppl 358.13 ----------------------------------------------------------------------------------------- | end of epoch 1 | time: 71.08s | valid loss 5.83 | valid ppl 339.86 ----------------------------------------------------------------------------------------- | epoch 2 | 200/ 2928 batches | lr 4.75 | ms/batch 22.63 | loss 5.87 | ppl 354.27 | epoch 2 | 400/ 2928 batches | lr 4.75 | ms/batch 22.53 | loss 5.86 | ppl 351.00 | epoch 2 | 600/ 2928 batches | lr 4.75 | ms/batch 22.51 | loss 5.68 | ppl 292.09 | epoch 2 | 800/ 2928 batches | lr 4.75 | ms/batch 22.53 | loss 5.71 | ppl 302.11 | epoch 2 | 1000/ 2928 batches | lr 4.75 | ms/batch 22.52 | loss 5.66 | ppl 287.92 | epoch 2 | 1200/ 2928 batches | lr 4.75 | ms/batch 22.50 | loss 5.69 | ppl 296.40 | epoch 2 | 1400/ 2928 batches | lr 4.75 | ms/batch 22.48 | loss 5.69 | ppl 296.61 | epoch 2 | 1600/ 2928 batches | lr 4.75 | ms/batch 22.47 | loss 5.72 | ppl 304.91 | epoch 2 | 1800/ 2928 batches | lr 4.75 | ms/batch 22.47 | loss 5.66 | ppl 286.45 | epoch 2 | 2000/ 2928 batches | lr 4.75 | ms/batch 22.48 | loss 5.68 | ppl 292.04 | epoch 2 | 2200/ 2928 batches | lr 4.75 | ms/batch 22.48 | loss 5.56 | ppl 260.02 | epoch 2 | 2400/ 2928 batches | lr 4.75 | ms/batch 22.52 | loss 5.66 | ppl 286.56 | epoch 2 | 2600/ 2928 batches | lr 4.75 | ms/batch 22.48 | loss 5.66 | ppl 285.89 | epoch 2 | 2800/ 2928 batches | lr 4.75 | ms/batch 22.51 | loss 5.59 | ppl 267.81 ----------------------------------------------------------------------------------------- | end of epoch 2 | time: 69.29s | valid loss 5.70 | valid ppl 299.63 ----------------------------------------------------------------------------------------- | epoch 3 | 200/ 2928 batches | lr 4.51 | ms/batch 22.59 | loss 5.61 | ppl 273.72 | epoch 3 | 400/ 2928 batches | lr 4.51 | ms/batch 22.51 | loss 5.63 | ppl 278.01 | epoch 3 | 600/ 2928 batches | lr 4.51 | ms/batch 22.44 | loss 5.44 | ppl 230.66 | epoch 3 | 800/ 2928 batches | lr 4.51 | ms/batch 22.26 | loss 5.49 | ppl 243.19 | epoch 3 | 1000/ 2928 batches | lr 4.51 | ms/batch 22.60 | loss 5.45 | ppl 232.38 | epoch 3 | 1200/ 2928 batches | lr 4.51 | ms/batch 22.56 | loss 5.49 | ppl 241.39 | epoch 3 | 1400/ 2928 batches | lr 4.51 | ms/batch 22.55 | loss 5.51 | ppl 246.10 | epoch 3 | 1600/ 2928 batches | lr 4.51 | ms/batch 22.53 | loss 5.53 | ppl 253.09 | epoch 3 | 1800/ 2928 batches | lr 4.51 | ms/batch 22.51 | loss 5.48 | ppl 239.64 | epoch 3 | 2000/ 2928 batches | lr 4.51 | ms/batch 22.53 | loss 5.50 | ppl 243.55 | epoch 3 | 2200/ 2928 batches | lr 4.51 | ms/batch 22.51 | loss 5.37 | ppl 214.97 | epoch 3 | 2400/ 2928 batches | lr 4.51 | ms/batch 22.49 | loss 5.47 | ppl 238.53 | epoch 3 | 2600/ 2928 batches | lr 4.51 | ms/batch 22.50 | loss 5.48 | ppl 240.65 | epoch 3 | 2800/ 2928 batches | lr 4.51 | ms/batch 22.51 | loss 5.42 | ppl 226.05 ----------------------------------------------------------------------------------------- | end of epoch 3 | time: 69.28s | valid loss 5.63 | valid ppl 278.84 -----------------------------------------------------------------------------------------
モデルをテストデータセットで評価する
テストデータセットで結果を確認するためにベストモデルを適用します。
test_loss = evaluate(model, test_data)
test_ppl = math.exp(test_loss)
print('=' * 89)
print(f'| End of training | test loss {test_loss:5.2f} | '
f'test ppl {test_ppl:8.2f}')
print('=' * 89)
========================================================================================= | End of training | test loss 5.54 | test ppl 255.35 =========================================================================================
以上