java 时间序列预测_ARIMA模型 预测时间序列 JAVA实现

最新推荐文章于 2024-07-03 15:17:29 发布
最新推荐文章于 2024-07-03 15:17:29 发布
阅读量1.4k 收藏 2
点赞数
文章标签： java 时间序列预测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34742806/article/details/114226214
版权
该博客介绍了如何使用Java实现ARIMA模型来处理时间序列预测。ARIMA类包含了预处理方法如一阶差分、归一化以及ARIMA模型的构建。通过对不同差分类型的处理，例如一阶普通差分和季节性差分，进行数据预处理，然后通过计算AIC值选择最佳模型参数，从而进行预测。
摘要由CSDN通过智能技术生成

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 armaARMAcoe=new Vector();

Vector bestarmaARMAcoe=new Vector();

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

{

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

{

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[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

{

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

{

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

{

temp=0;

for(int i=1;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

{

temp=0;

for(int i=0;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

{

temp=0;

temp2=0;

for(int i=0;i

{

temp+=arPara[i]*stdoriginalData[k-i-1];

}

for(int i=1;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 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

// 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

{

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

{

temp=0;

for(int i=0;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

{

temp=0;

temp2=0;

for(int i=0;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 para;

public modelandpara(int[] model,Vector para)

{

this.model=model;

this.para=para;

}

}

公子京
关注
Java 实现 时序预测 ARIMA模型 DEMO
10-27
Java 实现 时序预测 ARIMA模型 DEMO
Java时间序列预测(ARIMA)
yungge的博客
05-24 2765
有时候我们需要在Java里对时间序列的数据进行简单地预测,通过其他语言(Python或R)来实现会极大的提高开发和运维成本.另外,很多数学模型的原理比较复杂,并且涉及到模型训练和参数调优,这些也会加大我们的时间投入.本文尝试向大家分享一个大家需要了解算法,不需要参数调优就可以直接引用.
Java中使用arima预测未来数据
最新发布
feng905001561的专栏
07-03 534
arima预估值
【使用分享】Java使用weka进行时间序列预测
Ry1的博客
04-28 2640
本教程将向您展示如何使用Weka库在Java中进行基于时间序列数据的预测。我们将使用示例数据集，该数据集包含每月销售额的历史记录，并尝试预测未来12个月的销售额。
java 时间序列预测_LSTM - 时间序列预测
weixin_35662417的博客
02-13 655
Process one by one在这样的循环中完全相同：for epoch in range(numberOfEpochs):for sequence in yourSequences:model.reset_states()#1 - do the entire training for this sequence (1 epoch only)#you may use "model.train...
Python一行代码实现ADF检验（时间序列平稳性检验）（包含结果解读）
yyx的博客
02-09 7029
在做时间序列的平稳性检验时，经常会用到ADF检验法 如何用python写一个ADF检验平稳性呢？ 又该如何理解ADF检验的结果呢？ 很简单： # ADF result = adfuller(y_list) print('The result of ADF: ') print(result) 其中 y_list 是 List 类型变量 输出结果显示为 (-3.5847310180083602, 0.006059737672943494, 11, 355, {‘1%’: -3.44890553465
关于趋势预测，Java时间序列预测(ARIMA)
cai_xu_kun_kun的博客
09-26 735
【代码】关于趋势预测，Java时间序列预测(ARIMA)
ARIMA时间序列算法预测完整包
07-29
ARIMA（自回归整合滑动平均模型）是一种广泛应用于时间序列预测的重要统计工具，尤其在经济、金融、气象、工程等领域有着广泛的应用。这个“ARIMA时间序列算法预测完整包”可能包含了一系列的代码、教程或者案例研究...
ARIMA时间序列理论基础+JAVA代码实现
08-20
总之，ARIMA模型在时间序列预测中起着关键作用，而Java作为一种通用编程语言，提供了实现这一模型的工具和库。理解ARIMA模型的原理并掌握其在Java中的应用，对于解决各种预测问题是非常有价值的。
ARMA-Java--master.zip_AR建模_arima预测_math3 ARMA_序列 预测_非参数回归
07-14
ARIMA模型是通过将预测对象随时间推移而形成的数据序列当成一个随机序列，进而用一定的数学模型来近似表述该序列。根据原序列是否平稳以及回归中所包含部分的不同分为AR、MA、ARMA以及ARIMA过程。 在模型的使用过程...
arima的pq值matlab代码-timeseries-forecast:这是一个提供时间序列预测功能的Java开源库
06-02
arima的pq值matlab代码时间序列-预测 这是一个提供时间序列预测功能的 Java 开源库。 它是加法模型的实现。 该库由 Workday 的 Syman 团队发布，用于支持某些 Workday 产品中的基本时间序列预测功能。 如何使用 为了使用这个库，您需要提供输入时间序列数据以及 ARIMA 参数。 ARIMA 参数包括 a) 非季节性参数p,d,q和 b) 季节性参数P,D,Q,m 。 如果D或m小于 1，则模型被认为是非季节性的，并且季节性参数P,D,Q,m将不起作用。 import com.workday.insights.timeseries.arima.Arima ; import com.workday.insights.timeseries.arima.struct.ForecastResult ; // Prepare input timeseries data. double [] dataArray = new double [] { 2 , 1 , 2 , 5 , 2 , 1 , 2 , 5 , 2 , 1 , 2 , 5 , 2 , 1 , 2 ,
java-timeseries:Java中的时间序列分析
05-15
Java时间序列 Java中的时间序列分析。 公告内容 预发行版本0.4现在可用。 项目groupId已更改为com.github.signaflo。 有关更新的坐标，请参见下面的“使用”部分。 特征 季节性ARIMA模型。 ARIMA预测和模拟。 随机游走模拟和建模。 时间序列统计，移动平均值和聚合。 简单，直观且功能强大的时间建模。 自相关函数和ACF图。 使用 请注意，该库仍处于早期开发阶段。 预计在不久的将来会对API进行重大更改。 玛文 < dependency> < groupId>com.github.signaflo</ groupId> < artifactId>timeseries</ artifactId> < version>0.4</ version> </ dependency> Gradle compile
ARIMA JAVA 实现
06-10
JAVA实现的ARIMA 模型，可以预测一个数值，若需要预测多个，可以修改
arima 算法 JAVA 实现.zip
07-06
总之，ARIMA模型是时间序列预测的重要工具，通过Java实现可以将这种统计方法集成到数据分析系统中。理解模型背后的理论，结合适当的库和编程技巧，可以在各种领域，如金融、气象预报、销售预测等，应用ARIMA模型进行...
使用java-timeseries库，使用arima算法预测时间序列（
WonderKing'blog
05-09 1561
【代码】使用java-timeseries库，使用arima算法预测时间序列（
ARIMA模型 预测时间序列 JAVA实现
付石头的博客
12-10 9252
最近要用ARIMA模型预测用户的数量变化，所以调研了一下ARIMA模型，最后用JAVA实现了ARIMA算法。 一、ARIMA原理 ARIMA的原理主要参考的是ARIMA原理。 二、JAVA实现 弄懂了原理，用JAVA进行了实现，主要参考的步骤是ARIMA实现步骤，JAVA代码如下 (1)AR类，用于构建AR模型 package a...
java神经网络预测时间序列,在时间序列数据集上使用递归神经网络进行预测
weixin_36240214的博客
03-16 381
Description给定具有10个序列的数据集 - 序列对应于股票 Value 记录的一天 - 其中每个序列构成50个样本记录的库存值，从早晨或上午9:05开始以5分钟的间隔分开 . 但是，有一个额外的记录(第51个样本)仅在训练集中可用，该训练集是在50个样本记录中的最后记录样本的2小时后，而不是5分钟 . 对于测试集，需要预测第51个样本，其中还给出了前50个样本 .我正在使用 pybrai...
时间序列分析之 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 {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值