神经网络实现非线性系统设计范本

基于BP神经网络的非线性函数拟合系统实验分析与结果前几章已经完成了实验的数据准备并做好了相关理论研究，有了一定的理论基础。

本章将通过MATLAB软件搭建拟合模型，完成BP神经网络的训练和预测工作，并对最后的模型根据评价指标进行评价。

4.1 实验平台的搭建本实验的MATLAB软件版本为2018a，CPU I5 9300H，操作系统Windows-64位，显卡GTX 1050Ti 3G。

搭建步骤如下：（1）新建工程打开MATLAB，点击主页，选择新建→工程→空白工程，如图4-1所示。

图4-1 新建工程（2）新建M程序文件点击主页，选择‘新建脚本’，然后点击保存并对文件重命名为‘data.m’，如图4-2所示。

图4-2 新建M程序文件完成上述流程，表明程序运行环境搭建完毕，通过在程序文件里面编写程序完成实验内容。

4.2 数据归一化数据处理是数据拟合、预测和分类的关键步骤，对实验精度有很大影响。

本实验的数据是2个输入一个输出。

在进行BP 网络训练之前，由于每一项输入指标量化标准各不相同，不利于直接进行训练。

并且由于输入数据的单位不一样，有些数据的范围差别很大，导致神经网络收敛慢，训练时间长。

所以在此之前，对样本输入进行归一化处理。

4.2.1 最大-最小归一化最大-最小归一化是将Data 经过公式映射在固定的范围内，具体公式如下：min max minx-x y x x =- （4.1） 最大-最小归一化可以将数据各个特征映射在一定范围，消除量纲对数据特征的影响，不改变数据分布，加快模型的训练学习。

4.2.2 Z -Score 归一化Z -Score 归一化是将原始数据进行标准化，其中方差为a ，均值为b ，具体公式如下：x-b y a= （4.2） Z -Score 归一化可以将离群点的数据规范化，改变原有数据分布，减少离群点数据对模型的影响。

根据非线性函数的特点，本实验选择最大-最小归一化方法，并将数据归一化在[-1,1]之间。

基于神经网络的复杂非线性系统建模与控制技术研究复杂非线性系统建模与控制技术一直是控制理论领域研究的热点之一。

神经网络模型由于其强大的非线性拟合能力和广泛的应用场景，在非线性系统建模和控制方面也具有重要的地位。

本文主要讨论基于神经网络的复杂非线性系统建模与控制技术研究的现状和未来发展方向。

一、复杂非线性系统的建模1.传统方法传统的复杂非线性系统建模方法主要基于数理统计和系统辨识理论，例如ARMA模型、滑动平均模型、自回归移动平均模型等，这些方法要求系统的动力学方程必须是线性和参数可识别的。

但是，在实际应用过程中，很多系统的动力学方程都是非线性的，而且系统的特性通常是不确定和时间变化的，这些传统方法的建模能力在面对这些问题时会受到很大的限制。

2.基于神经网络的方法基于神经网络的建模方法具有较强的非线性逼近能力、泛化能力和鲁棒性，能够更好地适应实际系统的的复杂性、不确定性和时变性。

神经网络模型可以通过无监督学习和有监督学习来实现建模过程。

其中，无监督学习主要包括自组织特征映射网络、高斯混合模型等，有监督学习主要包括前馈神经网络、复杂神经网络等。

这些方法在复杂非线性系统建模和识别方面得到了广泛应用和研究。

二、复杂非线性系统的控制复杂非线性系统的控制方法主要包括传统控制方法和基于神经网络的控制方法。

1.传统控制方法传统的控制方法依赖于已知的系统模型，通常包括PID控制、模型预测控制、自适应控制等。

但是，在实际应用中，由于系统的不确定性和复杂性，传统的控制方法很难有效控制复杂非线性系统。

2.基于神经网络的控制方法基于神经网络的控制方法相对传统控制方法更具优势。

通过学习过程对非线性系统进行自适应在线辨识和控制。

其中，反向传播神经网络、径向基函数网络、自适应神经控制等方法在复杂非线性系统控制方面表现出了较高的控制精度和鲁棒性。

三、未来研究方向在基于神经网络的复杂非线性系统建模和控制领域，仍然存在许多研究问题亟待解决。

试论述神经网络系统建模的几种基本方法。

利用BP 网络对以下非线性系统进行辨识。

非线性系统22()(2(1)1)(1)()1()(1)y k y k y k u k y k y k -++=+++-1）首先利用u(k)=sin(2*pi*k/3)+1/3*sin(2*pi*k/6)，产生样本点500，输入到上述系统，产生y(k), 用于训练BP 网络；2）网络测试，利用u(k)=sin(2*pi*k/4)+1/5*sin(2*pi*k/7), 产生测试点200，输入到上述系统，产生y(k), 检验BP/RBF 网络建模效果。

3）利用模型参考自适应方法，设计NNMARC 控制器，并对周期为50，幅值为+/- 的方波给定，进行闭环系统跟踪控制仿真，检验控制效果(要求超调<5%)。

要求给出源程序和神经网络结构示意图，计算结果（权值矩阵），动态过程仿真图。

1、系统辨识题目中的非线性系统可以写成下式：22()(2(1)1)(1)()();()1()(1)y k y k y k f u k f y k y k -++=•+•=++- 使用BP 网络对非线性部分()f •进行辨识，网络结构如图所示，各层神经元个数分别为2-8-1，输入数据为y(k-1)和y(k-2)，输出数据为y(k)。

图 辨识非线性系统的BP 网络结构使用500组样本进行训练，最终达到设定的的误差，训练过程如图所示图网络训练过程使用200个新的测试点进行测试，得到测试网络输出和误差结果分别如下图，所示。

从图中可以看出，相对训练数据而言，测试数据的辨识误差稍微变大，在±0.06范围内，拟合效果还算不错。

图使用BP网络辨识的测试结果图使用BP网络辨识的测试误差情况clear all;close all;%% 产生训练数据和测试数据U=0; Y=0; T=0;u_1(1)=0; y_1(1)=0; y_2(1)=0;for k=1:1:500 %使用500个样本点训练数据U(k)=sin(2*pi/3*k) + 1/3*sin(2*pi/6*k);T(k)= y_1(k) * (2*y_2(k) + 1) / (1+ y_1(k)^2 + y_2(k)^2); %对应目标值Y(k) = u_1(k) + T(k); %非线性系统输出，用于更新y_1if k<500u_1(k+1) = U(k); y_2(k+1) = y_1(k); y_1(k+1) = Y(k); endendy_1(1)=; y_1(2)=0;y_2(1)=0; y_2(2)=; y_2(3)=0; %为避免组合后出现零向量，加上一个很小的数X=[y_1;y_2];save('traindata','X','T');clearvars -except X T ; %清除其余变量U=0; Y=0; Tc=0;u_1(1)=0; y_1(1)=0; y_2(1)=0;for k=1:1:200 %使用500个样本点训练数据U(k)=sin(2*pi/4*k) + 1/5*sin(2*pi/7*k); %新的测试函数Y(k) = u_1(k) + y_1(k) * (2*y_2(k) + 1) / (1+ y_1(k)^2 + y_2(k)^2); if k<200u_1(k+1) = U(k); y_2(k+1) = y_1(k); y_1(k+1) = Y(k); endendTc=Y; Uc=u_1;y_1(1)=; y_1(2)=0;y_2(1)=0; y_2(2)=; y_2(3)=0; %为避免组合后出现零向量，加上一个很小的数Xc=[y_1;y_2];save('testdata','Xc','Tc','Uc'); %保存测试数据clearvars -except Xc Tc Uc ; %清除其余变量，load traindata; load testdata; %加载训练数据和测试数据%% 网络建立与训练[R,Q]= size(X); [S,~]= size(T); [Sc,Qc]= size(Tc);Hid_num = 8; %隐含层选取8个神经元较合适val_iw =rands(Hid_num,R); %隐含层神经元的初始权值val_b1 =rands(Hid_num,1); %隐含层神经元的初始偏置val_lw =rands(S,Hid_num); %输出层神经元的初始权值val_b2 =rands(S,1); %输出层神经元的初始偏置net=newff(X,T,Hid_num); %建立BP神经网络，使用默认参数 %设置训练次数= 50;%设置mean square error，均方误差,%设置学习速率{1,1}=val_iw; %初始权值和偏置{2,1}=val_lw;{1}=val_b1;{2}=val_b2;[net,tr]=train(net,X,T); %训练网络save('aaa', 'net'); %将训练好的网络保存下来%% 网络测试A=sim(net,X); %测试网络E=T-A; %测试误差error = sumsqr(E)/(S*Q) %测试结果的的MSEA1=sim(net,Xc); %测试网络Yc= A1 + Uc;E1=Tc-Yc; %测试误差error_c = sumsqr(E1)/(Sc*Qc) %测试结果的的MSEfigure(1);plot(Tc,'r');hold on;plot(Yc,'b'); legend('exp','act'); xlabel('test smaple'); ylabel('output') figure(2); plot(E1);xlabel('test sample'); ylabel('error')2、MRAC 控制器被控对象为非线性系统：22()(2(1)1)(1)()();()1()(1)y k y k y k f u k f y k y k -++=•+•=++- 由第一部分对()f •的辨识结果，可知该非线性系统的辨识模型为：(1)[(),(1)]()I p y k N y k y k u k +=-+可知u(k)可以表示为(1)p y k +和(),(1)y k y k -的函数，因此可使用系统的逆模型进行控制器设计。

基于神经网络的非线性系统控制技术研究随着机器学习和人工智能技术的飞速发展，神经网络控制技术被广泛应用于非线性系统控制领域。

本文将重点介绍基于神经网络的非线性系统控制技术研究，探讨其在实际应用中的优势和挑战。

一、神经网络控制技术概述神经网络控制技术是一种将神经网络应用于非线性系统控制的方法，其核心思想是通过神经网络建模和预测实现系统控制。

与传统的控制方法相比，神经网络控制技术具有以下优势：1. 适用范围广神经网络可以对非线性系统进行建模和预测，而传统的控制方法往往只适用于线性系统。

2. 建模精度高神经网络可以根据系统在不同时间步的输入输出数据进行学习，从而得到更为准确的系统模型。

3. 控制效果好神经网络控制具有自适应性和鲁棒性，能够在复杂环境下实现精确控制。

二、基于神经网络的非线性系统建模方法神经网络控制技术的核心在于神经网络的建模和预测，下面介绍基于神经网络的非线性系统建模方法。

1. 前向神经网络建模方法前向神经网络是一种常用的人工神经网络类型，其具有简单明了的结构和较高的预测精度。

该方法通常将非线性系统输出作为神经网络的目标变量，将非线性系统的输入与输出作为神经网络的输入数据，通过神经网络模拟实现非线性系统的预测和控制。

2. 循环神经网络建模方法循环神经网络是一种带有时序信息的神经网络，其可以用于描述非线性系统的时序演化过程。

该方法通常将非线性系统的输出序列作为循环神经网络的目标变量，将非线性系统的输入序列作为循环神经网络的输入数据，通过循环神经网络模拟实现非线性系统的预测和控制。

三、基于神经网络的非线性系统控制方法基于神经网络的非线性系统控制技术包括开环控制、闭环控制和模糊神经网络控制等方法。

下面将重点介绍闭环控制方法。

闭环控制是一种基于系统反馈调节的控制方法，其核心在于将神经网络控制器与系统的反馈环结合，实现系统控制。

该方法通常将被控系统的测量输出作为反馈信号，将神经网络输出作为控制信号，通过反馈作用实现系统的实时控制。

摘要神经网络自适应控制是基于自适应的基本原理，利用神经网络的特点设计而成的。

它发挥了自适应与神经网络的各自长处，为非线性控制的研究提供了一种新方法。

本文基于Lyapunov稳定性理论，采用神经网络直接自适应控制的思想设计控制器，研究了一类带干扰的不确定非线性系统的控制问题。

控制器主要是针对不确定非线性系统中存在的两类未知项——未知函数和未知外界干扰而设计，其中未知函数利用径向基函数神经网络来近似，外界干扰利用非线性阻尼项来抑制，这样可以充分利用神经网络的逼近特性，克服复杂系统难以建模等困难，并且系统稳定性和收敛性在给出的假设的条件下均能得到保证。

最后设计程序进行仿真验证，在程序设计中，以高斯函数作为基函数，仿真结果表明在权值和控制的有界性方面取得了一定的效果。

本文第一章到第三章详细介绍了人工神经网络及神经网络控制的发展和研究现状；第四章主要介绍了径向基函数神经网络，并对其逼近能力进行仿真；在结束语中展望了神经网络控制的发展前景，提出以后的研究方向。

关键词：RBF神经网络，自适应控制，不确定非线性系统AbstractNeural network adaptive control is proposed combining adaptive control's advantages with neural network's characters and provides a new method for nonlinear control.Based on Lyapunov stability theorem and neural network direct adaptive control idea the control problem of a class of uncertain nonlinear system with disturbance is researched. The controller is designed arming at two kinds of uncertainties existing in nonlinear system--the unknown functions and the uncertain disturbance. In controller. the radial basis function neural network is used as approximation model for the unknown functions. and nonlinear damping term is used to counteract the disturbances. so neural network's better approximation capabilities can be utilized richly and the modeling difficulties can be avoided. Meanwhile. the controlled system's stability and convergence can be guaranteed under some assumptions. At last the program is designed to verify the effectiveness of the controller. In presented programs. Guassian function is used as basis function. Simulation results show that the bound ness effects of weighs and control input are better.The rough framework of this thesis is as following: the artificial neural network基于神经网络的非线性自适应控制研究and neural network control are introduced in detail from the first chapter to the third chapter; the radial basis function neural network is described and its approximation performance is simulated in the fourth chapter; the development of neural network control is expected and the further research prospect is proposed in the end words.Keywords: Radial Basis Function neural network adaptive control, uncertain nonlinear system1 绪论非线性现象是工程、自然界以及人类社会话动的各个领域普遍存在的问题，非线性控制在控制科学中也一直占有重要地位。

基于神经网络的非线性系统识别与控制技术研究随着技术的不断发展，越来越多的非线性系统被应用于工业制造、交通运输等各个领域。

非线性系统相比线性系统，其运行及控制难度较高，因此如何快速准确地对其进行识别及控制成为了一个亟待解决的问题。

近年来，随着人工智能的不断发展，神经网络逐渐成为了一种重要的非线性控制技术。

神经网络模型能够很好地模拟非线性系统，其具备优秀的非线性拟合、泛化能力和容错性，因此被广泛应用于非线性系统的识别及控制。

一、基于神经网络的非线性系统识别神经网络能够对非线性系统进行识别并建立模型，通过监督或非监督的学习方法，自动从训练数据中学习非线性系统的映射规律。

在训练时，神经网络能够自适应地调节其参数，以使得网络输出与实际数据误差最小。

与传统的系统识别方法相比，神经网络能够更好地处理非线性关系，具有更高的准确性和泛化能力。

除了基于监督或非监督的学习方法外，神经网络还可以结合其他的系统识别方法进行应用。

例如基于遗传算法的神经网络优化算法，能够通过优化网络权重和拓扑结构来提高网络的识别能力。

二、基于神经网络的非线性系统控制基于神经网络的非线性系统控制分为两类：基于神经网络的模型预测控制和基于神经网络的自适应控制。

其中，基于神经网络的模型预测控制是指将神经网络训练得到的非线性系统模型，用于进行模型预测控制，从而实现对于非线性系统的控制。

而基于神经网络的自适应控制则是指将神经网络作为在线逼近器，通过在线修正来逼近非线性系统，实现对系统的控制。

对于基于神经网络的自适应控制，其主要优点是能够处理未知的非线性系统和未知的外干扰，因为它采用了自适应控制策略，能够实现对于非线性系统的在线逼近控制。

另外，基于神经网络的自适应控制还可以应用于非线性系统的最优控制，从而实现最优控制。

三、神经网络技术在工业制造中的应用随着工业智能化的不断深入，神经网络技术在工业制造领域的应用也越来越广泛。

例如在化工、冶金、电力等领域中，神经网络技术被应用于非线性系统的控制和优化；在机器人控制中，神经网络可以用于机器人运动的规划和控制；在智能制造中，神经网络可以用于生产过程中的非线性系统建模和控制。

第17卷 第3期沈 阳 化 工 学 院 学 报Vol.17 No.32003.9JOURNAL OF SHENYANG INSTITU TE OF CHEM ICAL T ECHNOLOGYSep.2003文章编号: 1004-4639(2003)03-0224-03基于神经网络的非线性控制系统宋新乔, 姜长洪, 蔡庆春, 汪 勇, 赵文丹(沈阳化工学院,辽宁沈阳110142)摘 要: 研究基于神经网络的非线性系统控制,对生物反应器过程进行直接自适应神经网络控制,以BP 网络为控制器,采用BP 算法,控制效果良好.神经网络应用在对非线性系统建模和仿真,给非线性控制系统提供了良好的解决方法.关键词: 神经网络; 反馈控制; 非线性控制中图分类号: T B114 2 文献标识码: A收稿日期: 2002-11-12作者简介: 宋新乔(1978-),男,辽宁大连人,硕士研究生,主要从事人工智能和神经网络的研究.基于神经网络的智能控制系统也称作基于连接机制的智能控制系统.随着人工神经网络研究的不断深入,神经网络越来越多地应用于控制领域的各个方面.从过程控制、机器人控制、生产制造、模式识别直到决策支持都有许多应用神经网络的例子.本文研究神经网络对生物反应器过程的控制,得到了很好的控制效果[1~3].1 神经网络非线性控制1.1 神经网络自适应模型基于神经网络控制的模型参考直接自适应控制[4](如图1).图1 神经网络自适应控制设非线性控制系统的描述为:y (k +1)=f [y (k ),u (k )](1)神经网络训练准则取为:J 1= u (k )-u d (k ) 2(2)其中u(k )为神经网络控制器的输出量,u d (k )是当期望的对象输出为y d (k )时,神经网络应提供的控制量.在对象模型未知的情况下,可以把神经网络控制器与对象看作一个整体,即一个更多层的神经网络,网络最后一层为被控对象,这时取训练准则为:J = y (k +1)-y d (k +1) 2Q = e (k +1) 2Q(3)目的是选取当前控制量u (k ),使下一步的输出误差尽可能小.1.2 神经网络自适应控制调节算法神经网络作为自适应控制器,其控制作用的调整依赖网络权系数的改变.设神经网络最后一层权重的调整规则为:(k +1)= (k )=J (k )(4) J (k )= J u T(k ) u (k )(k )(5) J u T(k )=2[e (k +1)]T Q y (k +1)u T (k )(6)用先验知识确定u (k )各分量加入后y (k +1)的各分量变化趋势,并用u (k )各分量对y (k +1)各分量影响符号组成的矩阵sgn[y (k +1) u T(k )]替代式(6)中的 Ju T (k ),得到:J u T(k)=2[e (k +1)]T Q sg n[ y (k +1)u T (k )](7)u j (k )是向量U (k )的第j 个分量,也是神经网络最后一层第j 神经元的输出,根据BP 算法有:ji (k )= (u j (k )c i (k ))(8)式中c i (k )为紧靠输出层的前一层第i 个神经元的输出, ( )是该单元神经元特性.将式(5)与(7)和(8)结合起来,可得到神经网络最后一层的权重修改公式:w ij (k +1)=w ij (k )- j (k)c i (k )(9)j (k)=2 j (k )[e (k +1)]TQ sgn[ y (k +1)j (k )](10)对于其它层权重调整,仍按标准BP 算法,逐层计算.2 生物反应器过程的神经网络控制如图2所示,一个生物反应器为一个盛有水、培养液和生物细胞的水槽.培养液和细胞按流速V 引入水槽,含培养细胞的流出液流速与培养液的流入液流速相等,使槽内液体量保持恒定.该过程的过程参数为细胞数量和培养液量,控制目标使槽内细胞数量达到并保持预定的数量水平.图2 生物反应器生物反应器过程控制虽然控制参数较少,比较容易实现模拟,但它的非线性特性造成了控制的困难.因为控制参数很小的变化,就可能使过程处于不稳定.假设生物反应器的状态变量分别为细胞数量C 1、培养液量C 2和流速V .变量C 1和C 2经一定的变换转化为区间[0,1]的值,V转化为[0,1]区间值.系统的状态可由(C 1[t ],C 2[t])表示,状态方程为:C 1[t +1]=C 1[t ]+ (-C 1[t] V [t ]+C 1[t] (1-C 2[t ]) e C 2[t ])(11)C 2[t +1]=C 2[t ]+ (-C 2[t] V [t ]+C 2[t] (1-C 2[t ]) eC 2[t ] ) 1+1+ -C 1[t ](12)上式中, 为细胞生长参数( =0.02), 为培养抑制参数( =0.48),由这2个参数分别控制细胞的生长速度和培养液消耗. 为采样间隔( =0.01s).上式表示反应器在采样时间之后的状态.控制变量V ,每隔0.5s 调节一次.控制器的输入变量离散化为C 1[t ]和C 2[t],输出变量离散化为V [t ],t =50,100 ,在离散间隔内V [t ]=V [t -1].控制过程的目标函数对应(3),可以表示为下列累积误差形式:{50,100, ,5000}(C 1[t ]-C *1[t ])2(13)这里,C *1[t]为时间t 的预定细胞数量水平.图3所示为以上过程的神经网络控制器结构,为一个标准的多层BP 网络,含有4个节点的隐层,输入层有2个节点,对应于C 1[t]和C 2[t ],输出层有一个节点,对应于V [t].图3 神经网络控制器结构对于上述生物反应器控制,参考模型为1,这是自适应模型参考的特殊情况.假定目标状态[C *1]=0.1207,考察基于神经网络控制器的过程模拟结果.图4是神经网络训练寻优控制过程前50s 细胞生长曲线.图5是细胞50s 以后的生长曲线.可见神经网络控制器在线寻优经过350s 达到目标误差1 10-6.寻优训练过程误差曲线如图6所示.此时得到的最佳控制器控制的生物反应器50s 模拟过程曲线如图7所示.从细胞数量C 1的响应分析,经过10s 左右的时间稳定在0.1195,稳态误差为0.12%,最大超225第3期 宋新乔,等:基于神经网络的非线性控制系统调量为20%,系统动态响应很好.图4 前50s细胞生长曲线图5 50s以后细胞生长曲线图6误差曲线图7 细胞生长控制曲线3 结 论对过程控制而言,控制的目标是要求将一个或多个控制变量保持在预定的控制水平.上面给出的生物反应过程控制在神经网络的控制下,很好地适合了这一要求.在控制过程对象是非线性系统时,其控制依赖于人的经验,仅靠常规控制策略无法达到预期的控制目标.神经网络则可以实现对复杂非线性的建模和控制,它提供了一种知识表达的手段,并可以用网络结构和权重实现任何复杂的输入输出关系.本文对生物反应器过程控制的研究,得到了满意的结果,说明神经网络用于非线性过程控制是有效的.参考文献:[1] Chen Fu -chuang.Back -Propag ation N eural Networ kfor Nonlinear Sel-f T urning Adapt ive Co ntrol [J].IEEE Contr ol Systems M ag azine,1990,(4):24-30.[2] Moor e K L.A Reinforcement -learning N eural N et -work for the Controlof Nonlinear Systems [J].J.Amer.stat.Assac,1994,84:50-55.[3] 易继锴,侯媛彬.智能控制技术[M ].北京:北京工业大学出版社,1999.240.[4] 韦巍,蒋静坪.非线性系统的多神经网络自学习控制[J].信息与控制,1995,24(5):30-37.Design of Non -linear System Based on N eural N etworksSONG Xin -qiao, JIANG Chang -hong, CAI Qing -chun, WANG Yong, ZHAO Wen -dan(Shenyang Institute of Chemical Technolog y,Shenyang 110142,China)Abstract: This paper primarily m akes an research on the method of the design of nonlinear control sys -tem based on the neural networks.With the BP algorithm we obtained a better result in control of biologic reactor.The neural network is good at modeling and simulating on the nonlinear control system,especially for the complex nonlinear systems.Key words: neural netw ork; feedback control system; nonlinear control system226沈 阳 化 工 学 院 学 报 2003年。

Python利⽤神经⽹络解决⾮线性回归问题实例详解本⽂实例讲述了Python利⽤神经⽹络解决⾮线性回归问题。

分享给⼤家供⼤家参考，具体如下：问题描述现在我们通常使⽤神经⽹络进⾏分类，但是有时我们也会进⾏回归分析。

如本⽂的问题：我们知道⼀个⽣物体内的原始有毒物质的量，然后对这个⽣物体进⾏治疗，向其体内注射⼀个物质，过⼀段时间后重新测量这个⽣物体内有毒物质量的多少。

因此，问题中有两个输⼊，都是标量数据，分别为有毒物质的量和注射物质的量，⼀个输出，也就是注射治疗物质后⼀段时间⽣物体的有毒物质的量。

数据如下图：其中Dose of Mycotoxins 就是有毒物质，Dose of QCT就是治疗的药物。

其中蓝⾊底纹的数字就是输出结果。

⼀些说明由于本⽂是进⾏回归分析，所以最后⼀层不进⾏激活，⽽直接输出。

本⽂程序使⽤sigmoid函数进⾏激活。

本⽂程序要求程序有⼀定的可重复性，隐含层可以指定。

另外，注意到本⽂将使⽤数据预处理，也就是将数据减去均值再除以⽅差，否则使⽤sigmoid将会导致梯度消失。

因为数据⽐较⼤，⽐如200，这时输⼊200，当sigmoid函数的梯度就是接近于0了。

与此同时，我们在每⼀次激活前都进⾏BN处理，也就是batch normalize，中⽂可以翻译成规范化。

否则也会导致梯度消失的问题。

与预处理情况相同。

程序程序包括两部分，⼀部分是模型框架，⼀个是训练模型第⼀部分：# coding=utf-8import numpy as npdef basic_forard(x, w, b):x = x.reshape(x.shape[0], -1)out = np.dot(x, w) + bcache = (x, w, b)return out, cachedef basic_backward(dout, cache):x, w, b = cachedout = np.array(dout)dx = np.dot(dout, w.T)# dx = np.reshape(dx, x.shape)# x = x.reshape(x.shape[0], -1)dw = np.dot(x.T, dout)db = np.reshape(np.sum(dout, axis=0), b.shape)return dx, dw, dbdef batchnorm_forward(x, gamma, beta, bn_param):mode = bn_param['mode']eps = bn_param.get('eps', 1e-5)momentum = bn_param.get('momentum', 0.9)N, D = x.shaperunning_mean = bn_param.get('running_mean', np.zeros(D, dtype=x.dtype))running_var = bn_param.get('running_var', np.zeros(D, dtype=x.dtype))out, cache = None, Noneif mode == 'train':sample_mean = np.mean(x, axis=0)sample_var = np.var(x, axis=0)x_hat = (x - sample_mean) / (np.sqrt(sample_var + eps))out = gamma * x_hat + betacache = (gamma, x, sample_mean, sample_var, eps, x_hat)running_mean = momentum * running_mean + (1 - momentum) * sample_meanrunning_var = momentum * running_var + (1 - momentum) * sample_varelif mode == 'test':scale = gamma / (np.sqrt(running_var + eps))out = x * scale + (beta - running_mean * scale)else:raise ValueError('Invalid forward batchnorm mode "%s"' % mode)bn_param['running_mean'] = running_meanbn_param['running_var'] = running_varreturn out, cachedef batchnorm_backward(dout, cache):gamma, x, u_b, sigma_squared_b, eps, x_hat = cacheN = x.shape[0]dx_1 = gamma * doutdx_2_b = np.sum((x - u_b) * dx_1, axis=0)dx_2_a = ((sigma_squared_b + eps) ** -0.5) * dx_1dx_3_b = (-0.5) * ((sigma_squared_b + eps) ** -1.5) * dx_2_bdx_4_b = dx_3_b * 1dx_5_b = np.ones_like(x) / N * dx_4_bdx_6_b = 2 * (x - u_b) * dx_5_bdx_7_a = dx_6_b * 1 + dx_2_a * 1dx_7_b = dx_6_b * 1 + dx_2_a * 1dx_8_b = -1 * np.sum(dx_7_b, axis=0)dx_9_b = np.ones_like(x) / N * dx_8_bdx_10 = dx_9_b + dx_7_adgamma = np.sum(x_hat * dout, axis=0)dbeta = np.sum(dout, axis=0)dx = dx_10return dx, dgamma, dbeta# def relu_forward(x):# out = None# out = np.maximum(0,x)# cache = x# return out, cache### def relu_backward(dout, cache):# dx, x = None, cache# dx = (x >= 0) * dout# return dxdef sigmoid_forward(x):x = x.reshape(x.shape[0], -1)out = 1 / (1 + np.exp(-1 * x))cache = outreturn out, cachedef sigmoid_backward(dout, cache):out = cachedx = out * (1 - out)dx *= doutreturn dxdef basic_sigmoid_forward(x, w, b):basic_out, basic_cache = basic_forard(x, w, b)sigmoid_out, sigmoid_cache = sigmoid_forward(basic_out)cache = (basic_cache, sigmoid_cache)return sigmoid_out, cache# def basic_relu_forward(x, w, b):# basic_out, basic_cache = basic_forard(x, w, b)# relu_out, relu_cache = relu_forward(basic_out)# cache = (basic_cache, relu_cache)## return relu_out, cachedef basic_sigmoid_backward(dout, cache):basic_cache, sigmoid_cache = cachedx_sigmoid = sigmoid_backward(dout, sigmoid_cache)dx, dw, db = basic_backward(dx_sigmoid, basic_cache)return dx, dw, db# def basic_relu_backward(dout, cache):# basic_cache, relu_cache = cache# dx_relu = relu_backward(dout, relu_cache)# dx, dw, db = basic_backward(dx_relu, basic_cache)## return dx, dw, dbdef mean_square_error(x, y):x = np.ravel(x)loss = 0.5 * np.sum(np.square(y - x)) / x.shape[0]dx = (x - y).reshape(-1, 1)return loss, dxclass muliti_layer_net(object):def __init__(self, hidden_dim, input_dim=2, num_classes=2, weight_scale=0.01, dtype=np.float32, seed=None, reg=0.0, use_batchnorm=True): self.num_layers = 1 + len(hidden_dim)self.dtype = dtypeself.reg = regself.params = {}self.weight_scale = weight_scalee_batchnorm = use_batchnorm# init all parameterslayers_dims = [input_dim] + hidden_dim + [num_classes]for i in range(self.num_layers):self.params['W' + str(i + 1)] = np.random.randn(layers_dims[i], layers_dims[i + 1]) * self.weight_scaleself.params['b' + str(i + 1)] = np.zeros((1, layers_dims[i + 1]))if e_batchnorm and i < (self.num_layers - 1):self.params['gamma' + str(i + 1)] = np.ones((1, layers_dims[i + 1]))self.params['beta' + str(i + 1)] = np.zeros((1, layers_dims[i + 1]))self.bn_params = [] # listif e_batchnorm:self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]def loss(self, X, y=None):X = X.astype(self.dtype)mode = 'test' if y is None else 'train'# compute the forward data and cachebasic_sigmoid_cache = {}layer_out = {}layer_out[0] = Xout_basic_forward, cache_basic_forward = {}, {}out_bn, cache_bn = {}, {}out_sigmoid_forward, cache_sigmoid_forward = {}, {}for lay in range(self.num_layers - 1):# print('lay: %f' % lay)W = self.params['W' + str(lay + 1)]b = self.params['b' + str(lay + 1)]if e_batchnorm:gamma, beta = self.params['gamma' + str(lay + 1)], self.params['beta' + str(lay + 1)]out_basic_forward[lay], cache_basic_forward[lay] = basic_forard(np.array(layer_out[lay]), W, b)out_bn[lay], cache_bn[lay] = batchnorm_forward(np.array(out_basic_forward[lay]), gamma, beta, self.bn_params[lay])layer_out[lay + 1], cache_sigmoid_forward[lay] = sigmoid_forward(np.array(out_bn[lay]))# = out_sigmoid_forward[lay]else:layer_out[lay+1], basic_sigmoid_cache[lay] = basic_sigmoid_forward(layer_out[lay], W, b)score, basic_cache = basic_forard(layer_out[self.num_layers-1], self.params['W' + str(self.num_layers)], self.params['b' + str(self.num_layers)]) # print('Congratulations: Loss is computed successfully!')if mode == 'test':return score# compute the gradientgrads = {}loss, dscore = mean_square_error(score, y)dx, dw, db = basic_backward(dscore, basic_cache)grads['W' + str(self.num_layers)] = dw + self.reg * self.params['W' + str(self.num_layers)]grads['b' + str(self.num_layers)] = dbloss += 0.5 * self.reg * np.sum(self.params['W' + str(self.num_layers)] * self.params['b' + str(self.num_layers)])dbn, dsigmoid = {}, {}for index in range(self.num_layers - 1):lay = self.num_layers - 1 - index - 1loss += 0.5 * self.reg * np.sum(self.params['W' + str(lay + 1)] * self.params['b' + str(lay + 1)])if e_batchnorm:dsigmoid[lay] = sigmoid_backward(dx, cache_sigmoid_forward[lay])dbn[lay], grads['gamma' + str(lay + 1)], grads['beta' + str(lay + 1)] = batchnorm_backward(dsigmoid[lay], cache_bn[lay])dx, grads['W' + str(lay + 1)], grads['b' + str(lay + 1)] = basic_backward(dbn[lay], cache_basic_forward[lay])else:dx, dw, db = basic_sigmoid_backward(dx, basic_sigmoid_cache[lay])for lay in range(self.num_layers):grads['W' + str(lay + 1)] += self.reg * self.params['W' + str(lay + 1)]return loss, gradsdef sgd_momentum(w, dw, config=None):if config is None: config = {}config.setdefault('learning_rate', 1e-2)config.setdefault('momentum', 0.9)v = config.get('velocity', np.zeros_like(w))v = config['momentum'] * v - config['learning_rate'] * dwnext_w = w + vconfig['velocity'] = vreturn next_w, configclass Solver(object):def __init__(self, model, data, **kwargs):self.model = modelself.X_train = data['X_train']self.y_train = data['y_train']self.X_val = data['X_val']self.y_val = data['y_val']self.update_rule = kwargs.pop('update_rule', 'sgd_momentum')self.optim_config = kwargs.pop('optim_config', {})self.lr_decay = kwargs.pop('lr_decay', 1.0)self.batch_size = kwargs.pop('batch_size', 100)self.num_epochs = kwargs.pop('num_epochs', 10)self.weight_scale = kwargs.pop('weight_scale', 0.01)self.print_every = kwargs.pop('print_every', 10)self.verbose = kwargs.pop('verbose', True)if len(kwargs) > 0:extra = ', '.join('"%s"' % k for k in kwargs.keys())raise ValueError('Unrecognized argements %s' % extra)self._reset()def _reset(self):self.epoch = 100self.best_val_acc = 0self.best_params = {}self.loss_history = []self.train_acc_history = []self.val_acc_history = []self.optim_configs = {}for p in self.model.params:d = {k: v for k, v in self.optim_config.items()}self.optim_configs[p] = ddef _step(self):loss, grads = self.model.loss(self.X_train, self.y_train)self.loss_history.append(loss)for p, w in self.model.params.items():dw = grads[p]config = self.optim_configs[p]next_w, next_config = sgd_momentum(w, dw, config)self.model.params[p] = next_wself.optim_configs[p] = next_configreturn lossdef train(self):min_loss = 100000000num_train = self.X_train.shape[0]iterations_per_epoch = max(num_train / self.batch_size, 1)num_iterations = self.num_epochs * iterations_per_epochfor t in range(int(num_iterations)):loss = self._step()if self.verbose:# print(self.loss_history[-1])passif loss < min_loss:min_loss = lossfor k, v in self.model.params.items():self.best_params[k] = v.copy()self.model.params = self.best_params第⼆部分import numpy as np# import datadose_QCT = np.array([0, 5, 10, 20])mean_QCT, std_QCT = np.mean(dose_QCT), np.std(dose_QCT)dose_QCT = (dose_QCT - mean_QCT ) / std_QCTdose_toxins = np.array([0, 0.78125, 1.5625, 3.125, 6.25, 12.5, 25, 50, 100, 200])mean_toxins, std_toxins = np.mean(dose_toxins), np.std(dose_toxins)dose_toxins = (dose_toxins - mean_toxins ) / std_toxinsresult = np.array([[0, 4.037, 7.148, 12.442, 18.547, 25.711, 34.773, 62.960, 73.363, 77.878], [0, 2.552, 4.725, 8.745, 14.436, 21.066, 29.509, 55.722, 65.976, 72.426],[0, 1.207, 2.252, 4.037, 7.148, 11.442, 17.136, 34.121, 48.016, 60.865],[0, 0.663, 1.207, 2.157, 3.601, 5.615, 8.251, 19.558, 33.847, 45.154]])mean_result, std_result = np.mean(result), np.std(result)result = (result - mean_result ) / std_result# create the train datatrain_x, train_y = [], []for i,qct in enumerate(dose_QCT):for j,toxin in enumerate(dose_toxins):x = [qct, toxin]y = result[i, j]train_x.append(x)train_y.append(y)train_x = np.array(train_x)train_y = np.array(train_y)print(train_x.shape)print(train_y.shape)import layers_regressionsmall_data = {'X_train': train_x,'y_train': train_y,'X_val': train_x,'y_val': train_y,}batch_size = train_x.shape[0]learning_rate = 0.002reg = 0model = layers_regression.muliti_layer_net(hidden_dim=[5,5], input_dim=2, num_classes=1, reg=reg, dtype=np.float64)solver = layers_regression.Solver(model, small_data, print_every=0, num_epochs=50000, batch_size=batch_size, weight_scale=1, update_rule='sgd_momentum', optim_config={'learning_rate': learning_rate})print('Please wait several minutes!')solver.train()# print(model.params)best_model = modelprint('Train process is finised')import matplotlib.pyplot as plt# %matplotlib inlineplt.plot(solver.loss_history, '.')plt.title('Training loss history')plt.xlabel('Iteration')plt.ylabel('Training loss')plt.show()# predict the training_datapredict = best_model.loss(train_x)predict = np.round(predict * std_result + mean_result, 1)print('Predict is ')print('{}'.format(predict.reshape(4, 10)))# print('{}'.format(predict))# observe the error between the predict after training with ground truthresult = np.array([[0, 4.037, 7.148, 12.442, 18.547, 25.711, 34.773, 62.960, 73.363, 77.878],[0, 2.552, 4.725, 8.745, 14.436, 21.066, 29.509, 55.722, 65.976, 72.426],[0, 1.207, 2.252, 4.037, 7.148, 11.442, 17.136, 34.121, 48.016, 60.865],[0, 0.663, 1.207, 2.157, 3.601, 5.615, 8.251, 19.558, 33.847, 45.154]])result = result.reshape(4, 10)predict = predict.reshape(4, 10)error = np.round(result - predict, 2)print('error between predict and real data')print(error)print('The absulate error in all data is %f' % np.sum(np.abs(error)))print('The mean error in all data is %f' % np.mean(np.abs(error)))# figure the predict map in 3Dx_1 = (np.arange(0, 20, 0.1) - mean_QCT) / std_QCTx_2 = (np.arange(0, 200, 1) - mean_toxins) / std_toxinsx_test = np.zeros((len(x_1)*len(x_2), 2))index = 0for i in range(len(x_1)):for j in range(len(x_2)):x_test[int(index), 0] = x_1[int(i)]x_test[int(index), 1] = x_2[int(j)]index += 1test_pred = best_model.loss(x_test)predict = np.round(test_pred * std_result + mean_result, 3)from mpl_toolkits.mplot3d import Axes3Dx_1, x_2 = np.meshgrid(x_1 * std_QCT + mean_QCT, x_2 * std_toxins + mean_toxins)figure = plt.figure()ax = Axes3D(figure)predict = predict.reshape(len(x_1), len(x_2))ax.plot_surface(x_1, x_2, predict, rstride=1, cstride=1, cmap='rainbow')plt.show()# 最后本⽂将进⾏⼀些预测，但预测效果不是很好# question 2: predict with givendose_QCT_predict = np.ravel(np.array([7.5, 15]))dose_QCT_predict_ = (dose_QCT_predict - mean_QCT)/ std_QCTdose_toxins_predict = np.array([0, 0.78125, 1.5625, 3.125, 6.25, 12.5, 25, 50, 100, 200])dose_toxins_predict_ = (dose_toxins_predict - mean_toxins) / std_toxinstest = []for i,qct in enumerate(dose_QCT_predict):for j,toxin in enumerate(dose_toxins_predict):x = [qct, toxin]test.append(x)test = np.array(test)print('Please look at the test data:')print(test)test = []for i,qct in enumerate(dose_QCT_predict_):for j,toxin in enumerate(dose_toxins_predict_):x = [qct, toxin]test.append(x)test = np.array(test)test_pred = best_model.loss(test)predict = np.round(test_pred * std_result + mean_result, 1)print(predict.reshape(2, 10))更多关于Python相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》及《》希望本⽂所述对⼤家Python程序设计有所帮助。

基于PID神经网络的非线性时变系统辨识的报告，800字
本报告旨在探讨非线性时变系统辨识中基于PID神经网络的
方法。

首先，将介绍基于PID神经网络的非线性时变系统辨
识原理和要素，然后给出一个PID神经网络辨识方法的实例，讨论实例中采用的动态模型，最后对实例的实验数据进行分析，以评估该方法的有效性。

PID神经网络是一种基于神经网络的非线性时变系统辨识方法，其中包括两个要素：一是使用神经网络来建立映射关系，二是在设计PID控制器时引入神经网络。

该方法可以有效地处理
非线性、模糊、多元、时变等类型的系统，使得系统辨识更加精准。

以空气流动模型为例，该模型为二元参数的空气模型，已知模型的输入和输出，使用PID神经网络辨识模型的参数。

首先，使用BP神经网络进行模型辨识，然后使用PID控制器来更新
模型参数，以调整模型。

为了更好地描述该模型，可以采用
随机梯度下降法来优化模型参数，并使用相关指标来评估模型的准确性和有效性。

在进行实验之前，需要确定模型的输入、输出和参数，并根据实验设计合适的网络结构，学习算法和训练次数。

实验结果表明，该方法可以有效地调整参数，使得系统性能优于传统的控制设计方法。

综上所述，基于PID神经网络的非线性时变系统辨识方法可
以有效地处理非线性、模糊、多元、时变等复杂的系统，从而
改善系统的控制性能，提高系统的可控性和可信度，满足业务开发需求。