精华内容
下载资源
问答
  • 本文将介绍使用Python来完成时间序列分析ARIMA模型的完整步骤与流程 时间序列分析基础 在这里插入图片描述 文章目录 时间序列分析概念 建立模型基本步骤 ARIMA模型建模实战 导入模块 加载数据 平稳性检验 时序...
    本文将介绍使用Python来完成时间序列分析ARIMA模型的完整步骤与流程
    
    时间序列分析基础
    

    在这里插入图片描述
    文章目录

    时间序列分析概念
    建立模型基本步骤
    ARIMA模型建模实战
        导入模块
        加载数据
        平稳性检验
            时序图
            单位根检验
        白噪声检验
        模型定阶
        模型优化
        参数估计
        模型检验
            参数的显著性检验
            模型的显著性检验
        模型预测
    

    时间序列分析概念

    时间序列分析 是统计学中的一个非常重要的分支,是以概率论与数理统计为基础、计算机应用为技术支撑,迅速发展起来的一种应用性很强的科学方法。时间序列是变量按时间间隔的顺序而下形成的随机变量序列,大量自然界、社会经济等领域的统计指标都依年、季、月或日统计其指标值,随着时间的推移,形成了统计指标的时间序列,例如,股价指数、物价指数、GDP和产品销售量等等都属于时间序列。
    

    建立模型基本步骤

    在这里插入图片描述
    ARIMA模型建模实战
    导入模块

    小白可以参考我哦
    

    import sys
    import os
    import pandas as pd
    import numpy as np
    import statsmodels.api as sm
    import statsmodels.formula.api as smf
    import statsmodels.tsa.api as smt
    from statsmodels.tsa.stattools import adfuller
    from statsmodels.stats.diagnostic import acorr_ljungbox
    from statsmodels.graphics.api import qqplot
    import matplotlib.pylab as plt
    from matplotlib.pylab import style
    style.use(‘ggplot’)
    from arch.unitroot import ADF
    import warnings
    warnings.filterwarnings(“ignore”)
    pd.set_option(‘display.float_format’, lambda x: ‘%.5f’ % x)
    np.set_printoptions(precision=5, suppress=True)
    pd.set_option(‘display.max_columns’, 100)
    pd.set_option(‘display.max_rows’, 100)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    

    %matplotlib inline
    “”“中文显示问题”""
    plt.rcParams[‘font.family’] = [‘sans-serif’]
    plt.rcParams[‘font.sans-serif’] = [‘SimHei’]

    1
    2
    3
    4
    

    加载数据

    data = pd.read_excel(“data.xlsx”,index_col=“年份”,parse_dates=True)
    data.head()

    1
    2
    
    xt
    

    年份
    1952-01-01 100.00000
    1953-01-01 101.60000
    1954-01-01 103.30000
    1955-01-01 111.50000
    1956-01-01 116.50000
    平稳性检验
    时序图

    data[“diff1”] = data[“xt”].diff(1).dropna()
    data[“diff2”] = data[“diff1”].diff(1).dropna()
    “”“由于差分后会有缺失值,使用该方法需要填充缺失值”""

    data1 = data.loc[:,[“xt”,“diff1”,“diff2”]]

    data1.plot(subplots=True, figsize=(18, 12),title=“差分图”)

    fig = plt.figure(figsize=(20,6))
    ax1 = fig.add_subplot(131)
    ax1.plot(data[‘xt’],label=“原序列”)
    plt.legend()
    ax2 = fig.add_subplot(132)
    ax2.plot(data[‘diff1’].dropna().dropna(),label=“一阶差分”)
    plt.legend()
    ax3 = fig.add_subplot(133)
    ax3.plot(data[‘diff2’].dropna(),label=“二阶差分”)
    plt.legend(loc=“upper left”)
    plt.show()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    

    序列图

    时序图检验 - - 全靠肉眼的判断和判断人的经验,不同的人看到同样的图形,很可能会给出不同的判断。因此我们需要一个更有说服力、更加客观的统计方法来帮助我们检验时间序列的平稳性,这种方法,就是单位根检验。
    单位根检验

    print(“单位根检验:\n”)
    print(ADF(data.diff1.dropna()))

    1
    2
    

    单位根检验:

    Augmented Dickey-Fuller Results

    Test Statistic -3.156
    P-value 0.023
    Lags 0

    Trend: Constant
    Critical Values: -3.63 (1%), -2.95 (5%), -2.61 (10%)
    Null Hypothesis: The process contains a unit root.
    Alternative Hypothesis: The process is weakly stationary.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    

    单位根检验 - -对其一阶差分进行单位根检验,得到:1%、%5、%10不同程度拒绝原假设的统计值和ADF Test result的比较,本数据中,P-value 为 0.023,接近0,ADF Test result同时小于5%、10%即说明很好地拒绝该假设,本数据中,ADF结果为-3.156,拒绝原假设,即一阶差分后数据是平稳的。
    白噪声检验

    判断序列是否为非白噪声序列
    

    from statsmodels.stats.diagnostic import acorr_ljungbox
    acorr_ljungbox(data.diff1.dropna(), lags = [i for i in range(1,12)],boxpierce=True)

    1
    2
    

    (array([11.30402, 13.03896, 13.37637, 14.24184, 14.6937 , 15.33042,
    16.36099, 16.76433, 18.15565, 18.16275, 18.21663]),
    array([0.00077, 0.00147, 0.00389, 0.00656, 0.01175, 0.01784, 0.02202,
    0.03266, 0.03341, 0.05228, 0.07669]),
    array([10.4116 , 11.96391, 12.25693, 12.98574, 13.35437, 13.85704,
    14.64353, 14.94072, 15.92929, 15.93415, 15.9696 ]),
    array([0.00125, 0.00252, 0.00655, 0.01135, 0.02027, 0.03127, 0.04085,
    0.06031, 0.06837, 0.10153, 0.14226]))

    1
    2
    3
    4
    5
    6
    7
    8
    

    通过P<α,拒绝原假设,故差分后的序列是平稳的非白噪声序列,可以进行下一步建模
    模型定阶

    现在我们已经得到一个平稳的时间序列,接来下就是选择合适的ARIMA模型,即ARIMA模型中合适的p,q。
    第一步我们要先检查平稳时间序列的自相关图和偏自相关图。通过sm.graphics.tsa.plot_acf和sm.graphics.tsa.plot_pacf得到图形
    

    在这里插入图片描述

    从一阶差分序列的自相关图和偏自相关图可以发现:
    
    自相关图拖尾或一阶截尾
    偏自相关图一阶截尾,
    
    所以我们可以建立ARIMA(1,1,0)、ARIMA(1,1,1)、ARIMA(0,1,1)模型。
    

    模型优化

    在这里插入图片描述

    其中L是在该模型下的最大似然,n是数据数量,k是模型的变量个数。
    python代码如下:
    

    arma_mod20 = sm.tsa.ARIMA(data[“xt”],(1,1,0)).fit()
    arma_mod30 = sm.tsa.ARIMA(data[“xt”],(0,1,1)).fit()
    arma_mod40 = sm.tsa.ARIMA(data[“xt”],(1,1,0)).fit()
    values = [[arma_mod20.aic,arma_mod20.bic,arma_mod20.hqic],[arma_mod30.aic,arma_mod30.bic,arma_mod30.hqic],[arma_mod40.aic,arma_mod40.bic,arma_mod40.hqic]]
    df = pd.DataFrame(values,index=[“AR(1,1,0)”,“MA(0,1,1)”,“ARMA(1,1,0)”],columns=[“AIC”,“BIC”,“hqic”])
    df

    1
    2
    3
    4
    5
    6
    
    AIC	BIC	hqic
    

    AR(1,1,0) 253.09159 257.84215 254.74966
    MA(0,1,1) 251.97340 256.72396 253.63147
    ARMA(1,1,0) 253.09159 257.84215 254.74966

    构造这些统计量所遵循的统计思想是一致的,就是在考虑拟合残差的同时,依自变量个数施加“惩罚”。但要注意的是,这些准则不能说明某一个模型的精确度,也即是说,对于三个模型A,B,C,我们能够判断出B模型是最好的,但不能保证B模型能够很好地刻画数据
    

    参数估计

    from statsmodels.tsa.arima_model import ARIMA
    model = ARIMA(data[“xt”], order=(0,1,1))
    result = model.fit()
    print(result.summary())

    1
    2
    3
    4
    
                             ARIMA Model Results                              
    

    ==============================================================================
    Dep. Variable: D.xt No. Observations: 36
    Model: ARIMA(0, 1, 1) Log Likelihood -122.987
    Method: css-mle S.D. of innovations 7.309
    Date: Tue, 22 Dec 2020 AIC 251.973
    Time: 09:11:55 BIC 256.724
    Sample: 01-01-1953 HQIC 253.631
    - 01-01-1988

                 coef    std err          z      P>|z|      [0.025      0.975]
    

    const 4.9956 2.014 2.481 0.013 1.048 8.943
    ma.L1.D.xt 0.6710 0.165 4.071 0.000 0.348 0.994
    Roots

                  Real          Imaginary           Modulus         Frequency
    

    MA.1 -1.4902 +0.0000j 1.4902 0.5000

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    

    模型检验

    在这里插入图片描述
    参数的显著性检验

    参数检验
    在这里插入图片描述

    P<α,拒绝原假设,认为该参数显著非零MA(2)模型拟合该序列,残差序列已实现白噪声
    

    模型的显著性检验

    模型的显著性检验

    resid = result.resid#残差
    fig = plt.figure(figsize=(12,8))
    ax = fig.add_subplot(111)
    fig = qqplot(resid, line=‘q’, ax=ax, fit=True)

    1
    2
    3
    4
    

    在这里插入图片描述

    qq图显示,我们看到红色的KDE线与N(0,1)平行,这是残留物正太分布的良好指标,说明残差序列是白噪声序列,模型的信息的提取充分,当让大家也可以使用前面介绍的检验白噪声的方法LB统计量来检验

    ARIMA(0,1,1)模型拟合该序列,残差序列已实现白噪声,且参数均显著非零。说明AR(0,11)模型是该序列的有效拟合模型
    

    模型预测

    pred = result.predict(‘1988’, ‘1990’,dynamic=True, typ=‘levels’)
    print (pred)

    1
    2
    

    1988-01-01 278.35527
    1989-01-01 283.35088
    1990-01-01 288.34649
    Freq: AS-JAN, dtype: float64

    1
    2
    3
    4
    

    plt.figure(figsize=(12, 8))
    plt.xticks(rotation=45)
    plt.plot(pred)
    plt.plot(data.xt)
    plt.show()

    1
    2
    3
    4
    5
    

    在这里插入图片描述

    到这里就结束了,如果对你有帮助你,欢迎点赞关注,你的点赞对我很重要
    

    关注博主即可阅读全文

    展开全文
  • 你是否想要做时间序列分析,但却不知道代码怎么写?你是否不清楚时间序列分析各种...做Data Scientist,记得刚入职时,老板就跟我说未来我的主要任务是用各种类型的时间序列模型预测预测好莱坞游览车未来三年每...

    bf0d006a51ed642c9d3c2122911e3eed.png

    你是否想要做时间序列分析,但却不知道代码怎么写?

    你是否不清楚时间序列分析各种模型该在什么情况下使用?

    本文将针对以上两个问题,带你入门时间序列分析~

    等等!

    不止’入门‘

    读完这篇,你立即就能在R中写出不同模型的相应代码~

    先介绍以下我自己吧~

    我目前是Warner Bros.做Data Scientist,记得刚入职时,老板就跟我说未来我的主要任务是用各种类型的时间序列模型做预测:预测好莱坞游览车未来三年每天的乘客数量、预测<Aquaman>, <Joker>,<Wonder Women>等华纳出品的电影每分钟的观看量,预估艾伦秀不同播出计划的未来收视率和收入等等等等~~~

    刚入职的第一个月每天愁眉不展,时间序列的方法很多,很多时候,即使理论基础学懂了,但是到实践上,R里的code要怎么写又是个大问题,网上的很多教程,教授了公式,却不教授具体的代码怎么写。

    幸运的是,老板是个比较技术咖的人,他教会了我很多实际操作上的东西,结合我过去七个月做过的各种时间序列模型,决定好好总结一下时间序列常见模型各自的适用场合、特征等理论知识,更重要的是,每个模型在R里的具体代码实现以及操作步骤,希望能帮助到需要使用R来做时间序列的朋友们~


    时间序列数据是在一段时间内作为时间间隔序列收集的数据点。时间序列数据分析意味着对可用数据进行分析,以找出数据的模式或趋势,从而预测一些将来的价值,这些价值将有助于提高效率并优化业务决策。

    常见的用于时间序列分析的技术:

    • ARIMA模型
    • 指数平滑模型

    本篇将介绍 - ARIMA模型在R中如何使用


    ARIMA建模

    ARIMA是AutoRegressive集成移动平均线的缩写。自回归(AR)项是指差分序列的滞后,移动平均(MA)项是指误差的滞后,而I是用于使时间序列平稳的差分数。

    ARIMA模型假设

    • 数据平稳 – 这意味着数据的变化不依赖于时间变化。白噪声序列和具有循环特性的序列也可以视为平稳序列。
    • 数据应为单变量– ARIMA处理单个变量。自动回归就是关于过去值的回归。

    (PS: 对于有外部变量的数据,可以使用ARIMAX模型,这个将在下一篇中介绍)

    以下步骤1~5,很重要!很重要!!

    ARIMA建模要遵循的步骤

    1. 将数据集转化为时间序列格式
    2. 作图分析数据
    3. 确定p,d,q
    4. 拟合模型
    5. 做出预测

    下面将根据建模步骤来介绍R中code

    首先,导入需要用到的包:

    library(ggplot2) #作图

    library(forecast) #建模

    library(dplyr) # 数据处理

    library(lubridate) # 时间处理

    1. 将数据集转化为时间序列格式

    使用R进行时间序列数据建模的第一步是将数据转换为时间序列数据格式。为此,我们需要在R中运行以下命令:

    wbstl_weekly_data_ts = ts(wbstl_weekly_data$weekly_totalgross,frequency = 365.25/12,

    start= decimal_date(ymd('2011-01-01')))

    • wbstl_weekly_data$weekly_totalgross是我们要转换为时间序列的单变量数据
    • start给出数据的开始时间,在本例中为2011年1月。
    • frequency是数据的频率。由于它是月度数据,所以'frequency = 12'。(每周的数据,则frequency=52; daily data,则frequency=365.25)

    2. 作图分析数据

    ggplot(wbstl_weekly_data, aes(x =month, y = weekly_totalgross)) + geom_line()

    这是数据的样子:

    750de72a3501c65aa346f0a97e411037.png

    我们可以从图本身推断出,数据点遵循总体上升趋势,但在突然降低的值方面有一些异常值。现在,我们需要进行一些分析,以找出数据中确切的非平稳性和季节性。

    3. 确定p,d,q

    数据准备就绪并满足所有建模假设后,要确定要拟合数据的模型的顺序,我们需要三个变量:p,d和q,它们是指代负顺序的非负整数。模型的自回归,积分和移动平均值部分。

    要找到合适的p和q值,我们需要使用acf()并pacf()。

    pacf()滞后k是自相关函数,它描述了相距k步的所有数据点之间的相关性-在考虑了它们与这k步之间的数据的相关性之后。它有助于识别ARIMA模型中的自回归(AR)系数(p值)的数量。

    acf(tsstationary,lag.max = 34)

    pacf(tsstationary,lag.max = 34)

    结果如下:

    ed187746c896e2661cef984d62115ed1.png


    ACF用以确认q, 图中可以看出q = 1

    PACF用以确认p = 2

    处理好了数据,下面 进入最重要的部分:模型拟合 + 预测

    4. 模型拟合

    fitARIMA <- arima(tsData, order=c(1,1,1),seasonal = list(order = c(1,0,0), period = 12),method="ML")

    order 指定ARIMA模型的非季节部分:(p,d,q)指AR阶,差异度和MA阶。

    seasonal指定ARIMA模型的季节性部分,加上周期(此处是月度数据,所以为12)。该函数需要一个包含组件顺序和周期的列表,但是给定长度为3的数字矢量,它将把它们变成一个合适的列表,其规格为“ order”。

    method表示拟合方法,可以是“最大似然(ML)”或“最小平方和(CSS)”。

    这是一个递归过程,我们需要arima()使用不同的(p,d,q)值运行此函数,以找到最优化和高效的模型。


    上述介绍的是怎么手动根据数据确定ARIMA模型中各参数,这边还有个懒人方法 (实践中更多也是使用该懒人方法 - auto.arima() )

    auto.arima()功能:
    预测程序包提供两个功能:ets()和auto.arima()用于自动选择指数模型和ARIMA模型。

    auto.arima()R中的函数结合了单位根测试,最小化AIC和MLE来获得ARIMA模型。

    KPSS检验用于确定差异数量(d)在Hyndman-Khandakar算法中,用于自动ARIMA建模。

    然后通过最小化AICc来选择p,d和q。该算法使用逐步搜索遍历模型空间,以选择具有最小AICc的最佳模型。

    如果d = 0,则常数c被包括在内;如果d≥1,则常数c设置为零。通过将当前模型的p和/或q改变±1并包括/排除当前模型中的c来考虑当前模型的变化。

    到目前为止考虑的最佳模型(当前模型或这些变体之一)成为新的当前模型。

    现在,重复此过程,直到找不到更低的AIC。

    auto.arima(tsData,seasonal.test="ch",

    parallel=TRUE,num.cores=8,stepwise=FALSE,approximation=FALSE)

    该行code,运行时间较长,上周我用了1140个数据点,运行了1.5hr

    5. 使用ARIMA模型进行预测

    一旦为时间序列数据选择了最合适的模型,该ARIMA模型的参数就可以用作预测模型来预测时间序列的未来值。

    使用predict()的函数 - 用于根据各种模型拟合函数的结果进行预测。它需要一个参数n.ahead()来指定要预测多少时间。

    predict (fitARIMA,h = 5)

    意思就是对未来5个月进行预测

    forecast.Arima()forecastR包中的函数还可用于预测时间序列的未来值。在这里,我们还可以使用level参数指定预测间隔的置信度。

    futurVal <-Forecast.Arima(fitARIMA,h = 10,level = c(99.5))plot.forecast(futurVal)

    我们需要确保预测误差不相关,正态分布为均值零和恒定方差。我们可以使用诊断方法找出具有最佳可能预测值的适当模型。

    e5d062f18d213a27cf2fd08c788c5c0a.png

    预测显示为蓝线,而99.5%置信度水平的预测间隔为浅阴影区域。

    这是整个过程,我们可以使用ARIMA分析时间序列数据和现有序列的预测值。

    总结一下:

    ARIMA建模要遵循的步骤

    1. 将数据集转化为时间序列格式
    2. 作图分析数据
    3. 确定p,d,q / 或只用auto.arima()
    4. 拟合模型
    5. 做出预测

    大家看完别忘了赞一个让更多人看到

    另外,欢迎关注我的专栏: 煮一锅数据汤

    专栏定期分享数据分析方面干货,如时间序列模型实践、机器学习模型讲解、R编程语言操作、SQL小白入门等

    煮一锅数据汤zhuanlan.zhihu.com
    dcc6031d025cb76c27cd5964d89eaddf.png
    展开全文
  • ARIMA模型 预测时间序列 JAVA实现

    千次阅读 2018-12-10 10:34:36
    最近要用ARIMA模型预测用户的数量变化,所以调研了一下ARIMA模型,最后用JAVA实现了ARIMA算法。 一、ARIMA原理 ARIMA的原理主要参考的是ARIMA原理。 二、JAVA实现 弄懂了原理,用JAVA进行了实现,主要参考的步骤...

    最近要用ARIMA模型预测用户的数量变化,所以调研了一下ARIMA模型,最后用JAVA实现了ARIMA算法。


    一、ARIMA原理

    ARIMA的原理主要参考的是ARIMA原理


    二、JAVA实现

    弄懂了原理,用JAVA进行了实现,主要参考的步骤是ARIMA实现步骤JAVA代码如下

    (1)AR类,用于构建AR模型
    package arima;
    import java.util.*;
     
    public class AR {
    	
    	double[] stdoriginalData={};
    	int p;
    	ARMAMath armamath=new ARMAMath();
    	
    	/**
    	 * AR模型
    	 * @param stdoriginalData
    	 * @param p //p为MA模型阶数
    	 */
    	public AR(double [] stdoriginalData,int p)
    	{
    		this.stdoriginalData=new double[stdoriginalData.length];
    		System.arraycopy(stdoriginalData, 0, this.stdoriginalData, 0, stdoriginalData.length);
    		this.p=p;
    	}
    /**
     * 返回AR模型参数
     * @return
     */
    	public Vector<double[]> ARmodel()
    	{
    		Vector<double[]> v=new Vector<double[]>();
    		v.add(armamath.parcorrCompute(stdoriginalData, p, 0));
    		return v;//得到了自回归系数
    	}
    	
    }
    

    (2)MA类,用于构建MA模型

    
    package arima;
    import java.util.Vector;
    import arima.ARMAMath;
    public class MA {
     
    	double[] stdoriginalData={};
    	int q;
    	ARMAMath armamath=new ARMAMath();
    	
    	/** MA模型
    	 * @param stdoriginalData //预处理过后的数据
    	 * @param q //q为MA模型阶数
    	 */
    	public MA(double [] stdoriginalData,int q)
    	{
    		this.stdoriginalData=new double[stdoriginalData.length];
    		System.arraycopy(stdoriginalData, 0, this.stdoriginalData, 0, stdoriginalData.length);
    		this.q=q;
    		
    	}
    /**
     * 返回MA模型参数
     * @return
     */
    	public Vector<double[]> MAmodel()
    	{
    		Vector<double[]> v=new Vector<double[]>();
    		v.add(armamath.getMApara(armamath.autocorGrma(stdoriginalData,q), q));
    		
    		return v;//拿到MA模型里面的参数值
    	}
    		
    	
    }
    
    

    (3)ARMA类,用于构建ARMA模型

    package arima;
    import java.util.*;
     
    public class ARMA {
    	
    	double[] stdoriginalData={};
    	int p;
    	int q;
    	ARMAMath armamath=new ARMAMath();
    	
    	/**
    	 * ARMA模型
    	 * @param stdoriginalData
    	 * @param p,q //p,q为MA模型阶数
    	 */
    	public ARMA(double [] stdoriginalData,int p,int q)
    	{
    		this.stdoriginalData=new double[stdoriginalData.length];
    		System.arraycopy(stdoriginalData, 0, this.stdoriginalData, 0, stdoriginalData.length);
    		this.p=p;
    		this.q=q;	
    	}
    	public Vector<double[]> ARMAmodel()
    	{
    		double[] arcoe=armamath.parcorrCompute(stdoriginalData, p, q);
    		double[] autocorData=getautocorofMA(p, q, stdoriginalData, arcoe);
    		double[] macoe=armamath.getMApara(autocorData, q);//得到MA模型里面的参数值
    		Vector<double[]> v=new Vector<double[]>();
    		v.add(arcoe);
    		v.add(macoe);
    		return v;
    	}
    	/**
    	 * 得到MA的自相关系数
    	 * @param p
    	 * @param q
    	 * @param stdoriginalData
    	 * @param autoCordata
    	 * @return
    	 */
    	public double[] getautocorofMA(int p,int q,double[] stdoriginalData,double[] autoRegress)
    	{
    		int temp=0;
    		double[] errArray=new double[stdoriginalData.length-p];
    		int count=0;
    		for(int i=p;i<stdoriginalData.length;i++)
    		{
    			temp=0;
    			for(int j=1;j<=p;j++)
    				temp+=stdoriginalData[i-j]*autoRegress[j-1];
    			errArray[count++]=stdoriginalData[i]-temp;//保存估计残差序列
    		}
    		return armamath.autocorGrma(errArray, q);
    	}
    }
    
    

    (4)ARIMA类,用于构建ARIMA模型

    package arima;
    import arima.ARMAMath;
    import java.util.*;
     
    public class ARIMA {
     
    	double[] originalData={};
    	double[] originalDatafirDif={};
    	double[] originalDatasecDif={};
    	double[] originalDatathiDif={};
    	double[] originalDataforDif={};
    	double[] originalDatafriDif={};
    	
    	ARMAMath armamath=new ARMAMath();
    	double stderrDara=0;
    	double avgsumData=0;
    	Vector<double[]> armaARMAcoe=new Vector<double[]>();
    	Vector<double[]> bestarmaARMAcoe=new Vector<double[]>();
    	int typeofPredeal=0;
    /**
     * 构造函数
     * @param originalData 原始时间序列数据
     */
    	public ARIMA(double [] originalData,int typeofPredeal)
    	{
    		this.originalData=originalData;
    		this.typeofPredeal=typeofPredeal;//数据预处理类型 1:一阶普通查分7:季节性差分
    	}
    /**
     * 原始数据标准化处理:一阶季节性差分
     * @return 差分过后的数据
     */ 
    	public double[] preDealDif(double[] originalData)
    	{
    		//seasonal Difference:Peroid=7
    		double []tempData=new double[originalData.length-7];
    		for(int i=0;i<originalData.length-7;i++)
    		{
    			tempData[i]=originalData[i+7]-originalData[i];
    		}
    		return tempData;
    	}
    	
    	
    /**
     * 
     */
    	public double[] preFirDif(double[] originalData) 
    	{
    		// Difference:Peroid=1
    		double []tempData=new double[originalData.length-1];
    		for(int i=0;i<originalData.length-1;i++)
    		{
    			tempData[i]=originalData[i+1]-originalData[i];
    		}
     
    		return tempData;
    	}
    	
    /**
     * 原始数据标准化处理:Z-Score归一化
     * @param 待处理数据
     * @return 归一化过后的数据
     */
    	public double[] preDealNor(double[] tempData)
    	{
    		//Z-Score
    		avgsumData=armamath.avgData(tempData);
    		stderrDara=armamath.stderrData(tempData);
    		
    		for(int i=0;i<tempData.length;i++)
    		{
    			tempData[i]=(tempData[i]-avgsumData)/stderrDara;
    		}
    		return tempData;
    	}
    	
    	public modelandpara getARIMAmodel(int[] bestmodel)
    	{
    		double[] stdoriginalData=null;
    		
    		if(typeofPredeal==0)
    			{
    				stdoriginalData=new double[originalData.length];
    				System.arraycopy(originalData, 0, stdoriginalData, 0,originalData.length);
    			}
    		else if(typeofPredeal==1)		//原始数据一阶普通差分处理
    			{
    				originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    				System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    		
    				stdoriginalData=new double[originalDatafirDif.length];
    				System.arraycopy(originalDatafirDif, 0, stdoriginalData, 0,originalDatafirDif.length);	
    			}
    		else if (typeofPredeal==2)
    			{
    				originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    				System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
     
    				originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    				System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
     
    				stdoriginalData=new double[originalDatasecDif.length];
    				System.arraycopy(originalDatasecDif, 0, stdoriginalData, 0,originalDatasecDif.length);	
    			}
    		else if(typeofPredeal==3)
    			{
    				originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    				System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    	
    				originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    				System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
     
    				originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    				System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    	
    				stdoriginalData=new double[originalDatathiDif.length];
    				System.arraycopy(originalDatathiDif, 0, stdoriginalData, 0,originalDatathiDif.length);	
     
    			}
    		else if(typeofPredeal==4)
    			{
    			
    				originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    				System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    	
    				originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    				System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    	
    				originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    				System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    	
    				originalDataforDif=new double[this.preFirDif(originalDatathiDif).length];
    				System.arraycopy(this.preFirDif(originalDatathiDif), 0, originalDataforDif, 0,originalDataforDif.length);	
     
    				stdoriginalData=new double[originalDataforDif.length];
    				System.arraycopy(originalDataforDif, 0, stdoriginalData, 0,originalDataforDif.length);	
     
    			}
    		else if(typeofPredeal==5)
    			{
    				originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    				System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    	
    				originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    				System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    	
    				originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    				System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    	
    				originalDataforDif=new double[this.preFirDif(originalDatathiDif).length];
    				System.arraycopy(this.preFirDif(originalDatathiDif), 0, originalDataforDif, 0,originalDataforDif.length);	
    				
    				originalDatafriDif=new double[this.preFirDif(originalDataforDif).length];
    				System.arraycopy(this.preFirDif(originalDataforDif), 0, originalDatafriDif, 0,originalDatafriDif.length);	
    				
    				stdoriginalData=new double[originalDatafriDif.length];
    				System.arraycopy(originalDatafriDif, 0, stdoriginalData, 0,originalDatafriDif.length);	
     
    			}
    		else//原始数据季节性差分处理	
    			{
    				stdoriginalData=new double[this.preDealDif(originalData).length];
    				System.arraycopy(this.preDealDif(originalData), 0, stdoriginalData, 0,this.preDealDif(originalData).length);	
    			}
    		
    		armaARMAcoe.clear();
    		bestarmaARMAcoe.clear();
    		
    		if(bestmodel[0]==0)
    		{
    			MA ma=new MA(stdoriginalData, bestmodel[1]);
    			armaARMAcoe=ma.MAmodel(); //拿到ma模型的参数
    			
    		}
    		else if(bestmodel[1]==0)
    		{
    			AR ar=new AR(stdoriginalData, bestmodel[0]);
    			armaARMAcoe=ar.ARmodel(); //拿到ar模型的参数
    			
    		}
    		else
    		{
    			ARMA arma=new ARMA(stdoriginalData, bestmodel[0], bestmodel[1]);
    			armaARMAcoe=arma.ARMAmodel();//拿到arma模型的参数
    			
    		}
    		
    		bestarmaARMAcoe=armaARMAcoe;
    		modelandpara mp=new modelandpara(bestmodel, bestarmaARMAcoe);
    		
    		return mp;
     	}
    /**
    * 得到ARMA模型=[p,q]
     * @return ARMA模型的阶数信息
     *//*
    	public modelandpara getARIMAmodel()
    	{
    		double[] stdoriginalData=null;
    		if(typeofPredeal==0)
    		{
    			stdoriginalData=new double[originalData.length];
    			System.arraycopy(originalData, 0, stdoriginalData, 0,originalData.length);
    		}
    	else if(typeofPredeal==1)		//原始数据一阶普通差分处理
    		{
    		
    			originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    			System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    	
    			stdoriginalData=new double[originalDatafirDif.length];
    			System.arraycopy(originalDatafirDif, 0, stdoriginalData, 0,originalDatafirDif.length);	
    		}
    	else if (typeofPredeal==2)
    		{
    			originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    			System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    			originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    			System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    			stdoriginalData=new double[originalDatasecDif.length];
    			System.arraycopy(originalDatasecDif, 0, stdoriginalData, 0,originalDatasecDif.length);	
    		}
    	else if(typeofPredeal==3)
    		{
    			originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    			System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    			originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    			System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    			originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    			System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    			stdoriginalData=new double[originalDatathiDif.length];
    			System.arraycopy(originalDatathiDif, 0, stdoriginalData, 0,originalDatathiDif.length);	
    		}
    	else if(typeofPredeal==4)
    		{
    			originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    			System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    			originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    			System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    			originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    			System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    			originalDataforDif=new double[this.preFirDif(originalDatathiDif).length];
    			System.arraycopy(this.preFirDif(originalDatathiDif), 0, originalDataforDif, 0,originalDataforDif.length);	
    			stdoriginalData=new double[originalDataforDif.length];
    			System.arraycopy(originalDataforDif, 0, stdoriginalData, 0,originalDataforDif.length);	
    		}
    	else if(typeofPredeal==5)
    		{
    			originalDatafirDif=new double[this.preFirDif(originalData).length];//原始数据一阶普通差分处理
    			System.arraycopy(this.preFirDif(originalData), 0, originalDatafirDif, 0,originalDatafirDif.length);	
    			originalDatasecDif=new double[this.preFirDif(originalDatafirDif).length];
    			System.arraycopy(this.preFirDif(originalDatafirDif), 0, originalDatasecDif, 0,originalDatasecDif.length);	
    			originalDatathiDif=new double[this.preFirDif(originalDatasecDif).length];
    			System.arraycopy(this.preFirDif(originalDatasecDif), 0, originalDatathiDif, 0,originalDatathiDif.length);	
    			originalDataforDif=new double[this.preFirDif(originalDatathiDif).length];
    			System.arraycopy(this.preFirDif(originalDatathiDif), 0, originalDataforDif, 0,originalDataforDif.length);	
    			
    			originalDatafriDif=new double[this.preFirDif(originalDataforDif).length];
    			System.arraycopy(this.preFirDif(originalDataforDif), 0, originalDatafriDif, 0,originalDatafriDif.length);	
    			
    			stdoriginalData=new double[this.preFirDif(originalDatafriDif).length];
    			System.arraycopy(this.preFirDif(originalDatafriDif), 0, stdoriginalData, 0,originalDatafriDif.length);	
    		}
    	else//原始数据季节性差分处理	
    		{
    			stdoriginalData=new double[this.preDealDif(originalData).length];
    			System.arraycopy(this.preDealDif(originalData), 0, stdoriginalData, 0,this.preDealDif(originalData).length);	
    		}
    	
    		int paraType=0;
    		double minAIC=9999999;
    		int bestModelindex=0;
    		int[][] model=new int[][]{{0,1},{1,0},{1,1},{0,2},{2,0},{2,2},{1,2},{2,1},{3,0},{0,3},{3,1},{1,3},{3,2},{2,3},{3,3}};
    		//对模型进行迭代,选出平均预测误差最小的模型作为我们的模型
    		for(int i=0;i<model.length;i++)
    		{
    			
    			if(model[i][0]==0)
    			{
    				MA ma=new MA(stdoriginalData, model[i][1]);
    				armaARMAcoe=ma.MAmodel(); //拿到ma模型的参数
    				paraType=1;
    			}
    			else if(model[i][1]==0)
    			{
    				AR ar=new AR(stdoriginalData, model[i][0]);
    				armaARMAcoe=ar.ARmodel(); //拿到ar模型的参数
    				paraType=2;
    			}
    			else
    			{
    				ARMA arma=new ARMA(stdoriginalData, model[i][0], model[i][1]);
    				armaARMAcoe=arma.ARMAmodel();//拿到arma模型的参数
    				paraType=3;
    			}
    		
    			double temp=getmodelAIC(armaARMAcoe,stdoriginalData,paraType);
    			if (temp<minAIC)
    			{
    				bestModelindex=i;
    				minAIC=temp;
    				bestarmaARMAcoe=armaARMAcoe;
    			}
    		}
    		
    		modelandpara mp=new modelandpara(model[bestModelindex], bestarmaARMAcoe);
    		
    		return mp;
     	}*/
    /**
     * 计算ARMA模型的AIC
     * @param para 装载模型的参数信息
     * @param stdoriginalData   预处理过后的原始数据
     * @param type 1:MA;2:AR;3:ARMA
     * @return 模型的AIC值
     */
    	public double getmodelAIC(Vector<double[]> para,double[] stdoriginalData,int type)
    	{
    		double temp=0;
    		double temp2=0;
    		double sumerr=0;
    		int p=0;//ar1,ar2,...,sig2
    		int q=0;//sig2,ma1,ma2...
    		int n=stdoriginalData.length;
    		Random random=new Random();
    		
    		if(type==1)
    		{
    			double[] maPara=new double[para.get(0).length];
    			System.arraycopy(para.get(0), 0, maPara, 0, para.get(0).length);
    			
    			q=maPara.length;
    			double[] err=new double[q];  //error(t),error(t-1),error(t-2)...
    			for(int k=q-1;k<n;k++)
    			{
    				temp=0;
    				
    				for(int i=1;i<q;i++)
    				{
    					temp+=maPara[i]*err[i];
    				}
    			
    				//产生各个时刻的噪声
    				for(int j=q-1;j>0;j--)
    				{
    					err[j]=err[j-1];
    				}
    				err[0]=random.nextGaussian()*Math.sqrt(maPara[0]);
    				
    				//估计的方差之和
    				sumerr+=(stdoriginalData[k]-(temp))*(stdoriginalData[k]-(temp));
    				
    			}
    			
    			//return  (n-(q-1))*Math.log(sumerr/(n-(q-1)))+(q)*Math.log(n-(q-1));//AIC 最小二乘估计
    			return (n-(q-1))*Math.log(sumerr/(n-(q-1)))+(q+1)*2;
    		}
    		else if(type==2)
    		{
    			double[] arPara=new double[para.get(0).length];
    			System.arraycopy(para.get(0), 0, arPara, 0, para.get(0).length);
    			
    			p=arPara.length;
    			for(int k=p-1;k<n;k++)
    			{
    				temp=0;
    				for(int i=0;i<p-1;i++)
    				{
    					temp+=arPara[i]*stdoriginalData[k-i-1];
    				}
    				//估计的方差之和
    				sumerr+=(stdoriginalData[k]-temp)*(stdoriginalData[k]-temp);
    			}
    		
    			return (n-(q-1))*Math.log(sumerr/(n-(q-1)))+(p+1)*2;
    			//return (n-(p-1))*Math.log(sumerr/(n-(p-1)))+(p)*Math.log(n-(p-1));//AIC 最小二乘估计
    		}
    		else
    		{
    			double[] arPara=new double[para.get(0).length];
    			System.arraycopy(para.get(0), 0, arPara, 0, para.get(0).length);
    			double[] maPara=new double[para.get(1).length];
    			System.arraycopy(para.get(1), 0, maPara, 0, para.get(1).length);
    				
    			p=arPara.length;
    			q=maPara.length;
    			double[] err=new double[q];  //error(t),error(t-1),error(t-2)...
    			
    			for(int k=p-1;k<n;k++)
    			{
    				temp=0;
    				temp2=0;
    				for(int i=0;i<p-1;i++)
    				{
    					temp+=arPara[i]*stdoriginalData[k-i-1];
    				}
    			
    				for(int i=1;i<q;i++)
    				{
    					temp2+=maPara[i]*err[i];
    				}
    			
    				//产生各个时刻的噪声
    				for(int j=q-1;j>0;j--)
    				{
    					err[j]=err[j-1];
    				}
    				//System.out.println("predictBeforeDiff="+1);
    				err[0]=random.nextGaussian()*Math.sqrt(maPara[0]);
    				//估计的方差之和
    				sumerr+=(stdoriginalData[k]-(temp2+temp))*(stdoriginalData[k]-(temp2+temp));
    			}
    			
    			return (n-(q-1))*Math.log(sumerr/(n-(q-1)))+(p+q)*2;
    			//return (n-(p-1))*Math.log(sumerr/(n-(p-1)))+(p+q-1)*Math.log(n-(p-1));//AIC 最小二乘估计
    		}
    	}
    /**
     * 对预测值进行反差分处理
     * @param predictValue 预测的值
     * @return 反差分过后的预测值
     */
    	public int aftDeal(int predictValue)
    	{
    		int temp=0;
    		//System.out.println("predictBeforeDiff="+predictValue);
    		if(typeofPredeal==0)
    			temp=((int)predictValue);
    		else if(typeofPredeal==1)
    			temp=(int)(predictValue+originalData[originalData.length-1]);
    		else if(typeofPredeal==2)	
    			temp=(int)(predictValue+originalDatafirDif[originalDatafirDif.length-1]+originalData[originalData.length-1]);	
    		else if(typeofPredeal==3)
    			temp=(int)(predictValue+originalDatasecDif[originalDatasecDif.length-1]+originalDatafirDif[originalDatafirDif.length-1]+originalData[originalData.length-1]);			
    		else if(typeofPredeal==4)
    			temp=(int)(predictValue+originalDatathiDif[originalDatathiDif.length-1]+originalDatasecDif[originalDatasecDif.length-1]+originalDatafirDif[originalDatafirDif.length-1]+originalData[originalData.length-1]);			
    		else if(typeofPredeal==5)
    			temp=(int)(predictValue+originalDataforDif[originalDataforDif.length-1]+originalDatathiDif[originalDatathiDif.length-1]+originalDatasecDif[originalDatasecDif.length-1]+originalDatafirDif[originalDatafirDif.length-1]+originalData[originalData.length-1]);			
    		else
    			temp=(int)(predictValue+originalData[originalData.length-7]);	
    			
    				return temp>0?temp:0;
    	}
    	
    	
    /**
     * 进行一步预测
     * @param p ARMA模型的AR的阶数
     * @param q ARMA模型的MA的阶数
     * @return 预测值
     */
    	public int predictValue(int p,int q,Vector<double[]> bestpara)
    	{
    		double[] stdoriginalData=null;
    		if (typeofPredeal==0)
    			{
    				stdoriginalData=new double[originalData.length];
    				System.arraycopy(originalData, 0, stdoriginalData, 0, originalData.length);
    				
    			}
    		else if(typeofPredeal==1)
    			{
    				stdoriginalData=new double[originalDatafirDif.length];
    				
    				System.arraycopy(originalDatafirDif, 0, stdoriginalData, 0, originalDatafirDif.length);	
    			}
    		else if(typeofPredeal==2)
    			{
    				stdoriginalData=new double[originalDatasecDif.length];//普通二阶差分处理
    				System.arraycopy(originalDatasecDif, 0, stdoriginalData, 0, originalDatasecDif.length);	
    			}
    			
    		else if(typeofPredeal==3)
    			{
    				stdoriginalData=new double[originalDatathiDif.length];//普通三阶差分处理
    				System.arraycopy(originalDatathiDif, 0, stdoriginalData, 0, originalDatathiDif.length);	
    			}
    			
    		else if(typeofPredeal==4)
    			{
    				stdoriginalData=new double[originalDataforDif.length];//普通四阶差分处理
    				System.arraycopy(originalDataforDif, 0, stdoriginalData, 0, originalDataforDif.length);	
    			}
    			
    		else if(typeofPredeal==5)
    			{
    				stdoriginalData=new double[originalDatafriDif.length];//普通五阶差分处理
    				System.arraycopy(originalDatafriDif, 0, stdoriginalData, 0, originalDatafriDif.length);	
    			}
    		else
    			{
    				stdoriginalData=new double[this.preDealDif(originalData).length];//季节性一阶差分
    				System.arraycopy(this.preDealDif(originalData), 0, stdoriginalData, 0, this.preDealDif(originalData).length);	
    			}
    		//System.out.println("typeofPredeal= "+typeofPredeal+typeofPredeal);
    		
    //		for(int i=0;i<originalDatafirDif.length;i++)
    //			System.out.println(originalDatafirDif[i]);
    //		
    		int predict=0;
    		int n=stdoriginalData.length;
    		double temp=0,temp2=0;
    		double[] err=new double[q+1];
    	
    		Random random=new Random();
    		if(p==0)
    		{
    			double[] maPara=bestpara.get(0);
    			
    			
    			for(int k=q;k<n;k++)
    			{
    				temp=0;
    				for(int i=1;i<=q;i++)
    				{
    					temp+=maPara[i]*err[i];
    				}
    				//产生各个时刻的噪声
    				for(int j=q;j>0;j--)
    				{
    					err[j]=err[j-1];
    				}
    				err[0]=random.nextGaussian()*Math.sqrt(maPara[0]);
    			}
    			predict=(int)(temp); //产生预测
    			//System.out.println("predict=q "+predict);
    		}
    		else if(q==0)
    		{
    			double[] arPara=bestpara.get(0);
    		
    			for(int k=p;k<n;k++)
    			{
    				temp=0;
    				for(int i=0;i<p;i++)
    				{
    					temp+=arPara[i]*stdoriginalData[k-i-1];
    				}
    			}
    			predict=(int)(temp);
    			//System.out.println("predict= p"+predict);
    		}
    		else
    		{
    			double[] arPara=bestpara.get(0);
    			double[] maPara=bestpara.get(1);
    			
    			err=new double[q+1];  //error(t),error(t-1),error(t-2)...
    			for(int k=p;k<n;k++)
    			{
    				temp=0;
    				temp2=0;
    				for(int i=0;i<p;i++)
    				{
    					temp+=arPara[i]*stdoriginalData[k-i-1];
    				}
    			
    				for(int i=1;i<=q;i++)
    				{
    					temp2+=maPara[i]*err[i];
    				}
    			
    				//产生各个时刻的噪声
    				for(int j=q;j>0;j--)
    				{
    					err[j]=err[j-1];
    				}
    				
    				err[0]=random.nextGaussian()*Math.sqrt(maPara[0]);
    			}
    			
    			predict=(int)(temp2+temp);
    			//System.out.println("predict=p,q "+predict);
    		}
    		return predict;
    	}
     
    }
     
     
    class modelandpara
    {
    	int[] model;
    	Vector<double[]> para;
    	public modelandpara(int[] model,Vector<double[]> para)
    	{
    		this.model=model;
    		this.para=para;
    	}
    }
    
    

    (5)ARIMAiFlex类,用于构建AR模型

    package arima;
    import java.util.Hashtable;
    import java.util.*;
     
    public class ARIMAiFlex {
     
    	
    	int             count=0;
    	int []          model=new int[2];
    	int[][]      modelOri=new int[][]{{0,1},{1,0},{1,1},{0,2},{2,0},{2,2},{1,2},{2,1},{3,0},{0,3},{3,1},{1,3},{3,2},{2,3},{3,3}};
     
    	modelandpara       mp=null;
    	int  predictValuetemp=0;
    	int   avgpredictValue=0;
    	int[]       bestmodel=new int[2];
    	double[][] predictErr=new double[7][modelOri.length];
    	double  minpreDicterr=9999999;
    	int  bestpreDictValue=0;
    	int           bestDif=0;
    	int            memory=10;
    	double[] traindataArray=null;
    	double         validate=0;
    	double[]   predataArray=null;
    	
    	double[]     dataArrayPredict=null;
    	Hashtable<String,Integer>  ht=new Hashtable<String,Integer>();
    	Hashtable<String,Integer> ht2=new Hashtable<String,Integer>();
     
    	double thresvalue=0;
     
    	public ARIMAiFlex(double []dataArray)
    	{
    		//模型训练
    		System.out.println("begin to train...");
    		Vector<int[]> trainResult=this.Train(dataArray);
    		//预测数据初始化
    		int tempPredict=0;
    		System.out.println("begin to predict...");
    		for(int i=0;i<trainResult.size();i++)
    		{
    			thresvalue=0;
    			System.out.println("predict..."+i+"/"+trainResult.size());
    			tempPredict+=this.Predict(dataArray,memory,trainResult.get(i),0);
    		}
    		tempPredict=tempPredict/trainResult.size();
    		System.out.println("tempPredict="+tempPredict);
    	}
    	
    	public void preData(double[] dataArray,int type,int memory)
    	{
    			//      ++
    		//********** 
    		 //**********
    		this.traindataArray=new double[dataArray.length-memory];
    		System.arraycopy(dataArray, type, traindataArray, 0, traindataArray.length);
    		this.validate=dataArray[traindataArray.length+type];//最后一个值作为训练时候的验证值。
    		
    	}
    	
    	public int Predict(double[] dataArray,int memory,int[] trainResult,double fanwei)
    	{
    		if(memory<0)
    			return (int)(dataArray[dataArray.length-1]+dataArray[dataArray.length-2])/2;
    		
    		this.predataArray=new double[dataArray.length-memory];
    		System.arraycopy(dataArray, memory, predataArray, 0, predataArray.length);
    		ARIMA arima=new ARIMA(predataArray,trainResult[0]); //对原始数据做几阶差分处理0,1,2,7
    		//参数初始化
    		int count=100;
    		int predictValuetemp=0;
    		
    		//统计每种模型的预测平均值
    		while(count-->0)
    		{
    			mp=arima.getARIMAmodel(modelOri[trainResult[1]]);
    			predictValuetemp+=arima.aftDeal(arima.predictValue(mp.model[0],mp.model[1],mp.para));
    		}
    		
    		predictValuetemp/=100;
    		//System.out.println("Predict value is:"+predictValuetemp);
    		
    		if(Math.abs(predictValuetemp-predataArray[predataArray.length-1])/predataArray[predataArray.length-1]>(0.3+fanwei))
    		{	
    			thresvalue++;
    			System.out.println("thresvalue="+thresvalue);
    			//重新训练和预测
    			//模型训练
    			Vector<int[]> trainResult2=this.Train(dataArray);
    			//预测数据初始化
    			int tempPredict=0;
    			for(int i=0;i<trainResult2.size();i++)
    			{
    				tempPredict+=this.Predict(dataArray,(memory-5),trainResult2.get(i),0.1*thresvalue);
    			}
    			tempPredict=tempPredict/trainResult2.size();
    			//System.out.println("tempPredict="+tempPredict);
    			return tempPredict;
    		}
    		else
    		{
    			return predictValuetemp;
    		}
    	}
    	
    	public Vector<int[]> Train(double[] dataArray)
    	{
    		int memory=60;//训练的时候预测的值的个数
    	
    		for(int datai=0;datai<memory;datai++)
    		{
    			//System.out.println("train... "+datai+"/"+memory);
    			this.preData(dataArray, datai,memory);//准备训练数据
    			
    			for(int diedai=0;diedai<7;diedai++)
    			{
    				ARIMA arima=new ARIMA(traindataArray,diedai); //对原始数据做几阶差分处理0,1,2,7
     
    				//统计每种模型的预测平均值
    				for(int modeli=0;modeli<modelOri.length;modeli++)
    				{
    					//参数初始化
    					count=100;
    					predictValuetemp=0;
    					
    					while(count-->0)
    					{
    						mp=arima.getARIMAmodel(modelOri[modeli]);
    						predictValuetemp+=arima.aftDeal(arima.predictValue(mp.model[0],mp.model[1],mp.para));
    						//System.out.println("predictValuetemp"+predictValuetemp);
    					}
    					predictValuetemp/=100;
    					//计算训练误差
    					predictErr[diedai][modeli]+=Math.abs(100*(predictValuetemp-validate)/validate);
    				}
    			}
    		}
    		
    		double minvalue=10000000;
    		int tempi=0;
    		int tempj=0;
    		Vector<int[]> bestmodelVector=new Vector<int[]>();
    		int[][] flag=new int[7][modelOri.length];
    		
    		for(int ii=0;ii<5;ii++)
    		{	minvalue=10000000;
    			for(int i=0;i<predictErr.length;i++)
    			 {
    				for(int j=0;j<predictErr[i].length;j++)
    					{
    						if(flag[i][j]==0)
    						{
    							if(predictErr[i][j]<minvalue)
    							{
    								minvalue=predictErr[i][j];
    								tempi=i;
    								tempj=j;
    								flag[i][j]=1;
    							}
    						}
    					}
    			}
    			bestmodelVector.add(new int[]{tempi,tempj});
    			
    			//System.out.println("best model:Dif="+tempi+"..."+"index of model="+tempj);
    			System.out.println("ARIMAAvgPredictErr="+minvalue/memory);
    		}
    	
    //		for(int i=0;i<predictErr.length;i++)
    //			for(int j=0;j<predictErr[i].length;j++)
    //			{
    //				System.out.println("Dif "+i+" Model index"+j+"= "+predictErr[i][j]/memory);
    //			}
    		
    		//System.out.println("--tempi="+tempi+"~~~"+"tempj="+tempj);
    		System.out.println("----------------------------------------");
    		
    		return bestmodelVector;
    	}	
    	
    	}
    
    

    (6)ARMAMath类,常见的数据计算任务

    package arima;
    import Jama.Matrix;
     
    public class ARMAMath
    {
    	public double avgData(double[] dataArray)
    	{
    		return this.sumData(dataArray)/dataArray.length;
    	}
    	
    	public double sumData(double[] dataArray)
    	{
    		double sumData=0;
    		for(int i=0;i<dataArray.length;i++)
    		{
    			sumData+=dataArray[i];
    		}
    		return sumData;
    	}
    	
    	public double stderrData(double[] dataArray)
    	{
    		return Math.sqrt(this.varerrData(dataArray));
    	}
    	
    	public double varerrData(double[] dataArray)
    	{
    		double variance=0;
    		double avgsumData=this.avgData(dataArray);
    		
    		for(int i=0;i<dataArray.length;i++)
    		{
    			dataArray[i]-=avgsumData;
    			variance+=dataArray[i]*dataArray[i];
    		}
    		return variance/dataArray.length;//variance error;
    	}
    	
    	/**
    	 * 计算自相关的函数 Tho(k)=Grma(k)/Grma(0)
    	 * @param dataArray 数列
    	 * @param order 阶数
    	 * @return
    	 */
    	public double[] autocorData(double[] dataArray,int order)
    	{
    		double[] autoCor=new double[order+1];
    		double varData=this.varerrData(dataArray);//标准化过后的方差
    		
    		for(int i=0;i<=order;i++)
    		{
    			autoCor[i]=0;
    			for(int j=0;j<dataArray.length-i;j++)
    			{
    				autoCor[i]+=dataArray[j+i]*dataArray[j];
    			}
    			autoCor[i]/=(dataArray.length-i);
    			autoCor[i]/=varData;
    		}
    		return autoCor;
    	}
    	
    /**
     * Grma
     * @param dataArray
     * @param order
     * @return 序列的自相关系数
     */
    	public double[] autocorGrma(double[] dataArray,int order)
    	{
    		double[] autoCor=new double[order+1];
    		for(int i=0;i<=order;i++)
    		{
    			autoCor[i]=0;
    			for(int j=0;j<dataArray.length-i;j++)
    			{
    				autoCor[i]+=dataArray[j+i]*dataArray[j];
    			}
    			autoCor[i]/=(dataArray.length-i);
    			
    		}
    		return autoCor;
    	}
    	
    /**
     * 求偏自相关系数
     * @param dataArray
     * @param order
     * @return
     */
    	public double[] parautocorData(double[] dataArray,int order)
    	{
    		double parautocor[]=new double[order];
    		
    		for(int i=1;i<=order;i++)
    	    {
    			parautocor[i-1]=this.parcorrCompute(dataArray, i,0)[i-1];
    	    }
    		return parautocor;
    	}
    /**
     * 产生Toplize矩阵
     * @param dataArray
     * @param order
     * @return
     */
    	public double[][] toplize(double[] dataArray,int order)
    	{//返回toplize二维数组
    		double[][] toplizeMatrix=new double[order][order];
    		double[] atuocorr=this.autocorData(dataArray,order);
     
    		for(int i=1;i<=order;i++)
    		{
    			int k=1;
    			for(int j=i-1;j>0;j--)
    			{
    				toplizeMatrix[i-1][j-1]=atuocorr[k++];
    			}
    			toplizeMatrix[i-1][i-1]=1;
    			int kk=1;
    			for(int j=i;j<order;j++)
    			{
    				toplizeMatrix[i-1][j]=atuocorr[kk++];
    			}
    		}
    		return toplizeMatrix;
    	}
     
    	/**
    	 * 解MA模型的参数
    	 * @param autocorData
    	 * @param q
    	 * @return
    	 */
    	public double[] getMApara(double[] autocorData,int q)
    	{
    		double[] maPara=new double[q+1];//第一个存放噪声参数,后面q个存放ma参数sigma2,ma1,ma2...
    		double[] tempmaPara=new double[q+1];
    		
    		double temp=0;
    		boolean iterationFlag=true;
    		//解方程组
    		//迭代法解方程组
    		maPara[0]=1;//初始化
    		int count=10000;
    		while(iterationFlag&&count-->0)
    		{
    			temp=0;
    			for(int i=1;i<maPara.length;i++)
    			{
    				temp+=maPara[i]*maPara[i];
    			}
    			tempmaPara[0]=autocorData[0]/(1+temp);
    			
    			for(int i=1;i<maPara.length;i++)
    			{
    				temp=0;
    				for(int j=1;j<maPara.length-i;j++)
    				{
    					temp+=maPara[j]*maPara[j+i];
    				}
    				tempmaPara[i]=-(autocorData[i]/tempmaPara[0]-temp);
    			}
    			iterationFlag=false;
    			for(int i=0;i<maPara.length;i++)
    			{
    				if(Math.abs(maPara[i]-tempmaPara[i])>0.00001)
    				{
    					iterationFlag=true;
    					break;
    				}
    			}
    			
    			System.arraycopy(tempmaPara, 0, maPara, 0, tempmaPara.length);
    		}
    	
    		return maPara;
    	}
    	/**
    	 * 计算自回归系数
    	 * @param dataArray
    	 * @param p
    	 * @param q
    	 * @return
    	 */
    	public double[] parcorrCompute(double[] dataArray,int p,int q)
    	{
    		double[][] toplizeArray=new double[p][p];//p阶toplize矩阵;
    		
    		double[] atuocorr=this.autocorData(dataArray,p+q);//返回p+q阶的自相关函数
    		double[] autocorrF=this.autocorGrma(dataArray, p+q);//返回p+q阶的自相关系数数
    		for(int i=1;i<=p;i++)
    		{
    			int k=1;
    			for(int j=i-1;j>0;j--)
    			{
    				toplizeArray[i-1][j-1]=atuocorr[q+k++];
    			}
    			toplizeArray[i-1][i-1]=atuocorr[q];
    			int kk=1;
    			for(int j=i;j<p;j++)
    			{
    				toplizeArray[i-1][j]=atuocorr[q+kk++];
    			}
    		}
    		
    	    Matrix toplizeMatrix = new Matrix(toplizeArray);//由二位数组转换成二维矩阵
    	    Matrix toplizeMatrixinverse=toplizeMatrix.inverse();//矩阵求逆运算
    		
    	    double[] temp=new double[p];
    	    for(int i=1;i<=p;i++)
    	    {
    	    	temp[i-1]=atuocorr[q+i];
    	    }
    	    
    		Matrix autocorrMatrix=new Matrix(temp, p);
    		Matrix parautocorDataMatrix=toplizeMatrixinverse.times(autocorrMatrix); //  [Fi]=[toplize]x[autocorr]';
    		//矩阵计算结果应该是按照[a b c]'  列向量存储的
    		//System.out.println("row="+parautocorDataMatrix.getRowDimension()+"  Col="+parautocorDataMatrix.getColumnDimension());
    		//parautocorDataMatrix.print(p, 2);//(输出几行,小数点后保留位数)
    		//System.out.println(parautocorDataMatrix.get(p-1,0));
    		
    		double[] result=new double[parautocorDataMatrix.getRowDimension()+1];
    		for(int i=0;i<parautocorDataMatrix.getRowDimension();i++)
    		{
    			result[i]=parautocorDataMatrix.get(i,0);
    		}
    		
    		//估算sigmat2
    		double sum2=0;
    		for(int i=0;i<p;i++)
    			for(int j=0;j<p;j++)
    			{
    				sum2+=result[i]*result[j]*autocorrF[Math.abs(i-j)];
    			}
    		result[result.length-1]=autocorrF[0]-sum2; //result数组最后一个存储干扰估计值
    		
    		
    			return result;   //返回0列的最后一个就是k阶的偏自相关系数 pcorr[k]=返回值
    	}
     
    	}
    
    

    (7)test1,用于导入数据进行测试

    package arima;
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Scanner;
    public class test1 {
     
    	public static void main(String args[])
    	{
    		Scanner ino=null;
    			
    		try {
    			/*********************************************************/
    			ArrayList<Double> arraylist=new ArrayList<Double>();
    			ino=new Scanner(new File("E:\\work\\Arima\\Arima\\Data\\ceshidata.txt"));
    			
    			while(ino.hasNext())
    			{
    				arraylist.add(Double.parseDouble(ino.next()));
    			}
    			
    			double[] dataArray=new double[arraylist.size()]; 
    			
    			for(int i=0;i<dataArray.length;i++)
    				dataArray[i]=arraylist.get(i);
    	
    			
    			ARIMAiFlex myarima=new ARIMAiFlex(dataArray);
    			currentAlgorithm cc=new currentAlgorithm(dataArray);
    			
    			/*********************************************************/
    				
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			ino.close();
    		}
    	}
    	
    }
    
    
    

    完整代码托管在gitHub:ARIMA gitHub

    展开全文
  • 你是否想要做时间序列分析,但却不知道代码怎么写?你是否不清楚时间序列分析各种...做Data Scientist,记得刚入职时,老板就跟我说未来我的主要任务是用各种类型的时间序列模型预测预测好莱坞游览车未来三年每...

    你是否想要做时间序列分析,但却不知道代码怎么写?

    你是否不清楚时间序列分析各种模型该在什么情况下使用?

    本文将针对以上两个问题,带你入门时间序列分析~

    等等!

    不止’入门‘

    读完这篇,你立即就能在R中写出不同模型的相应代码~

    先介绍以下我自己吧~

    我目前是Warner Bros.做Data Scientist,记得刚入职时,老板就跟我说未来我的主要任务是用各种类型的时间序列模型做预测:预测好莱坞游览车未来三年每天的乘客数量、预测, ,等华纳出品的电影每分钟的观看量,预估艾伦秀不同播出计划的未来收视率和收入等等等等~~~

    刚入职的第一个月每天愁眉不展,时间序列的方法很多,很多时候,即使理论基础学懂了,但是到实践上,R里的code要怎么写又是个大问题,网上的很多教程,教授了公式,却不教授具体的代码怎么写。

    幸运的是,老板是个比较技术咖的人,他教会了我很多实际操作上的东西,结合我过去七个月做过的各种时间序列模型,决定好好总结一下时间序列常见模型各自的适用场合、特征等理论知识,更重要的是,每个模型在R里的具体代码实现以及操作步骤,希望能帮助到需要使用R来做时间序列的朋友们~

    时间序列数据是在一段时间内作为时间间隔序列收集的数据点。时间序列数据分析意味着对可用数据进行分析,以找出数据的模式或趋势,从而预测一些将来的价值,这些价值将有助于提高效率并优化业务决策。

    常见的用于时间序列分析的技术:ARIMA模型

    指数平滑模型

    本篇将介绍 - ARIMA模型在R中如何使用

    ARIMA建模

    ARIMA是AutoRegressive集成移动平均线的缩写。自回归(AR)项是指差分序列的滞后,移动平均(MA)项是指误差的滞后,而I是用于使时间序列平稳的差分数。

    ARIMA模型假设数据平稳 – 这意味着数据的变化不依赖于时间变化。白噪声序列和具有循环特性的序列也可以视为平稳序列。

    数据应为单变量– ARIMA处理单个变量。自动回归就是关于过去值的回归。

    (PS: 对于有外部变量的数据,可以使用ARIMAX模型,这个将在下一篇中介绍)

    以下步骤1~5,很重要!很重要!!

    ARIMA建模要遵循的步骤将数据集转化为时间序列格式

    作图分析数据

    确定p,d,q

    拟合模型

    做出预测

    下面将根据建模步骤来介绍R中code

    首先,导入需要用到的包:

    library(ggplot2) #作图

    library(forecast) #建模

    library(dplyr) # 数据处理

    library(lubridate) # 时间处理

    将数据集转化为时间序列格式

    使用R进行时间序列数据建模的第一步是将数据转换为时间序列数据格式。为此,我们需要在R中运行以下命令:

    wbstl_weekly_data_ts = ts(wbstl_weekly_data$weekly_totalgross,frequency = 365.25/12,

    start= decimal_date(ymd('2011-01-01')))wbstl_weekly_data$weekly_totalgross是我们要转换为时间序列的单变量数据

    start给出数据的开始时间,在本例中为2011年1月。

    frequency是数据的频率。由于它是月度数据,所以'frequency = 12'。(每周的数据,则frequency=52; daily data,则frequency=365.25)

    2. 作图分析数据

    ggplot(wbstl_weekly_data, aes(x =month, y = weekly_totalgross)) + geom_line()

    这是数据的样子:

    我们可以从图本身推断出,数据点遵循总体上升趋势,但在突然降低的值方面有一些异常值。现在,我们需要进行一些分析,以找出数据中确切的非平稳性和季节性。

    3. 确定p,d,q

    数据准备就绪并满足所有建模假设后,要确定要拟合数据的模型的顺序,我们需要三个变量:p,d和q,它们是指代负顺序的非负整数。模型的自回归,积分和移动平均值部分。

    要找到合适的p和q值,我们需要使用acf()并pacf()。

    pacf()滞后k是自相关函数,它描述了相距k步的所有数据点之间的相关性-在考虑了它们与这k步之间的数据的相关性之后。它有助于识别ARIMA模型中的自回归(AR)系数(p值)的数量。

    acf(tsstationary,lag.max = 34)

    pacf(tsstationary,lag.max = 34)

    结果如下:

    ACF用以确认q, 图中可以看出q = 1

    PACF用以确认p = 2

    处理好了数据,下面 进入最重要的部分:模型拟合 + 预测

    4. 模型拟合

    fitARIMA

    order 指定ARIMA模型的非季节部分:(p,d,q)指AR阶,差异度和MA阶。

    seasonal指定ARIMA模型的季节性部分,加上周期(此处是月度数据,所以为12)。该函数需要一个包含组件顺序和周期的列表,但是给定长度为3的数字矢量,它将把它们变成一个合适的列表,其规格为“ order”。

    method表示拟合方法,可以是“最大似然(ML)”或“最小平方和(CSS)”。

    这是一个递归过程,我们需要arima()使用不同的(p,d,q)值运行此函数,以找到最优化和高效的模型。

    上述介绍的是怎么手动根据数据确定ARIMA模型中各参数,这边还有个懒人方法 (实践中更多也是使用该懒人方法 - auto.arima() )

    auto.arima()功能:

    预测程序包提供两个功能:ets()和auto.arima()用于自动选择指数模型和ARIMA模型。

    auto.arima()R中的函数结合了单位根测试,最小化AIC和MLE来获得ARIMA模型。

    KPSS检验用于确定差异数量(d)在Hyndman-Khandakar算法中,用于自动ARIMA建模。

    然后通过最小化AICc来选择p,d和q。该算法使用逐步搜索遍历模型空间,以选择具有最小AICc的最佳模型。

    如果d = 0,则常数c被包括在内;如果d≥1,则常数c设置为零。通过将当前模型的p和/或q改变±1并包括/排除当前模型中的c来考虑当前模型的变化。

    到目前为止考虑的最佳模型(当前模型或这些变体之一)成为新的当前模型。

    现在,重复此过程,直到找不到更低的AIC。

    auto.arima(tsData,seasonal.test="ch",

    parallel=TRUE,num.cores=8,stepwise=FALSE,approximation=FALSE)

    该行code,运行时间较长,上周我用了1140个数据点,运行了1.5hr

    5. 使用ARIMA模型进行预测

    一旦为时间序列数据选择了最合适的模型,该ARIMA模型的参数就可以用作预测模型来预测时间序列的未来值。

    使用predict()的函数 - 用于根据各种模型拟合函数的结果进行预测。它需要一个参数n.ahead()来指定要预测多少时间。

    predict (fitARIMA,h = 5)

    意思就是对未来5个月进行预测

    forecast.Arima()forecastR包中的函数还可用于预测时间序列的未来值。在这里,我们还可以使用level参数指定预测间隔的置信度。

    futurVal

    plot.forecast(futurVal)

    我们需要确保预测误差不相关,正态分布为均值零和恒定方差。我们可以使用诊断方法找出具有最佳可能预测值的适当模型。

    预测显示为蓝线,而99.5%置信度水平的预测间隔为浅阴影区域。

    这是整个过程,我们可以使用ARIMA分析时间序列数据和现有序列的预测值。

    总结一下:

    ARIMA建模要遵循的步骤将数据集转化为时间序列格式

    作图分析数据

    确定p,d,q / 或只用auto.arima()

    拟合模型

    做出预测

    大家看完别忘了赞一个让更多人看到

    另外,欢迎关注我的专栏: 煮一锅数据汤

    专栏定期分享数据分析方面干货,如时间序列模型实践、机器学习模型讲解、R编程语言操作、SQL小白入门等煮一锅数据汤​zhuanlan.zhihu.com

    展开全文
  • ARIMA进行时间序列预测本文翻译于Kaggle,原文链接时间序列预测教程。中文论坛很少有对整个过程进行描述,所以想转载过来供大家一起学习。数据在原文也有,我也放了云盘天气数据。英文水平和学术水平都比较低,...
  • 时间序列预测之--ARIMA模型

    千次阅读 2018-03-16 15:05:10
    什么是 ARIMA模型 ARIMA的优缺点 判断是时序数据是稳定的方法 ARIMA的参数与数学形式 ARIMA模型的几个特例 ARIMA(0,1,0) ARIMA(1,0,0) ARIMA(1,1,0) ARIMA(0,1,1) ARIMA(2,1,2) ARIMA(2,2,2) ARIMA建模基本步骤 ...
  • 时间序列模型ARIMA和ARMA)完整步骤详述

    万次阅读 多人点赞 2019-05-28 14:57:27
    老师作业要求,实现ARMA和ARIMA模型的基本全过程和最后结果。 目录 所用的所有数据包 1,数据准备与预处理 (1)数据准备 (2)数据预处理 2,数据重采样 3,平稳性和非白噪声 (1)差分法实现 (2)平滑法...
  • 时间序列分析预测实战之ARIMA模型

    千次阅读 2018-11-09 16:40:21
    这时候ARIMA模型就登场了,全称是自回归差分移动平均模型,使用这个模型建模,具体的操作步骤如下: 1)观察时序的平稳性和随机性; 2)选择具体的模型; 3)拟合模型; 4)根据选定模型进行预测; 5)模型评价...
  • “常用的时间序列模型有四种:自回归模型 AR(p)、移动平均模型 MA(q)、自回归移动平均模型 ARMA(p,q)、自回归差分移动平均模型 ARIMA(p,d,q), 可以说前三种都是 ARIMA(p,d,q)模型的特殊形式。本文主要围绕着如何使用...
  • 27、python时间序列预测ARIMA模型案例代码)

    万次阅读 多人点赞 2019-01-03 15:07:43
    2、时间序列算法公式 3、详细步骤 01 平稳性检验(adf检验) 02 对数据进行差分构造平稳序列 03 平稳性监测 04 白噪声检验 05 定阶 06 模型预测 4、案例代码 1、模型识别 01 主要的模型 AR(P)模型...
  • 时间序列模型 ARIMA

    2020-12-14 20:10:06
    ARIMA模型(英语:AutoregressiveIntegratedMovingAverage model),差分整合移动平均自回归模型,又称整合移动平均自回归模型(移动也可称作滑动),是时间序列预测分析方法之一。ARIMA(p,d,q)中,AR是“自回归”...
  • 最近要用ARIMA模型预测用户的数量变化,所以调研了一下ARIMA模型,最后用JAVA实现了ARIMA算法。一、ARIMA原理ARIMA的原理主要参考的是ARIMA原理。二、JAVA实现弄懂了原理,用JAVA进行了实现,主要参考的步骤是ARIMA...
  • 时间序列模型步骤教程(ARIMA

    千次阅读 2020-10-29 19:17:17
    时间序列的分析的步骤是先对数据进行平稳性和非白噪声检验(如不满足需对数据进行平滑或差分等预处理),然后才是模型调参跟预测,因此本文分为2大部分介绍,答题思路见脑图。 一、数据准备&探索 1、平稳性 ...
  • 最近要用ARIMA模型预测用户的数量变化,所以调研了一下ARIMA模型,最后用JAVA实现了ARIMA算法。一、ARIMA原理ARIMA的原理主要参考的是ARIMA原理。二、JAVA实现弄懂了原理,用JAVA进行了实现,主要参考的步骤是ARIMA...
  • 时间序列分析之 ARIMA 模型的JAVA实现

    万次阅读 多人点赞 2015-01-26 13:06:09
    最近要用ARIMA模型预测用户的数量变化,所以调研了一下ARIMA模型,最后用JAVA实现了ARIMA算法。 一、ARIMA原理 ARIMA的原理主要参考的是ARIMA原理。 二、JAVA实现 弄懂了原理,用JAVA进行了实现,主要参考的步骤是...
  • 可是目前没找到ARMA模型、ARIMA模型的新发展,可能是叫别的模型吧(⊙﹏⊙)当ARIMA模型包括其它时间序列作为输入变量时,被称为传递函数模型(transfer function model)、多变量时间序列模型(multivariate time series ...
  • 时间序列分析的主要目的是根据已有的历史数据对未来进行预测。经济数据中大多数以时间序列的形式给出。根据观察时间的不同,时间序列中的时间可以是年份、季度、月份或其他任何时间形式。Notice构成要素:长期趋势,...
  • 时间序列预测模型笔记

    千次阅读 2019-08-29 11:07:21
    详细解释时间序列预测模型相关基础概念:差分、白噪声、残差序列、ADF结果如何查看、pq值如何确定。ARIMA模型具体实现步骤
  • 因为之前在学数据分析课程的时候老师讲到时间序列这里,但只是简单的对这个经典的时间序列案例介绍了一下,并没有涉及对差分次数d的查找、找ARIMA模型的p、q值和模型检验 这三个步骤。 后来我搜寻了整个网络,终于...
  • 一、Spass时间序列建模的思路 ...打开Spss,分析‐‐时间序列预测—创建传统模型,看看Sapss专家建模器得出的最优的模型类型 如果最后的结果是ARIMA(p,0,q)模型,那么我们就可以画出时间序列的样本.
  • 很高兴上篇文章能受到大家的认可,本人想从本文章开始利用一些统计学模型和机器学习、深度学习的方法(主要在R语言中)做一些金融时间序列的分析和预测,希望能对大家有所帮助,本文如有不妥之处还请各位多多指正。...
  • 学习创建时间序列预测步骤 关注Dickey-Fuller检验和ARIMA(自回归移动平均)模型 从理论上学习这些概念以及它们在python中的实现 介绍 时间序列(从现在起称为TS)被认为是数据科学领域中鲜为人知的技能之一...
  • ARIMA模型(英语:Autoregressive Integrated Moving Average model),差分整合移动平均自回归模型,又称整合移动平均自回归模型(移动也可称作滑动),是时间序列预测分析方法之一。ARIMA(p,d,q)中,AR是“自...
  • 解读导航:文章脉络会先以图问结合的方式,让你理解ARIMA的基本概念和术语,然后以预测下月商品销售额为实例,带你亲临建立时间序列模型步骤和方法,之后介绍一种很有前瞻性的方法Prophet,最后总结时间序列模型的...
  • 整洁的时间序列预测与tidymodels 。 讲解 :使用modeltime进行预测的6步骤过程的演练 :学习如何使用modeltime ,查找Modeltime模型以及扩展modeltime以便可以在Modeltime Workflow中使用新算法。 安装 CRAN版本: ...
  • ARIMA建模分析分析的步骤数据可视化,识别平稳性对非平稳的时间序列数据,做平稳性处理,得到平稳序列根据偏自相关系数和自相关系数选择模型模型的阶数在确定之后,对模型进行参数估计判断(诊断)残差序列是否为白...
  • 0 时间序列分析步骤 1.用pandas处理时序数据 2. 检验时序数据的平稳性 3. 将时序数据平稳化 4. 确定p.d.q值 5. 应用ARIMA模型对时序数据进行预测 其中ARIMA模型是Autoregressive Integrated Moving Average ...
  • 数据分析-ARIMA方法建模步骤总结

    千次阅读 2019-05-06 08:29:07
    ARIMA模型适用于非平稳时间序列数据,其中的I表示差分的次数,适当的差分可使原序列成为平稳序列后,再进行ARIMA模型的建模。 其建模步骤与ARMA模型类似,分为5个步骤: 平稳: 通过差分的手段,对非平稳时间序列...
  • 1、ARIMA模型是一种流行且广泛使用的时间序列预测统计方法。ARIMA是AutoRegressive Integrated Moving Average的缩写。它是一类模型,它捕获时间序列数据中的一套不同的标准时间结构。 AR:自回归。一种模型,它...
  • ARIMA模型(英语:AutoregressiveIntegratedMovingAverage model),差分整合移动平均自回归模型,又称整合移动平均自回归模型(移动也可称作滑动),是时间序列预测分析方法之一。Arima定阶比较困难,Python中的auto_...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

时间序列arima模型预测步骤