精华内容
下载资源
问答
  • 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, :]))
            return torch.stack(outs, dim=1), h_state
    
            # 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()
    

    注:

    1. adam():我们常使用该函数,因为其在各种情况下均有较好的表现
    2. 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
        optimizer.zero_grad()                   # clear gradients for this training step
        loss.backward()                         # backpropagation, compute gradients
        optimizer.step()                        # apply gradients
    
        # 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()
    展开全文
  • """ 用sin曲线预测cos曲线 重要:网络中的初始状态赋值为零,在下一次的时候一定要将上一次生成的隐层状态包装为variable """ import torch from torch import nn ...from torch.autograd import Variable ...
    """
    用sin曲线预测cos曲线
    重要:网络中的初始状态赋值为零,在下一次的时候一定要将上一次生成的隐层状态包装为variable
    """
    import torch
    from torch import nn
    from torch.autograd import Variable
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 超参数
    TIME_STEP = 10 
    INPUT_SIZE = 1
    LR = 0.02
    
    # 画图
    steps = np.linspace(0, np.pi*2, 100, dtype=np.float32)
    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,
                num_layers=1,
                batch_first=True,
            )
            self.out = nn.Linear(32, 1) # 此时的32对应上面hidden_size大小
    
        def forward(self, x, h_state): # 其中x代表batch个图片
            # 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) # 其中r_out对应每一步的输出
                                                  # h_state代表最后一步的h_state
    
            outs = []    # 保存每一步的预测结果
            for time_step in range(r_out.size(1)):    # 计算出每一步的预测结果用于保存
                outs.append(self.out(r_out[:, time_step, :]))
            return torch.stack(outs, dim=1), h_state # torch.stack()将列表转换为tensor的形式
                                                     # 返回h_state是为了用于训练下一个batch个图片
    
    rnn = RNN()
    print(rnn) # 打印出网络结构
    
    optimizer = torch.optim.Adam(rnn.parameters(), lr=LR)
    loss_func = nn.MSELoss()
    
    h_state = None      # 将隐层状态初始状态赋值为0
    
    plt.figure(1, figsize=(12, 5))
    plt.ion()           # 设置为实时打印
    
    for step in range(60):
        start, end = step * np.pi, (step+1)*np.pi   # time range
    
        steps = np.linspace(start, end, TIME_STEP, dtype=np.float32)
        x_np = np.sin(steps)
        y_np = np.cos(steps)
    
        # 以下操作为:先增加第一维和第三维,在转化为tensor形式,最后转化为Variable形式
        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)
    
        h_state = Variable(h_state.data)        # 将下一次的h_state重新包装为Variable
    
        loss = loss_func(prediction, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
        # 画图
        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()

     

    转载于:https://www.cnblogs.com/czz0508/p/10345760.html

    展开全文
  • RNN 循环神经网络 (回归)

    千次阅读 2019-02-18 15:24:23
    循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果. 如果你对循环神经网络还没有特别了解, 请观看几分钟的短动画, RNN 动画简介 和 LSTM 动画简介 能让你生...

    学习资料:

    要点 

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

    RNN 循环神经网络 (回归)

    训练数据 

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

    RNN 循环神经网络 (回归)

    import torch
    from torch import nn
    import numpy as np
    import matplotlib.pyplot as plt
    from torch.autograd import Variable
    
    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
    

    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, :]))
            return torch.stack(outs, dim=1), h_state
    
    
    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 来预测 cosrnn 会理解他们的关系, 并用里面的参数分析出来这个时刻 sin 曲线上的点如何对应上 cos 曲线上的点.

    RNN 循环神经网络 (回归)

    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
        optimizer.zero_grad()               # clear gradients for this training step
        loss.backward()                     # backpropagation, compute gradients
        optimizer.step()                    # apply gradients
    

    RNN 循环神经网络 (回归)

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

     

    展开全文
  • 1.1 回归: Investpedia: Regression refers to the relation between selected values of x and observed values of y (from which the most probable value of y can be predicted for any value of x). ...

    1 RNN的统计学基础

    1.1 回归:

    Investpedia:
    Regression refers to the relation between selected values of x and observed values of y (from which the most probable value of y can be predicted for any value of x). The general form of each type of regression is:

    • Simple linear regression: Y=a+bX+uY = a + bX + u
    • Multiple linear regression: Y=a+b1X1+b2X2+b3X3+...+btXt+uY = a + b_1X_1 + b_2X_2 + b_3X_3 + ... + b_tX_t + u
      Where:
      YY = the variable that you are trying to predict (dependent variable,因变量).
      XX = the variable that you are using to predict Y (independent variable,自变量).
      aa = the intercept(截距).
      bb = the slope(斜率).
      uu = the regression residual(回归残差).

    1.2 自回归(Auto-Regression, AR模型)

    自回归,即AR模型,属于时间序列分析的范畴,即用一个变量yty_t的历史信息来预测自己,tutorialspoint给出的定义:

    • For a stationary time series, an auto regression models sees the value of a variable at time ‘t’ as a linear function of values ‘p’ time steps preceding it. Mathematically it can be written as:
      yt=C+ϕ1yt1+ϕ2yt2+...+ϕpytp+ϵty_t=C+ϕ_1y_{t−1}+ϕ_2y_{t−2}+...+ϕ_py_{t−p}+ϵ_t
      Where,‘p’ is the auto-regressive trend parameter
      ϵtϵ_t is white noise, and yt1,yt2...ytpy_{t−1},y_{t−2}...y_{t−p} denote the value of variable at previous time periods.

    1.3 有外部输入的非线性自回归模型(Nonlinear AutoRegressive with Exogenous Inputs Model,NARX)

    NARX是自回归模型的扩展,在每个时刻tt都有一个外部输入xtx_t,产生一个输出yty_t,NARX通过一个延时器记录最近KxK_x次的外部输入和最近KyK_y次的输出,第tt个时刻的输出yty_t为:
    yt=f(xt,xt1,...,xtKx,yt1,yt2,...,ytKy)y_t=f(x_t,x_{t-1},...,x_{t-K_x},y_{t-1},y_{t-2},...,y_{t-K_y})
    其中f()f()表示非线性函数,可以是一个前馈网络,KxK_xKyK_y为超参数。

    2 简单循环神经网络

    2.1 循环神经网络的通用近似定理

    如果一个完全连接的循环神经网络有足够数量的 sigmoid 型隐藏神经元,它可以以任意的准确率去近似任何一个非线性动力系统:


    st=g(st1,xt)s_t = g(s_{t-1}, x_{t})
    yt=o(st)y_t = o(s_t)

    2.2 学习模式

    2.3 参数学习

    2.4 梯度爆炸、梯度消失与长程依赖问题

    2.5 门控机制、LSTM及其变体

    2.6 深层循环神经网络

    2.6.1 堆叠循环神经网络

    在这里插入图片描述
    图 按时间展开的堆叠循环神经网络

    2.6.2 双向循环神经网络

    在有些任务中,一个时刻的输出不但和过去时刻的信息有关,也和后续时刻
    的信息有关.比如给定一个句子,其中一个词的词性由它的上下文决定,即包含左右两边的信息.因此,在这些任务中,我们可以增加一个按照时间的逆序来传递信息的网络层,来增强网络的能力.
    双向循环神经网络(Bidirectional Recurrent Neural Network,Bi-RNN)由
    两层循环神经网络组成,它们的输入相同,只是信息传递的方向不同.按时间展开的双向循环神经网络
    图 按时间展开的双向循环神经网络

    展开全文
  • 用Keras搭建RNN回归循环神经网络2.1.导入必要模块2.2.超参数设置2.3.构造数据2.4.搭建模型2.5.激活模型2.6.训练+测试 1.前言 这次我们用循环神经网络(RNN, Recurrent Neural Networks)进行回归(Regression),主要...
  • 参考伯禹学习平台《动手学...1、线性回归 模型 假设价格只取决于房屋状况的两个因素,即面积(平方米)和房龄(年)。线性回归假设输出与各个输入之间是线性关系: 数据集 在机器学习术语里,数据集被称为训练数据...
  • bpnreg的目标是为循环数据拟合贝叶斯投影法线回归模型。 安装 可以从CRAN安装R软件包bpnreg,如下所示: install.packages( " bpnreg " ) 您可以使用以下命令从github安装bpnreg的beta版本: # install.packages...
  • 这次我们会使用RNN来进行回归(Regression)的训练,使用自己创建的sin曲线预测一条cos曲线。如下图所示,我们用蓝色的sin曲线预测红色的cos曲线。 二、回归预测要实现的效果 经过RNN的回归训练,我们的网络预测...
  • 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 # ...
  • 循环神经网络让神经网络有了记忆, 对于序列话的数据,循环神经网络能达到更好的效果.上次我们提到了用 RNN 的最后一个时间点输出来判断之前看到的图片属于哪一类, 这次我们来真的了, 用 RNN 来及时预测时间序列. ...
  • Pytorch教程目录 ...RNN 循环神经网络 (回归) 目录Pytorch教程目录训练数据RNN模型训练全部代码 训练数据 我们要用到的数据就是这样的一些数据, 我们想要用 sin 的曲线预测出 cos 的曲线. import torch from
  • 为了总结现代比较流行的方法是什么,在这篇文章中我们将对视频回归任务的深度学习方法进行一些研究。 处理视频意味着处理图像,所以这里需要cnn。但是,有不同的方法来处理时态组件。我试着概括出主要的几点: 现有...
  • RNN回归可以用来及时预测时间序列 训练数据 我们要用sin的曲线预测出cos的曲线。 import torch from torch import nn import numpy as np import matplotlib.pyplot as plt torch.manual_seed(1) TIME...
  • 循环神经网络(Recurrent Neural Network, RNN)是一类以序列(sequence)数据为输入,在序列的演进方向进行递归(recursion)且所有节点(循环单元)按链式连接的递归神经网络(recursive neural network) 对循环...
  • 本文主要介绍使用RNN来实现回归,对曲线进行预测。 示例代码: import numpy as np from keras.datasets import mnist from keras.utils import np_utils from keras.models import Sequential from keras.layers...
  • 这项工作的目的是在前馈人工神经网络(ANN)上应用和试验各种选择效果,该神经网络用于获得基于4个输入来预测联合循环电厂的电力输出功率(EP)的回归模型。 数据集是从开放的在线资源获得的。 这项工作显示并解释...
  • RNN_lstm 循环神经网络 - 回归任务

    千次阅读 2018-04-30 19:02:35
    #使用RNN进行回归训练,会用到自己创建对sin曲线,预测一条cos曲线, #【1】设置RNN各种参数 #import state as state import tensorflow as tf import numpy as np import matplotlib.pyplot as plt ...
  • 我没有尝试使用申请,但有些人告诉我,for循环是最好的(如果有人相信,请随意解释!)我认为这个问题非常普遍,而且不太深奥 . 论坛 .这就是我想要实现的目标:我有一个数据集,其中包含3个预测变量(性别,年龄,...
  • 这个系列记录下自己的深度学习练习,本文主要尝试了使用循环神经网络(RNN,GRU)解决回归类预测问题,因为规模较小且并未详细调整参数,实际效果提升并不是很明显。请读者理解循环层的用法就好,本人也是在不断摸索...
  • @(Aaron)[机器学习 | 循环神经网络] 主要内容包括: 基于循环神经网络的语言模型,提供了从零开始的实现与简洁实现 代码实践 文章目录循环神经网络的构造裁剪梯度代码实践 循环神经网络的构造   循环神经网络...
  • 这次用RNN_LSTM实现回归任务 代码中使用sin函数 拟合 cos函数 这里主要讲解搭建RNN部分,其他部分和前文中CNN搭建类似。 可参考pytorch搭建CNN卷积神经网络详解 ???? 搭建RNN(该任务使用RNN足矣) class RNN...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 890
精华内容 356
关键字:

循环回归