PyTorch 2.0 チュートリアル : テキスト : 文字レベル RNN で名前を生成する (翻訳/解説)

翻訳 : (株)クラスキャットセールスインフォメーション
作成日時 : 05/13/2023 (2.0.0)

* 本ページは、PyTorch 2.0 Tutorials の以下のページを翻訳した上で適宜、補足説明したものです：

Text : NLP From Scratch: Generating Names with a Character-Level RNN

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

クラスキャット人工知能研究開発支援サービス

◆ クラスキャットは人工知能・テレワークに関する各種サービスを提供しています。お気軽にご相談ください :

人工知能研究開発支援
1. 人工知能研修サービス(経営者層向けオンサイト研修)
2. テクニカルコンサルティングサービス
3. 実証実験(プロトタイプ構築)
4. アプリケーションへの実装
人工知能研修サービス
PoC(概念実証)を失敗させないための支援

◆ 人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。スケジュール。

お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。

◆ お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部セールス・インフォメーション
sales-info@classcat.com ; Website: www.classcat.com ; ClassCatJP

PyTorch 2.0 チュートリアル : テキスト : 文字レベル RNN で名前を生成する

これは「スクラッチからの NLP」の 3 つのチュートリアルの 2 番目です。最初のチュートリアルで名前をそれらの元の言語に分類するために RNN を利用しました。今回は逆向きに言語から名前を生成します。

> python sample.py Russian RUS
Rovakov
Uantov
Shavakov

> python sample.py German GER
Gerren
Ereng
Rosher

> python sample.py Spanish SPA
Salla
Parer
Allan

> python sample.py Chinese CHI
Chan
Hang
Iun

私達は依然として 2, 3 の線形層を持つ小さい RNN を手作業で作成していきます。大きな違いは名前の総ての文字を読み込んだ後にカテゴリーを予測する代わりに、カテゴリーを入力して一度に一つの文字を出力します。言語を形成するために文字群をリカレントに予測することは (これはまた単語や他の高次の構成物でも成されます) しばしば「言語モデル」として言及されます。

推奨 Reading:

RNN について、そしてそれらがどのように動作するかを知ることもまた有用でしょう :

The Unreasonable Effectiveness of Recurrent Neural Networks は多くの現実世界のサンプルを示します。
Understanding LSTM Networks は特に LSTM についてのものですが一般の RNN についても参考になります。

データを準備する

NOTE: ここからデータをダウンロードしてそれを current ディレクトリに展開してください。

このプロセスのより多くの詳細は最後のチュートリアルを見てください。簡潔に言えば、行毎に名前を持つプレーン・テキストファイル data/names/[Language].txt が数多くあります。行を配列に分割して、Unicode を ASCII に変換し、そして辞書 {language: [names …]} で終わりです。

from __future__ import unicode_literals, print_function, division
from io import open
import glob
import os
import unicodedata
import string

all_letters = string.ascii_letters + " .,;'-"
n_letters = len(all_letters) + 1 # Plus EOS marker

def findFiles(path): return glob.glob(path)

# Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
        and c in all_letters
    )

# Read a file and split into lines
def readLines(filename):
    with open(filename, encoding='utf-8') as some_file:
        return [unicodeToAscii(line.strip()) for line in some_file]

# Build the category_lines dictionary, a list of lines per category
category_lines = {}
all_categories = []
for filename in findFiles('data/names/*.txt'):
    category = os.path.splitext(os.path.basename(filename))[0]
    all_categories.append(category)
    lines = readLines(filename)
    category_lines[category] = lines

n_categories = len(all_categories)

if n_categories == 0:
    raise RuntimeError('Data not found. Make sure that you downloaded data '
        'from https://download.pytorch.org/tutorial/data.zip and extract it to '
        'the current directory.')

print('# categories:', n_categories, all_categories)
print(unicodeToAscii("O'Néàl"))

# categories: 18 ['Czech', 'German', 'Portuguese', 'Russian', 'Irish', 'French', 'Korean', 'Arabic', 'Vietnamese', 'Italian', 'Japanese', 'English', 'Polish', 'Scottish', 'Chinese', 'Dutch', 'Greek', 'Spanish']
O'Neal

ネットワークの作成

このネットワークは最後のチュートリアルの RNN をカテゴリー tensor のための追加の引数で拡張します、これは他のものと一緒に結合されます。カテゴリー tensor はちょうど文字入力のような one-hot ベクトルです。

出力を次の文字の確率として解釈します。サンプリングするとき、最も尤もらしい出力文字が次の入力文字として使用されます。

作業するためのより多くの筋肉をそれに与えるために (hidden と output を結合した後) 2 番目の線形層 o2o を追加しました。dropout 層もまたあります、これは与えられた確率 (ここでは 0.1) でその入力の一部をランダムにゼロにしてそして通常は overfitting を回避するために入力を曖昧にする (= fuzz) ために使用されます。ここでは何某かのカオスを与えてサンプリングの多様性を増すという意図でネットワークの最後の方に向けてそれを使用しています。

import torch
import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size

        self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)
        self.o2o = nn.Linear(hidden_size + output_size, output_size)
        self.dropout = nn.Dropout(0.1)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, category, input, hidden):
        input_combined = torch.cat((category, input, hidden), 1)
        hidden = self.i2h(input_combined)
        output = self.i2o(input_combined)
        output_combined = torch.cat((hidden, output), 1)
        output = self.o2o(output_combined)
        output = self.dropout(output)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        return torch.zeros(1, self.hidden_size)

訓練

訓練のための準備

まず最初に、(category, line) のランダムなペアを得るためのヘルパー関数です :

import random

# Random item from a list
def randomChoice(l):
    return l[random.randint(0, len(l) - 1)]

# Get a random category and random line from that category
def randomTrainingPair():
    category = randomChoice(all_categories)
    line = randomChoice(category_lines[category])
    return category, line

各時間ステップについて (つまり、訓練単語の各文字について)、ネットワークの入力は (category, current letter, hidden state) で出力は (next letter, next hidden state) です。そして各訓練セットのために、カテゴリー、入力文字のセット、そして出力/ターゲット文字のセットが必要となります。

各時間ステップについて現在の文字から次の文字を予測していますので、文字ペアは行からの連続する文字のグループです – e.g. “ABCD<EOS>” のためには (“A”, “B”), (“B”, “C”), (“C”, “D”), (“D”, “EOS”) を作成します。

category tensor はサイズ <1 x n_categories> の one-hot tensor です。訓練のときそれを総ての時間ステップでネットワークに供給します – これは設計上の選択です、それは初期隠れ状態か何か他のストラテジーの一部として含まれることもあるでしょう。

# One-hot vector for category
def categoryTensor(category):
    li = all_categories.index(category)
    tensor = torch.zeros(1, n_categories)
    tensor[0][li] = 1
    return tensor

# One-hot matrix of first to last letters (not including EOS) for input
def inputTensor(line):
    tensor = torch.zeros(len(line), 1, n_letters)
    for li in range(len(line)):
        letter = line[li]
        tensor[li][0][all_letters.find(letter)] = 1
    return tensor

# ``LongTensor`` of second letter to end (EOS) for target
def targetTensor(line):
    letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
    letter_indexes.append(n_letters - 1) # EOS
    return torch.LongTensor(letter_indexes)

訓練の間の便利のために randomTrainingExample 関数を作成します、これはランダムな (category, line) ペアを取得してそれらを要求される (category, input, target) tensor に変えます。

# Make category, input, and target tensors from a random category, line pair
def randomTrainingExample():
    category, line = randomTrainingPair()
    category_tensor = categoryTensor(category)
    input_line_tensor = inputTensor(line)
    target_line_tensor = targetTensor(line)
    return category_tensor, input_line_tensor, target_line_tensor

ネットワークの訓練

分類と対照的に、そこ (= 分類) では最後の出力だけが使用されましたが、私達は総てのステップで予測を行ないますので、総てのステップで損失を計算します。

autograd のマジックは各ステップでこれらの損失を単純に総計して最後に backward を呼び出すことを可能にします。

criterion = nn.NLLLoss()

learning_rate = 0.0005

def train(category_tensor, input_line_tensor, target_line_tensor):
    target_line_tensor.unsqueeze_(-1)
    hidden = rnn.initHidden()

    rnn.zero_grad()

    loss = 0

    for i in range(input_line_tensor.size(0)):
        output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
        l = criterion(output, target_line_tensor[i])
        loss += l

    loss.backward()

    for p in rnn.parameters():
        p.data.add_(p.grad.data, alpha=-learning_rate)

    return output, loss.item() / input_line_tensor.size(0)

訓練にどれくらい時間がかかるかを追跡するために timeSince(timestamp) 関数を追加しています、これは可読な文字列を返します :

import time
import math

def timeSince(since):
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

訓練は通常どおりの業務です – train を多くの回数呼び出して数分待ちます、print_every サンプル毎に現在時間と損失をプリントし、そして後のプロットのために plot_every サンプル毎の平均損失を all_losses にストアし続けます。

rnn = RNN(n_letters, 128, n_letters)

n_iters = 100000
print_every = 5000
plot_every = 500
all_losses = []
total_loss = 0 # Reset every ``plot_every`` ``iters``

start = time.time()

for iter in range(1, n_iters + 1):
    output, loss = train(*randomTrainingExample())
    total_loss += loss

    if iter % print_every == 0:
        print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / n_iters * 100, loss))

    if iter % plot_every == 0:
        all_losses.append(total_loss / plot_every)
        total_loss = 0

0m 13s (5000 5%) 2.8802
0m 26s (10000 10%) 2.8005
0m 39s (15000 15%) 3.3497
0m 52s (20000 20%) 2.0206
1m 4s (25000 25%) 1.9599
1m 17s (30000 30%) 2.3262
1m 31s (35000 35%) 3.3881
1m 44s (40000 40%) 2.1892
1m 57s (45000 45%) 3.0495
2m 10s (50000 50%) 3.1471
2m 23s (55000 55%) 2.1117
2m 36s (60000 60%) 2.5022
2m 49s (65000 65%) 2.2291
3m 1s (70000 70%) 1.9965
3m 14s (75000 75%) 3.4519
3m 27s (80000 80%) 1.7528
3m 40s (85000 85%) 2.8783
3m 53s (90000 90%) 2.3355
4m 6s (95000 95%) 2.1986
4m 19s (100000 100%) 2.2244

損失のプロット

all_losses からの履歴損失のプロットはネットワーク学習を示します :

import matplotlib.pyplot as plt

plt.figure()
plt.plot(all_losses)

ネットワークのサンプリング

サンプリングするためにネットワークに文字を与えて次の一つが何であるかを尋ねます、それを次の文字として供給し、そして EOS トークンまで反復します。

入力カテゴリー、開始文字、そして空の隠れ状態のための tensor を作成します
開始文字で文字列 output_name を作成します
最大の出力長まで、
- 現在の文字をネットワークに供給する
- 最も高い出力から次の文字、そして次の隠れ状態を得ます
- 文字が EOS である場合、ここで停止します
- 標準文字であれば、output_name に追加してそして続けます
最後の名前を返します

Note: 開始文字をそれに与えなければならない代わりに、もう一つの他のストラテジーは訓練で「文字列の開始」トークンを含めるとしてそしてネットワークにそれ自身の開始文字を選択させることでしょう。

max_length = 20

# Sample from a category and starting letter
def sample(category, start_letter='A'):
    with torch.no_grad():  # no need to track history in sampling
        category_tensor = categoryTensor(category)
        input = inputTensor(start_letter)
        hidden = rnn.initHidden()

        output_name = start_letter

        for i in range(max_length):
            output, hidden = rnn(category_tensor, input[0], hidden)
            topv, topi = output.topk(1)
            topi = topi[0][0]
            if topi == n_letters - 1:
                break
            else:
                letter = all_letters[topi]
                output_name += letter
            input = inputTensor(letter)

        return output_name

# Get multiple samples from one category and multiple starting letters
def samples(category, start_letters='ABC'):
    for start_letter in start_letters:
        print(sample(category, start_letter))

samples('Russian', 'RUS')

samples('German', 'GER')

samples('Spanish', 'SPA')

samples('Chinese', 'CHI')

Rovev
Uanovev
Shinovev
Gerren
Eren
Ronger
Saner
Pare
Allan
Ching
Hano
Iun

課題

category -> line の異なるデータセットで試してください、例えば :
- 小説シリーズ -> キャラクター名
- 品詞 -> 単語
- 国 (Country) -> 市 (City)
サンプリングが開始文字を選択することなしに遂行できるように「センテンス開始」トークンを使用する
より大きい and/or より良い形状のネットワークでより良い結果を得る
- nn.LSTM と nn.GRU 層を試す
- これら複数の RNN をより高位ネットワークとして結合する

以上

2023年5月
月	火	水	木	金	土	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31