NLP从零开始：用字符级RNN进行姓名分类

import torch

# Find letter index from all_letters, e.g. "a" = 0
def letterToIndex(letter):
    return all_letters.find(letter)

# Just for demonstration, turn a letter into a <1 x n_letters> Tensor
def letterToTensor(letter):
    tensor = torch.zeros(1, n_letters)
    tensor[0][letterToIndex(letter)] = 1
    return tensor

# Turn a line into a <line_length x 1 x n_letters>,
# or an array of one-hot letter vectors
def lineToTensor(line):
    tensor = torch.zeros(len(line), 1, n_letters)
    for li, letter in enumerate(line):
        tensor[li][0][letterToIndex(letter)] = 1
    return tensor

print(letterToTensor('J'))

print(lineToTensor('Jones').size())

tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0.]])
torch.Size([5, 1, 57])

def categoryFromOutput(output):
    top_n, top_i = output.topk(1)
    category_i = top_i[0].item()
    return all_categories[category_i], category_i

print(categoryFromOutput(output))

('Irish', 8)

import random

def randomChoice(l):
    return l[random.randint(0, len(l) - 1)]

def randomTrainingExample():
    category = randomChoice(all_categories)
    line = randomChoice(category_lines[category])
    category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)
    line_tensor = lineToTensor(line)
    return category, line, category_tensor, line_tensor

for i in range(10):
    category, line, category_tensor, line_tensor = randomTrainingExample()
    print('category =', category, '/ line =', line)

category = Chinese / line = Hou
category = Scottish / line = Mckay
category = Arabic / line = Cham
category = Russian / line = V'Yurkov
category = Irish / line = O'Keeffe
category = French / line = Belrose
category = Spanish / line = Silva
category = Japanese / line = Fuchida
category = Greek / line = Tsahalis
category = Korean / line = Chang

criterion = nn.NLLLoss()

learning_rate = 0.005 # If you set this too high, it might explode. If too low, it might not learn

def train(category_tensor, line_tensor):
    hidden = rnn.initHidden()

    rnn.zero_grad()

    for i in range(line_tensor.size()[0]):
        output, hidden = rnn(line_tensor[i], hidden)

    loss = criterion(output, category_tensor)
    loss.backward()

    # Add parameters' gradients to their values, multiplied by learning rate
    for p in rnn.parameters():
        p.data.add_(p.grad.data, alpha=-learning_rate)

    return output, loss.item()

import time
import math

n_iters = 100000
print_every = 5000
plot_every = 1000



# Keep track of losses for plotting
current_loss = 0
all_losses = []

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

start = time.time()

for iter in range(1, n_iters + 1):
    category, line, category_tensor, line_tensor = randomTrainingExample()
    output, loss = train(category_tensor, line_tensor)
    current_loss += loss

    # Print ``iter`` number, loss, name and guess
    if iter % print_every == 0:
        guess, guess_i = categoryFromOutput(output)
        correct = '✓' if guess == category else '✗ (%s)' % category
        print('%d%d%% (%s) %.4f%s / %s%s' % (iter, iter / n_iters * 100, timeSince(start), loss, line, guess, correct))

    # Add current loss avg to list of losses
    if iter % plot_every == 0:
        all_losses.append(current_loss / plot_every)
        current_loss = 0

5000 5% (0m 17s) 2.2208 Horigome / Japanese ✓
10000 10% (0m 35s) 1.6752 Miazga / Japanese ✗ (Polish)
15000 15% (0m 53s) 0.1778 Yukhvidov / Russian ✓
20000 20% (1m 11s) 1.5856 Mclaughlin / Irish ✗ (Scottish)
25000 25% (1m 29s) 0.6552 Banh / Vietnamese ✓
30000 30% (1m 47s) 1.5547 Machado / Japanese ✗ (Portuguese)
35000 35% (2m 5s) 0.0168 Fotopoulos / Greek ✓
40000 40% (2m 23s) 1.1464 Quirke / Irish ✓
45000 45% (2m 41s) 1.7532 Reier / French ✗ (German)
50000 50% (3m 0s) 0.8413 Hou / Chinese ✓
55000 55% (3m 18s) 0.8587 Duan / Vietnamese ✗ (Chinese)
60000 60% (3m 36s) 0.2047 Giang / Vietnamese ✓
65000 65% (3m 54s) 2.5534 Cober / French ✗ (Czech)
70000 70% (4m 12s) 1.5163 Mateus / Arabic ✗ (Portuguese)
75000 75% (4m 31s) 0.2217 Hamilton / Scottish ✓
80000 80% (4m 49s) 0.4456 Maessen / Dutch ✓
85000 85% (5m 7s) 0.0239 Gan / Chinese ✓
90000 90% (5m 25s) 0.0521 Bellomi / Italian ✓
95000 95% (5m 43s) 0.0867 Vozgov / Russian ✓
100000 100% (6m 1s) 0.2730 Tong / Vietnamese ✓

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

plt.figure()
plt.plot(all_losses)

[<matplotlib.lines.Line2D object at 0x7f9dd159d5d0>]

def predict(input_line, n_predictions=3):
    print('\n> %s' % input_line)
    with torch.no_grad():
        output = evaluate(lineToTensor(input_line))

        # Get top N categories
        topv, topi = output.topk(n_predictions, 1, True)
        predictions = []

        for i in range(n_predictions):
            value = topv[0][i].item()
            category_index = topi[0][i].item()
            print('(%.2f) %s' % (value, all_categories[category_index]))
            predictions.append([value, all_categories[category_index]])

predict('Dovesky')
predict('Jackson')
predict('Satoshi')

> Dovesky
(-0.23) Czech
(-2.02) Russian
(-3.35) English

> Jackson
(-0.20) Scottish
(-2.51) Russian
(-3.05) Greek

> Satoshi
(-0.91) Italian
(-1.26) Japanese
(-1.57) Polish

$pythonpredict.pyHazaki
(-0.42)Japanese
(-1.39)Polish
(-3.51)Czech