模糊神经网络的计算步骤如下：
测试数据如下：（胃病和非胃病）
输入X：
228 134 20 11
245 134 10 40
200 167 12 27
170 150 7 8
100 167 20 14
150 117 7 6
120 133 10 26
160 100 5 10
185 115 5 19
170 125 6 4
165 142 5 3
185 108 2 12
225 125 7 14
130 100 6 12
输出期望y：（1为胃病，2为非胃病）
1 1 1 1 1 2 2 2 2 2 2 2 2 2
代码如下:（该代码输出结果还是有些欠缺的，但从结果可以看出胃病和非胃病还是有比较明显的区别）
#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#include "math.h"
#include "vector"
using namespace std;
#define dimIn 4 //输入样本的维数
#define dimOut 1 //输出样本的维数
#define hidePoint 8 //隐藏节点
#define MAXITER 1000 //最大迭代次数
#define alpha 0.35 //学习率
typedef vector<double> doubleVector;
vector<doubleVector> getInputTrain(char *File); //获取训练样本
vector<doubleVector> getOutputTrain(char *File); //获取期望样本
vector<doubleVector> inputNormalization(vector<doubleVector> inputTrain); //训练样本归一化
vector<doubleVector> outputNormalization(vector<doubleVector> outputTrain); //输出期望归一化
void trainNet(vector<doubleVector> inputTrain, vector<doubleVector> outputTrain); //开始训练样本
double maxInputTrain[dimIn], minInputTrain[dimIn]; //输入训练样本的最大最小值
double maxOutputTrain[dimOut], minOutputTrain[dimOut]; //期望样本的最大最小值
void main()
{
int i, j;
char *inputFile = "input.txt";
char *outputFile = "output.txt";
vector<doubleVector> inputTrain; //输入训练样本
vector<doubleVector> outputTrain; //输出期望样本
inputTrain = getInputTrain(inputFile);
outputTrain = getOutputTrain(outputFile);
inputTrain = inputNormalization(inputTrain); //样本归一化
outputTrain = outputNormalization(outputTrain); //输出期望归一化
trainNet(inputTrain, outputTrain); //开始训练样本
}
//开始训练样本
void trainNet(vector<doubleVector> inputTrain, vector<doubleVector> outputTrain)
{
double Test[dimIn] = {100, 117, 7, 2};
int iter=0;
int i, j, k;
double p[dimIn+1][hidePoint], p_1[dimIn+1][hidePoint], d_p[hidePoint];
double c[hidePoint][dimIn], c_1[hidePoint][dimIn], d_c[hidePoint][dimIn];
double b[hidePoint][dimIn], b_1[hidePoint][dimIn], d_b[hidePoint][dimIn];
double u[dimIn][hidePoint];
double w[hidePoint];
double y[hidePoint];
//初始化参数
srand(time(NULL));
for(i=0; i<hidePoint; i++)
{
for(j=0; j<dimIn; j++)
{
c[i][j] = ((double)rand()/RAND_MAX);
b[i][j] = ((double)rand()/RAND_MAX);
c_1[i][j] = c[i][j];
b_1[i][j] = b[i][j];
}
}
for(i=0; i<dimIn+1; i++)
{
for(j=0; j<hidePoint; j++)
{
p[i][j] = 0.18;
p_1[i][j] = p[i][j];
}
}
//开始训练
double addw, addyw;
double e, yn;
for(iter=0; iter<MAXITER; iter++)
{
for(k=0; k<inputTrain.size(); k++)
{
//获取模糊参数
for(i=0; i<dimIn; i++)
for(j=0; j<hidePoint; j++)
u[i][j] = exp(-((inputTrain[k][i]-c[j][i])*(inputTrain[k][i]-c[j][i]))/b[j][i]);
//模糊隶属度计算
addw = 0;
for(i=0; i<hidePoint; i++)
{
double mul = 1;
for(j=0; j<dimIn; j++)
mul = mul*u[j][i];
w[i] = mul;
addw += w[i];
}
//计算输出
addyw = 0;
for(i=0; i<hidePoint; i++)
{
double sumTemp =0;
for(j=0; j<dimIn; j++)
sumTemp = sumTemp*p[j][i]*inputTrain[k][j];
y[i] = sumTemp+p[dimIn][i];
addyw += y[i]*w[i];
}
yn = addyw/addw; //模糊输出值
e = outputTrain[k][0]-yn;
//修正系数p
for(i=0; i<hidePoint; i++)
d_p[i] = alpha*e*w[i]/addw;
for(i=0; i<hidePoint; i++)
{
for(j=0; j<dimIn; j++)
p[j][i] = p_1[j][i]+d_p[i]*inputTrain[k][j];
p[dimIn][i] = p_1[dimIn][i];
}
//修正系数b
for(i=0; i<hidePoint; i++)
for(j=0; j<dimIn; j++)
b[i][j] = b_1[i][j]+alpha*e*(y[i]*addw-addyw)*(inputTrain[k][j]-c[i][j])*(inputTrain[k][j]-c[i][j])*w[i]/(b[i][j]*b[i][j]*addw*addw);
//修正系数c
for(i=0; i<hidePoint; i++)
for(j=0; j<dimIn; j++)
c[i][j] = c_1[i][j]+alpha*e*(y[i]*addw-addyw)*2*(inputTrain[k][j]-c[i][j])*w[i]/(b[i][j]*addw*addw);
}
}
//测试网络
for(k=0; k<13; k++)
{
for(i=0; i<dimIn; i++)
for(j=0; j<hidePoint; j++)
u[i][j] = exp(-((inputTrain[k][i]-c[j][i])*(inputTrain[k][i]-c[j][i]))/b[j][i]);
//模糊隶属度计算
addw = 0;
for(i=0; i<hidePoint; i++)
{
double mul = 1;
for(j=0; j<dimIn; j++)
mul = mul*u[j][i];
w[i] = mul;
addw += w[i];
}
//计算输出
addyw = 0;
for(i=0; i<hidePoint; i++)
{
double sumTemp =0;
for(j=0; j<dimIn; j++)
sumTemp = sumTemp+p[j][i]*inputTrain[k][j];
y[i] = sumTemp+p[dimIn][i];
addyw += y[i]*w[i];
}
yn = addw/addyw; //模糊输出值
printf("%lf\n", yn);
}
}
//输出期望归一化
vector<doubleVector> outputNormalization(vector<doubleVector> outputTrain)
{
int i, j;
double y;
doubleVector temp;
vector<doubleVector> dst;
for(i=0; i<dimOut; i++)
{
maxOutputTrain[i] = minOutputTrain[i] = outputTrain[0][i];
for(j=1; j<outputTrain.size(); j++)
{
if(maxOutputTrain[i]<outputTrain[j][i])
maxOutputTrain[i] = outputTrain[j][i];
if(minOutputTrain[i]>outputTrain[j][i])
minOutputTrain[i] = outputTrain[j][i];
}
}
//归一化
for(i=0; i<outputTrain.size(); i++)
{
temp.clear();
for(j=0; j<dimIn; j++)
{
y = (0.02+0.996*(outputTrain[i][j]-minOutputTrain[j]))/(maxOutputTrain[j]-minOutputTrain[j]);
temp.push_back(y);
}
dst.push_back(temp);
}
return dst;
}
//训练样本归一化
vector<doubleVector> inputNormalization(vector<doubleVector> inputTrain)
{
int i, j;
double y;
double maxInputTrain[dimIn], minInputTrain[dimIn];
doubleVector temp;
vector<doubleVector> dst;
for(i=0; i<dimIn; i++)
{
maxInputTrain[i] = minInputTrain[i] = inputTrain[0][i];
for(j=1; j<inputTrain.size(); j++)
{
if(maxInputTrain[i]<inputTrain[j][i])
maxInputTrain[i] = inputTrain[j][i];
if(minInputTrain[i]>inputTrain[j][i])
minInputTrain[i] = inputTrain[j][i];
}
}
//归一化
for(i=0; i<inputTrain.size(); i++)
{
temp.clear();
for(j=0; j<dimIn; j++)
{
y = (0.02+0.996*(inputTrain[i][j]-minInputTrain[j]))/(maxInputTrain[j]-minInputTrain[j]);
temp.push_back(y);
}
dst.push_back(temp);
}
return dst;
}
//获取输出样本
vector<doubleVector> getInputTrain(char *File)
{
int i=1;
doubleVector temp;
vector<doubleVector> dst;
double num;
FILE *fp = fopen(File, "r");
if(fp==NULL)
{
printf("Open input train error\n");
exit(0);
}
temp.clear();
while(fscanf(fp, "%lf", &num)!=EOF)
{
temp.push_back(num);
if(i%dimIn==0)
{
dst.push_back(temp);
temp.clear();
}
i++;
}
return dst;
}
//获取输出样本
vector<doubleVector> getOutputTrain(char *File)
{
int i=1;
doubleVector temp;
vector<doubleVector> dst;
double num;
FILE *fp = fopen(File, "r");
if(fp==NULL)
{
printf("Open input train error\n");
exit(0);
}
temp.clear();
while(fscanf(fp, "%lf", &num)!=EOF)
{
temp.push_back(num);
if(i%dimOut==0)
{
dst.push_back(temp);
temp.clear();
}
i++;
}
return dst;
}
