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

paddlex/ppcls/optimizer/learning_rate.py

@@ -1,159 +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 sys
-import math
-
-from paddle.optimizer.lr import LinearWarmup
-from paddle.optimizer.lr import PiecewiseDecay
-from paddle.optimizer.lr import CosineAnnealingDecay
-from paddle.optimizer.lr import ExponentialDecay
-
-__all__ = ['LearningRateBuilder']
-
-
-class Cosine(CosineAnnealingDecay):
-    """
-    Cosine learning rate decay
-    lr = 0.05 * (math.cos(epoch * (math.pi / epochs)) + 1)
-
-    Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        epochs(int): total training epochs
-    """
-
-    def __init__(self, lr, step_each_epoch, epochs, **kwargs):
-        super(Cosine, self).__init__(
-            learning_rate=lr,
-            T_max=step_each_epoch * epochs, )
-
-        self.update_specified = False
-
-
-class Piecewise(PiecewiseDecay):
-    """
-    Piecewise learning rate decay
-
-    Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        decay_epochs(list): piecewise decay epochs
-        gamma(float): decay factor
-    """
-
-    def __init__(self, lr, step_each_epoch, decay_epochs, gamma=0.1, **kwargs):
-        boundaries = [step_each_epoch * e for e in decay_epochs]
-        lr_values = [lr * (gamma**i) for i in range(len(boundaries) + 1)]
-        super(Piecewise, self).__init__(
-            boundaries=boundaries, values=lr_values)
-
-        self.update_specified = False
-
-
-class CosineWarmup(LinearWarmup):
-    """
-    Cosine learning rate decay with warmup
-    [0, warmup_epoch): linear warmup
-    [warmup_epoch, epochs): cosine decay
-
-    Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        epochs(int): total training epochs
-        warmup_epoch(int): epoch num of warmup
-    """
-
-    def __init__(self, lr, step_each_epoch, epochs, warmup_epoch=5, **kwargs):
-        assert epochs > warmup_epoch, "total epoch({}) should be larger than warmup_epoch({}) in CosineWarmup.".format(
-            epochs, warmup_epoch)
-        warmup_step = warmup_epoch * step_each_epoch
-        start_lr = 0.0
-        end_lr = lr
-        lr_sch = Cosine(lr, step_each_epoch, epochs - warmup_epoch)
-
-        super(CosineWarmup, self).__init__(
-            learning_rate=lr_sch,
-            warmup_steps=warmup_step,
-            start_lr=start_lr,
-            end_lr=end_lr)
-
-        self.update_specified = False
-
-
-class ExponentialWarmup(LinearWarmup):
-    """
-    Exponential learning rate decay with warmup
-    [0, warmup_epoch): linear warmup
-    [warmup_epoch, epochs): Exponential decay
-
-    Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        decay_epochs(float): decay epochs
-        decay_rate(float): decay rate
-        warmup_epoch(int): epoch num of warmup
-    """
-
-    def __init__(self,
-                 lr,
-                 step_each_epoch,
-                 decay_epochs=2.4,
-                 decay_rate=0.97,
-                 warmup_epoch=5,
-                 **kwargs):
-        warmup_step = warmup_epoch * step_each_epoch
-        start_lr = 0.0
-        end_lr = lr
-        lr_sch = ExponentialDecay(lr, decay_rate)
-
-        super(ExponentialWarmup, self).__init__(
-            learning_rate=lr_sch,
-            warmup_steps=warmup_step,
-            start_lr=start_lr,
-            end_lr=end_lr)
-
-        # NOTE: hac method to update exponential lr scheduler
-        self.update_specified = True
-        self.update_start_step = warmup_step
-        self.update_step_interval = int(decay_epochs * step_each_epoch)
-        self.step_each_epoch = step_each_epoch
-
-
-class LearningRateBuilder():
-    """
-    Build learning rate variable
-    https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/layers_cn.html
-
-    Args:
-        function(str): class name of learning rate
-        params(dict): parameters used for init the class
-    """
-
-    def __init__(self,
-                 function='Linear',
-                 params={'lr': 0.1,
-                         'steps': 100,
-                         'end_lr': 0.0}):
-        self.function = function
-        self.params = params
-
-    def __call__(self):
-        mod = sys.modules[__name__]
-        lr = getattr(mod, self.function)(**self.params)
-        return lr

paddlex/ppcls/optimizer/optimizer.py

@@ -1,165 +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 sys
-
-import paddle
-import paddle.regularizer as regularizer
-
-__all__ = ['OptimizerBuilder']
-
-
-class L1Decay(object):
-    """
-    L1 Weight Decay Regularization, which encourages the weights to be sparse.
-
-    Args:
-        factor(float): regularization coeff. Default:0.0.
-    """
-
-    def __init__(self, factor=0.0):
-        super(L1Decay, self).__init__()
-        self.factor = factor
-
-    def __call__(self):
-        reg = regularizer.L1Decay(self.factor)
-        return reg
-
-
-class L2Decay(object):
-    """
-    L2 Weight Decay Regularization, which encourages the weights to be sparse.
-
-    Args:
-        factor(float): regularization coeff. Default:0.0.
-    """
-
-    def __init__(self, factor=0.0):
-        super(L2Decay, self).__init__()
-        self.factor = factor
-
-    def __call__(self):
-        reg = regularizer.L2Decay(self.factor)
-        return reg
-
-
-class Momentum(object):
-    """
-    Simple Momentum optimizer with velocity state.
-
-    Args:
-        learning_rate (float|Variable) - The learning rate used to update parameters.
-            Can be a float value or a Variable with one float value as data element.
-        momentum (float) - Momentum factor.
-        regularization (WeightDecayRegularizer, optional) - The strategy of regularization.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 momentum,
-                 parameter_list=None,
-                 regularization=None,
-                 multi_precision=False,
-                 **args):
-        super(Momentum, self).__init__()
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.parameter_list = parameter_list
-        self.regularization = regularization
-        self.multi_precision = multi_precision
-
-    def __call__(self):
-        opt = paddle.optimizer.Momentum(
-            learning_rate=self.learning_rate,
-            momentum=self.momentum,
-            parameters=self.parameter_list,
-            weight_decay=self.regularization,
-            multi_precision=self.multi_precision)
-        return opt
-
-
-class RMSProp(object):
-    """
-    Root Mean Squared Propagation (RMSProp) is an unpublished, adaptive learning rate method.
-
-    Args:
-        learning_rate (float|Variable) - The learning rate used to update parameters.
-            Can be a float value or a Variable with one float value as data element.
-        momentum (float) - Momentum factor.
-        rho (float) - rho value in equation.
-        epsilon (float) - avoid division by zero, default is 1e-6.
-        regularization (WeightDecayRegularizer, optional) - The strategy of regularization.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 momentum,
-                 rho=0.95,
-                 epsilon=1e-6,
-                 parameter_list=None,
-                 regularization=None,
-                 **args):
-        super(RMSProp, self).__init__()
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.rho = rho
-        self.epsilon = epsilon
-        self.parameter_list = parameter_list
-        self.regularization = regularization
-
-    def __call__(self):
-        opt = paddle.optimizer.RMSProp(
-            learning_rate=self.learning_rate,
-            momentum=self.momentum,
-            rho=self.rho,
-            epsilon=self.epsilon,
-            parameters=self.parameter_list,
-            weight_decay=self.regularization)
-        return opt
-
-
-class OptimizerBuilder(object):
-    """
-    Build optimizer
-
-    Args:
-        function(str): optimizer name of learning rate
-        params(dict): parameters used for init the class
-        regularizer (dict): parameters used for create regularization
-    """
-
-    def __init__(self,
-                 function='Momentum',
-                 params={'momentum': 0.9},
-                 regularizer=None):
-        self.function = function
-        self.params = params
-        # create regularizer
-        if regularizer is not None:
-            mod = sys.modules[__name__]
-            reg_func = regularizer['function'] + 'Decay'
-            del regularizer['function']
-            reg = getattr(mod, reg_func)(**regularizer)()
-            self.params['regularization'] = reg
-
-    def __call__(self, learning_rate, parameter_list=None):
-        mod = sys.modules[__name__]
-        opt = getattr(mod, self.function)
-        return opt(learning_rate=learning_rate,
-                   parameter_list=parameter_list,
-                   **self.params)()

paddlex/ppcls/utils/__init__.py

@@ -1,27 +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 logger
-from . import misc
-from . import model_zoo
-from . import metrics
-
-from .save_load import init_model, save_model
-from .config import get_config
-from .misc import AverageMeter
-from .metrics import multi_hot_encode
-from .metrics import hamming_distance
-from .metrics import accuracy_score
-from .metrics import precision_recall_fscore
-from .metrics import mean_average_precision

paddlex/ppcls/utils/check.py

@@ -1,151 +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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-import paddle
-from paddle import is_compiled_with_cuda
-
-from paddlex.ppcls.modeling import get_architectures
-from paddlex.ppcls.modeling import similar_architectures
-from paddlex.ppcls.modeling import get_blacklist_model_in_static_mode
-from paddlex.ppcls.utils import logger
-
-
-def check_version():
-    """
-    Log error and exit when the installed version of paddlepaddle is
-    not satisfied.
-    """
-    err = "PaddlePaddle version 1.8.0 or higher is required, " \
-          "or a suitable develop version is satisfied as well. \n" \
-          "Please make sure the version is good with your code."
-    try:
-        pass
-        # paddle.utils.require_version('0.0.0')
-    except Exception:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_gpu():
-    """
-    Log error and exit when using paddlepaddle cpu version.
-    """
-    err = "You are using paddlepaddle cpu version! Please try to " \
-          "install paddlepaddle-gpu to run model on GPU."
-
-    try:
-        assert is_compiled_with_cuda()
-    except AssertionError:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_architecture(architecture):
-    """
-    check architecture and recommend similar architectures
-    """
-    assert isinstance(architecture, dict), \
-        ("the type of architecture({}) should be dict". format(architecture))
-    assert "name" in architecture, \
-        ("name must be in the architecture keys, just contains: {}". format(
-            architecture.keys()))
-
-    similar_names = similar_architectures(architecture["name"],
-                                          get_architectures())
-    model_list = ', '.join(similar_names)
-    err = "Architecture [{}] is not exist! Maybe you want: [{}]" \
-          "".format(architecture["name"], model_list)
-    try:
-        assert architecture["name"] in similar_names
-    except AssertionError:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_model_with_running_mode(architecture):
-    """
-    check whether the model is consistent with the operating mode
-    """
-    # some model are not supported in the static mode
-    blacklist = get_blacklist_model_in_static_mode()
-    if not paddle.in_dynamic_mode() and architecture["name"] in blacklist:
-        logger.error("Model: {} is not supported in the staic mode.".format(
-            architecture["name"]))
-        sys.exit(1)
-    return
-
-
-def check_mix(architecture, use_mix=False):
-    """
-    check mix parameter
-    """
-    err = "Cannot use mix processing in GoogLeNet, " \
-          "please set use_mix = False."
-    try:
-        if architecture["name"] == "GoogLeNet":
-            assert use_mix is not True
-    except AssertionError:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_classes_num(classes_num):
-    """
-    check classes_num
-    """
-    err = "classes_num({}) should be a positive integer" \
-        "and larger than 1".format(classes_num)
-    try:
-        assert isinstance(classes_num, int)
-        assert classes_num > 1
-    except AssertionError:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_data_dir(path):
-    """
-    check cata_dir
-    """
-    err = "Data path is not exist, please given a right path" \
-          "".format(path)
-    try:
-        assert os.isdir(path)
-    except AssertionError:
-        logger.error(err)
-        sys.exit(1)
-
-
-def check_function_params(config, key):
-    """
-    check specify config
-    """
-    k_config = config.get(key)
-    assert k_config is not None, \
-        ('{} is required in config'.format(key))
-
-    assert k_config.get('function'), \
-        ('function is required {} config'.format(key))
-    params = k_config.get('params')
-    assert params is not None, \
-        ('params is required in {} config'.format(key))
-    assert isinstance(params, dict), \
-        ('the params in {} config should be a dict'.format(key))

paddlex/ppcls/utils/config.py

@@ -1,201 +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 os
-
-import yaml
-
-from paddlex.ppcls.utils import check
-from paddlex.ppcls.utils import logger
-
-__all__ = ['get_config']
-
-
-class AttrDict(dict):
-    def __getattr__(self, key):
-        return self[key]
-
-    def __setattr__(self, key, value):
-        if key in self.__dict__:
-            self.__dict__[key] = value
-        else:
-            self[key] = value
-
-
-def create_attr_dict(yaml_config):
-    from ast import literal_eval
-    for key, value in yaml_config.items():
-        if type(value) is dict:
-            yaml_config[key] = value = AttrDict(value)
-        if isinstance(value, str):
-            try:
-                value = literal_eval(value)
-            except BaseException:
-                pass
-        if isinstance(value, AttrDict):
-            create_attr_dict(yaml_config[key])
-        else:
-            yaml_config[key] = value
-
-
-def parse_config(cfg_file):
-    """Load a config file into AttrDict"""
-    with open(cfg_file, 'r') as fopen:
-        yaml_config = AttrDict(yaml.load(fopen, Loader=yaml.SafeLoader))
-    create_attr_dict(yaml_config)
-    return yaml_config
-
-
-def print_dict(d, delimiter=0):
-    """
-    Recursively visualize a dict and
-    indenting acrrording by the relationship of keys.
-    """
-    placeholder = "-" * 60
-    for k, v in sorted(d.items()):
-        if isinstance(v, dict):
-            logger.info("{}{} : ".format(delimiter * " ",
-                                         logger.coloring(k, "HEADER")))
-            print_dict(v, delimiter + 4)
-        elif isinstance(v, list) and len(v) >= 1 and isinstance(v[0], dict):
-            logger.info("{}{} : ".format(delimiter * " ",
-                                         logger.coloring(str(k), "HEADER")))
-            for value in v:
-                print_dict(value, delimiter + 4)
-        else:
-            logger.info("{}{} : {}".format(delimiter * " ",
-                                           logger.coloring(k, "HEADER"),
-                                           logger.coloring(v, "OKGREEN")))
-
-        if k.isupper():
-            logger.info(placeholder)
-
-
-def print_config(config):
-    """
-    visualize configs
-
-    Arguments:
-        config: configs
-    """
-    logger.advertise()
-    print_dict(config)
-
-
-def check_config(config):
-    """
-    Check config
-    """
-    check.check_version()
-
-    use_gpu = config.get('use_gpu', True)
-    if use_gpu:
-        check.check_gpu()
-
-    architecture = config.get('ARCHITECTURE')
-    check.check_architecture(architecture)
-    check.check_model_with_running_mode(architecture)
-
-    use_mix = config.get('use_mix', False)
-    check.check_mix(architecture, use_mix)
-
-    classes_num = config.get('classes_num')
-    check.check_classes_num(classes_num)
-
-    mode = config.get('mode', 'train')
-    if mode.lower() == 'train':
-        check.check_function_params(config, 'LEARNING_RATE')
-        check.check_function_params(config, 'OPTIMIZER')
-
-
-def override(dl, ks, v):
-    """
-    Recursively replace dict of list
-
-    Args:
-        dl(dict or list): dict or list to be replaced
-        ks(list): list of keys
-        v(str): value to be replaced
-    """
-
-    def str2num(v):
-        try:
-            return eval(v)
-        except Exception:
-            return v
-
-    assert isinstance(dl, (list, dict)), ("{} should be a list or a dict")
-    assert len(ks) > 0, ('lenght of keys should larger than 0')
-    if isinstance(dl, list):
-        k = str2num(ks[0])
-        if len(ks) == 1:
-            assert k < len(dl), ('index({}) out of range({})'.format(k, dl))
-            dl[k] = str2num(v)
-        else:
-            override(dl[k], ks[1:], v)
-    else:
-        if len(ks) == 1:
-            # assert ks[0] in dl, ('{} is not exist in {}'.format(ks[0], dl))
-            if not ks[0] in dl:
-                logger.warning('A new filed ({}) detected!'.format(ks[0]))
-            dl[ks[0]] = str2num(v)
-        else:
-            if not ks[0] in dl:
-                logger.warning('A new filed ({}) detected!'.format(ks[0]))
-                dl[ks[0]] = {}
-            override(dl[ks[0]], ks[1:], v)
-
-
-def override_config(config, options=None):
-    """
-    Recursively override the config
-
-    Args:
-        config(dict): dict to be replaced
-        options(list): list of pairs(key0.key1.idx.key2=value)
-            such as: [
-                'topk=2',
-                'VALID.transforms.1.ResizeImage.resize_short=300'
-            ]
-
-    Returns:
-        config(dict): replaced config
-    """
-    if options is not None:
-        for opt in options:
-            assert isinstance(opt, str), (
-                "option({}) should be a str".format(opt))
-            assert "=" in opt, (
-                "option({}) should contain a ="
-                "to distinguish between key and value".format(opt))
-            pair = opt.split('=')
-            assert len(pair) == 2, ("there can be only a = in the option")
-            key, value = pair
-            keys = key.split('.')
-            override(config, keys, value)
-
-    return config
-
-
-def get_config(fname, overrides=None, show=True):
-    """
-    Read config from file
-    """
-    assert os.path.exists(fname), (
-        'config file({}) is not exist'.format(fname))
-    config = parse_config(fname)
-    override_config(config, overrides)
-    if show:
-        print_config(config)
-    check_config(config)
-    return config