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

pyxlpr/ppocr/losses/center_loss.py

@@ -1,88 +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.
-
-# This code is refer from: https://github.com/KaiyangZhou/pytorch-center-loss
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import os
-import pickle
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-
-class CenterLoss(nn.Layer):
-    """
-    Reference: Wen et al. A Discriminative Feature Learning Approach for Deep Face Recognition. ECCV 2016.
-    """
-
-    def __init__(self, num_classes=6625, feat_dim=96, center_file_path=None):
-        super().__init__()
-        self.num_classes = num_classes
-        self.feat_dim = feat_dim
-        self.centers = paddle.randn(
-            shape=[self.num_classes, self.feat_dim]).astype("float64")
-
-        if center_file_path is not None:
-            assert os.path.exists(
-                center_file_path
-            ), f"center path({center_file_path}) must exist when it is not None."
-            with open(center_file_path, 'rb') as f:
-                char_dict = pickle.load(f)
-                for key in char_dict.keys():
-                    self.centers[key] = paddle.to_tensor(char_dict[key])
-
-    def __call__(self, predicts, batch):
-        assert isinstance(predicts, (list, tuple))
-        features, predicts = predicts
-
-        feats_reshape = paddle.reshape(
-            features, [-1, features.shape[-1]]).astype("float64")
-        label = paddle.argmax(predicts, axis=2)
-        label = paddle.reshape(label, [label.shape[0] * label.shape[1]])
-
-        batch_size = feats_reshape.shape[0]
-
-        #calc l2 distance between feats and centers  
-        square_feat = paddle.sum(paddle.square(feats_reshape),
-                                 axis=1,
-                                 keepdim=True)
-        square_feat = paddle.expand(square_feat, [batch_size, self.num_classes])
-
-        square_center = paddle.sum(paddle.square(self.centers),
-                                   axis=1,
-                                   keepdim=True)
-        square_center = paddle.expand(
-            square_center, [self.num_classes, batch_size]).astype("float64")
-        square_center = paddle.transpose(square_center, [1, 0])
-
-        distmat = paddle.add(square_feat, square_center)
-        feat_dot_center = paddle.matmul(feats_reshape,
-                                        paddle.transpose(self.centers, [1, 0]))
-        distmat = distmat - 2.0 * feat_dot_center
-
-        #generate the mask
-        classes = paddle.arange(self.num_classes).astype("int64")
-        label = paddle.expand(
-            paddle.unsqueeze(label, 1), (batch_size, self.num_classes))
-        mask = paddle.equal(
-            paddle.expand(classes, [batch_size, self.num_classes]),
-            label).astype("float64")
-        dist = paddle.multiply(distmat, mask)
-
-        loss = paddle.sum(paddle.clip(dist, min=1e-12, max=1e+12)) / batch_size
-        return {'loss_center': loss}

pyxlpr/ppocr/losses/cls_loss.py

@@ -1,30 +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
-
-from paddle import nn
-
-
-class ClsLoss(nn.Layer):
-    def __init__(self, **kwargs):
-        super(ClsLoss, self).__init__()
-        self.loss_func = nn.CrossEntropyLoss(reduction='mean')
-
-    def forward(self, predicts, batch):
-        label = batch[1].astype("int64")
-        loss = self.loss_func(input=predicts, label=label)
-        return {'loss': loss}

pyxlpr/ppocr/losses/combined_loss.py

@@ -1,67 +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 paddle
-import paddle.nn as nn
-
-from .rec_ctc_loss import CTCLoss
-from .center_loss import CenterLoss
-from .ace_loss import ACELoss
-
-from .distillation_loss import DistillationCTCLoss
-from .distillation_loss import DistillationDMLLoss
-from .distillation_loss import DistillationDistanceLoss, DistillationDBLoss, DistillationDilaDBLoss
-
-
-class CombinedLoss(nn.Layer):
-    """
-    CombinedLoss:
-        a combionation of loss function
-    """
-
-    def __init__(self, loss_config_list=None):
-        super().__init__()
-        self.loss_func = []
-        self.loss_weight = []
-        assert isinstance(loss_config_list, list), (
-            'operator config should be a list')
-        for config in loss_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 forward(self, input, batch, **kargs):
-        loss_dict = {}
-        loss_all = 0.
-        for idx, loss_func in enumerate(self.loss_func):
-            loss = loss_func(input, batch, **kargs)
-            if isinstance(loss, paddle.Tensor):
-                loss = {"loss_{}_{}".format(str(loss), idx): loss}
-
-            weight = self.loss_weight[idx]
-
-            loss = {key: loss[key] * weight for key in loss}
-
-            if "loss" in loss:
-                loss_all += loss["loss"]
-            else:
-                loss_all += paddle.add_n(list(loss.values()))
-            loss_dict.update(loss)
-        loss_dict["loss"] = loss_all
-        return loss_dict

pyxlpr/ppocr/losses/det_basic_loss.py

@@ -1,208 +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.
-"""
-This code is refer from:
-https://github.com/WenmuZhou/DBNet.pytorch/blob/master/models/losses/basic_loss.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-
-
-class BalanceLoss(nn.Layer):
-    def __init__(self,
-                 balance_loss=True,
-                 main_loss_type='DiceLoss',
-                 negative_ratio=3,
-                 return_origin=False,
-                 eps=1e-6,
-                 **kwargs):
-        """
-               The BalanceLoss for Differentiable Binarization text detection
-               args:
-                   balance_loss (bool): whether balance loss or not, default is True
-                   main_loss_type (str): can only be one of ['CrossEntropy','DiceLoss',
-                       'Euclidean','BCELoss', 'MaskL1Loss'], default is  'DiceLoss'.
-                   negative_ratio (int|float): float, default is 3.
-                   return_origin (bool): whether return unbalanced loss or not, default is False.
-                   eps (float): default is 1e-6.
-               """
-        super(BalanceLoss, self).__init__()
-        self.balance_loss = balance_loss
-        self.main_loss_type = main_loss_type
-        self.negative_ratio = negative_ratio
-        self.return_origin = return_origin
-        self.eps = eps
-
-        if self.main_loss_type == "CrossEntropy":
-            self.loss = nn.CrossEntropyLoss()
-        elif self.main_loss_type == "Euclidean":
-            self.loss = nn.MSELoss()
-        elif self.main_loss_type == "DiceLoss":
-            self.loss = DiceLoss(self.eps)
-        elif self.main_loss_type == "BCELoss":
-            self.loss = BCELoss(reduction='none')
-        elif self.main_loss_type == "MaskL1Loss":
-            self.loss = MaskL1Loss(self.eps)
-        else:
-            loss_type = [
-                'CrossEntropy', 'DiceLoss', 'Euclidean', 'BCELoss', 'MaskL1Loss'
-            ]
-            raise Exception(
-                "main_loss_type in BalanceLoss() can only be one of {}".format(
-                    loss_type))
-
-    def forward(self, pred, gt, mask=None):
-        """
-        The BalanceLoss for Differentiable Binarization text detection
-        args:
-            pred (variable): predicted feature maps.
-            gt (variable): ground truth feature maps.
-            mask (variable): masked maps.
-        return: (variable) balanced loss
-        """
-        # if self.main_loss_type in ['DiceLoss']:
-        #     # For the loss that returns to scalar value, perform ohem on the mask
-        #     mask = ohem_batch(pred, gt, mask, self.negative_ratio)
-        #     loss = self.loss(pred, gt, mask)
-        #     return loss
-
-        positive = gt * mask
-        negative = (1 - gt) * mask
-
-        positive_count = int(positive.sum())
-        negative_count = int(
-            min(negative.sum(), positive_count * self.negative_ratio))
-        loss = self.loss(pred, gt, mask=mask)
-
-        if not self.balance_loss:
-            return loss
-
-        positive_loss = positive * loss
-        negative_loss = negative * loss
-        negative_loss = paddle.reshape(negative_loss, shape=[-1])
-        if negative_count > 0:
-            sort_loss = negative_loss.sort(descending=True)
-            negative_loss = sort_loss[:negative_count]
-            # negative_loss, _ = paddle.topk(negative_loss, k=negative_count_int)
-            balance_loss = (positive_loss.sum() + negative_loss.sum()) / (
-                positive_count + negative_count + self.eps)
-        else:
-            balance_loss = positive_loss.sum() / (positive_count + self.eps)
-        if self.return_origin:
-            return balance_loss, loss
-
-        return balance_loss
-
-
-class DiceLoss(nn.Layer):
-    def __init__(self, eps=1e-6):
-        super(DiceLoss, self).__init__()
-        self.eps = eps
-
-    def forward(self, pred, gt, mask, weights=None):
-        """
-        DiceLoss function.
-        """
-
-        assert pred.shape == gt.shape
-        assert pred.shape == mask.shape
-        if weights is not None:
-            assert weights.shape == mask.shape
-            mask = weights * mask
-        intersection = paddle.sum(pred * gt * mask)
-
-        union = paddle.sum(pred * mask) + paddle.sum(gt * mask) + self.eps
-        loss = 1 - 2.0 * intersection / union
-        assert loss <= 1
-        return loss
-
-
-class MaskL1Loss(nn.Layer):
-    def __init__(self, eps=1e-6):
-        super(MaskL1Loss, self).__init__()
-        self.eps = eps
-
-    def forward(self, pred, gt, mask):
-        """
-        Mask L1 Loss
-        """
-        loss = (paddle.abs(pred - gt) * mask).sum() / (mask.sum() + self.eps)
-        loss = paddle.mean(loss)
-        return loss
-
-
-class BCELoss(nn.Layer):
-    def __init__(self, reduction='mean'):
-        super(BCELoss, self).__init__()
-        self.reduction = reduction
-
-    def forward(self, input, label, mask=None, weight=None, name=None):
-        loss = F.binary_cross_entropy(input, label, reduction=self.reduction)
-        return loss
-
-
-def ohem_single(score, gt_text, training_mask, ohem_ratio):
-    pos_num = (int)(np.sum(gt_text > 0.5)) - (
-        int)(np.sum((gt_text > 0.5) & (training_mask <= 0.5)))
-
-    if pos_num == 0:
-        # selected_mask = gt_text.copy() * 0 # may be not good
-        selected_mask = training_mask
-        selected_mask = selected_mask.reshape(
-            1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32')
-        return selected_mask
-
-    neg_num = (int)(np.sum(gt_text <= 0.5))
-    neg_num = (int)(min(pos_num * ohem_ratio, neg_num))
-
-    if neg_num == 0:
-        selected_mask = training_mask
-        selected_mask = selected_mask.reshape(
-            1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32')
-        return selected_mask
-
-    neg_score = score[gt_text <= 0.5]
-    # 将负样本得分从高到低排序
-    neg_score_sorted = np.sort(-neg_score)
-    threshold = -neg_score_sorted[neg_num - 1]
-    # 选出 得分高的 负样本 和正样本 的 mask
-    selected_mask = ((score >= threshold) |
-                     (gt_text > 0.5)) & (training_mask > 0.5)
-    selected_mask = selected_mask.reshape(
-        1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32')
-    return selected_mask
-
-
-def ohem_batch(scores, gt_texts, training_masks, ohem_ratio):
-    scores = scores.numpy()
-    gt_texts = gt_texts.numpy()
-    training_masks = training_masks.numpy()
-
-    selected_masks = []
-    for i in range(scores.shape[0]):
-        selected_masks.append(
-            ohem_single(scores[i, :, :], gt_texts[i, :, :], training_masks[
-                i, :, :], ohem_ratio))
-
-    selected_masks = np.concatenate(selected_masks, 0)
-    selected_masks = paddle.to_tensor(selected_masks)
-
-    return selected_masks

pyxlpr/ppocr/losses/det_db_loss.py

@@ -1,80 +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.
-"""
-This code is refer from:
-https://github.com/WenmuZhou/DBNet.pytorch/blob/master/models/losses/DB_loss.py
-"""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-from paddle import nn
-
-from .det_basic_loss import BalanceLoss, MaskL1Loss, DiceLoss
-
-
-class DBLoss(nn.Layer):
-    """
-    Differentiable Binarization (DB) Loss Function
-    args:
-        param (dict): the super paramter for DB Loss
-    """
-
-    def __init__(self,
-                 balance_loss=True,
-                 main_loss_type='DiceLoss',
-                 alpha=5,
-                 beta=10,
-                 ohem_ratio=3,
-                 eps=1e-6,
-                 **kwargs):
-        super(DBLoss, self).__init__()
-        self.alpha = alpha
-        self.beta = beta
-        # 声明不同的损失函数
-        self.dice_loss = DiceLoss(eps=eps)
-        self.l1_loss = MaskL1Loss(eps=eps)
-        self.bce_loss = BalanceLoss(
-            balance_loss=balance_loss,
-            main_loss_type=main_loss_type,
-            negative_ratio=ohem_ratio)
-
-    def forward(self, predicts, labels):
-        predict_maps = predicts['maps']
-        label_threshold_map, label_threshold_mask, label_shrink_map, label_shrink_mask = labels[
-            1:]
-        shrink_maps = predict_maps[:, 0, :, :]
-        threshold_maps = predict_maps[:, 1, :, :]
-        binary_maps = predict_maps[:, 2, :, :]
-        # 1. 针对文本预测概率图，使用二值交叉熵损失函数
-        loss_shrink_maps = self.bce_loss(shrink_maps, label_shrink_map,
-                                         label_shrink_mask)
-        # 2. 针对文本预测阈值图使用L1距离损失函数
-        loss_threshold_maps = self.l1_loss(threshold_maps, label_threshold_map,
-                                           label_threshold_mask)
-        # 3. 针对文本预测二值图，使用dice loss损失函数
-        loss_binary_maps = self.dice_loss(binary_maps, label_shrink_map,
-                                          label_shrink_mask)
-        # 4. 不同的损失函数乘上不同的权重
-        loss_shrink_maps = self.alpha * loss_shrink_maps
-        loss_threshold_maps = self.beta * loss_threshold_maps
-
-        loss_all = loss_shrink_maps + loss_threshold_maps \
-                   + loss_binary_maps
-        losses = {'loss': loss_all, \
-                  "loss_shrink_maps": loss_shrink_maps, \
-                  "loss_threshold_maps": loss_threshold_maps, \
-                  "loss_binary_maps": loss_binary_maps}
-        return losses

pyxlpr/ppocr/losses/det_east_loss.py

@@ -1,63 +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
-
-
-class EASTLoss(nn.Layer):
-    """
-    """
-
-    def __init__(self,
-                 eps=1e-6,
-                 **kwargs):
-        super(EASTLoss, self).__init__()
-        self.dice_loss = DiceLoss(eps=eps)
-
-    def forward(self, predicts, labels):
-        l_score, l_geo, l_mask = labels[1:]
-        f_score = predicts['f_score']
-        f_geo = predicts['f_geo']
-
-        dice_loss = self.dice_loss(f_score, l_score, l_mask)
-
-        #smoooth_l1_loss
-        channels = 8
-        l_geo_split = paddle.split(
-            l_geo, num_or_sections=channels + 1, axis=1)
-        f_geo_split = paddle.split(f_geo, num_or_sections=channels, axis=1)
-        smooth_l1 = 0
-        for i in range(0, channels):
-            geo_diff = l_geo_split[i] - f_geo_split[i]
-            abs_geo_diff = paddle.abs(geo_diff)
-            smooth_l1_sign = paddle.less_than(abs_geo_diff, l_score)
-            smooth_l1_sign = paddle.cast(smooth_l1_sign, dtype='float32')
-            in_loss = abs_geo_diff * abs_geo_diff * smooth_l1_sign + \
-                (abs_geo_diff - 0.5) * (1.0 - smooth_l1_sign)
-            out_loss = l_geo_split[-1] / channels * in_loss * l_score
-            smooth_l1 += out_loss
-        smooth_l1_loss = paddle.mean(smooth_l1 * l_score)
-
-        dice_loss = dice_loss * 0.01
-        total_loss = dice_loss + smooth_l1_loss
-        losses = {"loss":total_loss, \
-                  "dice_loss":dice_loss,\
-                  "smooth_l1_loss":smooth_l1_loss}
-        return losses

pyxlpr/ppocr/losses/det_pse_loss.py

@@ -1,149 +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.
-"""
-This code is refer from:
-https://github.com/whai362/PSENet/blob/python3/models/head/psenet_head.py
-"""
-
-import paddle
-from paddle import nn
-from paddle.nn import functional as F
-import numpy as np
-from pyxlpr.ppocr.utils.iou import iou
-
-
-class PSELoss(nn.Layer):
-    def __init__(self,
-                 alpha,
-                 ohem_ratio=3,
-                 kernel_sample_mask='pred',
-                 reduction='sum',
-                 eps=1e-6,
-                 **kwargs):
-        """Implement PSE Loss.
-        """
-        super(PSELoss, self).__init__()
-        assert reduction in ['sum', 'mean', 'none']
-        self.alpha = alpha
-        self.ohem_ratio = ohem_ratio
-        self.kernel_sample_mask = kernel_sample_mask
-        self.reduction = reduction
-        self.eps = eps
-
-    def forward(self, outputs, labels):
-        predicts = outputs['maps']
-        predicts = F.interpolate(predicts, scale_factor=4)
-
-        texts = predicts[:, 0, :, :]
-        kernels = predicts[:, 1:, :, :]
-        gt_texts, gt_kernels, training_masks = labels[1:]
-
-        # text loss
-        selected_masks = self.ohem_batch(texts, gt_texts, training_masks)
-
-        loss_text = self.dice_loss(texts, gt_texts, selected_masks)
-        iou_text = iou((texts > 0).astype('int64'),
-                       gt_texts,
-                       training_masks,
-                       reduce=False)
-        losses = dict(loss_text=loss_text, iou_text=iou_text)
-
-        # kernel loss
-        loss_kernels = []
-        if self.kernel_sample_mask == 'gt':
-            selected_masks = gt_texts * training_masks
-        elif self.kernel_sample_mask == 'pred':
-            selected_masks = (
-                                     F.sigmoid(texts) > 0.5).astype('float32') * training_masks
-
-        for i in range(kernels.shape[1]):
-            kernel_i = kernels[:, i, :, :]
-            gt_kernel_i = gt_kernels[:, i, :, :]
-            loss_kernel_i = self.dice_loss(kernel_i, gt_kernel_i,
-                                           selected_masks)
-            loss_kernels.append(loss_kernel_i)
-        loss_kernels = paddle.mean(paddle.stack(loss_kernels, axis=1), axis=1)
-        iou_kernel = iou((kernels[:, -1, :, :] > 0).astype('int64'),
-                         gt_kernels[:, -1, :, :],
-                         training_masks * gt_texts,
-                         reduce=False)
-        losses.update(dict(loss_kernels=loss_kernels, iou_kernel=iou_kernel))
-        loss = self.alpha * loss_text + (1 - self.alpha) * loss_kernels
-        losses['loss'] = loss
-        if self.reduction == 'sum':
-            losses = {x: paddle.sum(v) for x, v in losses.items()}
-        elif self.reduction == 'mean':
-            losses = {x: paddle.mean(v) for x, v in losses.items()}
-        return losses
-
-    def dice_loss(self, input, target, mask):
-        input = F.sigmoid(input)
-
-        input = input.reshape([input.shape[0], -1])
-        target = target.reshape([target.shape[0], -1])
-        mask = mask.reshape([mask.shape[0], -1])
-
-        input = input * mask
-        target = target * mask
-
-        a = paddle.sum(input * target, 1)
-        b = paddle.sum(input * input, 1) + self.eps
-        c = paddle.sum(target * target, 1) + self.eps
-        d = (2 * a) / (b + c)
-        return 1 - d
-
-    def ohem_single(self, score, gt_text, training_mask, ohem_ratio=3):
-        pos_num = int(paddle.sum((gt_text > 0.5).astype('float32'))) - int(
-            paddle.sum(
-                paddle.logical_and((gt_text > 0.5), (training_mask <= 0.5))
-                    .astype('float32')))
-
-        if pos_num == 0:
-            selected_mask = training_mask
-            selected_mask = selected_mask.reshape(
-                [1, selected_mask.shape[0], selected_mask.shape[1]]).astype(
-                'float32')
-            return selected_mask
-
-        neg_num = int(paddle.sum((gt_text <= 0.5).astype('float32')))
-        neg_num = int(min(pos_num * ohem_ratio, neg_num))
-
-        if neg_num == 0:
-            selected_mask = training_mask
-            selected_mask = selected_mask.view(
-                1, selected_mask.shape[0],
-                selected_mask.shape[1]).astype('float32')
-            return selected_mask
-
-        neg_score = paddle.masked_select(score, gt_text <= 0.5)
-        neg_score_sorted = paddle.sort(-neg_score)
-        threshold = -neg_score_sorted[neg_num - 1]
-
-        selected_mask = paddle.logical_and(
-            paddle.logical_or((score >= threshold), (gt_text > 0.5)),
-            (training_mask > 0.5))
-        selected_mask = selected_mask.reshape(
-            [1, selected_mask.shape[0], selected_mask.shape[1]]).astype(
-            'float32')
-        return selected_mask
-
-    def ohem_batch(self, scores, gt_texts, training_masks, ohem_ratio=3):
-        selected_masks = []
-        for i in range(scores.shape[0]):
-            selected_masks.append(
-                self.ohem_single(scores[i, :, :], gt_texts[i, :, :],
-                                 training_masks[i, :, :], ohem_ratio))
-
-        selected_masks = paddle.concat(selected_masks, 0).astype('float32')
-        return selected_masks