一点奇怪的想法——PDFPlumber和PP-Structure——大佬给予的灵感

简历信息提取（一）：PDFPlumber和PP-Structure - 飞桨AI Studio星河社区 (baidu.com)

牛逼！！！牛逼！！！牛逼！！！ 

这个大佬写的确实很厉害，这个项目后期可以做一次完全的复现。

我个人觉得这个项目很牛的地方是（肯定不止这些，仅代表个人观点）

1 真正的解决了一些问题简化HR在找对应人上的工作

2 他在这个项目中做了信息收集和整理的工作。

#-----------------------------------------------------------分割线----------------------------------------------------------#

两个用到的地方，具体定位在这里: 简历信息提取（五）：用VI-LayoutXLM提升关键信息抽取效果 - 飞桨AI Studio星河社区 (baidu.com)

一个是predict_kie_token_ser_1.py需要放到需要放到

具体的如下：

# Copyright (c) 2022 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 os
import sys

__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(__dir__)
sys.path.insert(0, os.path.abspath(os.path.join(__dir__, '../..')))

os.environ["FLAGS_allocator_strategy"] = 'auto_growth'

import cv2
import json
import numpy as np
import time

import tools.infer.utility as utility
from ppocr.data import create_operators, transform
from ppocr.postprocess import build_post_process
from ppocr.utils.logging import get_logger
from ppocr.utils.visual import draw_ser_results
from ppocr.utils.utility import get_image_file_list, check_and_read
from ppstructure.utility import parse_args

from paddleocr import PaddleOCR

logger = get_logger()


class SerPredictor(object):
    def __init__(self, args):
        self.ocr_engine = PaddleOCR(
            use_angle_cls=args.use_angle_cls,
            det_model_dir=args.det_model_dir,
            rec_model_dir=args.rec_model_dir,
            show_log=False,
            use_gpu=args.use_gpu)

        pre_process_list = [{
            'VQATokenLabelEncode': {
                'algorithm': args.kie_algorithm,
                'class_path': args.ser_dict_path,
                'contains_re': False,
                'ocr_engine': self.ocr_engine,
                'order_method': args.ocr_order_method,
            }
        }, {
            'VQATokenPad': {
                'max_seq_len': 512,
                'return_attention_mask': True
            }
        }, {
            'VQASerTokenChunk': {
                'max_seq_len': 512,
                'return_attention_mask': True
            }
        }, {
            'Resize': {
                'size': [224, 224]
            }
        }, {
            'NormalizeImage': {
                'std': [58.395, 57.12, 57.375],
                'mean': [123.675, 116.28, 103.53],
                'scale': '1',
                'order': 'hwc'
            }
        }, {
            'ToCHWImage': None
        }, {
            'KeepKeys': {
                'keep_keys': [
                    'input_ids', 'bbox', 'attention_mask', 'token_type_ids',
                    'image', 'labels', 'segment_offset_id', 'ocr_info',
                    'entities'
                ]
            }
        }]
        postprocess_params = {
            'name': 'VQASerTokenLayoutLMPostProcess',
            "class_path": args.ser_dict_path,
        }

        self.preprocess_op = create_operators(pre_process_list,
                                              {'infer_mode': True})
        self.postprocess_op = build_post_process(postprocess_params)
        self.predictor, self.input_tensor, self.output_tensors, self.config = \
            utility.create_predictor(args, 'ser', logger)

    def __call__(self, img):
        ori_im = img.copy()
        data = {'image': img}
        data = transform(data, self.preprocess_op)
        if data[0] is None:
            return None, 0
        starttime = time.time()

        for idx in range(len(data)):
            if isinstance(data[idx], np.ndarray):
                data[idx] = np.expand_dims(data[idx], axis=0)
            else:
                data[idx] = [data[idx]]

        for idx in range(len(self.input_tensor)):
            self.input_tensor[idx].copy_from_cpu(data[idx])

        self.predictor.run()

        outputs = []
        for output_tensor in self.output_tensors:
            output = output_tensor.copy_to_cpu()
            outputs.append(output)
        preds = outputs[0]

        post_result = self.postprocess_op(
            preds, segment_offset_ids=data[6], ocr_infos=data[7])
        elapse = time.time() - starttime
        return post_result, data, elapse


def main(args):
    image_file_list = get_image_file_list(args.image_dir)
    ser_predictor = SerPredictor(args)
    count = 0
    total_time = 0

    os.makedirs(args.output, exist_ok=True)
    with open(
            os.path.join(args.output, 'infer.txt'), mode='w',
            encoding='utf-8') as f_w:
        for image_file in image_file_list:
            img, flag, _ = check_and_read(image_file)
            if not flag:
                img = cv2.imread(image_file)
                img = img[:, :, ::-1]
            if img is None:
                logger.info("error in loading image:{}".format(image_file))
                continue
            ser_res, _, elapse = ser_predictor(img)
            ser_res = ser_res[0]

            res_str = '{}'.format(
                json.dumps(
                    {
                        "ocr_info": ser_res,
                    }, ensure_ascii=False))
            f_w.write(res_str)

            img_res = draw_ser_results(
                image_file,
                ser_res,
                font_path=args.vis_font_path, )

            img_save_path = os.path.join(args.output,
                                         os.path.basename(image_file))
            cv2.imwrite(img_save_path, img_res)
            logger.info("save vis result to {}".format(img_save_path))
            if count > 0:
                total_time += elapse
            count += 1
            logger.info("Predict time of {}: {}".format(image_file, elapse))


if __name__ == "__main__":
    main(parse_args())

不同之处在后面生成的infer文件的格式上

第2个引用的地方是然后就是调用json对infer.txt中的信息进行提取，里面有点其他的东西就是往图片上写入文字，不是故意水字数的。

#受到启发后的一点想法

import datetime
import os
import fitz  # fitz就是pip install PyMuPDF
import cv2
import shutil
import numpy as np
import pandas as pd
from tqdm import tqdm
import json
from PIL import ImageFont, ImageDraw, Image


from pprint import pprint
from paddlenlp import Taskflow

infer = 'E:/2024/PaddleOCR-release-2.6/ppstructure/output/infer.txt'
bk_img = cv2.imread("E:/2024/PaddleOCR-release-2.6/ppocr_img/imgs/testas006.jpg")
fontpath = "E:/2024/PaddleOCR-release-2.6/doc/fonts/simfang.ttf"


try:
    with open(infer, 'r',encoding='UTF-8') as file:
        data = json.load(file)
        print (data)
    # 处理JSON数据
except json.decoder.JSONDecodeError as e:
    print("JSONDecodeError:", str(e))


# with open(infer, 'r',encoding='UTF-8') as f:
#     data = json.load(f)
    # print(data)
res = []
for i in range(len(data['ocr_info'])):
    res.append(data['ocr_info'][i]['transcription'])
# 拼接时不要添加分隔符，taskflow会自动分词
res = ''.join(res)
schema = ['姓名', '出生年月', '联系电话', '性别', '民族',  '政治面貌', '所在院校', '年纪专业']
ie = Taskflow('information_extraction', schema=schema)
pprint(ie(res)) 

font = ImageFont.truetype(fontpath, 32)
img_pil = Image.fromarray(bk_img)
# print (bk_img.size())
draw = ImageDraw.Draw(img_pil)

#绘制文字信息
draw.text((100, 300),  "Hello World", font = font, fill = (0, 255, 255))
draw.text((100, 350),  "你好", font = font, fill = (0, 255, 255))
bk_img = np.array(img_pil)

cv2.imshow("add_text",bk_img)
cv2.waitKey()
cv2.imwrite("add_text.jpg",bk_img)

输出如下：

然后就是将这些信息放到对应的地方

尝试。。。。麻了

opencv本是传家宝，现在麻了。

第一个 K-最近邻匹配（KNN）

第二个  FLANN匹配器只能使用SURF和SIFT算法。

不看这玩意不知道咋弄，看了更不知道咋弄。

两个想法 

1  （简单的）第一张图片在获取到对应信息时，它的任务就已经结束，将对应的信息送到对应的地址，----那么现在就只有这个地址的事，现阶段有七组信息其中在一排的有两组每组3个【'姓名', '出生年月', '联系电话', '性别', '民族'】---找中点，对应，输出。（缺点：只能用在较为单一的情况下）

2  （复杂的）现阶段很可能是不正确的

第一张图片上的对应信息找到三个点（A，a）(A,(0,0))(a,(0,0))利用某种神奇的算法得到他们的联系然后

第二张图片上已知信息A 和(0,0),求a

知道a 写入对应信息，结束？？？

.......

迷茫。

他们之间有关系吗?那种算法能用呢？

今天先到这吧，晚安。