自然语言处理---RNN经典案例之构建人名分类器

1 案例介绍

  • 关于人名分类问题:以一个人名为输入, 使用模型帮助判断它最有可能是来自哪一个国家的人名,这在某些国际化公司的业务中具有重要意义,在用户注册过程中,会根据用户填写的名字直接给他分配可能的国家或地区选项,以及该国家或地区的国旗,限制手机号码位数等等。

  • 人名分类数据,数据下载地址:https://download.pytorch.org/tutorial/data.zip

2 案例步骤

整个案例的实现可分为以下五个步骤

  • 第一步:导入必备的工具包
  • 第二步:对data文件中的数据进行处理,满足训练要求
  • 第三步:构建RNN模型(包括传统RNN,LSTM以及GRU)
  • 第四步:构建训练函数并进行训练
  • 第五步:构建评估函数并进行预测

2.1 导入必备的工具包

# 从io中导入文件打开方法
from io import open
# 帮助使用正则表达式进行子目录的查询
import glob
import os
# 用于获得常见字母及字符规范化
import string
import unicodedata
# 导入随机工具random
import random
# 导入时间和数学工具包
import time
import math
# 导入torch工具
import torch
# 导入nn准备构建模型
import torch.nn as nn
# 引入制图工具包        
import matplotlib.pyplot as plt

2.2 数据预处理

这里需要对data文件中的数据进行处理,满足训练要求。

1 获取常用的字符数量
# 获取所有常用字符包括字母和常用标点
all_letters = string.ascii_letters + " .,;'"# 获取常用字符数量
n_letters = len(all_letters)print("n_letter:", n_letters)
2 字符规范化之unicode转ascii函数
# 关于编码问题我们暂且不去考虑
# 我们认为这个函数的作用就是去掉一些语言中的重音标记
# 如: Ślusàrski ---> Slusarski
def unicodeToAscii(s):return ''.join(c for c in unicodedata.normalize('NFD', s)if unicodedata.category(c) != 'Mn'and c in all_letters)
3 构建一个从文件中读取内容到内存的函数
data_path = "./data/names/"def readLines(filename):"""从文件中读取每一行加载到内存中形成列表"""# 打开指定文件并读取所有内容, 使用strip()去除两侧空白符, 然后以'\n'进行切分lines = open(filename, encoding='utf-8').read().strip().split('\n')# 对应每一个lines列表中的名字进行Ascii转换, 使其规范化.最后返回一个名字列表return [unicodeToAscii(line) for line in lines]
4 构建人名类别(所属的语言)列表与人名对应关系字典
# 构建的category_lines形如:{"English":["Lily", "Susan", "Kobe"], "Chinese":["Zhang San", "Xiao Ming"]}
category_lines = {}# all_categories形如: ["English",...,"Chinese"]
all_categories = []# 读取指定路径下的txt文件, 使用glob,path中可以使用正则表达式
for filename in glob.glob(data_path + '*.txt'):# 获取每个文件的文件名, 就是对应的名字类别category = os.path.splitext(os.path.basename(filename))[0]# 将其逐一装到all_categories列表中all_categories.append(category)# 然后读取每个文件的内容,形成名字列表lines = readLines(filename)# 按照对应的类别,将名字列表写入到category_lines字典中category_lines[category] = lines# 查看类别总数
n_categories = len(all_categories)
print("n_categories:", n_categories)# 随便查看其中的一些内容
print(category_lines['Italian'][:5])
5 将人名转化为对应onehot张量表示
# 将字符串(单词粒度)转化为张量表示,如:"ab" --->
# tensor([[[1., 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., 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., 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.]]])
def lineToTensor(line):"""将人名转化为对应onehot张量表示, 参数line是输入的人名"""# 首先初始化一个0张量, 它的形状(len(line), 1, n_letters) # 代表人名中的每个字母用一个1 x n_letters的张量表示.tensor = torch.zeros(len(line), 1, n_letters)# 遍历这个人名中的每个字符索引和字符for li, letter in enumerate(line):# 使用字符串方法find找到每个字符在all_letters中的索引# 它也是我们生成onehot张量中1的索引位置tensor[li][0][all_letters.find(letter)] = 1# 返回结果return tensor

2.3 构建RNN模型

1 构建RNN模型
# 使用nn.RNN构建完成传统RNN使用类class RNN(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers=1):"""初始化函数中有4个参数, 分别代表RNN输入最后一维尺寸, RNN的隐层最后一维尺寸, RNN层数"""super(RNN, self).__init__()       # 将hidden_size与num_layers传入其中self.hidden_size = hidden_sizeself.num_layers = num_layers  # 实例化预定义的nn.RNN, 它的三个参数分别是input_size, hidden_size, num_layersself.rnn = nn.RNN(input_size, hidden_size, num_layers)# 实例化nn.Linear, 这个线性层用于将nn.RNN的输出维度转化为指定的输出维度self.linear = nn.Linear(hidden_size, output_size)# 实例化nn中预定的Softmax层, 用于从输出层获得类别结果self.softmax = nn.LogSoftmax(dim=-1)def forward(self, input, hidden):"""完成传统RNN中的主要逻辑, 输入参数input代表输入张量, 它的形状是1 x n_lettershidden代表RNN的隐层张量, 它的形状是self.num_layers x 1 x self.hidden_size"""# 因为预定义的nn.RNN要求输入维度一定是三维张量, 因此在这里使用unsqueeze(0)扩展一个维度input = input.unsqueeze(0)# 将input和hidden输入到传统RNN的实例化对象中,如果num_layers=1, rr恒等于hnrr, hn = self.rnn(input, hidden)# 将从RNN中获得的结果通过线性变换和softmax返回,同时返回hn作为后续RNN的输入return self.softmax(self.linear(rr)), hndef initHidden(self):"""初始化隐层张量"""# 初始化一个(self.num_layers, 1, self.hidden_size)形状的0张量     return torch.zeros(self.num_layers, 1, self.hidden_size)  
  • torch.unsqueeze演示:
>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1,  2,  3,  4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],[ 2],[ 3],[ 4]])
2 构建LSTM模型
# 使用nn.LSTM构建完成LSTM使用类class LSTM(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers=1):"""初始化函数的参数与传统RNN相同"""super(LSTM, self).__init__()# 将hidden_size与num_layers传入其中self.hidden_size = hidden_sizeself.num_layers = num_layers# 实例化预定义的nn.LSTMself.lstm = nn.LSTM(input_size, hidden_size, num_layers)# 实例化nn.Linear, 这个线性层用于将nn.RNN的输出维度转化为指定的输出维度self.linear = nn.Linear(hidden_size, output_size)# 实例化nn中预定的Softmax层, 用于从输出层获得类别结果self.softmax = nn.LogSoftmax(dim=-1)def forward(self, input, hidden, c):"""在主要逻辑函数中多出一个参数c, 也就是LSTM中的细胞状态张量"""# 使用unsqueeze(0)扩展一个维度input = input.unsqueeze(0)# 将input, hidden以及初始化的c传入lstm中rr, (hn, c) = self.lstm(input, (hidden, c))# 最后返回处理后的rr, hn, creturn self.softmax(self.linear(rr)), hn, cdef initHiddenAndC(self):  """初始化函数不仅初始化hidden还要初始化细胞状态c, 它们形状相同"""c = hidden = torch.zeros(self.num_layers, 1, self.hidden_size)return hidden, c
3 构建GRU模型
# 使用nn.GRU构建完成传统RNN使用类# GRU与传统RNN的外部形式相同, 都是只传递隐层张量, 因此只需要更改预定义层的名字class GRU(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers=1):super(GRU, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layers# 实例化预定义的nn.GRU, 它的三个参数分别是input_size, hidden_size, num_layersself.gru = nn.GRU(input_size, hidden_size, num_layers)self.linear = nn.Linear(hidden_size, output_size)self.softmax = nn.LogSoftmax(dim=-1)def forward(self, input, hidden):input = input.unsqueeze(0)rr, hn = self.gru(input, hidden)return self.softmax(self.linear(rr)), hndef initHidden(self):return torch.zeros(self.num_layers, 1, self.hidden_size)
4 实例化参数
# 因为是onehot编码, 输入张量最后一维的尺寸就是n_letters
input_size = n_letters# 定义隐层的最后一维尺寸大小
n_hidden = 128# 输出尺寸为语言类别总数n_categories
output_size = n_categories# num_layer使用默认值, num_layers = 1
5 输入参数
# 假如我们以一个字母B作为RNN的首次输入, 它通过lineToTensor转为张量
# 因为我们的lineToTensor输出是三维张量, 而RNN类需要的二维张量
# 因此需要使用squeeze(0)降低一个维度
input = lineToTensor('B').squeeze(0)# 初始化一个三维的隐层0张量, 也是初始的细胞状态张量
hidden = c = torch.zeros(1, 1, n_hidden)

2.4 构建训练函数并进行训练

1 从输出结果中获得指定类别函数
def categoryFromOutput(output):"""从输出结果中获得指定类别, 参数为输出张量output"""# 从输出张量中返回最大的值和索引对象, 我们这里主要需要这个索引top_n, top_i = output.topk(1)# top_i对象中取出索引的值category_i = top_i[0].item()# 根据索引值获得对应语言类别, 返回语言类别和索引值return all_categories[category_i], category_i
  • torch.topk演示:
>>> x = torch.arange(1., 6.)
>>> x
tensor([ 1.,  2.,  3.,  4.,  5.])
>>> torch.topk(x, 3)
torch.return_types.topk(values=tensor([5., 4., 3.]), indices=tensor([4, 3, 2]))
2 输入参数
# 将上一步中gru的输出作为函数的输入
output = gru_output
# tensor([[[-2.8042, -2.8894, -2.8355, -2.8951, -2.8682, -2.9502, -2.9056,
#          -2.8963, -2.8671, -2.9109, -2.9425, -2.8390, -2.9229, -2.8081,
#          -2.8800, -2.9561, -2.9205, -2.9546]]], grad_fn=<LogSoftmaxBackward>)
3 随机生成训练数据
def randomTrainingExample():"""该函数用于随机产生训练数据"""# 首先使用random的choice方法从all_categories随机选择一个类别category = random.choice(all_categories)# 然后在通过category_lines字典取category类别对应的名字列表# 之后再从列表中随机取一个名字line = random.choice(category_lines[category])# 接着将这个类别在所有类别列表中的索引封装成tensor, 得到类别张量category_tensorcategory_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)# 最后, 将随机取到的名字通过函数lineToTensor转化为onehot张量表示line_tensor = lineToTensor(line)return category, line, category_tensor, line_tensor
4 构建RNN训练函数
# 定义损失函数为nn.NLLLoss,因为RNN的最后一层是nn.LogSoftmax, 两者的内部计算逻辑正好能够吻合.  
criterion = nn.NLLLoss()# 设置学习率为0.005
learning_rate = 0.005 def trainRNN(category_tensor, line_tensor):"""定义训练函数, 它的两个参数是category_tensor类别的张量表示, 相当于训练数据的标签,line_tensor名字的张量表示, 相当于对应训练数据"""# 在函数中, 首先通过实例化对象rnn初始化隐层张量hidden = rnn.initHidden()# 然后将模型结构中的梯度归0rnn.zero_grad()# 下面开始进行训练, 将训练数据line_tensor的每个字符逐个传入rnn之中, 得到最终结果for i in range(line_tensor.size()[0]):output, hidden = rnn(line_tensor[i], hidden)# 因为我们的rnn对象由nn.RNN实例化得到, 最终输出形状是三维张量, 为了满足于category_tensor# 进行对比计算损失, 需要减少第一个维度, 这里使用squeeze()方法loss = criterion(output.squeeze(0), category_tensor)# 损失进行反向传播loss.backward()# 更新模型中所有的参数for p in rnn.parameters():# 将参数的张量表示与参数的梯度乘以学习率的结果相加以此来更新参数p.data.add_(-learning_rate, p.grad.data)# 返回结果和损失的值return output, loss.item()
5 构建LSTM训练函数
# 与传统RNN相比多出细胞状态cdef trainLSTM(category_tensor, line_tensor):hidden, c = lstm.initHiddenAndC()lstm.zero_grad()for i in range(line_tensor.size()[0]):# 返回output, hidden以及细胞状态coutput, hidden, c = lstm(line_tensor[i], hidden, c)loss = criterion(output.squeeze(0), category_tensor)loss.backward()for p in lstm.parameters():p.data.add_(-learning_rate, p.grad.data)return output, loss.item()
6 构建GRU训练函数
# 与RNN完全相同, 只不过名字改成了GRUdef trainGRU(category_tensor, line_tensor):hidden = gru.initHidden()gru.zero_grad()for i in range(line_tensor.size()[0]):output, hidden= gru(line_tensor[i], hidden)loss = criterion(output.squeeze(0), category_tensor)loss.backward()for p in gru.parameters():p.data.add_(-learning_rate, p.grad.data)return output, loss.item()
7 构建时间计算函数
def timeSince(since):"获得每次打印的训练耗时, since是训练开始时间"# 获得当前时间now = time.time()# 获得时间差,就是训练耗时s = now - since# 将秒转化为分钟, 并取整m = math.floor(s / 60)# 计算剩下不够凑成1分钟的秒数s -= m * 60# 返回指定格式的耗时return '%dm %ds' % (m, s)
8 构建训练过程的日志打印函数
# 设置训练迭代次数
n_iters = 1000
# 设置结果的打印间隔
print_every = 50
# 设置绘制损失曲线上的制图间隔
plot_every = 10def train(train_type_fn):"""训练过程的日志打印函数, 参数train_type_fn代表选择哪种模型训练函数, 如trainRNN"""# 每个制图间隔损失保存列表all_losses = []# 获得训练开始时间戳start = time.time()# 设置初始间隔损失为0current_loss = 0# 从1开始进行训练迭代, 共n_iters次 for iter in range(1, n_iters + 1):# 通过randomTrainingExample函数随机获取一组训练数据和对应的类别category, line, category_tensor, line_tensor = randomTrainingExample()# 将训练数据和对应类别的张量表示传入到train函数中output, loss = train_type_fn(category_tensor, line_tensor)      # 计算制图间隔中的总损失current_loss += loss   # 如果迭代数能够整除打印间隔if iter % print_every == 0:# 取该迭代步上的output通过categoryFromOutput函数获得对应的类别和类别索引guess, guess_i = categoryFromOutput(output)# 然后和真实的类别category做比较, 如果相同则打对号, 否则打叉号.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))# 如果迭代数能够整除制图间隔if iter % plot_every == 0:# 将保存该间隔中的平均损失到all_losses列表中all_losses.append(current_loss / plot_every)# 间隔损失重置为0current_loss = 0# 返回对应的总损失列表和训练耗时return all_losses, int(time.time() - start)
9 开始训练RNN, LSTM, GRU模型并制作对比图
# 调用train函数, 分别进行RNN, LSTM, GRU模型的训练
# 并返回各自的全部损失, 以及训练耗时用于制图
all_losses1, period1 = train(trainRNN)
all_losses2, period2 = train(trainLSTM)
all_losses3, period3 = train(trainGRU)# 绘制损失对比曲线, 训练耗时对比柱张图
# 创建画布0
plt.figure(0)
# 绘制损失对比曲线
plt.plot(all_losses1, label="RNN")
plt.plot(all_losses2, color="red", label="LSTM")
plt.plot(all_losses3, color="orange", label="GRU") 
plt.legend(loc='upper left') # 创建画布1
plt.figure(1)
x_data=["RNN", "LSTM", "GRU"] 
y_data = [period1, period2, period3]
# 绘制训练耗时对比柱状图
plt.bar(range(len(x_data)), y_data, tick_label=x_data)
10 日志输出
  • 传统RNN训练日志输出:
5000 5% (0m 16s) 3.2264 Carr / Chinese ✗ (English)
10000 10% (0m 30s) 1.2063 Biondi / Italian ✓
15000 15% (0m 47s) 1.4010 Palmeiro / Italian ✗ (Portuguese)
20000 20% (1m 0s) 3.8165 Konae / French ✗ (Japanese)
25000 25% (1m 17s) 0.5420 Koo / Korean ✓
30000 30% (1m 31s) 5.6180 Fergus / Portuguese ✗ (Irish)
35000 35% (1m 45s) 0.6073 Meeuwessen / Dutch ✓
40000 40% (1m 59s) 2.1356 Olan / Irish ✗ (English)
45000 45% (2m 13s) 0.3352 Romijnders / Dutch ✓
50000 50% (2m 26s) 1.1624 Flanagan / Irish ✓
55000 55% (2m 40s) 0.4743 Dubhshlaine / Irish ✓
60000 60% (2m 54s) 2.7260 Lee / Chinese ✗ (Korean)
65000 65% (3m 8s) 1.2075 Rutherford / English ✓
70000 70% (3m 23s) 3.6317 Han / Chinese ✗ (Vietnamese)
75000 75% (3m 37s) 0.1779 Accorso / Italian ✓
80000 80% (3m 52s) 0.1095 O'Brien / Irish ✓
85000 85% (4m 6s) 2.3845 Moran / Irish ✗ (English)
90000 90% (4m 21s) 0.3871 Xuan / Chinese ✓
95000 95% (4m 36s) 0.1104 Inoguchi / Japanese ✓
100000 100% (4m 52s) 4.2142 Simon / French ✓ (Irish)
  • LSTM训练日志输出:
5000 5% (0m 25s) 2.8640 Fabian / Dutch ✗ (Polish)
10000 10% (0m 48s) 2.9079 Login / Russian ✗ (Irish)
15000 15% (1m 14s) 2.8223 Fernandes / Greek ✗ (Portuguese)
20000 20% (1m 40s) 2.7069 Hudecek / Polish ✗ (Czech)
25000 25% (2m 4s) 2.6162 Acciaio / Czech ✗ (Italian)
30000 30% (2m 27s) 2.4044 Magalhaes / Greek ✗ (Portuguese)
35000 35% (2m 52s) 1.3030 Antoschenko / Russian ✓
40000 40% (3m 18s) 0.8912 Xing / Chinese ✓
45000 45% (3m 42s) 1.1788 Numata / Japanese ✓
50000 50% (4m 7s) 2.2863 Baz / Vietnamese ✗ (Arabic)
55000 55% (4m 32s) 3.2549 Close / Dutch ✗ (Greek)
60000 60% (4m 54s) 4.5170 Pan / Vietnamese ✗ (French)
65000 65% (5m 16s) 1.1503 San / Chinese ✗ (Korean)
70000 70% (5m 39s) 1.2357 Pavlik / Polish ✗ (Czech)
75000 75% (6m 2s) 2.3275 Alves / Portuguese ✗ (English)
80000 80% (6m 28s) 2.3294 Plamondon / Scottish ✗ (French)
85000 85% (6m 54s) 2.7794 Water / French ✗ (English)
90000 90% (7m 18s) 0.8021 Pereira / Portuguese ✓
95000 95% (7m 43s) 1.4374 Kunkel / German ✓
100000 100% (8m 5s) 1.2792 Taylor / Scottish ✓
  • GRU训练日志输出:
5000 5% (0m 22s) 2.8182 Bernard / Irish ✗ (Polish)
10000 10% (0m 48s) 2.8966 Macias / Greek ✗ (Spanish)
15000 15% (1m 13s) 3.1046 Morcos / Greek ✗ (Arabic)
20000 20% (1m 37s) 1.5359 Davlatov / Russian ✓
25000 25% (2m 1s) 1.0999 Han / Vietnamese ✓
30000 30% (2m 26s) 4.1017 Chepel / German ✗ (Russian)
35000 35% (2m 49s) 1.8765 Klein / Scottish ✗ (English)
40000 40% (3m 11s) 1.1265 an / Chinese ✗ (Vietnamese)
45000 45% (3m 34s) 0.3511 Slusarski / Polish ✓
50000 50% (3m 59s) 0.9694 Than / Vietnamese ✓
55000 55% (4m 25s) 2.3576 Bokhoven / Russian ✗ (Dutch)
60000 60% (4m 51s) 0.1344 Filipowski / Polish ✓
65000 65% (5m 15s) 1.4070 Reuter / German ✓
70000 70% (5m 37s) 1.8409 Guillory / Irish ✗ (French)
75000 75% (6m 0s) 0.6882 Song / Korean ✓
80000 80% (6m 22s) 5.0092 Maly / Scottish ✗ (Polish)
85000 85% (6m 43s) 2.4570 Sai / Chinese ✗ (Vietnamese)
90000 90% (7m 5s) 1.2006 Heel / German ✗ (Dutch)
95000 95% (7m 27s) 0.9144 Doan / Vietnamese ✓
100000 100% (7m 50s) 1.1320 Crespo / Portuguese ✓
11 结果分析
1 损失对比曲线分析

损失对比曲线:

  • 模型训练的损失降低快慢代表模型收敛程度。由图可知, 传统RNN的模型收敛情况最好, 然后是GRU, 最后是LSTM, 这是因为: 我们当前处理的文本数据是人名, 他们的长度有限, 且长距离字母间基本无特定关联, 因此无法发挥改进模型LSTM和GRU的长距离捕捉语义关联的优势. 所以在以后的模型选用时, 要通过对任务的分析以及实验对比, 选择最适合的模型.
2 训练耗时分析

训练耗时对比图:

  • 模型训练的耗时长短代表模型的计算复杂度, 由图可知, 也正如我们之前的理论分析, 传统RNN复杂度最低, 耗时几乎只是后两者的一半, 然后是GRU, 最后是复杂度最高的LSTM.
3 结论

模型选用一般应通过实验对比, 并非越复杂或越先进的模型表现越好, 而是需要结合自己的特定任务, 从对数据的分析和实验结果中获得最佳答案.

2.5 构建评估函数并进行预测

1 构建RNN评估函数
def evaluateRNN(line_tensor):"""评估函数, 和训练函数逻辑相同, 参数是line_tensor代表名字的张量表示"""# 初始化隐层张量hidden = rnn.initHidden()# 将评估数据line_tensor的每个字符逐个传入rnn之中for i in range(line_tensor.size()[0]):output, hidden = rnn(line_tensor[i], hidden)# 获得输出结果return output.squeeze(0)
2 构建LSTM评估函数
def evaluateLSTM(line_tensor):# 初始化隐层张量和细胞状态张量hidden, c = lstm.initHiddenAndC()# 将评估数据line_tensor的每个字符逐个传入lstm之中for i in range(line_tensor.size()[0]):output, hidden, c = lstm(line_tensor[i], hidden, c)return output.squeeze(0)
3 构建GRU评估函数
def evaluateGRU(line_tensor):hidden = gru.initHidden()# 将评估数据line_tensor的每个字符逐个传入gru之中for i in range(line_tensor.size()[0]):output, hidden = gru(line_tensor[i], hidden)return output.squeeze(0)
4 构建预测函数
def predict(input_line, evaluate, n_predictions=3):"""预测函数, 输入参数input_line代表输入的名字, n_predictions代表需要取最有可能的top个"""# 首先打印输入print('\n> %s' % input_line)# 以下操作的相关张量不进行求梯度with torch.no_grad():# 使输入的名字转换为张量表示, 并使用evaluate函数获得预测输出output = evaluate(lineToTensor(input_line))# 从预测的输出中取前3个最大的值及其索引topv, topi = output.topk(n_predictions, 1, True)# 创建盛装结果的列表predictions = []# 遍历n_predictionsfor i in range(n_predictions):# 从topv中取出的output值value = topv[0][i].item()# 取出索引并找到对应的类别category_index = topi[0][i].item()# 打印ouput的值, 和对应的类别print('(%.2f) %s' % (value, all_categories[category_index]))# 将结果装进predictions中predictions.append([value, all_categories[category_index]])

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/168612.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【C语言进阶】指针进阶(三)

指针进阶&#xff08;三&#xff09; 9.指针和数组笔试题解析10.指针笔试题 9.指针和数组笔试题解析 数组名的理解 数组名是数组首元素的地址 但是有2个例外&#xff1a; sizeof(数组名)&#xff0c;这里的数组名表示整个数组&#xff0c;sizeof(数组名)计算的是整个数组的大…

SpringMVC(三)获取请求参数

1.1通过ServletAPI获取 SpringMVC封装的就是原生的servlet 我们进行测试如下所示&#xff1a; package com.rgf.controller.service;import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping;import javax.servlet.…

纺织工厂数字孪生3D可视化管理平台,推动纺织产业数字化转型

近年来&#xff0c;我国加快数字化发展战略部署&#xff0c;全面推进制造业数字化转型&#xff0c;促进数字经济与实体经济深度融合。以数字孪生、物联网、云计算、人工智能为代表的数字技术发挥重要作用。聚焦数字孪生智能工厂可视化平台&#xff0c;推动纺织制造业数字化转型…

OpenCV17-图像形态学操作

OpenCV17-图像形态学操作 1.形态学操作1.1腐蚀1.2膨胀 2.形态学应用2.1开运算2.2闭运算2.3形态学梯度2.4顶帽运算2.5黑帽运算2.6击中击不中变换2.7形态学应用示例 1.形态学操作 1.1腐蚀 图像腐蚀&#xff08;Image erosion&#xff09;可用于减小图像中物体的大小、填充孔洞或…

css之Flex弹性布局(子项常见属性)

文章目录 &#x1f380;前言&#xff1a;本篇博客介绍弹性布局flex容器中子项的常见用法&#x1fa80;flex:子项目占得份数 &#xff08;划分不同子项的比例&#xff09;&#x1f387;align-self 控制单独一个子项在侧轴的排列方式&#x1f9f8;order属性定义子项的排列顺序 &a…

酷开科技 | 酷开系统,为居家生活打开更精彩的窗口

电视在我们的日常生活中扮演着重要的角色。虽然&#xff0c;作为客厅C位的扛把子——电视的娱乐作用深入人心&#xff0c;但是&#xff0c;它的涵义和影响力却因我们每个人的具体生活环境而存在着种种差异&#xff0c;而我们的生活环境又受到我们所处的社会及文化环境的影响。 …

一文了解AIGC与ChatGPT

一、AIGC简介 1.AIGC基础 (1)AIGC是什么 AIGC是人工智能图形计算的缩写&#xff0c;是一种基于图形处理器&#xff08;GPU&#xff09;的计算技术&#xff0c;可以加速各种计算任务&#xff0c;包括机器学习、深度学习、计算机视觉等。 AIGC是一种基于GPU的计算技术&#x…

Git(一)Windows下安装及使用Git Bash

目录 一、简介1.1 什么是Git&#xff1f;1.2 Git 的主要特点1.3 什么是 Git Bash&#xff1f; 二、下载三、安装3.1 同意协议3.2 选择安装位置3.3 其他配置&#xff08;【Next】 即可&#xff09;3.4 安装完毕3.5 打开 Git Bash 官网地址&#xff1a; https://www.git-scm.com/…

包管理工具

代码共享方案 放到npm仓库&#xff0c;下载到本地放到node_modules npm配置文件 必须填写的属性&#xff1a;name、version name是项目的名称&#xff1b; version是当前项目的版本号&#xff1b; description是描述信息&#xff0c;很多时候是作为项目的基本描述&#xff1b…

力扣每日一题61:旋转链表

题目描述&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4 输…

CSS必学:你需要知道的盒子模型的秘密

作者:WangMin 格言:努力做好自己喜欢的每一件事 CSDN原创文章 博客地址 &#x1f449; WangMin 作为前端开发来说&#xff0c;要掌握的CSS基础一定很多&#xff0c;那么CSS中盒子模型肯定是必考必问必掌握的前端知识点&#xff0c;因为它是CSS基础中非常重要的内容&#xff0c;…

异步编程详解(.NET)

在之前写的一篇关于async和await的前世今生的文章之后&#xff0c;大家似乎在async和await提高网站处理能力方面还有一些疑问&#xff0c;很多网站本身也做了不少的尝试。今天我们再来回答一下这个问题&#xff0c;同时我会做一个async和await在WinForm中的尝试&#xff0c;并且…

Java SOAP 调用 C# 的WebService

Java SOAP 调用 C# 的WebService&#xff0c;C# 的WebService方法的创建可以参考上一篇文章。IntelliJ IDEA Community Edition 2021.2.3的idea64.exe新建项目&#xff0c;导入需要的jar&#xff0c;代码如下&#xff1a; import org.apache.axis.client.Service; import org.…

循环神经网络(Recurrent Neural Network)

1. 为什么需要循环神经网络 RNN 上图是一幅全连接神经网络图&#xff0c;我们可以看到输入层-隐藏层-输出层&#xff0c;他们每一层之间是相互独立地&#xff0c;(框框里面代表同一层)&#xff0c;每一次输入生成一个节点&#xff0c;同一层中每个节点之间又相互独立的话&#…

PKU 概率论+数理统计+建模 期中考复习总结

目录 计算条件概率计算概率&#xff08;放回与不放回&#xff09;生成随机数算法Linear Congruential Method判断是否是full period Uniformity (test of frequency)1.Chi-Square testmethodreminderexample 2.Kolmogorov-Sminov testmethodexample Independence (test of auto…

互联网Java工程师面试题·Spring篇·第一弹

目录 1、一般问题 1.1、不同版本的 Spring Framework 有哪些主要功能&#xff1f; 1.2、什么是 Spring Framework&#xff1f; 1.3、列举 Spring Framework 的优点。 1.4、Spring Framework 有哪些不同的功能&#xff1f; 1.5、Spring Framework 中有多少个模块&#xff…

JSX 模板精简原则

学习目标&#xff1a; 使模板中的逻辑跟简洁 实现&#xff1a; 复杂的多分枝的逻辑收敛为一个函数&#xff0c;通过一个专门的函数来写分支逻辑&#xff0c;模板中只负责调用 实例&#xff1a; // 有一个状态type有1&#xff0c;2&#xff0c;3三种 // 1 展示 h1 // 2 展示 h2…

webpack proxy如何解决跨域?

一、是什么 webpack proxy&#xff0c;即webpack提供的代理服务 基本行为就是接收客户端发送的请求后转发给其他服务器 其目的是为了便于开发者在开发模式下解决跨域问题&#xff08;浏览器安全策略限制&#xff09; 想要实现代理首先需要一个中间服务器&#xff0c;webpac…

C++左值引用与右值引用

0.类型和值类别的区别&#xff1f; 类型&#xff08;type&#xff09;和值类别&#xff08;value category&#xff09; 1.类型指的是数据类型&#xff0c;int&#xff0c;char这样的内置类型&#xff0c;类型主要是用来区别它们的字节大小。除了内置类型还有自定义类型&…

【ESP-BOX-LITE】:照片查看器

目录 项目场景&#xff1a; 项目需求描述&#xff1a; 项目技术&#xff1a; 项目成果&#xff1a; 项目总结&#xff1a; 项目视频&#xff1a; 芳香 项目场景&#xff1a; 使用ESP-BOX-LITE实现照片查看器功能&#xff0c;显示多级目录下的图片或文件夹&#xff0c;自…