#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define INPUT_SIZE 2
#define HIDDEN_SIZE 3
#define OUTPUT_SIZE 1
/* 定义神经元结构体 */
typedef struct _neuron {
double* weights; // 权重数组
double bias; // 偏置值
double output; // 输出
} neuron;
/* 定义隐藏层和输出层结构体 */
typedef struct _layer {
int size; // 层数
neuron* neurons; // 神经元数组
} layer;
/* 定义神经网络结构体 */
typedef struct _network {
layer input_layer; // 输入层
layer hidden_layer; // 隐藏层
layer output_layer; // 输出层
} network;
/* 初始化神经元 */
void init_neuron(neuron* n, int size) {
n->weights = (double*)malloc(sizeof(double) * size);
for (int i = 0; i < size; i++) {
n->weights[i] = ((double)rand() / RAND_MAX) * 2 - 1;
}
n->bias = ((double)rand() / RAND_MAX) * 2 - 1;
}
/* 初始化层 */
void init_layer(layer* l, int size, int input_size) {
l->size = size;
l->neurons = (neuron*)malloc(sizeof(neuron) * size);
for (int i = 0; i < size; i++) {
init_neuron(&l->neurons[i], input_size);
}
}
/* 初始化神经网络 */
void init_network(network* net) {
init_layer(&net->input_layer, INPUT_SIZE, 0);
init_layer(&net->hidden_layer, HIDDEN_SIZE, INPUT_SIZE);
init_layer(&net->output_layer, OUTPUT_SIZE, HIDDEN_SIZE);
}
/* 计算神经元输出值 */
double activate(neuron* n, double* inputs) {
double sum = 0;
for (int i = 0; i < INPUT_SIZE; i++) {
sum += inputs[i] * n->weights[i];
}
sum += n->bias;
return 1.0 / (1.0 + exp(-sum));
}
/* 前向传播 */
void forward(network* net, double* inputs) {
/* 输入层计算 */
for (int i = 0; i < INPUT_SIZE; i++) {
net->input_layer.neurons[i].output = inputs[i];
}
/* 隐藏层计算 */
for (int i = 0; i < HIDDEN_SIZE; i++) {
neuron* n = &net->hidden_layer.neurons[i];
n->output = activate(n, inputs);
}
/* 输出层计算 */
for (int i = 0; i < OUTPUT_SIZE; i++) {
neuron* n = &net->output_layer.neurons[i];
n->output = activate(n, [n->output_layer.neurons[j].output for j in range(HIDDEN_SIZE)]);
}
}
/* 计算误差 */
double error(double* target_output, double* output) {
double err = 0;
for (int i = 0; i < OUTPUT_SIZE; i++) {
err += pow(target_output[i] - output[i], 2);
}
return err;
}
/* 反向传播 */
void backward(network* net, double* target_output, double learning_rate) {
/* 计算输出层误差 */
for (int i = 0; i < OUTPUT_SIZE; i++) {
neuron* n = &net->output_layer.neurons[i];
double output = n->output;
double error = -(target_output[i] - output) * output * (1 - output);
n->bias -= learning_rate * error;
for (int j = 0; j < HIDDEN_SIZE; j++) {
n->weights[j] -= learning_rate * error * net->hidden_layer.neurons[j].output;
}
}
/* 计算隐藏层误差 */
for (int i = 0; i < HIDDEN_SIZE; i++) {
neuron* n = &net->hidden_layer.neurons[i];
double output = n->output;
double error = 0;
for (int j = 0; j < OUTPUT_SIZE; j++) {
neuron* o = &net->output_layer.neurons[j];
error += o->weights[i] * (target_output[j] - o->output) * o->output * (1 - o->output);
}
n->bias -= learning_rate * error;
for (int j = 0; j < INPUT_SIZE; j++) {
n->weights[j] -= learning_rate * error * net->input_layer.neurons[j].output;
}
}
}
/* 训练神经网络 */
void train(network* net, double** training_inputs, double** training_outputs, int epochs, double learning_rate) {
for (int epoch = 0; epoch < epochs; epoch++) {
double total_error = 0;
for (int i = 0; i < NUM_EXAMPLES; i++) {
forward(net, training_inputs[i]);
total_error += error(training_outputs[i], [net->output_layer.neurons[j].output for j in range(OUTPUT_SIZE)]);
backward(net, training_outputs[i], learning_rate);
}
printf("Epoch %d: error = %f\n", epoch, total_error);
}
}
/* 测试神经网络 */
void test(network* net, double** test_inputs) {
for (int i = 0; i < NUM_TEST_EXAMPLES; i++) {
double* inputs = test_inputs[i];
forward(net, inputs);
printf("[");
for (int j = 0; j < INPUT_SIZE; j++) {
printf("%f ", inputs[j]);
}
printf("] -> [");
for (int j = 0; j < OUTPUT_SIZE; j++) {
printf("%f ", net->output_layer.neurons[j].output);
}
printf("]\n");
}
}
int main(int argc, char** argv) {
/* 初始化随机数种子 */
srand((unsigned int)time(NULL));
/* 定义训练集和测试集 */
double* training_inputs[NUM_EXAMPLES] = {
(double[]){
0, 0},
(double[]){
0, 1},
(double[]){
1, 0},
(double[]){
1, 1}
};
double* training_outputs[NUM_EXAMPLES] = {
(double[]){
0},
(double[]){
1},
(double[]){
1},
(double[]){
0}
};
double* test_inputs[NUM_TEST_EXAMPLES] = {
(double[]){
0, 0},
(double[]){
0, 1},
(double[]){
1, 0},
(double[]){
1, 1}
};
/* 初始化神经网络 */
network net;
init_network(&net);
/* 训练神经网络 */
train(&net, training_inputs, training_outputs, NUM_EPOCHS, LEARNING_RATE);
/* 测试神经网络 */
test(&net, test_inputs);
return 0;
}
解释说明
这是一个简单的实现，仅仅展示了神经网络框架的基本结构和算法。
该程序实现了一个简单的多层感知机（Multilayer Perceptron, MLP）神经网络，并使用该神经网络来解决XOR逻辑运算问题。以下是程序的主要流程：
定义常量：程序中定义了输入层、隐藏层和输出层的大小，以及学习率、迭代轮数、训练集和测试集的大小等常量。
定义结构体：程序中定义了三个结构体：神经元结构体（neuron）、层结构体（layer）和神经网络结构体（network），用于存储神经网络的各种参数信息。
初始化神经网络：程序中通过调用init_network函数初始化神经网络。在初始化过程中，会为每个神经元随机生成一组权重并将其存储在神经元结构体中。
前向传播：程序中通过调用forward函数实现前向传播算法。在前向传播中，程序会依次计算输入层、隐藏层和输出层的神经元的输出值。
计算误差：程序中定义了error函数用于计算预测结果与实际结果之间的误差。
反向传播：程序中通过调用backward函数实现反向传播算法。在反向传播中，程序首先计算输出层的误差，然后将误差信号向后传递到隐藏层和输入层，最后使用梯度下降算法更新权重和偏置值。
训练神经网络：程序中通过调用train函数对神经网络进行训练。训练过程中，程序会多次迭代计算误差并调整权重和偏置值，以使神经网络的性能逐步提高。
测试神经网络：程序中通过调用test函数对已经训练好的神经网络进行测试，并输出测试结果。
具体来说，该神经网络是一个三层结构的MLP，其中包含1个输入层、1个隐藏层和1个输出层。输入层大小为2，隐藏层大小为3，输出层大小为1。在训练阶段，程序使用反向传播算法对神经网络进行学习，然后使用前向传播算法进行预测，最后输出测试结果。
测试方法
定义测试集：在主函数中定义一个包含多组输入数据的测试集，每组输入数据都是一个大小为2的double类型数组
double* test_inputs[NUM_TEST_EXAMPLES] = {
(double[]){
0, 0},
(double[]){
0, 1},
(double[]){
1, 0},
(double[]){
1, 1}
};
调用test函数：在主函数中调用test函数，对测试集中的每一组输入数据进行测试，并输出测试结果。
/* 测试神经网络 */
test(&net, test_inputs);
在test函数内部，程序会依次计算每一组输入数据的输出结果，并将结果输出到控制台上。具体来说，程序会按照如下格式输出每组输入数据和其对应的输出结果：
[IN] -> [OUT]
其中，IN表示输入数据，OUT表示神经网络的输出结果。对于本例中的神经网络，输出结果只有一个值。
最后，通过观察输出结果，可以评估该神经网络在XOR逻辑运算问题上的性能表现
编译方法
gcc -o program program.c -lm
这里使用了-lm参数，表示需要链接数学库libm。因为本程序使用了数学函数，如exp和log等。
运行可执行文件，开始训练和测试神经网络。
./program
注意，本程序中使用了随机数生成函数，运行结果可能会略有不同。如果多次运行结果不一致，可以尝试增加训练轮数或调整学习率等参数来改善程序的性能。