深度学习作业九 RNN-SRN-Seq2Seq

server/2024/11/30 4:32:03/

目录

1. 实现SRN

（1）使用Numpy

（2）在1的基础上，增加激活函数tanh

（3）使用nn.RNNCell实现

（4）使用nn.RNN实现

2. 实现“序列到序列”

3. “编码器-解码器”的简单实现

4.谈一谈对“序列”、“序列到序列”的理解

4.1序列

4.2序列到序列

5.总结本周理论课和作业，写心得体会

1. 实现SRN

（1）使用Numpy

代码如下：

import numpy as npinputs = np.array([[1., 1.],[1., 1.],[2., 2.]])  # 初始化输入序列
print('inputs is ', inputs)state_t = np.zeros(2, )  # 初始化存储器
print('state_t is ', state_t)w1, w2, w3, w4, w5, w6, w7, w8 = 1., 1., 1., 1., 1., 1., 1., 1.
U1, U2, U3, U4 = 1., 1., 1., 1.
for input_t in inputs:print('inputs is ', input_t)print('state_t is ', state_t)in_h1 = np.dot([w1, w3], input_t) + np.dot([U2, U4], state_t)in_h2 = np.dot([w2, w4], input_t) + np.dot([U1, U3], state_t)state_t = in_h1, in_h2output_y1 = np.dot([w5, w7], [in_h1, in_h2])output_y2 = np.dot([w6, w8], [in_h1, in_h2])print('output_y is ', output_y1, output_y2)print('---------------------')

 运行结果：

如何算的呢？

如图，第一次输入x1，x2,均为1，此时a1，a2值为0，权重均为1，所以h1=w1*x1+w3*x2=2，h2=w2*x1+w4*x2=2，同时将h1，h2存入a1，a2中，a1=2，a2=2，之后y1=w5*h1+w7*h2=4，y2=w6*h1+w8*h2=4.

第二次输入x1，x2均为1，此时a1=2，a2=2，所以h1=w1*x1+w3*x2+u2*a1+u4*a2=6，h2=w2*x1+w4*x2+u1*a1+u3*a2=6，同时将h1，h2存入a1，a2中，a1=6，a2=6，之后y1=w5*h1+w7*h2=12，y2=w6*h1+w8*h2=12.

第三次输入x1，x2均为2，此时a1=6，a2=6，所以h1=w1*x1+w3*x2+u2*a1+u4*a2=16，h2=w2*x1+w4*x2+u1*a1+u3*a2=16，同时将h1，h2存入a1，a2中，a1=16，a2=16，之后y1=w5*h1+w7*h2=32，y2=w6*h1+w8*h2=32.

（2）在1的基础上，增加激活函数tanh

注：只在输入层到隐藏层使用了激活函数tanh，隐藏层到输出层激活函数依旧为linear

代码如下：

for input_t in inputs:print('inputs is ', input_t)print('state_t is ', state_t)in_h1 = np.tanh(np.dot([w1, w3], input_t) + np.dot([U2, U4], state_t))in_h2 = np.tanh(np.dot([w2, w4], input_t) + np.dot([U1, U3], state_t))state_t = in_h1, in_h2output_y1 = np.dot([w5, w7], [in_h1, in_h2])output_y2 = np.dot([w6, w8], [in_h1, in_h2])print('output_y is ', output_y1, output_y2)print('---------------------------------------------')

运行结果：

 

（3）使用nn.RNNCell实现

nn.RNNCell 是一个单步 RNN 单元，用于手动处理每一个时间步的数据。它适合需要细粒度控制或对序列操作的情景。

参数

  • input_size: 输入特征的维度。
  • hidden_size: 隐藏状态的维度。
  • bias: 是否包含偏置项，默认是 True。
  • nonlinearity: 激活函数类型，可选 'tanh' 或 'relu'，默认是 'tanh'。

使用步骤

  1. 定义一个 nn.RNNCell 实例，指定输入和隐藏层的维度。
  2. 初始化隐藏状态，一般是零张量。
  3. 手动遍历输入序列，在每个时间步调用 rnn_cell(input_t, hidden_t)。

主要就是实现上图这个功能（store） 

代码如下：

batch_size = 1
seq_len = 3  # 序列长度
input_size = 2  # 输入序列维度
hidden_size = 2  # 隐藏层维度
output_size = 2  # 输出层维度# RNNCell
cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
# 初始化参数，权重为1，偏置为0
for name, param in cell.named_parameters():if name.startswith("weight"):torch.nn.init.ones_(param)else:torch.nn.init.zeros_(param)
# 线性层
liner = torch.nn.Linear(hidden_size, output_size)
liner.weight.data = torch.Tensor([[1, 1], [1, 1]])
liner.bias.data = torch.Tensor([0.0])seq = torch.Tensor([[[1, 1]],[[1, 1]],[[2, 2]]])
hidden = torch.zeros(batch_size, hidden_size)
output = torch.zeros(batch_size, output_size)for idx, input in enumerate(seq):print('=' * 20, idx, '=' * 20)print('Input :', input)print('hidden :', hidden)hidden = cell(input, hidden)output = liner(hidden)print('output :', output)

运行结果：

对比上面numpy实现的结果相差不大

（4）使用nn.RNN实现

nn.RNN 是一个完整的 RNN 模块，可以一次性处理整个序列。它内部会自动迭代时间步并更新隐藏状态。

参数

  • input_size: 输入特征的维度。
  • hidden_size: 隐藏状态的维度。
  • num_layers: RNN 的层数，默认为 1。
  • nonlinearity: 激活函数类型，可选 'tanh' 或 'relu'，默认是 'tanh'。
  • batch_first: 若为 True，输入和输出的维度格式为 (batch_size, seq_len, input_size)；否则为 (seq_len, batch_size, input_size)。

返回值

  • output: 所有时间步的隐藏状态 (seq_len, batch_size, hidden_size)。
  • h_n: 最后一个时间步的隐藏状态 (num_layers, batch_size, hidden_size)。

使用步骤

  1. 定义一个 nn.RNN 实例，指定输入和隐藏层的维度。
  2. 初始化隐藏状态（可选）。
  3. 将输入序列和初始隐藏状态传入 rnn(inputs, hidden)。

代码如下：

batch_size = 1
seq_len = 3
input_size = 2
hidden_size = 2
num_layers = 1
output_size = 2cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers)
for name, param in cell.named_parameters():  # 初始化参数if name.startswith("weight"):torch.nn.init.ones_(param)else:torch.nn.init.zeros_(param)# 线性层
liner = torch.nn.Linear(hidden_size, output_size)
liner.weight.data = torch.Tensor([[1, 1], [1, 1]])
liner.bias.data = torch.Tensor([0.0])inputs = torch.Tensor([[[1, 1]],[[1, 1]],[[2, 2]]])
hidden = torch.zeros(num_layers, batch_size, hidden_size)
out, hidden = cell(inputs, hidden)
print("out:", out)
print("hidden:", hidden)
print('--------------------------------------')print('Input :', inputs[0])
print('hidden:', 0, 0)
print('Output:', liner(out[0]))
print('--------------------------------------')
print('Input :', inputs[1])
print('hidden:', out[0])
print('Output:', liner(out[1]))
print('--------------------------------------')
print('Input :', inputs[2])
print('hidden:', out[1])
print('Output:', liner(out[2]))

运行结果：

 

结果对比一样。 

2. 实现“序列到序列”

观看视频，学习RNN原理，并实现视频P12中的教学案例

12.循环神经网络（基础篇）_哔哩哔哩_bilibili

代码如下：

input_size = 4
hidden_size = 4
batch_size = 1idx2char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 2, 3]
y_data = [3, 1, 2, 3, 2]one_hot_lookup = [[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]]
x_one_hot = [one_hot_lookup[x] for x in x_data]inputs = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
labels = torch.LongTensor(y_data).view(-1, 1)class Model(torch.nn.Module):def __init__(self, input_size, hidden_size, batch_size):super(Model, self).__init__()self.batch_size = batch_sizeself.input_size = input_sizeself.hidden_size = hidden_sizeself.rnncell = torch.nn.RNNCell(input_size=self.input_size, hidden_size=self.hidden_size)def forward(self, input, hidden):hidden = self.rnncell(input, hidden)return hiddendef init_hidden(self):return torch.zeros(self.batch_size, self.hidden_size)net = Model(input_size, hidden_size, batch_size)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.1)for epoch in range(15):loss = 0optimizer.zero_grad()hidden = net.init_hidden()print('Predicted string: ', end='')for input, label in zip(inputs, labels):hidden = net(input, hidden)loss += criterion(hidden, label)_, idx = hidden.max(dim=1)print(idx2char[idx.item()], end='')loss.backward()optimizer.step()print(', Epoch [%d/15] loss=%.4f' % (epoch + 1, loss.item()))

 运行结果：

3. “编码器-解码器”的简单实现

参考链接：Seq2Seq的PyTorch实现 - mathor

代码如下：

import torch
import numpy as np
import torch.nn as nn
import torch.utils.data as Datadevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')letter = [c for c in 'SE?abcdefghijklmnopqrstuvwxyz']
letter2idx = {n: i for i, n in enumerate(letter)}seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'], ['girl', 'boy'], ['up', 'down'], ['high', 'low']]# Seq2Seq Parameter
n_step = max([max(len(i), len(j)) for i, j in seq_data])  # max_len(=5)
n_hidden = 128
n_class = len(letter2idx)  # classfication problem
batch_size = 3def make_data(seq_data):enc_input_all, dec_input_all, dec_output_all = [], [], []for seq in seq_data:for i in range(2):seq[i] = seq[i] + '?' * (n_step - len(seq[i]))  # 'man??', 'women'enc_input = [letter2idx[n] for n in (seq[0] + 'E')]  # ['m', 'a', 'n', '?', '?', 'E']dec_input = [letter2idx[n] for n in ('S' + seq[1])]  # ['S', 'w', 'o', 'm', 'e', 'n']dec_output = [letter2idx[n] for n in (seq[1] + 'E')]  # ['w', 'o', 'm', 'e', 'n', 'E']enc_input_all.append(np.eye(n_class)[enc_input])dec_input_all.append(np.eye(n_class)[dec_input])dec_output_all.append(dec_output)  # not one-hot# make tensorreturn torch.Tensor(enc_input_all), torch.Tensor(dec_input_all), torch.LongTensor(dec_output_all)enc_input_all, dec_input_all, dec_output_all = make_data(seq_data)class TranslateDataSet(Data.Dataset):def __init__(self, enc_input_all, dec_input_all, dec_output_all):self.enc_input_all = enc_input_allself.dec_input_all = dec_input_allself.dec_output_all = dec_output_alldef __len__(self):  # return dataset sizereturn len(self.enc_input_all)def __getitem__(self, idx):return self.enc_input_all[idx], self.dec_input_all[idx], self.dec_output_all[idx]loader = Data.DataLoader(TranslateDataSet(enc_input_all, dec_input_all, dec_output_all), batch_size, True)# Model
class Seq2Seq(nn.Module):def __init__(self):super(Seq2Seq, self).__init__()self.encoder = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5)  # encoderself.decoder = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5)  # decoderself.fc = nn.Linear(n_hidden, n_class)def forward(self, enc_input, enc_hidden, dec_input):enc_input = enc_input.transpose(0, 1)  # enc_input: [n_step+1, batch_size, n_class]dec_input = dec_input.transpose(0, 1)  # dec_input: [n_step+1, batch_size, n_class]# h_t : [num_layers(=1) * num_directions(=1), batch_size, n_hidden]_, h_t = self.encoder(enc_input, enc_hidden)# outputs : [n_step+1, batch_size, num_directions(=1) * n_hidden(=128)]outputs, _ = self.decoder(dec_input, h_t)model = self.fc(outputs)  # model : [n_step+1, batch_size, n_class]return modelmodel = Seq2Seq().to(device)
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)for epoch in range(5000):for enc_input_batch, dec_input_batch, dec_output_batch in loader:# make hidden shape [num_layers * num_directions, batch_size, n_hidden]h_0 = torch.zeros(1, batch_size, n_hidden).to(device)(enc_input_batch, dec_intput_batch, dec_output_batch) = (enc_input_batch.to(device), dec_input_batch.to(device), dec_output_batch.to(device))# enc_input_batch : [batch_size, n_step+1, n_class]# dec_intput_batch : [batch_size, n_step+1, n_class]# dec_output_batch : [batch_size, n_step+1], not one-hotpred = model(enc_input_batch, h_0, dec_intput_batch)# pred : [n_step+1, batch_size, n_class]pred = pred.transpose(0, 1)  # [batch_size, n_step+1(=6), n_class]loss = 0for i in range(len(dec_output_batch)):# pred[i] : [n_step+1, n_class]# dec_output_batch[i] : [n_step+1]loss += criterion(pred[i], dec_output_batch[i])if (epoch + 1) % 1000 == 0:print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))optimizer.zero_grad()loss.backward()optimizer.step()# Test
def translate(word):enc_input, dec_input, _ = make_data([[word, '?' * n_step]])enc_input, dec_input = enc_input.to(device), dec_input.to(device)# make hidden shape [num_layers * num_directions, batch_size, n_hidden]hidden = torch.zeros(1, 1, n_hidden).to(device)output = model(enc_input, hidden, dec_input)# output : [n_step+1, batch_size, n_class]predict = output.data.max(2, keepdim=True)[1]  # select n_class dimensiondecoded = [letter[i] for i in predict]translated = ''.join(decoded[:decoded.index('E')])return translated.replace('?', '')print('test')
print('man ->', translate('man'))
print('mans ->', translate('mans'))
print('king ->', translate('king'))
print('black ->', translate('black'))
print('up ->', translate('up'))
print('old ->', translate('old'))
print('high ->', translate('high'))

运行结果：

 

4.谈一谈对“序列”、“序列到序列”的理解

4.1序列

序列是指一个按时间或位置排列的数据集合，数据点之间存在某种逻辑或时间上的依赖关系。在深度学习中，序列是指具有时间步或顺序相关性的输入数据。

特点：

  • 数据点之间存在顺序依赖。
  • 序列长度可以是固定的或可变的。
  • 序列模型（如 RNN、LSTM、Transformer）可以捕捉序列中的上下文信息。

4.2序列到序列

序列到序列是一种特殊的深度学习任务，模型的输入是一个序列，输出也是一个序列。Seq2Seq 模型广泛应用于解决输入和输出长度不同且具有序列关系的问题。

Seq2Seq 模型通常由两部分组成：编码器（Encoder） 和 解码器（Decoder）。

编码器（Encoder）

  • 输入：源序列（例如英文句子）逐步输入到模型中。
  • 任务：提取输入序列的上下文信息，并将其压缩成一个固定维度的上下文向量（Context Vector），作为解码器的输入。
  • 常用模型：RNN、LSTM、GRU 或 Transformer。

解码器（Decoder）

  • 输入：编码器输出的上下文向量，以及解码器自身的前一步输出。
  • 任务：基于上下文向量和自身的历史输出，生成目标序列（例如翻译后的法语句子）。
  • 解码过程通常是逐步预测，依赖于上一时间步的输出和当前隐藏状态。

Seq2Seq 模型的优缺点

优点：

  1. 通用性：可以处理任意长度的输入和输出。
  2. 灵活性：适用于各种序列任务，包括翻译、摘要、文本生成。
  3. 扩展性：结合注意力机制、Transformer 等，可以进一步提升性能。

缺点：

  1. 训练复杂性：训练过程需要对整个序列进行建模，可能导致梯度消失或爆炸问题（部分通过 LSTM、GRU 缓解）。
  2. 效率问题：如果序列过长，计算成本较高。
  3. 性能瓶颈：在传统 RNN 基础上，长序列信息难以保留，可能导致上下文丢失。

5.总结本周理论课和作业，写心得体会

前馈神经网络存在以下缺点：

连接在层与层之间，每层节点间无连接。
输入和输出的维数固定，不能任意改变。
无法处理 时序数据。
每次输入都是独立的，只依赖于当前的输入
 
因此提出循环神经网络。
  • 序列强调数据的时间步或逻辑顺序，具有内在依赖性。
  • 序列到序列模型通过编码器解码器结构，学习输入序列到输出序列的映射关系

循环神经网络特点：

给网络增加记忆能力的三种方法：延时神经网络、有外部输入的非线性自回归模型、循环神经网络

 

这一周学到了很多东西，课上有一些疑问，看了看视频就看懂了，在课下也花了一大部分时间来看视频、论文、复现代码，但是还是有一些地方是有点疑问的，之后也会再去搜一些资料去学习弄懂的！

这次的分享就到这里啦，下次再见~

 


http://www.ppmy.cn/server/146072.html

相关文章

计算机网络：网络安全

计算机网络：网络安全

7.1、网络安全概述 1、安全包括哪些方面 数据存储安全应用程序安全操作系统安全网络安全物理安全用户安全教育 2、网络安全面临的问题 1）截获——从网络上窃听他人的通信内容。 2）中断——有意中断他人在网络上的通信。 3）篡改——故意…
阅读更多...
通过优化html的清洗来提高对网页RAG的效果

通过优化html的清洗来提高对网页RAG的效果

html检索的提升：HtmlRAG 之前在现实的工作场景中也做过很多次RAG，不过那会我的做法大多数是对数据进行结构化，例如做成json或者yaml文件存放进数据库里面。比如我现在有一个Word文档需要处理，那我就会按照一级标题，二…
阅读更多...
【python】pip不是内部命令解决方法

【python】pip不是内部命令解决方法

【python】pip不是内部命令解决方法 原因解决方法 不会配置环境变量的可以卸载python，重新安装，这两天，我会再出一期安装python的教程，希望对你有帮助 原因 通常情况下，出现“pip不是内部命令”的问题，往往…
阅读更多...
微信小程序中的WXSS与CSS的关系及使用技巧

微信小程序中的WXSS与CSS的关系及使用技巧

微信小程序中的WXSS与CSS的关系及使用技巧 引言 在微信小程序的开发中，样式的设计与实现是构建用户友好界面的关键。微信小程序使用WXSS（WeiXin Style Sheets）作为其样式表语言，WXSS在语法上与CSS非常相似，但也有一些独特的特性。本文将深入探讨WXSS与CSS的关系，介绍WX…
阅读更多...
面试小札：JVM虚拟机

面试小札：JVM虚拟机

1. 定义与基本概念 - JVM（Java Virtual Machine）即Java虚拟机，是Java程序的运行核心。它是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功能来运行Java字节码。字节码是一种中间格式，它使得Java程序能…
阅读更多...
光伏功率预测！Transformer-LSTM、Transformer、CNN-LSTM、LSTM、CNN五模型时序预测

光伏功率预测！Transformer-LSTM、Transformer、CNN-LSTM、LSTM、CNN五模型时序预测

目录 预测效果基本介绍程序设计参考资料 预测效果 基本介绍 Transformer-LSTM、Transformer、CNN-LSTM、LSTM、CNN五模型多变量时序光伏功率预测 (Matlab2023b 多输入单输出) 1.程序已经调试好，替换数据集后，仅运行一个main即可运行，数据格式…
阅读更多...
【DVWA】File Inclusion文件包含实战

【DVWA】File Inclusion文件包含实战

安能有术无道有道无心&#xff0c;乐得仁心仁义正心行道。 1.File Inclusion(Low) 相关代码分析 <?php// The page we wish to display $file $_GET[ page ];?>可以看到&#xff0c;服务器端对page参数没有做任何的过滤跟检查。 服务器期望用户的操作是点击下面的…
阅读更多...
Android 性能优化：内存优化（理论篇）

Android 性能优化：内存优化（理论篇）

内存作为App程序运行最重要的资源之一&#xff0c;需要运行过程中做到合理的资源分配与回收&#xff0c;不合理的内存占用轻则使得用户应用程序运行卡顿、ANR、黑屏&#xff0c;重则导致用户应用程序发生 OOM&#xff08;out of memory&#xff09;崩溃。喜马直播随着近些年的业…
阅读更多...
最新文章

Copyright @ 2022~2023