Program

    注意：默认情况下，Paddle内部默认含有 和 default_main_program ，它们共享参数。 只运行一次来初始化参数， default_main_program 在每个mini batch中运行并更新权重。

    Program是Paddle对于计算图的一种静态描述，使用Program的构造函数可以创建一个Program。Program中包括至少一个 ，当 Block 中存在条件选择的控制流OP（例如 等）时，该Program将会含有嵌套着的 Block 即控制流外部的 将包含着控制流内部的 Block ，而嵌套的 的元素访问控制将由具体的控制流OP来决定。关于Program具体的结构和包含的类型请参阅 framework.proto 。

    一个Program的集合通常包含初始化程序（startup_program）与主程序(main_program)，初始化程序是一个包含一些初始化工作的Program，主程序将会包含用来训练的网络结构和变量，在使用同一个 执行时他们会共享初始化工作的结果，例如初始化的参数。一个Program的集合可以被用来测试或者训练，被用来训练时， Paddle 将会利用所有用户使用的OP和变量来搭建一个训练网络，被用来测试时， 可以通过调用Program相关的接口例如：clone 剪去一些与测试无关的OP和变量，比如反向传播的OP和变量。

    Program，创建的空的Program

    代码示例

    to_string ( throw_on_error, with_details=False )

    将Program转换为字符串

    参数

    返回

    str，由Program转换得到的字符串

    抛出异常： ValueError - 当 throw_on_error == true ，当没有设置任何必需的字段时，抛出 ValueError 。

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. prog = static.default_main_program()
    7. x = static.data(name="X", shape=[2,3], dtype="float32")
    8. pred = static.nn.fc(x, size=3)
    9. prog_string = prog.to_string(throw_on_error=True, with_details=False)
    10. prog_string_with_details = prog.to_string(throw_on_error=False, with_details=True)
    11. print("program string without detail: {}".format(prog_string))
    12. print("program string with detail: {}".format(prog_string_with_details))

    clone ( for_test=False )

    注解

    1. Program.clone() 方法不会克隆例如 DataLoader 这样的数据读取相关的部分，这可能会造成的数据读取部分在克隆后丢失；

    2. 此API当 for_test=True 时将会裁剪部分OP和变量。为防止错误的裁剪，推荐在 和执行优化器之前使用； clone(for_test=True) 。

    当 for_test=True 时创建一个新的、仅包含当前Program前向内容的Program。否则创建一个新的，和当前Program完全相同的Program

    有些OP，在训练和测试之间的行为是不同的，比如 batch_norm 。它们有一个属性 is_test 来控制行为。当 for_test=True 时，此方法将把它们的 is_test 属性更改为True。

    • 克隆Program用于测试时，将 for_test 设置为True。虽然在这种情况下，如果在使用了优化器之后调用 clone 我们依旧会对Program当中反向执行以及优化器相关的内容进行自动裁剪，但是，我们强烈建议在使用优化器之前使用 clone 例如如果使用的是 可以这样去使用:

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. img = static.data(name='image', shape=[None, 784])
    7. pred = static.nn.fc(x=img, size=10, activation='relu')
    8. loss = paddle.mean(pred)
    9. # Here we use clone before Momentum
    10. test_program = static.default_main_program().clone(for_test=True)
    11. optimizer = paddle.optimizer.Momentum(learning_rate=0.01, momentum=0.9)
    12. optimizer.minimize(loss)

    参数

    返回

    Program，当 for_test=True 时返回一个新的、仅包含当前Program前向内容的Program。否则返回一个新的，和当前Program完全相同的Program

    代码示例

    注解

    Program在clone后的顺序可能不同，这不会影响的训练或测试进程。在下面的示例中，我们提供了一个简单的方法print_prog（Program）来打印程序描述，以确保clone后仍能得到同样的打印结果：

    1. import six
    3. def print_prog(prog):
    4.     for name, value in sorted(six.iteritems(prog.block(0).vars)):
    5.         print(value)
    6.         print("op type is {}".format(op.type))
    7.         print("op inputs are {}".format(op.input_arg_names))
    8.         print("op outputs are {}".format(op.output_arg_names))
    9.         for key, value in sorted(six.iteritems(op.all_attrs())):
    10.             if key not in ['op_callstack', 'op_role_var']:
    11.                 print(" [ attrs: {}:   {} ]".format(key, value))

    1.克隆一个Program，示例代码如下。

    2.如果分别运行 train Program 和 test Program，则可以不使用clone。

    1. import six
    2. import paddle
    3. import paddle.static as static
    4. import paddle.utils as utils
    5. import paddle.nn.functional as F
    7. paddle.enable_static()
    9. def print_prog(prog):
    10.     for name, value in sorted(six.iteritems(prog.block(0).vars)):
    11.         print(value)
    12.     for op in prog.block(0).ops:
    13.         print("op type is {}".format(op.type))
    14.         print("op inputs are {}".format(op.input_arg_names))
    15.         print("op outputs are {}".format(op.output_arg_names))
    16.         for key, value in sorted(six.iteritems(op.all_attrs())):
    17.             if key not in ['op_callstack', 'op_role_var']:
    18.                 print(" [ attrs: {}:   {} ]".format(key, value))
    20. def network():
    21.     img = static.data(name='image', shape=[None, 784])
    22.     hidden = static.nn.fc(x=img, size=200, activation='relu')
    23.     hidden = F.dropout(hidden, p=0.5)
    24.     loss = F.cross_entropy(
    25.         input=static.nn.fc(x=hidden, size=10, activation='softmax'),
    26.         label=static.data(name='label', shape=[1], dtype='int64'))
    27.     avg_loss = paddle.mean(loss)
    28.     return avg_loss
    30. train_program_2 = static.Program()
    31. startup_program_2 = static.Program()
    32. test_program_2 = static.Program()
    33. with static.program_guard(train_program_2, startup_program_2):
    34.     with utils.unique_name.guard():
    35.         avg_loss = network()
    36.         sgd = paddle.optimizer.SGD(learning_rate=1e-3)
    37.         sgd.minimize(avg_loss)
    38. # the test startup program is not used.
    39. with static.program_guard(test_program_2, startup_program_2):
    40.     with utils.unique_name.guard():
    41.         avg_loss = network()
    42. print_prog(test_program_2)

    上边两个代码片段生成和打印的Program是一样的。

    static parse_from_string ( binary_str )

    通过对 protobuf 的反序列化，转换成Program

    返回

    Program，反序列化后的 Program

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. startup_prog = static.Program()
    7. main_prog = static.Program()
    8. with static.program_guard(startup_prog, main_prog):
    9.     x = static.data(name='X', shape=[1000, 784], dtype='float32')
    11.     y = static.data(name='Y', shape=[784, 100], dtype='float32')
    13.     z = paddle.matmul(x=x, y=y)
    14.     binary_str = static.default_main_program().desc.serialize_to_string()
    15.     prog_restored = static.default_main_program().parse_from_string(binary_str)
    17.     print(static.default_main_program())
    18.     print(prog_restored)

    num_blocks

    该Program中的 的个数

    返回

    int，该Program中的 Block 的个数

    代码示例

    1. import paddle
    2. import paddle.static as static
    6. prog = static.default_main_program()
    7. num_blocks = prog.num_blocks
    8. print(num_blocks)
    10. # print result:
    11. # 1

    random_seed

    注解

    程序中随机运算符的默认随机种子。0意味着随机生成随机种子。

    返回

    int64，该Program中当前正在使用的random seed

    代码示例

    global_block ( )

    获取该Program的第一个 。

    返回

    Block，该Program的第一个 

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. prog = static.default_main_program()
    7. gb_block = prog.global_block()
    8. print(gb_block)

    block ( index )

    返回该Program中 ， index 指定的 Block 。 index 类型为int

    参数

    返回

    ，该Program中index对应的那个 Block

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. prog = static.default_main_program()
    7. block_0 = prog.block(0)
    8. print(block_0)

    current_block ( )

    获取当前 。当前 Block 是用来添加OP的。

    返回

    ，该Program中用户当前所在的 Block

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. prog = static.default_main_program()
    7. current_blk = prog.current_block()
    8. print(current_blk)

    list_vars ( )

    获取当前Program中所有变量。返回值是一个可迭代对象（iterable object)。

    返回

    Generator，会yield每个Program中的变量

    代码示例

    all_parameters ( )

    获取当前Program中所有的 。返回值是一个列表。

    代码示例

    1. import paddle
    2. import paddle.static as static
    4. paddle.enable_static()
    6. program = static.default_main_program()
    7. data = static.data(name='x', shape=[None, 13], dtype='float32')
    8. hidden = static.nn.fc(x=data, size=10)
    9. loss = paddle.mean(hidden)
    10. paddle.optimizer.SGD(learning_rate=0.01).minimize(loss)
    12. for param in program.all_parameters():
    13.     print(param)
    15. # Here will print all parameters in current program, in this example,
    16. # the result is like:
    17. #
    18. # persist trainable param fc_0.w_0 : paddle.VarType.LOD_TENSOR.shape(13, 10).astype(VarType.FP32)
    19. # persist trainable param fc_0.b_0 : paddle.VarType.LOD_TENSOR.shape(10,).astype(VarType.FP32)
    20. #
    21. # Here print(param) will print out all the properties of a parameter,
    22. # property of a parameter, such as param.name, param.type