मशीन लर्निंग में गॉसियन कर्नेल: Python कर्नेल विधियाँ
एवलिन क्लार्क
⚡ स्मार्ट सारांश
गॉसियन कर्नेल विधियाँ उच्च-आयामी फ़ीचर मैप बनाए बिना ही अविभाज्य डेटा को रैखिक रूप से विभाज्य बना देती हैं। यह विवरण बहुपद मानचित्र को दर्शाता है।ping पहले मैन्युअल रूप से, फिर टेन्सरफ्लो में एक रैंडम फूरियर कर्नेल क्लासिफायर को प्रशिक्षित करता है।
इस ट्यूटोरियल का उद्देश्य डेटासेट को रैखिक रूप से अलग करना है। ट्यूटोरियल को दो भागों में विभाजित किया गया है:
- सुविधा परिवर्तन
- TensorFlow का उपयोग करके कर्नेल क्लासिफायर को प्रशिक्षित करें
पहले भाग में, आप मशीन लर्निंग में कर्नेल विधि के पीछे के विचार को समझेंगे, जबकि दूसरे भाग में आप देखेंगे कि कर्नेल क्लासिफायर को कैसे प्रशिक्षित किया जाता है। TensorFlowआप वयस्क डेटासेट का उपयोग करेंगे। इस डेटासेट का उद्देश्य प्रत्येक परिवार के व्यवहार को जानते हुए, 50 डॉलर से कम और उससे अधिक आय वाले परिवारों को वर्गीकृत करना है।
आपको कर्नेल विधियों की आवश्यकता क्यों है?
हर क्लासिफायर का उद्देश्य क्लासों का सही अनुमान लगाना होता है। इसके लिए डेटासेट का पृथक्करणीय होना आवश्यक है। नीचे दिए गए ग्राफ को देखिए; यह आसानी से देखा जा सकता है कि काली रेखा के ऊपर के सभी बिंदु पहली क्लास से संबंधित हैं और बाकी बिंदु दूसरी क्लास से। हालांकि, इतना सरल डेटासेट मिलना अत्यंत दुर्लभ है। अधिकांश मामलों में, डेटा पृथक्करणीय नहीं होता है, और इस प्रकार का डेटा लॉजिस्टिक रिग्रेशन जैसे सरल क्लासिफायर के लिए मुश्किल पैदा करता है।
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
x_lin = np.array([1,2,3,4,5,6,7,8,9,10])
y_lin = np.array([2,2,3,2,2,9,6,8,8,9])
label_lin = np.array([0,0,0,0,0,1,1,1,1,1])
fig = plt.figure()
ax=fig.add_subplot(111)
plt.scatter(x_lin, y_lin, c=label_lin, s=60)
plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2)
ax.set_xlim([-5,15])
ax.set_ylim([-5,15])plt.show()
नीचे दिए गए चित्र में, हमने एक ऐसे डेटासेट को दर्शाया है जो रैखिक रूप से विभाज्य नहीं है। यदि हम एक सीधी रेखा खींचते हैं, तो अधिकांश बिंदु सही वर्ग में वर्गीकृत नहीं होंगे।
इस समस्या से निपटने का एक तरीका यह है कि डेटासेट को लेकर उसे किसी अन्य फ़ीचर मैप में रूपांतरित किया जाए। इसका अर्थ है कि आप एक फ़ंक्शन का उपयोग करके डेटा को एक ऐसे तल पर स्थानांतरित करेंगे जो रैखिक रूप से पृथक्करणीय हो।
x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18]) y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1]) label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1])
fig = plt.figure() plt.scatter(x, y, c=label, s=60) plt.show()
ऊपर दिए गए चित्र का डेटा एक द्विआयामी तल में स्थित है और इसे अलग-अलग नहीं किया जा सकता है। आप इस डेटा को त्रिआयामी रूप में रूपांतरित करने का प्रयास कर सकते हैं, जिसका अर्थ है कि आप तीन अक्षों वाला एक चित्र बना सकते हैं।
हमारे गॉसियन कर्नेल उदाहरण में, हम एक बहुपद मानचित्र लागू करेंगे।ping अपने डेटा को तीसरे आयाम में लाने के लिए। डेटा को रूपांतरित करने का सूत्र इस प्रकार है।
आप गॉसियन कर्नेल में एक फ़ंक्शन परिभाषित करते हैं Python नए फीचर मैप बनाने के लिए।
आप का उपयोग कर सकते हैं Numpy उपरोक्त सूत्र को कोड करने के लिए। नीचे दी गई प्रत्येक पंक्ति मानचित्र के एक पद को जोड़ती है।ping इसे उत्पन्न करने वाले ऐरे एक्सप्रेशन के साथ, और छोटी छवि दो के वर्गमूल के गुणनखंड को दर्शाती है।
| सूत्र | समतुल्य NumPy कोड |
|---|---|
| x | एक्स[:,0] |
| y | एक्स[:,1] |
| x² | x[:,0]**2 |
 |
एनपी.sqrt(2)* |
| xy | x[:,0]*x[:,1] |
| y² | x[:,1]**2 |
### illustration purpose def mapping(x, y): x = np.c_[(x, y)] if len(x) > 2: x_1 = x[:,0]**2 x_2 = np.sqrt(2)*x[:,0]*x[:,1] x_3 = x[:,1]**2 else: x_1 = x[0]**2 x_2 = np.sqrt(2)*x[0]*x[1] x_3 = x[1]**2 trans_x = np.array([x_1, x_2, x_3]) return trans_x
नया नक्शाping इसमें 3 आयाम और 16 बिंदु हैं।
x_1 = mapping(x, y) x_1.shape
(3, 16)
अब x, y और z अक्षों वाला एक नया प्लॉट बनाएं।
# plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60) ax.view_init(30, 185)ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label') plt.show()
हमें सुधार दिखाई देता है, लेकिन यदि हम प्लॉट का ओरिएंटेशन बदलते हैं तो यह स्पष्ट हो जाता है कि डेटासेट अब अलग करने योग्य है।
# plot fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60) ax.view_init(0, -180)ax.set_ylim([150,-50]) ax.set_zlim([-10000,10000]) ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label')plt.show()
यदि आपको किसी बड़े डेटासेट को संसाधित करना है और दो से अधिक आयाम बनाने हैं, तो उपरोक्त विधि से आपको बड़ी समस्या का सामना करना पड़ेगा। दरअसल, आपको सभी डेटा बिंदुओं को रूपांतरित करना होगा, जो स्पष्ट रूप से टिकाऊ नहीं है। इसमें आपको बहुत समय लगेगा और आपके कंप्यूटर की मेमोरी भी खत्म हो सकती है।
इस समस्या को दूर करने का सबसे आम तरीका कर्नेल का उपयोग करना है।
मशीन लर्निंग में कर्नेल क्या है?
इसका उद्देश्य उच्च-आयामी विशेषता स्थान का उपयोग करके डेटा को लगभग रैखिक रूप से अलग करने योग्य बनाना है, जैसा कि ऊपर दिए गए चित्र में दिखाया गया है।
ऐसे कई उच्च आयामी स्थान हैं जो डेटा बिंदुओं को वियोज्य बनाते हैं। उदाहरण के लिए, हमने दिखाया है कि बहुपद मानचित्रping एक बेहतरीन शुरुआत है.
हमने यह भी प्रदर्शित किया है कि बड़ी मात्रा में डेटा के साथ, ये रूपांतरण कुशल नहीं होते हैं। इसके बजाय, आप मशीन लर्निंग में कर्नेल फ़ंक्शन का उपयोग करके नए फ़ीचर प्लेन पर जाए बिना डेटा को संशोधित कर सकते हैं।
कर्नेल का जादू एक ऐसा फ़ंक्शन ढूंढना है जो उच्च-आयामी गणना से उत्पन्न होने वाली सभी परेशानियों से बच सके। कर्नेल का परिणाम एक अदिश राशि होता है, या दूसरे शब्दों में कहें तो, हम एक-आयामी स्थान पर वापस आ जाते हैं।
इस फ़ंक्शन को ढूंढने के बाद, आप इसे मानक लीनियर क्लासिफायर में प्लग कर सकते हैं।
यहां एक उदाहरण दिया गया है जो कर्नेल मशीन लर्निंग की अवधारणा को स्पष्ट करता है। आपके पास दो सदिश x1 और x2 हैं। उद्देश्य एक बहुपद मानचित्र का उपयोग करके एक उच्च आयाम बनाना है।pingआउटपुट नए फीचर मैप के डॉट प्रोडक्ट के बराबर है। उपरोक्त विधि से, आपको निम्न कार्य करने होंगे:
- x1 और x2 को एक नए आयाम में रूपांतरित करें
- डॉट उत्पाद की गणना करें: सभी कर्नेल के लिए सामान्य
x1 और x2 को एक नए आयाम में रूपांतरित करें
आप उच्च आयाम की गणना करने के लिए ऊपर बनाए गए फ़ंक्शन का उपयोग कर सकते हैं।
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
उत्पादन
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
डॉट उत्पाद की गणना करें
आप ऑब्जेक्ट डॉट का उपयोग कर सकते हैं Numpy x_1 में संग्रहित पहले और दूसरे वेक्टर के बीच डॉट प्रोडक्ट की गणना करना।
print(np.dot(x_1[:,0], x_1[:,1]))
8100.0
आउटपुट 8100 है। समस्या यहाँ स्पष्ट है: डॉट प्रोडक्ट की गणना करने के लिए आपको मेमोरी में एक नया फीचर मैप स्टोर करना होगा। यदि आपके पास लाखों रिकॉर्ड वाला डेटासेट है, तो यह गणनात्मक रूप से अप्रभावी है।
इसके बजाय, आप वेक्टर को रूपांतरित किए बिना डॉट प्रोडक्ट की गणना करने के लिए पॉलीनोमियल कर्नेल का उपयोग कर सकते हैं। यह फ़ंक्शन x1 और x2 का डॉट प्रोडक्ट इस प्रकार गणना करता है जैसे कि इन दोनों वैक्टरों को उच्च आयाम में रूपांतरित कर दिया गया हो। दूसरे शब्दों में, कर्नेल फ़ंक्शन किसी अन्य फ़ीचर स्पेस से डॉट प्रोडक्ट का परिणाम गणना करता है।
आप बहुपद कर्नेल फ़ंक्शन को लिख सकते हैं Python निम्नलिखित नुसार।
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
यह दो सदिशों के डॉट उत्पाद की शक्ति है। नीचे, आप बहुपद कर्नेल की दूसरी डिग्री लौटाते हैं। आउटपुट दूसरी विधि के बराबर है। यह कर्नेल का जादू है।
polynomial_kernel(x1, x2, p=2) 8100
कर्नेल विधियों के प्रकार
कई अलग-अलग कर्नेल तकनीकें उपलब्ध हैं। सबसे सरल है लीनियर कर्नेल। यह फ़ंक्शन टेक्स्ट वर्गीकरण के लिए काफी अच्छा काम करता है। अन्य कर्नेल इस प्रकार हैं:
- बहुपद कर्नेल
- गॉसियन कर्नेल
नीचे दी गई तालिका में प्रत्येक उपकरण के कार्य और चिकित्सकों द्वारा इसके उपयोग के समय का सारांश दिया गया है।
| गुठली | यह क्या गणना करता है | विशिष्ट उपयोग |
|---|---|---|
| रैखिक | मूल फ़ीचर स्पेस में प्लेन डॉट उत्पाद | पहले से ही पृथक करने योग्य डेटा और उच्च-आयामी पाठ विशेषताएँ |
| बहुपद | डॉट प्रोडक्ट को p डिग्री तक बढ़ाया गया, जो फीचर इंटरैक्शन को कैप्चर करता है। | जब अंतःक्रियाओं का महत्व ज्ञात हो तो घुमावदार सीमाएँ |
| गॉसियन (आरबीएफ) | दूरी पर आधारित समानता जो बिंदुओं के एक दूसरे से दूर जाने पर शून्य की ओर घटती जाती है | सीमा का आकार अज्ञात होने पर आमतौर पर पहला विकल्प यही होता है। |
TensorFlow के उदाहरण में, हम रैंडम फूरियर फ़ीचर का उपयोग करेंगे। TensorFlow में नए फ़ीचर स्पेस की गणना करने के लिए एक अंतर्निहित एस्टीमेटर है। रैंडम फूरियर फ़ीचर मैपर नीचे दिखाए गए गॉसियन कर्नेल फ़ंक्शन का एक सन्निकटन है।
गॉसियन फ़िल्टरिंग फ़ंक्शन बहुत उच्च आयामी स्थान में डेटा बिंदुओं के बीच समानता की गणना करता है।
सिद्धांत स्पष्ट हो जाने के बाद, इस विस्तृत प्रक्रिया के शेष भाग में एक वास्तविक डेटासेट पर गॉसियन कर्नेल का उपयोग किया जाएगा।
TensorFlow के साथ Gaussian Kernel क्लासिफायर को प्रशिक्षित करें
इस एल्गोरिथ्म का उद्देश्य 50 हजार से अधिक या कम आय वाले परिवारों को वर्गीकृत करना है।
सबसे पहले, आप एक बेंचमार्क मॉडल बनाने के लिए लॉजिस्टिक रिग्रेशन का मूल्यांकन करेंगे। उसके बाद, आप बेहतर परिणाम प्राप्त करने के लिए कर्नेल क्लासिफायर को प्रशिक्षित करेंगे।
आप वयस्क डेटासेट से निम्नलिखित चर का उपयोग करते हैं:
- उम्र
- वर्कक्लास
- एफएनएलडब्ल्यूजीटी
- शिक्षा
- शिक्षा_संख्या
- वैवाहिक
- व्यवसाय
- संबंध
- दौड़
- लिंग
- पूंजी_लाभ
- पूंजी_हानि
- घंटे_सप्ताह
- जन्मभूमि
- लेबल
मॉडल को प्रशिक्षित और मूल्यांकन करने से पहले आप निम्न प्रकार से आगे बढ़ेंगे:
- पुस्तकालयों को आयात करें
- डेटा आयात करें
- डेटा तैयार करें
- लॉजिस्टिक मॉडल का निर्माण करें: बेसलाइन मॉडल
- मॉडल का मूल्यांकन करें
- कर्नेल क्लासिफायर का निर्माण और मूल्यांकन करें
संस्करण नोट: नीचे दिए गए सभी कोड स्निपेट TensorFlow 1.x को लक्षित करते हैं। tf.contrib नेमस्पेस, जो real_valued_column, RandomFourierFeatureMapper और KernelLinearClassifier प्रदान करता है, TensorFlow 2.0 में हटा दिया गया था, और tf.estimator को TensorFlow 2.16 में हटा दिया गया था। वर्तमान रिलीज़ पर, tf.keras.layers.experimental.RandomFourierFeatures लेयर के बाद एक Dense आउटपुट लेयर के साथ, या scikit-learn से RBFSampler और SGDClassifier जोड़ी के साथ समान पाइपलाइन बनाएं।
चरण 1) लाइब्रेरीज़ आयात करें
कर्नेल मॉडल को आयात और प्रशिक्षित करने के लिए Artificial Intelligenceआपको TensorFlow आयात करने की आवश्यकता है। पांडा और नम्पी।
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
चरण 2) डेटा आयात करें
आप डेटा को डाउनलोड करते हैं यूसीआई वयस्क डेटासेट पृष्ठ और इसे पांडास डेटाफ्रेम के रूप में आयात करें।
## 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 "## Import 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)
अब जबकि ट्रेन और टेस्ट सेट परिभाषित हो चुके हैं, आप कॉलम लेबल को स्ट्रिंग से पूर्णांक में बदल सकते हैं। 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]
df_train.shape
(32561, 15)
चरण 3) डेटा तैयार करें
इस डेटासेट में सतत और श्रेणीबद्ध दोनों प्रकार की विशेषताएं हैं। सतत चरों के मानों को मानकीकृत करना एक अच्छा अभ्यास है। आप StandardScaler फ़ंक्शन का उपयोग कर सकते हैं। scikit सीखनेआप ट्रेन और टेस्ट सेट को आसानी से परिवर्तित करने के लिए एक उपयोगकर्ता-परिभाषित फ़ंक्शन भी बनाते हैं। ध्यान दें कि आप सतत और श्रेणीबद्ध चरों को एक सामान्य डेटासेट में संयोजित करते हैं, और सरणी का प्रकार float32 होना चाहिए।
COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week'] CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country'] from sklearn.preprocessing import StandardScaler from sklearn import preprocessing def prep_data_str(df): scaler = StandardScaler() le = preprocessing.LabelEncoder() df_toscale = df[COLUMNS_INT] df_scaled = scaler.fit_transform(df_toscale.astype(np.float64)) X_1 = df[CATE_FEATURES].apply(le.fit_transform) y = df['label'].astype(np.int32) X_conc = np.c_[df_scaled, X_1].astype(np.float32) return X_conc, y
ट्रांसफॉर्मर फ़ंक्शन तैयार है, इसलिए आप डेटासेट को परिवर्तित कर सकते हैं और input_fn फ़ंक्शन बना सकते हैं।
X_train, y_train = prep_data_str(df_train)
X_test, y_test = prep_data_str(df_test)
print(X_train.shape)
(32561, 14)
अगले चरण में, आप एक लॉजिस्टिक रिग्रेशन को प्रशिक्षित करेंगे। यह आपको एक बेसलाइन सटीकता देगा। इसका उद्देश्य एक अलग एल्गोरिथ्म, अर्थात् कर्नेल क्लासिफायर के साथ बेसलाइन को हराना है।
चरण 4) लॉजिस्टिक मॉडल का निर्माण करें: बेसलाइन मॉडल
आप फ़ीचर कॉलम का निर्माण real_valued_column ऑब्जेक्ट के साथ करते हैं। यह सुनिश्चित करेगा कि सभी चर सघन संख्यात्मक डेटा हैं।
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
एस्टिमेटर को TensorFlow एस्टिमेटर API का उपयोग करके परिभाषित किया जाता है; आपको फ़ीचर कॉलम और ग्राफ़ को सहेजने का स्थान प्रदान करना होता है।
estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],
n_classes=2,
model_dir = "kernel_log"
)
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'kernel_log', '_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 0x1a2003f780>, '_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}
आप 200 के आकार के मिनी-बैच का उपयोग करके लॉजिस्टिक रिग्रेशन को प्रशिक्षित करेंगे।
# Train the model train_input_fn = tf.estimator.inputs.numpy_input_fn( x={"features": X_train}, y=y_train, batch_size=200, num_epochs=None, shuffle=True)
आप मॉडल को 1,000 पुनरावृत्तियों के साथ प्रशिक्षित कर सकते हैं।
estimator.train(input_fn=train_input_fn, 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 kernel_log/model.ckpt. INFO:tensorflow:loss = 138.62949, step = 1 INFO:tensorflow:global_step/sec: 324.16 INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec) INFO:tensorflow:global_step/sec: 267.092 INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec) INFO:tensorflow:global_step/sec: 292.679 INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec) INFO:tensorflow:global_step/sec: 225.582 INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec) INFO:tensorflow:global_step/sec: 209.975 INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec) INFO:tensorflow:global_step/sec: 241.648 INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec) INFO:tensorflow:global_step/sec: 305.193 INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec) INFO:tensorflow:global_step/sec: 396.295 INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec) INFO:tensorflow:global_step/sec: 359.857 INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec) INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt. INFO:tensorflow:Loss for final step: 67.79706. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>
चरण 5) मॉडल का मूल्यांकन करें
आप मॉडल का मूल्यांकन करने के लिए NumPy इनपुट फ़ंक्शन को परिभाषित करते हैं। आप मूल्यांकन के लिए संपूर्ण परीक्षण सेट का उपयोग करते हैं।
# Evaluation test_input_fn = tf.estimator.inputs.numpy_input_fn( x={"features": X_test}, y=y_test, batch_size=16281, num_epochs=1, shuffle=False) estimator.evaluate(input_fn=test_input_fn, steps=1)
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-07-12-15:58:22 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23 INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663,
'accuracy_baseline': 0.76377374,
'auc': 0.84898686,
'auc_precision_recall': 0.67214864,
'average_loss': 0.3877216,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 6312.495,
'precision': 0.7362797,
'prediction/mean': 0.21208474,
'recall': 0.39417577}
आपकी सटीकता 82 प्रतिशत है। अगले भाग में, आप कर्नल क्लासिफायर का उपयोग करके लॉजिस्टिक क्लासिफायर को मात देने का प्रयास करेंगे।
चरण 6) कर्नेल क्लासिफायर का निर्माण करें
कर्नेल एस्टीमेटर, कम से कम संरचना के संदर्भ में, पारंपरिक रैखिक क्लासिफायर से बहुत अलग नहीं है। इसके पीछे का विचार एक स्पष्ट कर्नेल मैप की शक्ति को संयोजित करना है।ping लीनियर क्लासिफायर के साथ।
कर्नेल क्लासिफायर को प्रशिक्षित करने के लिए आपको TensorFlow में उपलब्ध दो पूर्व-निर्धारित अनुमानकों की आवश्यकता होगी:
- रैंडमफूरियरफीचरमैपर
- कर्नेललीनियरक्लासिफायर
आपने पहले भाग में सीखा कि कर्नेल फ़ंक्शन का उपयोग करके निम्न आयाम को उच्च आयाम में परिवर्तित करना आवश्यक है। अधिक सटीक रूप से, आप रैंडम फूरियर विशेषताओं का उपयोग करेंगे, जो गॉसियन फ़ंक्शन का अनुमान लगाती हैं। TensorFlow 1.x वह मैप प्रदान करता है।ping इसे RandomFourierFeatureMapper के रूप में उपयोग किया जा सकता है, और मॉडल को KernelLinearClassifier एस्टीमेटर का उपयोग करके प्रशिक्षित किया जा सकता है।
मॉडल बनाने के लिए, आपको इन चरणों का पालन करना होगा:
- उच्च आयाम कर्नेल फ़ंक्शन सेट करें
- L2 हाइपरपैरामीटर सेट करें
- मॉडल बनाएं
- मॉडल को प्रशिक्षित करें
- मॉडल का मूल्यांकन करें
चरण A) उच्च आयामी कर्नेल फ़ंक्शन सेट करें
वर्तमान डेटासेट में 14 विशेषताएँ हैं जिन्हें आप एक नए 5,000-आयामी वेक्टर में रूपांतरित करेंगे। रूपांतरण के लिए आप रैंडम फूरियर विशेषताओं का उपयोग करेंगे। यदि आपको गॉसियन कर्नेल सूत्र याद है, तो आपने देखा होगा कि इसमें एक मानक विचलन पैरामीटर परिभाषित किया जाता है। यह पैरामीटर वर्गीकरण के दौरान उपयोग किए जाने वाले समानता माप को नियंत्रित करता है: एक छोटा मानक विचलन कर्नेल को केवल बहुत निकट बिंदुओं को समान मानने देता है, जबकि एक बड़ा मानक विचलन निर्णय सीमा को सुगम बनाता है।
आप RandomFourierFeatureMapper में सभी पैरामीटर्स को निम्न प्रकार से ट्यून कर सकते हैं:
- इनपुट_डिम = 14
- आउटपुट_डिम = 5000
- मानक विचलन = 4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
आपको पहले बनाए गए फीचर कॉलम का उपयोग करके कर्नेल मैपर का निर्माण करना होगा: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
चरण B) L2 हाइपरपैरामीटर सेट करें
ओवरफिटिंग से बचने के लिए, आप L2 रेगुलराइज़र के साथ लॉस फ़ंक्शन को दंडित करते हैं। आप L2 हाइपरपैरामीटर को 0.1 और लर्निंग रेट को 5 पर सेट करते हैं।
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
चरण C) मॉडल बनाएं
अगला चरण लीनियर क्लासिफिकेशन के समान है। आप बिल्ट-इन एस्टीमेटर KernelLinearClassifier का उपयोग करते हैं। ध्यान दें कि आप पहले से परिभाषित कर्नेल मैपर को जोड़ते हैं और मॉडल डायरेक्टरी को बदलते हैं।
### Prep estimator estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2, optimizer=optimizer, kernel_mappers=kernel_mappers, model_dir="kernel_train")
नीचे दी गई अप्रचलन चेतावनियाँ TensorFlow 1.x पर अपेक्षित हैं, क्योंकि kernel_methods मॉड्यूल पुराने tf.contrib.learn अनुमानकों पर आधारित है।
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version. Instructions for updating: Please switch to tf.contrib.estimator.*_head. WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version. Instructions for updating: Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.* WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version. Instructions for updating: When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead. INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options { per_process_gpu_memory_fraction: 1.0 } , '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}
चरण D) मॉडल को प्रशिक्षित करें
अब जबकि कर्नेल क्लासिफायर बन चुका है, आप इसे प्रशिक्षित करने के लिए तैयार हैं। आप मॉडल को 2,000 बार दोहराने का विकल्प चुनते हैं।
### estimate
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. 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. WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version. Instructions for updating: When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one. 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 kernel_train/model.ckpt. INFO:tensorflow:loss = 0.6931474, step = 1 INFO:tensorflow:global_step/sec: 86.6365 INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec) INFO:tensorflow:global_step/sec: 80.1986 INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec) INFO:tensorflow:global_step/sec: 79.6376 INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec) INFO:tensorflow:global_step/sec: 95.8442 INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec) INFO:tensorflow:global_step/sec: 93.7799 INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec) INFO:tensorflow:global_step/sec: 94.7071 INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec) INFO:tensorflow:global_step/sec: 90.7402 INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec) INFO:tensorflow:global_step/sec: 94.4924 INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec) INFO:tensorflow:global_step/sec: 95.3472 INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec) INFO:tensorflow:global_step/sec: 97.2928 INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec) INFO:tensorflow:global_step/sec: 85.6761 INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec) INFO:tensorflow:global_step/sec: 91.4194 INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec) INFO:tensorflow:global_step/sec: 82.5954 INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec) INFO:tensorflow:global_step/sec: 89.8748 INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec) INFO:tensorflow:global_step/sec: 76.9761 INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec) INFO:tensorflow:global_step/sec: 73.7192 INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec) INFO:tensorflow:global_step/sec: 83.0573 INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec) INFO:tensorflow:global_step/sec: 71.7029 INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec) INFO:tensorflow:global_step/sec: 73.2663 INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec) INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt. INFO:tensorflow:Loss for final step: 0.37795097. KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})
चरण E) मॉडल का मूल्यांकन करें
अंतिम लेकिन महत्वपूर्ण बात यह है कि आप अपने मॉडल के प्रदर्शन का मूल्यांकन करें। आपको लॉजिस्टिक रिग्रेशन को मात देने में सक्षम होना चाहिए।
# Evaluate and report metrics.
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. 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:Starting evaluation at 2018-07-12-15:58:50 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51 INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004
अंतिम सटीकता 84% है, जो लॉजिस्टिक रिग्रेशन बेसलाइन से लगभग 1.6 प्रतिशत अंक अधिक है (0.83975184 बनाम 0.82353663)। सटीकता में सुधार और गणना लागत के बीच एक संतुलन बनाना आवश्यक है। आपको यह विचार करना होगा कि क्या यह सुधार अधिक जटिल क्लासिफायर द्वारा लिए गए समय के लायक है और क्या इसका आपके व्यवसाय पर कोई ठोस प्रभाव पड़ता है।
