语义实体识别的置信度

[eunij-peanut]

请问进行关键信息提取时，如何得到语义实体识别（SER）过程中，每个实体识别结果的置信度？
`from future import absolute_import
from future import division
from future import print_function

import numpy as np

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 paddle
import time

from ppocr.data import create_operators, transform
from ppocr.modeling.architectures import build_model
from ppocr.postprocess import build_post_process
from ppocr.utils.save_load import load_model
from ppocr.utils.visual import draw_ser_results
from ppocr.utils.utility import get_image_file_list, load_vqa_bio_label_maps
import tools.program as program

def to_tensor(data):
import numbers
from collections import defaultdict

data_dict = defaultdict(list)
to_tensor_idxs = []

for idx, v in enumerate(data):
    if isinstance(v, (np.ndarray, paddle.Tensor, numbers.Number)):
        if idx not in to_tensor_idxs:
            to_tensor_idxs.append(idx)
    data_dict[idx].append(v)
for idx in to_tensor_idxs:
    data_dict[idx] = paddle.to_tensor(data_dict[idx])
return list(data_dict.values())

class SerPredictor(object):
def init(self, config):
global_config = config["Global"]
self.algorithm = config["Architecture"]["algorithm"]

    self.post_process_class = build_post_process(
        config["PostProcess"], global_config
    )

    
    self.model = build_model(config["Architecture"])

    load_model(config, self.model, model_type=config["Architecture"]["model_type"])

    from paddleocr import PaddleOCR

    self.ocr_engine = PaddleOCR(
        use_angle_cls=False,
        show_log=False,
        rec_model_dir=global_config.get("kie_rec_model_dir", None),
        det_model_dir=global_config.get("kie_det_model_dir", None),
        use_gpu=global_config["use_gpu"],
    )

   
    transforms = []
    for op in config["Eval"]["dataset"]["transforms"]:
        op_name = list(op)[0]
        if "Label" in op_name:
            op[op_name]["ocr_engine"] = self.ocr_engine
        elif op_name == "KeepKeys":
            op[op_name]["keep_keys"] = [
                "input_ids",
                "bbox",
                "attention_mask",
                "token_type_ids",
                "image",
                "labels",
                "segment_offset_id",
                "ocr_info",
                "entities",
            ]

        transforms.append(op)
    if config["Global"].get("infer_mode", None) is None:
        global_config["infer_mode"] = True
    self.ops = create_operators(
        config["Eval"]["dataset"]["transforms"], global_config
    )
    self.model.eval()

def __call__(self, data):
    with open(data["img_path"], "rb") as f:
        img = f.read()
    data["image"] = img
    batch = transform(data, self.ops) # batch 有 score
    
    batch = to_tensor(batch)
    preds = self.model(batch)

    post_result = self.post_process_class(
        preds, segment_offset_ids=batch[6], ocr_infos=batch[7]
    ) # post_result 有 score

    return post_result, batch[7]  # 直接返回 batch[7]

def get_ocr_info(self, data):
    with open(data["img_path"], "rb") as f:
        img = f.read()
    data["image"] = img
    batch = transform(data, self.ops)
    batch = to_tensor(batch)
    return batch[7]  # 只返回 OCR 信息

import time

if name == "main":
# suppress_warnings() # 在主函数开始时调用这个函数

config, device, logger, vdl_writer = program.preprocess()
os.makedirs(config["Global"]["save_res_path"], exist_ok=True)

ser_engine = SerPredictor(config)

if config["Global"].get("infer_mode", None) is False:
    data_dir = config["Eval"]["dataset"]["data_dir"]
    with open(config["Global"]["infer_img"], "rb") as f:
        infer_imgs = f.readlines()
else:
    infer_imgs = get_image_file_list(config["Global"]["infer_img"])

excluded_preds = {'PAIHAO', 'GANGJUANH', 'GUIGE', 'LUHAO', 'CHANPINMC', 'FAHUORQ', 'PIHAO', 'DINGCHI', 'NONE', 'O','ZHENGMINGSH'}

with open(
    os.path.join(config["Global"]["save_res_path"], "infer_results.txt"),
    "w",
    encoding="utf-8"
) as fout:
    for idx, info in enumerate(infer_imgs):
        start_time = time.time()

        if config["Global"].get("infer_mode", None) is False:
            data_line = info.decode("utf-8")
            substr = data_line.strip("\n").split("\t")
            img_path = os.path.join(data_dir, substr[0])
            data = {"img_path": img_path, "label": substr[1]}
        else:
            img_path = info
            data = {"img_path": img_path}

        save_img_path = os.path.join(
            config["Global"]["save_res_path"],
            os.path.splitext(os.path.basename(img_path))[0] + "_ser.jpg",
        )

        result, ocr_info = ser_engine(data)  # result 有 score       

        result = result[0]
        
        filtered_result = [
            {"transcription": item["transcription"], "pred": item["pred"], "score": item["score"] }
            for item in result 
            if item["pred"].upper() not in excluded_preds
        ]
        
        if filtered_result:
            print(f"图片名称: {os.path.basename(img_path)}")
            print(json.dumps(filtered_result, ensure_ascii=False, indent=2))

        fout.write(
            img_path
            + "\t"
            + json.dumps(
                {
                    "ocr_info": result,
                },
                ensure_ascii=False,
            )
            + "\n"
        )
        img_res = draw_ser_results(img_path, result)
        cv2.imwrite(save_img_path, img_res)

        end_time = time.time()
        processing_time = end_time - start_time

        print(f"处理时间: {processing_time:.2f} 秒\n")

        logger.info(
            "process: [{}/{}], save result to {}, processing time: {:.2f} seconds".format(
                idx, len(infer_imgs), save_img_path, processing_time
            )
        )`

[GreatV]

在语义实体识别（SER）任务中，获取每个实体的置信度（score）可以通过模型的 后处理阶段 获取。在提供的代码中，SerPredictor 类的 __call__ 方法中已经实现了对置信度的获取。关键实现步骤如下：

1. 模型推理

preds = self.model(batch)

这里 preds 是模型的原始预测结果。

2. 后处理提取置信度

post_result = self.post_process_class(
    preds, segment_offset_ids=batch[6], ocr_infos=batch[7]
)

这里 post_result 中包含了模型预测的最终结果，其中 score 字段就是置信度。

3. 输出每个实体的置信度

在 SerPredictor.__call__ 方法返回的 result 中，每个 item 具有以下结构：

filtered_result = [
    {"transcription": item["transcription"], "pred": item["pred"], "score": item["score"]}
    for item in result 
    if item["pred"].upper() not in excluded_preds
]

item["score"] 就是当前实体预测的置信度。

如何使用置信度

如果你希望在调用 SerPredictor 时获取置信度，可以执行：

result, ocr_info = ser_engine(data)
for entity in result[0]:  # 每个实体的信息
    print(f"实体: {entity['transcription']}, 预测类别: {entity['pred']}, 置信度: {entity['score']}")

结论

在 post_result 返回的内容中，每个实体都包含 score 这个字段，它表示了模型对该实体的置信度。你可以使用 SerPredictor.__call__ 方法获取 result，并从中提取 score 值，即可获得每个实体的置信度。

---

Response generated by 🤖 feifei-bot | chatgpt-4o-latest

⚠️ This is an AI-generated response. Please verify any critical information.