动静态图结合

下载Notebook下载样例代码查看源文件

静态图和动态图的概念

目前主流的深度学习框架的执行模式有两种,分别为静态图模式和动态图模式。

静态图模式下,程序在编译执行时先生成神经网络的图结构,然后再执行图中涉及的计算操作。因此,在静态图模式下,编译器利用图优化等技术对执行图进行更大程度的优化,从而获得更好的执行性能,有助于规模部署和跨平台运行。

动态图模式下,程序按照代码的编写顺序执行,在执行正向过程中根据反向传播的原理,动态生成反向执行图。这种模式下,编译器将神经网络中的各个算子逐一下发执行,方便用户编写和调试神经网络模型。

MindSpore静态图

在MindSpore中,静态图模式又被称为Graph模式,可以通过set_context(mode=GRAPH_MODE)来设置成静态图模式。静态图模式比较适合网络固定且需要高性能的场景。在静态图模式下,基于图优化、计算图整图下沉等技术,编译器可以针对图进行全局的优化,因此在静态图下能获得较好的性能,但是执行图是从源码转换而来,因此在静态图下不是所有的Python语法都能支持。

Graph模式执行原理

在Graph模式下,MindSpore通过源码转换的方式,将Python的源码转换成IR,再在此基础上进行相关的图优化,最终在硬件设备上执行优化后的图。MindSpore使用的是一种基于图表示的函数式IR,即MindIR,采用了接近于ANF函数式的语义。Graph模式是基于MindIR进行编译优化的,使用Graph模式时,需要使用nn.Cell类并且在construct函数中编写执行代码,或者调用@jit装饰器。

Graph模式的代码用例如下所示:

[1]:
import numpy as np
import mindspore.nn as nn
import mindspore.ops as ops
import mindspore as ms

ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()
        self.mul = ops.Mul()

    def construct(self, x, y):
        return self.mul(x, y)

x = ms.Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
y = ms.Tensor(np.array([4.0, 5.0, 6.0]).astype(np.float32))

net = Net()
print(net(x, y))
[ 4. 10. 18.]

Graph模式自动微分原理

在MindSpore中,Graph模式下的自动微分原理可以参考自动微分

MindSpore动态图

在MindSpore中,动态图模式又被称为PyNative模式,可以通过set_context(mode=PYNATIVE_MODE)来设置成动态图模式。在脚本开发和网络流程调试中,推荐使用动态图模式进行调试,支持执行单算子、普通函数和网络、以及单独求梯度的操作。

PyNative模式执行原理

在PyNative模式下,用户可以使用完整的Python API,此外针对使用MindSpore提供的API时,框架会根据用户选择的硬件平台(Ascend,GPU,CPU),将算子API的操作在对应的硬件平台上执行,并返回相应的结果。框架整体的执行过程如下:

process

通过前端的Python API,调用到框架层,最终到相应的硬件设备上进行计算。例如:完成一个加法

[2]:
import numpy as np
import mindspore.nn as nn
import mindspore as ms
import mindspore.ops as ops

ms.set_context(mode=ms.PYNATIVE_MODE, device_target="CPU")
x = ms.Tensor(np.ones([1, 3, 3, 4]).astype(np.float32))
y = ms.Tensor(np.ones([1, 3, 3, 4]).astype(np.float32))
output = ops.add(x, y)
print(output.asnumpy())
[[[[2. 2. 2. 2.]
   [2. 2. 2. 2.]
   [2. 2. 2. 2.]]

  [[2. 2. 2. 2.]
   [2. 2. 2. 2.]
   [2. 2. 2. 2.]]

  [[2. 2. 2. 2.]
   [2. 2. 2. 2.]
   [2. 2. 2. 2.]]]]

此例中,当调用到Python接口ops.add(x, y)时,会将Python的接口调用通过Pybind11调用到框架的C++层,转换成C++的调用,接着框架会根据用户设置的device_target选择对应的硬件设备,在该硬件设备上执行add这个操作。

从上述原理可以看到,在PyNative模式下,Python脚本代码会根据Python的语法进行执行,而执行过程中涉及到MindSpore的API,会根据用户设置在不同的硬件上进行执行,从而进行加速。因此,在PyNative模式下,用户可以随意使用Python的语法以及调试方法。例如可以使用常见的PyCharm、VS Code等IDE进行代码的调试。

PyNative模式自动微分原理

在前面的介绍中,我们可以看出,在PyNative下执行正向过程完全是按照Python的语法进行执行。在PyNative下是基于Tensor进行实现反向传播的,我们在执行正向过程中,将所有应用于Tensor的操作记录下来,并针对每个操作求取其反向,并将所有反向过程串联起来形成整体反向传播图(简称反向图)。最终,将反向图在设备上进行执行计算出梯度。

反向构图过程示例,如下代码,对矩阵x乘上固定参数z,然后与y进行矩阵乘法,最终对x进行求导。

[3]:
import numpy as np
import mindspore.nn as nn
import mindspore.ops as ops
import mindspore as ms

ms.set_context(mode=ms.PYNATIVE_MODE, device_target="CPU")

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()
        self.matmul = ops.MatMul()
        self.z = ms.Parameter(ms.Tensor(np.array([2.0], np.float32)), name='z')

    def construct(self, x, y):
        x = x * self.z
        out = self.matmul(x, y)
        return out

class GradNetWrtX(nn.Cell):
    def __init__(self, net):
        super(GradNetWrtX, self).__init__()
        self.net = net

    def construct(self, x, y):
        gradient_function = ms.grad(self.net)
        return gradient_function(x, y)

x = ms.Tensor([[0.8, 0.6, 0.2], [1.8, 1.3, 1.1]], dtype=ms.float32)
y = ms.Tensor([[0.11, 3.3, 1.1], [1.1, 0.2, 1.4], [1.1, 2.2, 0.3]], dtype=ms.float32)
output = GradNetWrtX(Net())(x, y)
print(output)
[[9.02      5.4       7.2000003]
 [9.02      5.4       7.2000003]]

forward backward

根据上述PyNative下构图原理,我们可以看到,在正向传播过程中,我们记录了Mul的计算过程,根据Mul对应的反向bprop的定义,得到了反向的MulGrad算子,根据Mul算子的bprop定义,如下:

[4]:
from mindspore.ops._grad.grad_base import bprop_getters

@bprop_getters.register(ops.Mul)
def get_bprop_mul(self):
    """Grad definition for `Mul` operation."""
    mul_func = P.Mul()

    def bprop(x, y, out, dout):
        bc_dx = mul_func(y, dout)
        bc_dy = mul_func(x, dout)
        return binop_grad_common(x, y, bc_dx, bc_dy)

    return bprop

可以看到对Mul的输入求反向,需要两个输入和输出的反向传播梯度值,此时根据实际的输入值,可以将z连接到MulGrad。以此类推,对下一个算子Matmul,相应的得到MatmulGrad信息,再根据bprop的输入输出,将上下文梯度传播连接起来。

同理对于输入y求导,可以使用同样的过程进行推导。

PyNative模式下的控制流

在PyNative模式下,脚本按照Python的语法执行,因此在MindSpore中,针对控制流语法并没有做特殊处理,直接按照Python的语法直接展开执行,进而对展开的执行算子进行自动微分的操作。例如,对于for循环,在PyNative下会根据具体的循环次数,不断的执行for循环中的语句,并对其算子进行自动微分的操作。

动静统一

概述

当前在业界支持动态图和静态图两种模式,动态图通过解释执行,具有动态语法亲和性,表达灵活;静态图使用jit编译优化执行,偏静态语法,在语法上有较多限制。动态图和静态图的编译流程不一致,语法约束不一致。MindSpore针对动态图和静态图模式,首先统一API表达,在两种模式下使用相同的API;其次统一动态图和静态图的底层微分机制。

dynamic

动态图和静态图互相转换

在MindSpore中,我们可以通过控制模式输入参数来切换执行使用动态图还是静态图。例如:

[5]:
ms.set_context(mode=ms.PYNATIVE_MODE)

由于在静态图下,对于Python语法有所限制,因此从动态图切换成静态图时,需要符合静态图的语法限制,才能正确使用静态图来进行执行。更多静态图的语法限制可以参考静态图语法限制

动静结合

MindSpore支持在动态图下使用静态编译的方式来进行混合执行,通过使用jit修饰需要用静态图来执行的函数对象,即可实现动态图和静态图的混合执行,更多jit的使用可参考jit文档

例如:

[6]:
import numpy as np
import mindspore as ms
import mindspore.nn as nn

class AddMulMul(nn.Cell):
    def __init__(self):
        super(AddMulMul, self).__init__()
        self.param = ms.Parameter(ms.Tensor(0.5, ms.float32))

    @ms.jit
    def construct(self, x):
        x = x + x
        x = x * self.param
        x = x * x
        return x

class CellCallSingleCell(nn.Cell):
    def __init__(self):
        super(CellCallSingleCell, self).__init__()
        self.conv = nn.Conv2d(1, 2, kernel_size=2, stride=1, padding=0, weight_init="ones", pad_mode="valid")
        self.bn = nn.BatchNorm2d(2, momentum=0.99, eps=0.00001, gamma_init="ones")
        self.relu = nn.ReLU()
        self.add_mul_mul = AddMulMul()

    def construct(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.add_mul_mul(x)
        x = self.relu(x)
        return x

ms.set_context(mode=ms.PYNATIVE_MODE, device_target="CPU")
inputs = ms.Tensor(np.ones([1, 1, 2, 2]).astype(np.float32))
net = CellCallSingleCell()
out = net(inputs)
print(out)
[[[[15.99984]]

  [[15.99984]]]]

JIT Fallback

在MindSpore静态图模式下,用户编写程序时需要遵循MindSpore静态图语法支持,语法使用存在约束限制。而在动态图模式下,Python脚本代码会根据Python语法进行执行,用户可以使用任意Python语法。可以看出,静态图和动态图的语法约束限制是不同的。

JIT Fallback是从静态图的角度出发考虑静态图和动态图的统一。通过JIT Fallback特性,静态图可以支持尽量多的动态图语法,使得静态图提供接近动态图的语法使用体验,从而实现动静统一。为了便于用户选择是否使用JIT Fallback特性的能力,提供了开关MS_DEV_ENABLE_FALLBACK,当前默认已经打开。如果需要关闭,可以使用命令:export MS_DEV_ENABLE_FALLBACK=0

下面主要介绍JIT Fallback的支持范围和使用须知,以便您可以更有效地使用JIT Fallback功能。

支持范围

当前JIT Fallback特性主要应用于常量场景,即要求在编译期间能够确定实际值;有限支持部分变量场景。JIT Fallback特性还在持续完善中,下面列举出当前通过该特性已经支持的静态图编译语法。

创建和使用Tensor

JIT Fallback支持在静态图模式下创建和使用Tensor

代码用例如下,用例中的Tensor(1, dtype=mstype.int32)是通过JIT Fallback支持的。

[7]:
import mindspore.nn as nn
import mindspore as ms

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self):
        return ms.Tensor(1, dtype=ms.int32)

ms.set_context(mode=ms.GRAPH_MODE)

net = Net()
print(net())
[1]

调用第三方库

JIT Fallback支持在静态图模式下调用第三方库的对象和方法。

需要说明的是,对于具有返回值的方法,需要使用变量来保存其结果,否则可能出现报错。这个用法将在后续版本中支持。

调用第三方库的代码用例如下。用例调用了NumPy第三方库,其中np.array([1, 2, 3])np.array([4, 5, 6])是通过JIT Fallback支持的。

[8]:
import numpy as np
import mindspore as ms
import mindspore.nn as nn

# pylint: disable= W0235
class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self):
        a = np.array([1, 2, 3])
        b = np.array([4, 5, 6])
        c = a + b
        return ms.Tensor(c)

ms.set_context(mode=ms.GRAPH_MODE)
net = Net()
print(net())
[5 7 9]

使用Python原生的print打印

JIT Fallback支持在静态图模式下使用Python原生的print来打印常量,它与Print算子打印信息的时机有所不同。Python原生print是在编译过程中触发打印(编译时阶段打印),而Print算子是需要图编译完成后,下发到设备端运行才打印(运行时阶段打印)。

为了便于理解,举例如下。tensor_sum涉及Tensor相加,即运行时阶段才能得到结果,在调用print时,实际调用的是静态图模式中的Print算子,参考静态图语法支持。而np_num是由两个NumPy常量相加得到的结果,即通过JIT Fallback支持的用法,因此在调用print时,使用的是Python原生print。由于两者的打印时机不同,最终导致显示np_sum在tensor_sum之前,即通过JIT Fallback支持的Python原生print的打印结果会在Print算子之前。

[9]:
import numpy as np
import mindspore as ms
import mindspore.nn as nn

# pylint: disable= W0235
class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self):
        x = ms.Tensor(np.array([1, 2, 3, 4, 5]))
        y = ms.Tensor(np.array([1, 2, 3, 4, 5]))
        tensor_sum = x + y
        print("tensor_sum: ", tensor_sum)
        x = np.array([1, 2, 3, 4, 5])
        y = np.array([1, 2, 3, 4, 5])
        np_sum = x + y
        print("np_sum: ", np_sum)
        return tensor_sum, ms.Tensor(np_sum)

ms.set_context(mode=ms.GRAPH_MODE)
net = Net()
net()
np_sum: [2 4 6 8 10]
tensor_sum: (2, 4, 6, 8, 10)

当前不支持使用同一个print同时打印编译时期和运行时期执行的信息,例如将np_sum和tensor_sum放在同一个print中将会报错。错误的代码用例如下:

import numpy as np
import mindspore as ms
import mindspore.nn as nn

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self, input_x, input_y):
        tensor_sum = input_x + input_y
        x = np.array([1, 2, 3, 4, 5])
        y = np.array([1, 2, 3, 4, 5])
        np_sum = x + y
        print("np_sum: ", np_sum, "tensor_sum: ", tensor_sum)
        return tensor_sum, ms.Tensor(np_sum)

ms.set_context(mode=ms.GRAPH_MODE)
x = ms.Tensor(np.array([1, 2, 3, 4, 5]))
y = ms.Tensor(np.array([1, 2, 3, 4, 5]))
net = Net()
net(x,y)

报错信息如下:

ValueError: When using JIT Fallback to handle script 'print("np_sum: ", np_sum, "tensor_sum: ", tensor_sum)', the inputs should be constant, but found variable 'tensor_sum' to be nonconstant.

使用raise和assert

JIT Fallback支持在静态图模式下使用raise和assert。

使用raise时,要求条件语句为变量场景时,raise语句所在分支以外的分支不能返回none以外的值,否则可能出现不可预期的结果。正确的代码用例如下:

import mindspore.nn as nn
import mindspore as ms

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self, x):
        if x <= 0:
            raise ValueError("x should be greater than 0.")
        else:
            x += 1
        return x

ms.set_context(mode=ms.GRAPH_MODE)
net = Net()
net(-1)

输出结果:

ValueError: x should be greater than 0.

同理,使用assert时,也需要符合常量场景的条件。正确的代码用例如下:

import mindspore.nn as nn
import mindspore as ms

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()

    def construct(self):
        x = 1
        assert 1 in [2, 3, 4]
        return x

ms.set_context(mode=ms.GRAPH_MODE)
net = Net()
net()

输出结果中正常出现:

AssertionError.

调用Python内置函数

MindSpore在静态图模式下已经支持了一些Python内置函数,包括但不限于len、isinstance、map、zip等,详情请参考静态图语法支持。通过JIT Fallback,可以在常量场景中支持更多的Python内置函数的用法。下面简单举例支持的部分Python内置函数。

dict()

功能:用于创建一个字典。

有效输入:字典的 Key 只支持 String 类型,Value 只支持常量,不支持自定义类。

暂不支持对 dict() 创建的字典进行循环遍历,包括 dict.keys()dict.values()dict.items()

代码用例如下:

[10]:
import mindspore as ms

@ms.jit
def func():
    a = dict()                                          # 创建空字典
    b = dict(a='a', b='b', t='t')                       # 传入关键字
    c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    d = dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    return a, b, c, d

a, b, c, d = func()
print("a: ", a)
print("b: ", b)
print("c: ", c)
print("d: ", d)

a: {}
b: {'a': 'a', 'b': 'b', 't': 't'}
c: {'one': 1, 'two': 2, 'three': 3}
d: {'one': 1, 'two': 2, 'three': 3}
type()

功能:输出入参的类型。

有效输入:Number、list、tuple、dict、np.array、常量Tensor。

代码用例如下:

[11]:
import numpy as np
import mindspore as ms

@ms.jit
def func():
    a = type(1)
    b = type(1.0)
    c = type([1, 2, 3])
    d = type((1, 2, 3))
    e = type({'a': 1, 'b': 2})
    f = type(np.array([1, 2, 3]))
    g = type(ms.Tensor([1, 2, 3]))
    return a, b, c, d, e, f, g

a, b, c, d, e, f, g = func()
print("a: ", a)
print("b: ", b)
print("c: ", c)
print("d: ", d)
print("e: ", e)
print("f: ", f)
print("g: ", g)

a: <class 'int'>
b: <class 'float'>
c: <class 'list'>
d: <class 'tuple'>
e: <class 'dict'>
f: <class 'numpy.ndarray'>
g: <class 'mindspore.common.tensor.Tensor'>

type作为Python的原生函数还有另外一种使用方法,即type(name, bases, dict)返回name类型的类对象,由于该用法应用场景较少,因此暂不支持。

支持常量场景下控制流

为了提高Python标准语法支持度,在常量场景下实现动静统一,通过JIT Fallback实现常量场景下控制流语句的使用。控制流语句是指if、for、while等流程控制语句。JIT Fallback特性已经支持在静态图模式下创建和使用Tensor,支持调用Numpy等第三方库创建使用常量以及支持部分Python内置函数。理论上,通过JIT Fallback支持的常量语法,在常量控制流场景中也支持。 代码用例如下:

[ ]:
import numpy as np
import mindspore as ms

@ms.jit
def func():
    x = np.array(1)
    if x <= 1:
        x += 1
    return ms.Tensor(x)

res = func()
print("res: ", res)

res: 2

支持运行时(Runtime)阶段的JIT Fallback

JIT Fallback处理不支持的语法表达式时,将会生成相应的节点,常量会在编译时阶段推导出值,否则这些节点将传递到后端运行时,在后端通过Python的能力执行得到结果。示例代码如下,np.add(x, y)会生成相应节点,作为函数的返回值将会传递到运行时,当前已支持部分场景下的运行时阶段的JIT Fallback。

[ ]:
import numpy as np
import mindspore as ms

@ms.jit
def test_np_add():
    x = np.array([1, 2, 3, 4, 5])
    y = np.array([1, 2, 3, 4, 5])
    return np.add(x, y)

np_add_res = test_np_add()
print(np_add_res)
[ 2  4  6  8  10]

顶层图支持返回list、dict、scalar、none等基础类型

顶层图支持返回list
[ ]:
import mindspore as ms

@ms.jit
def test_return_list():
    return [1, "a", True, None, ms.Tensor([2])]

res = test_return_list()
print(res)
[1, "a", True, None, Tensor([2])]
顶层图支持返回dict
[ ]:
import mindspore as ms

@ms.jit
def test_return_dict():
    x = {'a': 1, 'b': 2}
    y = x.get('a')
    y_tensor = ms.Tensor([y])
    z = dict(a=y_tensor)
    return z

res = test_return_dict()
print(res)
{'a': ms.Tensor(np.array(1), ms.int64)}
顶层图支持返回scalar
[ ]:
import mindspore as ms

@ms.jit
def test_return_scalar(x, y):
    return x + y

res = test_return_scalar(ms.mutable(1), ms.mutable(2))
print(res)
3
顶层图支持返回None
[ ]:
import mindspore as ms

@ms.jit
def test_return_none():
    return 1, "a", None

res = test_return_none()
print(res)
(1, 'a', None)

使用须知

在使用JIT Fallback时,请注意以下几点:

1.当前JIT Fallback支持常量场景,即要求编译期间能够确定实际值。有限支持部分变量场景。

2.JIT Fallback对标动态图的支持能力,须在动态图语法范围内,包括但不限于数据类型等。

3.当前常量控制流场景中暂不支持对Numpy Array数据的取下标赋值,错误的代码用例如下:

import numpy as np
import mindspore as ms

@ms.jit
def func():
    x = np.array([1, 2, 3])
    x[0] += 1
    return ms.Tensor(x)

res = func()
print("res: ", res)

报错信息如下:

RuntimeError: The 'setitem' operation does not support the type [External, Int64, Int64].

4.值得注意的是,在常量场景中,NumPy整型数据、浮点型数据的运算结果将转换为常量进行保存,因此其运算结果可以作为函数返回值。例如:

[13]:
import numpy as np
import mindspore as ms

@ms.jit
def test_np_add_constant():
    x = 1.0
    y = 2.0
    return np.add(x, y)

res = test_np_add_constant()
print("res:", res)

res: 3.0

5.通过JIT Fallback支持的NumPy第三方库,与MindSpore提供的mindspore.numpy不同。

mindspore.numpy是通过MindSpore框架的算子能力实现的,涉及运行时阶段的算子计算,无法在编译期阶段推导其结果(变量的推导结果为None)。示例代码如下,对mnp.average(x)的结果使用Tensor()方法,不符合常量场景的条件,将会引发报错。

import mindspore as ms
import mindspore.numpy as mnp

@ms.jit
def test_mnp_average():
   x = mnp.array(([[1., 2.], [3., 4.]]))
   x_average = mnp.average(x)
   return ms.Tensor(x_average)

out = test_mnp_average()
print(out)

报错信息如下:

TypeError: For 'Tensor', the type of input_data should be one of '['Tensor', 'ndarray', 'str_', 'list', 'tuple', 'float', 'int', 'bool', 'complex']', but got 'None' with type 'NoneType'.