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

paddlex/ppdet/optimizer.py

@@ -1,335 +0,0 @@
-# Copyright (c) 2019 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 math
-import paddle
-import paddle.nn as nn
-
-import paddle.optimizer as optimizer
-import paddle.regularizer as regularizer
-
-from paddlex.ppdet.core.workspace import register, serializable
-
-__all__ = ['LearningRate', 'OptimizerBuilder']
-
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-
-@serializable
-class CosineDecay(object):
-    """
-    Cosine learning rate decay
-
-    Args:
-        max_epochs (int): max epochs for the training process.
-            if you commbine cosine decay with warmup, it is recommended that
-            the max_iters is much larger than the warmup iter
-    """
-
-    def __init__(self, max_epochs=1000, use_warmup=True):
-        self.max_epochs = max_epochs
-        self.use_warmup = use_warmup
-
-    def __call__(self,
-                 base_lr=None,
-                 boundary=None,
-                 value=None,
-                 step_per_epoch=None):
-        assert base_lr is not None, "either base LR or values should be provided"
-
-        max_iters = self.max_epochs * int(step_per_epoch)
-
-        if boundary is not None and value is not None and self.use_warmup:
-            warmup_iters = len(boundary)
-            for i in range(int(boundary[-1]), max_iters):
-                boundary.append(i)
-
-                decayed_lr = base_lr * 0.5 * (math.cos(
-                    (i - warmup_iters) * math.pi /
-                    (max_iters - warmup_iters)) + 1)
-                value.append(decayed_lr)
-            return optimizer.lr.PiecewiseDecay(boundary, value)
-
-        return optimizer.lr.CosineAnnealingDecay(base_lr, T_max=max_iters)
-
-
-@serializable
-class PiecewiseDecay(object):
-    """
-    Multi step learning rate decay
-
-    Args:
-        gamma (float | list): decay factor
-        milestones (list): steps at which to decay learning rate
-    """
-
-    def __init__(self,
-                 gamma=[0.1, 0.01],
-                 milestones=[8, 11],
-                 values=None,
-                 use_warmup=True):
-        super(PiecewiseDecay, self).__init__()
-        if type(gamma) is not list:
-            self.gamma = []
-            for i in range(len(milestones)):
-                self.gamma.append(gamma / 10**i)
-        else:
-            self.gamma = gamma
-        self.milestones = milestones
-        self.values = values
-        self.use_warmup = use_warmup
-
-    def __call__(self,
-                 base_lr=None,
-                 boundary=None,
-                 value=None,
-                 step_per_epoch=None):
-        if boundary is not None and self.use_warmup:
-            boundary.extend([int(step_per_epoch) * i for i in self.milestones])
-        else:
-            # do not use LinearWarmup
-            boundary = [int(step_per_epoch) * i for i in self.milestones]
-            value = [base_lr]  # during step[0, boundary[0]] is base_lr
-
-        # self.values is setted directly in config
-        if self.values is not None:
-            assert len(self.milestones) + 1 == len(self.values)
-            return optimizer.lr.PiecewiseDecay(boundary, self.values)
-
-        # value is computed by self.gamma
-        value = value if value is not None else [base_lr]
-        for i in self.gamma:
-            value.append(base_lr * i)
-
-        return optimizer.lr.PiecewiseDecay(boundary, value)
-
-
-@serializable
-class LinearWarmup(object):
-    """
-    Warm up learning rate linearly
-
-    Args:
-        steps (int): warm up steps
-        start_factor (float): initial learning rate factor
-    """
-
-    def __init__(self, steps=500, start_factor=1. / 3):
-        super(LinearWarmup, self).__init__()
-        self.steps = steps
-        self.start_factor = start_factor
-
-    def __call__(self, base_lr, step_per_epoch):
-        boundary = []
-        value = []
-        for i in range(self.steps + 1):
-            if self.steps > 0:
-                alpha = i / self.steps
-                factor = self.start_factor * (1 - alpha) + alpha
-                lr = base_lr * factor
-                value.append(lr)
-            if i > 0:
-                boundary.append(i)
-        return boundary, value
-
-
-@serializable
-class BurninWarmup(object):
-    """
-    Warm up learning rate in burnin mode
-    Args:
-        steps (int): warm up steps
-    """
-
-    def __init__(self, steps=1000):
-        super(BurninWarmup, self).__init__()
-        self.steps = steps
-
-    def __call__(self, base_lr, step_per_epoch):
-        boundary = []
-        value = []
-        burnin = min(self.steps, step_per_epoch)
-        for i in range(burnin + 1):
-            factor = (i * 1.0 / burnin)**4
-            lr = base_lr * factor
-            value.append(lr)
-            if i > 0:
-                boundary.append(i)
-        return boundary, value
-
-
-@register
-class LearningRate(object):
-    """
-    Learning Rate configuration
-
-    Args:
-        base_lr (float): base learning rate
-        schedulers (list): learning rate schedulers
-    """
-    __category__ = 'optim'
-
-    def __init__(self,
-                 base_lr=0.01,
-                 schedulers=[PiecewiseDecay(), LinearWarmup()]):
-        super(LearningRate, self).__init__()
-        self.base_lr = base_lr
-        self.schedulers = schedulers
-
-    def __call__(self, step_per_epoch):
-        assert len(self.schedulers) >= 1
-        if not self.schedulers[0].use_warmup:
-            return self.schedulers[0](base_lr=self.base_lr,
-                                      step_per_epoch=step_per_epoch)
-
-        # TODO: split warmup & decay
-        # warmup
-        boundary, value = self.schedulers[1](self.base_lr, step_per_epoch)
-        # decay
-        decay_lr = self.schedulers[0](self.base_lr, boundary, value,
-                                      step_per_epoch)
-        return decay_lr
-
-
-@register
-class OptimizerBuilder():
-    """
-    Build optimizer handles
-    Args:
-        regularizer (object): an `Regularizer` instance
-        optimizer (object): an `Optimizer` instance
-    """
-    __category__ = 'optim'
-
-    def __init__(self,
-                 clip_grad_by_norm=None,
-                 regularizer={'type': 'L2',
-                              'factor': .0001},
-                 optimizer={'type': 'Momentum',
-                            'momentum': .9}):
-        self.clip_grad_by_norm = clip_grad_by_norm
-        self.regularizer = regularizer
-        self.optimizer = optimizer
-
-    def __call__(self, learning_rate, model=None):
-        if self.clip_grad_by_norm is not None:
-            grad_clip = nn.ClipGradByGlobalNorm(
-                clip_norm=self.clip_grad_by_norm)
-        else:
-            grad_clip = None
-        if self.regularizer and self.regularizer != 'None':
-            reg_type = self.regularizer['type'] + 'Decay'
-            reg_factor = self.regularizer['factor']
-            regularization = getattr(regularizer, reg_type)(reg_factor)
-        else:
-            regularization = None
-
-        optim_args = self.optimizer.copy()
-        optim_type = optim_args['type']
-        del optim_args['type']
-        if optim_type != 'AdamW':
-            optim_args['weight_decay'] = regularization
-        op = getattr(optimizer, optim_type)
-
-        if 'without_weight_decay_params' in optim_args:
-            keys = optim_args['without_weight_decay_params']
-            params = [{
-                'params': [
-                    p for n, p in model.named_parameters()
-                    if any([k in n for k in keys])
-                ],
-                'weight_decay': 0.
-            }, {
-                'params': [
-                    p for n, p in model.named_parameters()
-                    if all([k not in n for k in keys])
-                ]
-            }]
-            del optim_args['without_weight_decay_params']
-        else:
-            params = model.parameters()
-
-        return op(learning_rate=learning_rate,
-                  parameters=params,
-                  grad_clip=grad_clip,
-                  **optim_args)
-
-
-class ModelEMA(object):
-    """
-    Exponential Weighted Average for Deep Neutal Networks
-    Args:
-        model (nn.Layer): Detector of model.
-        decay (int):  The decay used for updating ema parameter.
-            Ema's parameter are updated with the formula:
-           `ema_param = decay * ema_param + (1 - decay) * cur_param`.
-            Defaults is 0.9998.
-        use_thres_step (bool): Whether set decay by thres_step or not
-        cycle_epoch (int): The epoch of interval to reset ema_param and
-            step. Defaults is -1, which means not reset. Its function is to
-            add a regular effect to ema, which is set according to experience
-            and is effective when the total training epoch is large.
-    """
-
-    def __init__(self,
-                 model,
-                 decay=0.9998,
-                 use_thres_step=False,
-                 cycle_epoch=-1):
-        self.step = 0
-        self.epoch = 0
-        self.decay = decay
-        self.state_dict = dict()
-        for k, v in model.state_dict().items():
-            self.state_dict[k] = paddle.zeros_like(v)
-        self.use_thres_step = use_thres_step
-        self.cycle_epoch = cycle_epoch
-
-    def reset(self):
-        self.step = 0
-        self.epoch = 0
-        for k, v in self.state_dict.items():
-            self.state_dict[k] = paddle.zeros_like(v)
-
-    def update(self, model):
-        if self.use_thres_step:
-            decay = min(self.decay, (1 + self.step) / (10 + self.step))
-        else:
-            decay = self.decay
-        self._decay = decay
-        model_dict = model.state_dict()
-        for k, v in self.state_dict.items():
-            v = decay * v + (1 - decay) * model_dict[k]
-            v.stop_gradient = True
-            self.state_dict[k] = v
-        self.step += 1
-
-    def apply(self):
-        if self.step == 0:
-            return self.state_dict
-        state_dict = dict()
-        for k, v in self.state_dict.items():
-            v = v / (1 - self._decay**self.step)
-            v.stop_gradient = True
-            state_dict[k] = v
-        self.epoch += 1
-        if self.cycle_epoch > 0 and self.epoch == self.cycle_epoch:
-            self.reset()
-
-        return state_dict

paddlex/ppdet/slim/__init__.py

@@ -1,82 +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 prune
-from . import quant
-from . import distill
-from . import unstructured_prune
-
-from .prune import *
-from .quant import *
-from .distill import *
-from .unstructured_prune import *
-
-import yaml
-from paddlex.ppdet.core.workspace import load_config
-from paddlex.ppdet.utils.checkpoint import load_pretrain_weight
-
-
-def build_slim_model(cfg, slim_cfg, mode='train'):
-    with open(slim_cfg) as f:
-        slim_load_cfg = yaml.load(f, Loader=yaml.Loader)
-    if mode != 'train' and slim_load_cfg['slim'] == 'Distill':
-        return cfg
-
-    if slim_load_cfg['slim'] == 'Distill':
-        model = DistillModel(cfg, slim_cfg)
-        cfg['model'] = model
-    elif slim_load_cfg['slim'] == 'DistillPrune':
-        if mode == 'train':
-            model = DistillModel(cfg, slim_cfg)
-            pruner = create(cfg.pruner)
-            pruner(model.student_model)
-        else:
-            model = create(cfg.architecture)
-            weights = cfg.weights
-            load_config(slim_cfg)
-            pruner = create(cfg.pruner)
-            model = pruner(model)
-            load_pretrain_weight(model, weights)
-        cfg['model'] = model
-        cfg['slim_type'] = cfg.slim
-    elif slim_load_cfg['slim'] == 'PTQ':
-        model = create(cfg.architecture)
-        load_config(slim_cfg)
-        load_pretrain_weight(model, cfg.weights)
-        slim = create(cfg.slim)
-        cfg['slim_type'] = cfg.slim
-        cfg['model'] = slim(model)
-        cfg['slim'] = slim
-    elif slim_load_cfg['slim'] == 'UnstructuredPruner':
-        load_config(slim_cfg)
-        slim = create(cfg.slim)
-        cfg['slim_type'] = cfg.slim
-        cfg['slim'] = slim
-        cfg['unstructured_prune'] = True
-    else:
-        load_config(slim_cfg)
-        model = create(cfg.architecture)
-        if mode == 'train':
-            load_pretrain_weight(model, cfg.pretrain_weights)
-        slim = create(cfg.slim)
-        cfg['slim_type'] = cfg.slim
-        # TODO: fix quant export model in framework.
-        if mode == 'test' and slim_load_cfg['slim'] == 'QAT':
-            slim.quant_config['activation_preprocess_type'] = None
-        cfg['model'] = slim(model)
-        cfg['slim'] = slim
-        if mode != 'train':
-            load_pretrain_weight(cfg['model'], cfg.weights)
-
-    return cfg

paddlex/ppdet/slim/distill.py

@@ -1,110 +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 paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from paddlex.ppdet.core.workspace import register, create, load_config
-from paddlex.ppdet.modeling import ops
-from paddlex.ppdet.utils.checkpoint import load_pretrain_weight
-from paddlex.ppdet.utils.logger import setup_logger
-
-logger = setup_logger(__name__)
-
-
-class DistillModel(nn.Layer):
-    def __init__(self, cfg, slim_cfg):
-        super(DistillModel, self).__init__()
-
-        self.student_model = create(cfg.architecture)
-        logger.debug('Load student model pretrain_weights:{}'.format(
-            cfg.pretrain_weights))
-        load_pretrain_weight(self.student_model, cfg.pretrain_weights)
-
-        slim_cfg = load_config(slim_cfg)
-        self.teacher_model = create(slim_cfg.architecture)
-        self.distill_loss = create(slim_cfg.distill_loss)
-        logger.debug('Load teacher model pretrain_weights:{}'.format(
-            slim_cfg.pretrain_weights))
-        load_pretrain_weight(self.teacher_model, slim_cfg.pretrain_weights)
-
-        for param in self.teacher_model.parameters():
-            param.trainable = False
-
-    def parameters(self):
-        return self.student_model.parameters()
-
-    def forward(self, inputs):
-        if self.training:
-            teacher_loss = self.teacher_model(inputs)
-            student_loss = self.student_model(inputs)
-            loss = self.distill_loss(self.teacher_model, self.student_model)
-            student_loss['distill_loss'] = loss
-            student_loss['teacher_loss'] = teacher_loss['loss']
-            student_loss['loss'] += student_loss['distill_loss']
-            return student_loss
-        else:
-            return self.student_model(inputs)
-
-
-@register
-class DistillYOLOv3Loss(nn.Layer):
-    def __init__(self, weight=1000):
-        super(DistillYOLOv3Loss, self).__init__()
-        self.weight = weight
-
-    def obj_weighted_reg(self, sx, sy, sw, sh, tx, ty, tw, th, tobj):
-        loss_x = ops.sigmoid_cross_entropy_with_logits(sx, F.sigmoid(tx))
-        loss_y = ops.sigmoid_cross_entropy_with_logits(sy, F.sigmoid(ty))
-        loss_w = paddle.abs(sw - tw)
-        loss_h = paddle.abs(sh - th)
-        loss = paddle.add_n([loss_x, loss_y, loss_w, loss_h])
-        weighted_loss = paddle.mean(loss * F.sigmoid(tobj))
-        return weighted_loss
-
-    def obj_weighted_cls(self, scls, tcls, tobj):
-        loss = ops.sigmoid_cross_entropy_with_logits(scls, F.sigmoid(tcls))
-        weighted_loss = paddle.mean(paddle.multiply(loss, F.sigmoid(tobj)))
-        return weighted_loss
-
-    def obj_loss(self, sobj, tobj):
-        obj_mask = paddle.cast(tobj > 0., dtype="float32")
-        obj_mask.stop_gradient = True
-        loss = paddle.mean(
-            ops.sigmoid_cross_entropy_with_logits(sobj, obj_mask))
-        return loss
-
-    def forward(self, teacher_model, student_model):
-        teacher_distill_pairs = teacher_model.yolo_head.loss.distill_pairs
-        student_distill_pairs = student_model.yolo_head.loss.distill_pairs
-        distill_reg_loss, distill_cls_loss, distill_obj_loss = [], [], []
-        for s_pair, t_pair in zip(student_distill_pairs,
-                                  teacher_distill_pairs):
-            distill_reg_loss.append(
-                self.obj_weighted_reg(s_pair[0], s_pair[1], s_pair[2], s_pair[
-                    3], t_pair[0], t_pair[1], t_pair[2], t_pair[3], t_pair[4]))
-            distill_cls_loss.append(
-                self.obj_weighted_cls(s_pair[5], t_pair[5], t_pair[4]))
-            distill_obj_loss.append(self.obj_loss(s_pair[4], t_pair[4]))
-        distill_reg_loss = paddle.add_n(distill_reg_loss)
-        distill_cls_loss = paddle.add_n(distill_cls_loss)
-        distill_obj_loss = paddle.add_n(distill_obj_loss)
-        loss = (distill_reg_loss + distill_cls_loss + distill_obj_loss
-                ) * self.weight
-        return loss

paddlex/ppdet/slim/prune.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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-from paddle.utils import try_import
-
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-
-def print_prune_params(model):
-    model_dict = model.state_dict()
-    for key in model_dict.keys():
-        weight_name = model_dict[key].name
-        logger.info('Parameter name: {}, shape: {}'.format(
-            weight_name, model_dict[key].shape))
-
-
-@register
-@serializable
-class Pruner(object):
-    def __init__(self,
-                 criterion,
-                 pruned_params,
-                 pruned_ratios,
-                 print_params=False):
-        super(Pruner, self).__init__()
-        assert criterion in ['l1_norm', 'fpgm'], \
-            "unsupported prune criterion: {}".format(criterion)
-        self.criterion = criterion
-        self.pruned_params = pruned_params
-        self.pruned_ratios = pruned_ratios
-        self.print_params = print_params
-
-    def __call__(self, model):
-        # FIXME: adapt to network graph when Training and inference are
-        # inconsistent, now only supports prune inference network graph.
-        model.eval()
-        paddleslim = try_import('paddleslim')
-        from paddleslim.analysis import dygraph_flops as flops
-        input_spec = [{
-            "image": paddle.ones(
-                shape=[1, 3, 640, 640], dtype='float32'),
-            "im_shape": paddle.full(
-                [1, 2], 640, dtype='float32'),
-            "scale_factor": paddle.ones(
-                shape=[1, 2], dtype='float32')
-        }]
-        if self.print_params:
-            print_prune_params(model)
-
-        ori_flops = flops(model, input_spec) / (1000**3)
-        logger.info("FLOPs before pruning: {}GFLOPs".format(ori_flops))
-        if self.criterion == 'fpgm':
-            pruner = paddleslim.dygraph.FPGMFilterPruner(model, input_spec)
-        elif self.criterion == 'l1_norm':
-            pruner = paddleslim.dygraph.L1NormFilterPruner(model, input_spec)
-
-        logger.info("pruned params: {}".format(self.pruned_params))
-        pruned_ratios = [float(n) for n in self.pruned_ratios]
-        ratios = {}
-        for i, param in enumerate(self.pruned_params):
-            ratios[param] = pruned_ratios[i]
-        pruner.prune_vars(ratios, [0])
-        pruned_flops = flops(model, input_spec) / (1000**3)
-        logger.info("FLOPs after pruning: {}GFLOPs; pruned ratio: {}".format(
-            pruned_flops, (ori_flops - pruned_flops) / ori_flops))
-
-        return model

paddlex/ppdet/slim/quant.py

@@ -1,84 +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
-
-from paddle.utils import try_import
-
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-
-@register
-@serializable
-class QAT(object):
-    def __init__(self, quant_config, print_model):
-        super(QAT, self).__init__()
-        self.quant_config = quant_config
-        self.print_model = print_model
-
-    def __call__(self, model):
-        paddleslim = try_import('paddleslim')
-        self.quanter = paddleslim.dygraph.quant.QAT(config=self.quant_config)
-        if self.print_model:
-            logger.info("Model before quant:")
-            logger.info(model)
-
-        self.quanter.quantize(model)
-
-        if self.print_model:
-            logger.info("Quantized model:")
-            logger.info(model)
-
-        return model
-
-    def save_quantized_model(self, layer, path, input_spec=None, **config):
-        self.quanter.save_quantized_model(
-            model=layer, path=path, input_spec=input_spec, **config)
-
-
-@register
-@serializable
-class PTQ(object):
-    def __init__(self,
-                 ptq_config,
-                 quant_batch_num=10,
-                 output_dir='output_inference',
-                 fuse=True,
-                 fuse_list=None):
-        super(PTQ, self).__init__()
-        self.ptq_config = ptq_config
-        self.quant_batch_num = quant_batch_num
-        self.output_dir = output_dir
-        self.fuse = fuse
-        self.fuse_list = fuse_list
-
-    def __call__(self, model):
-        paddleslim = try_import('paddleslim')
-        self.ptq = paddleslim.PTQ(**self.ptq_config)
-        model.eval()
-        quant_model = self.ptq.quantize(
-            model, fuse=self.fuse, fuse_list=self.fuse_list)
-
-        return quant_model
-
-    def save_quantized_model(self,
-                             quant_model,
-                             quantize_model_path,
-                             input_spec=None):
-        self.ptq.save_quantized_model(quant_model, quantize_model_path,
-                                      input_spec)