作者 | News

编辑 | 安可

出品 | 磐创AI团队出品

【磐创AI 导读】：本篇文章讲解了PyTorch专栏的第三章中的混合前端的seq2seq模型部署。本教程将介绍如何是seq2seq模型转换为PyTorch可用的前端混合Torch脚本。我们要转换的模型来自于聊天机器人教程Chatbot tutorial。查看专栏历史文章，请点击下方蓝色字体进入相应链接阅读。查看关于本专栏的介绍：PyTorch专栏开篇。想要更多电子杂志的机器学习，深度学习资源，大家欢迎点击上方蓝字关注我们的公众号：磐创AI。

• PyTorch简介
• PyTorch环境搭建

• PyTorch入门
• PyTorch自动微分
• PyTorch神经网络
• PyTorch图像分类器
• PyTorch数据并行处理

• 数据加载和处理
• PyTorch小试牛刀
• 迁移学习
• 混合前端的seq2seq模型部署
• 保存和加载模型

• 微调基于torchvision 0.3的目标检测模型
• 微调TorchVision模型
• 空间变换器网络
• 使用PyTorch进行神经传递
• 生成对抗示例
• 使用ONNX将模型转移至Caffe2和移动端

• 聊天机器人教程
• 使用字符级RNN生成名字
• 使用字符级RNN进行名字分类
• 在深度学习和NLP中使用Pytorch
• 使用Sequence2Sequence网络和注意力进行翻译

混合前端的seq2seq模型部署

1.混合前端

2.预备环境

source-python
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import torch
import torch.nn as nn
import torch.nn.functional as F
import re
import os
import unicodedata
import numpy as np

device = torch.device("cpu")

MAX_LENGTH = 10 # Maximum sentence length

# 默认的词向量
PAD_token = 0 # Used for padding short sentences
SOS_token = 1 # Start-of-sentence token
EOS_token = 2 # End-of-sentence token

3.模型概述

正如前文所言，我们使用的sequence-to-sequence (seq2seq) 模型。这种类型的模型用于输入是可变长度序列的情况，我们的输出也是一个可变长度序列它不一定是一对一输入映射。seq2seq 模型由两个递归神经网络(RNNs)组成：编码器 encoder和解码器decoder. 

（1）编码器(Encoder)

（2）解码器(Decoder)

4.数据处理

class Voc:
    def __init__(self, name):
        self.name = name
        self.trimmed = False
        self.word2index = {}
        self.word2count = {}
        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
        self.num_words = 3 # 统计SOS, EOS, PAD

    def addSentence(self, sentence):
        for word in sentence.split(' '):
            self.addWord(word)

    def addWord(self, word):
        if word not in self.word2index:
            self.word2index[word] = self.num_words
            self.word2count[word] = 1
            self.index2word[self.num_words] = word
            self.num_words += 1
        else:
            self.word2count[word] += 1

    # Remove words below a certain count threshold
    def trim(self, min_count):
        if self.trimmed:
            return
        self.trimmed = True
        keep_words = []
        for k, v in self.word2count.items():
            if v >= min_count:
                keep_words.append(k)

        print('keep_words {} / {} = {:.4f}'.format(
            len(keep_words), len(self.word2index), len(keep_words) / len(self.word2index)
        ))
        # Reinitialize dictionaries
        self.word2index = {}
        self.word2count = {}
        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
        self.num_words = 3 # 统计默认的令牌
        for word in keep_words:
            self.addWord(word)

# 小写并删除非字母字符
def normalizeString(s):
    s = s.lower()
    s = re.sub(r"([.!?])", r" 1", s)
    s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
    return s

# 使用字符串句子，返回单词索引的句子
def indexesFromSentence(voc, sentence):
    return [voc.word2index[word] for word in sentence.split(' ')] + [EOS_token]

5.定义编码器

class EncoderRNN(nn.Module):
    def __init__(self, hidden_size, embedding, n_layers=1, dropout=0):
        super(EncoderRNN, self).__init__()
        self.n_layers = n_layers
        self.hidden_size = hidden_size
        self.embedding = embedding

        # 初始化GRU;input_size和hidden_size参数都设置为'hidden_size'
        # 因为我们输入的大小是一个有多个特征的词向量== hidden_size
        self.gru = nn.GRU(hidden_size, hidden_size, n_layers,
                          dropout=(0 if n_layers == 1 else dropout), bidirectional=True)

    def forward(self, input_seq, input_lengths, hidden=None):
        # 将单词索引转换为向量
        embedded = self.embedding(input_seq)
        # 为RNN模块填充批次序列
        packed = torch.nn.utils.rnn.pack_padded_sequence(embedded, input_lengths)
        # 正向通过GRU
        outputs, hidden = self.gru(packed, hidden)
        # 打开填充
        outputs, _ = torch.nn.utils.rnn.pad_packed_sequence(outputs)
        # 将双向GRU的输出结果总和
        outputs = outputs[:, :, :self.hidden_size] + outputs[:, : ,self.hidden_size:]
        # 返回输出以及最终的隐藏状态
        return outputs, hidden

6.定义解码器的注意力模块

# Luong的注意力层
class Attn(torch.nn.Module):
    def __init__(self, method, hidden_size):
        super(Attn, self).__init__()
        self.method = method
        if self.method not in ['dot', 'general', 'concat']:
            raise ValueError(self.method, "is not an appropriate attention method.")
        self.hidden_size = hidden_size
        if self.method == 'general':
            self.attn = torch.nn.Linear(self.hidden_size, hidden_size)
        elif self.method == 'concat':
            self.attn = torch.nn.Linear(self.hidden_size * 2, hidden_size)
            self.v = torch.nn.Parameter(torch.FloatTensor(hidden_size))

    def dot_score(self, hidden, encoder_output):
        return torch.sum(hidden * encoder_output, dim=2)

    def general_score(self, hidden, encoder_output):
        energy = self.attn(encoder_output)
        return torch.sum(hidden * energy, dim=2)

    def concat_score(self, hidden, encoder_output):
        energy = self.attn(torch.cat((hidden.expand(encoder_output.size(0), -1, -1), encoder_output), 2)).tanh()
        return torch.sum(self.v * energy, dim=2)

    def forward(self, hidden, encoder_outputs):
        # 根据给定的方法计算注意力权重（能量）
        if self.method == 'general':
            attn_energies = self.general_score(hidden, encoder_outputs)
        elif self.method == 'concat':
            attn_energies = self.concat_score(hidden, encoder_outputs)
        elif self.method == 'dot':
            attn_energies = self.dot_score(hidden, encoder_outputs)

        # 转置max_length和batch_size维度
        attn_energies = attn_energies.t()

        # 返回softmax归一化概率分数（增加维度）
        return F.softmax(attn_energies, dim=1).unsqueeze(1)

7.定义解码器

• 混合前端笔记 与EncoderRNN类似，此模块不包含任何依赖于数据的控制流。因此，在初始化该模型并加载其参数之后，我们可以再次使用跟踪tracing将其转换为Torch脚本。

class LuongAttnDecoderRNN(nn.Module):
    def __init__(self, attn_model, embedding, hidden_size, output_size, n_layers=1, dropout=0.1):
        super(LuongAttnDecoderRNN, self).__init__()

        # 保持参考
        self.attn_model = attn_model
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.n_layers = n_layers
        self.dropout = dropout

        # 定义层
        self.embedding = embedding
        self.embedding_dropout = nn.Dropout(dropout)
        self.gru = nn.GRU(hidden_size, hidden_size, n_layers, dropout=(0 if n_layers == 1 else dropout))
        self.concat = nn.Linear(hidden_size * 2, hidden_size)
        self.out = nn.Linear(hidden_size, output_size)

        self.attn = Attn(attn_model, hidden_size)

    def forward(self, input_step, last_hidden, encoder_outputs):
        # 注意：我们这步只运行一次
        # 获取当前输入字对应的向量映射
        embedded = self.embedding(input_step)
        embedded = self.embedding_dropout(embedded)
        # 通过单向GRU转发
        rnn_output, hidden = self.gru(embedded, last_hidden)
        # 通过当前GRU的输出计算注意力权重
        attn_weights = self.attn(rnn_output, encoder_outputs)
        # 注意力权重乘以编码器输出以获得新的“加权和”上下文向量
        context = attn_weights.bmm(encoder_outputs.transpose(0, 1))
        # 使用Luong的公式5来连接加权上下文向量和GRU输出
        rnn_output = rnn_output.squeeze(0)
        context = context.squeeze(1)
        concat_input = torch.cat((rnn_output, context), 1)
        concat_output = torch.tanh(self.concat(concat_input))
        # 使用Luong的公式6来预测下一个单词
        output = self.out(concat_output)
        output = F.softmax(output, dim=1)
        # 返回输出和最终的隐藏状态
        return output, hidden

8.定义评估

8.1 贪婪搜索解码器

• 混合前端笔记

为了了解可能需要的一些操作，我们将回顾聊天机器人教程中的GreedySearchDecoder实现与下面单元中使用的实现之间的区别。请注意， 用红色突出显示的行是从原始实现中删除的行，而用绿色突出显示的行是新的。 

变更事项：

• nn.Module -> torch.jit.ScriptModule 为了在模块上使用PyTorch的脚本化机制, 模型需要从torch.jit.ScriptModule继承。
• 将decoder_n_layers追加到结构参数 这种变化源于这样一个事实，即我们传递给这个模块的编码器和解码器模型将是TracedModule(非模块)的子模块。因此，我们无法使用 decoder.n_layers访问解码器的层数。相反，我们对此进行计划，并在模块构建过程中传入此值。
• 将新属性作为常量保存 在最初的实现中，我们可以在GreedySearchDecoder的forward方法中自由地使用来自周围(全局)范围的变量. 然而，现在我们正 在使用脚本，我们没有这种自由，因为脚本处理的设想4是我们不一定要保留Python对象，尤其是在导出时。 一个简单的解决方案是 将全局作用域中的这些值作为属性存储到构造函数中的模块中， 并将它们添加到一个名为__constants__的特殊列表中，以便在forward 方法中构造图形时将它们用作文本值。这种用法的一个例子在第19行，取代使用device和SOS_token全局值，我们使用常量属性 self._device和self._SOS_token。
• 将torch.jit.script_method装饰器添加到forward方法 添加这个装饰器可以让JIT编译器知道它所装饰的函数应该是脚本化的。
• 强制forward方法的参数类型 默认情况下，Torch脚本函数的所有参数都假定为张量。如果需要传递不同类型的参数，可以使用PEP 3107中引入的函数类型注释。 此外，还可以使用MyPy-style类型的注释声明不同类型的参数。
• 变更decoder_input的初始化 在原有实现中，我们用torch.LongTensor([[SOS_token]])初始化了decoder_input的张量。当脚本编写时,我们不允许像这样以 一种文字方式初始化张量。取而代之的是，我们可以用一个显式的torch函数，比如torch.ones来初始化我们的张量。这种情况下， 我们可以很方便的复制标量decoder_input和通过将1乘以我们存在常量中的SOS_token的值self._SOS_token得到的张量。 “`buildoutcfg class GreedySearchDecoder(torch.jit.ScriptModule): def init(self, encoder, decoder, decoder_n_layers): super(GreedySearchDecoder, self).init() self.encoder = encoder self.decoder = decoder self._device = device self._SOS_token = SOS_token self._decoder_n_layers = decoder_n_layers
  constants = [‘_device’, ‘_SOS_token’, ‘_decoder_n_layers’]
  @torch.jit.script_method def forward(self, input_seq : torch.Tensor, input_length : torch.Tensor, max_length : int): # 通过编码器模型转发输入 encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length) # 准备编码器的最终隐藏层作为解码器的第一个隐藏输入 decoder_hidden = encoder_hidden[:self._decoder_n_layers] # 使用SOS_token初始化解码器输入 decoder_input = torch.ones(1, 1, device=self._device, dtype=torch.long) * self._SOS_token # 初始化张量以将解码后的单词附加到 all_tokens = torch.zeros([0], device=self._device, dtype=torch.long) all_scores = torch.zeros([0], device=self._device) # 一次迭代地解码一个词令牌 for _ in range(max_length): # 正向通过解码器 decoder_output, decoder_hidden = self.decoder(decoder_input, decoder_hidden, encoder_outputs) # 获得最可能的单词标记及其softmax分数 decoder_scores, decoder_input = torch.max(decoder_output, dim=1) # 记录令牌和分数 all_tokens = torch.cat((all_tokens, decoder_input), dim=0) all_scores = torch.cat((all_scores, decoder_scores), dim=0) # 准备当前令牌作为下一个解码器输入（添加维度） decoder_input = torch.unsqueeze(decoder_input, 0) # 返回词令牌和分数的集合 return all_tokens, all_scores
  
  #### 8.2 输入评估
  

接下来，我们定义一些函数来计算输入。求值函数`evaluate`接受一个规范化字符串语句，将其处理为其对应的单词索引张量(批处理大小
为1)，并将该张量传递给一个名为`searcher`的`GreedySearchDecoder`实例，以处理编码/解码过程。检索器返回输出的单词索引向量和
一个分数张量，该张量对应于每个解码的单词标记的`softmax`分数。最后一步是使用`voc.index2word`将每个单词索引转换回其字符串表示形式。

我们还定义了两个函数来计算输入语句。`evaluateInput`函数提示用户输入，并计算输入。它持续请求另一次输入，直到用户输入“q”或“quit”。

`evaluateExample`函数只接受一个字符串输入语句作为参数，对其进行规范化、计算并输出响应。
```buildoutcfg
def evaluate(encoder, decoder, searcher, voc, sentence, max_length=MAX_LENGTH):
    # 格式化输入句子作为批处理
    # words -> indexes
    indexes_batch = [indexesFromSentence(voc, sentence)]
    # 创建长度张量
    lengths = torch.tensor([len(indexes) for indexes in indexes_batch])
    # 转置批量的维度以匹配模型的期望
    input_batch = torch.LongTensor(indexes_batch).transpose(0, 1)
    # 使用适当的设备
    input_batch = input_batch.to(device)
    lengths = lengths.to(device)
    # 用earcher解码句子s
    tokens, scores = searcher(input_batch, lengths, max_length)
    # indexes -> words
    decoded_words = [voc.index2word[token.item()] for token in tokens]
    return decoded_words


# 评估来自用户输入的输入(stdin)
def evaluateInput(encoder, decoder, searcher, voc):
    input_sentence = ''
    while(1):
        try:
            # 获取输入的句子
            input_sentence = input('> ')
            # Check if it is quit case
            if input_sentence == 'q' or input_sentence == 'quit': break
            # 规范化句子
            input_sentence = normalizeString(input_sentence)
            # 评估句子
            output_words = evaluate(encoder, decoder, searcher, voc, input_sentence)
            # 格式化和打印回复句
            output_words[:] = [x for x in output_words if not (x == 'EOS' or x == 'PAD')]
            print('Bot:', ' '.join(output_words))

        except KeyError:
            print("Error: Encountered unknown word.")

# 规范化输入句子并调用evaluate()
def evaluateExample(sentence, encoder, decoder, searcher, voc):
    print("> " + sentence)
    # 规范化句子
    input_sentence = normalizeString(sentence)
    # 评估句子
    output_words = evaluate(encoder, decoder, searcher, voc, input_sentence)
    output_words[:] = [x for x in output_words if not (x == 'EOS' or x == 'PAD')]
    print('Bot:', ' '.join(output_words))

9.加载预训练参数

9.1 使用托管模型

9.2 使用自己的模型

• 混合前端笔记

save_dir = os.path.join("data", "save")
corpus_name = "cornell movie-dialogs corpus"

# 配置模型
model_name = 'cb_model'
attn_model = 'dot'
#attn_model = 'general'
#attn_model = 'concat'
hidden_size = 500
encoder_n_layers = 2
decoder_n_layers = 2
dropout = 0.1
batch_size = 64

# 如果你加载的是自己的模型
# 设置要加载的检查点
checkpoint_iter = 4000
# loadFilename = os.path.join(save_dir, model_name, corpus_name,
#                             '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size),
#                             '{}_checkpoint.tar'.format(checkpoint_iter))

# 如果你加载的是托管模型
loadFilename = 'data/4000_checkpoint.tar'

# 加载模型
# 强制CPU设备选项（与本教程中的张量匹配）
checkpoint = torch.load(loadFilename, map_location=torch.device('cpu'))
encoder_sd = checkpoint['en']
decoder_sd = checkpoint['de']
encoder_optimizer_sd = checkpoint['en_opt']
decoder_optimizer_sd = checkpoint['de_opt']
embedding_sd = checkpoint['embedding']
voc = Voc(corpus_name)
voc.__dict__ = checkpoint['voc_dict']


print('Building encoder and decoder ...')
# 初始化词向量
embedding = nn.Embedding(voc.num_words, hidden_size)
embedding.load_state_dict(embedding_sd)
# 初始化编码器和解码器模型
encoder = EncoderRNN(hidden_size, embedding, encoder_n_layers, dropout)
decoder = LuongAttnDecoderRNN(attn_model, embedding, hidden_size, voc.num_words, decoder_n_layers, dropout)
# 加载训练模型参数
encoder.load_state_dict(encoder_sd)
decoder.load_state_dict(decoder_sd)
# 使用适当的设备
encoder = encoder.to(device)
decoder = decoder.to(device)
# 将dropout层设置为eval模式
encoder.eval()
decoder.eval()
print('Models built and ready to go!')

• 输出

Building encoder and decoder ...
Models built and ready to go!

10.将模型转换为 Torch 脚本

10.1 编码器

10.2 解码器

10.3 贪婪搜索解码器

### 转换编码器模型
# 创建人工输入
test_seq = torch.LongTensor(MAX_LENGTH, 1).random_(0, voc.num_words).to(device)
test_seq_length = torch.LongTensor([test_seq.size()[0]]).to(device)
# 跟踪模型
traced_encoder = torch.jit.trace(encoder, (test_seq, test_seq_length))

### 转换解码器模型
# 创建并生成人工输入
test_encoder_outputs, test_encoder_hidden = traced_encoder(test_seq, test_seq_length)
test_decoder_hidden = test_encoder_hidden[:decoder.n_layers]
test_decoder_input = torch.LongTensor(1, 1).random_(0, voc.num_words)
# 跟踪模型
traced_decoder = torch.jit.trace(decoder, (test_decoder_input, test_decoder_hidden, test_encoder_outputs))

### 初始化searcher模块
scripted_searcher = GreedySearchDecoder(traced_encoder, traced_decoder, decoder.n_layers)

11.图形打印

• 输出

• scripted_searcher graph:
   graph(%input_seq : Tensor,
        %input_length : Tensor,
        %max_length : int,
        %126 : Tensor,
        %127 : Tensor,
        %128 : Tensor,
        %129 : Tensor,
        %130 : Tensor,
        %131 : Tensor,
        %132 : Tensor,
        %133 : Tensor,
        %134 : Tensor,
        %135 : Tensor,
        %136 : Tensor,
        %137 : Tensor,
        %138 : Tensor,
        %139 : Tensor,
        %140 : Tensor,
        %141 : Tensor,
        %142 : Tensor,
        %143 : Tensor,
        %144 : Tensor,
        %145 : Tensor,
        %146 : Tensor,
        %147 : Tensor,
        %148 : Tensor,
        %149 : Tensor,
        %150 : Tensor,
        %151 : Tensor,
        %152 : Tensor,
        %153 : Tensor,
        %154 : Tensor,
        %155 : Tensor):
    %4 : bool? = prim::Constant()
    %5 : int? = prim::Constant()
    %6 : int = prim::Constant[value=9223372036854775807](), scope: EncoderRNN
    %7 : float = prim::Constant[value=0](), scope: EncoderRNN
    %8 : float = prim::Constant[value=0.1](), scope: EncoderRNN/GRU[gru]
    %9 : int = prim::Constant[value=2](), scope: EncoderRNN/GRU[gru]
    %10 : bool = prim::Constant[value=1](), scope: EncoderRNN/GRU[gru]
    %11 : int = prim::Constant[value=6](), scope: EncoderRNN/GRU[gru]
    %12 : int = prim::Constant[value=500](), scope: EncoderRNN/GRU[gru]
    %13 : int = prim::Constant[value=4](), scope: EncoderRNN
    %14 : Device = prim::Constant[value="cpu"](), scope: EncoderRNN
    %15 : bool = prim::Constant[value=0](), scope: EncoderRNN/Embedding[embedding]
    %16 : int = prim::Constant[value=-1](), scope: EncoderRNN/Embedding[embedding]
    %17 : int = prim::Constant[value=0]()
    %18 : int = prim::Constant[value=1]()
    %input.7 : Float(10, 1, 500) = aten::embedding(%155, %input_seq, %16, %15, %15), scope: EncoderRNN/Embedding[embedding]
    %lengths : Long(1) = aten::to(%input_length, %14, %13, %15, %15), scope: EncoderRNN
    %input.1 : Float(10, 500), %batch_sizes : Long(10) = aten::_pack_padded_sequence(%input.7, %lengths, %15), scope: EncoderRNN
    %43 : int[] = prim::ListConstruct(%13, %18, %12), scope: EncoderRNN/GRU[gru]
    %hx : Float(4, 1, 500) = aten::zeros(%43, %11, %17, %14, %15), scope: EncoderRNN/GRU[gru]
    %45 : Tensor[] = prim::ListConstruct(%154, %153, %152, %151, %150, %149, %148, %147, %146, %145, %144, %143, %142, %141, %140, %139), scope: EncoderRNN/GRU[gru]
    %46 : Float(10, 1000), %encoder_hidden : Float(4, 1, 500) = aten::gru(%input.1, %batch_sizes, %hx, %45, %10, %9, %8, %15, %10), scope: EncoderRNN/GRU[gru]
    %48 : int = aten::size(%batch_sizes, %17), scope: EncoderRNN
    %max_seq_length : Long() = prim::NumToTensor(%48), scope: EncoderRNN
    %50 : int = prim::Int(%max_seq_length), scope: EncoderRNN
    %outputs : Float(10, 1, 1000), %52 : Long(1) = aten::_pad_packed_sequence(%46, %batch_sizes, %15, %7, %50), scope: EncoderRNN
    %53 : Float(10, 1, 1000) = aten::slice(%outputs, %17, %17, %6, %18), scope: EncoderRNN
    %54 : Float(10, 1, 1000) = aten::slice(%53, %18, %17, %6, %18), scope: EncoderRNN
    %55 : Float(10, 1!, 500) = aten::slice(%54, %9, %17, %12, %18), scope: EncoderRNN
    %56 : Float(10, 1, 1000) = aten::slice(%outputs, %17, %17, %6, %18), scope: EncoderRNN
    %57 : Float(10, 1, 1000) = aten::slice(%56, %18, %17, %6, %18), scope: EncoderRNN
    %58 : Float(10, 1!, 500) = aten::slice(%57, %9, %12, %6, %18), scope: EncoderRNN
    %encoder_outputs : Float(10, 1, 500) = aten::add(%55, %58, %18), scope: EncoderRNN
    %decoder_hidden.1 : Tensor = aten::slice(%encoder_hidden, %17, %17, %9, %18)
    %61 : int[] = prim::ListConstruct(%18, %18)
    %62 : Tensor = aten::ones(%61, %13, %5, %14, %4)
    %decoder_input.1 : Tensor = aten::mul(%62, %18)
    %64 : int[] = prim::ListConstruct(%17)
    %all_tokens.1 : Tensor = aten::zeros(%64, %13, %5, %14, %4)
    %66 : int[] = prim::ListConstruct(%17)
    %all_scores.1 : Tensor = aten::zeros(%66, %5, %5, %14, %4)
    %all_scores : Tensor, %all_tokens : Tensor, %decoder_hidden : Tensor, %decoder_input : Tensor = prim::Loop(%max_length, %10, %all_scores.1, %all_tokens.1, %decoder_hidden.1, %decoder_input.1)
      block0(%72 : int, %73 : Tensor, %74 : Tensor, %75 : Tensor, %76 : Tensor):
        %input.2 : Float(1, 1, 500) = aten::embedding(%138, %76, %16, %15, %15), scope: LuongAttnDecoderRNN/Embedding[embedding]
        %input.3 : Float(1, 1, 500) = aten::dropout(%input.2, %8, %15), scope: LuongAttnDecoderRNN/Dropout[embedding_dropout]
        %97 : Tensor[] = prim::ListConstruct(%137, %136, %135, %134, %133, %132, %131, %130), scope: LuongAttnDecoderRNN/GRU[gru]
        %hidden : Float(1, 1, 500), %decoder_hidden.2 : Float(2, 1, 500) = aten::gru(%input.3, %75, %97, %10, %9, %8, %15, %15, %15), scope: LuongAttnDecoderRNN/GRU[gru]
        %100 : Float(10, 1, 500) = aten::mul(%hidden, %encoder_outputs), scope: LuongAttnDecoderRNN/Attn[attn]
        %101 : int[] = prim::ListConstruct(%9), scope: LuongAttnDecoderRNN/Attn[attn]
        %attn_energies : Float(10, 1) = aten::sum(%100, %101, %15), scope: LuongAttnDecoderRNN/Attn[attn]
        %input.4 : Float(1!, 10) = aten::t(%attn_energies), scope: LuongAttnDecoderRNN/Attn[attn]
        %104 : Float(1, 10) = aten::softmax(%input.4, %18), scope: LuongAttnDecoderRNN/Attn[attn]
        %attn_weights : Float(1, 1, 10) = aten::unsqueeze(%104, %18), scope: LuongAttnDecoderRNN/Attn[attn]
        %106 : Float(1!, 10, 500) = aten::transpose(%encoder_outputs, %17, %18), scope: LuongAttnDecoderRNN
        %context.1 : Float(1, 1, 500) = aten::bmm(%attn_weights, %106), scope: LuongAttnDecoderRNN
        %rnn_output : Float(1, 500) = aten::squeeze(%hidden, %17), scope: LuongAttnDecoderRNN
        %context : Float(1, 500) = aten::squeeze(%context.1, %18), scope: LuongAttnDecoderRNN
        %110 : Tensor[] = prim::ListConstruct(%rnn_output, %context), scope: LuongAttnDecoderRNN
        %input.5 : Float(1, 1000) = aten::cat(%110, %18), scope: LuongAttnDecoderRNN
        %112 : Float(1000!, 500!) = aten::t(%129), scope: LuongAttnDecoderRNN/Linear[concat]
        %113 : Float(1, 500) = aten::addmm(%128, %input.5, %112, %18, %18), scope: LuongAttnDecoderRNN/Linear[concat]
        %input.6 : Float(1, 500) = aten::tanh(%113), scope: LuongAttnDecoderRNN
        %115 : Float(500!, 7826!) = aten::t(%127), scope: LuongAttnDecoderRNN/Linear[out]
        %input : Float(1, 7826) = aten::addmm(%126, %input.6, %115, %18, %18), scope: LuongAttnDecoderRNN/Linear[out]
        %decoder_output : Float(1, 7826) = aten::softmax(%input, %18), scope: LuongAttnDecoderRNN
        %decoder_scores : Tensor, %decoder_input.2 : Tensor = aten::max(%decoder_output, %18, %15)
        %120 : Tensor[] = prim::ListConstruct(%74, %decoder_input.2)
        %all_tokens.2 : Tensor = aten::cat(%120, %17)
        %122 : Tensor[] = prim::ListConstruct(%73, %decoder_scores)
        %all_scores.2 : Tensor = aten::cat(%122, %17)
        %decoder_input.3 : Tensor = aten::unsqueeze(%decoder_input.2, %17)
        -> (%10, %all_scores.2, %all_tokens.2, %decoder_hidden.2, %decoder_input.3)
    %125 : (Tensor, Tensor) = prim::TupleConstruct(%all_tokens, %all_scores)
    return (%125)

12.运行结果评估

# 评估例子
sentences = ["hello", "what's up?", "who are you?", "where am I?", "where are you from?"]
for s in sentences:
    evaluateExample(s, traced_encoder, traced_decoder, scripted_searcher, voc)

# 评估你的输入
#evaluateInput(traced_encoder, traced_decoder, scripted_searcher, voc)

• 输出

> hello
Bot: hello .
> what's up?
Bot: i m going to get my car .
> who are you?
Bot: i m the owner .
> where am I?
Bot: in the house .
> where are you from?
Bot: south america .

13.保存模型

 下方点击 |  阅读原文 | 了解更多