• RNN 循环神经网络 回归 地平线上的背影关注 RNN网络较少运用于回归任务，但是并不代表其不可运用于回归任务。本文通过简单回归任务的RNN进一步加深对RNN的理解 1. 准备数据和超参数 import torch from torch ...
RNN 循环神经网络 回归

地平线上的背影关注

RNN网络较少运用于回归任务，但是并不代表其不可运用于回归任务。本文通过简单回归任务的RNN进一步加深对RNN的理解

1. 准备数据和超参数

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()


2. 构建RNN神经网络

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

self.rnn = nn.RNN(
input_size=INPUT_SIZE,
hidden_size=32,     # rnn hidden unit
num_layers=1,       # number of rnn layer
batch_first=True,
# input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
)
self.out = nn.Linear(32, 1)

def forward(self, x, h_state):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, hidden_size)
r_out, h_state = self.rnn(x, h_state)

outs = []    # save all predictions
for time_step in range(r_out.size(1)):    # calculate output for each time step
outs.append(self.out(r_out[:, time_step, :]))

# instead, for simplicity, you can replace above codes by follows
# r_out = r_out.view(-1, 32)
# outs = self.out(r_out)
# outs = outs.view(-1, TIME_STEP, 1)
# return outs, h_state

# or even simpler, since nn.Linear can accept inputs of any dimension
# and returns outputs with same dimension except for the last
# outs = self.out(r_out)
# return outs

rnn = RNN()
print(rnn)


3. 选择优化器和损失函数

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()


注：

MSELoss()：均方误差损失函数，常用于预测模型中

4. 初始化数据和plt图像

h_state = None      # for initial hidden state

plt.figure(1, figsize=(12, 5))
plt.ion()           # continuously plot


5. 训练和优化

for step in range(100):
start, end = step * np.pi, (step+1)*np.pi   # time range
# use sin predicts cos
steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)
# float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)

x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])
# shape (batch, time_step, input_size)
y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

prediction, h_state = rnn(x, h_state)   # rnn output
# !! next step is important !!
h_state = h_state.data
# repack the hidden state, break the connection from last iteration

loss = loss_func(prediction, y)         # calculate loss

# plotting
plt.plot(steps, y_np.flatten(), 'r-')
plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()

展开全文
• 本文主要介绍使用RNN来实现回归，对曲线进行预测。 示例代码： import numpy as np from keras.datasets import mnist from keras.utils import np_utils from keras.models import Sequential from keras.layers...
本文主要介绍使用RNN来实现回归，对曲线进行预测。

示例代码：

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, TimeDistributed, LSTM
import matplotlib.pyplot as plt

# 使多次生成的随机数相同
np.random.seed(1337)

# 超参数
BATCH_START = 0
TIME_STEPS = 20
BATCH_SIZE = 50
INPUT_SIZE = 1
OUTPUT_SIZE = 1
CELL_SIZE = 20
LR = 0.006

# 生成数据
def get_batch():
global BATCH_START, TIME_STEPS
# xs shape (50batch, 20steps)
xs = np.arange(BATCH_START, BATCH_START+TIME_STEPS*BATCH_SIZE).reshape((BATCH_SIZE, TIME_STEPS)) / (10*np.pi)
seq = np.sin(xs)
res = np.cos(xs)
BATCH_START += TIME_STEPS
# plt.plot(xs[0, :], res[0, :], 'r', xs[0, :], seq[0, :], 'b--')
# plt.show()
return [seq[:, :, np.newaxis], res[:, :, np.newaxis], xs]

# 查看数据
# get_batch()
# exit()
# 搭建网络
model = Sequential()

# 添加LSTM层
batch_input_shape=(BATCH_SIZE, TIME_STEPS, INPUT_SIZE),
output_dim=CELL_SIZE,
return_sequences=True,  # 对于每一个时间点需不需要输出对应的output, True每个时刻都输出， False最后的输出output
stateful=True,  # batch与batch之间是否有联系，需不需要将状态进行传递
))

# 优化器
model.compile(
loss='mse',
)

# 训练
print('Training ------------')
for step in range(501):
# data shape = (batch_num, steps, inputs/outputs)
X_batch, Y_batch, xs = get_batch()
cost = model.train_on_batch(X_batch, Y_batch)
pred = model.predict(X_batch, BATCH_SIZE)
plt.plot(xs[0, :], Y_batch[0].flatten(), 'r', xs[0, :], pred.flatten()[:TIME_STEPS], 'b--')
plt.ylim((-1.2, 1.2))
plt.draw()
plt.pause(0.1)
if step % 10 == 0:
print('train cost: ', cost)

数据示例：

def get_batch():
global BATCH_START, TIME_STEPS
# xs shape (50batch, 20steps)
xs = np.arange(BATCH_START, BATCH_START+TIME_STEPS*BATCH_SIZE).reshape((BATCH_SIZE, TIME_STEPS)) / (1*np.pi)
seq = np.sin(xs)
res = np.cos(xs)
BATCH_START += TIME_STEPS
plt.plot(xs[0, :], res[0, :], 'r', xs[0, :], seq[0, :], 'b--')
plt.show()
return [seq[:, :, np.newaxis], res[:, :, np.newaxis], xs]

# 查看数据
get_batch()
exit()

结果：

train cost:  0.50940645
train cost:  0.4966624
train cost:  0.48060146
train cost:  0.45672885
train cost:  0.4108651
train cost:  0.31347314
train cost:  0.12554297
train cost:  0.07388962
train cost:  0.10137392
train cost:  0.046597198
train cost:  0.05946522
train cost:  0.040294208
train cost:  0.053411756
train cost:  0.15622795
train cost:  0.17914045
train cost:  0.16356382
train cost:  0.21077277
train cost:  0.20014948
train cost:  0.18070495
train cost:  0.16142645
train cost:  0.19912449
train cost:  0.16934186
train cost:  0.16477375
train cost:  0.17521137
train cost:  0.20553884
train cost:  0.15104571
train cost:  0.16296455
train cost:  0.16819069
train cost:  0.11465822
train cost:  0.14150377
train cost:  0.13508156
train cost:  0.13755415
train cost:  0.13000277
train cost:  0.11969448
train cost:  0.09293661
train cost:  0.0819223
train cost:  0.06903682
train cost:  0.07125411
train cost:  0.08032415
train cost:  0.07321488
train cost:  0.096763514
train cost:  0.078285255
train cost:  0.07236056
train cost:  0.065320924
train cost:  0.057717755
train cost:  0.063192114
train cost:  0.047402352
train cost:  0.05537389
train cost:  0.051893406
train cost:  0.052938405
train cost:  0.05649735

欢迎关注我的公众号：

编程技术与生活（ID：hw_cchang）


展开全文
• 循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果.上次我们提到了用 RNN 的最后一个时间点输出来判断之前看到的图片属于哪一类, 这次我们来真的了, 用 RNN 来及时预测时间序列. ...
目录

1.写在前面

2.训练数据

3.RNN模型

4.训练

5.完整代码演示

1.写在前面

循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果.上次我们提到了用 RNN 的最后一个时间点输出来判断之前看到的图片属于哪一类, 这次我们来真的了, 用 RNN 来及时预测时间序列.

2.训练数据

我们要用到的数据就是这样的一些数据, 我们想要用 sin 的曲线预测出 cos 的曲线.

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step / image height
INPUT_SIZE = 1      # rnn input size / image width
LR = 0.02           # learning rate
DOWNLOAD_MNIST = False  # set to True if haven't download the data

3.RNN模型

这一次的 RNN, 我们对每一个 r_out 都得放到 Linear 中去计算出预测的 output, 所以我们能用一个 for loop 来循环计算. 这点是 Tensorflow 望尘莫及的! 看看我们的 PyTorch 和 Tensorflow 到底哪家强.

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

self.rnn = nn.RNN(  # 这回一个普通的 RNN 就能胜任
input_size=1,
hidden_size=32,     # 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(32, 1)

def forward(self, x, h_state):  # 因为 hidden state 是连续的, 所以我们要一直传递这一个 state
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, output_size)
r_out, h_state = self.rnn(x, h_state)   # h_state 也要作为 RNN 的一个输入

outs = []    # 保存所有时间点的预测值
for time_step in range(r_out.size(1)):    # 对每一个时间点计算 output
outs.append(self.out(r_out[:, time_step, :]))

rnn = RNN()
print(rnn)
"""
RNN (
(rnn): RNN(1, 32, batch_first=True)
(out): Linear (32 -> 1)
)
"""

其实熟悉 RNN 的朋友应该知道, forward 过程中的对每个时间点求输出还有一招使得计算量比较小的. 不过上面的内容主要是为了呈现 PyTorch 在动态构图上的优势, 所以我用了一个 for loop 来搭建那套输出系统. 下面介绍一个替换方式. 使用 reshape 的方式整批计算.

def forward(self, x, h_state):
r_out, h_state = self.rnn(x, h_state)
r_out = r_out.view(-1, 32)
outs = self.out(r_out)
return outs.view(-1, 32, TIME_STEP), h_state

4.训练

下面的代码就能实现动图的效果啦~开心, 可以看出, 我们使用 x 作为输入的 sin 值, 然后 y 作为想要拟合的输出, cos 值. 因为他们两条曲线是存在某种关系的, 所以我们就能用 sin 来预测 cos. rnn 会理解他们的关系, 并用里面的参数分析出来这个时刻 sin 曲线上的点如何对应上 cos 曲线上的点.

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all rnn parameters
loss_func = nn.MSELoss()

h_state = None   # 要使用初始 hidden state, 可以设成 None

for step in range(100):
start, end = step * np.pi, (step+1)*np.pi   # time steps
# sin 预测 cos
steps = np.linspace(start, end, 10, dtype=np.float32)
x_np = np.sin(steps)    # float32 for converting torch FloatTensor
y_np = np.cos(steps)

x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])    # shape (batch, time_step, input_size)
y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

prediction, h_state = rnn(x, h_state)   # rnn 对于每个 step 的 prediction, 还有最后一个 step 的 h_state
# !!  下一步十分重要 !!
h_state = h_state.data  # 要把 h_state 重新包装一下才能放入下一个 iteration, 不然会报错

loss = loss_func(prediction, y)     # cross entropy loss
optimizer.step()                    # apply gradients

5.完整代码演示

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step
INPUT_SIZE = 1      # rnn input size
LR = 0.02           # learning rate

# show data
steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)
plt.plot(steps, y_np, 'r-', label='target (cos)')
plt.plot(steps, x_np, 'b-', label='input (sin)')
plt.legend(loc='best')
plt.show()

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

self.rnn = nn.RNN(
input_size=INPUT_SIZE,
hidden_size=32,     # rnn hidden unit
num_layers=1,       # number of rnn layer
batch_first=True,   # input & output will has batch size as 1s dimension. e.g. (batch, time_step, input_size)
)
self.out = nn.Linear(32, 1)

def forward(self, x, h_state):
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, hidden_size)
r_out, h_state = self.rnn(x, h_state)

outs = []    # save all predictions
for time_step in range(r_out.size(1)):    # calculate output for each time step
outs.append(self.out(r_out[:, time_step, :]))

# instead, for simplicity, you can replace above codes by follows
# r_out = r_out.view(-1, 32)
# outs = self.out(r_out)
# outs = outs.view(-1, TIME_STEP, 1)
# return outs, h_state

# or even simpler, since nn.Linear can accept inputs of any dimension
# and returns outputs with same dimension except for the last
# outs = self.out(r_out)
# return outs

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all cnn parameters
loss_func = nn.MSELoss()

h_state = None      # for initial hidden state

plt.figure(1, figsize=(12, 5))
plt.ion()           # continuously plot

for step in range(100):
start, end = step * np.pi, (step+1)*np.pi   # time range
# use sin predicts cos
steps = np.linspace(start, end, TIME_STEP, dtype=np.float32, endpoint=False)  # float32 for converting torch FloatTensor
x_np = np.sin(steps)
y_np = np.cos(steps)

x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])    # shape (batch, time_step, input_size)
y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])

prediction, h_state = rnn(x, h_state)   # rnn output
# !! next step is important !!
h_state = h_state.data        # repack the hidden state, break the connection from last iteration

loss = loss_func(prediction, y)         # calculate loss

# plotting
plt.plot(steps, y_np.flatten(), 'r-')
plt.plot(steps, prediction.data.numpy().flatten(), 'b-')
plt.draw(); plt.pause(0.05)

plt.ioff()
plt.show()


展开全文
• 循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果. 如果你对循环神经网络还没有特别了解, 请观看几分钟的短动画, RNN 动画简介 和 LSTM 动画简介 能让你生...
学习资料:

本节的全部代码
Tensorflow 的 50行 RNN 代码
我制作的 循环神经网络 RNN 动画简介
我制作的 循环神经网络 LSTM 动画简介
PyTorch 官网
要点

循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果. 如果你对循环神经网络还没有特别了解, 请观看几分钟的短动画, RNN 动画简介 和 LSTM 动画简介 能让你生动理解 RNN. 上次我们提到了用 RNN 的最后一个时间点输出来判断之前看到的图片属于哪一类, 这次我们来真的了, 用 RNN 来及时预测时间序列.

训练数据

我们要用到的数据就是这样的一些数据, 我们想要用 sin 的曲线预测出 cos 的曲线.

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt

torch.manual_seed(1)    # reproducible

# Hyper Parameters
TIME_STEP = 10      # rnn time step / image height
INPUT_SIZE = 1      # rnn input size / image width
LR = 0.02           # learning rate


RNN模型

这一次的 RNN, 我们对每一个 r_out 都得放到 Linear 中去计算出预测的 output, 所以我们能用一个 for loop 来循环计算. 这点是 Tensorflow 望尘莫及的! 除了这点, 还有一些动态的过程都可以在这个教程中查看, 看看我们的 PyTorch 和 Tensorflow 到底哪家强.

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

self.rnn = nn.RNN(  # 这回一个普通的 RNN 就能胜任
input_size=1,
hidden_size=32,     # 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(32, 1)

def forward(self, x, h_state):  # 因为 hidden state 是连续的, 所以我们要一直传递这一个 state
# x (batch, time_step, input_size)
# h_state (n_layers, batch, hidden_size)
# r_out (batch, time_step, output_size)
r_out, h_state = self.rnn(x, h_state)   # h_state 也要作为 RNN 的一个输入

outs = []    # 保存所有时间点的预测值
for time_step in range(r_out.size(1)):    # 对每一个时间点计算 output
outs.append(self.out(r_out[:, time_step, :]))

rnn = RNN()
print(rnn)
"""
RNN (
(rnn): RNN(1, 32, batch_first=True)
(out): Linear (32 -> 1)
)
"""


其实熟悉 RNN 的朋友应该知道, forward 过程中的对每个时间点求输出还有一招使得计算量比较小的. 不过上面的内容主要是为了呈现 PyTorch 在动态构图上的优势, 所以我用了一个 for loop 来搭建那套输出系统. 下面介绍一个替换方式. 使用 reshape 的方式整批计算.

def forward(self, x, h_state):
r_out, h_state = self.rnn(x, h_state)
r_out = r_out.view(-1, 32)
outs = self.out(r_out)
return outs.view(-1, 32, TIME_STEP), h_state


训练

下面的代码就能实现动图的效果啦~开心, 可以看出, 我们使用 x 作为输入的 sin 值, 然后 y作为想要拟合的输出, cos 值. 因为他们两条曲线是存在某种关系的, 所以我们就能用 sin 来预测 cos. rnn 会理解他们的关系, 并用里面的参数分析出来这个时刻 sin 曲线上的点如何对应上 cos 曲线上的点.

optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)   # optimize all rnn parameters
loss_func = nn.MSELoss()

h_state = None   # 要使用初始 hidden state, 可以设成 None

for step in range(100):
start, end = step * np.pi, (step+1)*np.pi   # time steps
# sin 预测 cos
steps = np.linspace(start, end, 10, dtype=np.float32)
x_np = np.sin(steps)    # float32 for converting torch FloatTensor
y_np = np.cos(steps)

x = Variable(torch.from_numpy(x_np[np.newaxis, :, np.newaxis]))    # shape (batch, time_step, input_size)
y = Variable(torch.from_numpy(y_np[np.newaxis, :, np.newaxis]))

prediction, h_state = rnn(x, h_state)   # rnn 对于每个 step 的 prediction, 还有最后一个 step 的 h_state
# !!  下一步十分重要 !!
h_state = h_state.data  # 要把 h_state 重新包装一下才能放入下一个 iteration, 不然会报错

loss = loss_func(prediction, y)     # cross entropy loss


所以这也就是在我 github 代码 中的每一步的意义啦.


展开全文
• 重要：网络中的初始状态赋值为零，在下一次的时候一定要将上一次生成的隐层状态包装为variable """ import torch from torch import nn from torch.autograd import Variable import numpy as np import ...
• 这个系列记录下自己的深度学习练习，本文主要尝试了使用循环神经网络（RNN，GRU）解决回归类预测问题，因为规模较小且并未详细调整参数，实际效果提升并不是很明显。请读者理解循环层的用法就好，本人也是在不断摸索...
• Pytorch教程目录 ...RNN 循环神经网络 (回归) 目录Pytorch教程目录训练数据RNN模型训练全部代码 训练数据 我们要用到的数据就是这样的一些数据, 我们想要用 sin 的曲线预测出 cos 的曲线. import torch from
• Pytorch笔记：RNN 循环神经网络 (回归) import torch from torch import nn import numpy as np import matplotlib.pyplot as plt # torch.manual_seed(1) # reproducible # Hyper Parameters TIME_STEP = 10 # ...
• 用Keras搭建RNN回归循环神经网络2.1.导入必要模块2.2.超参数设置2.3.构造数据2.4.搭建模型2.5.激活模型2.6.训练+测试 1.前言 这次我们用循环神经网络(RNN, Recurrent Neural Networks)进行回归（Regression），主要...
• 一、RNN ...对循环神经网络的研究始于二十世纪80-90年代，并在二十一世纪初发展为深度学习（deep learning）算法之一 [2] ，其中双向循环神经网络（Bidirectional RNN, Bi-RNN）和长短期记忆网络
• RNN回归可以用来及时预测时间序列 训练数据 我们要用sin的曲线预测出cos的曲线。 import torch from torch import nn import numpy as np import matplotlib.pyplot as plt torch.manual_seed(1) TIME...
• @(Aaron)[机器学习 | 循环神经网络] 主要内容包括： 基于循环神经网络的语言模型，提供了从零开始的实现与简洁实现 代码实践 文章目录循环神经网络的构造裁剪梯度代码实践 循环神经网络的构造   循环神经网络...
• 实验结果： 这次用RNN_LSTM实现回归任务 ...可参考pytorch搭建CNN卷积神经网络详解 ???? 搭建RNN（该任务使用RNN足矣） class RNN(nn.Module): def __init__(self): super(RNN, self)._...
• #使用RNN进行回归训练，会用到自己创建对sin曲线，预测一条cos曲线， #【1】设置RNN各种参数 #import state as state import tensorflow as tf import numpy as np import matplotlib.pyplot as plt ...
• 参考伯禹学习平台《动手学...1、线性回归 模型 假设价格只取决于房屋状况的两个因素，即面积（平方米）和房龄（年）。线性回归假设输出与各个输入之间是线性关系: 数据集 在机器学习术语里，数据集被称为训练数据...
• “微信公众号” 一、回归预测要实现的问题 这次我们会使用RNN来进行回归（Regression）的训练，使用自己创建的sin曲线预测一条cos曲线。...经过RNN的回归训练，我们的网络预测结果和真实结果的一个比对图...
• 从本专栏开始，作者正式开始研究Python深度...本篇文章将分享循环神经网络LSTM RNN如何实现回归预测，通过sin曲线拟合实现如下图所示效果。本文代码量比较长，但大家还是可以学习下的。基础性文章，希望对您有所帮助！
• 循环神经网络LSTM RNN回归案例之sin曲线预测从本专栏开始，正式开始研究Python深度学习、神经网络及人工智能相关知识。前一篇文章详细讲解了如何评价神经网络，绘制训练过程中的loss曲线，并结合图像分类案例讲解...
• 给网络增加记忆能力1.1 延时神经网络1.2 有外部输入的非线性自回归模型1.3 循环神经网络2. 简单循环网络2.1 循环神经网络的计算能力2.1.1 循环神经网络的通用近似定理2.1.2 图灵完备3. 应用到机器学习3.1 序列到...

...