Update demo

demo/colorization/predict.py

 import paddle
 import paddlehub as hub
-import paddle.nn as nn
 
 if __name__ == '__main__':
-    paddle.disable_static()
     model = hub.Module(name='user_guided_colorization')
-    model.eval()
-    result = model.predict(images='house.png')
+    state_dict = paddle.load('img_colorization_ckpt')
+    model.set_dict(state_dict)
+    result = model.predict('house.png')

demo/colorization/train.py

 import paddle
 import paddlehub as hub
-import paddle.nn as nn
+import paddlehub.process.transforms as T
 from paddlehub.finetune.trainer import Trainer
-
 from paddlehub.datasets.colorizedataset import Colorizedataset
-import paddlehub.process.transforms as T
 
 if __name__ == '__main__':
 
-    paddle.disable_static()
     model = hub.Module(name='user_guided_colorization')
     transform = T.Compose([T.Resize((256, 256), interp='NEAREST'),
                            T.RandomPaddingCrop(crop_size=176),
                            T.RGB2LAB()],
                           stay_rgb=True,
                           is_permute=False)
+
     color_set = Colorizedataset(transform=transform, mode='train')
     optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
-    trainer = Trainer(model, optimizer, checkpoint_dir='test_ckpt_img_cls')
+    trainer = Trainer(model, optimizer, checkpoint_dir='img_colorization_ckpt')
     trainer.train(color_set, epochs=101, batch_size=2, eval_dataset=color_set, log_interval=10, save_interval=10)

demo/image_classification/predict.py

-import paddle.fluid as fluid
+import paddle
 import paddlehub as hub
-from paddlehub.finetune.trainer import Trainer
-from paddlehub.datasets.flowers import Flowers
-from paddlehub.process.transforms import Compose, Resize, Normalize
-from paddlehub.module.cv_module import ImageClassifierModule
 
 if __name__ == '__main__':
 
-    with fluid.dygraph.guard():
-        transforms = Compose([Resize((224, 224)), Normalize()])
-        flowers = Flowers(transforms)
-        flowers_validate = Flowers(transforms, mode='val')
-
-        model = hub.Module(directory='mobilenet_v2_animals', class_dim=flowers.num_classes)
-        # model = hub.Module(name='mobilenet_v2_animals', class_dim=flowers.num_classes)
-
-        optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.001, parameter_list=model.parameters())
-        trainer = Trainer(model, optimizer, checkpoint_dir='test_ckpt_img_cls')
-
-#         trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate)
+    model = hub.Module(name='mobilenet_v2_imagenet', class_dim=5)
+    state_dict = paddle.load('img_classification_ckpt')
+    model.set_dict(state_dict)
+    result = model.predict('flower.jpg')

demo/image_classification/train.py

 import paddle
 import paddlehub as hub
-from paddle.distributed import ParallelEnv
+import paddlehub.process.transforms as T
 from paddlehub.finetune.trainer import Trainer
 from paddlehub.datasets.flowers import Flowers
-from paddlehub.process.transforms import Compose, Resize, Normalize
-from paddlehub.module.cv_module import ImageClassifierModule
 
 if __name__ == '__main__':
-    paddle.disable_static(paddle.CUDAPlace(ParallelEnv().dev_id))
-    transforms = Compose([Resize((224, 224)), Normalize()])
+    transforms = T.Compose([T.Resize((224, 224)), T.Normalize()])
+
     flowers = Flowers(transforms)
     flowers_validate = Flowers(transforms, mode='val')
 
     model = hub.Module(name='mobilenet_v2_imagenet', class_dim=flowers.num_classes)
 
     optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
-    trainer = Trainer(model, optimizer, checkpoint_dir='test_ckpt_img_cls')
+    trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
 
     trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)

demo/key_point_detection/openpose_body/predict.py

-import paddle
-import paddlehub as hub
-
-if __name__ == "__main__":
-
-    paddle.disable_static()
-    model = hub.Module(name='openpose_body_estimation')
-    out1, out2 = model.predict("demo.jpg")

demo/key_point_detection/openpose_hands/predict.py

-import paddle
-import paddlehub as hub
-
-if __name__ == "__main__":
-
-    paddle.disable_static()
-    model = hub.Module(name='openpose_hands_estimation')
-    all_hand_peaks = model.predict("demo.jpg")

demo/style_transfer/predict.py

@@ -2,8 +2,7 @@ import paddle
 import paddlehub as hub
 
 if __name__ == '__main__':
-    place = paddle.CUDAPlace(0)
-    paddle.disable_static()
     model = hub.Module(name='msgnet')
-    model.eval()
+    state_dict = paddle.load('img_style_transfer_ckpt')
+    model.set_dict(state_dict)
     result = model.predict("venice-boat.jpg", "candy.jpg")

demo/style_transfer/train.py

 import paddle
 import paddlehub as hub
-
+import paddlehub.process.transforms as T
 from paddlehub.finetune.trainer import Trainer
 from paddlehub.datasets.styletransfer import StyleTransferData
-from paddlehub.process.transforms import Compose, Resize, CenterCrop, SetType
 
 if __name__ == "__main__":
-    place = paddle.CUDAPlace(0)
-    paddle.disable_static()
     model = hub.Module(name='msgnet')
-    transform = Compose([Resize((256, 256), interp='LINEAR'), CenterCrop(crop_size=256)], SetType(datatype='float32'))
+    transform = T.Compose([T.Resize(
+        (256, 256), interp='LINEAR'), T.CenterCrop(crop_size=256)], T.SetType(datatype='float32'))
+
     styledata = StyleTransferData(transform)
-    model.train()
     optimizer = paddle.optimizer.Adam(learning_rate=0.0001, parameters=model.parameters())
-    trainer = Trainer(model, optimizer, checkpoint_dir='test_ckpt_img_cls')
-    trainer.train(styledata, epochs=5, batch_size=1, eval_dataset=styledata, log_interval=1, save_interval=1)
+    trainer = Trainer(model, optimizer, checkpoint_dir='img_style_transfer_ckpt')
+    trainer.train(styledata, epochs=5, batch_size=16, eval_dataset=styledata, log_interval=1, save_interval=1)

paddlehub/finetune/trainer.py

@@ -111,20 +111,18 @@ class Trainer(object):
                 self.current_epoch, metric_msg))
 
         # load model checkpoint
-        model_params_path = os.path.join(self.checkpoint_dir, '{}_{}'.format('epoch', self.current_epoch),
-                                         'model.pdparmas')
+        model_params_path = os.path.join(self.checkpoint_dir, 'epoch_{}'.format(self.current_epoch), 'model.pdparmas')
         state_dict = paddle.load(model_params_path)
         self.model.set_dict(state_dict)
 
         # load optimizer checkpoint
-        optim_params_path = os.path.join(self.checkpoint_dir, '{}_{}'.format('epoch', self.current_epoch),
-                                         'model.pdopt')
+        optim_params_path = os.path.join(self.checkpoint_dir, 'epoch_{}'.format(self.current_epoch), 'model.pdopt')
         state_dict = paddle.load(optim_params_path)
         self.optimizer.set_dict(state_dict)
 
     def _save_checkpoint(self):
         '''Save model checkpoint and state dict'''
-        model_path = os.path.join(self.checkpoint_dir, '{}_{}'.format('epoch', self.current_epoch), 'model')
+        model_path = os.path.join(self.checkpoint_dir, 'epoch_{}'.format(self.current_epoch))
         logger.info('Saving model checkpoint to {}'.format(model_path))
         self.save_model(model_path)
 
@@ -171,7 +169,7 @@ class Trainer(object):
         batch_sampler = paddle.io.DistributedBatchSampler(
             train_dataset, batch_size=batch_size, shuffle=True, drop_last=False)
         loader = paddle.io.DataLoader(
-            train_dataset, batch_sampler=batch_sampler, places=place, num_workers=num_workers, return_list=True)
+            train_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True)
 
         steps_per_epoch = len(batch_sampler)
         timer = Timer(steps_per_epoch * epochs)
@@ -263,7 +261,7 @@ class Trainer(object):
             eval_dataset, batch_size=batch_size, shuffle=False, drop_last=False)
 
         loader = paddle.io.DataLoader(
-            eval_dataset, batch_sampler=batch_sampler, places=place, num_workers=num_workers, return_list=True)
+            eval_dataset, batch_sampler=batch_sampler, num_workers=num_workers, return_list=True)
 
         self.model.eval()
         avg_loss = num_samples = 0