paddlex 2.1.0__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

PaddleClas/ppcls/utils/save_load.py

@@ -1,136 +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 errno
-import os
-import re
-import shutil
-import tempfile
-
-import paddle
-from ppcls.utils import logger
-from .download import get_weights_path_from_url
-
-__all__ = ['init_model', 'save_model', 'load_dygraph_pretrain']
-
-
-def _mkdir_if_not_exist(path):
-    """
-    mkdir if not exists, ignore the exception when multiprocess mkdir together
-    """
-    if not os.path.exists(path):
-        try:
-            os.makedirs(path)
-        except OSError as e:
-            if e.errno == errno.EEXIST and os.path.isdir(path):
-                logger.warning(
-                    'be happy if some process has already created {}'.format(
-                        path))
-            else:
-                raise OSError('Failed to mkdir {}'.format(path))
-
-
-def load_dygraph_pretrain(model, path=None):
-    if not (os.path.isdir(path) or os.path.exists(path + '.pdparams')):
-        raise ValueError("Model pretrain path {} does not "
-                         "exists.".format(path))
-    param_state_dict = paddle.load(path + ".pdparams")
-    model.set_dict(param_state_dict)
-    return
-
-
-def load_dygraph_pretrain_from_url(model, pretrained_url, use_ssld=False):
-    if use_ssld:
-        pretrained_url = pretrained_url.replace("_pretrained",
-                                                "_ssld_pretrained")
-    local_weight_path = get_weights_path_from_url(pretrained_url).replace(
-        ".pdparams", "")
-    load_dygraph_pretrain(model, path=local_weight_path)
-    return
-
-
-def load_distillation_model(model, pretrained_model):
-    logger.info("In distillation mode, teacher model will be "
-                "loaded firstly before student model.")
-
-    if not isinstance(pretrained_model, list):
-        pretrained_model = [pretrained_model]
-
-    teacher = model.teacher if hasattr(model,
-                                       "teacher") else model._layers.teacher
-    student = model.student if hasattr(model,
-                                       "student") else model._layers.student
-    load_dygraph_pretrain(teacher, path=pretrained_model[0])
-    logger.info("Finish initing teacher model from {}".format(
-        pretrained_model))
-    # load student model
-    if len(pretrained_model) >= 2:
-        load_dygraph_pretrain(student, path=pretrained_model[1])
-        logger.info("Finish initing student model from {}".format(
-            pretrained_model))
-
-
-def init_model(config, net, optimizer=None):
-    """
-    load model from checkpoint or pretrained_model
-    """
-    checkpoints = config.get('checkpoints')
-    if checkpoints and optimizer is not None:
-        assert os.path.exists(checkpoints + ".pdparams"), \
-            "Given dir {}.pdparams not exist.".format(checkpoints)
-        assert os.path.exists(checkpoints + ".pdopt"), \
-            "Given dir {}.pdopt not exist.".format(checkpoints)
-        para_dict = paddle.load(checkpoints + ".pdparams")
-        opti_dict = paddle.load(checkpoints + ".pdopt")
-        metric_dict = paddle.load(checkpoints + ".pdstates")
-        net.set_dict(para_dict)
-        optimizer.set_state_dict(opti_dict)
-        logger.info("Finish load checkpoints from {}".format(checkpoints))
-        return metric_dict
-
-    pretrained_model = config.get('pretrained_model')
-    use_distillation = config.get('use_distillation', False)
-    if pretrained_model:
-        if use_distillation:
-            load_distillation_model(net, pretrained_model)
-        else:  # common load
-            load_dygraph_pretrain(net, path=pretrained_model)
-            logger.info(
-                logger.coloring("Finish load pretrained model from {}".format(
-                    pretrained_model), "HEADER"))
-
-
-def save_model(net,
-               optimizer,
-               metric_info,
-               model_path,
-               model_name="",
-               prefix='ppcls'):
-    """
-    save model to the target path
-    """
-    if paddle.distributed.get_rank() != 0:
-        return
-    model_path = os.path.join(model_path, model_name)
-    _mkdir_if_not_exist(model_path)
-    model_path = os.path.join(model_path, prefix)
-
-    paddle.save(net.state_dict(), model_path + ".pdparams")
-    paddle.save(optimizer.state_dict(), model_path + ".pdopt")
-    paddle.save(metric_info, model_path + ".pdstates")
-    logger.info("Already save model in {}".format(model_path))

PaddleClas/setup.py

@@ -1,58 +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 io import open
-from setuptools import setup
-
-with open('requirements.txt', encoding="utf-8-sig") as f:
-    requirements = f.readlines()
-
-
-def readme():
-    with open('docs/en/whl_en.md', encoding="utf-8-sig") as f:
-        README = f.read()
-    return README
-
-
-setup(
-    name='paddleclas',
-    packages=['paddleclas'],
-    package_dir={'paddleclas': ''},
-    include_package_data=True,
-    entry_points={
-        "console_scripts": ["paddleclas= paddleclas.paddleclas:main"]
-    },
-    version='0.0.0',
-    install_requires=requirements,
-    license='Apache License 2.0',
-    description='Awesome Image Classification toolkits based on PaddlePaddle ',
-    long_description=readme(),
-    long_description_content_type='text/markdown',
-    url='https://github.com/PaddlePaddle/PaddleClas',
-    download_url='https://github.com/PaddlePaddle/PaddleClas.git',
-    keywords=[
-        'A treasure chest for image classification powered by PaddlePaddle.'
-    ],
-    classifiers=[
-        'Intended Audience :: Developers',
-        'Operating System :: OS Independent',
-        'Natural Language :: Chinese (Simplified)',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.2',
-        'Programming Language :: Python :: 3.3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7', 'Topic :: Utilities'
-    ], )

PaddleClas/tools/__init__.py

@@ -1,15 +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.
-
-from . import infer

PaddleClas/tools/eval.py

@@ -1,31 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))
-
-from ppcls.utils import config
-from ppcls.engine.engine import Engine
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(
-        args.config, overrides=args.override, show=False)
-    engine = Engine(config, mode="eval")
-    engine.eval()

PaddleClas/tools/export_model.py

@@ -1,34 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))
-
-import paddle
-import paddle.nn as nn
-
-from ppcls.utils import config
-from ppcls.engine.engine import Engine
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(
-        args.config, overrides=args.override, show=False)
-    engine = Engine(config, mode="export")
-    engine.export()

PaddleClas/tools/infer.py

@@ -1,31 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))
-
-from ppcls.utils import config
-from ppcls.engine.engine import Engine
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(
-        args.config, overrides=args.override, show=False)
-    engine = Engine(config, mode="infer")
-    engine.infer()

PaddleClas/tools/train.py

@@ -1,32 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import os
-import sys
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))
-
-from ppcls.utils import config
-from ppcls.engine.engine import Engine
-
-if __name__ == "__main__":
-    args = config.parse_args()
-    config = config.get_config(
-        args.config, overrides=args.override, show=False)
-    config.profiler_options = args.profiler_options
-    engine = Engine(config, mode="train")
-    engine.train()

paddlex/cls.py

@@ -1,82 +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 script can be run normally only under PaddleX<2.0.0 ' + \
-    'but the installed PaddleX version is greater than or equal to 2.0.0, ' + \
-    'the solution is writen in the link {}, please refer to this link ro solve this issue.'.format(
-        'https://github.com/PaddlePaddle/PaddleX/tree/develop/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
-
-PPLCNet = cv.models.PPLCNet
-PPLCNet_ssld = cv.models.PPLCNet_ssld

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