TensorFlow में बाइनरी वर्गीकरण: रैखिक क्लासिफायरमेंट उदाहरण

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

रैखिक क्लासिफायरियर क्या है?

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

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

1. यदि लेबल में केवल दो वर्ग हैं, तो लर्निंग एल्गोरिथ्म एक बाइनरी क्लासिफायरियर है।
2. Multiclass Classifier दो से अधिक कक्षाओं के साथ लेबल से निपटता है।

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

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

इस ट्यूटोरियल में, आप सीखेंगे

• रैखिक क्लासिफायरियर क्या है?
• बाइनरी क्लासिफायर कैसे काम करता है?
• रैखिक क्लासिफायर के प्रदर्शन को कैसे मापें?
• शुद्धता
• असमंजस का जाल
• परिशुद्धता और संवेदनशीलता
• TensorFlow के साथ रैखिक क्लासिफायरियर
• चरण 1) डेटा आयात करें
• चरण 2) डेटा रूपांतरण
• चरण 3) क्लासीफायर को प्रशिक्षित करें
• चरण 4) मॉडल में सुधार करें
• चरण 5) हाइपरपरमीटर: लासो और रिज

बाइनरी क्लासिफायर कैसे काम करता है?

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

TensorFlow बाइनरी क्लासिफायरियर के लिए, लेबल में दो संभावित पूर्णांक मान हो सकते हैं। ज्यादातर मामलों में, यह या तो [0,1] या [1,2] है। उदाहरण के लिए, उद्देश्य यह अनुमान लगाना है कि ग्राहक कोई उत्पाद खरीदेगा या नहीं। लेबल को निम्नानुसार परिभाषित किया गया है:

• Y = 1 (ग्राहक ने उत्पाद खरीदा)
• Y = 0 (ग्राहक उत्पाद नहीं खरीदता)

मॉडल प्रत्येक ग्राहक को सबसे संभावित वर्ग में वर्गीकृत करने के लिए सुविधाओं के एक्स का उपयोग करता है, जिसका वह संभावित खरीदार या नहीं।

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

जहाँ 0 वज़न का सेट है, सुविधाएँ और b पूर्वाग्रह।

समारोह दो भागों में विघटित हो सकता है:

• रैखिक मॉडल
• रसद समारोह

रैखिक मॉडल

जिस तरह से वजन की गणना की जाती है उससे आप पहले से ही परिचित हैं। एक डॉट उत्पाद का उपयोग करके वज़न की गणना की जाती है: Y सभी सुविधाओं का एक रैखिक कार्य है x _i । यदि मॉडल में विशेषताएं नहीं हैं, तो पूर्वाग्रह पूर्वाग्रह के बराबर है, बी।

वज़न सुविधाएँ x _i और लेबल y के बीच सहसंबंध की दिशा को इंगित करता है । एक सकारात्मक सहसंबंध सकारात्मक वर्ग की संभावना को बढ़ाता है जबकि एक नकारात्मक सहसंबंध संभावना को 0 के करीब ले जाता है, (यानी, नकारात्मक संबंध)।

लीनियर मॉडल केवल वास्तविक संख्या देता है, जो रेंज [0,1] की प्रायिकता माप के साथ असंगत है। लॉजिस्टिक फ़ंक्शन को रैखिक मॉडल आउटपुट को प्रायिकता में बदलने की आवश्यकता होती है,

तार्किक कार्य

लॉजिस्टिक फ़ंक्शन या सिग्मॉइड फ़ंक्शन का एक एस-आकार होता है और इस फ़ंक्शन का आउटपुट हमेशा 0 और 1 के बीच होता है।

लॉजिस्टिक फंक्शन का उदाहरण

सिग्मॉइड फ़ंक्शन में रैखिक प्रतिगमन के आउटपुट को स्थानापन्न करना आसान है। यह 0 और 1 के बीच संभावना के साथ एक नई संख्या में परिणत होता है।

वर्गीकरणकर्ता संभाव्यता को कक्षा में बदल सकता है

• ० से ०.४ ९ के बीच मान वर्ग ० हो जाते हैं
• 0.5 से 1 के बीच मान कक्षा 1 बन जाते हैं

रैखिक क्लासिफायर के प्रदर्शन को कैसे मापें?

शुद्धता

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

सटीकता मीट्रिक का उपयोग करके रैखिक क्लासिफायर के प्रदर्शन को मापें

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

असमंजस का जाल

क्लासिफायर के प्रदर्शन का आकलन करने का एक बेहतर तरीका भ्रम मैट्रिक्स को देखना है।

भ्रम मैट्रिक्स का उपयोग करके रैखिक क्लासिफायरियर के प्रदर्शन को मापें

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

• टीपी: ट्रू पॉजिटिव: पूर्व निर्धारित मानों को वास्तविक पॉजिटिव बताया
• एफपी: अनुमानित मूल्यों ने गलत तरीके से वास्तविक सकारात्मक की भविष्यवाणी की। अर्थात, नकारात्मक मानों का सकारात्मक रूप से अनुमान लगाया जाता है
• एफएन: गलत नकारात्मक: सकारात्मक मूल्यों को नकारात्मक के रूप में भविष्यवाणी की जाती है
• TN: सच्चा नकारात्मक: पूर्व निर्धारित मानों को वास्तविक नकारात्मक के रूप में सही रूप से अनुमानित किया गया है

भ्रम मैट्रिक्स से, वास्तविक वर्ग और अनुमानित वर्ग की तुलना करना आसान है।

परिशुद्धता और संवेदनशीलता

भ्रम मैट्रिक्स सच्चे सकारात्मक और झूठे सकारात्मक में एक अच्छी अंतर्दृष्टि प्रदान करता है। कुछ मामलों में, अधिक संक्षिप्त मीट्रिक रखना बेहतर होता है।

शुद्धता

सटीक मीट्रिक सकारात्मक वर्ग की सटीकता को दर्शाता है। यह मापता है कि सकारात्मक वर्ग की भविष्यवाणी कितनी सही है।

अधिकतम अंक 1 है जब क्लासिफायर सभी सकारात्मक मूल्यों को पूरी तरह से वर्गीकृत करता है। अकेले परिशुद्धता बहुत उपयोगी नहीं है क्योंकि यह नकारात्मक वर्ग की उपेक्षा करता है। मीट्रिक को आमतौर पर रिकॉल मीट्रिक के साथ जोड़ा जाता है। रिकॉल को संवेदनशीलता या सच्ची सकारात्मक दर भी कहा जाता है।

संवेदनशीलता

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

TensorFlow के साथ रैखिक क्लासिफायरियर

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

• 1 के मान के साथ अगर आय> 50k
• 0 यदि आय <50k।

यह चर आपका लेबल है

इस डेटासेट में आठ श्रेणीबद्ध चर शामिल हैं:

• कार्यस्थल
• शिक्षा
• वैवाहिक
• कब्जे
• संबंध
• रेस
• लिंग
• मातृभूमि

इसके अलावा, छह निरंतर चर:

• उम्र
• fnlwgt
• education_num
• पूंजी लाभ
• capital_loss
• घंटे_वेक

इस TensorFlow वर्गीकरण उदाहरण के माध्यम से, आप समझेंगे कि TensorFlow अनुमानक के साथ रैखिक TensorFlow Classifiers कैसे प्रशिक्षित करें और सटीकता मीट्रिक कैसे सुधारें।

हम इस प्रकार आगे बढ़ेंगे:

• चरण 1) डेटा आयात करें
• चरण 2) डेटा रूपांतरण
• चरण 3) क्लासिफायरियर को प्रशिक्षित करें
• चरण 4) मॉडल में सुधार करें
• चरण 5) हाइपरपरमीटर: लासो और रिज

चरण 1) डेटा आयात करें

आप पहले ट्यूटोरियल के दौरान उपयोग किए जाने वाले पुस्तकालयों को आयात करते हैं।

import tensorflow as tfimport pandas as pd 

अगला, आप UCI के संग्रह से डेटा आयात करते हैं और कॉलम नामों को परिभाषित करते हैं। आप पंडों के डेटा फ्रेम में कॉलम को नाम देने के लिए COLUMNS का उपयोग करेंगे।

ध्यान दें कि आप पांडस डेटाफ्रेम का उपयोग करके क्लासिफायरियर को प्रशिक्षित करेंगे।

## Define path dataCOLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss','hours_week', 'native_country', 'label']PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

ऑनलाइन संग्रहीत डेटा पहले से ही ट्रेन सेट और परीक्षण सेट के बीच विभाजित हैं।

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

ट्रेन सेट में 32,561 अवलोकन और परीक्षण सेट 16,281 हैं

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

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

label = {'<=50K': 0,'>50K': 1}df_train.label = [label[item] for item in df_train.label]label_t = {'<=50K.': 0,'>50K.': 1}df_test.label = [label_t[item] for item in df_test.label]

ट्रेन के आंकड़ों में, ऊपर 50k और 7841 से कम 24,720 आय है। परीक्षण सेट के लिए अनुपात लगभग समान है। कृपया इस ट्यूटोरियल को और अधिक के लिए पहलुओं पर देखें।

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

चरण 2) डेटा रूपांतरण

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

मॉडल को प्रशिक्षित करने के लिए अनुमानक के पास सुविधाओं की एक सूची होनी चाहिए। इसलिए, कॉलम के डेटा को टेंसर में बदलना होगा।

एक अच्छा अभ्यास अपने प्रकार के आधार पर सुविधाओं की दो सूचियों को परिभाषित करना है और फिर उन्हें अनुमानक के feature_columns में पास करना है।

आप निरंतर सुविधाओं को परिवर्तित करके शुरू करेंगे, फिर स्पष्ट डेटा के साथ एक बाल्टी को परिभाषित करेंगे।

डेटासेट की विशेषताओं में दो प्रारूप हैं:

• पूर्णांक
• वस्तु

प्रत्येक सुविधा को अगले दो चर में उनके प्रकारों के अनुसार सूचीबद्ध किया गया है।

## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']### Define the categorical listCATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

Feature_column को ऑब्जेक्ट वेरिएबल_column से लैस किया गया है ताकि टेंसर में निरंतर वेरिएबल्स के रूपांतरण में मदद मिल सके। नीचे दिए गए कोड में, आप सभी वैरिएबल को CONTI_FEATURES से एक संख्यात्मक मान के साथ एक टेनॉर में बदलते हैं। मॉडल का निर्माण करना अनिवार्य है। सभी स्वतंत्र चर को उचित प्रकार के टेंसर में बदलना होगा।

नीचे हम आपको यह बताने के लिए एक कोड लिखते हैं कि आप क्या देख रहे हैं कि feature_column.numeric_column के पीछे क्या हो रहा है। हम उम्र के लिए परिवर्तित मूल्य को प्रिंट करेंगे। यह व्याख्यात्मक उद्देश्य के लिए है, इसलिए अजगर कोड को समझने की कोई आवश्यकता नहीं है। आप कोड को समझने के लिए आधिकारिक दस्तावेज का उल्लेख कर सकते हैं।

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif continuous == True:c = tf.feature_column.numeric_column(feature)feature_columns = [c]else:c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)c_indicator = tf.feature_column.indicator_column(c)feature_columns = [c_indicator]## Use input_layer to print the valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(sess.run(input_layer))print_transformation(feature = "age", continuous = True)[[39.][50.][38.]… [58.][22.][52.]]

मान बिल्कुल df_train जैसे ही हैं

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES] 

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

उदाहरण के लिए, यदि एक चर स्थिति के तीन अलग-अलग मूल्य हैं:

• पति
• बीवी
• एक

फिर तीन आईडी को जिम्मेदार ठहराया जाएगा। उदाहरण के लिए, पति के पास आईडी 1, पत्नी आईडी 2 और इतने पर होगा।

चित्रण उद्देश्य के लिए, आप इस कोड का उपयोग करके वस्तु चर को TensorFlow में एक श्रेणीगत कॉलम में बदल सकते हैं।

फीचर सेक्स में केवल दो मूल्य हो सकते हैं: पुरुष या महिला। जब हम फीचर सेक्स को रूपांतरित करेंगे, Tensorflow 2 नए कॉलम बनाएगा, एक पुरुष के लिए और एक महिला के लिए। यदि लिंग पुरुष के बराबर है, तो नया स्तंभ पुरुष 1 और महिला 0. के बराबर होगा। यह उदाहरण नीचे दी गई तालिका में प्रदर्शित किया गया है:

पंक्तियों	लिंग	परिवर्तन के बाद	पुरुष	महिला
1	पुरुष	=>	1	०
२	पुरुष	=>	1	०
३	महिला	=>	०	1

टेंसरफ़्लो में:

print_transformation(feature = "sex", continuous = False, size = 2)[[1. 0.][1. 0.][1. 0.]… [0. 1.][1. 0.][0. 1.]]relationship = tf.feature_column.categorical_column_with_vocabulary_list('relationship', ['Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried','Other-relative'])

नीचे, हमने एन्कोडिंग को प्रिंट करने के लिए पायथन कोड जोड़ा। फिर, आपको कोड को समझने की आवश्यकता नहीं है, इसका उद्देश्य परिवर्तन को देखना है

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

नीचे दिए गए कोड में, आप सभी स्पष्ट विशेषताओं पर एक लूप बनाते हैं।

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

चरण 3) क्लासीफायर को प्रशिक्षित करें

TensorFlow वर्तमान में रैखिक प्रतिगमन और रैखिक वर्गीकरण के लिए एक अनुमानक प्रदान करता है।

• रैखिक प्रतिगमन: रैखिक किरण
• रैखिक वर्गीकरण: रैखिकक्लासीफायर

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

मॉडल निरंतर_फिएट और श्रेणीबद्ध_फ्रीचर में निहित स्तंभों के वजन की गणना करेगा।

model = tf.estimator.LinearClassifier(n_classes = 2,model_dir="ongoing/train",feature_columns=categorical_features+ continuous_features)

OUTPUT:

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec':, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

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

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']LABEL= 'label'def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

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

आइए मॉडल को ऑब्जेक्ट model.train के साथ प्रशिक्षित करें। आप उपयुक्त मानों के साथ मॉडल को खिलाने के लिए पहले परिभाषित फ़ंक्शन का उपयोग करते हैं। ध्यान दें कि आपने बैच आकार को 128 पर सेट किया है और कोई भी युग नहीं है। मॉडल को एक हजार से अधिक चरणों में प्रशिक्षित किया जाएगा।

model.train(input_fn=get_input_fn(df_train,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow: Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.INFO:tensorflow:Loss for final step: 5444.363.

ध्यान दें कि नुकसान पिछले 100 कदमों के दौरान घटकर 901 से 1000 तक हो गया।

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

model.evaluate(input_fn=get_input_fn(df_test,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546{'accuracy': 0.7615626,'accuracy_baseline': 0.76377374,'auc': 0.63300294,'auc_precision_recall': 0.50891197,'average_loss': 47.12155,'global_step': 1000,'label/mean': 0.23622628,'loss': 5993.6406,'precision': 0.49401596,'prediction/mean': 0.18454961,'recall': 0.38637546}

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

चरण 4) मॉडल में सुधार करें

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

बहुपद प्रतिगमन तब सहायक होता है जब डेटा में गैर-रैखिकता होती है। डेटा में गैर-रैखिकता को पकड़ने के दो तरीके हैं।

• बहुपद शब्द जोड़ें
• एक परिवर्तनीय चर में निरंतर चर को बकेटाइज़ करें

बहुपद शब्द

नीचे दी गई तस्वीर से, आप देख सकते हैं कि एक बहुपद प्रतिगमन क्या है। यह एक्स चर के साथ अलग शक्ति के साथ एक समीकरण है। एक दूसरी डिग्री के बहुपद प्रतिगमन में दो चर, X और X वर्ग हैं। थर्ड डिग्री के तीन चर होते हैं, X, X ² और X ³

बहुपद प्रतिगमन क्या है

नीचे, हमने दो चर, X और Y के साथ एक ग्राफ का निर्माण किया। जाहिर है कि यह संबंध रैखिक नहीं है। यदि हम एक रेखीय प्रतिगमन जोड़ते हैं, तो हम देख सकते हैं कि मॉडल पैटर्न (बाईं तस्वीर) पर कब्जा करने में असमर्थ है।

अब, नीचे दी गई तस्वीर से बाईं तस्वीर को देखें, हमने पांच-अवधि को प्रतिगमन में जोड़ा (जो कि y = x + x ² + x ³ + x ⁴ + x ^{5 है} । मॉडल अब बेहतर तरीके से पैटर्न को कैप्चर करता है। बहुपद प्रतिगमन की शक्ति।

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

आइए देखें कि क्या यह सटीकता बढ़ाता है।

आपको इस नई सुविधा को डेटासेट में और निरंतर सुविधा की सूची में जोड़ना होगा।

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

def square_var(df_t, df_te, var_name = 'age'):df_t['new'] = df_t[var_name].pow(2)df_te['new'] = df_te[var_name].pow(2)return df_t, df_te

फ़ंक्शन के 3 तर्क हैं:

• df_t: प्रशिक्षण सेट को परिभाषित करें
• df_te: परीक्षण सेट को परिभाषित करें
• var_name = 'age': परिवर्तन करने के लिए चर को परिभाषित करें

आप चर आयु को वर्ग करने के लिए ऑब्जेक्ट पॉव (2) का उपयोग कर सकते हैं। ध्यान दें कि नए चर का नाम 'नया' है

अब फ़ंक्शन स्क्वायर_वर लिखा गया है, तो आप नए डेटासेट बना सकते हैं।

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age') 

जैसा कि आप देख सकते हैं, नए डेटासेट में एक और विशेषता है।

print(df_train_new.shape, df_test_new.shape)(32561, 16) (16281, 16) 

डाटासेट में वर्ग चर को नया कहा जाता है। आपको इसे निरंतर सुविधाओं की सूची में जोड़ने की आवश्यकता है।

CONTI_FEATURES_NEW = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

ध्यान दें कि आपने ग्राफ़ की निर्देशिका को बदल दिया है। आप एक ही निर्देशिका में विभिन्न मॉडलों को प्रशिक्षित नहीं कर सकते। इसका मतलब है, आपको तर्क model_dir के पथ को बदलने की आवश्यकता है। यदि आप TensorFlow नहीं करते हैं तो एक त्रुटि होगी।

model_1 = tf.estimator.LinearClassifier(model_dir="ongoing/train1",feature_columns=categorical_features+ continuous_features_new)

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec':, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES_NEW}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

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

model_1.train(input_fn=get_input_fn(df_train,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train1/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.INFO:tensorflow:Loss for final step: 28861.898.

model_1.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703{'accuracy': 0.7944229,'accuracy_baseline': 0.76377374,'auc': 0.6093755,'auc_precision_recall': 0.54885805,'average_loss': 111.0046,'global_step': 1000,'label/mean': 0.23622628,'loss': 14119.265,'precision': 0.6682401,'prediction/mean': 0.09116262,'recall': 0.2576703}

वर्ग चर ने 0.76 से 0.79 तक सटीकता में सुधार किया। आइए देखें कि क्या आप बकेटाइज़ेशन और इंटरैक्शन टर्म को एक साथ जोड़कर बेहतर कर सकते हैं।

बकेटाइजेशन और इंटरैक्शन

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

इन नई विशेषताओं के साथ, रैखिक मॉडल प्रत्येक बाल्टी के लिए अलग-अलग भार सीखकर रिश्ते को पकड़ सकता है।

TensorFlow में, यह bucketized_column के साथ किया जाता है। आपको सीमाओं में मूल्यों की श्रेणी को जोड़ने की आवश्यकता है।

age = tf.feature_column.numeric_column('age')age_buckets = tf.feature_column.bucketized_column(age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

आप पहले से ही जानते हैं कि आय के साथ गैर-रैखिक है। मॉडल को बेहतर बनाने का एक और तरीका बातचीत के माध्यम से है। TensorFlow के शब्द में, यह फीचर क्रॉसिंग है। फ़ीचर क्रॉसिंग नई सुविधाओं को बनाने का एक तरीका है जो मौजूदा लोगों के संयोजन हैं, जो एक रैखिक क्लासिफायरफायर के लिए सहायक हो सकते हैं जो सुविधाओं के बीच बातचीत को मॉडल नहीं कर सकते।

आप शिक्षा जैसी एक और विशेषता के साथ उम्र को तोड़ सकते हैं। यही है, कुछ समूहों की उच्च आय और अन्य कम होने की संभावना है (पीएचडी छात्र के बारे में सोचें)।

education_x_occupation = [tf.feature_column.crossed_column(['education', 'occupation'], hash_bucket_size=1000)]age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column([age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

एक क्रॉस फ़ीचर कॉलम बनाने के लिए, आप एक ब्रैकेट में क्रॉस करने के लिए चर के साथ cross_column का उपयोग करते हैं। Hash_bucket_size अधिकतम क्रॉसिंग संभावनाओं को इंगित करता है। चर (कम से कम एक चर को श्रेणीबद्ध होने की जरूरत है) के बीच बातचीत बनाने के लिए, आप tf.feature_column.crossed_column का उपयोग कर सकते हैं। इस ऑब्जेक्ट का उपयोग करने के लिए, आपको बातचीत करने के लिए चर ब्रैकेट में जोड़ना होगा और एक दूसरा तर्क, बाल्टी का आकार। बाल्टी का आकार एक चर के भीतर अधिकतम संभव समूह है। यहां आप इसे 1000 पर सेट करते हैं क्योंकि आप समूहों की सही संख्या नहीं जानते हैं

सुविधा स्तंभों में इसे जोड़ने से पहले age_buckets को चुकता करने की आवश्यकता है। आप सुविधाओं के कॉलम में नई सुविधाएँ भी जोड़ते हैं और अनुमानक तैयार करते हैं

base_columns = [age_buckets,]model_imp = tf.estimator.LinearClassifier(model_dir="ongoing/train3",feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

आउटपुट

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'native_country', 'new']def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

आप नए मॉडल का अनुमान लगाने के लिए तैयार हैं और देखें कि क्या यह सटीकता में सुधार करता है।

model_imp.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train3/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.INFO:tensorflow:Loss for final step: 44.18133.

model_imp.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216{'accuracy': 0.8358209,'accuracy_baseline': 0.76377374,'auc': 0.88401634,'auc_precision_recall': 0.69599575,'average_loss': 0.35122654,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.67437,'precision': 0.68986726,'prediction/mean': 0.23320661,'recall': 0.55408216}

नई सटीकता का स्तर 83.58 प्रतिशत है। यह पिछले मॉडल की तुलना में चार प्रतिशत अधिक है।

अंत में, आप ओवरफिटिंग को रोकने के लिए एक नियमितीकरण शब्द जोड़ सकते हैं।

चरण 5) हाइपरपरमीटर: लासो और रिज

आपका मॉडल से ग्रस्त हो सकते overfitting या underfitting ।

• ओवरफिटिंग: मॉडल नए डेटा की भविष्यवाणी को सामान्य करने में असमर्थ है
• अंडरफिटिंग: मॉडल डेटा के पैटर्न को पकड़ने में असमर्थ है। जब डेटा नॉन-लीनियर हो तो लीनियर रिग्रेशन

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

ओवरफिटिंग को रोकने के लिए, नियमितीकरण आपको इस तरह की जटिलता को नियंत्रित करने और इसे अधिक सामान्य बनाने की संभावनाएं देता है। दो नियमितीकरण तकनीकें हैं:

• एल 1: लासो
• L2: रिज

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

आप हाइपरपैरमीटर के अलग-अलग मूल्य अपने आप आज़मा सकते हैं और देख सकते हैं कि क्या आप सटीकता स्तर बढ़ा सकते हैं।

ध्यान दें कि यदि आप हाइपरपरमीटर बदलते हैं, तो आपको चल रहे फ़ोल्डर को हटाना होगा / train4 अन्यथा मॉडल पहले प्रशिक्षित मॉडल से शुरू होगा।

आइए देखें कि प्रचार के साथ सटीकता कैसे है

model_regu = tf.estimator.LinearClassifier(model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,optimizer=tf.train.FtrlOptimizer(learning_rate=0.1,l1_regularization_strength=0.9,l2_regularization_strength=5))

आउटपुट

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

model_regu.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

आउटपुट

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into ongoing/train4/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.INFO:tensorflow:Loss for final step: 43.4942.

model_regu.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

आउटपुट

INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823{'accuracy': 0.83833915,'accuracy_baseline': 0.76377374,'auc': 0.8869794,'auc_precision_recall': 0.7014905,'average_loss': 0.34691378,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.12581,'precision': 0.69720596,'prediction/mean': 0.23662092,'recall': 0.5579823}

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

सारांश

एक मॉडल को प्रशिक्षित करने के लिए, आपको निम्न करने की आवश्यकता है:

• सुविधाओं को परिभाषित करें: स्वतंत्र चर: एक्स
• लेबल को परिभाषित करें: निर्भर चर: y
• एक ट्रेन / परीक्षण सेट का निर्माण
• प्रारंभिक वजन को परिभाषित करें
• नुकसान फ़ंक्शन को परिभाषित करें: MSE
• मॉडल का अनुकूलन करें: ग्रेडिएंट वंश
• परिभाषित करें:
  • सीखने की दर
  • युग की संख्या
  • बैच का आकार
  • कक्षा की संख्या

इस ट्यूटोरियल में, आपने सीखा कि एक लीनियर रिग्रेशन क्लासिफायर के लिए उच्च-स्तरीय एपीआई का उपयोग कैसे करें। आपको परिभाषित करने की आवश्यकता है:

1. फ़ीचर कॉलम। यदि निरंतर: tf.feature_column.numeric_column ()। आप अजगर सूची समझ के साथ एक सूची आबाद कर सकते हैं
2. अनुमानक: tf.estimator.LinearClassifier (feature_columns, model_dir, n_classes = 2)
3. एक समारोह डेटा आयात करने के लिए, बैच आकार और युग: input_fn ()

उसके बाद, आप ट्रेन, मूल्यांकन और ट्रेन (), मूल्यांकन () और पूर्वानुमान () के साथ भविष्यवाणी करने के लिए तैयार हैं

मॉडल के प्रदर्शन को बेहतर बनाने के लिए, आप कर सकते हैं:

• बहुपद प्रतिगमन का उपयोग करें
• सहभागिता शब्द: tf.feature_column.crossed_column
• नियमितीकरण पैरामीटर जोड़ें