अजगर: भाषा का निर्धारण कैसे करें?

Question 1

मैं इसे प्राप्त करना चाहता हूं:

Input text: "ру́сский язы́к"
Output text: "Russian" 

Input text: "中文"
Output text: "Chinese" 

Input text: "にほんご"
Output text: "Japanese" 

Input text: "العَرَبِيَّة"
Output text: "Arabic"

मैं इसे अजगर में कैसे कर सकता हूं? धन्यवाद।

Question 2

क्या आपकी नज़र लैंगडेट पर पड़ गई है ?

from langdetect import detect

lang = detect("Ein, zwei, drei, vier")

print lang
#output: de

Question 3

टेक्स्टबल्ब । NLTK पैकेज की आवश्यकता है, Google का उपयोग करता है।
```
from textblob import TextBlob
b = TextBlob("bonjour")
b.detect_language()
```
pip install textblob
बहुवचन । ~~विंडोज के लिए काम करने की संभावना नहीं है~~ , यह खस्ता और कुछ रहस्यमय पुस्तकालयों की आवश्यकता है । (विंडोज के लिए, यहां से PyICU , Morfector और PyCLD2 का उपयुक्त संस्करण प्राप्त करें , फिर बस pip install downloaded_wheel.whl।) मिश्रित भाषाओं वाले पाठों का पता लगाने में सक्षम।
```
from polyglot.detect import Detector

mixed_text = u"""
China (simplified Chinese: 中国; traditional Chinese: 中國),
officially the People's Republic of China (PRC), is a sovereign state
located in East Asia.
"""
for language in Detector(mixed_text).languages:
        print(language)

# name: English     code: en       confidence:  87.0 read bytes:  1154
# name: Chinese     code: zh_Hant  confidence:   5.0 read bytes:  1755
# name: un          code: un       confidence:   0.0 read bytes:     0
```
pip install polyglot

निर्भरता स्थापित करने के लिए, चलाएं: sudo apt-get install python-numpy libicu-dev
chardet अगर वहाँ चरित्र रेंज में बाइट्स हैं भी भाषाओं का पता लगाने के एक सुविधा है (127-255]:
```
>>> chardet.detect("Я люблю вкусные пампушки".encode('cp1251'))
{'encoding': 'windows-1251', 'confidence': 0.9637267119204621, 'language': 'Russian'}
```
pip install chardet
langdetect में पाठ के बड़े हिस्से की आवश्यकता होती है। यह हुड के नीचे गैर-नियतात्मक दृष्टिकोण का उपयोग करता है। इसका मतलब है कि आपको एक ही टेक्स्ट सैंपल के लिए अलग-अलग परिणाम मिलेंगे। डॉक्स का कहना है कि इसे निर्धारित करने के लिए आपको निम्नलिखित कोड का उपयोग करना होगा:
```
from langdetect import detect, DetectorFactory
DetectorFactory.seed = 0
detect('今一はお前さん')
```
pip install langdetect
guess_language का उपयोग करके बहुत ही कम नमूने पता लगा सकता है इस शब्दकोशों के साथ वर्तनी परीक्षक।

pip install guess_language-spirit
लैंगिड दोनों मॉड्यूल प्रदान करता है
```
import langid
langid.classify("This is a test")
# ('en', -54.41310358047485)
```
और एक कमांड लाइन उपकरण:
```
$ langid < README.md
```
pip install langid
फास्टटेक्स्ट एक टेक्स्ट क्लासिफायरियर है, इसका इस्तेमाल 176 भाषाओं को भाषा वर्गीकरण के लिए उचित मॉडल के साथ पहचानने के लिए किया जा सकता है । इस मॉडल को डाउनलोड करें , फिर:
```
import fasttext
model = fasttext.load_model('lid.176.ftz')
print(model.predict('الشمس تشرق', k=2))  # top 2 matching languages

(('__label__ar', '__label__fa'), array([0.98124713, 0.01265871]))
```
pip install fasttext
pyCLD3 भाषा पहचान के लिए एक तंत्रिका नेटवर्क मॉडल है। इस पैकेज में एक संदर्भ कोड और एक प्रशिक्षित मॉडल है।
```
import cld3
cld3.get_language("影響包含對氣候的變化以及自然資源的枯竭程度")

LanguagePrediction(language='zh', probability=0.999969482421875, is_reliable=True, proportion=1.0)
```
pip install pycld3

Question 4

एक ऐसा मुद्दा है langdetectजब इसका उपयोग समानांतरकरण के लिए किया जा रहा है और यह विफल हो जाता है। लेकिन उसके spacy_langdetectलिए एक आवरण है और आप इसे उस उद्देश्य के लिए उपयोग कर सकते हैं। आप निम्नलिखित स्निपेट का उपयोग कर सकते हैं:

import spacy
from spacy_langdetect import LanguageDetector

nlp = spacy.load("en")
nlp.add_pipe(LanguageDetector(), name="language_detector", last=True)
text = "This is English text Er lebt mit seinen Eltern und seiner Schwester in Berlin. Yo me divierto todos los días en el parque. Je m'appelle Angélica Summer, j'ai 12 ans et je suis canadienne."
doc = nlp(text)
# document level language detection. Think of it like average language of document!
print(doc._.language['language'])
# sentence level language detection
for i, sent in enumerate(doc.sents):
    print(sent, sent._.language)

Question 5

यदि आप एक पुस्तकालय की तलाश कर रहे हैं जो लंबे ग्रंथों के साथ तेज है , polyglotऔर fastextयहां सबसे अच्छा काम कर रहा है।

मैंने गंदे और यादृच्छिक HTML के संग्रह से 10000 दस्तावेज़ों का नमूना लिया, और यहाँ परिणाम हैं:

+------------+----------+
| Library    | Time     |
+------------+----------+
| polyglot   | 3.67 s   |
+------------+----------+
| fasttext   | 6.41     |
+------------+----------+
| cld3       | 14 s     |
+------------+----------+
| langid     | 1min 8s  |
+------------+----------+
| langdetect | 2min 53s |
+------------+----------+
| chardet    | 4min 36s |
+------------+----------+

मैंने देखा है कि बहुत सारे तरीके छोटे ग्रंथों पर ध्यान केंद्रित करते हैं, शायद इसलिए कि इसे हल करना कठिन समस्या है: यदि आपके पास बहुत अधिक पाठ है, तो भाषाओं का पता लगाना वास्तव में आसान है (जैसे कोई सिर्फ एक शब्दकोश का उपयोग कर सकता है!)। हालांकि, यह लंबे ग्रंथों के लिए एक आसान और उपयुक्त विधि खोजने में मुश्किल बनाता है।

Question 6

मामले के आधार पर, आप निम्नलिखित विधियों में से किसी एक का उपयोग करने में रुचि रख सकते हैं:

विधि 0: किसी API या लाइब्रेरी का उपयोग करें

आमतौर पर, इन पुस्तकालयों के साथ कुछ समस्याएं हैं क्योंकि उनमें से कुछ छोटे ग्रंथों के लिए सटीक नहीं हैं, कुछ भाषाएं गायब हैं, धीमी हैं, इंटरनेट कनेक्शन की आवश्यकता है, गैर-मुक्त हैं, ... लेकिन आम तौर पर बोलना, वे सबसे अधिक आवश्यकताओं के अनुरूप होंगे ।

विधि 1: भाषा मॉडल

एक भाषा मॉडल हमें शब्दों के अनुक्रम की संभावना देता है। यह महत्वपूर्ण है क्योंकि यह हमें किसी पाठ की भाषा का दृढ़ता से पता लगाने की अनुमति देता है, यहां तक कि जब पाठ में अन्य भाषाओं के शब्द भी शामिल हैं (जैसे: "'होला' का अर्थ है 'स्पेनिश में हैलो' )।

आप अपने पाठ को स्कोर करने के लिए एन भाषा मॉडल (प्रति भाषा एक) का उपयोग कर सकते हैं। पता लगाई गई भाषा उस मॉडल की भाषा होगी जिसने आपको उच्चतम स्कोर दिया था।

यदि आप इसके लिए एक सरल भाषा मॉडल बनाना चाहते हैं, तो मैं 1-ग्राम के लिए जाऊंगा। ऐसा करने के लिए, आपको केवल एक बड़े पाठ से प्रत्येक शब्द की संख्या को गिनना होगा (उदाहरण के लिए "X" भाषा में विकिपीडिया कॉर्पस)।

फिर, किसी शब्द की संभावना विश्लेषण की कुल संख्या (सभी आवृत्तियों का योग) से विभाजित इसकी आवृत्ति होगी।

the 23135851162
of  13151942776
and 12997637966
to  12136980858
a   9081174698
in  8469404971
for 5933321709
...

=> P("'Hola' means 'hello' in spanish") = P("hola") * P("means") * P("hello") * P("in") * P("spanish")

यदि पता लगाने के लिए पाठ काफी बड़ा है, तो मैं एन यादृच्छिक शब्दों का नमूना लेने की सलाह देता हूं और फिर फ्लोटिंग-पॉइंट सटीक समस्याओं से बचने के लिए गुणन के योग का उपयोग करता हूं।

P(s) = 0.03 * 0.01 * 0.014 = 0.0000042
P(s) = log10(0.03) + log10(0.01) + log10(0.014) = -5.376

विधि 2: अंतर्वर्ती सेट

एक सरल तरीका यह भी है कि शीर्ष M सबसे अक्सर शब्दों के साथ N सेट (प्रति भाषा) तैयार किया जाए। फिर प्रत्येक सेट के साथ अपने पाठ को इंटरसेक्ट करें। सबसे अधिक संख्या वाले चौराहों के साथ सेट आपकी भाषा का पता लगाया जाएगा।

spanish_set = {"de", "hola", "la", "casa",...}
english_set = {"of", "hello", "the", "house",...}
czech_set = {"z", "ahoj", "závěrky", "dům",...}
...

text_set = {"hola", "means", "hello", "in", "spanish"}

spanish_votes = text_set.intersection(spanish_set)  # 1
english_votes = text_set.intersection(english_set)  # 4
czech_votes = text_set.intersection(czech_set)  # 0
...

विधि 3: ज़िप संपीड़न

यह किसी भी चीज़ की तुलना में अधिक उत्सुकता है, लेकिन यहां यह जाता है ... आप अपने पाठ (जैसे LZ77) को संपीड़ित कर सकते हैं और फिर एक संदर्भ संपीड़ित पाठ (लक्ष्य भाषा) के संबंध में ज़िप-दूरी को माप सकते हैं। व्यक्तिगत रूप से, मुझे यह पसंद नहीं आया क्योंकि यह धीमी, कम सटीक और अन्य विधियों की तुलना में कम वर्णनात्मक है। फिर भी, इस पद्धति के लिए दिलचस्प अनुप्रयोग हो सकते हैं। अधिक पढ़ने के लिए: भाषा के पेड़ और ज़िपिंग

Question 7

आप Googletrans (अनौपचारिक) का उपयोग पायथन के लिए एक मुफ्त और असीमित Google अनुवाद एपीआई कर सकते हैं ।

आप जितने चाहें उतने अनुरोध कर सकते हैं, कोई सीमा नहीं है

स्थापना:

$ pip install googletrans

भाषा का पता लगाने:

>>> from googletrans import Translator
>>> t = Translator().detect("hello world!")
>>> t.lang
'en'
>>> t.confidence
0.8225234

Question 8

प्रीट्रेन्ड फास्ट टेक्स्ट मॉडल ने मेरी समान आवश्यकताओं के लिए सबसे अच्छा काम किया

मैं आपके प्रश्न पर एक समान आवश्यकता के साथ पहुंचा। मुझे अपनी विशिष्ट आवश्यकताओं के लिए रबाश के उत्तरों से सबसे अधिक मदद मिली।

अपनी सिफारिशों के बीच सबसे अच्छा काम करने वाले को खोजने के लिए प्रयोग करने के बाद, जो यह सुनिश्चित कर रहा था कि पाठ फाइलें 60,000+ पाठ फ़ाइलों में अंग्रेजी में थीं, मैंने पाया कि फास्टटेक्स ऐसे कार्य के लिए एक उत्कृष्ट उपकरण था।

थोड़े काम के साथ, मेरे पास एक उपकरण था जो कई फाइलों पर बहुत तेजी से काम करता था। लेकिन यह आसानी से आपके मामले की तरह कुछ के लिए संशोधित किया जा सकता है, क्योंकि फास्टटेक्स्ट आसानी से लाइनों की सूची पर काम करता है।

टिप्पणियों के साथ मेरा कोड इस पोस्ट के जवाबों में से है । मेरा मानना है कि आप और अन्य इस कोड को अन्य विशिष्ट आवश्यकताओं के लिए आसानी से संशोधित कर सकते हैं।

Question 9

आप इनपुट स्ट्रिंग में वर्णों के यूनिकोड समूह को निर्धारित करने का प्रयास कर सकते हैं, प्रकार की भाषा, (रूसी के लिए सिरिलिक, उदाहरण के लिए), और फिर पाठ में भाषा-विशिष्ट प्रतीकों की खोज करें।

Question 10

मैंने सभी पुस्तकालयों की कोशिश की है, और मैंने यह निष्कर्ष निकाला है कि pycld2 सबसे अच्छा, तेज और सटीक है।

आप इसे इस तरह स्थापित कर सकते हैं:

python -m pip install -U pycld2

आप इसे इस तरह से उपयोग कर सकते हैं:

isReliable, textBytesFound, details = cld2.detect(your_sentence)

print(isReliable, details[0][1]) # reliablity(bool),lang abbrev.(en/es/de...)