अरबी में एक ही शब्द कई तरह से लिखा जा सकता है। यूज़र احمد टाइप करता है; दस्तावेज़ में أَحْمَد लिखा है। जो सर्च 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 ही काफ़ी हो।
