Pytorch实现的LSTM、RNN模型结构

最新推荐文章于 2024-04-30 22:45:00 发布
最新推荐文章于 2024-04-30 22:45:00 发布
阅读量727 收藏 2
点赞数
分类专栏： 记录本 文章标签： pytorch lstm 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45100200/article/details/133023072
版权

一、LSTM模型

import torch
from torch import nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

torch.manual_seed(1)

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 64
TIME_STEP = 28      # rnn 时间步数 / 图片高度
INPUT_SIZE = 28     # rnn 每步输入值 / 图片每行像素
LR = 0.01           # learning rate
DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 Fasle

# Mnist 手写数字
train_data = dsets.MNIST(
    root='./mnist/',      # 保存或者提取位置
    train=True,  # this is training data
    transform=transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

# plot one example
# print(train_data.train_data.size())     # (60000, 28, 28)
# print(train_data.train_labels.size())   # (60000)
# plt.imshow(train_data.train_data[0].numpy(), cmap='gray')
# plt.title('%i' % train_data.train_labels[0])
# plt.show()

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_data = dsets.MNIST(root='./mnist/', train=False, transform=transforms.ToTensor())
test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
test_y = test_data.test_labels.numpy()[:2000]    # covert to numpy array

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.LSTM(     # LSTM 效果要比 nn.RNN() 好多了
            input_size=28,      # 图片每行的数据像素点
            hidden_size=64,     # rnn hidden unit
            num_layers=1,       # 有几层 RNN layers
            batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)    # 输出层

    def forward(self, x):
        # 输入的input为，(batch, time_step, input_size)
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)
        # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
        # h_c shape (n_layers, batch, hidden_size)
        r_out, (h_n, h_c) = self.rnn(x, None)   # None 表示 hidden state 会用全0的 state

        # 选取最后一个时间点的 r_out 输出
        # 这里 r_out[:, -1, :] 的值也是 h_n 的值
        out = self.out(r_out[:, -1, :])
        return out

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):    # gives batch data
        b_x = b_x.view(-1, 28, 28)                      # reshape x to (batch, time_step, input_size)

        output = rnn(b_x)                               # rnn output
        loss = loss_func(output, b_y)                   # cross entropy loss
        optimizer.zero_grad()                           # clear gradients for this training step
        loss.backward()                                 # backpropagation, compute gradients
        optimizer.step()                                # apply gradients

        if step % 50 == 0:
            test_output = rnn(test_x)                   # (samples, time_step, input_size)
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            accuracy = float((pred_y == test_y).astype(int).sum()) / float(test_y.size)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)

# print 10 predictions from test data
test_output = rnn(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')

上述中，我们对于h_n, h_c全部以0为输入，此时我们也可以修改为随机参数：

import torch
from torch import nn

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.LSTM(     # LSTM 效果要比 nn.RNN() 好多了
            input_size=28,      # 图片每行的数据像素点
            hidden_size=64,     # rnn hidden unit
            num_layers=1,       # 有几层 RNN layers
            batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)    # 输出层

    def forward(self, x):
        # 输入的input为，(batch, time_step, input_size)
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)
        # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
        # h_c shape (n_layers, batch, hidden_size)

        # 初始化的隐藏元和记忆元,通常它们的维度是一样的
        # 1个LSTM层，batch_size=x.shape[0], 隐藏层的特征维度64
        h_0 = torch.randn(1, x.shape[0], 64)
        c_0 = torch.randn(1, x.shape[0], 64)
        r_out, (h_n, h_c) = self.rnn(x, (h_0, c_0))   # None 表示 hidden state 会用全0的 state

        # 选取最后一个时间点的 r_out 输出
        # 这里 r_out[:, -1, :] 的值也是 h_n 的值
        out = self.out(r_out[:, -1, :])
        return out

rnn = RNN()
print(rnn)

参数：

class torch.nn.LSTM(*args, **kwargs)
参数有：
    input_size：x的特征维度
    hidden_size：隐藏层的特征维度
    num_layers：lstm隐层的层数，默认为1
    bias：False则bihbih=0和bhhbhh=0. 默认为True
    batch_first：True则输入输出的数据格式为 (batch, seq, feature)
    dropout：除最后一层，每一层的输出都进行dropout，默认为: 0
    bidirectional：True则为双向lstm默认为False

LSTM的另外两个输入是 h0 和 c0，可以理解成网络的初始化参数，用随机数生成即可。

h0(num_layers * num_directions, batch, hidden_size)
c0(num_layers * num_directions, batch, hidden_size)
参数：
    num_layers：隐藏层数
    num_directions：如果是单向循环网络，则num_directions=1，双向则num_directions=2
    batch：输入数据的batch
    hidden_size：隐藏层神经元个数

注意，如果我们定义的input格式是：

input(batch, seq_len, input_size)
则H和C的格式也是要变的：
h0(batch, num_layers * num_directions,  hidden_size)
c0(batch, num_layers * num_directions,  hidden_size)

LSTM的输出是一个tuple，如下：

output,(ht, ct) = net(input)
    output: 最后一个状态的隐藏层的神经元输出
    ht：最后一个状态的隐含层的状态值
    ct：最后一个状态的隐含层的遗忘门值

output的默认维度是：

output(seq_len, batch, hidden_size * num_directions)
ht(num_layers * num_directions, batch, hidden_size)
ct(num_layers * num_directions, batch, hidden_size)

和input的情况类似，如果我们前面定义的input格式是：

input(batch, seq_len, input_size)
则ht和ct的格式也是要变的：
ht(batc，num_layers * num_directions, h, hidden_size)
ct(batc，num_layers * num_directions, h, hidden_size)

我们使用线性函数进行构建LSTM：

import torch
import torch.nn as nn


class LSTM_v1(nn.Module):
    def __init__(self, input_sz, hidden_sz):
        super().__init__()
        self.input_size = input_sz
        self.hidden_size = hidden_sz

        # 遗忘门
        self.f_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)

        # 输入门
        self.i_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)

        # 细胞cell
        self.c_cell = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)

        # 输出门
        self.o_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)

        self.init_weights()

    def init_weights(self):
        pass

    def forward(self, x, init_states=None):
        bs, seq_sz, _ = x.size()
        hidden_seq = []

        if init_states is None:
            h_t, c_t = (
                torch.zeros(bs, self.hidden_size).to(x.device),
                torch.zeros(bs, self.hidden_size).to(x.device)
            )
        else:
            h_t, c_t = init_states

        for t in range(seq_sz):
            x_t = x[:, t, :]

            input_t = torch.concat([x_t, h_t], dim=-1)
            f_t = torch.sigmoid(self.f_gate(input_t))
            i_t = torch.sigmoid(self.i_gate(input_t))
            c_t_ = torch.tanh(self.c_cell(input_t))
            c_t = f_t * c_t + i_t * c_t_

            o_t = torch.sigmoid(self.o_gate(input_t))
            h_t = o_t * torch.tanh(c_t)

            hidden_seq.append(h_t.unsqueeze(0))
        hidden_seq = torch.cat(hidden_seq, dim=0)
        hidden_seq = hidden_seq.transpose(0, 1).contiguous()
        return hidden_seq, (h_t, c_t)

二、RNN

import torch
from torch import nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

torch.manual_seed(1)

# Hyper Parameters
EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 64
TIME_STEP = 28      # rnn 时间步数 / 图片高度
INPUT_SIZE = 28     # rnn 每步输入值 / 图片每行像素
LR = 0.01           # learning rate
DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 Fasle

# Mnist 手写数字
train_data = dsets.MNIST(
    root='./mnist/',      # 保存或者提取位置
    train=True,  # this is training data
    transform=transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
                                                    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
)

# plot one example
# print(train_data.train_data.size())     # (60000, 28, 28)
# print(train_data.train_labels.size())   # (60000)
# plt.imshow(train_data.train_data[0].numpy(), cmap='gray')
# plt.title('%i' % train_data.train_labels[0])
# plt.show()

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_data = dsets.MNIST(root='./mnist/', train=False, transform=transforms.ToTensor())
test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
test_y = test_data.test_labels.numpy()[:2000]    # covert to numpy array

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.RNN(    
            input_size=28,      # 图片每行的数据像素点
            hidden_size=64,     # rnn hidden unit
            num_layers=1,       # 有几层 RNN layers
            batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)    # 输出层

    def forward(self, x):
        # 输入的input为，(batch, time_step, input_size)
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)
        # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
        # h_c shape (n_layers, batch, hidden_size)

        r_out, h = self.rnn(x, None)   # None 表示 hidden state 会用全0的 state

        # 选取最后一个时间点的 r_out 输出
        out = self.out(r_out[:, -1, :])
        return out

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader):    # gives batch data
        b_x = b_x.view(-1, 28, 28)                      # reshape x to (batch, time_step, input_size)

        output = rnn(b_x)                               # rnn output
        loss = loss_func(output, b_y)                   # cross entropy loss
        optimizer.zero_grad()                           # clear gradients for this training step
        loss.backward()                                 # backpropagation, compute gradients
        optimizer.step()                                # apply gradients

        if step % 50 == 0:
            test_output = rnn(test_x)                   # (samples, time_step, input_size)
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            accuracy = float((pred_y == test_y).astype(int).sum()) / float(test_y.size)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)

# print 10 predictions from test data
test_output = rnn(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')

上述中，我们对于h全部以0为输入，此时我们也可以修改为随机参数：

import torch
from torch import nn

class RNN(nn.Module):
    def __init__(self):
        super(RNN, self).__init__()

        self.rnn = nn.RNN(
            input_size=28,      # 图片每行的数据像素点
            hidden_size=64,     # rnn hidden unit
            num_layers=1,       # 有几层 RNN layers
            batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)    # 输出层

    def forward(self, x):
        # 输入的input为，(batch, time_step, input_size)
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)
        # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
        # h_c shape (n_layers, batch, hidden_size)

        # 初始化的隐藏元
        # 1个RNN层，batch_size=x.shape[0], 隐藏层的特征维度64
        h_0 = torch.randn(1,x.shape[0], 64)
        r_out, h = self.rnn(x, h_0)   # None 表示 hidden state 会用全0的 state

        # 选取最后一个时间点的 r_out 输出
        out = self.out(r_out[:, -1, :])
        return out

rnn = RNN()
print(rnn)

参数：

nn.RNN是PyTorch中的一个循环神经网络模型。它有几个重要的参数：

input_size：输入的特征维度大小。
hidden_size：隐藏状态的维度大小。
num_layers：RNN层数。
nonlinearity：非线性激活函数，默认为’tanh’。
bias：是否使用偏置，默认为True。
batch_first：如果为True，则输入的维度为(batch_size, seq_length, input_size)，否则为(seq_length, batch_size, input_size)。默认为False。
dropout：如果非零，则在输出之间应用丢弃以进行稀疏连接。
bidirectional：如果为True，则使用双向RNN，默认为False。
清纯世纪
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Pytorch使用 LSTM RNN 的词级语言建模代码.zip
08-13
Pytorch使用 LSTM RNN 的词级语言建模代码
pytorch中实现循环神经网络的基本单元RNN、LSTM、GRU的输入、输出、参数详细理解
MIss-Y的博客
08-31 1万+
前言：这篇文章是对已经较为深入理解了RNN、LSTM、GRU的数学原理以及运算过程的人而言的，如果不理解它的基本思想和过程，可能理解起来不是很简单。 一、先从一个实例看起 这是官网上面的一个例子，本次以LSTM作为例子而言，实际上，GRU、LSTM、RNN的运算过程是很类似的。 import torch import torch.nn as nn lstm = nn.LSTM(10,...
Pytorch实现RNN，LSTM和GRU超详细代码参数解析
adczsw的博客
12-04 5709
本文针对使用pytorch实现RNN，LSTM和GRU对应参数的详细解析，相信通过阅读此文章，能够让你对循环神经网络有一个很清楚的认识。也希望你能耐心看完，相信会对你有很大的帮助。大佬直接跳过。这篇文章分析的会特别基础。 Pytorch官网提供的循环脑神经网络总共7个函数，nn.RNN、nn.LSTM、nn.GRU可以实现多层的循环神经网络，而nn.RNNCell、nn.LSTMCell、nn.GRUCell只提供一个网络层。 官网：LSTM — PyTorch 1.10.0 documentati
时间序列数据处理1——基于Pytorch构建长短时记忆网络（LSTM）
sinat_41354290的博客
07-01 2745
 本文主要实现基于pytorch构建长短时记忆网络（LSTM）的相关搬运工作。 目录1. LSTM简介1.1 从RNN说起1.2 什么是LSTM1.3 深入LSTM1.4 总结 1. LSTM简介 1.1 从RNN说起 循环神经网络（Recurrent Neural Network，RNN）是一种用于处理序列数据的神经网络。相比一般的神经网络来说，他能够处理序列变化的数据。 RNN之所以在时序数据上有着优异的表现是因为RNN在 ttt 时间片时会将 t−1t-1t−1 时间片的隐节点作为当前时间片的输入..
pytorch搭建RNN-LSTM循环神经网络[回归]详解
Troublemaker丶的博客
04-11 3270
实验结果： 这次用RNN_LSTM实现回归任务 代码中使用sin函数 拟合 cos函数 这里主要讲解搭建RNN部分，其他部分和前文中CNN搭建类似。 可参考pytorch搭建CNN卷积神经网络详解 ???? 搭建RNN（该任务使用RNN足矣） class RNN(nn.Module): def __init__(self): super(RNN, self)._...
【pytorch】nn.LSTM的使用
安安爸Chris的专栏
08-29 1万+
官方文档在这里。 LSTM具体不做介绍了，本篇只做pytorch的API使用介绍 torch.nn.LSTM(*args, **kwargs) 公式 LSTM中参数挖掘 以下公式介绍都忽略bias 公式(1), 输入门 it=δ(Wiixt+Whiht−1)i_t = \delta(W_{ii}x_t+W_{hi}h_{t-1})it​=δ(Wii​xt​+Whi​ht−1​)， LSTM中有关输入的参是是WiiW_{ii}Wii​和WhiW_{hi}Whi​ 公式(2),遗忘门 ft=δ(Wifx
【Pytorch】nn.LSTM的理解
qq_37880748的博客
08-25 1万+
Pytorch中的nn.LSTM Pytorch中LSTM总共有7个参数，前面3个是必须输入的 input_size – The number of expected features in the input x hidden_size – The number of features in the hidden state h num_layers – Number of recurrent layers. E.g., setting num_layers=2 would mean stackin
PyTorch的nn.LSTM使用说明
屏幕里的日与夜
07-03 1万+
PyTorch的nn包下面自带很多经典的模型，我们可以快速的引入一个预训练好了的模型用来处理我们的任务，也可以单纯的添加一个这种架构的空白网络称为我们模型的子结构。其中LSTM是使用的相当多的一个，本文介绍nn.LSTM的一些使用情况。
[深度学习] Pytorch中RNN/LSTM 模型小结
摩登都市天空---专栏
01-15 1万+
目录 一 Liner 二 RNN 三 LSTM 四 LSTM 代码例子 概念介绍可以参考：[深度学习]理解RNN, GRU, LSTM 网络 Pytorch中所有模型分为构造参数和输入和输出构造参数两种类型。 模型构造参数主要限定了网络的结构，如对循环网络，则包括输入维度、隐层\输出维度、层数；对卷积网络，无论卷积层还是池化层，都不关心输入维度，其构造方法只涉及卷积核大小\步长等。...
pytorch实现LSTM（附code）
热门推荐
ting_qifengl的博客
01-23 5万+
最近搞了一个NASA PCoE的IGBT加速老化数据，想基于pytorch框架写一个LSTM模型进行IGBT退化状态的预测，于是有了这篇文章。 注：LSTM的原理就不多讲了，网上一大堆，不懂的自己去百度，本文主要侧重代码实现。 一、数据集介绍 本数据集是NASA PCoE研究中心公布的IGBT加速老化数据集。数据集含有四种实验条件下的IGBT加速老化数据，以下是实验条件： （1）新设备的源测量单元（SMU data for new devices） 该文件中含有一组原始实验条件下的电气特性数据，分
pytorch-sentiment-analysis-classification:情感分析分类的PyTorch教程（RNN，LSTM，Bi-LSTM，LSTM + Attention，CNN）
05-24
情感分析分类 先决条件 安装依赖项 pip install -r requirements.txt 安装Spacy英语数据 python -m spacy download en 框架 火炬 数据集 Cornell MR（电影评论）数据集...RNN LSTM 双LSTM LSTM +注意 有线电视新闻网
Pytorch实现LSTM和GRU示例
12-23
为了解决传统RNN无法长时依赖问题，RNN的两个变体LSTM和GRU被引入。 LSTM Long Short Term Memory，称为长短期记忆网络，意思就是长的短时记忆，其解决的仍然是短时记忆问题，这种短时记忆比较长，能一定程度上解决...
基于pytorch实现的LSTM神经网络，使LSTM学会0-9个位以内的加法运算
03-03
基于pytorch的实现的LSTM，有完整的定义和使用，数据集和验证集自动生成，训练500次后随机生成20组验证数据，正确率100%，代码加上注释共160行，是个简单实用的LTSM神经网络入门学习例子
基于pytorch的RNN、LSTM回归预测
04-12
datas/ 三份数据集 error_value/ 每种方法预测结果的评价指标（RMSE，MAE，MAPE） fig_res/ 预测曲线图 ...超参数.docx 三份数据集，RNN，LSTM，AM-LSTM三种方法所用超参数。MLP和SVR没调，可能意义不大
深度学习框架pytorch：tensor.data和tensor.detach()的区别
huanfeng_AI的博客
04-24 194
现在来看大家还是推荐使用detach(）方法，然后当tensor的requires_grad=False情况下，tensor.data或者tensor.detach（）与tensor等价，而当tensor的requires_grad=True情况下，tensor.data为获取tensor中的数据。
Pytorch分布式train——pytorch.distributed.launch V.S. torchrun
shuia64649495的博客
04-27 413
master_addr：master节点的ip地址，也就是0号主机的IP地址，该参数是为了让 其他节点 知道0号节点的位，来将自己训练的参数传送过去处理。-master_port：master节点的port号，在不同的节点上master_addr和master_port的设置是一样的，用来进行通信。node_rank：指的是当前启动的是第几台服务器，从 0 开始。nnodes：节点（主机）的数量，通常一个节点对应一个主机。nproc_per_node：一个节点中显卡的数量。
Ubuntu如何更换 PyTorch 版本
最新发布
玩人工智能的辣条哥的博客
04-30 263
WLS2。
搭建最新tensorflow 与pytorch环境
活到老、学到老
04-24 795
这将在您的用户家目录下创建一个名为 jupyter_lab_config.py 的文件，通常位于 ~/.jupyter/jupyter_lab_config.py（具体路径可能因操作系统而异）。请将 替换为您要安装的包名， 替换为具体的频道名，如 conda-forge、pytorch 等。如果没有报错且输出了 PyTorch 的版本号，并且（对于 GPU 版本）torch.cuda.is_available() 返回 True，说明安装成功。
【Pytorch】（十三）模型部署: TorchScript
weixin_44378835的博客
04-24 1334
用于将一个具体的输入示例追踪（trace）模型的一次计算过程，从而生成一个 TorchScript 模型。对于动态控制流（如条件语句），它只会记录每个分支中的一种情况。因此，它不适用于无固定形状输入、具有动态控制流的模型。用于将整个 PyTorch 模型转换为 TorchScript 模型，包括模型的所有逻辑和控制流。script适用于无固定形状输入、具有动态控制流的模型。但是，它可能会把保存一些多余的代码, 产生额外的性能开销。因此，可以将两者混合使用，扬长避短。
pytorch LstmRNN用法
07-20
在 PyTorch 中使用 LSTM 进行建模的步骤如下： 1. 导入必要的库和模块： ```python import torch import torch.nn as nn ``` 2. 定义 LSTM 模型： ```python class LSTMModel(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super(LSTMModel, self).__init__() self.hidden_dim = hidden_dim self.lstm = nn.LSTM(input_dim, hidden_dim) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): lstm_out, _ = self.lstm(x) out = self.fc(lstm_out[:, -1, :]) return out ``` 在这个例子中，我们定义了一个名为 LSTMModel 的类，继承自 nn.Module。在构造函数中，我们定义了 LSTM 层和全连接层。forward 方法用于定义数据在模型中的流动方式。 3. 实例化模型： ```python input_dim = 10 # 输入维度 hidden_dim = 32 # 隐藏层维度 output_dim = 1 # 输出维度 model = LSTMModel(input_dim, hidden_dim, output_dim) ``` 4. 定义损失函数和优化器： ```python criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) ``` 5. 准备数据并进行训练： ```python # 假设有训练数据 x 和目标值 y # 转换数据为 PyTorch 张量 x = torch.tensor(x, dtype=torch.float32) y = torch.tensor(y, dtype=torch.float32) # 前向传播和计算损失 outputs = model(x) loss = criterion(outputs, y) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() ``` 这是一个简单的使用 PyTorch 实现 LSTM 模型的示例。你可以根据自己的数据和任务进行适当的调整和扩展。记得根据具体情况调整模型架构、超参数和训练过程，以获得更好的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清纯世纪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值