一文搞懂tf.function

谁践踏了优雅 2022-09-08 03:52 235阅读 0赞

朋友们，如需转载请标明出处：[https://blog.csdn.net/jiangjunshow][https_blog.csdn.net_jiangjunshow]

在tensorflow1.x的时候，代码默认的执行方式是graph execution（图执行），而从tensorflow2.0开始，改为了eager execution（饥饿执行）。正如翻译的意思一样，eager execution会立即执行每一步代码，非常的饥渴。而graph execution会将所有代码组合成一个graph（图）后再执行。这里打一个不太恰当的比喻来帮助大家理解：eager execution就像搞一夜情，认识后就立即“执行”，而graph execution就像婚恋，认识后先憋着，不会立即“执行”，要经过了长时间的“积累”后，再一次性“执行”。

在eager 模式下，代码的编写变得很自然很简单，而且因为代码会被立即执行，所以调试时也变得很方便。而graph 模式下，代码的执行效率要高一些；而且由于graph其实就是一个由操作指令和数据组成的一个数据结构，所以graph可以很方便地被导出并保存起来，甚至之后可以运行在其它非python的环境下（因为graph就是个数据结构，里面定义了一些操作指令和数据，所以任何地方只要能解释这些操作和数据，那么就能运行这个模型）；也正因为graph是个数据结构，所以不同的运行环境可以按照自己的喜好来解释里面的操作和数据，这样一来，解释后生成的代码会更加符合当前运行的环境，这里一来代码的执行效率就更高了。

可能有些同学还无法理解上面所说的“graph是个数据结构…”。这里我打个比方来帮助大家理解。假设graph里面包含了两个数据x和y，另外还包含了一个操作指令“将x和y相加”。当C++的环境要运行这个graph时，“将x和y相加”这个操作就会被翻译成相应的C++代码，当Java环境下要运行这个graph时，就会被解释成相应的Java代码。graph里面只是一些数据和指令，具体怎么执行命令，要看当前运行的环境。

除了上面所说的，graph还有很多内部机制使代码更加高效运行。总之，graph execution可以让tensorflow模型运行得更快，效率更高，更加并行化，更好地适配不同的运行环境和运行设备。

graph 虽然运行很高效，但是代码却没有eager 的简洁，为了兼顾两种模式的优点，所以出现了tf.function。使用tf.function可以将eager 代码一键封装成graph。

既然是封装成graph，那为什么名字里使用function这个单词内，不应该是tf.graph吗？因为tf.function的作用就是将python function转化成包含了graph的tensorflow function。所以使用function这个单词也说得通。下面的代码可以帮助大家更好地理解。

import tensorflow as tf
    import timeit
    from datetime import datetime
    
    # 定义一个 Python function.
    def a_regular_function(x, y, b):
      x = tf.matmul(x, y)
      x = x + b
      return x
    
    # `a_function_that_uses_a_graph` 是一个 TensorFlow `Function`.
    a_function_that_uses_a_graph = tf.function(a_regular_function)
    
    # 定义一些tensorflow tensors.
    x1 = tf.constant([[1.0, 2.0]])
    y1 = tf.constant([[2.0], [3.0]])
    b1 = tf.constant(4.0)
    
    orig_value = a_regular_function(x1, y1, b1).numpy()
    # 在python中可以直接调用tenforflow Function。就像使用python自己的function一样。
    tf_function_value = a_function_that_uses_a_graph(x1, y1, b1).numpy()
    assert(orig_value == tf_function_value)

tf.function不仅仅只作用于顶层的python function，它也作用于内嵌的python function。看下面的代码你就能明白了。

def inner_function(x, y, b):
      x = tf.matmul(x, y)
      x = x + b
      return x
    
    # 使用tf.function将`outer_function`变成一个tensorflow `Function`。注意，之前的代码是将tf.function当作是函数来使用，这样是被当作了修饰符来使用。这两种方式都是被支持的。
    @tf.function
    def outer_function(x):
      y = tf.constant([[2.0], [3.0]])
      b = tf.constant(4.0)
    
      return inner_function(x, y, b)
    
    # tf.function构建的graph中不仅仅包含了 `outer_function`还包含了它里面调用的`inner_function`。
    outer_function(tf.constant([[1.0, 2.0]])).numpy()

输出结果：

array([[12.]], dtype=float32)

如果你之前使用过tenforflow 1.x，你会察觉到，在2.x中构建graph再也不需要tf.Session和Placeholder了。使代码大大地简洁了。

我们的代码里经常会将python代码和tensorflow代码混在一起。在使用tf.function进行graph转化时，tensorflow的代码会被直接进行转化，而python代码会被一个叫做AutoGraph (tf.autograph)的库来负责进行转化。

同一个tensorflow function可能会生成不同的graph。因为每一个tf.Graph的input输入类型必须是固定的，所以如果在调用tensorflow function时传入了新的数据类型，那么这次的调用就会生成一个新的graph。输入的类型以及维度被称为signature（签名），tensorflow function就是根据签名来生成graph的，遇到新的签名就会生成新的graph。下面的代码可以帮助你理解。

@tf.function
    def my_relu(x):
      return tf.maximum(0., x)
    
    # 下面对`my_relu` 的3次调用的数据类型都不同，所以生成了3个graph。这3个graph都被保存在my_relu这个tenforflow function中。
    print(my_relu(tf.constant(5.5)))
    print(my_relu([1, -1])) #python数组
    print(my_relu(tf.constant([3., -3.])))	# tf数组

输出结果：

tf.Tensor(5.5, shape=(), dtype=float32)
    tf.Tensor([1. 0.], shape=(2,), dtype=float32)
    tf.Tensor([3. 0.], shape=(2,), dtype=float32)

如果相同的输入类型被调用了，那么不会再重新生成新的类型。

# 下面这两个调用就不会生成新的graph.
    print(my_relu(tf.constant(-2.5))) # 这个数据类型与上面的 `tf.constant(5.5)`一样.
    print(my_relu(tf.constant([-1., 1.]))) # 这个数据类型与上面的 `tf.constant([3., -3.])`一样。

因为一个tensorflow function里面可以包含多个graph，所以说tensorflow function是具备多态性的。这种多态性使得tensorflow function可以任意支持不同的输入类型，非常的灵活；并且由于对每一个输入类型会生成一个特定的graph，这也会让代码执行时更加高效！

下面的代码打印出了3种不同的签名

print(my_relu.pretty_printed_concrete_signatures())

输出结果：

my_relu(x)
      Args:
        x: float32 Tensor, shape=()
      Returns:
        float32 Tensor, shape=()
    
    my_relu(x=[1, -1])
      Returns:
        float32 Tensor, shape=(2,)
    
    my_relu(x)
      Args:
        x: float32 Tensor, shape=(2,)
      Returns:
        float32 Tensor, shape=(2,)

上面你已经学会了如何使用tf.function将python function转化为tenforflow function。但要想在实际开发中正确地使用tf.function，还需要学习更多知识。下面我就带领大家来学习学习它们。八十八师的弟兄们，不要退缩，跟着我一起冲啊啊啊！

默认情况下，tenforflow function里面的代码会以graph的模式被执行，但是也可以让它们以eager的模式来执行。大家看下面的代码。

@tf.function
    def get_MSE():
      print("Calculating MSE!")
    
    #这条语句就是让下面的代码以eager的模式来执行
    tf.config.run_functions_eagerly(True)
    get_MSE(y_true, y_pred)
    #这条代码就是取消前面的设置
    tf.config.run_functions_eagerly(False)

某些情况下，同一个tensorflow function在graph与eager模式下会有不同的运行效果。python的print函数就是其中一个特殊情况。看下面的代码。

@tf.function
    def get_MSE(y_true, y_pred):
      print("Calculating MSE!")
      sq_diff = tf.pow(y_true - y_pred, 2)
      return tf.reduce_mean(sq_diff)
    
    y_true = tf.random.uniform([5], maxval=10, dtype=tf.int32)
    y_pred = tf.random.uniform([5], maxval=10, dtype=tf.int32)
    
    error = get_MSE(y_true, y_pred)
    error = get_MSE(y_true, y_pred)
    error = get_MSE(y_true, y_pred)

输出结果：

Calculating MSE!

看到输出结果你是不是很惊讶？get\_MSE被调用了3次，但是里面的python print函数只被执行了一次。这是为什么呢？因为python print函数只在创建graph时被执行，而上面的3次调用中输入参数的类型都是一样的，所以只有一个graph被创建了一次，所以python print函数也只会被调用一次。

为了将graph和eager进行对比，下面我们在eager模式下看看输出结果。

# 开启强制eager模式
    tf.config.run_functions_eagerly(True)
    
    error = get_MSE(y_true, y_pred)
    error = get_MSE(y_true, y_pred)
    error = get_MSE(y_true, y_pred)
    
    # 取消eager模式
    tf.config.run_functions_eagerly(False)

输出结果：

Calculating MSE!
    Calculating MSE!
    Calculating MSE!

看！在eager模式下，print被执行了3次。PS：如果使用tf.print，那么在graph和eager模式下都会打印3次。

graph execution模式还有一个特点，就是它会不执行那些无用的代码。看下面的代码。

def unused_return_eager(x):
      # 当传入的x只包含一个元素时，下面的代码会报错，因为下面的代码是要获取x的第二个元素。PS:索引是从0开始的，1代表第二个元素
      tf.gather(x, [1]) # unused 
      return x
    
    try:
      print(unused_return_eager(tf.constant([0.0])))
    except tf.errors.InvalidArgumentError as e:
      print(f'{type(e).__name__}: {e}')

上面的代码是以eager的模式运行，所以每一行代码都会被执行，所以上面的异常会发生并且会被捕获到。而下面的代码是以graph模式运行的，则不会报异常。因为tf.gather(x, \[1\])这句代码其实没有任何用途（它只是获取了x的第二个元素，并没有赋值也没有改变任何变量），所以graph模式下它根本就没有被执行，所以也就不会报任何异常了。

@tf.function
    def unused_return_graph(x):
      tf.gather(x, [1])
      return x
    
    try:
      print(unused_return_eager(tf.constant([0.0])))
    except tf.errors.InvalidArgumentError as e:
      print(f'{type(e).__name__}: {e}')

前面我们说graph的执行效率会比eager的要高，那到底高多少呢？其实我们可以用下面的代码来计算graph模式到底能比eager模式提升多少效率。

x = tf.random.uniform(shape=[10, 10], minval=-1, maxval=2, dtype=tf.dtypes.int32)
    
    def power(x, y):
      result = tf.eye(10, dtype=tf.dtypes.int32)
      for _ in range(y):
        result = tf.matmul(x, result)
      return result
    print("Eager execution:", timeit.timeit(lambda: power(x, 100), number=1000))

输出结果：

Eager execution: 1.8983725069999764

power_as_graph = tf.function(power)
    print("Graph execution:", timeit.timeit(lambda: power_as_graph(x, 100), number=1000))

输出结果：

Graph execution: 0.5891194120000023

从上面的代码可以看出graph比eager的执行时间缩短了近3倍。当然，因具体计算内容不同，效率的提升程度也是不同的。

graph虽然能提升运行效率，但是转化graph时也会有代价。对于某些代码，转化graph所需的时间可能比运行graph的还要长。所以在编写代码时要尽量避免graph的重复转化。如果你发现模型的效率很低，那么可以查查是否存在重复转化。可以通过加入print函数来判断是否存在重复转化（还记得前面我们讲过，每次转化graph时就会调用一次print函数）。看下面的代码。

@tf.function
    def a_function_with_python_side_effect(x):
      print("Tracing!") # An eager-only side effect.
      return x * x + tf.constant(2)
    
    print(a_function_with_python_side_effect(tf.constant(2)))
    print(a_function_with_python_side_effect(tf.constant(3)))

输出结果：

Tracing!
    tf.Tensor(6, shape=(), dtype=int32)
    tf.Tensor(11, shape=(), dtype=int32)

可以看出，因为上面两次调用的参数类型是一样的，所以只转化了一次graph，print只被调用了一次。

print(a_function_with_python_side_effect(2))
    print(a_function_with_python_side_effect(3))

输出结果：

Tracing!
    tf.Tensor(6, shape=(), dtype=int32)
    Tracing!
    tf.Tensor(11, shape=(), dtype=int32)

上面print被调用了2次。啊？为什么？你可以会表示不解~~上面两个参数的类型是一样的啊，为什么还调用了两次print。因为，输入参数是python类型，对于新的python类型每次都会创建一个新的graph。所以最好是用tenforflow的数据类型作为function的输入参数。

最后我给出tf.function相关的几点建议：

*  当需要切换eager和graph模式时，应该使用tf.config.run\_functions\_eagerly来进行明显的标注。
 *  应该在python function的外面创建tenforflow的变量（tf.Variables)，在里面修改它们的值。这条建议同样适用于其它那些使用tf.Variables的tenforflow对象（例如keras.layers,keras.Models,tf.optimizers）。
 *  避免函数内部依赖外部定义的python变量。
 *  应该尽量将更多的计算量代码包含在一个tf.function中而不是包含在多个tf.function里，这样可以将代码执行效率最大化。
 *  最好是用tenforflow的数据类型作为function的输入参数。

[https_blog.csdn.net_jiangjunshow]: https://blog.csdn.net/jiangjunshow