精华内容
下载资源
问答
  • AR自回归模型matlab代码宏观经济和金融预测工具箱 MATLAB 中金融和宏观经济预测的代码库(Python 和 R 版本正在进行中) 联系维克多塞勒米 () 了解更多信息。 请使用署名。 支持的型号 AR自回归模型 ARDI:因子...
  • AR自回归模型matlab预测程序

    热门讨论 2014-07-11 15:42:31
    AR自回归模型,采用matlab预测程序,差分标准化数据后进行AR模型使用判定,之后定AR阶数,做预测处理
  • MATLAB程序,附有数据和详细计算过程,自回归模型到分析过程
  • Autoregression / AR,就是用前期数据来预测后期数据的回归模型,所以叫做自回归模型。 它的逻辑简单,但对时间序列问题能够做出相当准确的预测。 1)自回归函数 y^t=b0+b1yt−1+...+bnyt−n,其中n<t y\hat{}_t =...

    Autoregression / AR,就是用前期数据来预测后期数据的回归模型,所以叫做自回归模型。

    它的逻辑简单,但对时间序列问题能够做出相当准确的预测。

    1)自回归函数

    y ^ t = b 0 + b 1 y t − 1 + . . . + b n y t − n , 其 中 n < t y\hat{}_t = b_0 + b_1y_{t-1} + ... + b_ny_{t-n} , 其中n<t y^t=b0+b1yt1+...+bnytn,n<t
    只有在数据平稳/若平稳的基础上,才能进行实现序列分析

    正式的说,如果一个时间序列 x t x_t xt 的一阶矩和二阶矩(即均值和方差)具有时间不变性,则称它为弱平稳的。弱平稳性是很重要的,因为它为预测提供了基础框架。
    ——《金融数据分析导论:基于R语言》2.1 平稳性

    2)上例子
    1. 首先取数&画图
    import pandas as pd
    import matplotlib.pyplot as plt
    
    df = pd.read_csv('https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-min-temperatures.csv',
    				 index_col=0, parse_dates=True)
    print(df.head())
    df.plot()
    plt.show()
    
    # 结果如下
                Temp
    Date            
    1981-01-01  20.7
    1981-01-02  17.9
    1981-01-03  18.8
    1981-01-04  14.6
    1981-01-05  15.8
    
    

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200408195712847.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h0dWh4Zg==,size_16,color_FFFFFF,t_70从上图可知温度序列是弱平稳的(weakly stationary);但是肉眼看不精确是不是平稳的,此时ADF Test/ Augmented Dickey-Fuller Test就排上用场了,其原假设H0:存在单位根/UNIT ROOT(即数据不平稳)

    from statsmodels.tsa.stattools import adfuller
    a = df.Temp
    print(adfuller(a,    # 下述参数均为默认值
    				maxlag=None, 
    				regression='c', 
    				autolag='AIC',   # 自动在[0, 1,...,maxlag]中间选择最优lag数的方法;
    				store=False, 
    				regresults=False)
    				)
    
    # 结果如下
    (-4.444804924611687,   #  AIC标准下得到的统计值,用于和下边 1%,5%,和10%临界值比较。但更方便的是直接用下边的p值
     0.00024708263003611164,   #  AIC标准下的p值,即原假设成立的概率
     20,     # AIC标准下的lags
     3629,   # nobs: 本次检测用到的观测值个数。ADF TEST中参数maxlag即由它决定,公式是 maxlag=12*(nobs/100)^{1/4},此处即29.45
    {'1%': -3.4321532327220154,   # 1%标准下的临界值
    '5%': -2.862336767636517, 
    '10%': -2.56719413172842}, 
    16642.822304301197)
    

    由p值可以看出,原假设成立的概率极底,我们应该拒绝原假设。即数据平稳。

    adfuller函数官方文档备注:
    Augmented Dickey-Fuller的原假设是存在单位根,备择假设是不存在单位根。如果p-value大于临界值,那么我们就不能拒绝有一个单位根存在。

    p-value是通过MacKinnon 1994年的回归曲面近似得到的,但使用的是更新的2010年表

    1. 快速查看数据是否适合AR模型
    from pandas.plotting import lag_plot
    lag_plot(df)   # 默认lag=1
    plt.show()
    # 结果如图所示:
    

    lag plot如上图所示, y t + 1 y_{t+1} yt+1 y t y_t yt明显相关。当然我们能通过计算,得到相关系数是0.77和显著性水平0。

    from scipy.stats.stats import pearsonr
    
    a = df.Temp
    b = df.Temp.shift(1)
    
    print(pearsonr(a[1:], b[1:]))
    
    # 结果如下
    (0.7748702165384458, 0.0)
    
    1. 上边是很好的检测方法。但是如果我们想同时查看 Y t Y_t Yt Y t − 1 Y_{t-1} Yt1,…, Y t − n Y_{t-n} Ytn的相关性,重复n次就太繁琐了。
      下面介绍一个一次性画出n多Lag的自回归系数方法:statsmodels.graphics.tsaplots.plot_acf()
    from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
    fig, axes = plt.subplots(2,1)
    
    fig, axes = plt.subplots(2, 1)
    plot_acf(df['Temp'], ax=axes[0])
    plot_pacf(df['Temp'], ax=axes[1])
    
    plt.tight_layout()
    plt.show()
    

    在这里插入图片描述
    4. 最后,到此为止我们就知道如何查看时间序列数据的自相关性了。接下来看如何用对它建立模型。

    import pandas as pd
    import numpy as np
    from statsmodels.tsa.ar_model import AR
    import matplotlib.pyplot as plt
    from sklearn.metrics import mean_squared_error as MSE
    
    df = pd.read_csv('e:/daily-min-temperatures.csv',
                     index_col=0, parse_dates=True)
    # 把模型数据分为train和test,分别用来训练模型和对比模型预测结果
    x = df.values
    train, test = x[:-7], x[-7:]  # test的个数设定为7
    
    # 训练模型得到所需参数:AR的滞后项个数p,和自回归函数的各个系数
    model_fit = AR(train).fit()
    params = model_fit.params
    p = model_fit.k_ar  # 即时间序列模型中常见的p,即AR(p), ARMA(p,q), ARIMA(p,d,q)中的p。
    # p的实际含义,此处得到p=29,意味着当天的温度由最近29天的温度来预测。
    
    history = train[-p:]   
    history = np.hstack(history).tolist()  # 也可以用history = [history[i] for i in range(len(history))] ,
    # 唯一的目的就是接下来通过append(test[i])实时更新history
    # (append函数不适用于np.narray类型的history)
    test = np.hstack(test).tolist()
    
    predictions = []
    for t in range(len(test)):
    	lag = history[-p:]
    	yhat = params[0]
    	for i in range(p):
    		yhat += params[i+1] * lag[p-1-i]
    	predictions.append(yhat)
    	obs = test[t]
    	history.append(obs)
    print(np.mean((np.array(test) - np.array(predictions))**2))  # 得到mean_squared_error, MSE
    plt.plot(test)
    plt.plot(predictions, color='r')
    plt.show()
    

    在这里插入图片描述附注:

    • 2个随机变量X和Y的pearson线性相关系数定义为:
      ρ x , y = C o v ( X , Y ) V a r ( X ) V a r ( Y ) = E [ ( X − μ x ) ( Y − μ y ) ] E ( X − μ x ) 2 E ( Y − μ y ) 2 ρ_{x,y} = \frac{Cov(X, Y)}{\sqrt{Var(X)Var(Y)}} = \frac{E[(X-μ_x)(Y-μ_y)]}{\sqrt{E(X-μ_x)^2E(Y-μ_y)^2}} ρx,y=Var(X)Var(Y) Cov(X,Y)=E(Xμx)2E(Yμy)2 E[(Xμx)(Yμy)]
      – 具体到样本:
      ρ ^ x , y = ∑ t = 1 T [ ( x t − x ˉ ) ( y t − y ˉ ) ] ∑ t = 1 T ( x t − x ˉ ) 2 ∑ t = 1 T ( y t − y ˉ ) 2 \hat{ρ}_{x,y} = \frac{\sum_{t=1}^{T} [(x_t -\bar{x})(y_t-\bar{y})]}{\sqrt{\sum_{t=1}^{T} (x_t -\bar{x})^2\sum_{t=1}^{T}(y_t-\bar{y})^2}} ρ^x,y=t=1T(xtxˉ)2t=1T(ytyˉ)2 t=1T[(xtxˉ)(ytyˉ)]
    展开全文
  • 金融时间序列分析:4. AR自回归模型

    万次阅读 多人点赞 2016-12-28 11:11:07
    AR模型AR模型:(Autoregressive Model)自回归模型,是时间序列分析模型中最简单的两个模型其中之一(另一个事MA模型)。 利用前期若干时刻的随机变量的线性组合来描述以后某时刻随机变量的线性回归模型(AR

    0. 目录

    金融时间序列分析:9. ARMA自回归移动平均模型
    金融时间序列分析:8. MA模型实例(Python)
    金融时间序列分析:7. MA滑动平均模型
    金融时间序列分析:6. AR模型实例
    金融时间序列分析:5. AR模型实例(Python)
    金融时间序列分析:4. AR自回归模型
    金融时间序列分析:3. First Demo By Python
    金融时间序列分析:2. 数学分析模型
    金融时间序列分析:1. 基础知识


    1. 前言

    接下来真是进入金融时间序列分析与预测阶段,可以说进入本篇算是正式入门了。
    这里会聊聊一个最基本的模型——AR模型


    2. AR模型

    AR模型:(Autoregressive Model)自回归模型,是时间序列分析模型中最简单的两个模型其中之一(另一个事MA模型)。

    利用前期若干时刻的随机变量的线性组合来描述以后某时刻随机变量的线性回归模型

    这里写图片描述
    其中{ at }是均值为0,方差为 σ2 的白噪声序列。


    3. AR(1)

    3.1 模型公式

    xt=ϕ0+ϕ1xt1+at,...............3.1

    or

    (1ϕ1B)xt=ϕ0+at

    3.2 数学特征

    期望

    E(xt)=μ=ϕ01ϕ1,................3.2

    推导方法:直接对公式3.1两边求期望即可

    把3.2带入3.1可以将AR模型公式改写为:

    xtμ=ϕ1(xt1μ)+at,................3.3

    方差

    Var(xt)=σa21ϕ12,....................3.4

    推导方法:直接对公式3.1两边求方差即可

    协方差
    这里写图片描述

    自相关函数

    ρk=ϕ1ρk1,k>0

    ρ1=ϕ1
    ρ2=ϕ12

    ρk=ϕ1k

    因为 |ρ1|=|ϕ1|1 ,所以 ρk 随着k的增大时不断衰减的,从显示意义上解释是:

    越是久远的数据,对当前数据的印象越小

    ACF表现如下:
    这里写图片描述

    3.3 预测

    yt=xtμ ,带入3.3式得:

    yt=ϕ1yt1+at,...................3.5

    单步预测
    (1)预测
    ŷ n(1)=ϕ1yn

    (2)误差
    en(1)=yn+1ŷ n(1)=at+1

    (3)误差波动率
    Var(en(1))=σa2

    两步预测
    (1)预测

    ŷ n(2)=ϕ1ŷ n(1)=ϕ21yn

    (2)误差
    en(2)=yn+2ŷ n(2)=ϕ1an+1+an+2

    (3)误差波动率
    Var(en(2))=(ϕ21+1)σa2

    多步预测
    (1)预测

    ŷ n(k)=ϕ1ŷ n(k1)=ϕk1yn

    (2)误差
    en(k)=yn+kŷ n(k)=an+k+ϕ1an+k1+...+ϕi1an+ki+ϕk11an+1

    (3)误差波动率
    Var(en(k))=(1+ϕ21+...+ϕ2(k1)1)σa2

    Particularly:

    k 时:
    ŷ n(k)0,x(n)μ
    Var(en(k))=Var(rn)


    4. AR(2)

    4.1 模型公式

    xt=ϕ0+ϕ1xt1+ϕ2xt2+at,...............4.1

    or

    (1ϕ1Bϕ2B2)xt=ϕ0+at

    4.2 数学特征

    期望

    E(xt)=μ=ϕ01ϕ1ϕ2,................4.2

    推导方法:直接对公式3.1两边求期望即可

    把3.2带入3.1可以将AR模型公式改写为:

    xtμ=ϕ1(xt1μ)+ϕ2(xt2μ)+at,................4.3

    PS:

    This form is often used in the finance literature to highlight the mean-reverting property of a stationary AR(2) model.
    In finance, mean reversion is the assumption that a stock’s price will tend to move to the average price over time.

    方差

    Var(xt)=σa21ϕ12,....................4.4

    推导方法:直接对公式3.1两边求方差即可

    ACF
    ρ0=1
    ρ1=ϕ11ϕ2

    ρk=ϕ1ρk1+ϕ2ρk2,k2,.......4.5

    4.3. 滞后算子B\L

    平稳的时间序列,AR(2) ACF满足二阶差分方程:

    (1ϕ1Bϕ2B2)ρk=0,..........4.6

    其中B成为延时算子或滞后算子(backshift),

    Bρk=ρk1

    B=ρk1ρk

    上面这个式子很重要,决定了AR(2)的性质。
    差分方程:
    1ϕ1zϕ2z2=0

    求解:
    z=ϕ1+ϕ21+4ϕ22ϕ2

    我们用ω1, ω2表示2个特征根(z的倒数),那么差分方程可以分解为
    (1 - ω1B)(1-ω2B) = 0
    这可以看成两个AR(1)模型的叠加。
    当ω1和ω2非复数时,ACF程混合指数衰减,如下图(a)
    当ω1和ω2为复数时,ACF呈减幅的正弦/余弦图像衰减,如图(b), (c), (d).

    这种情况很常见,也很重要,因为通常通过计算其波动周期确定对应序列的周期性。

    这里写图片描述


    6. 平稳性

    AR(1): |ϕ1|<1
    AR(p):所有特征根的的模小于1

    7. 参考文献

    [1] MIT, Analysis of Financial Time Series
    [2] https://en.wikipedia.org/wiki/Mean_reversion_(finance)
    [3] 金融时间序列分析, Ruey S. Tray

    展开全文
  • ) coord.request_stop() print('batch1:', batch1) print('batch2:', batch2) 采用AR自回归模型进行预测 train_array.py # coding: utf-8 from __future__ import print_function import numpy as np import ...

    前一段时间股市有一些大的波动,其实很早就有人说过,股市有风险,投资需谨慎。不过如果能有一个比较适合的模型进行预测就好了。今天我介绍一下,时间序列预测分析。
    本人也是深度循环网络的小白,所以也算是与大家共勉了哈。有问题还希望大家多多指正。闲话少说,上代码
    首先先读入numpy中的数据准备作为data
    test_input_array.py

    # coding: utf-8
    from __future__ import print_function
    import numpy as np
    import matplotlib
    matplotlib.use('agg')
    import matplotlib.pyplot as plt
    import tensorflow as tf
    from tensorflow.contrib.timeseries.python.timeseries import  NumpyReader
    
    
    x = np.array(range(1000))
    noise = np.random.uniform(-0.2, 0.2, 1000)
    y = np.sin(np.pi * x / 100) + x / 200. + noise
    plt.plot(x, y)
    plt.savefig('timeseries_y.jpg')
    
    data = {
        tf.contrib.timeseries.TrainEvalFeatures.TIMES: x,
        tf.contrib.timeseries.TrainEvalFeatures.VALUES: y,
    }
    
    reader = NumpyReader(data)
    
    with tf.Session() as sess:
        full_data = reader.read_full()
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        print(sess.run(full_data))
        coord.request_stop()
    
    train_input_fn = tf.contrib.timeseries.RandomWindowInputFn(
        reader, batch_size=2, window_size=10)
    
    with tf.Session() as sess:
        batch_data = train_input_fn.create_batch()
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        one_batch = sess.run(batch_data[0])
        coord.request_stop()
    
    print('one_batch_data:', one_batch)
    
    

    读入Excel中的数据,适用于数据较大的情况
    test_input_csv.py

    # coding: utf-8
    from __future__ import print_function
    import tensorflow as tf
    import os
    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    
    csv_file_name = './data/period_trend.csv'
    reader = tf.contrib.timeseries.CSVReader(csv_file_name)
    
    with tf.Session() as sess:
        data = reader.read_full()
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        print(sess.run(data))
        coord.request_stop()
    
    train_input_fn = tf.contrib.timeseries.RandomWindowInputFn(reader, batch_size=4, window_size=16)
    with tf.Session() as sess:
        data = train_input_fn.create_batch()
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)
        batch1 = sess.run(data[0])
        batch2 = sess.run(data[0])
        coord.request_stop()
    
    print('batch1:', batch1)
    print('batch2:', batch2)
    
    

    采用AR自回归模型进行预测
    train_array.py

    # coding: utf-8
    from __future__ import print_function
    import numpy as np
    import matplotlib
    matplotlib.use('agg')
    import matplotlib.pyplot as plt
    import tensorflow as tf
    from tensorflow.contrib.timeseries.python.timeseries import  NumpyReader
    
    
    def main(_):
        x = np.array(range(1000))
        noise = np.random.uniform(-0.2, 0.2, 1000)
        y = np.sin(np.pi * x / 100) + x / 200. + noise
        plt.plot(x, y)
        plt.savefig('timeseries_y.jpg')
    
        data = {
            tf.contrib.timeseries.TrainEvalFeatures.TIMES: x,
            tf.contrib.timeseries.TrainEvalFeatures.VALUES: y,
        }
    
        reader = NumpyReader(data)
    
        train_input_fn = tf.contrib.timeseries.RandomWindowInputFn(
            reader, batch_size=16, window_size=40)
    
        ar = tf.contrib.timeseries.ARRegressor(
            periodicities=200, input_window_size=30, output_window_size=10,
            num_features=1,
            loss=tf.contrib.timeseries.ARModel.NORMAL_LIKELIHOOD_LOSS)
    
        ar.train(input_fn=train_input_fn, steps=6000)
    
        evaluation_input_fn = tf.contrib.timeseries.WholeDatasetInputFn(reader)
        # keys of evaluation: ['covariance', 'loss', 'mean', 'observed', 'start_tuple', 'times', 'global_step']
        evaluation = ar.evaluate(input_fn=evaluation_input_fn, steps=1)
    
        (predictions,) = tuple(ar.predict(
            input_fn=tf.contrib.timeseries.predict_continuation_input_fn(
                evaluation, steps=250)))
    
        plt.figure(figsize=(15, 5))
        plt.plot(data['times'].reshape(-1), data['values'].reshape(-1), label='origin')
        plt.plot(evaluation['times'].reshape(-1), evaluation['mean'].reshape(-1), label='evaluation')
        plt.plot(predictions['times'].reshape(-1), predictions['mean'].reshape(-1), label='prediction')
        plt.xlabel('time_step')
        plt.ylabel('values')
        plt.legend(loc=4)
        plt.savefig('predict_result.jpg')
    
    
    if __name__ == '__main__':
        tf.logging.set_verbosity(tf.logging.INFO)
        tf.app.run()
    
    

    以下是AR模型的概念;
    AR模型描述在同一样本期间内的n个变量(内生变量)可以作为它们过去值的线性函数。
    例1.Yt = α+βXt-1 + ut, t = 1,2,…,n
    本例中Y的现期值与X的一期滞后值相联系,比较一般的情况是:
    Yt = α+β0Xt +β1Xt-1 +……+βsXt-s + ut,
    t = 1,2,…,n
    即Y的现期值不仅依赖于X的现期值,而且依赖于X的若干期滞后值。这类模型称为分布滞后模型,因为X变量的影响分布于若干周期。
    例2.Yt = α+βYt-1 + ut, t = 1,2,…,n
    本例中Y的现期值与它自身的一期滞后值相联系,即依赖于它的过去值。一般情况可能是:
    Yt = f (Yt-1, Yt-2, … , X2t, X3t, … )
    即Y的现期值依赖于它自身若干期滞后值,还依赖于其它解释变量。

    train_lstm.py
    采用LSTM网络进行模型的迭代后进行推理预测

    
    from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    
    from os import path
    
    import numpy as np
    import tensorflow as tf
    import os
    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    
    from tensorflow.contrib.timeseries.python.timeseries import estimators as ts_estimators
    from tensorflow.contrib.timeseries.python.timeseries import model as ts_model
    from tensorflow.contrib.timeseries.python.timeseries import NumpyReader
    
    import matplotlib
    matplotlib.use("agg")
    import matplotlib.pyplot as plt
    
    
    class _LSTMModel(ts_model.SequentialTimeSeriesModel):
      """A time series model-building example using an RNNCell."""
    
      def __init__(self, num_units, num_features, dtype=np.float32):
        """Initialize/configure the model object.
        Note that we do not start graph building here. Rather, this object is a
        configurable factory for TensorFlow graphs which are run by an Estimator.
        Args:
          num_units: The number of units in the model's LSTMCell.
          num_features: The dimensionality of the time series (features per
            timestep).
          dtype: The floating point data type to use.
        """
        super(_LSTMModel, self).__init__(
            # Pre-register the metrics we'll be outputting (just a mean here).
            train_output_names=["mean"],
            predict_output_names=["mean"],
            num_features=num_features,
            dtype=dtype)
        self._num_units = num_units
        # Filled in by initialize_graph()
        self._lstm_cell = None
        self._lstm_cell_run = None
        self._predict_from_lstm_output = None
    
      def initialize_graph(self, input_statistics):
        """Save templates for components, which can then be used repeatedly.
        This method is called every time a new graph is created. It's safe to start
        adding ops to the current default graph here, but the graph should be
        constructed from scratch.
        Args:
          input_statistics: A math_utils.InputStatistics object.
        """
        super(_LSTMModel, self).initialize_graph(input_statistics=input_statistics)
        self._lstm_cell = tf.nn.rnn_cell.LSTMCell(num_units=self._num_units)
        # Create templates so we don't have to worry about variable reuse.
        self._lstm_cell_run = tf.make_template(
            name_="lstm_cell",
            func_=self._lstm_cell,
            create_scope_now_=True)
        # Transforms LSTM output into mean predictions.
        self._predict_from_lstm_output = tf.make_template(
            name_="predict_from_lstm_output",
            func_=lambda inputs: tf.layers.dense(inputs=inputs, units=self.num_features),
            create_scope_now_=True)
    
      def get_start_state(self):
        """Return initial state for the time series model."""
        return (
            # Keeps track of the time associated with this state for error checking.
            tf.zeros([], dtype=tf.int64),
            # The previous observation or prediction.
            tf.zeros([self.num_features], dtype=self.dtype),
            # The state of the RNNCell (batch dimension removed since this parent
            # class will broadcast).
            [tf.squeeze(state_element, axis=0)
             for state_element
             in self._lstm_cell.zero_state(batch_size=1, dtype=self.dtype)])
    
      def _transform(self, data):
        """Normalize data based on input statistics to encourage stable training."""
        mean, variance = self._input_statistics.overall_feature_moments
        return (data - mean) / variance
    
      def _de_transform(self, data):
        """Transform data back to the input scale."""
        mean, variance = self._input_statistics.overall_feature_moments
        return data * variance + mean
    
      def _filtering_step(self, current_times, current_values, state, predictions):
        """Update model state based on observations.
        Note that we don't do much here aside from computing a loss. In this case
        it's easier to update the RNN state in _prediction_step, since that covers
        running the RNN both on observations (from this method) and our own
        predictions. This distinction can be important for probabilistic models,
        where repeatedly predicting without filtering should lead to low-confidence
        predictions.
        Args:
          current_times: A [batch size] integer Tensor.
          current_values: A [batch size, self.num_features] floating point Tensor
            with new observations.
          state: The model's state tuple.
          predictions: The output of the previous `_prediction_step`.
        Returns:
          A tuple of new state and a predictions dictionary updated to include a
          loss (note that we could also return other measures of goodness of fit,
          although only "loss" will be optimized).
        """
        state_from_time, prediction, lstm_state = state
        with tf.control_dependencies(
                [tf.assert_equal(current_times, state_from_time)]):
          transformed_values = self._transform(current_values)
          # Use mean squared error across features for the loss.
          predictions["loss"] = tf.reduce_mean(
              (prediction - transformed_values) ** 2, axis=-1)
          # Keep track of the new observation in model state. It won't be run
          # through the LSTM until the next _imputation_step.
          new_state_tuple = (current_times, transformed_values, lstm_state)
        return (new_state_tuple, predictions)
    
      def _prediction_step(self, current_times, state):
        """Advance the RNN state using a previous observation or prediction."""
        _, previous_observation_or_prediction, lstm_state = state
        lstm_output, new_lstm_state = self._lstm_cell_run(
            inputs=previous_observation_or_prediction, state=lstm_state)
        next_prediction = self._predict_from_lstm_output(lstm_output)
        new_state_tuple = (current_times, next_prediction, new_lstm_state)
        return new_state_tuple, {"mean": self._de_transform(next_prediction)}
    
      def _imputation_step(self, current_times, state):
        """Advance model state across a gap."""
        # Does not do anything special if we're jumping across a gap. More advanced
        # models, especially probabilistic ones, would want a special case that
        # depends on the gap size.
        return state
    
      def _exogenous_input_step(
              self, current_times, current_exogenous_regressors, state):
        """Update model state based on exogenous regressors."""
        raise NotImplementedError(
            "Exogenous inputs are not implemented for this example.")
    
    
    if __name__ == '__main__':
      tf.logging.set_verbosity(tf.logging.INFO)
      x = np.array(range(600))
      noise = np.random.uniform(-0.2, 0.2, 600)
      y = np.sin(np.pi * x / 50 ) + np.cos(np.pi * x / 50) + np.sin(np.pi * x / 25) + noise
    
      data = {
          tf.contrib.timeseries.TrainEvalFeatures.TIMES: x,
          tf.contrib.timeseries.TrainEvalFeatures.VALUES: y,
      }
    
      reader = NumpyReader(data)
    
      train_input_fn = tf.contrib.timeseries.RandomWindowInputFn(
          reader, batch_size=4, window_size=100)
    
      estimator = ts_estimators.TimeSeriesRegressor(
          model=_LSTMModel(num_features=1, num_units=128),
          optimizer=tf.train.AdamOptimizer(0.005))
    
      estimator.train(input_fn=train_input_fn, steps=2000)
      evaluation_input_fn = tf.contrib.timeseries.WholeDatasetInputFn(reader)
      evaluation = estimator.evaluate(input_fn=evaluation_input_fn, steps=1)
      # Predict starting after the evaluation
      (predictions,) = tuple(estimator.predict(
          input_fn=tf.contrib.timeseries.predict_continuation_input_fn(
              evaluation, steps=600)))
    
      observed_times = evaluation["times"][0]
      observed = evaluation["observed"][0, :, :]
      evaluated_times = evaluation["times"][0]
      evaluated = evaluation["mean"][0]
      predicted_times = predictions['times']
      predicted = predictions["mean"]
    
      plt.figure(figsize=(15, 5))
      plt.axvline(599, linestyle="dotted", linewidth=4, color='r')
      observed_lines = plt.plot(observed_times, observed, label="observation", color="k")
      evaluated_lines = plt.plot(evaluated_times, evaluated, label="evaluation", color="g")
      predicted_lines = plt.plot(predicted_times, predicted, label="prediction", color="r")
      plt.legend(handles=[observed_lines[0], evaluated_lines[0], predicted_lines[0]],
                 loc="upper left")
      plt.savefig('predict_result.jpg')
    
    

    最终效果如下:
    在这里插入图片描述
    完整的代码已经开源在本人的GitHub上,可以自己进行下载哈,同时在GitHub上的账号上有基于多重元素的LSTM时间序列预测以及读取文件中的data数据,欢迎star,哈哈
    GitHub地址:https://github.com/qianyuqianxun-DeepLearning/LSTM-process

    展开全文
  • 自回归AR模型

    千次阅读 2020-04-28 14:38:27
    1. 自回归模型的定义 2. AR模型的状态空间形式 3. AR模型的求解 4. AR模型示例 5 Python对模型参数的求解
    1. 自回归模型的定义
      自回归模型(Autoregressive Model)是用自身做回归变量的过程,即利用前期若干时刻的随机变量的线性组合来描述以后某时刻随机变量的线性回归模型[1],它是时间序列中的一种常见形式[2]。
      在这里插入图片描述

    2. AR模型的状态空间形式(AR-Process in State Space Form)
      AR模型可以写成状态空间模型的形式[4] [5] [6],令:
      在这里插入图片描述

    3. AR模型的求解
      AR模型可以采用Yule-Walker方程的形式进行求解[3]。考虑p阶AR模型有相应的AR特征多项式和相应的AR特征方程:
      在这里插入图片描述
      在这里插入图片描述

    4. AR模型示例
      在这里插入图片描述

    5 Python对模型参数的求解
      这里加上一点自己在运用模型时的感受,在实际我在运用AR模型进行时序数据的预测时,最常见有两个板块:
    (一)AR 模型的判定:
      这一部分的主要任务是,判断该问题是否适用 AR 模型建模,以及大致确定阶数 p。
    如果一个时间序列满足以下两个条件:

    1. ACF 具有拖尾性,即 ACF(k) 不会在 k 大于某个常数之后就恒等于 0。
    2. PACF 具有截尾性,即 PACF(k) 在 k>p 时变为 0。

    第 2 个条件还可以用来确定阶数 p。考虑到存在随机误差的存在,因此 PACF 在 p 阶延迟后未必严格为 0 ,而是在 0 附近的小范围内波动。
    例如:
    在这里插入图片描述
    从图中可以看出:1, 2, 4, 8, 20 都可以采用, 进一步理解就是要采用多少阶的模型比如AR(1), AR(2)….但是有一点,从AR模型公式看,当阶越大,数据处理难度越高。

    (二) AR 模型的参数估计:
    1. 模型的有效性检验: 
      一个好的拟合模型应该能够提取观测值序列中几乎所有的样本相关信息,即残差序列应该为白噪声序列。因此,模型的有效性检验即为残差序列的白噪声检验。如果残差序列是白噪声,那么理论赏其延迟任意阶的自相关系数为 0,考虑数据的偏差,那么绝大多数应该在 0 附近的范围内,通常在 95% 的置信水平(2倍标准差)以内。
    2. 参数的显著性检验
      这一部分的目标是,删除那些不显著参数使模型结构最为精简。对于模型参数 aj(j=1,…,p) 的检验,其原假设和备择假设分别为
      在这里插入图片描述
      检验统计量为 t 统计量:
      在这里插入图片描述
    在给定的显著水平 α 下,当检验统计量 T 大部分位于分点 t 1 − α / 2 t_1-α/2 t1α/2,或该统计量的 P 值小于 α 时,则可以以 1-α 的置信水平拒绝原假设,认为模型参数显著。反之,则不能显著拒绝参数为 0 的假设。
    通过python程序可以得到:

    import matplotlib.pyplot as plt
    import pandas as pd
    from statsmodels.tsa.stattools import adfuller
    from statsmodels.graphics.tsaplots import plot_acf  #自相关图
    
    
    def adf_test(ts):
        '''
            参数值:
            1.t统计量的值
            2.t统计量的P3.延迟阶数
            4.ADF回归和计算的观测值的个数
            5.配合第一个一起看的,是在99%95%90%置信区间下的临界的ADF检验的值
        '''
        adftest = adfuller(ts, autolag='AIC')
        adf_res = pd.Series(adftest[0:4],
                            index=['Test Statistic','p-value','Lags Used','Number of Observations Used'])
    
        for key, value in adftest[4].items():
            adf_res['Critical Value (%s)' % key] = value
        return adf_res
    
    inputfile = 'D:/Python/Python_learning/Mach_model/AR_model/data.xlsx' #销量及其他属性数据
    data = pd.read_excel(inputfile, index_col = u'时间')
    
    #发现图片有明显的递增趋势,可以判断是非平稳的序列
    data_drop = data.dropna()  #将数据data dropna()
    plot_acf(data_drop) #自相关图
    plt.show()
    
    adf_res = adf_test(data)
    print(adf_res)

    程序结果:
    运用AR模型后的参数

    Test Statistic                  1.816580
    p-value                         0.998381
    Lags Used                      10.000000
    Number of Observations Used    26.000000
    Critical Value (10%)           -2.630095
    Critical Value (5%)            -2.981247
    Critical Value (1%)            -3.711212
    dtype: float64

    从模型中可以看出“Lags Used ”也就是延迟阶数为:10,算是比较大的阶数。
    同时,可以绘制出它的自相关图:
    在这里插入图片描述

    展开全文
  • 这是一个相关法求AR模型谱估计的matlab程序。
  • 自回归模型(AR)预测时间序列的依据是什么?
  • AR极大似然函数的含义: h表示使用transformer或RNN模型单向传递来的上文context representation。maximize probability of xt given x1:t-1就是maximize softmax(hT e(xt)), x’是所有xt的可能,即vocabulary里的...
  • 时间序列之AR(自回归模型)

    千次阅读 2019-02-10 13:37:40
    时间序列之AR(自回归模型)
  • 比如自回归(Autoregressive,AR)语言模型和编码(autoencoding)模型等,这可能让不少人感到困惑。 ***自回归***是时间序列分析或者信号处理领域喜欢用的一个术语,我们这里理解成语言模型就好了。一个句子的生成...
  • 含注释,参数模型功率谱估计AR模型相关法仿真,原理来自《数字信号处理理论、算法与实现》第三版:P545-P547
  • 自回归模型(AR Model)

    万次阅读 多人点赞 2017-04-07 12:04:56
     自回归模型(Autoregressive Model)是用自身做回归变量的过程,即利用前期若干时刻的随机变量的线性组合来描述以后某时刻随机变量的线性回归模型[1],它是时间序列中的一种常见形式[2]。 2. AR模型的
  • 根据序列选模型(自回归AR模型、向量自回归VAR模型等)
  • AR模型功率谱估计的典型算法比较及MATLAB实现.pdf
  • 各类回归的python实现

    2018-03-14 15:40:10
    各种类型回归的python实现代码,附带数据,可运行,代码清晰完整,适用于python初学者
  • SVD方法是对Yule-Walker方程中的相关矩阵进行SVD分解来实现的,在MATLAB工具箱中arorder函数就是使用的该算法。其他五种算法的基本思想都是建立目标函数,阶次估计的标准是使目标函数最小化。 以上定阶准则...
  • AR模型的参数及阶数估计的MATLAB代码原创-estimate_AR.m 我附上的是我最近自己编写的R模型的参数及阶数估计,利用的是L-D算法解Y-W方程法,里面有相关注释。对学习随机信号的同学,应该有用。:)
  • 自回归模型到分析过程,AR.rar )灰色预测模型哈,自己看看,应该不难啊。
  • AR模型的matlab实现

    2018-02-11 11:54:56
    AR模型的初步学习,可以运行出结果,非常适合初学者使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,113
精华内容 3,245
关键字:

ar自回归