现代c++手撸2309神经网络最简化版230901

已于 2023-10-02 14:43:31 修改
阅读量868 收藏 4
点赞数 1
分类专栏： 手撸神经网络-条分缕析c++Modern机器学习 文章标签： 算法
于 2023-10-02 10:40:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aw344/article/details/133485771
版权
本文展示了如何使用C++从头构建一个简单的神经网络，包括前向传播和基于梯度下降的反向传播。代码中创建了一个拥有2个输入节点、4个隐藏节点和1个输出节点的网络，并进行训练和测试。主要问题在于可能存在数组越界风险，需修正`sigmoid_derivative`函数的计算。
摘要由CSDN通过智能技术生成

用c++输入数据:vector<vector<float>> inputs = { {1, 1}, {1, 0} };数据targets={0,1}; 测试：vector<vector<float>> inputs22 = { {1, 0}, {1,1} }; 构建神经网络，例如：NeuralNetwork nn({ 2, 4, 1 }); 则网络有四层、输入层2个节点、输出层1个节点、隐藏层4个节点、网络有梯度下降、反向传播…等。

以下是一个使用C++构建的基本神经网络示例，包含前向传播和基于梯度下降的反向传播。

在这个例子中：

  1. 我们创建了一个神经网络，具有输入层2个节点，隐藏层4个节点和输出层1个节点。
  2. 我们使用了两个输入向量（{1, 1}和{1, 0}）进行训练，目标输出分别是0和1。
  3. 我们进行了10000次训练迭代。
  4. 训练完成后，我们使用另外两个输入向量（{1, 0}和{1, 1}）来测试网络的性能。

你可以根据需要调整神经网络的参数，比如学习率和训练迭代次数，以获得更好的性能。

第二(改进)版:

#include <iostream>
#include <vector>

using namespace std;

bool  whetherOutputFlag = 0;
float sigmoid(float x) {
    return 1 / (1 + exp(-x));
}

float sigmoid_derivative(float x) {
    float s = sigmoid(x);
    return s * (1 - s);
}

class NeuralNetwork {
private:
    std::vector<std::vector<std::vector<float>>> weights;
    std::vector<std::vector<float>> layer_outputs;

public:
    NeuralNetwork(std::vector<int> topology) {
        std::srand(std::time(0));
        for (int i = 0; i < topology.size() - 1; i++) {
            weights.push_back(std::vector<std::vector<float>>(topology[i], std::vector<float>(topology[i + 1])));
            for (int j = 0; j < topology[i]; j++) {
                for (int k = 0; k < topology[i + 1]; k++) {
                    weights[i][j][k] = (std::rand() % 2000 - 1000) / 1000.0f;
                }
            }
        }
    }

    std::vector<float> feedforward(std::vector<float> input) {
        layer_outputs.clear();
        layer_outputs.push_back(input);
        for (int i = 0; i < weights.size(); i++) {
            std::vector<float> output(weights[i][0].size(), 0);
            for (int j = 0; j < weights[i][0].size(); j++) {
                for (int k = 0; k < input.size(); k++) {
                    output[j] += input[k] * weights[i][k][j];
                }
                output[j] = sigmoid(output[j]);
            }
            layer_outputs.push_back(output);
            input = output;
        }
        return input;
    }//feedforward


    void train(std::vector<float> input, std::vector<float> targets, float learning_rate , bool  whetherOutputFlag) {

        //--------------------------------------------- 前向传播--输出损失
        
        std::vector<float> outputs = feedforward(input);
        // 初始化误差
        std::vector<float> errors(outputs.size(), 0);
        float sumA=0.0;
        for (int i = 0; i < targets.size(); i++) {
            errors[i] = (targets[i] - outputs[i]);
            if (true == whetherOutputFlag) {//if220
                sumA += fabs((errors[i] ));
                cout << "i"<<i<<"]";
            }//if220
            
        }//for110i
        if(  true==whetherOutputFlag) std::cout << sumA;//根据标志位,决定是否输出损失
        //=============================================

        // 反向传播
        for (int i = weights.size() - 1; i >= 0; i--) {
            // 更新权重
            for (int j = 0; j < weights[i].size(); j++) {
                for (int k = 0; k < weights[i][j].size(); k++) {
                    float derivative = sigmoid_derivative(layer_outputs[i + 1][k]);
                    weights[i][j][k] += learning_rate * errors[k] * derivative * layer_outputs[i][j];
                }
            }

            // 计算下一层的误差
            std::vector<float> next_errors(weights[i].size(), 0);
            for (int j = 0; j < weights[i].size(); j++) {
                for (int k = 0; k < weights[i][j].size(); k++) {
                    next_errors[j] += errors[k] * weights[i][j][k];
                }
            }
            errors = next_errors;
        }
    }//void train(

};//

int main() {
    NeuralNetwork nn({ 2, 8,6, 1 });
    std::vector<std::vector<float>> inputs = { {1,0}, {1, 1}, {0,1},{0,0}  };
    std::vector<float> targets = { 1,0,1,0 };

    for (int i = 0; i < 50000; i++) {
        for (size_t j = 0; j < inputs.size(); j++) {
            nn.train(inputs[j], { targets[j] }, 0.05, false);//false 不输出 0.1);// 0.05);// 0.1);
            if (0 == (i % 10000)) {
                nn.train(inputs[j], { targets[j] }, 0.001 , true); //true 输出
                std::cout << "] ";
                std::cout << std::endl;
            }

        }
        if(0==(i%10000)) std::cout << std::endl;
    }//for110i

    std::vector<std::vector<float>> inputs22 = { {0,1},{0,0}, {1, 0}, {1, 1} };
    for (size_t j = 0; j < inputs22.size(); j++) {
        std::vector<float> output = nn.feedforward(inputs22[j]);
        std::cout << "Output for [" << inputs22[j][0] << ", " << inputs22[j][1] << "]: " << output[0] << std::endl;
    }

    return 0;
}//main

第一版:


#include <iostream>
#include <vector>

using namespace std;

bool  whetherOutputFlag = 0;
float sigmoid(float x) {
    return 1 / (1 + exp(-x));
}

float sigmoid_derivative(float x) {
    float s = sigmoid(x);
    return s * (1 - s);
}

class NeuralNetwork {
private:
    std::vector<std::vector<std::vector<float>>> weights;
    std::vector<std::vector<float>> layer_outputs;

public:
    NeuralNetwork(std::vector<int> topology) {
        std::srand(std::time(0));
        for (int i = 0; i < topology.size() - 1; i++) {
            weights.push_back(std::vector<std::vector<float>>(topology[i], std::vector<float>(topology[i + 1])));
            for (int j = 0; j < topology[i]; j++) {
                for (int k = 0; k < topology[i + 1]; k++) {
                    weights[i][j][k] = (std::rand() % 2000 - 1000) / 1000.0f;
                }
            }
        }
    }

    std::vector<float> feedforward(std::vector<float> input) {
        layer_outputs.clear();
        layer_outputs.push_back(input);
        for (int i = 0; i < weights.size(); i++) {
            std::vector<float> output(weights[i][0].size(), 0);
            for (int j = 0; j < weights[i][0].size(); j++) {
                for (int k = 0; k < input.size(); k++) {
                    output[j] += input[k] * weights[i][k][j];
                }
                output[j] = sigmoid(output[j]);
            }
            layer_outputs.push_back(output);
            input = output;
        }
        return input;
    }//feedforward


    void train(std::vector<float> input, std::vector<float> targets, float learning_rate , bool  whetherOutputFlag) {

        //--------------------------------------------- 前向传播--不输出损失
        std::vector<float> outputs = feedforward(input);
        // 初始化误差
        std::vector<float> errors(outputs.size(), 0);
        float sumA=0.0;
        for (int i = 0; i < targets.size(); i++) {
            errors[i] = (targets[i] - outputs[i]);
            if (true == whetherOutputFlag) {//if220
                sumA += fabs((targets[i] - outputs[i]));
                cout << "i"<<i<<"]";
            }//if220
            
        }//for110i
        if( true==whetherOutputFlag) std::cout << sumA;
        //=============================================

        // 反向传播
        for (int i = weights.size() - 1; i >= 0; i--) {
            // 更新权重
            for (int j = 0; j < weights[i].size(); j++) {
                for (int k = 0; k < weights[i][j].size(); k++) {
                    float derivative = sigmoid_derivative(layer_outputs[i + 1][k]);
                    weights[i][j][k] += learning_rate * errors[k] * derivative * layer_outputs[i][j];
                }
            }

            // 计算下一层的误差
            std::vector<float> next_errors(weights[i].size(), 0);
            for (int j = 0; j < weights[i].size(); j++) {
                for (int k = 0; k < weights[i][j].size(); k++) {
                    next_errors[j] += errors[k] * weights[i][j][k];
                }
            }
            errors = next_errors;
        }
    }//void train(

};//

int main() {
    NeuralNetwork nn({ 2, 4, 1 });
    std::vector<std::vector<float>> inputs = { {1,0}, {1, 1}, {0,1},{0,0}  };
    std::vector<float> targets = { 1,0,1,0 };

    for (int i = 0; i < 50000; i++) {
        for (size_t j = 0; j < inputs.size(); j++) {
            nn.train(inputs[j], { targets[j] }, 0.05, false);//false 不输出 0.1);// 0.05);// 0.1);
            if (0 == (i % 10000)) {
                nn.train(inputs[j], { targets[j] }, 0.001 , true); //true 输出
                std::cout << "] ";
                std::cout << std::endl;
            }

        }
        if(0==(i%10000)) std::cout << std::endl;
    }//for110i

    std::vector<std::vector<float>> inputs22 = { {0,1},{0,0}, {1, 0}, {1, 1} };
    for (size_t j = 0; j < inputs22.size(); j++) {
        std::vector<float> output = nn.feedforward(inputs22[j]);
        std::cout << "Output for [" << inputs22[j][0] << ", " << inputs22[j][1] << "]: " << output[0] << std::endl;
    }

    return 0;
}//main

下面代码出现:vector subscript out of range: float sigmoid(float x) { return 1 / (1 + exp(-x)); } float sigmoid_derivative(float x) { float s = sigmoid(x); return s * (1 - s); } class NeuralNetwork { private: std::vector<std::vector<std::vector<float>>> weights; std::vector<std::vector<float>> layer_outputs; public: NeuralNetwork(std::vector<int> topology) { std::srand(std::time(0)); for (int i = 0; i < topology.size() - 1; i++) { weights.push_back(std::vector<std::vector<float>>(topology[i], std::vector<float>(topology[i + 1]))); for (int j = 0; j < topology[i]; j++) { for (int k = 0; k < topology[i + 1]; k++) { weights[i][j][k] = (std::rand() % 2000 - 1000) / 1000.0f; } } } } std::vector<float> feedforward(std::vector<float> input) { layer_outputs.clear(); layer_outputs.push_back(input); for (int i = 0; i < weights.size(); i++) { std::vector<float> output(weights[i][0].size(), 0); for (int j = 0; j < weights[i][0].size(); j++) { for (int k = 0; k < input.size(); k++) { output[j] += input[k] * weights[i][k][j]; } output[j] = sigmoid(output[j]); } layer_outputs.push_back(output); input = output; } return input; } void train(std::vector<float> input, std::vector<float> targets, float learning_rate) { std::vector<float> outputs = feedforward(input); // 反向传播 for (int i = weights.size() - 1; i >= 0; i--) { std::vector<float> errors(targets.size(), 0); for (int j = 0; j < targets.size(); j++) { errors[j] = targets[j] - outputs[j]; } if (i != weights.size() - 1) { std::vector<float> prev_errors = errors; errors.clear(); errors.resize(weights[i + 1].size(), 0); for (int j = 0; j < weights[i + 1].size(); j++) { for (int k = 0; k < weights[i + 1][j].size(); k++) { errors[j] += prev_errors[k] * weights[i + 1][j][k]; } } } for (int j = 0; j < weights[i].size(); j++) { for (int k = 0; k < weights[i][j].size(); k++) { float derivative = sigmoid_derivative(layer_outputs[i + 1][k]); weights[i][j][k] += learning_rate * errors[k] * derivative * layer_outputs[i][j]; } } targets = layer_outputs[i]; } } }; int main() { NeuralNetwork nn({ 2, 4, 1 }); std::vector<std::vector<float>> inputs = { {1, 1}, {1, 0} }; std::vector<float> targets = { 0, 1 }; for (int i = 0; i < 10000; i++) { for (size_t j = 0; j < inputs.size(); j++) { nn.train(inputs[j], { targets[j] }, 0.1); } } std::vector<std::vector<float>> inputs22 = { {1, 0}, {1, 1} }; for (size_t j = 0; j < inputs22.size(); j++) { std::vector<float> output = nn.feedforward(inputs22[j]); std::cout << "Output for [" << inputs22[j][0] << ", " << inputs22[j][1] << "]: " << output[0] << std::endl; } return 0; } 请修正错误!

aw344
关注
专栏目录
C/C++ Adaline自适应线性神经网络算法详解及源码
weixin_44976692的博客
06-16 4万+
Adaline（自适应线性神经元）是一种用于模式分类的线性神经网络。它与感知器类似，但具有一些改进，如使用连续的激活函数和梯度下降算法进行权重调整。本文将介绍Adaline算法的原理、实现步骤以及用C/C++编写的源码。通过本文的介绍，你了解了Adaline算法的原理、实现步骤，并通过C/C++源码示例实现了一个简单的Adaline模型。希望本文对你有所帮助，欢迎在评论区分享你的想法和建议！
手撕神经网络：从零开始实现一个简单的神经网络（python）
生命在于折腾！
11-14 2101
手撕神经网络：从零开始实现一个简单的神经网络 1. 前言 现在有很多深度学习平台可以用，甚至我们根本不需要知道网络背后是怎么运行的，就可以训练出我们想要的模型，但是从学习的角度，从零开始写一个简单的神经网络是有必要的，它将有助于理解神经网络的工作原理。 之前有写过基于 TF 的全连接神经网络的实现，可以参考深度学习笔记——全连接神经网络样例程序及详细注释。但是这里将不借助任何深度学习平台来实现一个...
C++最易读手撸神经网络两隐藏层(任意Nodes每层)梯度下降230820a
aw344的专栏
08-22 786
int inputNode输入层之节点数s, hidden01Nodes, hidden22Nodes, outputNode输出层结点数s; vector 输入层到第1隐藏层之权重矩阵, 隐藏层1到第二隐藏层2之权重矩阵1to2, 隐藏22到输出层de权重矩阵; //这些变量为矩阵 vector 隐藏层1偏置1, 隐藏层2偏置2, O输出偏置o; vector隐藏层1数据1, 隐藏层2数据2, 输出数据o
【深度学习】使用C++手动搭建一个神经网络
DwD-的博客
09-21 1万+
1.前言 深度学习框架给我们带来了很多方便，但是过于依赖框架反而会让我们不知所以然。本篇博客中，我使用C++语言实现了一个简单的神经网络。 2.原理 神经网络由正向传播和反向传播构成。正向传播指的是输入样本数据x，通过一层层网络的计算后得到结果。反向传播值得是通过预测结果与正确结果的差异来对网络中的参数进行修正的过程。 下面我们分别来介绍正向传播算法和反向传播算法： 首先以一个最简单的神经元单元为例： 其中x1，x2，x3是一个输入样本的三个数据，输出是y =σ( x1*w1 + x2*w.
C++实现神经网络识别数字
GaoJieVery6
09-14 5974
0.综述 我用的神经网络是ANN，下文会介绍训练ANN的反向传播算法并给出相应的数学推导过程，以及一个简单的C++实现的基于反向传播的ANN代码，这个ANN可以进行粗略的数字识别，代码简单易懂，适合新手练手。 1.本文提供的资料 一份用于训练神经网络参数的ANN代码，复制粘贴即可使用。 一份通过使用上述代码训练出的参数进行数字预测的代码，复制粘贴即可使用。 拥有5000个样例的数据集。 ...
C++从零实现BP神经网络
IronYoung_不惧未来
10-27 3万+
BP（backward propogation）神经网络实现过程中的一些学习资料、心得，以及最终的源码实现，力求通俗、易懂
计算机科学与技术反思录
luckisok的专栏
03-08 8581
姓名：曾毅 OICQ：101811267 电子邮件：zengyi820@hotmail.com 　　　　 学历：本科（大学三年级） 专业：计算机科学与技术 个人爱好：计算机，英语　 英语水平：大学英语六级，四六级考试口语加试优秀   经历 微软高校信息交流中心基础科学版版主　　　　 　　 2001-2002北京工业大学实验学院学习部部长 北京工业大学计算机英语教学站点开发人员　　　　　主持开发北京
BP神经网络的c++实现 源码下载
06-02
用c++实现了BP神经网络类，文件中含有测试数据，测试效果良好，关于该BP神经网络类的实现原理，参考本人关于BP神经网络叙述的博客 http://blog.csdn.net/hjkhjk007/article/details/9001304
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
深度学习之卷积神经网络CNN用于人脸检测C++库
02-19
在这个"深度学习之卷积神经网络CNN用于人脸检测C++库"中，我们将深入探讨CNN在人脸检测中的应用以及C++实现的相关技术。 1. **卷积神经网络CNN**：CNN的核心特征在于其卷积层，通过滤波器（或称卷积核）对输入图像...
C++ 中的卷积神经网络 (CNN)
小白学视觉
06-15 3548
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 有很多卷积神经网络文章解释了 CNN 是什么以及它的用途是什么，而本文将用 C++ 编写一个 CN...
C++从零实现深度神经网络之零——前言
星沉阁
12-15 6072
一年前接触最初神经网络，半年前就像自己写一个最简单的BP神经网络练练手，结果由于能力有限，不光是编程能力还有理论方面的能力都有限，一直推到半年后的现在才真正的开始。其实很多坑必须要自己亲自踩过之后才能明白。在我看来，我现在这个过程就是在踩坑的过程。在不断犯错和改错中提高。在这里记录下自己的踩坑过程。这是一个堪称简陋（随着时间推移，应该会变得更好）的练手性质的小项目，而且重复造轮子，目的是为了加深自己
手撸神经网络（识别手写数字）
Gru的博客
10-20 670
import numpy as np import scipy.special import matplotlib.pyplot as plt class neuralNetwork: def __init__(self, inputNodes, hiddenNodes1,heddenNodes2, outputNodes, learningRate): # 一、设置每层节点个数和学习率 self.inodes = inputNodes self.
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 473
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1109
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
【算法】贪心+堆排序实现大根堆及标准库容器类的融合使用
2301_77954967的博客
09-25 1737
先看题这个算法，是要通过循环找到所有元素中最大的那个偶元素，对其除以2，然后再找这之后的最大的那个偶元素以此类推笔者的经历不多，第一次做的时候没有想到大根堆的算法，只是用sort将每次除以2后的整个数组进行降序排序，这样的作法使用sort对数组进行排序后，虽然可以确定数组中的元素大小顺序，但在每次选择偶数进行减半操作时，需要遍历整个数组来找到合适的偶数，效率较低。对于一个较大的数组，排序后可能需要花费较多的时间来找到下一个要进行减半操作的偶数，尤其是当操作次数较多时，这种遍历的方式会变得非常耗时。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 399
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 133
初识算法之二分查找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值