基于C语言写神经网络算法
时间: 2023-12-15 16:47:13 浏览: 49
在C语言中实现神经网络算法可以分为以下几个步骤:
1. 定义神经网络结构:包括输入层、隐藏层和输出层的节点数、权值矩阵、偏置向量等参数。
2. 实现前向传播算法:基于输入数据和神经网络参数,计算出每个节点的输出值。
3. 实现反向传播算法:基于损失函数和前向传播的输出值,计算出每个节点的误差,并根据误差调整权值和偏置。
4. 使用梯度下降算法优化参数:根据反向传播算法计算出的梯度,按照一定的步长更新权值和偏置,使得模型拟合效果更好。
以下是一个简单的单层神经网络的实现代码示例:
```c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define INPUT_SIZE 3
#define OUTPUT_SIZE 1
#define HIDDEN_SIZE 4
#define EPOCHS 10000
#define LEARNING_RATE 0.1
double input[INPUT_SIZE][4] = {{0, 0, 1, 1}, {0, 1, 0, 1}, {1, 1, 1, 1}};
double output[OUTPUT_SIZE][4] = {{0, 1, 1, 0}};
double hidden[HIDDEN_SIZE];
double weights_ih[INPUT_SIZE][HIDDEN_SIZE];
double weights_ho[HIDDEN_SIZE][OUTPUT_SIZE];
double bias_h[HIDDEN_SIZE];
double bias_o[OUTPUT_SIZE];
double sigmoid(double x) {
return 1.0 / (1.0 + exp(-x));
}
void forward(double* input_data, double* output_data) {
// 计算输入层到隐藏层的输出
for (int i = 0; i < HIDDEN_SIZE; i++) {
hidden[i] = 0;
for (int j = 0; j < INPUT_SIZE; j++) {
hidden[i] += input_data[j] * weights_ih[j][i];
}
hidden[i] += bias_h[i];
hidden[i] = sigmoid(hidden[i]);
}
// 计算隐藏层到输出层的输出
for (int i = 0; i < OUTPUT_SIZE; i++) {
output_data[i] = 0;
for (int j = 0; j < HIDDEN_SIZE; j++) {
output_data[i] += hidden[j] * weights_ho[j][i];
}
output_data[i] += bias_o[i];
output_data[i] = sigmoid(output_data[i]);
}
}
void backward(double* input_data, double* output_data) {
double delta_o[OUTPUT_SIZE];
double delta_h[HIDDEN_SIZE];
// 计算输出层误差
for (int i = 0; i < OUTPUT_SIZE; i++) {
delta_o[i] = (output_data[i] - output[i][0]) * output_data[i] * (1 - output_data[i]);
}
// 计算隐藏层误差
for (int i = 0; i < HIDDEN_SIZE; i++) {
double error = 0;
for (int j = 0; j < OUTPUT_SIZE; j++) {
error += delta_o[j] * weights_ho[i][j];
}
delta_h[i] = error * hidden[i] * (1 - hidden[i]);
}
// 更新输出层权值和偏置
for (int i = 0; i < OUTPUT_SIZE; i++) {
for (int j = 0; j < HIDDEN_SIZE; j++) {
weights_ho[j][i] -= LEARNING_RATE * delta_o[i] * hidden[j];
}
bias_o[i] -= LEARNING_RATE * delta_o[i];
}
// 更新隐藏层权值和偏置
for (int i = 0; i < HIDDEN_SIZE; i++) {
for (int j = 0; j < INPUT_SIZE; j++) {
weights_ih[j][i] -= LEARNING_RATE * delta_h[i] * input_data[j];
}
bias_h[i] -= LEARNING_RATE * delta_h[i];
}
}
int main() {
// 初始化权值和偏置
for (int i = 0; i < INPUT_SIZE; i++) {
for (int j = 0; j < HIDDEN_SIZE; j++) {
weights_ih[i][j] = (double) rand() / RAND_MAX;
}
}
for (int i = 0; i < HIDDEN_SIZE; i++) {
for (int j = 0; j < OUTPUT_SIZE; j++) {
weights_ho[i][j] = (double) rand() / RAND_MAX;
}
}
for (int i = 0; i < HIDDEN_SIZE; i++) {
bias_h[i] = (double) rand() / RAND_MAX;
}
for (int i = 0; i < OUTPUT_SIZE; i++) {
bias_o[i] = (double) rand() / RAND_MAX;
}
// 训练模型
for (int epoch = 0; epoch < EPOCHS; epoch++) {
double total_loss = 0;
for (int i = 0; i < 4; i++) {
double input_data[INPUT_SIZE];
double output_data[OUTPUT_SIZE];
for (int j = 0; j < INPUT_SIZE; j++) {
input_data[j] = input[j][i];
}
forward(input_data, output_data);
backward(input_data, output_data);
total_loss += pow(output_data[0] - output[i][0], 2);
}
printf("Epoch %d, loss = %lf\n", epoch, total_loss);
}
// 测试模型
double input_data[INPUT_SIZE] = {0, 0, 1};
double output_data[OUTPUT_SIZE];
forward(input_data, output_data);
printf("Predicted output: %lf\n", output_data[0]);
return 0;
}
```
该示例代码实现了一个单层神经网络,输入为3维向量,输出为1维标量,隐藏层有4个节点。其中使用sigmoid作为激活函数,损失函数为平方误差。在训练过程中,使用随机梯度下降算法不断更新权值和偏置,使得模型能够拟合训练数据。最后,使用模型对新的输入进行预测,并输出预测结果。