自定义神经网络四之编写自定义神经网络

news2025/1/19 16:56:40

文章目录

    • 前言
    • 神经网络组件代码
      • 整体的项目结构
      • Tensor张量
      • Layers层
      • NeuralNet神经网络
      • Loss损失函数
      • Optim优化器
      • data数据处理
      • train训练
    • 神经网络解决实际问题
      • 实际问题
      • 训练和推理代码
    • 总结

前言

自定义神经网络一之Tensor和神经网络
自定义神经网络二之模型训练推理
自定义神经网络三之梯度和损失函数激活函数

经过前几篇的铺垫，终于到了自定义神经网络的部分。这也是博主一开始的目标，不使用任何框架，跟着大佬手撸一个神经网络，然后run起来。
目标如下：

  1. 实践神经网络中的基础组件，例如Tensor，神经网络层，优化器，损失函数，激活函数等
  2. 手动实践模型的训练，推理，解决实际的问题
  3. 保存模型到本地，并且通过加载本地模型实现推理任务。

整篇文章的代码来源：(需要科学上网)
https://www.youtube.com/watch?v=o64FV-ez6Gw
https://github.com/joelgrus/joelnet

神经网络组件代码

整体的项目结构

image.png
joelnet就是大佬封装的神经网络的类。麻雀虽小，五脏俱全。其他的神经网络框架，比如pytorch等，相对来说是丰富了主干，但万变不离其宗。 大佬没有使用其他的第三方库，纯python手撸的神经网络类，值得学习。

Tensor张量

from numpy import ndarray as Tensor

我们这里不需要使用GPU来进行并行加速，因此使用python的ndarray就足够了，表示多维数组。

Layers层

from typing import Dict, Callable

import numpy as np

from joelnet.tensor import Tensor


class Layer:
    def __init__(self) -> None:
        self.params: Dict[str, Tensor] = {}
        self.grads: Dict[str, Tensor] = {}

    def forward(self, inputs: Tensor) -> Tensor:
        """
        Produce the outputs corresponding to these inputs
        """
        raise NotImplementedError

    def backward(self, grad: Tensor) -> Tensor:
        """
        Backpropagate this gradient thought the layer
        """
        raise NotImplementedError


class Linear(Layer):
    """
    computes output = input @ w + b
    这是一个线性层，也叫全连接层，在神经网络中非常常见。
    """
    def __init__(self, input_size: int, output_size: int) -> None:
        # inputs will be (bitch_size, input_size)
        # outputs will be (bitch_size, output_size)
        super().__init__()
        self.params["w"] = np.random.randn(input_size, output_size)
        self.params["b"] = np.random.randn(output_size)
    # 线性变换，其中@代表矩阵乘法，W是权重矩阵，b是偏差项（或称为偏置）
    def forward(self, inputs: Tensor) -> Tensor:
        """
        outputs = inputs @ w + b
        """
        self.inputs = inputs
        return inputs @ self.params["w"] + self.params["b"]

    # 计算误差，计算梯度，后续就可以使用优化算法（比如梯度下降）来更新参数W和b
    def backward(self, grad: Tensor) -> Tensor:
        # 当前层输出的梯度对偏差b的梯度，也就是误差项对偏差b的偏导数
        self.grads["b"] = np.sum(grad, axis=0)
        # 当前层输出的梯度对权重w的梯度，也就是误差项对权重w的偏导数
        self.grads["w"] = self.inputs.T @ grad
        # 计算损失对该层输入的梯度，这个梯度会被反向传播到前一层。
        return grad @ self.params["w"].T


"""
定义了一个类型 F。
F 类型的对象是一个函数，该函数接受一个 Tensor 类型的参数，并且返回一个 Tensor 类型的结果。
任何接受一个 Tensor 类型参数并返回一个 Tensor 类型结果的函数都可以被认为是 F 类型的函数。
"""
F = Callable[[Tensor], Tensor]


class Activation(Layer):
    """
    An activation layer just applies a function
    elementwise to its inputs
    激活层，构造函数的参数是：函数f和函数f的导数f_prime
    """
    def __init__(self, f: F, f_prime: F) -> None:
        super().__init__()
        self.f = f
        self.f_prime = f_prime

    def forward(self, inputs: Tensor) -> Tensor:
        self.inputs = inputs
        return self.f(inputs)

    def backward(self, grad: Tensor) -> Tensor:
        """
        if y = f(x) and x = g(z)
        then dy/dz = f'(x) * g'(z)
        """
        return self.f_prime(self.inputs) * grad


def tanh(x: Tensor) -> Tensor:
    return np.tanh(x)


def tanh_prime(x: Tensor) -> Tensor:
    y = tanh(x)
    return 1 - y ** 2


"""
tanh 是一种常见的激活函数，它的输出范围是 (-1, 1)。这样的输出范围通常
可能使得训练更加稳定，因为它可以把输入的数据标准化到一个比较小的范围。
"""


# Tanh 类是一个具体的激活层实现，它使用了 tanh 函数以及其导函数 tanh_prime。
class Tanh(Activation):
    def __init__(self) -> None:
        super().__init__(tanh, tanh_prime)

定义层代码，包括每层的参数，如权重，偏置等。 定义线性层，实现前向传播和反向传播的逻辑。
同时定义层的激活函数，给神经元添加一些非线性因素，使得神经网络可以逼近任何复杂函数，提高神经网络模型的表达能力。

NeuralNet神经网络

from typing import Sequence, Iterator, Tuple

from joelnet.tensor import Tensor
from joelnet.layers import Layer


class NeuralNet:
    def __init__(self, layers: Sequence[Layer]) -> None:
        self.layers = layers

    def forward(self, inputs: Tensor) -> Tensor:
        for layer in self.layers:
            inputs = layer.forward(inputs)
        return inputs

    def backward(self, grad: Tensor) -> Tensor:
        for layer in reversed(self.layers):
            grad = layer.backward(grad)
        return grad

    def params_and_grads(self) -> Iterator[Tuple[Tensor, Tensor]]:
        for layer in self.layers:
            for name, param in layer.params.items():
                grad = layer.grads[name]
                yield param, grad

定义神经网络，这里主要是构造神经网络结构，把上面定义的层给加进去。 params_and_grads函数主要是输出每层的权重参数和梯度，方便后续的优化器使用。

Loss损失函数

import numpy as np

from joelnet.tensor import Tensor


class Loss:
    def loss(self, predicted: Tensor, actual: Tensor) -> float:
        raise NotImplementedError

    def grad(self, predicted: Tensor, actual: Tensor) -> Tensor:
        raise NotImplementedError


class MSE(Loss):
    """
    MSE is mean squared error, although we're just
    going to do total squared error
    """
    def loss(self, predicted: Tensor, actual: Tensor) -> float:
        return np.sum((predicted - actual) ** 2)

    def grad(self, predicted: Tensor, actual: Tensor) -> Tensor:
        return 2 * (predicted - actual)

定义**均方误差损失函数。 **计算方法为预测值与真实值之差的平方和的均值。MSE对于大的误差值具有很高的惩罚程度，因为差值会被平方。

Optim优化器

"""
We use an optimizer to adjust the parameters
of our network based on the gradients computed
during backprepagation
实现了一个名为SGD（随机梯度下降）的优化器，这是一种用于神经网络训练的常见优化算法。
在每个训练步骤里，它会调整神经网络的参数以达到减小损失函数的目的。
也就是一直说的梯度下降算法
"""
from joelnet.nn import NeuralNet


class Optimizer:
    def step(self, net: NeuralNet) -> None:
        raise NotImplementedError


class SGD(Optimizer):
    def __init__(self, lr: float = 0.01) -> None:
        self.lr = lr

    def step(self, net: NeuralNet) -> None:
        for param, grad in net.params_and_grads():
            param -= self.lr * grad

这里的学习率可以调整，学习率小的话，训练时间会变长，收敛的慢。学习率过大的话，收敛慢，甚至可能会导致不收敛。

data数据处理

from typing import Iterator, NamedTuple

import numpy as np

from joelnet.tensor import Tensor

Batch = NamedTuple("Batch", [("inputs", Tensor), ("targets", Tensor)])


class DataIterator:
    def __call__(self, inputs: Tensor, targets: Tensor) -> Iterator[Batch]:
        raise NotImplementedError


class BatchIterator(DataIterator):
    def __init__(self, batch_size: int = 32, shuffle: bool = True) -> None:
        self.batch_size = batch_size
        self.shuffle = shuffle

    def __call__(self, inputs: Tensor, targets: Tensor) -> Iterator[Batch]:
        starts = np.arange(0, len(inputs), self.batch_size)
        # 打乱数据
        if self.shuffle:
            np.random.shuffle(starts)
        # 根据batch_size对数据分批次
        for start in starts:
            end = start + self.batch_size
            batch_inputs = inputs[start:end]
            batch_targets = targets[start:end]
            yield Batch(batch_inputs, batch_targets)

这个文件的目的是在训练神经网络时，按批次获取输入数据和目标数据，以方便神经网络进行分批训练

train训练

from joelnet.tensor import Tensor
from joelnet.nn import NeuralNet
from joelnet.loss import Loss, MSE
from joelnet.optim import Optimizer, SGD
from joelnet.data import DataIterator, BatchIterator


def train(net: NeuralNet,
          inputs: Tensor,
          targets: Tensor,
          num_epochs: int = 5000,
          iterator: DataIterator = BatchIterator(),
          loss: Loss = MSE(),
          optimizer: Optimizer = SGD()) -> None:
    for epoch in range(num_epochs):
        epoch_loss = 0.0
        for batch in iterator(inputs, targets):
            predicted = net.forward(batch.inputs)
            epoch_loss += loss.loss(predicted, batch.targets)
            grad = loss.grad(predicted, batch.targets)
            net.backward(grad)
            optimizer.step(net)
        print(epoch, epoch_loss)

参数分别是：

  1. 输出和输出数据
  2. 训练5000代
  3. 数据迭代器
  4. 损失函数和优化器

训练逻辑如下：

  1. 迭代数据，获取输入，传入到神经网络
  2. 根据预测值和期望结果，计算神经网络的误差
  3. 获取神经网络梯度，进行反向传播，更新参数
  4. 优化器调整根据学习率调整梯度

神经网络解决实际问题

实际问题

输入1到100的数值，期望：

  • 数值可以整除3，输出fizz
  • 数值可以整除5，输出buzz
  • 数值可以整除3和5，输出fizzbuzz
  • 不符合条件的数值原样输出

训练和推理代码

from typing import List

import numpy as np
import pickle

from joelnet.train import train
from joelnet.nn import NeuralNet
from joelnet.layers import Linear, Tanh
from joelnet.optim import SGD


def fizz_buzz_encode(x: int) -> List[int]:
    if x % 15 == 0:
        return [0, 0, 0, 1]
    elif x % 5 == 0:
        return [0, 0, 1, 0]
    elif x % 3 == 0:
        return [0, 1, 0, 0]
    else:
        return [1, 0, 0, 0]


# 整数转换成二进制编码，可以减小输入数据规模
# 神经网络不能直接理解整数，转换成二进制编码可以为
# 神经网络提供了一种更有效的信息表达方式，使得网络能从中学习到更多有用的信息。
def binary_encode(x: int) -> List[int]:
    """
    10 digit binary encoding of x
    """
    return [x >> i & 1 for i in range(10)]


# 训练数据是从101-1024之间的数字
inputs = np.array([
    binary_encode(x)
    for x in range(101, 1024)
])

# 列表生成式语法：[表达式 for 元素 in 可迭代对象]
targets = np.array([
    fizz_buzz_encode(x)
    for x in range(101, 1024)
])

# 两层线性变换神经网络
net = NeuralNet([
    Linear(input_size=10, output_size=50),
    Tanh(),
    Linear(input_size=50, output_size=4)
])

train(net,
      inputs,
      targets,
      num_epochs=50000,
      optimizer=SGD(lr=0.001))

print("save model")
# 保存模型。模型的大小和神经元的个数，层数等有关系
# 神经网络output_size=50的时候，模型大小是41k
# 神经网络output_size=60的时候，模型大小是48k
# 神经网络output_size=50，且设置为3层的时候，模型大小51k
with open('fizzbuzz.pkl', 'wb') as f:
    pickle.dump(net, f)


# 读取模型，进行推理
with open('fizzbuzz.pkl', 'rb') as f:
    loaded_net = pickle.load(f)

# 传入输入数据，获取模型推理结果
for x in range(1, 101):
    predicted = loaded_net.forward(binary_encode(x))
    predicted_idx = np.argmax(predicted)
    actual_idx = np.argmax(fizz_buzz_encode(x))
    labels = [str(x), "fizz", "buzz", "fizzbuzz"]
    # 输出预测值和实际应该返回的值
    print(x, labels[predicted_idx], labels[actual_idx])

注意，这里的训练epoch和lr学习率都可以自己调整的，博主这里分别调整到了训练5w次和学习率0.001.
模型大小和神经网络的层数和参数量有关系，具体可以看注释。
以上代码不依赖特殊的库，理论上来说可以直接运行的。

模型输出如下：

90 fizzbuzz fizzbuzz
91 91 91
92 92 92
93 fizz fizz
94 94 94
95 buzz buzz
96 fizz fizz
97 97 97
98 98 98
99 fizz fizz
100 buzz buzz

可以看到，模型推理出来的预测值和实际的值是一致的，说明训练有效果。

总结

本博客是在大佬代码的基础上，实现了自定义神经网络的训练和推理。外网上的优秀文章和视频太多了，可惜限于网络和语言，能被我们看到的太少了。 这个大佬40多分钟就手撸了简单的神经网络类，并且实现了训练和推理，博主只能说，牛逼。

本系列文章到这里就结束了。本来只是想分享一下大佬的视频和代码，但直接输出难免会没有上下文，因此只能把以前的一些笔记梳理下，期望读者能先有一些基础概念，然后再手撸代码实现一个自己的神经网络。

不得不感概，现在的网络资料太多了。依稀记得18年尝试学习一下TensorFlow的痛苦，上来就是各种公式和专业术语轰炸，直接劝退。近几年随着大量的工程师涌入人工智能领域，网上的教程也越来越通俗易懂了，站在工程的角度去讲概念，从实用性角度去学习可简单太多了。

end

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

线程计数器（CountDownLatch）

线程计数器（CountDownLatch）

🥭线程计数器（CountDownLatch） CountDownLatch也属于共享锁，其内部有一个int类型的属性表示可以同时并发并行的线程的数量 同时等待N个任务执行结束 举例说明： 比如跑步比赛，必须等所有运动员通过终点才…
阅读更多...
值类型和引用类型详解(C#)

值类型和引用类型详解(C#)

可能你对值类型和引用类型还不太了解。 值类型和引用类型，是c#比较基础，也必须掌握的知识点，但是也不是那么轻易就能掌握，今天跟着我一起来看看吧。 典型类型 首先我们看看这两种不同的类型有哪些比较典型的代表。 典型值类型…
阅读更多...
java面试题之mysql篇

java面试题之mysql篇

1、数据库索引 ​​​​​​​ 索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息。如果想按特定职员的姓来查找他或她，则与在表中搜索所有的行相比，索引有助于更快地获取信息。 索引的一个主要…
阅读更多...
H5多用途的产品介绍展示单页HTML5静态网页模板

H5多用途的产品介绍展示单页HTML5静态网页模板

H5多用途的产品介绍展示单页HTML5静态网页模板 源码介绍：一款H5自适应多用途的产品介绍展示单页HTML静态网页模板，可用于团队官网、产品官网。 下载地址： https://www.changyouzuhao.cn/13534.html
阅读更多...
26.java-单元测试xml注解

26.java-单元测试xml注解

单元测试&xml&注解 单元测试 单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对 Java 方法的测试，进而检查方法的正确性。 简单理解 : 就是一个测试代码的工具 目前测试…
阅读更多...
iPhone数据恢复软件有哪些？11 款 iPhone 数据恢复软件

iPhone数据恢复软件有哪些？11 款 iPhone 数据恢复软件

随着技术的出现，我们对智能手机的依赖程度超出了我们的想象。从保存珍贵的相册、电话簿、日记到重要文件，应有尽有。 但我们也意识到，技术给我们带来的东西也可能被夺走。一次错误的触摸或点击可能会删除手机上的所有数据；您可能…
阅读更多...
Linux第66步_linux字符设备驱动_挂载和卸载

Linux第66步_linux字符设备驱动_挂载和卸载

1、了解linux中的驱动类型: 1)、字符设备驱动 字符设备是limnux驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。如：GPIO输入输出、UART、I2C、SPI、USB、LCD、音频…
阅读更多...
Apache Doris 发展历程、技术特性及云原生时代的未来规划

Apache Doris 发展历程、技术特性及云原生时代的未来规划

文章目录 每日一句正能量前言作者介绍Apache Doris 特性极简架构高效自运维高并发场景支持MPP 执行引擎明细与聚合模型的统一便捷数据接入Apache Doris 极速 1.0 时代极速列式内存布局向量化的计算框架Cache 亲和度虚函数调用SIMD 指令集 稳定多源基于云原生向量数据库Milvus 的…
阅读更多...
Java学习笔记------继承

Java学习笔记------继承

继承 Java中提供了一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立继承关系 如图，Student和Teacher类中除了study（）和teacher（）两个成员函数不同，其他重复了&…
阅读更多...
万界星空科技商业开源MES

万界星空科技商业开源MES

一、万界星空科技商业开源MES系统概述： 万界星空科技免费MES、开源MES、商业开源MES、市面上最好的开源MES、MES源代码、适合二开的开源MES。 1.万界星空开源MES制造执行系统的Java开源版本。 开源mes系统包括系统管理，车间基础数据管理，计…
阅读更多...
ArcgisForJS如何使用ArcGIS Server的缓冲区几何服务？

ArcgisForJS如何使用ArcGIS Server的缓冲区几何服务？

文章目录 0.引言1.使用geometryService生成缓冲区2.使用geometryEngine生成缓冲区 0.引言 ArcGIS For JS是一款强大的JavaScript库，它提供了许多功能，包括使用ArcGIS Server的缓冲区几何服务。缓冲区几何服务是一种服务，它允许你在地理空间数…
阅读更多...
网络原理TCP之“三次握手“

网络原理TCP之“三次握手“

TCP内核中的建立连接 众所周知,TCP是有连接的. 当我们在客户端敲出socket new Socket(serverIp,severPort)时,就在系统内核就在建立连接 真正建立连接是在系统内核中建立的,我们程序员只是调用相关的api. 在此处,我们把TCP的建立连接称为三次握手. 系统在内核建立连接时如上…
阅读更多...
广联达Linkworks GetAllData 信息泄露漏洞

广联达Linkworks GetAllData 信息泄露漏洞

免责声明：文章来源互联网收集整理，请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息或者工具而造成的任何直接或者间接的后果及损失，均由使用者本人负责，所产生的一切不良后果与文章作者无关。该…
阅读更多...
Spring 容器、核心容器总结

Spring 容器、核心容器总结

目录 创建容器获取 bean容器类层次结构图核心容器总结容器相关bean 相关依赖注入相关 创建容器 方式一： 类路径加载配置文件 ApplicationContext ctx new ClassPathXmlApplicationContext("applicationContext.xml");方式二： 文件路径加载配…
阅读更多...
MySQL数据库进阶第四篇（视图/存储过程/触发器）

MySQL数据库进阶第四篇（视图/存储过程/触发器）

文章目录 一、视图简单介绍与基础语法二、视图的检查选项三、视图的更新四、视图的作用五、存储过程的概念与特点六、存储过程的 创建，调用，查看，删除七、存储过程 — 系统变量八、存储过程 — 用户定义变量九、存储过程 — 局部变量十、存储…
阅读更多...
＜网络安全＞《51 网络攻防专业课＜第十四课 - 华为防火墙的使用（4）＞

＜网络安全＞《51 网络攻防专业课＜第十四课 - 华为防火墙的使用（4）＞

8 防火墙的防范技术（3） 8.1 IP spoofing攻击防范 攻击介绍 为了获得访问权，或隐藏入侵者的身份信息，入侵者生成带有伪造源地址的报文。 处理方法 检测每个接口流入的IP报文的源地址与目的地址，并对报文的源地址反查路…
阅读更多...
C#与VisionPro联合开发——串口通信

C#与VisionPro联合开发——串口通信

串口通信 串口通信是一种常见的数据传输方式，通过串行接口（串口）将数据以串行比特流的形式进行传输。在计算机和外部设备之间，串口通信通常是通过串行通信标准（如RS-232）来实现的。串口通信可以用于连接各…
阅读更多...
【HarmonyOS】低代码开发—使用低代码开发服务卡片

【HarmonyOS】低代码开发—使用低代码开发服务卡片

DevEco Studio还支持使用低代码开发功能开发服务卡片，目前只支持JS语言，且compileSdkVersion必须为7或以上。 下面以创建一个新的服务卡片为例进行说明。 1.打开一个工程，创建服务卡片，创建方法包括如下两种方式： 选…
阅读更多...
vue3前端项目开发,具备纯天然的防止爬虫采集的特征

vue3前端项目开发,具备纯天然的防止爬虫采集的特征

vue3前端项目开发,具备纯天然的防止爬虫采集的特征！众所周知，网络爬虫可以在网上爬取到一些数据，很多公司，为了自己公司的数据安全， 尤其是web端项目，不希望被爬虫采集。那么，您可以使用vue技术…
阅读更多...
[c++] char * 和 std::string

[c++] char * 和 std::string

1 char * 和 std::string 的区别 char * 字符串是常量字符串，不能修改；std::string 指向的字符串可以修改 实例代码如下图所示，s1 和 s2 均是常量字符串，字符串常量保存在只读数据区，是只读的，不能写&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023