BP神经网络实现函数逼近python实现

合集下载

BP神经网络逼近非线性函数

3、试用BP 神经网络逼近非线性函数f(u) =)5.0u (9.1e+-sin(10u) 其中，u ∈[-0.5,0.5]（1）解题步骤：①网络建立:使用“net=newff(minmax(x), [20, 1], {'tansig ’,’ purelin' });，语句建立个前馈BP 神经网络。

该BP 神经网络只含个隐含层，且神经元的个数为20。

隐含层和输出层神经元的传递函数分别为tansig 和pure-lin 。

其他参数默认。

②网络训练:使用“net=train (net, x , y) ;”语句训练建立好的BP 神经网络。

当然在网络训练之前必须设置好训练参数。

如设定训练时间为50个单位时间，训练目标的误差小于0.01，用“net.trainParam.epochs=50; net.train-Param.goal=0.01；”，语句实现。

其他参数默认。

③网络仿真:使用“y1=sim(net, x); y2=sim(net, x};”语句仿真训练前后的BP 神经网络。

（2）程序如下：clear all ；x=[-0.5:0.01:0.5];y=exp(-1.9*(0.5+x)).*sin(10*x);net=newff(minmax(x),[20,1],{'tansig' 'purelin'});y1=sim(net,x); %未训练网络的仿真结果 net.trainParam.epochs=50;net.trainParam.goal=0.01;net=train(net,x,y);y2=sim(net,x); %训练后网络的仿真结果 figure;plot(x,y,'-',x,y1,'-',x,y2,'--')title('原函数与网络训练前后的仿真结果比较');xlabel('x');ylabel('y');legend('y','y1','y2');grid on（3）仿真结果如图：图1图1为原函数y与网络训练前后（y1，y2）的仿真结果比较图。

BP算法代码实现

BP算法代码实现BP算法（Backpropagation Algorithm）是一种常用的神经网络训练算法，它主要用于监督式学习任务中的模型训练。

BP算法的核心思想是通过反向传播来更新神经网络的权重和偏差，以使得神经网络的输出逼近目标输出。

在反向传播的过程中，通过求解梯度来更新每个连接权重和偏置的值，从而最小化损失函数。

以下是BP算法的代码实现示例：```pythonimport numpy as npclass NeuralNetwork:def __init__(self, layers):yers = layersself.weights = []self.biases = []self.activations = []#初始化权重和偏置for i in range(1, len(layers)):self.weights.append(np.random.randn(layers[i], layers[i-1])) self.biases.append(np.random.randn(layers[i]))def sigmoid(self, z):return 1 / (1 + np.exp(-z))def sigmoid_derivative(self, z):return self.sigmoid(z) * (1 - self.sigmoid(z))def forward_propagate(self, X):self.activations = []activation = X#前向传播计算每一层的激活值for w, b in zip(self.weights, self.biases):z = np.dot(w, activation) + bactivation = self.sigmoid(z)self.activations.append(activation)return activationdef backward_propagate(self, X, y, output):deltas = [None] * len(yers)deltas[-1] = output - y#反向传播计算每一层的误差（梯度）for i in reversed(range(len(yers)-1)):delta = np.dot(self.weights[i].T, deltas[i+1]) * self.sigmoid_derivative(self.activations[i])deltas[i] = delta#更新权重和偏置for i in range(len(yers)-1):self.weights[i] -= 0.1 * np.dot(deltas[i+1],self.activations[i].T)self.biases[i] -= 0.1 * np.sum(deltas[i+1], axis=1)def train(self, X, y, epochs):for epoch in range(epochs):output = self.forward_propagate(X)self.backward_propagate(X, y, output)def predict(self, X):output = self.forward_propagate(X)return np.round(output)```上述代码使用numpy实现了一个简单的多层神经网络，支持任意层数和任意神经元个数的构建。

(采用BP神经网络完成非线性函数的逼近)神经网络

控制系统仿真与模型处理设计报告（采用BP神经网络完成非线性函数的逼近）1、题目要求：（1）确定一种神经网络、网络结构参数和学习算法。

（2）选择适当的训练样本和检验样本，给出选取方法。

（3）训练网络使学习目标误差函数达到0.01，写出学习结束后的网络各参数，并绘制学习之前、第100次学习和学习结束后各期望输出曲线、实际输出曲线。

绘制网络训练过程的目标误差函数曲线。

（4）验证网络的泛化能力，给出网络的泛化误差。

绘制网络检验样本的期望输出曲线和网络输出曲线。

（5）分别改变神经网络的中间节点个数、改变网络的层数、改变学习算法进行比较实验，讨论系统的逼近情况，给出你自己的结论和看法。

2、设计方案：在MATLAB中建立M文件下输入如下命令：x=[0:0.01:1];y=2.2*power(x-0.25,2)+sin(5*pi*x);plot(x,y)xlabel('x');ylabel('y');title('非线性函数');得到如下图形，即所给的非线性函数曲线图：构造一个1-7-1的BP神经网络，第一层为输入层，节点个数为1；第二层为隐层，节点个数为7；变换函数选正切s型函数(tansig)；第三层为输出层，节点个数为1，输出层神经元传递函数为purelin函数。

并且选Levenberg-Marquardt算法(trainlm)为BP网络的学习算法。

对于该初始网络，我们选用sim()函数观察网络输出。

继续在M函数中如下输入。

net=newff(minmax(x),[1,7,1],{'tansig','tansig','purelin'},'trainlm'); y1=sim(net,x);figure;plot(x,y,'b',x,y1,'r')title('期望输出与实际输出比较');xlabel('t');则得到以下所示训练的BP网络期望输出与实际输出曲线比较：应用函数train()对网络进行训练之前，需要预先设置训练参数。

神经网络在函数逼近中的应用

二基于BP神经网络逼近函数基于BP神经网络逼近函数
步骤1：假设频率参数k=1，绘制要逼近的非线性步骤1：假设频率参数k=1，绘制要逼近的非线性函数的曲线。函数的曲线如图1 函数的曲线。函数的曲线如图1所示 k=1; p=[p=[-1:.05:8]; t=1+sin(k*pi/4*p); plot（ plot（p，t，'-')； ')； title('要逼近的非线性函数'); title('要逼近的非线性函数'); xlabel('时间'); xlabel('时间'); ylabel('非线性函数'); ylabel('非线性函数');
图3 训练过程从以上结果可以看出，网络训练速度很快，很快就达到了要求的精度0.001。快就达到了要求的精度0.001。
步骤4 步骤4：网络测试对于训练好的网络进行仿真： y2=sim(net,p); figure; plot(p,t,'plot(p,t,'-',p,y1,':',p,y2, '--') '--') title('训练后网络的输出结果'); title('训练后网络的输出结果'); xlabel('时间'); xlabel('时间'); ylabel('仿真输出'); ylabel('仿真输出'); 绘制网络输出曲线，并与原始非线性函数曲线以及未训练网络的输出结果曲线相比较，比较出来的结果如图4 的结果如图4所示。
BP网络在函数逼近中的应用 BP网络在函数逼近中的应用

用BP网络逼近非线性函数f(x)=sin2x+cos5x

智能技术实验三-BP程序的算法设计1熟悉BP网络的基本训练算法程序，练习课件上的相关程序。

（1）用BP网络逼近非线性函数f(x)=sin2x+cos5x程序：x=-0.8:0.05:0.75;t=sin(2*x)+cos(5*x);net=newff(minmax(x),[12,1],{'tansig','purelin'},'trainbfg','learngdm','sse');%利用准牛顿反向传播算法对网络进行训练，动量梯度下降权值与阈值的学习net.trainParam.epochs=1500;%训练步数net.trainParam.goal=0;%训练目标误差net.trainParam.lr=1.42;%学习速率net.trainParam.show=100;%现实训练结果的间隔步数[net,Tr]=train(net,x,t);x1=-0.77:0.05:0.78;y1=sim(net,x1);x2=0.75:0.05:0.95;%外推t2=sin(2*x2)+cos(5*x2);y2=sim(net,x2);e=y2-t2;xwc=e./t2;%相对误差figure(2)subplot(211)plot(x,t,'ko',x,t,'k-',x1,y1,'k*',x1,y1,'k-');xlabel('自变量x')ylabel('函数值')subplot(212)plot(x2,e,'k.',x2,e,'k-')xlabel('自变量x')ylabel('函数误差值e')运行结果：（2）BP 网络在故障诊断中的应用程序：P=[0.2286 0.1292 0.0720 0.1592 0.1335 0.0733 0.1159 0.0940 0.0522 0.1345 0.0090 0.1260 0.3619 0.0690 0.1828; 0.2090 0.0947 0.1393 0.1387 0.2558 0.0900 0.0771 0.0882 0.0393 0.1430 0.0126 0.1670 0.2450 0.0508 0.1328; 0.0442 0.0880 0.1147 0.0563 0.3347 0.1150 0.1453 0.0429 0.1818 0.0378 0.0092 0.2251 0.1516 0.0858 0.0670;0.2603 0.1715 0.0702 0.2711 0.1491 0.1330 0.0968 0.1911 0.2545 0.0871 0.0060 0.1793 0.1002 0.0789 0.0909; 0.3690 0.2222 0.0562 0.5157 0.1872 0.1614 0.1425 0.1506 0.1310 0.0500 0.0078 0.0348 0.0451 0.0707 0.0880; 0.0359 0.1149 0.1230 0.5460 0.1977 0.1248 0.0624 0.0832 0.1640 0.1002 0.0059 0.1503 0.1837 0.1295 0.0700;自变量x函数值0.750.80.850.90.95自变量x函数误差值e0.1759 0.2347 0.1829 0.1811 0.2922 0.0655 0.0774 0.2273 0.2056 0.0925 0.0078 0.1852 0.3501 0.1680 0.2668;0.0724 0.1909 0.1340 0.2409 0.2842 0.0450 0.0824 0.1064 0.1909 0.1586 0.0116 0.1698 0.3644 0.2718 0.2494;0.2634 0.2258 0.1165 0.1154 0.1074 0.0657 0.0610 0.2623 0.2588 0.1155 0.0050 0.0978 0.1511 0.2273 0.3220]';T=[1 0 0;1 0 0;1 0 0;0 1 0;0 1 0;0 1 0;0 0 1;0 0 1;0 0 1]';%输入向量的最大值与最小值threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1];net=newff(threshold,[31,3],{'tansig','l ogsig'},'trainlm');%训练次数为50，训练目标为0.001，学习速率为0.1net.trainParam.epochs=50;net.trainParam.goal=0.001;LP.lr=0.1;net=train(net,P,T);%测试数据test=[0.2593 0.1800 0.0711 0.2801 0.1501 0.1298 0.1001 0.1891 0.2531 0.0875 0.0058 0.1803 0.0992 0.0802 0.1002;0.2101 0.0950 0.1298 0.1359 0.2601 0.1001 0.0753 0.0890 0.0389 0.1451 0.0128 0.1590 0.2452 0.0512 0.1319;0.2599 0.2235 0.1201 0.1171 0.1102 0.0683 0.0621 0.2597 0.2602 0.1167 0.0048 0.1002 0.1521 0.2281 0.3205]';y=sim(net,test)运行结果：y =0.0160 0.9789 0.01010.9600 0.0234 0.03920.0161 0.0044 0.9701（3）BP网络在模式识别中的应用程序：%BP网络用血清胆固醇含量检测%prestd-对样本数据进行标准化处理%prepca-对样本数据进行主元分析%newff-生成一个新的前向神经网络%train-对BP网络进行训练%sim-对BP网络进行仿真%postreg-对仿真结果进行回归分析%加载样本数据load choles_all.matsizeofp=size(p);sizeoft=size(t);%对样本数据进行标准化处理[pn,meanp,stdp,tn,meant,stdt]=prestd(p, t);%对样本数据进行主元分析[ptrans,transMat]=prepca(pn,0.001); [R,Q]=size(ptrans);% 将样本数据划分为训练集、验证集和测试集iitst=2:4:Q;iival=4:4:Q;iitr=[1:4:Q 3:4:Q];val.P=ptrans(:,iival);%验证样本集val.T=tn(:,iival);test.P=ptrans(:,iitst);%测试样本集test.T=tn(:,iitst);ptr=ptrans(:,iitr);%训练样本集ttr=tn(:,iitr);%创建神经网络net=newff(minmax(ptr),[53],{'tansig','purelin'},'trainlm'); [net,tr]=train(net,ptr,ttr,[],[],val,te st);%绘制误差变化曲线plot(tr.epoch,tr.perf,tr.epoch,tr.vperf,':',tr.epoch,tr.tperf,'r-.') legend('Training','Validation','Test',-1);ylabel('Squard Error'); xlabel('Epoch'); %对神经网络进行仿真分析 an=sim(net,ptrans); a=poststd(an,meant,stdt);%将仿真结果与目标输出作线性回归分析 for i=1:3 figure(i+1)[m(i),b(i),r(i)]=postreg(a(i,:),t(i,:)); end运行结果：2468100.20.40.60.811.21.41.6EpochS q u a r d E r r o rTraining Validation Test2 采用2种不同的训练算法来训练BP网络，使其能够拟合某一附加有白噪声的正弦样本数据，其中样本数据可以采用下列语句生成：输入矢量：P=[-1:0.05:1];目标矢量：randn(’seed’,78341223)；T=sin(2*pi*P)+0.1*randn(size(P));% NEWFF——生成一个新的前向神经网络% TRAIN——对BP 神经网络进行训练% SIM——对BP 神经网络进行仿真算法1：Trainlm(L-M优化方法)程序：%定义网络输入和期望输出P=[-1:0.05:1];randn('seed',78341223);T=sin(2*pi*P)+0.1*randn(size(P));%建立相应的BP网络net=newff(minmax(P),[3,1],{'tansig','pu relin'},'trainlm');inputWeights=net.IW{1,1};inputbias=net.b{1};% 训练网络net.trainParam.show=50;net.trainParam.lr=0.05; net.trainParam.mc=0.9; net.trainParam.epochs=1000; net.trainParam.goal=0.0001;%调用TRAINGDM算法训练BP网络net=train(net,P,T);%对BP网络进行仿真A=sim(net,P);E=A-T;M=mse(E);N=sse(E);%测试网络%结果作图 %训练曲线 figure(1) plot(T,'r'); hold on plot(A,'b.:');legend('训练样本值','BP 拟合值'); title('BP 网络训练图');xlabel('样本个数'); %训练误差 figure(2) plot(T-A,'-');title('BP 网络训练误差'); legend('训练样本误差'); ylabel('训练绝对误差'); xlabel('样本个数'); grid;运行结果：51015202530354045-1.5-1-0.50.511.5样本个数BP 网络训练图算法2trainrp （弹性学习算法）程序：%定义网络输入和期望输出 P=[-1:0.05:1]; randn('seed',78341223);T=sin(2*pi*P)+0.1*randn(size(P)); %建立相应的BP 网络net=newff(minmax(P),[3,1],{'tansig','pu relin'},'trainrp'); inputWeights=net.IW{1,1}; inputbias=net.b{1};% 训练网络net.trainParam.show=50; net.trainParam.lr=0.05; net.trainParam.mc=0.9; net.trainParam.epochs=1000; net.trainParam.goal=0.0001;%调用TRAINGDM 算法训练BP 网络 net=train(net,P,T);%对BP 网络进行仿真 A=sim(net,P); E=A-T; M=mse(E); N=sse(E); %测试网络%结果作图 %训练曲线 figure(1) plot(T,'r'); hold on plot(A,'b.:');legend('训练样本值','BP 拟合值'); title('BP 网络训练图');xlabel('样本个数'); %训练误差 figure(2) plot(T-A,'-');title('BP 网络训练误差');51015202530354045-0.500.51BP 网络训练误差样本个数训练绝对误差legend('训练样本误差'); ylabel('训练绝对误差');xlabel('样本个数'); grid;运行结果：51015202530354045-1.5-1-0.50.511.5样本个数BP 网络训练图51015202530354045-0.8-0.6-0.4-0.200.20.40.60.8BP 网络训练误差样本个数训练绝对误差。

BP网络逼近sin函数

b2 = rands(outputLayer,1);%输出层阈值
alpha = 0.4;%学习速率
error = 0.0001;%误差阈值
M = 200;
%%训练数据200
for m = 1:M
y = sin(0.01*pi*m);%实际样本输出
for k = 1:50
%%对每个数据训练50次
for i = 1:hideLayer %隐层
hold on
plot (x,y1,'r-');
legend('标准sin图像','BP逼近的sin图像')
figure;
plot(e1);
title('错误率')
p(i) = logsig(w1(i) * x(m) + b1(i));
end
a = 0; %输出层
for j = 1:hideLayer
q(j) = p(j) * w2(j);
a = a + q(j);
end
a = a + b2;
if m <= 100
A = logsig(a);
elseif m > 100
bp网络函数逼近神经网络函数逼近函数逼近函数逼近论matlab函数逼近函数逼近理论函数逼近论方法样条函数逼近样条函数及其逼近复变函数逼近
%%网络结构1-2-1，学习率alpha=0.4
clear all;
close all;
clc;
input = 1; %输入层像两个数
hideLayer = 2;%隐藏层神经元个数
outputLayer = 1;%输出层神经元个数
x = [0.01*pi:0.01*pi:2*pi];%输入向量（1*200）

智能计算bp网络设计基于bp网络的分类和非线性函数逼近

1、基于BP网络的分类（1）问题的提出：在平直直角坐标系A 区域中 = x,y :x∈−4 ,0 ,y∈−4 ,0随机生成1000个点，令B 区域中的点为一类：B= x,y :x∈(−2.5 ,1) ,y∈(−2.5 ,1)A 区域的其他点为一类，现在利用BP神经网络学习这个分类，并用测试集C 中的点C= x k,y k: x k=−4+0.05k ,y k=−4+0.05k ,k=0,1,…,80测试C 中位于B 区域中的点能否被识别。

（2）网络的结构：net=newff([-4 0;-4 0],[n 2],{'logsig' 'logsig'},'trainlm','learngdm');（3）网络训练（采用不同的隐单元个数，使用常数及自适应学习率，加动量项，数值优化算法）采用不同的隐单元个数：隐层节点个数为n，本次实验取n=8和n=14并对其进行比较。

使用常数及自适应学习率：常数：net.trainParam.lr=0.1。

自适应学习率：'trainlm' 这个位置替换为'traingda' （在分类中并不能换）加动量项：'trainlm' 这个位置替换为'traingdm'（在分类中并不能换）数值优化算法：'trainlm' 这个位置替换为'traingdx'（在分类中并不能换）（4）网络测试与结果分析：①条件：隐层节点个数n=8 + 学习率常数net.trainParam.lr=0.1 + 梯度下降训练'trainglm'clear all;clc%给定训练点及目标值x=(rand(1,1000)*(-0.4))*10;y=(rand(1,1000)*(-0.4))*10;x=[x;y];T=zeros(2,size(x,2));for i=1:size(x,2);if abs(x(1,i)) < 2.5 && abs(x(1,i)) > 1 && abs(x(2,i)) < 2.5 && abs(x(2,i)) > 1 T(1,i)=1;endendfor i = 1:size(x,2);if T(1,i) == 1T(2,i) = 0;else T(2,i) = 1;endendinputs = x;targets = T;% 创建网络n = 8;net=newff([-4 0;-4 0],[n 2],{'logsig' 'logsig'},'trainlm','learngdm'); %Levenberg-Marquardtnet.inputs{1}.processFcns = {'removeconstantrows','mapminmax'}; %数据归一化net.outputs{2}.processFcns = {'removeconstantrows','mapminmax'}; %数据归一化%% 训练参数net.trainParam.epochs = 2000;net.trainParam.goal = 1e-4;net.trainParam.lr = 0.1;% 训练网络[net,tr] = train(net,inputs,targets);% 测试网络outputs = net(inputs);errors = gsubtract(targets,outputs); performance = perform(net,targets,outputs);%% 训练集合绘图figure(1);hold onfor i=1:size(x,2)if T(1,i)==1plot(x(1,i),x(2,i),'b*');endif T(2,i)==1plot(x(1,i),x(2,i),'r*');endend%% 模拟绘图figure(2);test=-4:0.05:0;output=[];[A,B]=meshgrid(test,test);C=[];v=size(test,2);for i=1:vC(1,1+(i-1)*v:i*v)=A(i,:);C(2,1+(i-1)*v:i*v)=B(i,:);endoutput=abs(net(C));N=zeros(1,v*v);for i=1:v*vif output(1,i)>=output(2,i)N(1,i)=1;endendplot3(C(1,:),C(2,:),N,'o');结果分析：说明8个隐藏层节点太少了，没有达到精度就到了最大迭代次数。

研究实验2报告示范——单入单出BP人工神经网络及算法研究

研究实验2报告示范——单入单出BP 人工神经网络及算法研究一．研究问题描述：用BP 方法实现一个单输入单输出的函数的逼近。

假设转换函数的输出范围在0到1之间。

函数取以下3个：(),0.20.8x f x e x -=≤≤()0.50.3*sin ,01f x x x =+≤≤()0.50.3*sin(2*),01f x x x =+≤≤二．网络结构：1．三层前向神经网络根据逼近定理知，只含一个隐层的前向网络（即三层前向神经网络）是一个通用的逼近器，可以任意逼近函数f ，因此，在本题中选用三层前向神经网络，即输入层（x0,y0），一个隐层（x1,y1），输出层（x2,y2）。

2．网络结构由于要逼近的函数为单输入单输出函数，故输出层只有一个节点；输入层除了一个样本输入点外，还有一个阈值单元，因此可以看作是两个输入节点；隐层的节点个数p 可以在程序运行时进行选择，以适应和测试不同的逼近效果。

由输入层至隐层的权矩阵记为W0，由隐层到输出层的权矩阵记为W1。

整个网络的结构初步设计如下图所示：（略）三．算法实现本实验用C++程序实现该算法。

报告中所给出的实验数据均是运行C++程序所得的结果，然后将这些结果在matlab 中画出对应图形。

1．标准BP 算法（无动量项）：根据公式：（α为学习率）-----⋅⋅-=∂∂⋅-=+Pl l l l l l j i l l j i l l j i k y k k w k w E k w k w 1,1,1,,1,,1,)()()()(/)()1(δαα编写程序，程序执行时允许选择：样本个数p ，隐层节点个数midnumber ，学习速率step ，训练过程结束条件（即训练结束时允许的最大误差）enderr 。

2．加动量项的BP 算法基本原理同上，仅在标准BP 算法的基础上，对权矩阵的修改添加动量项，程序执行时允许选择：样本个数p ，隐层节点个数midnumber ，学习速率step ，训练过程结束条件（即训练结束时允许的最大误差）enderr ，以及动量因子moti 。

基于BP神经网络工具箱实现函数逼近

第３８卷第９期・术学
ＶｏＩ．３８Ｎｏ９
湖
南
农
￥ｔＪ、
２０１１年９月
Ｓｅｐ．２０１１
ＨＵＮＡＮＡＧ刚ＣＵＵｒＵＲＡＬ数逼近
王丽萍
（安大学，长陕西西安７０５）１０４
摘要：用计算机高级语言编程对神经网络Ｂ模型进行仿真和辅助设计是件十分麻烦的事情，了解决这个运Ｐ为矛盾，ａａ神经网络工具箱中专门编制了大量有关设计Ｂ网络模型的工具函。ＭｔｂｌＰ数文章分析了Ｍｆｂａａ软件包中人工ｌ神经网络工具箱的有关ＢＰ网络的工具函数，结合一个实际的例子详细阐述了基于ＢＰ神经网络的函数逼近过程及其
ｌ ⅣＧ－ｉｇＬｉｐｎ
（ｈｎ＂ｎｖｒｉ，＇ｈｎｉ７０５，ｈｎ）ＣａｇａＵｉｓｙＸｉｎＳａｘ１０４ｉｎｅｔａＣａ
ＡｂｔａｔＴｅｈ－ｅｅｏｕｅａｇａｅｐｏｒｍｍｉｇｏｈＰｎｕａｅｗｏｋｓｍｕａｉｎａｄｍｏｅ－ｉｅｓｒｃｈｉｈｌｖｌｃｍｐｔｒｌｎｕｇｒｇａｇｎｎｔｅＢｅｒｌｎｔｒｉｌｔｎｄｌａｄｄｏ
ｐｃａｅｏｒｉｃａｅｒｌｎｔｒｏｌｏｆｔｅＢｅｗｒｔｉｕｃｉｎ，ｏｉｅｔｅａｌｄｐａｔａｘｍ— ａｋｇｆａｔｉｌｎｕａｅｗｏｋｔｏｂｘｏｈＰｎｔｏｋｕｉｔｆｎｔｓｃｍｂｎｄｗｉａｄｔｉｒｃｉｌｅａｉｆｌｙｏｈｅｃｐｅｂｓｄｏＰｎｕａｅｗｏｋｆｎｔｎａｐｏｉｔｎｐｃｓｎｌａｅｎＢｅｒｌｎｔｒｕｃｉｐｒｘｍａｉｒｅｓａｄＭＡＴＡＢｉｌｍｅｔｔｎｏｏｏＬｍｐｅｎａｉ．ｏＫｅｗｏｄ：ｔｂｙｒｓＭａｌ；ＢＰｎｕａｅｗｒ；ｏｌｏａｅｒｌｎｔｏｋｔｏｂｘ

基于BP神经网络的函数逼近实验及MATLAB实现_曹旭帆

! ( 3) 由 ymj = F
W y m m- 1 ij i
计算从第一层直至输
i
出层各节点 j的输出 ymj , 其中上标 m 为 BP 网络的层
标号, F 为神经元的激励函数 ymi - 1为 BP网络 m - 1层
的 i节点的输出, Wmij为 m - 1层的 i节点到 m 层的 j节
点的连接权值, M = M, M - 1, ∀, 1。
!mj = !mj +
m j
( 9) 返回 2, 输入下一组数据前重复 ( 2) ∃ ( 8)的
过程。由此可见, BP 算法的主要思路是从后向前逐层
传播输出层的误差, 并用此误差修正前层权值。
对于 BP 神经网络, 有一个重要定理, 对于任何闭
区间内的连续函数, 都可以用一个三层的 BP 网络逼
近, 本文要研究的问题就是 BP 网络的隐层神经元个
根据上述一系列实验以及各种算法的训练速度计算量及内存需求量我们设计的bp网络net隐层神经元数目定为16输入输出层神经元数目为1隐层输出层传递函数均为tansig训练函数为traingdx用样本训练网络net训练步数为10000步目标误差0000001bp网络net经过训练达到误差精度要求逼近误差e为00044959netiw11表示隐层16个神经元和输入层1神经元之间的连接权值netlw21表示输出层1个神经元和隐层16个神经元之间的连接权值netb1表示隐层16个神经元的阈值netb2表示输出个神经元的阈值bp网络net的各项权值和阈值如下
关键词: BP 神经网络; MATLAB; 函数逼近; 多项式拟合
中图分类号: TP183
文献标识码: A
文章编号: 1006- 7167( 2008) 05- 0034- 05

BP算法程序实现

BP算法程序实现BP算法（Back Propagation Algorithm，即反向传播算法）是一种用于训练神经网络的常用算法。

它的基本思想是通过不断地调整神经元之间的连接权值，使得网络的输出接近于期望的输出。

在实现BP算法时，需要进行以下几个步骤：1.初始化参数：首先，需要初始化神经网络的权值和偏置，通常可以使用随机的小数来初始化。

同时，需要设置好网络的学习率和最大迭代次数。

2.前向传播：通过前向传播过程，将输入数据输入到神经网络中，并计算出每个神经元的输出。

具体来说，对于第一层的神经元，它们的输出即为输入数据。

对于后续的层，可以使用如下公式计算输出：a[i] = sigmoid(z[i])其中，a[i]表示第i层的输出，z[i]为第i层的输入加权和，sigmoid为激活函数。

3.计算误差：根据网络的输出和期望的输出，可以计算出网络的误差。

一般来说，可以使用均方差作为误差的度量指标。

loss = 1/(2 * n) * Σ(y - a)^2其中，n为训练样本的数量，y为期望输出，a为网络的实际输出。

4.反向传播：通过反向传播算法，将误差从输出层向输入层逐层传播，更新权值和偏置。

具体来说，需要计算每一层神经元的误差，并使用如下公式更新权值和偏置：delta[i] = delta[i+1] * W[i+1]' * sigmoid_derivative(z[i])W[i] = W[i] + learning_rate * delta[i] * a[i-1]'b[i] = b[i] + learning_rate * delta[i]其中，delta[i]为第i层的误差，W[i]为第i层与i+1层之间的权值，b[i]为第i层的偏置，learning_rate为学习率，sigmoid_derivative为sigmoid函数的导数。

5.迭代更新：根据步骤4中的更新公式，不断迭代调整权值和偏置，直到达到最大迭代次数或误差小于一些阈值。

神经网络激活函数[BP神经网络实现函数逼近的应用分析]

神经网络激活函数[BP神经网络实现函数逼近的应用分析]神经网络激活函数是神经网络中非常重要的组成部分，它决定了神经网络的非线性特性，并且对于神经网络的求解效果和性能有着重要的影响。

本文将对神经网络激活函数进行详细的分析和探讨，并以BP神经网络实现函数逼近的应用为例进行具体分析。

1.神经网络激活函数的作用（1）引入非线性：神经网络通过激活函数引入非线性，使其具备处理非线性问题的能力，能够更好的逼近任意非线性函数。

（2）映射特征空间：激活函数可以将输入映射到另一个空间中，从而更好地刻画特征，提高神经网络的表达能力，并且可以保留原始数据的一些特性。

（3）增强模型的灵活性：不同的激活函数具有不同的形状和性质，选择合适的激活函数可以增加模型的灵活性，适应不同问题和数据的特点。

（4）解决梯度消失问题：神经网络中经常会遇到梯度消失的问题，通过使用合适的激活函数，可以有效地缓解梯度消失问题，提高神经网络的收敛速度。

2.常用的神经网络激活函数（1）Sigmoid函数：Sigmoid函数是一种常用的激活函数，它的输出值范围在(0,1)之间，具有平滑性，但是存在梯度消失问题。

（2）Tanh函数：Tanh函数是Sigmoid函数的对称形式，它的输出值范围在(-1,1)之间，相对于Sigmoid函数来说，均值为0，更符合中心化的要求。

（3）ReLU函数：ReLU函数在输入为负数时输出为0，在输入为正数时输出为其本身，ReLU函数简单快速，但是容易出现神经元死亡问题，即一些神经元永远不被激活。

（4）Leaky ReLU函数：Leaky ReLU函数是对ReLU函数的改进，当输入为负数时，输出为其本身乘以一个小的正数，可以解决神经元死亡问题。

（5）ELU函数：ELU函数在输入为负数时输出为一个负有指数衰减的值，可以在一定程度上缓解ReLU函数带来的神经元死亡问题，并且能够拟合更多的函数。

3.BP神经网络实现函数逼近的应用BP神经网络是一种常用的用于函数逼近的模型，它通过不断调整权重和偏置来实现对目标函数的拟合。

函数逼近法python

函数逼近法python
函数逼近法是一种常见的数学方法，它可以将一个复杂的函数逼近成一个简单的函数。

在Python中，有许多方法可以进行函数逼近，比如最小二乘法、样条函数法、高斯过程法等等。

下面我们将介绍一些常见的函数逼近方法及其Python实现。

1.最小二乘法
最小二乘法是一种基于平方误差最小化的函数逼近方法。

它通过求解最小二乘问题来确定逼近函数的系数，从而使得逼近函数与原函数在给定区间内的平方误差最小。

在Python中，可以使用numpy库的polyfit函数来进行最小二乘逼近。

2.样条函数法
样条函数法是一种基于分段多项式的函数逼近方法。

它将函数划分为若干个小区间，并在每个小区间内拟合一个多项式函数，以达到逼近的目的。

在Python中，可以使用scipy库的interpolate模块来进行样条函数逼近。

3.高斯过程法
高斯过程法是一种基于贝叶斯定理的函数逼近方法。

它通过利用已有数据的信息，对未知函数进行概率分布的建模，并在后验概率分布中选取一个最优函数作为逼近函数。

在Python中，可以使用scikit-learn库的GaussianProcessRegressor类来进行高斯过程逼近。

以上是一些常见的函数逼近方法及其Python实现。

在实际应用
中，可以根据具体问题的特点选择适合的函数逼近方法，并通过Python的强大功能快速高效地实现。

实验二基于BP神经网络算法的函数逼近

实验二基于BP神经网络算法的函数逼近一、引言函数逼近是神经网络应用的重要领域之一、在实际问题中，我们常常需要使用一个适当的数学函数来近似描述现象与问题之间的关系。

BP神经网络作为一种常用的函数逼近方法，具有良好的逼近性能和普适性，能够对非线性函数进行逼近，并且在实际应用中已经得到了广泛的应用。

本实验将通过BP神经网络算法对给定的函数进行逼近，验证其逼近效果和性能。

二、实验目标1.理解和掌握BP神经网络算法的基本原理和步骤；2.掌握使用BP神经网络进行函数逼近的方法；3.通过实验验证BP神经网络在函数逼近中的性能。

三、实验步骤1.准备数据集选择一个待逼近的非线性函数，生成一组训练数据和测试数据。

训练数据用于训练神经网络模型，测试数据用于评估逼近效果。

2.构建神经网络模型根据待逼近的函数的输入和输出维度，确定神经网络的输入层和输出层的神经元个数，并选择适当的激活函数和损失函数。

可以根据实际情况调整隐藏层的神经元个数，并添加正则化、dropout等技术来提高模型的泛化能力。

3.初始化网络参数对于神经网络的参数（权重和偏置）进行随机初始化，通常可以采用均匀分布或高斯分布来初始化。

4.前向传播和激活函数通过输入数据，进行前向传播计算，得到网络的输出值，并通过激活函数将输出值映射到合适的范围内。

5.计算损失函数根据网络的输出值和真实值，计算损失函数的值，用于评估模型的训练效果。

6.反向传播和权重更新通过反向传播算法，计算各个参数的梯度，根据学习率和梯度下降算法更新网络的参数。

7.循环迭代训练重复以上步骤，直至达到预设的训练停止条件（如达到最大迭代次数或损失函数满足收敛条件）。

8.模型测试和评估使用测试数据评估训练好的模型的逼近效果，可以计算出逼近误差和准确度等指标来评估模型的性能。

四、实验结果通过对比逼近函数的真实值和模型的预测值，可以得到模型的逼近效果。

同时，通过计算逼近误差和准确度等指标来评估模型的性能。

基于BP算法的函数逼近步骤

TAIYUAN UNIVERSITY OF SCIENCE & TECHNOLOGY 基于BP算法函数逼近步骤** : **学号 : S*********班级 : 研1507基于BP算法函数逼近步骤一、BP神经网络算法：BP（Back Propagation）网络是是一种按误差逆向传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。

BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。

它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。

BP神经网络模型拓扑结构包括输入层、隐含层和输出层。

输入层各神经元负责接收来自外界的输入信息，并传递给中间层各神经元；中间层是内部信息处理层，负责信息变换，根据信息变化能力的需求，中间层可以设计为单隐含层或者多隐含层结构；最后一个隐含层传递到输出层各神经元的信息，经进一步处理后，完成一次学习的正向传播处理过程，由输出层向外界输出信息处理结果。

当实际输出与期望输出不符时，进入误差的反向传播阶段。

误差通过输出层，按误差梯度下降的方式修正各层权值，向隐含层、输入层逐层反传。

周而复始的信息正向传播和误差反向传播过程，是各层权值不断调整的过程，也是神经网络学习训练的过程，此过程一直进行到网络输出的误差减少到可以接受的程度，或者预先设定的学习次数为止。

二、BP学习算法的计算步骤概述BP算法的基本原理是梯度最速下降法，它的中心思想是调整权值使网络总误差最小。

运行BP学习算法时，包含正向和反向传播两个阶段。

（1）正向传播输入信息从输入层经隐含层逐层处理，并传向输出层，每层神经元的状态只影响下一层神经元的状态。

（2）反向传播将误差信号沿原来的连接通道返回，通过修改各层神经元的权值，使误差信号最小。

学习过程是一种误差边向后传播边修正权系数的过程。

隐层的反传误差信号为jk Mk k j i w I f ∑=⋅=1')(δδ由此可得，隐层权值的修正公式为：i Mk jk k j ij O w I f w ⋅⋅=∆∑=)()(1'δη或iMk jk k j j ij O w O O w ⋅⋅-=∆∑=)()1(1δη四、程序代码w10=[0.1 0.2;0.3 0.15;0.2 0.4]; w11=[0.2 0.1;0.25 0.2;0.3 0.35]; w20=[0.2;0.25;0.3]; w21=[0.15;0.2;0.4];q0=[0.1 0.2 0.3]; q1=[0.2 0.15 0.25]; p0=0.2;p1=0.1; xj=[0.5;0.9]; k1=5;k2=1200; e0=0;e1=0;e2=0; for s=1:72yp1=cos(2*3.14*k1*s/360); for k=1:k2 for i=1:3x=w11(i,1)*xj(1,:)+w11(i,2)*xj(2,:); z=x+q1(:,i); o=[1-exp(-z)]/[1+exp(-z)]; m=1/[1+exp(-z)]; m1(i,:)=m; o1(i,:)=o; end for i=1:3 yb=0;yb=yb+w21(i,:)*o1(i,:); endyi=yb+p1; n=1/[1+exp(-yi)];y=[1-exp(-yi)]/[1+exp(-yi)]; e0=e1; e1=e2; e2=[(yp1-y).^2]/2; xj1=e2-e1; xj2=e2-2*e1+e0; xj=[xj1;xj2];d2=n*(1-y)*(yp1-y);bk=d2; for i=1:3u=w21(i,:)*bk;d1=[1-o1(i,:)]*u;d0=m1(i,:)*d1;qw=q1(:,i)-q0(:,i);q2=q1(:,i)+0.8*d0+0.4*qw;q3(:,i)=q2;for j=1:2dw=w11(i,j)-w10(i,j);w12=w11(i,j)+0.8*d0*xj(j,:)+0.6*dw; w13(i,j)=w12;endendw10=w11;w11=w13;q0=q1;q1=q3;for i=1:3h=w21(i,:)-w20(i,:);w22=w21(i,:)+0.4*d2*o1(i,:)+0.75*h;w23(i,:)=w22;endw20=w21;w21=w23;ph=p1-p0;p2=p1+0.9*d2+0.6*ph;p0=p1;p1=p2;if e2<0.0001,break;else k=k+1;endende(s)=e2;ya(s)=yp1;yo(s)=y;s=s+1;ends1=s-1;s=1:s1;plot(s,ya,s,yo,'g.',s,e,'rx');title('BP');五、运行结果1．此次逼近的函数为y=cosx，蓝色为真实的余弦曲线，绿色为逼近的余弦曲线，红色代表误差曲线，从图像上可以得出逼近结果与原曲线契合程度高，效果良好。

pso优化bp算法python代码精选全文完整版

可编辑修改精选全文完整版pso优化bp算法python代码PSO优化BP算法Python代码BP神经网络是一种常用的人工神经网络，它可以用于分类、回归等任务。

但是，BP神经网络的训练过程需要大量的计算和时间，而且容易陷入局部最优解。

为了解决这些问题，我们可以使用粒子群优化（PSO）算法来优化BP神经网络。

PSO算法是一种基于群体智能的优化算法，它模拟了鸟群或鱼群等生物的行为，通过不断地搜索和迭代，找到最优解。

在PSO算法中，每个粒子代表一个解，它们通过不断地移动和更新自己的位置和速度，来寻找最优解。

下面是使用Python实现PSO优化BP算法的代码：```pythonimport numpy as npimport random# 定义BP神经网络类class BPNN:def __init__(self, input_size, hidden_size, output_size):self.input_size = input_sizeself.hidden_size = hidden_sizeself.output_size = output_sizeself.W1 = np.random.randn(self.input_size, self.hidden_size) self.W2 = np.random.randn(self.hidden_size, self.output_size) # 定义sigmoid函数def sigmoid(self, x):return 1 / (1 + np.exp(-x))# 定义前向传播函数def forward(self, X):self.z2 = np.dot(X, self.W1)self.a2 = self.sigmoid(self.z2)self.z3 = np.dot(self.a2, self.W2)y_hat = self.sigmoid(self.z3)return y_hat# 定义损失函数def loss(self, X, y):y_hat = self.forward(X)J = 0.5 * sum((y - y_hat) ** 2)return J# 定义反向传播函数def backward(self, X, y):y_hat = self.forward(X)delta3 = np.multiply(-(y - y_hat), self.sigmoid(self.z3) * (1 - self.sigmoid(self.z3)))dJdW2 = np.dot(self.a2.T, delta3)delta2 = np.dot(delta3, self.W2.T) * self.sigmoid(self.z2) * (1 - self.sigmoid(self.z2))dJdW1 = np.dot(X.T, delta2)return dJdW1, dJdW2# 定义PSO算法类class PSO:def __init__(self, n_particles, input_size, hidden_size, output_size, max_iter, c1, c2, w):self.n_particles = n_particlesself.input_size = input_sizeself.hidden_size = hidden_sizeself.output_size = output_sizeself.max_iter = max_iterself.c1 = c1self.c2 = c2self.w = wself.particles = []self.gbest = Noneself.gbest_loss = float('inf')# 初始化粒子群for i in range(self.n_particles):bpnn = BPNN(self.input_size, self.hidden_size, self.output_size) particle = {'position': [bpnn.W1, bpnn.W2], 'velocity': [np.zeros((self.input_size, self.hidden_size)), np.zeros((self.hidden_size, self.output_size))], 'pbest': None, 'pbest_loss': float('inf')}self.particles.append(particle)# 定义更新粒子位置和速度的函数def update(self):for particle in self.particles:# 更新速度particle['velocity'][0] = self.w * particle['velocity'][0] + self.c1 * random.random() * (particle['pbest'][0] - particle['position'][0]) + self.c2 * random.random() * (self.gbest[0] - particle['position'][0])particle['velocity'][1] = self.w * particle['velocity'][1] + self.c1 * random.random() * (particle['pbest'][1] - particle['position'][1]) + self.c2 * random.random() * (self.gbest[1] - particle['position'][1])# 更新位置particle['position'][0] += particle['velocity'][0]particle['position'][1] += particle['velocity'][1]# 更新pbest和gbestbpnn = BPNN(self.input_size, self.hidden_size, self.output_size) bpnn.W1 = particle['position'][0]bpnn.W2 = particle['position'][1]loss = bpnn.loss(X, y)if loss < particle['pbest_loss']:particle['pbest'] = [bpnn.W1, bpnn.W2]particle['pbest_loss'] = lossif loss < self.gbest_loss:self.gbest = [bpnn.W1, bpnn.W2]self.gbest_loss = loss# 定义训练函数def train(self, X, y):for i in range(self.max_iter):self.update()print('Iteration:', i, 'Loss:', self.gbest_loss)# 测试代码X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])y = np.array([[0], [1], [1], [0]])pso = PSO(n_particles=10, input_size=2, hidden_size=4, output_size=1,max_iter=100, c1=2, c2=2, w=0.8)pso.train(X, y)```在上面的代码中，我们首先定义了一个BP神经网络类，包括前向传播、损失函数和反向传播等方法。

人工智能实验报告-BP神经网络算法的简单实现

⼈⼯智能实验报告-BP神经⽹络算法的简单实现⼈⼯神经⽹络是⼀种模仿⼈脑结构及其功能的信息处理系统，能提⾼⼈们对信息处理的智能化⽔平。

它是⼀门新兴的边缘和交叉学科，它在理论、模型、算法等⽅⾯⽐起以前有了较⼤的发展，但⾄今⽆根本性的突破，还有很多空⽩点需要努⼒探索和研究。

1⼈⼯神经⽹络研究背景神经⽹络的研究包括神经⽹络基本理论、⽹络学习算法、⽹络模型以及⽹络应⽤等⽅⾯。

其中⽐较热门的⼀个课题就是神经⽹络学习算法的研究。

近年来⼰研究出许多与神经⽹络模型相对应的神经⽹络学习算法，这些算法⼤致可以分为三类：有监督学习、⽆监督学习和增强学习。

在理论上和实际应⽤中都⽐较成熟的算法有以下三种：(1) 误差反向传播算法(Back Propagation，简称BP 算法)；(2) 模拟退⽕算法；(3) 竞争学习算法。

⽬前为⽌，在训练多层前向神经⽹络的算法中，BP 算法是最有影响的算法之⼀。

但这种算法存在不少缺点，诸如收敛速度⽐较慢，或者只求得了局部极⼩点等等。

因此，近年来，国外许多专家对⽹络算法进⾏深⼊研究，提出了许多改进的⽅法。

主要有：(1) 增加动量法：在⽹络权值的调整公式中增加⼀动量项，该动量项对某⼀时刻的调整起阻尼作⽤。

它可以在误差曲⾯出现骤然起伏时，减⼩振荡的趋势，提⾼⽹络训练速度；(2) ⾃适应调节学习率：在训练中⾃适应地改变学习率，使其该⼤时增⼤，该⼩时减⼩。

使⽤动态学习率，从⽽加快算法的收敛速度；(3) 引⼊陡度因⼦：为了提⾼BP 算法的收敛速度，在权值调整进⼊误差曲⾯的平坦区时，引⼊陡度因⼦，设法压缩神经元的净输⼊，使权值调整脱离平坦区。

此外，很多国内的学者也做了不少有关⽹络算法改进⽅⾯的研究，并把改进的算法运⽤到实际中，取得了⼀定的成果：(1) 王晓敏等提出了⼀种基于改进的差分进化算法，利⽤差分进化算法的全局寻优能⼒，能够快速地得到BP 神经⽹络的权值，提⾼算法的速度；(2) 董国君等提出了⼀种基于随机退⽕机制的竞争层神经⽹络学习算法，该算法将竞争层神经⽹络的串⾏迭代模式改为随机优化模式，通过采⽤退⽕技术避免⽹络收敛到能量函数的局部极⼩点，从⽽得到全局最优值；(3) 赵青提出⼀种分层遗传算法与BP 算法相结合的前馈神经⽹络学习算法。

基于BP神经网络算法的函数逼近

基于BP神经网络算法的函数逼近神经网络是一种基于生物神经元工作原理构建的计算模型，可以通过学习和调整权重来逼近非线性函数。

其中，基于误差反向传播算法（BP）的神经网络是最常见和广泛应用的一种，其能够通过反向传播来调整网络的权重，从而实现对函数的近似。

BP神经网络的算法包括了前馈和反向传播两个过程。

前馈过程是指输入信号从输入层经过隐藏层传递到输出层的过程，反向传播过程是指将网络输出与实际值进行比较，并根据误差来调整网络权重的过程。

在函数逼近问题中，我们通常将训练集中的输入值作为网络的输入，将对应的目标值作为网络的输出。

然后通过反复调整网络的权重，使得网络的输出逼近目标值。

首先，我们需要设计一个合适的神经网络结构。

对于函数逼近问题，通常使用的是多层前馈神经网络，其中包括了输入层、隐藏层和输出层。

隐藏层的神经元个数和层数可以根据具体问题进行调整，一般情况下，通过试验和调整来确定最优结构。

然后，我们需要确定误差函数。

对于函数逼近问题，最常用的误差函数是均方误差（Mean Squared Error）。

均方误差是输出值与目标值之间差值的平方和的均值。

接下来，我们进行前馈过程，将输入值通过网络传递到输出层，并计算出网络的输出值。

然后，我们计算出网络的输出与目标值之间的误差，并根据误差来调整网络的权重。

反向传播的过程中，我们使用梯度下降法来最小化误差函数，不断地调整权重以优化网络的性能。

最后，我们通过不断训练网络来达到函数逼近的目标。

训练过程中，我们将训练集中的所有样本都输入到网络中，并根据误差调整网络的权重。

通过反复训练，网络逐渐优化，输出值逼近目标值。

需要注意的是，在进行函数逼近时，我们需要将训练集和测试集分开。

训练集用于训练网络，测试集用于评估网络的性能。

如果训练集和测试集中的样本有重叠，网络可能会出现过拟合现象，导致在测试集上的性能下降。

在神经网络的函数逼近中，还有一些注意事项。

首先是选择适当的激活函数，激活函数能够在网络中引入非线性，使网络能够逼近任意函数。

BP及RBP神经网络逼近

《BP及RBP神经网络逼近、药品销售预测、基本遗传算法设计实验》实验指导书雷菊阳编机械工程学院2012年6月实验一、BP及RBP神经网络逼近一、实验目的1、了解MATLAB集成开发环境2、了解MATLAB编程基本方法3、加深对ＢＰ算法的理解和掌握4、掌握工具包入口初始化及调用5、加深BP、RBP神经网络对任意函数逼近的理解二、实验内容1、MATLAB基本指令和语法。

2、ＢＰ算法的MATLAB实现三、实验步骤1、熟悉MATLAB开发环境2、输入参考程序3、设置断点，运行程序，观察运行结果四、参考程序1、BP算法的matlab实现程序%lr为学习步长，err_goal期望误差最小值，max_epoch训练的最大次数，隐层和输出层初值为零lr=0.05;err_goal=0.01;max_epoch=3000;a=0.9;Oi=0;Ok=0;%两组训练集和目标值X=[1 1;-1 -1;1 1];T=[1 1;1 1];%初始化wki，wij（M为输入节点j的数量；q为隐层节点i的数量；L为输出节点k的数量）[M,N]=size(X);q=8;[L,N]=size(T);wij=rand(q,M);wki=rand(L,q);wij0=zeros(size(wij));wki0=zeros(size(wki));for epoch=1:max_epoch%计算隐层各神经元输出NETi=wij*X;for j=1:Nfor i=1:qOi(i,j)=2/(1+exp(-NETi(i,j)))-1; endend%计算输出层各神经元输出NETk=wki*Oi;for i=1:Nfor k=1:LOk(k,i)=2/(1+exp(-NETk(k,i)))-1; endend%计算误差函数E=((T-Ok)'*(T-Ok))/2;if (E<err_goal)break;end%调整输出层加权系数deltak=Ok.*(1-Ok).*(T-Ok);w=wki;wki=wki+lr*deltak*Oi';wki0=w;%调整隐层加权系数deltai=Oi.*(1-Oi).*(deltak'*wki)';w=wij;wij=wij+lr*deltai*X';wij0=w;endepoch %显示计算次数%根据训练好的wki，wij和给定的输入计算输出X1=X;%计算隐层各神经元的输出NETi=wij*X1;for j=1:Nfor i=1:qOi(i,j)=2/(1+exp(-NETi(i,j)))-1;endend%计算输出层各神经元的输出NETk=wki*Oi;for i=1:Nfor k=1:LOk(k,i)=2/(1+exp(-NETk(k,i)))-1;endendOk %显示网络输出层的输出2、BP 逼近任意函数算法的matlab 实现程序⏹ X=-4:0.08:4;⏹ T=1.1*(1-X+2*X.^2).*exp(-X.^2./2);⏹ net=newff(minmax(X),[20,1],{'tansig','purelin'});⏹ net.trainParam.epochs=15000;⏹ net.trainParam.goal=0.001;⏹ net=train(net,X,T);⏹ X1=-1:0.01:1;⏹ y=sim(net,X1);⏹ figure;⏹ plot(X1,y,'-r',X,T ,':b','LineWidth',2);-4-3-2-10123400.511.522.533.RBF 能够逼近任意的非线性函数⏹X=-4:0.08:4; ⏹T=1.1*(1-X+2*X.^2).*exp(-X.^2./2); ⏹net=newrb(X,T ,0.002,1); ⏹X1=-1:0.01:1; ⏹y=sim(net,X1); ⏹figure; ⏹ plot(X1,y,'-r',X,T ,':b','LineWidth',3);-4-3-2-101234-4-3-2-1012342468101214五、思考题1、试设计一个函数并将结果用图画出。