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

最新推荐文章于 2024-10-17 16:14:01 发布
最新推荐文章于 2024-10-17 16:14:01 发布
阅读量1.1k 收藏 18
点赞数 16
分类专栏： AI大模型技术积累 技术分享 Python 文章标签： 机器学习 numpy 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43799388/article/details/142078366
版权

文章目录


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

网络搭建

这里我们以训练 全连接神经网络 为例，也就是输入层，隐藏层和输出层都是 全连接层，激活函数选择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]
嗜睡的篠龙
关注
专栏目录
用numpy实现一个神经网络
羊城迷鹿的博客
03-20 1637
步骤 定义拥有一个隐层的神经网络，完成前向和后向传播的算法。（方便起见仅使用weight不使用bias） 加载数据并查看其分布。 对数据进行一些处理。 进行多轮训练。 画图并检验预测效果 # 加载必要模块 import numpy as np import pandas as pd np.random.seed(1024) 设计每一层的结构 ...
PyTorch深度学习实战（1）——神经网络与模型训练过程详解
热门推荐
盼小辉丶的博客
05-28 6万+
在本节中，我们将了解传统机器学习与人工神经网络间的差异，并了解如何在实现前向传播之前连接网络的各个层，以计算与网络当前权重对应的损失值；实现反向传播以优化权重达到最小化损失值的目标。并将实现网络的所有关键组成——前向传播、激活函数、损失函数、链式法则和梯度下降，从零开始构建并训练了一个简单的神经网络。
利用Numpy实现全连接神经网络实验分析
qq_61012545的博客
09-28 1029
用 python 的 numpy 模块实现全连接神经网络。网络结构为一个输入层、一个隐藏层、一个输出层。隐藏层的激活函数为 Relu 函数，输出层的激活函数为 softmax 函数，损失函数为交叉熵。
使用numpy手写一个神经网络
莫比的博客
05-27 2001
使用python写一个简单的神经网络
卷积神经网络（python实现）
最新发布
2201_75480557的博客
10-17 636
类似于卷积层，步幅决定了池化窗口的移动速度，影响输出特征图的尺寸。：自适应矩估计（Adam），是深度学习中最常用的优化器，结合了动量和自适应学习率，适用于大多数任务。：在输入图像的边缘添加像素，使得输出特征图的尺寸与输入图像相同（步幅为 1 时）。层将多维的输入数据展平为一维，通常在卷积层之后，用于将卷积特征图连接到全连接层。：当输入值为负时，输出为零，可能导致“神经元死亡”问题（即神经元的输出恒为零）。：控制卷积核的移动速度。将输入转换为概率分布，输出的值加起来为 1，常用于多分类问题的输出层。
零基础入门深度学习（一）：用numpy实现神经网络训练
Cry2engine的博客
01-06 727
授课讲师 | 毕然 百度深度学习技术平台部主任架构师 授课时间 | 每周二、周四晚20:00-21:00 编辑整理 | 刘威威 内容来源 | 百度飞桨深度学习集训营 本课程是百度官方开设的零基础入门深度学习课程，主要面向没有深度学习技术基础或者基础薄弱的同学，帮助大家实现从0到1的跨越。从本课程中，你将学习到： 深度学习基础知识 numpy实现神经网络构建和梯...
使用numpy实现神经网络
lianwaiyuwusheng的博客
11-05 1107
使用numpy实现神经网络 """ 1. 获取输入数据和标签 2. 定义网络，前向传播得到输出 3. 定义损失函数， 4. 训练，反向传播更新网络参数 """ import numpy as np N, D_in, H, D_out = 64, 1000, 100, 10 # 输入x和标签y x = np.random.randn(N, D_in) y = np.random.randn(N, D_out) # 初始化参数 w1 = np.random.randn(D_in, H) w2 = np.
Numpy 实现神经网络
颹蕭蕭
04-09 7603
#coding:utf-8 import numpy as np #定义激活函数和他们的导数 def tanh(x): return np.tanh(x) def tanh_deriv(x): return 1.0 - np.tanh(x)**2 def logistic(x): return 1/(1 + np.exp(-x...
用numpy搭建自己的神经网络
m0_73084903的博客
03-03 1008
构建模型的基本思想：构建深度学习的过程：产生idea，将idea转化成code，最后进行experiment，之后根据结果修改idea，继续idea–>code–>experiment的循环，直到最终训练到表现不错的深度学习网络模型。
机器学习中的numpy库
xiaomu_347的博客
01-02 1205
日常学习中总是遇到数据需要处理等问题，这时候我们就可以借助numpy这个工具来做一些有意思的事。 1.生成随机数的几种方式 x=np.random.random(12) ###生成12个随机数，也可以写成np.random.rand(12)、 np.random.random_integers、np.random.uniform、...
machine-learning:机器学习算法的Numpy，PyTorch和TensorFlow实现
04-04
在本项目中，"machine-learning:机器学习算法的Numpy，PyTorch和TensorFlow实现" 是一个关于使用Python编程语言以及Numpy、PyTorch和TensorFlow等库实现机器学习算法的资源库。这个仓库的目标是为学习者提供一个实践...
一种强大的机器学习算法，利用Q学习和神经网络，使用Torch和Lua实现
10-08
此外，Torch还拥有丰富的深度学习库，如nn模块用于构建神经网络，optim模块用于优化算法，以及torchnet用于构建更复杂的网络架构和训练流程。 Lua是一种轻量级、高性能的脚本语言，以其简洁的语法和灵活的嵌入性...
Keras深度学习实战（1）——神经网络基础与模型训练过程详解
盼小辉丶的博客
04-10 5万+
神经网络是一种性能强大的学习算法，其灵感来自大脑的运作方式。类似于神经元在大脑中彼此连接的方式，神经网络获取输入后，通过某些函数在网络中进行传递输入信息，连接在其后的一些神经元会被激活，从而产生输出。本文主要介绍神经网络中重要的基础知识，然后使用 Python 从零开始构建神经网络的训练流程，包括前向传播和反向传播，更直观的了解神经网络的通用训练流程。............
手把手教你使用Python和Numpy实现MNIST全连接网络训练
2. 神经网络训练： - 神经网络是一种模拟人脑神经元结构的信息处理系统，用于机器学习任务中的模式识别、分类等。 - 训练神经网络通常包括定义网络结构、初始化权重、前向传播输入数据、计算损失函数、反向传播...
NumPy实现神经网络
weixin_41064538的博客
10-28 563
好久没写博客了，今天突然想到用numpy来实现神经网络，想到就开始干吧。相信大家都对神经网络有了一些了解，在这里我就尽量只写代码，可能会比较枯燥，但是我相信会对一些初学者有帮助。 首先我们定义一个列表，其中包含网络的每一层，类似如下： lst_nn_layers=[ {"input_dim": 324, "output_dim": 512, "activation": "relu"}, {"input_dim": 512, "output_dim": 256, "activation":
numpy搭建简易神经网络(保姆级教程)
m0_63867120的博客
10-28 3358
本篇文章详细教如何用numpy手动搭建一个简单的两层神经网络，对每一步的操作都有详细的解释。涉及正向传播，反向传播，链式求导。参考教材：邱锡鹏《神经网络与深度学习》
用Numpy实现简单的神经网络
unseven的博客
06-04 1328
实现最简单的神经网络。在此次练习中，体会神经网络的一层如何构造，体会反向传播和梯度下降法对网络更新的作用，最后探讨了小批量随机梯度下降的使用。
使用Numpy实现一个神经网络
qq1344574215的博客
06-29 281
import numpy as np N, D_in, H, D_out = 64, 1000, 100, 10 x = np.random.randn(N, D_in) y = np.random.randn(N, D_out) w1 = np.random.randn(D_in, H) w2 = np.random.randn(H, D_out) lr = 1e-6 for i in range(500): # forward pass hidden_act = x.dot(w1) #.
用NumPy实现神经网络（Mysteries of Neural Networks Part III）
qq_47997583的博客
06-21 654
使用像Keras、TensorFlow或PyTorch这样的高级框架允许我们快速构建非常复杂的模型。 然而，花点时间看看内部情况并理解底层概念是值得的。 从一开始我就打算以一种更实际的方式来跟进这个话题。这一次，我们将尝试利用我们的知识，仅使用NumPy构建一个完全可操作的神经网络。最后，我们也将测试我们的模型-解决简单的分类问题，并将其性能与Keras建立的神经网络对比。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嗜睡的篠龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值