人工神经网络 附书bp c语言程序

人工神经网络是一种模拟人脑神经系统工作原理的计算模型，用于模拟人类智能的行为和思维过程。它由神经元和神经连接构成，通过改变神经元之间的连接权重来实现对输入信号的处理和输出结果的预测。

bp（反向传播）算法是人工神经网络中常用的训练算法之一。它通过将网络输出结果与预期结果之间的误差反向传播，调整神经元之间的连接权重，来达到减小误差的目的。bp算法的具体实现过程包含前向传播和反向传播两部分。

以C语言为例，以下是一个简单的bp算法的实现程序示例：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define INPUT_NUM 2
#define HIDDEN_NUM 2
#define OUTPUT_NUM 1
#define LEARNING_RATE 0.5
#define MAX_ITERATIONS 10000
#define ERROR_THRESHOLD 0.0001

/* 定义神经网络结构 */
typedef struct {
    double input[INPUT_NUM];        // 输入层
    double hidden[HIDDEN_NUM];      // 隐藏层
    double output[OUTPUT_NUM];      // 输出层
    double hidden_weights[HIDDEN_NUM][INPUT_NUM];   // 隐藏层权重
    double output_weights[OUTPUT_NUM][HIDDEN_NUM];  // 输出层权重
} NeuralNetwork;

/* sigmoid激活函数 */
double sigmoid(double x) {
    return 1 / (1 + exp(-x));
}

/* sigmoid激活函数的导数 */
double sigmoid_derivative(double x) {
    return sigmoid(x) * (1 - sigmoid(x));
}

/* 前向传播 */
void forward(NeuralNetwork *nn) {
    // 隐藏层计算
    for (int i = 0; i < HIDDEN_NUM; i++) {
        double sum = 0.0;
        for (int j = 0; j < INPUT_NUM; j++) {
            sum += nn->input[j] * nn->hidden_weights[i][j];
        }
        nn->hidden[i] = sigmoid(sum);
    }

    // 输出层计算
    for (int i = 0; i < OUTPUT_NUM; i++) {
        double sum = 0.0;
        for (int j = 0; j < HIDDEN_NUM; j++) {
            sum += nn->hidden[j] * nn->output_weights[i][j];
        }
        nn->output[i] = sigmoid(sum);
    }
}

/* 反向传播 */
void backward(NeuralNetwork *nn, double target_value) {
    // 输出层误差计算
    double output_error[OUTPUT_NUM];
    for (int i = 0; i < OUTPUT_NUM; i++) {
        output_error[i] = (target_value - nn->output[i]) * sigmoid_derivative(nn->output[i]);
    }

    // 隐藏层误差计算
    double hidden_error[HIDDEN_NUM];
    for (int i = 0; i < HIDDEN_NUM; i++) {
        double sum = 0.0;
        for (int j = 0; j < OUTPUT_NUM; j++) {
            sum += output_error[j] * nn->output_weights[j][i];
        }
        hidden_error[i] = sum * sigmoid_derivative(nn->hidden[i]);
    }

    // 更新输出层权重
    for (int i = 0; i < OUTPUT_NUM; i++) {
        for (int j = 0; j < HIDDEN_NUM; j++) {
            nn->output_weights[i][j] += LEARNING_RATE * output_error[i] * nn->hidden[j];
        }
    }

    // 更新隐藏层权重
    for (int i = 0; i < HIDDEN_NUM; i++) {
        for (int j = 0; j < INPUT_NUM; j++) {
            nn->hidden_weights[i][j] += LEARNING_RATE * hidden_error[i] * nn->input[j];
        }
    }
}

/* 训练神经网络 */
void train(NeuralNetwork *nn, double input1, double input2, double target_value) {
    nn->input[0] = input1;
    nn->input[1] = input2;

    // 进行前向传播和反向传播
    forward(nn);
    backward(nn, target_value);
}

int main() {
    NeuralNetwork nn;
    double input1, input2, target_value;
    int iterations = 0;

    // 初始化权重
    for (int i = 0; i < HIDDEN_NUM; i++) {
        for (int j = 0; j < INPUT_NUM; j++) {
            nn.hidden_weights[i][j] = (double)rand() / RAND_MAX;
        }
    }
    for (int i = 0; i < OUTPUT_NUM; i++) {
        for (int j = 0; j < HIDDEN_NUM; j++) {
            nn.output_weights[i][j] = (double)rand() / RAND_MAX;
        }
    }

    // 训练神经网络
    do {
        input1 = (double)rand() / RAND_MAX;
        input2 = (double)rand() / RAND_MAX;
        target_value = input1 + input2;

        train(&nn, input1, input2, target_value);

        iterations++;
    } while (iterations < MAX_ITERATIONS && nn.output[0] - target_value > ERROR_THRESHOLD);

    // 打印训练结果
    printf("训练结果：\n");
    printf("输入1: %.2f, 输入2: %.2f, 目标值: %.2f, 输出值: %.2f\n", input1, input2, target_value, nn.output[0]);

    return 0;
}

以上是一个简单的bp算法的神经网络训练程序示例，其中定义了一个具有2个输入神经元、2个隐藏神经元和1个输出神经元的神经网络结构，并通过随机初始化权重和输入数据，训练神经网络，最终输出训练结果。

请注意，以上示例只是一个简单的实现程序，实际应用中可能需要进一步优化和改进。