神經網路演算法優化

① 優化神經網路梯度演算法——Adam

"""
Created on Wed Oct 3 21:54:36 2018

@author: ltx
"""

import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import math
import sklearn
import sklearn.datasets

import opt_utils
import testCase
plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

def GetMinibatch(X,Y,batch_number,seed=0):
np.random.seed(seed)#指定隨機種子
m=X.shape[1]

print("-------------測試random_mini_batches-------------")
X_assess,Y_assess,mini_batch_size = testCase.random_mini_batches_test_case()
mini_batches = GetMinibatch(X_assess,Y_assess,mini_batch_size)

print("第1個mini_batch_X 的維度為：",mini_batches[0][0].shape)
print("第1個mini_batch_Y 的維度為：",mini_batches[0][1].shape)
print("第2個mini_batch_X 的維度為：",mini_batches[1][0].shape)
print("第2個mini_batch_Y 的維度為：",mini_batches[1][1].shape)
print("第3個mini_batch_X 的維度為：",mini_batches[2][0].shape)
print("第3個mini_batch_Y 的維度為：",mini_batches[2][1].shape)

def Initial_velocity(parameters):
L=len(parameters)//2 #L=4 //除後結果為整數，/除後結果為浮點數
V={}
for l in range(L):

print("-------------測試initialize_velocity-------------")
parameters = testCase.initialize_velocity_test_case()
v = Initial_velocity(parameters)

print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))

def UpdateWith_velocity (parameters,grads,V,beta,learning_rate):
L=len(parameters)//2
for l in range(L):
V["dW"+str(l+1)]=beta V["dW"+str(l+1)]+(1-beta) grads["dW"+str(l+1)]
V["db"+str(l+1)]=beta V["db"+str(l+1)]+(1-beta) grads["db"+str(l+1)]

print("-------------測試update_parameters_with_momentun-------------")
parameters,grads,v = testCase.update_parameters_with_momentum_test_case()
UpdateWith_velocity (parameters,grads,v,beta=0.9,learning_rate=0.01)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))

def initial_Adam(parameters):
L=len(parameters)//2
S={}
V={}
for l in range(L):
S["dW"+str(1+l)]=np.zeros_like(parameters["W"+str(1+l)])
S["db"+str(1+l)]=np.zeros_like(parameters["b"+str(1+l)])

print("-------------測試initialize_adam-------------")
parameters = testCase.initialize_adam_test_case()
v,s = initial_Adam(parameters)

print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))
print('s["dW1"] = ' + str(s["dW1"]))
print('s["db1"] = ' + str(s["db1"]))
print('s["dW2"] = ' + str(s["dW2"]))
print('s["db2"] = ' + str(s["db2"]))

def Update_parameter_Adam(parameters,grads,V,S,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
L=len(parameters)//2
V_corrected={}
S_corrected={}
for l in range(L):
V["dW"+str(1+l)]=beta1 V["dW"+str(1+l)]+(1-beta1) grads["dW"+str(1+l)]
V["db"+str(1+l)]=beta1 V["db"+str(1+l)]+(1-beta1) grads["db"+str(1+l)]

print("-------------測試update_with_parameters_with_adam-------------")
parameters , grads , v , s = testCase.update_parameters_with_adam_test_case()
Update_parameter_Adam(parameters,grads,v,s,t=2)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))
print('s["dW1"] = ' + str(s["dW1"]))
print('s["db1"] = ' + str(s["db1"]))
print('s["dW2"] = ' + str(s["dW2"]))
print('s["db2"] = ' + str(s["db2"]))

def Upadate_parameter(parameters,grads,learing_rate=0.8):
L=len(parameters)//2
for l in range(L):
parameters["W"+str(1+l)]=parameters["W"+str(1+l)]-learing_rate grads["dW"+str(1+l)]
parameters["b"+str(1+l)]=parameters["b"+str(1+l)]-learing_rate grads["db"+str(1+l)]
return parameters

train_X,train_Y = opt_utils.load_dataset(is_plot=False)

batch_number=64
layer_dims=[train_X.shape[0],5,2,1]

costs = []
parameters=opt_utils.initialize_parameters(layer_dims)

def model (parameters,td="gd",learing_rate=0.0007,beta=0.9,is_plot=True,print_cost=True,iterations=10000):
t = 0
seed = 10
for i in range(iterations):
seed=seed+1
Batches = GetMinibatch(train_X,train_Y ,batch_number,seed)
for batch in Batches :
(bacth_X,batch_Y)=batch
#向前傳播
A3,cache=opt_utils.forward_propagation(bacth_X,parameters)
#計算cost
cost=opt_utils.compute_cost(A3,batch_Y)
#向後傳播
grads=opt_utils.backward_propagation(bacth_X,batch_Y,cache)
#更新模型參數
if(td=="gd"):
parameters=Upadate_parameter(parameters,grads,learing_rate)
elif(td=="velocity"):
V=Initial_velocity(parameters)
parameters,V=UpdateWith_velocity (parameters,grads,V,beta,learing_rate)
elif(td=="adam"):
V,S=initial_Adam(parameters)
t=t+1
parameters,V,S=Update_parameter_Adam(parameters,grads,V,S,t,learing_rate,beta1=0.9,beta2=0.999,epsilon=1e-8)

parameters = model(parameters,td="gd",is_plot=True)

preditions = opt_utils.predict(train_X,train_Y,parameters)

plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5, 2.5])
axes.set_ylim([-1, 1.5])
opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)

--------------實驗結果------------------------------

② 關於遺傳演算法優化BP神經網路的問題

程序：
1、未經遺傳演算法優化的BP神經網路建模
clear;
clc;
%%%%%%%%%%%%%輸入參數%%%%%%%%%%%%%%
N=2000; %數據總個數
M=1500; %訓練數據
%%%%%%%%%%%%%訓練數據%%%%%%%%%%%%%%
for i=1:N
input(i,1)=-5+rand*10;
input(i,2)=-5+rand*10;
end
output=input(:,1).^2+input(:,2).^2;
save data input output

load data.mat

%從1到N隨機排序
k=rand(1,N);
[m,n]=sort(k);
%找出訓練數據和預測數據
input_train=input(n(1:M),:)';
output_train=output(n(1:M),:)';
input_test=input(n((M+1):N),:)';
output_test=output(n((M+1):N),:)';
%數據歸一化
[inputn,inputs]=mapminmax(input_train);
[outputn,outputs]=mapminmax(output_train);
%構建BP神經網路
net=newff(inputn,outputn,5);
net.trainParam.epochs=100;
net.trainParam.lr=0.1;
net.trainParam.goal=0.0000004;
%BP神經網路訓練
net=train(net,inputn,outputn);
%測試樣本歸一化
inputn_test=mapminmax('apply',input_test,inputs);
%BP神經網路預測
an=sim(net,inputn_test);
%%網路得到數據反歸一化
BPoutput=mapminmax('reverse',an,outputs);

figure(1)
%plot(BPoutput,':og');
scatter(1:(N-M),BPoutput,'rx');
hold on;
%plot(output_test,'-*');
scatter(1:(N-M),output_test,'o');
legend('預測輸出','期望輸出','fontsize',12);
title('BP網路預測輸出','fontsize',12);
xlabel('樣本','fontsize',12);
xlabel('優化前輸出的誤差','fontsize',12);

figure(2)
error=BPoutput-output_test;
plot(1:(N-M),error);
xlabel('樣本','fontsize',12);
ylabel('優化前輸出的誤差','fontsize',12);
%save net net inputs outputs
2、遺傳演算法優化的BP神經網路建模
（1）主程序
%清空環境變數
clc
clear

%讀取數據
load data.mat

%節點個數
inputnum=2;
hiddennum=5;
outputnum=1;

%訓練數據和預測數據
input_train=input(1:1500,:)';
input_test=input(1501:2000,:)';
output_train=output(1:1500)';
output_test=output(1501:2000)';

%選連樣本輸入輸出數據歸一化
[inputn,inputps]=mapminmax(input_train);
[outputn,outputps]=mapminmax(output_train);

%構建網路
net=newff(inputn,outputn,hiddennum);

%% 遺傳演算法參數初始化
maxgen=10; %進化代數，即迭代次數
sizepop=30; %種群規模
pcross=[0.3]; %交叉概率選擇，0和1之間
pmutation=[0.1]; %變異概率選擇，0和1之間

%節點總數
numsum=inputnum*hiddennum+hiddennum+hiddennum*outputnum+outputnum;

lenchrom=ones(1,numsum);
bound=[-3*ones(numsum,1) 3*ones(numsum,1)]; %數據范圍

%------------------------------------------------------種群初始化------------------------------%------------------

--------
indivials=struct('fitness',zeros(1,sizepop), 'chrom',[]); %將種群信息定義為一個結構體
%avgfitness=[]; %每一代種群的平均適應度
bestfitness=[]; %每一代種群的最佳適應度
bestchrom=[]; %適應度最好的染色體
%初始化種群
for i=1:sizepop
%隨機產生一個種群
indivials.chrom(i,:)=Code(lenchrom,bound); %編碼
x=indivials.chrom(i,:);
%計算適應度
indivials.fitness(i)=fun(x,inputnum,hiddennum,outputnum,net,inputn,outputn); %染色體的適應度
end

%找最好的染色體
[bestfitness bestindex]=min(indivials.fitness);
bestchrom=indivials.chrom(bestindex,:); %最好的染色體
%avgfitness=sum(indivials.fitness)/sizepop; %染色體的平均適應度
% 記錄每一代進化中最好的適應度和平均適應度
%trace=[avgfitness bestfitness];

%% 迭代求解最佳初始閥值和權值
% 進化開始
for i=1:maxgen
i
% 選擇
indivials=Select(indivials,sizepop);
% avgfitness=sum(indivials.fitness)/sizepop;
%交叉
indivials.chrom=Cross(pcross,lenchrom,indivials.chrom,sizepop,bound);
% 變異
indivials.chrom=Mutation(pmutation,lenchrom,indivials.chrom,sizepop,i,maxgen,bound);

% 計算適應度
for j=1:sizepop
x=indivials.chrom(j,:); %解碼
indivials.fitness(j)=fun(x,inputnum,hiddennum,outputnum,net,inputn,outputn);
end

%找到最小和最大適應度的染色體及它們在種群中的位置
[newbestfitness,newbestindex]=min(indivials.fitness);
[worestfitness,worestindex]=max(indivials.fitness);
% 代替上一次進化中最好的染色體
if bestfitness>newbestfitness
bestfitness=newbestfitness;
bestchrom=indivials.chrom(newbestindex,:);
end
indivials.chrom(worestindex,:)=bestchrom;
indivials.fitness(worestindex)=bestfitness;

%avgfitness=sum(indivials.fitness)/sizepop;

% trace=[trace;avgfitness bestfitness]; %記錄每一代進化中最好的適應度和平均適應度

end
%% 遺傳演算法結果分析
%figure(3)
%[r c]=size(trace);
%plot([1:r]',trace(:,2),'b--');
%title(['適應度曲線 ' '終止代數＝' num2str(maxgen)]);
%xlabel('進化代數');ylabel('適應度');
%legend('平均適應度','最佳適應度');
disp('適應度 變數');
x=bestchrom;

%% 把最優初始閥值權值賦予網路預測
% %用遺傳演算法優化的BP網路進行值預測
w1=x(1:inputnum*hiddennum);
B1=x(inputnum*hiddennum+1:inputnum*hiddennum+hiddennum);
w2=x(inputnum*hiddennum+hiddennum+1:inputnum*hiddennum+hiddennum+hiddennum*outputnum);
B2=x

(inputnum*hiddennum+hiddennum+hiddennum*outputnum+1:inputnum*hiddennum+hiddennum+hiddennum*outputnum+outputnum);

net.iw{1,1}=reshape(w1,hiddennum,inputnum);
net.lw{2,1}=reshape(w2,outputnum,hiddennum);
net.b{1}=reshape(B1,hiddennum,1);
net.b{2}=B2;

%% BP網路訓練
%網路進化參數
net.trainParam.epochs=100;
net.trainParam.lr=0.1;
%net.trainParam.goal=0.00001;

%網路訓練
[net,per2]=train(net,inputn,outputn);

%% BP網路預測
%數據歸一化
inputn_test=mapminmax('apply',input_test,inputps);
an=sim(net,inputn_test);
test_simu=mapminmax('reverse',an,outputps);
error=test_simu-output_test;

%figure(4);
hold on;plot(1:500,error,'r');
legend('優化前的誤差','優化後的誤差','fontsize',12)

(2)編碼子程序code.m
function ret=Code(lenchrom,bound)
%本函數將變數編碼成染色體，用於隨機初始化一個種群
% lenchrom input : 染色體長度
% bound input : 變數的取值范圍
% ret output: 染色體的編碼值
flag=0;
while flag==0
pick=rand(1,length(lenchrom));
ret=bound(:,1)'+(bound(:,2)-bound(:,1))'.*pick; %線性插值，編碼結果以實數向量存入ret中
flag=test(lenchrom,bound,ret); %檢驗染色體的可行性
end

(3)適應度函數fun.m
function error = fun(x,inputnum,hiddennum,outputnum,net,inputn,outputn)
%該函數用來計算適應度值
%x input 個體
%inputnum input 輸入層節點數
%outputnum input 隱含層節點數
%net input 網路
%inputn input 訓練輸入數據
%outputn input 訓練輸出數據
%error output 個體適應度值
%提取
w1=x(1:inputnum*hiddennum);
B1=x(inputnum*hiddennum+1:inputnum*hiddennum+hiddennum);
w2=x(inputnum*hiddennum+hiddennum+1:inputnum*hiddennum+hiddennum+hiddennum*outputnum);
B2=x(inputnum*hiddennum+hiddennum+hiddennum*outputnum+1:inputnum*hiddennum+hiddennum+hiddennum*outputnum+outputnum);
net=newff(inputn,outputn,hiddennum);
%網路進化參數
net.trainParam.epochs=20;
net.trainParam.lr=0.1;
net.trainParam.goal=0.00001;
net.trainParam.show=100;
net.trainParam.showWindow=0;
%網路權值賦值
net.iw{1,1}=reshape(w1,hiddennum,inputnum);
net.lw{2,1}=reshape(w2,outputnum,hiddennum);
net.b{1}=reshape(B1,hiddennum,1);
net.b{2}=B2;
%網路訓練
net=train(net,inputn,outputn);
an=sim(net,inputn);
error=sum(abs(an-outputn));

(4)選擇操作Select.m
function ret=select(indivials,sizepop)
% 該函數用於進行選擇操作
% indivials input 種群信息
% sizepop input 種群規模
% ret output 選擇後的新種群

%求適應度值倒數
[a bestch]=min(indivials.fitness);
%b=indivials.chrom(bestch);
%c=indivials.fitness(bestch);
fitness1=10./indivials.fitness; %indivials.fitness為個體適應度值

%個體選擇概率
sumfitness=sum(fitness1);
sumf=fitness1./sumfitness;

%採用輪盤賭法選擇新個體
index=[];
for i=1:sizepop %sizepop為種群數
pick=rand;
while pick==0
pick=rand;
end
for i=1:sizepop
pick=pick-sumf(i);
if pick<0
index=[index i];
break;
end
end
end
%index=[index bestch];
%新種群
indivials.chrom=indivials.chrom(index,:); %indivials.chrom為種群中個體
indivials.fitness=indivials.fitness(index);
%indivials.chrom=[indivials.chrom;b];
%indivials.fitness=[indivials.fitness;c];
ret=indivials;

(5)交叉操作cross.m
function ret=Cross(pcross,lenchrom,chrom,sizepop,bound)
%本函數完成交叉操作
% pcorss input : 交叉概率
% lenchrom input : 染色體的長度
% chrom input : 染色體群
% sizepop input : 種群規模
% ret output : 交叉後的染色體
for i=1:sizepop %每一輪for循環中，可能會進行一次交叉操作，染色體是隨機選擇的，交叉位置也是隨機選擇的，%但該輪for循環中是否進行交叉操作則由交叉概率決定（continue控制）
% 隨機選擇兩個染色體進行交叉
pick=rand(1,2);
while prod(pick)==0
pick=rand(1,2);
end
index=ceil(pick.*sizepop);
% 交叉概率決定是否進行交叉
pick=rand;
while pick==0
pick=rand;
end
if pick>pcross
continue;
end
flag=0;
while flag==0
% 隨機選擇交叉位
pick=rand;
while pick==0
pick=rand;
end
pos=ceil(pick.*sum(lenchrom)); %隨機選擇進行交叉的位置，即選擇第幾個變數進行交叉，注意：兩個染色體交叉的位置相同
pick=rand; %交叉開始
v1=chrom(index(1),pos);
v2=chrom(index(2),pos);
chrom(index(1),pos)=pick*v2+(1-pick)*v1;
chrom(index(2),pos)=pick*v1+(1-pick)*v2; %交叉結束
flag1=test(lenchrom,bound,chrom(index(1),:)); %檢驗染色體1的可行性
flag2=test(lenchrom,bound,chrom(index(2),:)); %檢驗染色體2的可行性
if flag1*flag2==0
flag=0;
else flag=1;
end %如果兩個染色體不是都可行，則重新交叉
end
end
ret=chrom;

(6)變異操作Mutation.m
function ret=Mutation(pmutation,lenchrom,chrom,sizepop,num,maxgen,bound)
% 本函數完成變異操作
% pcorss input : 變異概率
% lenchrom input : 染色體長度
% chrom input : 染色體群
% sizepop input : 種群規模
% opts input : 變異方法的選擇
% pop input : 當前種群的進化代數和最大的進化代數信息
% bound input : 每個個體的上屆和下屆
% maxgen input ：最大迭代次數
% num input : 當前迭代次數
% ret output : 變異後的染色體
for i=1:sizepop %每一輪for循環中，可能會進行一次變異操作，染色體是隨機選擇的，變異位置也是隨機選擇的，
%但該輪for循環中是否進行變異操作則由變異概率決定（continue控制）
% 隨機選擇一個染色體進行變異
pick=rand;
while pick==0
pick=rand;
end
index=ceil(pick*sizepop);
% 變異概率決定該輪循環是否進行變異
pick=rand;
if pick>pmutation
continue;
end
flag=0;
while flag==0
% 變異位置
pick=rand;
while pick==0
pick=rand;
end
pos=ceil(pick*sum(lenchrom)); %隨機選擇了染色體變異的位置，即選擇了第pos個變數進行變異
pick=rand; %變異開始
fg=(rand*(1-num/maxgen))^2;
if pick>0.5
chrom(i,pos)=chrom(i,pos)+(bound(pos,2)-chrom(i,pos))*fg;
else
chrom(i,pos)=chrom(i,pos)-(chrom(i,pos)-bound(pos,1))*fg;
end %變異結束
flag=test(lenchrom,bound,chrom(i,:)); %檢驗染色體的可行性
end
end
ret=chrom;

③ 神經網路中自適應的梯度下降優化演算法（二）

Adagrad演算法可以針對不同的參數自適應的採用不同的更新頻率，對低頻出現的特徵採用低的更新率，對高頻出現的特徵採用高的更新率，因此，對於稀疏的數據它表現的很好，很好的提升了SGD的魯棒性，在Google的通過Youtube視頻識別貓的神經網路訓練中有很好的表現。

梯度更新規則:

g(t,i)表示在t時刻目標函數對θ(i)的偏導數。SGD的每個參數的更新過程如下：

Adagrad的每個參數更新過程如下:

G(t)是一個對角矩陣，對角線上的每個元素是t時刻前所有θ(i)的梯度的平方和。ε通常取值在1e-8量級，它的存在是為了避免除數為0。一個有趣的現象是，如果沒有平方根操作，演算法的表現就非常糟糕。

Adagrad的主要缺點是，它的分母是平方梯度的累積，它的值會一直增加，最終導致學習率衰減到非常小，從而使得學習演算法無法進行下去。

TensorFlow實現:

tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1, use_locking=False, name='Adagrad')

Adadelta演算法主要解決Adagrad的缺陷，它不再累加過去所有的梯度，而是僅累積過去固定個數的梯度。

Adadelta不是採用平方梯度的簡單累加，而是採用 歷史 平方梯度的衰減的平均。

γ通常等於0.9

分母相當於梯度的均方根(root mean squared, RMS)，即將所有值平方求和，求其均值，再開平方，就得到均方根值。

梯度更新規則:

將學習率η設置為

，我們就不需要提前設定學習率。

RMSprop是Geoff Hinton提出的一種自適應學習率的方法，它與Adadelta方法都是為了解決Adagrad學習率急劇下降問題的。它與Adadelta方法是一致的。

梯度更新規則

超參數設定值:

Hinton建議設定γ=0.9, 學習率η=0.001。

TensorFlow實現:

tf.train.RMSPropOptimizer.__init__(learning_rate, decay, momentum=0.0, epsilon=1e-10, use_locking=False, name='RMSProp')

Adam也是對不同的參數自適應設置不同的學習率。它對 歷史 梯度和 歷史 平方梯度同時採用指數梯度衰減(exponentially decaying average)。

梯度更新規則

Adam作者觀察到，如果m(t)和v(t)初始化為零向量，並且衰減率很小時(比如β1和β2都非常接近於1時)，在開始的迭代中，m(t)和v(t)總是向零偏移，所以需要做偏移校正。

然後用校正後的值進行梯度更新:

Adam作者建議β1=0.9,β2=0.999,ε=10^{-8}

，在實踐中，Adam比其它演算法的效果要好。

TensorFlow實現：

tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam')

Adam更新規則中的梯度縮放與 歷史 梯度的L2范數成反比。

我們可以把這個規則泛化到Lp范數。

當p值增大的時候，Lp的值往往會變得不穩定，所以在實踐中L1和L2使用的比較普遍。但是Adamax作者發現L∞可以收斂到一個穩定值。

然後我們可以採用u(t)代替

來更新Adam中的梯度。

同時u(t)不需要做零偏校正。默認取值建議：

④ 神經網路演算法原理

一共有四種演算法及原理，如下所示：

1、自適應諧振理論（ART）網路

自適應諧振理論（ART）網路具有不同的方案。一個ART-1網路含有兩層一個輸入層和一個輸出層。這兩層完全互連，該連接沿著正向（自底向上）和反饋（自頂向下）兩個方向進行。

2、學習矢量量化（LVQ）網路

學習矢量量化（LVQ）網路，它由三層神經元組成，即輸入轉換層、隱含層和輸出層。該網路在輸入層與隱含層之間為完全連接，而在隱含層與輸出層之間為部分連接，每個輸出神經元與隱含神經元的不同組相連接。

3、Kohonen網路

Kohonen網路或自組織特徵映射網路含有兩層，一個輸入緩沖層用於接收輸入模式，另一個為輸出層，輸出層的神經元一般按正則二維陣列排列，每個輸出神經元連接至所有輸入神經元。連接權值形成與已知輸出神經元相連的參考矢量的分量。

4、Hopfield網路

Hopfield網路是一種典型的遞歸網路，這種網路通常只接受二進制輸入（0或1）以及雙極輸入（+1或-1）。它含有一個單層神經元，每個神經元與所有其他神經元連接，形成遞歸結構。

(4)神經網路演算法優化擴展閱讀：

人工神經網路演算法的歷史背景：

該演算法系統是 20 世紀 40 年代後出現的。它是由眾多的神經元可調的連接權值連接而成，具有大規模並行處理、分布式信息存儲、良好的自組織自學習能力等特點。

BP演算法又稱為誤差反向傳播演算法，是人工神經網路中的一種監督式的學習演算法。BP 神經網路演算法在理論上可以逼近任意函數，基本的結構由非線性變化單元組成，具有很強的非線性映射能力。

而且網路的中間層數、各層的處理單元數及網路的學習系數等參數可根據具體情況設定，靈活性很大，在優化、信號處理與模式識別、智能控制、故障診斷等許 多領域都有著廣泛的應用前景。

⑤ matlab的遺傳演算法優化BP神經網路

對y=x1^2+x2^2非線性系統進行建模，用1500組數據對網路進行構建網路，500組數據測試網路。由於BP神經網路初始神經元之間的權值和閾值一般隨機選擇，因此容易陷入局部最小值。本方法使用遺傳演算法優化初始神經元之間的權值和閾值，並對比使用遺傳演算法前後的效果。
步驟：
未經遺傳演算法優化的BP神經網路建模
1、
隨機生成2000組兩維隨機數(x1,x2)，並計算對應的輸出y=x1^2+x2^2，前1500組數據作為訓練數據input_train，後500組數據作為測試數據input_test。並將數據存儲在data中待遺傳演算法中使用相同的數據。
2、
數據預處理：歸一化處理。
3、
構建BP神經網路的隱層數，次數，步長，目標。
4、
使用訓練數據input_train訓練BP神經網路net。

⑥ 如何用其他演算法優化神經網路演算法

matlab有神經網路和遺傳演算法的工具箱， 我沒用過，不過你的問題看起來也很基礎的，應該容易做

⑦ 在MATLAB中用神經網路演算法求解無約束最優化問題

程序一：GA訓練BP權值的主函數 function net=GABPNET(XX,YY) % 使用遺傳演算法對BP網路權值閾值進行優化，再用BP演算法訓練網路 %數據歸一化預處理 nntwarn off XX=[1:19;2:20;3:21;4:22]'; YY=[1:4]; XX=premnmx(XX); YY=premnmx(YY); YY %創建網路 net=newff(minmax(XX),[19,25,1],{'tansig','tansig','purelin'},'trainlm'); %下面使用遺傳演算法對網路進行優化 P=XX; T=YY; R=size(P,1); S2=size(T,1); S1=25;%隱含層節點數 S=R*S1+S1*S2+S1+S2;%遺傳演算法編碼長度 aa=ones(S,1)*[-1,1]; popu=50;%種群規模 save data2 XX YY % 是將 xx,yy 二個變數的數值存入 data2 這個MAT-file， initPpp=initializega(popu,aa,'gabpEval');%初始化種群 gen=100;%遺傳代數 %下面調用gaot工具箱，其中目標函數定義為gabpEval [x,endPop,bPop,trace]=ga(aa,'gabpEval',[],initPpp,[1e-6 1 1],'maxGenTerm',gen,... 'normGeomSelect',[0.09],['arithXover'],[2],'nonUnifMutation',[2 gen 3]); %繪收斂曲線圖 figure(1) plot(trace(:,1),1./trace(:,3),'r-'); hold on plot(trace(:,1),1./trace(:,2),'b-'); xlabel('Generation'); ylabel('Sum-Squared Error'); figure(2) plot(trace(:,1),trace(:,3),'r-'); hold on plot(trace(:,1),trace(:,2),'b-'); xlabel('Generation'); ylabel('Fittness');

⑧ 用粒子群群演算法優化BP神經網路的參數，進行極值尋優

這四個都屬於人工智慧演算法的范疇。其中BP演算法、BP神經網路和神經網路
屬於神經網路這個大類。遺傳演算法為進化演算法這個大類。
神經網路模擬人類大腦神經計算過程，可以實現高度非線性的預測和計算，主要用於非線性擬合，識別，特點是需要「訓練」，給一些輸入，告訴他正確的輸出。若干次後，再給新的輸入，神經網路就能正確的預測對於的輸出。神經網路廣泛的運用在模式識別，故障診斷中。BP演算法和BP神經網路是神經網路的改進版，修正了一些神經網路的缺點。
遺傳演算法屬於進化演算法，模擬大自然生物進化的過程：優勝略汰。個體不斷進化，只有高質量的個體（目標函數最小（大））才能進入下一代的繁殖。如此往復，最終找到全局最優值。遺傳演算法能夠很好的解決常規優化演算法無法解決的高度非線性優化問題，廣泛應用在各行各業中。差分進化，蟻群演算法，粒子群演算法等都屬於進化演算法，只是模擬的生物群體對象不一樣而已。

⑨ 模擬退火演算法優化BP神經網路

bp神經元網路的學習過程真正求解的其實就是權值的最優解，因為有可能會得出局部最優解，所以你才會用模擬退火來跳出局部最優解，也就是引入了逃逸概率。在這里你可以把bp的學習過程理解成關於 誤差=f（w1,w2...） 的函數，讓這個函數在模擬退火中作為目標函數，再加上模擬退火的一些初始參數（初始溫度啊，退火速度啊等等），就能找到權值解空間的一個不錯的最優解，就是一組權向量。把權向量帶入到bp當中去，輸入新的對象，自然就能算出新的輸出了。
演算法學習要腳踏實地，你要先學會神經元，在學會退火，兩個的結合你才能理解。

⑩ 神經網路演算法可以求最優解嘛

神經網路可以做優化問題，但不一定能找到最優解。

邏輯性的思維是指根據邏輯規則進行推理的過程；它先將信息化成概念，並用符號表示，然後，根據符號運算按串列模式進行邏輯推理；這一過程可以寫成串列的指令，讓計算機執行。

直觀性的思維是將分布式存儲的信息綜合起來，忽然間產生的想法或解決問題的辦法。這種思維方式的根本之點在於以下兩點：

1、信息是通過神經元上的興奮模式分布存儲在網路上。

2、信息處理是通過神經元之間同時相互作用的動態過程來完成的。

神經網路：

思維學普遍認為，人類大腦的思維分為抽象（邏輯）思維、形象（直觀）思維和靈感（頓悟）思維三種基本方式。

人工神經網路就是模擬人思維的第二種方式。這是一個非線性動力學系統，其特色在於信息的分布式存儲和並行協同處理。雖然單個神經元的結構極其簡單，功能有限，但大量神經元構成的網路系統所能實現的行為卻是極其豐富多彩的。