pyxllib 0.3.96__py3-none-any.whl → 0.3.200__py3-none-any.whl

pyxlpr/ppocr/losses/det_sast_loss.py

@@ -1,121 +0,0 @@
-# copyright (c) 2019 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 paddle
-from paddle import nn
-from .det_basic_loss import DiceLoss
-import numpy as np
-
-
-class SASTLoss(nn.Layer):
-    """
-    """
-
-    def __init__(self, eps=1e-6, **kwargs):
-        super(SASTLoss, self).__init__()
-        self.dice_loss = DiceLoss(eps=eps)
-
-    def forward(self, predicts, labels):
-        """
-        tcl_pos: N x 128 x 3
-        tcl_mask: N x 128 x 1
-        tcl_label: N x X list or LoDTensor
-        """
-
-        f_score = predicts['f_score']
-        f_border = predicts['f_border']
-        f_tvo = predicts['f_tvo']
-        f_tco = predicts['f_tco']
-
-        l_score, l_border, l_mask, l_tvo, l_tco = labels[1:]
-
-        #score_loss
-        intersection = paddle.sum(f_score * l_score * l_mask)
-        union = paddle.sum(f_score * l_mask) + paddle.sum(l_score * l_mask)
-        score_loss = 1.0 - 2 * intersection / (union + 1e-5)
-
-        #border loss
-        l_border_split, l_border_norm = paddle.split(
-            l_border, num_or_sections=[4, 1], axis=1)
-        f_border_split = f_border
-        border_ex_shape = l_border_norm.shape * np.array([1, 4, 1, 1])
-        l_border_norm_split = paddle.expand(
-            x=l_border_norm, shape=border_ex_shape)
-        l_border_score = paddle.expand(x=l_score, shape=border_ex_shape)
-        l_border_mask = paddle.expand(x=l_mask, shape=border_ex_shape)
-
-        border_diff = l_border_split - f_border_split
-        abs_border_diff = paddle.abs(border_diff)
-        border_sign = abs_border_diff < 1.0
-        border_sign = paddle.cast(border_sign, dtype='float32')
-        border_sign.stop_gradient = True
-        border_in_loss = 0.5 * abs_border_diff * abs_border_diff * border_sign + \
-                    (abs_border_diff - 0.5) * (1.0 - border_sign)
-        border_out_loss = l_border_norm_split * border_in_loss
-        border_loss = paddle.sum(border_out_loss * l_border_score * l_border_mask) / \
-                    (paddle.sum(l_border_score * l_border_mask) + 1e-5)
-
-        #tvo_loss
-        l_tvo_split, l_tvo_norm = paddle.split(
-            l_tvo, num_or_sections=[8, 1], axis=1)
-        f_tvo_split = f_tvo
-        tvo_ex_shape = l_tvo_norm.shape * np.array([1, 8, 1, 1])
-        l_tvo_norm_split = paddle.expand(x=l_tvo_norm, shape=tvo_ex_shape)
-        l_tvo_score = paddle.expand(x=l_score, shape=tvo_ex_shape)
-        l_tvo_mask = paddle.expand(x=l_mask, shape=tvo_ex_shape)
-        #
-        tvo_geo_diff = l_tvo_split - f_tvo_split
-        abs_tvo_geo_diff = paddle.abs(tvo_geo_diff)
-        tvo_sign = abs_tvo_geo_diff < 1.0
-        tvo_sign = paddle.cast(tvo_sign, dtype='float32')
-        tvo_sign.stop_gradient = True
-        tvo_in_loss = 0.5 * abs_tvo_geo_diff * abs_tvo_geo_diff * tvo_sign + \
-                    (abs_tvo_geo_diff - 0.5) * (1.0 - tvo_sign)
-        tvo_out_loss = l_tvo_norm_split * tvo_in_loss
-        tvo_loss = paddle.sum(tvo_out_loss * l_tvo_score * l_tvo_mask) / \
-                    (paddle.sum(l_tvo_score * l_tvo_mask) + 1e-5)
-
-        #tco_loss
-        l_tco_split, l_tco_norm = paddle.split(
-            l_tco, num_or_sections=[2, 1], axis=1)
-        f_tco_split = f_tco
-        tco_ex_shape = l_tco_norm.shape * np.array([1, 2, 1, 1])
-        l_tco_norm_split = paddle.expand(x=l_tco_norm, shape=tco_ex_shape)
-        l_tco_score = paddle.expand(x=l_score, shape=tco_ex_shape)
-        l_tco_mask = paddle.expand(x=l_mask, shape=tco_ex_shape)
-
-        tco_geo_diff = l_tco_split - f_tco_split
-        abs_tco_geo_diff = paddle.abs(tco_geo_diff)
-        tco_sign = abs_tco_geo_diff < 1.0
-        tco_sign = paddle.cast(tco_sign, dtype='float32')
-        tco_sign.stop_gradient = True
-        tco_in_loss = 0.5 * abs_tco_geo_diff * abs_tco_geo_diff * tco_sign + \
-                    (abs_tco_geo_diff - 0.5) * (1.0 - tco_sign)
-        tco_out_loss = l_tco_norm_split * tco_in_loss
-        tco_loss = paddle.sum(tco_out_loss * l_tco_score * l_tco_mask) / \
-                    (paddle.sum(l_tco_score * l_tco_mask) + 1e-5)
-
-        # total loss
-        tvo_lw, tco_lw = 1.5, 1.5
-        score_lw, border_lw = 1.0, 1.0
-        total_loss = score_loss * score_lw + border_loss * border_lw + \
-                    tvo_loss * tvo_lw + tco_loss * tco_lw
-
-        losses = {'loss':total_loss, "score_loss":score_loss,\
-            "border_loss":border_loss, 'tvo_loss':tvo_loss, 'tco_loss':tco_loss}
-        return losses

pyxlpr/ppocr/losses/distillation_loss.py

@@ -1,272 +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 paddle
-import paddle.nn as nn
-import numpy as np
-import cv2
-
-from .rec_ctc_loss import CTCLoss
-from .basic_loss import DMLLoss
-from .basic_loss import DistanceLoss
-from .det_db_loss import DBLoss
-from .det_basic_loss import BalanceLoss, MaskL1Loss, DiceLoss
-
-
-def _sum_loss(loss_dict):
-    if "loss" in loss_dict.keys():
-        return loss_dict
-    else:
-        loss_dict["loss"] = 0.
-        for k, value in loss_dict.items():
-            if k == "loss":
-                continue
-            else:
-                loss_dict["loss"] += value
-        return loss_dict
-
-
-class DistillationDMLLoss(DMLLoss):
-    """
-    """
-
-    def __init__(self,
-                 model_name_pairs=[],
-                 act=None,
-                 use_log=False,
-                 key=None,
-                 maps_name=None,
-                 name="dml"):
-        super().__init__(act=act, use_log=use_log)
-        assert isinstance(model_name_pairs, list)
-        self.key = key
-        self.model_name_pairs = self._check_model_name_pairs(model_name_pairs)
-        self.name = name
-        self.maps_name = self._check_maps_name(maps_name)
-
-    def _check_model_name_pairs(self, model_name_pairs):
-        if not isinstance(model_name_pairs, list):
-            return []
-        elif isinstance(model_name_pairs[0], list) and isinstance(
-                model_name_pairs[0][0], str):
-            return model_name_pairs
-        else:
-            return [model_name_pairs]
-
-    def _check_maps_name(self, maps_name):
-        if maps_name is None:
-            return None
-        elif type(maps_name) == str:
-            return [maps_name]
-        elif type(maps_name) == list:
-            return [maps_name]
-        else:
-            return None
-
-    def _slice_out(self, outs):
-        new_outs = {}
-        for k in self.maps_name:
-            if k == "thrink_maps":
-                new_outs[k] = outs[:, 0, :, :]
-            elif k == "threshold_maps":
-                new_outs[k] = outs[:, 1, :, :]
-            elif k == "binary_maps":
-                new_outs[k] = outs[:, 2, :, :]
-            else:
-                continue
-        return new_outs
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            out1 = predicts[pair[0]]
-            out2 = predicts[pair[1]]
-            if self.key is not None:
-                out1 = out1[self.key]
-                out2 = out2[self.key]
-
-            if self.maps_name is None:
-                loss = super().forward(out1, out2)
-                if isinstance(loss, dict):
-                    for key in loss:
-                        loss_dict["{}_{}_{}_{}".format(key, pair[0], pair[1],
-                                                       idx)] = loss[key]
-                else:
-                    loss_dict["{}_{}".format(self.name, idx)] = loss
-            else:
-                outs1 = self._slice_out(out1)
-                outs2 = self._slice_out(out2)
-                for _c, k in enumerate(outs1.keys()):
-                    loss = super().forward(outs1[k], outs2[k])
-                    if isinstance(loss, dict):
-                        for key in loss:
-                            loss_dict["{}_{}_{}_{}_{}".format(key, pair[
-                                0], pair[1], self.maps_name, idx)] = loss[key]
-                    else:
-                        loss_dict["{}_{}_{}".format(self.name, self.maps_name[
-                            _c], idx)] = loss
-
-        loss_dict = _sum_loss(loss_dict)
-
-        return loss_dict
-
-
-class DistillationCTCLoss(CTCLoss):
-    def __init__(self, model_name_list=[], key=None, name="loss_ctc"):
-        super().__init__()
-        self.model_name_list = model_name_list
-        self.key = key
-        self.name = name
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, model_name in enumerate(self.model_name_list):
-            out = predicts[model_name]
-            if self.key is not None:
-                out = out[self.key]
-            loss = super().forward(out, batch)
-            if isinstance(loss, dict):
-                for key in loss:
-                    loss_dict["{}_{}_{}".format(self.name, model_name,
-                                                idx)] = loss[key]
-            else:
-                loss_dict["{}_{}".format(self.name, model_name)] = loss
-        return loss_dict
-
-
-class DistillationDBLoss(DBLoss):
-    def __init__(self,
-                 model_name_list=[],
-                 balance_loss=True,
-                 main_loss_type='DiceLoss',
-                 alpha=5,
-                 beta=10,
-                 ohem_ratio=3,
-                 eps=1e-6,
-                 name="db",
-                 **kwargs):
-        super().__init__()
-        self.model_name_list = model_name_list
-        self.name = name
-        self.key = None
-
-    def forward(self, predicts, batch):
-        loss_dict = {}
-        for idx, model_name in enumerate(self.model_name_list):
-            out = predicts[model_name]
-            if self.key is not None:
-                out = out[self.key]
-            loss = super().forward(out, batch)
-
-            if isinstance(loss, dict):
-                for key in loss.keys():
-                    if key == "loss":
-                        continue
-                    name = "{}_{}_{}".format(self.name, model_name, key)
-                    loss_dict[name] = loss[key]
-            else:
-                loss_dict["{}_{}".format(self.name, model_name)] = loss
-
-        loss_dict = _sum_loss(loss_dict)
-        return loss_dict
-
-
-class DistillationDilaDBLoss(DBLoss):
-    def __init__(self,
-                 model_name_pairs=[],
-                 key=None,
-                 balance_loss=True,
-                 main_loss_type='DiceLoss',
-                 alpha=5,
-                 beta=10,
-                 ohem_ratio=3,
-                 eps=1e-6,
-                 name="dila_dbloss"):
-        super().__init__()
-        self.model_name_pairs = model_name_pairs
-        self.name = name
-        self.key = key
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            stu_outs = predicts[pair[0]]
-            tch_outs = predicts[pair[1]]
-            if self.key is not None:
-                stu_preds = stu_outs[self.key]
-                tch_preds = tch_outs[self.key]
-
-            stu_shrink_maps = stu_preds[:, 0, :, :]
-            stu_binary_maps = stu_preds[:, 2, :, :]
-
-            # dilation to teacher prediction
-            dilation_w = np.array([[1, 1], [1, 1]])
-            th_shrink_maps = tch_preds[:, 0, :, :]
-            th_shrink_maps = th_shrink_maps.numpy() > 0.3  # thresh = 0.3 
-            dilate_maps = np.zeros_like(th_shrink_maps).astype(np.float32)
-            for i in range(th_shrink_maps.shape[0]):
-                dilate_maps[i] = cv2.dilate(
-                    th_shrink_maps[i, :, :].astype(np.uint8), dilation_w)
-            th_shrink_maps = paddle.to_tensor(dilate_maps)
-
-            label_threshold_map, label_threshold_mask, label_shrink_map, label_shrink_mask = batch[
-                1:]
-
-            # calculate the shrink map loss
-            bce_loss = self.alpha * self.bce_loss(
-                stu_shrink_maps, th_shrink_maps, label_shrink_mask)
-            loss_binary_maps = self.dice_loss(stu_binary_maps, th_shrink_maps,
-                                              label_shrink_mask)
-
-            # k = f"{self.name}_{pair[0]}_{pair[1]}"
-            k = "{}_{}_{}".format(self.name, pair[0], pair[1])
-            loss_dict[k] = bce_loss + loss_binary_maps
-
-        loss_dict = _sum_loss(loss_dict)
-        return loss_dict
-
-
-class DistillationDistanceLoss(DistanceLoss):
-    """
-    """
-
-    def __init__(self,
-                 mode="l2",
-                 model_name_pairs=[],
-                 key=None,
-                 name="loss_distance",
-                 **kargs):
-        super().__init__(mode=mode, **kargs)
-        assert isinstance(model_name_pairs, list)
-        self.key = key
-        self.model_name_pairs = model_name_pairs
-        self.name = name + "_l2"
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            out1 = predicts[pair[0]]
-            out2 = predicts[pair[1]]
-            if self.key is not None:
-                out1 = out1[self.key]
-                out2 = out2[self.key]
-            loss = super().forward(out1, out2)
-            if isinstance(loss, dict):
-                for key in loss:
-                    loss_dict["{}_{}_{}".format(self.name, key, idx)] = loss[
-                        key]
-            else:
-                loss_dict["{}_{}_{}_{}".format(self.name, pair[0], pair[1],
-                                               idx)] = loss
-        return loss_dict

pyxlpr/ppocr/losses/e2e_pg_loss.py

@@ -1,140 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from paddle import nn
-import paddle
-
-from .det_basic_loss import DiceLoss
-from pyxlpr.ppocr.utils.e2e_utils.extract_batchsize import pre_process
-
-
-class PGLoss(nn.Layer):
-    def __init__(self,
-                 tcl_bs,
-                 max_text_length,
-                 max_text_nums,
-                 pad_num,
-                 eps=1e-6,
-                 **kwargs):
-        super(PGLoss, self).__init__()
-        self.tcl_bs = tcl_bs
-        self.max_text_nums = max_text_nums
-        self.max_text_length = max_text_length
-        self.pad_num = pad_num
-        self.dice_loss = DiceLoss(eps=eps)
-
-    def border_loss(self, f_border, l_border, l_score, l_mask):
-        l_border_split, l_border_norm = paddle.tensor.split(
-            l_border, num_or_sections=[4, 1], axis=1)
-        f_border_split = f_border
-        b, c, h, w = l_border_norm.shape
-        l_border_norm_split = paddle.expand(
-            x=l_border_norm, shape=[b, 4 * c, h, w])
-        b, c, h, w = l_score.shape
-        l_border_score = paddle.expand(x=l_score, shape=[b, 4 * c, h, w])
-        b, c, h, w = l_mask.shape
-        l_border_mask = paddle.expand(x=l_mask, shape=[b, 4 * c, h, w])
-        border_diff = l_border_split - f_border_split
-        abs_border_diff = paddle.abs(border_diff)
-        border_sign = abs_border_diff < 1.0
-        border_sign = paddle.cast(border_sign, dtype='float32')
-        border_sign.stop_gradient = True
-        border_in_loss = 0.5 * abs_border_diff * abs_border_diff * border_sign + \
-                         (abs_border_diff - 0.5) * (1.0 - border_sign)
-        border_out_loss = l_border_norm_split * border_in_loss
-        border_loss = paddle.sum(border_out_loss * l_border_score * l_border_mask) / \
-                      (paddle.sum(l_border_score * l_border_mask) + 1e-5)
-        return border_loss
-
-    def direction_loss(self, f_direction, l_direction, l_score, l_mask):
-        l_direction_split, l_direction_norm = paddle.tensor.split(
-            l_direction, num_or_sections=[2, 1], axis=1)
-        f_direction_split = f_direction
-        b, c, h, w = l_direction_norm.shape
-        l_direction_norm_split = paddle.expand(
-            x=l_direction_norm, shape=[b, 2 * c, h, w])
-        b, c, h, w = l_score.shape
-        l_direction_score = paddle.expand(x=l_score, shape=[b, 2 * c, h, w])
-        b, c, h, w = l_mask.shape
-        l_direction_mask = paddle.expand(x=l_mask, shape=[b, 2 * c, h, w])
-        direction_diff = l_direction_split - f_direction_split
-        abs_direction_diff = paddle.abs(direction_diff)
-        direction_sign = abs_direction_diff < 1.0
-        direction_sign = paddle.cast(direction_sign, dtype='float32')
-        direction_sign.stop_gradient = True
-        direction_in_loss = 0.5 * abs_direction_diff * abs_direction_diff * direction_sign + \
-                            (abs_direction_diff - 0.5) * (1.0 - direction_sign)
-        direction_out_loss = l_direction_norm_split * direction_in_loss
-        direction_loss = paddle.sum(direction_out_loss * l_direction_score * l_direction_mask) / \
-                         (paddle.sum(l_direction_score * l_direction_mask) + 1e-5)
-        return direction_loss
-
-    def ctcloss(self, f_char, tcl_pos, tcl_mask, tcl_label, label_t):
-        f_char = paddle.transpose(f_char, [0, 2, 3, 1])
-        tcl_pos = paddle.reshape(tcl_pos, [-1, 3])
-        tcl_pos = paddle.cast(tcl_pos, dtype=int)
-        f_tcl_char = paddle.gather_nd(f_char, tcl_pos)
-        f_tcl_char = paddle.reshape(f_tcl_char,
-                                    [-1, 64, 37])  # len(Lexicon_Table)+1
-        f_tcl_char_fg, f_tcl_char_bg = paddle.split(f_tcl_char, [36, 1], axis=2)
-        f_tcl_char_bg = f_tcl_char_bg * tcl_mask + (1.0 - tcl_mask) * 20.0
-        b, c, l = tcl_mask.shape
-        tcl_mask_fg = paddle.expand(x=tcl_mask, shape=[b, c, 36 * l])
-        tcl_mask_fg.stop_gradient = True
-        f_tcl_char_fg = f_tcl_char_fg * tcl_mask_fg + (1.0 - tcl_mask_fg) * (
-            -20.0)
-        f_tcl_char_mask = paddle.concat([f_tcl_char_fg, f_tcl_char_bg], axis=2)
-        f_tcl_char_ld = paddle.transpose(f_tcl_char_mask, (1, 0, 2))
-        N, B, _ = f_tcl_char_ld.shape
-        input_lengths = paddle.to_tensor([N] * B, dtype='int64')
-        cost = paddle.nn.functional.ctc_loss(
-            log_probs=f_tcl_char_ld,
-            labels=tcl_label,
-            input_lengths=input_lengths,
-            label_lengths=label_t,
-            blank=self.pad_num,
-            reduction='none')
-        cost = cost.mean()
-        return cost
-
-    def forward(self, predicts, labels):
-        images, tcl_maps, tcl_label_maps, border_maps \
-            , direction_maps, training_masks, label_list, pos_list, pos_mask = labels
-        # for all the batch_size
-        pos_list, pos_mask, label_list, label_t = pre_process(
-            label_list, pos_list, pos_mask, self.max_text_length,
-            self.max_text_nums, self.pad_num, self.tcl_bs)
-
-        f_score, f_border, f_direction, f_char = predicts['f_score'], predicts['f_border'], predicts['f_direction'], \
-                                                 predicts['f_char']
-        score_loss = self.dice_loss(f_score, tcl_maps, training_masks)
-        border_loss = self.border_loss(f_border, border_maps, tcl_maps,
-                                       training_masks)
-        direction_loss = self.direction_loss(f_direction, direction_maps,
-                                             tcl_maps, training_masks)
-        ctc_loss = self.ctcloss(f_char, pos_list, pos_mask, label_list, label_t)
-        loss_all = score_loss + border_loss + direction_loss + 5 * ctc_loss
-
-        losses = {
-            'loss': loss_all,
-            "score_loss": score_loss,
-            "border_loss": border_loss,
-            "direction_loss": direction_loss,
-            "ctc_loss": ctc_loss
-        }
-        return losses

pyxlpr/ppocr/losses/kie_sdmgr_loss.py

@@ -1,113 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from paddle import nn
-import paddle
-
-
-class SDMGRLoss(nn.Layer):
-    def __init__(self, node_weight=1.0, edge_weight=1.0, ignore=0):
-        super().__init__()
-        self.loss_node = nn.CrossEntropyLoss(ignore_index=ignore)
-        self.loss_edge = nn.CrossEntropyLoss(ignore_index=-1)
-        self.node_weight = node_weight
-        self.edge_weight = edge_weight
-        self.ignore = ignore
-
-    def pre_process(self, gts, tag):
-        gts, tag = gts.numpy(), tag.numpy().tolist()
-        temp_gts = []
-        batch = len(tag)
-        for i in range(batch):
-            num, recoder_len = tag[i][0], tag[i][1]
-            temp_gts.append(
-                paddle.to_tensor(
-                    gts[i, :num, :num + 1], dtype='int64'))
-        return temp_gts
-
-    def accuracy(self, pred, target, topk=1, thresh=None):
-        """Calculate accuracy according to the prediction and target.
-
-        Args:
-            pred (torch.Tensor): The model prediction, shape (N, num_class)
-            target (torch.Tensor): The target of each prediction, shape (N, )
-            topk (int | tuple[int], optional): If the predictions in ``topk``
-                matches the target, the predictions will be regarded as
-                correct ones. Defaults to 1.
-            thresh (float, optional): If not None, predictions with scores under
-                this threshold are considered incorrect. Default to None.
-
-        Returns:
-            float | tuple[float]: If the input ``topk`` is a single integer,
-                the function will return a single float as accuracy. If
-                ``topk`` is a tuple containing multiple integers, the
-                function will return a tuple containing accuracies of
-                each ``topk`` number.
-        """
-        assert isinstance(topk, (int, tuple))
-        if isinstance(topk, int):
-            topk = (topk, )
-            return_single = True
-        else:
-            return_single = False
-
-        maxk = max(topk)
-        if pred.shape[0] == 0:
-            accu = [pred.new_tensor(0.) for i in range(len(topk))]
-            return accu[0] if return_single else accu
-        pred_value, pred_label = paddle.topk(pred, maxk, axis=1)
-        pred_label = pred_label.transpose(
-            [1, 0])  # transpose to shape (maxk, N)
-        correct = paddle.equal(pred_label,
-                               (target.reshape([1, -1]).expand_as(pred_label)))
-        res = []
-        for k in topk:
-            correct_k = paddle.sum(correct[:k].reshape([-1]).astype('float32'),
-                                   axis=0,
-                                   keepdim=True)
-            res.append(
-                paddle.multiply(correct_k,
-                                paddle.to_tensor(100.0 / pred.shape[0])))
-        return res[0] if return_single else res
-
-    def forward(self, pred, batch):
-        node_preds, edge_preds = pred
-        gts, tag = batch[4], batch[5]
-        gts = self.pre_process(gts, tag)
-        node_gts, edge_gts = [], []
-        for gt in gts:
-            node_gts.append(gt[:, 0])
-            edge_gts.append(gt[:, 1:].reshape([-1]))
-        node_gts = paddle.concat(node_gts)
-        edge_gts = paddle.concat(edge_gts)
-
-        node_valids = paddle.nonzero(node_gts != self.ignore).reshape([-1])
-        edge_valids = paddle.nonzero(edge_gts != -1).reshape([-1])
-        loss_node = self.loss_node(node_preds, node_gts)
-        loss_edge = self.loss_edge(edge_preds, edge_gts)
-        loss = self.node_weight * loss_node + self.edge_weight * loss_edge
-        return dict(
-            loss=loss,
-            loss_node=loss_node,
-            loss_edge=loss_edge,
-            acc_node=self.accuracy(
-                paddle.gather(node_preds, node_valids),
-                paddle.gather(node_gts, node_valids)),
-            acc_edge=self.accuracy(
-                paddle.gather(edge_preds, edge_valids),
-                paddle.gather(edge_gts, edge_valids)))