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')
load data3_1.txt[m,n]=size( data3_1)
tsx = data3_1(1:m-1,1)
tsx=tsx'
ts = data3_1(2:m,1)
ts=ts'
[TSX,TSXps]=mapminmax(tsx,1,2)
[TS,TSps]=mapminmax(ts,1,2)
TSX=TSX'
figure
plot(ts,'LineWidth',2)
title('到杭旅游总人数(1999.01.01-2009.12.31)','FontSize',12)
xlabel('统计年份(1990.12.19-2009.08.19)','FontSize',12)
ylabel('归一化后的总游客数/万人','FontSize',12)
grid on
% 生成BP网络、利用minmax函数求输入样本范围
net_1=newff(minmax(TS),[10,1],{'tansig','purelin'},'traincgf')
% 设置训练参数
net_1.trainParam.show = 50 %显示训练迭代过程（NaN表示不显示，缺省25）
net_1.trainParam.lr = 0.025%学习率（缺省埋旅森0.01）
net_1.trainParam.mc = 0.9 %动量因子（缺省0.9）
net_1.trainParam.epochs = 10000%最大训练次数
net_1.trainParam.goal = 0.001 %训练要求镇卖精度
inputWeights=net_1.IW{1,1} %输入层权值
inputbias=net_1.b{1} %输入弯亩层阈值
layerWeights=net_1.LW{2,1} %输出层权值
layerbias=net_1.b{2} %输出层阈值
TS',TSX
% 网络训练
[net_1,tr]=train(net_1,TS,TSX)
// 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 = 0i <mi++) {
new1[i] = alloc_1d_dbl(n)
}
return (new1)
}
/*** 随机初始化权值 ***/
void CAnnBP::bpnn_randomize_weights(double **w, int m, int n)
{
int i, j
for (i = 0i <= mi++) {
for (j = 0j <= nj++) {
w[i][j] = dpn1()
}
}
}
/*** 0初始化权值 ***/
void CAnnBP::bpnn_zero_weights(double **w, int m, int n)
{
int i, j
for (i = 0i <= mi++) {
for (j = 0j <= nj++) {
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 = 0i <= n1i++) {
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 = 0i <= n2i++) {
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 = 1j <= n2j++) {
/*** 计算输入的加权总和 ***/
sum = 0.0
for (k = 0k <= n1k++) {
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 = 1j <= njj++) {
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 = 1j <= nhj++) {
h = hidden[j]
sum = 0.0
for (k = 1k <= nok++) {
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 = 1j <= ndeltaj++) {
for (k = 0k <= nlyk++) {
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 = 0i <= n1i++) {
for (j = 0j <= n2j++) {
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 = 0i <= n2i++) {
for (j = 0j <= n3j++) {
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 = 0i <= n1i++) {
for (j = 0j <= n2j++) {
//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 = 0i <= n2i++) {
for (j = 0j <= n3j++) {
//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=1i<=input_numi++)
{
net->input_units[i]=input_unit[i-1]
}
for(int j=1j<=target_numj++)
{
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=1i<=input_numi++)
{
net->input_units[i]=input_unit[i-1]
}
bpnn_feedforward(net)
for(int j=1j<=target_numj++)
{
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)
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）