实验要求：
•实现10以内的非负双精度浮点数加法，例如输入4.99和5.70，能够预测输出为10.69
•使用Gprof测试代码热度
代码框架
•随机初始化1000对数值在0~10之间的浮点数，保存在二维数组a[1000][2]中。
•计算各对浮点数的相加结果，保存在数组b[1000]中，即b[0] = a[0][0] + a[0][1]，以此类推。数组a、b即可作为网络的训练样本。
•定义浮点数组w、v分别存放隐层和输出层的权值数据，并随机初始化w、v中元素为-1~1之间的浮点数。
•将1000组输入（a[1000][2]）逐个进行前馈计算，并根据计算的输出结果与b[1000]中对应标签值的差值进行反馈权值更新，调整w、v中各元素的数值。
•1000组输入迭代完成后，随机输入两个浮点数，测试结果。若预测误差较大，则增大训练的迭代次数（训练样本数）。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
//归一化二维数组
void normalization(float num[][]){
float max1 = 0.0,max2 = 0.0;
float min1 = 0.0,min2 = 0.0;
for(int i = ;i<;i++){
if(num[i][]>max1||num[i][]<min1){
if(num[i][]>max1){
max1 = num[i][];
}
if(num[i][]<min1){
min1 = num[i][];
}
}
if(num[i][]>max2||num[i][]<min2){
if(num[i][]>max2){
max2 = num[i][];
}
if(num[i][]<min2){
min2 = num[i][];
}
}
}
for(int i = ;i<;i++){
num[i][] = (num[i][]-min1+)/(max1-min1+);
num[i][] = (num[i][]-min2+)/(max2-min1+);
}
printf("a[][0]的最大值和最小值分别为：%f\t%f",max1,min1);
printf("\na[][1]的最大值和最小值分别为：%f\t%f",max2,min2);
printf("\n");
}
//归一化一维数组
void normalization_b(float num[]){
float max = 0.0,min = 0.0;
for(int i = ;i<;i++){
if(num[i]>max||num[i]<min){
if(num[i]>max){
max = num[i];
}else{
min = num[i];
}
}
}
for(int i = ;i<;i++){
num[i] = (num[i]-min+)/(max-min+);
}
printf("b数组归一化的最大值和最小值为:%f,%f",max,min);
}
//后向隐藏层公式计算
float compute_hidden(float a,float b,float *w_a,float *w_b,float *bias_c){
float value = 0.0;
value = a*(*w_a)+b*(*w_b)+(*bias_c);
value = /(+exp(-value));
return value;
}
//后向输出层公式计算
float compute_output(float c,float *w_c,float *bias_d){
float value = 0.0;
value = c*(*w_c)+(*bias_d);
value = /(+exp(-value));
return value;
}
//前向输出层公式计算
float pro_output(float predict_num,float real_num){
float error = 0.0;
error = predict_num*(-predict_num)*(real_num-predict_num);
return error;
}
//bp算法
void bp(float a,float b,float real_num,float *w_a,float *w_b,float *v,float *bias_c,float *bias_d){
//前向计算
//隐藏层
float output = compute_hidden(a,b,w_a,w_b,bias_c);
//输出层
float output_final = compute_output(output,v,bias_d);
//反向计算
float error_output = 0.0;
//输出层
error_output = pro_output(output_final,real_num);
//更新权重和偏向！
//定义学习率
double learning_rate = 0.01;
*v = *v + learning_rate*error_output*output;
*bias_d = *bias_d + learning_rate*error_output;
//前向隐藏层
float error_hidden = 0.0;
error_hidden = output*(-output)*(error_output*(*v));
//更新权重和偏向
*w_a = *w_a + learning_rate*(error_hidden*a);
*w_b = *w_b + learning_rate*(error_hidden*b);
*bias_c = *bias_c + learning_rate*error_hidden;
}
int main(int argc, const char * argv[]) {
//随机初始化1000对数值在0-10之间的双精度浮点数，保存在二维数组a[1000][2]中
srand((unsigned) (time(NULL)));
float a[][],b[];
for(int i = ;i<;i++){
for(int j = ;j<;j++){
int rd = rand()%;
a[i][j] = rd/100.0;
}
}
for(int i = ;i<;i++){
b[i] = a[i][] +a[i][];
}
//归一化处理
normalization(a);
normalization_b(b);
//定义浮点数组w,v分别存放隐层和输出层的权值数据，并随机初始化w,v为（-1，1）之间的浮点数
int w_a_rand = rand()%;
int w_b_rand = rand()%;
float w_a = w_a_rand/100000.0-;
float w_b = w_b_rand/100000.0-;
int v_rand = rand()%;
float v = v_rand/100000.0-;
int bias_c_rand = rand()%;
float bias_c = bias_c_rand/100000.0-;
int bias_d_rand = rand()%;
float bias_d = bias_d_rand/100000.0-;
printf("w_a,w_b,v初始随机值分别是:%f %f %f\n",w_a,w_b,v);
//将1000组输入（a[1000][2]）逐个进行前馈计算，并根据计算的输出结果与b[1000]中对应标签值的差值进行反馈权值更新，调整w、v中各元素的数值。
//对于每一个训练实例：执行bp算法
float max1 ,max2 ,min1 ,min2,max,min;
printf("x0的归一化参数（最大最小值):");
scanf("%f,%f",&max1,&min1);
printf("x1的归一化参数（最大最小值):");
scanf("%f,%f",&max2,&min2);
printf("b的归一化参数（最大最小值):");
scanf("%f,%f",&max,&min);
int mark = ;
float trainnig_data_a[][],trainnig_data_b[],test_data_a[][],test_data_b[];
int i = ;
while (i<) {
if(i == mark){
//设置测试集
for(int k = i;k<(i+);k++){
test_data_a[k][] = a[k][];
test_data_a[k][] = a[k][];
test_data_b[k] = b[k];
}
i +=;
}
//设置训练集
if(i<mark){
trainnig_data_a[i][] = a[i][];
trainnig_data_a[i][] = a[i][];
trainnig_data_b[i] = b[i];
i++;
}
if(i>mark){
trainnig_data_a[i-][] = a[i][];
trainnig_data_a[i-][] = a[i][];
trainnig_data_b[i-] = b[i];
i++;
}
}
for(int i = ;i<;i++){
//迭代600次
int times = ;
for(int i= ;i<;i++){
bp(trainnig_data_a[i][],trainnig_data_a[i][],trainnig_data_b[i],&w_a,&w_b,&v,&bias_c,&bias_d);
times++;
}
}
//进行预测
float pre_1,pre_2,predict_value,true_value; float MSE[];
for(int i = ;i<;i++){
pre_1 = test_data_a[i][];
pre_2 = test_data_a[i][];
true_value = test_data_b[i];
//进行计算
float pre_hidden = compute_hidden(pre_1, pre_2, &w_a, &w_b, &bias_c);
predict_value = compute_output(pre_hidden, &v, &bias_d);
//求均方误差
MSE[i] = (predict_value - true_value)*(predict_value-true_value);
predict_value = (predict_value*(max-min+))-+min;
true_value = (true_value*(max-min+))-+min;
printf("预测值为:%f 真实值为:%f\n",predict_value,true_value);
}
float mean_square_error = ;
for(int i = ;i<;i++){
mean_square_error += MSE[i];
}
mean_square_error = mean_square_error/;
printf("均方误差为:%lf",mean_square_error);
}
运行结果截图：
将隐藏层改为5个神经元
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
struct tag{
float value[];
}x,y;
//归一化二维数组
void normalization(float num[][]){
float max1 = 0.0,max2 = 0.0;
float min1 = 0.0,min2 = 0.0;
for(int i = ;i<;i++){
if(num[i][]>max1||num[i][]<min1){
if(num[i][]>max1){
max1 = num[i][];
}
if(num[i][]<min1){
min1 = num[i][];
}
}
if(num[i][]>max2||num[i][]<min2){
if(num[i][]>max2){
max2 = num[i][];
}
if(num[i][]<min2){
min2 = num[i][];
}
}
}
for(int i = ;i<;i++){
num[i][] = (num[i][]-min1+)/(max1-min1+);
num[i][] = (num[i][]-min2+)/(max2-min1+);
}
printf("a[][0]的最大值和最小值分别为：%f\t%f",max1,min1);
printf("\na[][1]的最大值和最小值分别为：%f\t%f",max2,min2);
printf("\n");
}
//归一化一维数组
void normalization_b(float num[]){
float max = 0.0,min = 0.0;
for(int i = ;i<;i++){
if(num[i]>max||num[i]<min){
if(num[i]>max){
max = num[i];
}else{
min = num[i];
}
}
}
for(int i = ;i<;i++){
num[i] = (num[i]-min+)/(max-min+);
}
printf("b数组归一化的最大值和最小值为:%f,%f",max,min);
}
//后向隐藏层公式计算
struct tag compute_hidden(float a,float b,float *w_a,float *w_b,float *bias_c){
for(int i=;i<;i++){
x.value[i] = a*(w_a[i])+b*(w_b[i])+(bias_c[i]);
x.value[i] = /(+exp(-(x.value[i])));
}
return x;
}
//后向输出层公式计算
float compute_output(struct tag c,float *w_c,float *bias_d){
float value_output = ;
for(int i = ;i<;i++){
c.value[i] = c.value[i]*(w_c[i]);
value_output+=c.value[i];
}
value_output = (value_output+(*bias_d))/;
value_output = /(+exp(-(value_output)));
return value_output;
}
//前向输出层公式计算
float pro_output(float predict_num,float real_num){
float error = 0.0;
error = predict_num*(-predict_num)*(real_num-predict_num);
return error;
}
//bp算法
void bp(float a,float b,float real_num,float *w_a,float *w_b,float *v,float *bias_c,float *bias_d){
//前向计算
//隐藏层
struct tag output = compute_hidden(a,b,w_a,w_b,bias_c);
//输出层
float output_final = compute_output(output,v,bias_d);
//反向计算
float error_output = 0.0;
//输出层
error_output = pro_output(output_final,real_num);
//更新权重和偏向！
//定义学习率
double learning_rate = 0.00003;
for(int i = ;i<;i++){
v[i] = v[i] + learning_rate*error_output*output.value[i];
}
*bias_d = *bias_d + learning_rate*error_output;
//前向隐藏层
float error_hidden[];
for(int i = ;i<;i++){
error_hidden[i] = output.value[i]*(-output.value[i])*(error_output*v[i]);
}
//更新权重和偏向
for(int i = ;i<;i++){
w_a[i] = w_a[i] + learning_rate*(error_hidden[i]*a);
w_b[i] = w_b[i] + learning_rate*(error_hidden[i]*b);
bias_c[i] = bias_c[i] + learning_rate*error_hidden[i];
}
}
int main(int argc, const char * argv[]) {
//随机初始化1000对数值在0-10之间的双精度浮点数，保存在二维数组a[1000][2]中
srand((unsigned) (time(NULL)));
float a[][],b[];
for(int i = ;i<;i++){
for(int j = ;j<;j++){
int rd = rand()%;
a[i][j] = rd/100.0;
}
}
for(int i = ;i<;i++){
b[i] = a[i][] +a[i][];
}
//归一化处理
normalization(a);
normalization_b(b);
//定义浮点数组w,v分别存放隐层和输出层的权值数据，并随机初始化w,v为（-1，1）之间的浮点数
int w_a_rand[];
int w_b_rand[];
for(int i = ;i<;i++){
w_a_rand[i] = rand()%;
}
for(int i = ;i<;i++){
w_b_rand[i] = rand()%;
}
float w_a[];
for(int i = ;i<;i++){
w_a[i] = w_a_rand[i]/100000.0-;
}
float w_b[];
for(int i = ;i<;i++){
w_b[i] = w_b_rand[i]/100000.0-;
}
int v_rand[];
for(int i = ;i<;i++){
v_rand[i] = rand()%;
}
float v[];
for(int i = ;i<;i++){
v[i] = v_rand[i]/100000.0-;
}
int bias_c_rand[];
for(int i = ;i<;i++){
bias_c_rand[i] = rand()%;
}
float bias_c[];
for(int i = ;i<;i++){
bias_c[i] = bias_c_rand[i]/100000.0-;
}
int bias_d_rand = rand()%;
float bias_d = bias_d_rand/100000.0-;
printf("w_a[1-5],w_b[1-5],v[1-5]初始随机值分别是:");
for(int i = ;i<;i++){
printf("w_a[%d]=%f,w_b[%d]=%f,v[%d]=%f\n",i,w_a[i],i,w_b[i],i,v[i]);
}
//将1000组输入（a[1000][2]）逐个进行前馈计算，并根据计算的输出结果与b[1000]中对应标签值的差值进行反馈权值更新，调整w、v中各元素的数值。
//对于每一个训练实例：执行bp算法
float max1 ,max2 ,min1 ,min2,max,min;
printf("x0的归一化参数（最大最小值):");
scanf("%f,%f",&max1,&min1);
printf("x1的归一化参数（最大最小值):");
scanf("%f,%f",&max2,&min2);
printf("b的归一化参数（最大最小值):");
scanf("%f,%f",&max,&min);
int mark = ;
float trainnig_data_a[][],trainnig_data_b[],test_data_a[][],test_data_b[];
int i = ;
while (i<) {
if(i == mark){
//设置测试集
for(int k = i;k<(i+);k++){
test_data_a[k][] = a[k][];
test_data_a[k][] = a[k][];
test_data_b[k] = b[k];
}
i +=;
}
//设置训练集
if(i<mark){
trainnig_data_a[i][] = a[i][];
trainnig_data_a[i][] = a[i][];
trainnig_data_b[i] = b[i];
i++;
}
if(i>mark){
trainnig_data_a[i-][] = a[i][];
trainnig_data_a[i-][] = a[i][];
trainnig_data_b[i-] = b[i];
i++;
}
}
for(int i = ;i<;i++){
//迭代600次
int times = ;
for(int j= ;j<;j++){
bp(trainnig_data_a[i][],trainnig_data_a[i][],trainnig_data_b[i],w_a,w_b,v,bias_c,&bias_d);
times++;
}
}
//进行预测
float pre_1,pre_2,predict_value,true_value; float MSE[];
for(int i = ;i<;i++){
pre_1 = test_data_a[i][];
pre_2 = test_data_a[i][];
true_value = test_data_b[i];
//进行计算
struct tag pre_hidden = compute_hidden(pre_1, pre_2,w_a,w_b,bias_c);
predict_value = compute_output(pre_hidden, v, &bias_d);
//求均方误差
MSE[i] = (predict_value - true_value)*(predict_value-true_value);
predict_value = (predict_value*(max-min+))-+min;
true_value = (true_value*(max-min+))-+min;
printf("预测值为:%f 真实值为:%f\n",predict_value,true_value);
}
float mean_square_error = ;
for(int i = ;i<;i++){
mean_square_error += MSE[i];
}
mean_square_error = mean_square_error/;
printf("均方误差为:%lf",mean_square_error);
}
但结果没什么优化，估计要批量训练可以将结果更优