Fix travis-ci issue.

.travis.yml

@@ -27,6 +27,7 @@ install:
     else
       pip install --upgrade paddlepaddle;
       pip install -r requirements.txt;
+      pip install yapf==0.26.0
     fi
 
 notifications:

demo/audio_classification/predict.py

@@ -26,16 +26,15 @@ parser.add_argument("--wav", type=str, required=True, help="Audio file to infer.
 parser.add_argument("--sr", type=int, default=44100, help="Sample rate of inference audio.")
 parser.add_argument("--model_type", type=str, default='panns_cnn14', help="Select model to to inference.")
 parser.add_argument("--topk", type=int, default=1, help="Show top k results of prediction labels.")
-parser.add_argument("--checkpoint",
-                    type=str,
-                    default='./checkpoint/best_model/model.pdparams',
-                    help="Checkpoint of model.")
+parser.add_argument(
+    "--checkpoint", type=str, default='./checkpoint/best_model/model.pdparams', help="Checkpoint of model.")
 args = parser.parse_args()
 
 if __name__ == '__main__':
     label_map = {idx: label for idx, label in enumerate(ESC50.label_list)}
 
-    model = hub.Module(name=args.model_type,
+    model = hub.Module(
+        name=args.model_type,
         version='1.0.0',
         task='sound-cls',
         num_class=ESC50.num_class,

demo/audio_classification/train.py

@@ -22,7 +22,8 @@ from paddlehub.datasets import ESC50
 
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--num_epoch", type=int, default=50, help="Number of epoches for fine-tuning.")
-parser.add_argument("--use_gpu",
+parser.add_argument(
+    "--use_gpu",
     type=ast.literal_eval,
     default=True,
     help="Whether use GPU for fine-tuning, input should be True or False")

demo/autoaug/README.md

@@ -173,8 +173,3 @@ bash search.sh
 cd PaddleHub/demo/autaug/
 bash train.sh
 ```
-
-
-
-
-

demo/autoaug/hub_fitter.py

@@ -23,6 +23,7 @@ logger = log.get_logger(level=logging.INFO)
 import auto_augment
 auto_augment_path = auto_augment.__file__
 
+
 class HubFitterClassifer(object):
     """Trains an instance of the Model class."""
 
@@ -43,8 +44,7 @@ class HubFitterClassifer(object):
         # `import paddle`. Otherwise, it would not take any effect.
         set_paddle_flags(
             # enable GC to save memory
-            FLAGS_fraction_of_gpu_memory_to_use=hparams.resource_config.gpu,
-        )
+            FLAGS_fraction_of_gpu_memory_to_use=hparams.resource_config.gpu, )
         import paddle
         import paddlehub as hub
         from paddlehub_utils.trainer import CustomTrainer
@@ -63,23 +63,18 @@ class HubFitterClassifer(object):
         paddle.disable_static(paddle.CUDAPlace(paddle.distributed.get_rank()))
 
         train_dataset, eval_dataset = _init_loader(self.hparams)
-        model = hub.Module(name=hparams["task_config"]["classifier"]["model_name"], label_list=self.class_to_id_dict.keys(), load_checkpoint=None)
-
-        optimizer = paddle.optimizer.Adam(
-            learning_rate=0.001, parameters=model.parameters())
-        trainer = CustomTrainer(
-            model=model,
-            optimizer=optimizer,
-            checkpoint_dir='img_classification_ckpt')
+        model = hub.Module(
+            name=hparams["task_config"]["classifier"]["model_name"],
+            label_list=self.class_to_id_dict.keys(),
+            load_checkpoint=None)
+
+        optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+        trainer = CustomTrainer(model=model, optimizer=optimizer, checkpoint_dir='img_classification_ckpt')
         self.model = model
         self.optimizer = optimizer
 
         trainer.init_train_and_eval(
-            train_dataset,
-            epochs=100,
-            batch_size=32,
-            eval_dataset=eval_dataset,
-            save_interval=1)
+            train_dataset, epochs=100, batch_size=32, eval_dataset=eval_dataset, save_interval=1)
         self.trainer = trainer
 
     def _fit_param(self, show: bool = False) -> None:
@@ -123,8 +118,7 @@ class HubFitterClassifer(object):
 
         """
         self.hparams = new_hparams
-        self.trainer.train_loader.dataset.reset_policy(
-            new_hparams.search_space)
+        self.trainer.train_loader.dataset.reset_policy(new_hparams.search_space)
         return None
 
     def save_model(self, checkpoint_dir: str, step: Optional[str] = None) -> str:
@@ -134,8 +128,7 @@ class HubFitterClassifer(object):
           step: If provided, creates a checkpoint with the given step
             number, instead of overwriting the existing checkpoints.
         """
-        checkpoint_path = os.path.join(checkpoint_dir,
-                                       'epoch') + '-' + str(step)
+        checkpoint_path = os.path.join(checkpoint_dir, 'epoch') + '-' + str(step)
         logger.info('Saving model checkpoint to {}'.format(checkpoint_path))
         self.trainer.save_model(os.path.join(checkpoint_path, "checkpoint"))
 
@@ -145,8 +138,7 @@ class HubFitterClassifer(object):
         """Loads a checkpoint with the architecture structure stored in the name."""
         ckpt_path = os.path.join(checkpoint_path, "checkpoint")
         self.trainer.load_model(ckpt_path)
-        logger.info(
-            'Loaded child model checkpoint from {}'.format(checkpoint_path))
+        logger.info('Loaded child model checkpoint from {}'.format(checkpoint_path))
 
     def eval_child_model(self, mode: str, pass_id: int = 0) -> dict:
         """Evaluate the child model.
@@ -204,10 +196,7 @@ class HubFitterClassifer(object):
         """Trains the model `m` for one epoch."""
         start_time = time.time()
         train_acc = self.train_one_epoch(curr_epoch)
-        logger.info(
-            'Epoch:{} time(min): {}'.format(
-                curr_epoch,
-                (time.time() - start_time) / 60.0))
+        logger.info('Epoch:{} time(min): {}'.format(curr_epoch, (time.time() - start_time) / 60.0))
         return train_acc
 
     def _compute_final_accuracies(self, iteration: int) -> dict:
@@ -228,8 +217,7 @@ class HubFitterClassifer(object):
         self._fit_param()
         train_acc = self._run_training_loop(epoch)
         valid_acc = self.eval_child_model(mode="val", pass_id=epoch)
-        logger.info('valid acc: {}'.format(
-            valid_acc))
+        logger.info('valid acc: {}'.format(valid_acc))
         all_metric = {}
         all_metric.update(train_acc)
         all_metric.update(valid_acc)

demo/autoaug/paddlehub_utils/reader.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 # -*- coding: utf-8 -*-
 # *******************************************************************************
 #
@@ -36,8 +35,7 @@ import paddlehub.vision.transforms as transforms
 from PIL import ImageFile
 from auto_augment.autoaug.transform.autoaug_transform import AutoAugTransform
 ImageFile.LOAD_TRUNCATED_IMAGES = True
-__imagenet_stats = {'mean': [0.485, 0.456, 0.406],
-                    'std': [0.229, 0.224, 0.225]}
+__imagenet_stats = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
 
 
 class PbaAugment(object):
@@ -45,8 +43,7 @@ class PbaAugment(object):
     pytorch 分类 PbaAugment transform
     """
 
-    def __init__(
-            self,
+    def __init__(self,
                  input_size: int = 224,
                  scale_size: int = 256,
                  normalize: Optional[list] = None,
@@ -64,27 +61,20 @@ class PbaAugment(object):
         """
 
         if normalize is None:
-            normalize = {
-                'mean': [
-                    0.485, 0.456, 0.406], 'std': [
-                    0.229, 0.224, 0.225]}
+            normalize = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
 
         policy = kwargs["policy"]
         assert stage in ["search", "train"]
         train_epochs = kwargs["hp_policy_epochs"]
-        self.auto_aug_transform = AutoAugTransform.create(
-            policy, stage=stage, train_epochs=train_epochs)
+        self.auto_aug_transform = AutoAugTransform.create(policy, stage=stage, train_epochs=train_epochs)
         #self.auto_aug_transform = PbtAutoAugmentClassiferTransform(conf)
         if pre_transform:
             self.pre_transform = transforms.Resize(input_size)
 
         self.post_transform = transforms.Compose(
-            transforms=[
-                transforms.Permute(),
-                transforms.Normalize(**normalize, channel_first=True)
-            ],
-            channel_first = False
-        )
+            transforms=[transforms.Permute(),
+                        transforms.Normalize(**normalize, channel_first=True)],
+            channel_first=False)
         self.cur_epoch = 0
 
     def set_epoch(self, indx: int) -> None:
@@ -164,8 +154,7 @@ class PicReader(paddle.io.Dataset):
     PicReader
     """
 
-    def __init__(
-            self,
+    def __init__(self,
                  root_path: str,
                  list_file: str,
                  meta: bool = False,
@@ -222,8 +211,7 @@ class PicReader(paddle.io.Dataset):
                 img = cv2.resize(img, (scale_size, scale_size))
                 self.cache_img_buff[image_path] = img
             except BaseException:
-                print("img_path:{} can not by cv2".format(
-                    image_path).format(image_path))
+                print("img_path:{} can not by cv2".format(image_path).format(image_path))
 
                 pass
 
@@ -265,9 +253,7 @@ class PicReader(paddle.io.Dataset):
 
         with open(self.list_file) as f:
             lines = f.read().splitlines()
-            print(
-                "PicReader:: found {} picture in `{}'".format(
-                    len(lines), self.list_file))
+            print("PicReader:: found {} picture in `{}'".format(len(lines), self.list_file))
             for i, line in enumerate(lines):
                 record = re.split(delimiter, line)
                 # record = line.split()
@@ -401,20 +387,12 @@ def _read_classes(csv_file: str) -> dict:
                 class_name = row.strip()
                 # print(class_id, class_name)
             except ValueError:
-                six.raise_from(
-                    ValueError(
-                        'line {}: format should be \'class_name\''.format(line)),
-                    None)
+                six.raise_from(ValueError('line {}: format should be \'class_name\''.format(line)), None)
 
-            class_id = _parse(
-                line,
-                int,
-                'line {}: malformed class ID: {{}}'.format(line))
+            class_id = _parse(line, int, 'line {}: malformed class ID: {{}}'.format(line))
 
             if class_name in result:
-                raise ValueError(
-                    'line {}: duplicate class name: \'{}\''.format(
-                        line, class_name))
+                raise ValueError('line {}: duplicate class name: \'{}\''.format(line, class_name))
             result[class_name] = class_id
     return result
 
@@ -439,10 +417,7 @@ def _init_loader(hparams: dict, TrainTransform=None) -> tuple:
     epochs = hparams.task_config.classifier.epochs
     no_cache_img = hparams.task_config.classifier.get("no_cache_img", False)
 
-    normalize = {
-        'mean': [
-            0.485, 0.456, 0.406], 'std': [
-            0.229, 0.224, 0.225]}
+    normalize = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
 
     if TrainTransform is None:
         TrainTransform = PbaAugment(
@@ -453,10 +428,7 @@ def _init_loader(hparams: dict, TrainTransform=None) -> tuple:
             hp_policy_epochs=epochs,
         )
     delimiter = hparams.data_config.delimiter
-    kwargs = dict(
-        conf=hparams,
-        delimiter=delimiter
-    )
+    kwargs = dict(conf=hparams, delimiter=delimiter)
 
     if hparams.task_config.classifier.use_class_map:
         class_to_id_dict = _read_classes(label_list=hparams.data_config.label_list)
@@ -475,13 +447,11 @@ def _init_loader(hparams: dict, TrainTransform=None) -> tuple:
         list_file=val_list,
         transform=transforms.Compose(
             transforms=[
-                transforms.Resize(
-                    (224,
-                     224)),
+                transforms.Resize((224, 224)),
                 transforms.Permute(),
-                transforms.Normalize(
-                    **normalize, channel_first=True)],
-            channel_first = False),
+                transforms.Normalize(**normalize, channel_first=True)
+            ],
+            channel_first=False),
         class_to_id_dict=class_to_id_dict,
         cache_img=not no_cache_img,
         **kwargs)

demo/autoaug/paddlehub_utils/trainer.py

@@ -18,6 +18,7 @@ from paddle.distributed import ParallelEnv
 from paddlehub.utils.log import logger
 from paddlehub.utils.utils import Timer
 
+
 class CustomTrainer(Trainer):
     def __init__(self, **kwargs) -> None:
         super(CustomTrainer, self).__init__(**kwargs)
@@ -33,10 +34,7 @@ class CustomTrainer(Trainer):
         self.batch_sampler, self.train_loader = self.init_train(train_dataset, batch_size, num_workers)
         self.eval_loader = self.init_evaluate(eval_dataset, batch_size, num_workers)
 
-    def init_train(self,
-              train_dataset: paddle.io.Dataset,
-              batch_size: int = 1,
-              num_workers: int = 0) -> tuple:
+    def init_train(self, train_dataset: paddle.io.Dataset, batch_size: int = 1, num_workers: int = 0) -> tuple:
         use_gpu = True
         place = paddle.CUDAPlace(ParallelEnv().dev_id) if use_gpu else paddle.CPUPlace()
         paddle.disable_static(place)
@@ -47,7 +45,8 @@ class CustomTrainer(Trainer):
             train_dataset, batch_sampler=batch_sampler, places=place, num_workers=num_workers, return_list=True)
         return batch_sampler, loader
 
-    def train_one_epoch(self, loader: paddle.io.DataLoader, timer: Timer, current_epoch: int, epochs: int, log_interval: int, steps_per_epoch: int) -> None:
+    def train_one_epoch(self, loader: paddle.io.DataLoader, timer: Timer, current_epoch: int, epochs: int,
+                        log_interval: int, steps_per_epoch: int) -> None:
         avg_loss = 0
         avg_metrics = defaultdict(int)
         self.model.train()
@@ -70,15 +69,13 @@ class CustomTrainer(Trainer):
                 if self.use_vdl:
                     self.log_writer.add_scalar(tag='TRAIN/loss', step=timer.current_step, value=avg_loss)
 
-                print_msg = 'Epoch={}/{}, Step={}/{}'.format(current_epoch, epochs, batch_idx + 1,
-                                                             steps_per_epoch)
+                print_msg = 'Epoch={}/{}, Step={}/{}'.format(current_epoch, epochs, batch_idx + 1, steps_per_epoch)
                 print_msg += ' loss={:.4f}'.format(avg_loss)
 
                 for metric, value in avg_metrics.items():
                     value /= log_interval
                     if self.use_vdl:
-                        self.log_writer.add_scalar(
-                            tag='TRAIN/{}'.format(metric), step=timer.current_step, value=value)
+                        self.log_writer.add_scalar(tag='TRAIN/{}'.format(metric), step=timer.current_step, value=value)
                     print_msg += ' {}={:.4f}'.format(metric, value)
 
                 print_msg += ' lr={:.6f} step/sec={:.2f} | ETA {}'.format(lr, timer.timing, timer.eta)
@@ -139,9 +136,7 @@ class CustomTrainer(Trainer):
                         self.save_model(best_model_path)
                         self._save_metrics()
 
-                        metric_msg = [
-                            '{}={:.4f}'.format(metric, value) for metric, value in self.best_metrics.items()
-                        ]
+                        metric_msg = ['{}={:.4f}'.format(metric, value) for metric, value in self.best_metrics.items()]
                         metric_msg = ' '.join(metric_msg)
                         logger.eval('Saving best model to {} [best {}]'.format(best_model_path, metric_msg))
 

demo/autoaug/search.py

-
 from auto_augment.autoaug.experiment.experiment import AutoAugExperiment
 from auto_augment.autoaug.utils.yaml_config import get_config
 from hub_fitter import HubFitterClassifer
@@ -9,14 +8,21 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 parser = argparse.ArgumentParser()
-parser.add_argument("--config",help="config file",)
-parser.add_argument("--workspace",default=None, help="work_space",)
-
+parser.add_argument(
+    "--config",
+    help="config file",
+)
+parser.add_argument(
+    "--workspace",
+    default=None,
+    help="work_space",
+)
 
 
 def main():
     search_test()
 
+
 def search_test():
     args = parser.parse_args()
     config = args.config
@@ -38,14 +44,13 @@ def search_test():
         resource_config=resource_config,
         data_config=data_config,
         search_space=search_space,
-        fitter=HubFitterClassifer
-    )
+        fitter=HubFitterClassifer)
     result = exper.search()  # 开始搜索任务
     policy = result.get_best_policy()  # 最佳策略获取， policy格式见 搜索结果应用格式
     print("policy is:{}".format(policy))
     dump_path = os.path.join(workspace, "auto_aug_config.json")
-    result.dump_best_policy(
-        path=dump_path)
+    result.dump_best_policy(path=dump_path)
+
 
 if __name__ == "__main__":
     main()

demo/autoaug/train.py

@@ -24,9 +24,20 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 parser = argparse.ArgumentParser()
-parser.add_argument("--config",help="config file",)
-parser.add_argument("--workspace",default=None, help="work_space",)
-parser.add_argument("--policy",default=None, help="data aug policy",)
+parser.add_argument(
+    "--config",
+    help="config file",
+)
+parser.add_argument(
+    "--workspace",
+    default=None,
+    help="work_space",
+)
+parser.add_argument(
+    "--policy",
+    default=None,
+    help="data aug policy",
+)
 
 if __name__ == '__main__':
     args = parser.parse_args()
@@ -39,10 +50,7 @@ if __name__ == '__main__':
 
     input_size = task_config.classifier.input_size
     scale_size = task_config.classifier.scale_size
-    normalize = {
-        'mean': [
-            0.485, 0.456, 0.406], 'std': [
-            0.229, 0.224, 0.225]}
+    normalize = {'mean': [0.485, 0.456, 0.406], 'std': [0.229, 0.224, 0.225]}
     epochs = task_config.classifier.epochs
 
     policy = args.policy
@@ -50,13 +58,11 @@ if __name__ == '__main__':
         print("use normal train transform")
         TrainTransform = transforms.Compose(
             transforms=[
-                transforms.Resize(
-                    (input_size,
-                     input_size)),
+                transforms.Resize((input_size, input_size)),
                 transforms.Permute(),
-                transforms.Normalize(
-                    **normalize, channel_first=True)],
-            channel_first = False)
+                transforms.Normalize(**normalize, channel_first=True)
+            ],
+            channel_first=False)
     else:
         TrainTransform = PbaAugment(
             input_size=input_size,
@@ -64,17 +70,12 @@ if __name__ == '__main__':
             normalize=normalize,
             policy=policy,
             hp_policy_epochs=epochs,
-            stage="train"
-        )
+            stage="train")
     train_dataset, eval_dataset = _init_loader(config, TrainTransform=TrainTransform)
     class_to_id_dict = _read_classes(config.data_config.label_list)
-    model = hub.Module(name=config.task_config.classifier.model_name, label_list=class_to_id_dict.keys(), load_checkpoint=None)
+    model = hub.Module(
+        name=config.task_config.classifier.model_name, label_list=class_to_id_dict.keys(), load_checkpoint=None)
 
-    optimizer = paddle.optimizer.Adam(
-        learning_rate=0.001, parameters=model.parameters())
-    trainer = CustomTrainer(
-        model=model,
-        optimizer=optimizer,
-        checkpoint_dir='img_classification_ckpt')
+    optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
+    trainer = CustomTrainer(model=model, optimizer=optimizer, checkpoint_dir='img_classification_ckpt')
     trainer.train(train_dataset, epochs=epochs, batch_size=32, eval_dataset=eval_dataset, save_interval=10)
-

demo/colorization/train.py

@@ -6,7 +6,8 @@ from paddlehub.datasets import Canvas
 
 if __name__ == '__main__':
 
-    transform = T.Compose([T.Resize((256, 256), interpolation='NEAREST'),
+    transform = T.Compose(
+        [T.Resize((256, 256), interpolation='NEAREST'),
          T.RandomPaddingCrop(crop_size=176),
          T.RGB2LAB()], to_rgb=True)
 

demo/semantic_segmentation/README.md

@@ -159,5 +159,3 @@ https://github.com/PaddlePaddle/PaddleSeg
 paddlepaddle >= 2.0.0
 
 paddlehub >= 2.0.0
-
-

demo/sequence_labeling/predict.py

@@ -24,9 +24,7 @@ if __name__ == '__main__':
         '华裔作家韩素音女士曾三次到大足，称“大足石窟是一座未被开发的金矿”。',
     ]
     data = [[split_char.join(text)] for text in text_a]
-    label_map = {
-        idx: label for idx, label in enumerate(label_list)
-    }
+    label_map = {idx: label for idx, label in enumerate(label_list)}
 
     model = hub.Module(
         name='ernie_tiny',
@@ -39,4 +37,3 @@ if __name__ == '__main__':
     results = model.predict(data=data, max_seq_len=128, batch_size=1, use_gpu=True)
     for idx, text in enumerate(text_a):
         print(f'Text:\n{text} \nLable: \n{", ".join(results[idx][1:len(text)+1])} \n')
-

demo/sequence_labeling/train.py

@@ -21,7 +21,11 @@ import argparse
 
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--num_epoch", type=int, default=3, help="Number of epoches for fine-tuning.")
-parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument(
+    "--use_gpu",
+    type=ast.literal_eval,
+    default=True,
+    help="Whether use GPU for fine-tuning, input should be True or False")
 parser.add_argument("--learning_rate", type=float, default=5e-5, help="Learning rate used to train with warmup.")
 parser.add_argument("--max_seq_len", type=int, default=128, help="Number of words of the longest seqence.")
 parser.add_argument("--batch_size", type=int, default=32, help="Total examples' number in batch for training.")
@@ -30,12 +34,9 @@ parser.add_argument("--save_interval", type=int, default=1, help="Save checkpoin
 
 args = parser.parse_args()
 
-
 if __name__ == '__main__':
     label_list = MSRA_NER.label_list
-    label_map = {
-        idx: label for idx, label in enumerate(label_list)
-    }
+    label_map = {idx: label for idx, label in enumerate(label_list)}
 
     model = hub.Module(
         name='ernie_tiny',
@@ -45,21 +46,9 @@ if __name__ == '__main__':
     )
 
     tokenizer = model.get_tokenizer()
-    train_dataset = MSRA_NER(
-        tokenizer=tokenizer,
-        max_seq_len=args.max_seq_len,
-        mode='train'
-    )
-    dev_dataset = MSRA_NER(
-        tokenizer=tokenizer,
-        max_seq_len=args.max_seq_len,
-        mode='dev'
-    )
-    test_dataset = MSRA_NER(
-        tokenizer=tokenizer,
-        max_seq_len=args.max_seq_len,
-        mode='test'
-    )
+    train_dataset = MSRA_NER(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='train')
+    dev_dataset = MSRA_NER(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='dev')
+    test_dataset = MSRA_NER(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='test')
 
     optimizer = paddle.optimizer.AdamW(learning_rate=args.learning_rate, parameters=model.parameters())
     trainer = hub.Trainer(model, optimizer, checkpoint_dir=args.checkpoint_dir, use_gpu=args.use_gpu)

demo/style_transfer/predict.py

@@ -3,4 +3,4 @@ import paddlehub as hub
 
 if __name__ == '__main__':
     model = hub.Module(name='msgnet', load_checkpoint="/PATH/TO/CHECKPOINT")
-    result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path ='style_tranfer')
+    result = model.predict(origin=["venice-boat.jpg"], style="candy.jpg", visualization=True, save_path='style_tranfer')
\ No newline at end of file

demo/text_classification/README.md

@@ -166,4 +166,3 @@ for idx, text in enumerate(data):
 ```
 
 参数配置正确后，请执行脚本`python predict.py`， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
-

demo/text_classification/embedding/predict.py

@@ -19,17 +19,19 @@ from model import BoWModel
 import ast
 import argparse
 
-
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--hub_embedding_name", type=str, default='w2v_baidu_encyclopedia_target_word-word_dim300', help="")
 parser.add_argument("--max_seq_len", type=int, default=128, help="Number of words of the longest seqence.")
 parser.add_argument("--batch_size", type=int, default=64, help="Total examples' number in batch for training.")
 parser.add_argument("--checkpoint", type=str, default='./checkpoint/best_model/model.pdparams', help="Model checkpoint")
-parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument(
+    "--use_gpu",
+    type=ast.literal_eval,
+    default=True,
+    help="Whether use GPU for fine-tuning, input should be True or False")
 
 args = parser.parse_args()
 
-
 if __name__ == '__main__':
     # Data to be prdicted
     data = [
@@ -44,12 +46,9 @@ if __name__ == '__main__':
 
     embedder = hub.Module(name=args.hub_embedding_name)
     tokenizer = embedder.get_tokenizer()
-    model = BoWModel(
-        embedder=embedder,
-        tokenizer=tokenizer,
-        load_checkpoint=args.checkpoint,
-        label_map=label_map)
+    model = BoWModel(embedder=embedder, tokenizer=tokenizer, load_checkpoint=args.checkpoint, label_map=label_map)
 
-    results = model.predict(data, max_seq_len=args.max_seq_len, batch_size=args.batch_size, use_gpu=args.use_gpu, return_result=False)
+    results = model.predict(
+        data, max_seq_len=args.max_seq_len, batch_size=args.batch_size, use_gpu=args.use_gpu, return_result=False)
     for idx, text in enumerate(data):
         print('Data: {} \t Lable: {}'.format(text[0], results[idx]))

demo/text_classification/embedding/train.py

@@ -21,7 +21,6 @@ from model import BoWModel
 import ast
 import argparse
 
-
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--hub_embedding_name", type=str, default='w2v_baidu_encyclopedia_target_word-word_dim300', help="")
 parser.add_argument("--num_epoch", type=int, default=10, help="Number of epoches for fine-tuning.")
@@ -30,11 +29,14 @@ parser.add_argument("--max_seq_len", type=int, default=128, help="Number of word
 parser.add_argument("--batch_size", type=int, default=64, help="Total examples' number in batch for training.")
 parser.add_argument("--checkpoint_dir", type=str, default='./checkpoint', help="Directory to model checkpoint")
 parser.add_argument("--save_interval", type=int, default=5, help="Save checkpoint every n epoch.")
-parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument(
+    "--use_gpu",
+    type=ast.literal_eval,
+    default=True,
+    help="Whether use GPU for fine-tuning, input should be True or False")
 
 args = parser.parse_args()
 
-
 if __name__ == '__main__':
     embedder = hub.Module(name=args.hub_embedding_name)
     tokenizer = embedder.get_tokenizer()
@@ -44,8 +46,7 @@ if __name__ == '__main__':
     test_dataset = ChnSentiCorp(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='test')
 
     model = BoWModel(embedder=embedder)
-    optimizer = paddle.optimizer.AdamW(
-        learning_rate=args.learning_rate, parameters=model.parameters())
+    optimizer = paddle.optimizer.AdamW(learning_rate=args.learning_rate, parameters=model.parameters())
     trainer = hub.Trainer(model, optimizer, checkpoint_dir=args.checkpoint_dir, use_gpu=args.use_gpu)
     trainer.train(
         train_dataset,

demo/text_classification/train.py

@@ -21,7 +21,11 @@ import argparse
 
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--num_epoch", type=int, default=3, help="Number of epoches for fine-tuning.")
-parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument(
+    "--use_gpu",
+    type=ast.literal_eval,
+    default=True,
+    help="Whether use GPU for fine-tuning, input should be True or False")
 parser.add_argument("--learning_rate", type=float, default=5e-5, help="Learning rate used to train with warmup.")
 parser.add_argument("--max_seq_len", type=int, default=128, help="Number of words of the longest seqence.")
 parser.add_argument("--batch_size", type=int, default=32, help="Total examples' number in batch for training.")
@@ -33,15 +37,11 @@ args = parser.parse_args()
 if __name__ == '__main__':
     model = hub.Module(name='ernie_tiny', version='2.0.1', task='seq-cls')
 
-    train_dataset = ChnSentiCorp(
-        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='train')
-    dev_dataset = ChnSentiCorp(
-        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='dev')
-    test_dataset = ChnSentiCorp(
-        tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='test')
+    train_dataset = ChnSentiCorp(tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='train')
+    dev_dataset = ChnSentiCorp(tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='dev')
+    test_dataset = ChnSentiCorp(tokenizer=model.get_tokenizer(), max_seq_len=args.max_seq_len, mode='test')
 
-    optimizer = paddle.optimizer.AdamW(
-        learning_rate=args.learning_rate, parameters=model.parameters())
+    optimizer = paddle.optimizer.AdamW(learning_rate=args.learning_rate, parameters=model.parameters())
     trainer = hub.Trainer(model, optimizer, checkpoint_dir=args.checkpoint_dir, use_gpu=args.use_gpu)
     trainer.train(
         train_dataset,

demo/text_matching/train.py

@@ -21,7 +21,11 @@ import argparse
 
 parser = argparse.ArgumentParser(__doc__)
 parser.add_argument("--num_epoch", type=int, default=10, help="Number of epoches for fine-tuning.")
-parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for fine-tuning, input should be True or False")
+parser.add_argument(
+    "--use_gpu",
+    type=ast.literal_eval,
+    default=True,
+    help="Whether use GPU for fine-tuning, input should be True or False")
 parser.add_argument("--learning_rate", type=float, default=5e-5, help="Learning rate used to train with warmup.")
 parser.add_argument("--max_seq_len", type=int, default=64, help="Number of words of the longest seqence.")
 parser.add_argument("--batch_size", type=int, default=128, help="Total examples' number in batch for training.")
@@ -38,8 +42,7 @@ if __name__ == '__main__':
     dev_dataset = LCQMC(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='dev')
     test_dataset = LCQMC(tokenizer=tokenizer, max_seq_len=args.max_seq_len, mode='test')
 
-    optimizer = paddle.optimizer.AdamW(
-        learning_rate=args.learning_rate, parameters=model.parameters())
+    optimizer = paddle.optimizer.AdamW(learning_rate=args.learning_rate, parameters=model.parameters())
     trainer = hub.Trainer(model, optimizer, checkpoint_dir=args.checkpoint_dir, use_gpu=args.use_gpu)
     trainer.train(
         train_dataset,

docs/docs_ch/figures.md

@@ -93,6 +93,3 @@ $ hub serving start -m chinese_ocr_db_crnn_mobile
 </p>
 
 * 如需在线快速体验，请点击[PaddleHub教程合集](https://aistudio.baidu.com/aistudio/projectdetail/231146)，可使用AI Studio平台提供的GPU算力进行快速尝试。
-
-
-

modules/audio/audio_classification/PANNs/cnn10/module.py

@@ -27,7 +27,8 @@ from paddlehub.module.module import moduleinfo
 from paddlehub.utils.log import logger
 
 
-@moduleinfo(name="panns_cnn10",
+@moduleinfo(
+    name="panns_cnn10",
     version="1.0.0",
     summary="",
     author="Baidu",
@@ -52,15 +53,15 @@ class PANN(nn.Layer):
             self.num_class = num_class
 
         if task == 'sound-cls':
-            self.cnn10 = CNN10(extract_embedding=True,
-                               checkpoint=os.path.join(MODULE_HOME, 'panns_cnn10', 'cnn10.pdparams'))
+            self.cnn10 = CNN10(
+                extract_embedding=True, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn10', 'cnn10.pdparams'))
             self.dropout = nn.Dropout(0.1)
             self.fc = nn.Linear(self.cnn10.emb_size, num_class)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         else:
-            self.cnn10 = CNN10(extract_embedding=False,
-                               checkpoint=os.path.join(MODULE_HOME, 'panns_cnn10', 'cnn10.pdparams'))
+            self.cnn10 = CNN10(
+                extract_embedding=False, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn10', 'cnn10.pdparams'))
 
         self.task = task
         if load_checkpoint is not None and os.path.isfile(load_checkpoint):

modules/audio/audio_classification/PANNs/cnn10/network.py

@@ -25,13 +25,15 @@ class ConvBlock(nn.Layer):
     def __init__(self, in_channels, out_channels):
         super(ConvBlock, self).__init__()
 
-        self.conv1 = nn.Conv2D(in_channels=in_channels,
+        self.conv1 = nn.Conv2D(
+            in_channels=in_channels,
             out_channels=out_channels,
             kernel_size=(3, 3),
             stride=(1, 1),
             padding=(1, 1),
             bias_attr=False)
-        self.conv2 = nn.Conv2D(in_channels=out_channels,
+        self.conv2 = nn.Conv2D(
+            in_channels=out_channels,
             out_channels=out_channels,
             kernel_size=(3, 3),
             stride=(1, 1),

modules/audio/audio_classification/PANNs/cnn14/module.py

@@ -27,7 +27,8 @@ from paddlehub.module.module import moduleinfo
 from paddlehub.utils.log import logger
 
 
-@moduleinfo(name="panns_cnn14",
+@moduleinfo(
+    name="panns_cnn14",
     version="1.0.0",
     summary="",
     author="Baidu",
@@ -52,15 +53,15 @@ class PANN(nn.Layer):
             self.num_class = num_class
 
         if task == 'sound-cls':
-            self.cnn14 = CNN14(extract_embedding=True,
-                               checkpoint=os.path.join(MODULE_HOME, 'panns_cnn14', 'cnn14.pdparams'))
+            self.cnn14 = CNN14(
+                extract_embedding=True, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn14', 'cnn14.pdparams'))
             self.dropout = nn.Dropout(0.1)
             self.fc = nn.Linear(self.cnn14.emb_size, num_class)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         else:
-            self.cnn14 = CNN14(extract_embedding=False,
-                               checkpoint=os.path.join(MODULE_HOME, 'panns_cnn14', 'cnn14.pdparams'))
+            self.cnn14 = CNN14(
+                extract_embedding=False, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn14', 'cnn14.pdparams'))
 
         self.task = task
         if load_checkpoint is not None and os.path.isfile(load_checkpoint):

modules/audio/audio_classification/PANNs/cnn14/network.py

@@ -25,13 +25,15 @@ class ConvBlock(nn.Layer):
     def __init__(self, in_channels, out_channels):
         super(ConvBlock, self).__init__()
 
-        self.conv1 = nn.Conv2D(in_channels=in_channels,
+        self.conv1 = nn.Conv2D(
+            in_channels=in_channels,
             out_channels=out_channels,
             kernel_size=(3, 3),
             stride=(1, 1),
             padding=(1, 1),
             bias_attr=False)
-        self.conv2 = nn.Conv2D(in_channels=out_channels,
+        self.conv2 = nn.Conv2D(
+            in_channels=out_channels,
             out_channels=out_channels,
             kernel_size=(3, 3),
             stride=(1, 1),

modules/audio/audio_classification/PANNs/cnn6/module.py

@@ -27,7 +27,8 @@ from paddlehub.module.module import moduleinfo
 from paddlehub.utils.log import logger
 
 
-@moduleinfo(name="panns_cnn6",
+@moduleinfo(
+    name="panns_cnn6",
     version="1.0.0",
     summary="",
     author="Baidu",
@@ -52,15 +53,15 @@ class PANN(nn.Layer):
             self.num_class = num_class
 
         if task == 'sound-cls':
-            self.cnn6 = CNN6(extract_embedding=True,
-                             checkpoint=os.path.join(MODULE_HOME, 'panns_cnn6', 'cnn6.pdparams'))
+            self.cnn6 = CNN6(
+                extract_embedding=True, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn6', 'cnn6.pdparams'))
             self.dropout = nn.Dropout(0.1)
             self.fc = nn.Linear(self.cnn6.emb_size, num_class)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         else:
-            self.cnn6 = CNN6(extract_embedding=False,
-                             checkpoint=os.path.join(MODULE_HOME, 'panns_cnn6', 'cnn6.pdparams'))
+            self.cnn6 = CNN6(
+                extract_embedding=False, checkpoint=os.path.join(MODULE_HOME, 'panns_cnn6', 'cnn6.pdparams'))
 
         self.task = task
         if load_checkpoint is not None and os.path.isfile(load_checkpoint):

modules/audio/audio_classification/PANNs/cnn6/network.py

@@ -25,7 +25,8 @@ class ConvBlock5x5(nn.Layer):
     def __init__(self, in_channels, out_channels):
         super(ConvBlock5x5, self).__init__()
 
-        self.conv1 = nn.Conv2D(in_channels=in_channels,
+        self.conv1 = nn.Conv2D(
+            in_channels=in_channels,
             out_channels=out_channels,
             kernel_size=(5, 5),
             stride=(1, 1),

modules/image/Image_editing/colorization/user_guided_colorization/data_feed.py

@@ -18,6 +18,7 @@ class ColorizeHint:
         hint(np.ndarray): hint images
         mask(np.ndarray): mask images
     """
+
     def __init__(self, percent: float, num_points: int = None, samp: str = 'normal', use_avg: bool = True):
         self.percent = percent
         self.num_points = num_points
@@ -52,11 +53,9 @@ class ColorizeHint:
                 # add color point
                 if self.use_avg:
                     # embed()
-                    hint[nn, :, h:h + P, w:w + P] = np.mean(np.mean(data[nn, :, h:h + P, w:w + P],
-                                                                    axis=2,
-                                                                    keepdims=True),
-                                                            axis=1,
-                                                            keepdims=True).reshape(1, C, 1, 1)
+                    hint[nn, :, h:h + P, w:w + P] = np.mean(
+                        np.mean(data[nn, :, h:h + P, w:w + P], axis=2, keepdims=True), axis=1, keepdims=True).reshape(
+                            1, C, 1, 1)
                 else:
                     hint[nn, :, h:h + P, w:w + P] = data[nn, :, h:h + P, w:w + P]
                 mask[nn, :, h:h + P, w:w + P] = 1
@@ -82,6 +81,7 @@ class ColorizePreprocess:
         data(dict)：The preprocessed data for colorization.
 
     """
+
     def __init__(self,
                  ab_thresh: float = 0.,
                  p: float = 0.,
@@ -113,8 +113,8 @@ class ColorizePreprocess:
         data['B'] = data_lab[:, 1:, :, :]
         if self.ab_thresh > 0:  # mask out grayscale images
             thresh = 1. * self.ab_thresh / 110
-            mask = np.sum(np.abs(np.max(np.max(data['B'], axis=3), axis=2) - np.min(np.min(data['B'], axis=3), axis=2)),
-                          axis=1)
+            mask = np.sum(
+                np.abs(np.max(np.max(data['B'], axis=3), axis=2) - np.min(np.min(data['B'], axis=3), axis=2)), axis=1)
             mask = (mask >= thresh)
             data['A'] = data['A'][mask, :, :, :]
             data['B'] = data['B'][mask, :, :, :]

modules/image/Image_editing/colorization/user_guided_colorization/module.py

@@ -40,6 +40,7 @@ class UserGuidedColorization(nn.Layer):
         load_checkpoint (str): Pretrained checkpoint path.
 
     """
+
     def __init__(self, use_tanh: bool = True, load_checkpoint: str = None):
         super(UserGuidedColorization, self).__init__()
         self.input_nc = 4

modules/image/Image_gan/style_transfer/msgnet/module.py

@@ -14,6 +14,7 @@ from paddlehub.module.cv_module import StyleTransferModule
 
 class GramMatrix(nn.Layer):
     """Calculate gram matrix"""
+
     def forward(self, y):
         (b, ch, h, w) = y.shape
         features = y.reshape((b, ch, w * h))
@@ -24,6 +25,7 @@ class GramMatrix(nn.Layer):
 
 class ConvLayer(nn.Layer):
     """Basic conv layer with reflection padding layer"""
+
     def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int):
         super(ConvLayer, self).__init__()
         pad = int(np.floor(kernel_size / 2))
@@ -51,6 +53,7 @@ class UpsampleConvLayer(nn.Layer):
     Return:
         img(paddle.Tensor): UpsampleConvLayer output.
     """
+
     def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int, upsample=None):
         super(UpsampleConvLayer, self).__init__()
         self.upsample = upsample
@@ -85,6 +88,7 @@ class Bottleneck(nn.Layer):
     Return:
         img(paddle.Tensor): Bottleneck output.
     """
+
     def __init__(self,
                  inplanes: int,
                  planes: int,
@@ -98,8 +102,8 @@ class Bottleneck(nn.Layer):
             self.residual_layer = nn.Conv2D(inplanes, planes * self.expansion, kernel_size=1, stride=stride)
         conv_block = (norm_layer(inplanes), nn.ReLU(), nn.Conv2D(inplanes, planes, kernel_size=1, stride=1),
                       norm_layer(planes), nn.ReLU(), ConvLayer(planes, planes, kernel_size=3, stride=stride),
-                      norm_layer(planes), nn.ReLU(), nn.Conv2D(planes, planes * self.expansion, kernel_size=1,
-                                                               stride=1))
+                      norm_layer(planes), nn.ReLU(), nn.Conv2D(
+                          planes, planes * self.expansion, kernel_size=1, stride=1))
         self.conv_block = nn.Sequential(*conv_block)
 
     def forward(self, x: paddle.Tensor):
@@ -125,14 +129,12 @@ class UpBottleneck(nn.Layer):
     Return:
         img(paddle.Tensor): UpBottleneck output.
     """
+
     def __init__(self, inplanes: int, planes: int, stride: int = 2, norm_layer: nn.Layer = nn.BatchNorm2D):
         super(UpBottleneck, self).__init__()
         self.expansion = 4
-        self.residual_layer = UpsampleConvLayer(inplanes,
-                                                planes * self.expansion,
-                                                kernel_size=1,
-                                                stride=1,
-                                                upsample=stride)
+        self.residual_layer = UpsampleConvLayer(
+            inplanes, planes * self.expansion, kernel_size=1, stride=1, upsample=stride)
         conv_block = []
         conv_block += [norm_layer(inplanes), nn.ReLU(), nn.Conv2D(inplanes, planes, kernel_size=1, stride=1)]
         conv_block += [
@@ -163,6 +165,7 @@ class Inspiration(nn.Layer):
     Return:
         img(paddle.Tensor): UpBottleneck output.
     """
+
     def __init__(self, C: int, B: int = 1):
         super(Inspiration, self).__init__()
 
@@ -179,8 +182,8 @@ class Inspiration(nn.Layer):
         self.P = paddle.bmm(self.weight.expand_as(self.G), self.G)
 
         x = paddle.bmm(
-            self.P.transpose((0, 2, 1)).expand((X.shape[0], self.C, self.C)), X.reshape(
-                (X.shape[0], X.shape[1], -1))).reshape(X.shape)
+            self.P.transpose((0, 2, 1)).expand((X.shape[0], self.C, self.C)), X.reshape((X.shape[0], X.shape[1],
+                                                                                         -1))).reshape(X.shape)
         return x
 
     def __repr__(self):
@@ -190,6 +193,7 @@ class Inspiration(nn.Layer):
 
 class Vgg16(nn.Layer):
     """ First four layers from Vgg16."""
+
     def __init__(self):
         super(Vgg16, self).__init__()
         self.conv1_1 = nn.Conv2D(3, 64, kernel_size=3, stride=1, padding=1)
@@ -264,12 +268,8 @@ class MSGNet(nn.Layer):
     Return:
         img(paddle.Tensor): MSGNet output.
     """
-    def __init__(self,
-                 input_nc=3,
-                 output_nc=3,
-                 ngf=128,
-                 n_blocks=6,
-                 norm_layer=nn.InstanceNorm2D,
+
+    def __init__(self, input_nc=3, output_nc=3, ngf=128, n_blocks=6, norm_layer=nn.InstanceNorm2D,
                  load_checkpoint=None):
         super(MSGNet, self).__init__()
         self.gram = GramMatrix()

modules/image/classification/resnet50_vd_imagenet_ssld/module.py

@@ -194,7 +194,7 @@ class ResNet50_vd(nn.Layer):
             label_file = os.path.join(self.directory, 'label_list.txt')
             files = open(label_file)
             for line in files.readlines():
-                line=line.strip('\n') 
+                line = line.strip('\n')
                 label_list.append(line)
             self.labels = label_list
             class_dim = len(self.labels)
@@ -248,7 +248,12 @@ class ResNet50_vd(nn.Layer):
             print("load pretrained checkpoint success")
 
     def transforms(self, images: Union[str, np.ndarray]):
-        transforms = T.Compose([T.Resize((256, 256)), T.CenterCrop(224), T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])], to_rgb=True)
+        transforms = T.Compose([
+            T.Resize((256, 256)),
+            T.CenterCrop(224),
+            T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ],
+                               to_rgb=True)
         return transforms(images)
 
     def forward(self, inputs: paddle.Tensor):

modules/image/industrial_application/meter_readings/barometer_reader/README.md

@@ -111,5 +111,3 @@ paddlepaddle >= 2.0.0
 paddlehub >= 2.0.0
 
 paddlex >= 1.3.0
-
-

modules/image/industrial_application/meter_readings/barometer_reader/module.py

@@ -12,7 +12,6 @@ import paddle.nn as nn
 from paddlex.seg import transforms as T
 from paddlehub.module.module import moduleinfo, runnable, serving
 
-
 METER_SHAPE = 512
 CIRCLE_CENTER = [256, 256]
 CIRCLE_RADIUS = 250
@@ -44,11 +43,13 @@ def cv2_to_base64(image: np.ndarray):
     return base64.b64encode(data.tostring()).decode('utf8')
 
 
-@moduleinfo(name="barometer_reader",
+@moduleinfo(
+    name="barometer_reader",
     type="CV/image_editing",
     author="paddlepaddle",
     author_email="",
-            summary="meter_reader implements the detection and automatic reading of traditional mechanical pointer meters based on Meter detection and  pointer segmentation.",
+    summary=
+    "meter_reader implements the detection and automatic reading of traditional mechanical pointer meters based on Meter detection and  pointer segmentation.",
     version="1.0.0")
 class BarometerReader(nn.Layer):
     def __init__(self):
@@ -121,8 +122,7 @@ class BarometerReader(nn.Layer):
             if pointer_flag:
                 if pointer_data[i] == 0 and pointer_data[i + 1] == 0:
                     one_pointer_end = i - 1
-                    pointer_location = (
-                        one_pointer_start + one_pointer_end) / 2
+                    pointer_location = (one_pointer_start + one_pointer_end) / 2
                     one_pointer_start = 0
                     one_pointer_end = 0
                     pointer_flag = False
@@ -135,8 +135,7 @@ class BarometerReader(nn.Layer):
                 if scale_location[i] <= pointer_location and pointer_location < scale_location[i + 1]:
                     scales = i + (pointer_location - scale_location[i]) / (
                         scale_location[i + 1] - scale_location[i] + 1e-05) + 1
-            ratio = (pointer_location - scale_location[0]) / (
-                scale_location[scale_num - 1] - scale_location[0] + 1e-05)
+            ratio = (pointer_location - scale_location[0]) / (scale_location[scale_num - 1] - scale_location[0] + 1e-05)
         result = {'scale_num': scale_num, 'scales': scales, 'ratio': ratio}
         return result
 
@@ -147,7 +146,7 @@ class BarometerReader(nn.Layer):
                 erode_kernel: int = 4,
                 use_erode: bool = True,
                 visualization: bool = False,
-                save_dir: str ='output'):
+                save_dir: str = 'output'):
 
         if isinstance(im_file, str):
             im = cv2.imread(im_file).astype('float32')
@@ -173,13 +172,7 @@ class BarometerReader(nn.Layer):
             meter_shape = sub_image.shape
             scale_x = float(METER_SHAPE) / float(meter_shape[1])
             scale_y = float(METER_SHAPE) / float(meter_shape[0])
-            meter_meter = cv2.resize(
-                sub_image,
-                None,
-                None,
-                fx=scale_x,
-                fy=scale_y,
-                interpolation=cv2.INTER_LINEAR)
+            meter_meter = cv2.resize(sub_image, None, None, fx=scale_x, fy=scale_y, interpolation=cv2.INTER_LINEAR)
             meter_meter = meter_meter.astype('float32')
             resized_meters.append(meter_meter)
 
@@ -191,9 +184,7 @@ class BarometerReader(nn.Layer):
             for j in range(i, im_size):
                 meter_images.append(resized_meters[j - i])
 
-            result = self.segmenter.batch_predict(
-                transforms=self.seg_transform,
-                img_file_list=meter_images)
+            result = self.segmenter.batch_predict(transforms=self.seg_transform, img_file_list=meter_images)
 
             if use_erode:
                 kernel = np.ones((erode_kernel, erode_kernel), np.uint8)
@@ -250,21 +241,16 @@ class BarometerReader(nn.Layer):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
         results = self.predict(im_file=args.input_path)
         return results
 
-
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")

modules/image/instance_segmentation/solov2/README.md

@@ -116,4 +116,3 @@ https://github.com/PaddlePaddle/PaddleDetection
 paddlepaddle >= 2.0.0
 
 paddlehub >= 2.0.0
-

modules/image/instance_segmentation/solov2/data_feed.py

@@ -42,38 +42,28 @@ def visualize_box_mask(im, results, labels=None, mask_resolution=14, threshold=0
         im (PIL.Image.Image): visualized image
     """
     if not labels:
-        labels = ['background', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
-                  'train', 'truck', 'boat', 'traffic light', 'fire', 'hydrant', 'stop sign', 'parking meter',
-                  'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
-                  'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
-                  'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle',
-                  'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
-                  'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed',
-                  'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
-                  'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
-                  'hair drier', 'toothbrush']
+        labels = [
+            'background', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat',
+            'traffic light', 'fire', 'hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
+            'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',
+            'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
+            'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+            'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
+            'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard',
+            'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors',
+            'teddy bear', 'hair drier', 'toothbrush'
+        ]
     if isinstance(im, str):
         im = Image.open(im).convert('RGB')
     else:
         im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
         im = Image.fromarray(im)
     if 'masks' in results and 'boxes' in results:
-        im = draw_mask(
-            im,
-            results['boxes'],
-            results['masks'],
-            labels,
-            resolution=mask_resolution)
+        im = draw_mask(im, results['boxes'], results['masks'], labels, resolution=mask_resolution)
     if 'boxes' in results:
         im = draw_box(im, results['boxes'], labels)
     if 'segm' in results:
-        im = draw_segm(
-            im,
-            results['segm'],
-            results['label'],
-            results['score'],
-            labels,
-            threshold=threshold)
+        im = draw_segm(im, results['segm'], results['label'], results['score'], labels, threshold=threshold)
     return im
 
 
@@ -200,28 +190,19 @@ def draw_box(im, np_boxes, labels):
         color = tuple(clsid2color[clsid])
 
         # draw bbox
-        draw.line(
-            [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin),
-             (xmin, ymin)],
+        draw.line([(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin)],
                   width=draw_thickness,
                   fill=color)
 
         # draw label
         text = "{} {:.4f}".format(labels[clsid], score)
         tw, th = draw.textsize(text)
-        draw.rectangle(
-            [(xmin + 1, ymin - th), (xmin + tw + 1, ymin)], fill=color)
+        draw.rectangle([(xmin + 1, ymin - th), (xmin + tw + 1, ymin)], fill=color)
         draw.text((xmin + 1, ymin - th), text, fill=(255, 255, 255))
     return im
 
 
-def draw_segm(im,
-              np_segms,
-              np_label,
-              np_score,
-              labels,
-              threshold=0.5,
-              alpha=0.7):
+def draw_segm(im, np_segms, np_label, np_score, labels, threshold=0.5, alpha=0.7):
     """
     Draw segmentation on image.
     """
@@ -250,28 +231,17 @@ def draw_segm(im,
         sum_y = np.sum(mask, axis=1)
         y = np.where(sum_y > 0.5)[0]
         x0, x1, y0, y1 = x[0], x[-1], y[0], y[-1]
-        cv2.rectangle(im, (x0, y0), (x1, y1),
-                      tuple(color_mask.astype('int32').tolist()), 1)
+        cv2.rectangle(im, (x0, y0), (x1, y1), tuple(color_mask.astype('int32').tolist()), 1)
         bbox_text = '%s %.2f' % (labels[clsid], score)
         t_size = cv2.getTextSize(bbox_text, 0, 0.3, thickness=1)[0]
-        cv2.rectangle(im, (x0, y0), (x0 + t_size[0], y0 - t_size[1] - 3),
-                      tuple(color_mask.astype('int32').tolist()), -1)
-        cv2.putText(
-            im,
-            bbox_text, (x0, y0 - 2),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.3, (0, 0, 0),
-            1,
-            lineType=cv2.LINE_AA)
+        cv2.rectangle(im, (x0, y0), (x0 + t_size[0], y0 - t_size[1] - 3), tuple(color_mask.astype('int32').tolist()),
+                      -1)
+        cv2.putText(im, bbox_text, (x0, y0 - 2), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 0), 1, lineType=cv2.LINE_AA)
 
     return Image.fromarray(im.astype('uint8'))
 
 
-def load_predictor(model_dir,
-                   run_mode='fluid',
-                   batch_size=1,
-                   use_gpu=False,
-                   min_subgraph_size=3):
+def load_predictor(model_dir, run_mode='fluid', batch_size=1, use_gpu=False, min_subgraph_size=3):
     """set AnalysisConfig, generate AnalysisPredictor
     Args:
         model_dir (str): root path of __model__ and __params__
@@ -282,20 +252,16 @@ def load_predictor(model_dir,
         ValueError: predict by TensorRT need use_gpu == True.
     """
     if not use_gpu and not run_mode == 'fluid':
-        raise ValueError(
-            "Predict by TensorRT mode: {}, expect use_gpu==True, but use_gpu == {}"
-                .format(run_mode, use_gpu))
+        raise ValueError("Predict by TensorRT mode: {}, expect use_gpu==True, but use_gpu == {}".format(
+            run_mode, use_gpu))
     if run_mode == 'trt_int8':
-        raise ValueError("TensorRT int8 mode is not supported now, "
-                         "please use trt_fp32 or trt_fp16 instead.")
+        raise ValueError("TensorRT int8 mode is not supported now, " "please use trt_fp32 or trt_fp16 instead.")
     precision_map = {
         'trt_int8': fluid.core.AnalysisConfig.Precision.Int8,
         'trt_fp32': fluid.core.AnalysisConfig.Precision.Float32,
         'trt_fp16': fluid.core.AnalysisConfig.Precision.Half
     }
-    config = fluid.core.AnalysisConfig(
-        os.path.join(model_dir, '__model__'),
-        os.path.join(model_dir, '__params__'))
+    config = fluid.core.AnalysisConfig(os.path.join(model_dir, '__model__'), os.path.join(model_dir, '__params__'))
     if use_gpu:
         # initial GPU memory(M), device ID
         config.enable_use_gpu(100, 0)

modules/image/instance_segmentation/solov2/module.py

@@ -33,20 +33,16 @@ class Detector(object):
         threshold (float): threshold to reserve the result for output.
     """
 
-    def __init__(self,
-                 min_subgraph_size: int = 60,
-                 use_gpu=False,
-                 threshold: float = 0.5):
+    def __init__(self, min_subgraph_size: int = 60, use_gpu=False, threshold: float = 0.5):
 
         model_dir = os.path.join(self.directory, 'solov2_r50_fpn_1x')
-        self.predictor = D.load_predictor(
-            model_dir,
-            min_subgraph_size=min_subgraph_size,
-            use_gpu=use_gpu)
-        self.compose = [P.Resize(max_size=1333),
+        self.predictor = D.load_predictor(model_dir, min_subgraph_size=min_subgraph_size, use_gpu=use_gpu)
+        self.compose = [
+            P.Resize(max_size=1333),
             P.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
             P.Permute(),
-                        P.PadStride(stride=32)]
+            P.PadStride(stride=32)
+        ]
 
     def transform(self, im: Union[str, np.ndarray]):
         im, im_info = P.preprocess(im, self.compose)
@@ -61,17 +57,14 @@ class Detector(object):
         for box in np_boxes:
             print('class_id:{:d}, confidence:{:.4f},'
                   'left_top:[{:.2f},{:.2f}],'
-                  ' right_bottom:[{:.2f},{:.2f}]'.format(
-                int(box[0]), box[1], box[2], box[3], box[4], box[5]))
+                  ' right_bottom:[{:.2f},{:.2f}]'.format(int(box[0]), box[1], box[2], box[3], box[4], box[5]))
         results['boxes'] = np_boxes
         if np_masks is not None:
             np_masks = np_masks[expect_boxes, :, :, :]
             results['masks'] = np_masks
         return results
 
-    def predict(self,
-                image: Union[str, np.ndarray],
-                threshold: float = 0.5):
+    def predict(self, image: Union[str, np.ndarray], threshold: float = 0.5):
         '''
         Args:
             image (str/np.ndarray): path of image/ np.ndarray read by cv2
@@ -117,12 +110,9 @@ class DetectorSOLOv2(Detector):
         use_gpu (bool): whether use gpu
         threshold (float): threshold to reserve the result for output.
     """
-    def __init__(self,
-                 use_gpu: bool = False,
-                 threshold: float = 0.5):
-        super(DetectorSOLOv2, self).__init__(
-            use_gpu=use_gpu,
-            threshold=threshold)
+
+    def __init__(self, use_gpu: bool = False, threshold: float = 0.5):
+        super(DetectorSOLOv2, self).__init__(use_gpu=use_gpu, threshold=threshold)
 
     def predict(self,
                 image: Union[str, np.ndarray],
@@ -148,12 +138,9 @@ class DetectorSOLOv2(Detector):
 
         self.predictor.zero_copy_run()
         output_names = self.predictor.get_output_names()
-        np_label = self.predictor.get_output_tensor(output_names[
-                                                        0]).copy_to_cpu()
-        np_score = self.predictor.get_output_tensor(output_names[
-                                                        1]).copy_to_cpu()
-        np_segms = self.predictor.get_output_tensor(output_names[
-                                                        2]).copy_to_cpu()
+        np_label = self.predictor.get_output_tensor(output_names[0]).copy_to_cpu()
+        np_score = self.predictor.get_output_tensor(output_names[1]).copy_to_cpu()
+        np_segms = self.predictor.get_output_tensor(output_names[2]).copy_to_cpu()
         output = dict(segm=np_segms, label=np_label, score=np_score)
 
         if visualization:

modules/image/instance_segmentation/solov2/processor.py

@@ -78,19 +78,12 @@ class Resize(object):
         im_channel = im.shape[2]
         im_scale_x, im_scale_y = self.generate_scale(im)
         if self.use_cv2:
-            im = cv2.resize(
-                im,
-                None,
-                None,
-                fx=im_scale_x,
-                fy=im_scale_y,
-                interpolation=self.interp)
+            im = cv2.resize(im, None, None, fx=im_scale_x, fy=im_scale_y, interpolation=self.interp)
         else:
             resize_w = int(im_scale_x * float(im.shape[1]))
             resize_h = int(im_scale_y * float(im.shape[0]))
             if self.max_size != 0:
-                raise TypeError(
-                    'If you set max_size to cap the maximum size of image,'
+                raise TypeError('If you set max_size to cap the maximum size of image,'
                                 'please set use_cv2 to True to resize the image.')
             im = im.astype('uint8')
             im = Image.fromarray(im)
@@ -99,8 +92,7 @@ class Resize(object):
 
         # padding im when image_shape fixed by infer_cfg.yml
         if self.max_size != 0 and self.image_shape is not None:
-            padding_im = np.zeros(
-                (self.max_size, self.max_size, im_channel), dtype=np.float32)
+            padding_im = np.zeros((self.max_size, self.max_size, im_channel), dtype=np.float32)
             im_h, im_w = im.shape[:2]
             padding_im[:im_h, :im_w, :] = im
             im = padding_im

modules/image/keypoint_detection/openpose_body_estimation/module.py

@@ -207,10 +207,7 @@ class BodyPoseModel(nn.Layer):
             save_path = os.path.join(save_path, img_name)
             cv2.imwrite(save_path, canvas)
 
-        results = {
-            'candidate': candidate,
-            'subset': subset,
-            'data': canvas}
+        results = {'candidate': candidate, 'subset': subset, 'data': canvas}
 
         return results
 
@@ -221,7 +218,7 @@ class BodyPoseModel(nn.Layer):
         """
         images_decode = [P.base64_to_cv2(image) for image in images]
         results = self.predict(img=images_decode[0], **kwargs)
-        final={}
+        final = {}
         final['candidate'] = P.cv2_to_base64(results['candidate'])
         final['subset'] = P.cv2_to_base64(results['subset'])
         final['data'] = P.cv2_to_base64(results['data'])
@@ -238,19 +235,13 @@ class BodyPoseModel(nn.Layer):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            img=args.input_path,
-            save_path=args.output_dir,
-            visualization=args.visualization)
+        results = self.predict(img=args.input_path, save_path=args.output_dir, visualization=args.visualization)
 
         return results
 
@@ -260,19 +251,12 @@ class BodyPoseModel(nn.Layer):
         """
 
         self.arg_config_group.add_argument(
-            '--output_dir',
-            type=str,
-            default='openpose_body',
-            help="The directory to save output images.")
+            '--output_dir', type=str, default='openpose_body', help="The directory to save output images.")
         self.arg_config_group.add_argument(
-            '--visualization',
-            type=bool,
-            default=True,
-            help="whether to save output as images.")
+            '--visualization', type=bool, default=True, help="whether to save output as images.")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
\ No newline at end of file

modules/image/keypoint_detection/openpose_hands_estimation/module.py

@@ -170,7 +170,11 @@ class HandPoseModel(nn.Layer):
 
         return np.array(all_peaks)
 
-    def predict(self, img: Union[str, np.ndarray], save_path: str = 'openpose_hand', scale: list = [0.5, 1.0, 1.5, 2.0], visualization: bool = True):
+    def predict(self,
+                img: Union[str, np.ndarray],
+                save_path: str = 'openpose_hand',
+                scale: list = [0.5, 1.0, 1.5, 2.0],
+                visualization: bool = True):
         self.eval()
         self.visualization = visualization
         if isinstance(img, str):
@@ -193,7 +197,11 @@ class HandPoseModel(nn.Layer):
             peaks[:, 1] = np.where(peaks[:, 1] == 0, peaks[:, 1], peaks[:, 1] + y)
             all_hand_peaks.append(peaks)
         canvas = copy.deepcopy(org_img)
-        canvas = self.draw_pose(canvas, body_result['candidate'], body_result['subset'],)
+        canvas = self.draw_pose(
+            canvas,
+            body_result['candidate'],
+            body_result['subset'],
+        )
         canvas = self.draw_hand(canvas, all_hand_peaks)
         if self.visualization:
             if not os.path.exists(save_path):
@@ -202,9 +210,7 @@ class HandPoseModel(nn.Layer):
             save_path = os.path.join(save_path, img_name)
             cv2.imwrite(save_path, canvas)
 
-        results = {
-            'all_hand_peaks': all_hand_peaks,
-            'data': canvas}
+        results = {'all_hand_peaks': all_hand_peaks, 'data': canvas}
 
         return results
 
@@ -215,8 +221,8 @@ class HandPoseModel(nn.Layer):
         """
         images_decode = [P.base64_to_cv2(image) for image in images]
         results = self.predict(img=images_decode[0], **kwargs)
-        final={}
-        final['all_hand_peaks']=[peak.tolist() for peak in results['all_hand_peaks']]
+        final = {}
+        final['all_hand_peaks'] = [peak.tolist() for peak in results['all_hand_peaks']]
         final['data'] = P.cv2_to_base64(results['data'])
         return final
 
@@ -230,20 +236,14 @@ class HandPoseModel(nn.Layer):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
         results = self.predict(
-            img=args.input_path,
-            save_path=args.output_dir,
-            scale=args.scale,
-            visualization=args.visualization)
+            img=args.input_path, save_path=args.output_dir, scale=args.scale, visualization=args.visualization)
 
         return results
 
@@ -253,24 +253,14 @@ class HandPoseModel(nn.Layer):
         """
 
         self.arg_config_group.add_argument(
-            '--output_dir',
-            type=str,
-            default='openpose_hand',
-            help="The directory to save output images.")
+            '--output_dir', type=str, default='openpose_hand', help="The directory to save output images.")
         self.arg_config_group.add_argument(
-            '--scale',
-            type=list,
-            default=[0.5, 1.0, 1.5, 2.0],
-            help="The search scale for openpose hands model.")
+            '--scale', type=list, default=[0.5, 1.0, 1.5, 2.0], help="The search scale for openpose hands model.")
         self.arg_config_group.add_argument(
-            '--visualization',
-            type=bool,
-            default=True,
-            help="whether to save output as images.")
+            '--visualization', type=bool, default=True, help="whether to save output as images.")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
\ No newline at end of file

modules/image/keypoint_detection/openpose_hands_estimation/processor.py

@@ -232,6 +232,7 @@ class ResizeScaling:
         resize_img = cv2.resize(img, (0, 0), fx=scale, fy=scale, interpolation=self.interpolation)
         return resize_img
 
+
 def npmax(array: np.ndarray):
     """Get max value and index."""
     arrayindex = array.argmax(1)

modules/image/semantic_segmentation/ExtremeC3_Portrait_Segmentation/module.py

@@ -6,6 +6,7 @@ import numpy as np
 from paddle.nn import Layer
 from paddlehub.module.module import moduleinfo
 
+
 @moduleinfo(
     name="ExtremeC3_Portrait_Segmentation",  # 模型名称
     type="CV/semantic_segmentation",  # 模型类型
@@ -26,7 +27,7 @@ class ExtremeC3_Portrait_Segmentation(Layer):
         self.model.eval()
 
         # 均值方差
-        self.mean = [107.304565, 115.69884, 132.35703 ]
+        self.mean = [107.304565, 115.69884, 132.35703]
         self.std = [63.97182, 65.1337, 68.29726]
 
     # 读取数据函数
@@ -107,20 +108,12 @@ class ExtremeC3_Portrait_Segmentation(Layer):
                 cv2.imwrite(os.path.join(output_dir, 'result_mask_%d.png' % i), mask)
                 cv2.imwrite(os.path.join(output_dir, 'result_%d.png' % i), result)
 
-            results.append({
-                'mask': mask,
-                'result': result
-            })
+            results.append({'mask': mask, 'result': result})
 
         return results
 
     # 关键点检测函数
-    def Segmentation(self,
-                       images=None,
-                       paths=None,
-                       batch_size=1,
-                       output_dir='output',
-                       visualization=False):
+    def Segmentation(self, images=None, paths=None, batch_size=1, output_dir='output', visualization=False):
         # 加载数据处理器
         datas = self.load_datas(paths, images)
 

modules/image/semantic_segmentation/SINet_Portrait_Segmentation/module.py

@@ -6,6 +6,7 @@ import numpy as np
 from paddle.nn import Layer
 from paddlehub.module.module import moduleinfo
 
+
 @moduleinfo(
     name="SINet_Portrait_Segmentation",  # 模型名称
     type="CV/semantic_segmentation",  # 模型类型
@@ -26,7 +27,7 @@ class SINet_Portrait_Segmentation(Layer):
         self.model.eval()
 
         # 均值方差
-        self.mean = [107.304565, 115.69884, 132.35703 ]
+        self.mean = [107.304565, 115.69884, 132.35703]
         self.std = [63.97182, 65.1337, 68.29726]
 
     # 读取数据函数
@@ -107,20 +108,12 @@ class SINet_Portrait_Segmentation(Layer):
                 cv2.imwrite(os.path.join(output_dir, 'result_mask_%d.png' % i), mask)
                 cv2.imwrite(os.path.join(output_dir, 'result_%d.png' % i), result)
 
-            results.append({
-                'mask': mask,
-                'result': result
-            })
+            results.append({'mask': mask, 'result': result})
 
         return results
 
     # 关键点检测函数
-    def Segmentation(self,
-                       images=None,
-                       paths=None,
-                       batch_size=1,
-                       output_dir='output',
-                       visualization=False):
+    def Segmentation(self, images=None, paths=None, batch_size=1, output_dir='output', visualization=False):
         # 加载数据处理器
         datas = self.load_datas(paths, images)
 

modules/image/semantic_segmentation/deeplabv3p_resnet50_voc/layers.py

@@ -30,8 +30,7 @@ def SyncBatchNorm(*args, **kwargs):
 class ConvBNLayer(nn.Layer):
     """Basic conv bn relu layer."""
 
-    def __init__(
-            self,
+    def __init__(self,
                  in_channels: int,
                  out_channels: int,
                  kernel_size: int,
@@ -44,8 +43,7 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2D(
-            kernel_size=2, stride=2, padding=0, ceil_mode=True)
+        self._pool2d_avg = AvgPool2D(kernel_size=2, stride=2, padding=0, ceil_mode=True)
         self._conv = Conv2D(
             in_channels=in_channels,
             out_channels=out_channels,
@@ -83,11 +81,7 @@ class BottleneckBlock(nn.Layer):
         super(BottleneckBlock, self).__init__()
 
         self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=1,
-            act='relu',
-            name=name + "_branch2a")
+            in_channels=in_channels, out_channels=out_channels, kernel_size=1, act='relu', name=name + "_branch2a")
 
         self.dilation = dilation
 
@@ -100,11 +94,7 @@ class BottleneckBlock(nn.Layer):
             dilation=dilation,
             name=name + "_branch2b")
         self.conv2 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels * 4,
-            kernel_size=1,
-            act=None,
-            name=name + "_branch2c")
+            in_channels=out_channels, out_channels=out_channels * 4, kernel_size=1, act=None, name=name + "_branch2c")
 
         if not shortcut:
             self.short = ConvBNLayer(
@@ -139,12 +129,7 @@ class BottleneckBlock(nn.Layer):
 class SeparableConvBNReLU(nn.Layer):
     """Depthwise Separable Convolution."""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(SeparableConvBNReLU, self).__init__()
         self.depthwise_conv = ConvBN(
             in_channels,
@@ -153,8 +138,7 @@ class SeparableConvBNReLU(nn.Layer):
             padding=padding,
             groups=in_channels,
             **kwargs)
-        self.piontwise_conv = ConvBNReLU(
-            in_channels, out_channels, kernel_size=1, groups=1)
+        self.piontwise_conv = ConvBNReLU(in_channels, out_channels, kernel_size=1, groups=1)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
         x = self.depthwise_conv(x)
@@ -165,15 +149,9 @@ class SeparableConvBNReLU(nn.Layer):
 class ConvBN(nn.Layer):
     """Basic conv bn layer"""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(ConvBN, self).__init__()
-        self._conv = Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
+        self._conv = Conv2D(in_channels, out_channels, kernel_size, padding=padding, **kwargs)
         self._batch_norm = SyncBatchNorm(out_channels)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
@@ -185,16 +163,10 @@ class ConvBN(nn.Layer):
 class ConvBNReLU(nn.Layer):
     """Basic conv bn relu layer."""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(ConvBNReLU, self).__init__()
 
-        self._conv = Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
+        self._conv = Conv2D(in_channels, out_channels, kernel_size, padding=padding, **kwargs)
         self._batch_norm = SyncBatchNorm(out_channels)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
@@ -251,8 +223,7 @@ class Activation(nn.Layer):
                 act_name = act_dict[act]
                 self.act_func = eval("activation.{}()".format(act_name))
             else:
-                raise KeyError("{} does not exist in the current {}".format(
-                    act, act_dict.keys()))
+                raise KeyError("{} does not exist in the current {}".format(act, act_dict.keys()))
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
 
@@ -281,7 +252,7 @@ class ASPPModule(nn.Layer):
                  in_channels: int,
                  out_channels: int,
                  align_corners: bool,
-                 use_sep_conv: bool= False,
+                 use_sep_conv: bool = False,
                  image_pooling: bool = False):
         super().__init__()
 
@@ -311,10 +282,7 @@ class ASPPModule(nn.Layer):
             out_size += 1
         self.image_pooling = image_pooling
 
-        self.conv_bn_relu = ConvBNReLU(
-            in_channels=out_channels * out_size,
-            out_channels=out_channels,
-            kernel_size=1)
+        self.conv_bn_relu = ConvBNReLU(in_channels=out_channels * out_size, out_channels=out_channels, kernel_size=1)
 
         self.dropout = nn.Dropout(p=0.1)  # drop rate
 
@@ -322,20 +290,12 @@ class ASPPModule(nn.Layer):
         outputs = []
         for block in self.aspp_blocks:
             y = block(x)
-            y = F.interpolate(
-                y,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
+            y = F.interpolate(y, x.shape[2:], mode='bilinear', align_corners=self.align_corners)
             outputs.append(y)
 
         if self.image_pooling:
             img_avg = self.global_avg_pool(x)
-            img_avg = F.interpolate(
-                img_avg,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
+            img_avg = F.interpolate(img_avg, x.shape[2:], mode='bilinear', align_corners=self.align_corners)
             outputs.append(img_avg)
 
         x = paddle.concat(outputs, axis=1)

modules/image/semantic_segmentation/deeplabv3p_resnet50_voc/module.py

@@ -27,7 +27,6 @@ from deeplabv3p_resnet50_voc.resnet import ResNet50_vd
 import deeplabv3p_resnet50_voc.layers as L
 
 
-
 @moduleinfo(
     name="deeplabv3p_resnet50_voc",
     type="CV/semantic_segmentation",
@@ -72,9 +71,8 @@ class DeepLabV3PResnet50(nn.Layer):
         super(DeepLabV3PResnet50, self).__init__()
         self.backbone = ResNet50_vd()
         backbone_channels = [self.backbone.feat_channels[i] for i in backbone_indices]
-        self.head = DeepLabV3PHead(num_classes, backbone_indices,
-                                   backbone_channels, aspp_ratios,
-                                   aspp_out_channels, align_corners)
+        self.head = DeepLabV3PHead(num_classes, backbone_indices, backbone_channels, aspp_ratios, aspp_out_channels,
+                                   align_corners)
         self.align_corners = align_corners
         self.transforms = T.Compose([T.Normalize()])
 
@@ -96,11 +94,8 @@ class DeepLabV3PResnet50(nn.Layer):
         feat_list = self.backbone(x)
         logit_list = self.head(feat_list)
         return [
-            F.interpolate(
-                logit,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners) for logit in logit_list]
+            F.interpolate(logit, x.shape[2:], mode='bilinear', align_corners=self.align_corners) for logit in logit_list
+        ]
 
 
 class DeepLabV3PHead(nn.Layer):
@@ -123,17 +118,13 @@ class DeepLabV3PHead(nn.Layer):
             is even, e.g. 1024x512, otherwise it is True, e.g. 769x769.
     """
 
-    def __init__(self, num_classes: int, backbone_indices: Tuple[paddle.Tensor], backbone_channels:  Tuple[paddle.Tensor],
-                 aspp_ratios:  Tuple[float], aspp_out_channels: int, align_corners: bool):
+    def __init__(self, num_classes: int, backbone_indices: Tuple[paddle.Tensor],
+                 backbone_channels: Tuple[paddle.Tensor], aspp_ratios: Tuple[float], aspp_out_channels: int,
+                 align_corners: bool):
         super().__init__()
 
         self.aspp = L.ASPPModule(
-            aspp_ratios,
-            backbone_channels[1],
-            aspp_out_channels,
-            align_corners,
-            use_sep_conv=True,
-            image_pooling=True)
+            aspp_ratios, backbone_channels[1], aspp_out_channels, align_corners, use_sep_conv=True, image_pooling=True)
         self.decoder = Decoder(num_classes, backbone_channels[0], align_corners)
         self.backbone_indices = backbone_indices
 
@@ -160,25 +151,17 @@ class Decoder(nn.Layer):
     def __init__(self, num_classes: int, in_channels: int, align_corners: bool):
         super(Decoder, self).__init__()
 
-        self.conv_bn_relu1 = L.ConvBNReLU(
-            in_channels=in_channels, out_channels=48, kernel_size=1)
+        self.conv_bn_relu1 = L.ConvBNReLU(in_channels=in_channels, out_channels=48, kernel_size=1)
 
-        self.conv_bn_relu2 = L.SeparableConvBNReLU(
-            in_channels=304, out_channels=256, kernel_size=3, padding=1)
-        self.conv_bn_relu3 = L.SeparableConvBNReLU(
-            in_channels=256, out_channels=256, kernel_size=3, padding=1)
-        self.conv = nn.Conv2D(
-            in_channels=256, out_channels=num_classes, kernel_size=1)
+        self.conv_bn_relu2 = L.SeparableConvBNReLU(in_channels=304, out_channels=256, kernel_size=3, padding=1)
+        self.conv_bn_relu3 = L.SeparableConvBNReLU(in_channels=256, out_channels=256, kernel_size=3, padding=1)
+        self.conv = nn.Conv2D(in_channels=256, out_channels=num_classes, kernel_size=1)
 
         self.align_corners = align_corners
 
     def forward(self, x: paddle.Tensor, low_level_feat: paddle.Tensor) -> paddle.Tensor:
         low_level_feat = self.conv_bn_relu1(low_level_feat)
-        x = F.interpolate(
-            x,
-            low_level_feat.shape[2:],
-            mode='bilinear',
-            align_corners=self.align_corners)
+        x = F.interpolate(x, low_level_feat.shape[2:], mode='bilinear', align_corners=self.align_corners)
         x = paddle.concat([x, low_level_feat], axis=1)
         x = self.conv_bn_relu2(x)
         x = self.conv_bn_relu3(x)

modules/image/semantic_segmentation/deeplabv3p_resnet50_voc/resnet.py

@@ -36,11 +36,7 @@ class BasicBlock(nn.Layer):
             act='relu',
             name=name + "_branch2a")
         self.conv1 = L.ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            act=None,
-            name=name + "_branch2b")
+            in_channels=out_channels, out_channels=out_channels, kernel_size=3, act=None, name=name + "_branch2b")
 
         if not shortcut:
             self.short = L.ConvBNLayer(
@@ -67,8 +63,7 @@ class BasicBlock(nn.Layer):
 
 
 class ResNet50_vd(nn.Layer):
-    def __init__(self,
-                 multi_grid: tuple = (1, 2, 4)):
+    def __init__(self, multi_grid: tuple = (1, 2, 4)):
         super(ResNet50_vd, self).__init__()
         depth = [3, 4, 6, 3]
         num_channels = [64, 256, 512, 1024]
@@ -76,26 +71,11 @@ class ResNet50_vd(nn.Layer):
         self.feat_channels = [c * 4 for c in num_filters]
         dilation_dict = {2: 2, 3: 4}
         self.conv1_1 = L.ConvBNLayer(
-            in_channels=3,
-            out_channels=32,
-            kernel_size=3,
-            stride=2,
-            act='relu',
-            name="conv1_1")
+            in_channels=3, out_channels=32, kernel_size=3, stride=2, act='relu', name="conv1_1")
         self.conv1_2 = L.ConvBNLayer(
-            in_channels=32,
-            out_channels=32,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv1_2")
+            in_channels=32, out_channels=32, kernel_size=3, stride=1, act='relu', name="conv1_2")
         self.conv1_3 = L.ConvBNLayer(
-            in_channels=32,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv1_3")
+            in_channels=32, out_channels=64, kernel_size=3, stride=1, act='relu', name="conv1_3")
         self.pool2d_max = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
         self.stage_list = []
 
@@ -104,18 +84,15 @@ class ResNet50_vd(nn.Layer):
             block_list = []
             for i in range(depth[block]):
                 conv_name = "res" + str(block + 2) + chr(97 + i)
-                dilation_rate = dilation_dict[
-                    block] if dilation_dict and block in dilation_dict else 1
+                dilation_rate = dilation_dict[block] if dilation_dict and block in dilation_dict else 1
                 if block == 3:
                     dilation_rate = dilation_rate * multi_grid[i]
                 bottleneck_block = self.add_sublayer(
                     'bb_%d_%d' % (block, i),
                     L.BottleneckBlock(
-                        in_channels=num_channels[block]
-                        if i == 0 else num_filters[block] * 4,
+                        in_channels=num_channels[block] if i == 0 else num_filters[block] * 4,
                         out_channels=num_filters[block],
-                        stride=2 if i == 0 and block != 0
-                                    and dilation_rate == 1 else 1,
+                        stride=2 if i == 0 and block != 0 and dilation_rate == 1 else 1,
                         shortcut=shortcut,
                         if_first=block == i == 0,
                         name=conv_name,

modules/image/semantic_segmentation/ocrnet_hrnetw18_voc/hrnet.py

@@ -51,8 +51,8 @@ class HRNet_W18(nn.Layer):
     def __init__(self,
                  pretrained: str = None,
                  stage1_num_modules: int = 1,
-                 stage1_num_blocks: tuple = (4,),
-                 stage1_num_channels: tuple = (64,),
+                 stage1_num_blocks: tuple = (4, ),
+                 stage1_num_channels: tuple = (64, ),
                  stage2_num_modules: int = 1,
                  stage2_num_blocks: tuple = (4, 4),
                  stage2_num_channels: tuple = (18, 36),
@@ -83,20 +83,10 @@ class HRNet_W18(nn.Layer):
         self.feat_channels = [sum(stage4_num_channels)]
 
         self.conv_layer1_1 = L.ConvBNReLU(
-            in_channels=3,
-            out_channels=64,
-            kernel_size=3,
-            stride=2,
-            padding='same',
-            bias_attr=False)
+            in_channels=3, out_channels=64, kernel_size=3, stride=2, padding='same', bias_attr=False)
 
         self.conv_layer1_2 = L.ConvBNReLU(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=2,
-            padding='same',
-            bias_attr=False)
+            in_channels=64, out_channels=64, kernel_size=3, stride=2, padding='same', bias_attr=False)
 
         self.la1 = Layer1(
             num_channels=64,
@@ -106,9 +96,7 @@ class HRNet_W18(nn.Layer):
             name="layer2")
 
         self.tr1 = TransitionLayer(
-            in_channels=[self.stage1_num_channels[0] * 4],
-            out_channels=self.stage2_num_channels,
-            name="tr1")
+            in_channels=[self.stage1_num_channels[0] * 4], out_channels=self.stage2_num_channels, name="tr1")
 
         self.st2 = Stage(
             num_channels=self.stage2_num_channels,
@@ -120,9 +108,7 @@ class HRNet_W18(nn.Layer):
             align_corners=align_corners)
 
         self.tr2 = TransitionLayer(
-            in_channels=self.stage2_num_channels,
-            out_channels=self.stage3_num_channels,
-            name="tr2")
+            in_channels=self.stage2_num_channels, out_channels=self.stage3_num_channels, name="tr2")
         self.st3 = Stage(
             num_channels=self.stage3_num_channels,
             num_modules=self.stage3_num_modules,
@@ -133,9 +119,7 @@ class HRNet_W18(nn.Layer):
             align_corners=align_corners)
 
         self.tr3 = TransitionLayer(
-            in_channels=self.stage3_num_channels,
-            out_channels=self.stage4_num_channels,
-            name="tr3")
+            in_channels=self.stage3_num_channels, out_channels=self.stage4_num_channels, name="tr3")
         self.st4 = Stage(
             num_channels=self.stage4_num_channels,
             num_modules=self.stage4_num_modules,
@@ -161,30 +145,16 @@ class HRNet_W18(nn.Layer):
         st4 = self.st4(tr3)
 
         x0_h, x0_w = st4[0].shape[2:]
-        x1 = F.interpolate(
-            st4[1], (x0_h, x0_w),
-            mode='bilinear',
-            align_corners=self.align_corners)
-        x2 = F.interpolate(
-            st4[2], (x0_h, x0_w),
-            mode='bilinear',
-            align_corners=self.align_corners)
-        x3 = F.interpolate(
-            st4[3], (x0_h, x0_w),
-            mode='bilinear',
-            align_corners=self.align_corners)
+        x1 = F.interpolate(st4[1], (x0_h, x0_w), mode='bilinear', align_corners=self.align_corners)
+        x2 = F.interpolate(st4[2], (x0_h, x0_w), mode='bilinear', align_corners=self.align_corners)
+        x3 = F.interpolate(st4[3], (x0_h, x0_w), mode='bilinear', align_corners=self.align_corners)
         x = paddle.concat([st4[0], x1, x2, x3], axis=1)
 
         return [x]
 
 
 class Layer1(nn.Layer):
-    def __init__(self,
-                 num_channels: int,
-                 num_filters: int,
-                 num_blocks: int,
-                 has_se: bool = False,
-                 name: str = None):
+    def __init__(self, num_channels: int, num_filters: int, num_blocks: int, has_se: bool = False, name: str = None):
         super(Layer1, self).__init__()
 
         self.bottleneck_block_list = []
@@ -253,12 +223,7 @@ class TransitionLayer(nn.Layer):
 
 
 class Branches(nn.Layer):
-    def __init__(self,
-                 num_blocks: int,
-                 in_channels: int,
-                 out_channels: int,
-                 has_se: bool = False,
-                 name: str = None):
+    def __init__(self, num_blocks: int, in_channels: int, out_channels: int, has_se: bool = False, name: str = None):
         super(Branches, self).__init__()
 
         self.basic_block_list = []
@@ -273,8 +238,7 @@ class Branches(nn.Layer):
                         num_channels=in_ch,
                         num_filters=out_channels[i],
                         has_se=has_se,
-                        name=name + '_branch_layer_' + str(i + 1) + '_' +
-                             str(j + 1)))
+                        name=name + '_branch_layer_' + str(i + 1) + '_' + str(j + 1)))
                 self.basic_block_list[i].append(basic_block_func)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
@@ -301,11 +265,7 @@ class BottleneckBlock(nn.Layer):
         self.downsample = downsample
 
         self.conv1 = L.ConvBNReLU(
-            in_channels=num_channels,
-            out_channels=num_filters,
-            kernel_size=1,
-            padding='same',
-            bias_attr=False)
+            in_channels=num_channels, out_channels=num_filters, kernel_size=1, padding='same', bias_attr=False)
 
         self.conv2 = L.ConvBNReLU(
             in_channels=num_filters,
@@ -316,26 +276,15 @@ class BottleneckBlock(nn.Layer):
             bias_attr=False)
 
         self.conv3 = L.ConvBN(
-            in_channels=num_filters,
-            out_channels=num_filters * 4,
-            kernel_size=1,
-            padding='same',
-            bias_attr=False)
+            in_channels=num_filters, out_channels=num_filters * 4, kernel_size=1, padding='same', bias_attr=False)
 
         if self.downsample:
             self.conv_down = L.ConvBN(
-                in_channels=num_channels,
-                out_channels=num_filters * 4,
-                kernel_size=1,
-                padding='same',
-                bias_attr=False)
+                in_channels=num_channels, out_channels=num_filters * 4, kernel_size=1, padding='same', bias_attr=False)
 
         if self.has_se:
             self.se = SELayer(
-                num_channels=num_filters * 4,
-                num_filters=num_filters * 4,
-                reduction_ratio=16,
-                name=name + '_fc')
+                num_channels=num_filters * 4, num_filters=num_filters * 4, reduction_ratio=16, name=name + '_fc')
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
         residual = x
@@ -375,26 +324,14 @@ class BasicBlock(nn.Layer):
             padding='same',
             bias_attr=False)
         self.conv2 = L.ConvBN(
-            in_channels=num_filters,
-            out_channels=num_filters,
-            kernel_size=3,
-            padding='same',
-            bias_attr=False)
+            in_channels=num_filters, out_channels=num_filters, kernel_size=3, padding='same', bias_attr=False)
 
         if self.downsample:
             self.conv_down = L.ConvBNReLU(
-                in_channels=num_channels,
-                out_channels=num_filters,
-                kernel_size=1,
-                padding='same',
-                bias_attr=False)
+                in_channels=num_channels, out_channels=num_filters, kernel_size=1, padding='same', bias_attr=False)
 
         if self.has_se:
-            self.se = SELayer(
-                num_channels=num_filters,
-                num_filters=num_filters,
-                reduction_ratio=16,
-                name=name + '_fc')
+            self.se = SELayer(num_channels=num_filters, num_filters=num_filters, reduction_ratio=16, name=name + '_fc')
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
         residual = x
@@ -423,17 +360,11 @@ class SELayer(nn.Layer):
         med_ch = int(num_channels / reduction_ratio)
         stdv = 1.0 / math.sqrt(num_channels * 1.0)
         self.squeeze = nn.Linear(
-            num_channels,
-            med_ch,
-            weight_attr=paddle.ParamAttr(
-                initializer=nn.initializer.Uniform(-stdv, stdv)))
+            num_channels, med_ch, weight_attr=paddle.ParamAttr(initializer=nn.initializer.Uniform(-stdv, stdv)))
 
         stdv = 1.0 / math.sqrt(med_ch * 1.0)
         self.excitation = nn.Linear(
-            med_ch,
-            num_filters,
-            weight_attr=paddle.ParamAttr(
-                initializer=nn.initializer.Uniform(-stdv, stdv)))
+            med_ch, num_filters, weight_attr=paddle.ParamAttr(initializer=nn.initializer.Uniform(-stdv, stdv)))
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
         pool = self.pool2d_gap(x)
@@ -442,8 +373,7 @@ class SELayer(nn.Layer):
         squeeze = F.relu(squeeze)
         excitation = self.excitation(squeeze)
         excitation = F.sigmoid(excitation)
-        excitation = paddle.reshape(
-            excitation, shape=[-1, self._num_channels, 1, 1])
+        excitation = paddle.reshape(excitation, shape=[-1, self._num_channels, 1, 1])
         out = x * excitation
         return out
 
@@ -507,11 +437,7 @@ class HighResolutionModule(nn.Layer):
         super(HighResolutionModule, self).__init__()
 
         self.branches_func = Branches(
-            num_blocks=num_blocks,
-            in_channels=num_channels,
-            out_channels=num_filters,
-            has_se=has_se,
-            name=name)
+            num_blocks=num_blocks, in_channels=num_channels, out_channels=num_filters, has_se=has_se, name=name)
 
         self.fuse_func = FuseLayers(
             in_channels=num_filters,
@@ -557,8 +483,7 @@ class FuseLayers(nn.Layer):
                     for k in range(i - j):
                         if k == i - j - 1:
                             residual_func = self.add_sublayer(
-                                "residual_{}_layer_{}_{}_{}".format(
-                                    name, i + 1, j + 1, k + 1),
+                                "residual_{}_layer_{}_{}_{}".format(name, i + 1, j + 1, k + 1),
                                 L.ConvBN(
                                     in_channels=pre_num_filters,
                                     out_channels=out_channels[i],
@@ -569,8 +494,7 @@ class FuseLayers(nn.Layer):
                             pre_num_filters = out_channels[i]
                         else:
                             residual_func = self.add_sublayer(
-                                "residual_{}_layer_{}_{}_{}".format(
-                                    name, i + 1, j + 1, k + 1),
+                                "residual_{}_layer_{}_{}_{}".format(name, i + 1, j + 1, k + 1),
                                 L.ConvBNReLU(
                                     in_channels=pre_num_filters,
                                     out_channels=out_channels[j],
@@ -592,11 +516,7 @@ class FuseLayers(nn.Layer):
                     y = self.residual_func_list[residual_func_idx](x[j])
                     residual_func_idx += 1
 
-                    y = F.interpolate(
-                        y,
-                        residual_shape,
-                        mode='bilinear',
-                        align_corners=self.align_corners)
+                    y = F.interpolate(y, residual_shape, mode='bilinear', align_corners=self.align_corners)
                     residual = residual + y
                 elif j < i:
                     y = x[j]

modules/image/semantic_segmentation/ocrnet_hrnetw18_voc/layers.py

@@ -30,8 +30,7 @@ def SyncBatchNorm(*args, **kwargs):
 class ConvBNLayer(nn.Layer):
     """Basic conv bn relu layer."""
 
-    def __init__(
-            self,
+    def __init__(self,
                  in_channels: int,
                  out_channels: int,
                  kernel_size: int,
@@ -44,8 +43,7 @@ class ConvBNLayer(nn.Layer):
         super(ConvBNLayer, self).__init__()
 
         self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = AvgPool2D(
-            kernel_size=2, stride=2, padding=0, ceil_mode=True)
+        self._pool2d_avg = AvgPool2D(kernel_size=2, stride=2, padding=0, ceil_mode=True)
         self._conv = Conv2D(
             in_channels=in_channels,
             out_channels=out_channels,
@@ -83,11 +81,7 @@ class BottleneckBlock(nn.Layer):
         super(BottleneckBlock, self).__init__()
 
         self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=1,
-            act='relu',
-            name=name + "_branch2a")
+            in_channels=in_channels, out_channels=out_channels, kernel_size=1, act='relu', name=name + "_branch2a")
 
         self.dilation = dilation
 
@@ -100,11 +94,7 @@ class BottleneckBlock(nn.Layer):
             dilation=dilation,
             name=name + "_branch2b")
         self.conv2 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels * 4,
-            kernel_size=1,
-            act=None,
-            name=name + "_branch2c")
+            in_channels=out_channels, out_channels=out_channels * 4, kernel_size=1, act=None, name=name + "_branch2c")
 
         if not shortcut:
             self.short = ConvBNLayer(
@@ -139,12 +129,7 @@ class BottleneckBlock(nn.Layer):
 class SeparableConvBNReLU(nn.Layer):
     """Depthwise Separable Convolution."""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(SeparableConvBNReLU, self).__init__()
         self.depthwise_conv = ConvBN(
             in_channels,
@@ -153,8 +138,7 @@ class SeparableConvBNReLU(nn.Layer):
             padding=padding,
             groups=in_channels,
             **kwargs)
-        self.piontwise_conv = ConvBNReLU(
-            in_channels, out_channels, kernel_size=1, groups=1)
+        self.piontwise_conv = ConvBNReLU(in_channels, out_channels, kernel_size=1, groups=1)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
         x = self.depthwise_conv(x)
@@ -165,15 +149,9 @@ class SeparableConvBNReLU(nn.Layer):
 class ConvBN(nn.Layer):
     """Basic conv bn layer"""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(ConvBN, self).__init__()
-        self._conv = Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
+        self._conv = Conv2D(in_channels, out_channels, kernel_size, padding=padding, **kwargs)
         self._batch_norm = SyncBatchNorm(out_channels)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
@@ -185,16 +163,10 @@ class ConvBN(nn.Layer):
 class ConvBNReLU(nn.Layer):
     """Basic conv bn relu layer."""
 
-    def __init__(self,
-                 in_channels: int,
-                 out_channels: int,
-                 kernel_size: int,
-                 padding: str = 'same',
-                 **kwargs: dict):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, padding: str = 'same', **kwargs: dict):
         super(ConvBNReLU, self).__init__()
 
-        self._conv = Conv2D(
-            in_channels, out_channels, kernel_size, padding=padding, **kwargs)
+        self._conv = Conv2D(in_channels, out_channels, kernel_size, padding=padding, **kwargs)
         self._batch_norm = SyncBatchNorm(out_channels)
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
@@ -251,8 +223,7 @@ class Activation(nn.Layer):
                 act_name = act_dict[act]
                 self.act_func = eval("activation.{}()".format(act_name))
             else:
-                raise KeyError("{} does not exist in the current {}".format(
-                    act, act_dict.keys()))
+                raise KeyError("{} does not exist in the current {}".format(act, act_dict.keys()))
 
     def forward(self, x: paddle.Tensor) -> paddle.Tensor:
 
@@ -276,13 +247,7 @@ class ASPPModule(nn.Layer):
         image_pooling (bool, optional): If augmented with image-level features. Default: False
     """
 
-    def __init__(self,
-                 aspp_ratios,
-                 in_channels,
-                 out_channels,
-                 align_corners,
-                 use_sep_conv=False,
-                 image_pooling=False):
+    def __init__(self, aspp_ratios, in_channels, out_channels, align_corners, use_sep_conv=False, image_pooling=False):
         super().__init__()
 
         self.align_corners = align_corners
@@ -311,10 +276,7 @@ class ASPPModule(nn.Layer):
             out_size += 1
         self.image_pooling = image_pooling
 
-        self.conv_bn_relu = ConvBNReLU(
-            in_channels=out_channels * out_size,
-            out_channels=out_channels,
-            kernel_size=1)
+        self.conv_bn_relu = ConvBNReLU(in_channels=out_channels * out_size, out_channels=out_channels, kernel_size=1)
 
         self.dropout = nn.Dropout(p=0.1)  # drop rate
 
@@ -322,20 +284,12 @@ class ASPPModule(nn.Layer):
         outputs = []
         for block in self.aspp_blocks:
             y = block(x)
-            y = F.interpolate(
-                y,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
+            y = F.interpolate(y, x.shape[2:], mode='bilinear', align_corners=self.align_corners)
             outputs.append(y)
 
         if self.image_pooling:
             img_avg = self.global_avg_pool(x)
-            img_avg = F.interpolate(
-                img_avg,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners)
+            img_avg = F.interpolate(img_avg, x.shape[2:], mode='bilinear', align_corners=self.align_corners)
             outputs.append(img_avg)
 
         x = paddle.concat(outputs, axis=1)

modules/image/semantic_segmentation/ocrnet_hrnetw18_voc/module.py

@@ -25,6 +25,7 @@ from paddlehub.module.cv_module import ImageSegmentationModule
 import ocrnet_hrnetw18_voc.layers as L
 from ocrnet_hrnetw18_voc.hrnet import HRNet_W18
 
+
 @moduleinfo(
     name="ocrnet_hrnetw18_voc",
     type="CV/semantic_segmentation",
@@ -90,11 +91,8 @@ class OCRNetHRNetW18(nn.Layer):
         feats = [feats[i] for i in self.backbone_indices]
         logit_list = self.head(feats)
         logit_list = [
-            F.interpolate(
-                logit,
-                x.shape[2:],
-                mode='bilinear',
-                align_corners=self.align_corners) for logit in logit_list]
+            F.interpolate(logit, x.shape[2:], mode='bilinear', align_corners=self.align_corners) for logit in logit_list
+        ]
         return logit_list
 
 
@@ -108,32 +106,23 @@ class OCRHead(nn.Layer):
         ocr_key_channels(int, optional): The number of key channels in ObjectAttentionBlock. Default: 256.
     """
 
-    def __init__(self,
-                 num_classes: int,
-                 in_channels: int,
-                 ocr_mid_channels: int = 512,
-                 ocr_key_channels: int = 256):
+    def __init__(self, num_classes: int, in_channels: int, ocr_mid_channels: int = 512, ocr_key_channels: int = 256):
         super().__init__()
 
         self.num_classes = num_classes
         self.spatial_gather = SpatialGatherBlock()
-        self.spatial_ocr = SpatialOCRModule(ocr_mid_channels, ocr_key_channels,
-                                            ocr_mid_channels)
+        self.spatial_ocr = SpatialOCRModule(ocr_mid_channels, ocr_key_channels, ocr_mid_channels)
 
         self.indices = [-2, -1] if len(in_channels) > 1 else [-1, -1]
 
-        self.conv3x3_ocr = L.ConvBNReLU(
-            in_channels[self.indices[1]], ocr_mid_channels, 3, padding=1)
+        self.conv3x3_ocr = L.ConvBNReLU(in_channels[self.indices[1]], ocr_mid_channels, 3, padding=1)
         self.cls_head = nn.Conv2D(ocr_mid_channels, self.num_classes, 1)
         self.aux_head = nn.Sequential(
-            L.ConvBNReLU(in_channels[self.indices[0]],
-                              in_channels[self.indices[0]], 1),
+            L.ConvBNReLU(in_channels[self.indices[0]], in_channels[self.indices[0]], 1),
             nn.Conv2D(in_channels[self.indices[0]], self.num_classes, 1))
 
-
     def forward(self, feat_list: List[paddle.Tensor]) -> paddle.Tensor:
-        feat_shallow, feat_deep = feat_list[self.indices[0]], feat_list[
-            self.indices[1]]
+        feat_shallow, feat_deep = feat_list[self.indices[0]], feat_list[self.indices[1]]
 
         soft_regions = self.aux_head(feat_shallow)
         pixels = self.conv3x3_ocr(feat_deep)
@@ -171,17 +160,11 @@ class SpatialGatherBlock(nn.Layer):
 class SpatialOCRModule(nn.Layer):
     """Aggregate the global object representation to update the representation for each pixel."""
 
-    def __init__(self,
-                 in_channels: int,
-                 key_channels: int,
-                 out_channels: int,
-                 dropout_rate: float = 0.1):
+    def __init__(self, in_channels: int, key_channels: int, out_channels: int, dropout_rate: float = 0.1):
         super().__init__()
 
         self.attention_block = ObjectAttentionBlock(in_channels, key_channels)
-        self.conv1x1 = nn.Sequential(
-            L.ConvBNReLU(2 * in_channels, out_channels, 1),
-            nn.Dropout2D(dropout_rate))
+        self.conv1x1 = nn.Sequential(L.ConvBNReLU(2 * in_channels, out_channels, 1), nn.Dropout2D(dropout_rate))
 
     def forward(self, pixels: paddle.Tensor, regions: paddle.Tensor) -> paddle.Tensor:
         context = self.attention_block(pixels, regions)
@@ -201,12 +184,10 @@ class ObjectAttentionBlock(nn.Layer):
         self.key_channels = key_channels
 
         self.f_pixel = nn.Sequential(
-            L.ConvBNReLU(in_channels, key_channels, 1),
-            L.ConvBNReLU(key_channels, key_channels, 1))
+            L.ConvBNReLU(in_channels, key_channels, 1), L.ConvBNReLU(key_channels, key_channels, 1))
 
         self.f_object = nn.Sequential(
-            L.ConvBNReLU(in_channels, key_channels, 1),
-            L.ConvBNReLU(key_channels, key_channels, 1))
+            L.ConvBNReLU(in_channels, key_channels, 1), L.ConvBNReLU(key_channels, key_channels, 1))
 
         self.f_down = L.ConvBNReLU(in_channels, key_channels, 1)
 

modules/text/language_model/bert-base-cased/module.py

@@ -60,29 +60,27 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = BertForSequenceClassification.from_pretrained(pretrained_model_name_or_path='bert-base-cased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-base-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = BertForTokenClassification.from_pretrained(pretrained_model_name_or_path='bert-base-cased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-base-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-cased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-cased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -130,8 +128,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -173,5 +170,4 @@ class Bert(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-base-cased', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-base-cased', *args, **kwargs)

modules/text/language_model/bert-base-chinese/module.py

@@ -60,37 +60,27 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = BertForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = BertForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-chinese', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-chinese', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class Bert(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-base-chinese', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-base-chinese', *args, **kwargs)

modules/text/language_model/bert-base-multilingual-cased/module.py

@@ -60,37 +60,29 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = BertForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-multilingual-cased',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-multilingual-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = BertForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-multilingual-cased',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-multilingual-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
-            self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-multilingual-cased', **kwargs)
+            self.model = BertModel.from_pretrained(
+                pretrained_model_name_or_path='bert-base-multilingual-cased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
-            self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-multilingual-cased', **kwargs)
+            self.model = BertModel.from_pretrained(
+                pretrained_model_name_or_path='bert-base-multilingual-cased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +130,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs

modules/text/language_model/bert-base-multilingual-uncased/module.py

@@ -60,37 +60,29 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = BertForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-multilingual-uncased',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-multilingual-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = BertForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-base-multilingual-uncased',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-base-multilingual-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
-            self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-multilingual-uncased', **kwargs)
+            self.model = BertModel.from_pretrained(
+                pretrained_model_name_or_path='bert-base-multilingual-uncased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
-            self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-multilingual-uncased', **kwargs)
+            self.model = BertModel.from_pretrained(
+                pretrained_model_name_or_path='bert-base-multilingual-uncased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +130,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs

modules/text/language_model/bert-base-uncased/module.py

@@ -60,29 +60,27 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = BertForSequenceClassification.from_pretrained(pretrained_model_name_or_path='bert-base-uncased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-base-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = BertForTokenClassification.from_pretrained(pretrained_model_name_or_path='bert-base-uncased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-base-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-uncased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-base-uncased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -130,8 +128,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -173,5 +170,4 @@ class Bert(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-base-uncased', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-base-uncased', *args, **kwargs)

modules/text/language_model/bert-large-cased/module.py

@@ -60,29 +60,27 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = BertForSequenceClassification.from_pretrained(pretrained_model_name_or_path='bert-large-cased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-large-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = BertForTokenClassification.from_pretrained(pretrained_model_name_or_path='bert-large-cased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-large-cased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-large-cased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-large-cased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -130,8 +128,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -173,5 +170,4 @@ class Bert(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-large-cased', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-large-cased', *args, **kwargs)

modules/text/language_model/bert-large-uncased/module.py

@@ -60,29 +60,27 @@ class Bert(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = BertForSequenceClassification.from_pretrained(pretrained_model_name_or_path='bert-large-uncased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-large-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = BertForTokenClassification.from_pretrained(pretrained_model_name_or_path='bert-large-uncased', num_classes=self.num_classes, **kwargs)
+            self.model = BertForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='bert-large-uncased', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-large-uncased', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-large-uncased', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -130,8 +128,7 @@ class Bert(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -173,5 +170,4 @@ class Bert(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-large-uncased', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-large-uncased', *args, **kwargs)

modules/text/language_model/chinese_bert_wwm/module.py

@@ -35,8 +35,7 @@ from paddlehub.utils.log import logger
     author="ymcui",
     author_email="ymcui@ir.hit.edu.cn",
     type="nlp/semantic_model",
-    meta=TransformerModule
-)
+    meta=TransformerModule)
 class BertWwm(nn.Layer):
     """
     BertWwm model
@@ -61,37 +60,27 @@ class BertWwm(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = BertForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-wwm-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-wwm-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = BertForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-wwm-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-wwm-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-wwm-chinese', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-wwm-chinese', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -139,8 +128,7 @@ class BertWwm(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -182,5 +170,4 @@ class BertWwm(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-wwm-chinese', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-wwm-chinese', *args, **kwargs)

modules/text/language_model/chinese_bert_wwm_ext/module.py

@@ -35,8 +35,7 @@ from paddlehub.utils.log import logger
     author="ymcui",
     author_email="ymcui@ir.hit.edu.cn",
     type="nlp/semantic_model",
-    meta=TransformerModule
-)
+    meta=TransformerModule)
 class BertWwm(nn.Layer):
     """
     BertWwm model
@@ -61,37 +60,27 @@ class BertWwm(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = BertForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-wwm-ext-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-wwm-ext-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = BertForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='bert-wwm-ext-chinese',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='bert-wwm-ext-chinese', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-wwm-ext-chinese', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = BertModel.from_pretrained(pretrained_model_name_or_path='bert-wwm-ext-chinese', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -139,8 +128,7 @@ class BertWwm(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -182,5 +170,4 @@ class BertWwm(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return BertTokenizer.from_pretrained(
-            pretrained_model_name_or_path='bert-wwm-ext-chinese', *args, **kwargs)
+        return BertTokenizer.from_pretrained(pretrained_model_name_or_path='bert-wwm-ext-chinese', *args, **kwargs)

modules/text/language_model/chinese_electra_base/module.py

@@ -60,37 +60,27 @@ class Electra(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ElectraForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='chinese-electra-base',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='chinese-electra-base', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ElectraForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='chinese-electra-base',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='chinese-electra-base', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='chinese-electra-base', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='chinese-electra-base', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class Electra(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class Electra(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ElectraTokenizer.from_pretrained(
-            pretrained_model_name_or_path='chinese-electra-base', *args, **kwargs)
+        return ElectraTokenizer.from_pretrained(pretrained_model_name_or_path='chinese-electra-base', *args, **kwargs)

modules/text/language_model/chinese_electra_small/module.py

@@ -60,37 +60,27 @@ class Electra(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ElectraForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='chinese-electra-small',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='chinese-electra-small', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ElectraForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='chinese-electra-small',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='chinese-electra-small', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='chinese-electra-small', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='chinese-electra-small', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class Electra(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class Electra(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ElectraTokenizer.from_pretrained(
-            pretrained_model_name_or_path='chinese-electra-small', *args, **kwargs)
+        return ElectraTokenizer.from_pretrained(pretrained_model_name_or_path='chinese-electra-small', *args, **kwargs)

modules/text/language_model/electra_base/module.py

@@ -29,8 +29,7 @@ from paddlehub.utils.log import logger
 @moduleinfo(
     name="electra-base",
     version="1.0.1",
-    summary=
-    "electra-base, 12-layer, 768-hidden, 12-heads, 110M parameters. The module is executed as paddle.dygraph.",
+    summary="electra-base, 12-layer, 768-hidden, 12-heads, 110M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
     type="nlp/semantic_model",
@@ -60,37 +59,27 @@ class Electra(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ElectraForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-base',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-base', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ElectraForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-base',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-base', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-base', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-base', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +127,7 @@ class Electra(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +169,4 @@ class Electra(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ElectraTokenizer.from_pretrained(
-            pretrained_model_name_or_path='electra-base', *args, **kwargs)
+        return ElectraTokenizer.from_pretrained(pretrained_model_name_or_path='electra-base', *args, **kwargs)

modules/text/language_model/electra_large/module.py

@@ -29,8 +29,7 @@ from paddlehub.utils.log import logger
 @moduleinfo(
     name="electra-large",
     version="1.0.1",
-    summary=
-    "electra-large, 24-layer, 1024-hidden, 16-heads, 335M parameters. The module is executed as paddle.dygraph.",
+    summary="electra-large, 24-layer, 1024-hidden, 16-heads, 335M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
     type="nlp/semantic_model",
@@ -60,37 +59,27 @@ class Electra(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ElectraForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-large',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-large', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ElectraForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-large',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-large', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-large', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-large', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +127,7 @@ class Electra(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +169,4 @@ class Electra(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ElectraTokenizer.from_pretrained(
-            pretrained_model_name_or_path='electra-large', *args, **kwargs)
+        return ElectraTokenizer.from_pretrained(pretrained_model_name_or_path='electra-large', *args, **kwargs)

modules/text/language_model/electra_small/module.py

@@ -29,8 +29,7 @@ from paddlehub.utils.log import logger
 @moduleinfo(
     name="electra-small",
     version="1.0.1",
-    summary=
-    "electra-small, 12-layer, 256-hidden, 4-heads, 14M parameters. The module is executed as paddle.dygraph.",
+    summary="electra-small, 12-layer, 256-hidden, 4-heads, 14M parameters. The module is executed as paddle.dygraph.",
     author="paddlepaddle",
     author_email="",
     type="nlp/semantic_model",
@@ -60,37 +59,27 @@ class Electra(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ElectraForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-small',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-small', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ElectraForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='electra-small',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='electra-small', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-small', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ElectraModel.from_pretrained(pretrained_model_name_or_path='electra-small', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +127,7 @@ class Electra(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +169,4 @@ class Electra(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ElectraTokenizer.from_pretrained(
-            pretrained_model_name_or_path='electra-small', *args, **kwargs)
+        return ElectraTokenizer.from_pretrained(pretrained_model_name_or_path='electra-small', *args, **kwargs)

modules/text/language_model/ernie/module.py

@@ -60,29 +60,27 @@ class Ernie(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = ErnieForSequenceClassification.from_pretrained(pretrained_model_name_or_path='ernie-1.0', num_classes=self.num_classes, **kwargs)
+            self.model = ErnieForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='ernie-1.0', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = ErnieForTokenClassification.from_pretrained(pretrained_model_name_or_path='ernie-1.0', num_classes=self.num_classes, **kwargs)
+            self.model = ErnieForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='ernie-1.0', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-1.0', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-1.0', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -130,8 +128,7 @@ class Ernie(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -173,5 +170,4 @@ class Ernie(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ErnieTokenizer.from_pretrained(
-            pretrained_model_name_or_path='ernie-1.0', *args, **kwargs)
+        return ErnieTokenizer.from_pretrained(pretrained_model_name_or_path='ernie-1.0', *args, **kwargs)

modules/text/language_model/ernie_tiny/module.py

@@ -59,29 +59,27 @@ class ErnieTiny(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
-            self.model = ErnieForSequenceClassification.from_pretrained(pretrained_model_name_or_path='ernie-tiny', num_classes=self.num_classes, **kwargs)
+            self.model = ErnieForSequenceClassification.from_pretrained(
+                pretrained_model_name_or_path='ernie-tiny', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
-            self.model = ErnieForTokenClassification.from_pretrained(pretrained_model_name_or_path='ernie-tiny', num_classes=self.num_classes, **kwargs)
+            self.model = ErnieForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path='ernie-tiny', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-tiny', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-tiny', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -129,8 +127,7 @@ class ErnieTiny(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -172,5 +169,4 @@ class ErnieTiny(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ErnieTinyTokenizer.from_pretrained(
-            pretrained_model_name_or_path='ernie-tiny', *args, **kwargs)
+        return ErnieTinyTokenizer.from_pretrained(pretrained_model_name_or_path='ernie-tiny', *args, **kwargs)

modules/text/language_model/ernie_v2_eng_base/module.py

@@ -60,37 +60,27 @@ class ErnieV2(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ErnieForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='ernie-2.0-en',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='ernie-2.0-en', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ErnieForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='ernie-2.0-en',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='ernie-2.0-en', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-2.0-en', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-2.0-en', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class ErnieV2(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class ErnieV2(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ErnieTokenizer.from_pretrained(
-            pretrained_model_name_or_path='ernie-2.0-en', *args, **kwargs)
+        return ErnieTokenizer.from_pretrained(pretrained_model_name_or_path='ernie-2.0-en', *args, **kwargs)
\ No newline at end of file

modules/text/language_model/ernie_v2_eng_large/module.py

@@ -60,37 +60,27 @@ class ErnieV2(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = ErnieForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='ernie-2.0-large-en',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='ernie-2.0-large-en', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = ErnieForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='ernie-2.0-large-en',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='ernie-2.0-large-en', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-2.0-large-en', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = ErnieModel.from_pretrained(pretrained_model_name_or_path='ernie-2.0-large-en', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class ErnieV2(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class ErnieV2(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return ErnieTokenizer.from_pretrained(
-            pretrained_model_name_or_path='ernie-2.0-large-en', *args, **kwargs)
+        return ErnieTokenizer.from_pretrained(pretrained_model_name_or_path='ernie-2.0-large-en', *args, **kwargs)

modules/text/language_model/rbt3/module.py

@@ -60,37 +60,27 @@ class Roberta(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = RobertaForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='rbt3',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='rbt3', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = RobertaForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='rbt3',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='rbt3', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='rbt3', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='rbt3', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class Roberta(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class Roberta(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return RobertaTokenizer.from_pretrained(
-            pretrained_model_name_or_path='rbt3', *args, **kwargs)
+        return RobertaTokenizer.from_pretrained(pretrained_model_name_or_path='rbt3', *args, **kwargs)

modules/text/language_model/rbtl3/module.py

@@ -60,37 +60,27 @@ class Roberta(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = RobertaForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='rbtl3',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='rbtl3', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = RobertaForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='rbtl3',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='rbtl3', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='rbtl3', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='rbtl3', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -138,8 +128,7 @@ class Roberta(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -181,5 +170,4 @@ class Roberta(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return RobertaTokenizer.from_pretrained(
-            pretrained_model_name_or_path='rbtl3', *args, **kwargs)
+        return RobertaTokenizer.from_pretrained(pretrained_model_name_or_path='rbtl3', *args, **kwargs)

modules/text/language_model/roberta-wwm-ext-large/module.py

@@ -61,37 +61,27 @@ class Roberta(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = RobertaForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='roberta-wwm-ext-large',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='roberta-wwm-ext-large', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = RobertaForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='roberta-wwm-ext-large',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='roberta-wwm-ext-large', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext-large', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext-large', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -139,8 +129,7 @@ class Roberta(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -182,5 +171,4 @@ class Roberta(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return RobertaTokenizer.from_pretrained(
-            pretrained_model_name_or_path='roberta-wwm-ext-large', *args, **kwargs)
+        return RobertaTokenizer.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext-large', *args, **kwargs)

modules/text/language_model/roberta-wwm-ext/module.py

@@ -61,37 +61,27 @@ class Roberta(nn.Layer):
             task = 'seq-cls'
             logger.warning(
                 "current task name 'sequence_classification' was renamed to 'seq-cls', "
-                "'sequence_classification' has been deprecated and will be removed in the future.",
-            )
+                "'sequence_classification' has been deprecated and will be removed in the future.", )
         if task == 'seq-cls':
             self.model = RobertaForSequenceClassification.from_pretrained(
-                pretrained_model_name_or_path='roberta-wwm-ext',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='roberta-wwm-ext', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task == 'token-cls':
             self.model = RobertaForTokenClassification.from_pretrained(
-                pretrained_model_name_or_path='roberta-wwm-ext',
-                num_classes=self.num_classes,
-                **kwargs
-            )
+                pretrained_model_name_or_path='roberta-wwm-ext', num_classes=self.num_classes, **kwargs)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
-            self.metric = ChunkEvaluator(
-                label_list=[self.label_map[i] for i in sorted(self.label_map.keys())]
-            )
+            self.metric = ChunkEvaluator(label_list=[self.label_map[i] for i in sorted(self.label_map.keys())])
         elif task == 'text-matching':
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext', **kwargs)
             self.dropout = paddle.nn.Dropout(0.1)
-            self.classifier = paddle.nn.Linear(self.model.config['hidden_size']*3, 2)
+            self.classifier = paddle.nn.Linear(self.model.config['hidden_size'] * 3, 2)
             self.criterion = paddle.nn.loss.CrossEntropyLoss()
             self.metric = paddle.metric.Accuracy()
         elif task is None:
             self.model = RobertaModel.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext', **kwargs)
         else:
-            raise RuntimeError("Unknown task {}, task should be one in {}".format(
-                task, self._tasks_supported))
+            raise RuntimeError("Unknown task {}, task should be one in {}".format(task, self._tasks_supported))
 
         self.task = task
 
@@ -139,8 +129,7 @@ class Roberta(nn.Layer):
                 loss = self.criterion(logits, labels.unsqueeze(-1))
                 num_infer_chunks, num_label_chunks, num_correct_chunks = \
                     self.metric.compute(None, seq_lengths, preds, labels)
-                self.metric.update(
-                    num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
+                self.metric.update(num_infer_chunks.numpy(), num_label_chunks.numpy(), num_correct_chunks.numpy())
                 _, _, f1_score = map(float, self.metric.accumulate())
                 return token_level_probs, loss, {'f1_score': f1_score}
             return token_level_probs
@@ -182,5 +171,4 @@ class Roberta(nn.Layer):
         """
         Gets the tokenizer that is customized for this module.
         """
-        return RobertaTokenizer.from_pretrained(
-            pretrained_model_name_or_path='roberta-wwm-ext', *args, **kwargs)
+        return RobertaTokenizer.from_pretrained(pretrained_model_name_or_path='roberta-wwm-ext', *args, **kwargs)

modules/text/language_model/simnet_bow/module.py

@@ -29,7 +29,8 @@ class DataFormatError(Exception):
         self.args = args
 
 
-@moduleinfo(name="simnet_bow",
+@moduleinfo(
+    name="simnet_bow",
     version="1.2.0",
     summary="Baidu's open-source similarity network model based on bow_pairwise.",
     author="baidu-nlp",
@@ -106,11 +107,11 @@ class SimnetBow(hub.Module):
             seq_len_used = fluid.layers.squeeze(seq_len, axes=[1])
 
             # Add embedding layer.
-            w_param_attrs = fluid.ParamAttr(name="emb",
-                                            initializer=fluid.initializer.TruncatedNormal(scale=0.02),
-                                            trainable=trainable)
+            w_param_attrs = fluid.ParamAttr(
+                name="emb", initializer=fluid.initializer.TruncatedNormal(scale=0.02), trainable=trainable)
             dict_dim = 500002
-            emb_1 = fluid.layers.embedding(input=text_1,
+            emb_1 = fluid.layers.embedding(
+                input=text_1,
                 size=[dict_dim, 128],
                 is_sparse=True,
                 padding_idx=dict_dim - 1,
@@ -122,7 +123,8 @@ class SimnetBow(hub.Module):
 
             if num_slots > 1:
                 text_2 = fluid.data(name='text_2', shape=[-1, max_seq_len], dtype='int64', lod_level=0)
-                emb_2 = fluid.embedding(input=text_2,
+                emb_2 = fluid.embedding(
+                    input=text_2,
                     size=[dict_dim, 128],
                     is_sparse=True,
                     padding_idx=dict_dim - 1,
@@ -134,7 +136,8 @@ class SimnetBow(hub.Module):
 
             if num_slots > 2:
                 text_3 = fluid.data(name='text_3', shape=[-1, max_seq_len], dtype='int64', lod_level=0)
-                emb_3 = fluid.embedding(input=text_3,
+                emb_3 = fluid.embedding(
+                    input=text_3,
                     size=[dict_dim, 128],
                     is_sparse=True,
                     padding_idx=dict_dim - 1,
@@ -295,10 +298,8 @@ class SimnetBow(hub.Module):
         """
         Run as a command
         """
-        self.parser = argparse.ArgumentParser(description="Run the simnet_bow module.",
-                                              prog='hub run simnet_bow',
-                                              usage='%(prog)s',
-                                              add_help=True)
+        self.parser = argparse.ArgumentParser(
+            description="Run the simnet_bow module.", prog='hub run simnet_bow', usage='%(prog)s', add_help=True)
 
         self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
@@ -323,10 +324,8 @@ class SimnetBow(hub.Module):
         """
         Add the command config options
         """
-        self.arg_config_group.add_argument('--use_gpu',
-                                           type=ast.literal_eval,
-                                           default=False,
-                                           help="whether use GPU for prediction")
+        self.arg_config_group.add_argument(
+            '--use_gpu', type=ast.literal_eval, default=False, help="whether use GPU for prediction")
 
         self.arg_config_group.add_argument('--batch_size', type=int, default=1, help="batch size for prediction")
 

modules/text/text_generation/Rumor_prediction/module.py

@@ -27,12 +27,12 @@ import numpy as np
 import paddle
 import paddlehub as hub
 
+
 @moduleinfo(
     name="Rumor_prediction",
     version="1.0.0",
     type="nlp/semantic_model",
-    summary=
-    "Is the input text prediction a rumor",
+    summary="Is the input text prediction a rumor",
     author="彭兆帅，郑博培",
     author_email="1084667371@qq.com，2733821739@qq.com")
 class Rumorprediction(hub.Module):
@@ -51,6 +51,7 @@ class Rumorprediction(hub.Module):
              image (list(numpy.ndarray)): images data, shape of each is [H, W, C], the color space is BGR.
              use_gpu(bool): Weather to use gpu
         """
+
         # 获取数据
         def get_data(sentence):
             # 读取数据字典
@@ -66,6 +67,7 @@ class Rumorprediction(hub.Module):
                     s = '<unk>'
                 data.append(int(dict_txt[s]))
             return data
+
         data = []
         for text in texts:
             text = get_data(text)
@@ -75,16 +77,14 @@ class Rumorprediction(hub.Module):
         place = paddle.CUDAPlace(0) if use_gpu else paddle.CPUPlace()
         exe = paddle.static.Executor(place)
         exe.run(paddle.static.default_startup_program())
-        [infer_program, feeded_var_names, target_var] = paddle.fluid.io.load_inference_model(dirname=self.default_pretrained_model_path, executor=exe)
+        [infer_program, feeded_var_names, target_var] = paddle.fluid.io.load_inference_model(
+            dirname=self.default_pretrained_model_path, executor=exe)
         # 生成预测数据
         tensor_words = paddle.fluid.create_lod_tensor(data, base_shape, place)
         # 执行预测
-        result = exe.run(program=infer_program,
-                        feed={feeded_var_names[0]: tensor_words},
-                        fetch_list=target_var)
+        result = exe.run(program=infer_program, feed={feeded_var_names[0]: tensor_words}, fetch_list=target_var)
         # 分类名称
-        names = [ '谣言', '非谣言']
-
+        names = ['谣言', '非谣言']
 
         results = []
 
@@ -93,36 +93,25 @@ class Rumorprediction(hub.Module):
             content = texts[i]
             lab = np.argsort(result)[0][i][-1]
 
-            alltext = {
-                'content': content,
-                'prediction': names[lab],
-                'probability': result[0][i][lab]
-            }
+            alltext = {'content': content, 'prediction': names[lab], 'probability': result[0][i][lab]}
             alltext = [alltext]
             results = results + alltext
 
         return results
 
-    
     def add_module_config_arg(self):
         """
         Add the command config options
         """
         self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=ast.literal_eval,
-            default=False,
-            help="whether use GPU for prediction")
+            '--use_gpu', type=ast.literal_eval, default=False, help="whether use GPU for prediction")
 
     def add_module_input_arg(self):
         """
         Add the command input options
         """
-        self.arg_input_group.add_argument(
-            '--input_text',
-            type=str,
-            default=None,
-            help="input_text is str")
+        self.arg_input_group.add_argument('--input_text', type=str, default=None, help="input_text is str")
+
     @runnable
     def run_cmd(self, argvs):
         """
@@ -134,19 +123,15 @@ class Rumorprediction(hub.Module):
             usage='%(prog)s',
             add_help=True)
 
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, optional.")
+            title="Config options", description="Run configuration for controlling module behavior, optional.")
 
         self.add_module_config_arg()
         self.add_module_input_arg()
 
         args = self.parser.parse_args(argvs)
         input_text = [args.input_text]
-        results = self.Rumor(
-            texts=input_text, use_gpu=args.use_gpu)
+        results = self.Rumor(texts=input_text, use_gpu=args.use_gpu)
 
         return results

modules/text/text_generation/ernie_gen_leave/model/decode.py

@@ -23,23 +23,14 @@ import paddle.fluid.dygraph as D
 
 def gen_bias(encoder_inputs, decoder_inputs, step):
     decoder_bsz, decoder_seqlen = decoder_inputs.shape[:2]
-    attn_bias = L.reshape(
-        L.range(0, decoder_seqlen, 1, dtype='float32') + 1, [1, -1, 1])
-    decoder_bias = L.cast(
-        (L.matmul(attn_bias, 1. / attn_bias, transpose_y=True) >= 1.),
+    attn_bias = L.reshape(L.range(0, decoder_seqlen, 1, dtype='float32') + 1, [1, -1, 1])
+    decoder_bias = L.cast((L.matmul(attn_bias, 1. / attn_bias, transpose_y=True) >= 1.),
                           'float32')  #[1, 1, decoderlen, decoderlen]
-    encoder_bias = L.unsqueeze(
-        L.cast(L.ones_like(encoder_inputs), 'float32'),
-        [1])  #[bsz, 1, encoderlen]
-    encoder_bias = L.expand(
-        encoder_bias, [1, decoder_seqlen, 1])  #[bsz,decoderlen, encoderlen]
-    decoder_bias = L.expand(decoder_bias,
-                            [decoder_bsz, 1, 1])  #[bsz, decoderlen, decoderlen]
+    encoder_bias = L.unsqueeze(L.cast(L.ones_like(encoder_inputs), 'float32'), [1])  #[bsz, 1, encoderlen]
+    encoder_bias = L.expand(encoder_bias, [1, decoder_seqlen, 1])  #[bsz,decoderlen, encoderlen]
+    decoder_bias = L.expand(decoder_bias, [decoder_bsz, 1, 1])  #[bsz, decoderlen, decoderlen]
     if step > 0:
-        bias = L.concat([
-            encoder_bias,
-            L.ones([decoder_bsz, decoder_seqlen, step], 'float32'), decoder_bias
-        ], -1)
+        bias = L.concat([encoder_bias, L.ones([decoder_bsz, decoder_seqlen, step], 'float32'), decoder_bias], -1)
     else:
         bias = L.concat([encoder_bias, decoder_bias], -1)
     return bias
@@ -71,27 +62,16 @@ def greedy_search_infilling(model,
     ids = L.stack([cls_ids, attn_ids], -1)
     for step in range(max_decode_len):
         bias = gen_bias(q_ids, ids, step)
-        pos_ids = D.to_variable(
-            np.tile(np.array([[step, step + 1]], dtype=np.int64), [d_batch, 1]))
+        pos_ids = D.to_variable(np.tile(np.array([[step, step + 1]], dtype=np.int64), [d_batch, 1]))
         pos_ids += seqlen
         _, logits, info = model(
-            ids,
-            L.ones_like(ids) * tgt_type_id,
-            pos_ids=pos_ids,
-            attn_bias=bias,
-            past_cache=past_cache)
+            ids, L.ones_like(ids) * tgt_type_id, pos_ids=pos_ids, attn_bias=bias, past_cache=past_cache)
         gen_ids = L.argmax(logits, -1)
 
         past_cached_k, past_cached_v = past_cache
         cached_k, cached_v = info['caches']
-        cached_k = [
-            L.concat([pk, k[:, :1, :]], 1)
-            for pk, k in zip(past_cached_k, cached_k)
-        ]  # concat cached
-        cached_v = [
-            L.concat([pv, v[:, :1, :]], 1)
-            for pv, v in zip(past_cached_v, cached_v)
-        ]
+        cached_k = [L.concat([pk, k[:, :1, :]], 1) for pk, k in zip(past_cached_k, cached_k)]  # concat cached
+        cached_v = [L.concat([pv, v[:, :1, :]], 1) for pv, v in zip(past_cached_v, cached_v)]
         past_cache = (cached_k, cached_v)
 
         gen_ids = gen_ids[:, 1]
@@ -107,10 +87,8 @@ def greedy_search_infilling(model,
     return output_ids
 
 
-BeamSearchState = namedtuple('BeamSearchState',
-                             ['log_probs', 'lengths', 'finished'])
-BeamSearchOutput = namedtuple('BeamSearchOutput',
-                              ['scores', 'predicted_ids', 'beam_parent_ids'])
+BeamSearchState = namedtuple('BeamSearchState', ['log_probs', 'lengths', 'finished'])
+BeamSearchOutput = namedtuple('BeamSearchOutput', ['scores', 'predicted_ids', 'beam_parent_ids'])
 
 
 def log_softmax(x):
@@ -120,8 +98,7 @@ def log_softmax(x):
 
 def mask_prob(p, onehot_eos, finished):
     is_finished = L.cast(L.reshape(finished, [-1, 1]) != 0, 'float32')
-    p = is_finished * (1. - L.cast(onehot_eos, 'float32')) * -9999. + (
-        1. - is_finished) * p
+    p = is_finished * (1. - L.cast(onehot_eos, 'float32')) * -9999. + (1. - is_finished) * p
     return p
 
 
@@ -130,8 +107,7 @@ def hyp_score(log_probs, length, length_penalty):
     return log_probs / lp
 
 
-def beam_search_step(state, logits, eos_id, beam_width, is_first_step,
-                     length_penalty):
+def beam_search_step(state, logits, eos_id, beam_width, is_first_step, length_penalty):
     """logits.shape == [B*W, V]"""
     beam_size, vocab_size = logits.shape  # as batch size=1 in this hub module. the first dim means bsz * beam_size equals beam_size
     logits_np = logits.numpy()
@@ -140,8 +116,7 @@ def beam_search_step(state, logits, eos_id, beam_width, is_first_step,
     logits = D.to_variable(logits_np)
 
     bsz, beam_width = state.log_probs.shape
-    onehot_eos = L.cast(
-        F.one_hot(L.ones([1], 'int64') * eos_id, vocab_size), 'int64')  #[1, V]
+    onehot_eos = L.cast(F.one_hot(L.ones([1], 'int64') * eos_id, vocab_size), 'int64')  #[1, V]
 
     probs = L.log(L.softmax(logits))  #[B*W, V]
     probs = mask_prob(probs, onehot_eos, state.finished)  #[B*W, V]
@@ -156,32 +131,24 @@ def beam_search_step(state, logits, eos_id, beam_width, is_first_step,
     alllen = L.reshape(alllen, [-1, beam_width * vocab_size])
     allscore = hyp_score(allprobs, alllen, length_penalty)
     if is_first_step:
-        allscore = L.reshape(
-            allscore,
-            [bsz, beam_width, -1])[:, 0, :]  # first step only consiter beam 0
+        allscore = L.reshape(allscore, [bsz, beam_width, -1])[:, 0, :]  # first step only consiter beam 0
     scores, idx = L.topk(allscore, k=beam_width)  #[B, W]
     next_beam_id = idx // vocab_size  #[B, W]
     next_word_id = idx % vocab_size
 
-    gather_idx = L.concat([L.where(idx != -1)[:, :1],
-                           L.reshape(idx, [-1, 1])], 1)
+    gather_idx = L.concat([L.where(idx != -1)[:, :1], L.reshape(idx, [-1, 1])], 1)
     next_probs = L.reshape(L.gather_nd(allprobs, gather_idx), idx.shape)
     next_len = L.reshape(L.gather_nd(alllen, gather_idx), idx.shape)
 
-    gather_idx = L.concat(
-        [L.where(next_beam_id != -1)[:, :1],
-         L.reshape(next_beam_id, [-1, 1])], 1)
-    next_finished = L.reshape(
-        L.gather_nd(state.finished, gather_idx),
+    gather_idx = L.concat([L.where(next_beam_id != -1)[:, :1], L.reshape(next_beam_id, [-1, 1])], 1)
+    next_finished = L.reshape(L.gather_nd(state.finished, gather_idx),
                               state.finished.shape)  #[gather new beam state according to new beam id]
 
     next_finished += L.cast(next_word_id == eos_id, 'int64')
     next_finished = L.cast(next_finished > 0, 'int64')
 
-    next_state = BeamSearchState(
-        log_probs=next_probs, lengths=next_len, finished=next_finished)
-    output = BeamSearchOutput(
-        scores=scores, predicted_ids=next_word_id, beam_parent_ids=next_beam_id)
+    next_state = BeamSearchState(log_probs=next_probs, lengths=next_len, finished=next_finished)
+    output = BeamSearchOutput(scores=scores, predicted_ids=next_word_id, beam_parent_ids=next_beam_id)
 
     return output, next_state
 
@@ -210,15 +177,13 @@ def beam_search_infilling(model,
 
     def reorder_(t, parent_id):
         """reorder cache according to parent beam id"""
-        gather_idx = L.where(parent_id != -1)[:, 0] * beam_width + L.reshape(
-            parent_id, [-1])
+        gather_idx = L.where(parent_id != -1)[:, 0] * beam_width + L.reshape(parent_id, [-1])
         t = L.gather(t, gather_idx)
         return t
 
     def tile_(t, times):
         _shapes = list(t.shape[1:])
-        ret = L.reshape(
-            L.expand(L.unsqueeze(t, [1]), [
+        ret = L.reshape(L.expand(L.unsqueeze(t, [1]), [
             1,
             times,
         ] + [
@@ -241,18 +206,11 @@ def beam_search_infilling(model,
     ids = L.stack([cls_ids, attn_ids], -1)
     for step in range(max_decode_len):
         bias = gen_bias(q_ids, ids, step)
-        pos_ids = D.to_variable(
-            np.tile(
-                np.array([[step, step + 1]], dtype=np.int64),
-                [d_batch * beam_width, 1]))
+        pos_ids = D.to_variable(np.tile(np.array([[step, step + 1]], dtype=np.int64), [d_batch * beam_width, 1]))
         pos_ids += seqlen
 
         _, logits, info = model(
-            ids,
-            L.ones_like(ids) * tgt_type_id,
-            pos_ids=pos_ids,
-            attn_bias=bias,
-            past_cache=past_cache)
+            ids, L.ones_like(ids) * tgt_type_id, pos_ids=pos_ids, attn_bias=bias, past_cache=past_cache)
 
         output, state = beam_search_step(
             state,
@@ -266,17 +224,14 @@ def beam_search_infilling(model,
         past_cached_k, past_cached_v = past_cache
         cached_k, cached_v = info['caches']
         cached_k = [
-            reorder_(L.concat([pk, k[:, :1, :]], 1), output.beam_parent_ids)
-            for pk, k in zip(past_cached_k, cached_k)
+            reorder_(L.concat([pk, k[:, :1, :]], 1), output.beam_parent_ids) for pk, k in zip(past_cached_k, cached_k)
         ]  # concat cached
         cached_v = [
-            reorder_(L.concat([pv, v[:, :1, :]], 1), output.beam_parent_ids)
-            for pv, v in zip(past_cached_v, cached_v)
+            reorder_(L.concat([pv, v[:, :1, :]], 1), output.beam_parent_ids) for pv, v in zip(past_cached_v, cached_v)
         ]
         past_cache = (cached_k, cached_v)
 
-        pred_ids_flatten = L.reshape(output.predicted_ids,
-                                     [d_batch * beam_width])
+        pred_ids_flatten = L.reshape(output.predicted_ids, [d_batch * beam_width])
         ids = L.stack([pred_ids_flatten, attn_ids], 1)
 
         if state.finished.numpy().all():
@@ -286,8 +241,7 @@ def beam_search_infilling(model,
     final_parent_ids = L.stack([o.beam_parent_ids for o in outputs], 0)
     final_ids = L.gather_tree(final_ids, final_parent_ids)  #[:, :,
     #0]  #pick best beam
-    final_ids = L.transpose(
-        L.reshape(final_ids, [-1, d_batch * 1, beam_width]), [1, 2, 0])
+    final_ids = L.transpose(L.reshape(final_ids, [-1, d_batch * 1, beam_width]), [1, 2, 0])
     return final_ids
 
 

modules/text/text_generation/ernie_gen_leave/model/file_utils.py

@@ -27,10 +27,7 @@ def _fetch_from_remote(url, force_download=False):
             r = requests.get(url, stream=True)
             total_len = int(r.headers.get('content-length'))
             for chunk in tqdm(
-                    r.iter_content(chunk_size=1024),
-                    total=total_len // 1024,
-                    desc='downloading %s' % url,
-                    unit='KB'):
+                    r.iter_content(chunk_size=1024), total=total_len // 1024, desc='downloading %s' % url, unit='KB'):
                 if chunk:
                     f.write(chunk)
                     f.flush()

modules/text/text_generation/ernie_gen_leave/model/modeling_ernie.py

@@ -30,9 +30,7 @@ def _build_linear(n_in, n_out, name, init, act=None):
     return D.Linear(
         n_in,
         n_out,
-        param_attr=F.ParamAttr(
-            name='%s.w_0' % name if name is not None else None,
-            initializer=init),
+        param_attr=F.ParamAttr(name='%s.w_0' % name if name is not None else None, initializer=init),
         bias_attr='%s.b_0' % name if name is not None else None,
         act=act)
 
@@ -41,11 +39,9 @@ def _build_ln(n_in, name):
     return D.LayerNorm(
         normalized_shape=n_in,
         param_attr=F.ParamAttr(
-            name='%s_layer_norm_scale' % name if name is not None else None,
-            initializer=F.initializer.Constant(1.)),
+            name='%s_layer_norm_scale' % name if name is not None else None, initializer=F.initializer.Constant(1.)),
         bias_attr=F.ParamAttr(
-            name='%s_layer_norm_bias' % name if name is not None else None,
-            initializer=F.initializer.Constant(1.)),
+            name='%s_layer_norm_bias' % name if name is not None else None, initializer=F.initializer.Constant(1.)),
     )
 
 
@@ -61,25 +57,18 @@ def append_name(name, postfix):
 class AttentionLayer(D.Layer):
     def __init__(self, cfg, name=None):
         super(AttentionLayer, self).__init__()
-        initializer = F.initializer.TruncatedNormal(
-            scale=cfg['initializer_range'])
+        initializer = F.initializer.TruncatedNormal(scale=cfg['initializer_range'])
         d_model = cfg['hidden_size']
         n_head = cfg['num_attention_heads']
         assert d_model % n_head == 0
-        d_model_q = cfg.get('query_hidden_size_per_head',
-                            d_model // n_head) * n_head
-        d_model_v = cfg.get('value_hidden_size_per_head',
-                            d_model // n_head) * n_head
+        d_model_q = cfg.get('query_hidden_size_per_head', d_model // n_head) * n_head
+        d_model_v = cfg.get('value_hidden_size_per_head', d_model // n_head) * n_head
         self.n_head = n_head
         self.d_key = d_model_q // n_head
-        self.q = _build_linear(d_model, d_model_q, append_name(
-            name, 'query_fc'), initializer)
-        self.k = _build_linear(d_model, d_model_q, append_name(name, 'key_fc'),
-                               initializer)
-        self.v = _build_linear(d_model, d_model_v, append_name(
-            name, 'value_fc'), initializer)
-        self.o = _build_linear(d_model_v, d_model, append_name(
-            name, 'output_fc'), initializer)
+        self.q = _build_linear(d_model, d_model_q, append_name(name, 'query_fc'), initializer)
+        self.k = _build_linear(d_model, d_model_q, append_name(name, 'key_fc'), initializer)
+        self.v = _build_linear(d_model, d_model_v, append_name(name, 'value_fc'), initializer)
+        self.o = _build_linear(d_model_v, d_model, append_name(name, 'output_fc'), initializer)
         self.dropout = lambda i: L.dropout(
             i,
             dropout_prob=cfg['attention_probs_dropout_prob'],
@@ -99,14 +88,11 @@ class AttentionLayer(D.Layer):
             k = L.concat([cached_k, k], 1)
             v = L.concat([cached_v, v], 1)
 
-        q = L.transpose(
-            L.reshape(q, [0, 0, self.n_head, q.shape[-1] // self.n_head]),
+        q = L.transpose(L.reshape(q, [0, 0, self.n_head, q.shape[-1] // self.n_head]),
                         [0, 2, 1, 3])  #[batch, head, seq, dim]
-        k = L.transpose(
-            L.reshape(k, [0, 0, self.n_head, k.shape[-1] // self.n_head]),
+        k = L.transpose(L.reshape(k, [0, 0, self.n_head, k.shape[-1] // self.n_head]),
                         [0, 2, 1, 3])  #[batch, head, seq, dim]
-        v = L.transpose(
-            L.reshape(v, [0, 0, self.n_head, v.shape[-1] // self.n_head]),
+        v = L.transpose(L.reshape(v, [0, 0, self.n_head, v.shape[-1] // self.n_head]),
                         [0, 2, 1, 3])  #[batch, head, seq, dim]
 
         q = L.scale(q, scale=self.d_key**-0.5)
@@ -127,19 +113,12 @@ class AttentionLayer(D.Layer):
 class PositionwiseFeedForwardLayer(D.Layer):
     def __init__(self, cfg, name=None):
         super(PositionwiseFeedForwardLayer, self).__init__()
-        initializer = F.initializer.TruncatedNormal(
-            scale=cfg['initializer_range'])
+        initializer = F.initializer.TruncatedNormal(scale=cfg['initializer_range'])
         d_model = cfg['hidden_size']
         d_ffn = cfg.get('intermediate_size', 4 * d_model)
         assert cfg['hidden_act'] in ['relu', 'gelu']
-        self.i = _build_linear(
-            d_model,
-            d_ffn,
-            append_name(name, 'fc_0'),
-            initializer,
-            act=cfg['hidden_act'])
-        self.o = _build_linear(d_ffn, d_model, append_name(name, 'fc_1'),
-                               initializer)
+        self.i = _build_linear(d_model, d_ffn, append_name(name, 'fc_0'), initializer, act=cfg['hidden_act'])
+        self.o = _build_linear(d_ffn, d_model, append_name(name, 'fc_1'), initializer)
         prob = cfg.get('intermediate_dropout_prob', 0.)
         self.dropout = lambda i: L.dropout(
             i,
@@ -158,14 +137,11 @@ class ErnieBlock(D.Layer):
     def __init__(self, cfg, name=None):
         super(ErnieBlock, self).__init__()
         d_model = cfg['hidden_size']
-        initializer = F.initializer.TruncatedNormal(
-            scale=cfg['initializer_range'])
+        initializer = F.initializer.TruncatedNormal(scale=cfg['initializer_range'])
 
-        self.attn = AttentionLayer(
-            cfg, name=append_name(name, 'multi_head_att'))
+        self.attn = AttentionLayer(cfg, name=append_name(name, 'multi_head_att'))
         self.ln1 = _build_ln(d_model, name=append_name(name, 'post_att'))
-        self.ffn = PositionwiseFeedForwardLayer(
-            cfg, name=append_name(name, 'ffn'))
+        self.ffn = PositionwiseFeedForwardLayer(cfg, name=append_name(name, 'ffn'))
         self.ln2 = _build_ln(d_model, name=append_name(name, 'post_ffn'))
         prob = cfg.get('intermediate_dropout_prob', cfg['hidden_dropout_prob'])
         self.dropout = lambda i: L.dropout(
@@ -175,9 +151,7 @@ class ErnieBlock(D.Layer):
         ) if self.training else i
 
     def forward(self, inputs, attn_bias=None, past_cache=None):
-        attn_out, cache = self.attn(
-            inputs, inputs, inputs, attn_bias,
-            past_cache=past_cache)  #self attn
+        attn_out, cache = self.attn(inputs, inputs, inputs, attn_bias, past_cache=past_cache)  #self attn
         attn_out = self.dropout(attn_out)
         hidden = attn_out + inputs
         hidden = self.ln1(hidden)  # dropout/ add/ norm
@@ -193,17 +167,13 @@ class ErnieEncoderStack(D.Layer):
     def __init__(self, cfg, name=None):
         super(ErnieEncoderStack, self).__init__()
         n_layers = cfg['num_hidden_layers']
-        self.block = D.LayerList([
-            ErnieBlock(cfg, append_name(name, 'layer_%d' % i))
-            for i in range(n_layers)
-        ])
+        self.block = D.LayerList([ErnieBlock(cfg, append_name(name, 'layer_%d' % i)) for i in range(n_layers)])
 
     def forward(self, inputs, attn_bias=None, past_cache=None):
         if past_cache is not None:
             assert isinstance(
-                past_cache, tuple
-            ), 'unknown type of `past_cache`, expect tuple or list. got %s' % repr(
-                type(past_cache))
+                past_cache,
+                tuple), 'unknown type of `past_cache`, expect tuple or list. got %s' % repr(type(past_cache))
             past_cache = list(zip(*past_cache))
         else:
             past_cache = [None] * len(self.block)
@@ -233,24 +203,18 @@ class ErnieModel(D.Layer):
         d_sent = cfg.get("sent_type_vocab_size") or cfg['type_vocab_size']
         self.n_head = cfg['num_attention_heads']
         self.return_additional_info = cfg.get('return_additional_info', False)
-        initializer = F.initializer.TruncatedNormal(
-            scale=cfg['initializer_range'])
+        initializer = F.initializer.TruncatedNormal(scale=cfg['initializer_range'])
 
         self.ln = _build_ln(d_model, name=append_name(name, 'pre_encoder'))
         self.word_emb = D.Embedding([d_vocab, d_emb],
                                     param_attr=F.ParamAttr(
-                                        name=append_name(
-                                            name, 'word_embedding'),
-                                        initializer=initializer))
+                                        name=append_name(name, 'word_embedding'), initializer=initializer))
         self.pos_emb = D.Embedding([d_pos, d_emb],
                                    param_attr=F.ParamAttr(
-                                       name=append_name(name, 'pos_embedding'),
-                                       initializer=initializer))
+                                       name=append_name(name, 'pos_embedding'), initializer=initializer))
         self.sent_emb = D.Embedding([d_sent, d_emb],
                                     param_attr=F.ParamAttr(
-                                        name=append_name(
-                                            name, 'sent_embedding'),
-                                        initializer=initializer))
+                                        name=append_name(name, 'sent_embedding'), initializer=initializer))
         prob = cfg['hidden_dropout_prob']
         self.dropout = lambda i: L.dropout(
             i,
@@ -258,15 +222,10 @@ class ErnieModel(D.Layer):
             dropout_implementation="upscale_in_train",
         ) if self.training else i
 
-        self.encoder_stack = ErnieEncoderStack(cfg, append_name(
-            name, 'encoder'))
+        self.encoder_stack = ErnieEncoderStack(cfg, append_name(name, 'encoder'))
         if cfg.get('has_pooler', True):
             self.pooler = _build_linear(
-                cfg['hidden_size'],
-                cfg['hidden_size'],
-                append_name(name, 'pooled_fc'),
-                initializer,
-                act='tanh')
+                cfg['hidden_size'], cfg['hidden_size'], append_name(name, 'pooled_fc'), initializer, act='tanh')
         else:
             self.pooler = None
         self.train()
@@ -317,10 +276,7 @@ class ErnieModel(D.Layer):
             encoded(`Variable` of shape `[batch_size, seq_len, hidden_size]`):
                 output logits of transformer stack
         """
-        assert len(
-            src_ids.shape
-        ) == 2, 'expect src_ids.shape = [batch, sequecen], got %s' % (repr(
-            src_ids.shape))
+        assert len(src_ids.shape) == 2, 'expect src_ids.shape = [batch, sequecen], got %s' % (repr(src_ids.shape))
         assert attn_bias is not None if past_cache else True, 'if `past_cache` is specified; attn_bias should not be None'
         d_batch = L.shape(src_ids)[0]
         d_seqlen = L.shape(src_ids)[1]
@@ -334,21 +290,14 @@ class ErnieModel(D.Layer):
             input_mask = L.unsqueeze(input_mask, axes=[-1])
             attn_bias = L.matmul(input_mask, input_mask, transpose_y=True)
             if use_causal_mask:
-                sequence = L.reshape(
-                    L.range(0, d_seqlen, 1, dtype='float32') + 1.,
-                    [1, 1, -1, 1])
-                causal_mask = L.cast(
-                    (L.matmul(sequence, 1. / sequence, transpose_y=True) >= 1.),
-                    'float32')
+                sequence = L.reshape(L.range(0, d_seqlen, 1, dtype='float32') + 1., [1, 1, -1, 1])
+                causal_mask = L.cast((L.matmul(sequence, 1. / sequence, transpose_y=True) >= 1.), 'float32')
                 attn_bias *= causal_mask
         else:
-            assert len(
-                attn_bias.shape
-            ) == 3, 'expect attn_bias tobe rank 3, got %r' % attn_bias.shape
+            assert len(attn_bias.shape) == 3, 'expect attn_bias tobe rank 3, got %r' % attn_bias.shape
         attn_bias = (1. - attn_bias) * -10000.0
         attn_bias = L.unsqueeze(attn_bias, [1])
-        attn_bias = L.expand(attn_bias,
-                             [1, self.n_head, 1, 1])  # avoid broadcast =_=
+        attn_bias = L.expand(attn_bias, [1, self.n_head, 1, 1])  # avoid broadcast =_=
         attn_bias.stop_gradient = True
 
         if sent_ids is None:
@@ -361,8 +310,7 @@ class ErnieModel(D.Layer):
 
         embedded = self.dropout(self.ln(embedded))
 
-        encoded, hidden_list, cache_list = self.encoder_stack(
-            embedded, attn_bias, past_cache=past_cache)
+        encoded, hidden_list, cache_list = self.encoder_stack(embedded, attn_bias, past_cache=past_cache)
         if self.pooler is not None:
             pooled = self.pooler(encoded[:, 0, :])
         else:

modules/text/text_generation/ernie_gen_leave/model/modeling_ernie_gen.py

@@ -24,25 +24,18 @@ class ErnieModelForGeneration(ErnieModel):
         cfg['return_additional_info'] = True
         cfg['has_pooler'] = False
         super(ErnieModelForGeneration, self).__init__(cfg, name=name)
-        initializer = F.initializer.TruncatedNormal(
-            scale=cfg['initializer_range'])
+        initializer = F.initializer.TruncatedNormal(scale=cfg['initializer_range'])
         d_model = cfg['hidden_size']
         d_vocab = cfg['vocab_size']
 
         self.mlm = _build_linear(
-            d_model,
-            d_model,
-            append_name(name, 'mask_lm_trans_fc'),
-            initializer,
-            act=cfg['hidden_act'])
-        self.mlm_ln = _build_ln(
-            d_model, name=append_name(name, 'mask_lm_trans'))
+            d_model, d_model, append_name(name, 'mask_lm_trans_fc'), initializer, act=cfg['hidden_act'])
+        self.mlm_ln = _build_ln(d_model, name=append_name(name, 'mask_lm_trans'))
         self.mlm_bias = L.create_parameter(
             dtype='float32',
             shape=[d_vocab],
             attr=F.ParamAttr(
-                name=append_name(name, 'mask_lm_out_fc.b_0'),
-                initializer=F.initializer.Constant(value=0.0)),
+                name=append_name(name, 'mask_lm_out_fc.b_0'), initializer=F.initializer.Constant(value=0.0)),
             is_bias=True,
         )
 
@@ -56,23 +49,17 @@ class ErnieModelForGeneration(ErnieModel):
         elif tgt_labels is None:
             encoded = self.mlm(encoded)
             encoded = self.mlm_ln(encoded)
-            logits = L.matmul(
-                encoded, self.word_emb.weight, transpose_y=True) + self.mlm_bias
+            logits = L.matmul(encoded, self.word_emb.weight, transpose_y=True) + self.mlm_bias
             output_ids = L.argmax(logits, -1)
             return output_ids, logits, info
         else:
             encoded_2d = L.gather_nd(encoded, tgt_pos)
             encoded_2d = self.mlm(encoded_2d)
             encoded_2d = self.mlm_ln(encoded_2d)
-            logits_2d = L.matmul(
-                encoded_2d, self.word_emb.weight,
-                transpose_y=True) + self.mlm_bias
+            logits_2d = L.matmul(encoded_2d, self.word_emb.weight, transpose_y=True) + self.mlm_bias
             if len(tgt_labels.shape) == 1:
                 tgt_labels = L.reshape(tgt_labels, [-1, 1])
 
             loss = L.reduce_mean(
-                L.softmax_with_cross_entropy(
-                    logits_2d,
-                    tgt_labels,
-                    soft_label=(tgt_labels.shape[-1] != 1)))
+                L.softmax_with_cross_entropy(logits_2d, tgt_labels, soft_label=(tgt_labels.shape[-1] != 1)))
             return loss, logits_2d, info

modules/text/text_generation/ernie_gen_leave/model/tokenizing_ernie.py

@@ -77,8 +77,7 @@ class ErnieTokenizer(object):
                  encoding='utf8',
                  special_token_list=[]):
         if not isinstance(vocab, dict):
-            raise ValueError(
-                'expect `vocab` to be instance of dict, got %s' % type(vocab))
+            raise ValueError('expect `vocab` to be instance of dict, got %s' % type(vocab))
         self.vocab = vocab
         self.lower = lower
         self.prefix = wordpiece_prefix
@@ -89,9 +88,7 @@ class ErnieTokenizer(object):
         self.unk_id = unk_token and self.vocab[unk_token]
         self.mask_id = mask_token and self.vocab[mask_token]
         self.unk_token = unk_token
-        special_tokens = {
-            pad_token, cls_token, sep_token, unk_token, mask_token
-        } | set(special_token_list)
+        special_tokens = {pad_token, cls_token, sep_token, unk_token, mask_token} | set(special_token_list)
         pat_str = ''
         for t in special_tokens:
             if t is None:
@@ -135,11 +132,9 @@ class ErnieTokenizer(object):
         len2 = len(id2)
         half = seqlen // 2
         if len1 > len2:
-            len1_truncated, len2_truncated = max(half, seqlen - len2), min(
-                half, len2)
+            len1_truncated, len2_truncated = max(half, seqlen - len2), min(half, len2)
         else:
-            len1_truncated, len2_truncated = min(half, seqlen - len1), max(
-                half, seqlen - len1)
+            len1_truncated, len2_truncated = min(half, seqlen - len1), max(half, seqlen - len1)
         return id1[:len1_truncated], id2[:len2_truncated]
 
     def build_for_ernie(self, text_id, pair_id=[]):
@@ -155,17 +150,14 @@ class ErnieTokenizer(object):
         return ret_id, ret_id_type
 
     def encode(self, text, pair=None, truncate_to=None):
-        text_id = np.array(
-            self.convert_tokens_to_ids(self.tokenize(text)), dtype=np.int64)
+        text_id = np.array(self.convert_tokens_to_ids(self.tokenize(text)), dtype=np.int64)
         text_id_type = np.zeros_like(text_id, dtype=np.int64)
         if pair is not None:
-            pair_id = np.array(
-                self.convert_tokens_to_ids(self.tokenize(pair)), dtype=np.int64)
+            pair_id = np.array(self.convert_tokens_to_ids(self.tokenize(pair)), dtype=np.int64)
         else:
             pair_id = []
         if truncate_to is not None:
-            text_id, pair_id = self.truncate(
-                text_id, [] if pair_id is None else pair_id, truncate_to)
+            text_id, pair_id = self.truncate(text_id, [] if pair_id is None else pair_id, truncate_to)
 
         ret_id, ret_id_type = self.build_for_ernie(text_id, pair_id)
         return ret_id, ret_id_type

modules/text/text_generation/ernie_gen_leave/module.py

@@ -35,8 +35,7 @@ from .model.modeling_ernie_gen import ErnieModelForGeneration
 @moduleinfo(
     name="ernie_gen_leave",
     version="1.0.0",
-    summary=
-    "",
+    summary="",
     author="彭兆帅，郑博培",
     author_email="1084667371@qq.com，2733821739@qq.com",
     type="nlp/text_generation",
@@ -53,10 +52,7 @@ class ErnieGen(hub.NLPPredictionModule):
             ernie_cfg = dict(json.loads(ernie_cfg_file.read()))
         ernie_vocab_path = os.path.join(assets_path, 'vocab.txt')
         with open(ernie_vocab_path, encoding='utf8') as ernie_vocab_file:
-            ernie_vocab = {
-                j.strip().split('\t')[0]: i
-                for i, j in enumerate(ernie_vocab_file.readlines())
-            }
+            ernie_vocab = {j.strip().split('\t')[0]: i for i, j in enumerate(ernie_vocab_file.readlines())}
 
         with fluid.dygraph.guard(fluid.CPUPlace()):
             with fluid.unique_name.guard():
@@ -83,13 +79,10 @@ class ErnieGen(hub.NLPPredictionModule):
         Returns:
              results(list): the predict result.
         """
-        if texts and isinstance(texts, list) and all(texts) and all(
-            [isinstance(text, str) for text in texts]):
+        if texts and isinstance(texts, list) and all(texts) and all([isinstance(text, str) for text in texts]):
             predicted_data = texts
         else:
-            raise ValueError(
-                "The input texts should be a list with nonempty string elements."
-            )
+            raise ValueError("The input texts should be a list with nonempty string elements.")
 
         if use_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
             use_gpu = False
@@ -134,13 +127,9 @@ class ErnieGen(hub.NLPPredictionModule):
         Add the command config options
         """
         self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=ast.literal_eval,
-            default=False,
-            help="whether use GPU for prediction")
+            '--use_gpu', type=ast.literal_eval, default=False, help="whether use GPU for prediction")
 
-        self.arg_config_group.add_argument(
-            '--beam_width', type=int, default=5, help="the beam search width")
+        self.arg_config_group.add_argument('--beam_width', type=int, default=5, help="the beam search width")
 
     @runnable
     def run_cmd(self, argvs):
@@ -153,12 +142,9 @@ class ErnieGen(hub.NLPPredictionModule):
             usage='%(prog)s',
             add_help=True)
 
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, optional.")
+            title="Config options", description="Run configuration for controlling module behavior, optional.")
 
         self.add_module_config_arg()
         self.add_module_input_arg()
@@ -171,7 +157,6 @@ class ErnieGen(hub.NLPPredictionModule):
             self.parser.print_help()
             return None
 
-        results = self.generate(
-            texts=input_data, use_gpu=args.use_gpu, beam_width=args.beam_width)
+        results = self.generate(texts=input_data, use_gpu=args.use_gpu, beam_width=args.beam_width)
 
         return results

modules/text/text_generation/plato-mini/module.py

@@ -46,10 +46,8 @@ class UnifiedTransformer(nn.Layer):
         """
         Convert input strings to tokens.
         """
-        return self.tokenizer.dialogue_encode(texts,
-                                              max_seq_len=max_seq_len,
-                                              add_start_token_as_response=True,
-                                              is_split_into_words=False)
+        return self.tokenizer.dialogue_encode(
+            texts, max_seq_len=max_seq_len, add_start_token_as_response=True, is_split_into_words=False)
 
     def _batchify(self, data: List[List[str]], max_seq_len: int, batch_size: int):
         """
@@ -127,7 +125,8 @@ class UnifiedTransformer(nn.Layer):
                 early_stopping=False,
                 num_return_sequences=1):
 
-        ids, scores = self.model.generate(input_ids=input_ids,
+        ids, scores = self.model.generate(
+            input_ids=input_ids,
             token_type_ids=token_type_ids,
             position_ids=position_ids,
             attention_mask=attention_mask,
@@ -173,11 +172,8 @@ class UnifiedTransformer(nn.Layer):
             num_return_sequences = 1 if 'num_return_sequences' not in kwargs\
                 else kwargs['num_return_sequences']
             results.extend(
-                select_response(ids,
-                                scores,
-                                self.tokenizer,
-                                num_return_sequences=num_return_sequences,
-                                keep_space=False))
+                select_response(
+                    ids, scores, self.tokenizer, num_return_sequences=num_return_sequences, keep_space=False))
 
         if self._interactive_mode:
             self.context.append(results[0].strip())

modules/text/text_generation/unified_transformer-12L-cn-luge/module.py

@@ -46,10 +46,8 @@ class UnifiedTransformer(nn.Layer):
         """
         Convert input strings to tokens.
         """
-        return self.tokenizer.dialogue_encode(texts,
-                                              max_seq_len=max_seq_len,
-                                              add_start_token_as_response=True,
-                                              is_split_into_words=False)
+        return self.tokenizer.dialogue_encode(
+            texts, max_seq_len=max_seq_len, add_start_token_as_response=True, is_split_into_words=False)
 
     def _batchify(self, data: List[List[str]], max_seq_len: int, batch_size: int):
         """
@@ -127,7 +125,8 @@ class UnifiedTransformer(nn.Layer):
                 early_stopping=False,
                 num_return_sequences=1):
 
-        ids, scores = self.model.generate(input_ids=input_ids,
+        ids, scores = self.model.generate(
+            input_ids=input_ids,
             token_type_ids=token_type_ids,
             position_ids=position_ids,
             attention_mask=attention_mask,
@@ -173,11 +172,8 @@ class UnifiedTransformer(nn.Layer):
             num_return_sequences = 1 if 'num_return_sequences' not in kwargs\
                 else kwargs['num_return_sequences']
             results.extend(
-                select_response(ids,
-                                scores,
-                                self.tokenizer,
-                                num_return_sequences=num_return_sequences,
-                                keep_space=False))
+                select_response(
+                    ids, scores, self.tokenizer, num_return_sequences=num_return_sequences, keep_space=False))
 
         if self._interactive_mode:
             self.context.append(results[0].strip())

modules/text/text_generation/unified_transformer-12L-cn/module.py

@@ -46,10 +46,8 @@ class UnifiedTransformer(nn.Layer):
         """
         Convert input strings to tokens.
         """
-        return self.tokenizer.dialogue_encode(texts,
-                                              max_seq_len=max_seq_len,
-                                              add_start_token_as_response=True,
-                                              is_split_into_words=False)
+        return self.tokenizer.dialogue_encode(
+            texts, max_seq_len=max_seq_len, add_start_token_as_response=True, is_split_into_words=False)
 
     def _batchify(self, data: List[List[str]], max_seq_len: int, batch_size: int):
         """
@@ -127,7 +125,8 @@ class UnifiedTransformer(nn.Layer):
                 early_stopping=False,
                 num_return_sequences=1):
 
-        ids, scores = self.model.generate(input_ids=input_ids,
+        ids, scores = self.model.generate(
+            input_ids=input_ids,
             token_type_ids=token_type_ids,
             position_ids=position_ids,
             attention_mask=attention_mask,
@@ -173,11 +172,8 @@ class UnifiedTransformer(nn.Layer):
             num_return_sequences = 1 if 'num_return_sequences' not in kwargs\
                 else kwargs['num_return_sequences']
             results.extend(
-                select_response(ids,
-                                scores,
-                                self.tokenizer,
-                                num_return_sequences=num_return_sequences,
-                                keep_space=False))
+                select_response(
+                    ids, scores, self.tokenizer, num_return_sequences=num_return_sequences, keep_space=False))
 
         if self._interactive_mode:
             self.context.append(results[0].strip())

modules/thirdparty/image/classification/DriverStatusRecognition/__init__.py

-

modules/thirdparty/image/classification/DriverStatusRecognition/module.py

@@ -41,18 +41,10 @@ def read_images(paths):
     version='1.0.0')
 class MODULE(hub.Module):
     def _initialize(self, **kwargs):
-        self.default_pretrained_model_path = os.path.join(
-            self.directory, 'assets')
-        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path,
-                                          **kwargs)
-
-    def predict(self,
-                images=None,
-                paths=None,
-                data=None,
-                batch_size=1,
-                use_gpu=False,
-                **kwargs):
+        self.default_pretrained_model_path = os.path.join(self.directory, 'assets')
+        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path, **kwargs)
+
+    def predict(self, images=None, paths=None, data=None, batch_size=1, use_gpu=False, **kwargs):
 
         all_data = images if images is not None else read_images(paths)
         total_num = len(all_data)
@@ -110,36 +102,27 @@ class MODULE(hub.Module):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            paths=[args.input_path],
-            use_gpu=args.use_gpu)
+        results = self.predict(paths=[args.input_path], use_gpu=args.use_gpu)
         return results
 
     def add_module_config_arg(self):
         """
         Add the command config options.
         """
-        self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=bool,
-            default=False,
-            help="whether use GPU or not")
+        self.arg_config_group.add_argument('--use_gpu', type=bool, default=False, help="whether use GPU or not")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+
 
 if __name__ == '__main__':
     module = MODULE(directory='./new_model')

modules/thirdparty/image/classification/SnakeIdentification/__init__.py

-

modules/thirdparty/image/classification/SnakeIdentification/module.py

@@ -41,18 +41,10 @@ def read_images(paths):
     version='1.0.0')
 class MODULE(hub.Module):
     def _initialize(self, **kwargs):
-        self.default_pretrained_model_path = os.path.join(
-            self.directory, 'assets')
-        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path,
-                                          **kwargs)
-
-    def predict(self,
-                images=None,
-                paths=None,
-                data=None,
-                batch_size=1,
-                use_gpu=False,
-                **kwargs):
+        self.default_pretrained_model_path = os.path.join(self.directory, 'assets')
+        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path, **kwargs)
+
+    def predict(self, images=None, paths=None, data=None, batch_size=1, use_gpu=False, **kwargs):
 
         all_data = images if images is not None else read_images(paths)
         total_num = len(all_data)
@@ -110,36 +102,27 @@ class MODULE(hub.Module):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            paths=[args.input_path],
-            use_gpu=args.use_gpu)
+        results = self.predict(paths=[args.input_path], use_gpu=args.use_gpu)
         return results
 
     def add_module_config_arg(self):
         """
         Add the command config options.
         """
-        self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=bool,
-            default=False,
-            help="whether use GPU or not")
+        self.arg_config_group.add_argument('--use_gpu', type=bool, default=False, help="whether use GPU or not")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+
 
 if __name__ == '__main__':
     module = MODULE(directory='./new_model')

modules/thirdparty/image/classification/SpinalNet_Gemstones/gem_dataset.py

@@ -3,11 +3,13 @@ import numpy as np
 from typing import Callable
 from code.config import config_parameters
 
+
 class GemStones(paddle.io.Dataset):
     """
     step 1：paddle.io.Dataset
     """
-    def __init__(self, transforms: Callable, mode: str ='train'):
+
+    def __init__(self, transforms: Callable, mode: str = 'train'):
         """
         step 2：create reader
         """
@@ -33,7 +35,6 @@ class GemStones(paddle.io.Dataset):
         elif self.mode == 'test':
             self.data = test_data_folder
 
-
     def __getitem__(self, index):
         """
         step 3：implement __getitem__

modules/thirdparty/image/classification/SpinalNet_Gemstones/spinalnet_res101_gemstone/module.py

@@ -43,20 +43,11 @@ class BottleneckBlock(nn.Layer):
         self.conv1 = nn.Conv2D(inplanes, width, 1, bias_attr=False)
         self.bn1 = norm_layer(width)
 
-        self.conv2 = nn.Conv2D(width,
-                               width,
-                               3,
-                               padding=dilation,
-                               stride=stride,
-                               groups=groups,
-                               dilation=dilation,
-                               bias_attr=False)
+        self.conv2 = nn.Conv2D(
+            width, width, 3, padding=dilation, stride=stride, groups=groups, dilation=dilation, bias_attr=False)
         self.bn2 = norm_layer(width)
 
-        self.conv3 = nn.Conv2D(width,
-                               planes * self.expansion,
-                               1,
-                               bias_attr=False)
+        self.conv3 = nn.Conv2D(width, planes * self.expansion, 1, bias_attr=False)
         self.bn3 = norm_layer(planes * self.expansion)
         self.relu = nn.ReLU()
         self.downsample = downsample
@@ -88,13 +79,7 @@ class BottleneckBlock(nn.Layer):
 class ResNet(nn.Layer):
     def __init__(self, block=BottleneckBlock, depth=101, with_pool=True):
         super(ResNet, self).__init__()
-        layer_cfg = {
-            18: [2, 2, 2, 2],
-            34: [3, 4, 6, 3],
-            50: [3, 4, 6, 3],
-            101: [3, 4, 23, 3],
-            152: [3, 8, 36, 3]
-        }
+        layer_cfg = {18: [2, 2, 2, 2], 34: [3, 4, 6, 3], 50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3]}
         layers = layer_cfg[depth]
         self.with_pool = with_pool
         self._norm_layer = nn.BatchNorm2D
@@ -102,12 +87,7 @@ class ResNet(nn.Layer):
         self.inplanes = 64
         self.dilation = 1
 
-        self.conv1 = nn.Conv2D(3,
-                               self.inplanes,
-                               kernel_size=7,
-                               stride=2,
-                               padding=3,
-                               bias_attr=False)
+        self.conv1 = nn.Conv2D(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias_attr=False)
         self.bn1 = self._norm_layer(self.inplanes)
         self.relu = nn.ReLU()
         self.maxpool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
@@ -127,18 +107,12 @@ class ResNet(nn.Layer):
             stride = 1
         if stride != 1 or self.inplanes != planes * block.expansion:
             downsample = nn.Sequential(
-                nn.Conv2D(self.inplanes,
-                          planes * block.expansion,
-                          1,
-                          stride=stride,
-                          bias_attr=False),
+                nn.Conv2D(self.inplanes, planes * block.expansion, 1, stride=stride, bias_attr=False),
                 norm_layer(planes * block.expansion),
             )
 
         layers = []
-        layers.append(
-            block(self.inplanes, planes, stride, downsample, 1, 64,
-                  previous_dilation, norm_layer))
+        layers.append(block(self.inplanes, planes, stride, downsample, 1, 64, previous_dilation, norm_layer))
         self.inplanes = planes * block.expansion
         for _ in range(1, blocks):
             layers.append(block(self.inplanes, planes, norm_layer=norm_layer))
@@ -161,7 +135,8 @@ class ResNet(nn.Layer):
         return x
 
 
-@moduleinfo(name="spinalnet_res101_gemstone",
+@moduleinfo(
+    name="spinalnet_res101_gemstone",
     type="CV/classification",
     author="nanting03",
     author_email="975348977@qq.com",
@@ -194,20 +169,16 @@ class SpinalNet_ResNet101(nn.Layer):
         self.half_in_size = half_in_size
 
         self.fc_spinal_layer1 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size, layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size, layer_width), nn.BatchNorm1D(layer_width), nn.ReLU())
         self.fc_spinal_layer2 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_spinal_layer3 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_spinal_layer4 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_out = nn.Sequential(
             nn.Dropout(p=0.5),
             nn.Linear(layer_width * 4, class_dim),
@@ -219,8 +190,7 @@ class SpinalNet_ResNet101(nn.Layer):
             print("load custom checkpoint success")
 
         else:
-            checkpoint = os.path.join(self.directory,
-                                      'spinalnet_res101.pdparams')
+            checkpoint = os.path.join(self.directory, 'spinalnet_res101.pdparams')
             self.model_dict = paddle.load(checkpoint)
             self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
@@ -240,14 +210,9 @@ class SpinalNet_ResNet101(nn.Layer):
         y = paddle.flatten(y, 1)
 
         y1 = self.fc_spinal_layer1(y[:, 0:self.half_in_size])
-        y2 = self.fc_spinal_layer2(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1],
-                          axis=1))
-        y3 = self.fc_spinal_layer3(
-            paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
-        y4 = self.fc_spinal_layer4(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3],
-                          axis=1))
+        y2 = self.fc_spinal_layer2(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1], axis=1))
+        y3 = self.fc_spinal_layer3(paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
+        y4 = self.fc_spinal_layer4(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3], axis=1))
 
         y = paddle.concat([y1, y2, y3, y4], axis=1)
 

modules/thirdparty/image/classification/SpinalNet_Gemstones/spinalnet_res50_gemstone/module.py

@@ -43,20 +43,11 @@ class BottleneckBlock(nn.Layer):
         self.conv1 = nn.Conv2D(inplanes, width, 1, bias_attr=False)
         self.bn1 = norm_layer(width)
 
-        self.conv2 = nn.Conv2D(width,
-                               width,
-                               3,
-                               padding=dilation,
-                               stride=stride,
-                               groups=groups,
-                               dilation=dilation,
-                               bias_attr=False)
+        self.conv2 = nn.Conv2D(
+            width, width, 3, padding=dilation, stride=stride, groups=groups, dilation=dilation, bias_attr=False)
         self.bn2 = norm_layer(width)
 
-        self.conv3 = nn.Conv2D(width,
-                               planes * self.expansion,
-                               1,
-                               bias_attr=False)
+        self.conv3 = nn.Conv2D(width, planes * self.expansion, 1, bias_attr=False)
         self.bn3 = norm_layer(planes * self.expansion)
         self.relu = nn.ReLU()
         self.downsample = downsample
@@ -88,13 +79,7 @@ class BottleneckBlock(nn.Layer):
 class ResNet(nn.Layer):
     def __init__(self, block=BottleneckBlock, depth=50, with_pool=True):
         super(ResNet, self).__init__()
-        layer_cfg = {
-            18: [2, 2, 2, 2],
-            34: [3, 4, 6, 3],
-            50: [3, 4, 6, 3],
-            101: [3, 4, 23, 3],
-            152: [3, 8, 36, 3]
-        }
+        layer_cfg = {18: [2, 2, 2, 2], 34: [3, 4, 6, 3], 50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3]}
         layers = layer_cfg[depth]
         self.with_pool = with_pool
         self._norm_layer = nn.BatchNorm2D
@@ -102,12 +87,7 @@ class ResNet(nn.Layer):
         self.inplanes = 64
         self.dilation = 1
 
-        self.conv1 = nn.Conv2D(3,
-                               self.inplanes,
-                               kernel_size=7,
-                               stride=2,
-                               padding=3,
-                               bias_attr=False)
+        self.conv1 = nn.Conv2D(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias_attr=False)
         self.bn1 = self._norm_layer(self.inplanes)
         self.relu = nn.ReLU()
         self.maxpool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
@@ -127,18 +107,12 @@ class ResNet(nn.Layer):
             stride = 1
         if stride != 1 or self.inplanes != planes * block.expansion:
             downsample = nn.Sequential(
-                nn.Conv2D(self.inplanes,
-                          planes * block.expansion,
-                          1,
-                          stride=stride,
-                          bias_attr=False),
+                nn.Conv2D(self.inplanes, planes * block.expansion, 1, stride=stride, bias_attr=False),
                 norm_layer(planes * block.expansion),
             )
 
         layers = []
-        layers.append(
-            block(self.inplanes, planes, stride, downsample, 1, 64,
-                  previous_dilation, norm_layer))
+        layers.append(block(self.inplanes, planes, stride, downsample, 1, 64, previous_dilation, norm_layer))
         self.inplanes = planes * block.expansion
         for _ in range(1, blocks):
             layers.append(block(self.inplanes, planes, norm_layer=norm_layer))
@@ -161,7 +135,8 @@ class ResNet(nn.Layer):
         return x
 
 
-@moduleinfo(name="spinalnet_res50_gemstone",
+@moduleinfo(
+    name="spinalnet_res50_gemstone",
     type="CV/classification",
     author="nanting03",
     author_email="975348977@qq.com",
@@ -194,20 +169,16 @@ class SpinalNet_ResNet50(nn.Layer):
         self.half_in_size = half_in_size
 
         self.fc_spinal_layer1 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size, layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size, layer_width), nn.BatchNorm1D(layer_width), nn.ReLU())
         self.fc_spinal_layer2 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_spinal_layer3 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_spinal_layer4 = nn.Sequential(
-            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width,
-                                         layer_width),
-            nn.BatchNorm1D(layer_width), nn.ReLU())
+            nn.Dropout(p=0.5), nn.Linear(half_in_size + layer_width, layer_width), nn.BatchNorm1D(layer_width),
+            nn.ReLU())
         self.fc_out = nn.Sequential(
             nn.Dropout(p=0.5),
             nn.Linear(layer_width * 4, class_dim),
@@ -219,8 +190,7 @@ class SpinalNet_ResNet50(nn.Layer):
             print("load custom checkpoint success")
 
         else:
-            checkpoint = os.path.join(self.directory,
-                                      'spinalnet_res50.pdparams')
+            checkpoint = os.path.join(self.directory, 'spinalnet_res50.pdparams')
             self.model_dict = paddle.load(checkpoint)
             self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
@@ -240,14 +210,9 @@ class SpinalNet_ResNet50(nn.Layer):
         y = paddle.flatten(y, 1)
 
         y1 = self.fc_spinal_layer1(y[:, 0:self.half_in_size])
-        y2 = self.fc_spinal_layer2(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1],
-                          axis=1))
-        y3 = self.fc_spinal_layer3(
-            paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
-        y4 = self.fc_spinal_layer4(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3],
-                          axis=1))
+        y2 = self.fc_spinal_layer2(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1], axis=1))
+        y3 = self.fc_spinal_layer3(paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
+        y4 = self.fc_spinal_layer4(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3], axis=1))
 
         y = paddle.concat([y1, y2, y3, y4], axis=1)
 

modules/thirdparty/image/classification/SpinalNet_Gemstones/spinalnet_vgg16_gemstone/module.py

@@ -61,16 +61,9 @@ def make_layers(cfg, batch_norm=False):
 
 cfgs = {
     'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
-    'B':
-    [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
-    'D': [
-        64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512,
-        512, 512, 'M'
-    ],
-    'E': [
-        64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512,
-        'M', 512, 512, 512, 512, 'M'
-    ],
+    'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
+    'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
 }
 
 
@@ -86,7 +79,8 @@ def vgg16(batch_norm=False, **kwargs):
     return _vgg(model_name, 'D', batch_norm, **kwargs)
 
 
-@moduleinfo(name="spinalnet_vgg16_gemstone",
+@moduleinfo(
+    name="spinalnet_vgg16_gemstone",
     type="CV/classification",
     author="nanting03",
     author_email="975348977@qq.com",
@@ -142,8 +136,7 @@ class SpinalNet_VGG16(nn.Layer):
             nn.BatchNorm1D(layer_width),
             nn.ReLU(),
         )
-        self.fc_out = nn.Sequential(nn.Dropout(p=0.5),
-                                    nn.Linear(layer_width * 4, class_dim))
+        self.fc_out = nn.Sequential(nn.Dropout(p=0.5), nn.Linear(layer_width * 4, class_dim))
 
         if load_checkpoint is not None:
             self.model_dict = paddle.load(load_checkpoint)[0]
@@ -151,8 +144,7 @@ class SpinalNet_VGG16(nn.Layer):
             print("load custom checkpoint success")
 
         else:
-            checkpoint = os.path.join(self.directory,
-                                      'spinalnet_vgg16.pdparams')
+            checkpoint = os.path.join(self.directory, 'spinalnet_vgg16.pdparams')
             self.model_dict = paddle.load(checkpoint)
             self.set_dict(self.model_dict)
             print("load pretrained checkpoint success")
@@ -173,14 +165,9 @@ class SpinalNet_VGG16(nn.Layer):
         y = paddle.flatten(y, 1)
 
         y1 = self.fc_spinal_layer1(y[:, 0:self.half_in_size])
-        y2 = self.fc_spinal_layer2(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1],
-                          axis=1))
-        y3 = self.fc_spinal_layer3(
-            paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
-        y4 = self.fc_spinal_layer4(
-            paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3],
-                          axis=1))
+        y2 = self.fc_spinal_layer2(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y1], axis=1))
+        y3 = self.fc_spinal_layer3(paddle.concat([y[:, 0:self.half_in_size], y2], axis=1))
+        y4 = self.fc_spinal_layer4(paddle.concat([y[:, self.half_in_size:2 * self.half_in_size], y3], axis=1))
 
         y = paddle.concat([y1, y2, y3, y4], axis=1)
 

modules/thirdparty/image/classification/food_classification/__init__.py

-

modules/thirdparty/image/classification/food_classification/module.py

@@ -41,18 +41,10 @@ def read_images(paths):
     version='1.0.0')
 class MODULE(hub.Module):
     def _initialize(self, **kwargs):
-        self.default_pretrained_model_path = os.path.join(
-            self.directory, 'assets')
-        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path,
-                                          **kwargs)
-
-    def predict(self,
-                images=None,
-                paths=None,
-                data=None,
-                batch_size=1,
-                use_gpu=False,
-                **kwargs):
+        self.default_pretrained_model_path = os.path.join(self.directory, 'assets')
+        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path, **kwargs)
+
+    def predict(self, images=None, paths=None, data=None, batch_size=1, use_gpu=False, **kwargs):
 
         all_data = images if images is not None else read_images(paths)
         total_num = len(all_data)
@@ -110,36 +102,27 @@ class MODULE(hub.Module):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            paths=[args.input_path],
-            use_gpu=args.use_gpu)
+        results = self.predict(paths=[args.input_path], use_gpu=args.use_gpu)
         return results
 
     def add_module_config_arg(self):
         """
         Add the command config options.
         """
-        self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=bool,
-            default=False,
-            help="whether use GPU or not")
+        self.arg_config_group.add_argument('--use_gpu', type=bool, default=False, help="whether use GPU or not")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+
 
 if __name__ == '__main__':
     module = MODULE(directory='./new_model')

modules/thirdparty/image/classification/marine_biometrics/__init__.py

-

modules/thirdparty/image/classification/marine_biometrics/module.py

@@ -37,22 +37,15 @@ def read_images(paths):
     type='cv/classification',
     author='郑博培、彭兆帅',
     author_email='2733821739@qq.com, 1084667371@qq.com',
-    summary='The model uses convolution neural network to tell you the key to identify marine fish, so that anyone can call out the names of the creatures.',
+    summary=
+    'The model uses convolution neural network to tell you the key to identify marine fish, so that anyone can call out the names of the creatures.',
     version='1.0.0')
 class MODULE(hub.Module):
     def _initialize(self, **kwargs):
-        self.default_pretrained_model_path = os.path.join(
-            self.directory, 'assets')
-        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path,
-                                          **kwargs)
-
-    def predict(self,
-                images=None,
-                paths=None,
-                data=None,
-                batch_size=1,
-                use_gpu=False,
-                **kwargs):
+        self.default_pretrained_model_path = os.path.join(self.directory, 'assets')
+        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path, **kwargs)
+
+    def predict(self, images=None, paths=None, data=None, batch_size=1, use_gpu=False, **kwargs):
 
         all_data = images if images is not None else read_images(paths)
         total_num = len(all_data)
@@ -110,36 +103,27 @@ class MODULE(hub.Module):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            paths=[args.input_path],
-            use_gpu=args.use_gpu)
+        results = self.predict(paths=[args.input_path], use_gpu=args.use_gpu)
         return results
 
     def add_module_config_arg(self):
         """
         Add the command config options.
         """
-        self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=bool,
-            default=False,
-            help="whether use GPU or not")
+        self.arg_config_group.add_argument('--use_gpu', type=bool, default=False, help="whether use GPU or not")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+
 
 if __name__ == '__main__':
     module = MODULE(directory='./new_model')

modules/thirdparty/image/semantic_segmentation/WatermeterSegmentation/__init__.py

-

modules/thirdparty/image/semantic_segmentation/WatermeterSegmentation/module.py

@@ -34,29 +34,35 @@ def read_images(paths):
         images.append(cv2.imread(path))
     return images
 
+
 '''旋转图像并剪裁'''
+
+
 def rotate(
         img,  # 图片
-        pt1, pt2, pt3, pt4,
+        pt1,
+        pt2,
+        pt3,
+        pt4,
         imgOutSrc):
     # print(pt1,pt2,pt3,pt4)
-    withRect = math.sqrt((pt4[0] - pt1[0]) ** 2 + (pt4[1] - pt1[1]) ** 2)  # 矩形框的宽度
-    heightRect = math.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) **2)
+    withRect = math.sqrt((pt4[0] - pt1[0])**2 + (pt4[1] - pt1[1])**2)  # 矩形框的宽度
+    heightRect = math.sqrt((pt1[0] - pt2[0])**2 + (pt1[1] - pt2[1])**2)
     # print("矩形的宽度",withRect, "矩形的高度", heightRect)
     angle = acos((pt4[0] - pt1[0]) / withRect) * (180 / math.pi)  # 矩形框旋转角度
     # print("矩形框旋转角度", angle)
 
     if withRect > heightRect:
-        if pt4[1]>pt1[1]:
+        if pt4[1] > pt1[1]:
             pass
             # print("顺时针旋转")
         else:
             # print("逆时针旋转")
-            angle=-angle
+            angle = -angle
 
     else:
         # print("逆时针旋转")
-        angle=90 - angle
+        angle = 90 - angle
 
     height = img.shape[0]  # 原始图像高度
     width = img.shape[1]  # 原始图像宽度
@@ -76,14 +82,15 @@ def rotate(
     [[pt4[0]], [pt4[1]]] = np.dot(rotateMat, np.array([[pt4[0]], [pt4[1]], [1]]))
 
     # 处理反转的情况
-    if pt2[1]>pt4[1]:
-        pt2[1],pt4[1]=pt4[1],pt2[1]
-    if pt1[0]>pt3[0]:
-        pt1[0],pt3[0]=pt3[0],pt1[0]
+    if pt2[1] > pt4[1]:
+        pt2[1], pt4[1] = pt4[1], pt2[1]
+    if pt1[0] > pt3[0]:
+        pt1[0], pt3[0] = pt3[0], pt1[0]
 
     imgOut = imgRotation[int(pt2[1]):int(pt4[1]), int(pt1[0]):int(pt3[0])]
     cv2.imwrite(imgOutSrc, imgOut)  # 裁减得到的旋转矩形框
 
+
 @moduleinfo(
     name='WatermeterSegmentation',
     type='CV/semantic_segmentatio',
@@ -93,18 +100,10 @@ def rotate(
     version='1.0.0')
 class MODULE(hub.Module):
     def _initialize(self, **kwargs):
-        self.default_pretrained_model_path = os.path.join(
-            self.directory, 'assets')
-        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path,
-                                          **kwargs)
-
-    def predict(self,
-                images=None,
-                paths=None,
-                data=None,
-                batch_size=1,
-                use_gpu=False,
-                **kwargs):
+        self.default_pretrained_model_path = os.path.join(self.directory, 'assets')
+        self.model = pdx.deploy.Predictor(self.default_pretrained_model_path, **kwargs)
+
+    def predict(self, images=None, paths=None, data=None, batch_size=1, use_gpu=False, **kwargs):
 
         all_data = images if images is not None else read_images(paths)
         total_num = len(all_data)
@@ -134,7 +133,7 @@ class MODULE(hub.Module):
         print(type(contours[0]))
         n = 0
         m = 0
-        for index,contour in enumerate(contours):
+        for index, contour in enumerate(contours):
             if len(contour) > n:
                 n = len(contour)
                 m = index
@@ -181,7 +180,6 @@ class MODULE(hub.Module):
             res.append(result)
         return res
 
-
     @runnable
     def run_cmd(self, argvs):
         """
@@ -192,36 +190,27 @@ class MODULE(hub.Module):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            paths=[args.input_path],
-            use_gpu=args.use_gpu)
+        results = self.predict(paths=[args.input_path], use_gpu=args.use_gpu)
         return results
 
     def add_module_config_arg(self):
         """
         Add the command config options.
         """
-        self.arg_config_group.add_argument(
-            '--use_gpu',
-            type=bool,
-            default=False,
-            help="whether use GPU or not")
+        self.arg_config_group.add_argument('--use_gpu', type=bool, default=False, help="whether use GPU or not")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+
 
 if __name__ == '__main__':
     module = MODULE(directory='./new_model')

modules/thirdparty/image/text_recognition/Vehicle_License_Plate_Recognition/module.py

@@ -13,16 +13,13 @@ from paddlehub.module.module import moduleinfo, serving
     author="jm12138",
     author_email="",
     summary="Vehicle_License_Plate_Recognition",
-    version="1.0.0"
-)
+    version="1.0.0")
 class Vehicle_License_Plate_Recognition(nn.Layer):
     def __init__(self):
         super(Vehicle_License_Plate_Recognition, self).__init__()
         self.vlpr = PaddleOCR(
             det_model_dir=os.path.join(self.directory, 'det_vlpr'),
-            rec_model_dir=os.path.join(
-                self.directory, 'ch_ppocr_server_v2.0_rec_infer')
-        )
+            rec_model_dir=os.path.join(self.directory, 'ch_ppocr_server_v2.0_rec_infer'))
 
     @staticmethod
     def base64_to_cv2(b64str):
@@ -38,17 +35,11 @@ class Vehicle_License_Plate_Recognition(nn.Layer):
         if isinstance(images, list):
             for item in images:
                 for bbox, text in self.vlpr.ocr(item):
-                    results.append({
-                        'license': text[0],
-                        'bbox': bbox
-                    })
+                    results.append({'license': text[0], 'bbox': bbox})
 
         elif isinstance(images, (str, np.ndarray)):
             for bbox, text in self.vlpr.ocr(images):
-                results.append({
-                    'license': text[0],
-                    'bbox': bbox
-                })
+                results.append({'license': text[0], 'bbox': bbox})
 
         return results
 

modules/thirdparty/text/text_generation/GPT2_Base_CN/module.py

@@ -38,18 +38,15 @@ class GPT2_Base_CN(nn.Layer):
 
             # 初始预测
             ids = self.tokenizer.encode(text)
-            input_id = paddle.to_tensor(
-                np.array(ids).reshape(1, -1).astype('int64'))
+            input_id = paddle.to_tensor(np.array(ids).reshape(1, -1).astype('int64'))
             output, cached_kvs = self.model(input_id, use_cache=True)
             next_token = int(np.argmax(output[0, -1].numpy()))
             ids.append(next_token)
 
             # 使用缓存进行继续预测
-            for i in range(max_len-1):
-                input_id = paddle.to_tensor(
-                    np.array([next_token]).reshape(1, -1).astype('int64'))
-                output, cached_kvs = self.model(
-                    input_id, use_cache=True, cache=cached_kvs)
+            for i in range(max_len - 1):
+                input_id = paddle.to_tensor(np.array([next_token]).reshape(1, -1).astype('int64'))
+                output, cached_kvs = self.model(input_id, use_cache=True, cache=cached_kvs)
                 next_token = int(np.argmax(output[0, -1].numpy()))
                 ids.append(next_token)
 
@@ -79,14 +76,12 @@ class GPT2_Base_CN(nn.Layer):
         if top_p < 1.0:
             sorted_logits = paddle.sort(logits, descending=True)
             sorted_indices = paddle.argsort(logits, descending=True).numpy()
-            cumulative_probs = paddle.cumsum(paddle.nn.functional.softmax(
-                sorted_logits, axis=-1), axis=-1).numpy()
+            cumulative_probs = paddle.cumsum(paddle.nn.functional.softmax(sorted_logits, axis=-1), axis=-1).numpy()
 
             # Remove tokens with cumulative probability above the threshold
             sorted_indices_to_remove = cumulative_probs > top_p
             # Shift the indices to the right to keep also the first token above the threshold
-            sorted_indices_to_remove[...,
-                                     1:] = sorted_indices_to_remove[..., :-1]
+            sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1]
             sorted_indices_to_remove[..., 0] = 0
 
             indices_to_remove = sorted_indices[sorted_indices_to_remove]
@@ -94,7 +89,14 @@ class GPT2_Base_CN(nn.Layer):
 
         return paddle.to_tensor(logits_np)
 
-    def nucleus_sample(self, text, max_len=32, end_word=None, repitition_penalty=1.0, temperature=1.0, top_k=0, top_p=1.0):
+    def nucleus_sample(self,
+                       text,
+                       max_len=32,
+                       end_word=None,
+                       repitition_penalty=1.0,
+                       temperature=1.0,
+                       top_k=0,
+                       top_p=1.0):
         with paddle.no_grad():
             # 终止标志
             if end_word is not None:
@@ -103,33 +105,28 @@ class GPT2_Base_CN(nn.Layer):
 
             # 初始预测
             ids = self.tokenizer.encode(text)
-            input_id = paddle.to_tensor(
-                np.array(ids).reshape(1, -1).astype('int64'))
+            input_id = paddle.to_tensor(np.array(ids).reshape(1, -1).astype('int64'))
             output, cached_kvs = self.model(input_id, use_cache=True)
             next_token_logits = output[0, -1, :]
             for id in set(ids):
                 next_token_logits[id] /= repitition_penalty
             next_token_logits = next_token_logits / temperature
-            filtered_logits = self.top_k_top_p_filtering(
-                next_token_logits, top_k=top_k, top_p=top_p)
-            next_token = paddle.multinomial(paddle.nn.functional.softmax(
-                filtered_logits, axis=-1), num_samples=1).numpy()
+            filtered_logits = self.top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
+            next_token = paddle.multinomial(
+                paddle.nn.functional.softmax(filtered_logits, axis=-1), num_samples=1).numpy()
             ids += [int(next_token)]
 
             # 使用缓存进行继续预测
-            for i in range(max_len-1):
-                input_id = paddle.to_tensor(
-                    np.array([next_token]).reshape(1, -1).astype('int64'))
-                output, cached_kvs = self.model(
-                    input_id, use_cache=True, cache=cached_kvs)
+            for i in range(max_len - 1):
+                input_id = paddle.to_tensor(np.array([next_token]).reshape(1, -1).astype('int64'))
+                output, cached_kvs = self.model(input_id, use_cache=True, cache=cached_kvs)
                 next_token_logits = output[0, -1, :]
                 for id in set(ids):
                     next_token_logits[id] /= repitition_penalty
                 next_token_logits = next_token_logits / temperature
-                filtered_logits = self.top_k_top_p_filtering(
-                    next_token_logits, top_k=top_k, top_p=top_p)
-                next_token = paddle.multinomial(paddle.nn.functional.softmax(
-                    filtered_logits, axis=-1), num_samples=1).numpy()
+                filtered_logits = self.top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
+                next_token = paddle.multinomial(
+                    paddle.nn.functional.softmax(filtered_logits, axis=-1), num_samples=1).numpy()
                 ids += [int(next_token)]
 
                 # 根据终止标志停止预测

modules/thirdparty/text/text_generation/GPT2_CPM_LM/module.py

@@ -30,13 +30,11 @@ class GPT2_CPM_LM(nn.Layer):
             max_position_embeddings=1024,
             type_vocab_size=1,
             initializer_range=0.02,
-            pad_token_id=0
-        )
+            pad_token_id=0)
         self.model = GPT2ForPretraining(gpt2)
 
         # 读取CPM-LM模型参数(FP16)
-        state_dict = paddle.load(os.path.join(
-            self.directory, 'CPM-LM.pdparams'))
+        state_dict = paddle.load(os.path.join(self.directory, 'CPM-LM.pdparams'))
 
         # FP16 -> FP32
         for param in state_dict:
@@ -51,8 +49,7 @@ class GPT2_CPM_LM(nn.Layer):
         # 加载编解码器
         self.tokenizer = GPT2ChineseTokenizer(
             vocab_file=os.path.join(self.directory, 'vocab.json'),
-            model_file=os.path.join(self.directory, 'chinese_vocab.model')
-        )
+            model_file=os.path.join(self.directory, 'chinese_vocab.model'))
 
         # 初始化编码器
         _ = self.tokenizer.encode('_')
@@ -67,18 +64,15 @@ class GPT2_CPM_LM(nn.Layer):
 
             # 初始预测
             ids = self.tokenizer.encode(text)
-            input_id = paddle.to_tensor(
-                np.array(ids).reshape(1, -1).astype('int64'))
+            input_id = paddle.to_tensor(np.array(ids).reshape(1, -1).astype('int64'))
             output, cached_kvs = self.model(input_id, use_cache=True)
             next_token = int(np.argmax(output[0, -1].numpy()))
             ids.append(next_token)
 
             # 使用缓存进行继续预测
-            for i in range(max_len-1):
-                input_id = paddle.to_tensor(
-                    np.array([next_token]).reshape(1, -1).astype('int64'))
-                output, cached_kvs = self.model(
-                    input_id, use_cache=True, cache=cached_kvs)
+            for i in range(max_len - 1):
+                input_id = paddle.to_tensor(np.array([next_token]).reshape(1, -1).astype('int64'))
+                output, cached_kvs = self.model(input_id, use_cache=True, cache=cached_kvs)
                 next_token = int(np.argmax(output[0, -1].numpy()))
                 ids.append(next_token)
 
@@ -108,14 +102,12 @@ class GPT2_CPM_LM(nn.Layer):
         if top_p < 1.0:
             sorted_logits = paddle.sort(logits, descending=True)
             sorted_indices = paddle.argsort(logits, descending=True).numpy()
-            cumulative_probs = paddle.cumsum(paddle.nn.functional.softmax(
-                sorted_logits, axis=-1), axis=-1).numpy()
+            cumulative_probs = paddle.cumsum(paddle.nn.functional.softmax(sorted_logits, axis=-1), axis=-1).numpy()
 
             # Remove tokens with cumulative probability above the threshold
             sorted_indices_to_remove = cumulative_probs > top_p
             # Shift the indices to the right to keep also the first token above the threshold
-            sorted_indices_to_remove[...,
-                                     1:] = sorted_indices_to_remove[..., :-1]
+            sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1]
             sorted_indices_to_remove[..., 0] = 0
 
             indices_to_remove = sorted_indices[sorted_indices_to_remove]
@@ -123,7 +115,14 @@ class GPT2_CPM_LM(nn.Layer):
 
         return paddle.to_tensor(logits_np)
 
-    def nucleus_sample(self, text, max_len=32, end_word=None, repitition_penalty=1.0, temperature=1.0, top_k=0, top_p=1.0):
+    def nucleus_sample(self,
+                       text,
+                       max_len=32,
+                       end_word=None,
+                       repitition_penalty=1.0,
+                       temperature=1.0,
+                       top_k=0,
+                       top_p=1.0):
         with paddle.no_grad():
             # 终止标志
             if end_word is not None:
@@ -132,35 +131,30 @@ class GPT2_CPM_LM(nn.Layer):
 
             # 初始预测
             ids = self.tokenizer.encode(text)
-            input_id = paddle.to_tensor(
-                np.array(ids).reshape(1, -1).astype('int64'))
+            input_id = paddle.to_tensor(np.array(ids).reshape(1, -1).astype('int64'))
             output, cached_kvs = self.model(input_id, use_cache=True)
             next_token_logits = output[0, -1, :]
             for id in set(ids):
                 next_token_logits[id] /= repitition_penalty
             next_token_logits = next_token_logits / temperature
             next_token_logits[self.tokenizer.encoder['<unk>']] = -float('Inf')
-            filtered_logits = self.top_k_top_p_filtering(
-                next_token_logits, top_k=top_k, top_p=top_p)
-            next_token = paddle.multinomial(paddle.nn.functional.softmax(
-                filtered_logits, axis=-1), num_samples=1).numpy()
+            filtered_logits = self.top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
+            next_token = paddle.multinomial(
+                paddle.nn.functional.softmax(filtered_logits, axis=-1), num_samples=1).numpy()
             ids += [int(next_token)]
 
             # 使用缓存进行继续预测
-            for i in range(max_len-1):
-                input_id = paddle.to_tensor(
-                    np.array([next_token]).reshape(1, -1).astype('int64'))
-                output, cached_kvs = self.model(
-                    input_id, use_cache=True, cache=cached_kvs)
+            for i in range(max_len - 1):
+                input_id = paddle.to_tensor(np.array([next_token]).reshape(1, -1).astype('int64'))
+                output, cached_kvs = self.model(input_id, use_cache=True, cache=cached_kvs)
                 next_token_logits = output[0, -1, :]
                 for id in set(ids):
                     next_token_logits[id] /= repitition_penalty
                 next_token_logits = next_token_logits / temperature
                 next_token_logits[self.tokenizer.encoder['<unk>']] = -float('Inf')
-                filtered_logits = self.top_k_top_p_filtering(
-                    next_token_logits, top_k=top_k, top_p=top_p)
-                next_token = paddle.multinomial(paddle.nn.functional.softmax(
-                    filtered_logits, axis=-1), num_samples=1).numpy()
+                filtered_logits = self.top_k_top_p_filtering(next_token_logits, top_k=top_k, top_p=top_p)
+                next_token = paddle.multinomial(
+                    paddle.nn.functional.softmax(filtered_logits, axis=-1), num_samples=1).numpy()
                 ids += [int(next_token)]
 
                 # 根据终止标志停止预测

modules/thirdparty/video/Video_editing/SkyAR/__init__.py

-

modules/thirdparty/video/Video_editing/SkyAR/module.py

@@ -4,41 +4,42 @@ from .skyfilter import SkyFilter
 from paddlehub.module.module import moduleinfo
 
 
-@moduleinfo(
-    name="SkyAR",
-    type="CV/Video_editing",
-    author="jm12138",
-    author_email="",
-    summary="SkyAR",
-    version="1.0.0"
-)
+@moduleinfo(name="SkyAR", type="CV/Video_editing", author="jm12138", author_email="", summary="SkyAR", version="1.0.0")
 class SkyAR(nn.Layer):
     def __init__(self, model_path=None):
         super(SkyAR, self).__init__()
-        self.imgs = ['cloudy', 'district9ship', 'floatingcastle',
-                     'galaxy', 'jupiter', 'rainy', 'sunny', 'sunset', 'supermoon']
+        self.imgs = [
+            'cloudy', 'district9ship', 'floatingcastle', 'galaxy', 'jupiter', 'rainy', 'sunny', 'sunset', 'supermoon'
+        ]
         self.videos = ['thunderstorm']
         if model_path:
             self.model_path = model_path
         else:
             self.model_path = os.path.join(self.directory, './ResNet50FCN')
 
-    def MagicSky(
-        self, video_path, save_path, config='jupiter',
-        is_rainy=False, preview_frames_num=0, is_video_sky=False, is_show=False,
-        skybox_img=None, skybox_video=None, rain_cap_path=None,
-        halo_effect=True, auto_light_matching=False,
-        relighting_factor=0.8, recoloring_factor=0.5, skybox_center_crop=0.5
-    ):
+    def MagicSky(self,
+                 video_path,
+                 save_path,
+                 config='jupiter',
+                 is_rainy=False,
+                 preview_frames_num=0,
+                 is_video_sky=False,
+                 is_show=False,
+                 skybox_img=None,
+                 skybox_video=None,
+                 rain_cap_path=None,
+                 halo_effect=True,
+                 auto_light_matching=False,
+                 relighting_factor=0.8,
+                 recoloring_factor=0.5,
+                 skybox_center_crop=0.5):
         if config in self.imgs:
-            skybox_img = os.path.join(
-                self.directory, 'skybox', '%s.jpg' % config)
+            skybox_img = os.path.join(self.directory, 'skybox', '%s.jpg' % config)
             skybox_video = None
             is_video_sky = False
         elif config in self.videos:
             skybox_img = None
-            skybox_video = os.path.join(
-                self.directory, 'skybox', '%s.mp4' % config)
+            skybox_video = os.path.join(self.directory, 'skybox', '%s.mp4' % config)
             is_video_sky = True
         elif skybox_img:
             is_video_sky = False
@@ -49,8 +50,7 @@ class SkyAR(nn.Layer):
             raise 'please check your configs'
 
         if not rain_cap_path:
-            rain_cap_path = os.path.join(
-                self.directory, 'rain_streaks', 'videoplayback.mp4')
+            rain_cap_path = os.path.join(self.directory, 'rain_streaks', 'videoplayback.mp4')
 
         skyfilter = SkyFilter(
             model_path=self.model_path,
@@ -67,7 +67,6 @@ class SkyAR(nn.Layer):
             skybox_video=skybox_video,
             is_video=is_video_sky,
             is_rainy=is_rainy,
-            is_show=is_show
-        )
+            is_show=is_show)
 
         skyfilter.run(preview_frames_num)

modules/thirdparty/video/Video_editing/SkyAR/rain.py

@@ -29,7 +29,7 @@ class Rain():
         return rain_layer
 
     def _create_haze_layer(self, rain_layer):
-        return 0.1*np.ones_like(rain_layer)
+        return 0.1 * np.ones_like(rain_layer)
 
     def forward(self, img):
         # get input image size
@@ -54,7 +54,7 @@ class Rain():
         img_out = 1 - (1 - rain_layer) * (1 - img)
 
         # gamma and light correction
-        img_out = self.light_correction*(img_out**self.gamma)
+        img_out = self.light_correction * (img_out**self.gamma)
 
         # check boundary
         img_out = np.clip(img_out, a_min=0, a_max=1.)

modules/thirdparty/video/Video_editing/SkyAR/skybox.py

@@ -6,10 +6,8 @@ from .utils import build_transformation_matrix, update_transformation_matrix, es
 
 
 class SkyBox():
-    def __init__(
-            self, out_size, skybox_img, skybox_video, halo_effect,
-            auto_light_matching, relighting_factor, recoloring_factor,
-            skybox_center_crop, rain_cap_path, is_video, is_rainy):
+    def __init__(self, out_size, skybox_img, skybox_video, halo_effect, auto_light_matching, relighting_factor,
+                 recoloring_factor, skybox_center_crop, rain_cap_path, is_video, is_rainy):
 
         self.out_size_w, self.out_size_h = out_size
 
@@ -28,12 +26,7 @@ class SkyBox():
         self.skybox_center_crop = skybox_center_crop
         self.load_skybox()
         self.rainmodel = Rain(
-            rain_cap_path=rain_cap_path,
-            rain_intensity=0.8,
-            haze_intensity=0.0,
-            gamma=1.0,
-            light_correction=1.0
-        )
+            rain_cap_path=rain_cap_path, rain_intensity=0.8, haze_intensity=0.0, gamma=1.0, light_correction=1.0)
 
         # motion parameters
         self.M = np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32)
@@ -43,10 +36,8 @@ class SkyBox():
     def tile_skybox_img(self, imgtile):
         screen_y1 = int(imgtile.shape[0] / 2 - self.out_size_h / 2)
         screen_x1 = int(imgtile.shape[1] / 2 - self.out_size_w / 2)
-        imgtile = np.concatenate(
-            [imgtile[screen_y1:, :, :], imgtile[0:screen_y1, :, :]], axis=0)
-        imgtile = np.concatenate(
-            [imgtile[:, screen_x1:, :], imgtile[:, 0:screen_x1, :]], axis=1)
+        imgtile = np.concatenate([imgtile[screen_y1:, :, :], imgtile[0:screen_y1, :, :]], axis=0)
+        imgtile = np.concatenate([imgtile[:, screen_x1:, :], imgtile[:, 0:screen_x1, :]], axis=1)
 
         return imgtile
 
@@ -57,12 +48,9 @@ class SkyBox():
             skybox_img = cv2.imread(self.skybox_img, cv2.IMREAD_COLOR)
             skybox_img = cv2.cvtColor(skybox_img, cv2.COLOR_BGR2RGB)
 
-            self.skybox_img = cv2.resize(
-                skybox_img, (self.out_size_w, self.out_size_h))
+            self.skybox_img = cv2.resize(skybox_img, (self.out_size_w, self.out_size_h))
             cc = 1. / self.skybox_center_crop
-            imgtile = cv2.resize(
-                skybox_img, (int(cc * self.out_size_w),
-                             int(cc*self.out_size_h)))
+            imgtile = cv2.resize(skybox_img, (int(cc * self.out_size_w), int(cc * self.out_size_h)))
             self.skybox_imgx2 = self.tile_skybox_img(imgtile)
             self.skybox_imgx2 = np.expand_dims(self.skybox_imgx2, axis=0)
 
@@ -71,15 +59,11 @@ class SkyBox():
             cap = cv2.VideoCapture(self.skybox_video)
             m_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             cc = 1. / self.skybox_center_crop
-            self.skybox_imgx2 = np.zeros(
-                [m_frames, int(cc*self.out_size_h),
-                 int(cc*self.out_size_w), 3], np.uint8)
+            self.skybox_imgx2 = np.zeros([m_frames, int(cc * self.out_size_h), int(cc * self.out_size_w), 3], np.uint8)
             for i in range(m_frames):
                 _, skybox_img = cap.read()
                 skybox_img = cv2.cvtColor(skybox_img, cv2.COLOR_BGR2RGB)
-                imgtile = cv2.resize(
-                    skybox_img, (int(cc * self.out_size_w),
-                                 int(cc * self.out_size_h)))
+                imgtile = cv2.resize(skybox_img, (int(cc * self.out_size_w), int(cc * self.out_size_h)))
                 skybox_imgx2 = self.tile_skybox_img(imgtile)
                 self.skybox_imgx2[i, :] = skybox_imgx2
 
@@ -87,8 +71,7 @@ class SkyBox():
         r, eps = 20, 0.01
         refined_skymask = guidedfilter(img[:, :, 2], G_pred[:, :, 0], r, eps)
 
-        refined_skymask = np.stack(
-            [refined_skymask, refined_skymask, refined_skymask], axis=-1)
+        refined_skymask = np.stack([refined_skymask, refined_skymask, refined_skymask], axis=-1)
 
         return np.clip(refined_skymask, a_min=0, a_max=1)
 
@@ -98,14 +81,13 @@ class SkyBox():
         nbgs, bgh, bgw, c = self.skybox_imgx2.shape
         fetch_id = self.frame_id % nbgs
         skybg_warp = cv2.warpAffine(
-            self.skybox_imgx2[fetch_id, :, :, :], self.M,
-            (bgw, bgh), borderMode=cv2.BORDER_WRAP)
+            self.skybox_imgx2[fetch_id, :, :, :], self.M, (bgw, bgh), borderMode=cv2.BORDER_WRAP)
 
         skybg = skybg_warp[0:self.out_size_h, 0:self.out_size_w, :]
 
         self.frame_id += 1
 
-        return np.array(skybg, np.float32)/255.
+        return np.array(skybg, np.float32) / 255.
 
     def skybox_tracking(self, frame, frame_prev, skymask):
         if np.mean(skymask) < 0.05:
@@ -113,27 +95,25 @@ class SkyBox():
             return np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32)
 
         prev_gray = cv2.cvtColor(frame_prev, cv2.COLOR_RGB2GRAY)
-        prev_gray = np.array(255*prev_gray, dtype=np.uint8)
+        prev_gray = np.array(255 * prev_gray, dtype=np.uint8)
         curr_gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
-        curr_gray = np.array(255*curr_gray, dtype=np.uint8)
+        curr_gray = np.array(255 * curr_gray, dtype=np.uint8)
 
         mask = np.array(skymask[:, :, 0] > 0.99, dtype=np.uint8)
 
-        template_size = int(0.05*mask.shape[0])
+        template_size = int(0.05 * mask.shape[0])
         mask = cv2.erode(mask, np.ones([template_size, template_size]))
 
         # ShiTomasi corner detection
         prev_pts = cv2.goodFeaturesToTrack(
-            prev_gray, mask=mask, maxCorners=200,
-            qualityLevel=0.01, minDistance=30, blockSize=3)
+            prev_gray, mask=mask, maxCorners=200, qualityLevel=0.01, minDistance=30, blockSize=3)
 
         if prev_pts is None:
             print('no feature point detected')
             return np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32)
 
         # Calculate optical flow (i.e. track feature points)
-        curr_pts, status, err = cv2.calcOpticalFlowPyrLK(
-            prev_gray, curr_gray, prev_pts, None)
+        curr_pts, status, err = cv2.calcOpticalFlowPyrLK(prev_gray, curr_gray, prev_pts, None)
         # Filter only valid points
         idx = np.where(status == 1)[0]
         if idx.size == 0:
@@ -147,15 +127,14 @@ class SkyBox():
             return np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32)
 
         # limit the motion to translation + rotation
-        dxdyda = estimate_partial_transform((
-            np.array(prev_pts), np.array(curr_pts)))
+        dxdyda = estimate_partial_transform((np.array(prev_pts), np.array(curr_pts)))
         m = build_transformation_matrix(dxdyda)
 
         return m
 
     def relighting(self, img, skybg, skymask):
         # color matching, reference: skybox_img
-        step = int(img.shape[0]/20)
+        step = int(img.shape[0] / 20)
         skybg_thumb = skybg[::step, ::step, :]
         img_thumb = img[::step, ::step, :]
         skymask_thumb = skymask[::step, ::step, :]
@@ -163,7 +142,7 @@ class SkyBox():
         img_mean = np.sum(img_thumb * (1-skymask_thumb), axis=(0, 1), keepdims=True) \
             / ((1-skymask_thumb).sum(axis=(0, 1), keepdims=True) + 1e-9)
         diff = skybg_mean - img_mean
-        img_colortune = img + self.recoloring_factor*diff
+        img_colortune = img + self.recoloring_factor * diff
 
         if self.auto_light_matching:
             img = img_colortune
@@ -176,11 +155,9 @@ class SkyBox():
 
     def halo(self, syneth, skybg, skymask):
         # reflection
-        halo = 0.5*cv2.blur(
-            skybg*skymask, (int(self.out_size_w/5),
-                            int(self.out_size_w/5)))
+        halo = 0.5 * cv2.blur(skybg * skymask, (int(self.out_size_w / 5), int(self.out_size_w / 5)))
         # screen blend 1 - (1-a)(1-b)
-        syneth_with_halo = 1 - (1-syneth) * (1-halo)
+        syneth_with_halo = 1 - (1 - syneth) * (1 - halo)
 
         return syneth_with_halo
 

modules/thirdparty/video/Video_editing/SkyAR/skyfilter.py

@@ -8,37 +8,37 @@ __all__ = ['SkyFilter']
 
 
 class SkyFilter():
-    def __init__(self, model_path, video_path, save_path, in_size,
-                 halo_effect, auto_light_matching, relighting_factor,
-                 recoloring_factor, skybox_center_crop, rain_cap_path,
-                 skybox_img, skybox_video, is_video, is_rainy, is_show
-                 ):
+    def __init__(self, model_path, video_path, save_path, in_size, halo_effect, auto_light_matching, relighting_factor,
+                 recoloring_factor, skybox_center_crop, rain_cap_path, skybox_img, skybox_video, is_video, is_rainy,
+                 is_show):
         self.in_size = in_size
         self.is_show = is_show
         self.cap = cv2.VideoCapture(video_path)
         self.m_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
         self.fps = self.cap.get(cv2.CAP_PROP_FPS)
-        self.out_size = int(self.cap.get(
-            cv2.CAP_PROP_FRAME_WIDTH)), int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.out_size = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-        self.model = paddle.jit.load(
-            model_path, model_filename='__model__', params_filename='__params__')
+        self.model = paddle.jit.load(model_path, model_filename='__model__', params_filename='__params__')
         self.model.eval()
 
         self.skyboxengine = SkyBox(
-            out_size=self.out_size, skybox_img=skybox_img, skybox_video=skybox_video,
-            halo_effect=halo_effect, auto_light_matching=auto_light_matching,
-            relighting_factor=relighting_factor, recoloring_factor=recoloring_factor,
-            skybox_center_crop=skybox_center_crop, rain_cap_path=rain_cap_path,
-            is_video=is_video, is_rainy=is_rainy
-        )
+            out_size=self.out_size,
+            skybox_img=skybox_img,
+            skybox_video=skybox_video,
+            halo_effect=halo_effect,
+            auto_light_matching=auto_light_matching,
+            relighting_factor=relighting_factor,
+            recoloring_factor=recoloring_factor,
+            skybox_center_crop=skybox_center_crop,
+            rain_cap_path=rain_cap_path,
+            is_video=is_video,
+            is_rainy=is_rainy)
         path, _ = os.path.split(save_path)
         if path == '':
             path = '.'
         if not os.path.exists(path):
             os.mkdir(path)
-        self.video_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'MP4V'),
-                                            self.fps, self.out_size)
+        self.video_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'MP4V'), self.fps, self.out_size)
 
     def synthesize(self, img_HD, img_HD_prev):
         h, w, _ = img_HD.shape
@@ -50,8 +50,7 @@ class SkyFilter():
         img = paddle.to_tensor(img)
 
         G_pred = self.model(img)
-        G_pred = paddle.nn.functional.interpolate(
-            G_pred, (h, w), mode='bicubic', align_corners=False)
+        G_pred = paddle.nn.functional.interpolate(G_pred, (h, w), mode='bicubic', align_corners=False)
         G_pred = G_pred[0, :].transpose([1, 2, 0])
         G_pred = paddle.concat([G_pred, G_pred, G_pred], axis=-1)
         G_pred = G_pred.detach().numpy()
@@ -68,7 +67,7 @@ class SkyFilter():
         frames_num = preview_frames_num if 0 < preview_frames_num < self.m_frames else self.m_frames
 
         print('frames_num: %d, running evaluation...' % frames_num)
-        for idx in range(1, frames_num+1):
+        for idx in range(1, frames_num + 1):
             ret, frame = self.cap.read()
             if ret:
                 frame = cv2.resize(frame, self.out_size)
@@ -84,7 +83,7 @@ class SkyFilter():
                 if self.is_show:
                     show_img = np.concatenate([frame, result], 1)
                     h, w = show_img.shape[:2]
-                    show_img = cv2.resize(show_img, (720, int(720/w*h)))
+                    show_img = cv2.resize(show_img, (720, int(720 / w * h)))
                     cv2.imshow('preview', show_img)
                     k = cv2.waitKey(1)
                     if (k == 27) or (cv2.getWindowProperty('preview', 0) == -1):

modules/thirdparty/video/Video_editing/SkyAR/utils.py

@@ -3,10 +3,7 @@ import numpy as np
 from sklearn.neighbors import KernelDensity
 
 __all__ = [
-    'build_transformation_matrix',
-    'update_transformation_matrix',
-    'estimate_partial_transform',
-    'removeOutliers',
+    'build_transformation_matrix', 'update_transformation_matrix', 'estimate_partial_transform', 'removeOutliers',
     'guidedfilter'
 ]
 
@@ -48,8 +45,7 @@ def estimate_partial_transform(matched_keypoints):
     :return: transform as list of [dx, dy, da]
     """
     prev_matched_kp, cur_matched_kp = matched_keypoints
-    transform = cv2.estimateAffinePartial2D(np.array(prev_matched_kp),
-                                            np.array(cur_matched_kp))[0]
+    transform = cv2.estimateAffinePartial2D(np.array(prev_matched_kp), np.array(cur_matched_kp))[0]
 
     if transform is not None:
         # translation x
@@ -83,16 +79,14 @@ def boxfilter(img, r):
     imDst = np.zeros_like(img)
 
     imCum = np.cumsum(img, 0)
-    imDst[0: r+1, :] = imCum[r: 2*r+1, :]
-    imDst[r+1: rows-r, :] = imCum[2*r+1: rows, :] - imCum[0: rows-2*r-1, :]
-    imDst[rows-r: rows, :] = np.tile(imCum[rows-1, :],
-                                     [r, 1]) - imCum[rows-2*r-1: rows-r-1, :]
+    imDst[0:r + 1, :] = imCum[r:2 * r + 1, :]
+    imDst[r + 1:rows - r, :] = imCum[2 * r + 1:rows, :] - imCum[0:rows - 2 * r - 1, :]
+    imDst[rows - r:rows, :] = np.tile(imCum[rows - 1, :], [r, 1]) - imCum[rows - 2 * r - 1:rows - r - 1, :]
 
     imCum = np.cumsum(imDst, 1)
-    imDst[:, 0: r+1] = imCum[:, r: 2*r+1]
-    imDst[:, r+1: cols-r] = imCum[:, 2*r+1: cols] - imCum[:, 0: cols-2*r-1]
-    imDst[:, cols-r: cols] = np.tile(imCum[:, cols-1],
-                                     [r, 1]).T - imCum[:, cols-2*r-1: cols-r-1]
+    imDst[:, 0:r + 1] = imCum[:, r:2 * r + 1]
+    imDst[:, r + 1:cols - r] = imCum[:, 2 * r + 1:cols] - imCum[:, 0:cols - 2 * r - 1]
+    imDst[:, cols - r:cols] = np.tile(imCum[:, cols - 1], [r, 1]).T - imCum[:, cols - 2 * r - 1:cols - r - 1]
 
     return imDst
 

paddlehub/compat/module/module_desc_pb2.py

@@ -64,7 +64,8 @@ _KVDATA_KEYTYPEENTRY = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='key',
+        _descriptor.FieldDescriptor(
+            name='key',
             full_name='paddlehub.module.desc.KVData.KeyTypeEntry.key',
             index=0,
             number=1,
@@ -79,7 +80,8 @@ _KVDATA_KEYTYPEENTRY = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='value',
+        _descriptor.FieldDescriptor(
+            name='value',
             full_name='paddlehub.module.desc.KVData.KeyTypeEntry.value',
             index=1,
             number=2,
@@ -114,7 +116,8 @@ _KVDATA_DATAENTRY = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='key',
+        _descriptor.FieldDescriptor(
+            name='key',
             full_name='paddlehub.module.desc.KVData.DataEntry.key',
             index=0,
             number=1,
@@ -129,7 +132,8 @@ _KVDATA_DATAENTRY = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='value',
+        _descriptor.FieldDescriptor(
+            name='value',
             full_name='paddlehub.module.desc.KVData.DataEntry.value',
             index=1,
             number=2,
@@ -164,7 +168,8 @@ _KVDATA = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='key_type',
+        _descriptor.FieldDescriptor(
+            name='key_type',
             full_name='paddlehub.module.desc.KVData.key_type',
             index=0,
             number=1,
@@ -179,7 +184,8 @@ _KVDATA = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='data',
+        _descriptor.FieldDescriptor(
+            name='data',
             full_name='paddlehub.module.desc.KVData.data',
             index=1,
             number=2,
@@ -217,7 +223,8 @@ _MODULEATTR = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='type',
+        _descriptor.FieldDescriptor(
+            name='type',
             full_name='paddlehub.module.desc.ModuleAttr.type',
             index=0,
             number=1,
@@ -232,7 +239,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='i',
+        _descriptor.FieldDescriptor(
+            name='i',
             full_name='paddlehub.module.desc.ModuleAttr.i',
             index=1,
             number=2,
@@ -247,7 +255,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='f',
+        _descriptor.FieldDescriptor(
+            name='f',
             full_name='paddlehub.module.desc.ModuleAttr.f',
             index=2,
             number=3,
@@ -262,7 +271,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='b',
+        _descriptor.FieldDescriptor(
+            name='b',
             full_name='paddlehub.module.desc.ModuleAttr.b',
             index=3,
             number=4,
@@ -277,7 +287,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='s',
+        _descriptor.FieldDescriptor(
+            name='s',
             full_name='paddlehub.module.desc.ModuleAttr.s',
             index=4,
             number=5,
@@ -292,7 +303,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='map',
+        _descriptor.FieldDescriptor(
+            name='map',
             full_name='paddlehub.module.desc.ModuleAttr.map',
             index=5,
             number=6,
@@ -307,7 +319,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='list',
+        _descriptor.FieldDescriptor(
+            name='list',
             full_name='paddlehub.module.desc.ModuleAttr.list',
             index=6,
             number=7,
@@ -322,7 +335,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='set',
+        _descriptor.FieldDescriptor(
+            name='set',
             full_name='paddlehub.module.desc.ModuleAttr.set',
             index=7,
             number=8,
@@ -337,7 +351,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='object',
+        _descriptor.FieldDescriptor(
+            name='object',
             full_name='paddlehub.module.desc.ModuleAttr.object',
             index=8,
             number=9,
@@ -352,7 +367,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='name',
+        _descriptor.FieldDescriptor(
+            name='name',
             full_name='paddlehub.module.desc.ModuleAttr.name',
             index=9,
             number=10,
@@ -367,7 +383,8 @@ _MODULEATTR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='info',
+        _descriptor.FieldDescriptor(
+            name='info',
             full_name='paddlehub.module.desc.ModuleAttr.info',
             index=10,
             number=11,
@@ -402,7 +419,8 @@ _FEEDDESC = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='var_name',
+        _descriptor.FieldDescriptor(
+            name='var_name',
             full_name='paddlehub.module.desc.FeedDesc.var_name',
             index=0,
             number=1,
@@ -417,7 +435,8 @@ _FEEDDESC = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='alias',
+        _descriptor.FieldDescriptor(
+            name='alias',
             full_name='paddlehub.module.desc.FeedDesc.alias',
             index=1,
             number=2,
@@ -452,7 +471,8 @@ _FETCHDESC = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='var_name',
+        _descriptor.FieldDescriptor(
+            name='var_name',
             full_name='paddlehub.module.desc.FetchDesc.var_name',
             index=0,
             number=1,
@@ -467,7 +487,8 @@ _FETCHDESC = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='alias',
+        _descriptor.FieldDescriptor(
+            name='alias',
             full_name='paddlehub.module.desc.FetchDesc.alias',
             index=1,
             number=2,
@@ -502,7 +523,8 @@ _MODULEVAR = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='fetch_desc',
+        _descriptor.FieldDescriptor(
+            name='fetch_desc',
             full_name='paddlehub.module.desc.ModuleVar.fetch_desc',
             index=0,
             number=1,
@@ -517,7 +539,8 @@ _MODULEVAR = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='feed_desc',
+        _descriptor.FieldDescriptor(
+            name='feed_desc',
             full_name='paddlehub.module.desc.ModuleVar.feed_desc',
             index=1,
             number=2,
@@ -552,7 +575,8 @@ _MODULEDESC_SIGN2VARENTRY = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='key',
+        _descriptor.FieldDescriptor(
+            name='key',
             full_name='paddlehub.module.desc.ModuleDesc.Sign2varEntry.key',
             index=0,
             number=1,
@@ -567,7 +591,8 @@ _MODULEDESC_SIGN2VARENTRY = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='value',
+        _descriptor.FieldDescriptor(
+            name='value',
             full_name='paddlehub.module.desc.ModuleDesc.Sign2varEntry.value',
             index=1,
             number=2,
@@ -602,7 +627,8 @@ _MODULEDESC = _descriptor.Descriptor(
     file=DESCRIPTOR,
     containing_type=None,
     fields=[
-        _descriptor.FieldDescriptor(name='sign2var',
+        _descriptor.FieldDescriptor(
+            name='sign2var',
             full_name='paddlehub.module.desc.ModuleDesc.sign2var',
             index=0,
             number=2,
@@ -617,7 +643,8 @@ _MODULEDESC = _descriptor.Descriptor(
             is_extension=False,
             extension_scope=None,
             options=None),
-        _descriptor.FieldDescriptor(name='attr',
+        _descriptor.FieldDescriptor(
+            name='attr',
             full_name='paddlehub.module.desc.ModuleDesc.attr',
             index=1,
             number=3,
@@ -679,14 +706,16 @@ KVData = _reflection.GeneratedProtocolMessageType(
         KeyTypeEntry=_reflection.GeneratedProtocolMessageType(
             'KeyTypeEntry',
             (_message.Message, ),
-            dict(DESCRIPTOR=_KVDATA_KEYTYPEENTRY,
+            dict(
+                DESCRIPTOR=_KVDATA_KEYTYPEENTRY,
                 __module__='module_desc_pb2'
                 # @@protoc_insertion_point(class_scope:paddlehub.module.desc.KVData.KeyTypeEntry)
             )),
         DataEntry=_reflection.GeneratedProtocolMessageType(
             'DataEntry',
             (_message.Message, ),
-            dict(DESCRIPTOR=_KVDATA_DATAENTRY,
+            dict(
+                DESCRIPTOR=_KVDATA_DATAENTRY,
                 __module__='module_desc_pb2'
                 # @@protoc_insertion_point(class_scope:paddlehub.module.desc.KVData.DataEntry)
             )),
@@ -701,7 +730,8 @@ _sym_db.RegisterMessage(KVData.DataEntry)
 ModuleAttr = _reflection.GeneratedProtocolMessageType(
     'ModuleAttr',
     (_message.Message, ),
-    dict(DESCRIPTOR=_MODULEATTR,
+    dict(
+        DESCRIPTOR=_MODULEATTR,
         __module__='module_desc_pb2'
         # @@protoc_insertion_point(class_scope:paddlehub.module.desc.ModuleAttr)
     ))
@@ -710,7 +740,8 @@ _sym_db.RegisterMessage(ModuleAttr)
 FeedDesc = _reflection.GeneratedProtocolMessageType(
     'FeedDesc',
     (_message.Message, ),
-    dict(DESCRIPTOR=_FEEDDESC,
+    dict(
+        DESCRIPTOR=_FEEDDESC,
         __module__='module_desc_pb2'
         # @@protoc_insertion_point(class_scope:paddlehub.module.desc.FeedDesc)
     ))
@@ -719,7 +750,8 @@ _sym_db.RegisterMessage(FeedDesc)
 FetchDesc = _reflection.GeneratedProtocolMessageType(
     'FetchDesc',
     (_message.Message, ),
-    dict(DESCRIPTOR=_FETCHDESC,
+    dict(
+        DESCRIPTOR=_FETCHDESC,
         __module__='module_desc_pb2'
         # @@protoc_insertion_point(class_scope:paddlehub.module.desc.FetchDesc)
     ))
@@ -728,7 +760,8 @@ _sym_db.RegisterMessage(FetchDesc)
 ModuleVar = _reflection.GeneratedProtocolMessageType(
     'ModuleVar',
     (_message.Message, ),
-    dict(DESCRIPTOR=_MODULEVAR,
+    dict(
+        DESCRIPTOR=_MODULEVAR,
         __module__='module_desc_pb2'
         # @@protoc_insertion_point(class_scope:paddlehub.module.desc.ModuleVar)
     ))
@@ -741,7 +774,8 @@ ModuleDesc = _reflection.GeneratedProtocolMessageType(
         Sign2varEntry=_reflection.GeneratedProtocolMessageType(
             'Sign2varEntry',
             (_message.Message, ),
-            dict(DESCRIPTOR=_MODULEDESC_SIGN2VARENTRY,
+            dict(
+                DESCRIPTOR=_MODULEDESC_SIGN2VARENTRY,
                 __module__='module_desc_pb2'
                 # @@protoc_insertion_point(class_scope:paddlehub.module.desc.ModuleDesc.Sign2varEntry)
             )),

paddlehub/datasets/base_audio_dataset.py

@@ -27,6 +27,7 @@ class InputExample(object):
     """
     Input example of one audio sample.
     """
+
     def __init__(self, guid: int, source: Union[list, str], label: Optional[str] = None):
         self.guid = guid
         self.source = source
@@ -37,6 +38,7 @@ class BaseAudioDataset(object):
     """
     Base class of speech dataset.
     """
+
     def __init__(self, base_path: str, data_file: str, mode: Optional[str] = "train"):
         self.data_file = os.path.join(base_path, data_file)
         self.mode = mode
@@ -92,7 +94,8 @@ class AudioClassificationDataset(BaseAudioDataset, paddle.io.Dataset):
             if self.feat_type == 'raw':
                 record['feat'] = example.source
             elif self.feat_type == 'mel':
-                record['feat'] = extract_melspectrogram(example.source,
+                record['feat'] = extract_melspectrogram(
+                    example.source,
                     sample_rate=self.feat_cfg['sample_rate'],
                     window_size=self.feat_cfg['window_size'],
                     hop_size=self.feat_cfg['hop_size'],

paddlehub/datasets/base_nlp_dataset.py

@@ -557,7 +557,9 @@ class TextMatchingDataset(BaseNLPDataset, paddle.io.Dataset):
                     pad_to_max_seq_len=True, return_length=True)
                 record = {'text_a': record_a, 'text_b': record_b}
             else:
-                raise RuntimeError("Unknown type of self.tokenizer: {}, it must be an instance of PretrainedTokenizer".format(type(self.tokenizer)))
+                raise RuntimeError(
+                    "Unknown type of self.tokenizer: {}, it must be an instance of PretrainedTokenizer".format(
+                        type(self.tokenizer)))
 
             if not record:
                 logger.info(
@@ -582,7 +584,9 @@ class TextMatchingDataset(BaseNLPDataset, paddle.io.Dataset):
             else:
                 return query_input_ids, query_token_type_ids, title_input_ids, title_token_type_ids
         else:
-            raise RuntimeError("Unknown type of self.tokenizer: {}, it must be an instance of PretrainedTokenizer".format(type(self.tokenizer)))
+            raise RuntimeError(
+                "Unknown type of self.tokenizer: {}, it must be an instance of PretrainedTokenizer".format(
+                    type(self.tokenizer)))
 
     def __len__(self):
         return len(self.records)

paddlehub/datasets/base_seg_dataset.py

@@ -63,46 +63,34 @@ class SegDataset(paddle.io.Dataset):
         self.edge = edge
 
         if mode.lower() not in ['train', 'val', 'test']:
-            raise ValueError(
-                "mode should be 'train', 'val' or 'test', but got {}.".format(
-                    mode))
+            raise ValueError("mode should be 'train', 'val' or 'test', but got {}.".format(mode))
 
         if self.transforms is None:
             raise ValueError("`transforms` is necessary, but it is None.")
 
         self.dataset_root = dataset_root
         if not os.path.exists(self.dataset_root):
-            raise FileNotFoundError('there is not `dataset_root`: {}.'.format(
-                self.dataset_root))
+            raise FileNotFoundError('there is not `dataset_root`: {}.'.format(self.dataset_root))
 
         if mode == 'train':
             if train_path is None:
-                raise ValueError(
-                    'When `mode` is "train", `train_path` is necessary, but it is None.'
-                )
+                raise ValueError('When `mode` is "train", `train_path` is necessary, but it is None.')
             elif not os.path.exists(train_path):
-                raise FileNotFoundError(
-                    '`train_path` is not found: {}'.format(train_path))
+                raise FileNotFoundError('`train_path` is not found: {}'.format(train_path))
             else:
                 file_path = train_path
         elif mode == 'val':
             if val_path is None:
-                raise ValueError(
-                    'When `mode` is "val", `val_path` is necessary, but it is None.'
-                )
+                raise ValueError('When `mode` is "val", `val_path` is necessary, but it is None.')
             elif not os.path.exists(val_path):
-                raise FileNotFoundError(
-                    '`val_path` is not found: {}'.format(val_path))
+                raise FileNotFoundError('`val_path` is not found: {}'.format(val_path))
             else:
                 file_path = val_path
         else:
             if test_path is None:
-                raise ValueError(
-                    'When `mode` is "test", `test_path` is necessary, but it is None.'
-                )
+                raise ValueError('When `mode` is "test", `test_path` is necessary, but it is None.')
             elif not os.path.exists(test_path):
-                raise FileNotFoundError(
-                    '`test_path` is not found: {}'.format(test_path))
+                raise FileNotFoundError('`test_path` is not found: {}'.format(test_path))
             else:
                 file_path = test_path
 
@@ -111,8 +99,7 @@ class SegDataset(paddle.io.Dataset):
                 items = line.strip().split(separator)
                 if len(items) != 2:
                     if mode == 'train' or mode == 'val':
-                        raise ValueError(
-                            "File list format incorrect! In training or evaluation task it should be"
+                        raise ValueError("File list format incorrect! In training or evaluation task it should be"
                                          " image_name{}label_name\\n".format(separator))
                     image_path = os.path.join(self.dataset_root, items[0])
                     label_path = None
@@ -138,4 +125,3 @@ class SegDataset(paddle.io.Dataset):
 
     def __len__(self) -> int:
         return len(self.file_list)
-

paddlehub/datasets/esc50.py

@@ -91,7 +91,8 @@ class ESC50(AudioClassificationDataset):
         else:
             data_file = 'dev.npz'
 
-        feat_cfg = dict(sample_rate=self.sample_rate,
+        feat_cfg = dict(
+            sample_rate=self.sample_rate,
             window_size=1024,
             hop_size=320,
             mel_bins=64,
@@ -99,7 +100,8 @@ class ESC50(AudioClassificationDataset):
             fmax=14000,
             window='hann')
 
-        super().__init__(base_path=base_path,
+        super().__init__(
+            base_path=base_path,
             data_file=data_file,
             file_type='npz',
             mode=mode,

paddlehub/datasets/opticdiscseg.py

@@ -24,6 +24,7 @@ import paddlehub.env as hubenv
 from paddlehub.utils.download import download_data
 from paddlehub.datasets.base_seg_dataset import SegDataset
 
+
 @download_data(url='https://paddleseg.bj.bcebos.com/dataset/optic_disc_seg.zip')
 class OpticDiscSeg(SegDataset):
     """
@@ -36,9 +37,7 @@ class OpticDiscSeg(SegDataset):
         edge (bool, optional): Whether to compute edge while training. Default: False
     """
 
-    def __init__(self,
-                 transforms: Callable = None,
-                 mode: str = 'train'):
+    def __init__(self, transforms: Callable = None, mode: str = 'train'):
         self.transforms = transforms
         mode = mode.lower()
         self.mode = mode
@@ -47,14 +46,11 @@ class OpticDiscSeg(SegDataset):
         self.ignore_index = 255
 
         if mode not in ['train', 'val', 'test']:
-            raise ValueError(
-                "`mode` should be 'train', 'val' or 'test', but got {}.".format(
-                    mode))
+            raise ValueError("`mode` should be 'train', 'val' or 'test', but got {}.".format(mode))
 
         if self.transforms is None:
             raise ValueError("`transforms` is necessary, but it is None.")
 
-
         if mode == 'train':
             file_path = os.path.join(hubenv.DATA_HOME, 'optic_disc_seg', 'train_list.txt')
         elif mode == 'test':
@@ -67,9 +63,7 @@ class OpticDiscSeg(SegDataset):
                 items = line.strip().split()
                 if len(items) != 2:
                     if mode == 'train' or mode == 'val':
-                        raise Exception(
-                            "File list format incorrect! It should be"
-                            " image_name label_name\\n")
+                        raise Exception("File list format incorrect! It should be" " image_name label_name\\n")
                     image_path = os.path.join(hubenv.DATA_HOME, 'optic_disc_seg', items[0])
                     grt_path = None
                 else:

paddlehub/datasets/pascalvoc.py

@@ -35,6 +35,7 @@ class DetectCatagory:
         label_ids(List(int)): The dataset label ids.
         category_to_id_map(dict): Mapping relations of category and id for images.
     """
+
     def __init__(self, attrbox: Callable, data_dir: str):
         self.attrbox = attrbox
         self.img_dir = data_dir
@@ -62,6 +63,7 @@ class ParseImages:
     Returns:
         imgs(dict): The input for detection model, it is a dict.
     """
+
     def __init__(self, attrbox: Callable, data_dir: str, category_to_id_map: dict):
         self.attrbox = attrbox
         self.img_dir = data_dir
@@ -94,6 +96,7 @@ class GTAnotations:
     Returns:
         img(dict): Set specific value on the attributes of 'gt boxes' and 'gt labels' for input.
     """
+
     def __init__(self, attrbox: Callable, category_to_id_map: dict):
         self.attrbox = attrbox
         self.category_to_id_map = category_to_id_map
@@ -154,6 +157,7 @@ class DetectionData(paddle.io.Dataset):
     Returns:
         DataSet: An iterable object for data iterating
     """
+
     def __init__(self, transform: Callable, size: int = 416, mode: str = 'train'):
         self.mode = mode
         self.transform = transform

paddlehub/finetune/trainer.py

@@ -68,7 +68,6 @@ class Trainer(object):
         if not isinstance(self.model, paddle.nn.Layer):
             raise TypeError('The model {} is not a `paddle.nn.Layer` object.'.format(self.model.__name__))
 
-
         if self.local_rank == 0 and not os.path.exists(self.checkpoint_dir):
             os.makedirs(self.checkpoint_dir)
 

paddlehub/module/cv_module.py

@@ -126,8 +126,8 @@ class ImageClassifierModule(RunModule, ImageServing):
         """
         top_k = int(top_k)
         images_decode = [base64_to_cv2(image) for image in images]
-        resdicts = self.predict(images=images_decode, top_k=top_k,**kwargs)
-        final={}
+        resdicts = self.predict(images=images_decode, top_k=top_k, **kwargs)
+        final = {}
         for resdict in resdicts:
             for key, value in resdict.items():
                 resdict[key] = float(value)
@@ -144,18 +144,13 @@ class ImageClassifierModule(RunModule, ImageServing):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            images=[args.input_path],
-            top_k=args.top_k)
+        results = self.predict(images=[args.input_path], top_k=args.top_k)
 
         return results
 
@@ -164,18 +159,13 @@ class ImageClassifierModule(RunModule, ImageServing):
         Add the command config options.
         """
 
-        self.arg_config_group.add_argument(
-            '--top_k',
-            type=int,
-            default=1,
-            help="top_k classification result.")
+        self.arg_config_group.add_argument('--top_k', type=int, default=1, help="top_k classification result.")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
 
 
 class ImageColorizeModule(RunModule, ImageServing):
@@ -288,11 +278,11 @@ class ImageColorizeModule(RunModule, ImageServing):
         """
         images_decode = [base64_to_cv2(image) for image in images]
         visual = self.predict(images=images_decode, **kwargs)
-        final={}
+        final = {}
         for i, visual_ret in enumerate(visual):
             h, w, c = images_decode[i].shape
             for key, value in visual_ret.items():
-                value = cv2.resize(cv2.cvtColor(value,cv2.COLOR_RGB2BGR), (w, h), cv2.INTER_NEAREST)
+                value = cv2.resize(cv2.cvtColor(value, cv2.COLOR_RGB2BGR), (w, h), cv2.INTER_NEAREST)
                 visual_ret[key] = cv2_to_base64(value)
         final['data'] = visual
         return final
@@ -307,19 +297,13 @@ class ImageColorizeModule(RunModule, ImageServing):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
-        results = self.predict(
-            images=[args.input_path],
-            visualization=args.visualization,
-            save_path=args.output_dir)
+        results = self.predict(images=[args.input_path], visualization=args.visualization, save_path=args.output_dir)
 
         return results
 
@@ -329,22 +313,15 @@ class ImageColorizeModule(RunModule, ImageServing):
         """
 
         self.arg_config_group.add_argument(
-            '--output_dir',
-            type=str,
-            default='colorization',
-            help="save visualization result.")
+            '--output_dir', type=str, default='colorization', help="save visualization result.")
         self.arg_config_group.add_argument(
-            '--visualization',
-            type=bool,
-            default=True,
-            help="whether to save output as images.")
+            '--visualization', type=bool, default=True, help="whether to save output as images.")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
 
 
 class Yolov3Module(RunModule, ImageServing):
@@ -523,7 +500,12 @@ class StyleTransferModule(RunModule, ImageServing):
 
         return {'loss': loss, 'metrics': {'content gap': content_loss, 'style gap': style_loss}}
 
-    def predict(self, origin: list, style: Union[str, np.ndarray], batch_size: int = 1, visualization: bool = True, save_path: str = 'style_tranfer'):
+    def predict(self,
+                origin: list,
+                style: Union[str, np.ndarray],
+                batch_size: int = 1,
+                visualization: bool = True,
+                save_path: str = 'style_tranfer'):
         '''
         Colorize images
 
@@ -578,7 +560,7 @@ class StyleTransferModule(RunModule, ImageServing):
         images_decode = [base64_to_cv2(image) for image in images[0]]
         style_decode = base64_to_cv2(images[1])
         results = self.predict(origin=images_decode, style=style_decode, **kwargs)
-        final={}
+        final = {}
         final['data'] = [cv2_to_base64(result) for result in results]
         return final
 
@@ -592,12 +574,9 @@ class StyleTransferModule(RunModule, ImageServing):
             prog='hub run {}'.format(self.name),
             usage='%(prog)s',
             add_help=True)
-        self.arg_input_group = self.parser.add_argument_group(
-            title="Input options", description="Input data. Required")
+        self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
         self.arg_config_group = self.parser.add_argument_group(
-            title="Config options",
-            description=
-            "Run configuration for controlling module behavior, not required.")
+            title="Config options", description="Run configuration for controlling module behavior, not required.")
         self.add_module_config_arg()
         self.add_module_input_arg()
         args = self.parser.parse_args(argvs)
@@ -615,25 +594,17 @@ class StyleTransferModule(RunModule, ImageServing):
         """
 
         self.arg_config_group.add_argument(
-            '--output_dir',
-            type=str,
-            default='style_tranfer',
-            help="The directory to save output images.")
+            '--output_dir', type=str, default='style_tranfer', help="The directory to save output images.")
 
         self.arg_config_group.add_argument(
-            '--visualization',
-            type=bool,
-            default=True,
-            help="whether to save output as images.")
+            '--visualization', type=bool, default=True, help="whether to save output as images.")
 
     def add_module_input_arg(self):
         """
         Add the command input options.
         """
-        self.arg_input_group.add_argument(
-            '--input_path', type=str, help="path to image.")
-        self.arg_input_group.add_argument(
-            '--style_path', type=str, help="path to style image.")
+        self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
+        self.arg_input_group.add_argument('--style_path', type=str, help="path to style image.")
 
 
 class ImageSegmentationModule(ImageServing, RunModule):
@@ -659,13 +630,17 @@ class ImageSegmentationModule(ImageServing, RunModule):
             if logit.shape[-2:] != label.shape[-2:]:
                 logit = F.interpolate(logit, label.shape[-2:], mode='bilinear')
 
-            logit = logit.transpose([0,2,3,1])
+            logit = logit.transpose([0, 2, 3, 1])
             loss_ce = criterionCE(logit, label)
             loss += loss_ce / len(logits)
 
         return {"loss": loss}
 
-    def predict(self, images: Union[str, np.ndarray], batch_size: int = 1, visualization: bool = True, save_path: str = 'seg_result') -> List[np.ndarray]:
+    def predict(self,
+                images: Union[str, np.ndarray],
+                batch_size: int = 1,
+                visualization: bool = True,
+                save_path: str = 'seg_result') -> List[np.ndarray]:
         '''
         Obtain segmentation results.
 
@@ -679,7 +654,7 @@ class ImageSegmentationModule(ImageServing, RunModule):
             output(list[np.ndarray]) : The segmentation mask.
         '''
         self.eval()
-        result=[]
+        result = []
 
         total_num = len(images)
         loop_num = int(np.ceil(total_num / batch_size))
@@ -697,17 +672,17 @@ class ImageSegmentationModule(ImageServing, RunModule):
             pred = paddle.argmax(pred[0], axis=1, keepdim=True, dtype='int32')
 
             for num in range(pred.shape[0]):
-                if isinstance(images[handle_id+num], str):
-                    image = cv2.imread(images[handle_id+num])
+                if isinstance(images[handle_id + num], str):
+                    image = cv2.imread(images[handle_id + num])
                 else:
-                    image = images[handle_id+num]
+                    image = images[handle_id + num]
                 h, w, c = image.shape
-                pred_final = utils.reverse_transform(pred[num: num+1], (h,w), self.transforms.transforms)
+                pred_final = utils.reverse_transform(pred[num:num + 1], (h, w), self.transforms.transforms)
                 pred_final = paddle.squeeze(pred_final)
                 pred_final = pred_final.numpy().astype('uint8')
 
                 if visualization:
-                    added_image = utils.visualize(images[handle_id+num], pred_final, weight=0.6)
+                    added_image = utils.visualize(images[handle_id + num], pred_final, weight=0.6)
                     pred_mask = utils.get_pseudo_color_map(pred_final)
                     pred_image_path = os.path.join(save_path, 'image', str(time.time()) + ".png")
                     pred_mask_path = os.path.join(save_path, 'mask', str(time.time()) + ".png")
@@ -728,7 +703,7 @@ class ImageSegmentationModule(ImageServing, RunModule):
         """
         images_decode = [base64_to_cv2(image) for image in images]
         visual = self.predict(images=images_decode, **kwargs)
-        final=[]
+        final = []
         for mask in visual:
             final.append(cv2_to_base64(mask))
         return final

paddlehub/utils/download.py

@@ -23,7 +23,6 @@ from paddlehub.utils import log, utils, xarfile
 
 
 def download_data(url):
-
     def _wrapper(Dataset):
         def _check_download():
             save_name = os.path.basename(url).split('.')[0]

paddlehub/utils/utils.py

@@ -40,6 +40,7 @@ from paddlehub.utils.log import logger
 
 class Version(packaging.version.Version):
     '''Extended implementation of packaging.version.Version'''
+
     def match(self, condition: str) -> bool:
         '''
         Determine whether the given condition are met
@@ -105,6 +106,7 @@ class Version(packaging.version.Version):
 
 class Timer(object):
     '''Calculate runing speed and estimated time of arrival(ETA)'''
+
     def __init__(self, total_step: int):
         self.total_step = total_step
         self.last_start_step = 0
@@ -408,7 +410,8 @@ def extract_melspectrogram(y,
         logger.error('Failed to import librosa. Please check that librosa and numba are correctly installed.')
         raise
 
-    s = librosa.stft(y,
+    s = librosa.stft(
+        y,
         n_fft=window_size,
         hop_length=hop_size,
         win_length=window_size,

paddlehub/vision/segmentation_transforms.py

@@ -145,18 +145,15 @@ class Padding:
                  label_padding_value: int = 255):
         if isinstance(target_size, list) or isinstance(target_size, tuple):
             if len(target_size) != 2:
-                raise ValueError(
-                    '`target_size` should include 2 elements, but it is {}'.
-                        format(target_size))
+                raise ValueError('`target_size` should include 2 elements, but it is {}'.format(target_size))
         else:
-            raise TypeError(
-                "Type of target_size is invalid. It should be list or tuple, now is {}"
-                    .format(type(target_size)))
+            raise TypeError("Type of target_size is invalid. It should be list or tuple, now is {}".format(
+                type(target_size)))
         self.target_size = target_size
         self.im_padding_value = im_padding_value
         self.label_padding_value = label_padding_value
 
-    def __call__(self, im: np.ndarray , label: np.ndarray = None) -> Tuple:
+    def __call__(self, im: np.ndarray, label: np.ndarray = None) -> Tuple:
         """
         Args:
             im (np.ndarray): The Image data.
@@ -179,13 +176,12 @@ class Padding:
                 'The size of image should be less than `target_size`, but the size of image ({}, {}) is larger than `target_size` ({}, {})'
                 .format(im_width, im_height, target_width, target_height))
         else:
-            im = cv2.copyMakeBorder(im, 0, pad_height, 0, pad_width, cv2.BORDER_CONSTANT, 
-                                    value=self.im_padding_value)
+            im = cv2.copyMakeBorder(im, 0, pad_height, 0, pad_width, cv2.BORDER_CONSTANT, value=self.im_padding_value)
             if label is not None:
-                label = cv2.copyMakeBorder(label, 0, pad_height, 0, pad_width, cv2.BORDER_CONSTANT,
-                                           value=self.label_padding_value)
+                label = cv2.copyMakeBorder(
+                    label, 0, pad_height, 0, pad_width, cv2.BORDER_CONSTANT, value=self.label_padding_value)
         if label is None:
-            return (im,)
+            return (im, )
         else:
             return (im, label)
 
@@ -200,15 +196,13 @@ class Normalize:
         ValueError: When mean/std is not list or any value in std is 0.
     """
 
-    def __init__(self, mean: Union[List[float], Tuple[float]] = (0.5, 0.5, 0.5), 
+    def __init__(self,
+                 mean: Union[List[float], Tuple[float]] = (0.5, 0.5, 0.5),
                  std: Union[List[float], Tuple[float]] = (0.5, 0.5, 0.5)):
         self.mean = mean
         self.std = std
-        if not (isinstance(self.mean, (list, tuple))
-                and isinstance(self.std, (list, tuple))):
-            raise ValueError(
-                "{}: input type is invalid. It should be list or tuple".format(
-                    self))
+        if not (isinstance(self.mean, (list, tuple)) and isinstance(self.std, (list, tuple))):
+            raise ValueError("{}: input type is invalid. It should be list or tuple".format(self))
         from functools import reduce
         if reduce(lambda x, y: x * y, self.std) == 0:
             raise ValueError('{}: std is invalid!'.format(self))
@@ -227,7 +221,7 @@ class Normalize:
         im = F.normalize(im, mean, std)
 
         if label is None:
-            return (im,)
+            return (im, )
         else:
             return (im, label)
 
@@ -260,17 +254,13 @@ class Resize:
     def __init__(self, target_size: Union[List[int], Tuple[int]] = (512, 512), interp: str = 'LINEAR'):
         self.interp = interp
         if not (interp == "RANDOM" or interp in self.interp_dict):
-            raise ValueError("`interp` should be one of {}".format(
-                self.interp_dict.keys()))
+            raise ValueError("`interp` should be one of {}".format(self.interp_dict.keys()))
         if isinstance(target_size, list) or isinstance(target_size, tuple):
             if len(target_size) != 2:
-                raise ValueError(
-                    '`target_size` should include 2 elements, but it is {}'.
-                        format(target_size))
+                raise ValueError('`target_size` should include 2 elements, but it is {}'.format(target_size))
         else:
-            raise TypeError(
-                "Type of `target_size` is invalid. It should be list or tuple, but it is {}"
-                    .format(type(target_size)))
+            raise TypeError("Type of `target_size` is invalid. It should be list or tuple, but it is {}".format(
+                type(target_size)))
 
         self.target_size = target_size
 
@@ -298,10 +288,9 @@ class Resize:
             interp = self.interp
         im = F.resize(im, self.target_size, self.interp_dict[interp])
         if label is not None:
-            label = F.resize(label, self.target_size,
-                           cv2.INTER_NEAREST)
+            label = F.resize(label, self.target_size, cv2.INTER_NEAREST)
 
         if label is None:
-            return (im,)
+            return (im, )
         else:
             return (im, label)

paddlehub/vision/transforms.py

@@ -31,6 +31,7 @@ class Compose:
         to_rgb(bool): Whether to transform the input from BGR mode to RGB mode, default is False.
         channel_first(bool): whether to permute image from channel laste to channel first
     """
+
     def __init__(self, transforms: Callable, to_rgb: bool = False, channel_first: bool = True):
         if not isinstance(transforms, list):
             raise TypeError('The transforms must be a list!')
@@ -57,16 +58,20 @@ class Compose:
             im = F.permute(im)
         return im
 
+
 class Permute:
     """
     Repermute the input image from [H, W, C] to [C, H, W].
     """
+
     def __init__(self):
         pass
+
     def __call__(self, im):
         im = F.permute(im)
         return im
 
+
 class RandomHorizontalFlip:
     """
     Randomly flip the image horizontally according to given probability.
@@ -74,6 +79,7 @@ class RandomHorizontalFlip:
     Args:
         prob(float): The probability for flipping the image horizontally, default is 0.5.
     """
+
     def __init__(self, prob: float = 0.5):
         self.prob = prob
 
@@ -90,6 +96,7 @@ class RandomVerticalFlip:
     Args:
         prob(float): The probability for flipping the image vertically, default is 0.5.
     """
+
     def __init__(self, prob: float = 0.5):
         self.prob = prob
 
@@ -146,6 +153,7 @@ class ResizeByLong:
     Args:
         long_size(int|list[int]): The target size of long side.
     """
+
     def __init__(self, long_size: Union[List[int], int]):
         self.long_size = long_size
 
@@ -162,6 +170,7 @@ class ResizeRangeScaling:
         min_value(int): The minimum value for targeted size.
         max_value(int): The maximum value for targeted size.
     """
+
     def __init__(self, min_value: int = 400, max_value: int = 600):
         if min_value > max_value:
             raise ValueError('min_value must be less than max_value, '
@@ -188,6 +197,7 @@ class ResizeStepScaling:
         scale_step_size(float): Scale interval.
 
     """
+
     def __init__(self, min_scale_factor: float = 0.75, max_scale_factor: float = 1.25, scale_step_size: float = 0.25):
         if min_scale_factor > max_scale_factor:
             raise ValueError('min_scale_factor must be less than max_scale_factor, '
@@ -224,6 +234,7 @@ class Normalize:
         std(list): Standard deviation for normalization.
         channel_first(bool): im channel firest or last
     """
+
     def __init__(self, mean: list = [0.5, 0.5, 0.5], std: list = [0.5, 0.5, 0.5], channel_first: bool = False):
         self.mean = mean
         self.std = std
@@ -253,6 +264,7 @@ class Padding:
         target_size(Union[List[int], Tuple[int], int]): Targeted image size.
         im_padding_value(list): Border value for 3 channels, default is [127.5, 127.5, 127.5].
     """
+
     def __init__(self, target_size: Union[List[int], Tuple[int], int], im_padding_value: list = [127.5, 127.5, 127.5]):
         if isinstance(target_size, list) or isinstance(target_size, tuple):
             if len(target_size) != 2:
@@ -292,6 +304,7 @@ class RandomPaddingCrop:
         crop_size(Union[List[int], Tuple[int], int]): Targeted image size.
         im_padding_value(list): Border value for 3 channels, default is [127.5, 127.5, 127.5].
     """
+
     def __init__(self, crop_size, im_padding_value=[127.5, 127.5, 127.5]):
         if isinstance(crop_size, list) or isinstance(crop_size, tuple):
             if len(crop_size) != 2:
@@ -339,6 +352,7 @@ class RandomBlur:
     Args:
         prob(float): The probability to blur the image, default is 0.1.
     """
+
     def __init__(self, prob: float = 0.1):
         self.prob = prob
 
@@ -370,6 +384,7 @@ class RandomRotation:
         max_rotation(float): Upper bound of rotation angle.
         im_padding_value(list): Border value for 3 channels, default is [127.5, 127.5, 127.5].
     """
+
     def __init__(self, max_rotation: float = 15, im_padding_value: list = [127.5, 127.5, 127.5]):
         self.max_rotation = max_rotation
         self.im_padding_value = im_padding_value
@@ -401,8 +416,6 @@ class RandomRotation:
         return im
 
 
-
-
 class RandomDistort:
     """
     Random adjust brightness, contrast, saturation and hue according to the given random range and probability, respectively.
@@ -418,6 +431,7 @@ class RandomDistort:
         hue_range(float): Boundary of hue.
         hue_prob(float): Probability for disturb the hue of image.
     """
+
     def __init__(self,
                  brightness_range: float = 0.5,
                  brightness_prob: float = 0.5,

tests/test_module.py

@@ -14,10 +14,8 @@ class TestHubModule(unittest.TestCase):
         self.assertEqual(results[0]['tag'], ['TIME', 'v', 'q', 'n'])
         self.assertEqual(results[1]['word'], ['天气预报', '说', '今天', '要', '下雨'])
         self.assertEqual(results[1]['tag'], ['n', 'v', 'TIME', 'v', 'v'])
-        self.assertEqual(results[2]['word'],
-                         ['下', '一班', '地铁', '马上', '就要', '到', '了'])
-        self.assertEqual(results[2]['tag'],
-                         ['f', 'm', 'n', 'd', 'v', 'v', 'xc'])
+        self.assertEqual(results[2]['word'], ['下', '一班', '地铁', '马上', '就要', '到', '了'])
+        self.assertEqual(results[2]['tag'], ['f', 'm', 'n', 'd', 'v', 'v', 'xc'])
 
     def test_senta(self):
         senta = hub.Module(name="senta_bilstm")
@@ -45,13 +43,11 @@ class TestHubModule(unittest.TestCase):
             if result['similarity'] > max_score:
                 max_score = result['similarity']
                 result_text = result['text_2']
-        print("The most matching with the %s is %s" % (test_text_1[0],
-                                                       result_text))
+        print("The most matching with the %s is %s" % (test_text_1[0], result_text))
 
     def test_ssd(self):
         ssd = hub.Module(name="ssd_mobilenet_v1_pascal")
-        test_img_path = os.path.join(
-            os.path.dirname(__file__), "resources", "test_img_cat.jpg")
+        test_img_path = os.path.join(os.path.dirname(__file__), "resources", "test_img_cat.jpg")
         input_dict = {"image": [test_img_path]}
         results = ssd.object_detection(data=input_dict)
         for result in results: