यह पता लगाने के लिए कि पाठ अंग्रेजी है (थोक में)

Question

मैं यह जानने का एक आसान तरीका ढूंढ रहा हूं कि टेक्स्ट का संक्षिप्त अंश, कुछ वाक्यों अंग्रेजी है या नहीं। मुझे लगता है कि यह समस्या मनमानी भाषा का पता लगाने की कोशिश करने से कहीं अधिक आसान है। क्या वहां कोई सॉफ्टवेयर है जो ऐसा कर सकता है? मैं अजगर में लिख रहा हूं, और एक अजगर पुस्तकालय पसंद करूंगा, लेकिन कुछ और भी ठीक होगा। मैंने Google की कोशिश की है, लेकिन फिर एहसास हुआ कि टीओएस ने स्वचालित प्रश्नों की अनुमति नहीं दी है।

Answer 1

मैं एक विधि पढ़ Trigrams

http://en.wikipedia.org/wiki/Trigram

आप पाठ के ऊपर जा सकते हैं, और में सबसे अधिक इस्तेमाल trigrams पता लगाने का प्रयास का उपयोग करके Enlgish भाषा के पता लगाने के लिए शब्द। सबसे अधिक इस्तेमाल किया लोगों को सबसे अंग्रेज़ी शब्द के बीच में इस्तेमाल किया साथ मेल खाते हैं, पाठ अंग्रेजी

में

कोशिश लिखा जा सकता है इस माणिक परियोजना में देखने के लिए:

https://github.com/feedbackmine/language_detector

Answer 2

संपादित करें: यह इस मामले में काम नहीं करेगा, क्योंकि ओपी Google के TOS के विरुद्ध थोक में पाठ संसाधित कर रहा है।

Google अनुवाद language detect API का उपयोग करें। डॉक्स से अजगर उदाहरण:

url = ('https://ajax.googleapis.com/ajax/services/language/detect?' + 
     'v=1.0&q=Hola,%20mi%20amigo!&key=INSERT-YOUR-KEY&userip=INSERT-USER-IP') 
request = urllib2.Request(url, None, {'Referer': /* Enter the URL of your site here */}) 
response = urllib2.urlopen(request) 
results = simplejson.load(response) 
if results['responseData']['language'] == 'en': 
    print 'English detected' 

Answer 3

हालांकि Google की अपनी के रूप में के रूप में अच्छा नहीं, मेरे पास अपाचे नच भाषाइंडिफायर का उपयोग करके अच्छे परिणाम हुए हैं जो अपने स्वयं के प्रक्षेपित एनजीआरएम मॉडल के साथ आता है। मेरे पास कई भाषाओं में वास्तविक दुनिया के डेटा के बड़े (50 जीबी पीडीएफ, टेक्स्ट-ज्यादातर) कॉर्पस पर काफी अच्छे परिणाम थे।

यह जावा में है, लेकिन मुझे यकीन है कि यदि आप इसे पायथन में पुन: कार्यान्वित करना चाहते हैं तो आप इससे ngram प्रोफाइल को फिर से पढ़ सकते हैं।

Answer 4

Google अनुवाद API v2 allows automated queries लेकिन इसे एक एपीआई कुंजी के उपयोग की आवश्यकता है जिसे आप स्वतंत्र रूप से Google APIs console पर प्राप्त कर सकते हैं।

का पता लगाने के लिए कि क्या पाठ आप सवाल Python - can I detect unicode string language code? करने के लिए अपने जवाब से detect_language_v2() समारोह (कि कि API का उपयोग करता) इस्तेमाल कर सकते हैं अंग्रेजी है:

if all(lang == 'en' for lang in detect_language_v2(['some text', 'more text'])): 
    # all text fragments are in English 

Answer 5

मैं हाल ही में इस के लिए एक समाधान लिखा था। मेरा समाधान मूर्ख प्रमाण नहीं है और मुझे नहीं लगता कि यह बड़ी मात्रा में टेक्स्ट के लिए कम्प्यूटेशनल रूप से व्यवहार्य होगा, लेकिन ऐसा लगता है कि मुझे छोटे वाक्यों के लिए अच्छा काम करना है।

मान लीजिए आप पाठ की दो तार है:

1. "LETMEBEGINBYSAYINGTHANKS"
2. "UNGHSYINDJFHAKJSNFNDKUAJUD"

लक्ष्य तो निर्धारित करने के लिए कि 1. शायद अंग्रेजी है, जबकि 2. नहीं है । सहजता से, जिस तरह से मेरा दिमाग यह निर्धारित करता है कि वाक्यों में अंग्रेजी शब्दों की शब्द सीमाएं (एलईटी, एमई, BEGIN, आदि) की तलाश है। लेकिन यह कम्प्यूटेशनल रूप से सरल नहीं है क्योंकि अतिव्यापी शब्द हैं (बीई, जीआईएन, BEGIN, कहें, कहें, धन्यवाद, धन्यवाद, आदि)।

1. { known English words } और { all substrings of the text of all lengths } के चौराहे लें:

   मेरे पद्धति का अनुसरण करता है।

2. शिखर के एक ग्राफ का निर्माण, जिनके पद वाक्य के शब्दों के प्रारंभिक सूचकांक हैं, निर्देशित किनारों के साथ शब्द के अंत के बाद पत्र की शुरुआती स्थिति में। E.g, (0)L होगा, इसलिए "LET" का प्रतिनिधित्व (0) -> (3) द्वारा किया जा सकता है, जहां (3)M है, इसलिए यह "मुझे दो" है।
3. सबसे बड़ा पूर्णांक n 0 और len(text) के बीच खोजें जिसके लिए एक सरल निर्देशित पथ इंडेक्स 0 से सूचकांक n पर मौजूद है।
4. पाठ की लंबाई से n उस संख्या को विभाजित करने के लिए पाठ का प्रतिशत कितना प्रतिशत अंग्रेजी शब्द दिखाई देता है।

ध्यान दें कि मेरा कोड शब्दों के बीच कोई स्थान नहीं मानता है, लेकिन मुझे लगता है कि आप इसे आसानी से रिक्त स्थान पर विचार करने के लिए अनुकूलित कर सकते हैं। ऐसा नहीं है कि मेरे कोड को काम करने के लिए आपको एक अंग्रेजी शब्दसूची फ़ाइल की आवश्यकता है। मुझे here से एक मिला है, लेकिन आप ऐसी किसी भी फ़ाइल का उपयोग कर सकते हैं, और मुझे कल्पना है कि इस तकनीक को अन्य भाषाओं में भी बढ़ाया जा सकता है। यहाँ

from collections import defaultdict 

# This function tests what percent of the string seems to me to be maybe 
# English-language 
# We use an English words list from here: 
# https://github.com/first20hours/google-10000-english 
def englishness(maybeplaintext): 
    maybeplaintext = maybeplaintext.lower() 
    f = open('words.txt', 'r') 
    words = f.read() 
    f.close() 
    words = words.lower().split("\n") 
    letters = [c for c in maybeplaintext] 
    # Now let's iterate over letters and look for some English! 
    wordGraph = defaultdict(list) 
    lt = len(maybeplaintext) 
    for start in range(0, lt): 
     st = lt - start 
     if st > 1: 
      for length in range(2, st): 
       end = start + length 
       possibleWord = maybeplaintext[start:end] 
       if possibleWord in words: 
        if not start in wordGraph: 
         wordGraph[start] = [] 
        wordGraph[start].append(end) 
    # Ok, now we have a big graph of words. 
    # What is the shortest path from the first letter to the last letter, 
    # moving exclusively through the English language? 
    # Does any such path exist? 
    englishness = 0 
    values = set([a for sublist in list(wordGraph.values()) for a in sublist]) 
    numberVertices = len(set(wordGraph.keys()).union(values)) 
    for i in range(2, lt): 
     if isReachable(numberVertices, wordGraph, i): 
      englishness = i 
    return englishness/lt 

# Here I use my modified version of the technique from: 
# https://www.geeksforgeeks.org/ 
# find-if-there-is-a-path-between-two-vertices-in-a-given-graph/ 
def isReachable(numberVertices, wordGraph, end): 
    visited = [0] 
    queue = [0] 
    while queue: 
     n = queue.pop(0) 
     if n == end or n > end: 
      return True 
     for i in wordGraph[n]: 
      if not i in visited: 
       queue.append(i) 
       visited.append(i) 
    return False 

और प्रारंभिक उदाहरण मैं दे दी है के लिए I/O है:

यहाँ कोड है

In [5]: englishness('LETMEBEGINBYSAYINGTHANKS') 
Out[5]: 0.9583333333333334 

In [6]: englishness('UNGHSYINDJFHAKJSNFNDKUAJUD') 
Out[6]: 0.07692307692307693 

तो फिर लगभग शब्दों में, मैं कर रहा हूँ 96% निश्चित LETMEBEGINBYSAYINGTHANKS अंग्रेजी नहीं है, और 8% निश्चित है कि UNGHSYINDJFHAKJSNFNDKUAJUD अंग्रेजी है। जो सही के बारे में लगता है!

टेक्स्ट के बहुत बड़े टुकड़ों को विस्तारित करने के लिए, मेरा सुझाव यादृच्छिक लघु सबस्ट्रिंग को कम करना होगा और उनकी "अंग्रेजी" जांचना होगा। उम्मीद है की यह मदद करेगा!