为您推荐:
精华内容
最热下载
问答
  • 5星
    17KB younow22 2021-02-15 20:33:07
  • 由于参加了一个小的课题,是关于时间序列预测的。平时习惯用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


    展开全文
    u011060119 2017-05-02 15:49:28
  • 4星
    5KB qq_34097688 2018-05-03 10:57:21
  • 488KB ccaoccll 2018-05-04 01:42:16
  • 5星
    17KB younow22 2021-02-15 20:33:07
  • 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.

    展开全文
    TIQCmatlab 2021-10-02 22:44:31
  • % if it is true the layer turn to the Bidirectional-LSTM and if it is false it will turn the units to the simple LSTM opt.isUseDropoutLayer = true; % dropout layer avoid of bieng overfit opt....

    1. 模型介绍

    2 部分代码

    clc; clear; close all;
    %% ---------------------------- init Variabels ----------------------------
    opt.Delays = 1:30;
    opt.dataPreprocessMode  = 'Data Standardization'; % 'None' 'Data Standardization' 'Data Normalization'
    opt.learningMethod      = 'LSTM';
    opt.trPercentage        = 0.80;                   %  divide data into Test  and Train dataset
    ​
    % ---- General Deep Learning Parameters(LSTM and CNN General Parameters)
    opt.maxEpochs     = 400;                         % maximum number of training Epoch in deeplearning algorithms.
    opt.miniBatchSize = 32;                         % minimum batch size in deeplearning algorithms .
    opt.executionEnvironment = 'cpu';                % 'cpu' 'gpu' 'auto'
    opt.LR                   = 'adam';               % 'sgdm' 'rmsprop' 'adam'
    opt.trainingProgress     = 'none';  % 'training-progress' 'none'
    ​
    % ------------- BILSTM parameters
    opt.isUseBiLSTMLayer  = true;                     % if it is true the layer turn to the Bidirectional-LSTM and if it is false it will turn the units to the simple LSTM
    opt.isUseDropoutLayer = true;                    % dropout layer avoid of bieng overfit
    opt.DropoutValue      = 0.5;
    ​
    % ------------ Optimization Parameters
    opt.optimVars = [
        optimizableVariable('NumOfLayer',[1 4],'Type','integer')
        optimizableVariable('NumOfUnits',[50 200],'Type','integer')
        optimizableVariable('isUseBiLSTMLayer',[1 2],'Type','integer')
        optimizableVariable('InitialLearnRate',[1e-2 1],'Transform','log')
        optimizableVariable('L2Regularization',[1e-10 1e-2],'Transform','log')];
    ​
    opt.isUseOptimizer         = true;
    ​
    opt.MaxOptimizationTime    = 14*60*60;
    opt.MaxItrationNumber      = 60;
    opt.isDispOptimizationLog  = true;
    ​
    opt.isSaveOptimizedValue       = false;        %  save all of Optimization output on mat files 
    opt.isSaveBestOptimizedValue   = true;         %  save Best Optimization output o丿 a mat file  
    ​
    ​
    %% --------------- load Data
    data = loadData(opt);
    if ~data.isDataRead
        return;
    end
    ​
    %% --------------- Prepair Data
    [opt,data] = PrepareData(opt,data);
    ​
    %% --------------- Find Best LSTM Parameters with Bayesian Optimization
    [opt,data] = OptimizeLSTM(opt,data);
    ​
    %% --------------- Evaluate Data
    [opt,data] = EvaluationData(opt,data);
    ​
    ​
    ​
    %% ---------------------------- Local Functions ---------------------------
    function data = loadData(opt)
    [chosenfile,chosendirectory] = uigetfile({'*.xlsx';'*.csv'},...
        'Select Excel time series Data sets','data.xlsx');
    filePath = [chosendirectory chosenfile];
    if filePath ~= 0
        data.DataFileName = chosenfile;
        data.CompleteData = readtable(filePath);
        if size(data.CompleteData,2)>1
            warning('Input data should be an excel file with only one column!');
            disp('Operation Failed... '); pause(.9);
            disp('Reloading data. ');     pause(.9);
            data.x = [];
            data.isDataRead = false;
            return;
        end
        data.seriesdataHeder = data.CompleteData.Properties.VariableNames(1,:);
        data.seriesdata = table2array(data.CompleteData(:,:));
        disp('Input data successfully read.');
        data.isDataRead = true;
        data.seriesdata = PreInput(data.seriesdata);
        
        figure('Name','InputData','NumberTitle','off');
        plot(data.seriesdata); grid minor;
        title({['Mean = ' num2str(mean(data.seriesdata)) ', STD = ' num2str(std(data.seriesdata)) ];});
        if strcmpi(opt.dataPreprocessMode,'None')
            data.x = data.seriesdata;
        elseif strcmpi(opt.dataPreprocessMode,'Data Normalization')
            data.x = DataNormalization(data.seriesdata);
            figure('Name','NormilizedInputData','NumberTitle','off');
            plot(data.x); grid minor;
            title({['Mean = ' num2str(mean(data.x)) ', STD = ' num2str(std(data.x)) ];});
        elseif strcmpi(opt.dataPreprocessMode,'Data Standardization')
            data.x = DataStandardization(data.seriesdata);
            figure('Name','NormilizedInputData','NumberTitle','off');
            plot(data.x); grid minor;
            title({['Mean = ' num2str(mean(data.x)) ', STD = ' num2str(std(data.x)) ];});
        end
        
    
    
    else
        warning(['In order to train network, please load data.' ...
            'Input data should be an excel file with only one column!']);
        disp('Operation Cancel.');
        data.isDataRead = false;
    end
    end
    function data = PreInput(data)
    if iscell(data)
        for i=1:size(data,1)
            for j=1:size(data,2)
                if strcmpi(data{i,j},'#NULL!')
                    tempVars(i,j) = NaN; %#ok
                else
                    tempVars(i,j) = str2num(data{i,j});   %#ok
                end
            end
        end
        data = tempVars;
    end
    end
    function vars = DataStandardization(data)
    for i=1:size(data,2)
        x.mu(1,i)   = mean(data(:,i),'omitnan');
        x.sig(1,i)  = std (data(:,i),'omitnan');
        vars(:,i) = (data(:,i) - x.mu(1,i))./ x.sig(1,i);
    end
    end
    function vars = DataNormalization(data)
    for i=1:size(data,2)
        vars(:,i) = (data(:,i) -min(data(:,i)))./ (max(data(:,i))-min(data(:,i)));
    end
    end
    % --------------- data preparation for LSTM ---
    function [opt,data] = PrepareData(opt,data)
    % prepare delays for time serie network
    data = CreateTimeSeriesData(opt,data);
    ​
    % divide data into test and train data
    data = dataPartitioning(opt,data);
    ​
    % LSTM data form
    data = LSTMInput(data);
    end
    ​
    % ----Run Bayesian Optimization Hyperparameters for LSTM Network Parameters
    function [opt,data] = OptimizeLSTM(opt,data)
    if opt.isDispOptimizationLog
        isLog = 2;
    else
        isLog = 0;
    end
    if opt.isUseOptimizer
        opt.ObjFcn  = ObjFcn(opt,data);
        BayesObject = bayesopt(opt.ObjFcn,opt.optimVars, ...
            'MaxTime',opt.MaxOptimizationTime, ...
            'IsObjectiveDeterministic',false, ...
            'MaxObjectiveEvaluations',opt.MaxItrationNumber,...
            'Verbose',isLog,...
            'UseParallel',false);
    end
    end
    ​
    % ---------------- objective function
    function ObjFcn = ObjFcn(opt,data)
    ObjFcn = @CostFunction;
    ​
    function [valError,cons,fileName] = CostFunction(optVars)
    inputSize    = size(data.X,1);
    outputMode   = 'last';
    numResponses = 1;
    dropoutVal   = .5;
    ​
    if optVars.isUseBiLSTMLayer == 2
        optVars.isUseBiLSTMLayer = 0;
    end
    ​
    if opt.isUseDropoutLayer % if dropout layer is true
        if optVars.NumOfLayer ==1
            if optVars.isUseBiLSTMLayer
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            else
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    lstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            end
        elseif optVars.NumOfLayer==2
            if optVars.isUseBiLSTMLayer
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            else
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    lstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    lstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            end
        elseif optVars.NumOfLayer ==3
            if optVars.isUseBiLSTMLayer
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            else
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            end
        elseif optVars.NumOfLayer==4
            if optVars.isUseBiLSTMLayer
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            else
                opt.layers = [ ...
                    sequenceInputLayer(inputSize)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode','sequence')
                    dropoutLayer(dropoutVal)
                    bilstmLayer(optVars.NumOfUnits,'OutputMode',outputMode)
                    dropoutLayer(dropoutVal)
                    fullyConnectedLayer(numResponses)
                    regressionLayer];
            end

    3 仿真结果

    img

    img

    img

    img

    4 参考文献

    [1]李万, 冯芬玲, 蒋琦玮. 改进粒子群算法优化LSTM神经网络的铁路客运量预测[J]. 铁道科学与工程学报, 2018, 15(12):260-266.

    5 MATLAB代码与数据下载地址

    见博客主页

    展开全文
    qq_59747472 2021-09-25 23:38:55
  • 5星
    5.64MB weixin_42696271 2021-09-10 17:02:45
  • 153KB weixin_38664159 2021-05-28 22:12:48
  • 4.94MB weixin_38699784 2021-05-22 07:44:27
  • 5星
    668KB weixin_42691388 2021-09-29 06:12:00
  • 一、麻雀算法及LSTM简介 1 麻雀算法简介 麻雀搜索算法(Sparrow Search Algorithm, SSA)是于2020年提出的。SSA 主要是受麻雀的觅食行为和反捕食行为的启发而提出的。该算法比较新颖,具有寻优能力强,收敛速度快的...

    一、麻雀算法及LSTM简介

    1 麻雀算法简介
    麻雀搜索算法(Sparrow Search Algorithm, SSA)是于2020年提出的。SSA 主要是受麻雀的觅食行为和反捕食行为的启发而提出的。该算法比较新颖,具有寻优能力强,收敛速度快的优点。
    1.1 算法原理
    建立麻雀搜索算法的数学模型,主要规则如下所述:
    (1)发现者通常拥有较高的能源储备并且在整个种群中负责搜索到具有丰富食物的区域,为所有的加入者提供觅食的区域和方向。在模型建立中能量储备的高低取决于麻雀个体所对应的适应度值(Fitness Value)的好坏。
    (2)一旦麻雀发现了捕食者,个体开始发出鸣叫作为报警信号。当报警值大于安全值时,发现者会将加入者带到其它安全区域进行觅食。
    (3)发现者和加入者的身份是动态变化的。只要能够寻找到更好的食物来源,每只麻雀都可以成为发现者,但是发现者和加入者所占整个种群数量的比重是不变的。也就是说,有一只麻雀变成发现者必然有另一只麻雀变成加入者。
    (4)加入者的能量越低,它们在整个种群中所处的觅食位置就越差。一些饥肠辘辘的加入者更有可能飞往其它地方觅食,以获得更多的能量。
    (5)在觅食过程中,加入者总是能够搜索到提供最好食物的发现者,然后从最好的食物中获取食物或者在该发现者周围觅食。与此同时,一些加入者为了增加自己的捕食率可能会不断地监控发现者进而去争夺食物资源。
    (6)当意识到危险时,群体边缘的麻雀会迅速向安全区域移动,以获得更好的位置,位于种群中间的麻雀则会随机走动,以靠近其它麻雀。
    在模拟实验中,我们需要使用虚拟麻雀进行食物的寻找,由n只麻雀组成的种群可表示为如下形式:
    在这里插入图片描述
    其中,d表示待优化问题变量的维数,n则是麻雀的数量。那么,所有麻雀的适应度值可以表示为如下形式:
    在这里插入图片描述
    其中,f表示适应度值。
    在SSA中, 具有较好适应度值的发现者在搜索过程中会优先获取食物。此外, 因为发现者负责为整个麻雀种群寻找食物并为所有加入者提供觅食的方向。因此,发现者可以获得比加入者更大的觅食搜索范围。根据规则(1)和规则(2),在每次迭代的过程中,发现者的位置更新描述如下:
    在这里插入图片描述
    其中, t代表当前迭代数, j=1, 2, 3, …, d.item maz是一个常数,表示最大的迭代次数。Xy表示第i个麻雀在第j维中的位置信息。xE(0,1]是一个随机数。R2(R2E[0,1])和ST(STe[0.5, 1] ) 分别表示预警值和安全值。Q是服从正态分布的随机数.L表示一个1×d的矩阵, 其中该矩阵内每个元素全部为
    1.
    当R2<ST时,这意味着此时的觅食环境周围没有捕食者,发现者可以执行广泛的搜索操作。如果R2≥ST,这表示种群中的一些麻雀已经发现了捕食者,井向种群中其它麻雀发出了警报,此时所有麻雀都需要迅速飞到其它安全的地方进行觅食。对于加入者,它们需要执行规则(3)和规则(4)。如前面所描述,在觅食过程中,一些加入者会时刻监视着发现者。一旦它们察觉到发现者已经找到了更好的食物,它们会立即离开现在的位置去争夺食物。如果它们赢了,它们可以立即获得该发现者的食物,否则需要继续执行规则(4)。加入者的位置更新描述如下:
    在这里插入图片描述
    其中, X, 是目前发现者所占据的最优位置, X worst则表示当前全局最差的位置。A表示一个1×d的矩阵, 其中每个元素随机赋值为1或-1,并且A+=A(AA)-.当i>n/2时,这表明,适应度值较低的第i个加入者没有获得食物,处于十分饥饿的状态,此时需要飞往其它地方觅食,以获得更多的能量。在模拟实验中,我们假设这些意识到危险的麻雀占总数量的10%到20%。这些麻雀的初始位置是在种群中随机产生的。根据规则(5),其数学表达式可以表示为如下形式:
    在这里插入图片描述
    其中, 其中X best是当前的全局最优位置。β作为步长控制参数, 是服从均值为0, 方差为1的正态分布的随机数。KE[-1, 1] 是一个随机数,则是当前麻雀个体的适应度值。f,和fw分别是当前全局最佳和最差的适应度值。e的常数,以避免分母出现零。
    为简单起见, 当f:>f, 表示此时的麻雀正处于种群的边缘, 极其容易受到捕食者的攻击。X best表示这个位置的麻雀是种群中最好的位置也是十分安全的。f;=f,时,这表明处于种群中间的麻雀意识到了危险,需要靠近其它的麻雀以此尽量减少它们被捕食的风险。K表示麻雀移动的方向同时也是步长控制参数。

    1.2 算法流程

    Step1: 初始化种群,迭代次数,初始化捕食者和加入者比列。
    Step2:计算适应度值,并排序。
    Step3:利用式(3)更新捕食者位置。
    Step4:利用式(4)更新加入者位置。
    Step5:利用式(5)更新警戒者位置。
    Step6:计算适应度值并更新麻雀位置。
    Step7:是否满足停止条件,满足则退出,输出结果,否则,重复执行Step2-6;

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

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

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

    二、部分源代码

    在这里插入代码片
    

    三、运行结果

    在这里插入图片描述
    在这里插入图片描述

    四、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.

    展开全文
    TIQCmatlab 2021-08-17 22:27:38
  • TIQCmatlab 2021-08-18 18:43:47
  • 5KB qq_31258627 2020-09-23 15:01:52
  • weixin_41791349 2019-04-16 09:19:56
  • kjm13182345320 2021-07-17 16:02:56
  • 33KB m0_60703264 2021-09-13 18:39:31
  • 4星
    13KB weixin_42696333 2019-08-06 13:58:04
  • yingliuzhizhu 2021-05-15 11:35:53
  • 1.24MB weixin_38522106 2021-05-29 04:34:07
  • 498KB weixin_42139460 2021-05-10 16:25:03
  • 5星
    13KB u011060119 2017-08-03 09:50:05
  • weixin_46197830 2021-07-12 14:51:09
  • m0_60703264 2021-09-06 15:13:35
  • kjm13182345320 2021-09-19 09:19:39
  • kjm13182345320 2021-03-24 16:26:10
  • weixin_45835837 2021-04-26 21:25:38
  • 4.28MB weixin_38612568 2021-06-02 07:20:08
  • 4星
    13KB leavemyleave 2021-10-14 23:39:55
  • 1.08MB olivia_ye 2020-04-02 11:42:17
  • weixin_38346042 2021-08-29 18:27:26

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 813
精华内容 325
关键字:

lstm时间序列预测matlab

matlab 订阅