paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

PaddleClas/tools/test_hubserving.py

@@ -1,113 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(__dir__)
-sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
-
-from tools.infer.utils import parse_args, get_image_list, preprocess, np_to_b64
-from ppcls.utils import logger
-import numpy as np
-import cv2
-import time
-import requests
-import json
-import base64
-
-
-def main(args):
-    image_path_list = get_image_list(args.image_file)
-    headers = {"Content-type": "application/json"}
-
-    cnt = 0
-    predict_time = 0
-    all_score = 0.0
-    start_time = time.time()
-
-    batch_input_list = []
-    img_name_list = []
-    cnt = 0
-    for idx, img_path in enumerate(image_path_list):
-        img = cv2.imread(img_path)
-        if img is None:
-            logger.warning(
-                "Image file failed to read and has been skipped. The path: {}".
-                format(img_path))
-            continue
-        else:
-            img = img[:, :, ::-1]
-            data = preprocess(img, args)
-            batch_input_list.append(data)
-            img_name = img_path.split('/')[-1]
-            img_name_list.append(img_name)
-            cnt += 1
-        if cnt % args.batch_size == 0 or (idx + 1) == len(image_path_list):
-            batch_input = np.array(batch_input_list)
-            b64str, revert_shape = np_to_b64(batch_input)
-            data = {
-                "images": b64str,
-                "revert_params": {
-                    "shape": revert_shape,
-                    "dtype": str(batch_input.dtype)
-                },
-                "top_k": args.top_k
-            }
-            try:
-                r = requests.post(
-                    url=args.server_url,
-                    headers=headers,
-                    data=json.dumps(data))
-                r.raise_for_status
-                if r.json()["status"] != "000":
-                    msg = r.json()["msg"]
-                    raise Exception(msg)
-            except Exception as e:
-                logger.error("{}, in file(s): {} etc.".format(e, img_name_list[
-                    0]))
-                continue
-            else:
-                results = r.json()["results"]
-                batch_result_list = results["prediction"]
-                elapse = results["elapse"]
-
-                cnt += len(batch_result_list)
-                predict_time += elapse
-
-                for number, result_list in enumerate(batch_result_list):
-                    all_score += result_list["scores"][0]
-                    result_str = ""
-                    for i in range(len(result_list["clas_ids"])):
-                        result_str += "{}: {:.2f}\t".format(
-                            result_list["clas_ids"][i],
-                            result_list["scores"][i])
-                    logger.info("File:{}, The top-{} result(s): {}".format(
-                        img_name_list[number], args.top_k, result_str))
-
-            finally:
-                batch_input_list = []
-                img_name_list = []
-
-    total_time = time.time() - start_time
-    logger.info("The average time of prediction cost: {:.3f} s/image".format(
-        predict_time / cnt))
-    logger.info("The average time cost: {:.3f} s/image".format(total_time /
-                                                               cnt))
-    logger.info("The average top-1 score: {:.3f}".format(all_score / cnt))
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main(args)

PaddleClas/tools/train.py

@@ -1,141 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import argparse
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(__dir__)
-sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
-
-import paddle
-
-from ppcls.data import Reader
-from ppcls.utils.config import get_config
-from ppcls.utils.save_load import init_model, save_model
-from ppcls.utils import logger
-import program
-
-
-def parse_args():
-    parser = argparse.ArgumentParser("PaddleClas train script")
-    parser.add_argument(
-        '-c',
-        '--config',
-        type=str,
-        default='configs/ResNet/ResNet50.yaml',
-        help='config file path')
-    parser.add_argument(
-        '-o',
-        '--override',
-        action='append',
-        default=[],
-        help='config options to be overridden')
-    args = parser.parse_args()
-    return args
-
-
-def main(args):
-    paddle.seed(12345)
-
-    config = get_config(args.config, overrides=args.override, show=True)
-    # assign the place
-    use_gpu = config.get("use_gpu", True)
-    use_xpu = config.get("use_xpu", False)
-    assert (
-        use_gpu and use_xpu
-    ) is not True, "gpu and xpu can not be true in the same time in static mode!"
-    if use_gpu:
-        place = paddle.set_device('gpu')
-    elif use_xpu:
-        place = paddle.set_device('xpu')
-    else:
-        place = paddle.set_device('cpu')
-
-    trainer_num = paddle.distributed.get_world_size()
-    use_data_parallel = trainer_num != 1
-    config["use_data_parallel"] = use_data_parallel
-
-    if config["use_data_parallel"]:
-        paddle.distributed.init_parallel_env()
-
-    net = program.create_model(config.ARCHITECTURE, config.classes_num)
-    optimizer, lr_scheduler = program.create_optimizer(
-        config, parameter_list=net.parameters())
-
-    dp_net = net
-    if config["use_data_parallel"]:
-        find_unused_parameters = config.get("find_unused_parameters", False)
-        dp_net = paddle.DataParallel(
-            net, find_unused_parameters=find_unused_parameters)
-
-    # load model from checkpoint or pretrained model
-    init_model(config, net, optimizer)
-
-    train_dataloader = Reader(config, 'train', places=place)()
-
-    if config.validate:
-        valid_dataloader = Reader(config, 'valid', places=place)()
-
-    last_epoch_id = config.get("last_epoch", -1)
-    best_top1_acc = 0.0  # best top1 acc record
-    best_top1_epoch = last_epoch_id
-
-    vdl_writer_path = config.get("vdl_dir", None)
-    vdl_writer = None
-    if vdl_writer_path:
-        from visualdl import LogWriter
-        vdl_writer = LogWriter(vdl_writer_path)
-    # Ensure that the vdl log file can be closed normally
-    try:
-        for epoch_id in range(last_epoch_id + 1, config.epochs):
-            net.train()
-            # 1. train with train dataset
-            program.run(train_dataloader, config, dp_net, optimizer,
-                        lr_scheduler, epoch_id, 'train', vdl_writer)
-
-            # 2. validate with validate dataset
-            if config.validate and epoch_id % config.valid_interval == 0:
-                net.eval()
-                with paddle.no_grad():
-                    top1_acc = program.run(valid_dataloader, config, net, None,
-                                           None, epoch_id, 'valid', vdl_writer)
-                if top1_acc > best_top1_acc:
-                    best_top1_acc = top1_acc
-                    best_top1_epoch = epoch_id
-                    model_path = os.path.join(config.model_save_dir,
-                                              config.ARCHITECTURE["name"])
-                    save_model(net, optimizer, model_path, "best_model")
-                message = "The best top1 acc {:.5f}, in epoch: {:d}".format(
-                    best_top1_acc, best_top1_epoch)
-                logger.info(message)
-
-            # 3. save the persistable model
-            if epoch_id % config.save_interval == 0:
-                model_path = os.path.join(config.model_save_dir,
-                                          config.ARCHITECTURE["name"])
-                save_model(net, optimizer, model_path, epoch_id)
-    except Exception as e:
-        logger.error(e)
-    finally:
-        vdl_writer.close() if vdl_writer else None
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    main(args)

paddlex/cls.py

@@ -1,76 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import sys
-from . import cv
-
-message = 'Your running script needs PaddleX<2.0.0, please refer to {} to solve this issue.'.format(
-    'https://github.com/PaddlePaddle/PaddleX/tree/release/2.0-rc/tutorials/train#%E7%89%88%E6%9C%AC%E5%8D%87%E7%BA%A7'
-)
-
-
-def __getattr__(attr):
-    if attr == 'transforms':
-
-        print("\033[1;31;40m{}\033[0m".format(message).encode("utf-8")
-              .decode("latin1"))
-        sys.exit(-1)
-
-
-ResNet18 = cv.models.ResNet18
-ResNet34 = cv.models.ResNet34
-ResNet50 = cv.models.ResNet50
-ResNet101 = cv.models.ResNet101
-ResNet152 = cv.models.ResNet152
-
-ResNet18_vd = cv.models.ResNet18_vd
-ResNet34_vd = cv.models.ResNet34_vd
-ResNet50_vd = cv.models.ResNet50_vd
-ResNet50_vd_ssld = cv.models.ResNet50_vd_ssld
-ResNet101_vd = cv.models.ResNet101_vd
-ResNet101_vd_ssld = cv.models.ResNet101_vd_ssld
-ResNet152_vd = cv.models.ResNet152_vd
-ResNet200_vd = cv.models.ResNet200_vd
-
-MobileNetV1 = cv.models.MobileNetV1
-MobileNetV2 = cv.models.MobileNetV2
-MobileNetV3_small = cv.models.MobileNetV3_small
-MobileNetV3_small_ssld = cv.models.MobileNetV3_small_ssld
-MobileNetV3_large = cv.models.MobileNetV3_large
-MobileNetV3_large_ssld = cv.models.MobileNetV3_large_ssld
-
-AlexNet = cv.models.AlexNet
-
-DarkNet53 = cv.models.DarkNet53
-
-DenseNet121 = cv.models.DenseNet121
-DenseNet161 = cv.models.DenseNet161
-DenseNet169 = cv.models.DenseNet169
-DenseNet201 = cv.models.DenseNet201
-DenseNet264 = cv.models.DenseNet264
-
-HRNet_W18_C = cv.models.HRNet_W18_C
-HRNet_W30_C = cv.models.HRNet_W30_C
-HRNet_W32_C = cv.models.HRNet_W32_C
-HRNet_W40_C = cv.models.HRNet_W40_C
-HRNet_W44_C = cv.models.HRNet_W44_C
-HRNet_W48_C = cv.models.HRNet_W48_C
-HRNet_W64_C = cv.models.HRNet_W64_C
-
-Xception41 = cv.models.Xception41
-Xception65 = cv.models.Xception65
-Xception71 = cv.models.Xception71
-
-ShuffleNetV2 = cv.models.ShuffleNetV2
-ShuffleNetV2_swish = cv.models.ShuffleNetV2_swish

paddlex/command.py

@@ -1,215 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from six import text_type as _text_type
-import argparse
-import sys
-import os
-import os.path as osp
-import paddlex.utils.logging as logging
-
-
-def arg_parser():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--model_dir",
-        "-m",
-        type=_text_type,
-        default=None,
-        help="define model directory path")
-    parser.add_argument(
-        "--save_dir",
-        "-s",
-        type=_text_type,
-        default=None,
-        help="path to save inference model")
-    parser.add_argument(
-        "--version",
-        "-v",
-        action="store_true",
-        default=False,
-        help="get version of PaddleX")
-    parser.add_argument(
-        "--export_inference",
-        "-e",
-        action="store_true",
-        default=False,
-        help="export inference model for C++/Python deployment")
-    parser.add_argument(
-        "--data_conversion",
-        "-dc",
-        action="store_true",
-        default=False,
-        help="convert the dataset to the standard format")
-    parser.add_argument(
-        "--source",
-        "-se",
-        type=_text_type,
-        default=None,
-        help="define dataset format before the conversion")
-    parser.add_argument(
-        "--to",
-        "-to",
-        type=_text_type,
-        default=None,
-        help="define dataset format after the conversion")
-    parser.add_argument(
-        "--pics",
-        "-p",
-        type=_text_type,
-        default=None,
-        help="define pictures directory path")
-    parser.add_argument(
-        "--annotations",
-        "-a",
-        type=_text_type,
-        default=None,
-        help="define annotations directory path")
-    parser.add_argument(
-        "--fixed_input_shape",
-        "-fs",
-        default=None,
-        help="export inference model with fixed input shape:[w,h] or [n,3,w,h]")
-    parser.add_argument(
-        "--split_dataset",
-        "-sd",
-        action="store_true",
-        default=False,
-        help="split dataset with the split value")
-    parser.add_argument(
-        "--format",
-        "-f",
-        default=None,
-        help="define dataset format(ImageNet/COCO/VOC/Seg)")
-    parser.add_argument(
-        "--dataset_dir",
-        "-dd",
-        type=_text_type,
-        default=None,
-        help="define the path of dataset to be splited")
-    parser.add_argument(
-        "--val_value",
-        "-vv",
-        default=None,
-        help="define the value of validation dataset(E.g 0.2)")
-    parser.add_argument(
-        "--test_value",
-        "-tv",
-        default=None,
-        help="define the value of test dataset(E.g 0.1)")
-
-    return parser
-
-
-def main():
-    import os
-    os.environ['CUDA_VISIBLE_DEVICES'] = ""
-
-    import paddlex as pdx
-
-    if len(sys.argv) < 2:
-        print("Use command 'paddlex -h` to print the help information\n")
-        return
-    parser = arg_parser()
-    args = parser.parse_args()
-
-    if args.version:
-        print("PaddleX-{}".format(pdx.__version__))
-        print("Repo: https://github.com/PaddlePaddle/PaddleX.git")
-        print("Email: paddlex@baidu.com")
-        return
-
-    if args.export_inference:
-        assert args.model_dir is not None, "--model_dir should be defined while exporting inference model"
-        assert args.save_dir is not None, "--save_dir should be defined to save inference model"
-
-        fixed_input_shape = None
-        if args.fixed_input_shape is not None:
-            fixed_input_shape = list(eval(args.fixed_input_shape))
-            assert len(fixed_input_shape) in [
-                2, 4
-            ], "fixed_input_shape must be a list/tuple with length 2 or 4, such as [224,224] or [1,3,224,244]"
-            if len(fixed_input_shape) == 4:
-                assert fixed_input_shape[
-                    1] == 3, "input channel in fixed_input_shape must be 3, but recieved is {}".format(
-                        fixed_input_shape[1])
-            assert fixed_input_shape[-2] > 0 and fixed_input_shape[
-                -1] > 0, "input width and height must be a positive integer, but recievied is {}".format(
-                    fixed_input_shape[-2:])
-
-            # input fixed_input_shape is [w,h]
-            # export_inference_model needs [h,w]
-            fixed_input_shape[-2:] = fixed_input_shape[-1:-3:-1]
-
-        os.environ['PADDLEX_EXPORT_STAGE'] = 'True'
-        os.environ['PADDLESEG_EXPORT_STAGE'] = 'True'
-        model = pdx.load_model(args.model_dir)
-        model._export_inference_model(args.save_dir, fixed_input_shape)
-
-    if args.data_conversion:
-        assert args.source is not None, "--source should be defined while converting dataset"
-        assert args.to is not None, "--to should be defined to confirm the taregt dataset format"
-        assert args.pics is not None, "--pics should be defined to confirm the pictures path"
-        assert args.annotations is not None, "--annotations should be defined to confirm the annotations path"
-        assert args.save_dir is not None, "--save_dir should be defined to store taregt dataset"
-        if args.source not in ['labelme', 'jingling', 'easydata']:
-            logging.error(
-                "The source format {} is not one of labelme/jingling/easydata".
-                format(args.source),
-                exit=False)
-        if args.to not in ['PascalVOC', 'MSCOCO', 'SEG', 'ImageNet']:
-            logging.error(
-                "The to format {} is not one of PascalVOC/MSCOCO/SEG/ImageNet".
-                format(args.to),
-                exit=False)
-        if args.source == 'labelme' and args.to == 'ImageNet':
-            logging.error(
-                "The labelme dataset can not convert to the ImageNet dataset.",
-                exit=False)
-        if args.source == 'jingling' and args.to == 'PascalVOC':
-            logging.error(
-                "The jingling dataset can not convert to the PascalVOC dataset.",
-                exit=False)
-        if not osp.exists(args.save_dir):
-            os.makedirs(args.save_dir)
-        pdx.tools.convert.dataset_conversion(args.source, args.to, args.pics,
-                                             args.annotations, args.save_dir)
-
-    if args.split_dataset:
-        assert args.dataset_dir is not None, "--dataset_dir should be defined while spliting dataset"
-        assert args.format is not None, "--format should be defined while spliting dataset"
-        assert args.val_value is not None, "--val_value should be defined while spliting dataset"
-
-        dataset_dir = args.dataset_dir
-        dataset_format = args.format.lower()
-        val_value = float(args.val_value)
-        test_value = float(args.test_value
-                           if args.test_value is not None else 0)
-        save_dir = dataset_dir
-
-        if not dataset_format in ["coco", "imagenet", "voc", "seg"]:
-            logging.error(
-                "The dataset format is not correct defined.(support COCO/ImageNet/VOC/Seg)"
-            )
-        if not osp.exists(dataset_dir):
-            logging.error("The path of dataset to be splited doesn't exist.")
-        if val_value <= 0 or val_value >= 1 or test_value < 0 or test_value >= 1 or val_value + test_value >= 1:
-            logging.error("The value of split is not correct.")
-
-        pdx.tools.split.dataset_split(dataset_dir, dataset_format, val_value,
-                                      test_value, save_dir)
-
-
-if __name__ == "__main__":
-    main()

paddlex/cv/__init__.py

@@ -1,17 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import models
-from . import transforms
-from . import datasets

paddlex/cv/datasets/__init__.py

@@ -1,18 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .seg_dataset import SegDataset
-from .imagenet import ImageNet
-from .voc import VOCDetection
-from .coco import CocoDetection