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

paddlex/ppdet/slim/__init__.py

@@ -1,62 +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 .prune import *
-from .quant import *
-from .distill 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
-    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
-        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,111 +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, serializable, load_config
-from paddlex.ppdet.core.workspace import create
-from paddlex.ppdet.utils.logger import setup_logger
-from paddlex.ppdet.modeling import ops
-from paddlex.ppdet.utils.checkpoint import load_pretrain_weight
-from paddlex.ppdet.modeling.losses import YOLOv3Loss
-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
-        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
-        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,52 +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
-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)

paddlex/ppdet/utils/__init__.py

@@ -1,13 +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.

paddlex/ppdet/utils/check.py

@@ -1,93 +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 sys
-
-import paddle
-import six
-import paddle.version as fluid_version
-
-from .logger import setup_logger
-logger = setup_logger(__name__)
-
-__all__ = ['check_gpu', 'check_version', 'check_config']
-
-
-def check_gpu(use_gpu):
-    """
-    Log error and exit when set use_gpu=true in paddlepaddle
-    cpu version.
-    """
-    err = "Config use_gpu cannot be set as true while you are " \
-          "using paddlepaddle cpu version ! \nPlease try: \n" \
-          "\t1. Install paddlepaddle-gpu to run model on GPU \n" \
-          "\t2. Set use_gpu as false in config file to run " \
-          "model on CPU"
-
-    try:
-        if use_gpu and not paddle.is_compiled_with_cuda():
-            logger.error(err)
-            sys.exit(1)
-    except Exception as e:
-        pass
-
-
-def check_version(version='2.0'):
-    """
-    Log error and exit when the installed version of paddlepaddle is
-    not satisfied.
-    """
-    err = "PaddlePaddle version {} or higher is required, " \
-          "or a suitable develop version is satisfied as well. \n" \
-          "Please make sure the version is good with your code.".format(version)
-
-    version_installed = [
-        fluid_version.major, fluid_version.minor, fluid_version.patch,
-        fluid_version.rc
-    ]
-    if version_installed == ['0', '0', '0', '0']:
-        return
-    version_split = version.split('.')
-
-    length = min(len(version_installed), len(version_split))
-    for i in six.moves.range(length):
-        if version_installed[i] > version_split[i]:
-            return
-        if version_installed[i] < version_split[i]:
-            raise Exception(err)
-
-
-def check_config(cfg):
-    """
-    Check the correctness of the configuration file. Log error and exit
-    when Config is not compliant.
-    """
-    err = "'{}' not specified in config file. Please set it in config file."
-    check_list = ['architecture', 'num_classes']
-    try:
-        for var in check_list:
-            if not var in cfg:
-                logger.error(err.format(var))
-                sys.exit(1)
-    except Exception as e:
-        pass
-
-    if 'log_iter' not in cfg:
-        cfg.log_iter = 20
-
-    return cfg

paddlex/ppdet/utils/checkpoint.py

@@ -1,216 +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
-from __future__ import unicode_literals
-
-import errno
-import os
-import time
-import re
-import numpy as np
-import paddle
-import paddle.nn as nn
-from .download import get_weights_path
-
-from .logger import setup_logger
-logger = setup_logger(__name__)
-
-
-def is_url(path):
-    """
-    Whether path is URL.
-    Args:
-        path (string): URL string or not.
-    """
-    return path.startswith('http://') \
-            or path.startswith('https://') \
-            or path.startswith('ppdet://')
-
-
-def _get_unique_endpoints(trainer_endpoints):
-    # Sorting is to avoid different environmental variables for each card
-    trainer_endpoints.sort()
-    ips = set()
-    unique_endpoints = set()
-    for endpoint in trainer_endpoints:
-        ip = endpoint.split(":")[0]
-        if ip in ips:
-            continue
-        ips.add(ip)
-        unique_endpoints.add(endpoint)
-    logger.info("unique_endpoints {}".format(unique_endpoints))
-    return unique_endpoints
-
-
-def get_weights_path_dist(path):
-    env = os.environ
-    if 'PADDLE_TRAINERS_NUM' in env and 'PADDLE_TRAINER_ID' in env:
-        trainer_id = int(env['PADDLE_TRAINER_ID'])
-        num_trainers = int(env['PADDLE_TRAINERS_NUM'])
-        if num_trainers <= 1:
-            path = get_weights_path(path)
-        else:
-            from paddlex.ppdet.utils.download import map_path, WEIGHTS_HOME
-            weight_path = map_path(path, WEIGHTS_HOME)
-            lock_path = weight_path + '.lock'
-            if not os.path.exists(weight_path):
-                from paddle.distributed import ParallelEnv
-                unique_endpoints = _get_unique_endpoints(ParallelEnv()
-                                                         .trainer_endpoints[:])
-                try:
-                    os.makedirs(os.path.dirname(weight_path))
-                except OSError as e:
-                    if e.errno != errno.EEXIST:
-                        raise
-                with open(lock_path, 'w'):  # touch
-                    os.utime(lock_path, None)
-                if ParallelEnv().current_endpoint in unique_endpoints:
-                    get_weights_path(path)
-                    os.remove(lock_path)
-                else:
-                    while os.path.exists(lock_path):
-                        time.sleep(1)
-            path = weight_path
-    else:
-        path = get_weights_path(path)
-
-    return path
-
-
-def _strip_postfix(path):
-    path, ext = os.path.splitext(path)
-    assert ext in ['', '.pdparams', '.pdopt', '.pdmodel'], \
-            "Unknown postfix {} from weights".format(ext)
-    return path
-
-
-def load_weight(model, weight, optimizer=None):
-    if is_url(weight):
-        weight = get_weights_path_dist(weight)
-
-    path = _strip_postfix(weight)
-    pdparam_path = path + '.pdparams'
-    if not os.path.exists(pdparam_path):
-        raise ValueError("Model pretrain path {} does not "
-                         "exists.".format(pdparam_path))
-
-    param_state_dict = paddle.load(pdparam_path)
-    model_dict = model.state_dict()
-    model_weight = {}
-    incorrect_keys = 0
-
-    for key in model_dict.keys():
-        if key in param_state_dict.keys():
-            model_weight[key] = param_state_dict[key]
-        else:
-            logger.info('Unmatched key: {}'.format(key))
-            incorrect_keys += 1
-
-    assert incorrect_keys == 0, "Load weight {} incorrectly, \
-            {} keys unmatched, please check again.".format(weight,
-                                                           incorrect_keys)
-    logger.info('Finish resuming model weights: {}'.format(pdparam_path))
-
-    model.set_dict(model_weight)
-
-    last_epoch = 0
-    if optimizer is not None and os.path.exists(path + '.pdopt'):
-        optim_state_dict = paddle.load(path + '.pdopt')
-        # to solve resume bug, will it be fixed in paddle 2.0
-        for key in optimizer.state_dict().keys():
-            if not key in optim_state_dict.keys():
-                optim_state_dict[key] = optimizer.state_dict()[key]
-        if 'last_epoch' in optim_state_dict:
-            last_epoch = optim_state_dict.pop('last_epoch')
-        optimizer.set_state_dict(optim_state_dict)
-
-    return last_epoch
-
-
-def load_pretrain_weight(model, pretrain_weight):
-    if is_url(pretrain_weight):
-        pretrain_weight = get_weights_path_dist(pretrain_weight)
-
-    path = _strip_postfix(pretrain_weight)
-    if not (os.path.isdir(path) or os.path.isfile(path) or
-            os.path.exists(path + '.pdparams')):
-        raise ValueError("Model pretrain path `{}` does not exists. "
-                         "If you don't want to load pretrain model, "
-                         "please delete `pretrain_weights` field in "
-                         "config file.".format(path))
-
-    model_dict = model.state_dict()
-
-    weights_path = path + '.pdparams'
-    param_state_dict = paddle.load(weights_path)
-    ignore_weights = set()
-
-    # hack: fit for faster rcnn. Pretrain weights contain prefix of 'backbone'
-    # while res5 module is located in bbox_head.head. Replace the prefix of
-    # res5 with 'bbox_head.head' to load pretrain weights correctly.
-    for k in param_state_dict.keys():
-        if 'backbone.res5' in k:
-            new_k = k.replace('backbone', 'bbox_head.head')
-            if new_k in model_dict.keys():
-                value = param_state_dict.pop(k)
-                param_state_dict[new_k] = value
-
-    for name, weight in param_state_dict.items():
-        if name in model_dict.keys():
-            if list(weight.shape) != list(model_dict[name].shape):
-                logger.info(
-                    '{} not used, shape {} unmatched with {} in model.'.format(
-                        name, weight.shape, list(model_dict[name].shape)))
-                ignore_weights.add(name)
-        else:
-            logger.info('Redundant weight {} and ignore it.'.format(name))
-            ignore_weights.add(name)
-
-    for weight in ignore_weights:
-        param_state_dict.pop(weight, None)
-
-    model.set_dict(param_state_dict)
-    logger.info('Finish loading model weights: {}'.format(weights_path))
-
-
-def save_model(model, optimizer, save_dir, save_name, last_epoch):
-    """
-    save model into disk.
-
-    Args:
-        model (paddle.nn.Layer): the Layer instalce to save parameters.
-        optimizer (paddle.optimizer.Optimizer): the Optimizer instance to
-            save optimizer states.
-        save_dir (str): the directory to be saved.
-        save_name (str): the path to be saved.
-        last_epoch (int): the epoch index.
-    """
-    if paddle.distributed.get_rank() != 0:
-        return
-    if not os.path.exists(save_dir):
-        os.makedirs(save_dir)
-    save_path = os.path.join(save_dir, save_name)
-    if isinstance(model, nn.Layer):
-        paddle.save(model.state_dict(), save_path + ".pdparams")
-    else:
-        assert isinstance(model,
-                          dict), 'model is not a instance of nn.layer or dict'
-        paddle.save(model, save_path + ".pdparams")
-    state_dict = optimizer.state_dict()
-    state_dict['last_epoch'] = last_epoch
-    paddle.save(state_dict, save_path + ".pdopt")
-    logger.info("Save checkpoint: {}".format(save_dir))