深度学习 - RNN训练过程推演

2024-06-17 22:12

本文主要是介绍深度学习 - RNN训练过程推演,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

1. 数据准备

字符序列 “hello” 转换为 one-hot 编码表示:

  • 输入: [‘h’, ‘e’, ‘l’, ‘l’]
  • 输出: [‘e’, ‘l’, ‘l’, ‘o’]

2. 初始化参数

我们使用一个单层的 RNN,隐藏层大小为2,每次传1个字符。初始参数如下:

W x h = ( 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 ) , W h h = ( 0.1 0.2 0.3 0.4 ) , W h y = ( 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 ) W_{xh} = \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \\ 0.5 & 0.6 \\ 0.7 & 0.8 \end{pmatrix}, \quad W_{hh} = \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \end{pmatrix}, \quad W_{hy} = \begin{pmatrix} 0.1 & 0.2 & 0.3 & 0.4 \\ 0.5 & 0.6 & 0.7 & 0.8 \end{pmatrix} Wxh= 0.10.30.50.70.20.40.60.8 ,Whh=(0.10.30.20.4),Why=(0.10.50.20.60.30.70.40.8)

偏置项初始化为0。

3. 前向传播和反向传播

时间步 1(输入 ‘h’):

输入向量 x 1 = [ 1 , 0 , 0 , 0 ] x_1 = [1, 0, 0, 0] x1=[1,0,0,0]

h 1 = tanh ⁡ ( W x h x 1 + W h h h 0 ) = tanh ⁡ ( ( 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 ) ( 1 0 0 0 ) + ( 0.1 0.2 0.3 0.4 ) ( 0 0 ) ) = tanh ⁡ ( ( 0.1 0.3 ) ) = ( 0.0997 0.2913 ) h_1 = \tanh(W_{xh} x_1 + W_{hh} h_0) = \tanh \left( \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \\ 0.5 & 0.6 \\ 0.7 & 0.8 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix} + \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \end{pmatrix} \begin{pmatrix} 0 \\ 0 \end{pmatrix} \right) = \tanh \left( \begin{pmatrix} 0.1 \\ 0.3 \end{pmatrix} \right) = \begin{pmatrix} 0.0997 \\ 0.2913 \end{pmatrix} h1=tanh(Wxhx1+Whhh0)=tanh 0.10.30.50.70.20.40.60.8 1000 +(0.10.30.20.4)(00) =tanh((0.10.3))=(0.09970.2913)

y 1 = W h y h 1 = ( 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 ) ( 0.0997 0.2913 ) = ( 0.1695 0.3889 0.6083 0.8277 ) y_1 = W_{hy} h_1 = \begin{pmatrix} 0.1 & 0.2 & 0.3 & 0.4 \\ 0.5 & 0.6 & 0.7 & 0.8 \end{pmatrix} \begin{pmatrix} 0.0997 \\ 0.2913 \end{pmatrix} = \begin{pmatrix} 0.1695 \\ 0.3889 \\ 0.6083 \\ 0.8277 \end{pmatrix} y1=Whyh1=(0.10.50.20.60.30.70.40.8)(0.09970.2913)= 0.16950.38890.60830.8277

预测值 y ^ 1 = softmax ( y 1 ) \hat{y}_1 = \text{softmax}(y_1) y^1=softmax(y1)

假设真实输出为 ‘e’,对应 one-hot 编码为 y 1 = [ 0 , 1 , 0 , 0 ] y_1 = [0, 1, 0, 0] y1=[0,1,0,0]

交叉熵损失函数:

loss 1 = − ∑ i y 1 i log ⁡ ( y ^ 1 i ) \text{loss}_1 = - \sum_{i} y_{1i} \log(\hat{y}_{1i}) loss1=iy1ilog(y^1i)

梯度计算:

∂ loss 1 ∂ W h y = ( y ^ 1 − y 1 ) h 1 T \frac{\partial \text{loss}_1}{\partial W_{hy}} = (\hat{y}_1 - y_1) h_1^T Whyloss1=(y^1y1)h1T

∂ loss 1 ∂ W x h = ∂ loss 1 ∂ h 1 ⋅ ∂ h 1 ∂ W x h \frac{\partial \text{loss}_1}{\partial W_{xh}} = \frac{\partial \text{loss}_1}{\partial h_1} \cdot \frac{\partial h_1}{\partial W_{xh}} Wxhloss1=h1loss1Wxhh1

∂ loss 1 ∂ W h h = ∂ loss 1 ∂ h 1 ⋅ ∂ h 1 ∂ W h h \frac{\partial \text{loss}_1}{\partial W_{hh}} = \frac{\partial \text{loss}_1}{\partial h_1} \cdot \frac{\partial h_1}{\partial W_{hh}} Whhloss1=h1loss1Whhh1

参数更新:

W x h = W x h − η ∂ loss 1 ∂ W x h W_{xh} = W_{xh} - \eta \frac{\partial \text{loss}_1}{\partial W_{xh}} Wxh=WxhηWxhloss1

W h h = W h h − η ∂ loss 1 ∂ W h h W_{hh} = W_{hh} - \eta \frac{\partial \text{loss}_1}{\partial W_{hh}} Whh=WhhηWhhloss1

W h y = W h y − η ∂ loss 1 ∂ W h y W_{hy} = W_{hy} - \eta \frac{\partial \text{loss}_1}{\partial W_{hy}} Why=WhyηWhyloss1

时间步 2(输入 ‘e’):

使用更新后的 W x h W_{xh} Wxh W h h W_{hh} Whh W h y W_{hy} Why 参数。

输入向量 x 2 = [ 0 , 1 , 0 , 0 ] x_2 = [0, 1, 0, 0] x2=[0,1,0,0]

h 2 = tanh ⁡ ( W x h x 2 + W h h h 1 ) = tanh ⁡ ( ( 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 ) ( 0 1 0 0 ) + ( 0.1 0.2 0.3 0.4 ) ( 0.0997 0.2913 ) ) h_2 = \tanh(W_{xh} x_2 + W_{hh} h_1) = \tanh \left( \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \\ 0.5 & 0.6 \\ 0.7 & 0.8 \end{pmatrix} \begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix} + \begin{pmatrix} 0.1 & 0.2 \\ 0.3 & 0.4 \end{pmatrix} \begin{pmatrix} 0.0997 \\ 0.2913 \end{pmatrix} \right) h2=tanh(Wxhx2+Whhh1)=tanh 0.10.30.50.70.20.40.60.8 0100 +(0.10.30.20.4)(0.09970.2913)

计算后得:

h 2 = tanh ⁡ ( ( 0.3 0.7 ) + ( 0.1283 0.2147 ) ) = tanh ⁡ ( ( 0.4283 0.9147 ) ) h_2 = \tanh \left( \begin{pmatrix} 0.3 \\ 0.7 \end{pmatrix} + \begin{pmatrix} 0.1283 \\ 0.2147 \end{pmatrix} \right) = \tanh \left( \begin{pmatrix} 0.4283 \\ 0.9147 \end{pmatrix} \right) h2=tanh((0.30.7)+(0.12830.2147))=tanh((0.42830.9147))

y 2 = W h y h 2 y_2 = W_{hy} h_2 y2=Whyh2

预测值 y ^ 2 = softmax ( y 2 ) \hat{y}_2 = \text{softmax}(y_2) y^2=softmax(y2)

假设真实输出为 ‘l’,对应 one-hot 编码为 y 2 = [ 0 , 0 , 1 , 0 ] y_2 = [0, 0, 1, 0] y2=[0,0,1,0]

交叉熵损失函数:

loss 2 = − ∑ i y 2 i log ⁡ ( y ^ 2 i ) \text{loss}_2 = - \sum_{i} y_{2i} \log(\hat{y}_{2i}) loss2=iy2ilog(y^2i)

梯度计算:

∂ loss 2 ∂ W h y = ( y ^ 2 − y 2 ) h 2 T \frac{\partial \text{loss}_2}{\partial W_{hy}} = (\hat{y}_2 - y_2) h_2^T Whyloss2=(y^2y2)h2T

∂ loss 2 ∂ W x h = ∂ loss 2 ∂ h 2 ⋅ ∂ h 2 ∂ W x h \frac{\partial \text{loss}_2}{\partial W_{xh}} = \frac{\partial \text{loss}_2}{\partial h_2} \cdot \frac{\partial h_2}{\partial W_{xh}} Wxhloss2=h2loss2Wxhh2

∂ loss 2 ∂ W h h = ∂ loss 2 ∂ h 2 ⋅ ∂ h 2 ∂ W h h \frac{\partial \text{loss}_2}{\partial W_{hh}} = \frac{\partial \text{loss}_2}{\partial h_2} \cdot \frac{\partial h_2}{\partial W_{hh}} Whhloss2=h2loss2Whhh2

参数更新:

W x h = W x h − η ∂ loss 2 ∂ W x h W_{xh} = W_{xh} - \eta \frac{\partial \text{loss}_2}{\partial W_{xh}} Wxh=WxhηWxhloss2

W h h = W h h − η ∂ loss 2 ∂ W h h W_{hh} = W_{hh} - \eta \frac{\partial \text{loss}_2}{\partial W_{hh}} Whh=WhhηWhhloss2

W h y = W h y − η ∂ loss 2 ∂ W h y W_{hy} = W_{hy} - \eta \frac{\partial \text{loss}_2}{\partial W_{hy}} Why=WhyηWhyloss2

时间步 3(输入 ‘l’):

使用更新后的 W x h W_{xh} Wxh W h h W_{hh} Whh W h y W_{hy} Why 参数。

输入向量 x 3 = [ 0 , 0 , 1 , 0 ] x_3 = [0, 0, 1, 0] x3=[0,0,1,0]

h 3 = tanh ⁡ ( W x h x 3 + W h h h 2 ) h_3 = \tanh(W_{xh} x_3 + W_{hh} h_2) h3=tanh(Wxhx3+Whhh2)

计算后得:

h 3 = tanh ⁡ ( ( 0.5 1.2 ) + W h h h 2 ) h_3 = \tanh \left( \begin{pmatrix} 0.5 \\ 1.2 \end{pmatrix} + W_{hh} h_2 \right) h3=tanh((0.51.2)+Whhh2)

y 3 = W h y h 3 y_3 = W_{hy} h_3 y3=Whyh3

预测值 y ^ 3 = softmax ( y 3 ) \hat{y}_3 = \text{softmax}(y_3) y^3=softmax(y3)

假设真实输出为 ‘l’,对应 one-hot 编码为 y 3 = [ 0 , 0 , 1 , 0 ] y_3 = [0, 0, 1, 0] y3=[0,0,1,0]

交叉熵损失函数:

$$
\text{loss}3 = - \sum{i} y_{3i} \log(\hat{y}_{3

i})
$$

梯度计算:

∂ loss 3 ∂ W h y = ( y ^ 3 − y 3 ) h 3 T \frac{\partial \text{loss}_3}{\partial W_{hy}} = (\hat{y}_3 - y_3) h_3^T Whyloss3=(y^3y3)h3T

∂ loss 3 ∂ W x h = ∂ loss 3 ∂ h 3 ⋅ ∂ h 3 ∂ W x h \frac{\partial \text{loss}_3}{\partial W_{xh}} = \frac{\partial \text{loss}_3}{\partial h_3} \cdot \frac{\partial h_3}{\partial W_{xh}} Wxhloss3=h3loss3Wxhh3

∂ loss 3 ∂ W h h = ∂ loss 3 ∂ h 3 ⋅ ∂ h 3 ∂ W h h \frac{\partial \text{loss}_3}{\partial W_{hh}} = \frac{\partial \text{loss}_3}{\partial h_3} \cdot \frac{\partial h_3}{\partial W_{hh}} Whhloss3=h3loss3Whhh3

参数更新:

W x h = W x h − η ∂ loss 3 ∂ W x h W_{xh} = W_{xh} - \eta \frac{\partial \text{loss}_3}{\partial W_{xh}} Wxh=WxhηWxhloss3

W h h = W h h − η ∂ loss 3 ∂ W h h W_{hh} = W_{hh} - \eta \frac{\partial \text{loss}_3}{\partial W_{hh}} Whh=WhhηWhhloss3

W h y = W h y − η ∂ loss 3 ∂ W h y W_{hy} = W_{hy} - \eta \frac{\partial \text{loss}_3}{\partial W_{hy}} Why=WhyηWhyloss3

时间步 4(输入 ‘l’):

使用更新后的 W x h W_{xh} Wxh W h h W_{hh} Whh W h y W_{hy} Why 参数。

输入向量 x 4 = [ 0 , 0 , 1 , 0 ] x_4 = [0, 0, 1, 0] x4=[0,0,1,0]

h 4 = tanh ⁡ ( W x h x 4 + W h h h 3 ) h_4 = \tanh(W_{xh} x_4 + W_{hh} h_3) h4=tanh(Wxhx4+Whhh3)

计算后得:

h 4 = tanh ⁡ ( ( 0.5 1.2 ) + W h h h 3 ) h_4 = \tanh \left( \begin{pmatrix} 0.5 \\ 1.2 \end{pmatrix} + W_{hh} h_3 \right) h4=tanh((0.51.2)+Whhh3)

y 4 = W h y h 4 y_4 = W_{hy} h_4 y4=Whyh4

预测值 y ^ 4 = softmax ( y 4 ) \hat{y}_4 = \text{softmax}(y_4) y^4=softmax(y4)

假设真实输出为 ‘o’,对应 one-hot 编码为 y 4 = [ 0 , 0 , 0 , 1 ] y_4 = [0, 0, 0, 1] y4=[0,0,0,1]

交叉熵损失函数:

loss 4 = − ∑ i y 4 i log ⁡ ( y ^ 4 i ) \text{loss}_4 = - \sum_{i} y_{4i} \log(\hat{y}_{4i}) loss4=iy4ilog(y^4i)

梯度计算:

∂ loss 4 ∂ W h y = ( y ^ 4 − y 4 ) h 4 T \frac{\partial \text{loss}_4}{\partial W_{hy}} = (\hat{y}_4 - y_4) h_4^T Whyloss4=(y^4y4)h4T

∂ loss 4 ∂ W x h = ∂ loss 4 ∂ h 4 ⋅ ∂ h 4 ∂ W x h \frac{\partial \text{loss}_4}{\partial W_{xh}} = \frac{\partial \text{loss}_4}{\partial h_4} \cdot \frac{\partial h_4}{\partial W_{xh}} Wxhloss4=h4loss4Wxhh4

∂ loss 4 ∂ W h h = ∂ loss 4 ∂ h 4 ⋅ ∂ h 4 ∂ W h h \frac{\partial \text{loss}_4}{\partial W_{hh}} = \frac{\partial \text{loss}_4}{\partial h_4} \cdot \frac{\partial h_4}{\partial W_{hh}} Whhloss4=h4loss4Whhh4

参数更新:

W x h = W x h − η ∂ loss 4 ∂ W x h W_{xh} = W_{xh} - \eta \frac{\partial \text{loss}_4}{\partial W_{xh}} Wxh=WxhηWxhloss4

W h h = W h h − η ∂ loss 4 ∂ W h h W_{hh} = W_{hh} - \eta \frac{\partial \text{loss}_4}{\partial W_{hh}} Whh=WhhηWhhloss4

W h y = W h y − η ∂ loss 4 ∂ W h y W_{hy} = W_{hy} - \eta \frac{\partial \text{loss}_4}{\partial W_{hy}} Why=WhyηWhyloss4

4.代码实现

下面是一个使用 PyTorch 实现简单 RNN(循环神经网络)的示例代码,该代码将字符序列作为输入并预测下一个字符。我们将使用一个小的字符集进行演示。

安装 PyTorch

在开始之前,请确保您已安装 PyTorch。您可以使用以下命令进行安装:

pip install torch
RNN 实现示例

我们将实现一个字符级 RNN,用于从序列 “hello” 中预测下一个字符。字符集为 {‘h’, ‘e’, ‘l’, ‘o’}。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 定义字符集和字符到索引的映射
chars = ['h', 'e', 'l', 'o']
char_to_idx = {ch: idx for idx, ch in enumerate(chars)}
idx_to_char = {idx: ch for idx, ch in enumerate(chars)}# 超参数
input_size = len(chars)
hidden_size = 10
output_size = len(chars)
num_layers = 1
learning_rate = 0.01
num_epochs = 100# 准备数据
def char_to_tensor(char):tensor = torch.zeros(input_size)tensor[char_to_idx[char]] = 1.0return tensordef string_to_tensor(string):tensor = torch.zeros(len(string), input_size)for idx, char in enumerate(string):tensor[idx][char_to_idx[char]] = 1.0return tensorinput_seq = "hell"
target_seq = "ello"input_tensor = string_to_tensor(input_seq)
target_tensor = torch.tensor([char_to_idx[ch] for ch in target_seq])# 定义 RNN 模型
class RNN(nn.Module):def __init__(self, input_size, hidden_size, output_size):super(RNN, self).__init__()self.hidden_size = hidden_sizeself.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x, hidden):out, hidden = self.rnn(x, hidden)out = self.fc(out[:, -1, :])return out, hiddendef init_hidden(self):return torch.zeros(num_layers, 1, hidden_size)# 初始化模型、损失函数和优化器
model = RNN(input_size, hidden_size, output_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)# 训练模型
for epoch in range(num_epochs):hidden = model.init_hidden()model.zero_grad()input_seq = input_tensor.unsqueeze(0)output, hidden = model(input_seq, hidden)loss = criterion(output, target_tensor.unsqueeze(0))loss.backward()optimizer.step()if (epoch + 1) % 10 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')# 测试模型
def predict(model, char, hidden=None):if hidden is None:hidden = model.init_hidden()input_tensor = char_to_tensor(char).unsqueeze(0).unsqueeze(0)output, hidden = model(input_tensor, hidden)_, predicted_idx = torch.max(output, 1)return idx_to_char[predicted_idx.item()], hiddenhidden = model.init_hidden()
input_char = 'h'
predicted_seq = input_char
for _ in range(len(input_seq)):next_char, hidden = predict(model, input_char, hidden)predicted_seq += next_charinput_char = next_charprint(f'Predicted sequence: {predicted_seq}')
代码说明
  1. 数据准备

    • 我们定义了一个简单的字符集 {‘h’, ‘e’, ‘l’, ‘o’},并创建了字符到索引和索引到字符的映射。
    • char_to_tensor 函数将字符转换为 one-hot 向量。
    • string_to_tensor 函数将字符串转换为一系列 one-hot 向量。
  2. 定义 RNN 模型

    • RNN 类继承自 nn.Module,包含一个 RNN 层和一个全连接层。
    • forward 方法执行前向传播。
    • init_hidden 方法初始化隐藏状态。
  3. 训练模型

    • 我们使用交叉熵损失函数和 Adam 优化器。
    • 在每个训练周期,我们进行前向传播、计算损失、反向传播和参数更新。
  4. 测试模型

    • predict 函数根据给定的输入字符生成下一个字符。
    • 我们使用训练好的模型从字符 ‘h’ 开始生成一个字符序列。

运行该代码后,您将看到模型预测的字符序列,它会逐渐学会从输入序列中预测下一个字符。

这篇关于深度学习 - RNN训练过程推演的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!


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

相关文章

JavaScript中的reduce方法执行过程、使用场景及进阶用法

《JavaScript中的reduce方法执行过程、使用场景及进阶用法》:本文主要介绍JavaScript中的reduce方法执行过程、使用场景及进阶用法的相关资料,reduce是JavaScri... 目录1. 什么是reduce2. reduce语法2.1 语法2.2 参数说明3. reduce执行过程

redis群集简单部署过程

《redis群集简单部署过程》文章介绍了Redis,一个高性能的键值存储系统,其支持多种数据结构和命令,它还讨论了Redis的服务器端架构、数据存储和获取、协议和命令、高可用性方案、缓存机制以及监控和... 目录Redis介绍1. 基本概念2. 服务器端3. 存储和获取数据4. 协议和命令5. 高可用性6.

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列(LCS)问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动

PLsql Oracle 下载安装图文过程详解

《PLsqlOracle下载安装图文过程详解》PL/SQLDeveloper是一款用于开发Oracle数据库的集成开发环境,可以通过官网下载安装配置,并通过配置tnsnames.ora文件及环境变... 目录一、PL/SQL Developer 简介二、PL/SQL Developer 安装及配置详解1.下

在Java中使用ModelMapper简化Shapefile属性转JavaBean实战过程

《在Java中使用ModelMapper简化Shapefile属性转JavaBean实战过程》本文介绍了在Java中使用ModelMapper库简化Shapefile属性转JavaBean的过程,对比... 目录前言一、原始的处理办法1、使用Set方法来转换2、使用构造方法转换二、基于ModelMapper

springboot启动流程过程

《springboot启动流程过程》SpringBoot简化了Spring框架的使用,通过创建`SpringApplication`对象,判断应用类型并设置初始化器和监听器,在`run`方法中,读取配... 目录springboot启动流程springboot程序启动入口1.创建SpringApplicat

本地搭建DeepSeek-R1、WebUI的完整过程及访问

《本地搭建DeepSeek-R1、WebUI的完整过程及访问》:本文主要介绍本地搭建DeepSeek-R1、WebUI的完整过程及访问的相关资料,DeepSeek-R1是一个开源的人工智能平台,主... 目录背景       搭建准备基础概念搭建过程访问对话测试总结背景       最近几年,人工智能技术

Linux部署jar包过程

《Linux部署jar包过程》文章介绍了在Linux系统上部署Java(jar)包时需要注意的几个关键点,包括统一JDK版本、添加打包插件、修改数据库密码以及正确执行jar包的方法... 目录linux部署jar包1.统一jdk版本2.打包插件依赖3.修改密码4.执行jar包总结Linux部署jar包部署

Go中sync.Once源码的深度讲解

《Go中sync.Once源码的深度讲解》sync.Once是Go语言标准库中的一个同步原语,用于确保某个操作只执行一次,本文将从源码出发为大家详细介绍一下sync.Once的具体使用,x希望对大家有... 目录概念简单示例源码解读总结概念sync.Once是Go语言标准库中的一个同步原语,用于确保某个操