NeuralNetwork.cpp

#include "NeuralNetwork.h"

#include <algorithm>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <random>

NeuralNetwork::NeuralNetwork(const std::vector<int>& hiddenLayers, double lr)
    : learningRate(lr),
      xMin(std::numeric_limits<double>::max()),
      xMax(std::numeric_limits<double>::lowest()),
      yMin(std::numeric_limits<double>::max()),
      yMax(std::numeric_limits<double>::lowest()) {
    // 构建网络结构：输入层 + 隐藏层 + 输出层
    layers.clear();
    layers.push_back(1);
    for (size_t i = 0; i < hiddenLayers.size(); ++i) {
        layers.push_back(hiddenLayers[i]);
    }
    layers.push_back(1);

    // 固定随机种子，便于复现实验结果
    std::mt19937 rng(42);
    std::uniform_real_distribution<double> dist(-0.5, 0.5);

    // 初始化权重与偏置
    for (size_t layer = 0; layer + 1 < layers.size(); ++layer) {
        int inSize = layers[layer];
        int outSize = layers[layer + 1];
        std::vector<std::vector<double> > w(outSize, std::vector<double>(inSize));
        std::vector<double> b(outSize, 0.0);
        for (int i = 0; i < outSize; ++i) {
            for (int j = 0; j < inSize; ++j) {
                w[i][j] = dist(rng);
            }
            b[i] = dist(rng);
        }
        weights.push_back(w);
        biases.push_back(b);
    }
}

bool NeuralNetwork::loadData(const std::string& filename) {
    // 读取数据并统计最大最小值
    data.clear();
    xMin = std::numeric_limits<double>::max();
    xMax = std::numeric_limits<double>::lowest();
    yMin = std::numeric_limits<double>::max();
    yMax = std::numeric_limits<double>::lowest();

    std::ifstream file(filename.c_str());
    if (!file.is_open()) {
        return false;
    }

    double x = 0.0;
    double y = 0.0;
    while (file >> x >> y) {
        if (x < xMin) {
            xMin = x;
        }
        if (x > xMax) {
            xMax = x;
        }
        if (y < yMin) {
            yMin = y;
        }
        if (y > yMax) {
            yMax = y;
        }
        data.push_back(std::vector<double>(2));
        data.back()[0] = x;
        data.back()[1] = y;
    }

    return !data.empty();
}

void NeuralNetwork::train(int epochs) {
    if (data.empty()) {
        return;
    }
    // 防止除零
    if (xMax == xMin) {
        xMax = xMin + 1.0;
    }
    if (yMax == yMin) {
        yMax = yMin + 1.0;
    }

    // 预先归一化训练数据，避免重复计算
    std::vector<std::vector<double> > normalizedData(data.size(), std::vector<double>(2, 0.0));
    for (size_t i = 0; i < data.size(); ++i) {
        normalizedData[i][0] = normalize(data[i][0], xMin, xMax);
        normalizedData[i][1] = normalize(data[i][1], yMin, yMax);
    }

    std::vector<std::vector<double> > outputs(layers.size());
    std::vector<std::vector<double> > deltas(layers.size());

    // 按样本逐条训练，并在每轮打乱样本顺序
    std::vector<size_t> indices(data.size());
    for (size_t i = 0; i < data.size(); ++i) {
        indices[i] = i;
    }
    std::mt19937 rng(42);
    for (int epoch = 0; epoch < epochs; ++epoch) {
        std::shuffle(indices.begin(), indices.end(), rng);
        for (size_t pos = 0; pos < indices.size(); ++pos) {
            size_t sample = indices[pos];
            double x = normalizedData[sample][0];
            double y = normalizedData[sample][1];

            // 前向传播
            outputs[0].assign(1, x);
            for (size_t layer = 0; layer + 1 < layers.size(); ++layer) {
                int outSize = layers[layer + 1];
                outputs[layer + 1].assign(outSize, 0.0);
                for (int i = 0; i < outSize; ++i) {
                    double sum = biases[layer][i];
                    for (int j = 0; j < layers[layer]; ++j) {
                        sum += weights[layer][i][j] * outputs[layer][j];
                    }
                    if (layer + 1 == layers.size() - 1) {
                        // 输出层使用线性激活
                        outputs[layer + 1][i] = sum;
                    } else {
                        outputs[layer + 1][i] = activate(sum);
                    }
                }
            }

            // 反向传播：输出层误差
            size_t last = layers.size() - 1;
            deltas[last].assign(layers[last], 0.0);
            deltas[last][0] = outputs[last][0] - y;

            // 隐藏层误差
            for (size_t layer = last - 1; layer > 0; --layer) {
                deltas[layer].assign(layers[layer], 0.0);
                for (int i = 0; i < layers[layer]; ++i) {
                    double sum = 0.0;
                    for (int k = 0; k < layers[layer + 1]; ++k) {
                        sum += weights[layer][k][i] * deltas[layer + 1][k];
                    }
                    deltas[layer][i] = activateDerivative(outputs[layer][i]) * sum;
                }
            }

            // 更新权重与偏置
            for (size_t layer = 0; layer + 1 < layers.size(); ++layer) {
                for (int i = 0; i < layers[layer + 1]; ++i) {
                    for (int j = 0; j < layers[layer]; ++j) {
                        weights[layer][i][j] -= learningRate * deltas[layer + 1][i] * outputs[layer][j];
                    }
                    biases[layer][i] -= learningRate * deltas[layer + 1][i];
                }
            }
        }
    }
}

double NeuralNetwork::predict(double x) const {
    // 与训练保持一致，防止归一化除零
    double safeXMax = xMax;
    double safeYMax = yMax;
    if (safeXMax == xMin) {
        safeXMax = xMin + 1.0;
    }
    if (safeYMax == yMin) {
        safeYMax = yMin + 1.0;
    }
    // 前向传播得到预测值
    double input = normalize(x, xMin, safeXMax);
    std::vector<double> current(1, input);

    for (size_t layer = 0; layer + 1 < layers.size(); ++layer) {
        int outSize = layers[layer + 1];
        std::vector<double> next(outSize, 0.0);
        for (int i = 0; i < outSize; ++i) {
            double sum = biases[layer][i];
            for (int j = 0; j < layers[layer]; ++j) {
                sum += weights[layer][i][j] * current[j];
            }
            if (layer + 1 == layers.size() - 1) {
                // 输出层线性
                next[i] = sum;
            } else {
                next[i] = activate(sum);
            }
        }
        current = next;
    }

    return denormalize(current[0], yMin, safeYMax);
}

void NeuralNetwork::printParameters() const {
    std::cout << "归一化参数：" << std::endl;
    std::cout << "x最小值=" << xMin << "，x最大值=" << xMax << std::endl;
    std::cout << "y最小值=" << yMin << "，y最大值=" << yMax << std::endl;

    std::cout << "网络参数：" << std::endl;
    for (size_t layer = 0; layer < weights.size(); ++layer) {
        std::cout << "第 " << layer + 1 << " 层权重与偏置：" << std::endl;
        for (size_t i = 0; i < weights[layer].size(); ++i) {
            std::cout << "  神经元 " << i + 1 << " 权重：";
            for (size_t j = 0; j < weights[layer][i].size(); ++j) {
                std::cout << " " << std::fixed << std::setprecision(6) << weights[layer][i][j];
            }
            std::cout << "，偏置=" << std::fixed << std::setprecision(6) << biases[layer][i] << std::endl;
        }
    }
}

double NeuralNetwork::normalize(double value, double minVal, double maxVal) const {
    return (value - minVal) / (maxVal - minVal);
}

double NeuralNetwork::denormalize(double value, double minVal, double maxVal) const {
    return value * (maxVal - minVal) + minVal;
}

double NeuralNetwork::activate(double x) const {
    return std::tanh(x);
}

double NeuralNetwork::activateDerivative(double y) const {
    return 1.0 - y * y;
}