PyTorchでChatGPTライクなTransformerを自作する方法

近年、自然言語処理（NLP）の分野で大きな注目を集める技術の一つが「Transformer」です。特に、その中でもOpenAIのChatGPTは多くの人々に衝撃を与えました。この記事では、PyTorchを用いてこのようなChatGPTライクなTransformerモデルを一歩ずつ構築していく方法を解説します。

必要なライブラリ

まず初めに、使用するライブラリをインポートします。

import torch
import torch.nn as nn
import torch.optim as optim

データ準備

次に、データセットの準備です。ここでは簡単な例としてテキストデータを使用します。

data = [
    "こんにちは",
    "お元気ですか？",
    "私は元気です"
]

# トークン化とボキャブラリの構築
tokenizer = {word: i for i, word in enumerate(set(" ".join(data).split()))}
vocab_size = len(tokenizer)

モデル構築

エンコーダーとデコーダーの定義

エンコーダーとデコーダーはTransformerモデルの基本的なブロックです。

class TransformerModel(nn.Module):
    def __init__(self, vocab_size, d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6):
        super(TransformerModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.transformer = nn.Transformer(d_model=d_model,
                                          nhead=nhead,
                                          num_encoder_layers=num_encoder_layers,
                                          num_decoder_layers=num_decoder_layers)
        self.fc_out = nn.Linear(d_model, vocab_size)

    def forward(self, src, tgt):
        src_emb = self.embedding(src) * math.sqrt(d_model)
        tgt_emb = self.embedding(tgt) * math.sqrt(d_model)

        src_mask = tgt_mask = None  # マスクなしの場合

        output = self.transformer(src_emb.transpose(0, 1), tgt_emb.transpose(0, 1),
                                  src_key_padding_mask=src_mask,
                                  tgt_key_padding_mask=tgt_mask).transpose(0, 1)

        return self.fc_out(output)

損失関数とオプティマイザ

model = TransformerModel(vocab_size=vocab_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.0001)

学習プロセス

学習ループでは、入力シーケンスとターゲットシーケンス間の損失計算とバックプロパゲーションが行われます。

for epoch in range(num_epochs):
    model.train()
    total_loss = 0

    for src_seq, tgt_seq in data:
        optimizer.zero_grad()

        src_tensor = torch.tensor([tokenizer[word] for word in src_seq.split()]).unsqueeze(0)
        tgt_tensor_minus_last_token_inputs_only_for_training_purposes_only_tgt_tensor_minus_last_token_inputs_only_for_training_purposes_only_tgt_tensor_minus_last_token_inputs_only_for_training_purposes_only_tgt_tensor_minus_last_token_inputs_only_for_training_purposes_only_tgt_tensor_minus_last_token_inputs_only_for_training_purposes_ouputs=torch.tensor([tokenizer[word] for word in (tgt_seq + ' <eos>').split()[:-1]]).unsqueeze(0)

tgt_output_target=torch.tensor([tokenizer[word] for word in ('<sos> ' + tgt_seq).split()[1:]]).unsqueeze(0)

output=model(src_tensor,tgttensorminuslasttokeninputs onlyfortrainingpurposesonlytgttensorminuslasttokeninputs onlyfortrainingpurposesonlytgttensorminuslasttokeninputs onlyfortrainingpurposesonlytgttensorminuslasttokeninputs onlyfortrainingpurposesonlytgttensorminuslasttokeninputs onlyfortrainingpurposesoutputs)

loss=criterion(output.view(-1,vocabsize),tgtoutputtarget.view(-1))

loss.backward()

optimizer.step()

totalloss+=loss.item()

print(f"Epoch{epoch+1}/{numepochs},Loss:{totalloss/len(data)}")