def test_dynamic_load(self):
mnist_data = MnistDataset(mode='train')
path = os.path.join(tempfile.mkdtemp(), '.cache_dynamic_load')
if not os.path.exists(path):
os.makedirs(path)
for new_optimizer in [True, False]:
paddle.disable_static()
net = LeNet()
inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')]
labels = [InputSpec([None, 1], 'int64', 'label')]
if new_optimizer:
optim = paddle.optimizer.Adam(
learning_rate=0.001, parameters=net.parameters())
else:
optim = fluid.optimizer.Adam(
learning_rate=0.001, parameter_list=net.parameters())
model = Model(net, inputs, labels)
model.prepare(
optimizer=optim, loss=CrossEntropyLoss(reduction="sum"))
model.fit(mnist_data, batch_size=64, verbose=0)
model.save(path)
model.load(path)
paddle.enable_static()
shutil.rmtree(path)
def test_static_save_dynamic_load(self):
path = os.path.join(tempfile.mkdtemp(),
'.cache_test_static_save_dynamic_load')
if not os.path.exists(path):
os.makedirs(path)
net = MyModel()
inputs = [InputSpec([None, 20], 'float32', 'x')]
labels = [InputSpec([None, 1], 'int64', 'label')]
optim = fluid.optimizer.SGD(learning_rate=0.001,
parameter_list=net.parameters())
model = Model(net, inputs, labels)
model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"))
model.save(path)
device = paddle.set_device('cpu')
fluid.enable_dygraph(device) #if dynamic else None
net = MyModel()
inputs = [InputSpec([None, 20], 'float32', 'x')]
labels = [InputSpec([None, 1], 'int64', 'label')]
optim = fluid.optimizer.SGD(learning_rate=0.001,
parameter_list=net.parameters())
model = Model(net, inputs, labels)
model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"))
model.load(path)
shutil.rmtree(path)
fluid.disable_dygraph()
def test_static_save_dynamic_load(self):
path = tempfile.mkdtemp()
net = MyModel(classifier_activation=None)
inputs = [InputSpec([None, 20], 'float32', 'x')]
labels = [InputSpec([None, 1], 'int64', 'label')]
optim = fluid.optimizer.SGD(learning_rate=0.001,
parameter_list=net.parameters())
model = Model(net, inputs, labels)
model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"))
model.save(path + '/test')
device = paddle.set_device('cpu')
fluid.enable_dygraph(device) #if dynamic else None
net = MyModel(classifier_activation=None)
inputs = [InputSpec([None, 20], 'float32', 'x')]
labels = [InputSpec([None, 1], 'int64', 'label')]
optim = fluid.optimizer.SGD(learning_rate=0.001,
parameter_list=net.parameters())
model = Model(net, inputs, labels)
model.prepare(optimizer=optim, loss=CrossEntropyLoss(reduction="sum"))
model.load(path + '/test')
shutil.rmtree(path)
fluid.disable_dygraph()
def predict(self, dynamic):
fluid.enable_dygraph(self.device) if dynamic else None
model = Model(LeNet(), self.inputs)
model.prepare()
model.load(self.weight_path)
output = model.predict(self.test_dataset,
batch_size=64,
stack_outputs=True)
np.testing.assert_equal(output[0].shape[0], len(self.test_dataset))
acc = compute_acc(output[0], self.val_dataset.labels)
np.testing.assert_allclose(acc, self.acc1)
sampler = DistributedBatchSampler(self.test_dataset,
batch_size=64,
shuffle=False)
test_loader = fluid.io.DataLoader(self.test_dataset,
batch_sampler=sampler,
places=self.device,
return_list=True)
model.evaluate(test_loader)
fluid.disable_dygraph() if dynamic else None
def test_predict_without_inputs(self):
fluid.enable_dygraph(self.device)
model = Model(LeNet())
model.prepare()
model.load(self.weight_path)
model._inputs = None
output = model.predict(
self.test_dataset, batch_size=64, stack_outputs=True)
np.testing.assert_equal(output[0].shape[0], len(self.test_dataset))
fluid.disable_dygraph()
def _calc_output(self, place, mode="test", dygraph=True):
if dygraph:
fluid.enable_dygraph(place)
else:
fluid.disable_dygraph()
gen = paddle.seed(self._random_seed)
paddle.framework.random._manual_program_seed(self._random_seed)
scope = fluid.core.Scope()
with fluid.scope_guard(scope):
layer = self.model_cls(**self.attrs) if isinstance(
self.attrs, dict) else self.model_cls(*self.attrs)
model = Model(layer, inputs=self.make_inputs())
model.prepare()
if self.param_states:
model.load(self.param_states, optim_state=None)
return model.predict_batch(self.inputs)
def evaluate(self, dynamic):
fluid.enable_dygraph(self.device) if dynamic else None
model = Model(LeNet(), self.inputs, self.labels)
model.prepare(metrics=Accuracy())
model.load(self.weight_path)
result = model.evaluate(self.val_dataset, batch_size=64)
np.testing.assert_allclose(result['acc'], self.acc1)
sampler = DistributedBatchSampler(
self.val_dataset, batch_size=64, shuffle=False)
val_loader = fluid.io.DataLoader(
self.val_dataset,
batch_sampler=sampler,
places=self.device,
return_list=True)
model.evaluate(val_loader)
fluid.disable_dygraph() if dynamic else None
