精华内容
下载资源
问答
  • LSTM时间序列预测

    2021-05-23 09:19:36
    LSTM时间序列预测(单维,多步预测一步) 文章目录LSTM时间序列预测(单维,多步预测一步)前言使用步骤1.引入库2.设置一下,画图时可以显示汉字3.设置监督学习格式3.读取数据4.缩放数据:归一化5.划分训练集和测试...

    LSTM时间序列预测(单维,多步预测一步)

    前言

    正在自学LSTM,记录一下学习过程,顺便请大佬们指点一二。
    本文代码是来自于github:https://github.com/yangwohenmai/LSTM,数据集是自己的,不过都差不多。

    使用步骤

    1.引入库

    import numpy
    import matplotlib.pyplot as plt
    from pandas import read_csv
    import math
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import LSTM
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.metrics import mean_squared_error
    import pandas as pd
    

    2.设置一下,画图时可以显示汉字

    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    

    3.设置监督学习格式

    意思就是1-100个数据去预测101个,2-101个数据去预测102个,以此类推。

    我也试过200个一组,不太明白这个数据是否是自己根据预测效果定义。

    # 将数据截取成100个一组的监督学习格式
    def create_dataset(dataset, look_back):
        dataX, dataY = [], []
        for i in range(len(dataset) - look_back - 1):   # 可以建多少个监督学习组
            a = dataset[i:(i + look_back),0]
            dataX.append(a)
            dataY.append(dataset[i + look_back,0])   # 第101个数据
        return numpy.array(dataX),numpy.array(dataY)
    

    3.读取数据

    # 定义随机种子,以便重现结果
    numpy.random.seed(7)
    # 加载数据
    dataframe = pd.read_csv(r'D:\PycharmProjects\ LSTM\hello3.csv', header=0, usecols=[1])
    dataset = dataframe.values
    dataset = dataset.astype('float32')
    print(dataframe.head())
    print('======>')
    
    

    4.缩放数据:归一化

    # 缩放数据
    scaler = MinMaxScaler(feature_range=(0, 1))
    dataset = scaler.fit_transform(dataset)
    

    5.划分训练集和测试集

    # # 分割2/3数据作为测试
    train_size = int(len(dataset) * 0.67)
    test_size = len(dataset) - train_size
    train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]
    

    6.把训练集和测试集的数据放到前面定义的监督学习函数里

    # 预测数据步长为100,100预测一个
    look_back = 100
    trainX, trainY = create_dataset(train, look_back)
    testX, testY = create_dataset(test, look_back)
    print(trainX.shape)
    # # 重构输入数据格式 [samples, time steps, features]
    trainX = numpy.reshape(trainX,(trainX.shape[0],trainX.shape[1], 1))
    testX = numpy.reshape(testX,(testX.shape[0],trainX.shape[1],1))
    print(trainX.shape)
    

    7.构建LSTM

    # # 构建 LSTM 网络
    model = Sequential() 
    model.add(LSTM(4, input_shape=(look_back,1)))
    model.add(Dense(1)) #全连接
    model.compile(loss='mean_squared_error', optimizer='adam')
    model.fit(trainX, trainY, epochs=20, batch_size=1, verbose=2)   # 训练20次,一个样本一次梯度下降一下 
    

    8.预测

    # # 对训练数据的Y进行预测
    trainPredict = model.predict(trainX)
    # # 对测试数据的Y进行预测
    testPredict = model.predict(testX)
    

    9.逆缩放

    
    # # # 对数据进行逆缩放
    trainPredict = scaler.inverse_transform(trainPredict)
    trainY = scaler.inverse_transform([trainY])
    testPredict = scaler.inverse_transform(testPredict)
    testY = scaler.inverse_transform([testY])
    
    

    10.计算均方根误差RMSE

    # # # 计算RMSE误差
    trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:, 0]))
    print('Train Score: %.2f RMSE' % (trainScore))
    testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:, 0]))
    print('Test Score: %.2f RMSE' % (testScore))
    

    11.构造一个与原来一样的数据集,将预测的数据放进去

    我理解的是这样是为了便于在图中展示

    # # # 构造一个和dataset格式相同的数组,dataset为总数据集,把预测的训练数据存进去
    trainPredictPlot = numpy.empty_like(dataset)
    # # 用nan填充数组
    trainPredictPlot[:] = numpy.nan
    trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict
    
    # # 构造一个和dataset格式相同的数组
    testPredictPlot = numpy.empty_like(dataset)
    testPredictPlot[:] =numpy.nan
    testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict
    
    

    12.最后画图

    # # 画图
    plt.plot(scaler.inverse_transform(dataset),color = 'g')
    plt.plot(trainPredictPlot,color = 'r')
    plt.plot(testPredictPlot,color = 'b')
    plt.show()
    

    在这里插入图片描述

    总结

    没有什么改进,完全照搬github代码,但是做了好久因为老报错,对于python新手真的是太难了。

    疑惑点:

    看了很多大佬写的文章,说这是一种拟合趋势,不是真正的预测,我也赞同。
    假设我只有1000个数据,想要预测1001.1002…这样应该怎么做?
    思路是,按照原来100预测一个,900-1000 预测1001不就可以了吗?
    这样的话,没有真实值做对比了,自己写还是很难的,希望有做类似的,可以分享一下代码。

    小朋友在此谢谢大佬们指点了。

    展开全文
  • LSTM(Long Short Term Memory Network)长短时记忆网络,一种改进之后的循环神经网络,可以解决 RNN 无法处理长距离的依赖的问题,在时间序列预测问题上面也有广泛的应用。 今天我们根据问题的输入输出模式划分,...

    LSTM(Long Short Term Memory Network)长短时记忆网络,是一种改进之后的循环神经网络,可以解决 RNN 无法处理长距离的依赖的问题,在时间序列预测问题上面也有广泛的应用。

    今天我们根据问题的输入输出模式划分,来看一下几种时间序列问题所对应的 LSTM 模型结构如何实现。


    1. Univariate

    Univariate 是指:

    input 为多个时间步,
    output 为一个时间的问题。

    数例:

    训练集:
    X,			y
    10, 20, 30		40
    20, 30, 40		50
    30, 40, 50		60
    …
    
    
    预测输入:
    X,
    70, 80, 90
    

    模型的 Keras 代码:

    # define model【Vanilla LSTM】
    
    model = Sequential()
    model.add( LSTM(50,  activation='relu',  input_shape = (n_steps, n_features)) )
    model.add( Dense(1) )
    model.compile(optimizer='adam', loss='mse')
    
    n_steps = 3
    n_features = 1
    

    其中:

    n_steps 为输入的 X 每次考虑几个时间步
    n_features 为每个时间步的序列数

    这个是最基本的模型结构,我们后面几种模型会和这个进行比较。


    2. Multiple Input

    Multiple Input 是指:

    input 为多个序列,
    output 为一个序列的问题。

    数例:

    训练集:
    X,       y
    [[10 15]
     [20 25]
     [30 35]] 65
    [[20 25]
     [30 35]
     [40 45]] 85
    [[30 35]
     [40 45]
     [50 55]] 105
    [[40 45]
     [50 55]
     [60 65]] 125
    …
    
    
    预测输入:
    X,
    80,	 85
    90,	 95
    100,     105
    

    即数据样式为:

    in_seq1: [10, 20, 30, 40, 50, 60, 70, 80, 90]
    in_seq2: [15, 25, 35, 45, 55, 65, 75, 85, 95]
    
    out_seq: [in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))]
    

    模型的 Keras 代码:

    # define model【Vanilla LSTM】
    model = Sequential()
    model.add(LSTM(50, activation='relu', input_shape=(n_steps, n_features)))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    
    n_steps = 3
    # 此例中 n features = 2,因为输入有两个并行序列
    n_features = X.shape[2]    
    

    其中:

    n_steps 为输入的 X 每次考虑几个时间步
    n_features 此例中 = 2,因为输入有两个并行序列

    和 Univariate 相比:

    模型的结构代码是一样的,只是在 n_features = X.shape[2],而不是 1.


    3. Multiple Parallel

    Multiple Parallel 是指:

    input 为多个序列,
    output 也是多个序列的问题。

    数例:

    训练集:
    X,			y
    [[10 15 25]
     [20 25 45]
     [30 35 65]] [40 45 85]
    [[20 25 45]
     [30 35 65]
     [40 45 85]] [ 50  55 105]
    [[ 30  35  65]
     [ 40  45  85]
     [ 50  55 105]] [ 60  65 125]
    [[ 40  45  85]
     [ 50  55 105]
     [ 60  65 125]] [ 70  75 145]
    …
    
    
    预测输入:
    X,
    70, 75, 145
    80, 85, 165
    90, 95, 185
    

    模型的 Keras 代码:

    # define model【Vanilla LSTM】
    model = Sequential()
    model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(n_steps, n_features)))
    model.add(Dense(n_features))
    model.compile(optimizer='adam', loss='mse')
    
    n_steps = 3
    # 此例中 n features = 3,因为输入有3个并行序列
    n_features = X.shape[2]       
    

    其中:

    n_steps 为输入的 X 每次考虑几个时间步
    n_features 此例中 = 3,因为输入有 3 个并行序列

    和 Univariate 相比:

    模型结构的定义中,多了一个 return_sequences=True,即返回的是序列,
    输出为 Dense(n_features),而不是 1.


    4. Multi-Step

    Multi-Step 是指:

    input 为多个时间步,
    output 也是多个时间步的问题。

    数例:

    训练集:
    X,			y
    [10 20 30] [40 50]
    [20 30 40] [50 60]
    [30 40 50] [60 70]
    [40 50 60] [70 80]
    …
    
    
    预测输入:
    X,
    [70, 80, 90]
    

    模型的 Keras 代码:

    # define model【Vanilla LSTM】
    model = Sequential()
    model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(n_steps_in, n_features)))
    model.add(LSTM(100, activation='relu'))
    model.add(Dense(n_steps_out))
    model.compile(optimizer='adam', loss='mse')
    
    n_steps_in, n_steps_out = 3, 2
    n_features = 1     
    

    其中:

    n_steps_in 为输入的 X 每次考虑几个时间步
    n_steps_out 为输出的 y 每次考虑几个时间步
    n_features 为输入有几个序列

    和 Univariate 相比:

    模型结构的定义中,多了一个 return_sequences=True,即返回的是序列,
    而且 input_shape=(n_steps_in, n_features) 中有代表输入时间步数的 n_steps_in
    输出为 Dense(n_steps_out),代表输出的 y 每次考虑几个时间步.

    当然这个问题还可以用 Encoder-Decoder 结构实现:

    # define model【Encoder-Decoder Model】
    model = Sequential()
    model.add(LSTM(100, activation='relu', input_shape=(n_steps_in, n_features)))
    model.add(RepeatVector(n_steps_out))
    model.add(LSTM(100, activation='relu', return_sequences=True))
    model.add(TimeDistributed(Dense(1)))
    model.compile(optimizer='adam', loss='mse')
    

    5. Multivariate Multi-Step

    Multivariate Multi-Step 是指:

    input 为多个序列,
    output 为多个时间步的问题。

    数例:

    训练集:
    X,			y
    [[10 15]
     [20 25]
     [30 35]] [65 
    	      85]
    [[20 25]
     [30 35]
     [40 45]] [ 85
    	       105]
    [[30 35]
     [40 45]
     [50 55]] [105 
             125]
    …
    
    
    预测输入:
    X,
    [40 45]
     [50 55]
     [60 65]
    

    模型的 Keras 代码:

    # define model
    model = Sequential()
    model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(n_steps_in, n_features)))
    model.add(LSTM(100, activation='relu'))
    model.add(Dense(n_steps_out))
    model.compile(optimizer='adam', loss='mse')
    
    n_steps_in, n_steps_out = 3, 2
    # 此例中 n features = 2,因为输入有2个并行序列  
    n_features = X.shape[2]        
    

    其中:

    n_steps_in 为输入的 X 每次考虑几个时间步
    n_steps_out 为输出的 y 每次考虑几个时间步
    n_features 为输入有几个序列,此例中 = 2,因为输入有 2 个并行序列

    和 Univariate 相比:

    模型结构的定义中,多了一个 return_sequences=True,即返回的是序列,
    而且 input_shape=(n_steps_in, n_features) 中有代表输入时间步数的 n_steps_in
    输出为 Dense(n_steps_out),代表输出的 y 每次考虑几个时间步,
    另外 n_features = X.shape[2],而不是 1,
    相当于是 Multivariate 和 Multi-Step 的结构组合起来。


    6. Multiple Parallel Input & Multi-Step Output

    Multiple Parallel Input & Multi-Step Output 是指:

    input 为多个序列,
    output 也是多个序列 & 多个时间步的问题。

    数例:

    训练集:
    X,			y
    [[10 15 25]
     [20 25 45]
     [30 35 65]] [[ 40  45  85]
     	      [ 50  55 105]]
    [[20 25 45]
     [30 35 65]
     [40 45 85]] [[ 50  55 105]
     	      [ 60  65 125]]
    [[ 30  35  65]
     [ 40  45  85]
     [ 50  55 105]] [[ 60  65 125]
     	         [ 70  75 145]]
    …
    
    
    预测输入:
    X,
    [[ 40  45  85]
     [ 50  55 105]
     [ 60  65 125]]
    

    模型的 Keras 代码:

    # define model【Encoder-Decoder model】
    model = Sequential()
    model.add(LSTM(200, activation='relu', input_shape=(n_steps_in, n_features)))
    model.add(RepeatVector(n_steps_out))
    model.add(LSTM(200, activation='relu', return_sequences=True))
    model.add(TimeDistributed(Dense(n_features)))
    model.compile(optimizer='adam', loss='mse')
    
    n_steps_in, n_steps_out = 3, 2
    # 此例中 n features = 3,因为输入有3个并行序列   
    n_features = X.shape[2]       
    

    其中:

    n_steps_in 为输入的 X 每次考虑几个时间步
    n_steps_out 为输出的 y 每次考虑几个时间步
    n_features 为输入有几个序列

    这里我们和 Multi-Step 的 Encoder-Decoder 相比:

    二者的模型结构,只是在最后的输出层参数不同,
    TimeDistributed(Dense(n_features)) 而不是 Dense(1)


    好啦,这几种时间序列的输入输出模式所对应的代码结构就是这样,如果您还有更有趣的,欢迎补充!


    大家好!
    我是 不会停的蜗牛 Alice,
    喜欢人工智能,没事儿写写机器学习干货,
    欢迎关注我!


    推荐阅读
    历史技术博文链接汇总
    也许可以找到你想要的:
    [入门问题][TensorFlow][深度学习][强化学习][神经网络][机器学习][自然语言处理][聊天机器人]

    展开全文
  • 一般有两种情况,分别对缺失值进行替换和学习,忽略对缺失值的学习 同时文章演示了对于缺失值得补全方法。 文末附带两个LSTM代码,比较了两种对缺失值不同处理方式的网络模型优劣 源码地址: ...

    导读:

    本文讨论分析了输入数据中,有数据缺失的情况如何处理
    一般有两种情况,分别是对缺失值进行替换和学习,忽略对缺失值的学习
    同时文章演示了对于缺失值得补全方法。
    文末附带两个LSTM代码,比较了两种对缺失值不同处理方式的网络模型优劣

    源码地址:

    https://github.com/yangwohenmai/LSTM/tree/master/%E9%95%BF%E7%9F%AD%E6%9C%9F%E8%AE%B0%E5%BF%86(LSTM)/LSTM%E7%9A%84%E6%95%B0%E6%8D%AE%E5%87%86%E5%A4%87/%E5%A4%84%E7%90%86%E5%BA%8F%E5%88%97%E9%A2%84%E6%B5%8B%E4%B8%AD%E7%9A%84%E7%BC%BA%E5%A4%B1%E6%97%B6%E9%97%B4%E6%AD%A5%E9%95%BF

    正文:

    如果序列数据中缺少观察结果。

    数据可能已丢失或不可用,但根据定义,你的数据也可能具有可变长度序列。具有较少时间步长的那些序列,可被认为是具有缺失值。

    在本教程中,您将了解如何使用Keras深度学习库处理Python中序列预测问题缺失值的数据。

    监督学习数据类型框架

    在使用神经网络时,序列必须被设置为监督学习问题。

    这意味着序列需要分为输入和输出对。

    该问题可以被构造为基于当前和先前时间步的函数进行预测。

    或者更正式地说:

    y(t) = f(x(t), x(t-1))

    其中y(t)是当前时间步长的期望输出,f()是我们寻求用神经网络逼近的函数,X(t)和X(t-1)是当前和之前的观测值时间步长。

    输出可以等于先前的观察值,例如,y(t)= X(t-1),但是它可以很容易地是y(t)= X(t)。我们针对这个问题进行训练的模型并不知道真正的表述,必须学习这种关系。

    这模拟了实际序列预测问题,其中我们将模型指定为一组固定的顺序时间步长的函数,但我们不知道从过去的观察到期望的输出值的实际函数关系。

    我们可以将这个回声问题的框架实现为python中的监督学习问题。

    的Pandas() 函数可以被用来创建可用于在时间步长之前以代表观测序列的移位版本。这可以与原始序列连接以提供X(t-1)和X(t)输入值。

    df = DataFrame(sequence)

    df = concat([df.shift(1), df], axis=1)

    然后我们可以将Pandas DataFrame中的值作为输入序列(X),并使用第一列作为输出序列(y)。

    # specify input and output data

    X, y = values, values[:, 0]

    综上所述,我们可以定义一个函数,它将时间步数作为参数,并返回序列学习的X,y数据,称为generate_data()。

    # generate data for the lstm
    def generate_data(n_timesteps):
    # generate sequence
    sequence = generate_sequence(n_timesteps)
    sequence = array(sequence)
    # create lag
    df = DataFrame(sequence)
    df = concat([df.shift(1), df], axis=1)
    values = df.values
    # specify input and output data
    X, y = values, values[:, 0]
    return X, y

     

    创建一个有监督数据序列

    我们可以将generate_sequence()和generate_data()代码绑定到一个工作示例中。

    下面列出了完整的示例。

    from random import random
    from numpy import array
    from pandas import concat
    from pandas import DataFrame
    
    # 生成一系列随机值
    def generate_sequence(n_timesteps):
    	return [random() for _ in range(n_timesteps)]
    
    # 生成lstm的数据
    def generate_data(n_timesteps):
        # 生成随机序列
        sequence = generate_sequence(n_timesteps)
        print(sequence)
        sequence = array(sequence)
        print(sequence)
        # 格式化成有序矩阵
        df = DataFrame(sequence)
        print(df)
        # 变成两两一组的有序数据矩阵,创建可用于在时间步长之前以代表观测序列的移位版
        df = concat([df.shift(1), df], axis=1)
        print(df)
        values = df.values
        print(values)
        # 指定输入和输出数据
        X, y = values, values[:, 0]
        print(y)
        return X, y
    
    # 生成序列
    n_timesteps = 10
    X, y = generate_data(n_timesteps)
    # 打印序列
    for i in range(n_timesteps):
        print(X[i], '=>', y[i])

    运行此示例会生成一个序列,将其转换为监督表示,并打印每个X,Y对。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    [0.9499452498907361, 0.9577216990829638, 0.8375281747300221, 0.3841115541079436, 0.5743029557433733, 0.10128265088053356, 0.6283099216390347, 0.17457841317845058, 0.7219971035263132, 0.6687711784414226]
    [0.94994525 0.9577217  0.83752817 0.38411155 0.57430296 0.10128265
     0.62830992 0.17457841 0.7219971  0.66877118]
              0
    0  0.949945
    1  0.957722
    2  0.837528
    3  0.384112
    4  0.574303
    5  0.101283
    6  0.628310
    7  0.174578
    8  0.721997
    9  0.668771
              0         0
    0       NaN  0.949945
    1  0.949945  0.957722
    2  0.957722  0.837528
    3  0.837528  0.384112
    4  0.384112  0.574303
    5  0.574303  0.101283
    6  0.101283  0.628310
    7  0.628310  0.174578
    8  0.174578  0.721997
    9  0.721997  0.668771
    [[       nan 0.94994525]
     [0.94994525 0.9577217 ]
     [0.9577217  0.83752817]
     [0.83752817 0.38411155]
     [0.38411155 0.57430296]
     [0.57430296 0.10128265]
     [0.10128265 0.62830992]
     [0.62830992 0.17457841]
     [0.17457841 0.7219971 ]
     [0.7219971  0.66877118]]
    [       nan 0.94994525 0.9577217  0.83752817 0.38411155 0.57430296
     0.10128265 0.62830992 0.17457841 0.7219971 ]
    [       nan 0.94994525] => nan
    [0.94994525 0.9577217 ] => 0.9499452498907361
    [0.9577217  0.83752817] => 0.9577216990829638
    [0.83752817 0.38411155] => 0.8375281747300221
    [0.38411155 0.57430296] => 0.3841115541079436
    [0.57430296 0.10128265] => 0.5743029557433733
    [0.10128265 0.62830992] => 0.10128265088053356
    [0.62830992 0.17457841] => 0.6283099216390347
    [0.17457841 0.7219971 ] => 0.17457841317845058
    [0.7219971  0.66877118] => 0.7219971035263132

    我们可以看到第一行有NaN值。

    这是因为我们没有事先观察序列中的第一个值。我们必须用一些东西填补这个空间。

    但我们无法使用NaN输入拟合模型。

    处理缺失的序列数据

    处理丢失的序列数据有两种主要方法。

    它们将删除缺少数据的行,并使用其他值填充缺少的时间步。

    有关处理缺失数据的更常用方法,请参阅帖子:

    处理缺失序列数据的最佳方法取决于您的问题和您选择的网络配置。我建议探索每种方法,看看哪种方法效果最好。

    删除缺失的序列数据

    在我们回显前一个时间步骤中的观察的情况下,第一行数据不包含任何有用的信息。

    也就是说,在上面的例子中,给定输入:

    1

    [        nan  0.18961404]

    和输出:

    1

    nan

    没有任何有意义的东西可以学习或预测。

    这里最好的情况是删除这一行。

    我们可以通过删除包含NaN值的所有行,在序列的制定过程中将其作为监督学习问题。具体来说,可以在将数据拆分为X和y组件之前调用dropna()函数

    完整示例如下:

    from random import random
    from numpy import array
    from pandas import concat
    from pandas import DataFrame
    
    # 生成一系列随机值
    def generate_sequence(n_timesteps):
    	return [random() for _ in range(n_timesteps)]
    
    # 生成lstm的数据
    def generate_data(n_timesteps):
    	# 生成随机序列
    	sequence = generate_sequence(n_timesteps)
    	sequence = array(sequence)
    	# 格式化成有序矩阵
    	df = DataFrame(sequence)
    	df = concat([df.shift(1), df], axis=1)
    	# 删除空值的数据
    	df.dropna(inplace=True)
    	values = df.values
    	# 指定输入和输出数据
    	X, y = values, values[:, 0]
    	return X, y
    
    # 生成序列
    n_timesteps = 10
    X, y = generate_data(n_timesteps)
    # print sequence
    for i in range(len(X)):
    	print(X[i], '=>', y[i])

    运行该示例会导致9 X,y对而不是10对,并删除第一行。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    [ 0.60619475  0.24408238] => 0.606194746194

    [ 0.24408238  0.44873712] => 0.244082383195

    [ 0.44873712  0.92939547] => 0.448737123424

    [ 0.92939547  0.74481645] => 0.929395472523

    [ 0.74481645  0.69891311] => 0.744816453809

    [ 0.69891311  0.8420314 ] => 0.69891310578

    [ 0.8420314   0.58627624] => 0.842031399202

    [ 0.58627624  0.48125348] => 0.586276240292

    [ 0.48125348  0.75057094] => 0.481253484036

    替换缺失的序列数据

    在回声问题被配置为在当前时间步长回显观察的情况下,第一行将包含有意义的信息。

    例如,我们可以将y的定义从值[:,0]更改为值[:,1]并重新运行演示以生成此问题的示例,如下所示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    [        nan  0.50513289] => 0.505132894821

    [ 0.50513289  0.22879667] => 0.228796667421

    [ 0.22879667  0.66980995] => 0.669809946421

    [ 0.66980995  0.10445146] => 0.104451463568

    [ 0.10445146  0.70642423] => 0.70642422679

    [ 0.70642423  0.10198636] => 0.101986362328

    [ 0.10198636  0.49648033] => 0.496480332278

    [ 0.49648033  0.06201137] => 0.0620113728356

    [ 0.06201137  0.40653087] => 0.406530870804

    [ 0.40653087  0.63299264] => 0.632992635565

    我们可以看到第一行给出了输入:

    1

    [        nan  0.50513289]

    和输出:

    1

    0.505132894821

    这可以从输入中学到。

    问题是,我们仍然需要处理NaN值。

    我们可以使用在输入中不会自然出现的特定值(例如-1)替换所有NaN值,而不是使用NaN值删除行。为此,我们可以使用fillna()Pandas函数

    完整示例如下:

    from random import random
    from numpy import array
    from pandas import concat
    from pandas import DataFrame
    
    # 生成一系列随机值
    def generate_sequence(n_timesteps):
    	return [random() for _ in range(n_timesteps)]
    
    # 生成lstm的数据
    def generate_data(n_timesteps):
    	# generate sequence
    	sequence = generate_sequence(n_timesteps)
    	sequence = array(sequence)
    	# 格式化成有序矩阵
    	df = DataFrame(sequence)
    	df = concat([df.shift(1), df], axis=1)
    	# 把NAN值用-1来填充
    	df.fillna(-1, inplace=True)
    	values = df.values
    	# 指定输入和输出数据
    	X, y = values, values[:, 1]
    	return X, y
    
    # 生成序列
    n_timesteps = 10
    X, y = generate_data(n_timesteps)
    # print sequence
    for i in range(len(X)):
    	print(X[i], '=>', y[i])

    运行该示例,我们可以看到第一行第一列中的NaN值被替换为-1值。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    [-1. 0.94641256] => 0.946412559807

    [ 0.94641256 0.11958645] => 0.119586451733

    [ 0.11958645 0.50597771] => 0.505977714614

    [ 0.50597771 0.92496641] => 0.924966407025

    [ 0.92496641 0.15011979] => 0.150119790096

    [ 0.15011979 0.69387197] => 0.693871974256

    [ 0.69387197 0.9194518 ] => 0.919451802966

    [ 0.9194518 0.78690337] => 0.786903370269

    [ 0.78690337 0.17017999] => 0.170179993691

    [ 0.17017999 0.82286572] => 0.822865722747

     

    对有缺失值得数据进行学习

    在学习具有标记缺失值的序列预测问题时,有两个主要选项。

    该问题可以按原样建模,我们可以鼓励模型了解特定值意味着“缺失”。或者,可以屏蔽特殊缺失值并从预测计算中明确排除。

    我们将通过两个输入来看看这两个案例的人为“回应当前观察”问题。

    学习缺失的价值观

    我们可以为预测问题开发LSTM。

    输入由2个时间步长和1个特征定义。在第一隐藏层中定义具有5个存储器单元的小LSTM,并且具有线性激活功能的单个输出层。

    使用均方误差丢失函数和具有默认配置的高效ADAM优化算法,网络将适合。

    # define model
    model = Sequential()
    model.add(LSTM(5, input_shape=(2, 1)))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')

    为了确保模型学习问题的广义解,即始终将输入作为输出返回(y(t)== X(t)),我们将在每个时期生成一个新的随机序列。该网络将适合500个时期,并且将在每个序列中的每个样本之后执行更新(batch_size = 1)。

    # fit model
    for i in range(500):
    X, y = generate_data(n_timesteps)
    model.fit(X, y, epochs=1, batch_size=1, verbose=2)

    一旦拟合,将生成另一个随机序列,并将来自模型的预测与预期值进行比较。这将提供模型技能的具体概念。

    # evaluate model on new data
    X, y = generate_data(n_timesteps)
    yhat = model.predict(X)
    for i in range(len(X)):
    print('Expected', y[i,0], 'Predicted', yhat[i,0])

    将所有这些结合在一起,下面提供了完整的代码清单。

    from random import random
    from numpy import array
    from pandas import concat
    from pandas import DataFrame
    from keras.models import Sequential
    from keras.layers import LSTM
    from keras.layers import Dense
    
    # 生成一系列随机值
    def generate_sequence(n_timesteps):
    	return [random() for _ in range(n_timesteps)]
    
    # generate data for the lstm
    def generate_data(n_timesteps):
    	# generate sequence
    	sequence = generate_sequence(n_timesteps)
    	sequence = array(sequence)
    	# create lag
    	df = DataFrame(sequence)
    	df = concat([df.shift(1), df], axis=1)
    	# 把NAN值用-1来填充
    	df.fillna(-1, inplace=True)
    	values = df.values
    	# specify input and output data
    	X, y = values, values[:, 1]
    	# reshape
    	X = X.reshape(len(X), 2, 1)
    	y = y.reshape(len(y), 1)
    	return X, y
    
    n_timesteps = 10
    # 构建一个网络模型
    model = Sequential()
    model.add(LSTM(5, input_shape=(2, 1)))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    # 调用网络
    for i in range(500):
    	X, y = generate_data(n_timesteps)
    	model.fit(X, y, epochs=1, batch_size=1, verbose=2)
    # 评估数据模型
    X, y = generate_data(n_timesteps)
    yhat = model.predict(X)
    for i in range(len(X)):
    	print('Expected', y[i,0], 'Predicted', yhat[i,0])

    回顾最终预测,我们可以看到网络已经学会了问题并预测了“足够好”的输出,即使存在缺失值。运行该示例打印每个时期的损失,并在运行结束时比较一个序列的预期输出与预测输出。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    ...

    Epoch 1/1

    0s - loss: 1.5992e-04

    Epoch 1/1

    0s - loss: 1.3409e-04

    Epoch 1/1

    0s - loss: 1.1581e-04

    Epoch 1/1

    0s - loss: 2.6176e-04

    Epoch 1/1

    0s - loss: 8.8303e-05

    Expected 0.390784174343 Predicted 0.394238

    Expected 0.688580469278 Predicted 0.690463

    Expected 0.347155799665 Predicted 0.329972

    Expected 0.345075533266 Predicted 0.333037

    Expected 0.456591840482 Predicted 0.450145

    Expected 0.842125610156 Predicted 0.839923

    Expected 0.354087132135 Predicted 0.342418

    Expected 0.601406667694 Predicted 0.60228

    Expected 0.368929815424 Predicted 0.351224

    Expected 0.716420996314 Predicted 0.719275

    您可以进一步尝试此示例,并将给定序列的t-1观察值的50%标记为-1,并查看它如何影响模型的技能随时间的变化。

    忽略缺失值

    可以从网络中的所有计算中屏蔽标记的缺失输入值。

    我们可以通过使用Masking层作为网络的第一层来实现。

    定义图层时,我们可以指定要屏蔽的输入中的哪个值。如果时间步长的所有要素都包含蒙版值,则整个时间步长将从计算中排除。

    这为完全排除行并强制网络了解标记缺失值的影响提供了一个中间立场。

    由于Masking层是网络中的第一个,因此必须指定输入的预期形状,如下所示:

    model.add(Masking(mask_value=-1, input_shape=(2, 1)))

    我们可以将所有这些结合起来并重新运行示例。完整的代码清单如下。

    from random import random
    from numpy import array
    from pandas import concat
    from pandas import DataFrame
    from keras.models import Sequential
    from keras.layers import LSTM
    from keras.layers import Dense
    from keras.layers import Masking
    
    # 生成一系列随机值
    def generate_sequence(n_timesteps):
    	return [random() for _ in range(n_timesteps)]
    
    # generate data for the lstm
    def generate_data(n_timesteps):
    	# generate sequence
    	sequence = generate_sequence(n_timesteps)
    	sequence = array(sequence)
    	# create lag
    	df = DataFrame(sequence)
    	df = concat([df.shift(1), df], axis=1)
    	#将NAN值替换为-1
    	df.fillna(-1, inplace=True)
    	values = df.values
    	# specify input and output data
    	X, y = values, values[:, 1]
    	# reshape
    	X = X.reshape(len(X), 2, 1)
    	y = y.reshape(len(y), 1)
    	return X, y
    
    n_timesteps = 10
    # 定义网络
    model = Sequential()
    # mask_value=-1使得网络对-1的值进行忽略,不进行学习
    model.add(Masking(mask_value=-1, input_shape=(2, 1)))
    model.add(LSTM(5))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    # fit model
    for i in range(500):
    	X, y = generate_data(n_timesteps)
    	model.fit(X, y, epochs=1, batch_size=1, verbose=2)
    # 评估数据模型
    X, y = generate_data(n_timesteps)
    yhat = model.predict(X)
    for i in range(len(X)):
    	print('Expected', y[i,0], 'Predicted', yhat[i,0])

    同样,预测看起来足够小到几位小数。同样,每个时期打印损失,并将预测与最终序列的预期值进行比较。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    ...

    Epoch 1/1

    0s - loss: 1.0252e-04

    Epoch 1/1

    0s - loss: 6.5545e-05

    Epoch 1/1

    0s - loss: 3.0831e-05

    Epoch 1/1

    0s - loss: 1.8548e-04

    Epoch 1/1

    0s - loss: 7.4286e-05

    Expected 0.550889403319 Predicted 0.538004

    Expected 0.24252028132 Predicted 0.243288

    Expected 0.718869927574 Predicted 0.724669

    Expected 0.355185878917 Predicted 0.347479

    Expected 0.240554707978 Predicted 0.242719

    Expected 0.769765554707 Predicted 0.776608

    Expected 0.660782450416 Predicted 0.656321

    Expected 0.692962017672 Predicted 0.694851

    Expected 0.0485233839401 Predicted 0.0722362

    Expected 0.35192019185 Predicted 0.339201

    展开全文
  • 基于Python时间序列LSTM预测系列教程(4)~(5)中介绍的LSTM案例 最简单状态的LSTM,要得到优化的LSTM,需要进行很多扩展实验 1、Mini-Step预测 可以将预测变成n-time step的预测 2、Tune模型 至少tune下神经...

    单变量LSTM预测模型(6)


    教程原文连接


    前置教程:

    Python时间序列LSTM预测系列教程(1)-单变量

    Python时间序列LSTM预测系列教程(2)-单变量

    Python时间序列LSTM预测系列教程(3)-单变量

    Python时间序列LSTM预测系列教程(4)-单变量

    Python时间序列LSTM预测系列教程(5)-单变量

    简单LSTM案例的扩展思考


    基于Python时间序列LSTM预测系列教程(4)~(5)中介绍的LSTM案例
    是最简单状态的LSTM,要得到优化的LSTM,需要进行很多扩展实验

    1、Mini-Step预测
    可以将预测变成n-time step的预测

    2、Tune模型
    至少tune下神经元个数和epoch的次数
    在训练期间,通过回调进行早期停止,也可能获得好的结果

    3、Seed状态
    网络状态的初始化seed方案,可能影响性能

    4、更新模型
    模型可以在每次walk-forward验证的时候更新

    5、输入的时间步
    需要支持多时间步长的输入

    6、输入lag属性
    可以将lay作为输入特征feature,看能否提升模型性能,类似AR(k)

    7、输入error序列
    可以建立误差序列(通过静态模型预测误差),将其作为输入特征feature,看能否提升模型性能,类似MA(k)

    8、学习非稳定数据
    LSTM可能学习到趋势或周期性,可以通过实验确定下

    9、对比无状态
    可以建立无状态LSTM进行对比

    10、统计特征
    多次repeat计算一些统计值,可以通过相关统计学知识,计算不同模型设置下的性能

    展开全文
  • LSTM时间序列预测及网络层搭建

    万次阅读 多人点赞 2018-10-07 10:48:38
    最近看到一篇博客,是时间预测问题,数据和代码的原地址在这里, https://www.jianshu.com/p/5d6d5aac4dbd 下面只是对其复现和思考: 首先关于数据预处理的问题,大家可以参考:...
  • LSTM(Long Short Term Memory Network)长短时记忆网络,一种改进之后的循环神经网络,可以解决 RNN 无法处理长距离的依赖的问题,在时间序列预测问题上面也有广泛的应用。 今天我们根据问题的输入输出模式划分...
  • 选用LSTM时间序列模型来探索,时间维度以月为单位,已经尝试了一对一,多对一的探索,效果不理想,预测未来三个月的销量,结果容易拟合成一条曲线,现在尝试用多对多的方式测试一下,思路用前三个月的销量预测后三...
  • LSTM_TEST:了解LSTM-源码

    2021-03-27 19:21:46
    让我们使用Google简洁的深度学习库TensorFlow,演示LSTM的用法,LSTM是一种可以处理顺序数据/时间序列的人工神经网络。 视频数据集概述 点击此链接可观看其中一位参与者在实验中记录的6项活动的视频: 有关输入...
  • 基于LSTM的股票时间序列预测(附数据集和代码)

    万次阅读 多人点赞 2020-05-20 20:04:01
    LSTM数据集实战 ...既然是时间序列预测,我们最关心的预测值在时间维度上的走势如何,那我们只要最后一列volume和第一列date这两列就好了。 实战 先是导入相关包,一些常见的包就不详细说了,我们需要的Se
  • 本文对: https://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/ https://blog.csdn.net/iyangdi/article/details/77877122 两篇博文的学习笔记,两个博主笔风...
  • input_shape=(128,40)#第一位是时间序列timesteps,第二个40特征数,之前搞反了训练很慢,调回来准确率就高了。最好不要用reshape调,用np.transpose()转置调,reshape不懂会不会打乱数据的时序和特征附上LSTM_...
  • 1.2 LSTM(long short-term memory) 二、RNN变种 三、自然语言建模 四、时间序列预测 一、概念 1.1 RNN 主要用来处理和预测序列数据。特点:隐藏层的输入不仅包括输入层的输出,还包括上一时刻隐藏层的输出...
  • 二、LSTM的神秘之处什么?三、一些细节1.脏数据2.dropout3.未知词条4.字符级建模5.使用one-hot向量6.数据集较小总结 前言 前文提到过用CNN、RNN、来解决隐藏在文本背后的语义问题,进而进行模型的训练。LSTM在...
  • 关于LSTM的核心点理解

    千次阅读 2019-06-13 14:14:58
    3.LSTM神经网络输入输出究竟怎样的? 4. 5.《神经网络与深度学习》 6. 一、LSTM的提出原因(针对RNN的长期依赖问题) 循环神经网络(RNN)在学习过程中的主要问题长期依赖问题。 具体来说就是: 虽然...
  • str1 = '北京时间2月17日凌晨,第69届柏林国际电影节公布主竞赛单元获奖名单,王景春、咏梅凭借王小帅执导的中国影片《地久天长》连夺最佳男女演员双银熊大奖,这中国演员首次包揽柏林电影节最佳男女演员奖,为...
  • TensorFlow实现经典深度学习网络(6):TensorFlow实现基于LSTM的语言模型 循环神经网络(Recurrent Neural Networks,RNNs)出现于20世纪80年代,由于神经网络结构的进步和GPU上深度学习训练效率的突破,PNNs已经在...
  • tensorflow中LSTM和GRU的用法分析

    千次阅读 2019-09-19 16:59:42
    tensorflow中LSTM和GRU层的用法分析说明LSTMGRU 说明 本文所用的实例基于python...#units,表示每个时间步的输出维度,比如输入的每个时间一个3维向量,则输出一个6维向量 #return_sequences,控制是否输出全部...
  • 450训练集的长度,2是时间步长,这个数据你要自己去转化,6是特征数 对应股票数据就是(训练集的长度,一次几条数据,股票的特征) 原始的数据集二维的,(450,6),你需要展开成三维的(450,1,6),作为...
  • 让我们使用Google简洁的深度学习库TensorFlow演示LSTM的用法,LSTM是一种可以处理顺序数据/时间序列的人工神经网络。 视频数据集概述 点击此链接可观看其中一位参与者在实验中记录的6个活动的视频: 有关输入数据...
  • 学习记录--- LSTM 时序特征提取

    千次阅读 2019-08-09 16:14:52
    最近做项目,看了一点关于LSTM的知识,目的想用LSTM提取时间序列的时序特征 和师姐讨论,加上个人理解,认为state.h (使用tensorflow深度学习框架)为一条序列的时序特征。(时序特征维数由隐层神经元个数num_...
  • RNN,LSTM,GRU网络的架构对比

    千次阅读 2018-12-02 22:40:05
    接下来要用到时间序列网络做实验,LSTM应该个不错的选择,今年6月份时候快速的过了一遍LSTM网络各个门控结构的定义,并跟着网络教程做了小demo实验。转眼又过去半年了,在这半年里接触、学习了很多的东西,深感...
  • 输入以前的收盘价,即t-20到t-1的最后20个输入的时间序列窗口(假设样本输入的timestamp20)。回归算法可能会学习在时间t-1或t-2处的值作为预测值,因为这样不需要做什么就可以达到优化的误差之类了。这样想:...
  • 使用深度学习中的LSTM(Long Short-Term Memory)长短期记忆网络,来尝试一下中文文本多分类,LSTM一种时间循环神经网络,适合于处理和预测时间序列中间隔和延迟相对较长的重要事件。 数据集 ChineseNlpCorpus...

空空如也

空空如也

1 2 3 4 5 6
收藏数 108
精华内容 43
关键字:

lstm时间是6