👴🏻 🏚️ 🤱 पायथन और मशीन लर्निंग के तरीकों के साथ पाठ विश्लेषण का परिचय 🐁 🙊 👨🏿‍🔬

परिचय

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

समस्या का बयान

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

डेटा प्रीप्रोसेसिंग

डेटा डाउनलोड करें और देखें कि हमारे पास क्या है:

from pandas import read_csv import pymorphy2 from sklearn.feature_extraction.text import HashingVectorizer from sklearn.cross_validation import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score, roc_auc_score from sklearn.decomposition import PCA train = read_csv('https://static.tcsbank.ru/documents/olymp/passport_training_set.csv',';', index_col='id' ,encoding='cp1251') train.head(5)

	passport_div_code	passport_issuer_name	passport_issue_month / वर्ष
आईडी
1	422,008	KEMEROVSK क्षेत्र की बेल्ट	11M2001
2	500,112	पहाड़ में टीपी नंबर 2। मो द्वारा रूस के नट-ज़ुइवो OUFMS ...	03M2009
3	642,001	वोल्गा ROVD GOR.SARATOV	04M2002
4	162,004	काज़ान शहर के मोसको जिले की एटीसी	12M2002
5	80,001	एलिस्ट में आरईएस कालिमिया पर रशिया के कार्यालय की व्यवस्था	08M2009

अब आप देख सकते हैं कि उपयोगकर्ता इकाई के उदाहरण के लिए "पासपोर्ट जारी करने वाले" क्षेत्र को कैसे रिकॉर्ड करते हैं:

 example_code = train.passport_div_code[train.passport_div_code.duplicated()].values[0] for i in train.passport_issuer_name[train.passport_div_code == example_code].drop_duplicates(): print i

कारेलिया के ग्रामीण क्षेत्र में रूस के एफएमएस की जमाबंदी। आर-ई
मेधावियों की भर्ती में आर। करेलिया में रूस के एफएमएस का मूल्यांकन
मेधावियों की संख्या में आरईएस करेलिया पर रूस के एफएमएस की जमाव
मध्ययुगीन जिले में करेलिया के प्रतिनिधि मंडल में रूस के एफएमएस की उपस्थिति
मेधावियों के राज्य बैंक में कारेलिया के रूस में रुस
Medvezhyegorsk जिले में कजाकिस्तान गणराज्य के लिए रूस की संघीय प्रवासन सेवा
करेलिया मेडीवेज़गर्सकी आर-वन के प्रतिनिधि मंडल में रूस के एफएमएस की उपस्थिति
मध्ययुगीन जिले में कजाखस्तान के राज्य में रूस के एफएमएस के संरक्षण
मध्ययुगीन जिले में कोरोलिया के गणराज्य में रूस के एफएमएस के संरक्षण
Medvezhyegorsk जिले के आर कारेलिया के लिए रूस की संघीय प्रवासन सेवा
मध्यप्रदेश में करेलिया के प्रतिनिधि मंडल में रूस के एफएमएस का जमाव
Medvezhyegorsk R-OH के करेलिया गणराज्य की संघीय प्रवासन सेवा
MEDVEZHEGORSKIY एटीएस

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

 train.passport_issuer_name = train.passport_issuer_name.str.lower() train[train.passport_div_code == example_code].head(5)

	passport_div_code	passport_issuer_name	passport_issue_month / वर्ष
आईडी
19	100,010	करेलिया गणराज्य में रूसी संघीय प्रवासन सेवा की शाखा ...	04M2008
22	100,010	रूस के यूएफएमएस का विभाग करेलिया एक भालू में ...	10M2009
5642	100,010	मेडे में करेलिया के प्रतिनिधि के लिए रूस के यूएफएमएस के विभाग द्वारा ...	08M2008
6668	100,010	करेलिया गणराज्य में रूसी संघीय प्रवासन सेवा की शाखा ...	08M2011
8732	100,010	करेलिया गणराज्य में रूसी संघीय प्रवासन सेवा की शाखा ...	08M2012

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

 train.passport_issuer_name = train.passport_issuer_name.str.replace(u'-(||||)*',u'') train.passport_issuer_name = train.passport_issuer_name.str.replace(u' ( |\.|((\.| )))', u'  ') train.passport_issuer_name = train.passport_issuer_name.str.replace(u' (\.| )', u'  ') train.passport_issuer_name = train.passport_issuer_name.str.replace(u' ([-]*)(\.)?', u'  ') train.passport_issuer_name = train.passport_issuer_name.str.replace(u' (\.| |( )?)', u'  ') train.passport_issuer_name = train.passport_issuer_name.str.replace(u'  ', u'   ')

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

 train.passport_issuer_name = train.passport_issuer_name.str.replace(u' - ?', u'-') train.passport_issuer_name = train.passport_issuer_name.str.replace(u'[^- -]','') train.passport_issuer_name = train.passport_issuer_name.str.replace(u'- ',' ') train.passport_issuer_name = train.passport_issuer_name.str.replace(u' *',' ')

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

 sokr = {u'': u'  ', u'': u'-  ', u'': u'  ', u'': u'-  ', u'': u'  ', u'': u'  ', u'': u'  ', u'c': u'  ', u'': u'  ', u'': u'- ', u'': u'- ', u'': u'- ', u'': u'- ', u'': u'    ', u'': u'   ', u'': u'   ', u'': u'  ', u'': u'   ', u'': u'   ', u'': u'   ', u'': u'  ', u'': u'   ', u'': u' ', u'': u' ', u'': u' '}

अब, हम वास्तव में संक्षिप्त विवरण को डिक्रिप्ट करेंगे और परिणामी अभिलेखों को प्रारूपित करेंगे:

 for i in sokr.iterkeys(): train.passport_issuer_name = train.passport_issuer_name.str.replace(u'( %s )|(^%s)|(%s$)' % (i,i,i), u' %s ' % (sokr[i])) #        train.passport_issuer_name = train.passport_issuer_name.str.lstrip() train.passport_issuer_name = train.passport_issuer_name.str.rstrip()

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

 train = train.drop(['passport_issue_month/year'], axis=1)

अब हम डेटा विश्लेषण पर आगे बढ़ सकते हैं।

डेटा विश्लेषण

इसलिए, हमारे पास मॉडल बनाने का डेटा है, लेकिन वे टेक्स्ट फॉर्म में हैं। एक मॉडल बनाने के लिए, उन्हें संख्यात्मक रूप में एनकोड करना अच्छा होगा।
स्किटिट-लर्न पैकेज के लेखकों ने ध्यान से हमारी देखभाल की और पाठ डेटा को निकालने और एन्कोडिंग के लिए कई तरीके जोड़े। इनमें से, मुझे सबसे अधिक दो पसंद हैं:

फ़ीचरहाशर एक स्ट्रिंग को हैश फ़ंक्शन ( मुरमुरश 3 का 32-बिट संस्करण) का उपयोग करके दिए गए लंबाई के संख्यात्मक सरणी में परिवर्तित करता है
CountVectorizer इनपुट पाठ को एक मैट्रिक्स में परिवर्तित करता है जिसके मान पाठ में इस कुंजी (शब्द) की घटनाओं की संख्या है। फ़ीचरहाशर के विपरीत, इसमें अधिक कॉन्फ़िगर करने योग्य पैरामीटर हैं (उदाहरण के लिए, आप टोकन सेट कर सकते हैं), लेकिन यह अधिक धीरे-धीरे काम करता है।
CountVectorizer के संचालन की अधिक सटीक समझ के लिए, हम एक सरल उदाहरण देते हैं। मान लें कि पाठ मानों के साथ एक तालिका है:

मूल्य
एक दो तीन
तीन चार दो दो
एक समय चार बार

शुरू करने के लिए, CountVectorizer सभी रिकॉर्ड से अद्वितीय कुंजियाँ एकत्र करता है, हमारे उदाहरण में यह होगा:

[एक, दो, तीन, चार]

अद्वितीय कुंजियों की सूची की लंबाई हमारे एन्कोडेड पाठ की लंबाई होगी (हमारे मामले में, यह 4 है)। और आइटम नंबर किसी दिए गए कुंजी की संख्या के अनुरूप होंगे जो इस संख्या को एक पंक्ति में पूरा करता है:

एक दो तीन -> [1,1,1,0]
तीन चार दो दो -> [0,2,1,1]

तदनुसार, इस पद्धति को लागू करने के बाद, हम प्राप्त करते हैं:

मूल्य
1,1,1,0
0,2,1,1
3,0,0,1

HashingVectorizer ऊपर वर्णित दो विधियों का मिश्रण है। इसमें, आप एन्कोडेड स्ट्रिंग के आकार को समायोजित कर सकते हैं (जैसा कि फीचरहैशर में ) और टोकन को कॉन्फ़िगर करें (जैसा कि काउंटवेक्टर में )। इसके अलावा, इसका प्रदर्शन फीचरहाशर के करीब है।
इसलिए, विश्लेषण पर वापस जाएं। यदि हम अपने डेटासेट पर करीब से नज़र डालते हैं, तो हम देख सकते हैं कि समान रेखाएँ हैं, लेकिन विभिन्न तरीकों से रिकॉर्ड की जाती हैं, उदाहरण के लिए: " ... रिपब्लिक ऑफ करेलिया ... " और " ... केरोलिया गणराज्य के लिए ... "।
तदनुसार, यदि हम एन्कोडिंग विधियों में से एक को लागू करने का प्रयास करते हैं, तो अब हमें बहुत समान मूल्य मिलेंगे। इस तरह के मामले को कम किया जा सकता है यदि हम रिकॉर्ड में सभी शब्दों को सामान्य रूप में लाते हैं।
इस कार्य के लिए pymorphy या nltk अच्छी तरह से अनुकूल है। मैं पहले वाले का उपयोग करूंगा, जैसा कि यह मूल रूप से रूसी भाषा के साथ काम करने के लिए बनाया गया था। तो, जो फ़ंक्शन लाइन को सामान्य करने और साफ़ करने के लिए जिम्मेदार होगा, वह इस तरह दिखता है:

 def f_tokenizer(s): morph = pymorphy2.MorphAnalyzer() if type(s) == unicode: t = s.split(' ') else: t = s f = [] for j in t: m = morph.parse(j.replace('.','')) if len(m) <> 0: wrd = m[0] if wrd.tag.POS not in ('NUMR','PREP','CONJ','PRCL','INTJ'): f.append(wrd.normal_form) return f

निम्नलिखित कार्य करता है:

सबसे पहले, यह स्ट्रिंग को एक सूची में परिवर्तित करता है
तब यह सभी शब्दों को पार्स करता है
यदि शब्द एक अंक, विधेय, पूर्वसर्ग, संघ, कण या अंतर्विरोध है, तो इसे अंतिम सेट में शामिल न करें
यदि शब्द पिछली सूची में नहीं आया, तो इसका सामान्य रूप लें और इसे अंतिम सेट में जोड़ें

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

 coder = HashingVectorizer(tokenizer=f_tokenizer, n_features=256)

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

 TrainNotDuble = train.drop_duplicates() trn = coder.fit_transform(TrainNotDuble.passport_issuer_name.tolist()).toarray()

मॉडल बिल्डिंग

सबसे पहले, हमें उस कॉलम के लिए मान सेट करने की आवश्यकता है जिसमें कक्षा लेबल होंगे:

 target = TrainNotDuble.passport_div_code.values

आज हम जो समस्या हल कर रहे हैं, वह कई वर्गों के साथ वर्गीकरण की समस्याओं का वर्ग है। इस समस्या को हल करने के लिए, RandomForest एल्गोरिथ्म सबसे उपयुक्त था। बाकी एल्गोरिदम ने बहुत खराब परिणाम (50% से कम) दिखाए, इसलिए मैंने लेख में जगह नहीं लेने का फैसला किया। यदि आप चाहें, तो कोई भी व्यक्ति इन परिणामों की जांच कर सकता है।
वर्गीकरण की गुणवत्ता का आकलन करने के लिए, हम उन दस्तावेजों की संख्या का उपयोग करेंगे जिनके लिए सही निर्णय लिया गया था, अर्थात्।
$LaTeX: सटीकता = \ frac {P} {N}$
, जहां पी दस्तावेजों की संख्या है जिसके द्वारा क्लासिफायरियर ने सही निर्णय लिया, और एन प्रशिक्षण नमूने का आकार है।
Scikit-learn पैकेज में इसके लिए एक फ़ंक्शन है: सटीकता_स्कोर
मॉडल का निर्माण शुरू करने से पहले, आइए, “प्रमुख घटक विधि” का उपयोग करके आयाम को कम करें, क्योंकि प्रशिक्षण के लिए काफी कुछ 256 कॉलम हैं:

 pca = PCA(n_components = 15) trn = pca.fit_transform(trn)

मॉडल इस तरह दिखेगा:

 model = RandomForestClassifier(n_estimators = 100, criterion='entropy') TRNtrain, TRNtest, TARtrain, TARtest = train_test_split(trn, target, test_size=0.4) model.fit(TRNtrain, TARtrain) print 'accuracy_score: ', accuracy_score(TARtest, model.predict(TRNtest))

सटीकता_स्कोर: 0.6523456

निष्कर्ष

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

UPD : IPython नोटबुक कंसोल TKCTask2Answer.ipynb