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

pyxlpr/ppocr/modeling/heads/det_db_head.py

@@ -1,118 +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 math
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-def get_bias_attr(k):
-    stdv = 1.0 / math.sqrt(k * 1.0)
-    initializer = paddle.nn.initializer.Uniform(-stdv, stdv)
-    bias_attr = ParamAttr(initializer=initializer)
-    return bias_attr
-
-
-class Head(nn.Layer):
-    def __init__(self, in_channels, name_list):
-        super(Head, self).__init__()
-        self.conv1 = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=in_channels // 4,
-            kernel_size=3,
-            padding=1,
-            weight_attr=ParamAttr(),
-            bias_attr=False)
-        self.conv_bn1 = nn.BatchNorm(
-            num_channels=in_channels // 4,
-            param_attr=ParamAttr(
-                initializer=paddle.nn.initializer.Constant(value=1.0)),
-            bias_attr=ParamAttr(
-                initializer=paddle.nn.initializer.Constant(value=1e-4)),
-            act='relu')
-        self.conv2 = nn.Conv2DTranspose(
-            in_channels=in_channels // 4,
-            out_channels=in_channels // 4,
-            kernel_size=2,
-            stride=2,
-            weight_attr=ParamAttr(
-                initializer=paddle.nn.initializer.KaimingUniform()),
-            bias_attr=get_bias_attr(in_channels // 4))
-        self.conv_bn2 = nn.BatchNorm(
-            num_channels=in_channels // 4,
-            param_attr=ParamAttr(
-                initializer=paddle.nn.initializer.Constant(value=1.0)),
-            bias_attr=ParamAttr(
-                initializer=paddle.nn.initializer.Constant(value=1e-4)),
-            act="relu")
-        self.conv3 = nn.Conv2DTranspose(
-            in_channels=in_channels // 4,
-            out_channels=1,
-            kernel_size=2,
-            stride=2,
-            weight_attr=ParamAttr(
-                initializer=paddle.nn.initializer.KaimingUniform()),
-            bias_attr=get_bias_attr(in_channels // 4), )
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.conv_bn1(x)
-        x = self.conv2(x)
-        x = self.conv_bn2(x)
-        x = self.conv3(x)
-        x = F.sigmoid(x)
-        return x
-
-
-class DBHead(nn.Layer):
-    """
-    Differentiable Binarization (DB) for text detection:
-        see https://arxiv.org/abs/1911.08947
-    args:
-        params(dict): super parameters for build DB network
-    """
-
-    def __init__(self, in_channels, k=50, **kwargs):
-        super(DBHead, self).__init__()
-        self.k = k
-        binarize_name_list = [
-            'conv2d_56', 'batch_norm_47', 'conv2d_transpose_0', 'batch_norm_48',
-            'conv2d_transpose_1', 'binarize'
-        ]
-        thresh_name_list = [
-            'conv2d_57', 'batch_norm_49', 'conv2d_transpose_2', 'batch_norm_50',
-            'conv2d_transpose_3', 'thresh'
-        ]
-        self.binarize = Head(in_channels, binarize_name_list)
-        self.thresh = Head(in_channels, thresh_name_list)
-
-    def step_function(self, x, y):
-        # 可微二值化实现，通过概率图和阈值图计算文本分割二值图
-        return paddle.reciprocal(1 + paddle.exp(-self.k * (x - y)))
-
-    def forward(self, x, targets=None):
-        shrink_maps = self.binarize(x)  # 概率图
-        if not self.training:
-            return {'maps': shrink_maps}
-
-        threshold_maps = self.thresh(x)  # 阈值图
-        binary_maps = self.step_function(shrink_maps, threshold_maps)
-        y = paddle.concat([shrink_maps, threshold_maps, binary_maps], axis=1)
-        return {'maps': y}

pyxlpr/ppocr/modeling/heads/det_east_head.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 math
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 padding,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '_weights'),
-            bias_attr=False)
-
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name="bn_" + name + "_scale"),
-            bias_attr=ParamAttr(name="bn_" + name + "_offset"),
-            moving_mean_name="bn_" + name + "_mean",
-            moving_variance_name="bn_" + name + "_variance")
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class EASTHead(nn.Layer):
-    """
-    """
-    def __init__(self, in_channels, model_name, **kwargs):
-        super(EASTHead, self).__init__()
-        self.model_name = model_name
-        if self.model_name == "large":
-            num_outputs = [128, 64, 1, 8]
-        else:
-            num_outputs = [64, 32, 1, 8]
-
-        self.det_conv1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=num_outputs[0],
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="det_head1")
-        self.det_conv2 = ConvBNLayer(
-            in_channels=num_outputs[0],
-            out_channels=num_outputs[1],
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="det_head2")
-        self.score_conv = ConvBNLayer(
-            in_channels=num_outputs[1],
-            out_channels=num_outputs[2],
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            if_act=False,
-            act=None,
-            name="f_score")
-        self.geo_conv = ConvBNLayer(
-            in_channels=num_outputs[1],
-            out_channels=num_outputs[3],
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            if_act=False,
-            act=None,
-            name="f_geo")
-
-    def forward(self, x, targets=None):
-        f_det = self.det_conv1(x)
-        f_det = self.det_conv2(f_det)
-        f_score = self.score_conv(f_det)
-        f_score = F.sigmoid(f_score)
-        f_geo = self.geo_conv(f_det)
-        f_geo = (F.sigmoid(f_geo) - 0.5) * 2 * 800
-
-        pred = {'f_score': f_score, 'f_geo': f_geo}
-        return pred

pyxlpr/ppocr/modeling/heads/det_pse_head.py

@@ -1,37 +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
-"""
-
-from paddle import nn
-
-
-class PSEHead(nn.Layer):
-    def __init__(self, in_channels, hidden_dim=256, out_channels=7, **kwargs):
-        super(PSEHead, self).__init__()
-        self.conv1 = nn.Conv2D(
-            in_channels, hidden_dim, kernel_size=3, stride=1, padding=1)
-        self.bn1 = nn.BatchNorm2D(hidden_dim)
-        self.relu1 = nn.ReLU()
-
-        self.conv2 = nn.Conv2D(
-            hidden_dim, out_channels, kernel_size=1, stride=1, padding=0)
-
-    def forward(self, x, **kwargs):
-        out = self.conv1(x)
-        out = self.relu1(self.bn1(out))
-        out = self.conv2(out)
-        return {'maps': out}

pyxlpr/ppocr/modeling/heads/det_sast_head.py

@@ -1,128 +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 math
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=(kernel_size - 1) // 2,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '_weights'),
-            bias_attr=False)
-
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name="bn_" + name + "_scale"),
-            bias_attr=ParamAttr(name="bn_" + name + "_offset"),
-            moving_mean_name="bn_" + name + "_mean",
-            moving_variance_name="bn_" + name + "_variance")
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class SAST_Header1(nn.Layer):
-    def __init__(self, in_channels, **kwargs):
-        super(SAST_Header1, self).__init__()
-        out_channels = [64, 64, 128]
-        self.score_conv = nn.Sequential(
-            ConvBNLayer(in_channels, out_channels[0], 1, 1, act='relu', name='f_score1'),
-            ConvBNLayer(out_channels[0], out_channels[1], 3, 1, act='relu', name='f_score2'),
-            ConvBNLayer(out_channels[1], out_channels[2], 1, 1, act='relu', name='f_score3'),
-            ConvBNLayer(out_channels[2], 1, 3, 1, act=None, name='f_score4')
-        )
-        self.border_conv = nn.Sequential(
-            ConvBNLayer(in_channels, out_channels[0], 1, 1, act='relu', name='f_border1'),
-            ConvBNLayer(out_channels[0], out_channels[1], 3, 1, act='relu', name='f_border2'),
-            ConvBNLayer(out_channels[1], out_channels[2], 1, 1, act='relu', name='f_border3'),
-            ConvBNLayer(out_channels[2], 4, 3, 1, act=None, name='f_border4')            
-        )
-
-    def forward(self, x):
-        f_score = self.score_conv(x)
-        f_score = F.sigmoid(f_score)
-        f_border = self.border_conv(x)
-        return f_score, f_border
-
-
-class SAST_Header2(nn.Layer):
-    def __init__(self, in_channels, **kwargs):
-        super(SAST_Header2, self).__init__()
-        out_channels = [64, 64, 128]
-        self.tvo_conv = nn.Sequential(
-            ConvBNLayer(in_channels, out_channels[0], 1, 1, act='relu', name='f_tvo1'),
-            ConvBNLayer(out_channels[0], out_channels[1], 3, 1, act='relu', name='f_tvo2'),
-            ConvBNLayer(out_channels[1], out_channels[2], 1, 1, act='relu', name='f_tvo3'),
-            ConvBNLayer(out_channels[2], 8, 3, 1, act=None, name='f_tvo4')
-        )
-        self.tco_conv = nn.Sequential(
-            ConvBNLayer(in_channels, out_channels[0], 1, 1, act='relu', name='f_tco1'),
-            ConvBNLayer(out_channels[0], out_channels[1], 3, 1, act='relu', name='f_tco2'),
-            ConvBNLayer(out_channels[1], out_channels[2], 1, 1, act='relu', name='f_tco3'),
-            ConvBNLayer(out_channels[2], 2, 3, 1, act=None, name='f_tco4')            
-        )
-
-    def forward(self, x):
-        f_tvo = self.tvo_conv(x)
-        f_tco = self.tco_conv(x)
-        return f_tvo, f_tco
-
-
-class SASTHead(nn.Layer):
-    """
-    """
-    def __init__(self, in_channels, **kwargs):
-        super(SASTHead, self).__init__()
-
-        self.head1 = SAST_Header1(in_channels)
-        self.head2 = SAST_Header2(in_channels)
-
-    def forward(self, x, targets=None):
-        f_score, f_border = self.head1(x)
-        f_tvo, f_tco = self.head2(x)
-
-        predicts = {}
-        predicts['f_score'] = f_score
-        predicts['f_border'] = f_border
-        predicts['f_tvo'] = f_tvo
-        predicts['f_tco'] = f_tco
-        return predicts

pyxlpr/ppocr/modeling/heads/e2e_pg_head.py

@@ -1,253 +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 math
-import paddle
-from paddle import nn
-import paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 padding,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '_weights'),
-            bias_attr=False)
-
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name="bn_" + name + "_scale"),
-            bias_attr=ParamAttr(name="bn_" + name + "_offset"),
-            moving_mean_name="bn_" + name + "_mean",
-            moving_variance_name="bn_" + name + "_variance",
-            use_global_stats=False)
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class PGHead(nn.Layer):
-    """
-    """
-
-    def __init__(self, in_channels, **kwargs):
-        super(PGHead, self).__init__()
-        self.conv_f_score1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=64,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_score{}".format(1))
-        self.conv_f_score2 = ConvBNLayer(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            act='relu',
-            name="conv_f_score{}".format(2))
-        self.conv_f_score3 = ConvBNLayer(
-            in_channels=64,
-            out_channels=128,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_score{}".format(3))
-
-        self.conv1 = nn.Conv2D(
-            in_channels=128,
-            out_channels=1,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            groups=1,
-            weight_attr=ParamAttr(name="conv_f_score{}".format(4)),
-            bias_attr=False)
-
-        self.conv_f_boder1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=64,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_boder{}".format(1))
-        self.conv_f_boder2 = ConvBNLayer(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            act='relu',
-            name="conv_f_boder{}".format(2))
-        self.conv_f_boder3 = ConvBNLayer(
-            in_channels=64,
-            out_channels=128,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_boder{}".format(3))
-        self.conv2 = nn.Conv2D(
-            in_channels=128,
-            out_channels=4,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            groups=1,
-            weight_attr=ParamAttr(name="conv_f_boder{}".format(4)),
-            bias_attr=False)
-        self.conv_f_char1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=128,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_char{}".format(1))
-        self.conv_f_char2 = ConvBNLayer(
-            in_channels=128,
-            out_channels=128,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            act='relu',
-            name="conv_f_char{}".format(2))
-        self.conv_f_char3 = ConvBNLayer(
-            in_channels=128,
-            out_channels=256,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_char{}".format(3))
-        self.conv_f_char4 = ConvBNLayer(
-            in_channels=256,
-            out_channels=256,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            act='relu',
-            name="conv_f_char{}".format(4))
-        self.conv_f_char5 = ConvBNLayer(
-            in_channels=256,
-            out_channels=256,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_char{}".format(5))
-        self.conv3 = nn.Conv2D(
-            in_channels=256,
-            out_channels=37,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            groups=1,
-            weight_attr=ParamAttr(name="conv_f_char{}".format(6)),
-            bias_attr=False)
-
-        self.conv_f_direc1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=64,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_direc{}".format(1))
-        self.conv_f_direc2 = ConvBNLayer(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            act='relu',
-            name="conv_f_direc{}".format(2))
-        self.conv_f_direc3 = ConvBNLayer(
-            in_channels=64,
-            out_channels=128,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            act='relu',
-            name="conv_f_direc{}".format(3))
-        self.conv4 = nn.Conv2D(
-            in_channels=128,
-            out_channels=2,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            groups=1,
-            weight_attr=ParamAttr(name="conv_f_direc{}".format(4)),
-            bias_attr=False)
-
-    def forward(self, x, targets=None):
-        f_score = self.conv_f_score1(x)
-        f_score = self.conv_f_score2(f_score)
-        f_score = self.conv_f_score3(f_score)
-        f_score = self.conv1(f_score)
-        f_score = F.sigmoid(f_score)
-
-        # f_border
-        f_border = self.conv_f_boder1(x)
-        f_border = self.conv_f_boder2(f_border)
-        f_border = self.conv_f_boder3(f_border)
-        f_border = self.conv2(f_border)
-
-        f_char = self.conv_f_char1(x)
-        f_char = self.conv_f_char2(f_char)
-        f_char = self.conv_f_char3(f_char)
-        f_char = self.conv_f_char4(f_char)
-        f_char = self.conv_f_char5(f_char)
-        f_char = self.conv3(f_char)
-
-        f_direction = self.conv_f_direc1(x)
-        f_direction = self.conv_f_direc2(f_direction)
-        f_direction = self.conv_f_direc3(f_direction)
-        f_direction = self.conv4(f_direction)
-
-        predicts = {}
-        predicts['f_score'] = f_score
-        predicts['f_border'] = f_border
-        predicts['f_char'] = f_char
-        predicts['f_direction'] = f_direction
-        return predicts