时间序列分析之ARIMA模型的JAVA实现

已于 2022-12-26 13:21:41 修改
阅读量1.4k 收藏 5
点赞数 1
分类专栏： java工具笔记 文章标签： java 开发语言
于 2022-12-26 12:37:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38567039/article/details/128442851
版权 
package com.zz.meridian.utils.algorithm.arima;

import java.util.Vector;

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=stdoriginalData;
		this.p=p;
	}
/**
 * 返回AR模型参数
 * @return
 */
	public Vector<double[]> ARmodel()
	{
		Vector<double[]> v=new Vector<double[]>();
		v.add(armamath.parcorrCompute(stdoriginalData, p, 0));
		return v;//得到了自回归系数
		
		//还要估计方差项吗？
	}
	
}


package com.zz.meridian.utils.algorithm.arima;


import com.alibaba.fastjson.JSON;

import java.util.List;
import java.util.Random;
import java.util.Vector;


public class ARIMA {

	double[] originalData={};
	ARMAMath armamath=new ARMAMath();
	double stderrDara=0;
	double avgsumData=0;
	Vector<double[]> armaARMAcoe=new Vector<double[]>();
	Vector<double[]> bestarmaARMAcoe=new Vector<double[]>();
	
/**
 * 构造函数
 * @param originalData 原始时间序列数据
 */
	public ARIMA(double [] originalData)
	{
		this.originalData=originalData;
	}
/**
 * 原始数据标准化处理：一阶季节性差分
 * @return 差分过后的数据
 */ 
	public double[] preDealDif()
	{
		
		//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;
	}
/**
 * 原始数据标准化处理：Z-Score归一化
 *  待处理数据
 * @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;
	}
/**
* 得到ARMA模型=[p,q]
 * @return ARMA模型的阶数信息
 */
	public int[] getARIMAmodel()
	{
		double[] stdoriginalData=this.preDealDif();//原始数据差分处理
		
		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}};//,{4,0},{0,4},{4,1},{1,4},{4,2},{2,4},{4,3},{3,4},{4,4}};
		//对8种模型进行迭代，选出AIC值最小的模型作为我们的模型
		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);
			System.out.println("AIC of these model="+temp);
			if (temp<minAIC)
			{
				bestModelindex=i;
				minAIC=temp;
				bestarmaARMAcoe=armaARMAcoe;
			}
		}
		
		return model[bestModelindex];
 	}
/**
 * 计算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=para.get(0);
			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=para.get(0);
			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=para.get(0);
			double[] maPara=para.get(1);
			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)
	{
		//System.out.println("predictBeforeDiff="+predictValue);
		return (int)(predictValue+originalData[originalData.length-7]);
	}
/**
 * 进行一步预测
 * @param p ARMA模型的AR的阶数
 * @param q ARMA模型的MA的阶数
 * @return 预测值
 */
	public int predictValue(int p,int q)
	{
		int predict=0;
		double[] stdoriginalData=this.preDealDif();
		int n=stdoriginalData.length;
		double temp=0,temp2=0;
		double[] err=new double[q+1];
	
		Random random=new Random();
		if(p==0)
		{
			double[] maPara=bestarmaARMAcoe.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); //产生预测
		}
		else if(q==0)
		{
			double[] arPara=bestarmaARMAcoe.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);
		}
		else
		{

			double[] arPara=bestarmaARMAcoe.get(0);
			double[] maPara=bestarmaARMAcoe.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);
			
		}
	
		
		return predict;
	}
/**
 * 计算MA模型的参数
 * @param autocorData 自相关系数Grma
 * @param q MA模型的阶数
 * @return 返回MA模型的参数
 */
	public double[] getMApara(double[] autocorData,int q)
	{
		double[] maPara=new double[q+1];//第一个存放噪声参数，后面q个存放ma参数sigma2,ma1,ma2...
		double[] tempmaPara=maPara;
		double temp=0;
		boolean iterationFlag=true;
		//解方程组
		//迭代法解方程组
		System.out.println("autocorData[0]"+autocorData[0]);
		while(iterationFlag)
		{
			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(maPara[i]!=tempmaPara[i])
				{
					iterationFlag=true;
					break;
				}
			}
			
			maPara=tempmaPara;
		}
		
		return maPara;
	}
	public static int[] generator(int size, List<Double> arraylist){

		int[] returnArray=new int[size];

		for (int i = 0; i <size ; i++) {
			double[] dataArray=new double[arraylist.size()];
			for(int j=0;j<arraylist.size()-1;j++) {
				dataArray[j] = arraylist.get(j);
			}
			//使用当前数据训练ARIMA模型
			ARIMA arima=new ARIMA(dataArray);
			//获得ARIM模型
			int []model=arima.getARIMAmodel();
			System.out.println("Best model is [p,q]="+"["+model[0]+" "+model[1]+"]");
			System.out.println("最佳模型是[p,q]="+"["+model[0]+" "+model[1]+"]");
			int deal = arima.aftDeal(arima.predictValue(model[0], model[1]));
			System.out.println("Predict value="+deal);
			System.out.println("预测值="+deal);
			System.out.println("Predict error="+(deal-arraylist.get(arraylist.size()-1))/arraylist.get(arraylist.size()-1)*100+"%");
			System.out.println("预测差值="+(deal-arraylist.get(arraylist.size()-1))/arraylist.get(arraylist.size()-1)*100+"%");
			arraylist.add(deal+0.0);
			returnArray[i]=deal;
		}
		System.out.println(JSON.toJSON(arraylist));
		System.out.println(JSON.toJSON(returnArray));
		return returnArray;
	}
}


package com.zz.meridian.utils.algorithm.arima;

import java.util.Vector;

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=stdoriginalData;
		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模型里面的参数值
//		for(int i=0;i<macoe.length;i++)
//			{
//				System.out.println(macoe[i]);
//			}
//		System.out.println();
		Vector<double[]> v=new Vector<double[]>();
		v.add(arcoe);
		v.add(macoe);
		return v;
	}
	
	/**
	 * 得到MA的自相关系数
	 * @param p
	 * @param q
	 * @param stdoriginalData
	 * @param autoRegress
	 * @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);
	}
}


package com.zz.meridian.utils.algorithm.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;
			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=maPara;
		double temp=0;
		boolean iterationFlag=true;
		//解方程组
		//迭代法解方程组
		maPara[0]=1;//初始化
		while(iterationFlag)
		{
			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]/maPara[0]-temp);
			}
			iterationFlag=false;
			for(int i=0;i<maPara.length;i++)
			{
				if(maPara[i]!=tempmaPara[i])
				{
					iterationFlag=true;
					break;
				}
			}
			
			maPara=tempmaPara;
		}
		
		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]=返回值
	}

	
	}


package com.zz.meridian.utils.algorithm.arima;

import java.util.Vector;

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=stdoriginalData;
		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模型里面的参数值
	}
		
	
}


package com.zz.meridian.utils.algorithm.arima;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

import static com.alibaba.druid.sql.ast.SQLPartitionValue.Operator.List;

public class Test1 {

    public static void main(String args[]) {
//		extracted();
		ArrayList<Double> arraylist = new ArrayList<Double>();
		arraylist.add(1.0d);
		arraylist.add(2.0d);
		arraylist.add(3.0d);
		arraylist.add(4.0d);
		arraylist.add(5.0d);
		arraylist.add(6.0d);
		arraylist.add(7.0d);
		arraylist.add(8.0d);
		arraylist.add(8.0d);
		arraylist.add(8.0d);
		arraylist.add(8.0d);
		arraylist.add(8.0d);
		int[] ints = ARIMALists(arraylist);
		System.err.println(Arrays.toString(ints));
	}

	private static int[] ARIMALists(ArrayList<Double> arraylist) {
    	if (arraylist.size()<10){
			System.out.println("创建ARIMA模型数据最少10条");
    		return null;
		}
		int[] ints = ARIMA.generator2(5, arraylist);
		return ints;
	}

	private static void extracted() {
		Scanner ino = null;

		try {
			ArrayList<Double> arraylist = new ArrayList<Double>();
			ino = new Scanner(new File("E:\\java_project\\siweikeji\\meridian\\code\\meridian\\src\\main\\java\\com\\zz\\meridian\\utils\\algorithm\\arima\\ceshidata1.txt"));
			while (ino.hasNext()) {
				arraylist.add(Double.parseDouble(ino.next()));
			}
			double[] dataArray = new double[arraylist.size() - 1];
			for (int i = 0; i < arraylist.size() - 1; i++) {
				dataArray[i] = arraylist.get(i);
			}

			ARIMA.generator(5, arraylist);
			//System.out.println(arraylist.size());
//			ARIMA arima=new ARIMA(dataArray);
//
//			int []model=arima.getARIMAmodel();
//			System.out.println("Best model is [p,q]="+"["+model[0]+" "+model[1]+"]");
//			System.out.println("Predict value="+arima.aftDeal(arima.predictValue(model[0],model[1])));
//			System.out.println("Predict error="+(arima.aftDeal(arima.predictValue(model[0],model[1]))-arraylist.get(arraylist.size()-1))/arraylist.get(arraylist.size()-1)*100+"%");
//
			//	String[] str = (String[])list1.toArray(new String[0]);

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			ino.close();
		}
	}


}


ceshidata1.txt文件
1156535
1291442
1359713
1374810
1416035
1528192
1521013
1156535
1291442
1359713
1374810
1455568
1534559
1517461
1384346

tiger_angel
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
时间序列分析之 ARIMA 模型的JAVA实现
AdairZhao
01-26 2万+
最近要用ARIMA模型预测用户的数量变化，所以调研了一下ARIMA模型，最后用JAVA实现了ARIMA算法。 一、ARIMA原理 ARIMA的原理主要参考的是ARIMA原理。 二、JAVA实现 弄懂了原理，用JAVA进行了实现，主要参考的步骤是ARIMA实现步骤， JAVA代码如下package arima; import java.util.*; public class AR {
JAVA实现ARIMA
03-22
用JAVA语言实现ARIMA模型，可以用于预测一组连续的时间序列
ARIMA模型原理及其java实现
热门推荐
u013201628的博客
03-15 1万+
ARIMA模型原理及其java实现一.基本原理ARIMA模型是通过将预测对象随时间推移而形成的数据序列当成一个随机序列，进而用一定的数学模型来近似表述该序列。根据原序列是否平稳以及回归中所包含部分的不同分为AR、MA、ARMA以及ARIMA过程。
ARIMA学习
酒中仙的专栏
03-22 1368
目录 1 ARIMA理论介绍 1.1 模型构成 1.1.1 AR模型 1.1.2 MA模型 1.1.3 ARMA模型 1.1.4 I差分 1.2 模型定阶 2 模型分析 2.1 是否选择ARIMA模型 2.1.1 Prophet 2.1.2 holt-winter模型 2.1.3 ARIMA模型 2.2 实现方式 2.2.1 Python实现 2.2.2 Jav...
基于Python实现时间序列分析建模(ARIMA模型)项目实战
10-31
【项目实战】基于Python实现时间序列分析建模(ARIMA模型)项目实战 内容包括： 资料说明：包括数据集+源代码+PDF文档说明+代码视频讲解。 资料内容包括： 1)项目背景； 2)数据收集； 3)数预处理； 4)RBF神经网络半导体刻蚀机故障诊断模型的构建； 5)模型评估； 6)实际应用。
ARIMA时间序列算法预测完整包
07-29
ARIMA时间序列算法预测完整包，可以预测序列数据不变的数据
ARIMA时间序列（JAVA示例代码，含注释）
最新发布
牟云飞的博客
12-20 500
算法模型上p、d、q阶差在3以内，阶差超过超过3，数据失真的可能性较高，所以我们设定3以内的阶差；拟合策略为USS，同时考虑季节性P D Q阶差，具体的p、d、q比例，选取所有的组合，通过AIC原则确定最优拟合方案，3以内的超参进行运算次数为（3*3*3）*（3*3*3）次，如果扩大超参运行增大，拟合策略为 CSSML(条件平方和，然后是最大似然), 除此之外还有：CSS, ML, CSSML, USS, USSML。创建工具类ArimaUti.java。pom.xml中引入。
Java时间序列预测(ARIMA)
yungge的博客
05-24 2029
有时候我们需要在Java里对时间序列的数据进行简单地预测,通过其他语言(Python或R)来实现会极大的提高开发和运维成本.另外,很多数学模型的原理比较复杂,并且涉及到模型训练和参数调优,这些也会加大我们的时间投入.本文尝试向大家分享一个大家需要了解算法,不需要参数调优就可以直接引用.
arima 算法 JAVA 实现.zip
07-06
arima 算法 JAVA 实现。包含参数估计、P，Q 定阶等 包含部分的分为AR、MA、ARMA以及ARIMA过程
java版arima
11-17
java撰写arima算法，有测试样例
数据趋势预测ARIMA算法实现
03-30
数据趋势预测分析的ARIMA算法JAVA实现，解压缩后导入eclipse工作空间即可测试使用
ARMA模型与ARIMA模型java实现例程
05-08
ARMA、ARIMA、AR、MA均是时间序列的重要方法。此例程中包含了以上所有的实现过程，java实现的，且含有main函数供自行调试，已亲测可用！
Java 实现 时序预测 ARIMA模型 DEMO
10-27
Java 实现 时序预测 ARIMA模型 DEMO
ARMA-Java--master.zip_AR建模_arima预测_math3 ARMA_序列 预测_非参数回归
07-14
ARIMA模型是通过将预测对象随时间推移而形成的数据序列当成一个随机序列，进而用一定的数学模型来近似表述该序列。根据原序列是否平稳以及回归中所包含部分的不同分为AR、MA、ARMA以及ARIMA过程。 在模型的使用过程中需要根据时间序列的自相关函数、偏自相关函数等对序列的平稳性进行判别；而对于非平稳序列一般都需要通过差分处理将其转换成平稳序列（ARIMA）；对得到的平稳序列进行建模以确定最佳模型（AR、MA、ARMA或者ARIMA）。在使用中最重要也是最关键的就是对序列进行参数估计，以检验其是否具有统计意义。
ARIMA时间序列理论基础+JAVA代码实现
08-20
ARIMA时间序列理论基础+JAVA代码实现 文档加代码 需要的自取
ARIMA模型时间序列数据分析python代码
06-27
使用ARIMA模型进行时间序列数据分析 编程语言：python 代码编辑器：jupyter notebook 适合想了解ARIMA模型的大致流程以及代码实现的朋友
ARIMA JAVA 实现
06-10
JAVA实现的ARIMA 模型，可以预测一个数值，若需要预测多个，可以修改
一个自己用JAVA实现的简单ARMA建模
04-25
一个自己用JAVA实现的ARMA模型，可以运行。实现比较简单，希望对大家有用。
MATLAB ARIMA 模型 做时间序列分析预测 matlab源码
03-01
资源名：MATLAB ARIMA 模型 做时间序列分析预测 matlab源码 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者更换。 适合人群...
如何用户Java实现时间序列分析算法
03-23
时间序列分析是一种用于研究时间序列数据的统计方法。Java中有许多库可以用于时间序列分析，其中最常用的是Apache Commons Math库和JFreeChart库。您可以使用这些库中的函数和类来实现时间序列分析算法。例如，您可以使用Apache Commons Math库中的ARIMA模型来进行时间序列预测，或使用JFreeChart库中的TimeSeries类来绘制时间序列图表。具体实现方法可以参考这些库的文档和示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值