MingJing (明镜):基于混合架构的智能中文敏感信息识别

前言


取意“明镜高悬”

第一部分:我们在对抗什么?

中文敏感信息识别的难题

中文环境的复杂度远超英文。在英文里,单词之间有空格作为天然分隔符,人名首字母大写,地址结构清晰(门牌-街道-城市)。但在中文里,字符流是连续的,信息密度极高,且有很多歧义,同一句话,经常就带有不同的意思

  • 非结构化的混沌:地址根本没有固定的可匹配模式,更多的是需要上下文的结合判断。比如经典老梗“长官,我要去二仙桥,走成华大道;但是正则是识别不了上下文的,填写的“某东 1 号园区大门”、“某公寓南门外卖柜”;什么正则才能匹配到这种多样性的地名?写宽了全是误报,写窄了全是漏报
  • 词的歧义 “张三”在“张三签署了合同”里是高敏感的姓名。那我请问了“法外狂徒张三”的张三,还是一个高敏感词汇吗,它就成了一个毫无价值的梗或代词,同样的还有“小爱”---我在
  • 分词的粘连陷阱:英文靠空格分词,中文呢?
    最典型的例子:“张三丰田汽车销售顾问”。如果用简单的规则,很容易把“张三丰”识别成人名(武当掌门)实体边界粘连往往是识别的第一步

正则困境

正则的本质是形式语言的模式匹配。它假设目标对象具有“可被严格定义的形式特征”。对于身份证(固定 18 位,含校验位)或 UUID(固定格式),正则确实是完美的解。但在中文互联网语境下,这一假设彻底失效

数字的“对抗性伪装”

在中文网络中,数字不仅仅是数学符号,更是绕过审查的工具。

  • “联系我:幺三八,九五二七” —— 汉字数字混排。
  • “VX:1-3-9-xxxx-xxxx” —— 分隔符对抗。
  • “扣扣:2432...” —— 全角字符。
    要匹配上述所有变种,正则的复杂度将呈指数级上升

无法理解语义

正则无法理解语义,这导致了无法调和的矛盾:

  • 太严 (Strict):为了不误报,将手机号规则定死为 ^1[3-9]\d{9}$。结果用户输入 138-1234-5678,直接漏报。
  • 太松 (Loose):为了不漏报,放宽为 \d{11}。结果订单号、时间戳、物流单号全部被误杀。

在没有语义理解的前提下,正则只能在误报和漏报之间做取舍和平衡

大模型时代

既然正则不懂语义,现在的 LLM(大语言模型)不是很强吗?为什么不直接把数据扔给 LLM

这就涉及到了工程落地的第一性原理思考:投入产出比。
理论上,LLM 确实能完美区分“我的电话是...”和“订单号是...”。但在实际的工程链路上,超大超长的文本下是行不通的

  1. 性能瓶颈:比如一个日志处理系统 QPS 经常过万。LLM 的推理速度还在毫秒甚至秒级,把它挂在实时流处理的链路上,整个系统会瞬间崩溃
  2. 成本: 正则的边际成本几乎为零,而 LLM 的成本与 Token 数线性相关,其算力成本将远超数据本身的价值,用 GPU 算力去扫描 1%的敏感内容,是不值的

其实在这个场景下,不存在一种万能的算法,只存在适合特定场景的算力密度

如果把数据处理看作一个漏斗,那么不同层级的数据应该匹配不同等级的算力。我的核心设计理念并非简单的“混合”,而是 “漏斗式分级治理”

让正则做 80% 的粗活,NLP 做 15% 的细活,最后 5% 的疑难交给 LLM

第二部分:三层混合架构

整个处理流可以抽象为:
规则引擎 (Layer 1) → NLP 引擎 (Layer 2) → LLM 决策 (Layer 3)

每一层不仅输出识别结果,还会附带一个 0.0 到 1.0 的置信度。系统根据动态阈值决定:是直接“信任”当前层的结果并返回,还是认为“不够确定”传给下一层。

第一层:规则引擎

虽然正则有很多缺陷,但是在这种“大”场景下,正则依然是作为核心的存在,而且在特殊场景下,正则就是 100%准确,成本低,且效率高,虽然维护的成本还是存在的,但是维护一次,永久使用,哈哈哈哈哈
但与传统正则不同,我引入了
“可验证机制” 和 “上下文嗅探”。

1. 数学验证:100% 置信度
对于身份证、银行卡这类带有校验位设计的实体,数学公式是是可靠的验证方式

  • 身份证:执行 ISO 7064 校验。
  • 银行卡:执行 Luhn (模10) 算法。

代码实现:

# 权重表(GB 11643-1999 标准)
WEIGHTS = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]

# 校验位映射表
CHECKSUM_MAP = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2']

def validate_result(self, pattern_text: str) -> Optional[bool]:
    """验证身份证校验位"""
    id_number = pattern_text.replace("-", "").replace(" ", "").upper()

    if len(id_number) != 18:
        return False  # 长度不对,明确无效

    # 验证省份码(前 2 位)
    province_code = id_number[:2]
    if province_code not in self.VALID_PROVINCE_CODES:
        return None  # 省份码未知,需 LLM 验证

    # 计算前 17 位的加权和
    total = 0
    for i in range(17):
        total += int(id_number[i]) * self.WEIGHTS[i]

    # 计算期望校验位
    expected_checksum = self.CHECKSUM_MAP[total % 11]
    actual_checksum = id_number[17].upper()

    if actual_checksum == expected_checksum:
        return True  # 校验通过,100% 确认
    else:
        return None  # 校验不匹配,可能是脱敏数据,需 LLM 验证

2. 宽松正则 + 上下文嗅探
对于手机号这种无法数学验证的实体,我们采用
“宽进严出” 策略:

  • 宽进:使用比较宽松的正则(如允许包含空格、连字符),确保不漏报任何疑似目标。
  • 上下文加分:如果数字周围检测到 "Tel", "联系方式", "手机" 等锚点词,置信度 +0.4。

代码实现:

# 上下文增强逻辑示意
context_keywords = ["电话", "手机", "Tel", "Mobile", "联系方式"]
context_score = 0.0

# 检查匹配项周围的上下文窗口
surrounding_text = get_context_window(text, start, end, window_size=20)
for keyword in context_keywords:
    if keyword in surrounding_text:
        context_score = 0.4  # 发现关键词,显著提升置信度
        break

final_score = base_regex_score + context_score
  1. 负向过滤
    除了正向验证,还有反向逻辑

场景

触发条件

手机号

11111111111(全相同数字)、12345678901(序列模式)、10000000000(服务号)

身份证

111111111111111111(全相同)、无效出生日期(月=13、日=32)

邮箱

文件路径伪装(.jpg)、版本号伪装(1.2.3.4.5@...)、测试邮箱(test@test)

代码实现:

def invalidate_result(self, pattern_text: str) -> bool:
    """检查匹配项是否明显无效"""
    phone = pattern_text.replace("-", "").replace(" ", "")

    # 1. 拒绝连号:所有数字相同
    if len(set(phone)) == 1:
        return True

    # 2. 拒绝序列模式
    sequential_patterns = [
        "12345678901",  # 顺序
        "10987654321",  # 逆序
        "11111111111",
        "00000000000",
    ]
    if phone in sequential_patterns:
        return True

    # 3. 拒绝特殊服务号(非个人手机)
    if phone.startswith(("100", "110", "120")):
        if len(phone) == 11:
            return True

    return False  # 未触发,保留

4. 中国特有实体识别

除了通用的身份证、手机号、邮箱,我们还针对中文环境实现了多种特有实体识别器。

敏感字段识别器 (CN_SENSITIVE_FIELD)

针对配置文件、日志、JSON 等场景,识别敏感字段名及其值:

# 匹配 JSON/Query/Assignment 中的敏感字段
PATTERNS = [
    # Password: "password": "value"
    r"""(?i)['"]?(?:password|passwd|pwd|pass)['"]?\s*[:=]\s*['"]([^'"]{1,100})['"]""",
    # Secret/Token: "secret": "value"
    r"""(?i)['"]?(?:secret|token|api[_-]?key|app[_-]?key)['"]?\s*[:=]\s*['"]([^'"]{1,100})['"]""",
    # Private key header
    r"""-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----""",
]

# 中文上下文词汇
CONTEXT = [
    "密码", "口令", "密钥", "凭证", "账号", "用户名",
    "认证", "授权", "令牌", "私钥", "证书",
]

负向过滤会排除占位符值:xxx、your_password、test、placeholder 等。

车牌号识别器 (CN_VEHICLE_PLATE)

支持中国所有类型的车牌格式,根据《GA 36-2018》标准:

车牌类型

格式

示例

普通号牌

省+字母+5位

京A12345

新能源

省+字母+6位

京AD12345

军用

军/空/海等+字母+5位

军A12345

警用

省+字母+4位+警

陕A1234警

使馆

使+3位+2位

使12345

港澳

粤Z+4位+港澳

粤Z1234港

# 31个省份简称
PROVINCES = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼"

# 边界检测确保不粘连
pattern = r"(?<![" + PROVINCES + r"A-Za-z0-9])[" + PROVINCES + r"][A-Z][A-Z0-9]{5}(?![A-Za-z0-9])"

其他中国特有识别器

  • CN_SOCIAL_CREDIT_CODE:统一社会信用代码(18位,含校验位)
  • CN_MEDICAL_LICENSE:医疗许可证号
  • CN_DRIVER_LICENSE:驾驶证号
  • CN_PASSPORT:护照号
  • CN_MILITARY_ID:军官证号
  • CN_WECHAT_ID:微信号
  • CN_CLOUD_KEY:云厂商密钥(AWS Access Key、阿里云 AK 等)

每种识别器都实现了 validate_result 和 invalidate_result,确保高置信度输出。

第二层:NLP 引擎 —— 句法结构的解析

正则对语义无能为力,我们需要 NLP 来理解上下文。这里接入了微软的 Presidio 项目,基于 spaCy 中文 NER 模型,并针对我们的置信度机制做了深度适配。

模型说明:

此识别器依赖 SpacyNlpEngine 加载的 NLP artifacts,不能单独使用。NER 模型的默认置信度为 0.4(ner_strength),需要通过上下文验证和特征校验来提升。

支持的实体类型:

  • PERSON:人名(如:张三、李四、王小明)
  • LOCATION:地名/地址(如:北京市、朝阳区、中关村大街)
  • ORGANIZATION:组织机构(如:阿里巴巴、腾讯公司、北京大学)
  • DATE_TIME:日期时间(如:2024年1月1日、下午3点)
  • NRP:国籍/宗教/政治团体(如:中国、佛教、共青团)

上下文词汇词典

对于每种实体类型,我们定义了丰富的上下文词汇。当实体周围出现这些词时,置信度 +0.1:

CONTEXT_WORDS = {
    "PERSON": [
        "姓名", "名字", "本人", "用户", "客户", "员工", "先生", "女士",
        "联系人", "负责人", "经办人", "申请人", "持卡人", "收件人", "发件人",
        "法人", "代表", "签名", "签字", "户主", "业主", "房主",
    ],
    "LOCATION": [
        "地址", "住址", "居住地", "户籍", "籍贯", "所在地", "位置",
        "省", "市", "区", "县", "镇", "乡", "村", "街道", "路", "号",
        "小区", "楼", "单元", "室", "门牌", "邮寄地址", "收货地址",
        "公司地址", "家庭地址", "工作地址", "通讯地址",
    ],
    "ORGANIZATION": [
        "公司", "企业", "单位", "机构", "组织", "部门", "集团",
        "有限公司", "股份公司", "责任公司", "合伙企业",
        "银行", "医院", "学校", "大学", "学院", "研究所", "研究院",
        "工作单位", "就职单位", "所属单位", "开户行", "发卡行",
    ],
    "DATE_TIME": [
        "日期", "时间", "出生日期", "生日", "出生年月", "入职日期",
        "有效期", "到期日", "签发日期", "注册日期", "创建时间",
    ],
}

实体特定验证逻辑

人名验证:

  • 长度检查:中文人名通常 2-4 个字,过短或过长扣分
  • 姓氏加分:检查第一个字是否在常见姓氏列表(王、李、张、刘...)中

地名验证:

  • 后缀加分:检查是否包含行政后缀(省、市、区、县、街道、路、镇、乡、村、道、巷、弄、号、楼、室)
  • 长度检查:太短的地名(<2字)可能是误识别

组织机构验证:

  • 后缀加分:检查是否包含组织后缀(公司、集团、银行、医院、学校、大学、学院、研究所、研究院、中心、局、部、厅、委、会、协会、基金会)
  • 长度检查:太短的组织名(<3字)可能是误识别
def _adjust_score(self, entity_type: str, entity_text: str, full_text: str,
               start: int, end: int, base_score: float) -> float:
    """根据上下文和实体特征调整置信分数"""
    score = base_score

    # 1. 上下文词汇检查(前后 20 个字符)
    context_words = self.CONTEXT_WORDS.get(entity_type, [])
    context = full_text[max(0, start-20):min(len(full_text), end+20)]
    for word in context_words:
        if word in context:
            score = min(1.0, score + 0.1)  # 有上下文词汇,提高分数
            break

    # 2. 实体类型特定验证
    if entity_type == "PERSON":
        # 人名长度检查
        if len(entity_text) < 2 or len(entity_text) > 6:
            score *= 0.5
        # 常见姓氏加分
        if entity_text and entity_text[0] in "王李张刘陈杨黄赵周吴徐孙马朱胡郭何高林罗郑梁谢宋唐许韩冯邓曹彭曾萧田董潘袁蔡蒋余于杜叶程魏苏吕丁任沈姚卢姜崔钟谭陆汪范金石廖贾夏韦傅方白邹孟熊秦邱江尹薛闫段雷侯龙史陶黎贺顾毛郝龚邵万钱严覃武戴莫孔向汤":
            score = min(1.0, score + 0.1)

    elif entity_type == "LOCATION":
        # 检查行政后缀
        location_suffixes = ["省", "市", "区", "县", "镇", "乡", "村", "街道", "路", "道", "巷", "弄", "号", "楼", "室"]
        for suffix in location_suffixes:
            if entity_text.endswith(suffix):
                score = min(1.0, score + 0.1)
                break
        # 太短的地名扣分
        if len(entity_text) < 2:
            score *= 0.5

    elif entity_type == "ORGANIZATION":
        # 检查组织后缀
        org_suffixes = ["公司", "集团", "银行", "医院", "学校", "大学", "学院", "研究所", "研究院", "中心", "局", "部", "厅", "委", "会", "协会", "基金会"]
        for suffix in org_suffixes:
            if entity_text.endswith(suffix):
                score = min(1.0, score + 0.1)
                break
        # 太短的组织名扣分
        if len(entity_text) < 3:
            score *= 0.5

    return score

第三层:LLM 决策引擎

这一层只在置信度处于模糊区间(如 0.4-0.8)时触发,充当"终极裁判"的角色。我们实现了完整的验证器类体系,支持多种部署模式。

结构化验证结果

@dataclass
class VerificationResult:
    entity_text: str      # 实体文本
    entity_type: str      # 实体类型
    original_score: float # 原始分数
    is_sensitive: bool    # LLM判断是否为敏感信息
    confidence: float     # LLM置信度 (0-1)
    final_score: float    # 最终分数
    reason: str           # LLM给出的理由
    context: str          # 上下文

上下文提取机制

LLM 需要看到实体周围的环境才能做出准确判断。我们在 extract_context 方法中实现了智能上下文窗口:

def extract_context(self, text: str, start: int, end: int) -> str:
    """提取实体周围的上下文,用【】标记实体位置。"""
    context_start = max(0, start - self.context_window)
    context_end = min(len(text), end + self.context_window)

    before = text[context_start:start]
    entity = text[start:end]
    after = text[end:context_end]

    # 添加省略号表示截断
    prefix = "..." if context_start > 0 else ""
    suffix = "..." if context_end < len(text) else ""

    return f"{prefix}{before}【{entity}】{after}{suffix}"

多模式支持

我们通过工厂函数支持三种模式,满足不同场景需求:

模式

适用场景

优点

缺点

API 模式

云端调用 OpenAI/通义/智谱

高精度,无需维护模型

数据出境,成本较高

Local 模式

本地加载 DeBERTa-v3

数据不出域,适合金融/政企

首次加载慢,需要 GPU

Mock 模式

单元测试/CI 流水线

零成本,零延迟

不提供真实判断

def create_verifier(mode: str = "api", **kwargs) -> BaseLLMVerifier:
    if mode == "api":
        return APILLMVerifier(**kwargs)
    elif mode == "local":
        return LocalLLMVerifier(**kwargs)
    elif mode == "mock":
        return MockLLMVerifier(**kwargs)
    else:
        raise ValueError(f"不支持的模式: {mode}")

最终分数融合策略

当 LLM 返回结果后,我们采用"最大值策略"融合分数:

# LLM 验证后的分数融合
if is_sensitive:
    final_score = max(original_score, confidence)  # 取两者较大值
else:
    final_score = 0.0  # LLM 明确说不是,直接清零

这样设计的原因是:如果 LLM 认为是敏感信息,我们就取它的高置信度;如果 LLM 认为不是,那它掌握的语义信息比正则/NLP 多,我们信任它的判断

第三部分:设计借鉴:Presidio 架构优势

深度借鉴了微软 Presidio 项目的架构设计,这是一个被广泛采用的工业级 PII 识别框架。通过沿其核心设计理念,有以下优势:

组件化架构

Presidio 的核心是将识别器抽象为可扩展的组件:

Presidio 组件

作用

MingJing 中的对应

Recognizer 抽象基类

统一识别器接口

所有中文识别器继承此类

PatternRecognizer

正则模式识别器基类

CnPhoneRecognizer, CnIdCardRecognizer

LocalRecognizer

NLP 本地识别识别器基类

CnNlpRecognizer

AnalyzerEngine

分析引擎编排器

协调各层识别器的核心

NlpEngine 抽象层

支持 spaCy/Stanza/HF 等后端

SpacyNlpEngine

RecognizerRegistry

识别器注册表

管理和查询识别器

优势:

  • 开闭原则(OCP):新增识别器无需修改引擎代码
  • 插件化:通过 YAML 配置即可加载自定义识别器
  • 热插拔:识别器可动态注册/卸载

NLP 引擎抽象层

Presidio 将 NLP 处理抽象为独立引擎,支持多种后端:

NLP 引擎

适用场景

MingJing 是否使用

SpacyNlpEngine

spaCy 模型(推荐)

是

StanzaNlpEngine

Stanza 模型

可扩展

HuggingFaceNlpEngine

HuggingFace 模型

可扩展

OpenAINlpEngine

GPT-4/Claude API

可扩展

优势:

  • 后端无关:更换 NLP 模型只需修改配置
  • 模型共享:多个识别器共享同一个 NLP 实例,降低内存占用
  • 延迟加载:NLP 模型按需加载,支持 Lazy Load

上下文感知

def _enhance_using_context(
    self, text, raw_results, nlp_artifacts, recognizers, context
) -> List[RecognizerResult]:
    results = []

    for recognizer in recognizers:
        # 分离当前识别器和其他识别器的结果
        recognizer_results = [r for r in raw_results
                           if r.recognition_metadata[RECOGNIZER_IDENTIFIER_KEY] == recognizer.id]
        other_results = [r for r in raw_results
                          if r.recognition_metadata[RECOGNIZER_IDENTIFIER_KEY] != recognizer.id]

        # 识别器级增强(看其他实体的上下文)
        recognizer_results = recognizer.enhance_using_context(
            text=text,
            raw_recognizer_results=recognizer_results,
            other_raw_recognizer_results=other_results,  # 关键!
            nlp_artifacts=nlp_artifacts,
            context=context,
        )
        results.extend(recognizer_results)

    # 全局上下文增强(基于词形/词典)
    results = self.context_aware_enhancer.enhance_using_context(
        text=text, raw_results=results, nlp_artifacts=nlp_artifacts,
        recognizers=recognizers, context=context,
    )
    return results

设计亮点:

  1. 分层增强:先在识别器级别(看其他实体),再在全局级别(看词典)
  2. 交叉实体感知:一个识别器可以看到其他识别器的结果,例如 "EmailRecognizer" 看到 "PhoneRecognizer" 发现了手机号,可以增强邮箱的置信度

第四部分:高度可自定义

自定义识别器

可以在后台直接添加自定义正则规则
比如公司内部的项目代号格式是
PRJ-2024-XXX,你只需要配置正则,设置一个基础置信度,无需修改一行代码即可生效

动态配置系统

MingJing 继承 Presidio 的配置设计,支持通过 YAML 文件完全控制识别器行为,无需修改一行代码。

YAML 配置文件结构

# config/recognizers.yaml
supported_languages: ["zh", "en"]

# 正则标志全局配置
global_regex_flags: 8  # re.IGNORECASE | re.MULTILINE

# 识别器列表
recognizers:
  # 1. 预定义识别器(通过名称引用)
  - type: "predefined"
    name: "CnIdCardRecognizer"
    enabled: true

  # 2. 自定义正则识别器
  - name: "ProjectCode"
    supported_language: "zh"
    patterns:
      - name: "Main pattern"
        regex: "PRJ-[2]\\d{3}-[A-Z]{3}"
        score: 0.9
      - name: "Weak pattern"
        regex: "[A-Z]{3}-\\d{5}"
        score: 0.5
    context: ["项目", "代号", "PRJ", "project"]
    supported_entity: "PROJECT_CODE"
    enabled: true

  # 3. 多语言配置
  - name: "CustomEmail"
    supported_languages:
      - language: "zh"
        context: ["邮箱", "邮件"]
      - language: "en"
        context: ["email", "mail"]
    patterns:
      - regex: "[a-z]+\\.project@example\\.com"
        score: 0.8
    supported_entity: "INTERNAL_EMAIL"

RecognizerRegistryProvider —— 配置加载器

from presidio_analyzer.recognizer_registry import RecognizerRegistryProvider

# 从 YAML 文件加载配置
provider = RecognizerRegistryProvider(
    conf_file="config/recognizers.yaml"
)

# 或直接使用字典配置
provider = RecognizerRegistryProvider(
    registry_configuration={
        "supported_languages": ["zh"],
        "global_regex_flags": 8,
        "recognizers": [...]
    }
)

# 创建识别器注册表
registry = provider.create_recognizer_registry()
  1. 配置解析:读取 YAML 并转换为 Python 字典
  2. 识别器创建:根据配置实例化 PatternRecognizer
  3. 语言管理:为每种语言创建独立的识别器实例
  4. NLP 识别器注入:自动添加 SpacyRecognizer

RecognizerListLoader —— 识别器实例化

class RecognizerListLoader:
    @staticmethod
    def get(recognizers_conf, supported_languages, global_regex_flags):
        """从配置创建识别器列表"""
        recognizers = []

        # 分离预定义和自定义识别器
        predefined, custom = _split_recognizers(recognizers_conf)

        # 加载预定义识别器(如 CnIdCardRecognizer)
        for rec_conf in predefined:
            cls = get_predefined_recognizer(rec_conf["name"])
            recognizers.append(cls())

        # 创建自定义识别器
        for rec_conf in custom:
            # 检查是否启用
            if not is_recognizer_enabled(rec_conf):
                continue

            # 为每种语言创建识别器
            for lang_conf in _get_recognizer_languages(rec_conf, supported_languages):
                recognizer = PatternRecognizer(
                    name=rec_conf["name"],
                    supported_language=lang_conf["supported_language"],
                    patterns=_create_patterns(rec_conf["patterns"]),
                    context=rec_conf.get("context", []) + (lang_conf["context"] or []),
                    supported_entity=rec_conf["supported_entity"]
                )
                recognizers.append(recognizer)

        return recognizers

    @staticmethod
    def is_recognizer_enabled(recognizer_conf):
        """检查识别器是否启用(默认启用)"""
        return "enabled" not in recognizer_conf or recognizer_conf["enabled"]

配置热更新

# 支持运行时重新加载配置
class DynamicAnalyzerEngine:
    def __init__(self, config_path):
        self.config_path = config_path
        self.reload_config()

    def reload_config(self):
        """重新加载配置文件"""
        provider = RecognizerRegistryProvider(
            conf_file=self.config_path
        )
        new_registry = provider.create_recognizer_registry()

        # 原子替换
        self.registry = new_registry
        logger.info(f"Configuration reloaded from {self.config_path}")

    def analyze(self, text, language, **kwargs):
        """使用最新配置分析"""
        return self.analyzer_engine.analyze(text, language, **kwargs)

# 使用
analyzer = DynamicAnalyzerEngine("config/recognizers.yaml")
results = analyzer.analyze("...", "zh")

# 配置文件更新后
analyzer.reload_config()  # 热更新,无需重启服务

最后

我主要是为了探索这种三层架构+上下文增强+置信度模型的有效性,并没有考虑规模化,DLP 等

https://github.com/nn0nkey/MingJing