头歌——机器、深度学习——RNN循环神经网络

小何爱编程2024

已于 2024-06-15 21:24:13 修改

阅读量1k

点赞数 17

分类专栏：头歌深度学习机器学习文章标签：深度学习 rnn 人工智能机器学习

于 2024-06-13 16:54:58 首次发布

本文链接：https://blog.csdn.net/absths/article/details/139658172

版权

机器学习同时被 3 个专栏收录

18 篇文章 1 订阅

订阅专栏

头歌

17 篇文章 0 订阅

订阅专栏

深度学习

11 篇文章 0 订阅

订阅专栏

第1关：Attention注意力机制

任务描述

本关任务：了解循环神经网络中的Attention注意力机制并回答相关问题

第1关任务——选择题

1、深度学习模型引入注意力机制的主要原因有：  （A）
    A、有利于将有限的计算资源用来处理更重要信息。
    B、减少模型参数量。
    C、防止梯度消失。
    D、防止梯度爆炸。

2、Attention计算的形式有哪几种。  (ABC)
    A、点乘形式
    B、加权点乘形式
    C、求和形式
    D、求导形式

3、seq2seq机器翻译模型中引入Attention的原因是？    (B)
    A、建立词向量之间的长依赖关系。
    B、使输入词向量更加有区分度、辨识度。
    C、减少模型参数量
    D、加快训练过程。

4、Self-Attention主要是为了解决什么样的问题？   (C)
    A、梯度消失问题
    B、梯度爆炸问题
    C、长距离依赖问题
    D、收敛速度问题

5、机器翻译任务中的Self-Attention的核心思想是？    (A)
    A、利用词向量生成的查询向量Q建立与其他词向量生成的键向量K之间的权重关系，从而加权到值向量V形成词向量之间的注意力。
    B、利用词向量生成的键向量K建立与其他词向量生成的值向量V之间的权重关系，从而加权到查询向量Q形成词向量之间的注意力。
    C、利用词向量生成的查询向量Q建立与其他词向量生成的查询向量Q之间权重关系，形成词向量之前的注意力。
    D、利用词向量生成的值向量Q建立与其他词向量生成的值向量Q之间权重关系，形成词向量之前的注意力。

第2关：Seq2Seq

任务描述

本关任务：使用pytorch框架编写一个Seq2Seq模型

第2关任务代码

平台会对你编写的代码进行测试：

测试输入："highh"
预期输出："low"

测试输入："kingh" 预期输出："queen"

提示：模型讲解中各模块的定义。

开始你的任务吧，祝你成功！

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
 
dtype = torch.FloatTensor
char_list = [c for c in 'SEPabcdefghijklmnopqrstuvwxyz']
char_dic = {n: i for i, n in enumerate(char_list)}
seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'], ['girl', 'boy'], ['up', 'down'], ['high', 'low']]
seq_len = 8
n_hidden = 128
n_class = len(char_list)
batch_size = len(seq_data)
 
##########Begin##########
#对数据进行编码部分
def make_batch(seq_data):
    batch_size = len(seq_data)
    input_batch,output_batch,target_batch = [],[],[]
    for seq in seq_data:
        for i in range(2):
            seq[i] += 'P' * (seq_len - len(seq[i]))
        input = [char_dic[n] for n in seq[0]]
        output = [char_dic[n] for n in ('S' + seq[1])]
        target = [char_dic[n] for n in (seq[1] + 'E')]
    
        input_batch.append(np.eye(n_class)[input])
        output_batch.append(np.eye(n_class)[output])
        target_batch.append(target)
    
    return Variable(torch.Tensor(input_batch)),Variable(torch.Tensor(output_batch)),Variable(torch.LongTensor(target_batch))
input_batch,output_batch,target_batch=make_batch(seq_data)
##########End##########
 
 
##########Begin##########
#模型类定义
class Seq2Seq(nn.Module):
    def __init__(self):
        super(Seq2Seq,self).__init__()
        self.encoder = nn.RNN(input_size = n_class,hidden_size = n_hidden)
        self.decoder = nn.RNN(input_size = n_class,hidden_size = n_hidden)
        self.fc = nn.Linear(n_hidden,n_class)
    def forward(self,enc_input,enc_hidden,dec_input):
        enc_input = enc_input.transpose(0,1) #需要将向量的第一第二维度进行转换
        dec_input = dec_input.transpose(0,1)
        
        _,h_states = self.encoder(enc_input,enc_hidden)
        outputs,_ = self.decoder(dec_input,h_states)
        outputs = self.fc(outputs)
        return outputs
##########End##########
 
model = Seq2Seq()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
##########Begin##########
#模型训练过程
for epoch in range(5001):
    hidden = Variable(torch.zeros(1,batch_size,n_hidden))
    optimizer.zero_grad()
    
    outputs = model(input_batch,hidden,output_batch)
    outputs = outputs.transpose(0,1)
    
    loss = 0
    for i in range(batch_size):
        loss += criterion(outputs[i],target_batch[i])
    # if (epoch % 500) == 0:
    #     print('epoch:{},loss:{}'.format(epoch,loss))
    loss.backward()
    optimizer.step()
##########End##########
 
 
##########Begin##########
#模型验证过程函数
def translated(word):
    input_batch,output_batch,_ = make_batch([[word,'P'*len(word)]])
    hidden = Variable(torch.zeros(1,1,n_hidden))
    outputs = model(input_batch,hidden,output_batch)
    predict = outputs.data.max(2,keepdim=True)[1]
    decode = [char_list[i] for i in predict]
    end = decode.index('P')
    translated = ''.join(decode[:end])
    print(translated)
##########End##########
 
translated('highh')
translated('kingh')