pytorch 3 计算图

最新推荐文章于 2024-09-16 19:52:18 发布
最新推荐文章于 2024-09-16 19:52:18 发布
阅读量615 收藏 10
点赞数 9
分类专栏： pytorch 文章标签： pytorch python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51147313/article/details/141199906
版权

计算图结构

**加粗样式**

分析：

  1. 起始节点 a
  2. b = 5 - 3a
  3. c = 2b + 3
  4. d = 5b + 6
  5. e = 7c + d^2
  6. f = 2e
  7. 最终输出 g = 3f - o（其中 o 是另一个输入）

前向传播

前向传播按照上述顺序计算每个节点的值。

反向传播过程

反向传播的目标是计算损失函数（这里假设为 g）对每个中间变量和输入的偏导数。从右向左进行计算：

  1. ∂g/∂o = -1
  2. ∂g/∂f = 3
  3. ∂f/∂e = 2
  4. ∂e/∂c = 7
  5. ∂e/∂d = 2d
  6. ∂d/∂b = 5
  7. ∂c/∂b = 2
  8. ∂b/∂a = -3

链式法则应用

使用链式法则计算出 g 对每个变量的全导数：

  1. dg/df = ∂g/∂f = 3
  2. dg/de = (∂g/∂f) * (∂f/∂e) = 3 * 2 = 6
  3. dg/dc = (dg/de) * (∂e/∂c) = 6 * 7 = 42
  4. dg/dd = (dg/de) * (∂e/∂d) = 6 * 2d
  5. dg/db = (dg/dc) * (∂c/∂b) + (dg/dd) * (∂d/∂b)
    = 42 * 2 + 6 * 2d * 5
    = 84 + 60d
  6. dg/da = (dg/db) * (∂b/∂a)
    = (84 + 60d) * (-3)
    = -252 - 180d

最终梯度

最终得到 g 对输入 a 和 o 的梯度：

  • dg/da = -252 - 180d
  • dg/do = -1

代码实现

静态图

import math

class Node:
    """
    表示计算图中的一个节点。
    每个节点都可以存储一个值、梯度，并且知道如何计算前向传播和反向传播。
    """
    def __init__(self, value=None):
        self.value = value  # 节点的值
        self.gradient = 0   # 节点的梯度
        self.parents = []   # 父节点列表
        self.forward_fn = lambda: None  # 前向传播函数
        self.backward_fn = lambda: None  # 反向传播函数

    def __add__(self, other):
        """加法操作"""
        return self._create_binary_operation(other, lambda x, y: x + y, lambda: (1, 1))

    def __mul__(self, other):
        """乘法操作"""
        return self._create_binary_operation(other, lambda x, y: x * y, lambda: (other.value, self.value))

    def __sub__(self, other):
        """减法操作"""
        return self._create_binary_operation(other, lambda x, y: x - y, lambda: (1, -1))

    def __pow__(self, power):
        """幂运算"""
        result = Node()
        result.parents = [self]
        def forward():
            result.value = math.pow(self.value, power)
        def backward():
            self.gradient += power * math.pow(self.value, power-1) * result.gradient
        result.forward_fn = forward
        result.backward_fn = backward
        return result

    def _create_binary_operation(self, other, forward_op, gradient_op):
        """
        创建二元操作的辅助方法。
        用于简化加法、乘法和减法的实现。
        """
        result = Node()
        result.parents = [self, other]
        def forward():
            result.value = forward_op(self.value, other.value)
        def backward():
            grads = gradient_op()
            self.gradient += grads[0] * result.gradient
            other.gradient += grads[1] * result.gradient
        result.forward_fn = forward
        result.backward_fn = backward
        return result

def topological_sort(node):
    """
    对计算图进行拓扑排序。
    确保在前向和反向传播中按正确的顺序处理节点。
    """
    visited = set()
    topo_order = []
    def dfs(n):
        if n not in visited:
            visited.add(n)
            for parent in n.parents:
                dfs(parent)
            topo_order.append(n)
    dfs(node)
    return topo_order

# 构建计算图
a = Node(2)  # 假设a的初始值为2
o = Node(1)  # 假设o的初始值为1

# 按照给定的数学表达式构建计算图
b = Node(5) - a * Node(3)
c = b * Node(2) + Node(3)
d = b * Node(5) + Node(6)
e = c * Node(7) + d ** 2
f = e * Node(2)
g = f * Node(3) - o

# 前向传播
sorted_nodes = topological_sort(g)
for node in sorted_nodes:
    node.forward_fn()

# 反向传播
g.gradient = 1  # 设置输出节点的梯度为1
for node in reversed(sorted_nodes):
    node.backward_fn()

# 打印结果
print(f"g = {g.value}")
print(f"dg/da = {a.gradient}")
print(f"dg/do = {o.gradient}")

# 验证手动计算的结果
d_value = 5 * b.value + 6
expected_dg_da = -252 - 180 * d_value
print(f"Expected dg/da = {expected_dg_da}")
print(f"Difference: {abs(a.gradient - expected_dg_da)}")

动态图

import math

class Node:
    """
    表示计算图中的一个节点。
    实现了动态计算图的核心功能，包括前向计算和反向传播。
    """
    def __init__(self, value, children=(), op=''):
        self.value = value  # 节点的值
        self.grad = 0       # 节点的梯度
        self._backward = lambda: None  # 反向传播函数，默认为空操作
        self._prev = set(children)  # 前驱节点集合
        self._op = op  # 操作符，用于调试

    def __add__(self, other):
        """加法操作"""
        other = other if isinstance(other, Node) else Node(other)
        result = Node(self.value + other.value, (self, other), '+')
        def _backward():
            self.grad += result.grad
            other.grad += result.grad
        result._backward = _backward
        return result

    def __mul__(self, other):
        """乘法操作"""
        other = other if isinstance(other, Node) else Node(other)
        result = Node(self.value * other.value, (self, other), '*')
        def _backward():
            self.grad += other.value * result.grad
            other.grad += self.value * result.grad
        result._backward = _backward
        return result

    def __pow__(self, other):
        """幂运算"""
        assert isinstance(other, (int, float)), "only supporting int/float powers for now"
        result = Node(self.value ** other, (self,), f'**{other}')
        def _backward():
            self.grad += (other * self.value**(other-1)) * result.grad
        result._backward = _backward
        return result

    def __neg__(self):
        """取反操作"""
        return self * -1

    def __sub__(self, other):
        """减法操作"""
        return self + (-other)

    def __truediv__(self, other):
        """除法操作"""
        return self * other**-1

    def __radd__(self, other):
        """反向加法"""
        return self + other

    def __rmul__(self, other):
        """反向乘法"""
        return self * other

    def __rtruediv__(self, other):
        """反向除法"""
        return other * self**-1

    def tanh(self):
        """双曲正切函数"""
        x = self.value
        t = (math.exp(2*x) - 1)/(math.exp(2*x) + 1)
        result = Node(t, (self,), 'tanh')
        def _backward():
            self.grad += (1 - t**2) * result.grad
        result._backward = _backward
        return result

    def backward(self):
        """
        执行反向传播，计算梯度。
        使用拓扑排序确保正确的反向传播顺序。
        """
        topo = []
        visited = set()
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build_topo(child)
                topo.append(v)
        build_topo(self)
        
        self.grad = 1  # 设置输出节点的梯度为1
        for node in reversed(topo):
            node._backward()  # 对每个节点执行反向传播

def main():
    """
    主函数，用于测试自动微分系统。
    构建一个计算图，执行反向传播，并验证结果。
    """
    # 构建计算图
    a = Node(2)
    o = Node(1)
    b = Node(5) - a * 3
    c = b * 2 + 3
    d = b * 5 + 6
    e = c * 7 + d ** 2
    f = e * 2
    g = f * 3 - o

    # 反向传播
    g.backward()

    # 打印结果
    print(f"g = {g.value}")
    print(f"dg/da = {a.grad}")
    print(f"dg/do = {o.grad}")

    # 验证手动计算的结果
    d_value = 5 * b.value + 6
    expected_dg_da = -252 - 180 * d_value
    print(f"Expected dg/da = {expected_dg_da}")
    print(f"Difference: {abs(a.grad - expected_dg_da)}")

if __name__ == "__main__":
    main()

解释:

  1. Node 类代表计算图中的一个节点,包含值、梯度、父节点以及前向和反向传播函数。
  2. 重载的数学运算符 (__add__, __mul__, __sub__, __pow__) 允许直观地构建计算图。
  3. _create_binary_operation 方法用于创建二元操作,简化了加法、乘法和减法的实现。
  4. topological_sort 函数对计算图进行拓扑排序,确保正确的计算顺序。
import math

class Node:
    """
    表示计算图中的一个节点。
    实现了动态计算图的核心功能，包括前向计算和反向传播。
    """
    def __init__(self, value, children=(), op=''):
        self.value = value  # 节点的值
        self.grad = 0       # 节点的梯度
        self._backward = lambda: None  # 反向传播函数，默认为空操作
        self._prev = set(children)  # 前驱节点集合
        self._op = op  # 操作符，用于调试

    def __add__(self, other):
        """加法操作"""
        other = other if isinstance(other, Node) else Node(other)
        result = Node(self.value + other.value, (self, other), '+')
        def _backward():
            self.grad += result.grad
            other.grad += result.grad
        result._backward = _backward
        return result

    def __mul__(self, other):
        """乘法操作"""
        other = other if isinstance(other, Node) else Node(other)
        result = Node(self.value * other.value, (self, other), '*')
        def _backward():
            self.grad += other.value * result.grad
            other.grad += self.value * result.grad
        result._backward = _backward
        return result

    def __pow__(self, other):
        """幂运算"""
        assert isinstance(other, (int, float)), "only supporting int/float powers for now"
        result = Node(self.value ** other, (self,), f'**{other}')
        def _backward():
            self.grad += (other * self.value**(other-1)) * result.grad
        result._backward = _backward
        return result

    def __neg__(self):
        """取反操作"""
        return self * -1

    def __sub__(self, other):
        """减法操作"""
        return self + (-other)

    def __truediv__(self, other):
        """除法操作"""
        return self * other**-1

    def __radd__(self, other):
        """反向加法"""
        return self + other

    def __rmul__(self, other):
        """反向乘法"""
        return self * other

    def __rtruediv__(self, other):
        """反向除法"""
        return other * self**-1

    def tanh(self):
        """双曲正切函数"""
        x = self.value
        t = (math.exp(2*x) - 1)/(math.exp(2*x) + 1)
        result = Node(t, (self,), 'tanh')
        def _backward():
            self.grad += (1 - t**2) * result.grad
        result._backward = _backward
        return result

    def backward(self):
        """
        执行反向传播，计算梯度。
        使用拓扑排序确保正确的反向传播顺序。
        """
        topo = []
        visited = set()
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build_topo(child)
                topo.append(v)
        build_topo(self)
        
        self.grad = 1  # 设置输出节点的梯度为1
        for node in reversed(topo):
            node._backward()  # 对每个节点执行反向传播

def main():
    """
    主函数，用于测试自动微分系统。
    构建一个计算图，执行反向传播，并验证结果。
    """
    # 构建计算图
    a = Node(2)
    o = Node(1)
    b = Node(5) - a * 3
    c = b * 2 + 3
    d = b * 5 + 6
    e = c * 7 + d ** 2
    f = e * 2
    g = f * 3 - o

    # 反向传播
    g.backward()

    # 打印结果
    print(f"g = {g.value}")
    print(f"dg/da = {a.grad}")
    print(f"dg/do = {o.grad}")

    # 验证手动计算的结果
    d_value = 5 * b.value + 6
    expected_dg_da = -252 - 180 * d_value
    print(f"Expected dg/da = {expected_dg_da}")
    print(f"Difference: {abs(a.grad - expected_dg_da)}")

if __name__ == "__main__":
    main()

解释：

  1. Node 类是核心，它代表计算图中的一个节点，并实现了各种数学运算。

  2. 每个数学运算（如 __add__, __mul__ 等）都创建一个新的 Node，并定义了相应的反向传播函数。

  3. backward 方法实现了反向传播算法，使用拓扑排序确保正确的计算顺序。

jerry609
关注
专栏目录
【20天拿下Pytorch：Day 3】Pytorch的核心概念：动态计算图
惊鸿若梦一书生
05-17 1051
PyTorch中的动态计算图是指在PyTorch框架中，计算图是动态构建的。这意味着在每次前向传播过程中，计算图都会重新构建。与静态计算图不同，动态计算图允许用户在运行时动态地定义、修改和调整计算图，而无需预先定义完整的计算图结构。Pytorch的计算图由节点和边组成，节点表示张量或者Function边表示张量和Function之间的依赖关系。解释：Function实际上就是 Pytorch中各种对张量操作的函数Pytorch中的计算图是动态图。这里的动态主要有两重含义。
PyTorchViz：一个可以将Pytorch执行计算图可视化的工具
NorthSmile的博客
09-11 2786
如果安装过程中没有选择自动添加环境变量，则在安装之后手动添加环境变量，即将GraphViz的bin目录路径添加到Path变量中。“我的电脑->属性->高级系统设置->环境变量->系统变量->Path->新建”，然后将该路径放入即可。执行此代码之后，可看到代码同目录下生成两个文件，一个是写入源码的文件，一个则是渲染过后的网络计算图。，根据人家给出的Readme文件可知在进行代码编写前首先需要进行环境配置，安装人家需要的第三方库。，对应自己系统选择32/64位的exe文件；2）双击exe进行安装；
pytorch 计算图
上帝是个娘们的博客
01-19 1601
例1 假设我们函数是y=(x+w)∗(w+1)y=(x+w)*(w+1)y=(x+w)∗(w+1)，我们要求yyy对x和wx和wx和w的导数，应该如何用pytorch来求解。 上面的计算图表示y=(x+w)∗(w+1)y=(x+w)*(w+1)y=(x+w)∗(w+1)，先计算括号内部的加法，再计算乘法。计算顺序是：a=x+wa=x+wa=x+w，b=w+1b=w+1b=w+1，y=a∗by=a*by=a∗b。 用代码来表示： import torch w = torch.tensor([1.], re
pytorch中计算图的理解
weixin_41469023的博客
02-15 1699
pytorch的计算图 pytorch是动态图机制，所以在训练模型的时候，每迭代一次都会构建一个新的计算图。而计算图代表着程序中变量之间的关系。y = ( a + b ) ( b + c ) y=(a+b)(b+c)y=(a+b)(b+c)在这个运算过程就会建立一个如下的计算图。在这个计算图中，叶子节点(leaf_node)就是参与运算的变量。这个图里面只有a，b，c是leaf_node。之所以要关注leaf_node，因为计算网络在反向传播的时候，需要根据链式求导法则求出网络最后输出的梯度，然后再对网络.
深度学习Pytorch中计算图的概念及理解
q774798577的博客
01-18 1497
深度学习pytorch框架计算图的概念理解
Pytorch截断计算图：detach操作
scnulpc的博客
12-24 1213
官方解析： torch.Tensor.detach(): Returns a new Tensor, detached from the current graph. The result will never require gradient. 举个例子： 在GAN训练中，训练判别器D时，无需调整生成器G的参数。 fake_image = Generato...
pytorch计算图
xinming_365的博客
07-30 6070
Pytorch中的神经网络 pytorch的计算图 pytorch是动态图机制，所以在训练模型的时候，每迭代一次都会构建一个新的计算图。而计算图代表着程序中变量之间的关系。y=(a+b)(b+c)y=(a+b)(b+c)y=(a+b)(b+c)在这个运算过程就会建立一个如下的计算图。在这个计算图中，叶子节点(leaf_node)就是参与运算的变量。这个图里面只有a，b，c是leaf_node。之所以要关注leaf_node，因为计算网络在反向传播的时候，需要根据链式求导法则求出网络最后输出的梯度，然后再对网
[Pytorch进阶技巧(零)] Pytorch中计算图的建立与运行
XavierLiu的博客
07-30 2116
前言 如今Pytorch的使用率正在超过tensorflow。虽然pytorch的开发效率比tensorflow高很多，但是使用tensorflow可以对计算图的概率更加清晰。关于tensorflow可以参考我的博文tensorflow。 不清楚pytorch背后的计算图概念，在进行pytorch编程时可能会遇到： 随着迭代显存占用不断增大，直至报错； 报错参数不在同个设备，比如报错cpu里的浮...
在Pytorch中计算自己模型的FLOPs方式
09-18
在PyTorch中，我们可以使用第三方库thop（又名torchprofile）来计算自定义模型的FLOPs，以便更好地理解和优化模型的性能。 首先，让我们详细了解一下如何安装和使用thop库。安装thop非常简单，只需要在命令行或终端...
pytorch-FID计算
01-31
**PyTorch FID 计算详解** 在深度学习领域，尤其是图像生成模型的评估中，Fréchet Inception Distance (FID) 是一个广泛使用的评价标准。它由Heusel等人在2017年提出，用于衡量生成样本与真实样本分布之间的差异。...
RNN股票预测(Pytorch版)
qq_52237775的博客
09-16 365
记录RNN实战
分布式训练：（Pytorch）
最新发布
qq_55794606的博客
09-16 671
数据加载：使用多个进程来并行加载和预处理数据，通过流水线处理减少数据加载的延迟。数据传输：利用 CUDA 流优化从固定内存到 GPU 的数据传输。数据并行性：使用数据并行和 NCCL 等通信库实现高效的梯度同步和模型参数更新，优化训练过程。这种方法结合了数据加载、数据传输和数据并行处理的优化，能够显著提升深度学习模型的训练效率和速度。dataset,num_workers=4, # 使用 4 个子进程加载数据pin_memory=True # 将数据转移到固定内存# 模型训练代码# ...
解决Linux服务器上下载pytorch速度过慢的问题
weixin_53697800的博客
09-13 521
torch-1.13.1+cu116-cp311-cp311-linux_x86_64.whl 注意cp311中的311指的是python版本，也需要与自己的python匹配，比如我的是3.8，我在Linux服务器中使用如下指令, 直接从指定的 URL 下载。需要下载的是GPU版本的pytorch，版本torch=1.13.1+cu116。ps:也可以使用其他下载器（如迅雷）通过镜像网站手动下载.whl文件到本地，然后。使用这种方式会从两个网址中查找安装包，清华源不存在安装包，仍然从官方下载。
探索pytorch数据集中Mnist数据集的数据格式
算法与编程之美
09-13 386
1 问题1.1安装pytorch时，由于使用的vscode编译器，所以采用pip进行安装，但是遇到pytorch版本与python版本不对应的问题。1.2探索pytorch数据集中Mnist数据集的数据格式。2 方法2.1 首先查看自己电脑能够适应的pytorch版本2.2 打开pytorch的官网，选择对应的版本2．3 最后在vscode的终端运行复制的pip代码。（下载pytorch命令：pi...
pytorch使用技巧
m0_73776435的博客
09-13 945
我们将模型划分为两部分，存放到一个列表里，每部分就对应上面的一个字典，在字典里设置不同的学习率。：去除dim指定的且size为1的维度，维度大于1时，squeeze()不起作用，不指定dim时，去除所有size为1的维度。也可以在列表外设置一个全局学习率，当各部分字典里设置了局部学习率时，就使用该学习率，否则就使用列表外的全局学习率。的作用就是释放缓存分配器当前持有的且未占用的缓存显存，以便这些显存可以被其他GPU应用程序中使用，并且通过。设置当前使用的GPU设备仅为0号设备，设备名称为。
【深度学习|PyTorch】基于 PyTorch 搭建 U-Net 深度学习语义分割模型——附代码及其解释！
985小水博的摸鱼日常
09-14 562
【深度学习|PyTorch】UNet学习笔记！
《深度学习》PyTorch 手写数字识别 案例解析及实现 ＜上＞
wx_AHao1004Y的博客
09-13 1394
MINIST是一种基于神经网络的手写数字识别算法。它是LeCun等人在1998年提出的，是深度学习领域的里程碑之一。MINIST数据集包含了大量的手写数字图片，MINIST算法通过训练神经网络，可以有效地识别这些手写数字。MINIST算法在计算机视觉和模式识别中有广泛的应用，被认为是机器学习领域的经典问题之一。MNIST包含70,000张手写数字图像，其中60,000张用于训练，10,000张用于测试。所有的图像都是灰度的，大小为28x28像素的，并且居中的，以减少预处理和加快运行。
从index_put出发全面学习cuda和pytorch技术
youzjuer的博客
09-13 141
深感目前对于cuda和pytorch所涉及知识的广度和深度，但一时又不知道该如何去学习，经过多日的考虑，还是决定管中窥豹，从一个算子出发，抽丝剥茧，慢慢学习，把学习中碰到的问题都记录下来，希望可以坚持下去。
《深度学习》CUDA安装配置、pytorch库、torchvision库、torchaudio库安装
wx_AHao1004Y的博客
09-13 1495
CUDA（Compute Unified Device Architecture）是由NVIDIA开发的一种并行计算平台和编程模型，用于利用NVIDIA GPU进行通用计算。它提供了一个编程接口，让开发者能够将计算任务分配到GPU上执行，以实现高性能的并行计算。CUDA可以用于各种领域的计算任务，包括科学计算、图形处理、机器学习等。
pytorch中计算图
05-17
在PyTorch中，计算图是一种表示计算操作和数据流的有向无环图（DAG）。计算图记录了模型中的每个操作和它们之间的依赖关系。当我们使用PyTorch构建神经网络时，我们实际上是在创建计算图。 PyTorch中的计算图分为两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值