精华内容
下载资源
问答
  • lstm时间序列预测模型
    2020-12-26 11:38:37

    参考基于 Keras 的 LSTM 时间序列分析——以苹果股价预测为例

    ######################导入库##########################
    import os
    os.environ['KERAS_BACKEND']='tensorflow'
    import keras
    import tensorflow as tf
    from keras import optimizers#优化器
    from keras.models import Sequential, load_model
    from keras.layers import Dense, LSTM
    from keras.layers import Dropout
    

    1层LSTM

    def lstm_single(x,y,hidden_cell,epoch,batch_size,verbose):
        #verbose=0不显示训练进度,verbose=2显示训练进度和每个epoch所需时间
        model = Sequential()
        model.add(LSTM(hidden_cell, input_shape=(x.shape[1],1)))
        model.add(Dense(1))
        adam=optimizers.Adam(learning_rate=0.01)
        model.compile(loss='mean_squared_error', optimizer=adam)
        model.fit(x,y, epochs=epoch, batch_size=batch_size, verbose=verbose)
        #loss=model.history.history['loss']#记录模型模型的损失函数值
        return model
    

    4层LSTM

    def lstm_4layer(x,y,hidden_cell,epoch,batch_size,verbose):	
    	model = Sequential()
    	model.add(LSTM(units=hidden_cell,return_sequences=True,input_shape=(x.shape[1], 1)))
    	model.add(Dropout(0.2))#可有可无,
    	model.add(LSTM(units=hidden_cell,return_sequences=True))
    	model.add(Dropout(0.2))
    	model.add(LSTM(units=hidden_cell,return_sequences=True))
    	model.add(Dropout(0.2))
    	model.add(LSTM(units=hidden_cell))
    	model.add(Dropout(0.2))
    	model.add(Dense(units=1))
    	adam=optimizers.Adam(learning_rate=0.01)
    	model.compile(loss='mean_squared_error', optimizer=adam)
    	#上面两行可以用下面这行代替,但是下面这行不能修改学习率
    	#model.compile(optimizer='adam',loss='mean_squared_error')
    	model.fit(x,y,epochs=epoch,batch_size=batch_size,verbose=verbose)
    	return model
    

    参数初始化

    '''变量初始化'''
    import numpy as np
    x_train=np.random.random(size=(300,5,1))
    y_train=np.random.random(300)
    x_test=np.random.random(size=(100,5,1))
    y_test=np.random.random(100)
    hidden_cell,epoch,batch_size,verbose=5,100,1,0
    #hidden_cell是隐层节点数,epoch是最大训练次数,batch_size我说不清,只知batch_size越大训练越快,但是精度下降,verbose=0不会显示训练过程,=1或者=2会显示训练过程batch_size和verbose有默认值
    

    模型训练

    x=x_train;y=y_train
    hidden_cell,epoch,batch_size,verbose=5,100,1,0
    model=lstm_4layer((x,y,hidden_cell,epoch,batch_size,verbose))
    

    绘制模型训练过程损失值变化情况

    plt.plot(model.history.history['loss'])
    plt.xlabel('epochs')
    plt.ylabel('loss')
    

    使用训练好的模型预测

    ypre=model.predict(x_test,y_test)
    
    更多相关内容
  • lstm时间序列预测模型 时间序列-LSTM模型 (Time Series - LSTM Model) Advertisements 广告 Previous Page 上一页 Next Page 下一页 Now, we are familiar with statistical modelling on time series...
    lstm时间序列预测模型

    lstm时间序列预测模型

    时间序列-LSTM模型 (Time Series - LSTM Model)

    Now, we are familiar with statistical modelling on time series, but machine learning is all the rage right now, so it is essential to be familiar with some machine learning models as well. We shall start with the most popular model in time series domain − Long Short-term Memory model.

    现在,我们已经很熟悉时间序列的统计建模,但是机器学习现在非常流行,因此也必须熟悉某些机器学习模型。 我们将从时间序列域中最流行的模型开始-长短期记忆模型。

    LSTM is a class of recurrent neural network. So before we can jump to LSTM, it is essential to understand neural networks and recurrent neural networks.

    LSTM是一类递归神经网络。 因此,在进入LSTM之前,必须了解神经网络和递归神经网络。

    神经网络 (Neural Networks)

    An artificial neural network is a layered structure of connected neurons, inspired by biological neural networks. It is not one algorithm but combinations of various algorithms which allows us to do complex operations on data.

    人工神经网络是受生物神经网络启发的连接神经元的分层结构。 它不是一种算法,而是多种算法的组合,使我们能够对数据进行复杂的操作。

    递归神经网络 (Recurrent Neural Networks)

    It is a class of neural networks tailored to deal with temporal data. The neurons of RNN have a cell state/memory, and input is processed according to this internal state, which is achieved with the help of loops with in the neural network. There are recurring module(s) of ‘tanh’ layers in RNNs that allow them to retain information. However, not for a long time, which is why we need LSTM models.

    它是为处理时间数据而量身定制的一类神经网络。 RNN的神经元具有细胞状态/内存,并根据此内部状态处理输入,这是借助神经网络中的循环来实现的。 RNN中有“ tanh”层的重复模块,可让它们保留信息。 但是,不是很长一段时间,这就是为什么我们需要LSTM模型。

    LSTM (LSTM)

    It is special kind of recurrent neural network that is capable of learning long term dependencies in data. This is achieved because the recurring module of the model has a combination of four layers interacting with each other.

    它是一种特殊的循环神经网络,能够学习数据的长期依赖性。 之所以能够实现这一目标,是因为模型的重复模块具有相互交互的四层组合。

    Neural Network

    The picture above depicts four neural network layers in yellow boxes, point wise operators in green circles, input in yellow circles and cell state in blue circles. An LSTM module has a cell state and three gates which provides them with the power to selectively learn, unlearn or retain information from each of the units. The cell state in LSTM helps the information to flow through the units without being altered by allowing only a few linear interactions. Each unit has an input, output and a forget gate which can add or remove the information to the cell state. The forget gate decides which information from the previous cell state should be forgotten for which it uses a sigmoid function. The input gate controls the information flow to the current cell state using a point-wise multiplication operation of ‘sigmoid’ and ‘tanh’ respectively. Finally, the output gate decides which information should be passed on to the next hidden state

    上图显示了黄色方框中的四个神经网络层,绿色圆圈中的点智能算子,黄色圆圈中的输入,蓝色圆圈中的单元状态。 LSTM模块具有单元状态和三个门,这三个门为它们提供了从每个单元中选择性地学习,取消学习或保留信息的能力。 LSTM中的单元状态仅允许一些线性交互作用,从而使信息流经这些单元而不会被更改。 每个单元都有一个输入,输出和一个忘记门,可以将信息添加或删除到单元状态。 遗忘门决定使用S形函数应忘记先前单元状态中的哪些信息。 输入门分别使用“ Sigmoid”和“ tanh”的逐点乘法运算将信息流控制为当前单元状态。 最后,输出门决定应将哪些信息传递到下一个隐藏状态

    Now that we have understood the internal working of LSTM model, let us implement it. To understand the implementation of LSTM, we will start with a simple example − a straight line. Let us see, if LSTM can learn the relationship of a straight line and predict it.

    现在我们已经了解了LSTM模型的内部工作原理,让我们实现它。 为了理解LSTM的实现,我们将从一个简单的示例开始-一条直线。 让我们看看,LSTM是否可以学习直线的关系并对其进行预测。

    First let us create the dataset depicting a straight line.

    首先,让我们创建描述直线的数据集。

    In [402]:

    在[402]中:

    
    x = numpy.arange (1,500,1)
    y = 0.4 * x + 30
    plt.plot(x,y)
    
    

    Out[402]:

    出[402]:

    
    [<matplotlib.lines.Line2D at 0x1eab9d3ee10>]
    
    
    Code Snippet 19

    In [403]:

    在[403]中:

    
    trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
    trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
    train = numpy.array(list(zip(trainx,trainy)))
    test = numpy.array(list(zip(trainx,trainy)))
    
    

    Now that the data has been created and split into train and test. Let’s convert the time series data into the form of supervised learning data according to the value of look-back period, which is essentially the number of lags which are seen to predict the value at time ‘t’.

    现在已经创建了数据,并将其拆分为训练和测试。 让我们根据回溯期的值将时间序列数据转换为监督学习数据的形式,回溯期的值本质上是指可以预测时间“ t”时的滞后次数。

    So a time series like this −

    所以这样的时间序列-

    
    time variable_x
    t1  x1
    t2  x2
     :   :
     :   :
    T   xT
    
    

    When look-back period is 1, is converted to −

    当回溯期为1时,转换为-

    
    x1   x2
    x2   x3
     :    :
     :    :
    xT-1 xT
    
    

    In [404]:

    在[404]中:

    
    def create_dataset(n_X, look_back):
       dataX, dataY = [], []
       for i in range(len(n_X)-look_back):
          a = n_X[i:(i+look_back), ]
          dataX.append(a)
          dataY.append(n_X[i + look_back, ])
       return numpy.array(dataX), numpy.array(dataY)
    
    

    In [405]:

    在[405]中:

    
    look_back = 1
    trainx,trainy = create_dataset(train, look_back)
    testx,testy = create_dataset(test, look_back)
    
    trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
    testx = numpy.reshape(testx, (testx.shape[0], 1, 2))
    
    

    Now we will train our model.

    现在,我们将训练模型。

    Small batches of training data are shown to network, one run of when entire training data is shown to the model in batches and error is calculated is called an epoch. The epochs are to be run ‘til the time the error is reducing.

    将小批量的训练数据显示给网络,一次将整个训练数据分批显示给模型并且计算出误差时的一次运行称为时期。 直到错误减少的时间段为止。

    In [ ]:

    在[]中:

    
    from keras.models import Sequential
    from keras.layers import LSTM, Dense
    
    model = Sequential()
    model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
    model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
    model.add(Dense(2))
    model.compile(loss = 'mean_squared_error', optimizer = 'adam')
    model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
    model.save_weights('LSTMBasic1.h5')
    
    

    In [407]:

    在[407]中:

    
    model.load_weights('LSTMBasic1.h5')
    predict = model.predict(testx)
    
    

    Now let’s see what our predictions look like.

    现在,让我们看看我们的预测是什么样的。

    In [408]:

    在[408]中:

    
    plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
    plt.plot(predict[:,0:1], predict[:,1:2])
    
    

    Out[408]:

    出[408]:

    
    [<matplotlib.lines.Line2D at 0x1eac792f048>]
    
    
    Code Snippet 22

    Now, we should try and model a sine or cosine wave in a similar fashion. You can run the code given below and play with the model parameters to see how the results change.

    现在,我们应该尝试以类似方式对正弦波或余弦波建模。 您可以运行下面给出的代码,并使用模型参数来查看结果如何变化。

    In [409]:

    在[409]中:

    
    x = numpy.arange (1,500,1)
    y = numpy.sin(x)
    plt.plot(x,y)
    
    

    Out[409]:

    出[409]:

    
    [<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]
    
    
    Code Snippet 23

    In [410]:

    在[410]中:

    
    trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
    trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
    train = numpy.array(list(zip(trainx,trainy)))
    test = numpy.array(list(zip(trainx,trainy)))
    
    

    In [411]:

    在[411]中:

    
    look_back = 1
    trainx,trainy = create_dataset(train, look_back)
    testx,testy = create_dataset(test, look_back)
    trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
    testx = numpy.reshape(testx, (testx.shape[0], 1, 2))
    
    

    In [ ]:

    在[]中:

    
    model = Sequential()
    model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
    model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
    model.add(Dense(2))
    model.compile(loss = 'mean_squared_error', optimizer = 'adam')
    model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
    model.save_weights('LSTMBasic2.h5')
    
    

    In [413]:

    在[413]中:

    
    model.load_weights('LSTMBasic2.h5')
    predict = model.predict(testx)
    
    

    In [415]:

    在[415]中:

    
    plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
    plt.plot(predict[:,0:1], predict[:,1:2])
    
    

    Out [415]:

    出[415]:

    
    [<matplotlib.lines.Line2D at 0x1eac7a1f550>]
    
    
    Code Snippet 23

    Now you are ready to move on to any dataset.

    现在您可以继续使用任何数据集了。

    翻译自: https://www.tutorialspoint.com/time_series/time_series_lstm_model.htm

    lstm时间序列预测模型

    展开全文
  • 序列预测方面,当属LSTM模型的应用最广。我基于matlab编写了用LSTM模型实现多步预测时间序列的程序代码。序列数据是我随机生成的,如果有自己的数据,就可以自己简单改一下代码,读取txt或excel都可以。注意读取后...
  • 主要介绍了Python中利用LSTM模型进行时间序列预测分析的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • LSTM Time Series Prediction with Bayesian optimization.zip
  • LSTM-attention.rar,LSTM-attention,Main.m,Model2.m,Model.m,Train.mat,paramsInit.m,Attention.m,Test.mat,thresholdL2Norm.m,TrainOptions.m,FullyConnect.m,LSTMModel.m,Model2Predict.m,ModelPredict.m,...
  • 时间序列预测,预测客流量、车流量短时时间序列
  • 时间序列预测——LSTM模型(附代码实现)

    万次阅读 热门讨论 2022-05-10 17:23:15
    长短时记忆网络( Long short-term memory,LSTM )是一种循环神经网络 (Recurrent neural network, RNN)的特殊变体。

    目录

    模型原理

    模型实现

    导入所需要的库

    设置随机数种子

    导入数据集

    打印前五行数据进行查看

    数据处理

    归一化处理

    查看归一化处理后的数据

    将时间序列转换为监督学习问题

    打印数据前五行

     划分训练集和测试集

    查看划分后的数据维度

    搭建LSTM模型

     得到损失图

    模型预测

    画图展示

    得到预测图像 

    回归评价指标


    模型原理

            长短时记忆网络( Long short-term memory,LSTM )是一种循环神经网络 (Recurrent neural network, RNN)的特殊变体,具有“门”结构,通过门单元的逻辑控制决定数据是否更新或是选择丢弃,克服了 RNN 权重影响过大、容易产生梯度消失和爆炸的缺点,使网络可以更好、更快地收敛,能够有效提高预测精度。LSTM 拥有三个门, 分别为遗忘门、输入门、输出门,以此决定每一时刻信息记忆与遗忘。输入门决定有多少新的信息加入到细胞当中,遗忘门控制每一时刻信息是否会被遗忘,输出门决定每一时刻是否有信息输出。其基本结构如图所示。

    公式如下:

    (1)遗忘门

    (2)输入门

    (3)单元

    (4)输出门

    (5)最终输出

    模型实现

    导入所需要的库

    import matplotlib.pyplot as plt
    from pandas import read_csv
    from pandas import DataFrame
    from pandas import concat
    from sklearn.preprocessing import MinMaxScaler
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import LSTM,Dense,Dropout
    from numpy import concatenate
    from sklearn.metrics import mean_squared_error,mean_absolute_error,r2_score
    from math import sqrt
    

    设置随机数种子

    import tensorflow as tf
    tf.random.set_seed(2)

    导入数据集

    qy_data=read_csv(r'C:\Users\HUAWEI\Desktop\abc.csv',parse_dates=['num'],index_col='num')
    qy_data.index.name='num' #选定索引列

    打印前五行数据进行查看

    数据处理

    # 获取DataFrame中的数据,形式为数组array形式
    values = qy_data.values
    # 确保所有数据为float类型
    values = values.astype('float32')

    归一化处理

    使用MinMaxScaler缩放器,将全部数据都缩放到[0,1]之间,加快收敛。

    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled = scaler.fit_transform(values)

    查看归一化处理后的数据

      

    将时间序列转换为监督学习问题

    时间序列形式的数据转换为监督学习集的形式,例如:[[10],[11],[12],[13],[14]]转换为[[0,10],[10,11],[11,12],[12,13],[13,14]],即把前一个数作为输入,后一个数作为对应输出。

    def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
        n_vars = 1 if type(data) is list else data.shape[1]
        df = DataFrame(data)
        cols, names = list(), list()
        # input sequence (t-n, ... t-1)
        for i in range(n_in, 0, -1):
            cols.append(df.shift(i))
            names += [('var%d(t-%d)' % (j + 1, i)) for j in range(n_vars)]
            # forecast sequence (t, t+1, ... t+n)
        for i in range(0, n_out):
            cols.append(df.shift(-i))
            if i == 0:
                names += [('var%d(t)' % (j + 1)) for j in range(n_vars)]
            else:
                names += [('var%d(t+%d)' % (j + 1, i)) for j in range(n_vars)]
        # put it all together
        agg = concat(cols, axis=1)
        agg.columns = names
        # drop rows with NaN values
        if dropnan:
            agg.dropna(inplace=True)
        return agg
    
    reframed = series_to_supervised(scaled, 2, 1)

    打印数据前五行

      

     划分训练集和测试集

    # 划分训练集和测试集
    values = reframed.values
    trainNum = int(len(values) * 0.7)
    train = values[:trainNum,:]
    test = values[trainNum:, :]

    查看划分后的数据维度

    print(train_X.shape, train_y.shape)
    print(test_X.shape, test_y.shape)

     

    搭建LSTM模型

    初始化LSTM模型,设置神经元核心的个数,迭代次数,优化器等等

    model = Sequential()
    model.add(LSTM(27, input_shape=(train_X.shape[1], train_X.shape[2])))
    model.add(Dropout(0.5))
    model.add(Dense(15,activation='relu'))#激活函数
    model.compile(loss='mae', optimizer='adam')
    history = model.fit(train_X, train_y, epochs=95, batch_size=2, validation_data=(test_X, test_y), verbose=2,shuffle=False)

     得到损失图

    ​​​​​​​ 

    模型预测

    y_predict = model.predict(test_X)
    test_X = test_X.reshape((test_X.shape[0], test_X.shape[2]))

    画图展示

    plt.figure(figsize=(10,8),dpi=150)
    plt.plot(inv_y,color='red',label='Original')
    plt.plot(inv_y_predict,color='green',label='Predict')
    plt.xlabel('the number of test data')
    plt.ylabel('Soil moisture')
    plt.legend()
    plt.show()

    得到预测图像 

    将测试集的y值和预测值绘制在同一张图表中

      

    回归评价指标

    # calculate MSE 均方误差
    mse=mean_squared_error(inv_y,inv_y_predict)
    # calculate RMSE 均方根误差
    rmse = sqrt(mean_squared_error(inv_y, inv_y_predict))
    #calculate MAE 平均绝对误差
    mae=mean_absolute_error(inv_y,inv_y_predict)
    #calculate R square
    r_square=r2_score(inv_y,inv_y_predict)
    print('均方误差MSE: %.6f' % mse)
    print('均方根误差RMSE: %.6f' % rmse)
    print('平均绝对误差MAE: %.6f' % mae)
    print('R_square: %.6f' % r_square)

    展开全文
  • LSTM模型进行股票预测,时间序列预测LSTM算法
  • LSTM时间序列预测方面的应用非常广,但有相当一部分没有考虑使用多长的数据预测下一个,类似AR模型中的阶数P。我基于matlab2021版编写了用LSTM模型实现多步预测时间序列的程序代码,可以自己调整使用的数据“阶数...
  • 时间序列预测(曲线回归或曲线拟合),结构为训练数据生成-》隐藏输入层-》LSTM神经层-》隐藏输入层-》结果,也可以采用LSTM神经层-》全连接层(多层的普通神经网络)构成,训练效果未对比,与参数调优相关。...

    RNN

    递归神经网络(RNN)相对于MLP和CNN的主要优点是,它能够处理序列数据,在传统神经网络或卷积神经网络中,样本(sample)输入与输出是没有“顺序”概念的,可以理解为,如果把输入序列和输出序列重新排布,对整体模型的理论性能不会有影响。RNN则不同,它保证了输入和输出至少有一端是有序列特征的。

    传统的神经网络结构可以归纳会下图左边的形式,隐藏层h的状态是不保存的,而在RNN中,每一个时间步的隐藏层状态都是由上一层的输入和上一个时间的状态共同计算得到。
    在这里插入图片描述
    RNN算法的细节这里就不赘述,RNN的缺点在于,误差反向传播时,由于时间步t的梯度是由t时的状态h分别对前面所有时间步的状态求导,再相乘得到,在状态权重的模大于1时,若时间步t较长,梯度就会消失(趋近于0),即长期的依赖很小,相反,在状态权重的模小于1时,若时间步t较短,梯度就会爆炸(很大),即短期的依赖很大。具体分析请[参考文献]。(http://ARXIV.org/pdf/1211.5063.pdf),解决这一问题有两个主要的方法:

    • 截断的时间反向传播法(TBPTT):将梯度限制在某个范围,这种做法简单粗暴,却能解决梯度爆炸和消失的问题,但是限制了梯度的传播;
    • 长短期记忆(LSTM)

    LSTM

    LSTM最先是被引入来解决梯度小时问题,LSTM在神经网络中是一个特殊的隐藏层,他将时间步t的隐藏层状态更新结构表示如下:
    在这里插入图片描述
    图来源以及LSTM的原理介绍可以参考
    LSTM由三个门来控制细胞状态,这三个门分别称为遗忘门、输入门和输出门。

    • 遗忘门:允许记忆单元在有限增长的情况下重置信元状态。遗忘门类似于一个过滤器,决定上一个时间步的信元状态C能否通过
    • 输入门:负责根据输入值和遗忘门的输出,来更新信元状态C
    • 输出们:更新隐藏单元的值
      当然,LSTM的形式也是存在很多变式的,不同的变式在大部分任务上效果都差不多,在一些特殊任务上,一些变式要优于标准的LSTM

    利用LSTM进行时间序列预测

    一般在时间序列预测上,常用的方法主要有ARIMA之类的统计分析,机器学习中经典的回归分析等

    • 统计分析中(如ARIMA),将时间序列分为三个部分:趋势,季节性和波动,通过统计学算法将序列分离,得到每个部分的模型再相加,但是模型对于序列的方差、均值平稳性以及自相关性都有很高的要求,否则模型偏差会很大。
    • 回归分析注重模型偏差和方差,对特征的要求也很高,回归分析中处理非线性问题是一个很艰难的过程。

    这里采用LSTM来进行时间序列预测,结构为:

    训练数据生成—>隐藏输入层—>LSTM神经层—>隐藏输出层(全连接层)—>结果

    当然,也可以根据任务增加隐藏层,LSTM层以及全连接层的数量。
    tensorflow中已经为我们准备好了LSTM层的接口,根据需要配置即可。
    这里列举几个重要的注意点:

    1. 首先要理解什么是序列和序列化数据,比如如果我要预测24小时的天气,那将会有很多种方案,每种方案的序列化都不一样,若模型输出就是24小时的序列,那么输入序列可以是 t-1之前任意长度的序列,输出序列是t > t+23;也可以输入序列为t-24之前的序列来预测t时候的值,进行24次预测;也可以用t-1之前的序列要预测t时,每次预测结果再代入输入中预测t时刻之后的值。总之,每种做法效果不一样,具体问题还需要具体分析;
    2. TIME_STEPS参数,可以理解为时间步,就是你需要几个时刻的样本来预测,INPUT_SIZE 为每个样本的维度,如果你的样本数据是一个单一序列,没有其他特征的话,则可设置为1;OUTPUT_SIZE 为输出的维度,就是输出序列的长度;如果输出也是一个序列的话,可以将y的维度设置为[None,TIME_STEPS,OUTPUT_SIZE]
    import numpy as np
    import tensorflow as tf
    import matplotlib.pyplot as plt
    %matplotlib inline
    #------------------------------------Generate Data-----------------------------------------------#
    TIME_STEPS = 20
    BATCH_SIZE = 1
    INPUT_SIZE = 1
    OUTPUT_SIZE = 1
    CELL_SIZE = 50
    LEARNING_RATE = 0.001
    EPOCH = 100
    LAYER_NUM =3
    
    # 参数说明:TIME_STEPS:输入序列的时间步,;
    #         INPUT_SIZE:输入序列中每个向量的维度
    #         BATCH_SIZE:训练的批次
    #         OUTPUT_SIZE:输出序列的向量维度
    #         CELL_SIZE:LSTM神经层的细胞数,也是LSTM层的输入和输出维度(这两个维度相同),也即为LSTMCell中的num_units参数;
    #         LEARNING_RATE:tensorflow中optimizer的学习率;
    #         EPOCH:迭代次数或训练次数;;
    #         LAYER_NUM:LSTM神经层的层数。
    #
    #生成训练数据和测试数据
    def generate(seq,time_step,output_size):
        X = []
        Y = []
        for i in range(len(seq)-time_step-output_size):
            X.append(seq[i:i+time_step])
            Y.append(seq[i+time_step:i+time_step+output_size])
        return np.array(X,dtype =np.float32),np.array(Y,dtype = np.float32)
    
    
    seq = np.sin(np.linspace(0,100,10000,dtype=np.float32)/np.pi)
    # seq_y = data_day.values.reshape([-1])
    X_train,y_train = generate(seq,TIME_STEPS,OUTPUT_SIZE)
    X_test, y_test = generate(seq[:-24*7],TIME_STEPS,OUTPUT_SIZE)
    
    
    
    X_train = np.reshape(X_train,newshape=(-1,TIME_STEPS,INPUT_SIZE))
    X_test = np.reshape(X_test,newshape=(-1,TIME_STEPS,INPUT_SIZE))
    y_train = np.reshape(y_train,newshape=(-1,OUTPUT_SIZE))
    y_test = np.reshape(y_test,newshape=(-1,OUTPUT_SIZE))
    
    TRAIN_EXAMPLES = X_train.shape[0]
    TEST_EXAMPLES = X_test.shape[0]
    
    
    
    def tf_init_state(batch_size,cells):
        if isinstance(cells,list):
            states = []
            for cell in cells:
                c_size = cell.state_size.c
                h_size = cell.state_size.h
                c = tf.Variable(np.zeros([batch_size,c_size],dtype=np.float32),dtype=tf.float32)
                h = tf.Variable(np.zeros([batch_size,c_size],dtype=np.float32),dtype=tf.float32)
                states.append(tf.nn.rnn_cell.LSTMStateTuple(c=c,h=h))
            return tuple(states)
        else:
            c_size = cells.state_size.c
            h_size = cells.state_size.h
            c = tf.get_variable('{}/c'.format(cells.name),[batch_size,c_size],dtype=tf.float32,initializer=tf.zeros_initializer(tf.float32))
            h = tf.get_variable('{}/h'.format(cells.name),[batch_size,h_size],dtype=tf.float32,initializer=tf.zeros_initializer(tf.float32))
            return tf.nn.rnn_cell.LSTMStateTuple(c=c,h=h)
        
    def get_states(statetuple,batch_pre):
        if isinstance(statetuple,tuple):
            newstate = []
            for state in list(statetuple):
                c = state[0][:batch_pre,:]
                h = state[1][:batch_pre,:]
                newstate.append(tf.nn.rnn_cell.LSTMStateTuple(c=c,h=h))
            return tuple(newstate)
        else:
            c = statetuple[0]
            h = statetuple[1]
            return tf.nn.rnn_cell.LSTMStateTuple(c=c[:batch_pre,:],h=h[:batch_pre,:])
    
    #------定义权重和偏差生成函数
    def weight_variable(shape, name='weights'):
        initializer = tf.random_normal_initializer(mean=0., stddev=1.,)
        return tf.get_variable(name=name, shape=shape, initializer=initializer)
    
    def bias_variable(shape, name='biases'):
        initializer = tf.constant_initializer(0.1)
        return tf.get_variable(name=name, shape=shape, initializer=initializer)
    
    #定义计算图---------------------------------------------------#
    graph = tf.Graph()
    with graph.as_default():
        with tf.name_scope('inputs'):
            x_p = tf.placeholder(dtype=tf.float32,shape=(None,TIME_STEPS,INPUT_SIZE),name='xs')
            y_p = tf.placeholder(dtype=tf.float32,shape=(None,OUTPUT_SIZE),name = 'ys')
            cell_batch = tf.placeholder(dtype=tf.float32,shape =None,name='batch_size')
    #定义输入隐藏层,x_p维度(batch_size,time_steps,input_size),l_in_x维度(batch_size*time_steps,input_size),l_in_y维度(batch_size*time_steps,cell_size)
        with tf.variable_scope('in_hidden'):
            l_in_x = tf.reshape(x_p,[-1,INPUT_SIZE])
            ws_in = weight_variable([INPUT_SIZE,CELL_SIZE],'ws_in')
            bs_in = bias_variable([CELL_SIZE,],'bs_in')
            l_in_y = tf.matmul(l_in_x,ws_in) +  bs_in
        
    #定义lstm神经层,l_cell_x维度(batch_size,time_steps,cell_size),l_cell_y维度(batch_size,time——steps,cell_size)
    #-----单层lstm神经层
    #     lstm_cell = tf.nn.rnn_cell.LSTMCell(num_units=HIDDEN_UNITS)
    #     lstm_model = lstm_cell
    #-----dynamic rnn
    #     outputs,states=tf.nn.dynamic_rnn(cell=lstm_cell,inputs=x_p,initial_state=init_state,dtype=tf.float32)
    #     h=outputs[:,-1,:]
    #     lstm_cell1 = rnn.BasicLSTMCell(num_units=HIDDEN_UNITS)
    #-----多层lstm神经层
        with tf.variable_scope('Lstm_cell_train'):
            l_cell_x= tf.reshape(l_in_y,[-1,TIME_STEPS,CELL_SIZE])
            lstm_cell = [tf.nn.rnn_cell.BasicLSTMCell(num_units=CELL_SIZE,state_is_tuple=True) for _ in range(LAYER_NUM)]
            lstm_model = tf.contrib.rnn.MultiRNNCell(cells=lstm_cell)
            init_state = lstm_model.zero_state(batch_size=BATCH_SIZE,dtype=tf.float32)
            l_cell_y,cell_states=tf.nn.dynamic_rnn(cell=lstm_model,inputs=l_cell_x,initial_state=init_state,dtype=tf.float32)
       
        
    #------这里可以直接用输出状态叠加一个全连接层得到最终结果,全连接层可以用函数定义或者手写
    #     dnn_out=dnn_stack(outputs[:,-1,:],layers={'layers':[32,16]})
    
    
    #定义输出隐藏层,这里为手写单层神经层,l_out_x的维度(batch_size,cell_size),l_out_y的维度为(batch_size,ouputsize)
        with tf.variable_scope('out_hidden'):
            l_out_x = tf.reshape(l_cell_y[:,-1,:],[-1,CELL_SIZE])
            ws_out = weight_variable([CELL_SIZE,OUTPUT_SIZE],'ws_out')
            bs_out = bias_variable([OUTPUT_SIZE,],'bs_out')
            l_out_y = tf.matmul(l_out_x,ws_out) +  bs_out
    
    
    #定义损失函数和优化器,损失函数采用MSE(mean-squared error),优化器有多种选择,基础优化器梯度下降法(GradientDescentOptimizer)
    #---------------------------------------------------------------------这里采用的是adam算法(AdamOptimizer),优化器一般在tf.train包中
    #     def ms_error(labels, logits):
    #         return tf.square(tf.subtract(labels, logits))
        with tf.name_scope('loss_funtion'):
            mse = tf.losses.mean_squared_error(labels = y_p,predictions = l_out_y)
    #     losses = tf.contrib.legacy_seq2seq.sequence_loss_by_example(logits=[tf.reshape(l_out_y,[-1],name='reshaped_pred')],
    #                                                              targets=[tf.reshape(y_p,[-1],name='reshaped_target')],
    #                                                              weights = [tf.ones([BATCH_SIZE*TIME_STEPS],dtype=tf.float32)],
    #                                                              softmax_loss_function=ms_error)
    #     mse = tf.div(tf.reduce_sum(losses, name='losses_sum'),BATCH_SIZE,name='average_cost')
        with tf.name_scope('train'):
            optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss = mse)
    #变量初始化
        init = tf.global_variables_initializer()
    
        
    #计算图对话-----session   
    # with tf.Session(graph=graph) as sess:
    sess = tf.Session(graph = graph)
    sess.run(init)
    #训练过程
    for epoch in range(1,EPOCH+1):   
        train_losses = []
    
        for j in range(TRAIN_EXAMPLES//BATCH_SIZE):
            if epoch==1 and j==0:            
                feed_dict = {
                    x_p:X_train[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                    y_p:y_train[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                }
            else:
                feed_dict = {
                    x_p:X_train[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                    y_p:y_train[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                    init_state:final_states
                }
            _,train_loss,final_states = sess.run(
            fetches =(optimizer,mse,cell_states),feed_dict = feed_dict)
            train_losses.append(train_loss)
        if epoch%10 ==0:
            print('epoch:',epoch)
            print('average training loss:',sum(train_losses)/len(train_losses))
    #预测过程
    if X_test.shape[0]>=TIME_STEPS:
        results = np.zeros(shape=(TEST_EXAMPLES,OUTPUT_SIZE))
        test_losses = []  
        for j in range(TEST_EXAMPLES//BATCH_SIZE):
            result,test_loss,wsin,bsin,wsout,bsout=sess.run(
            fetches =(l_out_y,mse,ws_in,bs_in,ws_out,bs_out),feed_dict ={
                    x_p:X_test[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                    y_p:y_test[j*BATCH_SIZE:(j+1)*BATCH_SIZE],
                    init_state:final_states
                } )
            results[j*BATCH_SIZE:(j+1)*BATCH_SIZE,:]=result
            test_losses.append(test_loss)
        print('average testing loss:',sum(test_losses)/len(test_losses))
    #绘制图形
    plt.figure(facecolor ='white',figsize=(20,12))
    plt.plot(range(j*BATCH_SIZE),y_test[:j*BATCH_SIZE],'r-',range(j*BATCH_SIZE),results[:j*BATCH_SIZE,:])
    plt.show()
    
    展开全文
  • 我的疑问,time_step = 8,意味着每8个数据预测下一个数据,为什么预测后的图画出来和原始数据的形状一直呢?3,data[:,0] data[1,:]的含义。下图是归一化后的原数据和预测数据。下图是没有归一化过的原数据。....
  • 时间序列预测问题中,建立LSTM模型,采用python语言代码实现
  • LSTM时间序列预测

    千次阅读 2021-09-10 09:40:11
    文章目录 1、tensorflow张量的形状 2、RNN 3、LSTM 3.1 深入了解LSTM结构 4、keras的LSTM 4.1 参数return_sequences含义 5、LSTM实现PM2.5的预测 1、tensorflow张量的形状 tensorflow中张量(tensor)的属性——维数...
  • pytorch LSTM 时间序列预测

    千次阅读 热门讨论 2021-12-02 11:28:49
    pytorch LSTM 时间序列预测
  • lstm训练模型,训练时间序列,可预测长时数据
  • 一、贝叶斯网络及LSTM简介 1 贝叶斯网络 贝叶斯网络(Bayesian network),又称信念网络(Belief Network),或有向无环图模型(directed acyclic graphical model),是一种概率图模型,于1985年由Judea Pearl首先提出。...
  • 时序预测 | MATLAB实现BiLSTM时间序列预测 目录时序预测 | MATLAB实现BiLSTM时间序列预测基本介绍程序设计单层网络多层网络参考资料致谢 基本介绍 双向 LSTM 或 biLSTM 是一种序列处理模型,由两个 LSTM 组成:一个...
  • Pytorch实现LSTM时间序列预测

    万次阅读 2018-05-10 17:25:53
     上一部分简单地介绍了LSTM模型结构,下边将具体介绍使用LSTM模型进行时间序列预测的具体过程。 02 — 数据准备  对于时间序列,本文选取正弦波序列,事先产生一定数量的序列数据,然后截取前部分作为训练数据...
  • PyTorch搭建LSTM实现时间序列预测(负荷预测)

    万次阅读 多人点赞 2022-01-18 22:03:24
    PyTorch搭建LSTM实现时间序列预测(负荷预测)
  • 完整代码已上传我的资源:【LSTM时间序列数据】基于matlab LSTM时间序列数据预测【含Matlab源码 1949期】获取代码方式2: 通过订阅紫极神光博客付费专栏,凭支付凭证,私信博主,可获得此代码。备注: 订阅紫极神光...
  • LSTM LSTM网络 long short term memory,即我们所称呼的LSTM,是为了解决长期以来问题而专门设计出来的,所有的RNN都具有一种重复神经网络模块的链式形式。在标准RNN中,这个重复的结构模块只有一个非常简单的结构,...
  • (只考虑一维数据) LSTM时间序列预测可以实现单步预测、多步预测 单步预测:步预测1步 多步预测::3步预测3步 将时序数据转换为LSTM的训练数据函数如下: 输入时序数据、input_size步预测output_size步 def data_...
  • 4.模型预测 1.特征工程 我们在进行模型搭建之前,需要进行特征工程。 1.1.创建样本集和标签集 def create_new_dataset(dataset,seq_len): #新建两个空列表,用来存放样本和标签数据 x=[] y=[]
  • TensorFlow框架下的LSTM时间序列预测【简易】
  • matlab出图,运行保障,代码有详细说明,适用初学者。
  • 参考链接: 在Python中使用LSTM和PyTorch进行时间序列预测 想了解更多好玩的人工智能应用,请关注公众号“机器AI学习 数据AI挖掘”,”智能应用"菜单中包括:颜值检测、植物花卉识别、文字识别、人脸美妆等有趣的...
  • LSTM模型预测时间序列(快速上手)

    万次阅读 多人点赞 2020-10-29 20:52:49
    LSTM模型的一个常见用途是对长时间序列数据进行学习预测,例如得到了某商品前一年的日销量数据,我们可以用LSTM模型预测未来一段时间内该商品的销量。但对于不熟悉神经网络或者对没有了解过RNN模型的人来说,想要...
  • LSTM 时间序列预测

    千次阅读 2020-12-09 21:41:54
    我们使用它来进行LSTM时间序列预测的实验。数据如图所示第一列为时间 第二列为数据编写代码头文件 import numpy import matplotlib.pyplot as plt from keras.models import Sequential from keras.layers impo

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,390
精华内容 9,756
关键字:

lstm时间序列预测模型