modernC++手撸任意层神经网络22前向传播反向传播&梯度下降等23代码补全的例子0901b

以下神经网络代码,请添加输入:{{1,0},{1,1}},输出{1,0};添加反向传播,梯度下降等训练!

以下神经网络代码,请添加输入:{{1,0},{1,1}},输出{1,0};添加反向传播,梯度下降等训练!
#include 
#include
#include
#include
#include
 
using namespace std;
 
Eigen::MatrixXd forwardPropagation(const std::vector& weights, const Eigen::VectorXd& input) {
    Eigen::MatrixXd output = input;
    for (const auto& w : weights) {
        output.conservativeResize(output.rows(), 1);  // Make sure it's a column vector
        output = w * output;
        output = output.unaryExpr([](double x) { return 1.0 / (1.0 + std::exp(-x)); }); // Activation function (sigmoid)
    }
    return output;
}//Eigen::MatrixXd forwardPropagation(
 
int main()
{
 
    // Read network architecture from file
    std::vector<int> layers = readLayers("\\s.txt");
 
    // Initialize weights randomly
    std::default_random_engine generator;
    std::normal_distribution<double> distribution(0.0, 1.0);
    std::vector weights;
 
    for (size_t i = 0; i < layers.size() - 1; ++i) {//for110i
        Eigen::MatrixXd w(layers[i + 1], layers[i]);
        w = w.unaryExpr([&](double x) { return distribution(generator); });
        weights.push_back(w);
    }//for110i
 
    // Initialize input (example)
    Eigen::VectorXd input(layers[0]);
    input << 0.5, 0.6;
 
    // Perform forward propagation
    Eigen::MatrixXd output = forwardPropagation(weights, input);
 
    std::cout << "Output:\n" << output << endl;
 
    std::cout << "Hello World!\n";
}//main(

硬盘 本盘，根目录的：

s1.txt文本文件中的内容：

{2,8,4,1}

// modernC++手撸任意层神经网络22前向传播&反向传播等神经网络230901b.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include 
#include
#include
#include
#include     //ifstream file1(fileName);//getline(file1, line01);
 
using namespace std;
 
vector<int> readLayers(const string& fileName) {
    ifstream file1(fileName);
    string line01;
    vector<int> layers1;
 
    getline(file1, line01);
    //---------------------------------
    //找大括号位置
    size_t start_pos = line01.find('{');
    size_t end_pos = line01.find('}');
 
    //确保找到大括号
    if (string::npos == start_pos || string::npos == end_pos || start_pos >= end_pos) {
        cout << "没有大括号!" << endl;
    }//if110
 
    // 截取大括号之间的内容
    string content = line01.substr(start_pos + 1, end_pos - start_pos - 1);
//    cout << "Line55:" << content << endl;
 
    // 使用istringstream和getline进行分割
    std::istringstream ss(content);
    std::string token;
    while (std::getline(ss, token, ',')) {
        // 使用stoi将字符串转换为整数，并添加到结果vector中
        layers1.push_back(std::stoi(token));
        cout << std::stoi(token) << std::endl;
    }
 
    return layers1;
 
}//vector readLayers(
 
Eigen::MatrixXd forwardPropagation(const std::vector& weights, const Eigen::VectorXd& input) {
    Eigen::MatrixXd output = input;
    for (const auto& w : weights) {
        output.conservativeResize(output.rows(), 1);  // Make sure it's a column vector
        output = w * output;
        output = output.unaryExpr([](double x) { return 1.0 / (1.0 + std::exp(-x)); }); // Activation function (sigmoid)
    }
    return output;
}//Eigen::MatrixXd forwardPropagation(
 
//重载
Eigen::MatrixXd forwardPropagation(const std::vector& weights, const Eigen::VectorXd& input, std::vector& activations) {
    Eigen::MatrixXd output = input;
    activations.push_back(output);
    for (const auto& w : weights) {
        output.conservativeResize(output.rows(), 1);  // Make sure it's a column vector
        output = w * output;
        output = output.unaryExpr([](double x) { return 1.0 / (1.0 + std::exp(-x)); }); // Activation function (sigmoid)
        activations.push_back(output);
    }
    return output;
}
 
Eigen::MatrixXd sigmoidDerivative(const Eigen::MatrixXd& x) {
    return x.unaryExpr([](double y) { return y * (1.0 - y); });
}
 
void backwardPropagation(const Eigen::MatrixXd& predicted, const Eigen::MatrixXd& target, const std::vector& activations, const std::vector& weights, std::vector& gradients) {
    Eigen::MatrixXd delta = (predicted - target).cwiseProduct(sigmoidDerivative(activations.back()));
    gradients.push_back(delta * activations[activations.size() - 2].transpose());
 
    for (int i = weights.size() - 2; i >= 0; --i) {
        delta = (weights[i + 1].transpose() * delta).cwiseProduct(sigmoidDerivative(activations[i + 1]));
        gradients.push_back(delta * activations[i].transpose());
    }
    std::reverse(gradients.begin(), gradients.end());
}//void backwardPropagation(
 
 
void Loss_backwardPropagation(const Eigen::MatrixXd& predicted, const Eigen::MatrixXd& target, const std::vector& activations, const std::vector& weights, std::vector& gradients) {
    Eigen::MatrixXd delta = (predicted - target);
    double sum_of_squares = delta.array().square().sum();
    std::cout << "Sum of squares of all elements: " << sum_of_squares << std::endl;
 
}//void backwardPropagation(
 
 
int main()
{
 
    // Read network architecture from file
    std::vector<int> layers = readLayers("\\s1.txt");
 
    // Initialize weights randomly
    std::default_random_engine generator;
    std::normal_distribution<double> distribution(0.0, 1.0);
    std::vector weights;
 
    for (size_t i = 0; i < layers.size() - 1; ++i) {//for110i
        Eigen::MatrixXd w(layers[i + 1], layers[i]);
        w = w.unaryExpr([&](double x) { return distribution(generator); });
        weights.push_back(w);
    }//for110i
 
    // Initialize input (example)
    Eigen::VectorXd input(layers[0]);
    input << 1, 0;// 0.5, 0.6;
 
    // Perform forward propagation
    Eigen::MatrixXd output = forwardPropagation(weights, input);
 
    std::cout << "Output:\n" << output << endl;
 
    std::cout << "Hello World!\n";
 
    //----------------------------------------------------
    // Training data
    vector inputs = {
        (Eigen::VectorXd(2) << 1, 0).finished(),
        (Eigen::VectorXd(2) << 0,0).finished(),
        (Eigen::VectorXd(2) << 0,1).finished(),
        (Eigen::VectorXd(2) << 1, 1).finished(),
    };
 
    vector targets = {
        (Eigen::VectorXd(1) << 1).finished(),
        (Eigen::VectorXd(1) << 0).finished(),
        (Eigen::VectorXd(1) << 1).finished(),
        (Eigen::VectorXd(1) << 0).finished()
    };
 
    double learningRate = 0.01;
    int epochs = 50000;
 
    for (int epoch = 0; epoch < epochs; ++epoch) {
        for (size_t i = 0; i < inputs.size(); ++i) {
            std::vector activations;
            Eigen::MatrixXd output = forwardPropagation(weights, inputs[i], activations);
 
            std::vector gradients;
            backwardPropagation(output, targets[i], activations, weights, gradients);
 
            for (size_t j = 0; j < weights.size(); ++j) {
                weights[j] -= learningRate * gradients[j];
            }//for3300j
 
            if (0 == epoch % 1000) {//if4400
                std::vector activations;
                std::vector gradients;
                Loss_backwardPropagation(output, targets[i], activations, weights, gradients);
            }//if4400
 
        }//for2200i
        
    }//for110epoch
 
    // Testing trained model
    for (size_t i = 0; i < inputs.size(); ++i) {
        std::vector activations;
        Eigen::MatrixXd output = forwardPropagation(weights, inputs[i], activations);
        std::cout << "Input:\n" << inputs[i] << "\nOutput:\n" << output << "\n";
    }
 
    return 0;
 
    //=======================================================
}//main(