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

pyxlpr/ppocr/modeling/necks/pg_fpn.py

@@ -1,314 +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
-import paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride=1,
-                 groups=1,
-                 is_vd_mode=False,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-
-        self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = nn.AvgPool2D(
-            kernel_size=2, stride=2, padding=0, ceil_mode=True)
-        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)
-        if name == "conv1":
-            bn_name = "bn_" + name
-        else:
-            bn_name = "bn" + name[3:]
-        self._batch_norm = nn.BatchNorm(
-            out_channels,
-            act=act,
-            param_attr=ParamAttr(name=bn_name + '_scale'),
-            bias_attr=ParamAttr(bn_name + '_offset'),
-            moving_mean_name=bn_name + '_mean',
-            moving_variance_name=bn_name + '_variance',
-            use_global_stats=False)
-
-    def forward(self, inputs):
-        y = self._conv(inputs)
-        y = self._batch_norm(y)
-        return y
-
-
-class DeConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size=4,
-                 stride=2,
-                 padding=1,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(DeConvBNLayer, self).__init__()
-
-        self.if_act = if_act
-        self.act = act
-        self.deconv = nn.Conv2DTranspose(
-            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.deconv(x)
-        x = self.bn(x)
-        return x
-
-
-class PGFPN(nn.Layer):
-    def __init__(self, in_channels, **kwargs):
-        super(PGFPN, self).__init__()
-        num_inputs = [2048, 2048, 1024, 512, 256]
-        num_outputs = [256, 256, 192, 192, 128]
-        self.out_channels = 128
-        self.conv_bn_layer_1 = ConvBNLayer(
-            in_channels=3,
-            out_channels=32,
-            kernel_size=3,
-            stride=1,
-            act=None,
-            name='FPN_d1')
-        self.conv_bn_layer_2 = ConvBNLayer(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            act=None,
-            name='FPN_d2')
-        self.conv_bn_layer_3 = ConvBNLayer(
-            in_channels=256,
-            out_channels=128,
-            kernel_size=3,
-            stride=1,
-            act=None,
-            name='FPN_d3')
-        self.conv_bn_layer_4 = ConvBNLayer(
-            in_channels=32,
-            out_channels=64,
-            kernel_size=3,
-            stride=2,
-            act=None,
-            name='FPN_d4')
-        self.conv_bn_layer_5 = ConvBNLayer(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name='FPN_d5')
-        self.conv_bn_layer_6 = ConvBNLayer(
-            in_channels=64,
-            out_channels=128,
-            kernel_size=3,
-            stride=2,
-            act=None,
-            name='FPN_d6')
-        self.conv_bn_layer_7 = ConvBNLayer(
-            in_channels=128,
-            out_channels=128,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name='FPN_d7')
-        self.conv_bn_layer_8 = ConvBNLayer(
-            in_channels=128,
-            out_channels=128,
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name='FPN_d8')
-
-        self.conv_h0 = ConvBNLayer(
-            in_channels=num_inputs[0],
-            out_channels=num_outputs[0],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_h{}".format(0))
-        self.conv_h1 = ConvBNLayer(
-            in_channels=num_inputs[1],
-            out_channels=num_outputs[1],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_h{}".format(1))
-        self.conv_h2 = ConvBNLayer(
-            in_channels=num_inputs[2],
-            out_channels=num_outputs[2],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_h{}".format(2))
-        self.conv_h3 = ConvBNLayer(
-            in_channels=num_inputs[3],
-            out_channels=num_outputs[3],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_h{}".format(3))
-        self.conv_h4 = ConvBNLayer(
-            in_channels=num_inputs[4],
-            out_channels=num_outputs[4],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_h{}".format(4))
-
-        self.dconv0 = DeConvBNLayer(
-            in_channels=num_outputs[0],
-            out_channels=num_outputs[0 + 1],
-            name="dconv_{}".format(0))
-        self.dconv1 = DeConvBNLayer(
-            in_channels=num_outputs[1],
-            out_channels=num_outputs[1 + 1],
-            act=None,
-            name="dconv_{}".format(1))
-        self.dconv2 = DeConvBNLayer(
-            in_channels=num_outputs[2],
-            out_channels=num_outputs[2 + 1],
-            act=None,
-            name="dconv_{}".format(2))
-        self.dconv3 = DeConvBNLayer(
-            in_channels=num_outputs[3],
-            out_channels=num_outputs[3 + 1],
-            act=None,
-            name="dconv_{}".format(3))
-        self.conv_g1 = ConvBNLayer(
-            in_channels=num_outputs[1],
-            out_channels=num_outputs[1],
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv_g{}".format(1))
-        self.conv_g2 = ConvBNLayer(
-            in_channels=num_outputs[2],
-            out_channels=num_outputs[2],
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv_g{}".format(2))
-        self.conv_g3 = ConvBNLayer(
-            in_channels=num_outputs[3],
-            out_channels=num_outputs[3],
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv_g{}".format(3))
-        self.conv_g4 = ConvBNLayer(
-            in_channels=num_outputs[4],
-            out_channels=num_outputs[4],
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv_g{}".format(4))
-        self.convf = ConvBNLayer(
-            in_channels=num_outputs[4],
-            out_channels=num_outputs[4],
-            kernel_size=1,
-            stride=1,
-            act=None,
-            name="conv_f{}".format(4))
-
-    def forward(self, x):
-        c0, c1, c2, c3, c4, c5, c6 = x
-        # FPN_Down_Fusion
-        f = [c0, c1, c2]
-        g = [None, None, None]
-        h = [None, None, None]
-        h[0] = self.conv_bn_layer_1(f[0])
-        h[1] = self.conv_bn_layer_2(f[1])
-        h[2] = self.conv_bn_layer_3(f[2])
-
-        g[0] = self.conv_bn_layer_4(h[0])
-        g[1] = paddle.add(g[0], h[1])
-        g[1] = F.relu(g[1])
-        g[1] = self.conv_bn_layer_5(g[1])
-        g[1] = self.conv_bn_layer_6(g[1])
-
-        g[2] = paddle.add(g[1], h[2])
-        g[2] = F.relu(g[2])
-        g[2] = self.conv_bn_layer_7(g[2])
-        f_down = self.conv_bn_layer_8(g[2])
-
-        # FPN UP Fusion
-        f1 = [c6, c5, c4, c3, c2]
-        g = [None, None, None, None, None]
-        h = [None, None, None, None, None]
-        h[0] = self.conv_h0(f1[0])
-        h[1] = self.conv_h1(f1[1])
-        h[2] = self.conv_h2(f1[2])
-        h[3] = self.conv_h3(f1[3])
-        h[4] = self.conv_h4(f1[4])
-
-        g[0] = self.dconv0(h[0])
-        g[1] = paddle.add(g[0], h[1])
-        g[1] = F.relu(g[1])
-        g[1] = self.conv_g1(g[1])
-        g[1] = self.dconv1(g[1])
-
-        g[2] = paddle.add(g[1], h[2])
-        g[2] = F.relu(g[2])
-        g[2] = self.conv_g2(g[2])
-        g[2] = self.dconv2(g[2])
-
-        g[3] = paddle.add(g[2], h[3])
-        g[3] = F.relu(g[3])
-        g[3] = self.conv_g3(g[3])
-        g[3] = self.dconv3(g[3])
-
-        g[4] = paddle.add(x=g[3], y=h[4])
-        g[4] = F.relu(g[4])
-        g[4] = self.conv_g4(g[4])
-        f_up = self.convf(g[4])
-        f_common = paddle.add(f_down, f_up)
-        f_common = F.relu(f_common)
-        return f_common

pyxlpr/ppocr/modeling/necks/rnn.py

@@ -1,92 +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 paddle import nn
-
-from pyxlpr.ppocr.modeling.heads.rec_ctc_head import get_para_bias_attr
-
-
-class Im2Seq(nn.Layer):
-    def __init__(self, in_channels, **kwargs):
-        super().__init__()
-        self.out_channels = in_channels
-
-    def forward(self, x):
-        B, C, H, W = x.shape
-        assert H == 1
-        x = x.squeeze(axis=2)
-        x = x.transpose([0, 2, 1])  # (NTC)(batch, width, channels)
-        return x
-
-
-class EncoderWithRNN(nn.Layer):
-    def __init__(self, in_channels, hidden_size):
-        super(EncoderWithRNN, self).__init__()
-        self.out_channels = hidden_size * 2
-        self.lstm = nn.LSTM(
-            in_channels, hidden_size, direction='bidirectional', num_layers=2)
-
-    def forward(self, x):
-        x, _ = self.lstm(x)
-        return x
-
-
-class EncoderWithFC(nn.Layer):
-    def __init__(self, in_channels, hidden_size):
-        super(EncoderWithFC, self).__init__()
-        self.out_channels = hidden_size
-        weight_attr, bias_attr = get_para_bias_attr(
-            l2_decay=0.00001, k=in_channels)
-        self.fc = nn.Linear(
-            in_channels,
-            hidden_size,
-            weight_attr=weight_attr,
-            bias_attr=bias_attr,
-            name='reduce_encoder_fea')
-
-    def forward(self, x):
-        x = self.fc(x)
-        return x
-
-
-class SequenceEncoder(nn.Layer):
-    def __init__(self, in_channels, encoder_type, hidden_size=48, **kwargs):
-        super(SequenceEncoder, self).__init__()
-        self.encoder_reshape = Im2Seq(in_channels)
-        self.out_channels = self.encoder_reshape.out_channels
-        if encoder_type == 'reshape':
-            self.only_reshape = True
-        else:
-            support_encoder_dict = {
-                'reshape': Im2Seq,
-                'fc': EncoderWithFC,
-                'rnn': EncoderWithRNN
-            }
-            assert encoder_type in support_encoder_dict, '{} must in {}'.format(
-                encoder_type, support_encoder_dict.keys())
-
-            self.encoder = support_encoder_dict[encoder_type](
-                self.encoder_reshape.out_channels, hidden_size)
-            self.out_channels = self.encoder.out_channels
-            self.only_reshape = False
-
-    def forward(self, x):
-        x = self.encoder_reshape(x)
-        if not self.only_reshape:
-            x = self.encoder(x)
-        return x

pyxlpr/ppocr/modeling/necks/sast_fpn.py

@@ -1,284 +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
-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 DeConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(DeConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.deconv = nn.Conv2DTranspose(
-            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.deconv(x)
-        x = self.bn(x)
-        return x
-
-
-class FPN_Up_Fusion(nn.Layer):
-    def __init__(self, in_channels):
-        super(FPN_Up_Fusion, self).__init__()
-        in_channels = in_channels[::-1]
-        out_channels = [256, 256, 192, 192, 128]
-                
-        self.h0_conv = ConvBNLayer(in_channels[0], out_channels[0], 1, 1, act=None, name='fpn_up_h0')
-        self.h1_conv = ConvBNLayer(in_channels[1], out_channels[1], 1, 1, act=None, name='fpn_up_h1')
-        self.h2_conv = ConvBNLayer(in_channels[2], out_channels[2], 1, 1, act=None, name='fpn_up_h2')
-        self.h3_conv = ConvBNLayer(in_channels[3], out_channels[3], 1, 1, act=None, name='fpn_up_h3')
-        self.h4_conv = ConvBNLayer(in_channels[4], out_channels[4], 1, 1, act=None, name='fpn_up_h4')
-
-        self.g0_conv = DeConvBNLayer(out_channels[0], out_channels[1], 4, 2, act=None, name='fpn_up_g0')
-
-        self.g1_conv = nn.Sequential(
-            ConvBNLayer(out_channels[1], out_channels[1], 3, 1, act='relu', name='fpn_up_g1_1'),
-            DeConvBNLayer(out_channels[1], out_channels[2], 4, 2, act=None, name='fpn_up_g1_2')
-        )
-        self.g2_conv = nn.Sequential(
-            ConvBNLayer(out_channels[2], out_channels[2], 3, 1, act='relu', name='fpn_up_g2_1'),
-            DeConvBNLayer(out_channels[2], out_channels[3], 4, 2, act=None, name='fpn_up_g2_2')
-        )
-        self.g3_conv = nn.Sequential(
-            ConvBNLayer(out_channels[3], out_channels[3], 3, 1, act='relu', name='fpn_up_g3_1'),
-            DeConvBNLayer(out_channels[3], out_channels[4], 4, 2, act=None, name='fpn_up_g3_2')
-        )
-
-        self.g4_conv = nn.Sequential(
-            ConvBNLayer(out_channels[4], out_channels[4], 3, 1, act='relu', name='fpn_up_fusion_1'),
-            ConvBNLayer(out_channels[4], out_channels[4], 1, 1, act=None, name='fpn_up_fusion_2')
-        )
-
-    def _add_relu(self, x1, x2):
-        x = paddle.add(x=x1, y=x2)
-        x = F.relu(x)
-        return x
-
-    def forward(self, x):
-        f = x[2:][::-1]
-        h0 = self.h0_conv(f[0])
-        h1 = self.h1_conv(f[1])
-        h2 = self.h2_conv(f[2])
-        h3 = self.h3_conv(f[3])
-        h4 = self.h4_conv(f[4])
-
-        g0 = self.g0_conv(h0)
-        g1 = self._add_relu(g0, h1)
-        g1 = self.g1_conv(g1)
-        g2 = self.g2_conv(self._add_relu(g1, h2))
-        g3 = self.g3_conv(self._add_relu(g2, h3))
-        g4 = self.g4_conv(self._add_relu(g3, h4))
-
-        return g4
-
-
-class FPN_Down_Fusion(nn.Layer):
-    def __init__(self, in_channels):
-        super(FPN_Down_Fusion, self).__init__()
-        out_channels = [32, 64, 128]
-
-        self.h0_conv = ConvBNLayer(in_channels[0], out_channels[0], 3, 1, act=None, name='fpn_down_h0')
-        self.h1_conv = ConvBNLayer(in_channels[1], out_channels[1], 3, 1, act=None, name='fpn_down_h1')
-        self.h2_conv = ConvBNLayer(in_channels[2], out_channels[2], 3, 1, act=None, name='fpn_down_h2')
-
-        self.g0_conv = ConvBNLayer(out_channels[0], out_channels[1], 3, 2, act=None, name='fpn_down_g0')
-
-        self.g1_conv = nn.Sequential(
-            ConvBNLayer(out_channels[1], out_channels[1], 3, 1, act='relu', name='fpn_down_g1_1'),
-            ConvBNLayer(out_channels[1], out_channels[2], 3, 2, act=None, name='fpn_down_g1_2')            
-        )
-
-        self.g2_conv = nn.Sequential(
-            ConvBNLayer(out_channels[2], out_channels[2], 3, 1, act='relu', name='fpn_down_fusion_1'),
-            ConvBNLayer(out_channels[2], out_channels[2], 1, 1, act=None, name='fpn_down_fusion_2')            
-        )
-
-    def forward(self, x):
-        f = x[:3]
-        h0 = self.h0_conv(f[0])
-        h1 = self.h1_conv(f[1])
-        h2 = self.h2_conv(f[2])
-        g0 = self.g0_conv(h0)
-        g1 = paddle.add(x=g0, y=h1)
-        g1 = F.relu(g1)
-        g1 = self.g1_conv(g1)
-        g2 = paddle.add(x=g1, y=h2)
-        g2 = F.relu(g2)
-        g2 = self.g2_conv(g2)
-        return g2
-
-
-class Cross_Attention(nn.Layer):
-    def __init__(self, in_channels):
-        super(Cross_Attention, self).__init__()
-        self.theta_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act='relu', name='f_theta')
-        self.phi_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act='relu', name='f_phi')
-        self.g_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act='relu', name='f_g')
-
-        self.fh_weight_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act=None, name='fh_weight')
-        self.fh_sc_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act=None, name='fh_sc')
-
-        self.fv_weight_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act=None, name='fv_weight')
-        self.fv_sc_conv = ConvBNLayer(in_channels, in_channels, 1, 1, act=None, name='fv_sc')
-
-        self.f_attn_conv = ConvBNLayer(in_channels * 2, in_channels, 1, 1, act='relu', name='f_attn')
-
-    def _cal_fweight(self, f, shape):
-        f_theta, f_phi, f_g = f
-        #flatten
-        f_theta = paddle.transpose(f_theta, [0, 2, 3, 1])
-        f_theta = paddle.reshape(f_theta, [shape[0] * shape[1], shape[2], 128])
-        f_phi = paddle.transpose(f_phi, [0, 2, 3, 1])
-        f_phi = paddle.reshape(f_phi, [shape[0] * shape[1], shape[2], 128])
-        f_g = paddle.transpose(f_g, [0, 2, 3, 1])
-        f_g = paddle.reshape(f_g, [shape[0] * shape[1], shape[2], 128])
-        #correlation
-        f_attn = paddle.matmul(f_theta, paddle.transpose(f_phi, [0, 2, 1]))
-        #scale
-        f_attn = f_attn / (128**0.5)
-        f_attn = F.softmax(f_attn)
-        #weighted sum
-        f_weight = paddle.matmul(f_attn, f_g)
-        f_weight = paddle.reshape(
-            f_weight, [shape[0], shape[1], shape[2], 128])
-        return f_weight
-
-    def forward(self, f_common):
-        f_shape = paddle.shape(f_common)
-        # print('f_shape: ', f_shape)
-
-        f_theta = self.theta_conv(f_common)
-        f_phi = self.phi_conv(f_common)
-        f_g = self.g_conv(f_common)
-
-        ######## horizon ########
-        fh_weight = self._cal_fweight([f_theta, f_phi, f_g], 
-                                        [f_shape[0], f_shape[2], f_shape[3]])
-        fh_weight = paddle.transpose(fh_weight, [0, 3, 1, 2])
-        fh_weight = self.fh_weight_conv(fh_weight)
-        #short cut
-        fh_sc = self.fh_sc_conv(f_common)
-        f_h = F.relu(fh_weight + fh_sc)
-
-        ######## vertical ########
-        fv_theta = paddle.transpose(f_theta, [0, 1, 3, 2])
-        fv_phi = paddle.transpose(f_phi, [0, 1, 3, 2])
-        fv_g = paddle.transpose(f_g, [0, 1, 3, 2])
-        fv_weight = self._cal_fweight([fv_theta, fv_phi, fv_g], 
-                                        [f_shape[0], f_shape[3], f_shape[2]])
-        fv_weight = paddle.transpose(fv_weight, [0, 3, 2, 1])
-        fv_weight = self.fv_weight_conv(fv_weight)
-        #short cut
-        fv_sc = self.fv_sc_conv(f_common)
-        f_v = F.relu(fv_weight + fv_sc)
-
-        ######## merge ########
-        f_attn = paddle.concat([f_h, f_v], axis=1)
-        f_attn = self.f_attn_conv(f_attn)
-        return f_attn
-
-
-class SASTFPN(nn.Layer):
-    def __init__(self, in_channels, with_cab=False, **kwargs):
-        super(SASTFPN, self).__init__()
-        self.in_channels = in_channels
-        self.with_cab = with_cab
-        self.FPN_Down_Fusion = FPN_Down_Fusion(self.in_channels)
-        self.FPN_Up_Fusion = FPN_Up_Fusion(self.in_channels)
-        self.out_channels = 128
-        self.cross_attention = Cross_Attention(self.out_channels)
-
-    def forward(self, x):
-        #down fpn
-        f_down = self.FPN_Down_Fusion(x)
-
-        #up fpn
-        f_up = self.FPN_Up_Fusion(x)
-
-        #fusion
-        f_common = paddle.add(x=f_down, y=f_up)
-        f_common = F.relu(f_common)
-
-        if self.with_cab:
-            # print('enhence f_common with CAB.')
-            f_common = self.cross_attention(f_common)
-
-        return f_common