PP-Structure版面分析、表格识别使用指南

原创
2022/10/13 14:26
阅读数 1K

版面分析

版面分析指的是对图片形式的文档进行区域划分,定位其中的关键区域,如文字、标题、表格、图片等。

在上图中,最上面有图片区域,中间是标题和表格区域,下面是文字区域。

命令行使用

paddleocr --image_dir=ppstructure/docs/table/1.png --type=structure --table=false --ocr=false

Python代码使用

import os
import cv2
from paddleocr import PPStructure,save_structure_res

if __name__ == '__main__':

    table_engine = PPStructure(table=False, ocr=False, show_log=True)

    save_folder = './output'
    img_path = 'ppstructure/docs/table/1.png'
    img = cv2.imread(img_path)
    result = table_engine(img)
    save_structure_res(result, save_folder, os.path.basename(img_path).split('.')[0])

    for line in result:
        img = line.pop('img')
        print(line)
        while True:
            cv2.imshow('img', img)
            key = cv2.waitKey()
            if key & 0xFF == ord('q'):
                break
        cv2.destroyAllWindows()

运行结果

{'type': 'text', 'bbox': [11, 729, 407, 847], 'res': '', 'img_idx': 0}
{'type': 'text', 'bbox': [442, 754, 837, 847], 'res': '', 'img_idx': 0}
{'type': 'title', 'bbox': [443, 705, 559, 719], 'res': '', 'img_idx': 0}
{'type': 'figure', 'bbox': [10, 1, 841, 294], 'res': '', 'img_idx': 0}
{'type': 'figure_caption', 'bbox': [70, 317, 707, 357], 'res': '', 'img_idx': 0}
{'type': 'figure_caption', 'bbox': [160, 317, 797, 335], 'res': '', 'img_idx': 0}
{'type': 'table', 'bbox': [453, 359, 822, 664], 'res': '', 'img_idx': 0}
{'type': 'table', 'bbox': [12, 360, 410, 716], 'res': '', 'img_idx': 0}
{'type': 'table_caption', 'bbox': [494, 343, 785, 356], 'res': '', 'img_idx': 0}
{'type': 'table_caption', 'bbox': [69, 318, 706, 357], 'res': '', 'img_idx': 0}

 'text', 'bbox': [11, 729, 407, 847]

'text', 'bbox': [442, 754, 837, 847]

'title', 'bbox': [443, 705, 559, 719]

'figure', 'bbox': [10, 1, 841, 294]

'figure_caption', 'bbox': [70, 317, 707, 357]

'figure_caption', 'bbox': [160, 317, 797, 335]

'table', 'bbox': [453, 359, 822, 664]

'table', 'bbox': [12, 360, 410, 716]

'table_caption', 'bbox': [494, 343, 785, 356]

'table_caption', 'bbox': [69, 318, 706, 357]

从运行的结果来看,它是将原始图像拆成了图像、图像标题、表格、表格标题、文字和文字标题六个分类。

模型训练

下载PaddleDection框架代码

PaddleDetection: PaddleDetection的目的是为工业界和学术界提供丰富、易用的目标检测模型 (gitee.com)

下载,解压,进入PaddleDection主目录,安装需要的Python库

pip install -r .\requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

cocotools安装错误的话可以使用如下命令安装

git clone https://github.com/pdollar/coco.git
cd coco/PythonAPI
python setup.py build_ext --inplace
python setup.py build_ext install

数据集:这是一个英文数据集,包含5个类{0: "Text", 1: "Title", 2: "List", 3:"Table", 4:"Figure"}

wget https://dax-cdn.cdn.appdomain.cloud/dax-publaynet/1.0.0/publaynet.tar.gz
tar -xzvf publaynet.tar.gz

这是一个COCO数据集,随便打开一张图像大概是这个样子的

它的标签文件是json文件,里面的内容如下

{"file_name": "PMC1087888_00001.jpg", "width": 612, "id": 410520, "height": 792}
{"segmentation": [[55.14, 456.69, 296.1, 456.69, 296.1, 467.82, 296.1, 467.82, 296.1, 480.15, 296.1, 480.15, 296.1, 491.28, 144.06, 491.28, 144.06, 503.04, 55.14, 503.04, 55.14, 491.92, 55.14, 480.15, 55.14, 468.46, 55.14, 456.69]], 
"area": 9380.344594193506, 
"iscrowd": 0, 
"image_id": 410520, 
"bbox": [55.14, 456.69, 240.96, 46.35], 
"category_id": 1, 
"id": 4010177}

第一行表示标注文件中图像信息列表,每个元素是一张图像的信息。第二行到最后一个行表示标注文件中目标物体的标注信息列表,每个元素是一个目标物体的标注信息。这里只是其中一个区域的标注,其他还有几个区域标注,这里没有列出。

{

    'segmentation':             # 物体的分割标注
    'area':                     # 物体的区域面积
    'iscrowd':                  # 是否多区域
    'image_id':                 # image id
    'bbox':                     # bbox [x1,y1,w,h]
    'category_id':              # 图片类别
    'id':                       # 区域 id
}

这里我们可以看到category_id为1,表示这个区域是一个Title。

修改配置文件configs/picodet/legacy_model/application/layout_analysis/picodet_lcnet_x1_0_layout.yml ,内容如下

 

PP-PicoDet模型原理

PP-PicoDet是一个目标检测模型,对比于YOLO系列在轻量级检测中(移动端)表现更好

PicoDet-S以0.99M参数以及1.08G-FLOPs实现30.06%mAP。它在移动端ARM-CPU上实现了150FPS,输入尺寸为320。PicoDet-M在仅2.15M参数和2.5G-FLOPs的情况下实现34.3%mAP。PicoDet-L在仅3.3M参数和8.74G-FLOPs情况下实现40.9%mAP。本文提供了小、中、大三种模型来支持不同的部署场景。

  • 整体网络结构

我们先来看它的主干网(Backbone),是百度自研的轻量级网络ESNet。它是根据ShuffleNet V2进行的改进,有关ShuffleNet V2的内容可以参考深度学习网络模型的改进与调整 中的ShuffleNet V2。

第一个改进是引入了 SE block,主要作用是对通道加权,增强特征的提取能力。有关SE block的内容可以参考深度学习网络模型的改进与调整 MobileNet V3。第二个改进是使用了一组深度可分离卷积在stride=2的时候,替换掉了channel shuffle。channel shuffle可以增强不同通道中的信息交换,但是这个信息交换是不容于1*1卷积的,1*1卷积的计算速度通常比较慢,这里在每次进行下采样的时候就会替换掉channel shuffle。第三个改进是引入了Ghost block,主要目的是降低网络的冗余性,有关Ghost block的内容可以参考深度学习网络模型的改进与调整 中的GhostNet的Ghost bottleneck。

Backbone的权重占整个网络的60%以上,并且Backbone的特征提取作用也是至关重要的。优化Backbone对检测的性能提升还是非常有帮助的。

在Neck部分,使用的是CSP-PAN。PAN是一种双向特征融合的网络,先上采样(深层到浅层)再下采样(浅层到深层)。CSP-PAN中在每层输入的地方插入了1*1的卷积,用来统一通道数,这么做的好处可以减少计算量,因为不统一通道数,在concat融合的过程中,通道数会成倍的增加,越来越多,对于移动端是非常不友好的。在上图中所示,分层特征图通过Backbone输出的各层中,C3的通道数最小为96,那么整个CSP-PAN都会通过1*1卷积统一到96通道数的维度上,整个参数量减少了73%。

CSP-PAN每一层输入的网络结构是CSP的结构,有关CSP结构的内容可以参考YOLO系列介绍(二) YOLOV4中的内容。一般的PAN网络都是三层输出,但是在CSP-PAN中增加了一层64倍下采样的分支,就是上图中右上角橙色框的P6部分,目的是为了增大大物体的召回率。这里的下采样都使用的是深度可分离卷积(DP)。这种操作mAP提升了1个点,速度只损失了0.25%。

  • Sim-OTA动态样本匹配

只有符合的标签匹配策略的样本才会定义为正样本,只有正样本所对应的特征图的像素才能够参与loss计算及反传。所以标签匹配策略是非常重要的,选择合适的正样本对精度提升至关重要。

Sim-OTA是YOLOX作者在OT策略上提出的简化算法,其作用是为不同目标选择不同数量的正样本。样本采集是动态的。

SimOTA跟其他采样方式相比,对于一些被遮挡的物体,它仍然可以采样到,比如上图中中间的头发背影。

  1. 上图是一张我们要检测的原始图像,上面有绿色框和黄色框,绿色框为ground truth box,即人工标注出来的区域。黄色框为当前ground truth box的中心点为中心点作为一个特征点,向上下左右四个方向分别延伸2.5倍的步长(stride,特征图对应原图的比例),不同的特征图上的特征点的黄色框是不同的。灰色网格代表FPN的其中一个步长(stride)为长度给图像打的网格,一个网格代表feature map中的像素点所能看到的感受野。如果feature map中的一个像素点对应原图的中心点在绿色框或者黄色框的区域内,那么这个像素点就属于正样本的候选区域。那么在上图中黄绿框相交的四个角的灰色网格不属于正样本区域。
  2. 计算正样本候选区域所产生的每个预测框与当前ground truth box的IoU。在YOLO中一个灰色网格会产生三个预测框Anchor。
  3. 将计算的IoU按从大到小排序,将排名靠前10的IoU求和,由于IoU本身值不会超过1,所以这个和的指区间为0~10,记该值为dynamic_k
  4. 计算正样本候选区域产生的预测框与当前ground truth box的cost值,得到Cost代价矩阵。该矩阵计算公式为c_{ij}= L_{ij}^{cls}+\lambda L_{ij}^{reg},其中λ是平衡系数,分别是ground truth box和预测框Anchor的分类损失和回归损失。该矩阵代表当前gruond truth box和预测框之间的代价关系,预测框的cost值越小越好。通过Cost矩阵,使网络能够自适应的找到每个ground truth box的正样本。Cost代价矩阵由三个部分组成:1、每个ground truth box和灰色网格的预测框的重合程度越高,代表这个灰色网格已经尝试去拟合ground truth box了,因此它的cost代价就会越小。2、每个ground truth box和灰色网格的预测框的分类精度越高,代表这个灰色网格已经尝试去拟合ground truth box了。3、每个ground truth box的中心是否落在灰色网格的一定半径内,如果在一定半径内,代表这个灰色网格已经尝试去拟合ground truth box了。
  5. 将Cost矩阵的的值按从小到大的顺序排列。取前dynamic_k个cost最小的预测框作为当前ground truth box最终的正样本,将其余剩下的预测框作为负样本。对于不同的ground truth box,dynamic_k的值是不一样的。
  6. 使用求出的最终正负样本来计算分类和回归损失。

在PP-PicoDet中,修改了Sim-OTA的原始loss,变为,该方法只在训练阶段使用,预测阶段是无损的。mAP提升了1%。

  • 其他优化

代码分析

ESNet的完整代码位于ppdet/modeling/backbones/esnet.py

class SEModule(nn.Layer):
    def __init__(self, channel, reduction=4):
        '''
        SE模块
        channel:输入通道数
        reducion:通道缩放率
        '''
        super(SEModule, self).__init__()
        # 通过全局池化将空间尺寸变成1*1,通道数不变
        self.avg_pool = AdaptiveAvgPool2D(1)
        # 1*1卷积进行通道降维
        self.conv1 = Conv2D(
            in_channels=channel,
            out_channels=channel // reduction,
            kernel_size=1,
            stride=1,
            padding=0,
            weight_attr=ParamAttr(),
            bias_attr=ParamAttr())
        # 1*1卷积进行通道升维
        self.conv2 = Conv2D(
            in_channels=channel // reduction,
            out_channels=channel,
            kernel_size=1,
            stride=1,
            padding=0,
            weight_attr=ParamAttr(),
            bias_attr=ParamAttr())

    def forward(self, inputs):
        outputs = self.avg_pool(inputs)
        outputs = self.conv1(outputs)
        outputs = F.relu(outputs)
        outputs = self.conv2(outputs)
        # 获取每个通道的权重
        outputs = F.hardsigmoid(outputs)
        # 利用每个通道的权重对输入的特征图进行特征值的调整
        return paddle.multiply(x=inputs, y=outputs)
def channel_shuffle(x, groups):
    '''
    通道洗牌
    '''
    batch_size, num_channels, height, width = x.shape[0:4]
    assert num_channels % groups == 0, 'num_channels should be divisible by groups'
    # 每通道的向量数n
    channels_per_group = num_channels // groups
    # reshape(g,n)的矩阵
    x = paddle.reshape(
        x=x, shape=[batch_size, groups, channels_per_group, height, width])
    # 转置成(n,g)
    x = paddle.transpose(x=x, perm=[0, 2, 1, 3, 4])
    # flatten打散
    x = paddle.reshape(x=x, shape=[batch_size, num_channels, height, width])
    return x
class ConvBNLayer(nn.Layer):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size,
                 stride,
                 padding,
                 groups=1,
                 act=None):
        '''
        普通卷积
        '''
        super(ConvBNLayer, self).__init__()
        self._conv = Conv2D(
            in_channels=in_channels,
            out_channels=out_channels,
            kernel_size=kernel_size,
            stride=stride,
            padding=padding,
            groups=groups,
            weight_attr=ParamAttr(initializer=KaimingNormal()),
            bias_attr=False)

        self._batch_norm = BatchNorm2D(
            out_channels,
            weight_attr=ParamAttr(regularizer=L2Decay(0.0)),
            bias_attr=ParamAttr(regularizer=L2Decay(0.0)))
        if act == "hard_swish":
            act = 'hardswish'
        self.act = act

    def forward(self, inputs):
        y = self._conv(inputs)
        y = self._batch_norm(y)
        if self.act:
            y = getattr(F, self.act)(y)
        return y
class InvertedResidual(nn.Layer):
    def __init__(self,
                 in_channels,
                 mid_channels,
                 out_channels,
                 stride,
                 act="relu"):
        '''
        stride=1构建块
        '''
        super(InvertedResidual, self).__init__()
        # 1*1卷积
        self._conv_pw = ConvBNLayer(
            in_channels=in_channels // 2,
            out_channels=mid_channels // 2,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act=act)
        # 3*3深度可分离卷积
        self._conv_dw = ConvBNLayer(
            in_channels=mid_channels // 2,
            out_channels=mid_channels // 2,
            kernel_size=3,
            stride=stride,
            padding=1,
            groups=mid_channels // 2,
            act=None)
        # SE block
        self._se = SEModule(mid_channels)
        # 1*1深度可分离卷积
        self._conv_linear = ConvBNLayer(
            in_channels=mid_channels,
            out_channels=out_channels // 2,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act=act)

    def forward(self, inputs):
        # 对特征图进行通道拆分
        x1, x2 = paddle.split(
            inputs,
            num_or_sections=[inputs.shape[1] // 2, inputs.shape[1] // 2],
            axis=1)
        # 左分支
        x2 = self._conv_pw(x2)
        x3 = self._conv_dw(x2)
        # 1*13*3的结果进行合并
        x3 = paddle.concat([x2, x3], axis=1)
        # 合并后SE
        x3 = self._se(x3)
        x3 = self._conv_linear(x3)
        # 合并左右分支
        out = paddle.concat([x1, x3], axis=1)
        return channel_shuffle(out, 2)
class InvertedResidualDS(nn.Layer):
    def __init__(self,
                 in_channels,
                 mid_channels,
                 out_channels,
                 stride,
                 act="relu"):
        '''
        stride=2构建块
        '''
        super(InvertedResidualDS, self).__init__()
        # 右分支
        # 3*3深度可分离卷积
        self._conv_dw_1 = ConvBNLayer(
            in_channels=in_channels,
            out_channels=in_channels,
            kernel_size=3,
            stride=stride,
            padding=1,
            groups=in_channels,
            act=None)
        # 1*1深度可分离卷积
        self._conv_linear_1 = ConvBNLayer(
            in_channels=in_channels,
            out_channels=out_channels // 2,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act=act)
        # 左分支
        # 1*1卷积
        self._conv_pw_2 = ConvBNLayer(
            in_channels=in_channels,
            out_channels=mid_channels // 2,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act=act)
        # 3*3深度可分离卷积
        self._conv_dw_2 = ConvBNLayer(
            in_channels=mid_channels // 2,
            out_channels=mid_channels // 2,
            kernel_size=3,
            stride=stride,
            padding=1,
            groups=mid_channels // 2,
            act=None)
        # se block
        self._se = SEModule(mid_channels // 2)
        # 1*1深度可分离卷积
        self._conv_linear_2 = ConvBNLayer(
            in_channels=mid_channels // 2,
            out_channels=out_channels // 2,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act=act)
        # 3*3深度可分离卷积
        self._conv_dw_mv1 = ConvBNLayer(
            in_channels=out_channels,
            out_channels=out_channels,
            kernel_size=3,
            stride=1,
            padding=1,
            groups=out_channels,
            act="hard_swish")
        # 1*1卷积
        self._conv_pw_mv1 = ConvBNLayer(
            in_channels=out_channels,
            out_channels=out_channels,
            kernel_size=1,
            stride=1,
            padding=0,
            groups=1,
            act="hard_swish")

    def forward(self, inputs):
        # 右分支
        x1 = self._conv_dw_1(inputs)
        x1 = self._conv_linear_1(x1)
        # 左分支
        x2 = self._conv_pw_2(inputs)
        x2 = self._conv_dw_2(x2)
        x2 = self._se(x2)
        x2 = self._conv_linear_2(x2)
        # 合并左右分支
        out = paddle.concat([x1, x2], axis=1)
        out = self._conv_dw_mv1(out)
        out = self._conv_pw_mv1(out)

        return out
@register
@serializable
class ESNet(nn.Layer):
    def __init__(self,
                 scale=1.0,
                 act="hard_swish",
                 feature_maps=[4, 11, 14],
                 channel_ratio=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]):
        '''
        ESNet Backbone
        '''
        super(ESNet, self).__init__()
        self.scale = scale
        if isinstance(feature_maps, Integral):
            feature_maps = [feature_maps]
        self.feature_maps = feature_maps
        # C3C4C5层的ES Block的数量
        stage_repeats = [3, 7, 3]
        # 每一步的输出通道数
        stage_out_channels = [
            -1, 24, make_divisible(128 * scale), make_divisible(256 * scale),
            make_divisible(512 * scale), 1024
        ]

        self._out_channels = []
        self._feature_idx = 0
        # 第一个普通卷积
        self._conv1 = ConvBNLayer(
            in_channels=3,
            out_channels=stage_out_channels[1],
            kernel_size=3,
            stride=2,
            padding=1,
            act=act)
        # 3*3最大池化层
        self._max_pool = MaxPool2D(kernel_size=3, stride=2, padding=1)
        self._feature_idx += 1

        # 2. bottleneck sequences
        self._block_list = []
        arch_idx = 0
        # 遍历每一个特征输出层
        for stage_id, num_repeat in enumerate(stage_repeats):
            # 遍历每一层中的重复次数
            for i in range(num_repeat):
                channels_scales = channel_ratio[arch_idx]
                mid_c = make_divisible(
                    int(stage_out_channels[stage_id + 2] * channels_scales),
                    divisor=8)
                if i == 0:
                    # 第一次进行降采样,即stride=2
                    block = self.add_sublayer(
                        name=str(stage_id + 2) + '_' + str(i + 1),
                        sublayer=InvertedResidualDS(
                            in_channels=stage_out_channels[stage_id + 1],
                            mid_channels=mid_c,
                            out_channels=stage_out_channels[stage_id + 2],
                            stride=2,
                            act=act))
                else:
                    # 之后不进行降采样,即stride=1
                    block = self.add_sublayer(
                        name=str(stage_id + 2) + '_' + str(i + 1),
                        sublayer=InvertedResidual(
                            in_channels=stage_out_channels[stage_id + 2],
                            mid_channels=mid_c,
                            out_channels=stage_out_channels[stage_id + 2],
                            stride=1,
                            act=act))
                # ES block列表
                self._block_list.append(block)
                arch_idx += 1
                self._feature_idx += 1
                self._update_out_channels(stage_out_channels[stage_id + 2],
                                          self._feature_idx, self.feature_maps)

    def _update_out_channels(self, channel, feature_idx, feature_maps):
        if feature_idx in feature_maps:
            self._out_channels.append(channel)

    def forward(self, inputs):
        y = self._conv1(inputs['image'])
        y = self._max_pool(y)
        outs = []
        for i, inv in enumerate(self._block_list):
            # 通过每一层的ES block
            y = inv(y)
            if i + 2 in self.feature_maps:
                outs.append(y)

        return outs

    @property
    def out_shape(self):
        return [ShapeSpec(channels=c) for c in self._out_channels]

CSP-PAN的完整代码位于ppdet/modeling/necks/csp_pan.py

class ConvBNLayer(nn.Layer):
    def __init__(self,
                 in_channel=96,
                 out_channel=96,
                 kernel_size=3,
                 stride=1,
                 groups=1,
                 act='leaky_relu'):
        '''
        普通卷积
        '''
        super(ConvBNLayer, self).__init__()
        initializer = nn.initializer.KaimingUniform()
        self.conv = nn.Conv2D(
            in_channels=in_channel,
            out_channels=out_channel,
            kernel_size=kernel_size,
            groups=groups,
            padding=(kernel_size - 1) // 2,
            stride=stride,
            weight_attr=ParamAttr(initializer=initializer),
            bias_attr=False)
        self.bn = nn.BatchNorm2D(out_channel)
        if act == "hard_swish":
            act = 'hardswish'
        self.act = act

    def forward(self, x):
        x = self.bn(self.conv(x))
        if self.act:
            x = getattr(F, self.act)(x)
        return x
class DPModule(nn.Layer):

    def __init__(self,
                 in_channel=96,
                 out_channel=96,
                 kernel_size=3,
                 stride=1,
                 act='leaky_relu',
                 use_act_in_out=True):
        '''
        深度可分离卷积DP
        '''
        super(DPModule, self).__init__()
        initializer = nn.initializer.KaimingUniform()
        self.use_act_in_out = use_act_in_out
        self.dwconv = nn.Conv2D(
            in_channels=in_channel,
            out_channels=out_channel,
            kernel_size=kernel_size,
            groups=out_channel,
            padding=(kernel_size - 1) // 2,
            stride=stride,
            weight_attr=ParamAttr(initializer=initializer),
            bias_attr=False)
        self.bn1 = nn.BatchNorm2D(out_channel)
        self.pwconv = nn.Conv2D(
            in_channels=out_channel,
            out_channels=out_channel,
            kernel_size=1,
            groups=1,
            padding=0,
            weight_attr=ParamAttr(initializer=initializer),
            bias_attr=False)
        self.bn2 = nn.BatchNorm2D(out_channel)
        if act == "hard_swish":
            act = 'hardswish'
        self.act = act

    def forward(self, x):
        x = self.bn1(self.dwconv(x))
        if self.act:
            x = getattr(F, self.act)(x)
        x = self.bn2(self.pwconv(x))
        if self.use_act_in_out and self.act:
            x = getattr(F, self.act)(x)
        return x
class DarknetBottleneck(nn.Layer):

    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=3,
                 expansion=0.5,
                 add_identity=True,
                 use_depthwise=False,
                 act="leaky_relu"):
        '''
        DarkNet block,包含两个卷积和一个残差连接
        '''
        super(DarknetBottleneck, self).__init__()
        hidden_channels = int(out_channels * expansion)
        conv_func = DPModule if use_depthwise else ConvBNLayer
        self.conv1 = ConvBNLayer(
            in_channel=in_channels,
            out_channel=hidden_channels,
            kernel_size=1,
            act=act)
        self.conv2 = conv_func(
            in_channel=hidden_channels,
            out_channel=out_channels,
            kernel_size=kernel_size,
            stride=1,
            act=act)
        self.add_identity = \
            add_identity and in_channels == out_channels

    def forward(self, x):
        identity = x
        out = self.conv1(x)
        out = self.conv2(out)

        if self.add_identity:
            return out + identity
        else:
            return out
class CSPLayer(nn.Layer):

    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=3,
                 expand_ratio=0.5,
                 num_blocks=1,
                 add_identity=True,
                 use_depthwise=False,
                 act="leaky_relu"):
        '''
        CSPDarkNet
        '''
        super().__init__()
        mid_channels = int(out_channels * expand_ratio)
        # 右分支
        self.main_conv = ConvBNLayer(in_channels, mid_channels, 1, act=act)
        # 左分支
        self.short_conv = ConvBNLayer(in_channels, mid_channels, 1, act=act)
        # 最后输出的1*1卷积
        self.final_conv = ConvBNLayer(
            2 * mid_channels, out_channels, 1, act=act)
        # 堆叠DarkNet block
        self.blocks = nn.Sequential(* [
            DarknetBottleneck(
                mid_channels,
                mid_channels,
                kernel_size,
                1.0,
                add_identity,
                use_depthwise,
                act=act) for _ in range(num_blocks)
        ])

    def forward(self, x):
        # 左分支,通过1*1的卷积,获取原特征图一半的通道数
        x_short = self.short_conv(x)
        # 右分支,通过1*1的卷积,获取原特征图一半的通道数
        x_main = self.main_conv(x)
        # 右分支通过一系列DarkNet block的堆叠
        x_main = self.blocks(x_main)
        # 拼接左右分支
        x_final = paddle.concat((x_main, x_short), axis=1)
        # 使用1*1卷积进行输出
        return self.final_conv(x_final)
class Channel_T(nn.Layer):
    def __init__(self,
                 in_channels=[116, 232, 464],
                 out_channels=96,
                 act="leaky_relu"):
        '''
        输入部分统一通道数
        '''
        super(Channel_T, self).__init__()
        self.convs = nn.LayerList()
        for i in range(len(in_channels)):
            self.convs.append(
                ConvBNLayer(
                    in_channels[i], out_channels, 1, act=act))

    def forward(self, x):
        outs = [self.convs[i](x[i]) for i in range(len(x))]
        return outs
@register
@serializable
class CSPPAN(nn.Layer):

    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=5,
                 num_features=3,
                 num_csp_blocks=1,
                 use_depthwise=True,
                 act='hard_swish',
                 spatial_scales=[0.125, 0.0625, 0.03125]):
        '''
        CSP-PAN Neck
        '''
        super(CSPPAN, self).__init__()
        self.conv_t = Channel_T(in_channels, out_channels, act=act)
        in_channels = [out_channels] * len(spatial_scales)
        # 输入的三层通道数
        self.in_channels = in_channels
        # 输出的三层通道数
        self.out_channels = out_channels
        # 空间尺度
        self.spatial_scales = spatial_scales
        # 特征数
        self.num_features = num_features
        # 卷积层,深度可分离卷积或普通卷积
        conv_func = DPModule if use_depthwise else ConvBNLayer

        if self.num_features == 4:
            # P6层的第一个深度可分离卷积
            self.first_top_conv = conv_func(
                in_channels[0], in_channels[0], kernel_size, stride=2, act=act)
            # P6层的第二个深度可分离卷积
            self.second_top_conv = conv_func(
                in_channels[0], in_channels[0], kernel_size, stride=2, act=act)
            self.spatial_scales.append(self.spatial_scales[-1] / 2)

        # 上采样
        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
        # 上采样模块列表
        self.top_down_blocks = nn.LayerList()
        for idx in range(len(in_channels) - 1, 0, -1):
            # 使用CSPDarkNet进行上采样
            self.top_down_blocks.append(
                CSPLayer(
                    in_channels[idx - 1] * 2,
                    in_channels[idx - 1],
                    kernel_size=kernel_size,
                    num_blocks=num_csp_blocks,
                    add_identity=False,
                    use_depthwise=use_depthwise,
                    act=act))

        # 下采样列表
        self.downsamples = nn.LayerList()
        # 下采样模块列表
        self.bottom_up_blocks = nn.LayerList()
        # 下采样中一个深度可分离卷积接一个CSPDarkNet
        for idx in range(len(in_channels) - 1):
            self.downsamples.append(
                conv_func(
                    in_channels[idx],
                    in_channels[idx],
                    kernel_size=kernel_size,
                    stride=2,
                    act=act))
            self.bottom_up_blocks.append(
                CSPLayer(
                    in_channels[idx] * 2,
                    in_channels[idx + 1],
                    kernel_size=kernel_size,
                    num_blocks=num_csp_blocks,
                    add_identity=False,
                    use_depthwise=use_depthwise,
                    act=act))

    def forward(self, inputs):
        assert len(inputs) == len(self.in_channels)
        # 统一输入通道数
        inputs = self.conv_t(inputs)

        # 上采样过程
        inner_outs = [inputs[-1]]
        for idx in range(len(self.in_channels) - 1, 0, -1):
            # 获取深层特征
            feat_heigh = inner_outs[0]
            # 获取浅层特征(feat_heigh低一层)
            feat_low = inputs[idx - 1]
            # 对深层特征进行上采样
            upsample_feat = self.upsample(feat_heigh)
            # 合并上采样之后的高层特征和浅层特征,再送入CSPDarkNet网络
            inner_out = self.top_down_blocks[len(self.in_channels) - 1 - idx](
                paddle.concat([upsample_feat, feat_low], 1))
            inner_outs.insert(0, inner_out)

        # 下采样过程
        outs = [inner_outs[0]]
        for idx in range(len(self.in_channels) - 1):
            # 获取浅层特征
            feat_low = outs[-1]
            # 获取深层特征(feat_low高一层)
            feat_height = inner_outs[idx + 1]
            # 对浅层特征使用深度可分离卷积进行下采样
            downsample_feat = self.downsamples[idx](feat_low)
            # 合并下采样之后的浅层特征和深层特征,再送入CSPDarkNet网络
            out = self.bottom_up_blocks[idx](paddle.concat(
                [downsample_feat, feat_height], 1))
            outs.append(out)

        top_features = None
        # 获取P6层的特征
        if self.num_features == 4:
            top_features = self.first_top_conv(inputs[-1])
            top_features = top_features + self.second_top_conv(outs[-1])
            outs.append(top_features)

        return tuple(outs)

    @property
    def out_shape(self):
        return [
            ShapeSpec(
                channels=self.out_channels, stride=1. / s)
            for s in self.spatial_scales
        ]

    @classmethod
    def from_config(cls, cfg, input_shape):
        return {'in_channels': [i.channels for i in input_shape], }

表格识别

表格识别指的是对图片上的表格进行识别,不仅要识别表格中的文字,而且需要识别表格中单元格的坐标信息。

tableocr_pipeline

整个过程分为两步,第一调用文本检测算法,对单行文本进行检测,得到一个一个的检测框,再对这些检测框送入到文本识别算法获得文字。第二调用表格结构预测算法获得单元格的坐标,并与文本检测的检测框坐标进行聚合,再与文本识别结果进行聚合,最终得到图像表格的Excel结果。

命令行使用

进入PaddleOCR的ppstructure目录

mkdir inference
cd inference
wget https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_infer.tar
tar -xzvf ch_PP-OCRv3_det_infer.tar
wget https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_rec_infer.tar
tar -xzvf ch_PP-OCRv3_rec_infer.tar
wget https://paddleocr.bj.bcebos.com/ppstructure/models/slanet/ch_ppstructure_mobile_v2.0_SLANet_infer.tar
tar -xzvf ch_ppstructure_mobile_v2.0_SLANet_infer.tar

在ppstructure/table/predict_table.py中添加执行参数

--det_model_dir=inference/ch_PP-OCRv3_det_infer --rec_model_dir=inference/ch_PP-OCRv3_rec_infer --table_model_dir=inference/ch_ppstructure_mobile_v2.0_SLANet_infer --rec_char_dict_path=../ppocr/utils/ppocr_keys_v1.txt --table_char_dict_path=../ppocr/utils/dict/table_structure_dict_ch.txt --image_dir=docs/table/table.jpg --output=../output/table 

并将工作目录设置为ppstructure。这里的表格图片如下

执行结果,生成的Excel文件如下

模型训练

文字检测模型略过,文字识别模型的训练可以参考PaddleOCR使用指南 中的模型训练

这里主要看一下表格结构预测模型的训练

数据集:https://dax-cdn.cdn.appdomain.cloud/dax-pubtabnet/2.0.0/pubtabnet.tar.gz

下载后解压,大概样子如下所示

数据集生成

下载数据集生成工具:GitHub - WenmuZhou/TableGeneration: 通过浏览器渲染生成表格图像

 

展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部