🚠 🥠 🔙 पायथन 3 में रूसी पाठ (पीओएस-टैगिंग) में भाषण के एक भाग की परिभाषा 👨‍👩‍👧‍👧 🥋 🥤

आज्ञा देना, वाक्य " इन नरम फ्रेंच रोल खाओ, हाँ चाय पीते हैं। ", जिसमें हमें प्रत्येक शब्द के लिए भाषण के भाग को निर्धारित करना होगा:

[('', '.'), ('', '.'), ('', '. .'), ('', '.'), ('', '.'), ('', '.'), ('', ''), ('', '.'), ('', '.')]

इसकी आवश्यकता क्यों है? उदाहरण के लिए, स्वचालित रूप से ब्लॉग पोस्ट के लिए टैग (संज्ञाओं के चयन के लिए) की पहचान करना। मॉर्फोलॉजिकल मार्कअप कंप्यूटर टेक्स्ट विश्लेषण के पहले चरणों में से एक है।

मौजूदा समाधान

बेशक, हमारे सामने सब कुछ पहले से ही आविष्कार किया गया है। रूसी भाषा के समर्थन के साथ यैंडेक्स , ट्रीटैगर से एक मस्टीस्ट है, पायथन ने nltk है , साथ ही किमीइक से पाइमोर्फी भी । ये सभी उपयोगिताओं ठीक काम करती हैं, हालांकि pymorphy में python 3 का समर्थन नहीं है, और nltk के पास केवल python के तीसरे संस्करण के लिए बीटा समर्थन है (और कुछ हमेशा हमेशा के लिए बंद हो जाता है)। लेकिन मॉड्यूल बनाने के लिए वास्तविक लक्ष्य अकादमिक है, यह समझने के लिए कि रूपात्मक विश्लेषक कैसे काम करता है।

एल्गोरिथ्म

शुरू करने के लिए, हम समझेंगे कि एक साधारण व्यक्ति यह निर्धारित करता है कि भाषण का कौन सा हिस्सा किस शब्द को संदर्भित करता है।

आमतौर पर हम जानते हैं कि भाषण का कौन सा हिस्सा हमारे लिए परिचित शब्द है। उदाहरण के लिए, हम जानते हैं कि " खाओ " एक क्रिया है।
यदि हम एक ऐसे शब्द के बारे में जानते हैं जिसे हम नहीं जानते हैं, तो हम भाषण के कुछ हिस्सों को परिचित शब्दों के साथ तुलना करके अनुमान लगा सकते हैं। उदाहरण के लिए, हम अनुमान लगा सकते हैं कि शब्द " सर्वांगसम " एक संज्ञा है, अर्थात अंत " -यॉस्ट " है, जो आमतौर पर संज्ञाओं में निहित है।
हम यह भी अनुमान लगा सकते हैं कि वाक्य में शब्दों की पंक्ति के बाद यह किस भाग का है: " फ्रेंच एक्स खाएं " - इस उदाहरण में, x की संज्ञा होने की संभावना है।
शब्द की लंबाई भी उपयोगी जानकारी प्रदान कर सकती है। यदि इस शब्द में केवल एक या दो अक्षर हैं, तो सबसे अधिक संभावना है कि यह एक पूर्वसर्ग, सर्वनाम या संयोजन है।

बेशक, एक कंप्यूटर के लिए यह कार्य कुछ अधिक जटिल होगा, क्योंकि उसके पास वह ज्ञान आधार नहीं है जो किसी व्यक्ति के पास है। लेकिन हम अपने पास उपलब्ध डेटा का उपयोग करके कंप्यूटर प्रशिक्षण का अनुकरण करने का प्रयास करेंगे।

डेटा

हमारी स्क्रिप्ट को प्रशिक्षित करने के लिए, मैंने रूसी भाषा के राष्ट्रीय कोष का उपयोग किया। कॉर्पस भाग, SynTagRus, प्रत्येक शब्द के लिए चिह्नित जानकारी के साथ ग्रंथों का एक संग्रह है, जैसे कि भाषण का हिस्सा, संख्या, मामला, क्रिया काल, आदि। यह एक्सएमएल प्रारूप में शरीर का हिस्सा कैसा दिखता है:

 <se> <w><ana lex="" gr="PR"></ana>`</w> <w><ana lex="" gr="S-PRO,n,sg=ins"></ana></w> <w><ana lex="" gr="S,m,anim=pl,nom"></ana>`</w> <w><ana lex="" gr="V,ipf,intr,act=pl,praes,3p,indic"></ana>`</w> <w><ana lex="" gr="PR"></ana></w> <w><ana lex="" gr="S,f,inan=pl,acc"></ana>`</w> . </se> <se> <w><ana lex="" gr="PART"></ana></w> <w><ana lex="" gr="ADV-PRO"></ana></w>, <w><ana lex="" gr="PR"></ana>`</w> <w><ana lex="" gr="NUM=acc"></ana></w> <w><ana lex="" gr="S,f,inan=pl,gen"></ana>`</w> <w><ana lex="" gr="PR"></ana></w> <w><ana lex="" gr="S,f,inan=pl,gen"></ana></w> , <w><ana lex="" gr="V,pf,intr,med=m,sg,praet,indic"></ana>``</w> <w><ana lex="" gr="A=m,sg,nom,plen"></ana>`</w> <w><ana lex="" gr="S,m,anim=sg,nom"></ana>`</w> . </se>

वाक्य <se> टैग्स में संलग्न हैं, जिसके अंदर <w> टैग में शब्द हैं। प्रत्येक शब्द के बारे में जानकारी <ana> टैग में निहित है, lex विशेषता एक टोकन, जीआर - व्याकरणिक श्रेणियों से मेल खाती है। पहली श्रेणी भाषण का हिस्सा है:

'S': '.',
'A': '.',
'NUM': '.',
'A-NUM': '.-.',
'V': '.',
'ADV': '.',
'PRAEDIC': '',
'PARENTH': '',
'S-PRO': '. .',
'A-PRO': '. .',
'ADV-PRO': '. .',
'PRAEDIC-PRO': '. .',
'PR': '',
'CONJ': '',
'PART': '',
'INTJ': '.'

SVM

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

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

यहां तक कि शैक्षणिक उद्देश्यों के लिए, SVM को लागू करना बहुत आलसी है, इसलिए हम तैयार CIB लाइब्रेरी LIBLINEAR का उपयोग करेंगे , जिसमें अजगर के लिए एक आवरण है। मॉडल को प्रशिक्षित करने के लिए, हम ट्रेन (प्रोब, परम) फ़ंक्शन का उपयोग करते हैं, जो समस्या को पहले तर्क के रूप में लेता है: समस्या (y, x) , जहां सरणी एक्स से प्रत्येक उदाहरण के लिए y भाषण के कुछ हिस्सों का सरणी है। प्रत्येक उदाहरण को विशेषताओं के वेक्टर द्वारा बदले में दर्शाया जाता है। समस्या के इस तरह के बयान को प्राप्त करने के लिए, हमें पहले भाषण के प्रत्येक भाग और प्रत्येक विशेषता को एक निश्चित संख्या के साथ सहसंबंधित करना होगा। उदाहरण के लिए:

 '''  -   -   - . ''' x = [{1001: 1, 2001: 1, 3001: 1}, # 1001 - , 2001 - , 3001 -  {1002: 1, 2002: 1, 3001: 1}, # 1002 - , 2002 - , 3001 -  {1003: 1, 2003: 1, 3002: 1}] # 1003 - , 2003 - , 3002 -  y = [1, 1, 2] # 1 - , 2 - . import liblinearutil as svm problem = svm.problem(y, x) #   param = svm.parameter('-c 1 -s 4') #   model = svm.train(prob, param) #   #      '' label, acc, vals = svm.predict([0], {1001: 1, 2001: 1, 3001: 1}, model, '') # [0] - ,

परिणामस्वरूप, हमारा एल्गोरिथ्म इस प्रकार है:

हम कॉर्पस फ़ाइल पढ़ते हैं और प्रत्येक शब्द के लिए हम इसकी विशेषताओं को निर्धारित करते हैं: शब्द ही, समाप्त होने वाला (अंतिम 2 और 3 अक्षर), उपसर्ग (पहले 2 और 3 अक्षर), साथ ही पिछले शब्दों के भाषण भागों।
हम भाषण और विशेषता के प्रत्येक भाग के लिए एक सीरियल नंबर प्रदान करते हैं और एसवीएम प्रशिक्षण के लिए एक कार्य बनाते हैं
SVM मॉडल सीखना
हम वाक्य में शब्दों के भाषण का हिस्सा निर्धारित करने के लिए प्रशिक्षित मॉडल का उपयोग करते हैं: इसके लिए, प्रत्येक शब्द को फिर से विशेषताओं के रूप में प्रस्तुत किया जाना चाहिए और एसवीएम मॉडल के इनपुट को खिलाया जाना चाहिए, जो कि सबसे उपयुक्त वर्ग का चयन करेगा, अर्थात्। भाषण का हिस्सा।

कार्यान्वयन

स्रोत कोड यहां पाया जा सकता है: github.com/irokez/Pyrus/tree/master/src

आवास

पहले आपको एक चिह्नित मामला प्राप्त करने की आवश्यकता है। रूसी भाषा के राष्ट्रीय कोर को बहुत ही रहस्यमय तरीके से वितरित किया जाता है। वाहिनी वेबसाइट पर ही, आप केवल ग्रंथों के माध्यम से खोज सकते हैं, लेकिन आप पूरे वाहिनी को डाउनलोड नहीं कर सकते:

"कॉर्पस का ऑफ-लाइन संस्करण उपलब्ध नहीं है, लेकिन 180 हजार शब्द प्रयोग (90 हजार प्रेस, 90 हजार साहित्यिक ग्रंथों, कानून और वैज्ञानिक ग्रंथों) के नि: शुल्क उपयोग के लिए हटाए गए शब्दकोष के साथ कारपस से वाक्यों का एक यादृच्छिक चयन (परेशान आदेश के साथ) मुफ्त उपयोग के लिए प्रदान किया गया है" ।

इसके अलावा, यह विकिपीडिया पर लिखा गया है

"कॉर्पस को ऑफ-लाइन उपलब्ध कराया जाएगा और गैर-वाणिज्यिक उद्देश्यों के लिए वितरित किया जाएगा, लेकिन वर्तमान में कुछ तकनीकी और / या कॉपीराइट समस्याओं के कारण यह केवल ऑन-लाइन उपलब्ध है।"

हालाँकि हमारे उद्देश्यों के लिए केस का एक छोटा सा नमूना उपलब्ध होगा, यहाँ उपलब्ध है: www.ruscorpora.ru/download/shuffled_rnc.zip

परिणामी संग्रह में मौजूद फाइलें Convert-rnc.py यूटिलिटी से गुजरनी चाहिए, जो टेक्स्ट को UTF-8 में बदल देती है और XML मार्कअप को सही करती है। उसके बाद, आपको अभी भी XML को मैन्युअल रूप से ठीक करने की आवश्यकता हो सकती है (xmllint आपकी सहायता के लिए)। Rnc.py फ़ाइल में सामान्यीकृत XML nat फ़ाइलों को पढ़ने के लिए एक साधारण रीडर वर्ग होता है। आवास।

 import xml.parsers.expat class Reader: def __init__(self): self._parser = xml.parsers.expat.ParserCreate() self._parser.StartElementHandler = self.start_element self._parser.EndElementHandler = self.end_element self._parser.CharacterDataHandler = self.char_data def start_element(self, name, attr): if name == 'ana': self._info = attr def end_element(self, name): if name == 'se': self._sentences.append(self._sentence) self._sentence = [] elif name == 'w': self._sentence.append((self._cdata, self._info)) elif name == 'ana': self._cdata = '' def char_data(self, content): self._cdata += content def read(self, filename): f = open(filename) content = f.read() f.close() self._sentences = [] self._sentence = [] self._cdata = '' self._info = '' self._parser.Parse(content) return self._sentences

Reader.read (स्वयं, फ़ाइल नाम) विधि फ़ाइल को पढ़ती है और वाक्यों की सूची प्रदर्शित करती है:

 [[('`', {'lex': '', 'gr': 'S,m,anim=sg,nom'}), ('`', {'lex': '', 'gr': 'S,f,inan=sg,gen'}), ('`', {'lex': '', 'gr': 'A-PRO=f,sg,acc'}), ('`', {'lex': '', 'gr': 'S,m,anim=pl,nom'}), ('`', {'lex': '', 'gr': 'V,pf,tran=pl,act,praet,indic'}), ('', {'lex': '', 'gr': 'PR'}), ('', {'lex': '', 'gr': 'S,m,inan,0=sg,gen'}), ('`', {'lex': '', 'gr': 'V,pf,tran=m,sg,act,praet,indic'}), ('', {'lex': '', 'gr': 'S-PRO,pl,3p=dat'}), ('`', {'lex': '', 'gr': 'A=n,sg,acc,inan,plen'}), ('`', {'lex': '', 'gr': 'S,n,inan=sg,acc'}), ('', {'lex': '', 'gr': 'PR'}), ('', {'lex': '', 'gr': 'S-PRO,n,sg=acc'}), ('`', {'lex': '', 'gr': 'V,pf,intr,med=m,sg,praet,indic'}), ('`', {'lex': '', 'gr': 'S,f,inan=sg,ins'})]]

सीखना और मार्कअप करना

SVM लाइब्रेरी को यहाँ डाउनलोड किया जा सकता है: http://www.csie.ntu.edu.tw/~cjlin/liblinear/ । तीसरे संस्करण के तहत अजगर के काम के लिए रैपर बनाने के लिए, मैंने एक छोटा सा पैच लिखा।

पॉज़्डो फ़ाइल में दो मुख्य वर्ग होते हैं: टैगर और टैगरफ्रीचर । टेगर वास्तव में, एक वर्ग है जो पाठ का मार्कअप करता है, अर्थात। प्रत्येक शब्द को उसके बोलने के भाग के लिए परिभाषित करता है। Tagger.train पद्धति (स्वयं, वाक्य, लेबल) तर्कों के रूप में वाक्यों की एक सूची (rnc.Reader.read के समान प्रारूप में) लेती है, साथ ही साथ प्रत्येक शब्द के लिए भाषण के कुछ हिस्सों की एक सूची, जिसके बाद यह पुस्तकालय का उपयोग करके SVM मॉडल को प्रशिक्षित करता है। LIBLINEAR। प्रशिक्षित मॉडल को बाद में (Tagger.save विधि के माध्यम से) सहेजा जाता है ताकि मॉडल को हर बार प्रशिक्षित न किया जा सके। Tagger.label (स्व, वाक्य) विधि वाक्य को चिह्नित करती है ।

TaggerFeatures वर्ग प्रशिक्षण और लेआउट के लिए विशेषताओं को बनाने के लिए डिज़ाइन किया गया है। TaggerFeatures.from_body () एक शब्द के रूप में एक विशेषता देता है, अर्थात कॉर्पस में शब्द आईडी लौटाता है। TaggerFeatures.from_suffix () और TaggerFeatures.from_prefix () शब्दों के अंत और उपसर्ग पर विशेषताएँ उत्पन्न करते हैं।

मॉडल प्रशिक्षण शुरू करने के लिए, एक ट्रेन एरो स्क्रिप्ट लिखी गई थी जो rnc.Reader का उपयोग करके शेल फ़ाइलों को पढ़ती है, और फिर Tagger.train पद्धति को कॉल करती है:

 import sys import re import rnc import pos sentences = [] sentences.extend(rnc.Reader().read('tmp/media1.xml')) sentences.extend(rnc.Reader().read('tmp/media2.xml')) sentences.extend(rnc.Reader().read('tmp/media3.xml')) re_pos = re.compile('([\w-]+)(?:[^\w-]|$)'.format('|'.join(pos.tagset))) tagger = pos.Tagger() sentence_labels = [] sentence_words = [] for sentence in sentences: labels = [] words = [] for word in sentence: gr = word[1]['gr'] m = re_pos.match(gr) if not m: print(gr, file = sys.stderr) pos = m.group(1) if pos == 'ANUM': pos = 'A-NUM' label = tagger.get_label_id(pos) if not label: print(gr, file = sys.stderr) labels.append(label) body = word[0].replace('`', '') words.append(body) sentence_labels.append(labels) sentence_words.append(words) tagger.train(sentence_words, sentence_labels, True) tagger.train(sentence_words, sentence_labels) tagger.save('tmp/svm.model', 'tmp/ids.pickle')

मॉडल को प्रशिक्षित करने और सहेजने के बाद, हमें अंततः पाठ को चिह्नित करने के लिए एक स्क्रिप्ट मिली। उदाहरण का उपयोग test.py में दिखाया गया है:

 import sys import pos sentence = sys.argv[1].split(' ') tagger = pos.Tagger() tagger.load('tmp/svm.model', 'tmp/ids.pickle') rus = { 'S': '.', 'A': '.', 'NUM': '.', 'A-NUM': '.-.', 'V': '.', 'ADV': '.', 'PRAEDIC': '', 'PARENTH': '', 'S-PRO': '. .', 'A-PRO': '. .', 'ADV-PRO': '. .', 'PRAEDIC-PRO': '. .', 'PR': '', 'CONJ': '', 'PART': '', 'INTJ': '.', 'INIT': '', 'NONLEX': '' } tagged = [] for word, label in tagger.label(sentence): tagged.append((word, rus[tagger.get_label(label)])) print(tagged)

यह इस तरह काम करता है:

$ src/test.py " , "
[('', '.'), ('', '.'), ('', '. .'), ('', '.'), ('', '.'), (',', '.'), ('', ''), ('', '.'), ('', ''), ('', '.')]

परीक्षण

एल्गोरिथ्म के वर्गीकरण की सटीकता का आकलन करने के लिए, प्रशिक्षण विधि Tagger.train () में एक वैकल्पिक पैरामीटर cross_validation है , जो यदि True पर सेट है, तो क्रॉस चेक करेगा , अर्थात्। प्रशिक्षण डेटा को K भागों में विभाजित किया गया है, जिसके बाद प्रत्येक भाग को विधि के संचालन का मूल्यांकन करने के लिए उपयोग किया जाता है, जबकि शेष का उपयोग प्रशिक्षण के लिए किया जाता है। मैं 92% की औसत सटीकता हासिल करने में कामयाब रहा, जो काफी अच्छा है, यह देखते हुए कि नेट के केवल एक सुलभ हिस्से का उपयोग किया गया था। आवास। आमतौर पर, भाषण के एक हिस्से के मार्कअप की सटीकता 96-98% तक होती है ।

निष्कर्ष और भविष्य की योजना

सामान्य तौर पर, नेट के साथ काम करना दिलचस्प था। आवास। यह देखा जा सकता है कि इस पर बहुत काम किया गया है, और इसमें बड़ी मात्रा में जानकारी है जिसे मैं पूरी तरह से उपयोग करना चाहूंगा। मैंने पूर्ण संस्करण के लिए अनुरोध भेजा, लेकिन, दुर्भाग्य से, अभी तक कोई जवाब नहीं है।

परिणामी मार्कअप स्क्रिप्ट को आसानी से विस्तारित किया जा सकता है ताकि यह अन्य रूपात्मक श्रेणियों को भी परिभाषित करे, उदाहरण के लिए, संख्या, लिंग, केस, आदि। मैं भविष्य में क्या करूंगा। भविष्य में, निश्चित रूप से, मैं रूसी भाषा के वाक्यविन्यास पार्सर को वाक्य संरचना प्राप्त करने के लिए लिखना चाहूंगा, लेकिन इसके लिए कॉर्पस के पूर्ण संस्करण की आवश्यकता है।

मुझे सवालों और सुझावों का जवाब देने में खुशी होगी।
स्रोत कोड यहां उपलब्ध है: github.com/irokez/Pyrus
डेमो: http://vps11096.ovh.net:8080

पायथन 3 में रूसी पाठ (पीओएस-टैगिंग) में भाषण के एक भाग की परिभाषा