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

PaddleClas/setup.py

@@ -1,55 +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 setuptools import setup
-from io import open
-
-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/download.py

@@ -1,50 +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.
-
-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__, '..')))
-
-from ppcls import model_zoo
-
-
-def parse_args():
-    def str2bool(v):
-        return v.lower() in ("true", "t", "1")
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-a', '--architecture', type=str, default='ResNet50')
-    parser.add_argument('-p', '--path', type=str, default='./pretrained/')
-    parser.add_argument('--postfix', type=str, default="pdparams")
-    parser.add_argument('-d', '--decompress', type=str2bool, default=False)
-    parser.add_argument('-l', '--list', type=str2bool, default=False)
-
-    args = parser.parse_args()
-    return args
-
-
-def main():
-    args = parse_args()
-    if args.list:
-        model_zoo.list_models()
-    else:
-        model_zoo.get(args.architecture, args.path, args.decompress,
-                      args.postfix)
-
-
-if __name__ == '__main__':
-    main()

PaddleClas/tools/ema.py

@@ -1,58 +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.
-
-import paddle
-import numpy as np
-
-
-class ExponentialMovingAverage():
-    def __init__(self, model, decay, thres_steps=True):
-        self._model = model
-        self._decay = decay
-        self._thres_steps = thres_steps
-        self._shadow = {}
-        self._backup = {}
-
-    def register(self):
-        self._update_step = 0
-        for name, param in self._model.named_parameters():
-            if param.stop_gradient is False:
-                self._shadow[name] = param.numpy().copy()
-
-    def update(self):
-        decay = min(self._decay, (1 + self._update_step) / (
-            10 + self._update_step)) if self._thres_steps else self._decay
-        for name, param in self._model.named_parameters():
-            if param.stop_gradient is False:
-                assert name in self._shadow
-                new_val = np.array(param.numpy().copy())
-                old_val = np.array(self._shadow[name])
-                new_average = decay * old_val + (1 - decay) * new_val
-                self._shadow[name] = new_average
-        self._update_step += 1
-        return decay
-
-    def apply(self):
-        for name, param in self._model.named_parameters():
-            if param.stop_gradient is False:
-                assert name in self._shadow
-                self._backup[name] = np.array(param.numpy().copy())
-                param.set_value(np.array(self._shadow[name]))
-
-    def restore(self):
-        for name, param in self._model.named_parameters():
-            if param.stop_gradient is False:
-                assert name in self._backup
-                param.set_value(self._backup[name])
-        self._backup = {}

PaddleClas/tools/eval.py

@@ -1,112 +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.
-
-import paddle
-import paddle.nn.functional as F
-
-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__, '..')))
-
-from ppcls.utils import logger
-from ppcls.utils.save_load import init_model
-from ppcls.utils.config import get_config
-from ppcls.utils import multi_hot_encode
-from ppcls.utils import accuracy_score
-from ppcls.utils import mean_average_precision
-from ppcls.utils import precision_recall_fscore
-from ppcls.data import Reader
-import program
-
-import numpy as np
-
-
-def parse_args():
-    parser = argparse.ArgumentParser("PaddleClas eval script")
-    parser.add_argument(
-        '-c',
-        '--config',
-        type=str,
-        default='./configs/eval.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, return_dict={}):
-    config = get_config(args.config, overrides=args.override, show=True)
-    config.mode = "valid"
-    # assign place
-    use_gpu = config.get("use_gpu", True)
-    place = paddle.set_device('gpu' if use_gpu else 'cpu')
-    multilabel = config.get("multilabel", False)
-
-    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)
-
-    init_model(config, net, optimizer=None)
-    valid_dataloader = Reader(config, 'valid', places=place)()
-    net.eval()
-    with paddle.no_grad():
-        if not multilabel:
-            top1_acc = program.run(valid_dataloader, config, net, None, None,
-                                   0, 'valid')
-            return_dict["top1_acc"] = top1_acc
-
-            return top1_acc
-        else:
-            all_outs = []
-            targets = []
-            for _, batch in enumerate(valid_dataloader()):
-                feeds = program.create_feeds(batch, False, config.classes_num,
-                                             multilabel)
-                out = net(feeds["image"])
-                out = F.sigmoid(out)
-
-                use_distillation = config.get("use_distillation", False)
-                if use_distillation:
-                    out = out[1]
-
-                all_outs.extend(list(out.numpy()))
-                targets.extend(list(feeds["label"].numpy()))
-            all_outs = np.array(all_outs)
-            targets = np.array(targets)
-
-            mAP = mean_average_precision(all_outs, targets)
-
-            return_dict["mean average precision"] = mAP
-
-            return mAP
-
-
-if __name__ == '__main__':
-    args = parse_args()
-    return_dict = {}
-    main(args, return_dict)
-    print(return_dict)

PaddleClas/tools/export_model.py

@@ -1,85 +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 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__, '..')))
-
-from ppcls.modeling import architectures
-from ppcls.utils.save_load import load_dygraph_pretrain
-import paddle
-import paddle.nn.functional as F
-from paddle.jit import to_static
-
-
-def parse_args():
-    def str2bool(v):
-        return v.lower() in ("true", "t", "1")
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-m", "--model", type=str)
-    parser.add_argument("-p", "--pretrained_model", type=str)
-    parser.add_argument("-o", "--output_path", type=str, default="./inference")
-    parser.add_argument("--class_dim", type=int, default=1000)
-    parser.add_argument("--load_static_weights", type=str2bool, default=False)
-    parser.add_argument("--img_size", type=int, default=224)
-
-    return parser.parse_args()
-
-
-class Net(paddle.nn.Layer):
-    def __init__(self, net, class_dim, model):
-        super(Net, self).__init__()
-        self.pre_net = net(class_dim=class_dim)
-        self.model = model
-
-    def eval(self):
-        self.training = False
-        for layer in self.sublayers():
-            layer.training = False
-            layer.eval()
-
-    def forward(self, inputs):
-        x = self.pre_net(inputs)
-        if self.model == "GoogLeNet":
-            x = x[0]
-        x = F.softmax(x)
-        return x
-
-
-def main():
-    args = parse_args()
-
-    net = architectures.__dict__[args.model]
-    model = Net(net, args.class_dim, args.model)
-    load_dygraph_pretrain(
-        model.pre_net,
-        path=args.pretrained_model,
-        load_static_weights=args.load_static_weights)
-    model.eval()
-
-    model = to_static(
-        model,
-        input_spec=[
-            paddle.static.InputSpec(
-                shape=[None, 3, args.img_size, args.img_size], dtype='float32')
-        ])
-    paddle.jit.save(model, os.path.join(args.output_path, "inference"))
-
-
-if __name__ == "__main__":
-    main()

PaddleClas/tools/export_serving_model.py

@@ -1,76 +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 argparse
-import os
-from ppcls.modeling import architectures
-
-import paddle.fluid as fluid
-import paddle_serving_client.io as serving_io
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-m", "--model", type=str)
-    parser.add_argument("-p", "--pretrained_model", type=str)
-    parser.add_argument("-o", "--output_path", type=str, default="")
-    parser.add_argument("--class_dim", type=int, default=1000)
-    parser.add_argument("--img_size", type=int, default=224)
-
-    return parser.parse_args()
-
-
-def create_input(img_size=224):
-    image = fluid.data(
-        name='image', shape=[None, 3, img_size, img_size], dtype='float32')
-    return image
-
-
-def create_model(args, model, input, class_dim=1000):
-    if args.model == "GoogLeNet":
-        out, _, _ = model.net(input=input, class_dim=class_dim)
-    else:
-        out = model.net(input=input, class_dim=class_dim)
-        out = fluid.layers.softmax(out)
-    return out
-
-
-def main():
-    args = parse_args()
-
-    model = architectures.__dict__[args.model]()
-
-    place = fluid.CPUPlace()
-    exe = fluid.Executor(place)
-
-    startup_prog = fluid.Program()
-    infer_prog = fluid.Program()
-
-    with fluid.program_guard(infer_prog, startup_prog):
-        with fluid.unique_name.guard():
-            image = create_input(args.img_size)
-            out = create_model(args, model, image, class_dim=args.class_dim)
-
-    infer_prog = infer_prog.clone(for_test=True)
-    fluid.load(
-        program=infer_prog, model_path=args.pretrained_model, executor=exe)
-
-    model_path = os.path.join(args.output_path, "ppcls_model")
-    conf_path = os.path.join(args.output_path, "ppcls_client_conf")
-    serving_io.save_model(model_path, conf_path, {"image": image},
-                          {"prediction": out}, infer_prog)
-
-
-if __name__ == "__main__":
-    main()

PaddleClas/tools/infer/__init__.py

@@ -1,16 +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 .predict import Predictor
-from .utils import parse_args, create_paddle_predictor, preprocess, postprocess, get_image_list, save_prelabel_results, b64_to_np, np_to_b64

PaddleClas/tools/infer/infer.py

@@ -1,94 +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 numpy as np
-import cv2
-import os
-import sys
-
-import paddle
-import paddle.nn.functional as F
-
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(__dir__)
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../..')))
-
-from ppcls.utils.save_load import load_dygraph_pretrain
-from ppcls.utils import logger
-from ppcls.modeling import architectures
-from utils import parse_args, get_image_list, preprocess, postprocess, save_prelabel_results
-
-
-def main():
-    args = parse_args()
-    # assign the place
-    place = paddle.set_device('gpu' if args.use_gpu else 'cpu')
-    multilabel = True if args.multilabel else False
-
-    net = architectures.__dict__[args.model](class_dim=args.class_num)
-    load_dygraph_pretrain(net, args.pretrained_model, args.load_static_weights)
-    image_list = get_image_list(args.image_file)
-    batch_input_list = []
-    img_path_list = []
-    cnt = 0
-    for idx, img_path in enumerate(image_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_path_list.append(img_path)
-            cnt += 1
-
-        if cnt % args.batch_size == 0 or (idx + 1) == len(image_list):
-            batch_tensor = paddle.to_tensor(batch_input_list)
-            net.eval()
-            batch_outputs = net(batch_tensor)
-            if args.model == "GoogLeNet":
-                batch_outputs = batch_outputs[0]
-            if multilabel:
-                batch_outputs = F.sigmoid(batch_outputs)
-            else:
-                batch_outputs = F.softmax(batch_outputs)
-            batch_outputs = batch_outputs.numpy()
-            batch_result_list = postprocess(batch_outputs, args.top_k, multilabel=multilabel)
-
-            for number, result_dict in enumerate(batch_result_list):
-                filename = img_path_list[number].split("/")[-1]
-                clas_ids = result_dict["clas_ids"]
-                if multilabel:
-                    print("File:{}, multilabel result: ".format(filename))
-                    for id, score in zip(clas_ids, result_dict["scores"]):
-                        print("\tclass id: {}, probability: {:.2f}".format(id, score))
-                else:
-                    scores_str = "[{}]".format(", ".join("{:.2f}".format(
-                        r) for r in result_dict["scores"]))
-                    print("File:{}, Top-{} result: class id(s): {}, score(s): {}".
-                        format(filename, args.top_k, clas_ids, scores_str))
-
-                if args.pre_label_image:
-                    save_prelabel_results(clas_ids[0], img_path_list[number],
-                                          args.pre_label_out_idr)
-
-            batch_input_list = []
-            img_path_list = []
-
-
-if __name__ == "__main__":
-    main()

PaddleClas/tools/infer/predict.py

@@ -1,117 +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 numpy as np
-import cv2
-import time
-
-import sys
-sys.path.insert(0, ".")
-from ppcls.utils import logger
-from tools.infer.utils import parse_args, get_image_list, create_paddle_predictor, preprocess, postprocess
-
-
-class Predictor(object):
-    def __init__(self, args):
-        # HALF precission predict only work when using tensorrt
-        if args.use_fp16 is True:
-            assert args.use_tensorrt is True
-        self.args = args
-
-        self.paddle_predictor = create_paddle_predictor(args)
-        input_names = self.paddle_predictor.get_input_names()
-        self.input_tensor = self.paddle_predictor.get_input_handle(input_names[
-            0])
-
-        output_names = self.paddle_predictor.get_output_names()
-        self.output_tensor = self.paddle_predictor.get_output_handle(
-            output_names[0])
-
-    def predict(self, batch_input):
-        self.input_tensor.copy_from_cpu(batch_input)
-        self.paddle_predictor.run()
-        batch_output = self.output_tensor.copy_to_cpu()
-        return batch_output
-
-    def normal_predict(self):
-        image_list = get_image_list(self.args.image_file)
-        batch_input_list = []
-        img_name_list = []
-        cnt = 0
-        for idx, img_path in enumerate(image_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]
-                img = preprocess(img, args)
-                batch_input_list.append(img)
-                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_list):
-                batch_outputs = self.predict(np.array(batch_input_list))
-                batch_result_list = postprocess(batch_outputs, self.args.top_k)
-
-                for number, result_dict in enumerate(batch_result_list):
-                    filename = img_name_list[number]
-                    clas_ids = result_dict["clas_ids"]
-                    scores_str = "[{}]".format(", ".join("{:.2f}".format(
-                        r) for r in result_dict["scores"]))
-                    print(
-                        "File:{}, Top-{} result: class id(s): {}, score(s): {}".
-                        format(filename, self.args.top_k, clas_ids,
-                               scores_str))
-                batch_input_list = []
-                img_name_list = []
-
-    def benchmark_predict(self):
-        test_num = 500
-        test_time = 0.0
-        for i in range(0, test_num + 10):
-            inputs = np.random.rand(args.batch_size, 3, 224,
-                                    224).astype(np.float32)
-            start_time = time.time()
-            batch_output = self.predict(inputs).flatten()
-            if i >= 10:
-                test_time += time.time() - start_time
-            time.sleep(0.01)  # sleep for T4 GPU
-
-        fp_message = "FP16" if args.use_fp16 else "FP32"
-        trt_msg = "using tensorrt" if args.use_tensorrt else "not using tensorrt"
-        print("{0}\t{1}\t{2}\tbatch size: {3}\ttime(ms): {4}".format(
-            args.model, trt_msg, fp_message, args.batch_size, 1000 * test_time
-            / test_num))
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    assert os.path.exists(
-        args.model_file), "The path of 'model_file' does not exist: {}".format(
-            args.model_file)
-    assert os.path.exists(
-        args.params_file
-    ), "The path of 'params_file' does not exist: {}".format(args.params_file)
-
-    predictor = Predictor(args)
-    if not args.enable_benchmark:
-        predictor.normal_predict()
-    else:
-        assert args.model is not None
-        predictor.benchmark_predict()