BroadRouter

सर्च और RAG के लिए अरबी टेक्स्ट normalization: क्या बदलें, क्या नहीं

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

सर्च और RAG index के लिए स्टोर की गई कॉपी और हर query, दोनों को एक ही तरह normalize करें: Unicode NFKC, तश्कील और tatweel हटाएँ, alef के रूप एक करें, ى को ي और ة को ه में बदलें, और अंक बदलें। दिखाने और LLM के लिए मूल टेक्स्ट रखें। hamza के आधार और ta marbuta को ट्यून करने लायक़ मानें: ये recall बढ़ाते हैं पर कुछ अलग शब्दों को मिला देते हैं।

अरबी में एक ही शब्द कई तरह से लिखा जा सकता है। यूज़र احمد टाइप करता है; दस्तावेज़ में أَحْمَد लिखा है। जो सर्च index अक्षरों को हूबहू मिलाता है, वह यह मेल चूक जाता है, और RAG पाइपलाइन का keyword वाला आधा हिस्सा भी। Normalization तुलना से पहले रूपों को एक रूप में बदलकर इसे ठीक करता है। लापरवाही से करने पर यह अलग-अलग अर्थ वाले शब्दों को भी मिला देता है। यह पोस्ट नियम-दर-नियम चलती है: हर नियम क्या करता है, कब लगाएँ, क्या तोड़ता है, और मुख्य लाइब्रेरियाँ कैसे अलग हैं। आख़िर में टेस्टेड Python है।

पूरी अरबी RAG पाइपलाइन (chunking, hybrid सर्च, हवालों वाले जवाब) के लिए देखें काम करने वाला अरबी RAG। यह पोस्ट normalization वाले चरण में और गहराई तक जाती है।

क्या normalization सच में retrieval में मदद करता है?

हाँ, keyword सर्च के लिए, और सबूत पुराना है पर साफ़ है। Larkey, Ballesteros और Connell (SIGIR 2002) ने TREC-2001 समाचार संग्रह पर अरबी retrieval टेस्ट किया। Stemming से पहले उन्होंने corpus और queries को normalize किया: हरकतें और विराम चिह्न हटाए, alef के रूप एक किए, और शब्द के अंत के ى और ة बदले। उनके monolingual नतीजे, बिना विस्तार वाली queries के साथ:

Processing Average precision कच्चे के मुक़ाबले बदलाव (राउंड किए आँकड़ों से)
कच्चा टेक्स्ट .194 —
Normalized .238 +22.7%
Normalized + light stemming (light8) .376 +93.8%

दो सावधानियाँ। यह समाचारों पर 2002 का keyword retrieval है, embedding सर्च नहीं। और सबसे बड़ा फ़ायदा light stemming (و और ال जैसे prefixes और आम suffixes हटाना) से आया, जो normalization से अलग चरण है। Lucene का ArabicAnalyzer और Elasticsearch का arabic analyzer दोनों लगाते हैं: पहले normalizer, फिर light stemmer।

क्या normalize करें, और हर नियम की क्या क़ीमत है?

नियम उदाहरण सर्च index जोखिम
Unicode NFKC ﻻ → لا, ا + ٔ → أ हाँ, हमेशा पहले दूसरी लिपियों के compatibility अक्षर भी बदलता है
अदृश्य निशान हटाएँ zero-width joiners, RLM/LRM, BOM हाँ अरबी के लिए कोई नहीं; फ़ारसी में ZWNJ मायने रखता है
तश्कील हटाएँ أَحْمَدُ → أحمد हाँ सिर्फ़ स्वरों से अलग पहचाने जाने वाले शब्द मिल जाते हैं
Tatweel (ـ) हटाएँ الـــمدينة → المدينة हाँ कोई नहीं
Alef एक करें أ إ آ ٱ → ا हाँ कुछ जोड़े मिल जाते हैं: سأل (पूछा) और سال (बहा)
Alef maksura ى → ي आमतौर पर على (पर) और علي (अली) मिल जाते हैं
Ta marbuta ة → ه आमतौर पर كتابة (लेखन) और كتابه (उसकी किताब) मिल जाते हैं
Hamza के आधार ؤ ئ → ء वैकल्पिक مسؤول और مسئول मिलते हैं (अच्छा) पर कुछ अलग शब्द भी
फ़ारसी अक्षर ی → ي, ک → ك हाँ, अगर यूज़र्स के पास फ़ारसी कीबोर्ड हैं अरबी टेक्स्ट के लिए कोई नहीं
अंक ٢٠٢٦ और ۲۰۲۶ → 2026 हाँ कोई नहीं; दिखाने के लिए मूल रखें

पहला कॉलम index key और query के लिए है। जो टेक्स्ट आप स्टोर करते, दिखाते और मॉडल को देते हैं, वह जैसा लिखा है वैसा ही रहता है।

Unicode normalization पहले क्यों आना चाहिए?

एक ही दिखने वाला अक्षर अलग-अलग तरह से स्टोर हो सकता है। أ एक code point (U+0623) हो सकता है या सादा alef और उसके बाद combining hamza (U+0627 U+0654)। पुराने PDF और कुछ कीबोर्ड अरबी presentation forms (U+FB50 से U+FEFF) बनाते हैं, जैसे एक-अक्षर वाला lam-alef ﻻ। Unicode normalization में NFC, hamza को alef पर जोड़ता है, और NFKC presentation forms और ligatures को भी खोलता है। Python में unicodedata.normalize("NFKC", "ﻻ") لا लौटाता है, और ﷲ الله बन जाता है।

इसे सबसे पहले चलाएँ। वरना أ बदलने वाला regex टूटे हुए रूप को चूक जाता है। एक दूसरा जाल भी है: CAMeL Tools का dediac_ar अपने AR_DIAC_CHARSET (U+064B से U+0652 और U+0670) के अक्षर हटाता है। उस set में combining hamza और madda के निशान (U+0653 से U+0655) नहीं हैं, इसलिए टूटे हुए टेक्स्ट पर वे हरकतें हटाने के बाद भी बचे रहते हैं। NFKC उन्हें पहले जोड़ देता है।

NFKC एक compatibility mapping है। यह अरबी के बाहर के अक्षर भी बदलता है, जैसे full-width लैटिन अक्षर। सर्च key में आमतौर पर यही चाहिए, और यह मूल को उसके साथ रखने की एक और वजह है।

क्या normalize नहीं करना चाहिए?

  • वह टेक्स्ट जो आप दिखाते, उद्धृत या quote करते हैं। Normalized अरबी ग़लत वर्तनी वाली लगती है (المدينه)। मूल को key के साथ स्टोर करें।
  • जो आप LLM को भेजते हैं। मॉडल hamza और तश्कील ठीक पढ़ लेते हैं, और हूबहू टेक्स्ट नाम और उद्धरण सही रखता है। तश्कील हटाने से कुछ टोकन बचते हैं; सटीकता के बदले यह सौदा करने से पहले अरबी टोकन काउंटर से देखें कि कितने।
  • ऐसा टेक्स्ट जहाँ निशान अर्थ रखते हैं: क़ुरआन, हदीस, शायरी, बच्चों की किताबें, उच्चारण और हरकतें लगाने वाले काम (देखें LLM से हरकतें लगाना)।
  • वर्तनी या व्याकरण सुधार: पहले normalize करने से वही hamza और taa marbuta की ग़लतियाँ मिट जाती हैं जिन्हें आप सुधारना चाहते हैं; देखें LLM से अरबी व्याकरण और वर्तनी सुधार।
  • Identifiers। प्रोडक्ट कोड, ईमेल, URL और लैटिन टेक्स्ट अरबी नियमों से नहीं गुज़रने चाहिए। Normalization सिर्फ़ अरबी लिपि वाले फ़ील्ड पर, या सिर्फ़ अरबी टोकन पर लगाएँ।
  • ऐसे फ़ील्ड जिन्हें लोग हूबहू सर्च करते हैं। क़ानूनी नामों या ID जैसे फ़ील्ड के लिए एक कच्ची कॉपी भी index करें, ताकि सटीक मेल फिर भी सबसे ऊपर आ सके।

CAMeL Tools, PyArabic और Lucene में क्या फ़र्क़ है?

ये एक जैसे नियम लागू नहीं करते, और इन्हें मिलाने से ऐसा index और queries बनती हैं जो कभी मेल नहीं खातीं। हमने हर लाइब्रेरी का डॉक्यूमेंटेशन और source पढ़ा, और PyArabic 0.6.15 चलाया:

Function असल में क्या करता है
CAMeL normalize_unicode NFKC (या compatibility=False के साथ NFC); ﷼ को ريال और ﷽ को उसके पूरे वाक्यांश में भी फैलाता है
CAMeL normalize_alef_ar إ أ ٱ آ → ا
CAMeL normalize_alef_maksura_ar ى → ي
CAMeL normalize_teh_marbuta_ar ة → ه
CAMeL dediac_ar U+064B से U+0652 और U+0670 हटाता है; tatweel छोड़ देता है
PyArabic strip_tashkeel shadda समेत सभी harakat हटाता है
PyArabic strip_tatweel ـ हटाता है
PyArabic normalize_alef alef का हर रूप और ى → ا, इसलिए إلى बन जाता है الا
PyArabic normalize_hamza डिफ़ॉल्ट तरीक़ा hamza के हर रूप को ء में बदलता है, أ समेत, इसलिए أحمد बन जाता है ءحمد
Lucene ArabicNormalizer alef पर hamza वाले रूप → ا, ة → ه, ى → ي, harakat और tatweel हटाता है

PyArabic वाली पंक्तियाँ लोगों को चौंकाती हैं। उसके normalize_alef का docstring कहता है कि alef maksura अपवाद है, लेकिन 0.6.15 में ALEFAT set में ى शामिल है, और function उसे ا में बदल देता है। उसका normalize_hamza hamza की परवाह न करने वाले मिलान के लिए बना है, आम सर्च के लिए नहीं। क्रम भी मायने रखता है: पहले alef normalization चलाएँ, तो normalize_hamza सिर्फ़ ؤ, ئ और ء को छूता है, इसलिए مسؤول और مسئول दोनों مسءول बन जाते हैं। उसका tasheel तरीक़ा इसकी जगह مسوول और مسيول देता है, जो आपस में मेल नहीं खाते।

Elasticsearch का arabic_normalization filter, Lucene normalizer इस्तेमाल करता है, इसलिए जो Python पाइपलाइन किसी Elasticsearch index से मेल खाना चाहती है, उसे Lucene के नियम हूबहू अपनाने चाहिए। यानी ى → ي, ى → ا नहीं।

टेस्ट किया हुआ normalizer कैसा दिखता है?

यह function Lucene के फ़ैसलों का पालन करता है, Unicode, अंकों और फ़ारसी अक्षरों को संभालना जोड़ता है, और जोखिम वाले नियमों को चालू-बंद करने लायक़ बनाता है। यह सिर्फ़ standard library इस्तेमाल करता है।

import re
import unicodedata

DIACRITICS = re.compile("[ً-ٰٟ]")  # tashkeel, extra marks, superscript alef
INVISIBLE = re.compile("[​-‏‪-‮⁦-⁩]")  # zero-width, bidi
ALEF = re.compile("[آأإٱ]")    # آ أ إ ٱ -> ا
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹", "0123456789" * 2)
FARSI = str.maketrans({"ی": "ي", "ک": "ك"})  # ی -> ي, ک -> ك

def normalize(text, *, alef=True, alef_maksura=True, ta_marbuta=True,
              hamza_seats=False, digits=True):
    text = unicodedata.normalize("NFKC", text)     # compose marks, unpack ligatures
    text = INVISIBLE.sub("", text)
    text = DIACRITICS.sub("", text).replace("ـ", "")   # tashkeel, tatweel
    text = text.translate(FARSI)
    if alef:
        text = ALEF.sub("ا", text)
    if alef_maksura:
        text = text.replace("ى", "ي")    # ى -> ي
    if ta_marbuta:
        text = text.replace("ة", "ه")    # ة -> ه
    if hamza_seats:
        text = re.sub("[ؤئ]", "ء", text)  # ؤ ئ -> ء
    if digits:
        text = text.translate(DIGITS)
    return text

हमारी टेस्ट strings पर इसने यह लौटाया:

इनपुट आउटपुट नोट
أَحْمَدُ احمد तश्कील और hamza हटे
الـــمدينة المدينه Tatweel और ta marbuta
إلى الي Alef और alef maksura
ا + U+0654 + مل امل टूटा hamza जुड़ा, फिर एक किया गया
ﻻبد لابد Presentation form खोला गया
٢٠٢٦ / ۱۴۰۵ 2026 / 1405 अरबी-भारतीय और फ़ारसी अंक
مسؤول / مسئول hamza_seats=True के साथ दोनों مسءول डिफ़ॉल्ट रूप से बिना बदलाव
فارسی فارسي फ़ारसी ya

इसे दो जगह इस्तेमाल करें: जब आप index key बनाते हैं और जब आप query पढ़ते हैं। original और normalize(original) साथ-साथ स्टोर करें, दूसरे पर सर्च करें और पहला लौटाएँ। मुफ़्त अरबी टेक्स्ट normalizer में आप टेक्स्ट पेस्ट करके अपनी सेटिंग्स चुनने से पहले हर नियम का असर देख सकते हैं।

Normalization, embeddings और RAG में कैसे फ़िट होता है?

RAG पाइपलाइन में आमतौर पर दो retrievers होते हैं: keyword सर्च (BM25) और embeddings। Normalization साफ़ तौर पर keyword वाले हिस्से में मदद करता है। Embedding वाले हिस्से पर ऊपर का सबूत लागू नहीं होता: embedding मॉडल कच्चे टेक्स्ट पर trained होते हैं, और बहुत से पहले ही احمد और أحمد को पास-पास रखते हैं। Embedding से पहले normalize करना मदद कर सकता है, कुछ न करे, या नुक़सान करे। जाने-पहचाने जवाबों वाली 50 से 100 असली queries बनाएँ, उन्हें कच्चे और normalized इनपुट के साथ चलाएँ, और जो ज़्यादा recall दे वह रखें। जो भी चुनें, उसे दस्तावेज़ों और queries पर एक जैसा लगाएँ।

Normalization टोकन की गिनती भी थोड़ी घटाता है, क्योंकि हरकतें और tatweel tokenizer के लिए अतिरिक्त अक्षर हैं। मापे गए अनुपात tokenizer efficiency dataset और अरबी में प्रति शब्द टोकन में हैं। Speech recognition को निष्पक्ष स्कोर करने के लिए भी यही normalization इस्तेमाल होता है; देखें अरबी WER की व्याख्या।

Arabizi (लैटिन अक्षरों में अरबी) को बिल्कुल अलग तरीक़ा चाहिए: LLM, Arabizi को कैसे संभालते हैं।

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

Normalization आपके अपने कोड में चलता है, इसलिए इसके लिए कोई API नहीं चाहिए। BroadNet Inference retrieval के बाद आता है। यह embeddings नहीं बेचता, इसलिए अपनी पसंद का retriever और embeddings प्रोवाइडर जवाब वाले चरण के लिए BroadNet चैट मॉडल के साथ जोड़ें। GLM 5.3 और DeepSeek V4.1 Flash 1,048,576 टोकन का कॉन्टेक्स्ट लेते हैं, इसलिए आप बहुत से निकाले गए अंश उनकी मूल, बिना normalize की अरबी में भेज सकते हैं। अरबी क्वालिटी पर मॉडल चुनने के लिए देखें अरबी के लिए LLM चुनना। अगर आपको सिर्फ़ keyword सर्च चाहिए, तो शायद Elasticsearch का बिल्ट-इन arabic analyzer ही काफ़ी हो।

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

क्या अरबी टेक्स्ट index करने से पहले तश्कील (हरकतें) हटा दूँ?

सर्च के लिए, हाँ: ज़्यादातर queries और ज़्यादातर आधुनिक टेक्स्ट में हरकतें नहीं होतीं, इसलिए वरना हरकतों वाले दस्तावेज़ मेल नहीं खाएँगे। उन्हें index key और query से हटाएँ, दिखाने के लिए मूल टेक्स्ट रखें, और क़ुरआन, शायरी या उच्चारण वाले कामों में उन्हें रखें जहाँ वे अर्थ रखती हैं।

क्या ta marbuta (ة) को ha (ه) में normalize करना चाहिए?

सर्च के लिए आमतौर पर हाँ, क्योंकि बहुत से लोग शब्द के अंत में ه टाइप करते हैं। यह कुछ जोड़ों को मिला देता है, जैसे كتابة (लेखन) और كتابه (उसकी किताब)। अगर आपके क्षेत्र में ये टकराव मायने रखते हैं, तो ة रखें और दोनों सेटिंग्स टेस्ट करें।

Elasticsearch में अरबी normalization क्या करता है?

arabic_normalization token filter, Lucene का ArabicNormalizer इस्तेमाल करता है: alef पर hamza वाले रूप सादे alef में, ta marbuta को ha में, alef maksura को ya में, और harakat और tatweel हटाना। बिल्ट-इन arabic analyzer इसमें stop words और एक stemmer जोड़ता है जो जुड़े हुए articles, conjunctions, prepositions और आम suffixes हटाता है।

क्या अरबी normalize करने से embedding सर्च में मदद मिलती है?

यह साबित नहीं है। मापे गए फ़ायदे keyword retrieval से आते हैं। Embedding मॉडल कच्चे टेक्स्ट से सीखते हैं और अक्सर वर्तनी के रूप संभाल लेते हैं, इसलिए तय करने से पहले असली queries का एक छोटा set बनाएँ और normalization के साथ और बिना recall मिलाएँ।

क्या LLM को भेजने से पहले अरबी टेक्स्ट normalize करूँ?

आमतौर पर नहीं। मूल टेक्स्ट भेजें ताकि उद्धरण, नाम और हवाले बिल्कुल सही रहें। तश्कील हटाने से कुछ टोकन बचते हैं, लेकिन ऐसा तभी करें जब काम को उन निशानों की ज़रूरत न हो।

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