🙏🏿 🏇🏿 📓 गणितज्ञों की भविष्यवाणी। हम विसंगतियों का पता लगाने के लिए मुख्य तरीकों का विश्लेषण करते हैं 📎 👩‍❤️‍👨 🤾🏻

उद्योग में कृत्रिम बुद्धिमत्ता का उपयोग विभिन्न प्रणालियों के भविष्य कहनेवाला रखरखाव के लिए विदेशों में अधिक से अधिक लोकप्रियता प्राप्त कर रहा है। इस पद्धति का उद्देश्य ऑपरेशन चरण के दौरान सिस्टम के संचालन में खराबी की पहचान करना है जब तक कि समय पर प्रतिक्रिया के लिए इसकी विफलता नहीं होती है।

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

इस लेख से आप सीखेंगे:

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

स्रोत

भविष्य कहनेवाला सेवा क्या सुविधाएँ प्रदान करती है?

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

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

डेटा एकत्रित करते समय या मॉडल बनाने के लिए डेटा का चयन करते समय, प्रश्नों के तीन समूहों का उत्तर देना महत्वपूर्ण होता है:

क्या सभी सिस्टम समस्याओं की भविष्यवाणी की जा सकती है? कौन सी भविष्यवाणी विशेष रूप से महत्वपूर्ण है?
एक विफलता प्रक्रिया क्या है? क्या पूरा सिस्टम काम करना बंद कर देता है या ऑपरेटिंग मोड केवल बदल रहा है? क्या यह एक तेज़ प्रक्रिया, तात्कालिक या क्रमिक गिरावट है?
क्या सिस्टम का प्रदर्शन पर्याप्त रूप से उसके प्रदर्शन को दर्शाता है? क्या वे सिस्टम के अलग-अलग हिस्सों से संबंधित हैं या पूरे सिस्टम के लिए?

अग्रिम में यह समझना भी महत्वपूर्ण है कि आप क्या भविष्यवाणी करना चाहते हैं, और क्या भविष्यवाणी करना संभव है और क्या नहीं है।

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

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

आशा है कि भविष्य में स्थिति में सुधार होगा। अब तक, भविष्य कहनेवाला रखरखाव के क्षेत्र में कठिनाइयाँ हैं: सिस्टम की खराबी के कुछ उदाहरण हैं, या सिस्टम की खराबी के क्षण पर्याप्त हैं, लेकिन वे चिह्नित नहीं हैं; विफलता प्रक्रिया अज्ञात है।

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

लेकिन यह पहले से ही बुरा नहीं है।

स्रोत

तरीकों

अब मैं विसंगति का पता लगाने के दृष्टिकोण की कुछ विशेषताओं के बारे में बात करना चाहता हूं, और फिर एक साथ हम कुछ सरल एल्गोरिदम की क्षमताओं का परीक्षण करेंगे।

हालांकि एक विशेष स्थिति में विसंगतियों की खोज करने और सर्वश्रेष्ठ को चुनने के लिए कई एल्गोरिदम का परीक्षण करने की आवश्यकता होगी, इस क्षेत्र में उपयोग की जाने वाली मुख्य तकनीकों के कुछ फायदे और नुकसान का निर्धारण करना संभव है।

सबसे पहले, अग्रिम में यह समझना महत्वपूर्ण है कि डेटा में विसंगतियों का प्रतिशत क्या है।

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

अन्य मामलों में, कटऑफ सीमा निर्धारित करने के लिए असामान्य और "सामान्य" अंक के अनुपात को जानने की आवश्यकता भी बनी हुई है।

यदि डेटा में विसंगतियों की संख्या 5% से अधिक है, और वे मुख्य नमूने से काफी अच्छी तरह से अलग हैं, तो मानक विसंगति खोज विधियों का उपयोग किया जा सकता है।

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

अन्य एल्गोरिदम बेहतर काम करते हैं यदि वे डेटा की बारीकियों के तहत "फिट" होते हैं।

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

यदि डेटा इस तरह से प्रस्तुत किया जाता है कि अलग-अलग बिंदुओं की सापेक्ष स्थिति उनके अंतर को अच्छी तरह से दर्शाती है, तो मीट्रिक तरीके एक अच्छा विकल्प प्रतीत होते हैं: उदाहरण के लिए, k निकटतम पड़ोसी, k-th निकटतम पड़ोसी, ABOD (कोण-आधारित बाहरी पहचान) या LOF (स्थानीय बाह्य कारक) )।

इन सभी विधियों से पता चलता है कि "सही" संकेतक बहुआयामी अंतरिक्ष के एक क्षेत्र में केंद्रित हैं। यदि निकटतम पड़ोसी के k (या k-th) के बीच सब कुछ लक्ष्य से दूर है, तो बिंदु एक विसंगति है। ABOD के लिए, तर्क समान है: यदि सभी k निकटतम बिंदु अंतरिक्ष के एक ही क्षेत्र में हैं, तो माना जाता है कि बिंदु एक विसंगति है। LOF के लिए: यदि स्थानीय घनत्व (k निकटतम पड़ोसियों द्वारा प्रत्येक बिंदु के लिए पूर्व निर्धारित) k निकटतम पड़ोसियों की तुलना में कम है, तो बिंदु एक विसंगति है।

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

यदि सबसे बड़े परिवर्तन की दिशाएं डेटा में अच्छी तरह से प्रतिष्ठित हैं, तो यह मुख्य घटक विधि के आधार पर विसंगतियों की खोज करने के लिए एक अच्छा विकल्प है। इस मामले में, n1 (सबसे "मुख्य" घटकों) और n2 (कम से कम "मुख्य") के लिए औसत मूल्य से विचलन को एक विसंगति उपाय माना जाता है।

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

मुझे नेटवर्क पर परीक्षण नमूने पर जवाब नहीं मिला, इसलिए हम केवल प्रशिक्षण के साथ खेलेंगे।

सामान्य तौर पर, सभी सेटिंग्स समान होती हैं, लेकिन भिन्न होती हैं, उदाहरण के लिए, घटकों की संख्या में, विसंगतियों की संख्या में, आदि। इसलिए, पहले 20 में सीखना, और दूसरों में परीक्षण करना बहुत मायने नहीं रखता है।

इसलिए, हम किसी एक इंस्टालेशन को चुनेंगे, उसे लोड करेंगे और इस डेटा पर एक नज़र डालेंगे। लेख फीचर इंजीनियरिंग के बारे में नहीं होगा, इसलिए हम ज्यादा सहकर्मी नहीं होंगे।

import pandas as pd import matplotlib.pyplot as plt %matplotlib inline import seaborn as sns from sklearn.covariance import EllipticEnvelope from sklearn.neighbors import LocalOutlierFactor from sklearn.ensemble import IsolationForest from sklearn.svm import OneClassSVM dfa=pd.read_csv('plant_12a.csv',names=['Component number','Time','S1','S2','S3','S4','S1ref','S2ref','S3ref','S4ref']) dfa.head(10)

जैसा कि आप देख सकते हैं, प्रत्येक के लिए सात घटक हैं जिनमें चार सेंसर की रीडिंग हैं जो हर 15 मिनट में ली जाती हैं। प्रतियोगिता के विवरण में S1ref-S4ref को संदर्भ मान के रूप में सूचीबद्ध किया गया है, लेकिन मान सेंसर की रीडिंग से बहुत अलग हैं। यह सोचने में समय बर्बाद न करने के लिए कि उनका क्या मतलब है, हम उन्हें हटा देते हैं। यदि आप प्रत्येक सुविधा (S1-S4) के मानों के वितरण को देखते हैं, तो यह पता चलता है कि वितरण S1, S2 और S4 के लिए निरंतर हैं, और S3 के लिए असतत हैं। इसके अलावा, यदि आप S2 और S4 के संयुक्त वितरण को देखते हैं, तो यह पता चलता है कि वे विपरीत आनुपातिक हैं।

हालांकि एक सीधी निर्भरता से विचलन एक गलती का संकेत दे सकता है, हम इसे जांच नहीं करेंगे, लेकिन बस एस 4 को हटा दें।

एक बार फिर, हम डेटा सेट की प्रक्रिया करते हैं। S1, S2 और S3 को छोड़ दें। StandardScaler के साथ स्केल S1 और S2 (हम औसत विचलन को घटाते हैं और मानक विचलन द्वारा विभाजित करते हैं), S3 को OHE (वन हॉट एन्कोडिंग) में अनुवाद करते हैं। हम एक पंक्ति में सभी स्थापना घटकों से रीडिंग को सीवे करते हैं। कुल 89 सुविधाएँ। 2 * 7 = 14 - 7 घटकों के लिए एस 1 और एस 2 रीडिंग और आर 3 के 75 अद्वितीय मूल्य। केवल 56 हजार ऐसी लाइनें।

त्रुटियों के साथ फ़ाइल अपलोड करें।

 dfc=pd.read_csv('plant_12c.csv',names=['Start Time', 'End Time','Type']) dfc.head()

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

सुविधाओं को अलग करने और मॉडल की गुणवत्ता निर्धारित करने के लिए कोड

 def load_and_preprocess(plant_num):   #      ,       dfa=pd.read_csv('plant_{}a.csv'.format(plant_num),names=['Component number','Time','S1','S2','S3','S4','S1ref','S2ref','S3ref','S4ref'])   dfc=pd.read_csv('plant_{}c.csv'.format(plant_num),names=['Start Time','End Time','Type']).drop(0,axis=0)   N_comp=len(dfa['Component number'].unique())   #  15    dfa['Time']=pd.to_datetime(dfa['Time']).dt.round('15min')   #  6    (  ,    )   dfc=dfc[dfc['Type']!=6]   dfc['Start Time']=pd.to_datetime(dfc['Start Time'])   dfc['End Time']=pd.to_datetime(dfc['End Time'])   #      ,       OHE  3-    dfa=pd.concat([dfa.groupby('Time').nth(i)[['S1','S2','S3']].rename(columns={"S1":"S1_{}".format(i),"S2":"S2_{}".format(i),"S3":"S3_{}".format(i)}) for i in range(N_comp)],axis=1).dropna().reset_index()   for k in range(N_comp):       dfa=pd.concat([dfa.drop('S3_'+str(k),axis=1),pd.get_dummies(dfa['S3_'+str(k)],prefix='S3_'+str(k))],axis=1).reset_index(drop=True)   #          df_train,df_test=train_test_split(dfa,test_size=0.25,shuffle=False)   cols_to_scale=df_train.filter(regex='S[1,2]').columns   scaler=preprocessing.StandardScaler().fit(df_train[cols_to_scale])   df_train[cols_to_scale]=scaler.transform(df_train[cols_to_scale])   df_test[cols_to_scale]=scaler.transform(df_test[cols_to_scale])   return df_train,df_test,dfc #       def get_true_labels(measure_times,dfc,shift_delta):   idxSet=set()   dfc['Start Time']-=pd.Timedelta(minutes=shift_delta)   dfc['End Time']-=pd.Timedelta(minutes=shift_delta)   for idx,mes_time in tqdm_notebook(enumerate(measure_times),total=measure_times.shape[0]):       intersect=np.array(dfc['Start Time']<mes_time).astype(int)*np.array(dfc['End Time']>mes_time).astype(int)       idxs=np.where(intersect)[0]       if idxs.shape[0]:           idxSet.add(idx)   dfc['Start Time']+=pd.Timedelta(minutes=shift_delta)   dfc['End Time']+=pd.Timedelta(minutes=shift_delta)   true_labels=pd.Series(index=measure_times.index)   true_labels.iloc[list(idxSet)]=1   true_labels.fillna(0,inplace=True)   return true_labels #          def check_model(model,df_train,df_test,filt='S[123]'):   model.fit(df_train.drop('Time',axis=1).filter(regex=(filt)))   y_preds = pd.Series(model.predict(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))).map({-1:1,1:0})   print('F1 score: {:.3f}'.format(f1_score(df_test['Label'],y_preds)))   print('Precision score: {:.3f}'.format(precision_score(df_test['Label'],y_preds)))   print('Recall score: {:.3f}'.format(recall_score(df_test['Label'],y_preds)))   score = model.decision_function(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))   sns.distplot(score[df_test['Label']==0])   sns.distplot(score[df_test['Label']==1]) df_train,df_test,anomaly_times=load_and_preprocess(12) df_test['Label']=get_true_labels(df_test['Time'],dfc,30)

PHM 2015 डेटा चैलेंज डेटासेट पर सरल विसंगति खोज एल्गोरिदम के लिए परीक्षा परिणाम

वापस एल्गोरिदम में। आइए हमारे डेटा पर वन क्लास एसवीएम (ओसीएसवीएम), आइसोलेशनफोरेस्ट (आईएफ), एलिप्टीकाइवल्यूड (ईई) और लोकलऑउटलाइफफैक्टर (एलओएफ) की कोशिश करें। शुरू करने के लिए, हम कोई पैरामीटर सेट नहीं करेंगे। मैं ध्यान देता हूं कि LOF दो मोड में काम कर सकता है। यदि नवीनता = गलत केवल प्रशिक्षण सेट में विसंगतियों की खोज करने में सक्षम है (केवल fit_predict है), यदि सही है, तो इसका उद्देश्य प्रशिक्षण सेट के बाहर विसंगतियों की खोज करना है (अलग से फिट और भविष्यवाणी कर सकते हैं)। IF में पुराने और नए का व्यवहार मोड है। हम नया प्रयोग करते हैं। वह बेहतर परिणाम देता है।

OCSVM विसंगतियों का अच्छी तरह से पता लगाता है, लेकिन बहुत सारे झूठे-सकारात्मक भी हैं। अन्य तरीकों के लिए, परिणाम और भी खराब है।

लेकिन मान लीजिए कि हम डेटा में विसंगतियों का प्रतिशत जानते हैं। हमारे मामले में, 27%। OCSVM में nu है - त्रुटियों के प्रतिशत के लिए ऊपरी अनुमान और समर्थन वैक्टर के प्रतिशत के लिए कम। अन्य संदूषण विधियों में डेटा त्रुटियों का प्रतिशत होता है। IF और LOF विधियों में, यह स्वचालित रूप से निर्धारित किया जाता है, जबकि OCSVM और EE के लिए यह डिफ़ॉल्ट रूप से 0.1 पर सेट है। आइए 0.27 पर संदूषण (एनयू) सेट करने का प्रयास करें। अब ईई के लिए शीर्ष परिणाम।

चेकिंग मॉडल के लिए कोड:

 def check_model(model,df_train,df_test,filt='S[123]'):   model_type,model = model   model.fit(df_train.drop('Time',axis=1).filter(regex=(filt)))   y_preds = pd.Series(model.predict(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))).map({-1:1,1:0})   print('F1 score for {}: {:.3f}'.format(model_type,f1_score(df_test['Label'],y_preds)))   print('Precision score for {}: {:.3f}'.format(model_type,precision_score(df_test['Label'],y_preds)))   print('Recall score for {}: {:.3f}'.format(model_type,recall_score(df_test['Label'],y_preds)))   score = model.decision_function(df_test.drop(['Time','Label'],axis=1).filter(regex=(filt)))   sns.distplot(score[df_test['Label']==0])   sns.distplot(score[df_test['Label']==1])   plt.title('Decision score distribution for {}'.format(model_type))   plt.show()

विभिन्न तरीकों के लिए विसंगति संकेतक के वितरण को देखना दिलचस्प है। यह देखा जा सकता है कि एलओएफ इस डेटा के लिए अच्छा काम नहीं करता है। ईई के पास ऐसे बिंदु हैं जो एल्गोरिथ्म को बेहद असामान्य मानता है। हालांकि, सामान्य बिंदु गिर जाते हैं। IsoFor और OCSVM दिखाते हैं कि कटऑफ थ्रेशोल्ड (संदूषण / नू) का चुनाव महत्वपूर्ण है, जो सटीकता और पूर्णता के बीच व्यापार को बदल देगा।

यह तर्कसंगत है कि सेंसर के रीडिंग में स्थिर मूल्यों के पास, सामान्य वितरण के करीब है। यदि हमारे पास वास्तव में एक लेबल परीक्षण नमूना है, और अधिमानतः एक सत्यापन भी है, तो संदूषण मूल्य को टिंट किया जा सकता है। अगला सवाल यह है कि कौन सी त्रुटियां अधिक उन्मुख हैं: झूठी सकारात्मक या झूठी नकारात्मक?

एलओएफ का परिणाम बहुत कम है। बहुत प्रभावशाली नहीं है। लेकिन याद रखें कि OHE वेरिएबल StandardScaler द्वारा रूपांतरित चर के साथ इनपुट पर जाते हैं। और डिफ़ॉल्ट दूरी यूक्लिडियन हैं। लेकिन यदि आप S1 और S2 के अनुसार केवल चर को गिनते हैं, तो स्थिति सही हो जाती है और परिणाम अन्य तरीकों के साथ तुलनीय होता है। हालांकि, यह समझना महत्वपूर्ण है कि सूचीबद्ध मीट्रिक क्लासिफायरों के प्रमुख मापदंडों में से एक पड़ोसी की संख्या है। यह महत्वपूर्ण रूप से गुणवत्ता को प्रभावित करता है, और इसे ट्यून किया जाना चाहिए। दूरी मीट्रिक खुद भी लेने के लिए अच्छा होगा।

अब दोनों मॉडलों को संयोजित करने का प्रयास करें। एक की शुरुआत में, हम प्रशिक्षण सेट से विसंगतियों को दूर करते हैं। और फिर हम OCSVM को एक "क्लीनर" प्रशिक्षण सेट पर प्रशिक्षित करेंगे। पिछले परिणामों के अनुसार, हमने ईई में सबसे बड़ी पूर्णता देखी। हम EE के माध्यम से प्रशिक्षण का नमूना साफ़ करते हैं, उस पर OCSVM को प्रशिक्षित करते हैं और F1 = 0.50, सटीकता = 0.34, पूर्णता = 0.95 प्राप्त करते हैं। प्रभावशाली नहीं है। लेकिन हमने सिर्फ nu = 0.27 पूछा। और हमारे पास जो डेटा है वह कमोबेश "स्वच्छ" है। यदि हम मानते हैं कि प्रशिक्षण नमूने पर ईई की पूर्णता समान है, तो 5% त्रुटियां बनी रहेंगी। हम अपने आप को ऐसे नू सेट करते हैं और एफ 1 = 0.69, सटीकता = 0.59, पूर्णता = 0.82 प्राप्त करते हैं। बहुत बढ़िया। यह ध्यान रखना महत्वपूर्ण है कि अन्य तरीकों में ऐसा संयोजन काम नहीं करेगा, क्योंकि वे यह कहते हैं कि प्रशिक्षण सेट और परीक्षण संख्या में विसंगतियों की संख्या समान है। शुद्ध प्रशिक्षण डेटा सेट पर इन विधियों को प्रशिक्षित करते समय, आपको वास्तविक डेटा की तुलना में कम संदूषण को निर्दिष्ट करना होगा और शून्य के करीब नहीं होना चाहिए, लेकिन क्रॉस-सत्यापन के लिए इसका चयन करना बेहतर है।

संकेत के अनुक्रम पर खोज परिणाम को देखना दिलचस्प है:

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

चार्ट की साजिश रचने के लिए कोड:

 def plot_time_course(df_test,dfc,y_preds,start,end,vert_shift=4):   plt.figure(figsize=(15,10))   cols=df_train.filter(regex=('S[12]')).columns   add=0   preds_idx=y_preds.iloc[start:end][y_preds[0]==1].index   true_idx=df_test.iloc[start:end,:][df_test['Label']==1].index   tp_idx=set(true_idx.values).intersection(set(preds_idx.values))   fn_idx=set(true_idx.values).difference(set(preds_idx.values))   fp_idx=set(preds_idx.values).difference(set(true_idx.values))   xtime=df_test['Time'].iloc[start:end]   for col in cols:       plt.plot(xtime,df_test[col].iloc[start:end]+add)       plt.scatter(xtime.loc[tp_idx].values,df_test.loc[tp_idx,col]+add,color='green')       plt.scatter(xtime.loc[fn_idx].values,df_test.loc[fn_idx,col]+add,color='violet')       plt.scatter(xtime.loc[fp_idx].values,df_test.loc[fp_idx,col]+add,color='red')       add+=vert_shift   failures=dfc[(dfc['Start Time']>xtime.iloc[0])&(dfc['Start Time']<xtime.iloc[-1])]   unique_fails=np.sort(failures['Type'].unique())   colors=np.array([np.random.rand(3) for fail in unique_fails])   for fail_idx in failures.index:       c=colors[np.where(unique_fails==failures.loc[fail_idx,'Type'])[0]][0]       plt.axvline(failures.loc[fail_idx,'Start Time'],color=c)       plt.axvline(failures.loc[fail_idx,'End Time'],color=c)   leg=plt.legend(unique_fails)   for i in range(len(unique_fails)):       leg.legendHandles[i].set_color(colors[i])

यदि विसंगतियों का प्रतिशत 5% से कम है और / या वे "सामान्य" संकेतकों से खराब रूप से अलग हैं, तो उपरोक्त विधियां खराब तरीके से काम करती हैं और यह तंत्रिका नेटवर्क पर आधारित एल्गोरिदम का उपयोग करने के लायक है। सबसे सरल मामले में, ये होंगे:

ऑटो एनकोडर (एक प्रशिक्षित ऑटो एनकोडर की एक उच्च त्रुटि रीडिंग में एक असामान्यता का संकेत देगी);
आवर्तक नेटवर्क (अंतिम पढ़ने की भविष्यवाणी करने के लिए अनुक्रम द्वारा सीखना। यदि अंतर बड़ा है - बिंदु असामान्य है)।

अलग-अलग, यह समय श्रृंखला के साथ काम करने की बारीकियों को ध्यान देने योग्य है। यह समझना महत्वपूर्ण है कि उपरोक्त एल्गोरिदम (ऑटोकेनोडर्स और जंगलों को छोड़कर) में से अधिकांश लैग सुविधाओं (समय में पिछले बिंदुओं से रीडिंग) को जोड़ते समय सबसे खराब गुणवत्ता देगा।

आइए हमारे उदाहरण में लैग सुविधाओं को जोड़ने का प्रयास करें। प्रतियोगिता का वर्णन कहता है कि त्रुटि से 3 घंटे पहले के मान किसी भी तरह से त्रुटि से नहीं जुड़े हैं। फिर 3 घंटे में संकेत जोड़ें। कुल 259 संकेत।

नतीजतन, OCSVM और IsolationForest के परिणाम लगभग अपरिवर्तित रहे, जबकि एलिप्टिक एन्वेल और LOF के लिए गिरावट आई।

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

स्रोत

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

होल्ट-विंटर्स मॉडल

ट्रिपल घातीय चौरसाई, श्रृंखला को 3 घटकों में विभाजित करता है: स्तर, प्रवृत्ति और मौसमी। तदनुसार, यदि श्रृंखला इस रूप में प्रस्तुत की जाती है, तो विधि अच्छी तरह से काम करती है। फेसबुक पैगंबर एक समान सिद्धांत पर काम करता है, लेकिन घटकों का मूल्यांकन अलग तरीके से करता है। अधिक विवरण पढ़ा जा सकता है, उदाहरण के लिए, यहाँ ।

एस (ARIMA)

इस पद्धति में, पूर्वानुमान मॉडल निरंकुशता और चलती औसत पर आधारित है। यदि हम S (ARIMA) के विस्तार के बारे में बात कर रहे हैं, तो यह हमें मौसमीता का मूल्यांकन करने की अनुमति देता है। यहाँ , यहाँ और यहाँ के दृष्टिकोण के बारे में और पढ़ें।

अन्य भविष्य कहनेवाला सेवा दृष्टिकोण

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

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

पंक्ति का निरंतर भाग चुना जाता है (उदाहरण के लिए, 70%, और बाकी को हटा दिया जाता है) और मूल आकार तक फैला हुआ है
पंक्ति का एक निरंतर भाग (जैसे, 20%) चयनित और फैला या संकुचित है। उसके बाद, पूरी पंक्ति तदनुसार संकुचित या अपने मूल आकार तक फैली हुई है।

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

आप स्वयं वितरण के बारे में यहाँ पढ़ सकते हैं, और यहाँ आवर्तक जाल के साथ इसके उपयोग के बारे में। इस वितरण के दो पैरामीटर हैं α और। α इंगित करता है कि घटना कब होगी, और confident इंगित करता है कि एल्गोरिथ्म कितना आश्वस्त है। यद्यपि इस दृष्टिकोण का अनुप्रयोग आशाजनक है, इस मामले में तंत्रिका नेटवर्क को प्रशिक्षित करने में कठिनाइयाँ आती हैं, क्योंकि एल्गोरिथ्म के लिए पहले से अनिश्चित होना आसान है ताकि पर्याप्त जीवनकाल का अनुमान लगाया जा सके।

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

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

क्या कोई रिक्तियां हैं? बेशक!

जावा डेवलपर (बड़ा डेटा)

गणितज्ञों की भविष्यवाणी। हम विसंगतियों का पता लगाने के लिए मुख्य तरीकों का विश्लेषण करते हैं

तरीकों

होल्ट-विंटर्स मॉडल

एस (ARIMA)

अन्य भविष्य कहनेवाला सेवा दृष्टिकोण

More articles: