《动手学深度学习》学习笔记(八)

最新推荐文章于 2024-05-21 16:34:25 发布

逍遥郎wj

最新推荐文章于 2024-05-21 16:34:25 发布

阅读量256

点赞数

分类专栏： # 动手学深度学习文章标签：深度学习 pytorch 神经网络 mxnet

本文链接：https://blog.csdn.net/xiaoyaolangwj/article/details/112967260

版权

动手学深度学习专栏收录该内容

10 篇文章 9 订阅

订阅专栏

第八章计算性能

影响计算性能的重要因子：命令式编程、符号式编程、异步计算、自动并行计算和多GPU计算。

一、命令式和符号式混合编程

之前我们用的全是命令式编程，使用编程语句改变程序状态。

import timeit
def add(a, b):
    return a+b

def fancy_func(a, b, c, d):
    e = add(a, b)
    f = add(c, d)
    g = add(e, f)
    return g

t1 = timeit.Timer("fancy_func(1, 2, 3, 4)", "from __main__ import fancy_func")
print("time cost %.5f seconds \n" % t1.timeit(number=1000))

# time cost 0.00081 seconds

命令式编程很方便，但是运行速度慢：

函数add被多次重复调用。python 会逐一执行三条add命令。
需要保存变量e和f的值，直到整体执行结束。

符号式编程通常在计算流程完全定义好后才被执行。多个深度学习框架，如Theano和TensorFlow，都使用了符号式编程。

符号式编程的程序需要3个步骤：

1、定义计算流程；

2、把计算机流程编译成可执行的程序；

3、给定输入，调用编译好的程序执行。

下面使用符号式编程重新实现上面的命令式编程代码。

import timeit
def add_str():
    return '''
def add(a, b):
    return a+b
    '''

def fancy_func_str():
    return '''
def fancy_func(a, b, c, d):
    e = add(a, b)
    f = add(c, d)
    g = add(e, f)
    return g
    '''

def evoke_str():
    return add_str() + fancy_func_str() +'''
print(fancy_func(1, 2, 3, 4))
    '''
def test():
    prog = evoke_str()
    # print(prog)
    y = compile(prog, "", "exec")
    exec(y)
t1 = timeit.Timer("test", "from __main__ import test")
print("time cost %.5f seconds \n" % t1.timeit(number=1000))

# time cost 0.00002 seconds

还可以使用如下方式测效率。在timeit中将要执行的语句保存为带三引号的字符串来执行测试。

from timeit import timeit


def add_str():
    return '''
def add(a, b):
    return a + b
'''


def fancy_func_str():
    return '''
def fancy_func(a, b, c, d):
    e = add(a, b)
    f = add(c, d)
    g = add(e, f)
    return g
'''


p= '''
def test():
    prog = evoke_str()
    # print(prog)
    y = compile(prog, '', 'exec')
    exec(y)
'''

print("time cost %.5f seconds \n" % timeit(stmt=p, number=1000))

# time cost 0.00011 seconds

以上定义的3个函数都仅以字符串的形式返回计算流程。最后我们通过compile函数编译完整的计算流程并运行。

由于在编译时系统能够完整地获取整个程序，因此有更多空间优化计算。例如，编译的时候可以将程序改写成print((1 + 2) + (3 + 4))，甚至直接改写成 print(10)。这样不仅减少了函数调用，还节省了内存。

对比这两种编程方式：命令式编程和符号式编程。

命令式编程更方便，直观。方便获取并打印中间变量值，或使用调试工具。
符号式编程高效，并更容易移植。编译的时候系统容易做更多的优化；符号式编程将程序变成一个与Python无关的格式，从而可以使程序在非Python环境下运行，以避免Python解释器的性能问题。

用户应该⽤纯命令式编程进⾏开发和调试；当需要产品级别的计算性能和部署时，用户可以将⼤部分命令式程序转换成符号式程序来运⾏。

由于PyTorch仅仅采⽤用了了命令式编程，所以跳过本节剩余部分Pytorch。那我们就来看看Gluon提供的混合式编程方式。

使用HybridSequential类构造模型

在混合式编程中，我们可以通过使⽤HybridBlock类或者HybridSequential类构建模型。默认情况下，它们和Block类或者Sequential类⼀样依据命令式编程的方式执行。当我们调⽤hybridize函数后，Gluon会转换成依据符号式编程的方式执行。事实上，绝大多数模型都可以接受这样的混合式编程的执行方式。

之前用Sequential类来串联多个层。为了使用混合式编程，将Sequential类替换成HybridSequential类。

from mxnet import nd,sym
from mxnet.gluon import nn
import time


def get_net():
    net = nn.HybridSequential()
    net.add(nn.Dense(256, activation="relu"), 
            nn.Dense(128, activation="relu"), 
            nn.Dense(2))
    net.initialize()
    return net

x = nd.random.normal(shape=(1, 512))
net = get_net()
net(x)

然后通过调用hybridize函数来编译和优化HybridSequential实例中串联的层的计算。

net.hybridize()
net(x)

只有继承HybridBlock类的层才会被优化计算。

计算性能对比：

def benchmark(net, x):
    start = time.time()
    for i in range(1000):
        _ = net(x)
    nd.waitall()
    return time.time() - start

net = get_net()
print("before hybridizing:%.4f sec" % (benchmark(net, x)))
net.hybridize()
print("after hybridizing:%.4f sec" % (benchmark(net, x)))

before hybridizing: 0.4733 sec
after hybridizing: 0.2195 sec

获取符号式程序：

通过export函数将符号式程序和模型参数保存在硬盘上。

net.export("my_mlp")

生成.json文件和.params文件。分别为符号式程序和模型参数。可以被Python和MXNet支持的其他前端语言读取，如C++、R、Scala、Perl和其他语言。这样我们就可以很方便地使用其他前端语言或其他设备上部署训练好的模型。同时由于部署时使用的是符号式编程程序，计算性能往往比命令式程序的性能更好。