C++最易读手撸神经网络两隐藏层(任意Nodes每层)梯度下降230821a

这篇具有很好参考价值的文章主要介绍了C++最易读手撸神经网络两隐藏层(任意Nodes每层)梯度下降230821a。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

// c++神经网络手撸20梯度下降22_230820a.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include<iostream>
#include<vector>
#include<iomanip> // setprecision
#include<sstream> // getline  stof()
#include<fstream>

using namespace std;
//
float Loss误差损失之和001 = 0.0;

class NN神经网络NN {

private: 
    const int inputNode输入层之节点数s, hidden01Node隐藏层01结点数s, hidden22Nodes, outputNode输出层结点数s;

    /*
       vector<vector<float>> 输入层到第1隐藏层之权重矩阵, 隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏22到输出层de权重矩阵; //这些变量为矩阵
       vector<float> 隐藏层1偏置1, 隐藏层2偏置2, O输出层偏置;
       vector<float>隐藏层1数据1, 隐藏层2数据2, 输出数据output; */

       void initLayer每一层的WeightsAndBiases(vector<vector<float>>& weights权重, vector<float>& biases偏置)
       {
           for (size_t i = 0; i < weights权重.size(); ++i) {//for110i
               for (size_t j = 0; j < weights权重[0].size(); ++j) { weights权重[i][j] = ((rand() % 2) - 1) / 1.0; }
               biases偏置[i] = ((rand() % 2) - 1) / 1.0;

           }//for110i
       }//void initLayerWeightsAndBiases(

       void initWeightsAndBiases初始化权重和偏置矩阵() {
           initLayer每一层的WeightsAndBiases(输入层到第1隐藏层之权重矩阵, 隐藏层1偏置1);
           initLayer每一层的WeightsAndBiases(隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏层2偏置2);
           initLayer每一层的WeightsAndBiases(隐藏22到输出层de权重矩阵 , O输出层偏置);
       }

       //激活函数-激活的过程
        vector<float> activate(const  vector<float>& inputs, const  vector< vector<float>>& weights, const  vector<float>& biases) {
            vector<float> layer_output(weights.size(), 0.0);
               for (size_t i = 0; i < weights.size(); i++) {
                       for (size_t j = 0; j < inputs.size(); j++) {
                           layer_output[i] += inputs[j] * weights[i][j];
                       }//for220j
                   layer_output[i] += biases[i];
                   layer_output[i] = sigmoid(layer_output[i]);
               }//for110i
           return layer_output;
       }//vector<float> activate

        //subtract求差:两个 向量的差
         vector<float> subtract(const  vector<float>& a, const  vector<float>& b) {
             vector<float> result(a.size(), 0.0);
            for (size_t i = 0; i < a.size(); i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }//vector<float>subtract

         //dotT点乘
         vector<float> dotT(const  vector<float>& a, const  vector< vector<float>>& b) {
             vector<float> result(b[0].size(), 0.0);
            for (size_t i = 0; i < b[0].size(); i++) {
                for (size_t j = 0; j < a.size(); j++) {
                    result[i] += a[j] * b[j][i];
                }
            }
            return result;
        }

        //更新权重矩阵s(们), 和偏置(向量)S们
        void updateWeights(const  vector<float>& inputs, const  vector<float>& errors, const  vector<float>& outputs,
             vector< vector<float>>& weights,  vector<float>& biases, float lr) {
            for (size_t i = 0; i < weights.size(); i++) {
                for (size_t j = 0; j < weights[0].size(); j++) {
                    weights[i][j] += lr * errors[i] * sigmoid导函数prime(outputs[i]) * inputs[j];
                }
                biases[i] += lr * errors[i] * sigmoid导函数prime(outputs[i]);
            }
        }//void updateWeights(


public:

    vector<vector<float>> 输入层到第1隐藏层之权重矩阵, 隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏22到输出层de权重矩阵; //这些变量为矩阵
    vector<float> 隐藏层1偏置1, 隐藏层2偏置2, O输出层偏置;
    vector<float>隐藏层1数据1, 隐藏层2数据2, 输出数据output;

    NN神经网络NN(int inputNode输入层之节点数s, int hidden01Node隐藏层01结点数s, int hidden22Nodes, int outputNode输出层结点数s)
        :inputNode输入层之节点数s(inputNode输入层之节点数s), hidden01Node隐藏层01结点数s(hidden01Node隐藏层01结点数s), hidden22Nodes(hidden22Nodes), outputNode输出层结点数s(outputNode输出层结点数s)
    {
                srand(time(NULL));

                //初始换权重矩阵
                输入层到第1隐藏层之权重矩阵.resize(hidden01Node隐藏层01结点数s, vector<float>(inputNode输入层之节点数s));
                隐藏层1到第二隐藏层2之权重矩阵1to2.resize(hidden22Nodes, vector<float>(hidden01Node隐藏层01结点数s));
                隐藏22到输出层de权重矩阵.resize(outputNode输出层结点数s, vector<float>(hidden22Nodes));//

                隐藏层1偏置1.resize(hidden01Node隐藏层01结点数s);
                隐藏层2偏置2.resize(hidden22Nodes);
                O输出层偏置.resize(outputNode输出层结点数s);

                initWeightsAndBiases初始化权重和偏置矩阵();

    }//NN神经网络NN(i

        //sigmoid激活函数及导数
        float sigmoid(float x){ return 1.0 / (1.0 + exp(-x)); }
        float sigmoid导函数prime(float x) { return x * (1 - x); }

        //Forward前向传播
        vector<float> predict(const vector<float>& input输入数据) {

            //用激活函数sigmoid-激活的过程
            隐藏层1数据1 = activate(input输入数据, 输入层到第1隐藏层之权重矩阵, 隐藏层1偏置1); //激活函数
            // 第一隐藏层到第二隐藏层
            隐藏层2数据2 = activate(隐藏层1数据1, 隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏层2偏置2);//hidden1, wh1h2, bias_h2);

            // 第二隐藏层到输出层
            输出数据output = activate(隐藏层2数据2, 隐藏22到输出层de权重矩阵, O输出层偏置);// , wh2o, bias_o);

            return 输出数据output;

        }//vector<float>predict(


         // 反向传播//Backpropagation
        void train(const  vector<float>& inputs, const  vector<float>& target目标数据s, float lr学习率) {
             vector<float> output尝试的输出数据s = predict(inputs);

            // 输出层误差
             vector<float> output_error输出误差s = subtract(target目标数据s, output尝试的输出数据s);//
             Loss误差损失之和001 = 0.0;
            for (int ii = 0; ii < outputNode输出层结点数s; ++ii) { Loss误差损失之和001 += fabs(output_error输出误差s[ii]); }
            //=========================================================================

            // 隐藏层2误差
             vector<float> hidden2_errors = dotT(output_error输出误差s, 隐藏22到输出层de权重矩阵);

            // 隐藏层1误差
             vector<float> hidden1_errors = dotT(hidden2_errors, 隐藏层1到第二隐藏层2之权重矩阵1to2);

            // 更新权重: 隐藏层2到输出层(的权重矩阵
            updateWeights(隐藏层2数据2,   output_error输出误差s, output尝试的输出数据s, 隐藏22到输出层de权重矩阵, O输出层偏置, lr学习率);

            // 更新权重: 隐藏层1到隐藏层2
            updateWeights(隐藏层1数据1,   hidden2_errors, 隐藏层2数据2, 隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏层2偏置2, lr学习率);

            // 更新权重: 输入层到隐藏层1的权重矩阵)
            updateWeights(inputs,   hidden1_errors, 隐藏层1数据1, 输入层到第1隐藏层之权重矩阵, 隐藏层1偏置1, lr学习率);
        }// void train(
    // // 反向传播//Backpropagation

};//class NN神经网络NN {


//----------------------------------------------------------------------------------------
void writeVectorToFile(const std::vector<float>& A, const std::string& fileName) {
    std::ofstream outFile(fileName);
    if (outFile.is_open()) {
        for (float value : A) {
            outFile << value << std::endl;
        }
        outFile.close();
    }
    else {
        std::cerr << "Unable to open file for writing: " << fileName << std::endl;
    }
}//writeVectorToFile

void readVectorFromFile(std::vector<float>& B, const std::string& fileName) {
    std::ifstream inFile(fileName);
    float value;
    if (inFile.is_open()) {
        while (inFile >> value) {
            B.push_back(value);
        }
        inFile.close();
    }
    else {
        std::cerr << "Unable to open file for reading: " << fileName << std::endl;
    }
}//readVectorFromFile

#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <sstream>

void writeToFile( const std::vector<std::vector<float>>& A , const std::string& filename) {
    std::ofstream file(filename);
    if (!file) {
        std::cerr << "Error opening file for writing: " << filename << std::endl;
        return;
    }

    for (const auto& row : A) {
        for (size_t i = 0; i < row.size(); ++i) {
            file << row[i];
            if (i != row.size() - 1) {
                file << ",";
            }
        }
        file << "\n";
    }

    file.close();
}//void writeToFile

std::vector<std::vector<float>> readFromFile(const std::string& filename) {
    std::vector<std::vector<float>> B;
    std::ifstream file(filename);
    if (!file) {
        std::cerr << "Error opening file for reading: " << filename << std::endl;
        return B;
    }

    std::string line;
    while (std::getline(file, line)) {
        std::vector<float> row;
        std::stringstream ss(line);
        std::string value;
        while (std::getline(ss, value, ',')) {
            row.push_back(std::stof(value));
        }
        B.push_back(row);
    }

    file.close();
    return B;
}//readFromFile(

//----------------------------------------------------------------------------------------

#define Num训练数据的个数s 4
int main()
{
    NN神经网络NN nn(2, 4, 3, 1);// 2, 3, 2, 1);// 11, 10, 4);
    // Example

    int 训练数据的个数s = Num训练数据的个数s;
     vector<float> input[Num训练数据的个数s];

/*  input[0] = {0,1,0, 0,1,0, 0,1,0};      //1“竖线”或 “1”字{ 1.0, 0.5, 0.25, 0.125 };
    input[1] = { 0,0,0, 1,1,1,0,0,0 };      //-“横线”或 “-”减号{ 1.0, 0.5, 0.25, 0.125 };
    input[2] = { 0,1,0, 1,1,1, 0,1,0 };      //+“+”加号{ 1.0, 0.5, 0.25, 0.125 };
    input[3] = { 0,1,0, 0,1.2, 0,  0,1, 0 };   // '1'或 '|'字型{ 1.0, 0.5, 0.25, 0.125 };
    input[4] = { 1,1,0, 1,0,1.2,  1,1,1 };      //“口”字型+{ 1.0, 0.5, 0.25, 0.125 };
     vector<float> target[Num训练数据的个数s];
    target[0] = { 1.0, 0,0,0 };// , 0};//1 , 0}; //0.0, 1.0, 0.5};      //{ 0.0, 1.0 };
    target[1] = { 0, 1.0 ,0,0 };// , 0};//- 91.0, 0};// , 0, 0}; //
    target[2] = { 0,0,1.0,0 };// , 0};//+ 1.0, 0.5};
    target[3] = { 1.0 ,0,0, 0.5 };// , 0}; //1
    target[4] = { 0,0,0,0 };// , 1.0}; //“口”
    */

    vector<float> target[Num训练数据的个数s];
    input[0] = { 0,0 };     target[0] = { 0 };   //"-"
    input[1] = { 1,0 };     target[1] = { 1 };
    input[2] = { 1,1};      target[2] = { 0};
    input[3] = { 0,1 };     target[3] = { 1 };


    string str0001;
 
LabeStart001:
    //--------------------------------------------------------------------------------------
   
    cout << "1_Trainning;" << endl;
    cout << "2_Test;" << endl;
    cout << "3_quit." << endl;
    getline(cin, str0001);
    stringstream s01s001(str0001);

    string temp;
    getline(s01s001, temp, ',');
    int choice = (float)stof(temp); //

    switch (choice) {
        case        1:
        goto LabeTraining;
        case 2:
            goto LabeTest;
        case 3:
            return 0;

    }


LabeTraining:
    for (int i = 0; i < 90000; ++i) {//for110i
        for (int jj = 0; jj < Num训练数据的个数s ;  ++jj) {
        //for (auto& val: input ) {
            nn.train(input[jj], target[jj], 0.001);
            if (0 ==i % 10000) { std::cout << "[Lost:" << Loss误差损失之和001 << endl; }
        
        }//for220jj

    }//for110i

//    writeToFile( nn.输入层到第1隐藏层之权重矩阵 , "/file输入层到第1隐藏层之权重矩阵Name220101.txt");
    writeToFile(nn.输入层到第1隐藏层之权重矩阵, "/file输入层到第1隐藏层之权重矩阵Name220101.txt");
    writeToFile(nn.隐藏22到输出层de权重矩阵, "/file隐藏22到输出层de权重矩阵Name220101.txt");
    writeToFile(nn.隐藏层1到第二隐藏层2之权重矩阵1to2, "/file隐藏层1到第二隐藏层2之权重矩阵1to2Name220101.txt");

    writeVectorToFile( nn.隐藏层1偏置1, "/file隐藏层1偏置1.txt");
    writeVectorToFile(nn.隐藏层2偏置2, "/file隐藏层2偏置2.txt");
    writeVectorToFile(nn.O输出层偏置, "/fileO输出层偏置.txt");
   
    std::cout << endl;


  LabeTest:
    //--------------------------------------
    input[1] = { 0,1 };// 0, 0, 1, 1, 0.98, 0, 0, 0};      //1/ 
     vector<float> outpu输出数据001t = nn.predict(input[0]);

    for (auto& val : outpu输出数据001t)
         std::cout <<  fixed <<  setprecision(9) << val << " ";
    std::cout << endl;

    //-------------------------------------------------------------


//    do {
         std::cout <<  endl << "请输入一个字符串(要求字符串是包含9个由逗号分隔的数字的字符串,如 1,2,0,0,5,0,0,8,9等): " <<  endl;
         getline( cin, str0001);

         stringstream 
             s01s002(str0001);
         for (int i = 0; i < 2;++i) {//
             //9; ++i) {
             string temp;
             getline(s01s002, temp, ',');

            input[1][i] = (float) stof(temp); // 将字符串转化为整数
        }

         std::cout << "数字数组为: ";
         for (int i = 0; i < 2;++i) {// 9; ++i) {
             std::cout << input[1][i] << " ";
        }

         //
         readVectorFromFile(nn.隐藏层1偏置1, "/file隐藏层1偏置1.txt");
         readVectorFromFile(nn.隐藏层2偏置2, "/file隐藏层2偏置2.txt");
         readVectorFromFile(nn.O输出层偏置, "/fileO输出层偏置.txt");

         nn.输入层到第1隐藏层之权重矩阵 = readFromFile("/file输入层到第1隐藏层之权重矩阵Name220101.txt");
         nn.隐藏层1到第二隐藏层2之权重矩阵1to2 = readFromFile("/file隐藏层1到第二隐藏层2之权重矩阵1to2Name220101.txt");
         nn.隐藏22到输出层de权重矩阵 = readFromFile("/file隐藏22到输出层de权重矩阵Name220101.txt");

         //
        outpu输出数据001t = nn.predict(input[1]);
         std::cout <<  endl;
        for (auto& val : outpu输出数据001t)
             std::cout <<  fixed <<  setprecision(9) << val << " ";

        cout << endl;

//    } while (true);// 1 == 1);

    //======================================
     std::cout << "Hello World!请继续……您可以继续训练网络,或者测试网络!\n";

     goto LabeStart001;

}//main文章来源地址https://www.toymoban.com/news/detail-674097.html

到了这里,关于C++最易读手撸神经网络两隐藏层(任意Nodes每层)梯度下降230821a的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【基于深度学习的人脸识别】(Dlib+ResNet残差神经网络)——QT(C++)+Linux

    dlib_face_recognition_resnet_model_v1.dat 是基于深度学习的人脸识别模型,是dlib库中的一个重要组件。该模型的原理涉及到深度卷积神经网络(DCNN)和具体的人脸识别算法。 dlib 人脸识别采用了 Resnet 残差神经网络,识别精度高于普通神经网络,同样我们可以到官网去下载训练好的模

    2024年04月23日
    浏览(46)
  • 神经网络基础-神经网络补充概念-30-搭建神经网络块

    搭建神经网络块是一种常见的做法,它可以帮助你更好地组织和复用网络结构。神经网络块可以是一些相对独立的模块,例如卷积块、全连接块等,用于构建更复杂的网络架构。

    2024年02月12日
    浏览(48)
  • 神经网络基础-神经网络补充概念-17-计算神经网络的输出

    计算神经网络的输出通常涉及前向传播(Forward Propagation)的过程,其中输入数据通过网络的层级结构,逐步被传递并变换,最终生成预测结果。下面我将为你展示一个简单的神经网络前向传播的示例。 假设我们有一个具有以下参数的简单神经网络: 输入层:2个神经元 隐藏

    2024年02月12日
    浏览(41)
  • 神经网络实验--卷积神经网络

    本实验主要为了掌握深度学习的基本原理;能够使用TensorFlow实现卷积神经网络,完成图像识别任务。 文章目录 1. 实验目的 2. 实验内容 3. 实验过程 题目一: 题目二: 实验小结讨论题 ①掌握深度学习的基本原理; ②能够使用TensorFlow实现卷积神经网络,完成图像识别任务。

    2024年02月06日
    浏览(53)
  • 神经网络与卷积神经网络

    全连接神经网络是一种深度学习模型,也被称为多层感知机(MLP)。它由多个神经元组成的层级结构,每个神经元都与前一层的所有神经元相连,它们之间的连接权重是可训练的。每个神经元都计算输入的加权和,并通过一个非线性激活函数进行转换,然后将结果传递到下一

    2024年02月10日
    浏览(45)
  • 神经网络基础-神经网络补充概念-40-神经网络权重的初始化

    神经网络权重的初始化是深度学习中的重要步骤,良好的权重初始化可以加速模型的训练收敛,提高模型的性能和稳定性。以下是一些常用的权重初始化方法: 零初始化(Zero Initialization):将权重初始化为零。然而,这种方法不太适合深层神经网络,因为它会导致所有神经

    2024年02月12日
    浏览(50)
  • 【神经网络】循环神经网络RNN和长短期记忆神经网络LSTM

    欢迎访问Blog总目录! 一文看尽RNN(循环神经网络) - 知乎 (zhihu.com) 一文搞懂RNN(循环神经网络)基础篇 - 知乎 (zhihu.com) 循环神经网络(Recurrent Neural Network, RNN)是一类以 序列 (sequence)数据为输入,在序列的演进方向进行 递归 (recursion)且所有节点(循环单元)按链式连

    2024年04月10日
    浏览(46)
  • 神经网络 04(神经网络的搭建)

    tf.Keras 中构建模有两种方式,一种是通过  Sequential  构建,一种是通过  Model  类构建。前者是按 一定的顺序对层进行堆叠 ,而后者可以用来 构建较复杂的网络模型 。首先我们介绍下用来构建网络的全连接层: units: 当前层中包含的神经元个数 Activation: 激活函数,relu,sig

    2024年02月09日
    浏览(29)
  • 卷积神经网络与前馈神经网络

    常见的人工神经网络结构 人工神经网络是一类由人工神经元组成的网络,常见的神经网络结构包括: 前馈神经网络(Feedforward Neural Network,FNN):最简单的神经网络结构,由一个输入层、一个输出层和若干个隐藏层组成,信号只能从输入层流向输出层,不允许在网络中形成回

    2023年04月26日
    浏览(42)
  • 神经网络基础-神经网络补充概念-53-将batch norm拟合进神经网络

    梯度消失问题的缓解:在深度神经网络中,梯度消失是一个常见的问题,特别是在深层网络中。批归一化通过在每个批次内对输入进行标准化,使得激活函数的输入分布更稳定,从而减轻了梯度消失问题,使得梯度更容易传播,促进了训练过程的稳定性和效率。 加速收敛:由

    2024年02月12日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包