基于BP神经网络的人脸识别C语言代码

以下是基于BP神经网络的人脸识别的C语言代码，仅供参考：

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

#define INPUT_NUM 1024   // 输入层节点数
#define HIDDEN_NUM 20    // 隐层节点数
#define OUTPUT_NUM 2     // 输出层节点数
#define ALPHA 0.1        // 学习速率
#define EPOCH 2000       // 迭代次数

int load_data(char* filename, double data[INPUT_NUM][OUTPUT_NUM])
{
    FILE* fp;
    int i, j, num;

    fp = fopen(filename, "r");
    if (fp == NULL) {
        printf("Can't open file %s\n", filename);
        return -1;
    }

    fscanf(fp, "%d", &num);
    for (i = 0; i < num; i++) {
        for (j = 0; j < INPUT_NUM; j++) {
            fscanf(fp, "%lf", &data[i][j]);
        }
        fscanf(fp, "%lf", &data[i][INPUT_NUM]);
    }

    fclose(fp);

    return num;
}

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

void forward(double input[INPUT_NUM], double output[OUTPUT_NUM], double w1[INPUT_NUM][HIDDEN_NUM], double w2[HIDDEN_NUM][OUTPUT_NUM], double b1[HIDDEN_NUM], double b2[OUTPUT_NUM])
{
    int i, j;
    double hidden[HIDDEN_NUM] = { 0 };
    double sum;

    // 计算隐层节点的值
    for (i = 0; i < HIDDEN_NUM; i++) {
        sum = 0.0;
        for (j = 0; j < INPUT_NUM; j++) {
            sum += input[j] * w1[j][i];
        }
        hidden[i] = sigmoid(sum + b1[i]);
    }

    // 计算输出节点的值
    for (i = 0; i < OUTPUT_NUM; i++) {
        sum = 0.0;
        for (j = 0; j < HIDDEN_NUM; j++) {
            sum += hidden[j] * w2[j][i];
        }
        output[i] = sigmoid(sum + b2[i]);
    }
}

void backward(double input[INPUT_NUM], double output[OUTPUT_NUM], double w1[INPUT_NUM][HIDDEN_NUM], double w2[HIDDEN_NUM][OUTPUT_NUM], double b1[HIDDEN_NUM], double b2[OUTPUT_NUM], double teach[OUTPUT_NUM])
{
    int i, j;
    double hidden[HIDDEN_NUM] = { 0 };
    double delta_o[OUTPUT_NUM] = { 0 };
    double delta_h[HIDDEN_NUM] = { 0 };
    double sum;

    // 计算误差信号
    for (i = 0; i < OUTPUT_NUM; i++) {
        delta_o[i] = output[i] * (1 - output[i]) * (teach[i] - output[i]);
    }

    // 计算隐层的误差信号
    for (i = 0; i < HIDDEN_NUM; i++) {
        sum = 0.0;
        for (j = 0; j < OUTPUT_NUM; j++) {
            sum += delta_o[j] * w2[i][j];
        }
        delta_h[i] = hidden[i] * (1 - hidden[i]) * sum;
    }

    // 更新输出层权值和偏置
    for (i = 0; i < OUTPUT_NUM; i++) {
        for (j = 0; j < HIDDEN_NUM; j++) {
            w2[j][i] += ALPHA * delta_o[i] * hidden[j];
        }
        b2[i] += ALPHA * delta_o[i];
    }

    // 更新隐层权值和偏置
    for (i = 0; i < HIDDEN_NUM; i++) {
        for (j = 0; j < INPUT_NUM; j++) {
            w1[j][i] += ALPHA * delta_h[i] * input[j];
        }
        b1[i] += ALPHA * delta_h[i];
    }
}

double test(double input[INPUT_NUM], double output[OUTPUT_NUM], double w1[INPUT_NUM][HIDDEN_NUM], double w2[HIDDEN_NUM][OUTPUT_NUM], double b1[HIDDEN_NUM], double b2[OUTPUT_NUM])
{
    int i, j;
    double hidden[HIDDEN_NUM] = { 0 };
    double sum;

    // 计算隐层节点的值
    for (i = 0; i < HIDDEN_NUM; i++) {
        sum = 0.0;
        for (j = 0; j < INPUT_NUM; j++) {
            sum += input[j] * w1[j][i];
        }
        hidden[i] = sigmoid(sum + b1[i]);
    }

    // 计算输出节点的值
    for (i = 0; i < OUTPUT_NUM; i++) {
        sum = 0.0;
        for (j = 0; j < HIDDEN_NUM; j++) {
            sum += hidden[j] * w2[j][i];
        }
        output[i] = sigmoid(sum + b2[i]);
    }

    return output[0];
}

int main(int argc, char** argv)
{
    double input[INPUT_NUM];
    double output[OUTPUT_NUM] = { 0 };
    double w1[INPUT_NUM][HIDDEN_NUM] = { 0 };
    double w2[HIDDEN_NUM][OUTPUT_NUM] = { 0 };
    double b1[HIDDEN_NUM] = { 0 };
    double b2[OUTPUT_NUM] = { 0 };
    double teach[OUTPUT_NUM];
    double data[INPUT_NUM][OUTPUT_NUM];
    int num, i, j, k;
    double err, err_sum;

    if (argc != 4) {
        printf("Usage: %s train_data_file test_data_file model_file\n", argv[0]);
        return -1;
    }

    // 加载训练数据
    num = load_data(argv[1], data);

    // 随机初始化权值和偏置
    for (i = 0; i < INPUT_NUM; i++) {
        for (j = 0; j < HIDDEN_NUM; j++) {
            w1[i][j] = (double)rand() / RAND_MAX - 0.5;
        }
    }
    for (i = 0; i < HIDDEN_NUM; i++) {
        for (j = 0; j < OUTPUT_NUM; j++) {
            w2[i][j] = (double)rand() / RAND_MAX - 0.5;
        }
    }
    for (i = 0; i < HIDDEN_NUM; i++) {
        b1[i] = (double)rand() / RAND_MAX - 0.5;
    }
    for (i = 0; i < OUTPUT_NUM; i++) {
        b2[i] = (double)rand() / RAND_MAX - 0.5;
    }

    // 训练模型
    for (k = 0; k < EPOCH; k++) {
        err_sum = 0.0;
        for (i = 0; i < num; i++) {
            for (j = 0; j < INPUT_NUM; j++) {
                input[j] = data[i][j];
            }
            teach[0] = data[i][INPUT_NUM];
            teach[1] = 1 - data[i][INPUT_NUM];
            forward(input, output, w1, w2, b1, b2);
            backward(input, output, w1, w2, b1, b2, teach);
            err = (teach[0] - output[0]) * (teach[0] - output[0]);
            err_sum += err;
        }
        printf("Epoch %d: err=%lf\n", k, err_sum);
    }

    // 保存模型
    FILE* fp = fopen(argv[3], "wb");
    fwrite(w1, sizeof(double), INPUT_NUM * HIDDEN_NUM, fp);
    fwrite(w2, sizeof(double), HIDDEN_NUM * OUTPUT_NUM, fp);
    fwrite(b1, sizeof(double), HIDDEN_NUM, fp);
    fwrite(b2, sizeof(double), OUTPUT_NUM, fp);
    fclose(fp);

    // 加载测试数据
    num = load_data(argv[2], data);

    // 加载模型
    fp = fopen(argv[3], "rb");
    fread(w1, sizeof(double), INPUT_NUM * HIDDEN_NUM, fp);
    fread(w2, sizeof(double), HIDDEN_NUM * OUTPUT_NUM, fp);
    fread(b1, sizeof(double), HIDDEN_NUM, fp);
    fread(b2, sizeof(double), OUTPUT_NUM, fp);
    fclose(fp);

    // 测试模型
    int correct = 0;
    for (i = 0; i < num; i++) {
        for (j = 0; j < INPUT_NUM; j++) {
            input[j] = data[i][j];
        }
        teach[0] = data[i][INPUT_NUM];
        teach[1] = 1 - data[i][INPUT_NUM];
        double result = test(input, output, w1, w2, b1, b2);
        if ((result > 0.5 && teach[0] == 1) || (result < 0.5 && teach[1] == 1)) {
            correct++;
        }
    }
    printf("Accuracy: %lf\n", (double)correct / num);

    return 0;
}