精华内容
下载资源
问答
  • 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时间序列预测模型

    展开全文
  • 参考基于 Keras 的 LSTM 时间序列分析——以苹果股价预测为例 ######################导入库########################## import os os.environ['KERAS_BACKEND']='tensorflow' import keras import tensorflow as tf...

    参考基于 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神经层-》全连接层(多层的普通神经网络)构成,训练效果未对比,与参数调优相关。...

    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()
    
    展开全文
  • 1.通过自回归(AR,ARIMA)模型进行时间序列预测合集:https://github.com/yangwohenmai/TimeSeriesForecasting 2.通过深度学习模型进行时间序列预测合集:https://github.com/yangwohenmai/DeepLearningForTSF 3.基于...
  • 接上文,本文继续讲解如何开发LSTM时间序列预测模型–多步LSTM模型。 之前的文章: 【Part1】如何开发LSTM实现时间序列预测详解 01 Univariate LSTM 【Part2】如何开发LSTM实现时间序列预测详解 02 Multivariate ...

    【时间序列预测/分类】 全系列45篇由浅入深的博文汇总:传送门


    上文,本文继续讲解如何开发LSTM时间序列预测模型–多步LSTM模型。


    之前的文章:

    【Part1】如何开发LSTM实现时间序列预测详解 01 Univariate LSTM
    【Part2】如何开发LSTM实现时间序列预测详解 02 Multivariate LSTM



    3. 多步 LSTM 模型

    多步时间序列预测:通过历史数据对未来多个时间步进行预测的时间序列预测问题。两种主要的LSTM模型可用于多步预测:

    • Vector Output Model
    • Encoder-Decoder Model

    3.1 准备数据

    与一个时间步预测任务一样,用于多步时间序列预测的序列数据也必须分成具有输入和输出分量的样本。输入和输出由多个时间步的采样值组成,并且输入和预测输出可能具有不同的时间步数。例如,给定单变量时间序列:

    [10, 20, 30, 40, 50, 60, 70, 80, 90]
    

    假设我们通过以往三个时间步的数据来预测接下来两个时间步的数据,那么就可以把单变量时间序列划分为如下的样本:

    [10 20 30] [40 50]
    [20 30 40] [50 60]
    [30 40 50] [60 70]
    [40 50 60] [70 80]
    [50 60 70] [80 90]
    

    以上样本生成的过程中,滑动窗口的窗口宽度为3,滑动步长为1,特征数为1,生成的样本数为5。

    数据准备好之后,接下来重塑样本形状;定义模型,进行训练、测试。


    3.2 Vector Output Model

    与其他类型的神经网络模型一样,LSTM可以直接输出一个可以解释为多步预测的向量。在上一篇文章中,这种方法是将每个输出时间序列的一个时间步长作为向量进行预测。与单变量LSTM一样,再进行训练之前,必须重塑样本。顺序模型(Sequential)中,LSTM的第一层输入要求数据的形状为:[样本、时间步、特征]([samples, timesteps, features]),这里的时间步(timesteps)其实就是窗口宽度,在我们的示例中,特征数为1,使用 reshape 方法进行重塑数据:

    n_features = 1
    X = X.reshape((X.shape[0], X.shape[1], n_features))
    

    训练样本和样本标签的shape分别为:

    (5, 3, 1), (5, 2)
    

    本系列的第一篇文章中的任何一种LSTM都可以使用,例如Vanilla、Stacked、Bidirectional、CNN或Conv LSTM模型。此处使用Stacked LSTM进行演示。注意:此处的 n_features = 1 ,因为只有一个时间序列并且是根据序列的之前三个值预测后两个值,这与多输入序列的特征数是不同的。一定要搞清楚样本、时间步、特征数的定义和相互关系,要不在开发过程中很容易感到困惑。

    训练完成之后,在进行预测时,单个样本的形状也需要重塑为跟训练数据中单个训练样本相同的shape,在本文的示例中,尺寸应该为: [1、3、1]其中“1”表示单个样本,“3”表示一个样本包含多少个采样点,最后一个“1” 表示样本中的特征数,因为是单变量预测,所以为1。通过代码实现:

    test_seq = array([70, 80, 90])
    test_seq = test_seq.reshape((1, sw_width, n_features))
    yhat = model.predict(test_seq, verbose=0)
    

    3.3 Encoder-Decoder Model

    专门为预测可变长度输出序列而开发的模型称为 编码器-解码器LSTM(Encoder-Decoder LSTM)。该模型是为序列到序列(seq2seq)的预测问题(即同时有输入和输出序列)而设计的,seq2seq模型常用在自然语言处理领域,例如语言翻译。该模型也可用于多步时间序列预测。顾名思义,该模型由两个子模型组成:编码器(Encoder)和解码器(Decoder)。

    编码器是负责读取和解释输入序列的模型。编码器的输出是固定长度的向量,代表模型对序列的解释。传统上,该编码器是Vanilla LSTM模型,但也可以使用其他编码器模型,例如Stacked,Bidirectional和CNN模型。

    model.add(LSTM(100, activation='relu', input_shape=(n_steps_in, n_features)))
    

    解码器使用编码器的输出作为输入。首先,编码器的固定长度输出被重复,对于输出序列中的每个所需时间步重复一次。

    model.add(RepeatVector(n_steps_out))
    

    我们可以使用一个或多个相同的输出层在输出序列中的每个时间步进行预测。这可以通过将模型的输出部分包装在 TimeDistributed() 包装器中来实现。

    完整代码:

    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')
    

    有几点关于以上API的说明:

    1.keras.layers.RepeatVector(n)

    • n:整数,重复因子
    • 输入shape:(num_samples, features)
    • 输出shape:(num_samples, n, features)

    2.LSTM()return_sequences 参数

    • 布尔值,设置为 True 返回完整序列;设置为 False 返回输出序列中的最后一个输出;

    3.4 完整代码

    在这段时间的学习过程中,遇到了很多疑惑的地方,发现很多教程都没有对关键的地方做解释,可能是大神写的吧…咱也不知道,咱也不敢问,反正对我这样的小白不友好。
    在这里插入图片描述
    随着理解的加深,也算是对LSTM处理时间序列预测问题有些许领悟和体会了,于是参考Jason的博客,自己重新梳理总结了一遍,将代码中比较难理解的地方做了注释,小白应该也能看懂,算是保姆级教程了吧… 数据处理、转化过程、尺寸变化等信息也打印出来了,结合文章内容应该不难理解。

    3.4.1 数据处理与模型定义

    import numpy as np
    from tensorflow.keras.models import Sequential, Model
    from tensorflow.keras.layers import Dense, LSTM, Flatten, Bidirectional
    from tensorflow.keras.layers import TimeDistributed,RepeatVector
            
        
    class MultiStepModels:
        '''
        多时间步预测时间序列LSTM模型
        '''
        def __init__(self, train_seq, test_seq, sw_width, pred_length, features, epochs_num, verbose_set, flag=0): 
            '''
            初始化变量和参数
            '''
            self.train_seq = train_seq
            self.test_seq = test_seq
            self.sw_width = sw_width
            self.pred_length = pred_length
            
            self.features = features
            
            self.epochs_num = epochs_num
            self.verbose_set = verbose_set
            
            self.flag = flag
            
            self.X, self.y = [], []     
            
        def split_sequence(self):
            '''
            该函数实现多输入序列数据的样本划分
            '''
            for i in range(len(self.train_seq)):
                # 找到最后一个元素的索引,因为for循环中i从1开始,切片索引从0开始,切片区间前闭后开,所以不用减去1;
                end_index = i + self.sw_width
                # 找到需要预测指定时间步长的最后一个元素的索引;
                out_end_index = end_index + self.pred_length
                # 如果最后一个期望输出最后一个元素的索引大于序列中最后一个元素的索引则丢弃该样本;
                # 这里len(self.sequence)没有减去1的原因是:保证最后一个元素的索引恰好等于序列数据索引时,能够截取到样本;
                if out_end_index > len(self.train_seq) :
                    break
                    
                # 实现以滑动步长为1(因为是for循环),窗口宽度为self.sw_width的滑动步长取值;
                seq_x, seq_y = self.train_seq[i:end_index], self.train_seq[end_index:out_end_index]
                self.X.append(seq_x)
                self.y.append(seq_y)
                
            self.X, self.y = np.array(self.X), np.array(self.y)
            self.X = self.X.reshape((self.X.shape[0], self.X.shape[1], self.features))
            self.test_seq = self.test_seq.reshape((1, self.sw_width, self.features))
    
            if self.flag == 1:
                self.y = self.y.reshape((self.y.shape[0], self.y.shape[1], self.features))
            else:
                pass
            
            for i in range(len(self.X)):
                print(self.X[i], self.y[i])
            
            print('X:\n{}\ny:\n{}\ntest_seq:\n{}\n'.format(self.X, self.y, self.test_seq))
            print('X.shape:{}, y.shape:{}, test_seq.shape:{}\n'.format(self.X.shape, self.y.shape, self.test_seq.shape))
            
            return self.X, self.y, self.test_seq       
    
        def stacked_lstm(self):
            model = Sequential()
            model.add(LSTM(100, activation='relu', return_sequences=True, 
                           input_shape=(self.sw_width, self.features)))
            model.add(LSTM(100, activation='relu'))
            model.add(Dense(units=self.pred_length))
            model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
            print(model.summary())
    
            history = model.fit(self.X, self.y, epochs=self.epochs_num, verbose=self.verbose_set)
            print('\ntrain_acc:%s'%np.mean(history.history['accuracy']), '\ntrain_loss:%s'%np.mean(history.history['loss']))
            print('yhat:%s'%(model.predict(self.test_seq)),'\n-----------------------------')
    
        def encoder_decoder_lstm(self):
            model = Sequential()
            model.add(LSTM(100, activation='relu',
                           input_shape=(self.sw_width, self.features)))
            model.add(RepeatVector(self.pred_length))
            model.add(LSTM(100, activation='relu', return_sequences=True))
            model.add(TimeDistributed(Dense(1)))
            
            model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
            print(model.summary())
            
            history = model.fit(self.X, self.y, epochs=self.epochs_num, verbose=self.verbose_set)
            print('\ntrain_acc:%s'%np.mean(history.history['accuracy']), '\ntrain_loss:%s'%np.mean(history.history['loss']))
            print('yhat:%s'%(model.predict(self.test_seq)),'\n-----------------------------')
    
    

    3.4.2 实例化代码

    if __name__ == '__main__':
    
        train_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]
        test_seq = np.array([70, 80, 90])
        
        sliding_window_width = 3
        predict_length = 2
        n_features = 1
        
        epochs_num = 100
        verbose_set = 0
        
        print('-------以下为 【向量输出 LSTM 模型】 相关信息------')
        MultiStepLSTM = MultiStepModels(train_seq, test_seq, sliding_window_width, predict_length, n_features, 
                                          epochs_num, verbose_set)
        MultiStepLSTM.split_sequence()
        MultiStepLSTM.stacked_lstm()
        
        print('-------以下为 【编码器-解码器 LSTM 模型】 相关信息------')
        MultiStepLSTM = MultiStepModels(train_seq, test_seq, sliding_window_width, predict_length, n_features, 
                                          epochs_num, verbose_set, flag=1)
        MultiStepLSTM.split_sequence()
        MultiStepLSTM.encoder_decoder_lstm()
    

    3.4.3 数据处理过程、训练、测试信息详情

    -------以下为 【向量输出 LSTM 模型】 相关信息------
    [[10]
     [20]
     [30]] [40 50]
    [[20]
     [30]
     [40]] [50 60]
    [[30]
     [40]
     [50]] [60 70]
    [[40]
     [50]
     [60]] [70 80]
    [[50]
     [60]
     [70]] [80 90]
    X:
    [[[10]
      [20]
      [30]]
    
     [[20]
      [30]
      [40]]
    
     [[30]
      [40]
      [50]]
    
     [[40]
      [50]
      [60]]
    
     [[50]
      [60]
      [70]]]
    y:
    [[40 50]
     [50 60]
     [60 70]
     [70 80]
     [80 90]]
    test_seq:
    [[[70]
      [80]
      [90]]]
    
    X.shape:(5, 3, 1), y.shape:(5, 2), test_seq.shape:(1, 3, 1)
    
    Model: "sequential_2"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    lstm_4 (LSTM)                (None, 3, 100)            40800     
    _________________________________________________________________
    lstm_5 (LSTM)                (None, 100)               80400     
    _________________________________________________________________
    dense_2 (Dense)              (None, 2)                 202       
    =================================================================
    Total params: 121,402
    Trainable params: 121,402
    Non-trainable params: 0
    _________________________________________________________________
    None
    
    train_acc:1.0 
    train_loss:752.8949569225312
    yhat:[[107.224014 119.64806 ]] 
    -----------------------------
    -------以下为 【编码器-解码器 LSTM 模型】 相关信息------
    [[10]
     [20]
     [30]] [[40]
     [50]]
    [[20]
     [30]
     [40]] [[50]
     [60]]
    [[30]
     [40]
     [50]] [[60]
     [70]]
    [[40]
     [50]
     [60]] [[70]
     [80]]
    [[50]
     [60]
     [70]] [[80]
     [90]]
    X:
    [[[10]
      [20]
      [30]]
    
     [[20]
      [30]
      [40]]
    
     [[30]
      [40]
      [50]]
    
     [[40]
      [50]
      [60]]
    
     [[50]
      [60]
      [70]]]
    y:
    [[[40]
      [50]]
    
     [[50]
      [60]]
    
     [[60]
      [70]]
    
     [[70]
      [80]]
    
     [[80]
      [90]]]
    test_seq:
    [[[70]
      [80]
      [90]]]
    
    X.shape:(5, 3, 1), y.shape:(5, 2, 1), test_seq.shape:(1, 3, 1)
    
    Model: "sequential_3"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    lstm_6 (LSTM)                (None, 100)               40800     
    _________________________________________________________________
    repeat_vector_1 (RepeatVecto (None, 2, 100)            0         
    _________________________________________________________________
    lstm_7 (LSTM)                (None, 2, 100)            80400     
    _________________________________________________________________
    time_distributed_1 (TimeDist (None, 2, 1)              101       
    =================================================================
    Total params: 121,301
    Trainable params: 121,301
    Non-trainable params: 0
    _________________________________________________________________
    None
    
    train_acc:0.0 
    train_loss:694.8172243946791
    yhat:[[[102.96109 ]
      [116.349144]]] 
    -----------------------------
    

    本文是LSTM处理时间序列预测任务的第3篇,最后一篇介绍多变量多时间步预测的LSTM模型,请看下一篇文章。
    在这里插入图片描述


    展开全文
  • 向AI转型的程序员都关注了这个号????????????人工智能大数据与深度学习 公众号:datayx本文将介绍如何用 keras 深度学习的框架搭建 LSTM 模型时间序列预测。1...
  • <p>LSTM时间序列预测,预测值画出来结果成了一条直线,下面是原数据的大概样子 <p style="text-align:center"><img alt="" height="352" src=...
  • 深度学习之LSTM时间序列预测

    万次阅读 多人点赞 2018-07-04 17:17:19
    LSTM(long short-term memory,LSTM):长短时记忆网络,是循环神经网络(recurrent neural network,RNN)的一个重要结构,循环神经的主要用途是处理和预测序列数据。全连接神经网络(感知机,BP神经网络,RBF 神经...
  • #时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题,和回归分析模型的预测不同,时间序列模型是依赖于事件发生的先后顺序的,同样...
  •  上一篇中我们较为详细地铺垫了关于RNN及其变种LSTM的一些基本知识,也提到了LSTM时间序列预测上优越的性能,本篇就将对如何利用tensorflow,在实际时间序列预测任务中搭建模型来完成任务,若你对RNN及LSTM不甚...
  • 最近对公司一款产品做销量预测,选用LSTM时间序列模型来探索,时间维度以月为单位,已经尝试了一对一,多对一的探索,效果不理想,预测未来三个月的销量,结果容易拟合成一条曲线,现在尝试用多对多的方式测试一下,...
  • 6 种用 LSTM时间序列预测模型结构 - Keras 实现 XI YANG 学习 59 人赞同了该文章 LSTM(Long Short Term Memory Network)长短时记忆网络,是一种改进之后的循环神经网络,可以解决 RNN 无法处理长距离的...
  • 前三篇文章,讨论了单变量、多变量和多步时间序列预测。对于不同的问题,可以使用不同类型的LSTM模型,例如Vanilla、Stacked、Bidirectional、CNN-LSTM、Conv LSTM模型。这也适用于涉及多变量和多时间步预测的时间...
  • 本文介绍了在以tensorflow2.1.0为后端的Keras中,如何为各种时间序列预测问题开发LSTM模型。本文旨在为每种类型的时间序列问题提供所对应模型的示例,你可以依此为模板,针对自己的业务需求进行修改。
  • 模型通过LSTM网络结构获得时间序列的长期记忆,充分挖掘变形数据的内部时间特征;并通过正交试验对LSTM模型的参数进行优化;最后通过实测数据对模型进行验证,实验结果表明,模型预测值与实际监测值吻合较好.通过...
  • LSTM(Long Short Term Memory Network)长短时记忆网络,是一种改进之后的循环神经网络,可以解决 RNN 无法处理长距离的依赖的问题,在时间序列预测问题上面也有广泛的应用。 Multiple Parallel: input 为多个...
  • 接上篇文章,本文继续介绍用于处理间序列LSTM模型--多变量LSTM模型( Multivariate LSTM Models)。
  • 时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题,和回归分析模型的预测不同,时间序列模型是依赖于事件发生的先后顺序的,同样大小...
  • RNN模型 LSTM 股票时间序列预测

    千次阅读 2020-07-25 23:58:50
    activation="linear")) #配置模型 回归模型y model.compile(optimizer="adam",loss="mean_squared_error") model.summary() 训练 model.fit(X,y,batch_size=30,epochs=200) 预测 #预测 训练数据 y_train_predict = ...

空空如也

空空如也

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

lstm时间序列预测模型