Pytorch实现RNN原理

最新推荐文章于 2024-09-15 12:46:45 发布
最新推荐文章于 2024-09-15 12:46:45 发布
阅读量685 收藏 2
点赞数 1
分类专栏： 机器学习 神经网络 文章标签： rnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43056256/article/details/114272542
版权

Pytorch实现RNN原理

rnn公式如下。
h t = W h h h t − 1 + W i h X t {{\rm{h}}_t} = {W_{hh}}{{\rm{h}}_{t - 1}} + {W_{ih}}{X_t} ht​=Whh​ht−1​+Wih​Xt​
其中 X t {X_t} Xt​表示t时刻的输入序列。Pytorch中RNN的输入 X {X} X大小为[seq, batch_size, embedding]。
所以 X t {X_t} Xt​的大小为[batch_size, embedding]。其中embedding维度是要参与运算的维度，batch_size是要保留的信息。所以一般将 X t {X_t} Xt​的大小写成转置的形式[embedding, batch_size]。

W i h X t {W_{ih}}{X_t} Wih​Xt​ 的结果为[hidden_size, batch_size]。从矩阵的角度来理解就是batchsize个维度为hidden_size的列向量产生都是由原本的序列产生，依赖于自身序列。而与其他的句子无关

上次写的还是有很多小错误，进行了改正

import numpy as np
import torch
from torch import nn
from torch.nn.parameter import Parameter

class Rnn(nn.Module):

    def __init__(self, input_size, hidden_size, num_layers, bidirectional=False):
        super(Rnn, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.bidirectional = bidirectional
        Wih = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(1, self.num_layers)]
        Whh = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(self.num_layers)]
        self.Wih, self.Whh = Parameter(torch.tensor(Wih)), Parameter(torch.tensor(Whh))
        Wih0 = np.random.random((self.hidden_size, self.hidden_size))
        self.Wih0 = Parameter(torch.tensor(Wih0))

    def forward(self, x):
        '''

        :param x: [seq, batch_size, embedding]
        :return: out, hidden
        '''

        # x.shape [sep, batch, feature]
        # hidden.shape [hidden_size, batch]
        # Whh0.shape [hidden_size, hidden_size]  Wih0.shape [hidden_size, feature]
        # Whh1.shape [hidden_size, hidden_size]  Wih1.size  [hidden_size, hidden_size]
        if not isinstance(x, torch.Tensor):
            raise TypeError('x is not tensor')

        out = []
        hidden = [np.zeros((self.hidden_size, x.shape[1])) for i in range(self.num_layers)]

        Wih0 = np.random.random((self.hidden_size, x.shape[2]))

        # x, hidden, Wih, Whh = torch.from_numpy(x), torch.tensor(hidden), torch.tensor(Wih), torch.tensor(Whh)

        hidden = torch.tensor(hidden)
        self.Wih0 = Parameter(torch.tensor(Wih0))


        time = x.shape[0]
        for i in range(time):
            hidden[0] = torch.tanh((torch.matmul(self.Wih0, torch.transpose(x[i, ...], 1, 0)) +
                              torch.matmul(self.Whh[0], hidden[0].clone().detach())
                              ))

            for i in range(1, self.num_layers):
                hidden[i] = torch.tanh((torch.matmul(self.Wih[i-1], hidden[i-1].clone().detach()) +
                                     torch.matmul(self.Whh[i], hidden[i].clone().detach())
                                     ))

            out.append(hidden[self.num_layers-1])
        # 如果list中的元素为tensor，就无法用torch.tensor()转换，会报错
        return torch.stack([i for i in out]).permute(0, 2, 1).contiguous(), hidden.permute(0, 2, 1).contiguous()


if __name__ == '__main__':
    a = torch.tensor([1, 2, 3])
    print(torch.cuda.is_available(), type(a))
    rnn = Rnn(1, 5, 4)
    rnn_office = nn.RNN(1, 5, 4)
    optimizer = torch.optim.Adam(params=rnn.parameters(), lr=0.1)
    # print(list(rnn.parameters()))
    input = torch.tensor(np.random.random((6, 3, 1)))
    for _ in range(10):
        out, h = rnn(input)
        # pred = torch.softmax(h.mean(dim=0), dim=1).argmax(dim=1).to(torch.float64)
        pred = h.mean(dim=0)
        a = rnn.parameters()
        # print(rnn)

        param = [i for i in a]

        label = torch.tensor([1, 2, 3])
        criticism = nn.CrossEntropyLoss()
        loss = criticism(pred, label)
        print(loss.item())
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(rnn_office(input.to(torch.float32))[1].shape)
    print(f'seq is {input.shape[0]}, batch_size is {input.shape[1]} ', 'out.shape ', out.shape, ' h.shape ', h.shape)

    # print(sigmoid(np.random.random((2, 3))))
    #
    # element-wise multiplication
    # print(np.array([1, 2])*np.array([2, 1]))

分割线

我又将代码稍微调整，使得其可以进行梯度下降计算。

import numpy as np
import torch
from torch import nn

class Rnn(nn.Module):

    def __init__(self, input_size, hidden_size, num_layers, bidirectional=False):
        super(Rnn, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.bidirectional = bidirectional

    def forward(self, x):
        '''

        :param x: [seq, batch_size, embedding]
        :return: out, hidden
        '''

        # x.shape [sep, batch, feature]
        # hidden.shape [hidden_size, batch]
        # Whh0.shape [hidden_size, hidden_size]  Wih0.shape [hidden_size, feature]
        # Whh1.shape [hidden_size, hidden_size]  Wih1.size  [hidden_size, hidden_size]

        out = []
        x, hidden = np.array(x), [np.zeros((self.hidden_size, x.shape[1])) for i in range(self.num_layers)]
        Wih = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(1, self.num_layers)]
        Wih0 = np.random.random((self.hidden_size, x.shape[2]))
        Whh = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(self.num_layers)]
        # x, hidden, Wih, Whh = torch.from_numpy(x), torch.tensor(hidden), torch.tensor(Wih), torch.tensor(Whh)

        x = torch.from_numpy(x)
        hidden = torch.tensor(hidden)
        Wih0 = torch.tensor(Wih0, requires_grad=True)
        Wih, Whh = torch.tensor(Wih, requires_grad=True), torch.tensor(Whh, requires_grad=True)

        time = x.shape[0]
        for i in range(time):
            hidden[0] = torch.tanh((torch.matmul(Wih0, torch.transpose(x[i, ...], 1, 0)) +
                              torch.matmul(Whh[0], hidden[0])
                              ))

            for i in range(1, self.num_layers):
                hidden[i] = torch.tanh((torch.matmul(Wih[i-1], hidden[i-1]) +
                                     torch.matmul(Whh[i], hidden[i])
                                     ))

            out.append(hidden[self.num_layers-1])
        # 如果list中的元素为tensor，就无法用torch.tensor()转换，会报错
        return torch.stack([i for i in out]), hidden


def sigmoid(x):
    return 1.0/(1.0 + 1.0/np.exp(x))


if __name__ == '__main__':
    a = torch.tensor([1, 2, 3])
    print(torch.cuda.is_available(), type(a))
    rnn = Rnn(1, 5, 4)
    input = np.random.random((6, 2, 1))
    out, h = rnn(input)
    print(f'seq is {input.shape[0]}, batch_size is {input.shape[1]} ', 'out.shape ', out.shape, ' h.shape ', h.shape)
    # print(sigmoid(np.random.random((2, 3))))
    #
    # element-wise multiplication
    # print(np.array([1, 2])*np.array([2, 1]))

分割线

首先说明代码只是帮助理解，并未写出梯度下降部分，默认参数已经被固定，不影响理解。代码主要实现RNN原理，只使用numpy库，不可用于GPU加速。

import numpy as np


class Rnn():

    def __init__(self, input_size, hidden_size, num_layers, bidirectional=False):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.bidirectional = bidirectional

    def feed(self, x):
        '''

        :param x: [seq, batch_size, embedding]
        :return: out, hidden
        '''

        # x.shape [sep, batch, feature]
        # hidden.shape [hidden_size, batch]
        # Whh0.shape [hidden_size, hidden_size]  Wih0.shape [hidden_size, feature]
        # Whh1.shape [hidden_size, hidden_size]  Wih1.size  [hidden_size, hidden_size]

        out = []
        x, hidden = np.array(x), [np.zeros((self.hidden_size, x.shape[1])) for i in range(self.num_layers)]
        Wih = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(1, self.num_layers)]
        Wih.insert(0, np.random.random((self.hidden_size, x.shape[2])))
        Whh = [np.random.random((self.hidden_size, self.hidden_size)) for i in range(self.num_layers)]

        time = x.shape[0]
        for i in range(time):
            hidden[0] = np.tanh((np.dot(Wih[0], np.transpose(x[i, ...], (1, 0))) +
                              np.dot(Whh[0], hidden[0])
                              ))

            for i in range(1, self.num_layers):
                hidden[i] = np.tanh((np.dot(Wih[i], hidden[i-1]) +
                                     np.dot(Whh[i], hidden[i])
                                     ))

            out.append(hidden[self.num_layers-1])

        return np.array(out), np.array(hidden)


def sigmoid(x):
    return 1.0/(1.0 + 1.0/np.exp(x))


if __name__ == '__main__':
    rnn = Rnn(1, 5, 4)
    input = np.random.random((6, 2, 1))
    out, h = rnn.feed(input)
    print(f'seq is {input.shape[0]}, batch_size is {input.shape[1]} ', 'out.shape ', out.shape, ' h.shape ', h.shape)
    # print(sigmoid(np.random.random((2, 3))))
    #
    # element-wise multiplication
    # print(np.array([1, 2])*np.array([2, 1]))
J k l
关注
专栏目录
pytorch 实现rnn
qq_40107571的博客
06-29 1397
pytorch 实现rnn
如何使用PyTorch实现RNN
AI天才研究院
08-20 559
1. 背景介绍 1.1 循环神经网络 (RNN) 的发展历程 循环神经网络 (RNN) 是一种特殊类型的神经网络，专门用于处理序列数据。它们在20世纪80年代首次被提出，并在过去几十年中取得了显著的进展。RNN 的关键特性是其内部记忆，允许网络存储来自先前时间步的信息，并将其用于当前
人人都能用Python写出LSTM-RNN的代码！[你的神经网络学习最佳起步]
热门推荐
Life is Float.
11-21 9万+
我的最佳学习法就是通过玩具代码，一边调试一边学习理论。这篇博客通过一个非常简单的python玩具代码来讲解循环神经网络。 那么依旧是废话少说，放‘码’过来！
pytorch实现RNN网络
最新发布
Hiweir的博客
09-15 1015
pytorch实现RNN网络：加载数据、构建模型、模型训练、模型预测
pytorch实现RNN
weixin_43955530的博客
07-07 2881
RNN实现分类问题 import torch import torch.nn as nn from torch.autograd import Variable import torchvision.datasets as dsets #包括了一些数据库，图片的数据库也包含了 import torchvision.transforms as transforms import matplotlib.pyplot as plt #超参数 EPOCH = 1 BATCH_SIZE = 64 TIME_STEP
使用PyTorch实现简单的RNN
qq_41775769的博客
12-03 5061
使用PyTorch实现简单的RNN 假设 Xt∈Rn×dX_t \in R^{n \times d}Xt​∈Rn×d 是序列中时间步 ttt 的小批量输入，Ht∈Rn×hH_t \in R^{n \times h}Ht​∈Rn×h 是该时间步输入的隐藏变量。计算过程如下：： Ht=ϕ(XtWdh+Ht−1Whh+bh) H_{t}=\phi(X_tW_{dh}+H_{t-1}W_{hh}+b_h) Ht​=ϕ(Xt​Wdh​+Ht−1​Whh​+bh​) 其中，隐藏层的权重 Wdh∈Rd×hW_{dh} \
用pytorch实现简易RNN
qq_40206371的博客
06-02 3535
1 导入库函数 import torch import numpy as np import matplotlib.pyplot as plt
pytorch实现RNN实验.rar
12-01
在本实验中，我们将深入探讨如何使用PyTorch实现循环神经网络（RNN），以及其变种长短期记忆网络（LSTM）和门控循环单元（GRU）。这些模型广泛应用于序列数据处理，如自然语言处理（NLP）、时间序列预测和音频识别等...
基于Pytorch的RNN手写数字识别功能实现.zip
05-07
在本项目中，我们主要探讨的是如何利用PyTorch库构建一个循环神经网络（RNN）来实现手写数字的...此外，RNN在自然语言处理、语音识别等领域也有广泛应用，熟练掌握其原理和实现方式对于进一步探索这些领域至关重要。
pytorch 最简单的单向RNN应用
qq_40107571的博客
12-19 759
pytorch 最简单的单向RNN应用
Pytorch项目实战 ：基于RNN的实现情感分析
02-22
Pytorch项目实战 ：基于RNN的实现情感分析 ├──1 Word2Sequence的初始化函数.mp4 31.70M ├──10 RNN模型的预测.mp4 20.75M ├──11 循环神经网络基本原理和模型改进.mp4 67.78M ├──2 语料库词频统计.mp4 26....
pytorch-基于RNN的MNIST手写数据集识别
04-23
代码是利用pytorch框架实现的，识别过程是利用循环神经网络RNN进行训练。
Pytorch 实现RNN回归.zip
01-22
Pytorch 实现RNN回归
PyTorch 的 RNNs 实现
Warmer_Sweeter
03-02 468
欢迎关注“小白玩转Python”，发现更多 “有趣”大多数类型的神经网络都是建立在对样本进行预测的基础上的，这些样本的目标都是神经网络训练过的。一个典型的例子是 MNIST 数据集。像 ...
Python实现RNN
weixin_33853827的博客
05-12 624
一般的前馈神经网络中, 输出的结果只与当前输入有关与历史状态无关, 而递归神经网络(Recurrent Neural Network, RNN)神经元的历史输出参与下一次预测. 本文中我们将尝试使用RNN处理二进制加法问题: 两个加数作为两个序列输入, 从右向左处理加数序列.和的某一位不仅与加数的当前位有关, 还与上一位的进位有关. 词语的含义与上下文有关, 未来的状态不仅与当前相关还与历史状态相...
PyTorch实现RNN（两种构造RNN的方式；序列到序列的训练）
WeilingDu的博客
09-16 4414
RNN pytorch 在PyTorch中有两种构造RNN的方式：一种是构造RNNCell，然后自己写循环；一种是直接构造RNN。 第一种：构造RNNCell，然后自己写循环 构造RNNCell 需要两个参数：input_size和hidden_size。 cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size) 使用RNNCell hidden = cell(input, hidden) 调用时，将当前输入
pytorch实现RNN循环神经网络
m0_71145378的博客
10-25 3615
一、概述循环神经网络（Recurrent Neural Network, RNN）是一类以（sequence）数据为输入，在序列的演进方向进行（recursion）且所有节点（循环单元）按链式连接的（recursive neural network），通过网络的内部结构捕捉序列之间的模式特征，一般也是以序列形式输出。RNN(Recurrent Neural Network) 是带有循环的神经网络。假设我们有一组向量，通过假设函数$H$解释代表时间量，是非线性函数，相对应的是每次循环的输出。
【PyTorch】深度学习实践之 RNN基础篇——实现RNN
zoetu
08-19 1万+
深度学习实践之 RNN基础篇——实现RNN，one-hot向量、LSTM，GRU
pytorch实现RNN：循环神经网络在股价预测的应用
"第九章（1）：循环神经网络与pytorch示例（RNN实现股价预测）" 在本章节中，我们将深入探讨循环神经网络（RNN）的概念及其在PyTorch中的应用，特别是用于股价预测。循环神经网络是处理序列数据的强大工具，尤其...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值