精华内容
下载资源
问答
  • 自己写的,编程渣渣,写的很乱,但也基本实现了,仅供参考。有朋友可以联系我相互讨论学习,
  • 利用粒子群算法(PSO)对BP神经网络模型进行优化,可以对数据进行仿真训练,可以对变形监测以及其他领域的数据进行预测,实验结果表明粒子群算法(PSO)对BP神经网络模型比BP神经网络模型有着更好的预测精度以及在...
  • 粒子群优化BP神经网络初始权值(python实现)

    千次阅读 多人点赞 2021-04-09 21:27:12
    粒子群优化BP神经网络初始权值(python实现) 网上看了一些资料,但都是用matlab写的,(还要用csdn会员积分下载)自己不太会用matlab,就试着用python写了段小程序实现,数据用的是sklearn中的波士顿房价数据集,...

    粒子群优化BP神经网络初始权值(python实现)

    网上看了一些资料,但都是用matlab写的,(还要用csdn会员积分下载)自己不太会用matlab,就试着用python写了段小程序实现,数据用的是sklearn中的波士顿房价数据集,神经网络部分是用tensorflow2。(本来想用sklearn,但不知道怎么把网络权值提取出来)
    思路挺简单的,就是把BP网络误差作为粒子群优化的目标,每个粒子对应网络初始权重,一轮一轮的迭代。(先是在一篇建模论文里看到了这个想法,虽然好像没啥实用价值各位看官就全当茶余饭后图个乐吧。

    #import tensorflow.compat.v1 as tf
    #tf.compat.v1.disable_v2_behavior()
    #import tensorflow as tf
    #第一次用上面的语句跑的时候还好好的,再跑就报错了
    import tensorflow as tf
    tf = tf.compat.v1
    tf.disable_v2_behavior()
    
    
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import random
    from sklearn.datasets import load_boston
    from sklearn.model_selection import train_test_split
    from sklearn.neural_network import MLPRegressor
    from sklearn.preprocessing import StandardScaler
    
    
    def function(x1,y1,x2,y2,W):#  W是神经网络的W权重,根据这个权重设置神经网络
    
    
    
    
        #定义激活函数
        activation_function=tf.nn.relu
        #输入输出数据集
        xs=tf.placeholder(tf.float32,[None,None])
        ys=tf.placeholder(tf.float32,[None,None])
    
    
    
    
        #设计bp神经网络,三层,13,3,1
        weights_1=tf.Variable(W[0,:,:],tf.float32)
        biases_1=tf.Variable(tf.zeros([1,3])+0.1,tf.float32)
        wx_plus_b_1=tf.matmul( xs, tf.cast(weights_1,tf.float32))+biases_1
        outputs_1=activation_function(wx_plus_b_1)
    
    
        weights_2=tf.Variable(W[1,0:3,:],tf.float32)
        biases_2=tf.Variable(tf.zeros([1,3])+0.1,tf.float32)
        wx_plus_b_2=tf.matmul(outputs_1 , tf.cast(weights_2,tf.float32))+biases_2
        outputs_2=activation_function(wx_plus_b_2)
    
    
        w3=W[2,0:3,0].reshape(3,1)
        weights_3=tf.Variable(w3,tf.float32)
        biases_3=tf.Variable(0.1,tf.float32)
    
        wx_plus_b_3=tf.matmul(outputs_2,tf.cast(weights_3,tf.float32))+biases_3
    
    
    
        #预测输出结果
        prediction=wx_plus_b_3      #看来这里的数据就用行向量来输入输出
    
        #定义损失函数
        loss=tf.reduce_mean(tf.reduce_sum(tf.square(y1-prediction),reduction_indices=[1]))
    
        #梯度下降法训练
        train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    
        #初始化变量
        init=tf.global_variables_initializer()
    
        #执行会话,开始训练模型
        print("开始")
        with tf.Session() as sess:
            sess.run(init)
            for i in range (1000):
                sess.run(train_step,feed_dict={ xs:x1  , ys:y1 })
    
    #为什么损失函数喂入x2,y2就不行?QAQ
            end_loss=sess.run(loss,feed_dict={xs:x1,ys:y1})
            print(end_loss)
    # print(sess.run(prediction,feed_dict={xs:x2}))
            print("结束")
        return end_loss
    
    
    #导入数据集
    data=load_boston()
    data_pd=pd.DataFrame(data.data,columns=data.feature_names)
    data_pd["price"]=data.target
    
    
    
    
    #dataframe导入numpy
    x=np.array(data_pd.loc[:,'CRIM':'LSTAT'])
    
    y=np.array(data_pd.loc[:,'price'])
    
    y.shape=(506,1)
    #训练集测试集
    x_train,x_test,y_train,y_test=train_test_split(x,y , test_size=0.1 )
    #数据标准化
    SC=StandardScaler()
    x_train=SC.fit_transform(x_train)
    y_train=SC.fit_transform(y_train)
    x_test=SC.fit_transform(x_test)
    y_test=SC.fit_transform(y_test)
    
    
    
    #粒子数量num
    num = 3
    
    #粒子位置矩阵的形状
    num_x = 3
    num_y = 13
    num_z = 3
    
    #p为粒子位置矩阵,初始化为标准正态分布
    p = np.random.randn(num,num_x,num_y,num_z)
    
    #初始化粒子速度,以标准正态分布随机初始化
    v = np.random.randn(num,num_x,num_y,num_z)
    
    #个体最佳位置
    good_p = np.array(p, copy=True)
    
    #全局最佳位置
    best_p = np.zeros((num_x, num_y, num_z))
    
    #每次粒子移动后所计算出新的目标函数值
    new_y = np.zeros(num)
    
    #粒子个体历史最优值
    good_y = np.zeros(num)
    
    #粒子群体历史最优值
    best_y = 0
    
    #计算出初始粒子群的目标函数值
    for i in range(num):
        good_y[i] = function(x_train, y_train, x_test, y_test, p[i, :, :, :])
    
    #目标函数返回值是误差,那么最小的就是最优的
    best_y = min(good_y)
    
    #确定初始时最优位置
    best_p = p[np.argmin(good_y), :, :, :]
    
    #设置最大迭代次数
    max_iter = 10
    
    #开始迭代
    for i in range(max_iter):
    
        #速度更新公式
        v = random.random() * v + 2.4 * random.random() * (best_p - p) + 1.7 * random.random() * ( good_p - p )
    
        #粒子位置更新
        p = p + v
    
        #计算每个粒子到达新位置后所得到的目标函数值
        for i in range(num):
            new_y[i] = function(x_train, y_train, x_test, y_test, p[i, :, :, :])
    
        #更新全局最优
        if min(new_y) < best_y:
            best_y = min(new_y)
            best_p = p[np.argmin(new_y), :, :, :]
    
        #更新个体历史最优
        for i in range(num):
            if new_y[i] < good_y[i]:
                good_y[i] = new_y[i]
                good_p[i, :, :, :] = p[i, :, :, :]  # 当对切片修改时,原始numpy数据也修改
    
    
    print("结束")
    print('目标函数最优值:',best_y)
    print('此时的粒子位置:',best_p)
    
    
    展开全文
  • PSO粒子群算法优化神经网络,针对bp神经网络容易陷入局部极小,收敛速度慢的缺点,利用pso优化神经网络,提高了网络的泛化能力。
  • 该程序可以实现利用粒子群算法对K-MEANS算法进行优化
  • %1.2 设置神经网络参数 global indim; % 输入层神经元个数 indim=1; global hiddennum; % 隐藏层神经元个数 hiddennum=3; global outdim; % 输出层神经元个数 outdim=1; global Gpos; %1.3 设置微粒群参数 ...

    clc

    clear all

    %

    一、初始化部分

    %1.1

    预处理样本数据

    %

    选取训练样本

    (x,y)

    for

    i=1:126

    x=0+0.0251*(i-1);

    y(i)=(sin(x)+(x.^2/9+x/3)*exp((-0.5)*(x.^2)))/2;

    %

    待逼近函数

    end

    AllSamIn=0:0.0251:pi;

    %

    训练样本输入

    AllSamOut=y;

    %

    训练样本输出

    %

    选取测试样本

    for

    i=1:125

    x=0.0125+0.0251*(i-1);

    %

    测试样本输入

    ytest(i)=(sin(x)+(x.^2/9+x/3)*exp((-0.5)*(x.^2)))/2;

    %

    测试样本输出

    end

    AlltestIn=0.0125:0.0251:(pi-0.0125);

    AlltestOut=ytest;

    %

    归一化训练样本,测试样本

    [AlltestInn,minAlltestIn,maxAlltestIn,AlltestOutn,minAlltestOut,maxAlltestOut]=

    premnmx(AlltestIn,AlltestOut);

    %

    测试样本

    [AllSamInn,minAllSamIn,maxAllSamIn,AllSamOutn,minAllSamOut,maxAllSamOut]=

    premnmx(AllSamIn,AllSamOut); %

    训练样本

    testIn=AlltestInn;

    testOut=AlltestOutn;

    global Ptrain;

    Ptrain = AllSamInn;

    global Ttrain;

    Ttrain = AllSamOutn;

    %1.2

    设置神经网络参数

    global indim;

    %

    输入层神经元个数

    indim=1;

    global hiddennum; %

    隐藏层神经元个数

    hiddennum=3;

    global outdim;

    %

    输出层神经元个数

    outdim=1;

    global Gpos;

    %1.3

    设置微粒群参数

    vmax=0.5;

    %

    速度上限

    minerr=1e-7;

    %

    目标误差

    wmax=0.95;

    展开全文
  • %the end of PSO%% for i=1:MaxEpochs%%Hiddenout=logsig(SamIn*W1+repmat(B1',SamNum,1)); Networkout=Hiddenout*W2+repmat(B2',SamNum,1); Error=Networkout-SamOut; SSE=sumsqr(Error) ErrHistory=[ SSE];if SSE ...

    clc

    clear

    tic

    SamNum=30;

    HiddenNum=7;

    InDim=1;

    OutDim=1;

    load train_x

    load train_f

    a=train_x';

    d=train_f';

    p=[a];

    t=[d];

    [SamIn,minp,maxp,tn,mint,maxt]=premnmx(p,t);

    NoiseVar=0.01;

    Noise=NoiseVar*randn(1,SamNum);

    SamOut=tn +Noise;

    SamIn=SamIn';

    SamOut=SamOut';

    MaxEpochs=60000;

    lr=0.025;

    E0=0.65*10^(-6);%%

    %the begin of PSO

    E0=0.001;

    Max_num=500;

    particlesize=200;

    c1=1;

    c2=1;

    w=2;

    vc=2;

    vmax=5;

    dims=InDim*HiddenNum+HiddenNum+HiddenNum*OutDim+OutDim;

    x=-4+7*rand(particlesize,dims);

    v=-4+5*rand(particlesize,dims);

    f=zeros(particlesize,1);%%

    for jjj=1:particlesize

    trans_x=x(jjj,:);

    W1=zeros(InDim,HiddenNum);

    B1=zeros(HiddenNum,1);

    W2=zeros(HiddenNum,OutDim);

    B2=zeros(OutDim,1);

    W1=trans_x(1,1:HiddenNum);

    B1=trans_x(1,HiddenNum+1:2*HiddenNum)';

    W2=trans_x(1,2*HiddenNum+1:3*HiddenNum)';

    B2=trans_x(1,3*HiddenNum+1);

    Hiddenout=logsig(SamIn*W1+repmat(B1',SamNum,1));

    Networkout=Hiddenout*W2+repmat(B2',SamNum,1);

    Error=Networkout-SamOut;

    SSE=sumsqr(Error)

    f(jjj)=SSE;

    end

    personalbest_x=x;

    personalbest_f=f;

    [groupbest_f i]=min(personalbest_f);

    groupbest_x=x(i,:);for j_Num=1:Max_num

    vc=(5/3*Max_num-j_Num)/Max_num;%%v=w*v+c1*rand*(personalbest_x-x)+c2*rand*(repmat(groupbest_x,particlesize,1)-x);for kk=1:particlesizefor kk0=1:dimsif v(kk,kk0)>vmax

    v(kk,kk0)=vmax;else if v(kk,kk0)

    v(kk,kk0)=-vmax;

    end

    end

    end

    end

    x=x+vc*v;%%

    for jjj=1:particlesize

    trans_x=x(jjj,:);

    W1=zeros(InDim,HiddenNum);

    B1=zeros(HiddenNum,1);

    W2=zeros(HiddenNum,OutDim);

    B2=zeros(OutDim,1);

    W1=trans_x(1,1:HiddenNum);

    B1=trans_x(1,HiddenNum+1:2*HiddenNum)';

    W2=trans_x(1,2*HiddenNum+1:3*HiddenNum)';

    B2=trans_x(1,3*HiddenNum+1);

    Hiddenout=logsig(SamIn*W1+repmat(B1',SamNum,1));

    Networkout=Hiddenout*W2+repmat(B2',SamNum,1);

    Error=Networkout-SamOut;

    SSE=sumsqr(Error);

    f(jjj)=SSE;

    end%%

    for kk=1:particlesizeif f(kk)

    personalbest_f(kk)=f(kk);

    personalbest_x(kk)=x(kk);

    end

    end

    [groupbest_f0 i]=min(personalbest_f);if groupbest_f0

    groupbest_x=x(i,:);

    groupbest_f=groupbest_f0;

    end

    ddd(j_Num)=groupbest_f

    end

    str=num2str(groupbest_f);

    trans_x=groupbest_x;

    W1=trans_x(1,1:HiddenNum);

    B1=trans_x(1,HiddenNum+1:2*HiddenNum)';

    W2=trans_x(1,2*HiddenNum+1:3*HiddenNum)';

    B2=trans_x(1,3*HiddenNum+1);%the end of PSO%%

    for i=1:MaxEpochs%%Hiddenout=logsig(SamIn*W1+repmat(B1',SamNum,1));

    Networkout=Hiddenout*W2+repmat(B2',SamNum,1);

    Error=Networkout-SamOut;

    SSE=sumsqr(Error)

    ErrHistory=[ SSE];if SSE

    dB2=zeros(OutDim,1);

    dW2=zeros(HiddenNum,OutDim);for jj=1:HiddenNumfor k=1:SamNum

    dW2(jj,OutDim)=dW2(jj,OutDim)+Error(k)*Hiddenout(k,jj);

    end

    endfor k=1:SamNum

    dB2(OutDim,1)=dB2(OutDim,1)+Error(k);

    end

    dW1=zeros(InDim,HiddenNum);

    dB1=zeros(HiddenNum,1);for ii=1:InDimfor jj=1:HiddenNumfor k=1:SamNum

    dW1(ii,jj)=dW1(ii,jj)+Error(k)*W2(jj,OutDim)*Hiddenout(k,jj)*(1-Hiddenout(k,jj))*(SamIn(k,ii));

    dB1(jj,1)=dB1(jj,1)+Error(k)*W2(jj,OutDim)*Hiddenout(k,jj)*(1-Hiddenout(k,jj));

    end

    end

    end

    W2=W2-lr*dW2;

    B2=B2-lr*dB2;

    W1=W1-lr*dW1;

    B1=B1-lr*dB1;

    end

    Hiddenout=logsig(SamIn*W1+repmat(B1',SamNum,1));

    Networkout=Hiddenout*W2+repmat(B2',SamNum,1);

    aa=postmnmx(Networkout,mint,maxt);

    x=a;

    newk=aa;

    figure

    plot(x,d,'r-o',x,newk,'b--+')

    legend('原始数据','训练后的数据');

    xlabel('x');ylabel('y');

    toc

    展开全文
  • 需要高手帮我将程序改进,将BP中的梯度下降法用PSO(粒子群算法)改进!万分感谢。可加我QQ675424730目前的程序(包括数据)clcclearp=[8 110 20 1.0 2.0;9 150 30 5.0 0.09 150 30 5.0 3.0;9 50 3 1.0 2.09 50 3 1.0 ...

    需要高手帮我将程序改进,将BP中的梯度下降法用PSO(粒子群算法)改进!

    万分感谢。可加我QQ675424730

    目前的程序(包括数据)

    clc

    clear

    p=[

    8 110 20 1.0 2.0;9 150 30 5.0 0.0

    9 150 30 5.0 3.0;9 50 3 1.0 2.0

    9 50 3 1.0 0.0;6 50 3 1.0 0.0

    7 70 10 2.0 1.0;8 90 20 3.0 1.5

    6 50 3 5.0 0.0;7 70 10 3.0 1.0

    9 150 30 1.0 3.0;6 50 3 1.0 3.0

    7 70 10 2.0 1.5;8 90 20 3.0 1.0

    8 70 10 2.0 1.0;7 90 20 3.0 1.5

    6 150 30 5.0 3.0;6 150 3 1.0 3.0

    7 90 10 2.0 1.5;8 70 20 3.0 1.0

    6 50 30 1.0 0.0;7 70 20 2.0 1.0

    8 90 10 3.0 1.5;9 150 5 5.0 3.0

    6 70 5 5.0 3.0;8 70 1 1.0 0.0

    6 50 3 3.0 3.0;9 150 2 2.0 0.0

    7 90 3 3.0 1.0;9 90 10 1.0 0.0

    5 90 20 2.0 2.0;5 50 30 3.0 0.0

    5 70 3 1.0 0.0;5 150 10 2.0 1.0

    5 50 20 3.0 3.0;9 150 2 2.0 2.0

    6 50 2 3.0 0.0;7 50 2 2.0 0.0

    8 50 2 3.0 1.0;6 70 2 5.0 1.0

    7 90 2 1.0 0.0;9 50 2 2.0 1.0

    9 150 3 0.5 1.5;9 150 3 0.5 1.0

    6 50 3 0.5 1.0;7 50 10 0.5 1.5;

    8 50 20 0.5 3.0;6 70 3 0.5 3.0

    7 90 10 0.5 1.5;9 50 30 0.5 1.0

    ];

    %训练目标向量t

    p=p';

    t=[

    74;95;110;91;77;107;90;68;112;108

    75;115;83;66;80;100;137;100;83;74

    71;77;92;105;114;91;117;92;114;86

    100;73;114;145;86;95;105;76;88;125

    90;83;86;98;107;76;67;83;86;68

    ];

    t=t';

    %测试样本P_testp

    p_test=[

    6 70 3 0.5 0.0;7 150 10 0.5 1.0

    8 90 20 0.5 1.5;8 70 10 0.5 3.0

    5 150 3 5.0 0.0;5 150 2 0.5 0.0

    5 50 20 1.0 0.0;5 50 2 0.5 0.0

    7 50 20 2.0 0.0;9 150 30 3.0 0.0];

    p_test=p_test';

    %测试目标t1

    t1=[117;93;67;81;135;126;75;98;84;91];

    %训练样本归一化

    t1=t1';

    [pn,ps]=mapminmax(p);

    [tn,ts]=mapminmax(t);

    %创建网络参数,可以根据自己要求修改

    %net=newff(pn,tn,6);

    %net=newff(pn,tn,[1,1],{'tansig','logsig'});

    %net=newff(minmax(p),[5,1],{'tansig','logsig'},'trainlm');

    net=newff(minmax(p),[6,1],{'tansig','purelin'});

    net.trainparam.show=20;

    net.trainparam.mc=0.01;

    net.trainparam.lr=0.05;

    net.trainparam.epochs=5000;

    net.trainparam.goal=0.001;

    %网络初始化

    net=init(net);

    %训练网络

    net=train(net,pn,tn);

    %测试样本归一化

    pn_test=mapminmax('apply',p_test,ps);

    %网络仿真

    an=sim(net,pn_test);

    %反归一化

    [t2]= mapminmax('reverse',an,ts);

    %mse指标

    E = abs(t1 - t2);

    MSE=mse(E);

    %作图表示实测值和仿真值

    figure(1);

    X=1:10;

    plot(X,t2,'r*',X,t1,'bo',X,E,'y-');

    legend('预测输出','期望输出','误差曲线');

    title('SMT焊膏厚度输出');

    ylabel('厚度');

    xlabel('样本');

    算法设计和实现:

    (1)先初始化BP网络结构,设定网络的输入层、隐含层、输出层的神经元个数。

    (2)初始化粒子群及每个粒子的速度:

    ①粒子位置、速度向量的维数(dimSize为粒子种群规模,即粒子个数)

    dimSize=输入层至隐含层的连接权值个数+隐含层至输出层的连接权值个数+隐含层的阈值个数+输出层的阈值个数

    ②在初始化粒子群及每个粒子速度时,先初始化一二维矩阵x,前面dimSize列表示粒子位置的各维,后面dimSize列表示粒子速度的各维,最后一列表示粒子的适应度。

    ③初始化每一个粒子的个体极值和全局最优值。

    (3)计算每个粒子的适应度:

    ①先输入一个粒子,对每一个样本而言,都可以按BP网络的前向计算方法计算出一个网络的输出值,再按(式3-23)计算出其误差;同样的方法,计算出所有样本的误差;再按(式3-24)计算出所有样本的均方差,即该粒子的适应度。

    ②返回到①步骤,继续输入其它粒子,直至计算出所有粒子的适应度:

    (a)为了计算方便,把初始化粒子矩阵中从1到IN*HN列的各元素赋给输入层到隐含层的权值矩阵IN*HN+1到IN*HN+HN*ON列各元素分别赋给隐含层到输出层的权值矩阵,IN*HN+HN*ON+1到IN*HN+HN*ON+HN列各元素分别赋给隐含层的阈值,IN*HN+HN*ON+HN+1到IN*HN+HN*ON+HN+ON的各元素分别赋给输出层的阈值。其中,IN为输入层神经元个数,HN为隐含层神经元个数,ON为输出层神经元个数。

    (b)在使用BP算法的前向传播计算时,隐含层使用Sig-moid函数,输出层的计算使用线性Pureline函数。因为在BP网络模型中,当网络的最后一层采用曲线函数时,输出被限制在一个很小的范围内,如果采用线性函数,则输出可为任意值。因此,在MATLAB中设计BP网络,最后一层采用线性函数。即:f(x)=x。

    (4)比较适应度,确定每个粒子的个体极值点和全局最优极值点:

    若Present

    若Present

    其中,Present为当前粒子的适应度,Pbest为粒子的个体极值,gbest为全局最优值。

    (5)更新每个粒子的位置和速度:

    根据(式3-21)、(式3-22)更新粒子的速度和位置,并且考虑更新后的速度和位置是否在限定的范围内。

    考虑速度:

    若vij(t+1)>vmax,则vij(t+1)=vmax;

    若vij(t+1)

    否则vij(t+1)不变。

    考虑位置:

    若xij(t+1)>xmax,则xij(t+1)=xmax;

    若xij(t+1)

    否则xij(t+1)不变。

    其中,vmax、xmax、xmin都是常数,由用户设定。

    (6)采用在线性能准则或离线性能准则计算出算法的误差。

    本论文采用离线性能准则来评价网络的性能,公式如下:

    其中,iter为算法当前迭代次数,fun(gbesti)为第i次迭代的全局最优值的适应度。

    (7)比较次数是否达到最大迭代次数或式(5)的值满足精度。若满足预设精度,算法收敛,最后一次迭代的全局最优值gbest中每一维的权值和阈值就是我们所求的;否则返回(2),算法继续迭代。

    [本帖最后由 Carey_sjtu 于 2010-6-15 20:15 编辑]

    展开全文
  • PSO算法优化BP神经网络

    万次阅读 热门讨论 2019-01-20 20:17:01
    PSO算法和BP神经网络都是现在非常热门的两个算法,在各自的领域都担当着至关重要的作用,下面通过MATLAB中的一个实例来介绍一下如何将二者进行完美的结合,以发挥其最大优势: 1、在MATLAB的主界面编辑器中写入下列...
  • 用量子BP神经网络PSO结合的参数反演
  • 神经网络中,我们以同样的方式定义神经网络体系结构,通过比较实际标签和预测标签来计算误差,然后使用某种优化算法来优化该误差。训练神经网络最广泛使用的算法是反向传播和梯度下降。但是,我们可以使用任何优化...
  • 基于PSO-BP的算法

    2019-07-11 16:05:48
    基于matlab,利用pso算法的搜索能力,优化bp神经网络的阈值初始化,防止过拟合的发生。
  • 粒子群优化算法对BPNN进行超参数优化python代码实现,亲测可用
  • 虽然CNN架构由三种类型的层——卷积层、池化层,全连接层,和不同类型的编码信息层变化的参数的数量和范围在每个参数显示在表我,网络IP地址的固定长度足够可以用来容纳所有类型的CNN层,然后网络IP可分为无数的子集,每...
  • 我正在使用pyswarms PSO进行神经网络优化。 我正在尝试创建输入层和输出层的网络。# Store the features as X and the labels as yX = np.random.randn(25000,20)y = np.random.random_integers(0,2,25000)# In[29]:...
  • 粒子群算法优化BP神经网络

    万次阅读 多人点赞 2017-06-09 09:58:12
    刚学粒子群算法,然后用粒子群算法优化神经网络的隐藏节点数,代码写的不是太好,如果代码有问题,请大家多多指教。第一次写博客,多多包涵。 本文的粒子群算法用的是标准粒子群算法,权重更新采用线性递减策略。
  • 通过网络来获取各类信息也更加方便,这就给网络钓鱼带来了肥沃的生存土壤。网络钓鱼的不断泛滥,给人们的生产生活带来了巨大威胁,网民的财产安全受到侵犯,不利于经济的发展和社会的稳定。因此,加大网络钓鱼检测...
  • Matlab神经网络(九)--粒子群算法(PSO)实现函数极值优化
  • 本代码实现了粒子群算法(PSO)的python 实现(入门级),可以实现简单的优化功能, 需根据实际问题改变优化目标,以及部分代码
  • 1.数据介绍 ...3.SSA优化BP神经网络 3.1 BP神经网络参数设置 神经网络参数如下: %% 构造网络结构 %创建神经网络 inputnum = 2; %inputnum 输入层节点数 2维特征 hiddennum = 10; %hiddennum 隐...
  • pso-rbf python实现

    2018-10-15 17:13:50
    一种粒子群算法优化的rbf神经网络python实现,这是一次课程作业
  • 本文主要涉及工程实现,若要关注原理,网上比较多啦~ 一、pso(粒子群)算法简要介绍 ...目前已被广泛应用于函数优化神经网络训练、模糊系统控制以及其他遗传算法的应用领域。 二、代码关键实..
  • 人工智能,神经网络,深度学习,RBF
  • 在写论文,上一些资源网站花重金购买的,害,这样分享不太好,里面含有很多代码数据材料。做这些够用了,对了是R+MATLAB+python的一些代码整合的。
  • 文章前言:其实很多优化算法PSO,GA,GWO等等算法,都有一些相似之处,只要学会其中一种优化算法用在神经网络的框架结构,再把其他的优化算法依葫芦画瓢套进去即可。所以这里用SSA算法做个模板,效果如下图 ...
  • 自己写的一份 基于Python利用PSO算法优化BP神经网络完成数据反演程序
  • 详细BP神经网络预测算法及实现过程实例

    万次阅读 多人点赞 2019-09-13 21:47:37
    BP神经网络通常采用Sigmoid可微函数和线性函数作为网络的激励函数。本文选择S型正切函数tansig作为隐层神经元的激励函数。而由于网络的输出归一到[ -1, 1]范围内, 因此预测模型选取S 型对数函数tansig作为输出层...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

pso优化bp神经网络python

python 订阅