Echo/fcb_photo_review
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更换文档检测模型

Browse Source
This commit is contained in:
liuyebo
2024-08-27 14:42:45 +08:00
parent aea6f19951
commit 1514e09c40
2072 changed files with 254336 additions and 4967 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
paddle_detection/ppdet/modeling/necks/ttf_fpn.py Normal file
View File

@@ -0,0 +1,242 @@
# 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
import paddle.nn.functional as F
from paddle import ParamAttr
from paddle.nn.initializer import Constant, Uniform, Normal, XavierUniform
from ppdet.core.workspace import register, serializable
from paddle.regularizer import L2Decay
from ppdet.modeling.layers import DeformableConvV2, ConvNormLayer, LiteConv
import math
from ppdet.modeling.ops import batch_norm
from ..shape_spec import ShapeSpec
__all__ = ['TTFFPN']
class Upsample(nn.Layer):
def __init__(self, ch_in, ch_out, norm_type='bn'):
super(Upsample, self).__init__()
fan_in = ch_in * 3 * 3
stdv = 1. / math.sqrt(fan_in)
self.dcn = DeformableConvV2(
ch_in,
ch_out,
kernel_size=3,
weight_attr=ParamAttr(initializer=Uniform(-stdv, stdv)),
bias_attr=ParamAttr(
initializer=Constant(0),
regularizer=L2Decay(0.),
learning_rate=2.),
lr_scale=2.,
regularizer=L2Decay(0.))
self.bn = batch_norm(
ch_out, norm_type=norm_type, initializer=Constant(1.))
def forward(self, feat):
dcn = self.dcn(feat)
bn = self.bn(dcn)
relu = F.relu(bn)
out = F.interpolate(relu, scale_factor=2., mode='bilinear')
return out
class DeConv(nn.Layer):
def __init__(self, ch_in, ch_out, norm_type='bn'):
super(DeConv, self).__init__()
self.deconv = nn.Sequential()
conv1 = ConvNormLayer(
ch_in=ch_in,
ch_out=ch_out,
stride=1,
filter_size=1,
norm_type=norm_type,
initializer=XavierUniform())
conv2 = nn.Conv2DTranspose(
in_channels=ch_out,
out_channels=ch_out,
kernel_size=4,
padding=1,
stride=2,
groups=ch_out,
weight_attr=ParamAttr(initializer=XavierUniform()),
bias_attr=False)
bn = batch_norm(ch_out, norm_type=norm_type, norm_decay=0.)
conv3 = ConvNormLayer(
ch_in=ch_out,
ch_out=ch_out,
stride=1,
filter_size=1,
norm_type=norm_type,
initializer=XavierUniform())
self.deconv.add_sublayer('conv1', conv1)
self.deconv.add_sublayer('relu6_1', nn.ReLU6())
self.deconv.add_sublayer('conv2', conv2)
self.deconv.add_sublayer('bn', bn)
self.deconv.add_sublayer('relu6_2', nn.ReLU6())
self.deconv.add_sublayer('conv3', conv3)
self.deconv.add_sublayer('relu6_3', nn.ReLU6())
def forward(self, inputs):
return self.deconv(inputs)
class LiteUpsample(nn.Layer):
def __init__(self, ch_in, ch_out, norm_type='bn'):
super(LiteUpsample, self).__init__()
self.deconv = DeConv(ch_in, ch_out, norm_type=norm_type)
self.conv = LiteConv(ch_in, ch_out, norm_type=norm_type)
def forward(self, inputs):
deconv_up = self.deconv(inputs)
conv = self.conv(inputs)
interp_up = F.interpolate(conv, scale_factor=2., mode='bilinear')
return deconv_up + interp_up
class ShortCut(nn.Layer):
def __init__(self,
layer_num,
ch_in,
ch_out,
norm_type='bn',
lite_neck=False,
name=None):
super(ShortCut, self).__init__()
shortcut_conv = nn.Sequential()
for i in range(layer_num):
fan_out = 3 * 3 * ch_out
std = math.sqrt(2. / fan_out)
in_channels = ch_in if i == 0 else ch_out
shortcut_name = name + '.conv.{}'.format(i)
if lite_neck:
shortcut_conv.add_sublayer(
shortcut_name,
LiteConv(
in_channels=in_channels,
out_channels=ch_out,
with_act=i < layer_num - 1,
norm_type=norm_type))
else:
shortcut_conv.add_sublayer(
shortcut_name,
nn.Conv2D(
in_channels=in_channels,
out_channels=ch_out,
kernel_size=3,
padding=1,
weight_attr=ParamAttr(initializer=Normal(0, std)),
bias_attr=ParamAttr(
learning_rate=2., regularizer=L2Decay(0.))))
if i < layer_num - 1:
shortcut_conv.add_sublayer(shortcut_name + '.act',
nn.ReLU())
self.shortcut = self.add_sublayer('shortcut', shortcut_conv)
def forward(self, feat):
out = self.shortcut(feat)
return out
@register
@serializable
class TTFFPN(nn.Layer):
"""
Args:
in_channels (list): number of input feature channels from backbone.
[128,256,512,1024] by default, means the channels of DarkNet53
backbone return_idx [1,2,3,4].
planes (list): the number of output feature channels of FPN.
[256, 128, 64] by default
shortcut_num (list): the number of convolution layers in each shortcut.
[3,2,1] by default, means DarkNet53 backbone return_idx_1 has 3 convs
in its shortcut, return_idx_2 has 2 convs and return_idx_3 has 1 conv.
norm_type (string): norm type, 'sync_bn', 'bn', 'gn' are optional.
bn by default
lite_neck (bool): whether to use lite conv in TTFNet FPN,
False by default
fusion_method (string): the method to fusion upsample and lateral layer.
'add' and 'concat' are optional, add by default
"""
__shared__ = ['norm_type']
def __init__(self,
in_channels,
planes=[256, 128, 64],
shortcut_num=[3, 2, 1],
norm_type='bn',
lite_neck=False,
fusion_method='add'):
super(TTFFPN, self).__init__()
self.planes = planes
self.shortcut_num = shortcut_num[::-1]
self.shortcut_len = len(shortcut_num)
self.ch_in = in_channels[::-1]
self.fusion_method = fusion_method
self.upsample_list = []
self.shortcut_list = []
self.upper_list = []
for i, out_c in enumerate(self.planes):
in_c = self.ch_in[i] if i == 0 else self.upper_list[-1]
upsample_module = LiteUpsample if lite_neck else Upsample
upsample = self.add_sublayer(
'upsample.' + str(i),
upsample_module(
in_c, out_c, norm_type=norm_type))
self.upsample_list.append(upsample)
if i < self.shortcut_len:
shortcut = self.add_sublayer(
'shortcut.' + str(i),
ShortCut(
self.shortcut_num[i],
self.ch_in[i + 1],
out_c,
norm_type=norm_type,
lite_neck=lite_neck,
name='shortcut.' + str(i)))
self.shortcut_list.append(shortcut)
if self.fusion_method == 'add':
upper_c = out_c
elif self.fusion_method == 'concat':
upper_c = out_c * 2
else:
raise ValueError('Illegal fusion method. Expected add or\
concat, but received {}'.format(self.fusion_method))
self.upper_list.append(upper_c)
def forward(self, inputs):
feat = inputs[-1]
for i, out_c in enumerate(self.planes):
feat = self.upsample_list[i](feat)
if i < self.shortcut_len:
shortcut = self.shortcut_list[i](inputs[-i - 2])
if self.fusion_method == 'add':
feat = feat + shortcut
else:
feat = paddle.concat([feat, shortcut], axis=1)
return feat
@classmethod
def from_config(cls, cfg, input_shape):
return {'in_channels': [i.channels for i in input_shape], }
@property
def out_shape(self):
return [ShapeSpec(channels=self.upper_list[-1], )]