Adapt paddle-rc version

paddlehub/compat/paddle_utils.py

@@ -40,9 +40,9 @@ def convert_dtype_to_string(dtype: str) -> paddle.fluid.core.VarDesc.VarType:
     raise TypeError("dtype shoule in %s" % list(dtype_map.keys()))
 
 
-def get_variable_info(var: paddle.Variable) -> dict:
-    if not isinstance(var, paddle.Variable):
-        raise TypeError("var shoule be an instance of paddle.Variable")
+def get_variable_info(var: paddle.static.Variable) -> dict:
+    if not isinstance(var, paddle.static.Variable):
+        raise TypeError("var shoule be an instance of paddle.static.Variable")
 
     var_info = {
         'name': var.name,
@@ -114,7 +114,7 @@ def rename_var(block: paddle.device.framework.Block, old_name: str, new_name: st
 
 def add_vars_prefix(program: paddle.static.Program,
                     prefix: str,
-                    vars: List[paddle.Variable] = None,
+                    vars: List[paddle.static.Variable] = None,
                     excludes: Callable = None):
     '''
     '''
@@ -127,7 +127,7 @@ def add_vars_prefix(program: paddle.static.Program,
 
 def remove_vars_prefix(program: paddle.static.Program,
                        prefix: str,
-                       vars: List[paddle.Variable] = None,
+                       vars: List[paddle.static.Variable] = None,
                        excludes: Callable = None):
     '''
     '''

paddlehub/compat/task/base_task.py

@@ -287,7 +287,7 @@ class BaseTask(object):
         return self.env.generator
 
     @property
-    def loss(self) -> paddle.Variable:
+    def loss(self) -> paddle.static.Variable:
         if self.is_predict_phase:
             raise RuntimeError()
 
@@ -296,7 +296,7 @@ class BaseTask(object):
         return self.env.loss
 
     @property
-    def labels(self) -> List[paddle.Variable]:
+    def labels(self) -> List[paddle.static.Variable]:
         if self.is_predict_phase:
             raise RuntimeError()
 
@@ -305,7 +305,7 @@ class BaseTask(object):
         return self.env.labels
 
     @property
-    def outputs(self) -> List[paddle.Variable]:
+    def outputs(self) -> List[paddle.static.Variable]:
         if not self.env.is_inititalized:
             self._build_env()
         return self.env.outputs
@@ -342,7 +342,7 @@ class BaseTask(object):
         return feed_list
 
     @property
-    def feed_var_list(self) -> List[paddle.Variable]:
+    def feed_var_list(self) -> List[paddle.static.Variable]:
         if not self.env.is_inititalized:
             self._build_env()
 
@@ -356,7 +356,7 @@ class BaseTask(object):
         return [output.name for output in self.outputs]
 
     @property
-    def fetch_var_list(self) -> List[paddle.Variable]:
+    def fetch_var_list(self) -> List[paddle.static.Variable]:
         vars = self.main_program.global_block().vars
         return [vars[varname] for varname in self.fetch_list]
 

paddlehub/compat/task/transformer_emb_task.py

@@ -25,8 +25,8 @@ from paddlehub.compat.task.task_utils import RunState
 
 class TransformerEmbeddingTask(BaseTask):
     def __init__(self,
-                 pooled_feature: paddle.Variable,
-                 seq_feature: paddle.Variable,
+                 pooled_feature: paddle.static.Variable,
+                 seq_feature: paddle.static.Variable,
                  feed_list: List[str],
                  data_reader: Generic,
                  config: RunConfig = None):
@@ -36,7 +36,7 @@ class TransformerEmbeddingTask(BaseTask):
         self.pooled_feature = pooled_feature
         self.seq_feature = seq_feature
 
-    def _build_net(self) -> List[paddle.Variable]:
+    def _build_net(self) -> List[paddle.static.Variable]:
         # ClassifyReader will return the seqence length of an input text
         self.seq_len = paddle.data(name='seq_len', shape=[1], dtype='int64', lod_level=0)
         return [self.pooled_feature, self.seq_feature]

paddlehub/finetune/trainer.py

@@ -74,8 +74,9 @@ class Trainer(object):
         self.best_metrics = defaultdict(int)
 
         if self.nranks > 1:
-            context = paddle.distributed.init_parallel_env()
-            self.model = paddle.DataParallel(self.model, context)
+            paddle.distributed.init_parallel_env()
+            strategy = paddle.distributed.prepare_context()
+            self.model = paddle.DataParallel(self.model, strategy)
         self.compare_metrics = self._compare_metrics if not compare_metrics else compare_metrics
 
         self._load_checkpoint()
@@ -109,11 +110,18 @@ class Trainer(object):
             logger.info('PaddleHub model checkpoint loaded. current_epoch={} [{}]'.format(
                 self.current_epoch, metric_msg))
 
-        # load model from checkpoint
-        model_path = os.path.join(self.checkpoint_dir, '{}_{}'.format('epoch', self.current_epoch), 'model')
-        state_dict, _ = paddle.load(model_path)
+        # load model checkpoint
+        model_params_path = os.path.join(self.checkpoint_dir, '{}_{}'.format('epoch', 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')
+        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')
@@ -122,7 +130,10 @@ class Trainer(object):
 
     def save_model(self, save_dir: str):
         '''Save model'''
-        paddle.save(self.model.state_dict(), save_dir)
+        model_params_path = os.path.join(save_dir, 'model.pdparams')
+        optim_params_path = os.path.join(save_dir, 'model.pdopt')
+        paddle.save(self.model.state_dict(), model_params_path)
+        paddle.save(self.model.state_dict(), optim_params_path)
 
     def _save_metrics(self):
         with open(os.path.join(self.checkpoint_dir, 'metrics.pkl'), 'wb') as file:
@@ -154,8 +165,8 @@ class Trainer(object):
             save_interval(int) : Save the checkpoint every `save_interval` epochs.
         '''
         use_gpu = True
-        place = paddle.CUDAPlace(ParallelEnv().dev_id) if use_gpu else paddle.CPUPlace()
-        paddle.disable_static(place)
+        place = 'gpu' if use_gpu else 'cpu'
+        paddle.set_device(place)
 
         batch_sampler = paddle.io.DistributedBatchSampler(
             train_dataset, batch_size=batch_size, shuffle=True, drop_last=False)
@@ -245,8 +256,8 @@ class Trainer(object):
             num_workers(int) : Number of subprocess to load data, default is 0.
         '''
         use_gpu = True
-        place = paddle.CUDAPlace(ParallelEnv().dev_id) if use_gpu else paddle.CPUPlace()
-        paddle.disable_static(place)
+        place = 'gpu' if use_gpu else 'cpu'
+        paddle.set_device(place)
 
         batch_sampler = paddle.io.DistributedBatchSampler(
             eval_dataset, batch_size=batch_size, shuffle=False, drop_last=False)
@@ -312,12 +323,7 @@ class Trainer(object):
         metrics = result.get('metrics', {})
 
         # back prop
-        if self.nranks > 1:
-            self.model.scale_loss(loss)
-            loss.backward()
-            self.model.apply_collective_grads()
-        else:
-            loss.backward()
+        loss.backward()
 
         return loss, metrics
 
@@ -350,7 +356,7 @@ class Trainer(object):
         self.learning_rate_step(epoch_idx, batch_idx, self.optimizer.get_lr(), loss)
 
     def learning_rate_step(self, epoch_idx: int, batch_idx: int, learning_rate: Generic, loss: paddle.Tensor):
-        if isinstance(learning_rate, paddle.optimizer._LRScheduler):
+        if isinstance(learning_rate, paddle.optimizer.lr.LRScheduler):
             learning_rate.step()
 
     def optimizer_zero_grad(self, epoch_idx: int, batch_idx: int, optimizer: paddle.optimizer.Optimizer):

paddlehub/module/cv_module.py

@@ -239,17 +239,18 @@ class Yolov3Module(RunModule, ImageServing):
 
         for i, out in enumerate(outputs):
             anchor_mask = self.anchor_masks[i]
-            loss = F.yolov3_loss(x=out,
-                                 gt_box=gtbox,
-                                 gt_label=gtlabel,
-                                 gt_score=gtscore,
-                                 anchors=self.anchors,
-                                 anchor_mask=anchor_mask,
-                                 class_num=self.class_num,
-                                 ignore_thresh=self.ignore_thresh,
-                                 downsample_ratio=32,
-                                 use_label_smooth=False)
-            losses.append(paddle.reduce_mean(loss))
+            loss = F.yolov3_loss(
+                x=out,
+                gt_box=gtbox,
+                gt_label=gtlabel,
+                gt_score=gtscore,
+                anchors=self.anchors,
+                anchor_mask=anchor_mask,
+                class_num=self.class_num,
+                ignore_thresh=self.ignore_thresh,
+                downsample_ratio=32,
+                use_label_smooth=False)
+            losses.append(paddle.mean(loss))
             self.downsample //= 2
 
         return {'loss': sum(losses)}
@@ -287,13 +288,14 @@ class Yolov3Module(RunModule, ImageServing):
                 mask_anchors.append((self.anchors[2 * m]))
                 mask_anchors.append(self.anchors[2 * m + 1])
 
-            box, score = F.yolo_box(x=out,
-                                    img_size=im_shape,
-                                    anchors=mask_anchors,
-                                    class_num=self.class_num,
-                                    conf_thresh=self.valid_thresh,
-                                    downsample_ratio=self.downsample,
-                                    name="yolo_box" + str(i))
+            box, score = F.yolo_box(
+                x=out,
+                img_size=im_shape,
+                anchors=mask_anchors,
+                class_num=self.class_num,
+                conf_thresh=self.valid_thresh,
+                downsample_ratio=self.downsample,
+                name="yolo_box" + str(i))
 
             boxes.append(box)
             scores.append(paddle.transpose(score, perm=[0, 2, 1]))
@@ -302,13 +304,14 @@ class Yolov3Module(RunModule, ImageServing):
         yolo_boxes = paddle.concat(boxes, axis=1)
         yolo_scores = paddle.concat(scores, axis=2)
 
-        pred = F.multiclass_nms(bboxes=yolo_boxes,
-                                scores=yolo_scores,
-                                score_threshold=self.valid_thresh,
-                                nms_top_k=self.nms_topk,
-                                keep_top_k=self.nms_posk,
-                                nms_threshold=self.nms_thresh,
-                                background_label=-1)
+        pred = F.multiclass_nms(
+            bboxes=yolo_boxes,
+            scores=yolo_scores,
+            score_threshold=self.valid_thresh,
+            nms_top_k=self.nms_topk,
+            keep_top_k=self.nms_posk,
+            nms_threshold=self.nms_thresh,
+            background_label=-1)
 
         bboxes = pred.numpy()
         labels = bboxes[:, 0].astype('int32')