devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Pytorch实现的LSTM、RNN模型结构_pytorch lstm

作者：运维做开发 | 2024-07-29 04:48:54

赞

踩

pytorch lstm

一、LSTM模型

  1. import torch
  2. from torch import nn
  3. import torchvision.datasets as dsets
  4. import torchvision.transforms as transforms
  5. import matplotlib.pyplot as plt
  6.  
  7. torch.manual_seed(1)
  8.  
  9. # Hyper Parameters
  10. EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
  11. BATCH_SIZE = 64
  12. TIME_STEP = 28      # rnn 时间步数 / 图片高度
  13. INPUT_SIZE = 28     # rnn 每步输入值 / 图片每行像素
  14. LR = 0.01           # learning rate
  15. DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 Fasle
  16.  
  17. # Mnist 手写数字
  18. train_data = dsets.MNIST(
  19.     root='./mnist/',      # 保存或者提取位置
  20.     train=True,  # this is training data
  21.     transform=transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
  22.                                                     # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
  23.     download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
  24. )
  25.  
  26. # plot one example
  27. # print(train_data.train_data.size())     # (60000, 28, 28)
  28. # print(train_data.train_labels.size())   # (60000)
  29. # plt.imshow(train_data.train_data[0].numpy(), cmap='gray')
  30. # plt.title('%i' % train_data.train_labels[0])
  31. # plt.show()
  32.  
  33. # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
  34. train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
  35.  
  36. # 为了节约时间, 我们测试时只测试前2000个
  37. test_data = dsets.MNIST(root='./mnist/', train=False, transform=transforms.ToTensor())
  38. test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
  39. test_y = test_data.test_labels.numpy()[:2000]    # covert to numpy array
  40.  
  41. class RNN(nn.Module):
  42.     def __init__(self):
  43.         super(RNN, self).__init__()
  44.  
  45.         self.rnn = nn.LSTM(     # LSTM 效果要比 nn.RNN() 好多了
  46.             input_size=28,      # 图片每行的数据像素点
  47.             hidden_size=64,     # rnn hidden unit
  48.             num_layers=1,       # 有几层 RNN layers
  49.             batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
  50.         )
  51.  
  52.         self.out = nn.Linear(64, 10)    # 输出层
  53.  
  54.     def forward(self, x):
  55.         # 输入的input为，(batch, time_step, input_size)
  56.         # x shape (batch, time_step, input_size)
  57.         # r_out shape (batch, time_step, output_size)
  58.         # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
  59.         # h_c shape (n_layers, batch, hidden_size)
  60.         r_out, (h_n, h_c) = self.rnn(x, None)   # None 表示 hidden state 会用全0的 state
  61.  
  62.         # 选取最后一个时间点的 r_out 输出
  63.         # 这里 r_out[:, -1, :] 的值也是 h_n 的值。
  64.         # 单向：(batch_size, time_step, input_size)，如果是双向：(batch_size, time_step, hidden_size * 2)
  65.         out = self.out(r_out[:, -1, :])
  66.         return out
  67.  
  68. rnn = RNN()
  69. print(rnn)
  70.  
  71. optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
  72. loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted
  73.  
  74. # training and testing
  75. for epoch in range(EPOCH):
  76.     for step, (b_x, b_y) in enumerate(train_loader):    # gives batch data
  77.         b_x = b_x.view(-1, 28, 28)                      # reshape x to (batch, time_step, input_size)
  78.  
  79.         output = rnn(b_x)                               # rnn output
  80.         loss = loss_func(output, b_y)                   # cross entropy loss
  81.         optimizer.zero_grad()                           # clear gradients for this training step
  82.         loss.backward()                                 # backpropagation, compute gradients
  83.         optimizer.step()                                # apply gradients
  84.  
  85.         if step % 50 == 0:
  86.             test_output = rnn(test_x)                   # (samples, time_step, input_size)
  87.             pred_y = torch.max(test_output, 1)[1].data.numpy()
  88.             accuracy = float((pred_y == test_y).astype(int).sum()) / float(test_y.size)
  89.             print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
  90.  
  91. # print 10 predictions from test data
  92. test_output = rnn(test_x[:10].view(-1, 28, 28))
  93. pred_y = torch.max(test_output, 1)[1].data.numpy()
  94. print(pred_y, 'prediction number')
  95. print(test_y[:10], 'real number')

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

  1. import torch
  2. from torch import nn
  3.  
  4. class RNN(nn.Module):
  5.     def __init__(self):
  6.         super(RNN, self).__init__()
  7.  
  8.         self.rnn = nn.LSTM(     # LSTM 效果要比 nn.RNN() 好多了
  9.             input_size=28,      # 图片每行的数据像素点
  10.             hidden_size=64,     # rnn hidden unit
  11.             num_layers=1,       # 有几层 RNN layers
  12.             batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
  13.         )
  14.  
  15.         self.out = nn.Linear(64, 10)    # 输出层
  16.  
  17.     def forward(self, x):
  18.         # 输入的input为，(batch, time_step, input_size)
  19.         # x shape (batch, time_step, input_size)
  20.         # r_out shape (batch, time_step, output_size)
  21.         # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
  22.         # h_c shape (n_layers, batch, hidden_size)
  23.  
  24.         # 初始化的隐藏元和记忆元,通常它们的维度是一样的
  25.         # 1个LSTM层，batch_size=x.shape[0], 隐藏层的特征维度64
  26.         h_0 = torch.randn(1, x.shape[0], 64)
  27.         c_0 = torch.randn(1, x.shape[0], 64)
  28.         r_out, (h_n, h_c) = self.rnn(x, (h_0, c_0))   # None 表示 hidden state 会用全0的 state
  29.  
  30.         # 选取最后一个时间点的 r_out 输出
  31.         # 这里 r_out[:, -1, :] 的值也是 h_n 的值
  32.         out = self.out(r_out[:, -1, :])
  33.         return out
  34.  
  35. rnn = RNN()
  36. print(rnn)

参数：

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

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

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

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

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

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

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

output的默认维度是：

  1. output(seq_len, batch, hidden_size * num_directions)
  2. ht(num_layers * num_directions, batch, hidden_size)
  3. ct(num_layers * num_directions, batch, hidden_size)

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

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

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

  1. import torch
  2. import torch.nn as nn
  3.  
  4.  
  5. class LSTM_v1(nn.Module):
  6.     def __init__(self, input_sz, hidden_sz):
  7.         super().__init__()
  8.         self.input_size = input_sz
  9.         self.hidden_size = hidden_sz
  10.  
  11.         # 遗忘门
  12.         self.f_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)
  13.  
  14.         # 输入门
  15.         self.i_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)
  16.  
  17.         # 细胞cell
  18.         self.c_cell = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)
  19.  
  20.         # 输出门
  21.         self.o_gate = nn.Linear(self.input_size+self.hidden_size, self.hidden_size)
  22.  
  23.         self.init_weights()
  24.  
  25.     def init_weights(self):
  26.         pass
  27.  
  28.     def forward(self, x, init_states=None):
  29.         bs, seq_sz, _ = x.size()
  30.         hidden_seq = []
  31.  
  32.         if init_states is None:
  33.             h_t, c_t = (
  34.                 torch.zeros(bs, self.hidden_size).to(x.device),
  35.                 torch.zeros(bs, self.hidden_size).to(x.device)
  36.             )
  37.         else:
  38.             h_t, c_t = init_states
  39.  
  40.         for t in range(seq_sz):
  41.             x_t = x[:, t, :]
  42.  
  43.             input_t = torch.concat([x_t, h_t], dim=-1)
  44.             f_t = torch.sigmoid(self.f_gate(input_t))
  45.             i_t = torch.sigmoid(self.i_gate(input_t))
  46.             c_t_ = torch.tanh(self.c_cell(input_t))
  47.             c_t = f_t * c_t + i_t * c_t_
  48.  
  49.             o_t = torch.sigmoid(self.o_gate(input_t))
  50.             h_t = o_t * torch.tanh(c_t)
  51.  
  52.             hidden_seq.append(h_t.unsqueeze(0))
  53.         hidden_seq = torch.cat(hidden_seq, dim=0)
  54.         hidden_seq = hidden_seq.transpose(0, 1).contiguous()
  55.         return hidden_seq, (h_t, c_t)

二、RNN

  1. import torch
  2. from torch import nn
  3. import torchvision.datasets as dsets
  4. import torchvision.transforms as transforms
  5. import matplotlib.pyplot as plt
  6.  
  7. torch.manual_seed(1)
  8.  
  9. # Hyper Parameters
  10. EPOCH = 1           # 训练整批数据多少次, 为了节约时间, 我们只训练一次
  11. BATCH_SIZE = 64
  12. TIME_STEP = 28      # rnn 时间步数 / 图片高度
  13. INPUT_SIZE = 28     # rnn 每步输入值 / 图片每行像素
  14. LR = 0.01           # learning rate
  15. DOWNLOAD_MNIST = True  # 如果你已经下载好了mnist数据就写上 Fasle
  16.  
  17. # Mnist 手写数字
  18. train_data = dsets.MNIST(
  19.     root='./mnist/',      # 保存或者提取位置
  20.     train=True,  # this is training data
  21.     transform=transforms.ToTensor(),    # 转换 PIL.Image or numpy.ndarray 成
  22.                                                     # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
  23.     download=DOWNLOAD_MNIST,          # 没下载就下载, 下载了就不用再下了
  24. )
  25.  
  26. # plot one example
  27. # print(train_data.train_data.size())     # (60000, 28, 28)
  28. # print(train_data.train_labels.size())   # (60000)
  29. # plt.imshow(train_data.train_data[0].numpy(), cmap='gray')
  30. # plt.title('%i' % train_data.train_labels[0])
  31. # plt.show()
  32.  
  33. # 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
  34. train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
  35.  
  36. # 为了节约时间, 我们测试时只测试前2000个
  37. test_data = dsets.MNIST(root='./mnist/', train=False, transform=transforms.ToTensor())
  38. test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
  39. test_y = test_data.test_labels.numpy()[:2000]    # covert to numpy array
  40.  
  41. class RNN(nn.Module):
  42.     def __init__(self):
  43.         super(RNN, self).__init__()
  44.  
  45.         self.rnn = nn.RNN(    
  46.             input_size=28,      # 图片每行的数据像素点
  47.             hidden_size=64,     # rnn hidden unit
  48.             num_layers=1,       # 有几层 RNN layers
  49.             batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
  50.         )
  51.  
  52.         self.out = nn.Linear(64, 10)    # 输出层
  53.  
  54.     def forward(self, x):
  55.         # 输入的input为，(batch, time_step, input_size)
  56.         # x shape (batch, time_step, input_size)
  57.         # r_out shape (batch, time_step, output_size)
  58.         # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
  59.         # h_c shape (n_layers, batch, hidden_size)
  60.  
  61.         r_out, h = self.rnn(x, None)   # None 表示 hidden state 会用全0的 state
  62.  
  63.         # 选取最后一个时间点的 r_out 输出
  64.         out = self.out(r_out[:, -1, :])
  65.         return out
  66.  
  67. rnn = RNN()
  68. print(rnn)
  69.  
  70. optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
  71. loss_func = nn.CrossEntropyLoss()                       # the target label is not one-hotted
  72.  
  73. # training and testing
  74. for epoch in range(EPOCH):
  75.     for step, (b_x, b_y) in enumerate(train_loader):    # gives batch data
  76.         b_x = b_x.view(-1, 28, 28)                      # reshape x to (batch, time_step, input_size)
  77.  
  78.         output = rnn(b_x)                               # rnn output
  79.         loss = loss_func(output, b_y)                   # cross entropy loss
  80.         optimizer.zero_grad()                           # clear gradients for this training step
  81.         loss.backward()                                 # backpropagation, compute gradients
  82.         optimizer.step()                                # apply gradients
  83.  
  84.         if step % 50 == 0:
  85.             test_output = rnn(test_x)                   # (samples, time_step, input_size)
  86.             pred_y = torch.max(test_output, 1)[1].data.numpy()
  87.             accuracy = float((pred_y == test_y).astype(int).sum()) / float(test_y.size)
  88.             print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
  89.  
  90. # print 10 predictions from test data
  91. test_output = rnn(test_x[:10].view(-1, 28, 28))
  92. pred_y = torch.max(test_output, 1)[1].data.numpy()
  93. print(pred_y, 'prediction number')
  94. print(test_y[:10], 'real number')

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

  1. import torch
  2. from torch import nn
  3.  
  4. class RNN(nn.Module):
  5.     def __init__(self):
  6.         super(RNN, self).__init__()
  7.  
  8.         self.rnn = nn.RNN(
  9.             input_size=28,      # 图片每行的数据像素点
  10.             hidden_size=64,     # rnn hidden unit
  11.             num_layers=1,       # 有几层 RNN layers
  12.             batch_first=True,   # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
  13.         )
  14.  
  15.         self.out = nn.Linear(64, 10)    # 输出层
  16.  
  17.     def forward(self, x):
  18.         # 输入的input为，(batch, time_step, input_size)
  19.         # x shape (batch, time_step, input_size)
  20.         # r_out shape (batch, time_step, output_size)
  21.         # h_n shape (n_layers, batch, hidden_size)   LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
  22.         # h_c shape (n_layers, batch, hidden_size)
  23.  
  24.         # 初始化的隐藏元
  25.         # 1个RNN层，batch_size=x.shape[0], 隐藏层的特征维度64
  26.         h_0 = torch.randn(1,x.shape[0], 64)
  27.         r_out, h = self.rnn(x, h_0)   # None 表示 hidden state 会用全0的 state
  28.  
  29.         # 选取最后一个时间点的 r_out 输出
  30.         out = self.out(r_out[:, -1, :])
  31.         return out
  32.  
  33. rnn = RNN()
  34. print(rnn)

参数：

  1. nn.RNN是PyTorch中的一个循环神经网络模型。它有几个重要的参数：
  2.  
  3. input_size：输入的特征维度大小。
  4. hidden_size：隐藏状态的维度大小。
  5. num_layers：RNN层数。
  6. nonlinearity：非线性激活函数，默认为’tanh’。
  7. bias：是否使用偏置，默认为True。
  8. batch_first：如果为True，则输入的维度为(batch_size, seq_length, input_size)，否则为(seq_length, batch_size, input_size)。默认为False。
  9. dropout：如果非零，则在输出之间应用丢弃以进行稀疏连接。
  10. bidirectional：如果为True，则使用双向RNN，默认为False。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/897234
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号