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

pyxlpr/ppocr/metrics/distillation_metric.py

@@ -1,73 +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.
-
-import importlib
-import copy
-
-from .rec_metric import RecMetric
-from .det_metric import DetMetric
-from .e2e_metric import E2EMetric
-from .cls_metric import ClsMetric
-
-
-class DistillationMetric(object):
-    def __init__(self,
-                 key=None,
-                 base_metric_name=None,
-                 main_indicator=None,
-                 **kwargs):
-        self.main_indicator = main_indicator
-        self.key = key
-        self.main_indicator = main_indicator
-        self.base_metric_name = base_metric_name
-        self.kwargs = kwargs
-        self.metrics = None
-
-    def _init_metrcis(self, preds):
-        self.metrics = dict()
-        mod = importlib.import_module(__name__)
-        for key in preds:
-            self.metrics[key] = getattr(mod, self.base_metric_name)(
-                main_indicator=self.main_indicator, **self.kwargs)
-            self.metrics[key].reset()
-
-    def __call__(self, preds, batch, **kwargs):
-        assert isinstance(preds, dict)
-        if self.metrics is None:
-            self._init_metrcis(preds)
-        output = dict()
-        for key in preds:
-            self.metrics[key].__call__(preds[key], batch, **kwargs)
-
-    def get_metric(self):
-        """
-        return metrics {
-                 'acc': 0,
-                 'norm_edit_dis': 0,
-            }
-        """
-        output = dict()
-        for key in self.metrics:
-            metric = self.metrics[key].get_metric()
-            # main indicator
-            if key == self.key:
-                output.update(metric)
-            else:
-                for sub_key in metric:
-                    output["{}_{}".format(key, sub_key)] = metric[sub_key]
-        return output
-
-    def reset(self):
-        for key in self.metrics:
-            self.metrics[key].reset()

pyxlpr/ppocr/metrics/e2e_metric.py

@@ -1,86 +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
-
-__all__ = ['E2EMetric']
-
-from pyxlpr.ppocr.utils.e2e_metric.Deteval import get_socre_A, get_socre_B, combine_results
-from pyxlpr.ppocr.utils.e2e_utils.extract_textpoint_slow import get_dict
-
-
-class E2EMetric(object):
-    def __init__(self,
-                 mode,
-                 gt_mat_dir,
-                 character_dict_path,
-                 main_indicator='f_score_e2e',
-                 **kwargs):
-        self.mode = mode
-        self.gt_mat_dir = gt_mat_dir
-        self.label_list = get_dict(character_dict_path)
-        self.max_index = len(self.label_list)
-        self.main_indicator = main_indicator
-        self.reset()
-
-    def __call__(self, preds, batch, **kwargs):
-        if self.mode == 'A':
-            gt_polyons_batch = batch[2]
-            temp_gt_strs_batch = batch[3][0]
-            ignore_tags_batch = batch[4]
-            gt_strs_batch = []
-
-            for temp_list in temp_gt_strs_batch:
-                t = ""
-                for index in temp_list:
-                    if index < self.max_index:
-                        t += self.label_list[index]
-                gt_strs_batch.append(t)
-
-            for pred, gt_polyons, gt_strs, ignore_tags in zip(
-                [preds], gt_polyons_batch, [gt_strs_batch], ignore_tags_batch):
-                # prepare gt
-                gt_info_list = [{
-                    'points': gt_polyon,
-                    'text': gt_str,
-                    'ignore': ignore_tag
-                } for gt_polyon, gt_str, ignore_tag in
-                                zip(gt_polyons, gt_strs, ignore_tags)]
-                # prepare det
-                e2e_info_list = [{
-                    'points': det_polyon,
-                    'texts': pred_str
-                } for det_polyon, pred_str in
-                                 zip(pred['points'], pred['texts'])]
-
-                result = get_socre_A(gt_info_list, e2e_info_list)
-                self.results.append(result)
-        else:
-            img_id = batch[5][0]
-            e2e_info_list = [{
-                'points': det_polyon,
-                'texts': pred_str
-            } for det_polyon, pred_str in zip(preds['points'], preds['texts'])]
-            result = get_socre_B(self.gt_mat_dir, img_id, e2e_info_list)
-            self.results.append(result)
-
-    def get_metric(self):
-        metircs = combine_results(self.results)
-        self.reset()
-        return metircs
-
-    def reset(self):
-        self.results = []  # clear results

pyxlpr/ppocr/metrics/eval_det_iou.py

@@ -1,274 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from collections import namedtuple
-import numpy as np
-from shapely.geometry import Polygon
-
-"""
-reference from :
-https://github.com/MhLiao/DB/blob/3c32b808d4412680310d3d28eeb6a2d5bf1566c5/concern/icdar2015_eval/detection/iou.py#L8
-"""
-
-
-class DetectionIoUEvaluator(object):
-    """ 文字检测和普通目标检测有点不太一样，所以用了个人觉得并不是最精确的iou指标
-
-    iou指标有个0.5的阈值，好像gt和pred达到0.5就算匹配了，没有扣分
-    """
-
-    def __init__(self, iou_constraint=0.5, area_precision_constraint=0.5):
-        self.iou_constraint = iou_constraint
-        self.area_precision_constraint = area_precision_constraint
-
-    def evaluate_image(self, gt, pred):
-        """ 计算一张图上的所有检测框精度
-
-        输入的文本内容目前看好像是用不到的~~
-        """
-
-        def get_union(pD, pG):
-            return Polygon(pD).union(Polygon(pG)).area
-
-        def get_intersection_over_union(pD, pG):
-            # 因为底层是使用Polygon计算交并比，所以其实支持任意多边形的
-            return get_intersection(pD, pG) / get_union(pD, pG)
-
-        def get_intersection(pD, pG):
-            return Polygon(pD).intersection(Polygon(pG)).area
-
-        def compute_ap(confList, matchList, numGtCare):
-            correct = 0
-            AP = 0
-            if len(confList) > 0:
-                confList = np.array(confList)
-                matchList = np.array(matchList)
-                sorted_ind = np.argsort(-confList)
-                confList = confList[sorted_ind]
-                matchList = matchList[sorted_ind]
-                for n in range(len(confList)):
-                    match = matchList[n]
-                    if match:
-                        correct += 1
-                        AP += float(correct) / (n + 1)
-
-                if numGtCare > 0:
-                    AP /= numGtCare
-
-            return AP
-
-        perSampleMetrics = {}
-
-        matchedSum = 0
-
-        Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
-
-        numGlobalCareGt = 0
-        numGlobalCareDet = 0
-
-        arrGlobalConfidences = []
-        arrGlobalMatches = []
-
-        recall = 0
-        precision = 0
-        hmean = 0
-
-        detMatched = 0
-
-        iouMat = np.empty([1, 1])
-
-        gtPols = []
-        detPols = []
-
-        gtPolPoints = []
-        detPolPoints = []
-
-        # Array of Ground Truth Polygons' keys marked as don't Care
-        gtDontCarePolsNum = []
-        # Array of Detected Polygons' matched with a don't Care GT
-        detDontCarePolsNum = []
-
-        pairs = []
-        detMatchedNums = []
-
-        arrSampleConfidences = []
-        arrSampleMatch = []
-
-        evaluationLog = ""
-
-        # print(len(gt))
-        for n in range(len(gt)):
-            points = gt[n]['points']
-            # transcription = gt[n]['text']
-            dontCare = gt[n]['ignore']
-            #             points = Polygon(points)
-            #             points = points.buffer(0)
-            if not Polygon(points).is_valid or not Polygon(points).is_simple:
-                continue
-
-            gtPol = points
-            gtPols.append(gtPol)
-            gtPolPoints.append(points)
-            if dontCare:
-                gtDontCarePolsNum.append(len(gtPols) - 1)
-
-        evaluationLog += "GT polygons: " + str(len(gtPols)) + (
-            " (" + str(len(gtDontCarePolsNum)) + " don't care)\n"
-            if len(gtDontCarePolsNum) > 0 else "\n")
-
-        for n in range(len(pred)):
-            points = pred[n]['points']
-            #             points = Polygon(points)
-            #             points = points.buffer(0)
-            if not Polygon(points).is_valid or not Polygon(points).is_simple:
-                continue
-
-            detPol = points
-            detPols.append(detPol)
-            detPolPoints.append(points)
-            if len(gtDontCarePolsNum) > 0:
-                for dontCarePol in gtDontCarePolsNum:
-                    dontCarePol = gtPols[dontCarePol]
-                    intersected_area = get_intersection(dontCarePol, detPol)
-                    pdDimensions = Polygon(detPol).area
-                    precision = 0 if pdDimensions == 0 else intersected_area / pdDimensions
-                    if (precision > self.area_precision_constraint):
-                        detDontCarePolsNum.append(len(detPols) - 1)
-                        break
-
-        evaluationLog += "DET polygons: " + str(len(detPols)) + (
-            " (" + str(len(detDontCarePolsNum)) + " don't care)\n"
-            if len(detDontCarePolsNum) > 0 else "\n")
-
-        if len(gtPols) > 0 and len(detPols) > 0:
-            # Calculate IoU and precision matrixs
-            outputShape = [len(gtPols), len(detPols)]
-            # 1. 创建[n, m]大小的矩阵，用于保存计算的IOU
-            iouMat = np.empty(outputShape)
-            gtRectMat = np.zeros(len(gtPols), np.int8)
-            detRectMat = np.zeros(len(detPols), np.int8)
-            for gtNum in range(len(gtPols)):
-                for detNum in range(len(detPols)):
-                    pG = gtPols[gtNum]
-                    pD = detPols[detNum]
-                    # 2. 计算预测框和GT框之间的IOU
-                    iouMat[gtNum, detNum] = get_intersection_over_union(pD, pG)
-
-            for gtNum in range(len(gtPols)):
-                for detNum in range(len(detPols)):
-                    if gtRectMat[gtNum] == 0 and detRectMat[
-                        detNum] == 0 and gtNum not in gtDontCarePolsNum and detNum not in detDontCarePolsNum:
-                        # 2.1 统计IOU大于阈值0.5的个数
-                        if iouMat[gtNum, detNum] > self.iou_constraint:
-                            gtRectMat[gtNum] = 1
-                            detRectMat[detNum] = 1
-                            detMatched += 1
-                            pairs.append({'gt': gtNum, 'det': detNum})
-                            detMatchedNums.append(detNum)
-                            evaluationLog += "Match GT #" + \
-                                             str(gtNum) + " with Det #" + str(detNum) + "\n"
-
-        numGtCare = (len(gtPols) - len(gtDontCarePolsNum))
-        numDetCare = (len(detPols) - len(detDontCarePolsNum))
-        if numGtCare == 0:
-            recall = float(1)
-            precision = float(0) if numDetCare > 0 else float(1)
-        else:
-            # 3. IOU大于阈值0.5的个数除以GT框的个数numGtcare得到recall
-            recall = float(detMatched) / numGtCare
-            # 4. IOU大于阈值0.5的个数除以预测框的个数numDetcare得到precision
-            precision = 0 if numDetCare == 0 else float(detMatched) / numDetCare
-
-        # 5. 通过公式计算得到Hmean指标
-        hmean = 0 if (precision + recall) == 0 else 2.0 * \
-                                                    precision * recall / (precision + recall)
-
-        matchedSum += detMatched
-        numGlobalCareGt += numGtCare
-        numGlobalCareDet += numDetCare
-
-        perSampleMetrics = {
-            'precision': precision,
-            'recall': recall,
-            'hmean': hmean,
-            'pairs': pairs,
-            'iouMat': [] if len(detPols) > 100 else iouMat.tolist(),
-            'gtPolPoints': gtPolPoints,
-            'detPolPoints': detPolPoints,
-            'gtCare': numGtCare,
-            'detCare': numDetCare,
-            'gtDontCare': gtDontCarePolsNum,
-            'detDontCare': detDontCarePolsNum,
-            'detMatched': detMatched,
-            'evaluationLog': evaluationLog
-        }
-
-        return perSampleMetrics
-
-    def combine_results(self, results):
-        numGlobalCareGt = 0
-        numGlobalCareDet = 0
-        matchedSum = 0
-        for result in results:
-            numGlobalCareGt += result['gtCare']
-            numGlobalCareDet += result['detCare']
-            matchedSum += result['detMatched']
-
-        methodRecall = 0 if numGlobalCareGt == 0 else float(
-            matchedSum) / numGlobalCareGt
-        methodPrecision = 0 if numGlobalCareDet == 0 else float(
-            matchedSum) / numGlobalCareDet
-        methodHmean = 0 if methodRecall + methodPrecision == 0 else 2 * \
-                                                                    methodRecall * methodPrecision / (
-                                                                            methodRecall + methodPrecision)
-        # print(methodRecall, methodPrecision, methodHmean)
-        # sys.exit(-1)
-        methodMetrics = {
-            'precision': methodPrecision,
-            'recall': methodRecall,
-            'hmean': methodHmean
-        }
-
-        return methodMetrics
-
-    def evaluate_image_simple(self, gt, pred):
-        """ 官方原版接口太复杂，这里扩展支持普通的list的函数，内部实现数据类型扩展 """
-        gt = [{'points': x, 'text': '', 'ignore': False} for x in gt]
-        pred = [{'points': x, 'text': '', 'ignore': False} for x in pred]
-        return self.evaluate_image(gt, pred)
-
-    @classmethod
-    def eval(cls, gts, preds):
-        """ N张图的IoU检测分数
-
-        gts、preds都是长度为N的list
-        每个元素值仍然是list，存储每张图的所有boxes检测框，polygon格式表示的任意多边形
-        """
-        evaluator = DetectionIoUEvaluator()
-        results = []
-        for gt, pred in zip(gts, preds):
-            results.append(evaluator.evaluate_image_simple(gt, pred))
-        metrics = evaluator.combine_results(results)
-        return metrics
-
-
-if __name__ == '__main__':
-    evaluator = DetectionIoUEvaluator()
-    gts = [[{
-        'points': [(0, 0), (1, 0), (1, 1), (0.5, 1), (0, 1)],
-        'text': 1234,
-        'ignore': False,
-    }, {
-        'points': [(2, 2), (3, 2), (3, 3), (2, 3)],
-        'text': 5678,
-        'ignore': False,
-    }]]
-    preds = [[{
-        'points': [(0.1, 0.1), (1, 0), (1, 1), (0, 1)],
-        'text': 123,
-        'ignore': False,
-    }]]
-    results = []
-    for gt, pred in zip(gts, preds):
-        results.append(evaluator.evaluate_image(gt, pred))
-    metrics = evaluator.combine_results(results)
-    print(metrics)

pyxlpr/ppocr/metrics/kie_metric.py

@@ -1,70 +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 numpy as np
-import paddle
-
-__all__ = ['KIEMetric']
-
-
-class KIEMetric(object):
-    def __init__(self, main_indicator='hmean', **kwargs):
-        self.main_indicator = main_indicator
-        self.reset()
-        self.node = []
-        self.gt = []
-
-    def __call__(self, preds, batch, **kwargs):
-        nodes, _ = preds
-        gts, tag = batch[4].squeeze(0), batch[5].tolist()[0]
-        gts = gts[:tag[0], :1].reshape([-1])
-        self.node.append(nodes.numpy())
-        self.gt.append(gts)
-        # result = self.compute_f1_score(nodes, gts)
-        # self.results.append(result)
-
-    def compute_f1_score(self, preds, gts):
-        ignores = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 25]
-        C = preds.shape[1]
-        classes = np.array(sorted(set(range(C)) - set(ignores)))
-        hist = np.bincount(
-            (gts * C).astype('int64') + preds.argmax(1), minlength=C
-            **2).reshape([C, C]).astype('float32')
-        diag = np.diag(hist)
-        recalls = diag / hist.sum(1).clip(min=1)
-        precisions = diag / hist.sum(0).clip(min=1)
-        f1 = 2 * recalls * precisions / (recalls + precisions).clip(min=1e-8)
-        return f1[classes]
-
-    def combine_results(self, results):
-        node = np.concatenate(self.node, 0)
-        gts = np.concatenate(self.gt, 0)
-        results = self.compute_f1_score(node, gts)
-        data = {'hmean': results.mean()}
-        return data
-
-    def get_metric(self):
-
-        metircs = self.combine_results(self.results)
-        self.reset()
-        return metircs
-
-    def reset(self):
-        self.results = []  # clear results
-        self.node = []
-        self.gt = []

pyxlpr/ppocr/metrics/rec_metric.py

@@ -1,75 +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.
-
-import Levenshtein
-import string
-
-
-class RecMetric(object):
-    def __init__(self, main_indicator='acc', is_filter=False, **kwargs):
-        self.main_indicator = main_indicator
-        self.is_filter = is_filter
-        self.reset()
-
-    def _normalize_text(self, text):
-        text = ''.join(
-            filter(lambda x: x in (string.digits + string.ascii_letters), text))
-        return text.lower()
-
-    def __call__(self, pred_label, *args, **kwargs):
-        preds, labels = pred_label
-        correct_num = 0
-        all_num = 0
-        norm_edit_dis = 0.0
-        for (pred, pred_conf), (target, _) in zip(preds, labels):
-            pred = pred.replace(" ", "")
-            target = target.replace(" ", "")
-            if self.is_filter:
-                pred = self._normalize_text(pred)
-                target = self._normalize_text(target)
-            norm_edit_dis += Levenshtein.distance(pred, target) / max(
-                len(pred), len(target), 1)
-            if pred == target:
-                correct_num += 1
-            all_num += 1
-        self.correct_num += correct_num
-        self.all_num += all_num
-        self.norm_edit_dis += norm_edit_dis
-        return {
-            'acc': correct_num / all_num,
-            'norm_edit_dis': 1 - norm_edit_dis / (all_num + 1e-3)
-        }
-
-    def get_metric(self):
-        """
-        return metrics {
-                 'acc': 0,
-                 'norm_edit_dis': 0,
-            }
-        """
-        acc = 1.0 * self.correct_num / (self.all_num + 1e-3)
-        norm_edit_dis = 1 - self.norm_edit_dis / (self.all_num + 1e-3)
-        self.reset()
-        return {'acc': acc, 'norm_edit_dis': norm_edit_dis}
-
-    def reset(self):
-        self.correct_num = 0
-        self.all_num = 0
-        self.norm_edit_dis = 0
-
-    @classmethod
-    def eval(cls, preds, labels):
-        preds = [(x, 1) for x in preds]
-        labels = [(x, 1) for x in labels]
-        return cls()([preds, labels])

pyxlpr/ppocr/metrics/table_metric.py

@@ -1,50 +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.
-import numpy as np
-class TableMetric(object):
-    def __init__(self, main_indicator='acc', **kwargs):
-        self.main_indicator = main_indicator
-        self.reset()
-
-    def __call__(self, pred, batch, *args, **kwargs):
-        structure_probs = pred['structure_probs'].numpy()
-        structure_labels = batch[1]
-        correct_num = 0
-        all_num = 0
-        structure_probs = np.argmax(structure_probs, axis=2)
-        structure_labels = structure_labels[:, 1:]
-        batch_size = structure_probs.shape[0]
-        for bno in range(batch_size):
-            all_num += 1
-            if (structure_probs[bno] == structure_labels[bno]).all():
-                correct_num += 1
-        self.correct_num += correct_num
-        self.all_num += all_num
-        return {
-            'acc': correct_num * 1.0 / all_num,
-        }
-
-    def get_metric(self):
-        """
-        return metrics {
-                 'acc': 0,
-            }
-        """
-        acc = 1.0 * self.correct_num / self.all_num
-        self.reset()
-        return {'acc': acc}
-
-    def reset(self):
-        self.correct_num = 0
-        self.all_num = 0

pyxlpr/ppocr/modeling/architectures/__init__.py

@@ -1,32 +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.
-
-import copy
-import importlib
-
-from .base_model import BaseModel
-from .distillation_model import DistillationModel
-
-__all__ = ['build_model']
-
-
-def build_model(config):
-    config = copy.deepcopy(config)
-    if not "name" in config:
-        arch = BaseModel(config)
-    else:
-        name = config.pop("name")
-        mod = importlib.import_module(__name__)
-        arch = getattr(mod, name)(config)
-    return arch