👨🏿 👩🏾‍🏫 🙏🏻 मशीन लर्निंग का उपयोग करते हुए टिकट समाधान समय की भविष्यवाणी करना 👩🏽‍🔬 ⏩ 👨🏻‍🔧

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

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

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

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

तो, चलिए शब्दों से कर्मों की ओर बढ़ते हैं।

प्रारंभिक डेटा विश्लेषण

हम अपनी ज़रूरत की सभी चीज़ों को लोड करते हैं और उपयोग किए गए पैकेज के संस्करण प्रदर्शित करते हैं।

स्रोत कोड

import warnings warnings.simplefilter('ignore') %matplotlib inline import matplotlib.pyplot as plt import pandas as pd import numpy as np import datetime from nltk.corpus import stopwords from sklearn.model_selection import train_test_split from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.neighbors import KNeighborsRegressor from sklearn.linear_model import LinearRegression from datetime import time, date for package in [pd, np, matplotlib, sklearn, nltk]: print(package.__name__, 'version:', package.__version__)

 pandas version: 0.23.4 numpy version: 1.15.0 matplotlib version: 2.2.2 sklearn version: 0.19.2 nltk version: 3.3

सीएसवी फ़ाइल से डेटा डाउनलोड करें। इसमें पिछले 1.5 वर्षों से बंद टिकटों की जानकारी है। फ़ाइल में डेटा लिखने से पहले, वे पहले से संसाधित थे। उदाहरण के लिए, अल्पविराम और अवधि को वर्णन के साथ पाठ क्षेत्रों से हटा दिया गया है। हालांकि, यह केवल प्रारंभिक प्रसंस्करण है और भविष्य में पाठ को और अधिक साफ किया जाएगा।

आइए देखें कि हमारे डेटा सेट में क्या है। कुल मिलाकर 10783 टिकट इसमें मिले।

क्षेत्र की व्याख्या

बनाया गया	टिकट निर्माण की तारीख और समय
हल	टिकट की समाप्ति तिथि और समय
Resolution_time	टिकट बनाने और बंद करने के बीच कई मिनट बीत गए। इसे कैलेंडर का समय माना जाता है, क्योंकि कंपनी के विभिन्न देशों में कार्यालय हैं, विभिन्न समय क्षेत्रों में काम कर रहे हैं और पूरे विभाग के लिए कोई निश्चित समय नहीं है।
Engineer_N	इंजीनियरों के "कोडेड" नाम (ताकि अनजाने में भविष्य में कोई व्यक्तिगत या गोपनीय जानकारी न दे, लेख में "एन्कोडेड" डेटा का एक बहुत होगा, जो वास्तव में बस नाम बदल दिया जाता है)। इन फ़ील्डों में प्रस्तुत दिनांक सेट में प्रत्येक टिकट की प्राप्ति के समय "प्रगति में" मोड में टिकटों की संख्या होती है। मैं लेख के अंत में इन क्षेत्रों पर अलग से रहूंगा, क्योंकि वे अतिरिक्त ध्यान देने योग्य हैं।
संपत्ति-भागी	जो कर्मचारी समस्या को हल करने में शामिल था।
ISSUE_TYPE	टिकट का प्रकार।
वातावरण	परीक्षण कार्य वातावरण का नाम जिसके लिए टिकट बनाया गया था (इसका मतलब या तो एक विशिष्ट वातावरण या पूरे के रूप में स्थान हो सकता है, उदाहरण के लिए, एक डेटा केंद्र)।
प्राथमिकता	टिकट प्राथमिकता।
Worktype	इस टिकट के लिए अपेक्षित कार्य का प्रकार (सर्वर को जोड़ना या हटाना, पर्यावरण को अद्यतन करना, निगरानी के साथ काम करना, आदि)
विवरण	विवरण
सारांश	टिकट का शीर्षक।
पर नजर रखने वालों	टिकट को "देखने" वाले लोगों की संख्या, अर्थात्। वे टिकट में प्रत्येक गतिविधि के लिए ईमेल सूचनाएं प्राप्त करते हैं।
वोट	टिकट के लिए "वोट" करने वालों की संख्या, जिससे इसका महत्व और इसमें उनकी रुचि दिखाई दे रही है।
रिपोर्टर	वह व्यक्ति जिसने टिकट जारी किया था।
Engineer_N_vacation	टिकट जारी करने के समय इंजीनियर छुट्टी पर था या नहीं।

 df.info()

 <class 'pandas.core.frame.DataFrame'> Index: 10783 entries, ENV-36273 to ENV-49164 Data columns (total 37 columns): Created 10783 non-null object Resolved 10783 non-null object Resolution_time 10783 non-null int64 engineer_1 10783 non-null int64 engineer_2 10783 non-null int64 engineer_3 10783 non-null int64 engineer_4 10783 non-null int64 engineer_5 10783 non-null int64 engineer_6 10783 non-null int64 engineer_7 10783 non-null int64 engineer_8 10783 non-null int64 engineer_9 10783 non-null int64 engineer_10 10783 non-null int64 engineer_11 10783 non-null int64 engineer_12 10783 non-null int64 Assignee 10783 non-null object Issue_type 10783 non-null object Environment 10771 non-null object Priority 10783 non-null object Worktype 7273 non-null object Description 10263 non-null object Summary 10783 non-null object Watchers 10783 non-null int64 Votes 10783 non-null int64 Reporter 10783 non-null object engineer_1_vacation 10783 non-null int64 engineer_2_vacation 10783 non-null int64 engineer_3_vacation 10783 non-null int64 engineer_4_vacation 10783 non-null int64 engineer_5_vacation 10783 non-null int64 engineer_6_vacation 10783 non-null int64 engineer_7_vacation 10783 non-null int64 engineer_8_vacation 10783 non-null int64 engineer_9_vacation 10783 non-null int64 engineer_10_vacation 10783 non-null int64 engineer_11_vacation 10783 non-null int64 engineer_12_vacation 10783 non-null int64 dtypes: float64(12), int64(15), object(10) memory usage: 3.1+ MB

कुल में, हमारे पास 10 "ऑब्जेक्ट" फ़ील्ड हैं (जो कि पाठ मान युक्त है) और 27 संख्यात्मक फ़ील्ड हैं।
सबसे पहले, तुरंत हमारे डेटा में उत्सर्जन की तलाश करें। जैसा कि आप देख सकते हैं, ऐसे टिकट हैं जिनमें निर्णय का समय लाखों मिनटों में अनुमानित है। यह स्पष्ट रूप से प्रासंगिक जानकारी नहीं है, इस तरह के डेटा केवल मॉडल के निर्माण में हस्तक्षेप करेंगे। वे यहां मिले, क्योंकि JIRA से डेटा संग्रह हल क्षेत्र पर एक क्वेरी द्वारा किया गया था, और नहीं बनाया गया था। तदनुसार, पिछले 1.5 वर्षों में बंद किए गए टिकट यहां मिल गए, लेकिन उन्हें बहुत पहले खोला जा सकता था। इनसे छुटकारा पाने का समय आ गया है। हम उन टिकटों को त्याग देंगे जो 1 जून 2017 से पहले बनाए गए थे। हमारे पास 9493 टिकट बचे होंगे।

कारणों के रूप में - मुझे लगता है कि हर परियोजना में आप आसानी से उन अनुरोधों को पा सकते हैं जो विभिन्न परिस्थितियों के कारण काफी समय से घूम रहे हैं और अधिक बार समस्या को हल करने से नहीं, बल्कि "सीमाओं के क़ानून की समाप्ति" द्वारा बंद कर दिया जाता है।

स्रोत कोड

 df[['Created', 'Resolved', 'Resolution_time']].sort_values('Resolution_time', ascending=False).head()

स्रोत कोड

 df = df[df['Created'] >= '2017-06-01 00:00:00'] print(df.shape)

 (9493, 33)

तो, आइए हम देखना शुरू करें कि हम अपने डेटा में क्या दिलचस्प पा सकते हैं। आरंभ करने के लिए, आइए जानें सबसे सरल - हमारे टिकटों के बीच सबसे लोकप्रिय वातावरण, सबसे सक्रिय "रिपोर्टर" और जैसे।

स्रोत कोड

 df.describe(include=['object'])

स्रोत कोड

 df['Environment'].value_counts().head(10)

 Environment_104 442 ALL 368 Location02 367 Environment_99 342 Location03 342 Environment_31 322 Environment_14 254 Environment_1 232 Environment_87 227 Location01 202 Name: Environment, dtype: int64

स्रोत कोड

 df['Reporter'].value_counts().head()

 Reporter_16 388 Reporter_97 199 Reporter_04 147 Reporter_110 145 Reporter_133 138 Name: Reporter, dtype: int64

स्रोत कोड

 df['Worktype'].value_counts()

 Support 2482 Infrastructure 1655 Update environment 1138 Monitoring 388 QA 300 Numbers 110 Create environment 95 Tools 62 Delete environment 24 Name: Worktype, dtype: int64

स्रोत कोड

 df['Priority'].value_counts().plot(kind='bar', figsize=(12,7), rot=0, fontsize=14, title='   ');

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

सबसे लोकप्रिय वातावरण और सबसे सक्रिय संवाददाताओं के लिए कॉलम से, हम देखते हैं कि रिपोर्टर_16 एक विस्तृत मार्जिन से जाता है, और पर्यावरण_104 पर्यावरण में पहले स्थान पर आता है। यहां तक कि अगर आपको अभी तक अनुमान नहीं लगाया गया है, तो मैं आपको थोड़ा गुप्त बताऊंगा - यह रिपोर्टर इस विशेष वातावरण पर काम करने वाली टीम से है।
आइए देखें कि सबसे महत्वपूर्ण टिकट किस तरह के वातावरण से आते हैं।

स्रोत कोड

 df[df['Priority'] == 'Critical']['Environment'].value_counts().index[0]

 'Environment_91'

अब हम विभिन्न प्राथमिकताओं वाले टिकटों की जानकारी एक ही "महत्वपूर्ण" वातावरण से लेते हैं।

स्रोत कोड

 df[df['Environment'] == df[df['Priority'] == 'Critical']['Environment'].value_counts().index[0]]['Priority'].value_counts()

 High 62 Critical 57 Normal 46 Name: Priority, dtype: int64

आइए प्राथमिकताओं के संदर्भ में टिकट के निष्पादन समय को देखें। उदाहरण के लिए, यह देखने के लिए मजेदार है कि कम प्राथमिकता वाले टिकट का औसत रन समय 70 हजार मिनट (लगभग 1.5 महीने) से अधिक है। इसकी प्राथमिकता पर टिकट निष्पादन समय की निर्भरता का भी आसानी से पता लगाया जा सकता है।

स्रोत कोड

 df.groupby(['Priority'])['Resolution_time'].describe()

या यहाँ एक ग्राफ के रूप में, औसत मूल्य। जैसा कि आप देख सकते हैं, चित्र बहुत बदल नहीं गया है, इसलिए, उत्सर्जन वितरण को बहुत प्रभावित नहीं करता है।

स्रोत कोड

 df.groupby(['Priority'])['Resolution_time'].median().sort_values().plot(kind='bar', figsize=(12,7), rot=0, fontsize=14);

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

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

स्रोत कोड

 engineers = [i.replace('_vacation', '') for i in df.columns if 'vacation' in i] cols = 2 rows = int(len(engineers) / cols) fig, axes = plt.subplots(nrows=rows, ncols=cols, figsize=(16,24)) for i in range(rows): for j in range(cols): df.groupby(engineers[i * cols + j])['Resolution_time'].mean().plot(kind='bar', rot=0, ax=axes[i, j]).set_xlabel('Engineer_' + str(i * cols + j + 1)) del cols, rows, fig, axes

परिणाम के रूप में लंबी तस्वीर

चलिए निम्नलिखित विशेषताओं के जोड़ीदार अंत: क्रिया का एक छोटा सा मैट्रिक्स बनाते हैं: टिकट समाधान का समय, वोटों की संख्या और पर्यवेक्षकों की संख्या। एक विकर्ण बोनस के साथ, हमारे पास प्रत्येक विशेषता का वितरण है।

दिलचस्प से, एक पर्यवेक्षकों की बढ़ती संख्या पर टिकट समाधान समय को कम करने की निर्भरता देख सकता है। यह भी देखा जाता है कि लोग वोट का उपयोग करने के लिए बहुत सक्रिय नहीं हैं।

स्रोत कोड

 pd.scatter_matrix(df[['Resolution_time', 'Watchers', 'Votes']], figsize=(15, 15), diagonal='hist');

परिणाम तस्वीर

इसलिए, हमने डेटा का एक छोटा प्रारंभिक विश्लेषण किया, लक्ष्य विशेषता के बीच मौजूदा निर्भरताएं देखीं, जो टिकट को हल करने में लगने वाला समय है, और टिकट के लिए वोटों की संख्या, इसके पीछे "पर्यवेक्षकों" की संख्या और इसकी प्राथमिकता के रूप में ऐसे संकेत हैं। हम आगे बढ़ते हैं।

एक मॉडल का निर्माण। भवन का चिन्ह

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

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

स्रोत कोड

 y = df['Resolution_time'] df.drop(['Created', 'Resolved', 'Resolution_time', 'Assignee'], axis=1, inplace=True) df['Description'].fillna('', inplace=True) df['Summary'].fillna('', inplace=True)

हम विरल वैक्टर ( एक-गर्म एन्कोडिंग ) में स्पष्ट संकेतों को विघटित करते हैं। जब तक हम टिकट की सामग्री के विवरण और तालिका के साथ खेतों को नहीं छूते हैं। हम उन्हें थोड़ा अलग तरीके से इस्तेमाल करेंगे। कुछ रिपोर्टर नामों में एक [X] होता है। इसलिए JIRA निष्क्रिय कर्मचारियों को चिह्नित करता है जो अब कंपनी में काम नहीं करते हैं। मैंने उन्हें संकेतों के बीच छोड़ने का फैसला किया, हालांकि उनसे डेटा को साफ करना संभव है, क्योंकि भविष्य में, मॉडल का उपयोग करते समय, हम इन कर्मचारियों से टिकट नहीं देखेंगे।

स्रोत कोड

 def create_df(dic, feature_list): out = pd.DataFrame(dic) out = pd.concat([out, pd.get_dummies(out[feature_list])], axis = 1) out.drop(feature_list, axis = 1, inplace = True) return out X = create_df(df, df.columns[df.dtypes == 'object'].drop(['Description', 'Summary'])) X.columns = X.columns.str.replace(' \[X\]', '')

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

हम nltk पुस्तकालय के अनुसार, " शब्दों को रोकें " को हटाते हैं, और अनावश्यक वर्णों के पाठ को अधिक अच्छी तरह से साफ करते हैं। आपको याद दिला दूं कि यह सबसे सरल काम है जो पाठ के साथ किया जा सकता है। हम " स्टैम्प " शब्दों का उपयोग नहीं करते हैं, आप सबसे लोकप्रिय एन-ग्राम शब्दों को भी गिन सकते हैं, लेकिन हम खुद को उसी तक सीमित रखेंगे।

स्रोत कोड

 all_words = np.concatenate(df['Description'].apply(lambda s: s.split()).values) stop_words = stopwords.words('english') stop_words.extend(['please', 'hi', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '(', ')', '=', '{', '}']) stop_words.extend(['h3', '+', '-', '@', '!', '#', '$', '%', '^', '&', '*', '(for', 'output)']) stop_symbols = ['=>', '|', '[', ']', '#', '*', '\\', '/', '->', '>', '<', '&'] words_series = pd.Series(list(all_words)) del all_words words_series = words_series[~words_series.isin(stop_words)] for symbol in stop_symbols: words_series = words_series[~words_series.str.contains(symbol, regex=False, na=False)]

इस सब के बाद, हमें पंडों का नाम मिला है। आइए उनमें से सबसे लोकप्रिय को देखें और संकेत के रूप में उपयोग करने के लिए सूची से पहले 50 लें। प्रत्येक टिकट के लिए, हम देखेंगे कि क्या इस शब्द का उपयोग विवरण में किया गया है, और यदि ऐसा है, तो संबंधित कॉलम में 1 डाल दें, अन्यथा 0।

स्रोत कोड

 usefull_words = list(words_series.value_counts().head(50).index) print(usefull_words[0:10])

 ['error', 'account', 'info', 'call', '{code}', 'behavior', 'array', 'update', 'env', 'actual']

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

स्रोत कोड

 for word in usefull_words: X['Description_' + word] = X['Description'].str.contains(word).astype('int64') X.drop('Description', axis=1, inplace=True)

हम टिकट टाइटल फील्ड के लिए भी ऐसा ही करेंगे।

स्रोत कोड

 all_words = np.concatenate(df['Summary'].apply(lambda s: s.split()).values) words_series = pd.Series(list(all_words)) del all_words words_series = words_series[~words_series.isin(stop_words)] for symbol in stop_symbols: words_series = words_series[~words_series.str.contains(symbol, regex=False, na=False)] usefull_words = list(words_series.value_counts().head(50).index) for word in usefull_words: X['Summary_' + word] = X['Summary'].str.contains(word).astype('int64') X.drop('Summary', axis=1, inplace=True)

आइए देखें कि हमने फीचर मैट्रिक्स एक्स और रिस्पांस वेक्टर वाई में क्या खत्म किया।

स्रोत कोड

 print(X.shape, y.shape)

 ((9493, 1114), (9493,))

अब हम इस डेटा को एक प्रशिक्षण (ट्रेनिंग) नमूने और एक परीक्षण नमूने में 75/25 प्रतिशत के अनुपात में विभाजित करेंगे। कुल मिलाकर, हमारे पास 7119 उदाहरण हैं, जिन पर हम प्रशिक्षण देंगे, और 2374, जिस पर हम अपने मॉडलों का मूल्यांकन करेंगे। और हमारे मैट्रिक्स विशेषताओं का आयाम स्पष्ट संकेतों के बाहर बिछाने के कारण बढ़कर 1114 हो गया।

स्रोत कोड

 X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.25, random_state=17) print(X_train.shape, X_holdout.shape)

 ((7119, 1114), (2374, 1114))

हम मॉडल को प्रशिक्षित करते हैं।

रैखिक प्रतिगमन

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

रैखिक प्रतिगमन के मामले में, मॉडल कम या ज्यादा स्वीकार्य प्रशिक्षण डेटा पर खुद को दिखाता है, लेकिन विलंबित नमूने पर सटीकता राक्षसी रूप से कम है। यहां तक कि सभी टिकटों के लिए सामान्य औसत की भविष्यवाणी करने से भी बदतर।

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

R^{2} = 1 - s u m_{i = 1}^{m} (y_{i} - h a t y)^{2} o v e r s u m_{i = 1}^{m} (y_{i)} - o v e r l i n e y)^{2}

$R ^ 2 = 1 - {\ sum_ {i = 1} ^ {m} (y_ {i} - \ hat {y}) ^ 2 \ over \ sum_ {i = 1} ^ {m} (y_ {i) } - \ overline {y}) ^ 2}$

जहाँ $\ _ {y}$ परिणाम मॉडल द्वारा भविष्यवाणी की है एक $\ overline {y}$ - पूरे नमूने के लिए औसत मूल्य।

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

स्रोत कोड

 lr = LinearRegression() lr.fit(X_train, y_train) print('R^2 train:', lr.score(X_train, y_train)) print('R^2 test:', lr.score(X_holdout, y_holdout)) print('MAE train', mean_absolute_error(lr.predict(X_train), y_train)) print('MAE test', mean_absolute_error(lr.predict(X_holdout), y_holdout))

 R^2 train: 0.3884389470220214 R^2 test: -6.652435243123196e+17 MAE train: 8503.67256637168 MAE test: 1710257520060.8154

धीरे-धीरे बूस्ट

ठीक है, जहां इसके बिना, ग्रेडिएंट बूस्टिंग के बिना? आइए मॉडल को प्रशिक्षित करने का प्रयास करें और देखें कि क्या होता है। हम इसके लिए कुख्यात XGBoost का उपयोग करेंगे। आइए मानक हाइपरपरमीटर सेटिंग्स के साथ शुरू करें।

स्रोत कोड

 import xgboost xgb = xgboost.XGBRegressor() xgb.fit(X_train, y_train) print('R^2 train:', xgb.score(X_train, y_train)) print('R^2 test:', xgb.score(X_holdout, y_holdout)) print('MAE train', mean_absolute_error(xgb.predict(X_train), y_train)) print('MAE test', mean_absolute_error(xgb.predict(X_holdout), y_holdout))

 R^2 train: 0.5138516547636054 R^2 test: 0.12965507684512545 MAE train: 7108.165167471887 MAE test: 8343.433260957032

आउट ऑफ द बॉक्स अब बुरा नहीं है। आइए हाइपरपरमेटर्स का चयन करके मॉडल को मॉडल करने का प्रयास करें: n_estimators, learning_rate और max_depth। नतीजतन, हम क्रमशः 150, 0.1 और 3 के मूल्यों पर ध्यान केंद्रित करते हैं, क्योंकि प्रशिक्षण डेटा पर मॉडल के ओवरट्रेनिंग की अनुपस्थिति में परीक्षण नमूने पर सबसे अच्छा परिणाम दिखाते हैं।

हम n_estimators का चयन करते हैं

* चित्र में R ^ 2 स्कोर के बजाय MAE होना चाहिए।

 xgb_model_abs_testing = list() xgb_model_abs_training = list() rng = np.arange(1,151) for i in rng: xgb = xgboost.XGBRegressor(n_estimators=i) xgb.fit(X_train, y_train) xgb.score(X_holdout, y_holdout) xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout)) xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train)) plt.figure(figsize=(14, 8)) plt.plot(rng, xgb_model_abs_testing, label='MAE test'); plt.plot(rng, xgb_model_abs_training, label='MAE train'); plt.xlabel('Number of estimators') plt.ylabel('$R^2 Score$') plt.legend(loc='best') plt.show();

हम learning_rate का चयन करते हैं

 xgb_model_abs_testing = list() xgb_model_abs_training = list() rng = np.arange(0.05, 0.65, 0.05) for i in rng: xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=i) xgb.fit(X_train, y_train) xgb.score(X_holdout, y_holdout) xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout)) xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train)) plt.figure(figsize=(14, 8)) plt.plot(rng, xgb_model_abs_testing, label='MAE test'); plt.plot(rng, xgb_model_abs_training, label='MAE train'); plt.xlabel('Learning rate') plt.ylabel('MAE') plt.legend(loc='best') plt.show();

हम max_depth का चयन करते हैं

 xgb_model_abs_testing = list() xgb_model_abs_training = list() rng = np.arange(1, 11) for i in rng: xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=0.1, max_depth=i) xgb.fit(X_train, y_train) xgb.score(X_holdout, y_holdout) xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout)) xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train)) plt.figure(figsize=(14, 8)) plt.plot(rng, xgb_model_abs_testing, label='MAE test'); plt.plot(rng, xgb_model_abs_training, label='MAE train'); plt.xlabel('Maximum depth') plt.ylabel('MAE') plt.legend(loc='best') plt.show();

अब हम चयनित हाइपरपैरामीटर के साथ मॉडल को प्रशिक्षित करेंगे।

स्रोत कोड

 xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=0.1, max_depth=3) xgb.fit(X_train, y_train) print('R^2 train:', xgb.score(X_train, y_train)) print('R^2 test:', xgb.score(X_holdout, y_holdout)) print('MAE train', mean_absolute_error(xgb.predict(X_train), y_train)) print('MAE test', mean_absolute_error(xgb.predict(X_holdout), y_holdout))

 R^2 train: 0.6745967150462303 R^2 test: 0.15415143189670344 MAE train: 6328.384400466232 MAE test: 8217.07897417256

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

स्रोत कोड

 features_df = pd.DataFrame(data=xgb.feature_importances_.reshape(1, -1), columns=X.columns).sort_values(axis=1, by=[0], ascending=False) features_df.loc[0][0:10].plot(kind='bar', figsize=(16, 8), rot=75, fontsize=14);

तंत्रिका नेटवर्क

लेकिन हम एक क्रमिक बूस्टिंग पर नहीं रुकेंगे और तंत्रिका नेटवर्क को प्रशिक्षित करने की कोशिश करेंगे, अधिक सटीक रूप से मल्टीलेयर परसेप्ट्रॉन, एक पूरी तरह से जुड़ा हुआ प्रत्यक्ष वितरण तंत्रिका नेटवर्क। इस बार हम हाइपरपरमेटर्स की मानक सेटिंग्स के साथ शुरू नहीं करेंगे, जैसा कि स्केलेर लाइब्रेरी में, जिसका हम उपयोग करेंगे, डिफ़ॉल्ट रूप से 100 न्यूरॉन्स के साथ केवल एक छिपी हुई परत है और प्रशिक्षण के दौरान मॉडल मानक 200 पुनरावृत्तियों के लिए असहमति के बारे में चेतावनी देता है। हम तुरंत 300, 200 और 100 न्यूरॉन्स के साथ क्रमशः 3 छिपी हुई परतों का उपयोग करते हैं।

नतीजतन, हम देखते हैं कि प्रशिक्षण नमूने पर मॉडल को अधिक प्रशिक्षित नहीं किया गया है, जो हालांकि, परीक्षण नमूने पर एक सभ्य परिणाम दिखाने से नहीं रोकता है। यह परिणाम ग्रेडिएंट बूस्टिंग के परिणाम से काफी कम है।

स्रोत कोड

 from sklearn.neural_network import MLPRegressor nn = MLPRegressor(random_state=17, hidden_layer_sizes=(300, 200 ,100), alpha=0.03, learning_rate='adaptive', learning_rate_init=0.0005, max_iter=200, momentum=0.9, nesterovs_momentum=True) nn.fit(X_train, y_train) print('R^2 train:', nn.score(X_train, y_train)) print('R^2 test:', nn.score(X_holdout, y_holdout)) print('MAE train', mean_absolute_error(nn.predict(X_train), y_train)) print('MAE test', mean_absolute_error(nn.predict(X_holdout), y_holdout))

 R^2 train: 0.9771443840549647 R^2 test: -0.15166596239118246 MAE train: 1627.3212161350423 MAE test: 8816.204561947616

आइए देखें कि हम अपने नेटवर्क की सर्वश्रेष्ठ वास्तुकला को चुनने की कोशिश करके क्या हासिल कर सकते हैं। , , 200 , , . .

 plt.figure(figsize=(14, 8)) for i in [(500,), (750,), (1000,), (500,500)]: nn = MLPRegressor(random_state=17, hidden_layer_sizes=i, alpha=0.03, learning_rate='adaptive', learning_rate_init=0.0005, max_iter=200, momentum=0.9, nesterovs_momentum=True) nn.fit(X_train, y_train) plt.plot(nn.loss_curve_, label=str(i)); plt.xlabel('Iterations') plt.ylabel('MSE') plt.legend(loc='best') plt.show()

. 3 10 .

 plt.figure(figsize=(14, 8)) for i in [(500,300,100), (80, 60, 60, 60, 40, 40, 40, 40, 20, 10), (80, 60, 60, 40, 40, 40, 20, 10), (150, 100, 80, 60, 40, 40, 20, 10), (200, 100, 100, 100, 80, 80, 80, 40, 20), (80, 40, 20, 20, 10, 5), (300, 250, 200, 100, 80, 80, 80, 40, 20)]: nn = MLPRegressor(random_state=17, hidden_layer_sizes=i, alpha=0.03, learning_rate='adaptive', learning_rate_init=0.001, max_iter=200, momentum=0.9, nesterovs_momentum=True) nn.fit(X_train, y_train) plt.plot(nn.loss_curve_, label=str(i)); plt.xlabel('Iterations') plt.ylabel('MSE') plt.legend(loc='best') plt.show()

"" (200, 100, 100, 100, 80, 80, 80, 40, 20) :
2506
7351

, , . learning rate .

 nn = MLPRegressor(random_state=17, hidden_layer_sizes=(200, 100, 100, 100, 80, 80, 80, 40, 20), alpha=0.1, learning_rate='adaptive', learning_rate_init=0.007, max_iter=200, momentum=0.9, nesterovs_momentum=True) nn.fit(X_train, y_train) print('R^2 train:', nn.score(X_train, y_train)) print('R^2 test:', nn.score(X_holdout, y_holdout)) print('MAE train', mean_absolute_error(nn.predict(X_train), y_train)) print('MAE test', mean_absolute_error(nn.predict(X_holdout), y_holdout))

 R^2 train: 0.836204705204337 R^2 test: 0.15858607391959356 MAE train: 4075.8553476632796 MAE test: 7530.502826043687

, . , . , , .

. : ( , 200 ). , "" . , 30 200 , issue type: Epic . , .. , , , , . 4 5 . , . , .

— 9 , . , , , .

 pd.Series([X_train.columns[abs(nn.coefs_[0][:,i]).argmax()] for i in range(nn.hidden_layer_sizes[0])]).value_counts().head(5).sort_values().plot(kind='barh', title='Feature importance', fontsize=14, figsize=(14,8));

. क्यों? 7530 8217. (7530 + 8217) / 2 = 7873, , , ? , . , . , 7526.

, kaggle . , , .

 nn_predict = nn.predict(X_holdout) xgb_predict = xgb.predict(X_holdout) print('NN MSE:', mean_squared_error(nn_predict, y_holdout)) print('XGB MSE:', mean_squared_error(xgb_predict, y_holdout)) print('Ensemble:', mean_squared_error((nn_predict + xgb_predict) / 2, y_holdout)) print('NN MAE:', mean_absolute_error(nn_predict, y_holdout)) print('XGB MSE:', mean_absolute_error(xgb_predict, y_holdout)) print('Ensemble:', mean_absolute_error((nn_predict + xgb_predict) / 2, y_holdout))

 NN MSE: 628107316.262393 XGB MSE: 631417733.4224195 Ensemble: 593516226.8298339 NN MAE: 7530.502826043687 XGB MSE: 8217.07897417256 Ensemble: 7526.763569558157

? 7500 . यानी 5 . . . , .

( ):

 ((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values(ascending=False).head(10).values

 [469132.30504392, 454064.03521379, 252946.87342439, 251786.22682697, 224012.59016987, 15671.21520735, 13201.12440327, 203548.46460229, 172427.32150665, 171088.75543224]

. , .

 df.loc[((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values(ascending=False).head(10).index][['Issue_type', 'Priority', 'Worktype', 'Summary', 'Watchers']]

, - , . 4 .

, .

 print(((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values().head(10).values) df.loc[((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values().head(10).index][['Issue_type', 'Priority', 'Worktype', 'Summary', 'Watchers']]

 [ 1.24606014, 2.6723969, 4.51969139, 10.04159236, 11.14335444, 14.4951508, 16.51012874, 17.78445744, 21.56106258, 24.78219295]

, , - , - . , , , .

Engineer

, 'Engineer', , , ? .

, 2 . , , , , . , , , "" , ( ) , , , . , " ", .

, . , , 12 , ( JQL JIRA):

 assignee was engineer_N during (ticket_creation_date) and status was "In Progress"

10783 * 12 = 129396 , … . , , , .. 5 .
, , , , 2 . .

. SLO , .

, , ( : - , - , - ) , .

मशीन लर्निंग का उपयोग करते हुए टिकट समाधान समय की भविष्यवाणी करना

प्रारंभिक डेटा विश्लेषण

एक मॉडल का निर्माण। भवन का चिन्ह

हम मॉडल को प्रशिक्षित करते हैं।

रैखिक प्रतिगमन

धीरे-धीरे बूस्ट

तंत्रिका नेटवर्क

Engineer

More articles: