BroadRouter

Arabic named entity extraction gamit ang LLM: JSON, petsa at check

Ng BroadNet Inference team · 7 minutong basa · Nailathala

Hilingin sa model na kopyahin nang eksakto ang bawat entity, na may type mula sa nakapirming listahan, bilang JSON. I-check sa code ang bawat entity: dapat lumabas ito sa source kapag natanggal na ang diacritics at napag-isa ang mga anyo ng alef. I-convert ang Hijri na petsa gamit ang library gaya ng hijridate, hindi ang model. I-score ang isang sample na may label ng tao gamit ang entity-level precision, recall at F1.

Ginagawang record na magagamit ng code mo ng named entity extraction ang isang talata: sino, aling organisasyon, saan at kailan. Apat na problemang bihirang makita sa English na pipeline ang idinadagdag ng Arabic: opsyonal na diacritics, ilang spelling ng iisang letra, mga pangalang nakasulat sa Latin na letra (Arabizi), at mga petsa sa dalawang kalendaryo. Bumubuo ang post na ito ng extraction step sa isang OpenAI-compatible LLM na hinaharap ang bawat isa sa code, at ng scoring script na magsasabi sa iyo kung gumagana ito sa text mo.

Para sa pag-classify ng buong mensahe sa halip na pagkuha ng mga span mula rito, tingnan ang Arabic text classification. Para sa mismong mga opsyon ng JSON request, tingnan ang JSON mode vs json_schema.

Gaano kahusay ang mga LLM sa Arabic NER?

Ang pinakanauugnay na pampublikong sukat na nakita namin ay ang LAraBench (Abdelali et al., EACL 2024), na pinatakbo ang GPT-3.5 at GPT-4 sa mga Arabic NER set bilang token-by-token na tagging. Macro-F1, mas mataas ay mas mahusay:

Dataset GPT-3.5 zero-shot GPT-4 zero-shot GPT-4 3-shot Binanggit na fine-tuned system
ANERcorp (balita) 0.210 0.355 0.420 0.886
AQMAR (Wikipedia) 0.230 0.365 0.390 0.690
QASR (transcript) 0.208 0.504 n/a 0.698

Nakatulong ang mas maraming halimbawa: tumaas ang GPT-4 sa ANERcorp mula 0.355 nang walang halimbawa hanggang 0.451 na may sampu. Kinailangan ding i-remap ng mga awtor ang mga tag na isinulat ng model sa sarili nitong format, gaya ng PER-B sa halip na B-PER.

Basahin ito nang maingat. Mga model ito ng 2023 na gumagawa ng mahigpit na tagging task sa mga label set ng benchmark. Ang isang kasalukuyang model na hinihingan ng maikling listahan ng mga tao at kumpanya sa isang support ticket ay puwedeng mas mahusay nang malaki, o hindi. Dalawang bagay ang sinasabi ng table na totoo pa rin: hindi awtomatikong mahusay na NER system ang LLM, at kailangan mo ng sarili mong sukat.

Anong mga Arabic NER dataset ang mayroon?

Dataset Text Laki at label
ANERcorp Balita Mga 150,000 token; person, location, organisation, miscellaneous. Naglalathala ang CAMeL Lab ng standard na train/test split
CLEANANERCorp Itinamang ANERcorp Inaayos ang mga annotation error, nawawalang label at hindi pagkakapare-pareho na nakita sa orihinal
AQMAR Arabic Wikipedia 74,000 token mula sa 28 artikulo
Wojood MSA at dialect Mga 550,000 token, 21 entity type, nested; ginamit sa WojoodNER 2023 shared task
CANERCorpus Classical Arabic na hadith Mahigit 7,000 hadith, 20 type tungkol sa mga paksang Islamiko

Gamitin ang mga ito para i-sanity-check ang prompt, hindi bilang acceptance test mo. Iba ang mga entity type mo (customer, produkto, branch, numero ng kontrata) sa kanila, at iba-iba rin ang mga lisensya nila. Suriin ang bawat isa bago gamitin nang pang-komersyo.

Ano ang dapat hingin ng prompt?

Tatlong patakaran ang nagpapa-check sa output:

  1. Kopyahin nang eksakto ang span. Walang pagsasalin, walang transliteration, walang “pagkumpleto” ng first name para maging buong pangalan. Kung kailangan mo ng English na spelling, hingin ito sa hiwalay na field at ituring itong hindi pa nasusuri.
  2. Saradong listahan ng type. PERSON, ORG, LOCATION, DATE, o sarili mong set. Hindi masi-score ang mga free-form na type.
  3. Mga petsa bilang mga bahagi, hindi conversion. Hingin ang taon, buwan at araw gaya ng pagkakasulat, pati ang kalendaryo. Ang هـ sa dulo ay tanda ng Hijri na petsa; ang م ay Gregorian.

Isulat ang mga instruction sa English o Arabic; tinatalakay ng Arabic prompt engineering ang trade-off. Ilagay ang hugis ng JSON sa system prompt at panatilihin itong pareho sa bawat request para ma-cache ito.

Paano i-check ang mga entity laban sa source?

Puwedeng magbalik ang model ng pangalang hindi kailanman binanggit sa text, o kopyahin nang tama ang pangalan pero walang diacritics. Hindi kayang paghiwalayin ng simpleng substring test ang dalawa. I-normalise muna ang dalawang panig: tanggalin ang tashkeel at tatweel, pag-isahin ang mga anyo ng alef, at pagdugtungin ang عبد ال para tumugma ang عبد الله sa عبدالله. Pareho ang mga patakaran sa Arabic text normalization para sa search, na inilalapat lang sa pag-match. Panatilihin ang orihinal na span para sa display.

import json, os, re
from hijridate import Hijri
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

TYPES = {"PERSON", "ORG", "LOCATION", "DATE"}
SYSTEM = """Extract named entities from the Arabic text. Reply with JSON only:
{"entities": [{"text": "...", "type": "PERSON|ORG|LOCATION|DATE"}],
 "dates": [{"text": "...", "calendar": "hijri|gregorian", "year": 0, "month": 0, "day": 0}]}
Rules: copy "text" exactly as it appears in the input, including any diacritics.
Do not translate, transliterate or complete names. A date followed by هـ is Hijri.
If there are no entities, return empty lists."""

DIACRITICS = re.compile(r"[ً-ٰٟـ]")   # tashkeel, dagger alef, tatweel
def norm(s: str) -> str:
    s = DIACRITICS.sub("", s)
    s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي").replace("عبد ال", "عبدال")
    return " ".join(s.split())

def validate(source: str, data: dict) -> tuple[list, list]:
    """Keep entities that really occur in the source; report everything else."""
    src, kept, problems = norm(source), [], []
    for e in data.get("entities", []):
        if e.get("type") not in TYPES:
            problems.append(f"unknown type: {e}")
        elif norm(e.get("text", "")) not in src:
            problems.append(f"not in source: {e['text']}")
        else:
            kept.append(e)
    for d in data.get("dates", []):
        if d.get("calendar") == "hijri":
            try:
                d["iso"] = Hijri(d["year"], d["month"], d["day"]).to_gregorian().isoformat()
            except (ValueError, OverflowError) as err:
                problems.append(f"bad Hijri date {d['text']}: {err}")
    return kept, problems

def extract(text: str, model="broadnet/qwen3.8-27b") -> dict:
    r = client.chat.completions.create(
        model=model, max_tokens=2000,
        messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": text}])
    data = json.loads(r.choices[0].message.content)
    data["entities"], data["problems"] = validate(text, data)
    return data

text = "التقى خالِد بن سَعِيد مديرةَ شركة النخيل للتقنية في جدة يوم ١٥ جمادى الآخرة ١٤٤٥هـ."
print(json.dumps(extract(text), ensure_ascii=False, indent=1))

Pinatakbo namin ito laban sa isang local mock server (walang live API call) na ang nakahandang sagot ay nagdagdag ng isang inimbentong tao at isang imposibleng petsa (buwan 13). Pinanatili ng output ang خالد بن سعيد (tinanggal ng sagot ang diacritics; nahanap pa rin ito ng normalised na match), شركة النخيل للتقنية at جدة. Na-convert nito ang ١٥ جمادى الآخرة ١٤٤٥هـ sa 2023-12-28, at naglista ng dalawang problema: “not in source” ang inimbentong pangalan, at nag-raise ng “month must be in 1-12” ang buwan 13. Kathang-isip ang mga pangalan at kumpanya.

Mga tala sa code:

  • max_tokens=2000 ang nag-iiwan ng espasyo para sa reasoning. Ayon sa docs ng BroadNet, nagre-reason muna ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B bago sumagot, at kasama sa max_tokens ang reasoning na iyon. Tingnan ang mga empty response mula sa reasoning model.
  • Puwedeng pumalya ang json.loads. Balutin ito, at kapag pumalya, ipadala ulit nang isang beses kasama ang error, gaya ng sa repair loop. Sa GLM 5.3 at Qwen3.8 27B, na idinodokumento ng BroadNet na may structured output, magdagdag din ng response_format schema. Nananatili ang validation alinman ang gamitin.
  • Sinadyang maluwag ang substring matching. Kinukumpirma nito na umiiral ang span; hindi nito kinukumpirma ang type. Ang mga type ang sinusukat ng scoring step sa ibaba.

Paano hahawakan ang mga Hijri na petsa?

Maraming paraan ng pagsulat ng petsa sa Arabic na text: ١٥/٦/١٤٤٥هـ, ١٥ جمادى الآخرة ١٤٤٥, o Gregorian na petsa na may pangalan ng buwan na iba-iba kada rehiyon (نوفمبر sa Egypt at Gulf, تشرين الثاني sa Levant). Kadalasan kaya ng model na hatiin ito sa mga bahagi, at sinusuri ng code ang mga bahagi. Ang pag-convert sa pagitan ng mga kalendaryo ay aritmetika sa isang nailathalang table, at walang dahilan ang model para makuha ito nang tama.

Ang hijridate, dating hijri-converter, ay nagko-convert gamit ang Umm al-Qura calendar. 1343 hanggang 1500 AH (1 Agosto 1924 hanggang 16 Nobyembre 2077 CE) ang nakadokumentong range nito. Kapag labas sa range, nagre-raise ito ng OverflowError; ang di-wastong buwan o araw ay nagre-raise ng ValueError, kaya parehong hinuhuli ng code. Ayon sa docs nito, hindi ito para sa mga relihiyosong layunin kung saan mas pinipili ang pagtanaw sa crescent, kaya puwedeng iba ang petsang itinakda sa pagtanaw kaysa sa na-convert na value. I-store ang petsa gaya ng pagkakasulat katabi ng na-convert.

Hindi kailangan ng espesyal na paghawak ang Eastern Arabic na digit dito: integer ang ibinabalik ng model. Kung ikaw mismo ang magpa-parse ng mga petsa, i-map muna ang ٠١٢٣٤٥٦٧٨٩ (at ang Persian na ۰–۹) sa 0–9.

Paano naman ang mga pangalan sa Arabizi at halo-halong text?

Madalas isulat ng mga customer ang pangalan sa Latin na letra: “ana 7a2ool la Mo7ammad bokra”. Gumagana pa rin ang patakaran ng eksaktong span: “Mo7ammad” ang entity text, at pumapasa ang substring check. Ang pumapalya ay ang pag-match ng record na iyon sa محمد sa CRM mo. Gawin iyon sa pangalawang step: i-convert ang span sa Arabic na script, gaya ng sa paghawak ng Arabizi, saka i-match laban sa mga record mo gamit ang parehong normalisation. Maglagay ng confidence flag sa anumang record na dumaan sa conversion.

Ganoon din sa mga English na pangalan ng kumpanya sa loob ng Arabic na pangungusap, at sa mga Latin na spelling ng Arabic na pangalan (Mohammed, Muhammad, Mohamed). Huwag ipapili sa extraction step ang iisang spelling.

Paano i-score ang extractor?

Lagyan ng label nang mano-mano ang 100 hanggang 200 totoong sample, gamit ang parehong listahan ng type. Saka ikumpara ang mga prediction gamit ang entity-level exact match sa normalised na text at type, at iulat ang precision, recall at F1 kada type:

from collections import Counter

def score(gold: list[list[dict]], pred: list[list[dict]]) -> dict:
    """Entity-level exact match on (normalised text, type), micro-averaged, plus per type."""
    tp, fp, fn = Counter(), Counter(), Counter()
    for g, p in zip(gold, pred):
        G = Counter((norm(e["text"]), e["type"]) for e in g)
        P = Counter((norm(e["text"]), e["type"]) for e in p)
        for (t, ty), n in (G | P).items():
            hit = min(G[(t, ty)], P[(t, ty)])
            tp[ty] += hit; fp[ty] += P[(t, ty)] - hit; fn[ty] += G[(t, ty)] - hit
    def prf(a, b, c):
        p = a / (a + b) if a + b else 0.0
        r = a / (a + c) if a + c else 0.0
        return {"p": round(p, 3), "r": round(r, 3), "f1": round(2 * p * r / (p + r), 3) if p + r else 0.0}
    out = {ty: prf(tp[ty], fp[ty], fn[ty]) for ty in sorted(tp | fp | fn)}
    out["micro"] = prf(sum(tp.values()), sum(fp.values()), sum(fn.values()))
    return out

Sa isang toy set na may dalawang pangungusap (tatlong gold entity; tinawag ng prediction na ORG ang جدة sa halip na LOCATION at nagdagdag ng isang lugar), nag-print ito ng micro precision 0.5, recall 0.667 at F1 0.571, at LOCATION F1 0. Ipinapakita ng view kada type kung saan dapat ilaan ang pagsisikap: kadalasan, ang mahinang ORG score ay nangangahulugang kailangan ng mga halimbawa ng mga depinisyon ng type mo, hindi ng mas malaking model.

Magpasya nang maaga kung ano ang bibilangin na match. Mahigpit ang exact match: ang “شركة النخيل” laban sa gold na “شركة النخيل للتقنية” ay bibilangin na isang false positive at isang false negative. Kung katanggap-tanggap ang bahagyang span sa gamit mo, mag-ulat ng pangalawang score na batay sa overlap, pero gawing pangunahin ang mahigpit.

Aling BroadNet model ang dapat gamitin?

Kada 1M token ang lahat ng presyo, mula sa pricing page ng BroadNet.

Model Bakit Input / output
Qwen3.8 27B May nakadokumentong structured output; ayon sa BroadNet, sinubukan ito sa Arabic, kasama ang pag-unawa sa Gulf at Egyptian na dialect; nakakabasa ng larawan $0.175 / $2.17
GLM 5.3 May nakadokumentong structured output; 1,048,576-token na context para sa napakahahabang dokumento $0.78 / $3.46
Gemma 4 VL 26B Tumatakbo sa $5 na panimulang credit; walang nakadokumentong structured output, kaya i-validate ang JSON na galing sa prompt lang; 32,768-token na context $0.10 / $0.22

Patakbuhin ang scoring script sa sample mo gamit ang bawat kandidato at pumili batay sa F1 kada type at gastos, hindi sa paglalarawan ng vendor. Kadalasan mas maraming token ang Arabic kaysa sa English para sa parehong nilalaman; nasa tokens per word sa Arabic ang mga nasukat na ratio. Para sa mga entity sa loob ng na-scan na form o larawan, kunin nang direkta mula sa larawan, gaya ng sa pagbasa ng Arabic na invoice gamit ang vision.

Saan pumapasok ang BroadNet Inference

Ang BroadRouter ay sariling site ng BroadNet. Binibigyan ka ng BroadNet Inference ng OpenAI-compatible na access sa mga model sa itaas gamit ang iisang key, kaya tumatakbo ang code gamit ang OpenAI Python SDK pagkatapos palitan ang base URL. Ayon sa docs nito, hindi itinatago ang mga prompt at sagot pagkatapos ng request, na mahalaga kapag puno ng pangalan ng tao ang text. Wala itong dedikadong NER endpoint at walang inilalathalang sariling Arabic NER benchmark, kaya sukatin sa data mo. Kung kailangan mo ng self-hosted na tagger para sa malaking volume, puwedeng mas mura at mas pare-pareho ang isang fine-tuned na model na sinanay sa Wojood o sa sarili mong mga label kaysa sa anumang LLM; ang nailathalang agwat sa itaas ang dahilan para suriin ito.

Mga tanong

Kaya bang gawin ng LLM ang Arabic named entity recognition?

Oo, basta may mga check. Malayo ang agwat ng mga nailathalang zero-shot na resulta sa token-level na Arabic NER kumpara sa mga fine-tuned na model, kaya i-validate ang bawat entity laban sa source text at i-score ang model sa isang sample ng sarili mong data na may label bago ka umasa rito.

Paano i-match ang Arabic na pangalan na may at walang diacritics?

I-normalise ang dalawang panig bago ikumpara: tanggalin ang tashkeel (U+064B hanggang U+065F), ang dagger alef at tatweel, i-map ang إ أ آ ٱ sa ا at ang ى sa ي, at pagsamahin ang mga space. Panatilihin ang orihinal na text para sa display; gamitin lang ang normalised na anyo sa pag-match.

Paano i-convert ang Hijri na petsa sa Gregorian sa Python?

Gamitin ang hijridate (dating hijri-converter): ibinabalik ng Hijri(1445, 6, 15).to_gregorian() ang 2023-12-28. Sinusunod nito ang Umm al-Qura calendar, sinusuportahan ang 1343 hanggang 1500 AH, at hindi ito para sa mga relihiyosong petsa na itinatakda ng pagtanaw sa buwan.

Aling Arabic NER dataset ang puwede kong gamitin sa pag-test?

ANERcorp (balita, mga 150,000 token, apat na type), AQMAR (74,000 token mula sa Wikipedia), Wojood (mga 550,000 token ng MSA at dialect na may 21 nested na type) at CANERCorpus (Classical Arabic na hadith, 20 type). Suriin ang lisensya ng bawat isa, at i-map ang mga label nila sa iyo.

Dapat bang isalin o i-transliterate ng model ang mga pangalan?

Hindi sa extraction step. Hingin ang eksaktong span mula sa source, para masuri mo ito. Magdagdag ng hiwalay na field para sa Latin na spelling kung kailangan mo, at ituring itong hindi pa nasusuri.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity