PyTorch 1.3 Tutorials : テキスト : 文字レベル RNN で名前を生成する (翻訳/解説)
翻訳 : (株)クラスキャットセールスインフォメーション
作成日時 : 12/24/2019 (1.3.1)

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

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

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

テキスト : 文字レベル 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):
    lines = open(filename, encoding='utf-8').read().strip().split('\n')
    return [unicodeToAscii(line) for line in lines]

# 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 ['French', 'Czech', 'Dutch', 'Polish', 'Scottish', 'Chinese', 'English', 'Italian', 'Portuguese', 'Japanese', 'German', 'Russian', 'Korean', 'Arabic', 'Greek', 'Vietnamese', 'Spanish', 'Irish']
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_(-learning_rate, p.grad.data)

    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 20s (5000 5%) 4.0048
0m 40s (10000 10%) 3.2227
1m 0s (15000 15%) 3.2196
1m 20s (20000 20%) 2.8245
1m 39s (25000 25%) 2.3931
1m 59s (30000 30%) 2.7044
2m 18s (35000 35%) 2.4974
2m 38s (40000 40%) 2.4680
2m 57s (45000 45%) 2.9390
3m 17s (50000 50%) 1.4770
3m 36s (55000 55%) 1.7358
3m 56s (60000 60%) 2.0499
4m 15s (65000 65%) 2.8512
4m 34s (70000 70%) 2.7533
4m 54s (75000 75%) 2.2430
5m 13s (80000 80%) 2.4625
5m 33s (85000 85%) 2.5223
5m 52s (90000 90%) 2.5578
6m 11s (95000 95%) 1.5125
6m 31s (100000 100%) 2.4397

損失をプロットする

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

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

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')

Rovaki
Uantonovak
Sarishivan
Gerren
Ererer
Roure
Sara
Para
Arara
Cha
Han
Ian

課題

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

以上

2019年12月
月	火	水	木	金	土	日
						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