昇思25天学习打卡营第8天 | 使用静态图加速

最新推荐文章于 2024-07-05 13:39:44 发布

loveisastory

最新推荐文章于 2024-07-05 13:39:44 发布

阅读量947

点赞数 21

分类专栏： LLM 文章标签：人工智能 mindspore 静态图加速

本文链接：https://blog.csdn.net/u014255803/article/details/140091714

版权

LLM 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 使用静态图加速

1.1 背景介绍

AI编译框架分为两种运行模式，分别是动态图模式以及静态图模式。MindSpore默认情况下是以动态图模式运行，但也支持手工切换为静态图模式。

导入依赖

# 导入numpy库，并重命名为np
import numpy as np
# 导入mindspore库，并重命名为ms
import mindspore as ms
# 从mindspore库中导入nn模块（用于构建神经网络）和Tensor类（用于创建张量）
from mindspore import nn, Tensor
# 设置MindSpore的执行模式为动态图模式，这样可以让操作立即执行，便于调试

1.2 动态图模式

动态图的特点是计算图的构建和计算同时发生（Define by run），其符合Python的解释执行方式，在计算图中定义一个Tensor时，其值就已经被计算且确定，因此在调试模型时较为方便，能够实时得到中间结果的值，但由于所有节点都需要被保存，导致难以对整个计算图进行优化。

在MindSpore中，动态图模式又被称为PyNative模式。由于动态图的解释执行特性，在脚本开发和网络流程调试过程中，推荐使用动态图模式进行调试。
如需要手动控制框架采用PyNative模式，可以通过以下代码进行网络构建：

ms.set_context(mode=ms.PYNATIVE_MODE)  

# 定义一个名为Network的类，继承自nn.Cell，用于构建神经网络模型
class Network(nn.Cell):
	# 初始化函数，定义了一个神经网络
    def __init__(self):
        # 调用父类的构造函数
        super().__init__()
        # 实例化一个Flatten层，用于将输入张量展平为一维张量
        self.flatten = nn.Flatten()
        # 实例化一个SequentialCell，包含三个全连接层和两个ReLU激活函数层
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),  # 第一个全连接层，输入维度为28*28，输出维度为512
            nn.ReLU(),             # 第一个ReLU激活函数层
            nn.Dense(512, 512),    # 第二个全连接层，输入和输出维度均为512
            nn.ReLU(),             # 第二个ReLU激活函数层
            nn.Dense(512, 10)      # 第三个全连接层，输入维度为512，输出维度为10，对应10个分类
        )

    # 定义前向传播的construct方法
    def construct(self, x):
        # 使用Flatten层将输入x展平为一维张量
        x = self.flatten(x)
        # 将展平后的张量输入到SequentialCell中，得到输出logits
        logits = self.dense_relu_sequential(x)
        # 返回logits作为网络的输出
        return logits

# 实例化Network类，创建一个模型对象
model = Network()
# 创建一个形状为[64, 1, 28, 28]的全1张量，模拟一批次输入数据，数据类型为float32
# 这个张量代表是的具有64个样本，每个样本是一个单通道图像，大小为28*28像素，图像的每个元素的像素值都是1
input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))
# 将输入数据传入模型，得到模型的输出
output = model(input)
# 打印输出结果
print(output)

输出：

[[-0.09957386  0.02354695 -0.28844753 -0.02921139 -0.10638421  0.0182976
  -0.00546881 -0.02069293  0.21207093  0.06852885]
 [-0.09957386  0.02354695 -0.28844753 -0.02921139 -0.10638421  0.0182976
  -0.00546881 -0.02069293  0.21207093  0.06852885]
 ... 
 [-0.09957386  0.02354695 -0.28844753 -0.02921139 -0.10638421  0.0182976
  -0.00546881 -0.02069293  0.21207093  0.06852885]
 [-0.09957386  0.02354695 -0.28844753 -0.02921139 -0.10638421  0.0182976
  -0.00546881 -0.02069293  0.21207093  0.06852885]]

经过神经网络后，输出了64个含有10个分类的预测值
耗时38秒，内存约8GB

1.3 静态图模式

相较于动态图而言，静态图的特点是将计算图的构建和实际计算分开（Define and run）。有关静态图模式的运行原理，可以参考静态图语法支持。

在MindSpore中，静态图模式又被称为Graph模式，在Graph模式下，基于图优化、计算图整图下沉等技术，编译器可以针对图进行全局的优化，获得较好的性能，因此比较适合网络固定且需要高性能的场景。

如需要手动控制框架采用静态图模式，可以通过以下代码进行网络构建：

# 设置MindSpore的执行模式为静态图模式，这种模式会先生成计算图再执行，适合生产环境
ms.set_context(mode=ms.GRAPH_MODE)  

# 定义一个名为Network的类，继承自nn.Cell，用于构建神经网络模型
class Network(nn.Cell):
    def __init__(self):
        # 调用父类的构造函数
        super().__init__()
        # 实例化一个Flatten层，用于将输入张量展平为一维张量
        self.flatten = nn.Flatten()
        # 实例化一个SequentialCell，包含三个全连接层和两个ReLU激活函数层
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),  # 第一个全连接层，输入维度为28*28，输出维度为512
            nn.ReLU(),             # 第一个ReLU激活函数层
            nn.Dense(512, 512),    # 第二个全连接层，输入和输出维度均为512
            nn.ReLU(),             # 第二个ReLU激活函数层
            nn.Dense(512, 10)      # 第三个全连接层，输入维度为512，输出维度为10，对应10个分类
        )

    # 定义前向传播的construct方法
    def construct(self, x):
        # 使用Flatten层将输入x展平为一维张量
        x = self.flatten(x)
        # 将展平后的张量输入到SequentialCell中，得到输出logits
        logits = self.dense_relu_sequential(x)
        # 返回logits作为网络的输出
        return logits

# 实例化Network类，创建一个模型对象
model = Network()
# 创建一个形状为[64, 1, 28, 28]的全1张量，模拟一批次输入数据，数据类型为float32
input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))
# 将输入数据传入模型，得到模型的输出
output = model(input)
# 打印输出结果
print(output)

输出：

耗时33秒，内存约8GB
经过多次的运行测试，实际上，在这个模型上，性能的差异并没有直观的体观

1.4 静态图模式的使用场景

MindSpore编译器重点面向Tensor数据的计算以及其微分处理。因此使用MindSpore API以及基于Tensor对象的操作更适合使用静态图编译优化。其他操作虽然可以部分入图编译，但实际优化作用有限。另外，静态图模式先编译后执行的模式导致其存在编译耗时。因此，如果函数无需反复执行，那么使用静态图加速也可能没有价值。

有关使用静态图来进行网络编译的示例，请参考网络构建。

1.5 静态图模式开启方式

通常情况下，由于动态图的灵活性，我们会选择使用PyNative模式来进行自由的神经网络构建，以实现模型的创新和优化。但是当需要进行性能加速时，我们需要对神经网络部分或整体进行加速。MindSpore提供了两种切换为图模式的方式，分别是基于装饰器的开启方式以及基于全局context的开启方式。

1.5.1 基于装饰器的开启方式

MindSpore提供了jit装饰器，可以通过修饰Python函数或者Python类的成员函数使其被编译成计算图，通过图优化等技术提高运行速度。此时我们可以简单的对想要进行性能优化的模块进行图编译加速，而模型其他部分，仍旧使用解释执行方式，不丢失动态图的灵活性。无论全局context是设置成静态图模式还是动态图模式，被jit修饰的部分始终会以静态图模式进行运行。

在需要对Tensor的某些运算进行编译加速时，可以在其定义的函数上使用jit修饰器，在调用该函数时，该模块自动被编译为静态图。需要注意的是，jit装饰器只能用来修饰函数，无法对类进行修饰。jit的使用示例如下：

import numpy as np
import mindspore as ms
from mindspore import nn, Tensor

class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),
            nn.ReLU(),
            nn.Dense(512, 512),
            nn.ReLU(),
            nn.Dense(512, 10)
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits

input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))

@ms.jit  # 使用ms.jit装饰器，使被装饰的函数以静态图模式运行
def run(x):
    model = Network()
    return model(x)

output = run(input)
print(output)

输出：

[[-0.12126954  0.06986676 -0.2230821  -0.07087803 -0.01003947  0.01063392
   0.10143848 -0.0200909  -0.09724037  0.0114444 ]
 [-0.12126954  0.06986676 -0.2230821  -0.07087803 -0.01003947  0.01063392
   0.10143848 -0.0200909  -0.09724037  0.0114444 ]
 ...
 [-0.12126954  0.06986676 -0.2230821  -0.07087803 -0.01003947  0.01063392
   0.10143848 -0.0200909  -0.09724037  0.0114444 ]
 [-0.12126954  0.06986676 -0.2230821  -0.07087803 -0.01003947  0.01063392
   0.10143848 -0.0200909  -0.09724037  0.0114444 ]]

除使用修饰器外，也可使用函数变换方式调用jit方法，示例如下：

import numpy as np
import mindspore as ms
from mindspore import nn, Tensor

class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),
            nn.ReLU(),
            nn.Dense(512, 512),
            nn.ReLU(),
            nn.Dense(512, 10)
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits

input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))

def run(x):
    model = Network()
    return model(x)

run_with_jit = ms.jit(run)  # 通过调用jit将函数转换为以静态图方式执行
output = run(input)
print(output)

输出：

[[ 0.11027216 -0.09628229  0.0457969   0.05396656 -0.06958974  0.0428197
  -0.1572069  -0.14151613 -0.04531277  0.07521383]
 [ 0.11027216 -0.09628229  0.0457969   0.05396656 -0.06958974  0.0428197
  -0.1572069  -0.14151613 -0.04531277  0.07521383]
 ...
 [ 0.11027216 -0.09628229  0.0457969   0.05396656 -0.06958974  0.0428197
  -0.1572069  -0.14151613 -0.04531277  0.07521383]
 [ 0.11027216 -0.09628229  0.0457969   0.05396656 -0.06958974  0.0428197
  -0.1572069  -0.14151613 -0.04531277  0.07521383]]

当我们需要对神经网络的某部分进行加速时，可以直接在construct方法上使用jit修饰器，在调用实例化对象时，该模块自动被编译为静态图。示例如下：

import numpy as np
import mindspore as ms
from mindspore import nn, Tensor

class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),
            nn.ReLU(),
            nn.Dense(512, 512),
            nn.ReLU(),
            nn.Dense(512, 10)
        )

    @ms.jit  # 使用ms.jit装饰器，使被装饰的函数以静态图模式运行
    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits

input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))
model = Network()
output = model(input)
print(output)

输出：

[[ 0.10522258  0.06597593 -0.09440921 -0.04883489  0.07194916  0.1343117
  -0.06813788  0.01986085  0.0216996  -0.05345828]
 [ 0.10522258  0.06597593 -0.09440921 -0.04883489  0.07194916  0.1343117
  -0.06813788  0.01986085  0.0216996  -0.05345828]
 ...
 [ 0.10522258  0.06597593 -0.09440921 -0.04883489  0.07194916  0.1343117
  -0.06813788  0.01986085  0.0216996  -0.05345828]
 [ 0.10522258  0.06597593 -0.09440921 -0.04883489  0.07194916  0.1343117
  -0.06813788  0.01986085  0.0216996  -0.05345828]]

1.5.2 基于context的开启方式

context模式是一种全局的设置模式。代码示例如下：

import numpy as np
import mindspore as ms
from mindspore import nn, Tensor
ms.set_context(mode=ms.GRAPH_MODE)  # 使用set_context进行运行静态图模式的配置

class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),
            nn.ReLU(),
            nn.Dense(512, 512),
            nn.ReLU(),
            nn.Dense(512, 10)
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits

model = Network()
input = Tensor(np.ones([64, 1, 28, 28]).astype(np.float32))
output = model(input)
print(output)

输出：

[[ 0.08501796 -0.04404321 -0.05165704  0.00357929  0.00051521  0.00946456
   0.02748473 -0.19415936 -0.00278988  0.04024826]
 [ 0.08501796 -0.04404321 -0.05165704  0.00357929  0.00051521  0.00946456
   0.02748473 -0.19415936 -0.00278988  0.04024826]
 ...
 [ 0.08501796 -0.04404321 -0.05165704  0.00357929  0.00051521  0.00946456
   0.02748473 -0.19415936 -0.00278988  0.04024826]
 [ 0.08501796 -0.04404321 -0.05165704  0.00357929  0.00051521  0.00946456
   0.02748473 -0.19415936 -0.00278988  0.04024826]]

静态图加速

1.6 静态图的语法约束

在Graph模式下，Python代码并不是由Python解释器去执行，而是将代码编译成静态计算图，然后执行静态计算图。因此，编译器无法支持全量的Python语法。MindSpore的静态图编译器维护了Python常用语法子集，以支持神经网络的构建及训练。详情可参考静态图语法支持。

1.7 JitConfig配置选项

在图模式下，可以通过使用JitConfig配置选项来一定程度的自定义编译流程，目前JitConfig支持的配置参数如下：

jit_level: 用于控制优化等级。
exec_mode: 用于控制模型执行方式。
jit_syntax_level: 设置静态图语法支持级别，详细介绍请见静态图语法支持。

1.8 静态图高级编程技巧

使用静态图高级编程技巧可以有效地提高编译效率以及执行效率，并可以使程序运行的更加稳定。详情可参考静态图高级编程技巧。

2. 小结

文本主要介绍了AI编译框架的两种运行模式动态图模式和静态图模式加速。在脚本开发和网络流程调试过程中，推荐使用动态图模式进行调试。静态图模式则适合比较适合网络固定且需要高性能的场景。然后介绍了静态图模式的使用场景、开启方式、语法约束、配置选项和高级编程技巧。其中开启方式主要包括装饰器开启和基于context开启。