精华内容
下载资源
问答
  • 本人在数学建模过程中撰写的matlab代码,完全可用,功能是利用BP神经网络对时间序列进行预测,内含matlab格式的数据,便于运行检验。
  • 阿里流行音乐预测代码,简单的,决定系数0.95左右。亲测有效,自己编的,可以机器学习快速入门使用
  • 时间序列预测matlab程序

    热门讨论 2012-10-26 16:20:21
    时间序列预测matlab程序
  • 时间序列预测代码matlab 多尺度时间序列预测 主要目标是构建一个预测模型,以同时预测多尺度时间序列集的输出。 输入数据是一组时间序列。 每个时间序列都包含某些信号的记录,并具有自己的观测值数量。 任务是预测...
  • matlab源码
  • matlab中实现ARIMA时间序列预测。函数形式如下: function [result] = ARIMA_algorithm(data, Periodicity, ACF_P, PACF_Q, n) 其中data为预测所用的数据,为一维列向量;Periodicity为数据的周期;ACF_P和PACF_Q...
  • 时间序列是按时间顺序排列的、随时间变化且相互关联的数据序列。分析时间序列的方法构成数据分析的一个重要领域,即时间序列分析。代码
  • MATLAB 时间序列预测算法(有代码)

    万次阅读 多人点赞 2019-09-05 09:57:44
    ##MATLAB 时间序列预测算法(有代码) #最近在学习时间序列,找了很多资料,都需要会员,充值,本着共同进步的原则,给大家分享一下我找到的学习资料,里面大部分代码能实现,只有ARMA部分不能,因为现在的库中没有...

    ##MATLAB 时间序列预测算法(有代码)
    #最近在学习时间序列,找了很多资料,都需要会员,充值,本着共同进步的原则,给大家分享一下我找到的学习资料,里面大部分代码能实现,只有ARMA部分不能,因为现在的库中没有garchset了,所以还在找替代的方法,有大佬知道了解,也希望伸出援助之手帮助我这个渣渣,谢谢。

    我是为了方便学习,就写在一个文档里了,你们实现的时候只要把你想用的算法前面的%去掉就好了。

    %平均移动法
    %clc;
    %clear all;
    %y=[0.35 0.33 0.29 0.19 0.23 0.24 0.39 0.37 0.21 0.21 0.21];
    %m=length(y);
    %n=[1,2]; % 自定义
    %for i=1:length(n)
     %   for j=1:m-n(i)+1
      %       yhat{i}(j)=sum(y(j:j+n(i)-1))/n(i);
       % end
        %y31(i)=yhat{i}(end);
        %s(i)=sqrt(mean((y(n(i)+1:m)-yhat{i}(1:end-1)).^2));
    %end
    %y31,s
    
    
    %加权平均
    %clc;
    %clear all;
    %y=[215 197 203 234 194 108 191 241 232 221 196 226 201 219 217 213 203 225 237 188 212 198 219 177 231 199 203];
    %w=[1/7;3/7;3/7];
    %m=length(y);n=3;
    %for i=1:m-n+1
     %   yhat(i)=y(i:i+n-1)*w;
        
    %end
    %yhat;
    %err=abs(y(n+1:m)-yhat(1:end-1))./y(n+1:m);
    %T_err=1-sum(yhat(1:end-1))/sum(y(n+1:m));
    %y1989=yhat(i)/(1-T_err);
    
    
    %趋势移动平均法
    %clc;
    %clear all;
    %y=[216 199 222 218 217 259 206 230 255 221 214 212 219 224 210 205 186 249 214 228 211 226 219 238 217 205 206];
    %y=[676 825 774 716 940 1159 1384 1524 1668 1688 1958 2031 2234 2566 2820 3006 3093 3277 3514 3770 4107];
    %m1=length(y);
    %n=6;
    %for i=1:m1-n+1
     %   yhat1(i)=sum(y(i:i+n-1))/n;
    %end
    %yhat1;
    %m2=length(yhat1);
    %for i=1:m2-n+1
     %   yhat2(i)=sum(yhat1(i:i+n-1))/n;
    %end
    %yhat2;
    %plot(1:27,y,'*');
    %a21=2*yhat1(end)-yhat2(end);
    %b21=2*(yhat1(end)-yhat2(end))/(n-1);
    %y1986=a21+b21
    %y1987=a21+2*b21
    
    
    %指数平滑法
    %clc,clear all;
    %yt=[216 199 222 218 217 259 206 230 255 221 214 212 219 224 210 205 186 249 214 228 211 226 219 238 217 205 206];
    %yt=[50 52 47 51 49 48 51 40 48 52 51 59];
    %n=length(yt); 
    %alpha=[0.2 0.5 0.8];m=length(alpha); 
    %yhat(1,1:m)=(yt(1)+yt(2))/2; 
    %for i=2:n 
     %yhat(i,:)=alpha*yt(i-1)+(1-alpha).*yhat(i-1,:); 
    %end
    %yhat;
    %y1=yt';
    %err=sqrt(mean((repmat(y1,1,m)-yhat).^2))
    %xlswrite('yt',yhat) ;
    %yhat1988=alpha*yt(n)+(1-alpha).*yhat(n,:)
    
    
    %三次指数平滑法
    %clc,clear;
    %yt=[20.04 20.06 25.72 34.61 51.77 55.92 80.65 131.11 148.58 162.67 232.26];
    %n=length(yt); 
    %alpha=0.3; st1_0=mean(yt(1:3)); st2_0=st1_0;st3_0=st1_0; 
    %st1(1)=alpha*yt(1)+(1-alpha)*st1_0; 
    %st2(1)=alpha*st1(1)+(1-alpha)*st2_0; 
    %st3(1)=alpha*st2(1)+(1-alpha)*st3_0; 
    %for i=2:n 
    % st1(i)=alpha*yt(i)+(1-alpha)*st1(i-1); 
    % st2(i)=alpha*st1(i)+(1-alpha)*st2(i-1); 
    % st3(i)=alpha*st2(i)+(1-alpha)*st3(i-1); 
    %end 
    %xlswrite('touzi.xls',[st1',st2',st3']) 
    %st1=[st1_0,st1];st2=[st2_0,st2];st3=[st3_0,st3]; 
    %a=3*st1-3*st2+st3; 
    %b=0.5*alpha/(1-alpha)^2*((6-5*alpha)*st1-2*(5-4*alpha)*st2+(4-3*alpha)*st3); 
    %c=0.5*alpha^2/(1-alpha)^2*(st1-2*st2+st3); 
    %yhat=a+b+c; 
    %xlswrite('touzi.xls',yhat','Sheet1','D1') 
    %plot(1:n,yt,'*',1:n,yhat(1:n),'O') 
    %legend('实际值','预测值') 
    %xishu=[c(n+1),b(n+1),a(n+1)]; 
    %yhat1990=polyval(xishu,2)
    
    
    %自适应滤波法
    %clc,clear;
    %yt=[217 207.5 215 223 222 221.5 209 213 217 213 217 215];
    %m=length(yt);k=0.083;
    %N=12;Terr=10000;
    %w=ones(1,N)/N;
    %while abs(Terr)>0.00001
     %   Terr=[];
      %  for j=N+1;m-1
         %    yhat(j)=w*yt(j-1:-1:j-N)';
          %   err=yt(j)-yhat(j);
            % Terr=[Terr,abs(err)];
            % w=w+2*k*err*yt(j-1:-1:j-N);
        % end
       %  Terr=max(Terr);
     %end
     %w,yhat
     
     
    %趋势外推预测法——修正指数曲线法(以下三种类似,选S标准误差小的模型)
    %function chanliang
    %clc,clear;
    %global a b k
    %%yt=[217 207.5 215 223 222 221.5 209 213 217 213 217];
    %yt=[42.1 47.5 52.7 57.7 62.5 67.1 71.5 75.7 79.8 83.7 87.5 91.1 94.6 97.9 101.1];
    %n=length(yt);m=n/3;
    %%值得注意的是,并不是任何一组数据都可以用修正指数曲线拟合。采用前应对数据进行检验,检验方法是看给定数据的逐期增长量的比率是否接近某一常数b
    %cf=diff(yt);
    %for i=1:n-2
     %   bzh(i)=cf(i+1)/cf(i)
    %end
    %range=minmax(bzh)     %b的范围
    %s1=sum(yt(1:m)),s2=sum(yt(m+1:2*m)),s3=sum(yt(2*m+1:end))
    %b=((s3-s2)/(s2-s1))^(1/m)
    %a=(s2-s1)*(b-1)/(b*(b^m-1)^2)
    %k=(s1-a*b*(b^m-1)/(b-1))/m
    %y=yuce(1:18)
    %定义预测函数
    %function y=yuce(t)
    %global a b k
    %y=k+a*b.^t;
    
    %Compertz 曲线:  初期增长缓慢,以后逐渐加快。当达到一定程度后,增长率又逐渐下降。
    %clc,clear
    %yuce=@(t,a,b,k)k*a.^(b.^t);
    %y=[42.1 47.5 52.7 57.7 62.5 67.1 71.5 75.7 79.8 83.7 87.5 91.1 94.6 97.9 101.1];
    %yt=log(y);n=length(yt);m=n/3;
    %s1=sum(yt(1:m)),s2=sum(yt(m+1:2*m)),s3=sum(yt(2*m+1:end))
    %b=((s3-s2)/(s2-s1))^(1/m)
    %a=(s2-s1)*(b-1)/(b*(b^m-1)^2)
    %k=(s1-a*b*(b^m-1)/(b-1))/m
    %a=exp(a)
    %k=exp(k)
    %y=yuce(1:18,a,b,k)
    
    
    %Logistic 曲线(生长曲线)
    %clc,clear
    %yuce=@(t,a,b,k) 1./(k+a*b.^t);
    %y=[42.1 47.5 52.7 57.7 62.5 67.1 71.5 75.7 79.8 83.7 87.5 91.1 94.6 97.9 101.1];
    %yt=1./y;n=length(yt);m=n/3;
    %s1=sum(yt(1:m)),s2=sum(yt(m+1:2*m)),s3=sum(yt(2*m+1:end))
    %b=((s3-s2)/(s2-s1))^(1/m)
    %a=(s2-s1)*(b-1)/(b*(b^m-1)^2)
    %k=(s1-a*b*(b^m-1)/(b-1))/m
    %y1=yuce(1:18,a,b,k)
    

    [原文档在百度网盘里链接:https://pan.baidu.com/s/1rKEWW4ynqH-rM_Gt15aCUw
    提取码:tdby
    ]

    ##欢迎批评指正!

    展开全文
  • LSTM 时间序列预测 matlab

    万次阅读 多人点赞 2017-05-02 15:49:28
    由于参加了一个小的课题,是关于时间序列预测的。平时习惯用matlab, 网上这种资源就比较少。 借鉴了 http://blog.csdn.net/u010540396/article/details/52797489  的内容,稍微修改了一下程序。 程序说明:DATA....


    由于参加了一个小的课题,是关于时间序列预测的。平时习惯用matlab, 网上这种资源就比较少。

    借鉴了  http://blog.csdn.net/u010540396/article/details/52797489  的内容,稍微修改了一下程序。


    程序说明:DATA.mat 是一行时序值,

    numdely 是用前numdely个点预测当前点,cell_num是隐含层的数目,cost_gate 是误差的阈值。

    直接在命令行输入RunLstm(numdely,cell_num,cost_gate)即可。

    function [r1, r2] = RunLstm(numdely,cell_num,cost_gate)
    %% 数据加载,并归一化处理
    figure;
    [train_data,test_data]=LSTM_data_process(numdely);
    data_length=size(train_data,1)-1;
    data_num=size(train_data,2);
    %% 网络参数初始化
    % 结点数设置
    input_num=data_length;
    % cell_num=5;
    output_num=1;
    % 网络中门的偏置
    bias_input_gate=rand(1,cell_num);
    bias_forget_gate=rand(1,cell_num);
    bias_output_gate=rand(1,cell_num);
    %网络权重初始化
    ab=20;
    weight_input_x=rand(input_num,cell_num)/ab;
    weight_input_h=rand(output_num,cell_num)/ab;
    weight_inputgate_x=rand(input_num,cell_num)/ab;
    weight_inputgate_c=rand(cell_num,cell_num)/ab;
    weight_forgetgate_x=rand(input_num,cell_num)/ab;
    weight_forgetgate_c=rand(cell_num,cell_num)/ab;
    weight_outputgate_x=rand(input_num,cell_num)/ab;
    weight_outputgate_c=rand(cell_num,cell_num)/ab;
    %hidden_output权重
    weight_preh_h=rand(cell_num,output_num);
    %网络状态初始化
    % cost_gate=0.25;
    h_state=rand(output_num,data_num);
    cell_state=rand(cell_num,data_num);
    %% 网络训练学习
    for iter=1:100
        yita=0.01;            %每次迭代权重调整比例
        for m=1:data_num
            %前馈部分
            if(m==1)
                gate=tanh(train_data(1:input_num,m)'*weight_input_x);
                input_gate_input=train_data(1:input_num,m)'*weight_inputgate_x+bias_input_gate;
                output_gate_input=train_data(1:input_num,m)'*weight_outputgate_x+bias_output_gate;
                for n=1:cell_num
                    input_gate(1,n)=1/(1+exp(-input_gate_input(1,n)));
                    output_gate(1,n)=1/(1+exp(-output_gate_input(1,n)));
                end
                forget_gate=zeros(1,cell_num);
                forget_gate_input=zeros(1,cell_num);
                cell_state(:,m)=(input_gate.*gate)';
            else
                gate=tanh(train_data(1:input_num,m)'*weight_input_x+h_state(:,m-1)'*weight_input_h);
                input_gate_input=train_data(1:input_num,m)'*weight_inputgate_x+cell_state(:,m-1)'*weight_inputgate_c+bias_input_gate;
                forget_gate_input=train_data(1:input_num,m)'*weight_forgetgate_x+cell_state(:,m-1)'*weight_forgetgate_c+bias_forget_gate;
                output_gate_input=train_data(1:input_num,m)'*weight_outputgate_x+cell_state(:,m-1)'*weight_outputgate_c+bias_output_gate;
                for n=1:cell_num
                    input_gate(1,n)=1/(1+exp(-input_gate_input(1,n)));
                    forget_gate(1,n)=1/(1+exp(-forget_gate_input(1,n)));
                    output_gate(1,n)=1/(1+exp(-output_gate_input(1,n)));
                end
                cell_state(:,m)=(input_gate.*gate+cell_state(:,m-1)'.*forget_gate)';   
            end
            pre_h_state=tanh(cell_state(:,m)').*output_gate;
            h_state(:,m)=(pre_h_state*weight_preh_h)'; 
        end
        % 误差的计算
    %     Error=h_state(:,m)-train_data(end,m);
        Error=h_state(:,:)-train_data(end,:);
        Error_Cost(1,iter)=sum(Error.^2);
        if Error_Cost(1,iter) < cost_gate
                iter
            break;
        end
                     [ weight_input_x,...
                    weight_input_h,...
                    weight_inputgate_x,...
                    weight_inputgate_c,...
                    weight_forgetgate_x,...
                    weight_forgetgate_c,...
                    weight_outputgate_x,...
                    weight_outputgate_c,...
                    weight_preh_h ]=LSTM_updata_weight(m,yita,Error,...
                                                       weight_input_x,...
                                                       weight_input_h,...
                                                       weight_inputgate_x,...
                                                       weight_inputgate_c,...
                                                       weight_forgetgate_x,...
                                                       weight_forgetgate_c,...
                                                       weight_outputgate_x,...
                                                       weight_outputgate_c,...
                                                       weight_preh_h,...
                                                       cell_state,h_state,...
                                                       input_gate,forget_gate,...
                                                       output_gate,gate,...
                                                       train_data,pre_h_state,...
                                                       input_gate_input,...
                                                       output_gate_input,...
                                                       forget_gate_input);
    
    
    end
    %% 绘制Error-Cost曲线图
    for n=1:1:iter
        semilogy(n,Error_Cost(1,n),'*');
        hold on;
        title('Error-Cost曲线图');   
    end
    %% 数据检验
    %数据加载
    test_final=test_data;
    test_final=test_final/sqrt(sum(test_final.^2));
    total = sqrt(sum(test_data.^2));
    test_output=test_data(:,end);
    %前馈
    m=data_num;
    gate=tanh(test_final(1:input_num)'*weight_input_x+h_state(:,m-1)'*weight_input_h);
    input_gate_input=test_final(1:input_num)'*weight_inputgate_x+cell_state(:,m-1)'*weight_inputgate_c+bias_input_gate;
    forget_gate_input=test_final(1:input_num)'*weight_forgetgate_x+cell_state(:,m-1)'*weight_forgetgate_c+bias_forget_gate;
    output_gate_input=test_final(1:input_num)'*weight_outputgate_x+cell_state(:,m-1)'*weight_outputgate_c+bias_output_gate;
    for n=1:cell_num
        input_gate(1,n)=1/(1+exp(-input_gate_input(1,n)));
        forget_gate(1,n)=1/(1+exp(-forget_gate_input(1,n)));
        output_gate(1,n)=1/(1+exp(-output_gate_input(1,n)));
    end
    cell_state_test=(input_gate.*gate+cell_state(:,m-1)'.*forget_gate)';
    pre_h_state=tanh(cell_state_test').*output_gate;
    h_state_test=(pre_h_state*weight_preh_h)'* total;
    test_output(end);
    test = sprintf('----Test result is %s----' ,num2str(h_state_test));
    true = sprintf('----True result is %s----' ,num2str(test_output(end)));
    disp(test);
    disp(true);
    

    function [train_data,test_data]=LSTM_data_process(numdely)
    
    load('DATA.mat');
    numdata = size(a,1);
    numsample = numdata - numdely - 1;
    train_data = zeros(numdely+1, numsample);
    test_data = zeros(numdely+1,1);
    
    for i = 1 :numsample
        train_data(:,i) = a(i:i+numdely)';
    end
    
    test_data = a(numdata-numdely: numdata);
    
    data_length=size(train_data,1);          
    data_num=size(train_data,2);           
    % 
    %%归一化过程
    for n=1:data_num
        train_data(:,n)=train_data(:,n)/sqrt(sum(train_data(:,n).^2));  
    end
    % for m=1:size(test_data,2)
    %     test_data(:,m)=test_data(:,m)/sqrt(sum(test_data(:,m).^2));
    % end


    function [   weight_input_x,weight_input_h,weight_inputgate_x,weight_inputgate_c,weight_forgetgate_x,weight_forgetgate_c,weight_outputgate_x,weight_outputgate_c,weight_preh_h ]=LSTM_updata_weight(n,yita,Error,...
                                                       weight_input_x, weight_input_h, weight_inputgate_x,weight_inputgate_c,weight_forgetgate_x,weight_forgetgate_c,weight_outputgate_x,weight_outputgate_c,weight_preh_h,...
                                                       cell_state,h_state,input_gate,forget_gate,output_gate,gate,train_data,pre_h_state,input_gate_input, output_gate_input,forget_gate_input)
    
    data_length=size(train_data,1) - 1;
    data_num=size(train_data,2);
    weight_preh_h_temp=weight_preh_h;
    
    
    %%% 权重更新函数
    input_num=data_length;
    cell_num=size(weight_preh_h_temp,1);
    output_num=1;
    
    %% 更新weight_preh_h权重
    for m=1:output_num
        delta_weight_preh_h_temp(:,m)=2*Error(m,1)*pre_h_state;
    end
    weight_preh_h_temp=weight_preh_h_temp-yita*delta_weight_preh_h_temp;
    
    %% 更新weight_outputgate_x
    for num=1:output_num
        for m=1:data_length
            delta_weight_outputgate_x(m,:)=(2*weight_preh_h(:,num)*Error(num,1).*tanh(cell_state(:,n)))'.*exp(-output_gate_input).*(output_gate.^2)*train_data(m,n);
        end
        weight_outputgate_x=weight_outputgate_x-yita*delta_weight_outputgate_x;
    end
    %% 更新weight_inputgate_x
    for num=1:output_num
    for m=1:data_length
        delta_weight_inputgate_x(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*gate.*exp(-input_gate_input).*(input_gate.^2)*train_data(m,n);
    end
    weight_inputgate_x=weight_inputgate_x-yita*delta_weight_inputgate_x;
    end
    
    
    if(n~=1)
        %% 更新weight_input_x
        temp=train_data(1:input_num,n)'*weight_input_x+h_state(:,n-1)'*weight_input_h;
        for num=1:output_num
        for m=1:data_length
            delta_weight_input_x(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*input_gate.*(ones(size(temp))-tanh(temp.^2))*train_data(m,n);
        end
        weight_input_x=weight_input_x-yita*delta_weight_input_x;
        end
        %% 更新weight_forgetgate_x
        for num=1:output_num
        for m=1:data_length
            delta_weight_forgetgate_x(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*cell_state(:,n-1)'.*exp(-forget_gate_input).*(forget_gate.^2)*train_data(m,n);
        end
        weight_forgetgate_x=weight_forgetgate_x-yita*delta_weight_forgetgate_x;
        end
        %% 更新weight_inputgate_c
        for num=1:output_num
        for m=1:cell_num
            delta_weight_inputgate_c(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*gate.*exp(-input_gate_input).*(input_gate.^2)*cell_state(m,n-1);
        end
        weight_inputgate_c=weight_inputgate_c-yita*delta_weight_inputgate_c;
        end
        %% 更新weight_forgetgate_c
        for num=1:output_num
        for m=1:cell_num
            delta_weight_forgetgate_c(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*cell_state(:,n-1)'.*exp(-forget_gate_input).*(forget_gate.^2)*cell_state(m,n-1);
        end
        weight_forgetgate_c=weight_forgetgate_c-yita*delta_weight_forgetgate_c;
        end
        %% 更新weight_outputgate_c
        for num=1:output_num
        for m=1:cell_num
            delta_weight_outputgate_c(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*tanh(cell_state(:,n))'.*exp(-output_gate_input).*(output_gate.^2)*cell_state(m,n-1);
        end
        weight_outputgate_c=weight_outputgate_c-yita*delta_weight_outputgate_c;
        end
        %% 更新weight_input_h
        temp=train_data(1:input_num,n)'*weight_input_x+h_state(:,n-1)'*weight_input_h;
        for num=1:output_num
        for m=1:output_num
            delta_weight_input_h(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*input_gate.*(ones(size(temp))-tanh(temp.^2))*h_state(m,n-1);
        end
        weight_input_h=weight_input_h-yita*delta_weight_input_h;
        end
    else
        %% 更新weight_input_x
        temp=train_data(1:input_num,n)'*weight_input_x;
        for num=1:output_num
        for m=1:data_length
            delta_weight_input_x(m,:)=2*(weight_preh_h(:,num)*Error(num,1))'.*output_gate.*(ones(size(cell_state(:,n)))-tanh(cell_state(:,n)).^2)'.*input_gate.*(ones(size(temp))-tanh(temp.^2))*train_data(m,n);
        end
        weight_input_x=weight_input_x-yita*delta_weight_input_x;
        end
    end
    weight_preh_h=weight_preh_h_temp;
    
    end


    ---------------------------------------2017.08.03 UPDATE----------------------------------------

    代码数据链接:

    http://download.csdn.net/detail/u011060119/9919621


    展开全文
  • 基于MATLAB,用神经网络对已有数据进行时间序列分析、建模、预测。内含视频教学,有数据可供练习。(教程缺乏预测部分,但是网上有简单的教学,一查就可以查到)主要可用于数学建模,美赛国赛均可。
  • 小波神经网络的时间序列预测matlab代码.zip
  • 使用matlab进行时间序列分析,预测效果如文档所示,代码运行简单,修改方便。已做成工具箱,只需替换数据即可运行
  • Matlab实现时间序列预测

    千次阅读 2021-07-28 16:41:36
    在之前的版本做时间预测是比较麻烦操作的,MathWorks公司对时间序列预测做了详细的解决,跑模型非常简便。 当前网络是非常的非线性网络,增加神经元个数,同时增加delays到4。 利用以上模型和NAR模型进行训练,误差...


    Matlab从2010b版本以后,神经网络工具箱已经升级为7.0,功能大大加强。在之前的版本做时间预测是比较麻烦操作的,MathWorks公司对时间序列预测做了详细的解决,跑模型非常简便。

    下面通过一个例子演示在Matlab实现时间序列预测。

    一、数据准备

    极客范儿在夏天吹电扇的体温变化

    时间风速温度
    0137.21405
    0.124571.0137.26016
    0.249151.0237.26324
    0.373731.0337.31242
    0.49831.0437.3155
    0.622581.0537.36468
    0.747451.0637.36776
    0.872031.0737.41694
    0.996611.0837.42002
    % 原始数据读入到Matlab中
    rawData=xlsread('time_series_data.xlsx','sheet1','A2:C52);
    % 第一列时间,第二列风速,第三列温度
    % yt第三列
    y_t=rawData(:,3);
    % xt第二列
    x_t=rawData(:,2);
    
    

    二、时间序列预测分类

    时间序列预测分为三类:

    1、输入为xt,输出是yt

    即有过去的输入xt,也有过去的输出yt,同时当前的输出不仅依赖于过去的输入,也同时依赖于过去的输出
    过去时间段温度的变化,预测将来某个时间温度的变化,这种情况就是只有过去的输出

    %   x_t - 时间序列输入
    %   y_t - 反馈时间序列
    
    X = tonndata(x_t,false,false);
    T = tonndata(y_t,false,false);
    
    % 选择训练功能
    % 'trainlm'通常是最快
    % 'trainbr'耗时较长,但可能更适合解决挑战性的问题
    % 'trainscg'使用更少的内存。适用于低内存情况
    trainFcn = 'trainlm';  % Levenberg-Marquardt反向传播
    
    % 创建一个非线性自回归网络
    feedbackDelays = 1:6;
    hiddenLayerSize = 20;
    net = narnet(feedbackDelays,hiddenLayerSize,'open',trainFcn);
    
    % 为训练和模拟准备数据
    % PREPARETS函数为特定网络准备时间序列数据
    % 移动时间的最小量,以声明填充输入状态和层
    % 使用PREPARETS允许保留原始的时间序列数据不变,同时轻松定制它的网络与不同
    % 具有开环或闭环反馈模式的延迟数
    [x,xi,ai,t] = preparets(net,{},{},T);
    
    % 建立训练,验证,测试的数据
    net.divideParam.trainRatio = 70/100;
    net.divideParam.valRatio = 15/100;
    net.divideParam.testRatio = 15/100;
    
    % 训练静态神经网络 
    [net,tr] = train(net,x,t,xi,ai);
    
    % 测试神经网络
    y = net(x,xi,ai);
    e = gsubtract(t,y);
    performance = perform(net,t,y)
    
    % 查看神经网络
    view(net)
    
    % Plots
    % Uncomment these lines to enable various plots.
    %figure, plotperform(tr)
    %figure, plottrainstate(tr)
    %figure, ploterrhist(e)
    %figure, plotregression(t,y)
    %figure, plotresponse(t,y)
    %figure, ploterrcorr(e)
    %figure, plotinerrcorr(x,e)
    
    % 提前预测网络
    % 利用该网络进行多步预测
    % CLOSELOOP函数将反馈输入替换为直接输入
    % 从外部层连接
    nets = removedelay(net);
    nets.name = [net.name ' - Predict One Step Ahead'];
    view(netc)
    [xs,xis,ais,ts] = preparets(nets,X,{},T);
    ys = nets(xs,xis,ais);
    stepAheadPerformance = perform(nets,ts,ys)
    
    

    2、有x值,有y值:NARX

    只有过去的输出
    如果给环境加一个风扇,这时候有了风速,过去时间风速在改变,同时也在影响温度的改变
    Matlab现在提供时间序列预测工具箱,可以在图形界面上进行调参选择,使用命令ntstool打开时间序列预测工具箱

    类似股票的模型,只知道早上9:30开市到11:30的股票行情,预测11:30之后的股票行情,不考虑任何的输入

    (1)选择模型类型

    tool-001

    (2)选择输出,只有y_t

    tool-002

    (3)选择70%用来作为训练数据,15%用来作为验证使用,15%用来测试

    tool-003

    (4)选择delay

    tool-004

    (5)开始训练

    tool-005

    (6)得到参数

    tool-006
    tool-007

    (7)将神经网络导出代码

    tool-008

    3、无x,有y值:NAR

    没有线性的输入输出,很少遇到这种情况

    三、总结

    Matlab从2010b版本以后,使用图形界面训练网络调参,生成的代码与手敲的功能无异,Matlab时间序列预测工具箱实用而且好用。

    展开全文
  • 时间序列数据准备视频教程第1部分, https://youtu.be/gKT8HSoJ0cE 代码和结果输出,第2部分https://youtu.be/G1kcWoXZE6A ------- || 如果喜欢,请点赞并订阅我的频道。 CNN和LSTM网络的一些其他结果。 标普500...
  • LSTM-时间序列预测.zip

    2020-04-04 11:57:18
    # 代码功能: LS-TM 循环神经网络,预测时间序列---------------------------- # 第1步: 处理原始数据集, 归一化,制作X_train、Y_train、X_test、Y_test # 第2步: 训练LS-TM网络, epoch=300 ...# 第3步: 时间序列预测
  • 一、CNN简介 二、 LSTM简介 1 LSTM控制流程 LSTM的控制流程:是在前向传播的过程中处理流经细胞的数据,不同之处在于 LSTM 中细胞的结构和运算有所变化。...理论上讲,细胞状态能够将序列处理过程中的相关

    一、卷积神经网络(CNN)简介

    1 卷积神经网络(CNN)定义
    卷积神经网络(convolutional neural network, CNN),是一种专门用来处理具有类似网格结构的数据的神经网络。卷积网络是指那些至少在网络的一层中使用卷积运算来替代一般的矩阵乘法运算的神经网络。

    2 CNN神经网络图
    在这里插入图片描述
    CNN是一种通过卷积计算的前馈神经网络,其是受生物学上的感受野机制提出的,具有平移不变性,使用卷积核,最大的应用了局部信息,保留了平面结构信息。

    3 CNN五种结构组成
    3.1 输入层

    在处理图像的CNN中,输入层一般代表了一张图片的像素矩阵。可以用三维矩阵代表一张图片。三维矩阵的长和宽代表了图像的大小,而三维矩阵的深度代表了图像的色彩通道。比如黑白图片的深度为1,而在RGB色彩模式下,图像的深度为3。

    3.2 卷积层(Convolution Layer)
    卷积层是CNN最重要的部分。它与传统全连接层不同,卷积层中每一个节点的输入只是上一层神经网络的一小块。卷积层被称为过滤器(filter)或者内核(kernel),Tensorflow的官方文档中称这个部分为过滤器(filter)。
    【注意】在一个卷积层中,过滤器(filter)所处理的节点矩阵的长和宽都是由人工指定的,这个节点矩阵的尺寸也被称为过滤器尺寸。常用的尺寸有3x3或5x5,而过滤层处理的矩阵深度和当前处理的神经层网络节点矩阵的深度一致。
    下图为卷积层过滤器(filter)结构示意图
    在这里插入图片描述
    下图为卷积过程
    在这里插入图片描述
    详细过程如下,Input矩阵是像素点矩阵,Kernel矩阵是过滤器(filter)
    在这里插入图片描述
    3.3 池化层(Pooling Layer)
    池化层不会改变三维矩阵的深度,但是它可以缩小矩阵的大小。通过池化层,可以进一步缩小最后全连接层中节点的个数,从而达到减少整个神经网络参数的目的。使用池化层既可以加快计算速度也可以防止过拟合。池化层filter的计算不是节点的加权和,而是采用最大值或者平均值计算。使用最大值操作的池化层被称之为最大池化层(max pooling)(最大池化层是使用的最多的磁化层结构)。使用平均值操作的池化层被称之为平均池化层(mean pooling)。
    下图分别表示不重叠的4个2x2区域的最大池化层(max pooling)、平均池化层(mean pooling)
    在这里插入图片描述
    在这里插入图片描述
    3.4 全连接层
    在经过多轮卷积层和池化层的处理之后,在CNN的最后一般会由1到2个全连接层来给出最后的分类结果。经过几轮卷积层和池化层的处理之后,可以认为图像中的信息已经被抽象成了信息含量更高的特征。我们可以将卷积层和池化层看成自动图像特征提取的过程。在提取完成之后,仍然需要使用全连接层来完成分类任务。

    3.5 Softmax层
    通过Softmax层,可以得到当前样例属于不同种类的概率分布问题。

    二、 LSTM简介

    1 LSTM控制流程
    LSTM的控制流程:是在前向传播的过程中处理流经细胞的数据,不同之处在于 LSTM 中细胞的结构和运算有所变化。
    在这里插入图片描述
    这一系列运算操作使得 LSTM具有能选择保存信息或遗忘信息的功能。咋一看这些运算操作时可能有点复杂,但没关系下面将带你一步步了解这些运算操作。

    2 核心概念
    LSTM 的核心概念在于细胞状态以及“门”结构。细胞状态相当于信息传输的路径,让信息能在序列连中传递下去。你可以将其看作网络的“记忆”。理论上讲,细胞状态能够将序列处理过程中的相关信息一直传递下去。
    因此,即使是较早时间步长的信息也能携带到较后时间步长的细胞中来,这克服了短时记忆的影响。信息的添加和移除我们通过“门”结构来实现,“门”结构在训练过程中会去学习该保存或遗忘哪些信息。

    3 Sigmoid
    门结构中包含着 sigmoid 激活函数。Sigmoid 激活函数与 tanh 函数类似,不同之处在于 sigmoid 是把值压缩到 0~1 之间而不是 -1~1 之间。这样的设置有助于更新或忘记信息,因为任何数乘以 0 都得 0,这部分信息就会剔除掉。同样的,任何数乘以 1 都得到它本身,这部分信息就会完美地保存下来。这样网络就能了解哪些数据是需要遗忘,哪些数据是需要保存。
    在这里插入图片描述
    4LSTM门结构
    LSTM 有三种类型的门结构:遗忘门、输入门和输出门。
    4.1 遗忘门
    遗忘门的功能是决定应丢弃或保留哪些信息。来自前一个隐藏状态的信息和当前输入的信息同时传递到 sigmoid 函数中去,输出值介于 0 和 1 之间,越接近 0 意味着越应该丢弃,越接近 1 意味着越应该保留。
    在这里插入图片描述
    4.2 输入门
    输入门用于更新细胞状态。首先将前一层隐藏状态的信息和当前输入的信息传递到 sigmoid 函数中去。将值调整到 0~1 之间来决定要更新哪些信息。0 表示不重要,1 表示重要。
    其次还要将前一层隐藏状态的信息和当前输入的信息传递到 tanh 函数中去,创造一个新的侯选值向量。最后将 sigmoid 的输出值与 tanh 的输出值相乘,sigmoid 的输出值将决定 tanh 的输出值中哪些信息是重要且需要保留下来的。
    在这里插入图片描述
    4.3 细胞状态
    下一步,就是计算细胞状态。首先前一层的细胞状态与遗忘向量逐点相乘。如果它乘以接近 0 的值,意味着在新的细胞状态中,这些信息是需要丢弃掉的。然后再将该值与输入门的输出值逐点相加,将神经网络发现的新信息更新到细胞状态中去。至此,就得到了更新后的细胞状态。
    在这里插入图片描述
    4.4 输出门
    输出门用来确定下一个隐藏状态的值,隐藏状态包含了先前输入的信息。首先,我们将前一个隐藏状态和当前输入传递到 sigmoid 函数中,然后将新得到的细胞状态传递给 tanh 函数。
    最后将 tanh 的输出与 sigmoid 的输出相乘,以确定隐藏状态应携带的信息。再将隐藏状态作为当前细胞的输出,把新的细胞状态和新的隐藏状态传递到下一个时间步长中去。
    在这里插入图片描述
    让我们再梳理一下。遗忘门确定前一个步长中哪些相关的信息需要被保留;输入门确定当前输入中哪些信息是重要的,需要被添加的;输出门确定下一个隐藏状态应该是什么。

    三、部分源代码

    1.Matlab实现CNN-LST M的时间序列预测;
    2.预测的是单变量时间序列数据;
    3.所有文件放在一个文件夹运行,文件解释如下:
    CNN_L STMTS.m为主程序, 需要运行;
    其余m文件是子函数, 无需运行, data是数据集;
    Deep Learning.pdf是一份关于深度学习的文件;
    运行环境Matlab 2020b;
    
    

    四、运行结果

    五、matlab版本及参考文献

    1 matlab版本
    2014a

    2 参考文献
    [1] 包子阳,余继周,杨杉.智能优化算法及其MATLAB实例(第2版)[M].电子工业出版社,2016.
    [2]张岩,吴水根.MATLAB优化算法源代码[M].清华大学出版社,2017.
    [3]周品.MATLAB 神经网络设计与应用[M].清华大学出版社,2013.
    [4]陈明.MATLAB神经网络原理与实例精解[M].清华大学出版社,2013.
    [5]方清城.MATLAB R2016a神经网络设计与应用28个案例分析[M].清华大学出版社,2018.

    展开全文
  • 在这里,您将找到用于混沌时间序列预测任务的径向基函数神经网络 (RBF-NN) 的两种变体。 特别是,我以常规方式实施了RBF,并将其性能与时空RBF-NN进行了Mackey-Glass时间序列预测。 * 对于引文,请参阅 [引用为] ...
  • MATLAB 2018中用深度学习进行时间序列预测

    万次阅读 多人点赞 2019-04-16 09:19:56
    本例展示了如何用LSTM网络预测时间序列数据。为了预测一个序列的未来时间步长值,你可以训练一个sequence-to-sequence LSTM回归网络,其中[2]网络的响应是训练序列值移动了一个时间步长。也就是说,在输入序列的每个...
  • 时序预测 | MATLAB实现SARIMA时间序列预测(arima函数) 经常还会遇到一种情况,即某些时间序列中存在明显的周期性变化,这种周期是由于季节性变化(季度、月度等)引起的,ARIMA的扩展支持SARIMA,它支持对该系列的...
  • 采用LSTM循环神经网络对时序数据进行预测,根据评价指标对测试集进行误差计算,具有较好的预测精度
  • 本示例旨在提出将卷积神经网络(CNN)与递归神经网络(RNN)相结合的概念... 在每个时间步,CNN都会提取序列的主要特征,而RNN会学习预测下一时间步的下一个值。 如果您认为这对您有帮助,请对它做出评价。 谢谢你。
  • 时序预测 | MATLAB实现CNN(卷积神经网络)时间序列预测 预测效果一览 以下介绍程序设计过程: 加载数据与数据集划分,常用load载入.mat文件 划分数据集,计算数据长度 clc;clear;close all load data nwhole...

空空如也

空空如也

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

时间序列预测matlab

matlab 订阅