feat: dual-model routing + fallback strategy (v3.0)

Models
EN/AR → urchade/gliner_multi-v2.1 (GLiNER zero-shot, ~1 GB, ~500 ms)
ZH → shibing624/bert4ner-base-chinese (BERT NER, ~400 MB, ~100 ms)
mixed → both models run in parallel, results merged + deduplicated

Language detection (app/ner.py)
Layer-1 Unicode script ratio (CJK / Arabic / Latin)
mixed = cjk>=8% AND latin>=10% (prevents dominant-CJK from
masking bilingual text)
Layer-2 langdetect n-gram fallback when Layer-1 returns 'en'

Fallback / merge (NERService.extract)
zh primary=BERT, fallback=GLiNER when entities==0
en/ar primary=GLiNER, fallback=BERT when entities==0
mixed run both, _deduplicate keeps highest-score per (start,end) span

Other changes
app/config.py EN_MODEL_NAME / ZH_MODEL_NAME env vars; legacy MODEL_NAME kept
app/labels.py BERT_TYPE_TO_LABEL, LABEL_TO_BERT_TYPES, labels_to_bert_types()
requirements.txt add transformers>=4.40.0, langdetect>=1.0.9
Dockerfile pre-download both models at build time
tests 38 tests (was 25); cover fallback, merge, dedup, lang-detect

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.env.example

@@ -1,6 +1,12 @@
-MODEL_NAME=knowledgator/gliner-multitask-large-v0.5
+# 英文 / 阿拉伯文 / 混合文本模型（GLiNER 零样本，~1GB）
+EN_MODEL_NAME=urchade/gliner_multi-v2.1
+
+# 中文专用模型（BERT NER，~400MB，快速）
+ZH_MODEL_NAME=shibing624/bert4ner-base-chinese
+
 MODEL_CACHE_DIR=./model_cache
 HOST=0.0.0.0
 PORT=4000
+
 # 国内环境取消注释；HF Spaces 上留空
 # HF_ENDPOINT=https://hf-mirror.com

Dockerfile

@@ -5,11 +5,19 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Pre-download model at build time so cold-start needs no network access.
-# The image will be ~1.5 GB but startup is instant.
+# ── 构建时预下载两个模型，冷启动无需联网 ──────────────────────────────────────
+# EN / AR 模型：GLiNER 零样本多语言（~1 GB）
 RUN python -c "\
 from gliner import GLiNER; \
-GLiNER.from_pretrained('knowledgator/gliner-multitask-large-v0.5', cache_dir='/app/model_cache')"
+GLiNER.from_pretrained('urchade/gliner_multi-v2.1', cache_dir='/app/model_cache')"
+
+# ZH 模型：BERT 专用中文 NER（~400 MB）
+RUN python -c "\
+from transformers import pipeline; \
+pipeline('token-classification', \
+         model='shibing624/bert4ner-base-chinese', \
+         model_kwargs={'cache_dir': '/app/model_cache'}, \
+         aggregation_strategy='simple')"
 
 COPY app/ app/
 COPY run.py .
@@ -17,6 +25,8 @@ COPY run.py .
 ENV HOST=0.0.0.0
 ENV PORT=7860
 ENV MODEL_CACHE_DIR=/app/model_cache
+ENV EN_MODEL_NAME=urchade/gliner_multi-v2.1
+ENV ZH_MODEL_NAME=shibing624/bert4ner-base-chinese
 
 EXPOSE 7860
 

app/config.py

@@ -1,12 +1,22 @@
 import os
 
-MODEL_NAME: str = os.getenv("MODEL_NAME", "knowledgator/gliner-multitask-large-v0.5")
+# ── 模型配置 ──────────────────────────────────────────────────────────────────
+# 英文 / 阿拉伯文 / 混合：轻量 GLiNER 零样本模型
+EN_MODEL_NAME: str = os.getenv("EN_MODEL_NAME", "urchade/gliner_multi-v2.1")
+
+# 中文：专用 BERT NER 模型（400MB，~100ms/次，4 种固定实体类型）
+ZH_MODEL_NAME: str = os.getenv("ZH_MODEL_NAME", "shibing624/bert4ner-base-chinese")
+
+# 兼容旧版环境变量（若设置 MODEL_NAME，则覆盖 EN_MODEL_NAME）
+_legacy = os.getenv("MODEL_NAME")
+if _legacy:
+    EN_MODEL_NAME = _legacy
+
 MODEL_CACHE_DIR: str = os.getenv("MODEL_CACHE_DIR", "./model_cache")
 HOST: str = os.getenv("HOST", "0.0.0.0")
 PORT: int = int(os.getenv("PORT", "4000"))
 
-# Only override HF_ENDPOINT when explicitly set (local mirror) so HF Spaces
-# can reach huggingface.co directly without forcing the mirror.
+# 可选：国内镜像（留空则使用 huggingface.co）
 _hf_endpoint = os.getenv("HF_ENDPOINT")
 if _hf_endpoint:
     os.environ["HF_ENDPOINT"] = _hf_endpoint

app/labels.py

@@ -1,30 +1,32 @@
 """
 双语标签管理模块
-────────────────
-* DEFAULT_LABELS   — 内置通用双语标签集（labels 为空时使用）
-* expand_bilingual — 自动为已有标签补充对等的另一语言版本
+────────────────────────────────────────────────────────────────
+* DEFAULT_LABELS       — 内置通用双语标签集（labels 为空时使用）
+* expand_bilingual     — 自动为已有标签补充对等的另一语言版本
+* BERT_TYPE_TO_LABEL   — 中文 BERT 模型固定实体类型 → 标准双语标签
+* LABEL_TO_BERT_TYPES  — 标准标签 → 对应 BERT 实体类型列表（用于过滤）
 """
 
-# 英文 ↔ 中文 对照表（顺序决定输出标签的语言偏好）
+# ── 英中对照表 ─────────────────────────────────────────────────────────────────
 _PAIRS: list[tuple[str, str]] = [
-    ("full name of a person",             "人名或姓名"),
-    ("company or organization name",      "公司或组织机构名称"),
-    ("geographical location",             "地名或城市"),
-    ("product or technology name",        "产品或技术名称"),
-    ("date or year",                      "日期或年份"),
-    ("hospital or medical institution",   "医院或医疗机构名称"),
-    ("university or research institution","大学或研究机构"),
-    ("project or initiative name",        "项目或计划名称"),
-    ("legislation or policy name",        "法规或政策名称"),
-    ("monetary amount",                   "金额或货币"),
-    ("job title or position",             "职位或头衔"),
-    ("event name",                        "事件或活动名称"),
+    ("full name of a person",              "人名或姓名"),
+    ("company or organization name",       "公司或组织机构名称"),
+    ("geographical location",              "地名或城市"),
+    ("product or technology name",         "产品或技术名称"),
+    ("date or year",                       "日期或年份"),
+    ("hospital or medical institution",    "医院或医疗机构名称"),
+    ("university or research institution", "大学或研究机构"),
+    ("project or initiative name",         "项目或计划名称"),
+    ("legislation or policy name",         "法规或政策名称"),
+    ("monetary amount",                    "金额或货币"),
+    ("job title or position",              "职位或头衔"),
+    ("event name",                         "事件或活动名称"),
 ]
 
-# 默认标签集：英中并列，涵盖最常用实体类型
+# 默认标签集：英中并列
 DEFAULT_LABELS: list[str] = [item for pair in _PAIRS for item in pair]
 
-# 快速查找：任意一种语言的标签 → 对等标签
+# 快速查找
 _EN_TO_ZH: dict[str, str] = {en: zh for en, zh in _PAIRS}
 _ZH_TO_EN: dict[str, str] = {zh: en for en, zh in _PAIRS}
 
@@ -32,16 +34,7 @@ _ZH_TO_EN: dict[str, str] = {zh: en for en, zh in _PAIRS}
 def expand_bilingual(labels: list[str]) -> list[str]:
     """
     为调用者传入的标签自动补充另一语言的对等描述。
-
-    例如：
-        ["人名或姓名", "company or organization name"]
-        →  ["人名或姓名", "full name of a person",
-            "company or organization name", "公司或组织机构名称"]
-
-    规则：
-    * 已有标签保持原位不变
-    * 对等标签紧随其后插入（若已存在则跳过）
-    * 未在对照表中的自定义标签原样保留，不做处理
+    已有标签保持原位不变，对等标签紧随其后插入（若已存在则跳过）。
     """
     seen: set[str] = set(labels)
     result: list[str] = []
@@ -52,3 +45,49 @@ def expand_bilingual(labels: list[str]) -> list[str]:
             result.append(counterpart)
             seen.add(counterpart)
     return result
+
+
+# ── 中文 BERT NER 固定类型映射 ────────────────────────────────────────────────
+# shibing624/bert4ner-base-chinese 输出的实体类型
+BERT_TYPE_TO_LABEL: dict[str, str] = {
+    "PER":  "人名或姓名",
+    "LOC":  "地名或城市",
+    "ORG":  "公司或组织机构名称",
+    "TIME": "日期或年份",
+    "GPE":  "地名或城市",    # 部分模型区分 GPE（地缘政治实体）
+}
+
+# 标准标签 → BERT 类型列表（用于用户自定义标签过滤）
+LABEL_TO_BERT_TYPES: dict[str, list[str]] = {
+    # 人名
+    "人名或姓名":                   ["PER"],
+    "full name of a person":        ["PER"],
+    # 地名
+    "地名或城市":                   ["LOC", "GPE"],
+    "geographical location":        ["LOC", "GPE"],
+    # 机构
+    "公司或组织机构名称":           ["ORG"],
+    "company or organization name": ["ORG"],
+    "医院或医疗机构名称":           ["ORG"],
+    "hospital or medical institution": ["ORG"],
+    "大学或研究机构":               ["ORG"],
+    "university or research institution": ["ORG"],
+    # 时间
+    "日期或年份":                   ["TIME"],
+    "date or year":                 ["TIME"],
+}
+
+
+def labels_to_bert_types(labels: list[str]) -> set[str] | None:
+    """
+    将用户标签列表转换为 BERT 实体类型集合。
+    返回 None 表示"接受所有类型"（labels 为空或无法映射时）。
+    """
+    if not labels:
+        return None   # 无限制，返回全部
+    types: set[str] = set()
+    for lbl in labels:
+        mapped = LABEL_TO_BERT_TYPES.get(lbl)
+        if mapped:
+            types.update(mapped)
+    return types if types else None  # 无映射 → 不过滤

app/main.py

@@ -3,7 +3,7 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from app.config import MODEL_CACHE_DIR, MODEL_NAME
+from app.config import EN_MODEL_NAME, MODEL_CACHE_DIR, ZH_MODEL_NAME
 from app.logger import get_logger
 from app.models import ExtractRequest, ExtractResponse
 from app.ner import NERService
@@ -15,9 +15,14 @@ ner_service: NERService | None = None
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global ner_service
-    logger.info("Loading model: %s (cache_dir=%s)", MODEL_NAME, MODEL_CACHE_DIR)
-    ner_service = NERService(MODEL_NAME, MODEL_CACHE_DIR)
-    logger.info("Model ready")
+    logger.info(
+        "Initializing NER service | en_model=%s zh_model=%s cache=%s",
+        EN_MODEL_NAME, ZH_MODEL_NAME, MODEL_CACHE_DIR,
+    )
+    ner_service = NERService(EN_MODEL_NAME, ZH_MODEL_NAME, MODEL_CACHE_DIR)
+    # 预热：启动时同时加载两个模型，首个请求无需等待
+    ner_service.warmup()
+    logger.info("NER service ready")
     yield
     ner_service = None
 
@@ -25,11 +30,12 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="NER API",
     description=(
-        "Zero-shot Named Entity Recognition powered by GLiNER. "
-        "Supports English, Chinese, Arabic and mixed-language text. "
+        "Zero-shot Named Entity Recognition powered by GLiNER (EN/AR) "
+        "and BERT-Chinese (ZH). "
+        "Supports English · Chinese · Arabic · mixed-language text. "
         "Labels are optional — omit them to use built-in bilingual defaults."
     ),
-    version="2.0.0",
+    version="3.0.0",
     lifespan=lifespan,
 )
 
@@ -58,9 +64,9 @@ def extract(req: ExtractRequest):
     elapsed_ms = (time.perf_counter() - t0) * 1000
 
     logger.info(
-        "extract response | entities=%d elapsed=%.1fms labels_used=%d",
+        "extract response | entities=%d elapsed=%.1fms language=%s",
         len(entities),
         elapsed_ms,
-        len(labels_used),
+        req.language,
     )
     return ExtractResponse(entities=entities, labels_used=labels_used)

app/ner.py

@@ -1,45 +1,108 @@
+"""
+NER 服务层 — 双模型路由 + 兜底策略
+──────────────────────────────────────────────────────────────────────────────
+语言检测（两层）：
+  1. Unicode 脚本比例：快速，适合中文 / 阿拉伯文等脚本明显的语言
+  2. langdetect 库兜底：覆盖纯英文及边界文本
+
+路由 & 兜底规则：
+  ┌──────────┬──────────────────┬──────────────────────────────┐
+  │ language │ 主模型           │ 兜底条件                     │
+  ├──────────┼──────────────────┼──────────────────────────────┤
+  │ zh       │ ChineseBERT      │ 实体数=0 → 补充 GLiNER 结果  │
+  │ en / ar  │ GLiNER           │ 实体数=0 → 补充 BERT 结果    │
+  │ mixed    │ GLiNER + BERT    │ 同时运行两个模型，结果合并   │
+  │ auto     │ 先检测语言再路由 │                              │
+  └──────────┴──────────────────┴──────────────────────────────┘
+"""
+
+import threading
 import unicodedata
+from abc import ABC, abstractmethod
 
 from gliner import GLiNER
 
-from app.labels import DEFAULT_LABELS, expand_bilingual
+from app.labels import (
+    DEFAULT_LABELS,
+    BERT_TYPE_TO_LABEL,
+    expand_bilingual,
+    labels_to_bert_types,
+)
 from app.models import Entity
 
 
 # ── 语言检测 ──────────────────────────────────────────────────────────────────
+#
+# 两层策略：
+#   Layer-1  Unicode 脚本比例
+#     · 遍历文本中所有字母字符，统计 CJK / Arabic 脚本占比
+#     · 优点：零依赖、极快；缺点：对极短或纯拉丁文本判断力弱
+#
+#   Layer-2  langdetect（仅 Layer-1 返回 'en' 时作为校验）
+#     · 基于 n-gram 概率模型，原理同 Google CLD2
+#     · 对短文本（<20 字）仍有一定误判率，以 Layer-1 为主
+#     · 若 langdetect 检测到中文/日文/韩文 → 返回 'zh'
+#     · 失败时静默回退到 Layer-1 结果
 
-def _detect_language(text: str) -> str:
-    """
-    通过 Unicode 脚本比例判断文本语言。
-    返回: 'zh' | 'ar' | 'mixed' | 'en'
-    """
-    if not text:
-        return "en"
-
+def _unicode_script_ratio(text: str) -> str:
+    """Layer-1：基于 Unicode 脚本比例的语言分类。"""
     cjk = arabic = letters = 0
     for ch in text:
-        cat = unicodedata.category(ch)
-        if cat.startswith("L"):
-            letters += 1
-            cp = ord(ch)
-            if (0x4E00 <= cp <= 0x9FFF or   # CJK Unified
-                    0x3400 <= cp <= 0x4DBF or
-                    0xF900 <= cp <= 0xFAFF or
-                    0x20000 <= cp <= 0x2A6DF):
-                cjk += 1
-            elif 0x0600 <= cp <= 0x06FF or 0x0750 <= cp <= 0x077F:
-                arabic += 1
-
+        if not unicodedata.category(ch).startswith("L"):
+            continue
+        letters += 1
+        cp = ord(ch)
+        if (0x4E00 <= cp <= 0x9FFF or 0x3400 <= cp <= 0x4DBF or
+                0xF900 <= cp <= 0xFAFF or 0x20000 <= cp <= 0x2A6DF):
+            cjk += 1
+        elif 0x0600 <= cp <= 0x06FF or 0x0750 <= cp <= 0x077F:
+            arabic += 1
     if not letters:
         return "en"
     cjk_r = cjk / letters
     ar_r  = arabic / letters
-    if cjk_r >= 0.20 and ar_r < 0.08:
+    latin_r = (letters - cjk - arabic) / letters
+
+    # 中文+拉丁都显著 → mixed（优先级高于单纯 zh 判断）
+    if cjk_r >= 0.08 and latin_r >= 0.10:
+        return "mixed"
+    # 阿拉伯+拉丁都显著 → mixed
+    if ar_r >= 0.08 and latin_r >= 0.10:
+        return "mixed"
+    # 单脚本主导
+    if cjk_r >= 0.20:
         return "zh"
-    if ar_r >= 0.20 and cjk_r < 0.08:
+    if ar_r >= 0.20:
         return "ar"
-    if cjk_r >= 0.08 or ar_r >= 0.08:
-        return "mixed"
+    return "en"
+
+
+def detect_language(text: str) -> str:
+    """
+    两层语言检测，返回 'zh' | 'ar' | 'mixed' | 'en'。
+
+    Layer-1 优先（Unicode 脚本比例）；Layer-1 返回 'en' 时，
+    用 langdetect 做一次二次确认，防止把中文误判为英文。
+    """
+    if not text:
+        return "en"
+
+    layer1 = _unicode_script_ratio(text)
+    if layer1 != "en":          # 已明确是非英文，直接返回
+        return layer1
+
+    # Layer-2：langdetect 校验（仅对 Layer-1='en' 的文本）
+    try:
+        from langdetect import detect, DetectorFactory
+        DetectorFactory.seed = 0    # 保证结果���定
+        lang_code = detect(text)    # e.g. 'zh-cn', 'ar', 'en', 'ja' …
+        if lang_code.startswith("zh") or lang_code in ("ja", "ko"):
+            return "zh"
+        if lang_code == "ar":
+            return "ar"
+    except Exception:
+        pass                        # langdetect 失败时静默回退
+
     return "en"
 
 
@@ -47,8 +110,8 @@ def _detect_language(text: str) -> str:
 
 def _deduplicate(entities: list[Entity]) -> list[Entity]:
     """
-    双语标签可能对同一 (start, end) 跨度产生两条结果，
-    保留置信度最高的那条，并按位置排序。
+    双语标签或模型合并时可能产生同一 (start, end) 的重复结果，
+    保留置信度最高的那条，并按起始位置排序。
     """
     best: dict[tuple[int, int], Entity] = {}
     for e in entities:
@@ -58,12 +121,155 @@ def _deduplicate(entities: list[Entity]) -> list[Entity]:
     return sorted(best.values(), key=lambda x: x.start)
 
 
-# ── NER 服务 ──────────────────────────────────────────────────────────────────
+# ── 后端基类 ──────────────────────────────────────────────────────────────────
+
+class _Backend(ABC):
+    @abstractmethod
+    def predict(
+        self, text: str, labels: list[str], threshold: float
+    ) -> tuple[list[Entity], list[str]]:
+        """返回 (entities, labels_used)"""
+
+
+# ── GLiNER 后端（英文 / 阿拉伯文 / 混合） ─────────────────────────────────────
+
+class GLiNERBackend(_Backend):
+    """
+    零样本 NER：urchade/gliner_multi-v2.1
+    • 支持英文、阿拉伯文及混合文本
+    • 自动做双语标签扩展，提升召回率
+    """
 
-class NERService:
     def __init__(self, model_name: str, cache_dir: str) -> None:
         self._model = GLiNER.from_pretrained(model_name, cache_dir=cache_dir)
 
+    def predict(
+        self, text: str, labels: list[str], threshold: float
+    ) -> tuple[list[Entity], list[str]]:
+        eff_labels = expand_bilingual(labels) if labels else DEFAULT_LABELS
+        raw = self._model.predict_entities(text, eff_labels, threshold=threshold)
+        entities = [
+            Entity(
+                text=e["text"],
+                label=e["label"],
+                score=round(e["score"], 4),
+                start=e["start"],
+                end=e["end"],
+            )
+            for e in raw
+        ]
+        return _deduplicate(entities), eff_labels
+
+
+# ── 中文 BERT 后端 ─────────────────────────────────────────────────────────────
+
+class ChineseBERTBackend(_Backend):
+    """
+    专用中文 NER：shibing624/bert4ner-base-chinese
+    • 模型大小：~400 MB（BERT-base）
+    • 推理速度：~100 ms
+    • 固定实体类型：PER / LOC / ORG / TIME → 映射为双语标签
+    • 用户传入标签时按标签类型过滤；无法映射的自定义标签不过滤（返回全部）
+    """
+
+    def __init__(self, model_name: str, cache_dir: str) -> None:
+        # 延迟导入：避免顶层 import 在测试收集阶段触发 torch.__spec__ 检测
+        from transformers import pipeline as hf_pipeline
+        self._pipe = hf_pipeline(
+            "token-classification",
+            model=model_name,
+            model_kwargs={"cache_dir": cache_dir},
+            aggregation_strategy="simple",
+        )
+
+    def predict(
+        self, text: str, labels: list[str], threshold: float
+    ) -> tuple[list[Entity], list[str]]:
+        raw = self._pipe(text)
+        allowed_types = labels_to_bert_types(labels)   # None = 不过滤
+
+        entities: list[Entity] = []
+        labels_seen: set[str] = set()
+
+        for r in raw:
+            score = float(r["score"])
+            if score < threshold:
+                continue
+
+            bert_type = r.get("entity_group", r.get("entity", ""))
+            bert_type = bert_type.lstrip("BI-").strip()  # 去掉可能的 B-/I- 前缀
+
+            if allowed_types is not None and bert_type not in allowed_types:
+                continue
+
+            std_label = BERT_TYPE_TO_LABEL.get(bert_type, bert_type)
+            labels_seen.add(std_label)
+            entities.append(Entity(
+                text=r["word"],
+                label=std_label,
+                score=round(score, 4),
+                start=r["start"],
+                end=r["end"],
+            ))
+
+        used = list(labels_seen) if labels_seen else list(BERT_TYPE_TO_LABEL.values())
+        return entities, used
+
+
+# ── NER 服务（路由 + 兜底） ─────────────────────────────���──────────────────────
+
+class NERService:
+    """
+    持有两个后端，按检测到的语言分发请求。
+
+    兜底规则（召回为空时）：
+      zh   主模型 BERT 无结果 → 用 GLiNER 补充
+      en/ar 主模型 GLiNER 无结果 → 用 BERT 补充
+      mixed 同时运行两个模型，合并去重后返回
+    """
+
+    def __init__(self, en_model_name: str, zh_model_name: str, cache_dir: str) -> None:
+        self._en_name = en_model_name
+        self._zh_name = zh_model_name
+        self._cache_dir = cache_dir
+
+        self._en_backend: GLiNERBackend | None = None
+        self._zh_backend: ChineseBERTBackend | None = None
+        self._en_lock = threading.Lock()
+        self._zh_lock = threading.Lock()
+
+    # ── 懒加载 ────────────────────────────────────────────────────────────────
+
+    def _en(self) -> GLiNERBackend:
+        if self._en_backend is None:
+            with self._en_lock:
+                if self._en_backend is None:
+                    self._en_backend = GLiNERBackend(self._en_name, self._cache_dir)
+        return self._en_backend
+
+    def _zh(self) -> ChineseBERTBackend:
+        if self._zh_backend is None:
+            with self._zh_lock:
+                if self._zh_backend is None:
+                    self._zh_backend = ChineseBERTBackend(self._zh_name, self._cache_dir)
+        return self._zh_backend
+
+    # ── 兜底合并 ──────────────────────────────────────────────────────────────
+
+    def _merge(
+        self,
+        primary: tuple[list[Entity], list[str]],
+        fallback: tuple[list[Entity], list[str]],
+    ) -> tuple[list[Entity], list[str]]:
+        """合并两个模型的结果，去重后按位置排序。"""
+        p_ents, p_labels = primary
+        f_ents, f_labels = fallback
+        merged = _deduplicate(p_ents + f_ents)
+        used = list(dict.fromkeys(p_labels + f_labels))  # 保序去重
+        return merged, used
+
+    # ── 主入口 ────────────────────────────────────────────────────────────────
+
     def extract(
         self,
         text: str,
@@ -74,35 +280,40 @@ class NERService:
         """
         返回 (entities, labels_used)。
 
-        labels 处理逻辑：
-          1. labels 为空 → 使用内置双语默认标签集
-          2. labels 非空 → 自动补充双语对等标签（提升中文召回）
-
-        threshold 处理逻辑：
-          - language='auto' 时自动检测
-          - 中文 / 混合文本若传入默认 threshold(0.4) 则不调整（已足够低）
+        路由逻辑：
+          auto  → 检测语言 → 路由
+          zh    → BERT 主，GLiNER 兜底（主模型无结果时补充）
+          en/ar → GLiNER 主，BERT 兜底（主模型无结果时补充）
+          mixed → 两模型同时运行，结果合并去重
         """
         if not text:
             return [], labels
 
-        # 确定有效语言
-        eff_lang = language if language != "auto" else _detect_language(text)
+        lang = language if language != "auto" else detect_language(text)
 
-        # 确定标签集
-        if not labels:
-            eff_labels = DEFAULT_LABELS
-        else:
-            eff_labels = expand_bilingual(labels)
+        if lang == "mixed":
+            # 同时运行两个模型，合并结果
+            en_result = self._en().predict(text, labels, threshold)
+            zh_result = self._zh().predict(text, labels, threshold)
+            return self._merge(en_result, zh_result)
 
-        raw = self._model.predict_entities(text, eff_labels, threshold=threshold)
-        entities = [
-            Entity(
-                text=e["text"],
-                label=e["label"],
-                score=round(e["score"], 4),
-                start=e["start"],
-                end=e["end"],
-            )
-            for e in raw
-        ]
-        return _deduplicate(entities), eff_labels
+        if lang == "zh":
+            primary_result = self._zh().predict(text, labels, threshold)
+            if not primary_result[0]:       # 主模型无结果 → GLiNER 兜底
+                fallback_result = self._en().predict(text, labels, threshold)
+                if fallback_result[0]:
+                    return fallback_result
+            return primary_result
+
+        # en / ar / 其他
+        primary_result = self._en().predict(text, labels, threshold)
+        if not primary_result[0]:           # 主模型无结果 → BERT 兜底
+            fallback_result = self._zh().predict(text, labels, threshold)
+            if fallback_result[0]:
+                return fallback_result
+        return primary_result
+
+    def warmup(self) -> None:
+        """启动时预热两个模型，首个请求无需等待。"""
+        self._en()
+        self._zh()

requirements.txt

@@ -1,3 +1,5 @@
 fastapi>=0.111.0
 uvicorn[standard]>=0.29.0
 gliner>=0.2.0
+transformers>=4.40.0
+langdetect>=1.0.9

tests/test_extract.py

@@ -1,27 +1,39 @@
 """
-Unit tests — no real model loaded (GLiNER/torch stubbed in conftest.py).
+Unit tests — no real model loaded (GLiNER/torch stubbed via conftest.py).
 Covers:
-  - API contract (health, validation, threshold forwarding)
-  - New v2 features: optional labels, bilingual expansion, labels_used echo
-  - English / Chinese / Arabic / mixed-language text handling
+  - API contract (health, validation, threshold, language field)
+  - Dual-model routing (ZH → BERT backend, EN/AR/mixed → GLiNER backend)
+  - Optional labels + bilingual auto-expansion
+  - English / Chinese / Arabic / mixed-language scenarios
+  - labels_used echo in response
 """
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, patch, PropertyMock
 
 import pytest
 from fastapi.testclient import TestClient
 
-import app.main as main_module
 from app.main import app
 from app.models import Entity
-from app.labels import DEFAULT_LABELS, expand_bilingual
+from app.labels import DEFAULT_LABELS, expand_bilingual, labels_to_bert_types
+from app.ner import detect_language
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _ents(*args: Entity) -> tuple[list[Entity], list[str]]:
+    """Wrap entities in (entities, labels_used) tuple expected by NERService."""
+    return list(args), [e.label for e in args]
 
 
 # ── Fixture ───────────────────────────────────────────────────────────────────
 
 @pytest.fixture()
 def client():
+    """
+    Patch NERService so no model is actually loaded.
+    mock_ner.extract() returns ([], []) by default.
+    """
     mock_ner = MagicMock()
-    # Default: extract() returns ([], [])
     mock_ner.extract.return_value = ([], [])
     with pytest.MonkeyPatch().context() as mp:
         mp.setattr("app.main.NERService", lambda *_: mock_ner)
@@ -29,61 +41,49 @@ def client():
             yield c, mock_ner
 
 
-def _ents(*args) -> tuple[list[Entity], list[str]]:
-    """Helper: wrap Entity list in the (entities, labels_used) tuple."""
-    entities = list(args)
-    labels = [e.label for e in entities]
-    return entities, labels
-
-
 # ── System / API contract ─────────────────────────────────────────────────────
 
 def test_health(client):
     c, _ = client
-    resp = c.get("/api/v1/health")
-    assert resp.status_code == 200
-    assert resp.json() == {"status": "ok"}
+    assert c.get("/api/v1/health").json() == {"status": "ok"}
 
 
-def test_extract_empty_text(client):
-    c, mock_ner = client
+def test_extract_empty_text_returns_empty(client):
+    c, _ = client
     resp = c.post("/api/v1/extract", json={"text": "", "labels": ["person"]})
     assert resp.status_code == 200
     assert resp.json()["entities"] == []
 
 
-def test_extract_empty_labels_uses_defaults(client):
-    """labels 为空时服务端应自动使用默认双语标签集，不报错。"""
+def test_extract_labels_optional(client):
+    """labels 字段完全不传应正常返回 200。"""
     c, mock_ner = client
     mock_ner.extract.return_value = ([], DEFAULT_LABELS)
-    resp = c.post("/api/v1/extract", json={"text": "Apple Inc. is in Cupertino."})
+    resp = c.post("/api/v1/extract", json={"text": "Some text."})
     assert resp.status_code == 200
-    data = resp.json()
-    assert "entities" in data
-    assert "labels_used" in data
-    assert len(data["labels_used"]) > 0
+    assert len(resp.json()["labels_used"]) > 0
 
 
-def test_extract_omit_labels_entirely(client):
-    """labels 字段完全不传也应该正常工作。"""
+def test_extract_empty_labels_uses_defaults(client):
+    """labels=[] 时应使用默认双语标签集。"""
     c, mock_ner = client
     mock_ner.extract.return_value = ([], DEFAULT_LABELS)
-    resp = c.post("/api/v1/extract", json={"text": "Some text."})
+    resp = c.post("/api/v1/extract", json={"text": "Hello world.", "labels": []})
     assert resp.status_code == 200
+    assert resp.json()["labels_used"] == DEFAULT_LABELS
 
 
 def test_extract_threshold_forwarded(client):
     c, mock_ner = client
     c.post("/api/v1/extract",
-           json={"text": "Hello world", "labels": ["person"], "threshold": 0.8})
-    mock_ner.extract.assert_called_once_with("Hello world", ["person"], 0.8, language="auto")
+           json={"text": "Hello", "labels": ["person"], "threshold": 0.8})
+    mock_ner.extract.assert_called_once_with("Hello", ["person"], 0.8, language="auto")
 
 
 def test_extract_invalid_threshold(client):
     c, _ = client
-    resp = c.post("/api/v1/extract",
-                  json={"text": "Hello", "labels": ["person"], "threshold": 1.5})
-    assert resp.status_code == 422
+    assert c.post("/api/v1/extract",
+                  json={"text": "x", "threshold": 1.5}).status_code == 422
 
 
 def test_extract_language_field_forwarded(client):
@@ -94,86 +94,117 @@ def test_extract_language_field_forwarded(client):
 
 
 def test_extract_invalid_language(client):
-    """不支持的 language 值应返回 422。"""
     c, _ = client
-    resp = c.post("/api/v1/extract",
-                  json={"text": "Hello", "language": "jp"})
-    assert resp.status_code == 422
+    assert c.post("/api/v1/extract",
+                  json={"text": "x", "language": "jp"}).status_code == 422
+
+
+def test_labels_used_echoed(client):
+    c, mock_ner = client
+    used = ["人名或姓名", "地名或城市"]
+    mock_ner.extract.return_value = ([], used)
+    resp = c.post("/api/v1/extract", json={"text": "马云在杭州。", "labels": ["人名或姓名"]})
+    assert resp.json()["labels_used"] == used
 
 
 def test_entity_response_fields(client):
-    """每个实体包含全部必填字段且值合法。"""
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
         Entity(text="Apple", label="organization", score=0.95, start=0, end=5)
     )
     resp = c.post("/api/v1/extract",
                   json={"text": "Apple is great.", "labels": ["organization"]})
-    assert resp.status_code == 200
     e = resp.json()["entities"][0]
-    assert set(e.keys()) >= {"text", "label", "score", "start", "end"}
+    assert {"text", "label", "score", "start", "end"} <= e.keys()
     assert 0.0 <= e["score"] <= 1.0
     assert e["start"] < e["end"]
 
 
-def test_labels_used_echoed(client):
-    """响应中 labels_used 应回传实际使用的标签列表。"""
-    c, mock_ner = client
-    used = ["person", "organization"]
-    mock_ner.extract.return_value = ([], used)
-    resp = c.post("/api/v1/extract",
-                  json={"text": "Elon Musk works at Tesla.", "labels": ["person"]})
-    assert resp.status_code == 200
-    assert resp.json()["labels_used"] == used
+# ── Language detection ────────────────────────────────────────────────────────
+
+def test_detect_language_english():
+    assert detect_language("Elon Musk founded SpaceX in California.") == "en"
+
+
+def test_detect_language_chinese():
+    assert detect_language("阿里巴巴集团创始人马云于杭州卸任。") == "zh"
+
+
+def test_detect_language_arabic():
+    assert detect_language("أعلن الرئيس محمد بن سلمان عن مشروع نيوم.") == "ar"
+
+
+def test_detect_language_mixed():
+    assert detect_language("张伟加入了 Google 北京研发中心，负责 Android 优化。") == "mixed"
+
+
+def test_detect_language_empty():
+    assert detect_language("") == "en"
 
 
-# ── Bilingual label expansion (unit-level, no HTTP) ───────────────────────────
+# ── Bilingual label expansion ─────────────────────────────────────────────────
 
 def test_expand_bilingual_adds_english_for_chinese():
     result = expand_bilingual(["人名或姓名"])
-    assert "人名或姓名" in result
     assert "full name of a person" in result
 
 
 def test_expand_bilingual_adds_chinese_for_english():
     result = expand_bilingual(["company or organization name"])
-    assert "company or organization name" in result
     assert "公司或组织机构名称" in result
 
 
 def test_expand_bilingual_no_duplicate():
-    labels = ["人名或姓名", "full name of a person"]
-    result = expand_bilingual(labels)
+    result = expand_bilingual(["人名或姓名", "full name of a person"])
     assert result.count("人名或姓名") == 1
     assert result.count("full name of a person") == 1
 
 
 def test_expand_bilingual_custom_label_preserved():
-    """自定义标签（不在对照表中）原样保留。"""
     result = expand_bilingual(["my custom label"])
     assert "my custom label" in result
 
 
-def test_default_labels_nonempty():
-    assert len(DEFAULT_LABELS) > 0
-    # 必须包含中英文各至少一个
+def test_default_labels_bilingual():
     has_en = any(all(ord(c) < 128 for c in lbl) for lbl in DEFAULT_LABELS)
     has_zh = any(any('一' <= c <= '鿿' for c in lbl) for lbl in DEFAULT_LABELS)
     assert has_en and has_zh
 
 
+# ── BERT label mapping ────────────────────────────────────────────────────────
+
+def test_labels_to_bert_types_chinese_label():
+    types = labels_to_bert_types(["人名或姓名"])
+    assert "PER" in types
+
+
+def test_labels_to_bert_types_english_label():
+    types = labels_to_bert_types(["geographical location"])
+    assert "LOC" in types
+
+
+def test_labels_to_bert_types_empty_returns_none():
+    assert labels_to_bert_types([]) is None
+
+
+def test_labels_to_bert_types_unmapped_returns_none():
+    # 无法映射的标签 → 不过滤（返回 None）
+    assert labels_to_bert_types(["some unknown label"]) is None
+
+
 # ── English ───────────────────────────────────────────────────────────────────
 
 def test_english_person_org(client):
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
-        Entity(text="Elon Musk",  label="person",       score=0.98, start=0,  end=9),
-        Entity(text="Tesla",      label="organization", score=0.96, start=18, end=23),
-        Entity(text="SpaceX",     label="organization", score=0.97, start=28, end=34),
+        Entity(text="Elon Musk", label="person",       score=0.98, start=0,  end=9),
+        Entity(text="Tesla",     label="organization", score=0.96, start=18, end=23),
+        Entity(text="SpaceX",    label="organization", score=0.97, start=28, end=34),
     )
     resp = c.post("/api/v1/extract",
                   json={"text": "Elon Musk is the CEO of Tesla and founded SpaceX.",
-                        "labels": ["full name of a person", "company or organization name"]})
+                        "labels": ["full name of a person", "company or organization name"],
+                        "language": "en"})
     assert resp.status_code == 200
     texts = {e["text"] for e in resp.json()["entities"]}
     assert {"Elon Musk", "Tesla", "SpaceX"} <= texts
@@ -188,28 +219,24 @@ def test_english_location_date(client):
     )
     resp = c.post("/api/v1/extract",
                   json={"text": "The summit was held in Paris in 2024, in France.",
-                        "labels": ["geographical location", "date or year"]})
-    assert resp.status_code == 200
+                        "labels": ["geographical location", "date or year"],
+                        "language": "en"})
     texts = {e["text"] for e in resp.json()["entities"]}
     assert {"Paris", "France", "2024"} <= texts
 
 
-def test_english_threshold_filters(client):
+def test_english_threshold_forwarded(client):
     c, mock_ner = client
-    mock_ner.extract.return_value = _ents(
-        Entity(text="NASA", label="organization", score=0.95, start=0, end=4),
-    )
-    resp = c.post("/api/v1/extract",
-                  json={"text": "NASA explored the Moon.",
-                        "labels": ["company or organization name"],
-                        "threshold": 0.8})
-    assert resp.status_code == 200
+    c.post("/api/v1/extract",
+           json={"text": "NASA explored the Moon.",
+                 "labels": ["company or organization name"],
+                 "threshold": 0.8, "language": "en"})
     mock_ner.extract.assert_called_once_with(
-        "NASA explored the Moon.", ["company or organization name"], 0.8, language="auto"
+        "NASA explored the Moon.", ["company or organization name"], 0.8, language="en"
     )
 
 
-# ── Chinese ───────────────────────────────────────────────────────────────────
+# ── Chinese (BERT backend) ────────────────────────────────────────────────────
 
 def test_chinese_person_org(client):
     c, mock_ner = client
@@ -222,13 +249,12 @@ def test_chinese_person_org(client):
                   json={"text": "阿里巴巴集团创始人马云卸任，由张勇接任。",
                         "labels": ["人名或姓名", "公司或组织机构名称"],
                         "language": "zh"})
-    assert resp.status_code == 200
     texts = {e["text"] for e in resp.json()["entities"]}
     assert {"马云", "张勇", "阿里巴巴"} <= texts
 
 
 def test_chinese_entity_boundary(client):
-    """实体边界不应包含动词 — '尤氏来请' 应只取 '尤氏'。"""
+    """BERT NER 应精确截断实体边界，不含动词。"""
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
         Entity(text="尤氏",   label="人名或姓名", score=0.82, start=0,  end=2),
@@ -236,8 +262,7 @@ def test_chinese_entity_boundary(client):
     )
     resp = c.post("/api/v1/extract",
                   json={"text": "尤氏来请，王熙凤笑道：'你来了。'",
-                        "labels": ["人名或姓名"]})
-    assert resp.status_code == 200
+                        "labels": ["人名或姓名"], "language": "zh"})
     texts = {e["text"] for e in resp.json()["entities"]}
     assert "尤氏"       in texts
     assert "王熙凤"     in texts
@@ -248,33 +273,42 @@ def test_chinese_entity_boundary(client):
 def test_chinese_location_product(client):
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
-        Entity(text="杭州",  label="地名或城市",    score=0.93, start=17, end=19),
-        Entity(text="淘宝",  label="产品或品牌名称", score=0.91, start=22, end=24),
-        Entity(text="天猫",  label="产品或品牌名称", score=0.92, start=25, end=27),
-        Entity(text="支付宝", label="产品或品牌名称", score=0.90, start=28, end=31),
+        Entity(text="杭州",  label="地名或城市",    score=0.93, start=9,  end=11),
+        Entity(text="淘宝",  label="产品或品牌名称", score=0.91, start=14, end=16),
+        Entity(text="天猫",  label="产品或品牌名称", score=0.92, start=17, end=19),
+        Entity(text="支付宝", label="产品或品牌名称", score=0.90, start=20, end=23),
     )
     resp = c.post("/api/v1/extract",
                   json={"text": "阿里巴巴总部位于杭州，旗下有淘宝、天猫、支付宝。",
-                        "labels": ["地名或城市", "产品或品牌名称"]})
-    assert resp.status_code == 200
+                        "labels": ["地名或城市", "产品或品牌名称"],
+                        "language": "zh"})
     texts = {e["text"] for e in resp.json()["entities"]}
     assert {"杭州", "淘宝", "天猫", "支付宝"} <= texts
 
 
+def test_chinese_auto_routes_to_zh(client):
+    """auto 检测到中文应路由到 ZH 模型（language 透传为 'auto'，内部检测为 zh）。"""
+    c, mock_ner = client
+    c.post("/api/v1/extract",
+           json={"text": "马云创立了阿里巴巴。"})
+    # NERService.extract 被调用时 language='auto'，路由逻辑在 ner.py 内部处理
+    mock_ner.extract.assert_called_once()
+    call_kwargs = mock_ner.extract.call_args
+    assert call_kwargs[1].get("language") == "auto" or call_kwargs[0][3] == "auto"
+
+
 # ── Arabic ────────────────────────────────────────────────────────────────────
 
 def test_arabic_person_location(client):
-    """阿拉伯语：识别人名与地名。"""
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
         Entity(text="محمد بن سلمان",           label="full name of a person", score=0.82, start=12, end=26),
         Entity(text="المملكة العربية السعودية", label="geographical location",  score=0.85, start=44, end=68),
     )
     resp = c.post("/api/v1/extract",
-                  json={"text": "أعلن الرئيس محمد بن سلمان عن مشروع نيوم في المملكة العربية السعودية.",
+                  json={"text": "أعلن الرئيس محمد بن سلمان مشروع نيوم في المملكة العربية السعودية.",
                         "labels": ["full name of a person", "geographical location"],
                         "language": "ar"})
-    assert resp.status_code == 200
     texts = {e["text"] for e in resp.json()["entities"]}
     assert "محمد بن سلمان"           in texts
     assert "المملكة العربية السعودية" in texts
@@ -295,29 +329,12 @@ def test_mixed_entities_both_scripts(client):
                         "labels": ["full name of a person", "人名或姓名",
                                    "company or organization name", "公司或组织机构名称",
                                    "geographical location", "地名或城市",
-                                   "product or technology name"]})
-    assert resp.status_code == 200
+                                   "product or technology name"],
+                        "language": "mixed"})
     texts = {e["text"] for e in resp.json()["entities"]}
     assert {"张伟", "Google", "北京", "Android"} <= texts
 
 
-def test_mixed_labels_chinese_and_english(client):
-    c, mock_ner = client
-    mock_ner.extract.return_value = _ents(
-        Entity(text="李明",  label="人名或姓名", score=0.94, start=0,  end=2),
-        Entity(text="Tesla", label="人名或姓名", score=0.96, start=10, end=15),
-        Entity(text="上海",  label="地名或城市", score=0.92, start=22, end=24),
-    )
-    resp = c.post("/api/v1/extract",
-                  json={"text": "李明在上海加入了 Tesla。",
-                        "labels": ["人名或姓名", "full name of a person",
-                                   "地名或城市", "geographical location",
-                                   "company or organization name"]})
-    assert resp.status_code == 200
-    texts = {e["text"] for e in resp.json()["entities"]}
-    assert {"李明", "Tesla", "上海"} <= texts
-
-
 def test_mixed_no_cross_language_contamination(client):
     c, mock_ner = client
     mock_ner.extract.return_value = _ents(
@@ -327,7 +344,108 @@ def test_mixed_no_cross_language_contamination(client):
     resp = c.post("/api/v1/extract",
                   json={"text": "他在 OpenAI 工作，同事王芳也在同一部门。",
                         "labels": ["person", "organization"]})
-    assert resp.status_code == 200
     entities = resp.json()["entities"]
     assert any(e["text"] == "OpenAI" and e["label"] == "organization" for e in entities)
     assert any(e["text"] == "王芳"   and e["label"] == "person"       for e in entities)
+
+
+# ── Fallback & merge (NERService unit tests, no HTTP) ────────────────────────
+
+def test_fallback_zh_empty_uses_en():
+    """ZH 主模型返回空时，应使用 GLiNER 兜底。"""
+    from app.ner import NERService
+
+    svc = NERService.__new__(NERService)
+    svc._en_lock = __import__("threading").Lock()
+    svc._zh_lock = __import__("threading").Lock()
+
+    # ZH backend: returns nothing
+    zh_mock = MagicMock()
+    zh_mock.predict.return_value = ([], [])
+    # EN fallback: returns one entity
+    en_mock = MagicMock()
+    en_mock.predict.return_value = _ents(
+        Entity(text="马云", label="person", score=0.75, start=0, end=2)
+    )
+    svc._zh_backend = zh_mock
+    svc._en_backend = en_mock
+
+    entities, _ = svc.extract("马云", [], 0.4, language="zh")
+    assert any(e.text == "马云" for e in entities)
+    zh_mock.predict.assert_called_once()
+    en_mock.predict.assert_called_once()   # 兜底被调用
+
+
+def test_fallback_zh_has_results_no_en_called():
+    """ZH 主模型有结果时，不应调用 GLiNER 兜底。"""
+    from app.ner import NERService
+
+    svc = NERService.__new__(NERService)
+    svc._en_lock = __import__("threading").Lock()
+    svc._zh_lock = __import__("threading").Lock()
+
+    zh_mock = MagicMock()
+    zh_mock.predict.return_value = _ents(
+        Entity(text="马云", label="person", score=0.92, start=0, end=2)
+    )
+    en_mock = MagicMock()
+    svc._zh_backend = zh_mock
+    svc._en_backend = en_mock
+
+    svc.extract("马云", [], 0.4, language="zh")
+    en_mock.predict.assert_not_called()   # 不应调用兜底
+
+
+def test_mixed_runs_both_models_and_merges():
+    """Mixed 语言应同时运行两个模型并合并结果。"""
+    from app.ner import NERService
+
+    svc = NERService.__new__(NERService)
+    svc._en_lock = __import__("threading").Lock()
+    svc._zh_lock = __import__("threading").Lock()
+
+    en_mock = MagicMock()
+    en_mock.predict.return_value = _ents(
+        Entity(text="Google", label="organization", score=0.95, start=5, end=11)
+    )
+    zh_mock = MagicMock()
+    zh_mock.predict.return_value = _ents(
+        Entity(text="张伟", label="person", score=0.91, start=0, end=2)
+    )
+    svc._en_backend = en_mock
+    svc._zh_backend = zh_mock
+
+    entities, _ = svc.extract("张伟加入 Google。", [], 0.4, language="mixed")
+    texts = {e.text for e in entities}
+    assert "Google" in texts
+    assert "张伟"   in texts
+    en_mock.predict.assert_called_once()
+    zh_mock.predict.assert_called_once()
+
+
+def test_mixed_deduplicates_overlapping_spans():
+    """两个模型对同一 span 都命中时，只保留得分最高的。"""
+    from app.ner import NERService
+
+    svc = NERService.__new__(NERService)
+    svc._en_lock = __import__("threading").Lock()
+    svc._zh_lock = __import__("threading").Lock()
+
+    en_mock = MagicMock()
+    en_mock.predict.return_value = (
+        [Entity(text="张伟", label="person", score=0.70, start=0, end=2)],
+        ["person"],
+    )
+    zh_mock = MagicMock()
+    zh_mock.predict.return_value = (
+        [Entity(text="张伟", label="人名或姓名", score=0.92, start=0, end=2)],
+        ["人名或姓名"],
+    )
+    svc._en_backend = en_mock
+    svc._zh_backend = zh_mock
+
+    entities, _ = svc.extract("张伟", [], 0.4, language="mixed")
+    # 去重后只有 1 个 "张伟"，且是得分更高的那条
+    zhang_wei = [e for e in entities if e.text == "张伟"]
+    assert len(zhang_wei) == 1
+    assert zhang_wei[0].score == 0.92