y=ax^2+bx+c，
有三个系数要回归，如果只给你1～2组数据，你觉得能回归好吗？
考虑到样本本身有误差，为了防止过拟合（或过学习），一般要求神经网络的训练样本数是连接权系数（包括阈值）的2～3倍。你用了太多的连接权系数（包括阈值），即使效果不错，风险仍然很高。
// 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条）