BroadRouter

LLM से अरबी named entity extraction: JSON, तारीख़ें और जाँच

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित

मॉडल से कहें कि हर entity को बिल्कुल वैसे ही कॉपी करे जैसे लिखी है, तय सूची के एक type के साथ, JSON में। हर entity को कोड में जाँचें: हरकतें हटाने और अलिफ़ के रूप एक करने के बाद वह स्रोत में होनी चाहिए। हिजरी तारीख़ें मॉडल से नहीं, hijridate जैसी लाइब्रेरी से बदलें। हाथ से लेबल किए सैंपल को entity-स्तर के precision, recall और F1 से स्कोर करें।

Named entity extraction एक पैराग्राफ़ को ऐसे रिकॉर्ड में बदलता है जिन्हें आपका कोड इस्तेमाल कर सके: कौन, कौन-सा संगठन, कहाँ और कब। अरबी चार ऐसी समस्याएँ जोड़ती है जो अंग्रेज़ी पाइपलाइन को कम ही मिलती हैं: वैकल्पिक हरकतें, एक ही अक्षर की कई वर्तनियाँ, लैटिन अक्षरों में लिखे नाम (Arabizi), और दो कैलेंडरों में तारीख़ें। यह पोस्ट एक OpenAI-compatible LLM पर extraction चरण बनाती है जो इनमें से हर एक को कोड में संभालता है, और एक स्कोरिंग स्क्रिप्ट जो बताती है कि यह आपके टेक्स्ट पर काम करता है या नहीं।

मैसेज से span निकालने के बजाय पूरे मैसेज को वर्गीकृत करने के लिए अरबी टेक्स्ट classification देखें। JSON अनुरोध के विकल्पों के लिए JSON mode बनाम json_schema देखें।

LLM अरबी NER में कितने अच्छे हैं?

हमें मिला सबसे प्रासंगिक सार्वजनिक माप LAraBench (Abdelali et al., EACL 2024) है, जिसने GPT-3.5 और GPT-4 को अरबी NER सेटों पर token-दर-token tagging के रूप में चलाया। Macro-F1, ज़्यादा बेहतर है:

डेटासेट GPT-3.5 zero-shot GPT-4 zero-shot GPT-4 3-shot उद्धृत fine-tuned सिस्टम
ANERcorp (समाचार) 0.210 0.355 0.420 0.886
AQMAR (Wikipedia) 0.230 0.365 0.390 0.690
QASR (ट्रांसक्रिप्ट) 0.208 0.504 n/a 0.698

ज़्यादा उदाहरणों से मदद मिली: ANERcorp पर GPT-4 बिना उदाहरण के 0.355 से दस उदाहरणों के साथ 0.451 तक पहुँचा। लेखकों को मॉडल के अपने फ़ॉर्मैट में लिखे tags भी दोबारा मैप करने पड़े, जैसे B-PER की जगह PER-B।

इसे सावधानी से पढ़ें। ये 2023 के मॉडल हैं जो benchmark लेबल सेटों पर एक सख़्त tagging काम कर रहे हैं। किसी सपोर्ट टिकट में लोगों और कंपनियों की छोटी सूची माँगने पर मौजूदा मॉडल कहीं बेहतर कर सकता है, या नहीं भी। तालिका दो बातें बताती है जो अब भी सही हैं: LLM अपने आप अच्छा NER सिस्टम नहीं है, और आपको अपना माप चाहिए।

कौन-से अरबी NER डेटासेट मौजूद हैं?

डेटासेट टेक्स्ट आकार और लेबल
ANERcorp समाचार लगभग 150,000 tokens; person, location, organisation, miscellaneous। CAMeL Lab एक मानक train/test split प्रकाशित करता है
CLEANANERCorp ANERcorp, सुधारा हुआ मूल में मिली annotation की ग़लतियाँ, छूटे लेबल और असंगतियाँ ठीक करता है
AQMAR अरबी Wikipedia 28 लेखों से 74,000 tokens
Wojood MSA और बोली लगभग 550,000 tokens, 21 entity types, nested; WojoodNER 2023 shared task में इस्तेमाल हुआ
CANERCorpus क्लासिकल अरबी हदीस 7,000 से ज़्यादा हदीसें, इस्लामी विषयों पर 20 types

इन्हें प्रॉम्प्ट की शुरुआती जाँच के लिए इस्तेमाल करें, अपने acceptance टेस्ट के रूप में नहीं। आपके entity types (ग्राहक, प्रोडक्ट, शाखा, कॉन्ट्रैक्ट नंबर) इनसे अलग होंगे, और इनके लाइसेंस भी अलग हैं। व्यावसायिक इस्तेमाल से पहले हर एक जाँचें।

प्रॉम्प्ट में क्या माँगें?

तीन नियम आउटपुट को जाँचने लायक़ बनाते हैं:

  1. span बिल्कुल वैसा ही कॉपी करें। न अनुवाद, न लिप्यंतरण, न पहले नाम को “पूरा” करके पूरा नाम बनाना। अगर अंग्रेज़ी वर्तनी चाहिए, तो उसे अलग फ़ील्ड में माँगें और बिना जाँचा हुआ मानें।
  2. types की बंद सूची। PERSON, ORG, LOCATION, DATE, या आपका अपना सेट। खुले types स्कोर नहीं किए जा सकते।
  3. तारीख़ें हिस्सों में, बदली हुई नहीं। साल, महीना और दिन जैसे लिखे हैं वैसे माँगें, साथ में कैलेंडर। आख़िर में هـ हिजरी तारीख़ बताता है; م ग्रेगोरियन।

निर्देश अंग्रेज़ी या अरबी में लिखें; अरबी प्रॉम्प्ट इंजीनियरिंग इसका फ़ायदा-नुक़सान बताती है। JSON का आकार system प्रॉम्प्ट में रखें और हर अनुरोध में एक जैसा रखें ताकि वह कैश हो सके।

Entities को स्रोत से कैसे जाँचें?

मॉडल ऐसा नाम लौटा सकता है जिसका टेक्स्ट में ज़िक्र ही नहीं, या नाम सही कॉपी करे लेकिन उसकी हरकतों के बिना। सीधा substring टेस्ट इन दोनों में फ़र्क़ नहीं कर सकता। पहले दोनों तरफ़ normalise करें: तश्कील और ततवील हटाएँ, अलिफ़ के रूप एक करें, और عبد ال को जोड़ें ताकि عبد الله और عبدالله मेल खाएँ। नियम वही हैं जो सर्च के लिए अरबी टेक्स्ट normalization में हैं, सिर्फ़ मिलान पर लागू। दिखाने के लिए मूल span रखें।

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))

हमने इसे एक लोकल mock सर्वर पर चलाया (कोई live API कॉल नहीं), जिसके तय जवाब में एक मनगढ़ंत व्यक्ति और एक असंभव तारीख़ (महीना 13) जोड़ी गई थी। आउटपुट ने خالد بن سعيد (जवाब में हरकतें हट गई थीं; normalised मिलान ने फिर भी उसे पाया), شركة النخيل للتقنية और جدة रखे। इसने ١٥ جمادى الآخرة ١٤٤٥هـ को 2023-12-28 में बदला, और दो समस्याएँ बताईं: मनगढ़ंत नाम “not in source” (अनुवाद: स्रोत में नहीं) था, और महीना 13 ने “month must be in 1-12” (अनुवाद: महीना 1-12 में होना चाहिए) उठाया। नाम और कंपनी काल्पनिक हैं।

कोड पर टिप्पणियाँ:

  • max_tokens=2000 reasoning के लिए जगह छोड़ता है। BroadNet के docs कहते हैं कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब देने से पहले reasoning करते हैं, और वह reasoning max_tokens में गिनी जाती है। देखें reasoning मॉडल से ख़ाली जवाब।
  • json.loads फ़ेल हो सकता है। इसे लपेटें, और फ़ेल होने पर error के साथ एक बार दोबारा भेजें, जैसा repair loop में है। GLM 5.3 और Qwen3.8 27B पर, जिन्हें BroadNet structured output के साथ डॉक्यूमेंट करता है, एक response_format schema भी जोड़ें। validation दोनों हालात में रहता है।
  • Substring मिलान जानबूझकर ढीला है। यह पक्का करता है कि span मौजूद है; type पक्का नहीं करता। types वही हैं जिन्हें नीचे का स्कोरिंग चरण मापता है।

हिजरी तारीख़ें कैसे संभालें?

अरबी टेक्स्ट तारीख़ें कई तरह से लिखता है: ١٥/٦/١٤٤٥هـ, ١٥ جمادى الآخرة ١٤٤٥, या ऐसी ग्रेगोरियन तारीख़ जिसके महीनों के नाम इलाक़े के हिसाब से बदलते हैं (मिस्र और खाड़ी में نوفمبر, लेवांत में تشرين الثاني)। मॉडल आमतौर पर इन्हें हिस्सों में बाँट सकता है, और कोड हिस्सों को जाँचता है। कैलेंडरों के बीच बदलना एक प्रकाशित तालिका पर गणित है, और मॉडल के पास इसे सही करने की कोई वजह नहीं है।

hijridate, पहले hijri-converter, उम्म अल-क़ुरा कैलेंडर से बदलता है। इसकी दस्तावेज़ी रेंज 1343 से 1500 हिजरी (1 अगस्त 1924 से 16 नवंबर 2077 ईस्वी) है। रेंज के बाहर यह OverflowError उठाता है; ग़लत महीना या दिन ValueError उठाता है, इसीलिए कोड दोनों पकड़ता है। इसके docs कहते हैं कि यह उन धार्मिक कामों के लिए नहीं है जहाँ चाँद देखना बेहतर माना जाता है, इसलिए चाँद देखकर तय हुई तारीख़ बदले गए मान से अलग हो सकती है। तारीख़ जैसी लिखी है, उसे बदली हुई तारीख़ के साथ सहेजें।

पूर्वी अरबी अंकों के लिए यहाँ कुछ ख़ास नहीं करना: मॉडल integers लौटाता है। अगर आप तारीख़ें ख़ुद parse करते हैं, तो पहले ٠١٢٣٤٥٦٧٨٩ (और फ़ारसी ۰–۹) को 0–9 में बदलें।

Arabizi और मिले-जुले टेक्स्ट में नामों का क्या?

ग्राहकों के मैसेज अक्सर नाम लैटिन अक्षरों में लिखते हैं: “ana 7a2ool la Mo7ammad bokra”। सटीक-span नियम फिर भी काम करता है: entity टेक्स्ट “Mo7ammad” है, और substring जाँच पास होती है। जो फ़ेल होता है वह है उस रिकॉर्ड को आपके CRM के محمد से मिलाना। यह दूसरे चरण में करें: span को अरबी लिपि में बदलें, जैसा Arabizi संभालने में है, फिर उसी normalisation के साथ अपने रिकॉर्ड से मिलाएँ। conversion से होकर आए हर रिकॉर्ड पर confidence फ़्लैग रखें।

यही बात अरबी वाक्यों के अंदर अंग्रेज़ी कंपनी नामों पर, और अरबी नामों की लैटिन वर्तनियों (Mohammed, Muhammad, Mohamed) पर लागू होती है। extraction चरण से एक वर्तनी चुनने को न कहें।

Extractor का स्कोर कैसे निकालें?

100 से 200 असली सैंपल हाथ से लेबल करें, उसी type सूची के साथ। फिर normalised टेक्स्ट और type पर entity-स्तर के exact match से predictions की तुलना करें, और हर type के लिए precision, recall और F1 रिपोर्ट करें:

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

दो वाक्यों के एक छोटे सेट पर (तीन gold entities; prediction ने جدة को LOCATION की जगह ORG बताया और एक अतिरिक्त जगह जोड़ी), इसने micro precision 0.5, recall 0.667 और F1 0.571 प्रिंट किया, और LOCATION F1 0। हर type का अलग नज़ारा दिखाता है कि मेहनत कहाँ लगानी है: कमज़ोर ORG स्कोर का मतलब आमतौर पर यह होता है कि आपकी type परिभाषाओं को उदाहरण चाहिए, बड़ा मॉडल नहीं।

पहले से तय करें कि मिलान किसे गिनेंगे। exact match सख़्त है: gold “شركة النخيل للتقنية” के सामने “شركة النخيل” एक false positive और एक false negative गिना जाता है। अगर आपके काम के लिए आंशिक span चलते हैं, तो overlap पर आधारित दूसरा स्कोर रिपोर्ट करें, लेकिन मुख्य आँकड़ा सख़्त वाला ही रखें।

कौन-सा BroadNet मॉडल इस्तेमाल करें?

सारी कीमतें प्रति 1M टोकन हैं, BroadNet के pricing पेज से।

मॉडल क्यों इनपुट / आउटपुट
Qwen3.8 27B structured output डॉक्यूमेंटेड; BroadNet रिपोर्ट करता है कि इसे अरबी में टेस्ट किया गया, खाड़ी और मिस्री बोली की समझ सहित; इमेज पढ़ता है $0.175 / $2.17
GLM 5.3 structured output डॉक्यूमेंटेड; बहुत लंबे दस्तावेज़ों के लिए 1,048,576-टोकन कॉन्टेक्स्ट $0.78 / $3.46
Gemma 4 VL 26B $5 के शुरुआती क्रेडिट पर चलता है; structured output डॉक्यूमेंटेड नहीं, इसलिए सिर्फ़ प्रॉम्प्ट से बने JSON को validate करें; 32,768-टोकन कॉन्टेक्स्ट $0.10 / $0.22

हर उम्मीदवार के साथ अपने सैंपल पर स्कोरिंग स्क्रिप्ट चलाएँ और हर type के F1 और लागत के आधार पर चुनें, वेंडर के विवरण के आधार पर नहीं। एक जैसी सामग्री के लिए अरबी आमतौर पर अंग्रेज़ी से ज़्यादा टोकन लेती है; मापे गए अनुपात अरबी में प्रति शब्द टोकन में हैं। स्कैन किए फ़ॉर्म या फ़ोटो के अंदर की entities के लिए सीधे इमेज से निकालें, जैसा vision से अरबी इनवॉइस पढ़ने में है।

BroadNet Inference कहाँ फ़िट होता है

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference ऊपर के मॉडलों तक एक key से OpenAI-compatible पहुँच देता है, इसलिए base URL बदलने के बाद कोड OpenAI Python SDK के साथ चलता है। इसके docs कहते हैं कि अनुरोध के बाद प्रॉम्प्ट और जवाब नहीं रखे जाते, जो तब मायने रखता है जब टेक्स्ट लोगों के नामों से भरा हो। इसमें कोई समर्पित NER endpoint नहीं है और यह अपना कोई अरबी NER benchmark प्रकाशित नहीं करता, इसलिए अपने डेटा पर मापें। अगर बड़ी मात्रा के लिए self-hosted tagger चाहिए, तो Wojood या आपके अपने लेबल पर ट्रेन हुआ fine-tuned मॉडल किसी भी LLM से सस्ता और ज़्यादा एकसार हो सकता है; ऊपर का प्रकाशित अंतर इसे जाँचने की वजह है।

अक्सर पूछे जाने वाले सवाल

क्या LLM अरबी named entity recognition कर सकता है?

हाँ, जाँच के साथ। token-स्तर के अरबी NER पर प्रकाशित zero-shot नतीजे fine-tuned मॉडलों से काफ़ी पीछे हैं, इसलिए भरोसा करने से पहले हर entity को स्रोत टेक्स्ट से मिलाएँ और अपने डेटा के लेबल किए सैंपल पर मॉडल का स्कोर निकालें।

हरकतों के साथ और बिना लिखे अरबी नाम कैसे मिलाऊँ?

तुलना से पहले दोनों तरफ़ normalise करें: तश्कील (U+064B से U+065F), खड़ा अलिफ़ और ततवील हटाएँ, إ أ آ ٱ को ا और ى को ي में बदलें, और spaces समेटें। दिखाने के लिए मूल टेक्स्ट रखें; normalised रूप सिर्फ़ मिलान के लिए इस्तेमाल करें।

Python में हिजरी तारीख़ को ग्रेगोरियन में कैसे बदलूँ?

hijridate (पहले hijri-converter) इस्तेमाल करें: Hijri(1445, 6, 15).to_gregorian() 2023-12-28 लौटाता है। यह उम्म अल-क़ुरा कैलेंडर मानता है, 1343 से 1500 हिजरी सपोर्ट करता है, और चाँद देखकर तय होने वाली धार्मिक तारीख़ों के लिए नहीं बना है।

किन अरबी NER डेटासेट पर टेस्ट कर सकता हूँ?

ANERcorp (समाचार, लगभग 150,000 tokens, चार types), AQMAR (Wikipedia के 74,000 tokens), Wojood (MSA और बोली के लगभग 550,000 tokens, 21 nested types) और CANERCorpus (क्लासिकल अरबी हदीस, 20 types)। हर एक का लाइसेंस जाँचें, और उनके लेबल अपने लेबल से मैप करें।

क्या मॉडल नामों का अनुवाद या लिप्यंतरण करे?

extraction चरण में नहीं। स्रोत का बिल्कुल सही span माँगें, ताकि आप उसे जाँच सकें। अगर लैटिन वर्तनी चाहिए तो अलग फ़ील्ड जोड़ें, और उसे बिना जाँचा हुआ मानें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें