从零开始学习深度学习库-2：反向传播

欢迎来到本系列的第二篇文章，我们将从头开始构建一个深度学习库。
本博客系列的代码可以在这个Github仓库中找到。

上一篇文章

在上一篇文章中（链接见这里），我们实现了线性层和常见的激活函数，并成功构建了神经网络的前向传递。
到目前为止，我们的模型只能进行预测，但没有能力训练和纠正其预测。这正是我们今天要讲解的内容，通过实现一个称为反向传播的过程。

反向传播的工作概述

当神经网络进行训练时，它会被给定一个包含输入及其对应输出的数据集。
网络会根据数据集的输入产生预测，并计算其预测与数据集中给出的真实输出之间的偏差（这称为损失）。
训练神经网络的目标是最小化这个损失。
在计算出损失后，网络的权重和偏差会以某种方式进行调整，以减少损失值。记住在上一篇文章中提到，权重和偏差是我们可调节的网络参数，用于计算网络输出。
这个过程会重复数次，希望每次重复时损失都会减少。每次重复被称为一个时代（epoch）。

损失函数

虽然有许多不同的损失函数，但在这篇文章中，我们只会关注均方误差函数。未来的文章中会讨论更多损失函数。
损失函数接收网络的原始错误（通过预测输出 - 实际输出计算得出）并产生一个关于错误严重程度的度量。
均方误差（MSE）接收错误向量，并返回向量中所有平方值的平均值。
例如…

Network output: [1, 2, 3]
Actual outputs: [3, 2, 1]
Error: [-2, 0, 2]
Loss: 2.6666666 ( ( (-2)**2 + (0)**2 + (2)**2 ) / 3 )

在计算平均值之前先对误差进行平方的原因是为了使误差向量中的负值与正值同等对待（因为负数的平方是正数）。
下面是我们的Python类，用于实现均方误差（MSE）…

#loss.py

import numpy as np

class MSE:
    def __call__(self, pred, y):
        self.error = pred - y
        return np.mean(self.error ** 2)

反向传播

反向传播是网络的训练过程。
神经网络训练的目标是最小化损失。
这可以被视为一个优化问题，其解决方案在很大程度上依赖于微积分——更具体地说，是微分。

计算梯度

反向传播的第一步是找到网络中所有权重和偏差相对于损失函数的梯度。
我们用一个例子来演示…
我们的小型示例网络由以下部分组成：

  1. 线性层
  2. Sigmoid层
    所以整个网络的输出计算如下：
  • x - 网络输入
  • w - 线性层的权重
  • b - 线性层的偏差
  • a - 线性层输出
  • pred - 网络输出 / Sigmoid输出

在这里插入图片描述
在这里插入图片描述
现在让我们计算损失

  • y - 对于输入 x 的期望输出
    在这里插入图片描述
    在这里插入图片描述
    现在我们需要找到相对于损失的权重/偏差的梯度。
    在这里插入图片描述
    在这里插入图片描述
    这一步使用了链式法则。
    我们现在已经计算出了参数相对于损失的梯度。
    计算某一层相对于损失的权重/偏差梯度的一般规则是：
  1. 对每一层的输出相对于其输入进行微分（从最后一层开始，直到达到你想要调整参数的那一层）
  2. 将所有这些结果相乘，称之为 grad
  3. 一旦到达所需的层，对其输出相对于其权重进行微分（称这个为 w_grad），并对其偏差进行微分（称这个为 b_grad）。
  4. 将 w_grad 和 grad 相乘以获得相对于该层权重的损失梯度。对 b_grad 做同样的操作，以获得相对于该层偏差的损失梯度。

有了这个思路，下面是我们所有层和MSE的代码。

#loss.py

import numpy as np

class MSE:
    def __call__(self, pred, y):
        self.error = pred - y
        return np.mean(self.error ** 2)

    def backward(self):
        return 2 * (1 / self.error.shape[-1]) * self.error 

#layers.py

import numpy as np


class Activation:
    def __init__(self):
        pass

class Layer:
    def __init__(self):
        pass

class Model: 
    def __init__(self, layers):
        self.layers = layers

    def __call__(self, x):
        output = x
        for layer in self.layers:
            output = layer(output)

        return output

class Linear(Layer):
    def __init__(self, units):
        self.units = units
        self.initialized = False

    def __call__(self, x):
        self.input = x
        if not self.initialized:
            self.w = np.random.rand(self.input.shape[-1], self.units)
            self.b = np.random.rand(self.units)
            self.initialized = True

        return self.input @ self.w + self.b

    def backward(self, grad):
        self.w_gradient = self.input.T @ grad
        self.b_gradient = np.sum(grad, axis=0)
        return grad @ self.w.T

class Sigmoid(Activation):
    def __call__(self, x):
        self.output = 1 / (1 + np.exp(-x))

        return self.output

    def backward(self, grad):
        return grad * (self.output * (1 - self.output))

class Relu(Activation):
    def __call__(self, x):
        self.output = np.maximum(0, x)   
        return self.output

    def backward(self, grad):
        return grad * np.clip(self.output, 0, 1)

class Softmax(Activation):
    def __call__(self, x):
        exps = np.exp(x - np.max(x))
        self.output = exps / np.sum(exps, axis=1, keepdims=True)
        return self.output

    def backward(self, grad):
        m, n = self.output.shape
        p = self.output
        tensor1 = np.einsum('ij,ik->ijk', p, p)
        tensor2 = np.einsum('ij,jk->ijk', p, np.eye(n, n))
        dSoftmax = tensor2 - tensor1
        dz = np.einsum('ijk,ik->ij', dSoftmax, grad) 
        return dz

class Tanh(Activation):
    def __call__(self, x):
        self.output = np.tanh(x)

        return self.output

    def backward(self, grad):
        return grad * (1 - self.output ** 2)

每个类中的 backward 方法是一个函数，用于对层的输出相对于其输入进行微分。
随意查阅每个激活函数的导数，这将使代码更加易于理解。
线性层的 backward 函数不同，因为它不仅计算了输出相对于输入的梯度，还计算了相对于其参数的梯度。

注意
矩阵乘法的微分规则如下，其中 x 和 y 是被相乘的矩阵。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用随机梯度下降优化参数

优化网络参数的方法有很多，但在这篇文章中，我们将介绍最基本的方法，即随机梯度下降（SGD）。
SGD非常简单。它将每个参数计算出的梯度乘以一个指定的学习率。然后，相应的参数减去这个结果。
使用学习率的原因是为了控制网络学习的速度。
最佳学习率值在少量的时代内最小化成本。
过小的学习率也能最小化成本，但需要经过多个时代，因此会花费时间。
过大的学习率会使损失逼近一个非最小值，因此网络无法正确训练。
下面是MSE的代码。

#optim.py

import layers
import tqdm
#Tqdm是一个进度条，所以我们可以看到代码运行的进度

class SGD:
    def __init__(self, lr = 0.01):
        self.lr = lr

    def __call__(self, model, loss):
        grad = loss.backward()

        for layer in tqdm.tqdm(model.layers[::-1]):
            grad = layer.backward(grad) #计算图层参数梯度

            if isinstance(layer, layers.Layer):
                layer.w -= layer.w_gradient * self.lr
                layer.b -= layer.b_gradient * self.lr

随着网络训练所需的一切都已准备就绪，我们可以在我们的模型中添加一个训练函数。

#layers.py

import numpy as np
import loss
import optim
np.random.seed(0)

#...

class Model: 
    def __init__(self, layers):
        self.layers = layers

    def __call__(self, x):
        output = x
        for layer in self.layers:
            output = layer(output)

        return output

    def train(self, x, y, optim = optim.SGD(), loss=loss.MSE(), epochs=10):
        for epoch in range(1, epochs + 1):
            pred = self.__call__(x)
            l = loss(pred, y)
            optim(self, loss)
            print (f"epoch {epoch} loss {l}")

#...

测试一下！

我们将构建并训练一个神经网络，使其能够作为异或门（XOR gate）。
异或门接收两个输入。输入可以是 0 或 1（代表假或真）。
如果两个输入相同，则门输出 0。
如果两个输入不同，则门输出 1。

#main.py

import layers
import loss
import optim
import numpy as np


x = np.array([[0, 1], [0, 0], [1, 1], [0, 1]])
y = np.array([[1],[0],[0], [1]]) 

net = layers.Model([
    layers.Linear(8),
    layers.Relu(),
    layers.Linear(4),
    layers.Sigmoid(),
    layers.Linear(1),
    layers.Sigmoid()
])

net.train(x, y, optim=optim.SGD(lr=0.6), loss=loss.MSE(), epochs=400)

print (net(x))

`` Output ... epoch 390 loss 0.0011290060124405485 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 391 loss 0.0011240809175767955 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 392 loss 0.0011191976855805586 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 393 loss 0.0011143557916784605 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 394 loss 0.0011095547197546522 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 395 loss 0.00110479396217416 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 396 loss 0.0011000730196106248 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 397 loss 0.0010953914008780786 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 398 loss 0.0010907486227668803 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 399 loss 0.0010861442098835058 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s] epoch 400 loss 0.0010815776944942087 [[0.96955654] [0.03727081] [0.03264158] [0.96955654]] ``

正如您所见，结果非常好，与真实输出相差不远（0.001 的损失非常低）。
我们还可以调整模型，使其适用于其他激活函数。

#main.py

import layers
import loss
import optim
import numpy as np


x = np.array([[0, 1], [0, 0], [1, 1], [0, 1]])
y = np.array([[0, 1], [1, 0], [1, 0], [0, 1]]) 

net = layers.Model([
    layers.Linear(8),
    layers.Relu(),
    layers.Linear(4),
    layers.Sigmoid(),
    layers.Linear(2),
    layers.Softmax()
])

net.train(x, y, optim=optim.SGD(lr=0.6), loss=loss.MSE(), epochs=400)

print (net(x)) 

Output
epoch 390 loss 0.00045429759266240227
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 391 loss 0.0004524694487356741
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 392 loss 0.000450655387643655
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 393 loss 0.00044885525012255907
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<00:00, 6236.88it/s]
epoch 394 loss 0.00044706887927775473
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 395 loss 0.0004452961205401462
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<00:00, 5748.25it/s]
epoch 396 loss 0.0004435368216234964
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 397 loss 0.00044179083248269265
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 398 loss 0.00044005800527292425
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 399 loss 0.00043833819430972714
100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 6/6 [00:00<?, ?it/s]
epoch 400 loss 0.0004366312560299245
[[0.01846441 0.98153559]
 [0.97508489 0.02491511]
 [0.97909267 0.02090733]
 [0.01846441 0.98153559]]

我们已经成功构建了一个有效的神经网络。这可以成功应用于更有用的事物，比如MNIST数据集，我们很快会在另一篇文章中使用它。
下一篇文章将介绍更多的损失函数和更多的优化函数。
感谢阅读！

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

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

相关文章

浅谈HTTP 和 HTTPS (中间人问题)

浅谈HTTP 和 HTTPS (中间人问题)

前言 由于之前的文章已经介绍过了HTTP , 这篇文章介绍 HTTPS 相对于 HTTP 做出的改进 开门见山: HTTPS 是对 HTTP 的加强版 主要是对一些关键信息 进行了加密 一.两种加密方式 1.对称加密 公钥 明文 密文 密文 公钥 明文 2.非对称加密 举个例子就好比 小区邮箱 提供一…
阅读更多...
Python学习笔记-Flask实现简单的投票程序

Python学习笔记-Flask实现简单的投票程序

1.导入flask包 from flask import Flask,jsonify,abort,make_response,request,render_template 2.初始化 Flask 应用: app Flask(__name__) 3. 定义投票种类 data [{id:0,name:劳动节,num:0},{id:1,name:国庆节,num:0},{id:2,name:春节,num:0} ] 4.app.route(/index): …
阅读更多...
2024考研计算机考研复试-每日重点（第二十期）

2024考研计算机考研复试-每日重点（第二十期）

公众号“准研计算机复试”&#xff0c;超全大佬复试资料&#xff0c;保姆级复试&#xff0c;80%的题目都是上岸大佬提供的。 研宝们&#xff0c;App更新啦&#xff01; 计算机组成原理&#xff1a; 10.☆什么是数据存储的大端模式和小端模式&#xff1f; 大端模式&#xff1a;数…
阅读更多...
github拉取项目找不到前端代码

github拉取项目找不到前端代码

今天从github上拉取了一个项目&#xff0c;使用docker部署在了服务器上&#xff0c; 代码正常运行&#xff0c;但是想在下载的项目中找前端代码遇到了问题&#xff0c;项目结构中的template模板只有一个页面&#xff0c;于是查看nginx配置文件 查看index.html 引入了一些js文件…
阅读更多...
EasyRecovery恢复电脑丢失数据怎么样?

EasyRecovery恢复电脑丢失数据怎么样?

电脑是我们大家熟悉并且常用的数据存储设备&#xff0c;也是综合性非常强的数据处理设备。对于电脑设备来讲&#xff0c;最主要的数据存储介质是硬盘&#xff0c;电脑硬盘被划分成多个分区&#xff0c;在电脑上表现为C盘&#xff0c;E盘等&#xff0c;用来保存系统文件以及其他…
阅读更多...
easyrecovery破解版百度云（含Mac/Win版）以及EasyRecovery可以恢复哪些设备

easyrecovery破解版百度云（含Mac/Win版）以及EasyRecovery可以恢复哪些设备

软件介绍 当不小心将回收站的文件删除了怎么办&#xff1f;想找回但是不知道怎么找回需要的数据文件&#xff1f;别担心今天小编就为大家介绍一款非常专业的电脑数据文件恢复工具&#xff0c;easyrecovery14是由Ontrack专为电脑用户推出的一款专业的数据恢复软件&…
阅读更多...
IT廉连看——Uniapp——模板语法

IT廉连看——Uniapp——模板语法

IT廉连看——Uniapp——模板语法 众所周知&#xff0c;Uniapp是使用vue.js框架开发出来的&#xff0c;所以说它可以使用vue中的语法和指令来开发我们的项目。如果没有学习过vue的话开发起来会比较吃力&#xff0c;所以这节课就带大家学习几个常用的vue知识。如果有学习过vue&a…
阅读更多...
【编码魔法师系列_结构型5】外观模式（Facade Pattern）

【编码魔法师系列_结构型5】外观模式（Facade Pattern）

学会设计模式&#xff0c;你就可以像拥有魔法一样&#xff0c;在开发过程中解决一些复杂的问题。设计模式是由经验丰富的开发者们&#xff08;GoF&#xff09;凝聚出来的最佳实践&#xff0c;可以提高代码的可读性、可维护性和可重用性&#xff0c;从而让我们的开发效率更高。通…
阅读更多...
改三行代码就发了SCI一区？基于全面学习策略的Jaya算法！学会你也可以！CEC2017效果极佳！

改三行代码就发了SCI一区？基于全面学习策略的Jaya算法！学会你也可以！CEC2017效果极佳！

声明&#xff1a;文章是从本人公众号中复制而来&#xff0c;因此&#xff0c;想最新最快了解各类智能优化算法及其改进的朋友&#xff0c;可关注我的公众号&#xff1a;强盛机器学习&#xff0c;不定期会有很多免费代码分享~ 目录 原始Jaya算法 改进Jaya算法策略详解&…
阅读更多...
基于Verilog的简易CPU设计

基于Verilog的简易CPU设计

前言 本篇文章将简单讲解CPU之间各部分的功能及接线&#xff0c;并提供Verilog模拟CPU的各个组成部分。该CPU可以完成一些操作&#xff0c;如&#xff1a;加减法&#xff0c;与或&#xff0c;指令跳转等&#xff0c;最后提供testbench用于测试该CPU的工作情况是否符合预期。 C…
阅读更多...
keycloak18.0.0==前后端分离项目中使用，前端react后端springboot

keycloak18.0.0==前后端分离项目中使用，前端react后端springboot

配置keycloak 启动keycloak18 新建一个realm,名字叫test1 新建两个client&#xff0c;一个用于前端&#xff0c;一个用于后端 第一个 react http://localhost:8081/auth/realms/test1/react/ 第二个 backend-service 在两个client下分别创建role testRole backend-servic…
阅读更多...
CF575H Bots 题解 组合数学

CF575H Bots 题解 组合数学

Bots&#xff08;波特&#xff09; 传送门 Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The ga…
阅读更多...
生产企业如何发现瓶颈工序并解决它

生产企业如何发现瓶颈工序并解决它

众所周知&#xff0c;瓶颈工序决定整体产能&#xff0c;产能均衡是高效生产的重要保证&#xff0c;在100个工序中&#xff0c;只要存在一个工序效率低下&#xff0c;那么99个工序的努力都无法解决整体产能落后的问题。 如何解决瓶颈工序产能不足问题&#xff0c;进而提高工厂整…
阅读更多...
k8s部署InfluxDB

k8s部署InfluxDB

&#xff08;作者&#xff1a;陈玓玏&#xff09; 1. 拉取镜像 docker pull influxdb #拉取镜像 docker run -d influxdb:latest #后台运行容器 docker exec -it 89b /bin/bash #进入容器&#xff0c;89b是容器ID的前三位 cd /usr/bin #进入容器后&#xff0c;进入此文件夹…
阅读更多...
【WPS】压缩图片

【WPS】压缩图片

第一步&#xff1a; 点击插入&#xff0c;点击图片 第二步&#xff1a; 点击图片工具&#xff0c;点击压缩图片 第三步&#xff1a;
阅读更多...
Git 遇到合并冲突如何解决

Git 遇到合并冲突如何解决

Git 遇到合并冲突解决方法 前言一、解决冲突 回滚二、将解冲突后的文件 提交到暂存区三、git commit 提交代码到本地Git仓库四、git push 提交五、注意 ​ 2024/3/13 前言 Git突然无法拉取下来&#xff0c;显示有合并冲突&#xff1a; 步骤&#xff1a;解决回滚解决冲突后、添…
阅读更多...
数据结构-链表（二）

数据结构-链表（二）

1.两两交换列表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2…
阅读更多...
[HackMyVm] Vinulizer

[HackMyVm] Vinulizer

kali:192.168.56.104 主机发现 arp-scan -l # arp-scan -l Interface: eth0, type: EN10MB, MAC: 00:0c:29:d2:e0:49, IPv4: 192.168.56.104 Starting arp-scan 1.10.0 with 256 hosts (https://github.com/royhills/arp-scan) 192.168.56.1 0a:00:27:00:00:05 (Un…
阅读更多...
CCCorelib 点云ICP配准（CloudCompare内置算法库）

CCCorelib 点云ICP配准（CloudCompare内置算法库）

文章目录 一、简介二、实现代码三、实现效果参考资料一、简介 ICP算法总共分为6个阶段，如下图所示： （1）挑选发生重叠的点云子集，这一步如果原始点云数据量比较巨大，一般会对原始点云进行下采样操作。 （2）匹配特征点。通常是距离最近的两个点，当然这需要视评判的准则而…
阅读更多...
mysql不能远程连接的解决办法

mysql不能远程连接的解决办法

问题: 安装完mysql之后,在本机可以正常使用,但是通过其它电脑不能远程连接. 解决方案: 在安装mysql的电脑上,登录mysql, 执行权限 GRANT ALL PRIVILEGES ON *.* TO root"%" IDENTIFIED BY "password"; 刷新权限 flush privileges;
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站