人工神经网络源代码(神经网络开源代码)
admin 发布:2022-12-19 22:37 204
本篇文章给大家谈谈人工神经网络源代码,以及神经网络开源代码对应的知识点,希望对各位有所帮助,不要忘了收藏本站喔。
本文目录一览:
- 1、求BP神经网络算法的C++源代码
- 2、基于BP人工神经网络的英文字母识别,MATLAB的程序源代码
- 3、matlab实现人工神经网络的时候如何设置输出层的节点?
- 4、人工神经网络BP算法源代码与演示程序怎么用?
- 5、设计一个简单的人工神经网络识别 matlab源程序
- 6、BP神经网络matlab源程序代码讲解
求BP神经网络算法的C++源代码
// AnnBP.cpp: implementation of the CAnnBP class.
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "AnnBP.h"
#include "math.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CAnnBP::CAnnBP()
{
eta1=0.3;
momentum1=0.3;
}
CAnnBP::~CAnnBP()
{
}
double CAnnBP::drnd()
{
return ((double) rand() / (double) BIGRND);
}
/*** 返回-1.0到1.0之间的双精度随机数 ***/
double CAnnBP::dpn1()
{
return (double) (rand())/(32767/2)-1;
}
/*** 作用函数,目前是S型函数 ***/
double CAnnBP::squash(double x)
{
return (1.0 / (1.0 + exp(-x)));
}
/*** 申请1维双精度实数数组 ***/
double* CAnnBP::alloc_1d_dbl(int n)
{
double *new1;
new1 = (double *) malloc ((unsigned) (n * sizeof (double)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");
return (NULL);
}
return (new1);
}
/*** 申请2维双精度实数数组 ***/
double** CAnnBP::alloc_2d_dbl(int m, int n)
{
int i;
double **new1;
new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n");
return (NULL);
}
for (i = 0; i m; i++) {
new1[i] = alloc_1d_dbl(n);
}
return (new1);
}
/*** 随机初始化权值 ***/
void CAnnBP::bpnn_randomize_weights(double **w, int m, int n)
{
int i, j;
for (i = 0; i = m; i++) {
for (j = 0; j = n; j++) {
w[i][j] = dpn1();
}
}
}
/*** 0初始化权值 ***/
void CAnnBP::bpnn_zero_weights(double **w, int m, int n)
{
int i, j;
for (i = 0; i = m; i++) {
for (j = 0; j = n; j++) {
w[i][j] = 0.0;
}
}
}
/*** 设置随机数种子 ***/
void CAnnBP::bpnn_initialize(int seed)
{
CString msg,s;
msg="Random number generator seed:";
s.Format("%d",seed);
AfxMessageBox(msg+s);
srand(seed);
}
/*** 创建BP网络 ***/
BPNN* CAnnBP::bpnn_internal_create(int n_in, int n_hidden, int n_out)
{
BPNN *newnet;
newnet = (BPNN *) malloc (sizeof (BPNN));
if (newnet == NULL) {
printf("BPNN_CREATE: Couldn't allocate neural network\n");
return (NULL);
}
newnet-input_n = n_in;
newnet-hidden_n = n_hidden;
newnet-output_n = n_out;
newnet-input_units = alloc_1d_dbl(n_in + 1);
newnet-hidden_units = alloc_1d_dbl(n_hidden + 1);
newnet-output_units = alloc_1d_dbl(n_out + 1);
newnet-hidden_delta = alloc_1d_dbl(n_hidden + 1);
newnet-output_delta = alloc_1d_dbl(n_out + 1);
newnet-target = alloc_1d_dbl(n_out + 1);
newnet-input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
newnet-hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
newnet-input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
newnet-hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);
return (newnet);
}
/* 释放BP网络所占地内存空间 */
void CAnnBP::bpnn_free(BPNN *net)
{
int n1, n2, i;
n1 = net-input_n;
n2 = net-hidden_n;
free((char *) net-input_units);
free((char *) net-hidden_units);
free((char *) net-output_units);
free((char *) net-hidden_delta);
free((char *) net-output_delta);
free((char *) net-target);
for (i = 0; i = n1; i++) {
free((char *) net-input_weights[i]);
free((char *) net-input_prev_weights[i]);
}
free((char *) net-input_weights);
free((char *) net-input_prev_weights);
for (i = 0; i = n2; i++) {
free((char *) net-hidden_weights[i]);
free((char *) net-hidden_prev_weights[i]);
}
free((char *) net-hidden_weights);
free((char *) net-hidden_prev_weights);
free((char *) net);
}
/*** 创建一个BP网络,并初始化权值***/
BPNN* CAnnBP::bpnn_create(int n_in, int n_hidden, int n_out)
{
BPNN *newnet;
newnet = bpnn_internal_create(n_in, n_hidden, n_out);
#ifdef INITZERO
bpnn_zero_weights(newnet-input_weights, n_in, n_hidden);
#else
bpnn_randomize_weights(newnet-input_weights, n_in, n_hidden);
#endif
bpnn_randomize_weights(newnet-hidden_weights, n_hidden, n_out);
bpnn_zero_weights(newnet-input_prev_weights, n_in, n_hidden);
bpnn_zero_weights(newnet-hidden_prev_weights, n_hidden, n_out);
return (newnet);
}
void CAnnBP::bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2)
{
double sum;
int j, k;
/*** 设置阈值 ***/
l1[0] = 1.0;
/*** 对于第二层的每个神经元 ***/
for (j = 1; j = n2; j++) {
/*** 计算输入的加权总和 ***/
sum = 0.0;
for (k = 0; k = n1; k++) {
sum += conn[k][j] * l1[k];
}
l2[j] = squash(sum);
}
}
/* 输出误差 */
void CAnnBP::bpnn_output_error(double *delta, double *target, double *output, int nj, double *err)
{
int j;
double o, t, errsum;
errsum = 0.0;
for (j = 1; j = nj; j++) {
o = output[j];
t = target[j];
delta[j] = o * (1.0 - o) * (t - o);
errsum += ABS(delta[j]);
}
*err = errsum;
}
/* 隐含层误差 */
void CAnnBP::bpnn_hidden_error(double *delta_h, int nh, double *delta_o, int no, double **who, double *hidden, double *err)
{
int j, k;
double h, sum, errsum;
errsum = 0.0;
for (j = 1; j = nh; j++) {
h = hidden[j];
sum = 0.0;
for (k = 1; k = no; k++) {
sum += delta_o[k] * who[j][k];
}
delta_h[j] = h * (1.0 - h) * sum;
errsum += ABS(delta_h[j]);
}
*err = errsum;
}
/* 调整权值 */
void CAnnBP::bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double **w, double **oldw, double eta, double momentum)
{
double new_dw;
int k, j;
ly[0] = 1.0;
for (j = 1; j = ndelta; j++) {
for (k = 0; k = nly; k++) {
new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
w[k][j] += new_dw;
oldw[k][j] = new_dw;
}
}
}
/* 进行前向运算 */
void CAnnBP::bpnn_feedforward(BPNN *net)
{
int in, hid, out;
in = net-input_n;
hid = net-hidden_n;
out = net-output_n;
/*** Feed forward input activations. ***/
bpnn_layerforward(net-input_units, net-hidden_units,
net-input_weights, in, hid);
bpnn_layerforward(net-hidden_units, net-output_units,
net-hidden_weights, hid, out);
}
/* 训练BP网络 */
void CAnnBP::bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh)
{
int in, hid, out;
double out_err, hid_err;
in = net-input_n;
hid = net-hidden_n;
out = net-output_n;
/*** 前向输入激活 ***/
bpnn_layerforward(net-input_units, net-hidden_units,
net-input_weights, in, hid);
bpnn_layerforward(net-hidden_units, net-output_units,
net-hidden_weights, hid, out);
/*** 计算隐含层和输出层误差 ***/
bpnn_output_error(net-output_delta, net-target, net-output_units,
out, out_err);
bpnn_hidden_error(net-hidden_delta, hid, net-output_delta, out,
net-hidden_weights, net-hidden_units, hid_err);
*eo = out_err;
*eh = hid_err;
/*** 调整输入层和隐含层权值 ***/
bpnn_adjust_weights(net-output_delta, out, net-hidden_units, hid,
net-hidden_weights, net-hidden_prev_weights, eta, momentum);
bpnn_adjust_weights(net-hidden_delta, hid, net-input_units, in,
net-input_weights, net-input_prev_weights, eta, momentum);
}
/* 保存BP网络 */
void CAnnBP::bpnn_save(BPNN *net, char *filename)
{
CFile file;
char *mem;
int n1, n2, n3, i, j, memcnt;
double dvalue, **w;
n1 = net-input_n; n2 = net-hidden_n; n3 = net-output_n;
printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename);
try
{
file.Open(filename,CFile::modeWrite|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e-ReportError();
e-Delete();
}
file.Write(n1,sizeof(int));
file.Write(n2,sizeof(int));
file.Write(n3,sizeof(int));
memcnt = 0;
w = net-input_weights;
mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
// mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));
for (i = 0; i = n1; i++) {
for (j = 0; j = n2; j++) {
dvalue = w[i][j];
//fastcopy(mem[memcnt], dvalue, sizeof(double));
fastcopy(mem[memcnt], dvalue, sizeof(double));
memcnt += sizeof(double);
}
}
file.Write(mem,sizeof(double)*(n1+1)*(n2+1));
free(mem);
memcnt = 0;
w = net-hidden_weights;
mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
// mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));
for (i = 0; i = n2; i++) {
for (j = 0; j = n3; j++) {
dvalue = w[i][j];
fastcopy(mem[memcnt], dvalue, sizeof(double));
// fastcopy(mem[memcnt], dvalue, sizeof(double));
memcnt += sizeof(double);
}
}
file.Write(mem, (n2+1) * (n3+1) * sizeof(double));
// free(mem);
file.Close();
return;
}
/* 从文件中读取BP网络 */
BPNN* CAnnBP::bpnn_read(char *filename)
{
char *mem;
BPNN *new1;
int n1, n2, n3, i, j, memcnt;
CFile file;
try
{
file.Open(filename,CFile::modeRead|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e-ReportError();
e-Delete();
}
// printf("Reading '%s'\n", filename);// fflush(stdout);
file.Read(n1, sizeof(int));
file.Read(n2, sizeof(int));
file.Read(n3, sizeof(int));
new1 = bpnn_internal_create(n1, n2, n3);
// printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3);
// printf("Reading input weights..."); // fflush(stdout);
memcnt = 0;
mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));
file.Read(mem, ((n1+1)*(n2+1))*sizeof(double));
for (i = 0; i = n1; i++) {
for (j = 0; j = n2; j++) {
//fastcopy((new1-input_weights[i][j]), mem[memcnt], sizeof(double));
fastcopy((new1-input_weights[i][j]), mem[memcnt], sizeof(double));
memcnt += sizeof(double);
}
}
free(mem);
// printf("Done\nReading hidden weights..."); //fflush(stdout);
memcnt = 0;
mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));
file.Read(mem, (n2+1) * (n3+1) * sizeof(double));
for (i = 0; i = n2; i++) {
for (j = 0; j = n3; j++) {
//fastcopy((new1-hidden_weights[i][j]), mem[memcnt], sizeof(double));
fastcopy((new1-hidden_weights[i][j]), mem[memcnt], sizeof(double));
memcnt += sizeof(double);
}
}
free(mem);
file.Close();
printf("Done\n"); //fflush(stdout);
bpnn_zero_weights(new1-input_prev_weights, n1, n2);
bpnn_zero_weights(new1-hidden_prev_weights, n2, n3);
return (new1);
}
void CAnnBP::CreateBP(int n_in, int n_hidden, int n_out)
{
net=bpnn_create(n_in,n_hidden,n_out);
}
void CAnnBP::FreeBP()
{
bpnn_free(net);
}
void CAnnBP::Train(double *input_unit,int input_num, double *target,int target_num, double *eo, double *eh)
{
for(int i=1;i=input_num;i++)
{
net-input_units[i]=input_unit[i-1];
}
for(int j=1;j=target_num;j++)
{
net-target[j]=target[j-1];
}
bpnn_train(net,eta1,momentum1,eo,eh);
}
void CAnnBP::Identify(double *input_unit,int input_num,double *target,int target_num)
{
for(int i=1;i=input_num;i++)
{
net-input_units[i]=input_unit[i-1];
}
bpnn_feedforward(net);
for(int j=1;j=target_num;j++)
{
target[j-1]=net-output_units[j];
}
}
void CAnnBP::Save(char *filename)
{
bpnn_save(net,filename);
}
void CAnnBP::Read(char *filename)
{
net=bpnn_read(filename);
}
void CAnnBP::SetBParm(double eta, double momentum)
{
eta1=eta;
momentum1=momentum;
}
void CAnnBP::Initialize(int seed)
{
bpnn_initialize(seed);
}
基于BP人工神经网络的英文字母识别,MATLAB的程序源代码
同是模式识别,我也在求代码中,我问了一个预测的问题,关注关注。。。。。
matlab实现人工神经网络的时候如何设置输出层的节点?
newff里面设置啊。
一个函数你想要拟合2种结果?奇了怪了!!!
人工神经网络BP算法源代码与演示程序怎么用?
在matlab里建立一个.m的M文件,把代码输进去,保存,运行就可以了。
演示程序是在command 里打demo就可以了找到了 . 你邮箱多少,我只有简单的BP神经网络程序。
设计一个简单的人工神经网络识别 matlab源程序
神经网络的是我的毕业论文的一部分
4.人工神经网络
人的思维有逻辑性和直观性两种不同的基本方式。逻辑性的思维是指根据逻辑规则进行推理的过程;它先将信息化成概念,并用符号表示,然后,根据符号运算按串行模式进行逻辑推理。这一过程可以写成串行的指令,让计算机执行。然而,直观性的思维是将分布式存储的信息综合起来,结果是忽然间产生想法或解决问题的办法。这种思维方式的根本之点在于以下两点:1.信息是通过神经元上的兴奋模式分布在网络上;2.信息处理是通过神经元之间同时相互作用的动态过程来完成的。
人工神经网络就是模拟人思维的第二种方式。这是一个非线性动力学系统,其特色在于信息的分布式存储和并行协同处理。虽然单个神经元的结构极其简单,功能有限,但大量神经元构成的网络系统所能实现的行为却是极其丰富多彩的。
4.1人工神经网络学习的原理
人工神经网络首先要以一定的学习准则进行学习,然后才能工作。现以人工神经网络对手写“A”、“B”两个字母的识别为例进行说明,规定当“A”输入网络时,应该输出“1”,而当输入为“B”时,输出为“0”。
所以网络学习的准则应该是:如果网络做出错误的判决,则通过网络的学习,应使得网络减少下次犯同样错误的可能性。首先,给网络的各连接权值赋予(0,1)区间内的随机值,将“A”所对应的图像模式输入给网络,网络将输入模式加权求和、与门限比较、再进行非线性运算,得到网络的输出。在此情况下,网络输出为“1”和“0”的概率各为50%,也就是说是完全随机的。这时如果输出为“1”(结果正确),则使连接权值增大,以便使网络再次遇到“A”模式输入时,仍然能做出正确的判断。
如果输出为“0”(即结果错误),则把网络连接权值朝着减小综合输入加权值的方向调整,其目的在于使网络下次再遇到“A”模式输入时,减小犯同样错误的可能性。如此操作调整,当给网络轮番输入若干个手写字母“A”、“B”后,经过网络按以上学习方法进行若干次学习后,网络判断的正确率将大大提高。这说明网络对这两个模式的学习已经获得了成功,它已将这两个模式分布地记忆在网络的各个连接权值上。当网络再次遇到其中任何一个模式时,能够做出迅速、准确的判断和识别。一般说来,网络中所含的神经元个数越多,则它能记忆、识别的模式也就越多。
4.2人工神经网络的优缺点
人工神经网络由于模拟了大脑神经元的组织方式而具有了人脑功能的一些基本特征,为人工智能的研究开辟了新的途径,神经网络具有的优点在于:
(1)并行分布性处理
因为人工神经网络中的神经元排列并不是杂乱无章的,往往是分层或以一种有规律的序列排列,信号可以同时到达一批神经元的输入端,这种结构非常适合并行计算。同时如果将每一个神经元看作是一个小的处理单元,则整个系统可以是一个分布式计算系统,这样就避免了以往的“匹配冲突”,“组合爆炸”和“无穷递归”等题,推理速度快。
(2)可学习性
一个相对很小的人工神经网络可存储大量的专家知识,并且能根据学习算法,或者利用样本指导系统来模拟现实环境(称为有教师学习),或者对输入进行自适应学习(称为无教师学习),不断地自动学习,完善知识的存储。
(3)鲁棒性和容错性
由于采用大量的神经元及其相互连接,具有联想记忆与联想映射能力,可以增强专家系统的容错能力,人工神经网络中少量的神经元发生失效或错误,不会对系统整体功能带来严重的影响。而且克服了传统专家系统中存在的“知识窄台阶”问题。
(4)泛化能力
人工神经网络是一类大规模的非线形系统,这就提供了系统自组织和协同的潜力。它能充分逼近复杂的非线形关系。当输入发生较小变化,其输出能够与原输入产生的输出保持相当小的差距。
(5)具有统一的内部知识表示形式,任何知识规则都可以通过对范例的学习存储于同一个神经网络的各连接权值中,便于知识库的组织管理,通用性强。
虽然人工神经网络有很多优点,但基于其固有的内在机理,人工神经网络也不可避免的存在自己的弱点:
(1)最严重的问题是没能力来解释自己的推理过程和推理依据。
(2)神经网络不能向用户提出必要的询问,而且当数据不充分的时候,神经网络就无法进行工作。
(3)神经网络把一切问题的特征都变为数字,把一切推理都变为数值计算,其结果势必是丢失信息。
(4)神经网络的理论和学习算法还有待于进一步完善和提高。
4.3神经网络的发展趋势及在柴油机故障诊断中的可行性
神经网络为现代复杂大系统的状态监测和故障诊断提供了全新的理论方法和技术实现手段。神经网络专家系统是一类新的知识表达体系,与传统专家系统的高层逻辑模型不同,它是一种低层数值模型,信息处理是通过大量的简单处理元件(结点) 之间的相互作用而进行的。由于它的分布式信息保持方式,为专家系统知识的获取与表达以及推理提供了全新的方式。它将逻辑推理与数值运算相结合,利用神经网络的学习功能、联想记忆功能、分布式并行信息处理功能,解决诊断系统中的不确定性知识表示、获取和并行推理等问题。通过对经验样本的学习,将专家知识以权值和阈值的形式存储在网络中,并且利用网络的信息保持性来完成不精确诊断推理,较好地模拟了专家凭经验、直觉而不是复杂的计算的推理过程。
但是,该技术是一个多学科知识交叉应用的领域,是一个不十分成熟的学科。一方面,装备的故障相当复杂;另一方面,人工神经网络本身尚有诸多不足之处:
(1)受限于脑科学的已有研究成果。由于生理实验的困难性,目前对于人脑思维与记忆机制的认识还很肤浅。
(2)尚未建立起完整成熟的理论体系。目前已提出了众多的人工神经网络模型,归纳起来,这些模型一般都是一个由结点及其互连构成的有向拓扑网,结点间互连强度所构成的矩阵,可通过某种学习策略建立起来。但仅这一共性,不足以构成一个完整的体系。这些学习策略大多是各行其是而无法统一于一个完整的框架之中。
(3)带有浓厚的策略色彩。这是在没有统一的基础理论支持下,为解决某些应用,而诱发出的自然结果。
(4)与传统计算技术的接口不成熟。人工神经网络技术决不能全面替代传统计算技术,而只能在某些方面与之互补,从而需要进一步解决与传统计算技术的接口问题,才能获得自身的发展。
虽然人工神经网络目前存在诸多不足,但是神经网络和传统专家系统相结合的智能故障诊断技术仍将是以后研究与应用的热点。它最大限度地发挥两者的优势。神经网络擅长数值计算,适合进行浅层次的经验推理;专家系统的特点是符号推理,适合进行深层次的逻辑推理。智能系统以并行工作方式运行,既扩大了状态监测和故障诊断的范围,又可满足状态监测和故障诊断的实时性要求。既强调符号推理,又注重数值计算,因此能适应当前故障诊断系统的基本特征和发展趋势。随着人工神经网络的不断发展与完善,它将在智能故障诊断中得到广泛的应用。
根据神经网络上述的各类优缺点,目前有将神经网络与传统的专家系统结合起来的研究倾向,建造所谓的神经网络专家系统。理论分析与使用实践表明,神经网络专家系统较好地结合了两者的优点而得到更广泛的研究和应用。
离心式制冷压缩机的构造和工作原理与离心式鼓风机极为相似。但它的工作原理与活塞式压缩机有根本的区别,它不是利用汽缸容积减小的方式来提高汽体的压力,而是依靠动能的变化来提高汽体压力。离心式压缩机具有带叶片的工作轮,当工作轮转动时,叶片就带动汽体运动或者使汽体得到动能,然后使部分动能转化为压力能从而提高汽体的压力。这种压缩机由于它工作时不断地将制冷剂蒸汽吸入,又不断地沿半径方向被甩出去,所以称这种型式的压缩机为离心式压缩机。其中根据压缩机中安装的工作轮数量的多少,分为单级式和多级式。如果只有一个工作轮,就称为单级离心式压缩机,如果是由几个工作轮串联而组成,就称为多级离心式压缩机。在空调中,由于压力增高较少,所以一般都是采用单级,其它方面所用的离心式制冷压缩机大都是多级的。单级离心式制冷压缩机的构造主要由工作轮、扩压器和蜗壳等所组成。 压缩机工作时制冷剂蒸汽由吸汽口轴向进入吸汽室,并在吸汽室的导流作用引导由蒸发器(或中间冷却器)来的制冷剂蒸汽均匀地进入高速旋转的工作轮3(工作轮也称叶轮,它是离心式制冷压缩机的重要部件,因为只有通过工作轮才能将能量传给汽体)。汽体在叶片作用下,一边跟着工作轮作高速旋转,一边由于受离心力的作用,在叶片槽道中作扩压流动,从而使汽体的压力和速度都得到提高。由工作轮出来的汽体再进入截面积逐渐扩大的扩压器4(因为汽体从工作轮流出时具有较高的流速,扩压器便把动能部分地转化为压力能,从而提高汽体的压力)。汽体流过扩压器时速度减小,而压力则进一步提高。经扩压器后汽体汇集到蜗壳中,再经排气口引导至中间冷却器或冷凝器中。
二、离心式制冷压缩机的特点与特性
离心式制冷压缩机与活塞式制冷压缩机相比较,具有下列优点:
(1)单机制冷量大,在制冷量相同时它的体积小,占地面积少,重量较活塞式轻5~8倍。
(2)由于它没有汽阀活塞环等易损部件,又没有曲柄连杆机构,因而工作可靠、运转平稳、噪音小、操作简单、维护费用低。
(3)工作轮和机壳之间没有摩擦,无需润滑。故制冷剂蒸汽与润滑油不接触,从而提高了蒸发器和冷凝器的传热性能。
(4)能经济方便的调节制冷量且调节的范围较大。
(5)对制冷剂的适应性差,一台结构一定的离心式制冷压缩机只能适应一种制冷剂。
(6)由于适宜采用分子量比较大的制冷剂,故只适用于大制冷量,一般都在25~30万大卡/时以上。如制冷量太少,则要求流量小,流道窄,从而使流动阻力大,效率低。但近年来经过不断改进,用于空调的离心式制冷压缩机,单机制冷量可以小到10万大卡/时左右。
制冷与冷凝温度、蒸发温度的关系。
由物理学可知,回转体的动量矩的变化等于外力矩,则
T=m(C2UR2-C1UR1)
两边都乘以角速度ω,得
Tω=m(C2UωR2-C1UωR1)
也就是说主轴上的外加功率N为:
N=m(U2C2U-U1C1U)
上式两边同除以m则得叶轮给予单位质量制冷剂蒸汽的功即叶轮的理论能量头。 U2 C2
ω2 C2U R1 R2 ω1 C1 U1 C2r β 离心式制冷压缩机的特性是指理论能量头与流量之间变化关系,也可以表示成制冷
W=U2C2U-U1C1U≈U2C2U
(因为进口C1U≈0)
又C2U=U2-C2rctgβ C2r=Vυ1/(A2υ2)
故有
W= U22(1-
Vυ1
ctgβ)
A2υ2U2
式中:V—叶轮吸入蒸汽的容积流量(m3/s)
υ1υ2 ——分别为叶轮入口和出口处的蒸汽比容(m3/kg)
A2、U2—叶轮外缘出口面积(m2)与圆周速度(m/s)
β—叶片安装角
由上式可见,理论能量头W与压缩机结构、转速、冷凝温度、蒸发温度及叶轮吸入蒸汽容积流量有关。对于结构一定、转速一定的压缩机来说,U2、A2、β皆为常量,则理论能量头W仅与流量V、蒸发温度、冷凝温度有关。
按照离心式制冷压缩机的特性,宜采用分子量比较大的制冷剂,目前离心式制冷机所用的制冷剂有F—11、F—12、F—22、F—113和F—114等。我国目前在空调用离心式压缩机中应用得最广泛的是F—11和F—12,且通常是在蒸发温度不太低和大制冷量的情况下,选用离心式制冷压缩机。此外,在石油化学工业中离心式的制冷压缩机则采用丙烯、乙烯作为制冷剂,只有制冷量特别大的离心式压缩机才用氨作为制冷剂。
三、离心式制冷压缩机的调节
离心式制冷压缩机和其它制冷设备共同构成一个能量供给与消耗的统一系统。制冷机组在运行时,只有当通过压缩机的制冷剂的流量与通过设备的流量相等时,以及压缩机所产生的能量头与制冷设备的阻力相适应时,制冷系统的工况才能保持稳定。但是制冷机的负荷总是随外界条件与用户对冷量的使用情况而变化的,因此为了适应用户对冷负荷变化的需要和安全经济运行,就需要根据外界的变化对制冷机组进行调节,离心式制冷机组制冷量的调节有:1°改变压缩机的转速;2°采用可转动的进口导叶;3°改变冷凝器的进水量;4°进汽节流等几种方式,其中最常用的是转动进口导叶调节和进汽节流两种调节方法。所谓转动进口导叶调节,就是转动压缩机进口处的导流叶片以使进入到叶轮去的汽体产生旋绕,从而使工作轮加给汽体的动能发生变化来调节制冷量。所谓进汽节流调节,就是在压缩机前的进汽管道上安装一个调节阀,如要改变压缩机的工况时,就调节阀门的大小,通过节流使压缩机进口的压力降低,从而实现调节制冷量。离心式压缩机制冷量的调节最经济有效的方法就是改变进口导叶角度,以改变蒸汽进入叶轮的速度方向(C1U)和流量V。但流量V必须控制在稳定工作范围内,以免效率下降。
BP神经网络matlab源程序代码讲解
newff 创建前向BP网络格式:
net = newff(PR,[S1 S2...SNl],{TF1 TF2...TFNl},BTF,BLF,PF)
其中:PR —— R维输入元素的R×2阶最大最小值矩阵; Si —— 第i层神经元的个数,共N1层; TFi——第i层的转移函数,默认‘tansig’; BTF—— BP网络的训练函数,默认‘trainlm’; BLF—— BP权值/偏差学习函数,默认’learngdm’ PF ——性能函数,默认‘mse’;(误差)
e.g.
P = [0 1 2 3 4 5 6 7 8 9 10];T = [0 1 2 3 4 3 2 1 2 3 4];
net = newff([0 10],[5 1],{'tansig' 'purelin'});net.trainparam.show=50; %每次循环50次net.trainParam.epochs = 500; %最大循环500次
net.trainparam.goal=0.01; %期望目标误差最小值
net = train(net,P,T); %对网络进行反复训练
Y = sim(net,P)Figure % 打开另外一个图形窗口
plot(P,T,P,Y,'o')
人工神经网络源代码的介绍就聊到这里吧,感谢你花时间阅读本站内容,更多关于神经网络开源代码、人工神经网络源代码的信息别忘了在本站进行查找喔。
版权说明:如非注明,本站文章均为 AH站长 原创,转载请注明出处和附带本文链接;
相关推荐
- 05-09网页代码,网页代码快捷键
- 05-07pb超级报表源代码(pb报表工具)[20240507更新]
- 05-07简历源代码可以上传照片的简单介绍[20240507更新]
- 05-07广告切换源代码免费下载(广告切换源代码免费下载安装)[20240507更新]
- 05-06单页网站的代码(完整的网页代码)[20240506更新]
- 05-06阁楼网源代码(阁楼是什么网站)[20240506更新]
- 05-06个人主页图片代码(个人主页图片代码怎么弄)[20240506更新]
- 05-06提取微信名片代码(微信名片信息提取)[20240506更新]
- 05-06php后台权限管理代码(php管理员权限)[20240506更新]
- 05-06付费观看代码php(付费观看代码)[20240506更新]
取消回复欢迎 你 发表评论:
- 标签列表
- 最近发表
- 友情链接