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

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

रैखिक वर्गीकारक क्या है?

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

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

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

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

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

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

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

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

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

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

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

जहाँ 0 भारों का समूह, विशेषताएँ और b पूर्वाग्रह है।

फ़ंक्शन को दो भागों में विभाजित किया जा सकता है:

• रेखीय मॉडल
• लॉजिस्टिक फ़ंक्शन

रैखिक मॉडल

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

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

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

लॉजिस्टिक फ़ंक्शन

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

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

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

• 0 से 0.49 के बीच के मान वर्ग 0 बन जाते हैं
• 0.5 से 1 के बीच के मान वर्ग 1 बन जाते हैं

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

शुद्धता

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

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

असमंजस का जाल

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

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

• टीपी: सत्य सकारात्मक: पूर्वानुमानित मान वास्तविक सकारात्मक के रूप में सही ढंग से पूर्वानुमानित
• एफपी: पूर्वानुमानित मूल्यों ने वास्तविक सकारात्मक की गलत भविष्यवाणी की। यानी, नकारात्मक मूल्यों को सकारात्मक के रूप में पूर्वानुमानित किया गया
• FN: गलत नकारात्मक: सकारात्मक मानों की नकारात्मक के रूप में भविष्यवाणी की गई
• टीएन: सत्य नकारात्मक: पूर्वानुमानित मान वास्तविक नकारात्मक के रूप में सही ढंग से पूर्वानुमानित हैं

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

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

कन्फ्यूजन मैट्रिक्स ट्रू पॉजिटिव और फॉल्स पॉजिटिव के बारे में अच्छी जानकारी देता है। कुछ मामलों में, अधिक संक्षिप्त मीट्रिक होना बेहतर होता है।

शुद्धता

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

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

संवेदनशीलता

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

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

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

• यदि आय 1 हजार से अधिक है तो इसका मान 50 होगा
• 0 यदि आय < 50k.

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

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

• कार्यस्थल
• शिक्षा
• वैवाहिक
• व्यवसाय
• संबंध
• दौड़
• लिंग
• जन्मभूमि

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

• उम्र
• एफएनएलडब्ल्यूजीटी
• शिक्षा_संख्या
• पूंजी_लाभ
• पूंजी_हानि
• घंटे_सप्ताह

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

हम निम्नानुसार आगे बढ़ेंगे:

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

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

आप सबसे पहले ट्यूटोरियल के दौरान उपयोग की गई लाइब्रेरीज़ को आयात करें।

import tensorflow as tf
import pandas as pd

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

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

## Define path data
COLUMNS = ['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                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

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

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]

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

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: object

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

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

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

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

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

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

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

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

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

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

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

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if 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 value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(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 दस्तावेज़ के अनुसार, श्रेणीबद्ध डेटा को परिवर्तित करने के विभिन्न तरीके हैं। यदि किसी विशेषता की शब्दावली सूची ज्ञात है और उसमें बहुत सारे मान नहीं हैं, तो categorical_column_with_vocabulary_list के साथ श्रेणीबद्ध कॉलम बनाना संभव है। यह सभी अद्वितीय शब्दावली सूची को एक आईडी प्रदान करेगा।

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

• पति
• पत्नी
• सिंगल

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

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

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

पंक्तियाँ	लिंग	परिवर्तन के बाद	नर	महिला
1	नर	=>	1	0
2	नर	=>	1	0
3	महिला	=>	0	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'])

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

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

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

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

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

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

• रैखिक प्रतिगमन: LinearRegressor
• रैखिक वर्गीकरण: LinearClassifier

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

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

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

उत्पादन

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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_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)

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

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

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 = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

ध्यान दें कि अंतिम 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:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO: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:23
INFO: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⁵मॉडल अब पैटर्न को बेहतर तरीके से पकड़ता है। यह पॉलीनोमियल रिग्रेशन की शक्ति है।

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

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

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

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

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': रूपांतरित करने के लिए चर को परिभाषित करें

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

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

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]

नोट कि आपने ग्राफ की निर्देशिका बदल दी है। आप एक ही निर्देशिका में अलग-अलग मॉडल को प्रशिक्षित नहीं कर सकते। इसका मतलब है, आपको तर्क मॉडल_निर्देशिका का पथ बदलने की आवश्यकता है। यदि आप ऐसा नहीं करते हैं तो 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': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_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 = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>

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:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO: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:39
INFO: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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_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 = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO: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.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>

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:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO: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:54
INFO: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 प्रतिशत है। यह पिछले मॉडल की तुलना में XNUMX प्रतिशत अधिक है।

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

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

आपका मॉडल इससे पीड़ित हो सकता है ओवरफिटिंग or अंडरफिटिंग.

• ओवरफिटिंग: मॉडल नए डेटा के लिए पूर्वानुमान को सामान्यीकृत करने में असमर्थ है
• अंडरफिटिंग: मॉडल डेटा के पैटर्न को पकड़ने में असमर्थ है। यानी, जब डेटा गैर-रैखिक होता है तो रैखिक प्रतिगमन

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

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

• एल1: लैस्सो
• L2: रिज

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

आप स्वयं हाइपरपैरामीटर्स के विभिन्न मानों को आज़मा सकते हैं और देख सकते हैं कि क्या आप सटीकता के स्तर को बढ़ा सकते हैं।

नोट यदि आप हाइपरपैरामीटर बदलते हैं, तो आपको underway/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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_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 = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO: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.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>

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:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO: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:09
INFO: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}

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

सारांश

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

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

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

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

इसके बाद, आप train(), evaluate() और predict() के साथ प्रशिक्षण, मूल्यांकन और भविष्यवाणी करने के लिए तैयार हैं

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

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