load

paddle.jit.load ( path, \*configs* ) [源代码]

将接口 paddle.jit.save 或者 paddle.static.save_inference_model 存储的模型载入为 paddle.jit.TranslatedLayer ，用于预测推理或者fine-tune训练。

注解

如果载入的模型是通过 paddle.static.save_inference_model 存储的，在使用它进行fine-tune训练时会存在一些局限： 1. 命令式编程模式不支持 LoDTensor ，所有原先输入变量或者参数依赖于LoD信息的模型暂时无法使用； 2. 所有存储模型的feed变量都需要被传入 Translatedlayer 的forward方法； 3. 原模型变量的 stop_gradient 信息已丢失且无法准确恢复； 4. 原模型参数的 trainable 信息已丢失且无法准确恢复。

参数

  • path (str) - 载入模型的路径前缀。格式为 dirname/file_prefix 或者 file_prefix 。

  • **config (dict, 可选) - 其他用于兼容的载入配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为 None。目前支持以下配置选项：(1) model_filename (str) - paddle 1.x版本 save_inference_model 接口存储格式的预测模型文件名，原默认文件名为 __model__ ； (2) params_filename (str) - paddle 1.x版本 save_inference_model 接口存储格式的参数文件名，没有默认文件名，默认将各个参数分散存储为单独的文件。

返回

TranslatedLayer，一个能够执行存储模型的 Layer 对象。

代码示例

  1. 载入由接口 paddle.jit.save 存储的模型进行预测推理及fine-tune训练。

    1. import numpy as np
    2. import paddle
    3. import paddle.nn as nn
    4. import paddle.optimizer as opt
    6. BATCH_SIZE = 16
    7. BATCH_NUM = 4
    8. EPOCH_NUM = 4
    10. IMAGE_SIZE = 784
    11. CLASS_NUM = 10
    13. # define a random dataset
    14. class RandomDataset(paddle.io.Dataset):
    15.     def __init__(self, num_samples):
    16.         self.num_samples = num_samples
    18.     def __getitem__(self, idx):
    19.         image = np.random.random([IMAGE_SIZE]).astype('float32')
    20.         label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64')
    21.         return image, label
    23.     def __len__(self):
    24.         return self.num_samples
    26. class LinearNet(nn.Layer):
    27.     def __init__(self):
    28.         super(LinearNet, self).__init__()
    29.         self._linear = nn.Linear(IMAGE_SIZE, CLASS_NUM)
    31.     @paddle.jit.to_static
    32.     def forward(self, x):
    33.         return self._linear(x)
    35. def train(layer, loader, loss_fn, opt):
    36.     for epoch_id in range(EPOCH_NUM):
    37.         for batch_id, (image, label) in enumerate(loader()):
    38.             out = layer(image)
    39.             loss = loss_fn(out, label)
    40.             loss.backward()
    41.             opt.step()
    42.             opt.clear_grad()
    43.             print("Epoch {} batch {}: loss = {}".format(
    44.                 epoch_id, batch_id, np.mean(loss.numpy())))
    46. # 1. train & save model.
    48. # create network
    49. layer = LinearNet()
    50. loss_fn = nn.CrossEntropyLoss()
    51. adam = opt.Adam(learning_rate=0.001, parameters=layer.parameters())
    53. # create data loader
    54. dataset = RandomDataset(BATCH_NUM * BATCH_SIZE)
    55. loader = paddle.io.DataLoader(dataset,
    56.     batch_size=BATCH_SIZE,
    57.     shuffle=True,
    58.     drop_last=True,
    59.     num_workers=2)
    61. # train
    62. train(layer, loader, loss_fn, adam)
    64. # save
    65. path = "example_model/linear"
    66. paddle.jit.save(layer, path)
    68. # 2. load model
    70. # load
    71. loaded_layer = paddle.jit.load(path)
    73. # inference
    74. loaded_layer.eval()
    75. x = paddle.randn([1, IMAGE_SIZE], 'float32')
    76. pred = loaded_layer(x)
    78. # fine-tune
    79. loaded_layer.train()
    80. adam = opt.Adam(learning_rate=0.001, parameters=loaded_layer.parameters())
    81. train(loaded_layer, loader, loss_fn, adam)

  2. 兼容载入由接口 paddle.fluid.io.save_inference_model 存储的模型进行预测推理及fine-tune训练。

    1. import numpy as np
    2. import paddle
    3. import paddle.static as static
    4. import paddle.nn as nn
    5. import paddle.optimizer as opt
    6. import paddle.nn.functional as F
    8. BATCH_SIZE = 16
    9. BATCH_NUM = 4
    10. EPOCH_NUM = 4
    12. IMAGE_SIZE = 784
    13. CLASS_NUM = 10
    15. # define a random dataset
    16. class RandomDataset(paddle.io.Dataset):
    17.     def __init__(self, num_samples):
    18.         self.num_samples = num_samples
    20.     def __getitem__(self, idx):
    21.         image = np.random.random([IMAGE_SIZE]).astype('float32')
    22.         label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64')
    23.         return image, label
    25.     def __len__(self):
    26.         return self.num_samples
    28. paddle.enable_static()
    30. image = static.data(name='image', shape=[None, 784], dtype='float32')
    31. label = static.data(name='label', shape=[None, 1], dtype='int64')
    32. pred = static.nn.fc(x=image, size=10, activation='softmax')
    33. loss = F.cross_entropy(input=pred, label=label)
    34. avg_loss = paddle.mean(loss)
    36. optimizer = paddle.optimizer.SGD(learning_rate=0.001)
    37. optimizer.minimize(avg_loss)
    39. place = paddle.CPUPlace()
    40. exe = static.Executor(place)
    41. exe.run(static.default_startup_program())
    43. # create data loader
    44. dataset = RandomDataset(BATCH_NUM * BATCH_SIZE)
    45. loader = paddle.io.DataLoader(dataset,
    46.     feed_list=[image, label],
    47.     places=place,
    48.     batch_size=BATCH_SIZE,
    49.     shuffle=True,
    50.     drop_last=True,
    51.     num_workers=2)
    53. # 1. train and save inference model
    54. for data in loader():
    55.     exe.run(
    56.         static.default_main_program(),
    57.         feed=data,
    58.         fetch_list=[avg_loss])
    60. model_path = "fc.example.model"
    61. paddle.fluid.io.save_inference_model(
    62.     model_path, ["image"], [pred], exe)
    64. # 2. load model
    66. # enable dygraph mode
    67. paddle.disable_static(place)
    69. # load
    70. fc = paddle.jit.load(model_path)
    72. # inference
    73. fc.eval()
    74. x = paddle.randn([1, IMAGE_SIZE], 'float32')
    75. pred = fc(x)
    77. # fine-tune
    78. fc.train()
    79. loss_fn = nn.CrossEntropyLoss()
    80. adam = opt.Adam(learning_rate=0.001, parameters=fc.parameters())
    81. loader = paddle.io.DataLoader(dataset,
    82.     places=place,
    83.     batch_size=BATCH_SIZE,
    84.     shuffle=True,
    85.     drop_last=True,
    86.     num_workers=2)
    87. for epoch_id in range(EPOCH_NUM):
    88.     for batch_id, (image, label) in enumerate(loader()):
    89.         out = fc(image)
    90.         loss = loss_fn(out, label)
    91.         loss.backward()
    92.         adam.step()
    93.         adam.clear_grad()
    94.         print("Epoch {} batch {}: loss = {}".format(
    95.             epoch_id, batch_id, np.mean(loss.numpy())))