前言
有好几个月没搞神经网络代码了，期间也就是回顾了两边之前的文字。
不料，对nn，cnn的理解反而更深入了-_-！。
修改
《零基础学习人工智能---Python---Pytorch学习（四）》，关于Linear的理解是错误的，已修改。
RNN
RNN是Recurrent Neural Network的缩写。中文叫循环神经网络。
RNN是在NN的基础上的扩展。
我们知道在训练NN的时候，要传递一个待训练的tensor。RNN简单来说就是在传递tensor的同时，再传递一个hidden。
这个hidden是哪来的？它是上一轮训练时，返回y_predict的同时，返回的（我们之前写NN只会返回y_predict，现在要多返回一个hidden）。
如果没有上一轮，那hidden就等于空的tensor。
代码实现
定义RNN
class RNN(nn.Module):
# implement RNN from scratch rather than using nn.RNN
def __init__(self, input_size, hidden_size, output_size):
super(RNN, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)
def forward(self, input_tensor, hidden_tensor):
combined = torch.cat((input_tensor, hidden_tensor), 1)
hidden = self.i2h(combined) #input to hidden=i2h
output = self.i2o(combined) #input to output=i2o
output = self.softmax(output)
return output, hidden
def init_hidden(self):
return torch.zeros(1, self.hidden_size)代码分析
init
init函数增加了一个参数hidden_size。我们知道init函数是接受x的列和y_predict的列的，x的列是input，y_predict的列是输出。
现在我们增加了hidden_size，他是hidden层的tensor的列。
我们在使用linear的时候，会把input_size和hidden_size相加，因为，我们后面再前向传播的时候，也会把x的tensor和hidden的tensor组合成一个向量。
forward
forward函数，我们先看return。
return多返回了一个对象------hidden，hidden是一个tensor，是执行linear（i2h）时的output，他也是根据x进行线性变换后的tensor，因为不是最后输出的tensor，所以他叫做hidden，而最后输出的output的tensor叫做y_predict。
我们在看forward的第一行，combined = torch.cat((input_tensor, hidden_tensor), 1)。
这是把tensor变量input_tensor和hidden_tensor给合并成了一个tensor，使用的是torch.cat函数。参数1是指按列的方向合并。
即input_tensor如果是(3,5),hidden_tensor是（3,2）,我们将得到一个（3,7），相当与把hidden的每一行的值取出来，添加进相同行的input_tensor里。
所以我们上面的init里，初始化linear的第一个参数（x的列）是input_size + hidden_size。
定义工具函数
import io
import os
import unicodedata
import string
import glob
import torch
import random
# alphabet small + capital letters + " .,;'"
ALL_LETTERS = string.ascii_letters + " .,;'"
N_LETTERS = len(ALL_LETTERS)
# Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
def unicode_to_ascii(s):
return ''.join(
c for c in unicodedata.normalize('NFD', s)
if unicodedata.category(c) != 'Mn'
and c in ALL_LETTERS
)
def load_data():
# Build the category_lines dictionary, a list of names per language
category_lines = {}
all_categories = []
def find_files(path):
return glob.glob(path)
# Read a file and split into lines
def read_lines(filename):
lines = io.open(filename, encoding='utf-8').read().strip().split('\n')
return [unicode_to_ascii(line) for line in lines]
for filename in find_files('data/names/*.txt'):
category = os.path.splitext(os.path.basename(filename))[0]
all_categories.append(category)
lines = read_lines(filename)
category_lines[category] = lines
return category_lines, all_categories
"""
To represent a single letter, we use a "one-hot vector" of
size <1 x n_letters>. A one-hot vector is filled with 0s
except for a 1 at index of the current letter, e.g. "b" = <0 1 0 0 0 ...>.
To make a word we join a bunch of those into a
2D matrix <line_length x 1 x n_letters>.
That extra 1 dimension is because PyTorch assumes
everything is in batches - we're just using a batch size of 1 here.
"""
# Find letter index from all_letters, e.g. "a" = 0
def letter_to_index(letter):
return ALL_LETTERS.find(letter)
# Just for demonstration, turn a letter into a <1 x n_letters> Tensor
def letter_to_tensor(letter):
tensor = torch.zeros(1, N_LETTERS)
tensor[0][letter_to_index(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 line_to_tensor(line):
tensor = torch.zeros(len(line), 1, N_LETTERS)
for i, letter in enumerate(line):
tensor[i][0][letter_to_index(letter)] = 1
return tensor
def random_training_example(category_lines, all_categories):
def random_choice(a):
random_idx = random.randint(0, len(a) - 1)
return a[random_idx]
category = random_choice(all_categories)
line = random_choice(category_lines[category])
category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)
line_tensor = line_to_tensor(line)
return category, line, category_tensor, line_tensor
if __name__ == '__main__':
print(ALL_LETTERS)
print(unicode_to_ascii('Ślusàrski'))
category_lines, all_categories = load_data()
print(category_lines['Italian'][:5])
print(letter_to_tensor('J')) # [1, 57]
print(line_to_tensor('Jones').size()) # [5, 1, 57]代码分析
string.ascii_letters 是一个字符串常量，它包含了所有 ASCII 字母，即小写字母 'abcdefghijklmnopqrstuvwxyz' 和大写字母 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 的组合
letter_to_tensor函数：是把入参的字母转成tensor，tensor的shape是(1,57)，后面我们使用该向量做神经网络的输入。
one-hot 向量
letter_to_tensor函数输出是tensor被称为one-hot向量，直译就是一个热点向量，即向量里就一个值是有意义的值。
【one-hot向量】就是一行N列的向量，列的值为1时，该列的位置，就是字母在字符串的位置。
如果我们有以下字母表,共27个字符（26个字母 + 空格）：
ALL_LETTERS = "abcdefghijklmnopqrstuvwxyz "转成one-hot 向量，就会如下图模式分配。
load_data函数：查询一个文件夹下的全部文件，然后把文件名全部取出来，组成集合，然后把文件的内容取出来，结合文件的名字，组成字典。
glob.glob：系统函数，查询指定目录下的指定文件。
data.names文件夹如下：
RNN前向传播
category_lines, all_categories = load_data()
n_categories = len(all_categories)
n_hidden = 128
print("N_LETTERS",N_LETTERS)
rnn = RNN(N_LETTERS, n_hidden, n_categories) # RNN(57,128,18) 18是18个国家即18个类别
input_tensor = letter_to_tensor('A') # 把A转成tensor(1,57)
hidden_tensor = rnn.init_hidden()
output, next_hidden = rnn(input_tensor, hidden_tensor)
input_tensor = line_to_tensor('Albert')
hidden_tensor = rnn.init_hidden()
output, next_hidden = rnn(input_tensor[0], hidden_tensor)
def category_from_output(output):
category_idx = torch.argmax(output).item()
return all_categories[category_idx]
print(category_from_output(output))代码分析
torch.argmax(output).item()是取出tensor里的最大值，其最大值的索引。
这里，我们通过整个RNN的前向传播，得到了一个output，即通过线性转换，我们得到y_predict，然后我们找到y_predict里最大的值的索引，我们认为，我们这个索引对应国家集合里对应索引的国家名，就是我们预测的我们输入的名字（实际输入的是字母）的所属国家。
完整代码：
import threading
import torch
import torch.nn as nn
from utils import ALL_LETTERS, N_LETTERS
from utils import load_data, letter_to_tensor, line_to_tensor, random_training_example
def category_from_output(output):
category_idx = torch.argmax(output).item()
return all_categories[category_idx]
class RNN(nn.Module):
# implement RNN from scratch rather than using nn.RNN
def __init__(self, input_size, hidden_size, output_size):
super(RNN, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)
def forward(self, input_tensor, hidden_tensor):
combined = torch.cat((input_tensor, hidden_tensor), 1)
hidden = self.i2h(combined) #input to hidden=i2h
output = self.i2o(combined) #input to output=i2o
output = self.softmax(output)
return output, hidden
def init_hidden(self):
return torch.zeros(1, self.hidden_size)
category_lines, all_categories = load_data()
n_categories = len(all_categories)
n_hidden = 128
print("N_LETTERS",N_LETTERS)
rnn = RNN(N_LETTERS, n_hidden, n_categories) # RNN(57,128,18) 18是18个国家即18个类别
input_tensor = letter_to_tensor('A') # 把A转成tensor(1,57)
hidden_tensor = rnn.init_hidden()
output, next_hidden = rnn(input_tensor, hidden_tensor)
print(category_from_output(output))
input_tensor = line_to_tensor('Albert')
hidden_tensor = rnn.init_hidden()
output, next_hidden = rnn(input_tensor[0], hidden_tensor)
print(category_from_output(output))使用RNN训练及预测
定义训练函数
def train(line_tensor, category_tensor):
hidden = rnn.init_hidden()
for i in range(line_tensor.size()[0]):
output, hidden = rnn(line_tensor[i], hidden)
loss = criterion(output, category_tensor)
optimizer.zero_grad()
loss.backward()
optimizer.step()
return output, loss.item()代码分析
入参line_tensor是一个tesnor,shape是（n,1,57），即，是一个字符串转成n个one-hot向量。他是一个名字的字符串。
入参category_tensor是真实的y值，这里他的shape是tensor(1)，即，这个名字的真实国家的索引。
然后我们通过循环执行output, hidden = rnn(line_tensor[i], hidden)，把每个字母都在rnn里进行线性变换，这里每次都会把hidden返回，然后下次调用rnn，会把hideen传递过去，形成循环网络。
最后输出的output是个1行18列的tensor，1行是因为我们输出的x是1行，18列是因为我们创建rnn时，指定了18列的输出。
然后我们执行损失函数，loss = criterion(output, category_tensor)，计算损失值，损失函数有很多种。（我们可以简单这样理解损失函数的运行逻辑，上面通过线性计算把X转成了tensor（1,18），这个tensor是y_predict,现在我们计算y_predicd与真y的差，在把结果平方，在求平均数，反正就是计算出一个数，这个数如果是2,3，那就代表我们的模型错的很离谱）
损失值求完，我们就可以使用损失值进行逆向传播了loss.backward()。这里loss是触发逆向传播的，也就是计算梯度，也就是求偏导数，之所以是loss触发，是因为loss本身是通过函数计算出来的，而我们求梯度，是对这个求loss的函数偏导，但是loss值，并不参与求偏导，所以loss是触发逆向传播的启点。
完整代码
import threading
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from utils import ALL_LETTERS, N_LETTERS
from utils import load_data, letter_to_tensor, line_to_tensor, random_training_example
def category_from_output(output):
category_idx = torch.argmax(output).item()
return all_categories[category_idx]
class RNN(nn.Module):
# implement RNN from scratch rather than using nn.RNN
def __init__(self, input_size, hidden_size, output_size):
super(RNN, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim=1)
def forward(self, input_tensor, hidden_tensor):
combined = torch.cat((input_tensor, hidden_tensor), 1)
hidden = self.i2h(combined) #input to hidden=i2h
output = self.i2o(combined) #input to output=i2o
output = self.softmax(output)
return output, hidden
def init_hidden(self):
return torch.zeros(1, self.hidden_size)
category_lines, all_categories = load_data()
# print("category_lines",category_lines)
# print("all_categories",all_categories)
n_categories = len(all_categories)
n_hidden = 128
rnn = RNN(N_LETTERS, n_hidden, n_categories)
criterion = nn.NLLLoss()
learning_rate = 0.005
optimizer = torch.optim.SGD(rnn.parameters(), lr=learning_rate)
def train(line_tensor, category_tensor):
hidden = rnn.init_hidden()
for i in range(line_tensor.size()[0]):
output, hidden = rnn(line_tensor[i], hidden)
loss = criterion(output, category_tensor)
optimizer.zero_grad()
loss.backward()
optimizer.step()
return output, loss.item()
current_loss = 0
all_losses = []
plot_steps, print_steps = 1000, 5000
n_iters = 100000
for i in range(n_iters):
category, line, category_tensor, line_tensor = random_training_example(category_lines, all_categories) # category=国家名 line=这个国家下的随机一个名字 category_tensor=国家名索引值转换成的tensor(1) line_tensor=名字转换成的tensor(n,1,57)
output, loss = train(line_tensor, category_tensor)
current_loss += loss
if (i+1) % plot_steps == 0:
all_losses.append(current_loss / plot_steps)
current_loss = 0
if (i+1) % print_steps == 0:
guess = category_from_output(output)
correct = "CORRECT" if guess == category else f"WRONG ({category})"
print(f"{i+1} {(i+1)/n_iters*100} {loss:.4f} {line} / {guess} {correct}")
def show():
plt.figure()
plt.plot(all_losses)
plt.show()
show()
def predict(input_line):
print(f"\n> {input_line}")
with torch.no_grad():
line_tensor = line_to_tensor(input_line)
hidden = rnn.init_hidden()
for i in range(line_tensor.size()[0]):
output, hidden = rnn(line_tensor[i], hidden)
guess = category_from_output(output)
print("guess:",guess)
while True:
sentence = input("Input:")
if sentence == "quit":
break
predict(sentence)到此，Python---Pytorch学习-RNN（一）就介绍完了。
参考网站：https://github.com/patrickloeber/pytorch-examples/tree/master/rnn-name-classification
注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！
若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！