精华内容
下载资源
问答
  • pytorch seq2seq模型

    2020-02-19 22:43:50
    Seq2SeqEncoder , self ) . __init__ ( ** kwargs ) self . num_hiddens = num_hiddens self . num_layers = num_layers self . embedding = nn . Embedding ( vocab_size , embed_size ) self . rnn = ...

    机器翻译和数据集

    机器翻译(MT):将一段文本从一种语言自动翻译为另一种语言,用神经网络解决这个问题通常称为神经机器翻译(NMT)。 主要特征:输出是单词序列而不是单个单词。 输出序列的长度可能与源序列的长度不同。

    数据预处理

    将数据集清洗、转化为神经网络的输入minbatch

    with open('/home/kesci/input/fraeng6506/fra.txt', 'r') as f:
          raw_text = f.read()
    print(raw_text[0:1000])
    
    def preprocess_raw(text):
        text = text.replace('\u202f', ' ').replace('\xa0', ' ')
        out = ''
        for i, char in enumerate(text.lower()):
            if char in (',', '!', '.') and i > 0 and text[i-1] != ' ':
                out += ' '
            out += char
        return out
    
    text = preprocess_raw(raw_text)
    print(text[0:1000])
    

    Encoder-Decoder
    在这里插入图片描述

    class Encoder(nn.Module):
        def __init__(self, **kwargs):
            super(Encoder, self).__init__(**kwargs)
    
        def forward(self, X, *args):
            raise NotImplementedError
    
    class Decoder(nn.Module):
        def __init__(self, **kwargs):
            super(Decoder, self).__init__(**kwargs)
    
        def init_state(self, enc_outputs, *args):
            raise NotImplementedError
    
        def forward(self, X, state):
            raise NotImplementedError
    
    class EncoderDecoder(nn.Module):
        def __init__(self, encoder, decoder, **kwargs):
            super(EncoderDecoder, self).__init__(**kwargs)
            self.encoder = encoder
            self.decoder = decoder
    
        def forward(self, enc_X, dec_X, *args):
            enc_outputs = self.encoder(enc_X, *args)
            dec_state = self.decoder.init_state(enc_outputs, *args)
            return self.decoder(dec_X, dec_state)
    

    Sequence to Sequence模型
    在这里插入图片描述
    在这里插入图片描述

    class Seq2SeqEncoder(d2l.Encoder):
        def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                     dropout=0, **kwargs):
            super(Seq2SeqEncoder, self).__init__(**kwargs)
            self.num_hiddens=num_hiddens
            self.num_layers=num_layers
            self.embedding = nn.Embedding(vocab_size, embed_size)
            self.rnn = nn.LSTM(embed_size,num_hiddens, num_layers, dropout=dropout)
       
        def begin_state(self, batch_size, device):
            return [torch.zeros(size=(self.num_layers, batch_size, self.num_hiddens),  device=device),
                    torch.zeros(size=(self.num_layers, batch_size, self.num_hiddens),  device=device)]
        def forward(self, X, *args):
            X = self.embedding(X) # X shape: (batch_size, seq_len, embed_size)
            X = X.transpose(0, 1)  # RNN needs first axes to be time
            # state = self.begin_state(X.shape[1], device=X.device)
            out, state = self.rnn(X)
            # The shape of out is (seq_len, batch_size, num_hiddens).
            # state contains the hidden state and the memory cell
            # of the last time step, the shape is (num_layers, batch_size, num_hiddens)
            return out, state
    
    class Seq2SeqDecoder(d2l.Decoder):
        def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                     dropout=0, **kwargs):
            super(Seq2SeqDecoder, self).__init__(**kwargs)
            self.embedding = nn.Embedding(vocab_size, embed_size)
            self.rnn = nn.LSTM(embed_size,num_hiddens, num_layers, dropout=dropout)
            self.dense = nn.Linear(num_hiddens,vocab_size)
    
        def init_state(self, enc_outputs, *args):
            return enc_outputs[1]
    
        def forward(self, X, state):
            X = self.embedding(X).transpose(0, 1)
            out, state = self.rnn(X, state)
            # Make the batch to be the first dimension to simplify loss computation.
            out = self.dense(out).transpose(0, 1)
            return out, state
    

    Beam Search
    在这里插入图片描述

    展开全文
  • 准备深入学习一下神经网络的搭建方法的时候,选了机器翻译来试试,正好查了很多资料,...原文实现代码:https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html 其他博主的中文翻译及解释: ...

    准备深入学习一下神经网络的搭建方法的时候,选了机器翻译来试试,正好查了很多资料,发现pytorch里有例子。就结合自己的理解和探究记录一下。原文实现代码:https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html
    其他博主的中文翻译及解释:
    https://blog.csdn.net/u014514939/article/details/89410425?utm_medium=distribute.pc_relevant.none-task-blog-title-2&spm=1001.2101.3001.4242
    (此处只做大致流程和细节分析,完整代码上述原文就可获取)
    机器翻译流程:

    喂进神经网络前的数据准备与处理

    1.准备语料,也就是句子对,我找到的是英语-法语的语料,下载地址:https://download.pytorch.org/tutorial/data.zip
    在这里插入图片描述
    2.明确输入进神经网络的是怎样的数据,也就是怎样将数据处理成神经网络能理解的形式。我们这里不讨论one-hot、embedding等概念,只需要明白,将一个句子转化成数字来表示就可以,比如“i love you”,可能对应的向量形式就是[3,63,8],"i hate you"可能是[3,99,8],也就是句子中的每一个词都是由一个能表示他的数字来代指的(这个数字在此时并没有什么高深的意思,仅仅是个数字而已,就跟取名字一样)
    在这里插入图片描述
    为句子加上首尾标识SOS、EOS后转化为向量:
    (此处是我自己实现的代码,格式与原文有点不一样,但是表述的是这个意思)
    在这里插入图片描述

    Seq2Seq训练细节

    每一轮训练时数据的使用

    将句子对转化为向量后,就可以将其喂进神经网络中,这个机器翻译模型在开始训练后trainIters函数里。在训练时,每次喂进一对句子向量
    在这里插入图片描述
    需要注意的是,原文实现的代码里,将此处喂进去的向量全部转化为了列向量喂进去,如果自己实现代码不注意会报错。
    在这里插入图片描述

    而在encoder_decoder模型训练时每次喂进去的是一个句子中的一个词。
    在这里插入图片描述

    神经网络中train的细节

    在这里插入图片描述

    encoder的输入input_tensor[ei], encoder_hidden,在原文中input_tensor[ei] 是一个tensor([1])的单一元素,encoder_hidden在初始化时大小为tensor[1,1,256]
    在这里插入图片描述
    而在输入后,input_tensor经过embedding层输出形状是tensor([1,256]),之后经过.view(1,1,-1),形状变为tensor([1,1,256]),encoder的输出也是torch.Size([1, 1, 256])
    在这里插入图片描述
    在每一轮的encoder训练完后得到的输出encoder_output,encoder_hidden,由于是单个单词训练的结果,其实从内容上看是一样的,因此,encoder_outputs[ei]相当于保留了每一步每一个单词的state。

    在这里插入图片描述
    decoder中由于名义上不知道句子的第一个开头词是什么,因此使用通用标识SOS来作为句子的第一个输入。
    在这里插入图片描述
    对于decoder的三个输入decoder_input, decoder_hidden, encoder_outputs:
    decoder_input即是目标句子的此轮输入进去的单词向量,大小为tensor.size([1])
    decoder_hidden是直接继承自encoder_hidden,此时的encoder_hidden是原句子最后一个单词的输出,大致来说,这样一个输出可以看做是包含了一整个句子的信息,大小是tensor.size([1,1,256])
    encoder_outputs[ei]则是保存了一个句子中所有词的当时输出的状态。encoder_outputs的大小是torch.Size([10, 256])

    decoder内部
    class AttnDecoderRNN(nn.Module):
        def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
            super(AttnDecoderRNN, self).__init__()
            self.hidden_size = hidden_size
            self.output_size = output_size
            self.dropout_p = dropout_p
            self.max_length = max_length
    
            self.embedding = nn.Embedding(self.output_size, self.hidden_size)
            self.attn = nn.Linear(self.hidden_size * 2, self.max_length)
            self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)
            self.dropout = nn.Dropout(self.dropout_p)
            self.gru = nn.GRU(self.hidden_size, self.hidden_size)
            self.out = nn.Linear(self.hidden_size, self.output_size)
    
        def forward(self, input, hidden, encoder_outputs):
            embedded = self.embedding(input).view(1, 1, -1)
            embedded = self.dropout(embedded)
    
            attn_weights = F.softmax(
                self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)
            print(342, torch.cat((embedded[0], hidden[0]), 1).size(), attn_weights)
            attn_applied = torch.bmm(attn_weights.unsqueeze(0),
                                     encoder_outputs.unsqueeze(0))  #必须有三个维度
            output = torch.cat((embedded[0], attn_applied[0]), 1)
            output = self.attn_combine(output).unsqueeze(0)
            output = F.relu(output)
            output, hidden = self.gru(output, hidden)
            output = F.log_softmax(self.out(output[0]), dim=1)
            print(output.size(), hidden.size(), attn_weights.size())
            return output, hidden, attn_weights
    

    这里首先要注意的是decoder的输入和输出output_size都是法语词表的大小,而具体到最后的三个输出output,hidden,attn_weight各自的大小为torch.Size([1, 79]) torch.Size([1, 1, 256]) torch.Size([1, 10])。至于output的大小原因,因为对于decoder来说,最终是为了确定在法语词表中哪个词的可能性最大,因此它最后一层实际上可以看做一个分类类别为词表大小的分类模型。

    attention的问题

    一般而言attention的思想用比较简单的话来说就是两个向量之间的相似度,他的方法有很多简单的乘法,点积,还有各种公式,但是我理解的便是两个向量之间越相似,方向越接近,他们点乘后就越大
    在这里插入图片描述
    如图两个红色向量因为方向近似,相乘后会是一个正的较大的值,而绿色的和红色的方向相悖(不相似),他们乘出来会使一个负值。
    而关于原文attention实现的问题,我在看的时候就很困惑觉得无法理解,查阅大量资料也没有结果,最后在某个角落找到了这种实现attention的方法其实错的,因此如果无法理解建议去看论文或者别的例子的attention实现。
    查错指路:https://zhuanlan.zhihu.com/p/68637282

    在这里插入图片描述

    展开全文
  • output_paded,seq_len = pad_packed_sequence(output,batch_first=True,padding_value=config.ns.PAD) return output_paded,hidden #[1,batch_size,encoder_hidden_size]  decoder.py """ 实现解码器 "...

    num_sequence.py

    """
    数字序列化方法
    """
    
    class NumSequence:
        """
        input : intintint
        output :[int,int,int]
        """
        PAD_TAG = "<PAD>"
        UNK_TAG = "<UNK>"
        SOS_TAG = "<SOS>"
        EOS_TAG = "<EOS>"
    
        PAD = 0
        UNK = 1
        SOS = 2
        EOS = 3
    
        def __init__(self):
            self.dict = {
                self.PAD_TAG:self.PAD,
                self.UNK_TAG: self.UNK,
                self.SOS_TAG: self.SOS,
                self.EOS_TAG: self.EOS
            }
            #0--》int ,1--->int,2--->int
            for i in range(0,10):
                self.dict[str(i)] = len(self.dict)
            self.inverse_dict = dict(zip(self.dict.values(),self.dict.keys()))
    
        def transform(self,sentence,max_len=None,add_eos=False):
            """
            实现转化为数字序列
            :param sentence: list() ,["1","2","5"...str]
            :param max_len: int
            :param add_eos: 是否要添加结束符
            :return: [int,int,int]
    
            """
    
            if add_eos : #不是必须的,仅仅是为了最终句子的长度=设置的max;如果没有,最终的句子长度= max_len+1
                max_len = max_len - 1
            if max_len is not None:
                if len(sentence)> max_len:
                    sentence = sentence[:max_len]
                else:
                    sentence = sentence + [self.PAD_TAG]*(max_len-len(sentence))
            if add_eos:
                if sentence[-1] == self.PAD_TAG:  #句子中有PAD,在PAD之前添加EOS
                    pad_index = sentence.index(self.PAD_TAG)
                    sentence.insert(pad_index,self.EOS_TAG)
                else:#句子中没有PAD,在最后添加EOS
                    sentence += [self.EOS_TAG]
    
            return [self.dict.get(i,self.UNK) for i in sentence]
    
        def inverse_transform(self,incides):
            """
            把序列转化为数字
            :param incides:[1,3,4,5,2,]
            :return: "12312312"
            """
            result = []
            for i in incides:
                temp = self.inverse_dict.get(i, self.UNK_TAG)
                if temp != self.EOS_TAG:  #把EOS之后的内容删除,123---》1230EOS,predict 1230EOS123
                    result.append(temp)
                else:
                    break
    
            return "".join(result)
    
        def __len__(self):
            return len(self.dict)
    
    
    if __name__ == '__main__':
        num_Sequence = NumSequence()
        print(num_Sequence.dict)
        s = list("123123")
        ret = num_Sequence.transform(s)
        print(ret)
        ret = num_Sequence.inverse_transform(ret)
        print(ret)
    

      dataset.py

    """
    准备数据集
    """
    from torch.utils.data import DataLoader,Dataset
    import numpy as np
    import config
    import torch
    
    class NumDataset(Dataset):
        def __init__(self,train=True):
            np.random.seed(9) if train else np.random.seed(10)
            self.size = 400000 if train else 100000
            self.data = np.random.randint(1,1e8,size=self.size)
    
        def __len__(self):
            return self.size
    
        def __getitem__(self, idx):
            input = list(str(self.data[idx]))
            target = input+["0"]
            return input,target,len(input),len(target)
    
    def collate_fn(batch):
        """
        :param batch:[(一个getitem的结果),(一个getitem的结果),(一个getitem的结果)、、、、]
        :return:
        """
        #把batch中的数据按照input的长度降序排序
        batch = sorted(batch,key=lambda x:x[-2],reverse=True)
        input,target,input_len,target_len = zip(*batch)
        input = torch.LongTensor([config.ns.transform(i,max_len=config.max_len) for i in input])
        target = torch.LongTensor([config.ns.transform(i,max_len=config.max_len,add_eos=True) for i in target])
        input_len = torch.LongTensor(input_len)
        target_len = torch.LongTensor(target_len)
        return input,target,input_len,target_len
    
    def get_dataloader(train=True):
        batch_size = config.train_batchsize if train else config.test_batch_size
        return DataLoader(NumDataset(train),batch_size=batch_size,shuffle=False,collate_fn=collate_fn)
    
    
    if __name__ == '__main__':
        loader = get_dataloader(train=False)
        for idx,(input,target,input_len,target_len) in enumerate(loader):
            print(idx)
            print(input)
            print(target)
            print(input_len)
            print(target_len)
            break
    

      config.py

    """
    配置文件
    """
    from num_sequence import NumSequence
    import torch
    
    device= torch.device("cpu")
    # device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
    train_batchsize = 256
    test_batch_size = 1000
    
    
    ns = NumSequence()
    max_len = 10
    

      encoder.py

    """
    进行编码
    """
    
    import torch.nn as nn
    from torch.nn.utils.rnn import pad_packed_sequence,pack_padded_sequence
    import config
    
    
    class Encoder(nn.Module):
        def __init__(self):
            super(Encoder,self).__init__()
            self.embedding = nn.Embedding(num_embeddings=len(config.ns),
                                         embedding_dim=50,
                                         padding_idx=config.ns.PAD
                                         )
            self.gru = nn.GRU(input_size=50,
                              hidden_size=64,
                              num_layers=1,
                              batch_first=True,
                              bidirectional=False,
                              dropout=0)
    
    
        def forward(self, input,input_len):
            input_embeded = self.embedding(input)
    
            #对输入进行打包
            input_packed = pack_padded_sequence(input_embeded,input_len,batch_first=True)
            #经过GRU处理
            output,hidden = self.gru(input_packed)
            # print("encoder gru hidden:",hidden.size())
            #进行解包
            output_paded,seq_len = pad_packed_sequence(output,batch_first=True,padding_value=config.ns.PAD)
            return output_paded,hidden  #[1,batch_size,encoder_hidden_size]
    

      decoder.py

    """
    实现解码器
    """
    import torch.nn as nn
    import config
    import torch
    import torch.nn.functional as F
    import numpy as np
    
    
    class Decoder(nn.Module):
        def __init__(self):
            super(Decoder,self).__init__()
    
            self.embedding = nn.Embedding(num_embeddings=len(config.ns),
                                          embedding_dim=50,
                                          padding_idx=config.ns.PAD)
    
            #需要的hidden_state形状:[1,batch_size,64]
            self.gru = nn.GRU(input_size=50,
                              hidden_size=64,
                              num_layers=1,
                              bidirectional=False,
                              batch_first=True,
                              dropout=0)
    
            #假如encoder的hidden_size=64,num_layer=1 encoder_hidden :[2,batch_sizee,64]
    
            self.fc = nn.Linear(64,len(config.ns))
    
        def forward(self, encoder_hidden):
    
            #第一个时间步的输入的hidden_state
            decoder_hidden = encoder_hidden  #[1,batch_size,encoder_hidden_size]
            #第一个时间步的输入的input
            batch_size = encoder_hidden.size(1)
            decoder_input = torch.LongTensor([[config.ns.SOS]]*batch_size).to(config.device)         #[batch_size,1]
            # print("decoder_input:",decoder_input.size())
    
    
            #使用全为0的数组保存数据,[batch_size,max_len,vocab_size]
            decoder_outputs = torch.zeros([batch_size,config.max_len,len(config.ns)]).to(config.device)
    
            for t in range(config.max_len):
                decoder_output_t,decoder_hidden = self.forward_step(decoder_input,decoder_hidden)
                decoder_outputs[:,t,:] = decoder_output_t
    
                #获取当前时间步的预测值
                value,index = decoder_output_t.max(dim=-1)
                decoder_input = index.unsqueeze(-1)  #[batch_size,1]
                # print("decoder_input:",decoder_input.size())
            return decoder_outputs,decoder_hidden
    
    
        def forward_step(self,decoder_input,decoder_hidden):
            '''
            计算一个时间步的结果
            :param decoder_input: [batch_size,1]
            :param decoder_hidden: [batch_size,encoder_hidden_size]
            :return:
            '''
    
            decoder_input_embeded = self.embedding(decoder_input)
            # print("decoder_input_embeded:",decoder_input_embeded.size())
    
            out,decoder_hidden = self.gru(decoder_input_embeded,decoder_hidden)
    
            #out :【batch_size,1,hidden_size】
    
            out_squeezed = out.squeeze(dim=1) #去掉为1的维度
            out_fc = F.log_softmax(self.fc(out_squeezed),dim=-1) #[bathc_size,vocab_size]
            # out_fc.unsqueeze_(dim=1) #[bathc_size,1,vocab_size]
            # print("out_fc:",out_fc.size())
            return out_fc,decoder_hidden
    
        def evaluate(self,encoder_hidden):
    
            # 第一个时间步的输入的hidden_state
            decoder_hidden = encoder_hidden  # [1,batch_size,encoder_hidden_size]
            # 第一个时间步的输入的input
            batch_size = encoder_hidden.size(1)
            decoder_input = torch.LongTensor([[config.ns.SOS]] * batch_size).to(config.device)  # [batch_size,1]
            # print("decoder_input:",decoder_input.size())
    
            # 使用全为0的数组保存数据,[batch_size,max_len,vocab_size]
            decoder_outputs = torch.zeros([batch_size, config.max_len, len(config.ns)]).to(config.device)
    
            decoder_predict = []  #[[],[],[]]  #123456  ,targe:123456EOS,predict:123456EOS123
            for t in range(config.max_len):
                decoder_output_t, decoder_hidden = self.forward_step(decoder_input, decoder_hidden)
                decoder_outputs[:, t, :] = decoder_output_t
    
                # 获取当前时间步的预测值
                value, index = decoder_output_t.max(dim=-1)
                decoder_input = index.unsqueeze(-1)  # [batch_size,1]
                # print("decoder_input:",decoder_input.size())
                decoder_predict.append(index.cpu().detach().numpy())
    
            #返回预测值
            decoder_predict = np.array(decoder_predict).transpose() #[batch_size,max_len]
            return decoder_outputs, decoder_predict
    

      seq2seq.py

    """
    完成seq2seq模型
    """
    import torch.nn as nn
    from encoder import Encoder
    from decoder import Decoder
    
    
    class Seq2Seq(nn.Module):
        def __init__(self):
            super(Seq2Seq,self).__init__()
            self.encoder = Encoder()
            self.decoder = Decoder()
    
        def forward(self, input,input_len):
            encoder_outputs,encoder_hidden = self.encoder(input,input_len)
            decoder_outputs,decoder_hidden = self.decoder(encoder_hidden)
            return decoder_outputs
    
        def evaluate(self,input,input_len):
            encoder_outputs, encoder_hidden = self.encoder(input, input_len)
            decoder_outputs, decoder_predict = self.decoder.evaluate(encoder_hidden)
            return decoder_outputs,decoder_predict
    

      train.py

    """
    进行模型的训练
    """
    import torch
    import torch.nn.functional as F
    from seq2seq import Seq2Seq
    from torch.optim import Adam
    from dataset import get_dataloader
    from tqdm import tqdm
    import config
    import numpy as np
    import pickle
    from matplotlib import pyplot as plt
    from eval import eval
    import os
    
    model = Seq2Seq().to(config.device)
    optimizer = Adam(model.parameters())
    
    if os.path.exists("./models/model.pkl"):
        model.load_state_dict(torch.load("./models/model.pkl"))
        optimizer.load_state_dict(torch.load("./models/optimizer.pkl"))
    
    loss_list = []
    
    def train(epoch):
        data_loader = get_dataloader(train=True)
        bar = tqdm(data_loader,total=len(data_loader))
    
        for idx,(input,target,input_len,target_len) in enumerate(bar):
            input = input.to(config.device)
            target = target.to(config.device)
            input_len = input_len.to(config.device)
            optimizer.zero_grad()
            decoder_outputs = model(input,input_len) #[batch_Size,max_len,vocab_size]
            predict = decoder_outputs.view(-1,len(config.ns))
            target = target.view(-1)
            loss = F.nll_loss(predict,target,ignore_index=config.ns.PAD)
            loss.backward()
            optimizer.step()
            loss_list.append(loss.item())
            bar.set_description("epoch:{} idx:{} loss:{:.6f}".format(epoch,idx,np.mean(loss_list)))
    
            if idx%100 == 0:
                torch.save(model.state_dict(),"./models/model.pkl")
                torch.save(optimizer.state_dict(),"./models/optimizer.pkl")
                pickle.dump(loss_list,open("./models/loss_list.pkl","wb"))
    
    
    if __name__ == '__main__':
        for i in range(5):
            train(i)
            eval()
    
        plt.figure(figsize=(50,8))
        plt.plot(range(len(loss_list)),loss_list)
        plt.show()
    

      eval.py

    """
    进行模型的评估
    """
    
    import torch
    import torch.nn.functional as F
    from seq2seq import Seq2Seq
    from torch.optim import Adam
    from dataset import get_dataloader
    from tqdm import tqdm
    import config
    import numpy as np
    import pickle
    from matplotlib import pyplot as plt
    
    
    
    def eval():
        model = Seq2Seq().to(config.device)
        model.load_state_dict(torch.load("./models/model.pkl"))
    
        loss_list = []
        acc_list = []
        data_loader = get_dataloader(train=False) #获取测试集
        with torch.no_grad():
            for idx,(input,target,input_len,target_len) in enumerate(data_loader):
                input = input.to(config.device)
                # target = target #[batch_size,max_len]
                input_len = input_len.to(config.device)
                #decoder_predict:[batch_size,max_len]
                decoder_outputs,decoder_predict = model.evaluate(input,input_len) #[batch_Size,max_len,vocab_size]
                loss = F.nll_loss(decoder_outputs.view(-1,len(config.ns)),target.to(config.device).view(-1),ignore_index=config.ns.PAD)
                loss_list.append(loss.item())
    
                #把traget 和 decoder_predict进行inverse_transform
                target_inverse_tranformed = [config.ns.inverse_transform(i) for i in target.numpy()]
                predict_inverse_tranformed = [config.ns.inverse_transform(i)for i in decoder_predict]
                cur_eq =[1 if target_inverse_tranformed[i] == predict_inverse_tranformed[i] else 0 for i in range(len(target_inverse_tranformed))]
                acc_list.extend(cur_eq)
                # print(np.mean(cur_eq))
    
    
        print("mean acc:{} mean loss:{:.6f}".format(np.mean(acc_list),np.mean(loss_list)))
    
    
    
    def interface(_input): #进行预测
        model = Seq2Seq().to(config.device)
        model.load_state_dict(torch.load("./models/model.pkl"))
        input = list(str(_input))
        input_len = torch.LongTensor([len(input)]) #[1]
        input = torch.LongTensor([config.ns.transform(input)])  #[1,max_len]
    
        with torch.no_grad():
            input = input.to(config.device)
            input_len = input_len.to(config.device)
            _, decoder_predict = model.evaluate(input, input_len)  # [batch_Size,max_len,vocab_size]
            # decoder_predict进行inverse_transform
            pred = [config.ns.inverse_transform(i) for i in decoder_predict]
            print(_input,"---->",pred[0])
    
    
    if __name__ == '__main__':
        interface("89767678")
    

      

    展开全文
  • SRC 符号解释: 蓝色框表示可训练网络 绿色框表示函数 红色框表示数据

    SRC


    在这里插入图片描述

    符号解释:

    • 蓝色框表示可训练网络
    • 绿色框表示函数
    • 红色框表示数据
    展开全文
  • """test"""importnumpy as npimporttorchimporttorch.nn as nnimporttorch.optim as optimfrom torch.autograd importVariable#创建字典seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'], ['...
  • NLP 机器翻译(Machine Translation)之 Pytorch+seq2seq + attention 目录seq2seq于机器翻译中的应用seq2seq + attention 于机器翻译中的原理seq2seq+att 的模型框架及attention 计算python 实现bleu ,NLTK调包...
  • from seq2seq import Seq2Seq from torch.optim import Adam from dataset import get_dataloader from tqdm import tqdm import config import numpy as np import pickle from matplotlib import pyplot as plt ...
  • 如果要查看图文版教程,请到 http://studyai.com/pytorch-1.4/intermediate/seq2seq_translation_tutorial.html 在这个项目中,我们将教一个神经网络,把法语翻译成英语。 [KEY: > input, = target, < output]...
  • 问题说明 ...说明: 每个序列都补充为定长, 那么就不算是Seq问题了 补充为定长,https://github.com/ruclion/bilingual-ppg/blob/EnglishASR-hujiankun590-1019/ppg_decode_spec_DataBakerCN/dataload_Data.
  • cut_sentence.py ...2. 实现按照词语分词 2.1 加载词典 3. 使用停用词 """ import string import jieba import jieba.posseg as psg import logging stopwords_path = "../corpus/stopwords.txt" ...
  • PyTorch Seq2Seq Note: This repo only works with torchtext 0.9 or above which requires PyTorch 1.8 or above. If you are using torchtext 0.8 then please use this branch This repo contains tutorials ...
  • #[batch_size,128*2] #context_vector:[batch_size,128*2] --> 128*4 #attention_result = [batch_size,128*4] --->[batch_size,128*2] attention_result = torch.tanh(self.fc_attn(torch.cat([context_vector,...
  • Pytorch实现Seq2Seq

    2020-04-10 09:27:03
    前言 Seq2Seq模型用来处理nlp中序列到序列的问题,是一种常见的Encoder-Decoder模型架构,基于RNN同时解决了RNN的一些弊端(输入和输入必须是等长的)。...本文主要介绍如何用Pytorch实现Seq2Seq模型。...
  • https://blog.csdn.net/wuzqchom/article/details/75792501 ...amp;wfr=spider&amp;for=pc pytorch源码 这是李宏毅老师的ppt。右侧对应pytorch seq2seq源码。 我们的问题是,左边的数学符号,右侧...
  • 今天小编就为大家分享一篇pytorch实现seq2seq时对loss进行mask的方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • pytorch-seq2seq-example:基于实用pytorch和更多额外功能的完全批处理的seq2seq示例
  • 使用PyTorchSeq2Seq聊天机器人实现功能:Seq2Seq +光束搜索+ antiLM 要求 Python3 火炬0.3 语料库 用法 训练 python train . py 测试 python console python console . py . / ckpt model 光束搜索示例: me: ...
  • PyTorch中的Seq2seq代码 根据和 数据预处理: 我使用以下步骤 > config/WMT14/download.sh # download WMT14 data into raw_data/WMT14 > config/WMT14/prepare.sh # preprocess the data, and copy the files to ...
  • PyTorch》Part6 PyTorchseq2seq 基于PyTorch实现聊天机器人。 在这里插入代码片 运行结果: 在这里插入代码片
  • Pytorch-seq2seq-光束搜索 带有注意力和贪婪搜索/波束搜索的Seq2Seq模型,用于在PyTorch中进行神经机器翻译。 此实现着重于以下功能: 用于其他项目的模块化结构 最少的代码以提高可读性 充分利用批处理和GPU。 ...
  • PyTorchseq2seq模型的一个框架
  • pytorch-seq2seq文档这是在PyTorch中实现的序列到序列(seq2seq)模型的框架。 该框架具有用于seq2seq模型,训练和推论,检查点的模块化和可扩展组件pytorch-seq2seq文档这是在PyTorch中实现的序列到序列(seq2seq)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,789
精华内容 2,715
关键字:

pytorchseq2seq