DB算法原理与构建

参考：
https://aistudio.baidu.com/projectdetail/4483048
https://www.bilibili.com/video/BV1xf4y1p7Gf/
Real-Time Scene Text Detection with Differentiable Binarization
如何读论文-by 李沐
DB (Real-Time Scene Text Detection with Differentiable Binarization)
原理

DB是一个基于分割的文本检测算法，其提出的可微分阈值，接纳动态的阈值区分文本区域与背景

基于分割的平凡文本检测算法，流程如上图蓝色箭头所示，得到分割结果后接纳固定的阈值(标准二值化不可微，导致网络无法端到端训练)得到二值化的分割图，之后接纳诸如像素聚类的开导式算法得到文本区域。
DB算法的流程如图中红色箭头所示，最大的差别在于DB有一个阈值图，通过网络去推测图片每个位置处的阈值，threshold map相当于自适应threshold，每个像素点都有一个阈值，而不是接纳一个固定的值，结合segment map与threshold map得到近似二值化特征图

上风：
1.算法结构简单，无需繁琐的后处理
2.开源数据上拥有精良的精度和性能
输入的图像经过网络Backbone和FPN提取特征，提取后的特征级联在一起，得到原图四分之一大小的特征，然后使用卷积层分别得到文本区域推测概率图和阈值图，进而通过DB的后处理得到文本困绕曲线。
FPN-Convolution
deformable 卷积作用是为了增大感受野

如何通过两个map得到近似二值图

k是一个参数，论文里是50
DB算法提出了可微二值化，可微二值化将标准二值化中的阶跃函数举行了近似，使用如下公式举行代替：

白色区域是probalibitymap
黄色区域是threshold map

使用这种设置，是为了可微分

L是周长 A是面积

i,j 是点到红色四条边的距离
归一化

正样本是笔墨区域 负样本是背景区域

九个方位。每个方位x,y以是是18

DB文本检测模型构建

DB文本检测模型可以分为三个部分：
Backbone网络，负责提取图像的特征
FPN网络，特征金字塔结构加强特征
Head网络，计算文本区域概率图
backbone网络：论文中使用了ResNet50，本节实验中，为了加速训练速率，接纳MobileNetV3 large结构作为backbone。
DB的Backbone用于提取图像的多标准特征，如下代码所示，假设输入的形状为[640, 640]，backbone网络的输出有四个特征，其形状分别是 [1, 16, 160, 160]，[1, 24, 80, 80]， [1, 56, 40, 40]，[1, 480, 20, 20]。 这些特征将输入给特征金字塔FPN网络进一步的加强特征。

1. import paddle
2. from ppocr.modeling.backbones.det_mobilenet_v3 import MobileNetV3
4. fake_inputs = paddle.randn([1, 3, 640, 640], dtype="float32")
6. # 1. 声明Backbone
7. model_backbone = MobileNetV3()
8. model_backbone.eval()
10. # 2. 执行预测
11. outs = model_backbone(fake_inputs)
13. # 3. 打印网络结构
14. # print(model_backbone)
16. # 4. 打印输出特征形状
17. for idx, out in enumerate(outs):
18.     print("The index is ", idx, "and the shape of output is ", out.shape)

复制代码

FPN网络
特征金字塔结构FPN是一种卷积网络来高效提取图片中各维度特征的常用方法。
FPN网络的输入为Backbone部分的输出，输出特征图的高度和宽度为原图的四分之一。假设输入图像的形状为[1, 3, 640, 640]，FPN输出特征的高度和宽度为[160, 160]

1. import paddle
2. from paddle import nn
3. import paddle.nn.functional as F
4. from paddle import ParamAttr
6. class DBFPN(nn.Layer):
7.     def __init__(self, in_channels, out_channels, **kwargs):
8.         super(DBFPN, self).__init__()
9.         self.out_channels = out_channels
11.         # DBFPN详细实现参考： https://github.com/PaddlePaddle/PaddleOCRblob/release%2F2.4/ppocr/modeling/necks/db_fpn.py
13.     def forward(self, x):
14.         c2, c3, c4, c5 = x
16.         in5 = self.in5_conv(c5)
17.         in4 = self.in4_conv(c4)
18.         in3 = self.in3_conv(c3)
19.         in2 = self.in2_conv(c2)
21.         # 特征上采样
22.         out4 = in4 + F.upsample(
23.             in5, scale_factor=2, mode="nearest", align_mode=1)  # 1/16
24.         out3 = in3 + F.upsample(
25.             out4, scale_factor=2, mode="nearest", align_mode=1)  # 1/8
26.         out2 = in2 + F.upsample(
27.             out3, scale_factor=2, mode="nearest", align_mode=1)  # 1/4
29.         p5 = self.p5_conv(in5)
30.         p4 = self.p4_conv(out4)
31.         p3 = self.p3_conv(out3)
32.         p2 = self.p2_conv(out2)
34.         # 特征上采样
35.         p5 = F.upsample(p5, scale_factor=8, mode="nearest", align_mode=1)
36.         p4 = F.upsample(p4, scale_factor=4, mode="nearest", align_mode=1)
37.         p3 = F.upsample(p3, scale_factor=2, mode="nearest", align_mode=1)
39.         fuse = paddle.concat([p5, p4, p3, p2], axis=1)
40.         return fuse

复制代码

Head网络
计算文本区域概率图，文本区域阈值图以及文本区域二值图。
DB Head网络会在FPN特征的基础上作上采样，将FPN特征由原图的四分之一大小映射到原图大小。

2. import math
3. import paddle
4. from paddle import nn
5. import paddle.nn.functional as F
6. from paddle import ParamAttr
8. class DBHead(nn.Layer):
9.     """
10.     Differentiable Binarization (DB) for text detection:
11.         see https://arxiv.org/abs/1911.08947
12.     args:
13.         params(dict): super parameters for build DB network
14.     """
16.     def __init__(self, in_channels, k=50, **kwargs):
17.         super(DBHead, self).__init__()
18.         self.k = k
20.         # DBHead详细实现参考 https://github.com/PaddlePaddle/PaddleOCR/blob/release%2F2.4/ppocr/modeling/heads/det_db_head.py
22.     def step_function(self, x, y):
23.         # 可微二值化实现，通过概率图和阈值图计算文本分割二值图
24.         return paddle.reciprocal(1 + paddle.exp(-self.k * (x - y)))
26.     def forward(self, x, targets=None):
27.         shrink_maps = self.binarize(x)
28.         if not self.training:
29.             return {'maps': shrink_maps}
31.         threshold_maps = self.thresh(x)
32.         binary_maps = self.step_function(shrink_maps, threshold_maps)
33.         y = paddle.concat([shrink_maps, threshold_maps, binary_maps], axis=1)
34.         return {'maps': y}

复制代码

1. # 1. 从PaddleOCR中imort DBHead
2. from ppocr.modeling.heads.det_db_head import DBHead
3. import paddle
5. # 2. 计算DBFPN网络输出结果
6. fake_inputs = paddle.randn([1, 3, 640, 640], dtype="float32")
7. model_backbone = MobileNetV3()
8. in_channles = model_backbone.out_channels
9. model_fpn = DBFPN(in_channels=in_channles, out_channels=256)
10. outs = model_backbone(fake_inputs)
11. fpn_outs = model_fpn(outs)
13. # 3. 声明Head网络
14. model_db_head = DBHead(in_channels=256)
16. # 4. 打印DBhead网络
17. print(model_db_head)
19. # 5. 计算Head网络的输出
20. db_head_outs = model_db_head(fpn_outs)
21. print(f"The shape of fpn outs {fpn_outs.shape}")
22. print(f"The shape of DB head outs {db_head_outs['maps'].shape}")

复制代码

运行后发现报错：
类不完整，于是重新到github paddle ocr目录下下载相应文件
db_fpn.py
det_db_head.py
完整代码：

3. import math
4. import paddle
5. from paddle import nn
6. import paddle.nn.functional as F
7. from paddle import ParamAttr
11. def make_divisible(v, divisor=8, min_value=None):
12.     if min_value is None:
13.         min_value = divisor
14.     new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
15.     if new_v < 0.9 * v:
16.         new_v += divisor
17.     return new_v
20. class MobileNetV3(nn.Layer):
21.     def __init__(self,
22.                  in_channels=3,
23.                  model_name='large',
24.                  scale=0.5,
25.                  disable_se=False,
26.                  **kwargs):
27.         """
28.         the MobilenetV3 backbone network for detection module.
29.         Args:
30.             params(dict): the super parameters for build network
31.         """
32.         super(MobileNetV3, self).__init__()
34.         self.disable_se = disable_se
36.         if model_name == "large":
37.             cfg = [
38.                 # k, exp, c,  se,     nl,  s,
39.                 [3, 16, 16, False, 'relu', 1],
40.                 [3, 64, 24, False, 'relu', 2],
41.                 [3, 72, 24, False, 'relu', 1],
42.                 [5, 72, 40, True, 'relu', 2],
43.                 [5, 120, 40, True, 'relu', 1],
44.                 [5, 120, 40, True, 'relu', 1],
45.                 [3, 240, 80, False, 'hardswish', 2],
46.                 [3, 200, 80, False, 'hardswish', 1],
47.                 [3, 184, 80, False, 'hardswish', 1],
48.                 [3, 184, 80, False, 'hardswish', 1],
49.                 [3, 480, 112, True, 'hardswish', 1],
50.                 [3, 672, 112, True, 'hardswish', 1],
51.                 [5, 672, 160, True, 'hardswish', 2],
52.                 [5, 960, 160, True, 'hardswish', 1],
53.                 [5, 960, 160, True, 'hardswish', 1],
54.             ]
55.             cls_ch_squeeze = 960
56.         elif model_name == "small":
57.             cfg = [
58.                 # k, exp, c,  se,     nl,  s,
59.                 [3, 16, 16, True, 'relu', 2],
60.                 [3, 72, 24, False, 'relu', 2],
61.                 [3, 88, 24, False, 'relu', 1],
62.                 [5, 96, 40, True, 'hardswish', 2],
63.                 [5, 240, 40, True, 'hardswish', 1],
64.                 [5, 240, 40, True, 'hardswish', 1],
65.                 [5, 120, 48, True, 'hardswish', 1],
66.                 [5, 144, 48, True, 'hardswish', 1],
67.                 [5, 288, 96, True, 'hardswish', 2],
68.                 [5, 576, 96, True, 'hardswish', 1],
69.                 [5, 576, 96, True, 'hardswish', 1],
70.             ]
71.             cls_ch_squeeze = 576
72.         else:
73.             raise NotImplementedError("mode[" + model_name +
74.                                       "_model] is not implemented!")
76.         supported_scale = [0.35, 0.5, 0.75, 1.0, 1.25]
77.         assert scale in supported_scale, \
78.             "supported scale are {} but input scale is {}".format(supported_scale, scale)
79.         inplanes = 16
80.         # conv1
81.         self.conv = ConvBNLayer(
82.             in_channels=in_channels,
83.             out_channels=make_divisible(inplanes * scale),
84.             kernel_size=3,
85.             stride=2,
86.             padding=1,
87.             groups=1,
88.             if_act=True,
89.             act='hardswish')
91.         self.stages = []
92.         self.out_channels = []
93.         block_list = []
94.         i = 0
95.         inplanes = make_divisible(inplanes * scale)
96.         for (k, exp, c, se, nl, s) in cfg:
97.             se = se and not self.disable_se
98.             start_idx = 2 if model_name == 'large' else 0
99.             if s == 2 and i > start_idx:
100.                 self.out_channels.append(inplanes)
101.                 self.stages.append(nn.Sequential(*block_list))
102.                 block_list = []
103.             block_list.append(
104.                 ResidualUnit(
105.                     in_channels=inplanes,
106.                     mid_channels=make_divisible(scale * exp),
107.                     out_channels=make_divisible(scale * c),
108.                     kernel_size=k,
109.                     stride=s,
110.                     use_se=se,
111.                     act=nl))
112.             inplanes = make_divisible(scale * c)
113.             i += 1
114.         block_list.append(
115.             ConvBNLayer(
116.                 in_channels=inplanes,
117.                 out_channels=make_divisible(scale * cls_ch_squeeze),
118.                 kernel_size=1,
119.                 stride=1,
120.                 padding=0,
121.                 groups=1,
122.                 if_act=True,
123.                 act='hardswish'))
124.         self.stages.append(nn.Sequential(*block_list))
125.         self.out_channels.append(make_divisible(scale * cls_ch_squeeze))
126.         for i, stage in enumerate(self.stages):
127.             self.add_sublayer(sublayer=stage, name="stage{}".format(i))
129.     def forward(self, x):
130.         x = self.conv(x)
131.         out_list = []
132.         for stage in self.stages:
133.             x = stage(x)
134.             out_list.append(x)
135.         return out_list
138. class ConvBNLayer(nn.Layer):
139.     def __init__(self,
140.                  in_channels,
141.                  out_channels,
142.                  kernel_size,
143.                  stride,
144.                  padding,
145.                  groups=1,
146.                  if_act=True,
147.                  act=None):
148.         super(ConvBNLayer, self).__init__()
149.         self.if_act = if_act
150.         self.act = act
151.         self.conv = nn.Conv2D(
152.             in_channels=in_channels,
153.             out_channels=out_channels,
154.             kernel_size=kernel_size,
155.             stride=stride,
156.             padding=padding,
157.             groups=groups,
158.             bias_attr=False)
160.         self.bn = nn.BatchNorm(num_channels=out_channels, act=None)
162.     def forward(self, x):
163.         x = self.conv(x)
164.         x = self.bn(x)
165.         if self.if_act:
166.             if self.act == "relu":
167.                 x = F.relu(x)
168.             elif self.act == "hardswish":
169.                 x = F.hardswish(x)
170.             else:
171.                 print("The activation function({}) is selected incorrectly.".
172.                       format(self.act))
173.                 exit()
174.         return x
177. class ResidualUnit(nn.Layer):
178.     def __init__(self,
179.                  in_channels,
180.                  mid_channels,
181.                  out_channels,
182.                  kernel_size,
183.                  stride,
184.                  use_se,
185.                  act=None):
186.         super(ResidualUnit, self).__init__()
187.         self.if_shortcut = stride == 1 and in_channels == out_channels
188.         self.if_se = use_se
190.         self.expand_conv = ConvBNLayer(
191.             in_channels=in_channels,
192.             out_channels=mid_channels,
193.             kernel_size=1,
194.             stride=1,
195.             padding=0,
196.             if_act=True,
197.             act=act)
198.         self.bottleneck_conv = ConvBNLayer(
199.             in_channels=mid_channels,
200.             out_channels=mid_channels,
201.             kernel_size=kernel_size,
202.             stride=stride,
203.             padding=int((kernel_size - 1) // 2),
204.             groups=mid_channels,
205.             if_act=True,
206.             act=act)
207.         if self.if_se:
208.             self.mid_se = SEModule(mid_channels)
209.         self.linear_conv = ConvBNLayer(
210.             in_channels=mid_channels,
211.             out_channels=out_channels,
212.             kernel_size=1,
213.             stride=1,
214.             padding=0,
215.             if_act=False,
216.             act=None)
218.     def forward(self, inputs):
219.         x = self.expand_conv(inputs)
220.         x = self.bottleneck_conv(x)
221.         if self.if_se:
222.             x = self.mid_se(x)
223.         x = self.linear_conv(x)
224.         if self.if_shortcut:
225.             x = paddle.add(inputs, x)
226.         return x
229. class SEModule(nn.Layer):
230.     def __init__(self, in_channels, reduction=4):
231.         super(SEModule, self).__init__()
232.         self.avg_pool = nn.AdaptiveAvgPool2D(1)
233.         self.conv1 = nn.Conv2D(
234.             in_channels=in_channels,
235.             out_channels=in_channels // reduction,
236.             kernel_size=1,
237.             stride=1,
238.             padding=0)
239.         self.conv2 = nn.Conv2D(
240.             in_channels=in_channels // reduction,
241.             out_channels=in_channels,
242.             kernel_size=1,
243.             stride=1,
244.             padding=0)
246.     def forward(self, inputs):
247.         outputs = self.avg_pool(inputs)
248.         outputs = self.conv1(outputs)
249.         outputs = F.relu(outputs)
250.         outputs = self.conv2(outputs)
251.         outputs = F.hardsigmoid(outputs, slope=0.2, offset=0.5)
252.         return inputs * outputs
255. class DBFPN(nn.Layer):
256.     def __init__(self, in_channels, out_channels, **kwargs):
257.         super(DBFPN, self).__init__()
258.         self.out_channels = out_channels
259.         weight_attr = paddle.nn.initializer.KaimingUniform()
261.         self.in2_conv = nn.Conv2D(
262.             in_channels=in_channels[0],
263.             out_channels=self.out_channels,
264.             kernel_size=1,
265.             weight_attr=ParamAttr(initializer=weight_attr),
266.             bias_attr=False)
267.         self.in3_conv = nn.Conv2D(
268.             in_channels=in_channels[1],
269.             out_channels=self.out_channels,
270.             kernel_size=1,
271.             weight_attr=ParamAttr(initializer=weight_attr),
272.             bias_attr=False)
273.         self.in4_conv = nn.Conv2D(
274.             in_channels=in_channels[2],
275.             out_channels=self.out_channels,
276.             kernel_size=1,
277.             weight_attr=ParamAttr(initializer=weight_attr),
278.             bias_attr=False)
279.         self.in5_conv = nn.Conv2D(
280.             in_channels=in_channels[3],
281.             out_channels=self.out_channels,
282.             kernel_size=1,
283.             weight_attr=ParamAttr(initializer=weight_attr),
284.             bias_attr=False)
285.         self.p5_conv = nn.Conv2D(
286.             in_channels=self.out_channels,
287.             out_channels=self.out_channels // 4,
288.             kernel_size=3,
289.             padding=1,
290.             weight_attr=ParamAttr(initializer=weight_attr),
291.             bias_attr=False)
292.         self.p4_conv = nn.Conv2D(
293.             in_channels=self.out_channels,
294.             out_channels=self.out_channels // 4,
295.             kernel_size=3,
296.             padding=1,
297.             weight_attr=ParamAttr(initializer=weight_attr),
298.             bias_attr=False)
299.         self.p3_conv = nn.Conv2D(
300.             in_channels=self.out_channels,
301.             out_channels=self.out_channels // 4,
302.             kernel_size=3,
303.             padding=1,
304.             weight_attr=ParamAttr(initializer=weight_attr),
305.             bias_attr=False)
306.         self.p2_conv = nn.Conv2D(
307.             in_channels=self.out_channels,
308.             out_channels=self.out_channels // 4,
309.             kernel_size=3,
310.             padding=1,
311.             weight_attr=ParamAttr(initializer=weight_attr),
312.             bias_attr=False)
314.     def forward(self, x):
315.         c2, c3, c4, c5 = x
317.         in5 = self.in5_conv(c5)
318.         in4 = self.in4_conv(c4)
319.         in3 = self.in3_conv(c3)
320.         in2 = self.in2_conv(c2)
322.         out4 = in4 + F.upsample(
323.             in5, scale_factor=2, mode="nearest", align_mode=1)  # 1/16
324.         out3 = in3 + F.upsample(
325.             out4, scale_factor=2, mode="nearest", align_mode=1)  # 1/8
326.         out2 = in2 + F.upsample(
327.             out3, scale_factor=2, mode="nearest", align_mode=1)  # 1/4
329.         p5 = self.p5_conv(in5)
330.         p4 = self.p4_conv(out4)
331.         p3 = self.p3_conv(out3)
332.         p2 = self.p2_conv(out2)
333.         p5 = F.upsample(p5, scale_factor=8, mode="nearest", align_mode=1)
334.         p4 = F.upsample(p4, scale_factor=4, mode="nearest", align_mode=1)
335.         p3 = F.upsample(p3, scale_factor=2, mode="nearest", align_mode=1)
337.         fuse = paddle.concat([p5, p4, p3, p2], axis=1)
338.         return fuse
341. def get_bias_attr(k):
342.     stdv = 1.0 / math.sqrt(k * 1.0)
343.     initializer = paddle.nn.initializer.Uniform(-stdv, stdv)
344.     bias_attr = ParamAttr(initializer=initializer)
345.     return bias_attr
348. class Head(nn.Layer):
349.     def __init__(self, in_channels, name_list):
350.         super(Head, self).__init__()
351.         self.conv1 = nn.Conv2D(
352.             in_channels=in_channels,
353.             out_channels=in_channels // 4,
354.             kernel_size=3,
355.             padding=1,
356.             weight_attr=ParamAttr(),
357.             bias_attr=False)
358.         self.conv_bn1 = nn.BatchNorm(
359.             num_channels=in_channels // 4,
360.             param_attr=ParamAttr(
361.                 initializer=paddle.nn.initializer.Constant(value=1.0)),
362.             bias_attr=ParamAttr(
363.                 initializer=paddle.nn.initializer.Constant(value=1e-4)),
364.             act='relu')
365.         self.conv2 = nn.Conv2DTranspose(
366.             in_channels=in_channels // 4,
367.             out_channels=in_channels // 4,
368.             kernel_size=2,
369.             stride=2,
370.             weight_attr=ParamAttr(
371.                 initializer=paddle.nn.initializer.KaimingUniform()),
372.             bias_attr=get_bias_attr(in_channels // 4))
373.         self.conv_bn2 = nn.BatchNorm(
374.             num_channels=in_channels // 4,
375.             param_attr=ParamAttr(
376.                 initializer=paddle.nn.initializer.Constant(value=1.0)),
377.             bias_attr=ParamAttr(
378.                 initializer=paddle.nn.initializer.Constant(value=1e-4)),
379.             act="relu")
380.         self.conv3 = nn.Conv2DTranspose(
381.             in_channels=in_channels // 4,
382.             out_channels=1,
383.             kernel_size=2,
384.             stride=2,
385.             weight_attr=ParamAttr(
386.                 initializer=paddle.nn.initializer.KaimingUniform()),
387.             bias_attr=get_bias_attr(in_channels // 4), )
389.     def forward(self, x):
390.         x = self.conv1(x)
391.         x = self.conv_bn1(x)
392.         x = self.conv2(x)
393.         x = self.conv_bn2(x)
394.         x = self.conv3(x)
395.         x = F.sigmoid(x)
396.         return x
399. class DBHead(nn.Layer):
400.     """
401.     Differentiable Binarization (DB) for text detection:
402.         see https://arxiv.org/abs/1911.08947
403.     args:
404.         params(dict): super parameters for build DB network
405.     """
407.     def __init__(self, in_channels, k=50, **kwargs):
408.         super(DBHead, self).__init__()
409.         self.k = k
410.         binarize_name_list = [
411.             'conv2d_56', 'batch_norm_47', 'conv2d_transpose_0', 'batch_norm_48',
412.             'conv2d_transpose_1', 'binarize'
413.         ]
414.         thresh_name_list = [
415.             'conv2d_57', 'batch_norm_49', 'conv2d_transpose_2', 'batch_norm_50',
416.             'conv2d_transpose_3', 'thresh'
417.         ]
418.         self.binarize = Head(in_channels, binarize_name_list)
419.         self.thresh = Head(in_channels, thresh_name_list)
421.     def step_function(self, x, y):
422.         return paddle.reciprocal(1 + paddle.exp(-self.k * (x - y)))
424.     def forward(self, x, targets=None):
425.         shrink_maps = self.binarize(x)
426.         if not self.training:
427.             return {'maps': shrink_maps}
429.         threshold_maps = self.thresh(x)
430.         binary_maps = self.step_function(shrink_maps, threshold_maps)
431.         y = paddle.concat([shrink_maps, threshold_maps, binary_maps], axis=1)
432.         return {'maps': y}
437. if __name__=='__main__':
440.     fake_inputs = paddle.randn([1, 3, 640, 640], dtype="float32")
442.     #   声明Backbone
443.     model_backbone = MobileNetV3()
444.    
445.     in_channles = model_backbone.out_channels
447.     # 声明FPN网络
448.     model_fpn = DBFPN(in_channels=in_channles, out_channels=256)
450.     #  打印FPN网络
451.     print(model_fpn)
452.     # DBFPN(
453.     #   (in2_conv): Conv2D(16, 256, kernel_size=[1, 1], data_format=NCHW)
454.     #   (in3_conv): Conv2D(24, 256, kernel_size=[1, 1], data_format=NCHW)
455.     #   (in4_conv): Conv2D(56, 256, kernel_size=[1, 1], data_format=NCHW)
456.     #   (in5_conv): Conv2D(480, 256, kernel_size=[1, 1], data_format=NCHW)
457.     #   (p5_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
458.     #   (p4_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
459.     #   (p3_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
460.     #   (p2_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
461.     # )
462.     # 5. 计算得到FPN结果输出
463.     outs = model_backbone(fake_inputs)
464.     fpn_outs = model_fpn(outs)
465.     # The shape of fpn outs [1, 256, 160, 160]
467.     # 3. 声明Head网络
468.     model_db_head = DBHead(in_channels=256)
470.     # 4. 打印DBhead网络
471.     print(model_db_head)
472.     # DBHead(
473.     #   (binarize): Head(
474.     #     (conv1): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
475.     #     (conv_bn1): BatchNorm()
476.     #     (conv2): Conv2DTranspose(64, 64, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
477.     #     (conv_bn2): BatchNorm()
478.     #     (conv3): Conv2DTranspose(64, 1, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
479.     #   )
480.     #   (thresh): Head(
481.     #     (conv1): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
482.     #     (conv_bn1): BatchNorm()
483.     #     (conv2): Conv2DTranspose(64, 64, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
484.     #     (conv_bn2): BatchNorm()
485.     #     (conv3): Conv2DTranspose(64, 1, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
486.     #   )
487.     # )
488.     # 5. 计算Head网络的输出
489.     db_head_outs = model_db_head(fpn_outs)
490.     print(f"The shape of fpn outs {fpn_outs.shape}")
491.     # The shape of fpn outs [1, 256, 160, 160]
492.     print(f"The shape of DB head outs {db_head_outs['maps'].shape}")
493.     # The shape of DB head outs [1, 3, 640, 640]

复制代码

结果：

1. DBFPN(
2.   (in2_conv): Conv2D(16, 256, kernel_size=[1, 1], data_format=NCHW)
3.   (in3_conv): Conv2D(24, 256, kernel_size=[1, 1], data_format=NCHW)
4.   (in4_conv): Conv2D(56, 256, kernel_size=[1, 1], data_format=NCHW)
5.   (in5_conv): Conv2D(480, 256, kernel_size=[1, 1], data_format=NCHW)
6.   (p5_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
7.   (p4_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
8.   (p3_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
9.   (p2_conv): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
10. )
11. DBHead(
12.   (binarize): Head(
13.     (conv1): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
14.     (conv_bn1): BatchNorm()
15.     (conv2): Conv2DTranspose(64, 64, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
16.     (conv_bn2): BatchNorm()
17.     (conv3): Conv2DTranspose(64, 1, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
18.   )
19.   (thresh): Head(
20.     (conv1): Conv2D(256, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
21.     (conv_bn1): BatchNorm()
22.     (conv2): Conv2DTranspose(64, 64, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
23.     (conv_bn2): BatchNorm()
24.     (conv3): Conv2DTranspose(64, 1, kernel_size=[2, 2], stride=[2, 2], data_format=NCHW)
25.   )
26. )
27. The shape of fpn outs [1, 256, 160, 160]
28. The shape of DB head outs [1, 3, 640, 640]

复制代码

简化代码

1. from ppocr.modeling.backbones.det_mobilenet_v3 import MobileNetV3
3. from ppocr.modeling.necks.db_fpn import DBFPN
5. from ppocr.modeling.heads.det_db_head import DBHead
7. import paddle
10. fake_inputs = paddle.randn([1, 3, 640, 640], dtype="float32")
11. model_backbone = MobileNetV3()
12. print(model_backbone)
13. in_channles = model_backbone.out_channels
14. outs = model_backbone(fake_inputs)
18. model_fpn = DBFPN(in_channels=in_channles, out_channels=256)
19. print(model_fpn)
20. fpn_outs = model_fpn(outs)
23. model_db_head = DBHead(in_channels=256)
24. print(model_db_head)
27. db_head_outs = model_db_head(fpn_outs)
28. print(f"The shape of fpn outs {fpn_outs.shape}") # [1, 256, 160, 160]
29. print(f"The shape of DB head outs {db_head_outs['maps'].shape}")#[1, 3, 640, 640]

复制代码

DB算法优点：（有监督，backbone选ResNet50效果更好）

• 我们的方法在五个场景文本基准数据集中均取得了连续精良的表现，涵盖了程度、多方向和弯曲文本。
  2.相比先前的领先方法，我们的方法运行速率显著更快，因为DB可以或许提供高度鲁棒的二值化图，极大地简化了后期处理步调。
  3.当搭配轻量级主干网络时，DB表现出色，特殊是在使用ResNet-18作为主干网络时，显著提升了检测性能。
  4.由于在推理阶段可以移除DB而不断送性能，因此测试阶段无需额外的内存/时间开销。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。