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

PaddleClas/ppcls/engine/evaluation/retrieval.py

@@ -1,169 +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 platform
-import paddle
-from ppcls.utils import logger
-
-
-def retrieval_eval(engine, epoch_id=0):
-    engine.model.eval()
-    # step1. build gallery
-    if engine.gallery_query_dataloader is not None:
-        gallery_feas, gallery_img_id, gallery_unique_id = cal_feature(
-            engine, name='gallery_query')
-        query_feas, query_img_id, query_query_id = gallery_feas, gallery_img_id, gallery_unique_id
-    else:
-        gallery_feas, gallery_img_id, gallery_unique_id = cal_feature(
-            engine, name='gallery')
-        query_feas, query_img_id, query_query_id = cal_feature(
-            engine, name='query')
-
-    # step2. do evaluation
-    sim_block_size = engine.config["Global"].get("sim_block_size", 64)
-    sections = [sim_block_size] * (len(query_feas) // sim_block_size)
-    if len(query_feas) % sim_block_size:
-        sections.append(len(query_feas) % sim_block_size)
-    fea_blocks = paddle.split(query_feas, num_or_sections=sections)
-    if query_query_id is not None:
-        query_id_blocks = paddle.split(
-            query_query_id, num_or_sections=sections)
-    image_id_blocks = paddle.split(query_img_id, num_or_sections=sections)
-    metric_key = None
-
-    if engine.eval_loss_func is None:
-        metric_dict = {metric_key: 0.}
-    else:
-        metric_dict = dict()
-        for block_idx, block_fea in enumerate(fea_blocks):
-            similarity_matrix = paddle.matmul(
-                block_fea, gallery_feas, transpose_y=True)
-            if query_query_id is not None:
-                query_id_block = query_id_blocks[block_idx]
-                query_id_mask = (query_id_block != gallery_unique_id.t())
-
-                image_id_block = image_id_blocks[block_idx]
-                image_id_mask = (image_id_block != gallery_img_id.t())
-
-                keep_mask = paddle.logical_or(query_id_mask, image_id_mask)
-                similarity_matrix = similarity_matrix * keep_mask.astype(
-                    "float32")
-            else:
-                keep_mask = None
-
-            metric_tmp = engine.eval_metric_func(similarity_matrix,
-                                                 image_id_blocks[block_idx],
-                                                 gallery_img_id, keep_mask)
-
-            for key in metric_tmp:
-                if key not in metric_dict:
-                    metric_dict[key] = metric_tmp[key] * block_fea.shape[
-                        0] / len(query_feas)
-                else:
-                    metric_dict[key] += metric_tmp[key] * block_fea.shape[
-                        0] / len(query_feas)
-
-    metric_info_list = []
-    for key in metric_dict:
-        if metric_key is None:
-            metric_key = key
-        metric_info_list.append("{}: {:.5f}".format(key, metric_dict[key]))
-    metric_msg = ", ".join(metric_info_list)
-    logger.info("[Eval][Epoch {}][Avg]{}".format(epoch_id, metric_msg))
-
-    return metric_dict[metric_key]
-
-
-def cal_feature(engine, name='gallery'):
-    all_feas = None
-    all_image_id = None
-    all_unique_id = None
-    has_unique_id = False
-
-    if name == 'gallery':
-        dataloader = engine.gallery_dataloader
-    elif name == 'query':
-        dataloader = engine.query_dataloader
-    elif name == 'gallery_query':
-        dataloader = engine.gallery_query_dataloader
-    else:
-        raise RuntimeError("Only support gallery or query dataset")
-
-    max_iter = len(dataloader) - 1 if platform.system() == "Windows" else len(
-        dataloader)
-    for idx, batch in enumerate(dataloader):  # load is very time-consuming
-        if idx >= max_iter:
-            break
-        if idx % engine.config["Global"]["print_batch_step"] == 0:
-            logger.info(
-                f"{name} feature calculation process: [{idx}/{len(dataloader)}]"
-            )
-        if engine.use_dali:
-            batch = [
-                paddle.to_tensor(batch[0]['data']),
-                paddle.to_tensor(batch[0]['label'])
-            ]
-        batch = [paddle.to_tensor(x) for x in batch]
-        batch[1] = batch[1].reshape([-1, 1]).astype("int64")
-        if len(batch) == 3:
-            has_unique_id = True
-            batch[2] = batch[2].reshape([-1, 1]).astype("int64")
-        out = engine.model(batch[0], batch[1])
-        batch_feas = out["features"]
-
-        # do norm
-        if engine.config["Global"].get("feature_normalize", True):
-            feas_norm = paddle.sqrt(
-                paddle.sum(paddle.square(batch_feas), axis=1, keepdim=True))
-            batch_feas = paddle.divide(batch_feas, feas_norm)
-
-        # do binarize
-        if engine.config["Global"].get("feature_binarize") == "round":
-            batch_feas = paddle.round(batch_feas).astype("float32") * 2.0 - 1.0
-
-        if engine.config["Global"].get("feature_binarize") == "sign":
-            batch_feas = paddle.sign(batch_feas).astype("float32")
-
-        if all_feas is None:
-            all_feas = batch_feas
-            if has_unique_id:
-                all_unique_id = batch[2]
-            all_image_id = batch[1]
-        else:
-            all_feas = paddle.concat([all_feas, batch_feas])
-            all_image_id = paddle.concat([all_image_id, batch[1]])
-            if has_unique_id:
-                all_unique_id = paddle.concat([all_unique_id, batch[2]])
-
-    if engine.use_dali:
-        dataloader.reset()
-
-    if paddle.distributed.get_world_size() > 1:
-        feat_list = []
-        img_id_list = []
-        unique_id_list = []
-        paddle.distributed.all_gather(feat_list, all_feas)
-        paddle.distributed.all_gather(img_id_list, all_image_id)
-        all_feas = paddle.concat(feat_list, axis=0)
-        all_image_id = paddle.concat(img_id_list, axis=0)
-        if has_unique_id:
-            paddle.distributed.all_gather(unique_id_list, all_unique_id)
-            all_unique_id = paddle.concat(unique_id_list, axis=0)
-
-    logger.info("Build {} done, all feat shape: {}, begin to eval..".format(
-        name, all_feas.shape))
-    return all_feas, all_image_id, all_unique_id

PaddleClas/ppcls/engine/slim/__init__.py

@@ -1,16 +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 ppcls.engine.slim.prune import get_pruner
-from ppcls.engine.slim.quant import get_quaner

PaddleClas/ppcls/engine/slim/prune.py

@@ -1,66 +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, division, print_function
-import paddle
-from ppcls.utils import logger
-
-
-def get_pruner(config, model):
-    if config.get("Slim", False) and config["Slim"].get("prune", False):
-        import paddleslim
-        prune_method_name = config["Slim"]["prune"]["name"].lower()
-        assert prune_method_name in [
-            "fpgm", "l1_norm"
-        ], "The prune methods only support 'fpgm' and 'l1_norm'"
-        if prune_method_name == "fpgm":
-            pruner = paddleslim.dygraph.FPGMFilterPruner(
-                model, [1] + config["Global"]["image_shape"])
-        else:
-            pruner = paddleslim.dygraph.L1NormFilterPruner(
-                model, [1] + config["Global"]["image_shape"])
-
-        # prune model
-        _prune_model(pruner, config, model)
-    else:
-        pruner = None
-
-    return pruner
-
-
-def _prune_model(pruner, config, model):
-    from paddleslim.analysis import dygraph_flops as flops
-    logger.info("FLOPs before pruning: {}GFLOPs".format(
-        flops(model, [1] + config["Global"]["image_shape"]) / 1e9))
-    model.eval()
-
-    params = []
-    for sublayer in model.sublayers():
-        for param in sublayer.parameters(include_sublayers=False):
-            if isinstance(sublayer, paddle.nn.Conv2D):
-                params.append(param.name)
-    ratios = {}
-    for param in params:
-        ratios[param] = config["Slim"]["prune"]["pruned_ratio"]
-    plan = pruner.prune_vars(ratios, [0])
-
-    logger.info("FLOPs after pruning: {}GFLOPs; pruned ratio: {}".format(
-        flops(model, [1] + config["Global"]["image_shape"]) / 1e9,
-        plan.pruned_flops))
-
-    for param in model.parameters():
-        if "conv2d" in param.name:
-            logger.info("{}\t{}".format(param.name, param.shape))
-
-    model.train()

PaddleClas/ppcls/engine/slim/quant.py

@@ -1,55 +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, division, print_function
-import paddle
-from ppcls.utils import logger
-
-QUANT_CONFIG = {
-    # weight preprocess type, default is None and no preprocessing is performed.
-    'weight_preprocess_type': None,
-    # activation preprocess type, default is None and no preprocessing is performed.
-    'activation_preprocess_type': None,
-    # weight quantize type, default is 'channel_wise_abs_max'
-    'weight_quantize_type': 'channel_wise_abs_max',
-    # activation quantize type, default is 'moving_average_abs_max'
-    'activation_quantize_type': 'moving_average_abs_max',
-    # weight quantize bit num, default is 8
-    'weight_bits': 8,
-    # activation quantize bit num, default is 8
-    'activation_bits': 8,
-    # data type after quantization, such as 'uint8', 'int8', etc. default is 'int8'
-    'dtype': 'int8',
-    # window size for 'range_abs_max' quantization. default is 10000
-    'window_size': 10000,
-    # The decay coefficient of moving average, default is 0.9
-    'moving_rate': 0.9,
-    # for dygraph quantization, layers of type in quantizable_layer_type will be quantized
-    'quantizable_layer_type': ['Conv2D', 'Linear'],
-}
-
-
-def get_quaner(config, model):
-    if config.get("Slim", False) and config["Slim"].get("quant", False):
-        from paddleslim.dygraph.quant import QAT
-        assert config["Slim"]["quant"]["name"].lower(
-        ) == 'pact', 'Only PACT quantization method is supported now'
-        QUANT_CONFIG["activation_preprocess_type"] = "PACT"
-        quanter = QAT(config=QUANT_CONFIG)
-        quanter.quantize(model)
-        logger.info("QAT model summary:")
-        paddle.summary(model, (1, 3, 224, 224))
-    else:
-        quanter = None
-    return quanter

PaddleClas/ppcls/engine/train/__init__.py

@@ -1,14 +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 ppcls.engine.train.train import train_epoch

PaddleClas/ppcls/engine/train/train.py

@@ -1,79 +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, division, print_function
-
-import time
-import paddle
-from ppcls.engine.train.utils import update_loss, update_metric, log_info
-from ppcls.utils import profiler
-
-
-def train_epoch(engine, epoch_id, print_batch_step):
-    tic = time.time()
-    for iter_id, batch in enumerate(engine.train_dataloader):
-        if iter_id >= engine.max_iter:
-            break
-        profiler.add_profiler_step(engine.config["profiler_options"])
-        if iter_id == 5:
-            for key in engine.time_info:
-                engine.time_info[key].reset()
-        engine.time_info["reader_cost"].update(time.time() - tic)
-        if engine.use_dali:
-            batch = [
-                paddle.to_tensor(batch[0]['data']),
-                paddle.to_tensor(batch[0]['label'])
-            ]
-        batch_size = batch[0].shape[0]
-        if not engine.config["Global"].get("use_multilabel", False):
-            batch[1] = batch[1].reshape([batch_size, -1])
-        engine.global_step += 1
-
-        # image input
-        if engine.amp:
-            with paddle.amp.auto_cast(custom_black_list={
-                    "flatten_contiguous_range", "greater_than"
-            }):
-                out = forward(engine, batch)
-        else:
-            out = forward(engine, batch)
-
-        loss_dict = engine.train_loss_func(out, batch[1])
-
-        # step opt and lr
-        if engine.amp:
-            scaled = engine.scaler.scale(loss_dict["loss"])
-            scaled.backward()
-            engine.scaler.minimize(engine.optimizer, scaled)
-        else:
-            loss_dict["loss"].backward()
-            engine.optimizer.step()
-        engine.optimizer.clear_grad()
-        engine.lr_sch.step()
-
-        # below code just for logging
-        # update metric_for_logger
-        update_metric(engine, out, batch, batch_size)
-        # update_loss_for_logger
-        update_loss(engine, loss_dict, batch_size)
-        engine.time_info["batch_cost"].update(time.time() - tic)
-        if iter_id % print_batch_step == 0:
-            log_info(engine, batch_size, epoch_id, iter_id)
-        tic = time.time()
-
-
-def forward(engine, batch):
-    if not engine.is_rec:
-        return engine.model(batch[0])
-    else:
-        return engine.model(batch[0], batch[1])

PaddleClas/ppcls/engine/train/utils.py

@@ -1,72 +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, division, print_function
-
-import datetime
-from ppcls.utils import logger
-from ppcls.utils.misc import AverageMeter
-
-
-def update_metric(trainer, out, batch, batch_size):
-    # calc metric
-    if trainer.train_metric_func is not None:
-        metric_dict = trainer.train_metric_func(out, batch[-1])
-        for key in metric_dict:
-            if key not in trainer.output_info:
-                trainer.output_info[key] = AverageMeter(key, '7.5f')
-            trainer.output_info[key].update(metric_dict[key].numpy()[0],
-                                            batch_size)
-
-
-def update_loss(trainer, loss_dict, batch_size):
-    # update_output_info
-    for key in loss_dict:
-        if key not in trainer.output_info:
-            trainer.output_info[key] = AverageMeter(key, '7.5f')
-        trainer.output_info[key].update(loss_dict[key].numpy()[0], batch_size)
-
-
-def log_info(trainer, batch_size, epoch_id, iter_id):
-    lr_msg = "lr: {:.5f}".format(trainer.lr_sch.get_lr())
-    metric_msg = ", ".join([
-        "{}: {:.5f}".format(key, trainer.output_info[key].avg)
-        for key in trainer.output_info
-    ])
-    time_msg = "s, ".join([
-        "{}: {:.5f}".format(key, trainer.time_info[key].avg)
-        for key in trainer.time_info
-    ])
-
-    ips_msg = "ips: {:.5f} images/sec".format(
-        batch_size / trainer.time_info["batch_cost"].avg)
-    eta_sec = ((trainer.config["Global"]["epochs"] - epoch_id + 1
-                ) * len(trainer.train_dataloader) - iter_id
-               ) * trainer.time_info["batch_cost"].avg
-    eta_msg = "eta: {:s}".format(str(datetime.timedelta(seconds=int(eta_sec))))
-    logger.info("[Train][Epoch {}/{}][Iter: {}/{}]{}, {}, {}, {}, {}".format(
-        epoch_id, trainer.config["Global"]["epochs"], iter_id,
-        len(trainer.train_dataloader), lr_msg, metric_msg, time_msg, ips_msg,
-        eta_msg))
-
-    logger.scaler(
-        name="lr",
-        value=trainer.lr_sch.get_lr(),
-        step=trainer.global_step,
-        writer=trainer.vdl_writer)
-    for key in trainer.output_info:
-        logger.scaler(
-            name="train_{}".format(key),
-            value=trainer.output_info[key].avg,
-            step=trainer.global_step,
-            writer=trainer.vdl_writer)

PaddleClas/ppcls/loss/__init__.py

@@ -1,65 +0,0 @@
-import copy
-
-import paddle
-import paddle.nn as nn
-from ppcls.utils import logger
-
-from .celoss import CELoss, MixCELoss
-from .googlenetloss import GoogLeNetLoss
-from .centerloss import CenterLoss
-from .emlloss import EmlLoss
-from .msmloss import MSMLoss
-from .npairsloss import NpairsLoss
-from .trihardloss import TriHardLoss
-from .triplet import TripletLoss, TripletLossV2
-from .supconloss import SupConLoss
-from .pairwisecosface import PairwiseCosface
-from .dmlloss import DMLLoss
-from .distanceloss import DistanceLoss
-
-from .distillationloss import DistillationCELoss
-from .distillationloss import DistillationGTCELoss
-from .distillationloss import DistillationDMLLoss
-from .multilabelloss import MultiLabelLoss
-
-from .deephashloss import DSHSDLoss, LCDSHLoss
-
-
-class CombinedLoss(nn.Layer):
-    def __init__(self, config_list):
-        super().__init__()
-        self.loss_func = []
-        self.loss_weight = []
-        assert isinstance(config_list, list), (
-            'operator config should be a list')
-        for config in config_list:
-            assert isinstance(config,
-                              dict) and len(config) == 1, "yaml format error"
-            name = list(config)[0]
-            param = config[name]
-            assert "weight" in param, "weight must be in param, but param just contains {}".format(
-                param.keys())
-            self.loss_weight.append(param.pop("weight"))
-            self.loss_func.append(eval(name)(**param))
-
-    def __call__(self, input, batch):
-        loss_dict = {}
-        # just for accelerate classification traing speed
-        if len(self.loss_func) == 1:
-            loss = self.loss_func[0](input, batch)
-            loss_dict.update(loss)
-            loss_dict["loss"] = list(loss.values())[0]
-        else:
-            for idx, loss_func in enumerate(self.loss_func):
-                loss = loss_func(input, batch)
-                weight = self.loss_weight[idx]
-                loss = {key: loss[key] * weight for key in loss}
-                loss_dict.update(loss)
-            loss_dict["loss"] = paddle.add_n(list(loss_dict.values()))
-        return loss_dict
-
-
-def build_loss(config):
-    module_class = CombinedLoss(copy.deepcopy(config))
-    logger.debug("build loss {} success.".format(module_class))
-    return module_class

PaddleClas/ppcls/loss/celoss.py

@@ -1,67 +0,0 @@
-# copyright (c) 2021 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 warnings
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from ppcls.utils import logger
-
-
-class CELoss(nn.Layer):
-    """
-    Cross entropy loss
-    """
-
-    def __init__(self, epsilon=None):
-        super().__init__()
-        if epsilon is not None and (epsilon <= 0 or epsilon >= 1):
-            epsilon = None
-        self.epsilon = epsilon
-
-    def _labelsmoothing(self, target, class_num):
-        if len(target.shape) == 1 or target.shape[-1] != class_num:
-            one_hot_target = F.one_hot(target, class_num)
-        else:
-            one_hot_target = target
-        soft_target = F.label_smooth(one_hot_target, epsilon=self.epsilon)
-        soft_target = paddle.reshape(soft_target, shape=[-1, class_num])
-        return soft_target
-
-    def forward(self, x, label):
-        if isinstance(x, dict):
-            x = x["logits"]
-        if self.epsilon is not None:
-            class_num = x.shape[-1]
-            label = self._labelsmoothing(label, class_num)
-            x = -F.log_softmax(x, axis=-1)
-            loss = paddle.sum(x * label, axis=-1)
-        else:
-            if label.shape[-1] == x.shape[-1]:
-                label = F.softmax(label, axis=-1)
-                soft_label = True
-            else:
-                soft_label = False
-            loss = F.cross_entropy(x, label=label, soft_label=soft_label)
-        loss = loss.mean()
-        return {"CELoss": loss}
-
-
-class MixCELoss(object):
-    def __init__(self, *args, **kwargs):
-        msg = "\"MixCELos\" is deprecated, please use \"CELoss\" instead."
-        logger.error(DeprecationWarning(msg))
-        raise DeprecationWarning(msg)

PaddleClas/ppcls/loss/centerloss.py

@@ -1,54 +0,0 @@
-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
-
-
-class CenterLoss(nn.Layer):
-    def __init__(self, num_classes=5013, feat_dim=2048):
-        super(CenterLoss, self).__init__()
-        self.num_classes = num_classes
-        self.feat_dim = feat_dim
-        self.centers = paddle.randn(
-            shape=[self.num_classes, self.feat_dim]).astype(
-                "float64")  #random center
-
-    def __call__(self, input, target):
-        """
-        inputs: network output: {"features: xxx", "logits": xxxx}
-        target: image label
-        """
-        feats = input["features"]
-        labels = target
-        batch_size = feats.shape[0]
-
-        #calc feat * feat   
-        dist1 = paddle.sum(paddle.square(feats), axis=1, keepdim=True)
-        dist1 = paddle.expand(dist1, [batch_size, self.num_classes])
-
-        #dist2 of centers
-        dist2 = paddle.sum(paddle.square(self.centers), axis=1,
-                           keepdim=True)  #num_classes
-        dist2 = paddle.expand(dist2,
-                              [self.num_classes, batch_size]).astype("float64")
-        dist2 = paddle.transpose(dist2, [1, 0])
-
-        #first x * x + y * y
-        distmat = paddle.add(dist1, dist2)
-        tmp = paddle.matmul(feats, paddle.transpose(self.centers, [1, 0]))
-        distmat = distmat - 2.0 * tmp
-
-        #generate the mask
-        classes = paddle.arange(self.num_classes).astype("int64")
-        labels = paddle.expand(
-            paddle.unsqueeze(labels, 1), (batch_size, self.num_classes))
-        mask = paddle.equal(
-            paddle.expand(classes, [batch_size, self.num_classes]),
-            labels).astype("float64")  #get mask
-
-        dist = paddle.multiply(distmat, mask)
-        loss = paddle.sum(paddle.clip(dist, min=1e-12, max=1e+12)) / batch_size
-
-        return {'CenterLoss': loss}