Model

class paddle.Model [源代码]

Model 对象是一个具备训练、测试、推理的神经网络。该对象同时支持静态图和动态图模式，飞桨框架默认为动态图模式，通过 paddle.enable_static() 来切换到静态图模式。需要注意的是，需要在实例化 Model 对象之前完成切换。

参数

  • network (paddle.nn.Layer): 是 paddle.nn.Layer 的一个实例

  • inputs (InputSpec|list|dict|None, 可选): network 的输入，可以是 InputSpec 的实例，或者是一个 InputSpec 的 list ,或者是格式为 {name: InputSpec} 的 dict ，或者为 None . 默认值为 None .

  • labels (InputSpec|list|None, 可选): network 的标签，可以是 InputSpec 的实例，或者是一个 InputSpec 的 list ,或者为 None. 默认值为 None .

注解

在动态图中， inputs 和 labels 都可以设置为 None. 但是，在静态图中， input 不能设置为 None . 而如果损失函数需要标签(label)作为输入，则必须设置 labels ，否则，可以为 None 。

代码示例

  1. import paddle
  2. import paddle.nn as nn
  3. import paddle.vision.transforms as T
  4. from paddle.static import InputSpec
  6. device = paddle.set_device('cpu') # or 'gpu'
  8. net = nn.Sequential(
  9.     nn.Flatten(1),
  10.     nn.Linear(784, 200),
  11.     nn.Tanh(),
  12.     nn.Linear(200, 10))
  14. # inputs and labels are not required for dynamic graph.
  15. input = InputSpec([None, 784], 'float32', 'x')
  16. label = InputSpec([None, 1], 'int64', 'label')
  18. model = paddle.Model(net, input, label)
  19. optim = paddle.optimizer.SGD(learning_rate=1e-3,
  20.     parameters=model.parameters())
  21. model.prepare(optim,
  22.               paddle.nn.CrossEntropyLoss(),
  23.               paddle.metric.Accuracy())
  25. transform = T.Compose([
  26.     T.Transpose(),
  27.     T.Normalize([127.5], [127.5])
  28. ])
  29. data = paddle.vision.datasets.MNIST(mode='train', transform=transform)
  30. model.fit(data, epochs=2, batch_size=32, verbose=1)

方法

train_batch(inputs, labels=None)

在一个批次的数据上进行训练。

参数：

  • inputs (list) - 1维列表，每个元素都是一批次的输入数据，数据类型为 numpy.ndarray。

  • labels (list) - 1维列表，每个元素都是一批次的输入标签，数据类型为 numpy.ndarray 。默认值：None。

返回：如果没有定义评估函数，则返回包含了训练损失函数的值的列表；如果定义了评估函数，则返回一个元组（损失函数的列表，评估指标的列表）。

代码示例：

  1. import numpy as np
  2. import paddle
  3. import paddle.nn as nn
  4. from paddle.static import InputSpec
  6. device = paddle.set_device('cpu') # or 'gpu'
  8. net = nn.Sequential(
  9.     nn.Linear(784, 200),
  10.     nn.Tanh(),
  11.     nn.Linear(200, 10))
  13. input = InputSpec([None, 784], 'float32', 'x')
  14. label = InputSpec([None, 1], 'int64', 'label')
  15. model = paddle.Model(net, input, label)
  16. optim = paddle.optimizer.SGD(learning_rate=1e-3,
  17.     parameters=model.parameters())
  18. model.prepare(optim, paddle.nn.CrossEntropyLoss())
  19. data = np.random.random(size=(4,784)).astype(np.float32)
  20. label = np.random.randint(0, 10, size=(4, 1)).astype(np.int64)
  21. loss = model.train_batch([data], [label])
  22. print(loss)

eval_batch(inputs, labels=None)

在一个批次的数据上进行评估。

参数：

  • inputs (list) - 1维列表，每个元素都是一批次的输入数据，数据类型为 numpy.ndarray 。

  • labels (list) - 1维列表，每个元素都是一批次的输入标签，数据类型为 numpy.ndarray 。默认值：None。

返回：如果没有定义评估函数，则返回包含了预测损失函数的值的列表；如果定义了评估函数，则返回一个元组（损失函数的列表，评估指标的列表）。

返回类型：list

代码示例：

  1. import numpy as np
  2. import paddle
  3. import paddle.nn as nn
  4. from paddle.static import InputSpec
  6. device = paddle.set_device('cpu') # or 'gpu'
  8. net = nn.Sequential(
  9.     nn.Linear(784, 200),
  10.     nn.Tanh(),
  11.     nn.Linear(200, 10))
  13. input = InputSpec([None, 784], 'float32', 'x')
  14. label = InputSpec([None, 1], 'int64', 'label')
  15. model = paddle.Model(net, input, label)
  16. optim = paddle.optimizer.SGD(learning_rate=1e-3,
  17.     parameters=model.parameters())
  18. model.prepare(optim,
  19.             paddle.nn.CrossEntropyLoss())
  20. data = np.random.random(size=(4,784)).astype(np.float32)
  21. label = np.random.randint(0, 10, size=(4, 1)).astype(np.int64)
  22. loss = model.eval_batch([data], [label])
  23. print(loss)

predict_batch(inputs)

在一个批次的数据上进行测试。

参数：

  • inputs (list) - 1维列表，每个元素都是一批次的输入数据，数据类型为 numpy.ndarray 。

返回：一个列表，包含了模型的输出。

返回类型：list

代码示例：

  1. import numpy as np
  2. import paddle
  3. import paddle.nn as nn
  4. from paddle.static import InputSpec
  6. device = paddle.set_device('cpu') # or 'gpu'
  8. input = InputSpec([None, 784], 'float32', 'x')
  9. label = InputSpec([None, 1], 'int64', 'label')
  11. net = nn.Sequential(
  12.     nn.Linear(784, 200),
  13.     nn.Tanh(),
  14.     nn.Linear(200, 10),
  15.     nn.Softmax())
  17. model = paddle.Model(net, input, label)
  18. model.prepare()
  19. data = np.random.random(size=(4,784)).astype(np.float32)
  20. out = model.predict_batch([data])
  21. print(out)

save(path, training=True)

将模型的参数和训练过程中优化器的信息保存到指定的路径，以及推理所需的参数与文件。如果training=True，所有的模型参数都会保存到一个后缀为 .pdparams 的文件中。 所有的优化器信息和相关参数，比如 Adam 优化器中的 beta1 ， beta2 ，momentum 等，都会被保存到后缀为 .pdopt。如果优化器比如SGD没有参数，则该不会产生该文件。如果training=False，则不会保存上述说的文件。只会保存推理需要的参数文件和模型文件。

参数：

  • path (str) - 保存的文件名前缀。格式如 dirname/file_prefix 或者 file_prefix 。

  • training (bool，可选) - 是否保存训练的状态，包括模型参数和优化器参数等。如果为False，则只保存推理所需的参数与文件。默认值：True。

返回：None

代码示例：

  1. import paddle
  2. import paddle.nn as nn
  3. import paddle.vision.transforms as T
  4. from paddle.static import InputSpec
  6. class Mnist(nn.Layer):
  7.     def __init__(self):
  8.         super(Mnist, self).__init__()
  9.         self.net = nn.Sequential(
  10.             nn.Flatten(1),
  11.             nn.Linear(784, 200),
  12.             nn.Tanh(),
  13.             nn.Linear(200, 10),
  14.             nn.Softmax())
  16.     def forward(self, x):
  17.         return self.net(x)
  19. dynamic = True  # False
  20. # if use static graph, do not set
  21. if not dynamic:
  22.     paddle.enable_static()
  24. input = InputSpec([None, 784], 'float32', 'x')
  25. label = InputSpec([None, 1], 'int64', 'label')
  26. model = paddle.Model(Mnist(), input, label)
  27. optim = paddle.optimizer.SGD(learning_rate=1e-3,
  28.     parameters=model.parameters())
  29. model.prepare(optim, paddle.nn.CrossEntropyLoss())
  31. transform = T.Compose([
  32.     T.Transpose(),
  33.     T.Normalize([127.5], [127.5])
  34. ])
  35. data = paddle.vision.datasets.MNIST(mode='train', transform=transform)
  37. model.fit(data, epochs=1, batch_size=32, verbose=0)
  38. model.save('checkpoint/test')  # save for training
  39. model.save('inference_model', False)  # save for inference

load(path, skip_mismatch=False, reset_optimizer=False)

从指定的文件中载入模型参数和优化器参数，如果不想恢复优化器参数信息，优化器信息文件可以不存在。需要注意的是：参数名称的检索是根据保存模型时结构化的名字，当想要载入参数进行迁移学习时要保证预训练模型和当前的模型的参数有一样结构化的名字。

参数：

  • path (str) - 保存参数或优化器信息的文件前缀。格式如 path.pdparams 或者 path.pdopt ，后者是非必要的，如果不想恢复优化器信息。

  • skip_mismatch (bool) - 是否需要跳过保存的模型文件中形状或名称不匹配的参数，设置为 False 时，当遇到不匹配的参数会抛出一个错误。默认值：False。

  • reset_optimizer (bool) - 设置为 True 时，会忽略提供的优化器信息文件。否则会载入提供的优化器信息。默认值：False。

返回：None

代码示例：

  1. import paddle
  2. import paddle.nn as nn
  3. from paddle.static import InputSpec
  5. device = paddle.set_device('cpu')
  7. input = InputSpec([None, 784], 'float32', 'x')
  8. label = InputSpec([None, 1], 'int64', 'label')
  9. model = paddle.Model(nn.Sequential(
  10.     nn.Linear(784, 200),
  11.     nn.Tanh(),
  12.     nn.Linear(200, 10),
  13.     nn.Softmax()),
  14.     input,
  15.     label)
  16. model.save('checkpoint/test')
  17. model.load('checkpoint/test')

parameters(*args, **kwargs)

返回一个包含模型所有参数的列表。

返回：在静态图中返回一个包含 Parameter 的列表，在动态图中返回一个包含 ParamBase 的列表。

代码示例：

  1. import paddle
  2. import paddle.nn as nn
  3. from paddle.static import InputSpec
  5. model = paddle.Model(nn.Sequential(
  6.     nn.Linear(784, 200),
  7.     nn.Tanh(),
  8.     nn.Linear(200, 10)))
  10. params = model.parameters()

prepare(optimizer=None, loss=None, metrics=None)

配置模型所需的部件，比如优化器、损失函数和评价指标。

参数：

  • optimizer (Optimizer) - 当训练模型的，该参数必须被设定。当评估或测试的时候，该参数可以不设定。默认值：None。

  • loss (Loss) - 当训练模型的，该参数必须被设定。默认值：None。

  • metrics (Metric|list[Metric]) - 当该参数被设定时，所有给定的评估方法会在训练和测试时被运行，并返回对应的指标。默认值：None。

fit(train_data=None, eval_data=None, batch_size=1, epochs=1, eval_freq=1, log_freq=10, save_dir=None, save_freq=1, verbose=2, drop_last=False, shuffle=True, num_workers=0, callbacks=None)

训练模型。当 eval_data 给定时，会在 eval_freq 个 epoch 后进行一次评估。

参数：

  • train_data (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 paddle paddle.io.Dataset 或 paddle.io.Dataloader 的实例。默认值：None。

  • eval_data (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 paddle paddle.io.Dataset 或 paddle.io.Dataloader 的实例。当给定时，会在每个 epoch 后都会进行评估。默认值：None。

  • batch_size (int) - 训练数据或评估数据的批大小，当 train_data 或 eval_data 为 DataLoader 的实例时，该参数会被忽略。默认值：1。

  • epochs (int) - 训练的轮数。默认值：1。

  • eval_freq (int) - 评估的频率，多少个 epoch 评估一次。默认值：1。

  • log_freq (int) - 日志打印的频率，多少个 step 打印一次日志。默认值：1。

  • save_dir (str|None) - 保存模型的文件夹，如果不设定，将不保存模型。默认值：None。

  • save_freq (int) - 保存模型的频率，多少个 epoch 保存一次模型。默认值：1。

  • verbose (int) - 可视化的模型，必须为0，1，2。当设定为0时，不打印日志，设定为1时，使用进度条的方式打印日志，设定为2时，一行一行地打印日志。默认值：2。

  • drop_last (bool) - 是否丢弃训练数据中最后几个不足设定的批次大小的数据。默认值：False。

  • shuffle (bool) - 是否对训练数据进行洗牌。当 train_data 为 DataLoader 的实例时，该参数会被忽略。默认值：True。

  • num_workers (int) - 启动子进程用于读取数据的数量。当 train_data 和 eval_data 都为 DataLoader 的实例时，该参数会被忽略。默认值：True。

  • callbacks (Callback|list[Callback]|None) - Callback 的一个实例或实例列表。该参数不给定时，默认会插入 ProgBarLogger 和 ModelCheckpoint 这两个实例。默认值：None。

返回：None

代码示例：

  1. 使用Dataset训练，并设置batch_size的例子。
  1. import paddle
  2. import paddle.vision.transforms as T
  3. from paddle.vision.datasets import MNIST
  4. from paddle.static import InputSpec
  6. dynamic = True
  7. if not dynamic:
  8.     paddle.enable_static()
  10. transform = T.Compose([
  11.     T.Transpose(),
  12.     T.Normalize([127.5], [127.5])
  13. ])
  14. train_dataset = MNIST(mode='train', transform=transform)
  15. val_dataset = MNIST(mode='test', transform=transform)
  17. input = InputSpec([None, 1, 28, 28], 'float32', 'image')
  18. label = InputSpec([None, 1], 'int64', 'label')
  20. model = paddle.Model(
  21.     paddle.vision.models.LeNet(),
  22.     input, label)
  23. optim = paddle.optimizer.Adam(
  24.     learning_rate=0.001, parameters=model.parameters())
  25. model.prepare(
  26.     optim,
  27.     paddle.nn.CrossEntropyLoss(),
  28.     paddle.metric.Accuracy(topk=(1, 2)))
  29. model.fit(train_dataset,
  30.           val_dataset,
  31.           epochs=2,
  32.           batch_size=64,
  33.           save_dir='mnist_checkpoint')
  1. 使用Dataloader训练的例子.
  1. import paddle
  2. import paddle.vision.transforms as T
  3. from paddle.vision.datasets import MNIST
  4. from paddle.static import InputSpec
  6. dynamic = True
  7. if not dynamic:
  8.     paddle.enable_static()
  10. transform = T.Compose([
  11.       T.Transpose(),
  12.       T.Normalize([127.5], [127.5])
  13.   ])
  14. train_dataset = MNIST(mode='train', transform=transform)
  15. train_loader = paddle.io.DataLoader(train_dataset,
  16.     batch_size=64)
  17. val_dataset = MNIST(mode='test', transform=transform)
  18. val_loader = paddle.io.DataLoader(val_dataset,
  19.     batch_size=64)
  21. input = InputSpec([None, 1, 28, 28], 'float32', 'image')
  22. label = InputSpec([None, 1], 'int64', 'label')
  24. model = paddle.Model(
  25.     paddle.vision.models.LeNet(), input, label)
  26. optim = paddle.optimizer.Adam(
  27.     learning_rate=0.001, parameters=model.parameters())
  28. model.prepare(
  29.     optim,
  30.     paddle.nn.CrossEntropyLoss(),
  31.     paddle.metric.Accuracy(topk=(1, 2)))
  32. model.fit(train_loader,
  33.           val_loader,
  34.           epochs=2,
  35.           save_dir='mnist_checkpoint')

evaluate(eval_data, batch_size=1, log_freq=10, verbose=2, num_workers=0, callbacks=None)

在输入数据上，评估模型的损失函数值和评估指标。

参数：

  • eval_data (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 paddle paddle.io.Dataset 或 paddle.io.Dataloader 的实例。默认值：None。

  • batch_size (int) - 训练数据或评估数据的批大小，当 eval_data 为 DataLoader 的实例时，该参数会被忽略。默认值：1。

  • log_freq (int) - 日志打印的频率，多少个 step 打印一次日志。默认值：1。

  • verbose (int) - 可视化的模型，必须为0，1，2。当设定为0时，不打印日志，设定为1时，使用进度条的方式打印日志，设定为2时，一行一行地打印日志。默认值：2。

  • num_workers (int) - 启动子进程用于读取数据的数量。当 eval_data 为 DataLoader 的实例时，该参数会被忽略。默认值：True。

  • callbacks (Callback|list[Callback]|None) - Callback 的一个实例或实例列表。该参数不给定时，默认会插入 ProgBarLogger 和 ModelCheckpoint 这两个实例。默认值：None。

返回：dict, key是 prepare 时Metric的的名称，value是该Metric的值。

代码示例：

  1. import paddle
  2. import paddle.vision.transforms as T
  3. from paddle.static import InputSpec
  5. # declarative mode
  6. transform = T.Compose([
  7.         T.Transpose(),
  8.         T.Normalize([127.5], [127.5])
  9.     ])
  10. val_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)
  12. input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
  13. label = InputSpec([None, 1], 'int64', 'label')
  14. model = paddle.Model(paddle.vision.models.LeNet(), input, label)
  15. model.prepare(metrics=paddle.metric.Accuracy())
  16. result = model.evaluate(val_dataset, batch_size=64)
  17. print(result)

predict(test_data, batch_size=1, num_workers=0, stack_outputs=False, callbacks=None)

在输入数据上，预测模型的输出。

参数：

  • test_data (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 paddle paddle.io.Dataset 或 paddle.io.Dataloader 的实例。默认值：None。

  • batch_size (int) - 训练数据或评估数据的批大小，当 eval_data 为 DataLoader 的实例时，该参数会被忽略。默认值：1。

  • num_workers (int) - 启动子进程用于读取数据的数量。当 eval_data 为 DataLoader 的实例时，该参数会被忽略。默认值：True。

  • stack_outputs (bool) - 是否将输出进行堆叠。默认值：False。

  • callbacks (Callback|list[Callback]|None) - Callback 的一个实例或实例列表。默认值：None。

返回：模型的输出。

代码示例：

  1. import numpy as np
  2. import paddle
  3. from paddle.static import InputSpec
  5. class MnistDataset(paddle.vision.datasets.MNIST):
  6.     def __init__(self, mode, return_label=True):
  7.         super(MnistDataset, self).__init__(mode=mode)
  8.         self.return_label = return_label
  10.     def __getitem__(self, idx):
  11.         img = np.reshape(self.images[idx], [1, 28, 28])
  12.         if self.return_label:
  13.             return img, np.array(self.labels[idx]).astype('int64')
  14.         return img,
  16.     def __len__(self):
  17.         return len(self.images)
  19. test_dataset = MnistDataset(mode='test', return_label=False)
  21. # imperative mode
  22. input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
  23. model = paddle.Model(paddle.vision.models.LeNet(), input)
  24. model.prepare()
  25. result = model.predict(test_dataset, batch_size=64)
  26. print(len(result[0]), result[0][0].shape)
  28. # declarative mode
  29. device = paddle.set_device('cpu')
  30. paddle.enable_static()
  31. input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
  32. model = paddle.Model(paddle.vision.models.LeNet(), input)
  33. model.prepare()
  35. result = model.predict(test_dataset, batch_size=64)
  36. print(len(result[0]), result[0][0].shape)

summary(input_size=None, batch_size=None, dtype=None)

打印网络的基础结构和参数信息。

参数：

  • input_size (tuple|InputSpec|list[tuple|InputSpec，可选) - 输入张量的大小。如果网络只有一个输入，那么该值需要设定为tuple或InputSpec。如果模型有多个输入。那么该值需要设定为list[tuple|InputSpec]，包含每个输入的shape。如果该值没有设置，会将 self._inputs 作为输入。默认值：None。

  • batch_size (int，可选) - 输入张量的批大小。默认值：None。

  • dtypes (str，可选) - 输入张量的数据类型，如果没有给定，默认使用 float32 类型。默认值：None。

返回：字典：包含网络全部参数的大小和全部可训练参数的大小。

代码示例：

  1. import paddle
  2. from paddle.static import InputSpec
  4. input = InputSpec([None, 1, 28, 28], 'float32', 'image')
  5. label = InputSpec([None, 1], 'int64', 'label')
  7. model = paddle.Model(paddle.vision.LeNet(),
  8.     input, label)
  9. optim = paddle.optimizer.Adam(
  10.     learning_rate=0.001, parameters=model.parameters())
  11. model.prepare(
  12.     optim,
  13.     paddle.nn.CrossEntropyLoss())
  15. params_info = model.summary()
  16. print(params_info)