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

pyxlpr/ppocr/losses/rec_aster_loss.py

@@ -1,99 +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
-
-import paddle
-from paddle import nn
-
-
-class CosineEmbeddingLoss(nn.Layer):
-    def __init__(self, margin=0.):
-        super(CosineEmbeddingLoss, self).__init__()
-        self.margin = margin
-        self.epsilon = 1e-12
-
-    def forward(self, x1, x2, target):
-        similarity = paddle.fluid.layers.reduce_sum(
-            x1 * x2, dim=-1) / (paddle.norm(
-                x1, axis=-1) * paddle.norm(
-                    x2, axis=-1) + self.epsilon)
-        one_list = paddle.full_like(target, fill_value=1)
-        out = paddle.fluid.layers.reduce_mean(
-            paddle.where(
-                paddle.equal(target, one_list), 1. - similarity,
-                paddle.maximum(
-                    paddle.zeros_like(similarity), similarity - self.margin)))
-
-        return out
-
-
-class AsterLoss(nn.Layer):
-    def __init__(self,
-                 weight=None,
-                 size_average=True,
-                 ignore_index=-100,
-                 sequence_normalize=False,
-                 sample_normalize=True,
-                 **kwargs):
-        super(AsterLoss, self).__init__()
-        self.weight = weight
-        self.size_average = size_average
-        self.ignore_index = ignore_index
-        self.sequence_normalize = sequence_normalize
-        self.sample_normalize = sample_normalize
-        self.loss_sem = CosineEmbeddingLoss()
-        self.is_cosin_loss = True
-        self.loss_func_rec = nn.CrossEntropyLoss(weight=None, reduction='none')
-
-    def forward(self, predicts, batch):
-        targets = batch[1].astype("int64")
-        label_lengths = batch[2].astype('int64')
-        sem_target = batch[3].astype('float32')
-        embedding_vectors = predicts['embedding_vectors']
-        rec_pred = predicts['rec_pred']
-
-        if not self.is_cosin_loss:
-            sem_loss = paddle.sum(self.loss_sem(embedding_vectors, sem_target))
-        else:
-            label_target = paddle.ones([embedding_vectors.shape[0]])
-            sem_loss = paddle.sum(
-                self.loss_sem(embedding_vectors, sem_target, label_target))
-
-        # rec loss
-        batch_size, def_max_length = targets.shape[0], targets.shape[1]
-
-        mask = paddle.zeros([batch_size, def_max_length])
-        for i in range(batch_size):
-            mask[i, :label_lengths[i]] = 1
-        mask = paddle.cast(mask, "float32")
-        max_length = max(label_lengths)
-        assert max_length == rec_pred.shape[1]
-        targets = targets[:, :max_length]
-        mask = mask[:, :max_length]
-        rec_pred = paddle.reshape(rec_pred, [-1, rec_pred.shape[2]])
-        input = nn.functional.log_softmax(rec_pred, axis=1)
-        targets = paddle.reshape(targets, [-1, 1])
-        mask = paddle.reshape(mask, [-1, 1])
-        output = -paddle.index_sample(input, index=targets) * mask
-        output = paddle.sum(output)
-        if self.sequence_normalize:
-            output = output / paddle.sum(mask)
-        if self.sample_normalize:
-            output = output / batch_size
-
-        loss = output + sem_loss * 0.1
-        return {'loss': loss}

pyxlpr/ppocr/losses/rec_att_loss.py

@@ -1,39 +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
-
-import paddle
-from paddle import nn
-
-
-class AttentionLoss(nn.Layer):
-    def __init__(self, **kwargs):
-        super(AttentionLoss, self).__init__()
-        self.loss_func = nn.CrossEntropyLoss(weight=None, reduction='none')
-
-    def forward(self, predicts, batch):
-        targets = batch[1].astype("int64")
-        label_lengths = batch[2].astype('int64')
-        batch_size, num_steps, num_classes = predicts.shape[0], predicts.shape[
-            1], predicts.shape[2]
-        assert len(targets.shape) == len(list(predicts.shape)) - 1, \
-            "The target's shape and inputs's shape is [N, d] and [N, num_steps]"
-
-        inputs = paddle.reshape(predicts, [-1, predicts.shape[-1]])
-        targets = paddle.reshape(targets, [-1])
-
-        return {'loss': paddle.sum(self.loss_func(inputs, targets))}

pyxlpr/ppocr/losses/rec_ctc_loss.py

@@ -1,44 +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
-
-
-class CTCLoss(nn.Layer):
-    def __init__(self, use_focal_loss=False, **kwargs):
-        super(CTCLoss, self).__init__()
-        self.loss_func = nn.CTCLoss(blank=0, reduction='none')
-        self.use_focal_loss = use_focal_loss
-
-    def forward(self, predicts, batch):
-        if isinstance(predicts, (list, tuple)):
-            predicts = predicts[-1]
-        predicts = predicts.transpose((1, 0, 2))
-        N, B, _ = predicts.shape
-        preds_lengths = paddle.to_tensor([N] * B, dtype='int64')
-        labels = batch[1].astype("int32")
-        label_lengths = batch[2].astype('int64')
-        loss = self.loss_func(predicts, labels, preds_lengths, label_lengths)
-        if self.use_focal_loss:
-            weight = paddle.exp(-loss)
-            weight = paddle.subtract(paddle.to_tensor([1.0]), weight)
-            weight = paddle.square(weight)
-            loss = paddle.multiply(loss, weight)
-        loss = loss.mean()
-        return {'loss': loss}

pyxlpr/ppocr/losses/rec_enhanced_ctc_loss.py

@@ -1,70 +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
-
-import paddle
-from paddle import nn
-from .ace_loss import ACELoss
-from .center_loss import CenterLoss
-from .rec_ctc_loss import CTCLoss
-
-
-class EnhancedCTCLoss(nn.Layer):
-    def __init__(self,
-                 use_focal_loss=False,
-                 use_ace_loss=False,
-                 ace_loss_weight=0.1,
-                 use_center_loss=False,
-                 center_loss_weight=0.05,
-                 num_classes=6625,
-                 feat_dim=96,
-                 init_center=False,
-                 center_file_path=None,
-                 **kwargs):
-        super(EnhancedCTCLoss, self).__init__()
-        self.ctc_loss_func = CTCLoss(use_focal_loss=use_focal_loss)
-
-        self.use_ace_loss = False
-        if use_ace_loss:
-            self.use_ace_loss = use_ace_loss
-            self.ace_loss_func = ACELoss()
-            self.ace_loss_weight = ace_loss_weight
-
-        self.use_center_loss = False
-        if use_center_loss:
-            self.use_center_loss = use_center_loss
-            self.center_loss_func = CenterLoss(
-                num_classes=num_classes,
-                feat_dim=feat_dim,
-                init_center=init_center,
-                center_file_path=center_file_path)
-            self.center_loss_weight = center_loss_weight
-
-    def __call__(self, predicts, batch):
-        loss = self.ctc_loss_func(predicts, batch)["loss"]
-
-        if self.use_center_loss:
-            center_loss = self.center_loss_func(
-                predicts, batch)["loss_center"] * self.center_loss_weight
-            loss = loss + center_loss
-
-        if self.use_ace_loss:
-            ace_loss = self.ace_loss_func(
-                predicts, batch)["loss_ace"] * self.ace_loss_weight
-            loss = loss + ace_loss
-
-        return {'enhanced_ctc_loss': loss}

pyxlpr/ppocr/losses/rec_nrtr_loss.py

@@ -1,30 +0,0 @@
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-
-
-class NRTRLoss(nn.Layer):
-    def __init__(self, smoothing=True, **kwargs):
-        super(NRTRLoss, self).__init__()
-        self.loss_func = nn.CrossEntropyLoss(reduction='mean', ignore_index=0)
-        self.smoothing = smoothing
-
-    def forward(self, pred, batch):
-        pred = pred.reshape([-1, pred.shape[2]])
-        max_len = batch[2].max()
-        tgt = batch[1][:, 1:2 + max_len]
-        tgt = tgt.reshape([-1])
-        if self.smoothing:
-            eps = 0.1
-            n_class = pred.shape[1]
-            one_hot = F.one_hot(tgt, pred.shape[1])
-            one_hot = one_hot * (1 - eps) + (1 - one_hot) * eps / (n_class - 1)
-            log_prb = F.log_softmax(pred, axis=1)
-            non_pad_mask = paddle.not_equal(
-                tgt, paddle.zeros(
-                    tgt.shape, dtype=tgt.dtype))
-            loss = -(one_hot * log_prb).sum(axis=1)
-            loss = loss.masked_select(non_pad_mask).mean()
-        else:
-            loss = self.loss_func(pred, tgt)
-        return {'loss': loss}

pyxlpr/ppocr/losses/rec_sar_loss.py

@@ -1,28 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-from paddle import nn
-
-
-class SARLoss(nn.Layer):
-    def __init__(self, **kwargs):
-        super(SARLoss, self).__init__()
-        self.loss_func = paddle.nn.loss.CrossEntropyLoss(
-            reduction="mean", ignore_index=92)
-
-    def forward(self, predicts, batch):
-        predict = predicts[:, :
-                           -1, :]  # ignore last index of outputs to be in same seq_len with targets
-        label = batch[1].astype(
-            "int64")[:, 1:]  # ignore first index of target in loss calculation
-        batch_size, num_steps, num_classes = predict.shape[0], predict.shape[
-            1], predict.shape[2]
-        assert len(label.shape) == len(list(predict.shape)) - 1, \
-            "The target's shape and inputs's shape is [N, d] and [N, num_steps]"
-
-        inputs = paddle.reshape(predict, [-1, num_classes])
-        targets = paddle.reshape(label, [-1])
-        loss = self.loss_func(inputs, targets)
-        return {'loss': loss}

pyxlpr/ppocr/losses/rec_srn_loss.py

@@ -1,47 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import paddle
-from paddle import nn
-
-
-class SRNLoss(nn.Layer):
-    def __init__(self, **kwargs):
-        super(SRNLoss, self).__init__()
-        self.loss_func = paddle.nn.loss.CrossEntropyLoss(reduction="sum")
-
-    def forward(self, predicts, batch):
-        predict = predicts['predict']
-        word_predict = predicts['word_out']
-        gsrm_predict = predicts['gsrm_out']
-        label = batch[1]
-
-        casted_label = paddle.cast(x=label, dtype='int64')
-        casted_label = paddle.reshape(x=casted_label, shape=[-1, 1])
-
-        cost_word = self.loss_func(word_predict, label=casted_label)
-        cost_gsrm = self.loss_func(gsrm_predict, label=casted_label)
-        cost_vsfd = self.loss_func(predict, label=casted_label)
-
-        cost_word = paddle.reshape(x=paddle.sum(cost_word), shape=[1])
-        cost_gsrm = paddle.reshape(x=paddle.sum(cost_gsrm), shape=[1])
-        cost_vsfd = paddle.reshape(x=paddle.sum(cost_vsfd), shape=[1])
-
-        sum_cost = cost_word * 3.0 + cost_vsfd + cost_gsrm * 0.15
-
-        return {'loss': sum_cost, 'word_loss': cost_word, 'img_loss': cost_vsfd}

pyxlpr/ppocr/losses/table_att_loss.py

@@ -1,109 +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
-
-import paddle
-from paddle import nn
-from paddle.nn import functional as F
-from paddle import fluid
-
-class TableAttentionLoss(nn.Layer):
-    def __init__(self, structure_weight, loc_weight, use_giou=False, giou_weight=1.0, **kwargs):
-        super(TableAttentionLoss, self).__init__()
-        self.loss_func = nn.CrossEntropyLoss(weight=None, reduction='none')
-        self.structure_weight = structure_weight
-        self.loc_weight = loc_weight
-        self.use_giou = use_giou
-        self.giou_weight = giou_weight
-        
-    def giou_loss(self, preds, bbox, eps=1e-7, reduction='mean'):
-        '''
-        :param preds:[[x1,y1,x2,y2], [x1,y1,x2,y2],,,]
-        :param bbox:[[x1,y1,x2,y2], [x1,y1,x2,y2],,,]
-        :return: loss
-        '''
-        ix1 = fluid.layers.elementwise_max(preds[:, 0], bbox[:, 0])
-        iy1 = fluid.layers.elementwise_max(preds[:, 1], bbox[:, 1])
-        ix2 = fluid.layers.elementwise_min(preds[:, 2], bbox[:, 2])
-        iy2 = fluid.layers.elementwise_min(preds[:, 3], bbox[:, 3])
-
-        iw = fluid.layers.clip(ix2 - ix1 + 1e-3, 0., 1e10)
-        ih = fluid.layers.clip(iy2 - iy1 + 1e-3, 0., 1e10)
-
-        # overlap
-        inters = iw * ih
-
-        # union
-        uni = (preds[:, 2] - preds[:, 0] + 1e-3) * (preds[:, 3] - preds[:, 1] + 1e-3
-            ) + (bbox[:, 2] - bbox[:, 0] + 1e-3) * (
-            bbox[:, 3] - bbox[:, 1] + 1e-3) - inters + eps
-
-        # ious
-        ious = inters / uni
-
-        ex1 = fluid.layers.elementwise_min(preds[:, 0], bbox[:, 0])
-        ey1 = fluid.layers.elementwise_min(preds[:, 1], bbox[:, 1])
-        ex2 = fluid.layers.elementwise_max(preds[:, 2], bbox[:, 2])
-        ey2 = fluid.layers.elementwise_max(preds[:, 3], bbox[:, 3])
-        ew = fluid.layers.clip(ex2 - ex1 + 1e-3, 0., 1e10)
-        eh = fluid.layers.clip(ey2 - ey1 + 1e-3, 0., 1e10)
-
-        # enclose erea
-        enclose = ew * eh + eps
-        giou = ious - (enclose - uni) / enclose
-
-        loss = 1 - giou
-
-        if reduction == 'mean':
-            loss = paddle.mean(loss)
-        elif reduction == 'sum':
-            loss = paddle.sum(loss)
-        else:
-            raise NotImplementedError
-        return loss
-
-    def forward(self, predicts, batch):
-        structure_probs = predicts['structure_probs']
-        structure_targets = batch[1].astype("int64")
-        structure_targets = structure_targets[:, 1:]
-        if len(batch) == 6:
-            structure_mask = batch[5].astype("int64")
-            structure_mask = structure_mask[:, 1:]
-            structure_mask = paddle.reshape(structure_mask, [-1])
-        structure_probs = paddle.reshape(structure_probs, [-1, structure_probs.shape[-1]])
-        structure_targets = paddle.reshape(structure_targets, [-1])
-        structure_loss = self.loss_func(structure_probs, structure_targets)
-        
-        if len(batch) == 6:
-             structure_loss = structure_loss * structure_mask
-            
-#         structure_loss = paddle.sum(structure_loss) * self.structure_weight
-        structure_loss = paddle.mean(structure_loss) * self.structure_weight
-        
-        loc_preds = predicts['loc_preds']
-        loc_targets = batch[2].astype("float32")
-        loc_targets_mask = batch[4].astype("float32")
-        loc_targets = loc_targets[:, 1:, :]
-        loc_targets_mask = loc_targets_mask[:, 1:, :]
-        loc_loss = F.mse_loss(loc_preds * loc_targets_mask, loc_targets) * self.loc_weight
-        if self.use_giou:
-            loc_loss_giou = self.giou_loss(loc_preds * loc_targets_mask, loc_targets) * self.giou_weight
-            total_loss = structure_loss + loc_loss + loc_loss_giou
-            return {'loss':total_loss, "structure_loss":structure_loss, "loc_loss":loc_loss, "loc_loss_giou":loc_loss_giou}
-        else:
-            total_loss = structure_loss + loc_loss            
-            return {'loss':total_loss, "structure_loss":structure_loss, "loc_loss":loc_loss}

pyxlpr/ppocr/metrics/__init__.py

@@ -1,44 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import copy
-
-__all__ = ["build_metric"]
-
-from .det_metric import DetMetric
-from .rec_metric import RecMetric
-from .cls_metric import ClsMetric
-from .e2e_metric import E2EMetric
-from .distillation_metric import DistillationMetric
-from .table_metric import TableMetric
-from .kie_metric import KIEMetric
-
-
-def build_metric(config):
-    support_dict = [
-        "DetMetric", "RecMetric", "ClsMetric", "E2EMetric",
-        "DistillationMetric", "TableMetric", 'KIEMetric'
-    ]
-
-    config = copy.deepcopy(config)
-    module_name = config.pop("name")
-    assert module_name in support_dict, Exception(
-        "metric only support {}".format(support_dict))
-    module_class = eval(module_name)(**config)
-    return module_class

pyxlpr/ppocr/metrics/cls_metric.py

@@ -1,45 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-class ClsMetric(object):
-    def __init__(self, main_indicator='acc', **kwargs):
-        self.main_indicator = main_indicator
-        self.reset()
-
-    def __call__(self, pred_label, *args, **kwargs):
-        preds, labels = pred_label
-        correct_num = 0
-        all_num = 0
-        for (pred, pred_conf), (target, _) in zip(preds, labels):
-            if pred == target:
-                correct_num += 1
-            all_num += 1
-        self.correct_num += correct_num
-        self.all_num += all_num
-        return {'acc': correct_num / all_num, }
-
-    def get_metric(self):
-        """
-        return metrics {
-                 'acc': 0
-            }
-        """
-        acc = self.correct_num / self.all_num
-        self.reset()
-        return {'acc': acc}
-
-    def reset(self):
-        self.correct_num = 0
-        self.all_num = 0

pyxlpr/ppocr/metrics/det_metric.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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-__all__ = ['DetMetric']
-
-from .eval_det_iou import DetectionIoUEvaluator
-
-
-class DetMetric(object):
-    def __init__(self, main_indicator='hmean', **kwargs):
-        self.evaluator = DetectionIoUEvaluator()
-        self.main_indicator = main_indicator
-        self.reset()
-
-    def __call__(self, preds, batch, **kwargs):
-        '''
-       batch: a list produced by dataloaders.
-           image: np.ndarray  of shape (N, C, H, W).
-           ratio_list: np.ndarray  of shape(N,2)
-           polygons: np.ndarray  of shape (N, K, 4, 2), the polygons of objective regions.
-           ignore_tags: np.ndarray  of shape (N, K), indicates whether a region is ignorable or not.
-       preds: a list of dict produced by post process
-            points: np.ndarray of shape (N, K, 4, 2), the polygons of objective regions.
-
-        自己调试补充的笔记：
-        list batch:
-            image: (1, 3, 736, 1280)，原始图数据，应该只有一张图N=1，检测不方便多图批量处理吧
-            ratio_list: (1, 4)，与描述不符，这里应该是 (N, 4)
-            polygons: (1, 4, 4, 2)，K是检测框数量，这里是gt标注框
-            ignore_tags: (1, 4)，是否为难样本，一般都是False
-        list[dict] preds: 一般长度只有1，直接取 preds[0]['points']
-            points: (3, 4, 2)，检测出3个框
-       '''
-        gt_polyons_batch = batch[2]
-        ignore_tags_batch = batch[3]
-        for pred, gt_polyons, ignore_tags in zip(preds, gt_polyons_batch,
-                                                 ignore_tags_batch):
-            # prepare gt
-            gt_info_list = [{
-                'points': gt_polyon,
-                'text': '',
-                'ignore': ignore_tag
-            } for gt_polyon, ignore_tag in zip(gt_polyons, ignore_tags)]
-            # prepare det
-            det_info_list = [{
-                'points': det_polyon,
-                'text': ''
-            } for det_polyon in pred['points']]
-            result = self.evaluator.evaluate_image(gt_info_list, det_info_list)
-            self.results.append(result)
-
-
-    def get_metric(self):
-        """
-        return metrics {
-                 'precision': 0,
-                 'recall': 0,
-                 'hmean': 0
-            }
-        """
-
-        metircs = self.evaluator.combine_results(self.results)
-        self.reset()
-        return metircs
-
-    def reset(self):
-        self.results = []  # clear results