经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » 编程经验 » 查看文章
微型神经网络库MicroGrad-基于标量自动微分的类pytorch接口的深度学习框架
来源:cnblogs  作者:LeonYi  时间:2023/7/3 9:17:47  对本文有异议

一、MicroGrad

MicroGrad是大牛Andrej Karpathy写的一个非常轻量级别的神经网络库(框架),其基本构成为一个90行python代码的标量反向传播(自动微分)引擎,以及在此基础上实现的神经网络层。

其介绍如下:

A tiny scalar-valued autograd engine and a neural net library on top of it with PyTorch-like API

Andrej Karpathy时长2.5小时的通俗易懂的讲解,一步一步教你构建MicroGrad。学习完视频,相信可以一窥现代深度学习框架的底层实现。Bili视频链接:https://www.bilibili.com/video/BV1aB4y13761/?vd_source=e5f3442199b63a8df006d57974ad4e23

Github链接:https://github.com/karpathy/micrograd

image
项目除了框架源码外,给出了基于该库在一个二分类数据集上训练了一个2层MLP,源码为demo.ipynb
此外,给出了基于graphviz库的神经网络计算图可视化notebooktrace_graph.ipynb,可以形象地观察前向和反向传播过程。

接下来将简要介绍一下其标量反向传播引擎engine.py和神经网络层nn.py

二、标量反向传播引擎Engine

2.1 反向传播与自动微分

反向传播的核心就是链式法则,而深度神经网络的反向传播最多再加一个矩阵求导。

在反向传播的过程,本质是求网络的每个参数关于最终损失函数的梯度,而该梯度可以成是回传的全局梯度和局部梯度之乘。

形象地说,梯度代表了当前层参数的变化,对最终预测损失的影响(变化率),而该变化率实际取决于当前层参数对下一层输入的影响,以及下一层输入对最终预测损失的影响。两个变化一乘,不就是当前层参数对对最终预测损失的影响。

神经网络本质上可视为一个复杂函数,而该函数的计算公式无论多复杂,都可分解为一系列基本的算数运算(加减乘除等)和基本函数(exp,log,sin,cos,等)等。对相关操作进行分解,同时应用链式求导法则,就可以实现自动微分。

形如:c = 3a + b, o = 2 * c。直观的说,每个参与运行的变量以及运算符都要建模成一个节点,从而构成计算图。

2.2 标量Value类

为了实现自动微分,作者具体实现了一个Engine引擎。

Engine的核心其实就是实现了一个标量Value类,其关键就是在标量值的基础上实现基础运算和其它复杂运算(算子)的前向和反向传播(对基本运行进行了重写)。

为了构建计算图,并在其基础上执行从输出到各个运算节点的梯度反向回传,它绑定了相应的运算关系。为此,每个最基本的计算操作都会生成一个标量Value对象,同时记录产生该对象的运算类型以及参与运算的对象(children)。

每个Value对象都可以视为一个计算节点,在每次计算过程中,中间变量也会被建模成一个计算节点。

  1. class Value:
  2. """ stores a single scalar value and its gradient """
  3. def __init__(self, data, _children=(), _op=''):
  4. self.data = data # 标量数据
  5. self.grad = 0 # 对应梯度值,初始为0
  6. # 用于构建自动微分图的内部变量
  7. self._backward = lambda: None # 计算梯度的函数
  8. self._prev = set(_children) # 前向节点(参与该运算的Value对象集合),将用于反向传播
  9. self._op = _op # 产生这个计算节点的运算类型

例如对于如下的+运算:

  1. x = Value(1.0)
  2. y = x + 2

首先,构建Value对象x, 然后在执行+的过程中,调用x.add(self, other)方法。此时,2也被构建为一个Value对象。然后执行如下操作:
out = Value(self.data + other.data, (self, other), '+')
最终,返回一个代表计算结果(记录了前向节点)的新Value对象y。

废话不多说,直接上完整源码。

  1. class Value:
  2. """ stores a single scalar value and its gradient """
  3. def __init__(self, data, _children=(), _op=''):
  4. self.data = data
  5. self.grad = 0
  6. # internal variables used for autograd graph construction
  7. self._backward = lambda: None
  8. self._prev = set(_children)
  9. self._op = _op # the op that produced this node, for graphviz / debugging / etc
  10. def __add__(self, other):
  11. other = other if isinstance(other, Value) else Value(other)
  12. out = Value(self.data + other.data, (self, other), '+')
  13. def _backward():
  14. self.grad += out.grad
  15. other.grad += out.grad
  16. out._backward = _backward
  17. return out
  18. def __mul__(self, other):
  19. other = other if isinstance(other, Value) else Value(other)
  20. out = Value(self.data * other.data, (self, other), '*')
  21. def _backward():
  22. self.grad += other.data * out.grad
  23. other.grad += self.data * out.grad
  24. out._backward = _backward
  25. return out
  26. def __pow__(self, other):
  27. assert isinstance(other, (int, float)), "only supporting int/float powers for now"
  28. out = Value(self.data**other, (self,), f'**{other}')
  29. def _backward():
  30. self.grad += (other * self.data**(other-1)) * out.grad
  31. out._backward = _backward
  32. return out
  33. def relu(self):
  34. out = Value(0 if self.data < 0 else self.data, (self,), 'ReLU')
  35. def _backward():
  36. self.grad += (out.data > 0) * out.grad
  37. out._backward = _backward
  38. return out
  39. def backward(self):
  40. # topological order all of the children in the graph
  41. topo = []
  42. visited = set()
  43. def build_topo(v):
  44. if v not in visited:
  45. visited.add(v)
  46. for child in v._prev:
  47. build_topo(child)
  48. topo.append(v)
  49. build_topo(self)
  50. # go one variable at a time and apply the chain rule to get its gradient
  51. self.grad = 1
  52. for v in reversed(topo):
  53. v._backward()
  54. def __neg__(self): # -self
  55. return self * -1
  56. def __radd__(self, other): # other + self
  57. return self + other
  58. def __sub__(self, other): # self - other
  59. return self + (-other)
  60. def __rsub__(self, other): # other - self
  61. return other + (-self)
  62. def __rmul__(self, other): # other * self
  63. return self * other
  64. def __truediv__(self, other): # self / other
  65. return self * other**-1
  66. def __rtruediv__(self, other): # other / self
  67. return other * self**-1
  68. def __repr__(self):
  69. return f"Value(data={self.data}, grad={self.grad})"

有了该框架后,就可构建出计算图。然后,通过基于拓扑排序的backward(self)方法,来进行反向传播。

Value类其实很类似于Pytorh中的Variable类,基于它就可构造复杂的神经网络,而不必手动的计算梯度。

三、简易网络

  1. import random
  2. from micrograd.engine import Value
  3. class Module:
  4. def zero_grad(self):
  5. for p in self.parameters():
  6. p.grad = 0
  7. def parameters(self):
  8. return []
  9. class Neuron(Module):
  10. def __init__(self, nin, nonlin=True):
  11. self.w = [Value(random.uniform(-1,1)) for _ in range(nin)]
  12. self.b = Value(0)
  13. self.nonlin = nonlin
  14. def __call__(self, x):
  15. act = sum((wi*xi for wi,xi in zip(self.w, x)), self.b)
  16. return act.relu() if self.nonlin else act
  17. def parameters(self):
  18. return self.w + [self.b]
  19. def __repr__(self):
  20. return f"{'ReLU' if self.nonlin else 'Linear'}Neuron({len(self.w)})"
  21. class Layer(Module):
  22. def __init__(self, nin, nout, **kwargs):
  23. self.neurons = [Neuron(nin, **kwargs) for _ in range(nout)]
  24. def __call__(self, x):
  25. out = [n(x) for n in self.neurons]
  26. return out[0] if len(out) == 1 else out
  27. def parameters(self):
  28. return [p for n in self.neurons for p in n.parameters()]
  29. def __repr__(self):
  30. return f"Layer of [{', '.join(str(n) for n in self.neurons)}]"
  31. class MLP(Module):
  32. def __init__(self, nin, nouts):
  33. sz = [nin] + nouts
  34. self.layers = [Layer(sz[i], sz[i+1], nonlin=i!=len(nouts)-1) for i in range(len(nouts))]
  35. def __call__(self, x):
  36. for layer in self.layers:
  37. x = layer(x)
  38. return x
  39. def parameters(self):
  40. return [p for layer in self.layers for p in layer.parameters()]
  41. def __repr__(self):
  42. return f"MLP of [{', '.join(str(layer) for layer in self.layers)}]"

未完待续

原文链接:https://www.cnblogs.com/justLittleStar/p/17521734.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号