"ऐसा लगता है कि यह पहले से ही हुआ है?" इसी तरह की घटनाओं और दावों के लिए खोजें

जिन लोगों ने एक निश्चित समय बिताया, वे सिस्टम का समर्थन करते हुए एक नई एप्लीकेशन मिलने पर déjà vu भावना से परिचित हैं: "यह ऐसा था, इसे हल किया गया था, लेकिन मुझे याद नहीं है कि वास्तव में क्या है"। आप समय व्यतीत कर सकते हैं, पिछले अनुप्रयोगों में तल्लीन कर सकते हैं और समान खोजने की कोशिश कर सकते हैं। यह मदद करेगा: घटना तेजी से बंद हो जाएगी, या मूल कारण का पता लगाना और समस्या को एक बार और सभी के लिए बंद करना संभव हो सकता है।

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

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

हम पहले से ही घटनाओं को वर्गीकृत करने के लिए एमएल मॉडल का उपयोग कर रहे हैं। हमारी टीम के अनुप्रयोगों को अधिक कुशलता से मदद करने के लिए, हमने "पहले से बंद समान घटनाओं" की सूची तैयार करने के लिए एक और एमएल मॉडल बनाया है। विवरण - कटौती के तहत।

हमें क्या चाहिए?

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

घटनाओं की तुलना करने के लिए, संपर्क करते समय उपयोगकर्ता द्वारा प्रदान की गई जानकारी का उपयोग करना आवश्यक है: एक संक्षिप्त विवरण, एक विस्तृत विवरण (यदि कोई हो), उपयोगकर्ता के रिकॉर्ड की कोई भी विशेषता।

टीम सिस्टम के 4 समूहों का समर्थन करती है। घटनाओं की कुल संख्या जो मैं समान लोगों की खोज के लिए उपयोग करना चाहता हूं वह लगभग 10 हजार है।

पहला फैसला

हाथ पर घटनाओं की "समानता" पर कोई सत्यापित जानकारी नहीं है। इसलिए सियामी नेटवर्क के प्रशिक्षण के लिए अत्याधुनिक विकल्पों को फिलहाल स्थगित करना होगा।
पहली बात जो दिमाग में आती है, वह "शब्दों की थैली" की सरल गुत्थी है जो अपीलों की सामग्री से बनी है।

इस मामले में, घटना से निपटने की प्रक्रिया इस प्रकार है:

1. आवश्यक पाठ अंशों को हाइलाइट करना
2. टेक्स्ट प्रीप्रोसेसिंग / सफाई
3. TF-IDF वेक्टरकरण
4. अपने निकटतम पड़ोसी का पता लगाएं

यह स्पष्ट है कि वर्णित दृष्टिकोण के साथ, समानता शब्दकोशों की तुलना पर आधारित होगी: एक ही शब्द या दो अलग-अलग घटनाओं में एन-ग्राम का उपयोग करना "समानता" माना जाएगा।

बेशक, यह एक काफी सरलीकृत दृष्टिकोण है। लेकिन यह याद रखना कि हम उपयोगकर्ता हिट के ग्रंथों का मूल्यांकन करते हैं, यदि समस्या को समान शब्दों में वर्णित किया गया है - सबसे अधिक संभावना है कि घटनाएं समान हैं। पाठ के अतिरिक्त, आप उपयोगकर्ता के विभाग का नाम जोड़ सकते हैं, यह अपेक्षा करते हुए कि विभिन्न संगठनों में समान विभागों के उपयोगकर्ताओं को समान समस्याएं होंगी।

आवश्यक पाठ अंशों को हाइलाइट करना

घटना डेटा हमें सबसे सरल तरीके से service-now.com से प्राप्त होता है - कस्टम रिपोर्ट्स को प्रोग्रामेटिक रूप से चलाकर और CSV फ़ाइलों के रूप में उनके परिणामों को पुनः प्राप्त करके।

घटना के हिस्से के रूप में समर्थन और उपयोगकर्ताओं के बीच बदले गए संदेशों पर डेटा इस मामले में एक बड़े पाठ क्षेत्र के रूप में पत्राचार के पूरे इतिहास के साथ वापस आ जाता है।

इस तरह के क्षेत्र से पहली कॉल के बारे में जानकारी नियमित अभिव्यक्तियों द्वारा "कट आउट" की जानी थी।

• सभी संदेशों को एक विशेषता रेखा से अलग किया जाता है <जब> - <जो>।
• संदेश अक्सर औपचारिक हस्ताक्षर के साथ समाप्त होते हैं, खासकर अगर अपील ई-मेल द्वारा की गई थी। यह जानकारी महत्वपूर्ण शब्दों की सूची में "fonil" है, इसलिए हस्ताक्षर को भी हटाना पड़ा।

यह कुछ इस तरह से निकला:

def get_first_message(messages): res = "" if len(messages) > 0: # take the first message spl = re.split("\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2} - ((\w+((\s|-)\w+)?,(\s\w+)+)|\w{9}|guest)\s\(\w+\s\w+\)\n", messages.lower()) res = spl[-1] # cut off "mail footer" with finalization statements res = re.split("(best|kind)(\s)+regard(s)+", res)[0] # cut off "mail footer" with embedded pictures res = re.split("\[cid:", res)[0] # cut off "mail footer" with phone prefix res = re.split("\+(\d(\s|-)?){7}", res)[0] return res 

प्रीप्रोसेसिंग घटना ग्रंथ

वर्गीकरण की गुणवत्ता में सुधार करने के लिए, अपील पाठ पूर्व-संसाधित है।

घटना के विवरणों में नियमित अभिव्यक्तियों के सेट का उपयोग करते हुए, विशिष्ट टुकड़े पाए गए: तिथियां, सर्वर नाम, उत्पाद कोड, आईपी पते, वेब पते, नामों के गलत रूप आदि। इस तरह के टुकड़ों को संबंधित अवधारणा टोकन के साथ बदल दिया गया था।

अंत में, शब्दों को एक सामान्य रूप में लाने के लिए स्टैमिंग का उपयोग किया गया था। इससे हमें बहुवचन रूपों और क्रियाओं के अंत से छुटकारा पाने की अनुमति मिली। प्रसिद्ध snowballstemmer का उपयोग स्टेमर के रूप में किया गया था।

सभी प्रोसेसिंग प्रोसेस को एक ट्रांसफॉर्मिंग क्लास में संयोजित किया जाता है, जिसका उपयोग विभिन्न प्रक्रियाओं में किया जा सकता है।

वैसे, यह निकला (प्रयोगात्मक रूप से, निश्चित रूप से) कि stemmer.stemWord() विधि थ्रेड सुरक्षित नहीं है। इसलिए, यदि आप पाइप लाइन के भीतर समानांतर पाठ प्रसंस्करण को लागू करने की कोशिश करते हैं, उदाहरण के लिए, joblib समानांतर / विलंब का उपयोग करते हुए, तो स्टेम के सामान्य उदाहरण तक पहुंच को ताले से संरक्षित किया जाना चाहिए।

 __replacements = [ ('(\d{1,3}\.){3}\d{1,3}', 'IPV4'), ('(?<=\W)((\d{2}[-\/ \.]?){2}(19|20)\d{2})|(19|20)\d{2}([-\/ \.]?\d{2}){2}(?=\W)', 'YYYYMMDD'), ('(?<=\W)(19|20)\d{2}(?=\W)', 'YYYY'), ('(?<=\W)(0|1)?\d\s?(am|pm)(?=\W)', 'HOUR'), ('http[s]?:\/\/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', 'SOMEURL') #      ] __stemmer_lock = threading.Lock() __stemmer = snowballstemmer.stemmer('english') def stem_string(text: str): def stem_words(word_list): with __stemmer_lock: res = __stemmer.stemWords(word_list) return res return " ".join(stem_words(text.split())) def clean_text(text: str): res = text for p in __replacements: res = re.sub(p[0], '#'+p[1]+'#', res) return res def process_record(record): txt = "" for t in record: t = "" if t == np.nan else t txt += " " + get_first_message(str(t)) return stem_string(clean_text(txt.lower())) class CommentsTextTransformer(BaseEstimator, TransformerMixin): _n_jobs = 1 def __init__(self, n_jobs=1): self._n_jobs = n_jobs def fit(self, X, y=None): return self def transform(self, X, y=None): features = Parallel(n_jobs=self._n_jobs)( delayed(process_record)(rec) for i, rec in enumerate(X.values) ) return np.array(features, dtype=object).reshape(len(X),) 

vectorization

निम्न सेटिंग्स के साथ मानक TfidfVectorizer द्वारा TfidfVectorizer किया जाता है:

• max_features = 10000
• ngram = (1,3) - स्थिर संयोजनों और अर्थ संयोजी को पकड़ने के प्रयास में
• max_df / min_df - डिफ़ॉल्ट रूप से छोड़ा गया
• stop_words - अंग्रेजी शब्दों की एक मानक सूची, और शब्दों का अपना अतिरिक्त समूह। उदाहरण के लिए, कुछ उपयोगकर्ताओं ने विश्लेषक नामों का उल्लेख किया, और अक्सर उचित नाम महत्वपूर्ण गुण बन गए।

TfidfVectorizer स्वयं डिफ़ॉल्ट रूप से L2 सामान्यीकरण करता है, इसलिए घटना वैक्टर उनके बीच कोसाइन दूरी को मापने के लिए तैयार हैं।

इसी तरह की घटनाओं के लिए खोज करें

प्रक्रिया का मुख्य कार्य निकटतम एन पड़ोसियों की सूची वापस करना है। sklearn.neighbors.NearestNeighbors वर्ग इसके लिए काफी उपयुक्त है। एक समस्या यह है कि यह transform विधि को लागू नहीं करता है, जिसके बिना इसका उपयोग pipeline में नहीं किया जा सकता है।

इसलिए, इसे Transformer आधार पर बनाना आवश्यक था, जो तब ही इसे pipeline के अंतिम चरण पर रखता था:

 class NearestNeighborsTransformer(NearestNeighbors, TransformerMixin): def __init__(self, n_neighbors=5, radius=1.0, algorithm='auto', leaf_size=30, metric='minkowski', p=2, metric_params=None, n_jobs=None, **kwargs): super(NearestNeighbors, self).__init__(n_neighbors=n_neighbors, radius=radius, algorithm=algorithm, leaf_size=leaf_size, metric=metric, p=p, metric_params=metric_params, n_jobs=n_jobs) def transform(self, X, y=None): res = self.kneighbors(X, self.n_neighbors, return_distance=True) return res 

प्रसंस्करण की प्रक्रिया

यह सब एक साथ रखकर, हमें एक कॉम्पैक्ट प्रक्रिया मिलती है:

 p = Pipeline( steps=[ ('grp', ColumnTransformer( transformers=[ ('text', Pipeline(steps=[ ('pp', CommentsTextTransformer(n_jobs=-1)), ("tfidf", TfidfVectorizer(stop_words=get_stop_words(), ngram_range=(1, 3), max_features=10000)) ]), ['short_description', 'comments', 'u_impacted_department'] ) ] )), ("nn", NearestNeighborsTransformer(n_neighbors=10, metric='cosine')) ], memory=None) 

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

 # inc_data - pandas.Dataframe,     # ref_data - pandas.Dataframe,    . #     .    # inc_data["recommendations_json"] = "" #   . # column_list -  ,          nn_dist, nn_refs = p.transform(inc_data[column_list]) for idx, refs in enumerate(nn_refs): nn_data = ref_data.iloc[refs][['number', 'short_description']].copy() nn_data['distance'] = nn_dist[idx] inc_data.iloc[idx]["recommendations_json"] = nn_data.to_json(orient='records') #     , .     -. inc_data[['number', 'short_description', 'recommendations_json']].to_json(out_file_name, orient='records') 

पहले आवेदन परिणाम

"संकेत" की एक प्रणाली की शुरूआत के लिए सहकर्मियों की प्रतिक्रिया आम तौर पर बहुत सकारात्मक थी। आवर्ती घटनाएं तेजी से हल होने लगीं, हमने समस्या निवारण पर काम करना शुरू किया।

हालांकि, कोई भी सीखने की अनिश्चित प्रणाली से चमत्कार की उम्मीद नहीं कर सकता था। सहकर्मियों ने शिकायत की कि कभी-कभी सिस्टम पूरी तरह अप्रासंगिक लिंक प्रदान करता है। कभी-कभी यह समझना भी मुश्किल था कि ऐसी सिफारिशें कहाँ से आती हैं।

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

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

हमारे पास HTTP लॉग्स तक पहुंच नहीं थी, क्योंकि सेवा प्रणाली दूरस्थ रूप से काम करती है (सास)। हमने उपयोगकर्ता सर्वेक्षण किए - लेकिन केवल गुणात्मक रूप से। मात्रात्मक आकलन के लिए आगे बढ़ना आवश्यक था, और उनके आधार पर स्पष्ट गुणवत्ता मैट्रिक्स का निर्माण करना था।

लेकिन इसके बारे में अगले भाग में ...