【机器学习】使用Numpy实现神经网络训练全流程

文章目录

  • 网络搭建
  • 前向传播
  • 反向传播
  • 损失计算
  • 完整代码

曾经在面试一家大模型公司时遇到的面试真题，当时费力写了一个小时才写出来，自然面试也挂了。后来复盘，发现反向传播掌握程度还是太差，甚至连梯度链式传播法则都没有弄明白。

网络搭建

这里我们以训练 全连接神经网络 为例，也就是输入层，隐藏层和输出层都是 全连接层，激活函数选择Relu函数。

  • 构造Linear层来实现全连接层，其中权重参数 w w w和偏执参数 b i a s bias bias分别使用随机初始化和零初始化
  • Relu激活函数没有可学习参数
  • 整个网络写成MLP类，并设置参数控制中间隐藏层的个数
class Relu:
    ''' relu activation function
    '''
    def forward(self, x):
        self.x = x
        return np.maximum(0, x)
    
class LinearLayer:
    def __init__(self, input_c, output_c):
        # y = x @ w + b
        # self.w = np.random.rand(input_c, output_c)
        self.w = np.random.rand(input_c, output_c) * 0.001 # 这里乘上0.001是为了防止结果太大，梯度爆炸
        self.b = np.zeros(output_c)
    
class MLP:
    def __init__(self, input_c, hidden_c, output_c, layers_num):
        self.layers = []

        # 初始化网络第一层
        self.layers.append(LinearLayer(input_c, hidden_c))
        self.layers.append(Relu())

        # 初始化网络中间层
        for i in range(layers_num - 2):
            self.layers.append(LinearLayer(hidden_c, hidden_c))
            self.layers.append(Relu())
        
        # 初始化网络最后一层，注意，最后一层没有relu激活函数
        self.layers.append(LinearLayer(hidden_c, output_c))

前向传播

前向传播部分，主要包括 Linear层的前向，Relu激活函数的前向，以及MLP类的前向：

  • Relu激活函数：前向就是和0比较大小，大于零的保留，小于零的都置为0
  • Linear层：前向计算公式就是线性回归方程，要注意计算时维度需要对齐
  • MLP类：逐层调用前向传播函数
class Relu:
    ''' relu activation function
    '''
    def forward(self, x):
        self.x = x
        return np.maximum(0, x)
    
class LinearLayer:
    def __init__(self, input_c, output_c):
        # y = x @ w + b
        # self.w = np.random.rand(input_c, output_c)
        self.w = np.random.rand(input_c, output_c) * 0.001 # 这里乘上0.001是为了防止结果太大，梯度爆炸
        self.b = np.zeros(output_c)

    def forward(self, x):
        self.x = x # 这里保存输入，为了后续在反向传播中计算梯度
        # y = x @ w + b
        return np.dot(x, self.w) + self.b
    
class MLP:
    def __init__(self, input_c, hidden_c, output_c, layers_num):
        self.layers = []

        # 初始化网络第一层
        self.layers.append(LinearLayer(input_c, hidden_c))
        self.layers.append(Relu())

        # 初始化网络中间层
        for i in range(layers_num - 2):
            self.layers.append(LinearLayer(hidden_c, hidden_c))
            self.layers.append(Relu())
        
        # 初始化网络最后一层，注意，最后一层没有relu激活函数
        self.layers.append(LinearLayer(hidden_c, output_c))
        

    def forward(self, x):
        res = x
        for layer in self.layers:
            res = layer.forward(res)
        return res

反向传播

前向的输出，变为反向的输入
梯度，就是多元函数对某个变量的偏导数（变化最快的方向）
梯度下降法更新参数，就是朝着梯度的反方向更新参数
参数的梯度，意思是 损失函数对这个参数的梯度，根据求导的链式法则，可以表示为逐层求导乘积的形式

同前向一样，反向传播部分，也包括 Linear层的反向，Relu激活函数的反向，以及MLP类的反向：

  • Relu激活函数：大于0时导数为1，小于等于0时导数为0。同时由于没有可学习参数，所以只需要回传输入的梯度值即可
  • MLP类：由于是反向传播，所以起点就是 损失函数 对于 MLP最后一层的输出 的梯度值，然后从最后一层向前，逐层 回传 梯度值
  • Linear层：由于存在可学习参数需要去更新，因此不仅需要计算输入的梯度，还需要计算两个可学习参数 w w w和 b i a s bias bias的梯度，然后更新参数
class Relu:
    ''' relu activation function
    '''
    def forward(self, x):
        self.x = x
        return np.maximum(0, x)
    
    def backward(self, grad_output, lr):
        # 这里的lr没有用到，但是为了保持参数接口的一致性，还是保留了
        return grad_output * (self.x > 0) # relu函数的一阶导数，大于0部分为1，小于0部分为0
    
class LinearLayer:
    def __init__(self, input_c, output_c):
        # y = x @ w + b
        # self.w = np.random.rand(input_c, output_c)
        self.w = np.random.rand(input_c, output_c) * 0.001 # 这里乘上0.001是为了防止结果太大，梯度爆炸
        self.b = np.zeros(output_c)

    def forward(self, x):
        self.x = x # 这里保存输入，为了后续在反向传播中计算梯度
        # y = x @ w + b
        return np.dot(x, self.w) + self.b

    def backward(self, grad_output, lr):
        # linear层的梯度计算，涉及三个参数，x，w，b，为 dx, dw, db
        # 其中，dw和db是为了更新w和b
        # dx是为了计算下一层的梯度，链式法则

        # y = x @ w + b
        # dl / dx = dl / dy * dy / dx = grad_output * w
        # 这里要注意矩阵的维度要对齐
        grad_input = np.dot(grad_output, self.w.T)

        # dl / dw = dl / dy * dy / dw = grad_output * x
        # 这里要注意矩阵的维度要对齐
        w_grad = np.dot(self.x.T, grad_output)

        b_grad = np.sum(grad_output, axis=0)

        # 更新w和b的参数
        self.w -= lr * w_grad
        self.b -= lr * b_grad

        return grad_input
    
class MLP:
    def __init__(self, input_c, hidden_c, output_c, layers_num):
        self.layers = []

        # 初始化网络第一层
        self.layers.append(LinearLayer(input_c, hidden_c))
        self.layers.append(Relu())

        # 初始化网络中间层
        for i in range(layers_num - 2):
            self.layers.append(LinearLayer(hidden_c, hidden_c))
            self.layers.append(Relu())
        
        # 初始化网络最后一层，注意，最后一层没有relu激活函数
        self.layers.append(LinearLayer(hidden_c, output_c))
        

    def forward(self, x):
        res = x
        for layer in self.layers:
            res = layer.forward(res)
        return res

    def backward(self, grad_output, lr):
        grad = grad_output

        # 倒序遍历每一层，反向传播，计算每一层梯度
        # for layer in reversed(self.layers):
        for layer in self.layers[::-1]:
            grad = layer.backward(grad, lr)

        return grad

损失计算

这里为了简化操作，使用MSE均方误差函数，作为损失函数：

在这里插入图片描述
然后，计算损失loss对模型最后一层输出的梯度： l g r a d = 2 ∗ ( y − y ^ ) l_{grad}=2*(y-\hat{y}) lgrad​=2∗(y−y^​)，然后，将 l g r a d l_{grad} lgrad​作为模型反向传播的起点，逐层回传梯度并使用梯度下降法更新参数。

完整代码

import numpy as np

class Relu:
    ''' relu activation function
    '''
    def forward(self, x):
        self.x = x
        return np.maximum(0, x)
    
    def backward(self, grad_output, lr):
        # 这里的lr没有用到，但是为了保持参数接口的一致性，还是保留了
        return grad_output * (self.x > 0) # relu函数的一阶导数，大于0部分为1，小于0部分为0
    
class LinearLayer:
    def __init__(self, input_c, output_c):
        # y = x @ w + b
        # self.w = np.random.rand(input_c, output_c)
        self.w = np.random.rand(input_c, output_c) * 0.001 # 这里乘上0.001是为了防止结果太大，梯度爆炸
        self.b = np.zeros(output_c)

    def forward(self, x):
        self.x = x # 这里保存输入，为了后续在反向传播中计算梯度
        # y = x @ w + b
        return np.dot(x, self.w) + self.b

    def backward(self, grad_output, lr):
        # linear层的梯度计算，涉及三个参数，x，w，b，为 dx, dw, db
        # 其中，dw和db是为了更新w和b
        # dx是为了计算下一层的梯度，链式法则

        # y = x @ w + b
        # dl / dx = dl / dy * dy / dx = grad_output * w
        # 这里要注意矩阵的维度要对齐
        grad_input = np.dot(grad_output, self.w.T)

        # dl / dw = dl / dy * dy / dw = grad_output * x
        # 这里要注意矩阵的维度要对齐
        w_grad = np.dot(self.x.T, grad_output)

        b_grad = np.sum(grad_output, axis=0)

        # 更新w和b的参数
        self.w -= lr * w_grad
        self.b -= lr * b_grad

        return grad_input
    
class MLP:
    def __init__(self, input_c, hidden_c, output_c, layers_num):
        self.layers = []

        # 初始化网络第一层
        self.layers.append(LinearLayer(input_c, hidden_c))
        self.layers.append(Relu())

        # 初始化网络中间层
        for i in range(layers_num - 2):
            self.layers.append(LinearLayer(hidden_c, hidden_c))
            self.layers.append(Relu())
        
        # 初始化网络最后一层，注意，最后一层没有relu激活函数
        self.layers.append(LinearLayer(hidden_c, output_c))
        

    def forward(self, x):
        res = x
        for layer in self.layers:
            res = layer.forward(res)
        return res

    def backward(self, grad_output, lr):
        grad = grad_output

        # 倒序遍历每一层，反向传播，计算每一层梯度
        # for layer in reversed(self.layers):
        for layer in self.layers[::-1]:
            grad = layer.backward(grad, lr)

        return grad

if __name__ == '__main__':
    input_data = np.random.rand(2, 8)
    input_c = 8
    hidden_c = 16
    output_c = 3
    layers = 5
    target = np.random.rand(2, 3)

    mlp_model = MLP(input_c, hidden_c, output_c, layers)

    # print(mlp_model.layers)

    for i in range(10):
        print(f'[Epoch: {i} / 100]', end='   ')
        res = mlp_model.forward(input_data)

        # 计算损失loss，这里使用mse，均方误差函数
        loss = ((res - target) ** 2).mean()

        # 损失对于最后一层输出res的梯度
        loss_grad = 2 * (res - target)

        # 反向传播，计算每一层梯度
        mlp_model.backward(loss_grad, lr=0.1)

        print(f'[loss: {loss}]')

输出结果：

[Epoch: 0 / 100]   [loss: 0.7094113331502839]
[Epoch: 1 / 100]   [loss: 0.2770589775342763]
[Epoch: 2 / 100]   [loss: 0.12141369105814748]
[Epoch: 3 / 100]   [loss: 0.06538216434144564]
[Epoch: 4 / 100]   [loss: 0.04521136910150728]
[Epoch: 5 / 100]   [loss: 0.037950191234703855]
[Epoch: 6 / 100]   [loss: 0.03533631186000425]
[Epoch: 7 / 100]   [loss: 0.03439537638899603]
[Epoch: 8 / 100]   [loss: 0.034056663841438094]
[Epoch: 9 / 100]   [loss: 0.033934736564443235]

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/875772.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Wophp靶场寻找漏洞练习

Wophp靶场寻找漏洞练习

1.命令执行漏洞 打开网站划到最下，此处的输入框存在任意命令执行漏洞 输入命令whoami 2.SQL注入 搜索框存在SQL注入，类型为整数型 最终结果可以找到管理员账户和密码 3.任意文件上传漏洞 在进入管理员后台后，上传木马文件 访问该文件&…
阅读更多...
element表格合并列数据相同合并单元格

element表格合并列数据相同合并单元格

<!-- :span-method"objectSpanMethod"合并列 --><el-table stripe :data"morningdataList" style"width: 100%" :span-method"objectSpanMethod" ><el-table-column align"center" label"" :show…
阅读更多...
使用 BentoML快速实现Llama-3推理服务

使用 BentoML快速实现Llama-3推理服务

介绍 近年来&#xff0c;开源大模型如雨后春笋般涌现&#xff0c;为自然语言处理领域带来了革命性的变化。从文本生成到代码编写&#xff0c;从机器翻译到问答系统&#xff0c;开源大模型展现出惊人的能力&#xff0c;吸引了越来越多的开发者和企业投身其中。 然而&#xff0…
阅读更多...
LabVIEW环境中等待FPGA模块初始化完成

LabVIEW环境中等待FPGA模块初始化完成

这个程序使用的是LabVIEW环境中的FPGA模块和I/O模块初始化功能&#xff0c;主要实现等待FAM&#xff08;Field-Programmable Gate Array Module&#xff0c;FPGA模块&#xff09;的初始化完成&#xff0c;并处理初始化过程中的错误。让我们逐步分析各部分的功能&#xff1a; 1.…
阅读更多...
DataWind将string类型转化为int类型的报错解决

DataWind将string类型转化为int类型的报错解决

一、现象&#xff1a; toInt64([kernel_wakeup_top_count_str]) 二、日志&#xff1a; 遇到&#xff1a;错误: 直连查询失败&#xff0c;内部异常:<class aeolus.aeolus.libs.exception.aeolus_base_exception.AeolusBaseException>: aeolus/logicQuery/logicQueryMysq…
阅读更多...
.NET 一款在线解密Web.config的脚本

.NET 一款在线解密Web.config的脚本

01阅读须知 此文所提供的信息只为网络安全人员对自己所负责的网站、服务器等&#xff08;包括但不限于&#xff09;进行检测或维护参考&#xff0c;未经授权请勿利用文章中的技术资料对任何计算机系统进行入侵操作。利用此文所提供的信息而造成的直接或间接后果和损失&#xf…
阅读更多...
攻防世界---＞re2-cpp-是-awesome

攻防世界---＞re2-cpp-是-awesome

学习笔记。 下载 查壳。 64ida打开。 直接ctrlX进行跟踪 逆向往前看。 没事&#xff0c;对解题并不影响。 编写脚本&#xff1a; ALEXCTF{W3_L0v3_C_W1th_CL45535}
阅读更多...
哈希表简单介绍

哈希表简单介绍

概念 在顺序结构以及平衡树中&#xff0c;元素关键字与他们存储的位置并没有直接的映射关系&#xff0c;从而会影响查找关键字的效率&#xff0c;顺序结构中查找关键字的时间复杂度为O&#xff08;N&#xff09;&#xff0c;平衡树查找关键字的时间复杂度为O&#xff08;log2^…
阅读更多...
.Net6/.Net8(.Net Core) IIS中部署 使用 IFormFile 上传大文件报错解决方案

.Net6/.Net8(.Net Core) IIS中部署 使用 IFormFile 上传大文件报错解决方案

描述 最近使用.Net6 WebAPI IFormFile对象接收上传文件时大于30MB(兆)的文件就会报错 原因分析 IIS上传文件有大小默认限制大约28.6MB 解决办法 .无论是Net6还是.Net8写法都一样 方法一&#xff1a;IIS可视化操作 1.打开Internet Information Services (llS)管理器&…
阅读更多...
Pandas读取某列、某行数据——loc、iloc区别

Pandas读取某列、某行数据——loc、iloc区别

loc&#xff1a;通过行、列的名称或标签来索引 iloc&#xff1a;通过行、列的索引位置来寻找数据 首先&#xff0c;我们先创建一个DataFrame生成数据 import pandas as pddata {a:[1,2,3,4,5],b:[6,7,8,9,10],c:[11,12,13,14,15] } data pd.DataFrame(data) print(data) 运行…
阅读更多...
关于【禁止new对象时在for循环内定义申明变量】

关于【禁止new对象时在for循环内定义申明变量】

文章目录 简介代码分析反编译之后对比性能测试内存与垃圾回收情况JDK和常用框架怎么写总结依赖 简介 不知道是谁最先提出了一个不要将变量定义在循环内。 然后我们在代码扫描中有一项是&#xff1a;【禁止new对象时在for循环内定义申明变量】 我也好奇为什么不能&#xff1f…
阅读更多...
e冒泡排序---复杂度O(X^2)

e冒泡排序---复杂度O(X^2)

排序原理: 1.比较相邻的元素。如果前一个元素比后一个元素大&#xff0c;就交换这两个元素的位置。 2.对每一对相邻元素做同样的工作,从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值, public class 冒泡排序 {public static void main(String[] args) {I…
阅读更多...
学习使用LangGraph x GPT-Researcher构建一个多智能体架构的AI自主研究助理

学习使用LangGraph x GPT-Researcher构建一个多智能体架构的AI自主研究助理

原文&#xff1a;学习使用LangGraph x GPT-Researcher构建一个多智能体架构的AI自主研究助理 - 百度智能云千帆社区 本文为大家剖析一个通过多智能体协作来完成的AI研究助理&#xff0c;可以用来帮助进行各种综合的在线研究任务并输出报告。该应用基于LangGraph以及开源的GPT-…
阅读更多...
electron有关mac构建

electron有关mac构建

针对 Mac M1/2/3 芯片的设备&#xff0c;proces.archarm64. 执行下面命令&#xff0c;检查下按照的 node.js 版本是不是 intel x64 指令集&#xff0c;如果是的话安装下 arm64 指令集的 node.js终端中执行以下命令&#xff1a;node -p process.arch 对应的node版本也是arm版 …
阅读更多...
YoloV10 训练自己的数据集（推理，转化，C#部署）

YoloV10 训练自己的数据集（推理，转化，C#部署）

目录 一、下载 三、开始训练 train.py detect.py export.py 超参数都在这个路径下 四、C#读取yolov10模型进行部署推理 如下程序是用来配置openvino 配置好引用后就可以生成dll了 再创建一个控件&#xff0c;作为显示 net framework 4.8版本的 再nuget工具箱里下载 …
阅读更多...
春之学习：SpringBoot在线教育平台构建

春之学习：SpringBoot在线教育平台构建

第三章 系统分析 3.1 系统设计目标 在线视频教育平台主要是为了用户方便对首页、个人中心、用户管理、教师管理、课程信息管理、课程类型管理、我的收藏管理、系统管理、订单管理等信息进行查询&#xff0c;也是为了更好的让管理员进行更好存储所有数据信息及快速方便的检索功能…
阅读更多...
僵尸网络开发了新的攻击技术和基础设施

僵尸网络开发了新的攻击技术和基础设施

臭名昭著的 Quad7 僵尸网络&#xff08;也称为 7777 僵尸网络&#xff09;不断发展其运营&#xff0c;最近的发现表明其目标和攻击方法都发生了重大变化。 根据 Sekoia.io 的最新报告&#xff0c;Quad7 的运营商正在开发新的后门和基础设施&#xff0c;以增强僵尸网络的弹性&a…
阅读更多...
K8s利用etcd定时备份集群结合钉钉机器人通知

K8s利用etcd定时备份集群结合钉钉机器人通知

如何通过脚本的方式进行K8s集群的备份 查看K8s中master节点中etcd集群的状态 kubectl get pods -n kube-system | grep etcd由于使用的etcd服务是K8s搭建时自身携带的，并不是独立搭建的etcd集群信息。使用 K8s 搭建集群时，etcd 是 Kubernetes 集成的一个重要组件因此需要查…
阅读更多...
DDR3AXI4接口读写仿真

DDR3AXI4接口读写仿真

前文已经介绍了DDR3和AXI4总线的相关知识&#xff0c;我们知道MIG ip核除了可以生成native接口还能生成AXI4接口&#xff0c;今天就练习一下将AXI4接口的DDR3打包成FIFO。首先我们生成一个AXI4接口的MIG ip核&#xff0c;其余步骤与Native接口的ip核相同&#xff0c;如果我们勾…
阅读更多...
vue3.0 使用echarts与echarts-gl 实现3D饼图

vue3.0 使用echarts与echarts-gl 实现3D饼图

效果 安装echarts npm install echarts npm install echarts-gl 3d饼图组件&#xff1a; <template><div style"width: 100%; height: 100%" ref"echart"></div> </template><script setup> import { reactive, ref, onMou…
阅读更多...
最新文章

Copyright @ 2022~2023