精华内容
下载资源
问答
  • R语言的ARIMA模型实现代码,用来分析非平稳时间序列,并可进行预测
  • VR 虚拟现实 ARIMA 模型预测 5ARIMA 模型预测 5.1 模型选取 目前学术界较为成熟的预测方法很多各种不同的预测方法有其所面向的 特定对象不存在一种普遍 最好的预测方法GM 1,1模型预测是以灰色 系统理论为基础通过...
  • 输入数据txt格式: 2017-05-01 100 ...function:时间序列预测ARIMA模型预测每天的销售额 author:dongli date:2018-05-25 """ # 导入库 import numpy as np # numpy库 from sta...

    输入数据txt格式:
    2017-05-01 100
    2017-05-02 200
    …….

    python 实现arima:

    # encoding: utf-8
    
    """
    function:时间序列预测ARIMA模型预测每天的销售额
    author:dongli
    date:2018-05-25
    """
    
    
    # 导入库
    import numpy as np  # numpy库
    from statsmodels.graphics.tsaplots import plot_acf, plot_pacf  # acf和pacf展示库
    from statsmodels.tsa.stattools import adfuller  # adf检验库
    from statsmodels.stats.diagnostic import acorr_ljungbox  # 随机性检验库
    from statsmodels.tsa.arima_model import ARMA  # ARMA库
    import matplotlib.pyplot as plt  # matplotlib图形展示库
    import prettytable  # 导入表格库
    import pandas as pd  #导入数据处理库
    from datetime import datetime,timedelta #导入时间库
    import warnings
    import time
    time1=time.time()
    from sklearn.externals import joblib  #模型导出
    # 忽略提醒
    warnings.filterwarnings("ignore")
    
    
    # 把字符串转成datetime
    def string_toDatetime(string):
        '''
        :param string: 日期字符串
        :return: 返回日期格式数据
        '''
    
        return datetime.strptime(string, "%Y-%m-%d")
    
    # 定义一个日期列表
    def datelist(beginDate, endDate):
        '''
        :beginDate string: 日期字符串
        :endDate string: 日期字符串
        :return: 返回日期格式列表
        '''
        # beginDate, endDate是形如‘20160601’的字符串或datetime 2018-04-23格式
        date_l=[datetime.strftime(x,'%Y-%m-%d') for x in list(pd.date_range(start=beginDate, end=endDate))]
        return date_l
    
    
    # 多次用到的表格
    def pre_table(table_name, table_rows):
        '''
        :param table_name: 表格名称,字符串列表
        :param table_rows: 表格内容,嵌套列表
        :return: 展示表格对象
        '''
        table = prettytable.PrettyTable()  # 创建表格实例
        table.field_names = table_name  # 定义表格列名
        for i in table_rows:  # 循环读多条数据
            table.add_row(i)  # 增加数据
        return table
    
    
    # 数据平稳处理
    def get_best_log(ts, max_log=5, rule1=True, rule2=True):
        '''
        :param ts: 时间序列数据,Series类型
        :param max_log: 最大log处理的次数,int型
        :param rule1: rule1规则布尔值,布尔型
        :param rule2: rule2规则布尔值,布尔型
        :return: 达到平稳处理的最佳次数值和处理后的时间序列
        '''
        if rule1 and rule2:  # 如果两个规则同时满足
            return 0, ts  # 直接返回0和原始时间序列数据
        else:  # 只要有一个规则不满足
            for i in range(1, max_log):  # 循环做log处理
                ts = np.log(ts)  # log处理
                adf, pvalue1, usedlag, nobs, critical_values, icbest = adfuller(ts)  # 稳定性(ADF)检验
                lbvalue, pvalue2 = acorr_ljungbox(ts, lags=1)  # 白噪声(随机性)检验
                rule_1 = (adf < critical_values['1%'] and adf < critical_values['5%'] and adf < critical_values['10%'] and pvalue1 < 0.01)  # 稳定性(ADF)检验规则
                rule_2 = (pvalue2 < 0.05)  # 白噪声(随机性)规则
                rule_3 = (i < 5)
                if rule_1 and rule_2 and rule_3:  # 如果同时满足条件
                    # print ('The best log n is: {0}'.format(i))  # 打印输出最佳次数
                    return i, ts  # 返回最佳次数和处理后的时间序列
    
    
    
    # 还原经过平稳处理的数据
    def recover_log(ts, log_n):
        '''
        :param ts: 经过log方法平稳处理的时间序列,Series类型
        :param log_n: log方法处理的次数,int型
        :return: 还原后的时间序列
        '''
        for i in range(1, log_n + 1):  # 循环多次
            ts = np.exp(ts)  # log方法还原
        return ts  # 返回时间序列
    
    
    
    # 稳定性(ADF)检验
    def adf_val(ts, ts_title, acf_title, pacf_title):
        '''
        :param ts: 时间序列数据,Series类型
        :param ts_title: 时间序列图的标题名称,字符串
        :param acf_title: acf图的标题名称,字符串
        :param pacf_title: pacf图的标题名称,字符串
        :return: adf值、adf的p值、三种状态的检验值
        '''
        # plt.figure()
        # plt.plot(ts)  # 时间序列图
        # plt.title(ts_title)  # 时间序列标题
        # plt.show()
        # plot_acf(ts, lags=20, title=acf_title).show()  # 自相关检测
        # plot_pacf(ts, lags=20, title=pacf_title).show()  # 偏相关检测
        adf, pvalue, usedlag, nobs, critical_values, icbest = adfuller(ts)  # 稳定性(ADF)检验
        table_name = ['adf', 'pvalue', 'usedlag', 'nobs', 'critical_values', 'icbest']  # 表格列名列表
        table_rows = [[adf, pvalue, usedlag, nobs, critical_values, icbest]]  # 表格行数据,嵌套列表
        adf_table = pre_table(table_name, table_rows)  # 获得平稳性展示表格对象
        # print ('stochastic score')  # 打印标题
        # print (adf_table)  # 打印展示表格
        return adf, pvalue, critical_values,  # 返回adf值、adf的p值、三种状态的检验值
    
    
    
    # 白噪声(随机性)检验
    def acorr_val(ts):
        '''
        :param ts: 时间序列数据,Series类型
        :return: 白噪声检验的P值和展示数据表格对象
        '''
        lbvalue, pvalue = acorr_ljungbox(ts, lags=1)  # 白噪声检验结果
        table_name = ['lbvalue', 'pvalue']  # 表格列名列表
        table_rows = [[lbvalue, pvalue]]  # 表格行数据,嵌套列表
        acorr_ljungbox_table = pre_table(table_name, table_rows)  # 获得白噪声检验展示表格对象
        # print ('stationarity score')  # 打印标题
        # print (acorr_ljungbox_table)  # 打印展示表格
        return pvalue  # 返回白噪声检验的P值和展示数据表格对象
    
    
    # arma最优模型训练
    def arma_fit(ts):
        '''
        :param ts: 时间序列数据,Series类型
        :return: 最优状态下的p值、q值、arma模型对象、pdq数据框和展示参数表格对象
        '''
        max_count = int(len(ts) / 10)  # 最大循环次数最大定义为记录数的10%
        bic = float('inf')  # 初始值为正无穷
        tmp_score = []  # 临时p、q、aic、bic和hqic的值的列表
        for tmp_p in range(max_count + 1):  # p循环max_count+1次
            for tmp_q in range(max_count + 1):  # q循环max_count+1次
                model = ARMA(ts, order=(tmp_p, tmp_q))  # 创建ARMA模型对象
                try:
                    results_ARMA = model.fit(disp=-1, method='css')  # ARMA模型训练
                except:
                    continue  # 遇到报错继续
                finally:
                    tmp_aic = results_ARMA.aic  # 模型的获得aic
                    tmp_bic = results_ARMA.bic  # 模型的获得bic
                    tmp_hqic = results_ARMA.hqic  # 模型的获得hqic
                    tmp_score.append([tmp_p, tmp_q, tmp_aic, tmp_bic, tmp_hqic])  # 追加每个模型的训练参数和结果
                    if tmp_bic < bic:  # 如果模型bic小于最小值,那么获得最优模型ARMA的下列参数:
                        p = tmp_p  # 最优模型ARMA的p值
                        q = tmp_q  # 最优模型ARMA的q值
                        model_arma = results_ARMA  # 最优模型ARMA的模型对象
                        aic = tmp_bic  # 最优模型ARMA的aic
                        bic = tmp_bic  # 最优模型ARMA的bic
                        hqic = tmp_bic  # 最优模型ARMA的hqic
        pdq_metrix = np.array(tmp_score)  # 将嵌套列表转换为矩阵
        pdq_pd = pd.DataFrame(pdq_metrix, columns=['p', 'q', 'aic', 'bic', 'hqic'])  # 基于矩阵创建数据框
        table_name = ['p', 'q', 'aic', 'bic', 'hqic']  # 表格列名列表
        table_rows = [[p, q, aic, bic, hqic]]  # 表格行数据,嵌套列表
        parameter_table = pre_table(table_name, table_rows)  # 获得最佳ARMA模型结果展示表格对象
        # print ('each p/q traning record')  # 打印标题
        # print (pdq_pd)  # 打印输出每次ARMA拟合结果,包含p、d、q以及对应的AIC、BIC、HQIC
        # print ('best p and q')  # 打印标题
        # print (parameter_table)  # 输出最佳ARMA模型结果展示表格对象
        return model_arma  # 最优状态下的arma模型对象
    
    
    # 模型训练和效果评估
    def train_test(model_arma, ts, log_n, rule1=True, rule2=True):
        '''
        :param model_arma: 最优ARMA模型对象
        :param ts: 时间序列数据,Series类型
        :param log_n: 平稳性处理的log的次数,int型
        :param rule1: rule1规则布尔值,布尔型
        :param rule2: rule2规则布尔值,布尔型
        :return: 还原后的时间序列
        '''
        train_predict = model_arma.predict()  # 得到训练集的预测时间序列
        if not (rule1 and rule2):  # 如果两个条件有任意一个不满足
            train_predict = recover_log(train_predict, log_n)  # 恢复平稳性处理前的真实时间序列值
            ts = recover_log(ts, log_n)  # 时间序列还原处理
        ts_data_new = ts[train_predict.index]  # 将原始时间序列数据的长度与预测的周期对齐
        RMSE = np.sqrt(np.sum((train_predict - ts_data_new) ** 2) / ts_data_new.size)  # 求RMSE
    
        print("均方根误差为:%s" %RMSE)
        # # 对比训练集的预测和真实数据
        # plt.figure()  # 创建画布
        # train_predict.plot(label='predicted data', style='--')  # 以虚线展示预测数据
        # ts_data_new.plot(label='raw data')  # 以实线展示原始数据
        # plt.legend(loc='best')  # 设置图例位置
        # plt.title('raw data and predicted data with RMSE of %.2f' % RMSE)  # 设置标题
        # plt.show()  # 展示图像
        return ts  # 返回还原后的时间序列
    
    
    # 预测未来指定时间项的数据
    def predict_data(model_arma, ts, log_n,start, end,rule1=True, rule2=True):
        '''
        :param model_arma: 最优ARMA模型对象
        :param ts: 时间序列数据,Series类型
        :param log_n: 平稳性处理的log的次数,int型
        :param start: 要预测数据的开始时间索引
        :param end: 要预测数据的结束时间索引
        :param rule1: rule1规则布尔值,布尔型
        :param rule2: rule2规则布尔值,布尔型
        :return: 无
        '''
    
        m1=string_toDatetime(end)-string_toDatetime(start)
        # 预测未来指定时间项的数据
        predict_ts = model_arma.predict(start=len(ts)-5, end=len(ts)+m1.days+1)
        beginDate =ts.index[len(ts)-6]
        endDate = string_toDatetime(end)
        m = datelist(beginDate, endDate)
        # print(m)
        print ('-----------predict data----------')  # 打印标题
        if not (rule1 and rule2):  # 如果两个条件有任意一个不满足
            predict_ts = recover_log(predict_ts, log_n)  # 还原数据
    
        predict_ts_dataframe=pd.DataFrame(predict_ts,columns = ['number'])
    
        # print(predict_ts_dataframe)
        predict_ts_dataframe['day']=m
    
    
        pre_result=predict_ts_dataframe[predict_ts_dataframe['day']>=start]
        kk=list(pre_result.loc[:,'number'].apply(lambda x: x*10))
        # 展示预测数据
        pre_result2=pd.DataFrame({"day":pre_result['day'],"number":kk})
        print(pre_result2)
    
        #####输出csv
        pre_result2.to_csv("C:\\Users\\xiaohu\\Desktop\\销售数据预测\\训练数据\\pre_result2.csv", index=False)
    
    
    
    
    
    if __name__ == '__main__':
    
        # 读取数据
        # date_parse = lambda dates: pd.datetime.strptime(dates, '%Y/%m/%d')  # 创建解析列的功能对象
        # df = pd.read_table('C:\\Users\\xiaohu\\Desktop\销售数据预测\\训练数据\\train_2018.txt', delimiter='\t', index_col='date', date_parser=date_parse)  # 读取数据
    
        # 读取数据
        date_parse = lambda dates: pd.datetime.strptime(dates, '%Y-%m-%d')  # 创建解析列的功能对象
        df = pd.read_table('C:\\Users\\xiaohu\\Desktop\\book\\chapter4\\time_series4.txt', delimiter='\t', index_col='date',date_parser=date_parse)  # 读取数据
    
    
    
        # print(df)
    
        ts_data = df['number'].astype('float32')  # 将列转换为float32类型
        # print ('data summary')  # 打印标题
        # print (ts_data.describe())  # 打印输出时间序列数据概况
    
    
    
        # 原始数据检验
        adf, pvalue1, critical_values = adf_val(ts_data, 'raw time series', 'raw acf', 'raw pacf')  # 稳定性检验
        pvalue2 = acorr_val(ts_data)  # 白噪声检验
    
    
        # 创建用于区分是否进行平稳性处理的规则
        rule1 = (adf < critical_values['1%'] and adf < critical_values['5%'] and adf < critical_values[
            '10%'] and pvalue1 < 0.01)  # 稳定性检验
        rule2 = (pvalue2[0,] < 0.05)  # 白噪声检验
    
    
    
    
    
    
        # 对时间序列做稳定性处理
        log_n, ts_data = get_best_log(ts_data, max_log=5, rule1=rule1, rule2=rule2)
        # 再次做检验
        adf, pvalue1, critical_values = adf_val(ts_data, 'final time series', 'final acf', 'final pacf')  # 稳定性检验
        pvalue2 = acorr_val(ts_data)  # 白噪声检验
    
    
    
    
        # 训练最佳ARMA模型并输出相关参数和对象
       # model_arma = arma_fit(ts_data)
    
    
        # sklearn中提供了高效的模型持久化模块joblib,将模型保存至硬盘。
        #joblib.dump(model_arma, 'C:\\Users\\xiaohu\\Desktop\\销售数据预测\\训练数据\\model_arma_day.model')# 模型导出
        model_arma = joblib.load('C:\\Users\\xiaohu\\Desktop\\销售数据预测\\训练数据\\model_arma_day.model')# 模型导入
        #
    
    
        # 模型训练和效果评估
        ts_data = train_test(model_arma, ts_data, log_n, rule1=rule1, rule2=rule2)
        # print(ts_data)
    
    
        # # 模型预测应用
        start ='2018-06-04'  # 设置预测开始的时间索引
        end ='2018-06-10'  # 设置预测结束的时间索引
        predict_data(model_arma, ts_data, log_n,start,end ,rule1=rule1, rule2=rule2)  # 预测时间序列数据
    
        time2=time.time()
        print('总共耗时:' + str(time2 - time1) + 's')
    展开全文
  • VR虚拟现实ARIMA模型预测 5ARIMA模型预测 5.1模型选取 目前学术界较为成熟的预测方法很多各种不同的预测方法有其所面向的特定对象不存在一种普遍最好的预测方法GM1,1模型预测是以灰色系统理论为基础通过原始数据的...
  • 对数据进行分析,接着进行ARIMA模型拟合,对接下来的进行预测
  • 基于ARIMA模型预测我国2020年汽车整车及零配件进口情况
  • ARIMA 是预测算法下时间序列分析的一部分,本文尝试使用 ARIMA 模型预测在 NIFTY100 上市的印度选定制药公司的股价。 从 2017 年 1 月 1 日到 2019 年 12 月 31 日,每个选定的制药公司的 782 个时间序列观察的样本...
  • 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

    展开全文
  • VR虚拟现实ARIMA模型预测GDP 刘春锋的论文请勿作抄袭使用 基于ARIMA模型对河南省2010年GDP预测 摘要ARIMA模型是对ARMA模型的差分得到的平稳时间序列模型具有序列相关性本文收集了1978-2009年河南省GDP数据根据ARIMA...
  • %adf检验,判断时间序列是否平稳化 end %---------模型定阶或识别-------------- u = iddata(TempData); test = []; for p = 1:5 %自回归对应PACF,给定滞后长度上限p和q,一般取为T/10、ln(T)或T^(1/2),这里取T/10=...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    y=xlsread('E:\数据3.xls','a1:a300')

    Data=y; %共300个数据

    SourceData=Data(1:250,1); %前250个训练集

    step=50; %后50个测试

    TempData=SourceData;

    TempData=detrend(TempData);%去趋势线

    TrendData=SourceData-TempData;%趋势函数

    %--------差分,平稳化时间序列---------

    H=adftest(TempData);

    difftime=0;

    SaveDiffData=[];

    while ~H

    SaveDiffData=[SaveDiffData,TempData(1,1)];

    TempData=diff(TempData);%差分,平稳化时间序列

    difftime=difftime+1;%差分次数

    H=adftest(TempData);%adf检验,判断时间序列是否平稳化

    end

    %---------模型定阶或识别--------------

    u = iddata(TempData);

    test = [];

    for p = 1:5 %自回归对应PACF,给定滞后长度上限p和q,一般取为T/10、ln(T)或T^(1/2),这里取T/10=12

    for q = 1:5 %移动平均对应ACF

    m = armax(u,[p q]);

    AIC = aic(m); %armax(p,q),计算AIC

    test = [test;p q AIC];

    end

    end

    for k = 1:size(test,1)

    if test(k,3) == min(test(:,3)) %选择AIC值最小的模型

    p_test = test(k,1);

    q_test = test(k,2);

    break;

    end

    end

    %------1阶预测-----------------

    TempData=[TempData;zeros(step,1)];

    n=iddata(TempData);

    m = armax(u,[p_test q_test]);

    %m = armax(u(1:ls),[p_test q_test]); %armax(p,q),[p_test q_test]对应AIC值最小,自动回归滑动平均模型

    P1=predict(m,n,1);

    PreR=P1.OutputData;

    PreR=PreR';

    %----------还原差分-----------------

    if size(SaveDiffData,2)~=0

    for index=size(SaveDiffData,2):-1:1

    PreR=cumsum([SaveDiffData(index),PreR]);

    end

    end %-------------------预测趋势并返回结果----------------

    mp1=polyfit([1:size(TrendData',2)],TrendData',1);

    xt=[];

    for j=1:step

    xt=[xt,size(TrendData',2)+j];

    end

    TrendResult=polyval(mp1,xt);

    PreData=TrendResult+PreR(size(SourceData',2)+1:size(PreR,2));

    tempx=[TrendData',TrendResult]+PreR; % tempx为预测结果

    plot(tempx,'r');

    hold on

    plot(Data,'b');

    最后预测的图怎么是那样的。。

    展开全文
  • R语言时间序列(time series)分析实战:使用ARIMA模型预测时间序列 目录 R语言时间序列(time series)分析实战:使用ARIMA模型预测时间序列 #数据集 #加载时间序列数据 #ARIMA模型 #选择合适的ARIMA模型 ...

    R语言时间序列(time series)分析实战:使用ARIMA模型预测时间序列

    目录

    展开全文
  • R语言 时间序列分析之ARIMA模型预测

    千次阅读 2017-04-08 18:49:51
    原文地址:R语言学习日记——时间序列分析之ARIMA模型预测作者:Kevin ARIMA预测时间序列: 指数平滑法对于预测来说是非常有帮助的,而且它对时间序列上面连续的值之间相关性没有要求。但是,如果你想使用...
  • R语言时间序列分析之ARIMA模型预测

    万次阅读 2015-11-10 22:48:52
    R语言时间序列分析之ARIMA模型预测   今天学习ARIMA预测时间序列。  指数平滑法对于预测来说是非常有帮助的,而且它对时间序列上面连续的值之间相关性没有要求。但是,如果你想使用指数平滑法计算出...
  • 本文是我们通过时间序列和ARIMA模型预测拖拉机销售的制造案例研究示例的延续。您可以在以下链接中找到以前的部分: 第1部分:时间序列建模和预测简介 第2部分:在预测之前将时间序列分解为解密模式和趋势 第3部分...
  • 在这篇文章中,我们将介绍流行的ARIMA预测模型,以预测库存的回报,并演示使用R编程的ARIMA建模的逐步过程。 时间序列中的预测模型是什么? 预测涉及使用其历史数据点预测变量的值,或者还...
  • 概述 : 在这个脚本中,它使用 MATLAB 中的 ARIMA 模型预测股票价格。 使用现实生活数据,它将探索如何管理时间戳数据和调整 ARIMA 模型的参数(积分度、自回归阶数、移动平均阶数)。 在 ARIMA 模型之前,它需要...
  • 三、模型预测 运用上述得到的 ARIMA(2,2,1)模型对全国硕士研究生报名人数及置信水平分别为80%和90%双层置信区间进行预测,并给出预测表和预测图如下。 > kaoyanpredict.fore(am221,h=3) > kaoyanpredict.fore > ...
  • 机器学习-ARIMA模型预测

    千次阅读 2020-05-24 10:32:34
    ARIMA模型全称是自回归移动平均模型(Autoregressive Integrated Moving Average Model),...ARIMA模型的核心思想是将预测对象随时间推移而形成的数据序列视为一个随机序列,以时间序列的自相关分析为基础,用一定的数据
  • 通过数学模型预测资源消费量,是当今最精确、最流行的预测方法
  • 时间序列模型对产品销量的月预测任务:做出一个时间序列预测模型,从而实现对一系列产品销量的月预测方法:针对数据特征,采用了ARIMA模型。并成功实现了任务在这里预设了8种数据预处理模型,从而使数据平稳,保证尽...
  • 时间序列分析之ARIMA模型预测__R篇

    万次阅读 2017-01-20 10:24:19
    之前一直用SAS做ARIMA模型预测,今天尝试用了一下R,发现灵活度更高,结果输出也更直观。现在记录一下如何用R分析ARIMA模型。   1. 处理数据 1.1. 导入forecast包 forecast包是一个封装的ARIMA统计...
  • python 时间序列ARIMA模型预测

    千次阅读 2019-12-26 10:41:37
    时间序列ARIMA模型 平稳性检验与纯随机性检验 python时序预测的7种方法 经验模态分解EMD ARIMA模型 安装statsmodels pip install statsmodels 建模过程 一、时间序列预处理 注意: 1、白噪声时序也是...
  • P500股指的ARIMA模型预测与残差ARCH效应分析前言一、数据及分析目的二、数据探索三、ARIMA模型构建四、残差分析五、模型预测 前言 由于R语言对新手并不够友好,网上的资料相对也偏少,导致博主在使用R进行时间序列...
  • ARIMA模型预测后出现一条直线的原因

    千次阅读 2020-12-23 21:15:44
    最近又有朋友来询问为何他的时序数据用ARIMA模型后...首先,使用ARIMA模型进行时序预测为何会出现是一条直线? 解答:简单来说是因为你的时序数据中存在“季节周期性”(注:这里的季节性是泛指)特征。所以模型无
  • 本文是我们通过时间序列和ARIMA模型预测拖拉机销售的制造案例研究示例的延续。您可以在以下链接中找到以前的部分: 第1部分:时间序列建模和预测简介 第2部分:在预测之前将时间序列分解为解密模式和趋势 第3部分...
  • 这项研究旨在找到一个模型,使用自回归综合移动平均值(ARIMA)来预测每月的麻疹免疫接种率。 该模型的开发使用了2014年1月至2018年12月的月度麻疹免疫覆盖率注册数据。 归一化贝叶斯信息准则(BIC)最小为8.673的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,260
精华内容 1,704
关键字:

arima模型预测