• Pytorch实现的LSTM、RNN模型结构

    一、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.         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_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。
  • 相关阅读:
    如何恢复edge的自动翻译功能
    基于vue3 + ant-design 自定义SVG图标iconfont的解决方案；ant-design加载本地iconfont.js不显示图标问题
    RoHS认证测试的3种方法，RoHS测试，RoHS检测，RoHS认证是什么
    中文编程开发语言工具构件说明：屏幕截取构件的编程操作
    我的创作纪念日
    ES6知识点（1）
    leetcode - 22 672. 灯泡开关 Ⅱ
    第四章 串
    关于python上的一个坑——reload导致模块重置
    《一个程序猿的生命周期》-《发展篇》- 42.逃离“管理”陷阱
  • 原文地址：https://blog.csdn.net/qq_45100200/article/details/133023072