BP神经网络代码用c语言写出来。

以下是一个基于BP算法的神经网络的C语言实现，用于解决二元函数分类问题：

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

#define N 100 // 样本数量
#define M 2 // 输入层神经元数量
#define L 1 // 输出层神经元数量
#define H 5 // 隐藏层神经元数量

double alpha = 0.1; // 学习速率

double x[N][M] = {0}; // 输入样本
double y[N][L] = {0}; // 输出样本

double v[M+1][H] = {0}; // 输入层到隐藏层的权重矩阵
double w[H+1][L] = {0}; // 隐藏层到输出层的权重矩阵

double b[H+1] = {0}; // 隐藏层神经元的偏置
double c[L+1] = {0}; // 输出层神经元的偏置

double z[N][H+1] = {0}; // 隐藏层输出
double u[N][L+1] = {0}; // 输出层输出

double sigmoid(double x) {
    return 1.0 / (1.0 + exp(-x));
}

void train() {
    int i, j, k, t;
    double delta, sum;
    for (t = 0; t < 1000; t++) { // 迭代次数
        for (k = 0; k < N; k++) {
            // 前向传播
            for (j = 0; j < H; j++) {
                sum = 0;
                for (i = 0; i < M; i++) {
                    sum += x[k][i] * v[i][j];
                }
                z[k][j+1] = sigmoid(sum + b[j+1]);
            }
            for (j = 0; j < L; j++) {
                sum = 0;
                for (i = 0; i < H; i++) {
                    sum += z[k][i+1] * w[i+1][j];
                }
                u[k][j+1] = sigmoid(sum + c[j+1]);
            }
            // 反向传播
            for (j = 0; j < L; j++) {
                delta = (y[k][j] - u[k][j+1]) * u[k][j+1] * (1 - u[k][j+1]);
                for (i = 0; i < H; i++) {
                    w[i+1][j] += alpha * delta * z[k][i+1];
                }
                c[j+1] += alpha * delta;
            }
            for (j = 0; j < H; j++) {
                sum = 0;
                for (i = 0; i < L; i++) {
                    sum += (y[k][i] - u[k][i+1]) * u[k][i+1] * (1 - u[k][i+1]) * w[j+1][i];
                }
                delta = sum * z[k][j+1] * (1 - z[k][j+1]);
                for (i = 0; i < M; i++) {
                    v[i][j] += alpha * delta * x[k][i];
                }
                b[j+1] += alpha * delta;
            }
        }
    }
}

int classify(double *input) {
    double z[H+1] = {0};
    double u[L+1] = {0};
    int i, j;
    // 前向传播
    for (j = 0; j < H; j++) {
        double sum = 0;
        for (i = 0; i < M; i++) {
            sum += input[i] * v[i][j];
        }
        z[j+1] = sigmoid(sum + b[j+1]);
    }
    for (j = 0; j < L; j++) {
        double sum = 0;
        for (i = 0; i < H; i++) {
            sum += z[i+1] * w[i+1][j];
        }
        u[j+1] = sigmoid(sum + c[j+1]);
    }
    // 输出分类结果
    if (u[1] >= 0.5) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    srand(time(NULL));
    // 生成随机样本
    int i, j;
    for (i = 0; i < N; i++) {
        for (j = 0; j < M; j++) {
            x[i][j] = rand() % 2;
        }
        y[i][0] = x[i][0] ^ x[i][1];
    }
    // 训练神经网络
    train();
    // 分类测试
    int correct = 0;
    for (i = 0; i < 1000; i++) {
        double input[M] = {rand() % 2, rand() % 2};
        int output = classify(input);
        int expected = input[0] ^ input[1];
        if (output == expected) {
            correct++;
        }
    }
    printf("Accuracy: %lf\n", (double)correct / 1000);
    return 0;
}

该代码实现了一个基于BP算法的神经网络，用于解决二元函数分类问题。首先通过随机生成样本数据，并使用 `train()` 函数训练神经网络。然后通过 `classify()` 函数对输入样本进行分类，并输出分类结果。最后，通过对随机测试样本的分类结果进行统计，计算神经网络的分类准确率。