मशीन लर्निंग में गॉसियन कर्नेल: कर्नेल तरीके उदाहरण

इस ट्यूटोरियल का उद्देश्य एक डेटासेट को रैखिक रूप से अलग करना है। ट्यूटोरियल को दो भागों में विभाजित किया गया है:

1. फ़ीचर परिवर्तन
2. Tensorflow के साथ एक कर्नेल क्लासिफायरफ़ॉर्म ट्रेन

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

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

• आपको कर्नेल विधियों की आवश्यकता क्यों है?
• मशीन लर्निंग में एक कर्नेल क्या है?
• कर्नेल विधियों के प्रकार
• TensorFlow के साथ गाऊसी कर्नेल क्लासिफायर ट्रेन

आपको कर्नेल विधियों की आवश्यकता क्यों है?

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

import numpy as npimport matplotlib.pyplot as pltfrom 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() 

ऊपर दिए गए आंकड़े का डेटा 2 डी गाऊसी कर्नेल योजना में है जो अलग नहीं है। आप इन डेटा को तीन-आयाम में बदलने का प्रयास कर सकते हैं, इसका मतलब है, आप 3 अक्षों के साथ एक आंकड़ा बनाते हैं।

हमारे गाऊसी कर्नेल उदाहरण में, हम अपने डेटा को 3 डी आयाम में लाने के लिए एक बहुपद मानचित्रण लागू करेंगे। डेटा को बदलने का सूत्र इस प्रकार है।

आप नई सुविधा नक्शे बनाने के लिए गॉसियन कर्नेल पायथन में एक फ़ंक्शन को परिभाषित करते हैं

उपरोक्त सूत्र को कोड करने के लिए आप numpy का उपयोग कर सकते हैं:

सूत्र	समतुल्य Numpy कोड
एक्स	x [:, 0] **
य	x [:, १]
x 2	x [:, ०] ** २
	np.sqrt (2) *
xy	x [:, ०] * x [:, १]
य २	x [:, १] ** २

### illustration purposedef mapping(x, y):x = np.c_[(x, y)]if len(x) > 2:x_1 = x[:,0]**2x_2 = np.sqrt(2)*x[:,0]*x[:,1]x_3 = x[:,1]**2else:x_1 = x[0]**2x_2 = np.sqrt(2)*x[0]*x[1]x_3 = x[1]**2trans_x = np.array([x_1, x_2, x_3])return trans_x

नई मैपिंग 16 बिंदुओं के साथ 3 आयामों के साथ होनी चाहिए

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

आइए क्रमशः 3 अक्ष, x, y और z के साथ एक नया प्लॉट बनाएं।

# plotfig = 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() 

हमें एक सुधार दिखाई देता है लेकिन अगर हम कथानक के उन्मुखीकरण को बदलते हैं, तो यह स्पष्ट है कि डेटासेट अब अलग है

# plotfig = 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() 

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

इस समस्या को दूर करने का सबसे आम तरीका एक कर्नेल का उपयोग करना है ।

मशीन लर्निंग में एक कर्नेल क्या है?

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

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

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

कर्नेल का जादू एक ऐसा फ़ंक्शन ढूंढना है जो उच्च-आयामी संगणना द्वारा उत्पन्न सभी परेशानी से बचा जाता है। कर्नेल का परिणाम एक अदिश राशि है, या अलग-अलग कहा जाता है कि हम एक आयामी स्थान पर वापस आ गए हैं

इस फ़ंक्शन को प्राप्त करने के बाद, आप इसे मानक रैखिक क्लासिफायरियर पर प्लग कर सकते हैं।

आइए कर्नेल मशीन लर्निंग की अवधारणा को समझने के लिए एक उदाहरण देखते हैं। आपके पास दो वैक्टर, X1 और x2 हैं। उद्देश्य बहुपद मानचित्रण का उपयोग करके एक उच्च आयाम बनाना है। आउटपुट नए फीचर मैप के डॉट प्रोडक्ट के बराबर है। उपरोक्त विधि से, आपको निम्न करने की आवश्यकता है:

1. नए आयाम में X1 और x2 का रूपांतरण करें
2. डॉट उत्पाद की गणना करें: सभी गुठली के लिए सामान्य
3. नए आयाम में X1 और x2 का रूपांतरण करें

आप उच्च आयाम की गणना करने के लिए ऊपर बनाए गए फ़ंक्शन का उपयोग कर सकते हैं।

## Kernelx1 = 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. ]] 

डॉट उत्पाद की गणना करें

आप x_1 में संग्रहीत पहले और दूसरे वेक्टर के बीच डॉट उत्पाद की गणना करने के लिए ऑब्जेक्ट को numpy से उपयोग कर सकते हैं।

print(np.dot(x_1[:,0], x_1[:,1]))8100.0 

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

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

आप पालन के रूप में बहुपद कर्नेल फ़ंक्शन को पायथन में लिख सकते हैं।

def polynomial_kernel(x, y, p=2):return (np.dot(x, y)) ** p 

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

polynomial_kernel(x1, x2, p=2)8100 

कर्नेल विधियों के प्रकार

बहुत सारी कर्नेल तकनीक उपलब्ध हैं। सबसे सरल रैखिक कर्नेल है। यह फ़ंक्शन पाठ वर्गीकरण के लिए बहुत अच्छा काम करता है। अन्य कर्नेल है:

• बहुपद कर्नेल
• गाऊसी कर्नेल

TensorFlow के साथ उदाहरण में, हम रैंडम फूरियर का उपयोग करेंगे। TensorFlow के पास नई सुविधा स्थान की गणना करने के लिए अनुमानक में एक निर्माण है। गाऊसी फिल्टर फ़ंक्शन गाऊसी कर्नेल फ़ंक्शन का एक अनुमान है।

गाऊसी फ़िल्टरिंग फ़ंक्शन बहुत अधिक आयामी स्थान में डेटा बिंदुओं के बीच समानता की गणना करता है।

TensorFlow के साथ गाऊसी कर्नेल क्लासिफायर ट्रेन

एल्गोरिथ्म का उद्देश्य 50k से अधिक या कम कमाई वाले घर का वर्गीकरण करना है।

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

आप वयस्क डाटासेट से निम्नलिखित चर का उपयोग करते हैं:

• उम्र
• वर्कक्लास
• fnlwgt
• शिक्षा
• education_num
• वैवाहिक
• कब्जे
• संबंध
• रेस
• लिंग
• पूंजी लाभ
• capital_loss
• घंटे_वेक
• मातृभूमि
• लेबल

मॉडल का मूल्यांकन और मूल्यांकन करने से पहले आप आगे बढ़ेंगे:

• चरण 1) पुस्तकालयों को आयात करें
• चरण 2) डेटा आयात करें
• चरण 3) डेटा तैयार करें
• चरण 4) input_fn का निर्माण करें
• चरण 5) लॉजिस्टिक मॉडल का निर्माण करें: बेसलाइन मॉडल
• चरण 6) मॉडल का मूल्यांकन करें
• चरण 7) कर्नेल क्लासिफायरियर का निर्माण करें
• चरण 8) कर्नेल क्लासिफायरियर का मूल्यांकन करें

चरण 1) पुस्तकालयों को आयात करें

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

#import numpy as npfrom sklearn.model_selectionimport train_test_splitimport tensorflow as tfimport pandas as pdimport numpy as np

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

आप निम्न वेबसाइट से डेटा डाउनलोड करते हैं और आप इसे पांडा डेटाफ़्रेम के रूप में आयात करते हैं।

## 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"## Importdf_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) 

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

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) डेटा तैयार करें

डेटासेट में निरंतर और श्रेणीबद्ध दोनों विशेषताएं होती हैं। एक अच्छा अभ्यास निरंतर चर के मूल्यों को मानकीकृत करना है। आप समारोह का उपयोग कर सकते हैं Standard -caler विज्ञान-किट से सीखें। आप एक उपयोगकर्ता-परिभाषित फ़ंक्शन बनाते हैं और साथ ही ट्रेन और परीक्षण सेट को परिवर्तित करना आसान बनाते हैं। ध्यान दें कि, आप एक सामान्य डेटासेट के लिए निरंतर और श्रेणीबद्ध चर को समेटते हैं और सरणी का प्रकार होना चाहिए: 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 StandardScalerfrom sklearn import preprocessingdef 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 Estimator का उपयोग करके परिभाषित किया गया है, आप फ़ीचर कॉलम और ग्राफ़ को सहेजने के लिए निर्देश देते हैं।

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': , '_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 modeltrain_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 = 1INFO:tensorflow:global_step/sec: 324.16INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)INFO:tensorflow:global_step/sec: 267.092INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)INFO:tensorflow:global_step/sec: 292.679INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)INFO:tensorflow:global_step/sec: 225.582INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)INFO:tensorflow:global_step/sec: 209.975INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)INFO:tensorflow:global_step/sec: 241.648INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)INFO:tensorflow:global_step/sec: 305.193INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)INFO:tensorflow:global_step/sec: 396.295INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)INFO:tensorflow:global_step/sec: 359.857INFO: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.

चरण 6) मॉडल का मूल्यांकन करें

आप मॉडल का मूल्यांकन करने के लिए संख्यात्मक अनुमानक को परिभाषित करते हैं। आप मूल्यांकन के लिए संपूर्ण डेटासेट का उपयोग करते हैं

# Evaluationtest_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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000INFO: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:23INFO: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 प्रतिशत की सटीकता है। अगले भाग में, आप एक कर्नेल क्लासिफायर के साथ लॉजिस्टिक क्लासिफायर को हराने की कोशिश करेंगे

चरण 7) कर्नेल क्लासिफायरियर का निर्माण करें

कर्नेल आकलनकर्ता पारंपरिक रैखिक क्लासिफायरियर से अलग नहीं है, कम से कम निर्माण की अवधि में। पीछे का विचार रैखिक क्लासिफायरियर के साथ स्पष्ट कर्नेल की शक्ति का उपयोग करना है।

कर्नेल क्लासिफायरियर को प्रशिक्षित करने के लिए आपको TensorFlow में दो पूर्व-परिभाषित अनुमानक उपलब्ध हैं:

• रैंडमफायररफेसर मैपर
• कर्नेलिनियरक्लासीफायर

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

मॉडल बनाने के लिए, आप इन चरणों का पालन करेंगे:

1. उच्च आयाम कर्नेल फ़ंक्शन सेट करें
2. L2 हाइपरपरमीटर सेट करें
3. मॉडल बनाएं
4. मॉडल को प्रशिक्षित करें
5. मॉडल का मूल्यांकन करें

चरण ए) उच्च आयाम कर्नेल फ़ंक्शन सेट करें

वर्तमान डेटासेट में 14 विशेषताएं हैं जो आप 5.000-आयामी वेक्टर के नए उच्च आयाम में बदल देंगे। आप परिवर्तन को प्राप्त करने के लिए यादृच्छिक फूरियर विशेषताओं का उपयोग करते हैं। यदि आप गाऊसी कर्नेल सूत्र को याद करते हैं, तो आप ध्यान दें कि परिभाषित करने के लिए मानक विचलन पैरामीटर है। वर्गीकरण के दौरान समानता माप के लिए यह पैरामीटर नियंत्रण करता है।

आप RandomFourierFeatureMapper में सभी मापदंडों को ट्यून कर सकते हैं:

• input_dim = 14
• output_dim = 5000
• stddev = 4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm') 

आपको पहले बनाए गए फ़ीचर कॉलम का उपयोग करके कर्नेल मैपर बनाने की आवश्यकता है: feat_column

### Map Kernelkernel_mappers = {feat_column: [kernel_mapper]} 

चरण बी) एल 2 हाइपरपरमीटर सेट करें

ओवरफिटिंग को रोकने के लिए, आप एल 2 रेग्युलर के साथ नुकसान फ़ंक्शन को दंडित करते हैं। आपने L2 हाइपरपरमीटर को 0.1 और लर्निंग रेट को 5 पर सेट किया है

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1) 

चरण C) मॉडल बनाएँ

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

### Prep estimatorestimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train")

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': , '_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'}

चरण डी) मॉडल को प्रशिक्षित करें

अब जब कर्नेल क्लासिफायर बनाया गया है, तो आप इसे प्रशिक्षित करने के लिए तैयार हैं। आप 2000 बार मॉडल को पुनरावृत्त करना चुनते हैं

### estimateestimator_kernel.fit(input_fn=train_input_fn, steps=2000)

WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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 = 1INFO:tensorflow:global_step/sec: 86.6365INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)INFO:tensorflow:global_step/sec: 80.1986INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)INFO:tensorflow:global_step/sec: 79.6376INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)INFO:tensorflow:global_step/sec: 95.8442INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)INFO:tensorflow:global_step/sec: 93.7799INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)INFO:tensorflow:global_step/sec: 94.7071INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)INFO:tensorflow:global_step/sec: 90.7402INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)INFO:tensorflow:global_step/sec: 94.4924INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)INFO:tensorflow:global_step/sec: 95.3472INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)INFO:tensorflow:global_step/sec: 97.2928INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)INFO:tensorflow:global_step/sec: 85.6761INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)INFO:tensorflow:global_step/sec: 91.4194INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)INFO:tensorflow:global_step/sec: 82.5954INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)INFO:tensorflow:global_step/sec: 89.8748INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)INFO:tensorflow:global_step/sec: 76.9761INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)INFO:tensorflow:global_step/sec: 73.7192INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)INFO:tensorflow:global_step/sec: 83.0573INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)INFO:tensorflow:global_step/sec: 71.7029INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)INFO:tensorflow:global_step/sec: 73.2663INFO: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': , 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': , 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): []}}) 

चरण ई) मॉडल का मूल्यांकन करें

अंतिम लेकिन कम से कम, आप अपने मॉडल के प्रदर्शन का मूल्यांकन करते हैं। आपको लॉजिस्टिक रिग्रेशन को मात देने में सक्षम होना चाहिए।

# Evaluate and report metrics.eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 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:50INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000INFO: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:51INFO: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% है, यह लॉजिस्टिक प्रतिगमन की तुलना में 2% सुधार है। सटीकता में सुधार और कम्प्यूटेशनल लागत के बीच एक व्यापार है। आपको यह सोचने की ज़रूरत है कि क्या अलग-अलग क्लासिफायर द्वारा खपत किए गए समय के 2% सुधार और अगर आपके व्यवसाय पर इसका प्रभाव पड़ता है।

सारांश

कर्नेल गैर-रैखिक डेटा को (लगभग) रैखिक में बदलने के लिए एक महान उपकरण है। इस विधि की कमी यह कम्प्यूटेशनल समय लेने वाली और महंगी है।

नीचे, आप कर्नेल क्लासफ़र को प्रशिक्षित करने के लिए सबसे महत्वपूर्ण कोड पा सकते हैं

उच्च आयाम कर्नेल फ़ंक्शन सेट करें

• input_dim = 14
• output_dim = 5000
• stddev = 4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm') 

L2 हाइपरपरमीटर सेट करें

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1) 

मॉडल बनाएं

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train") 

मॉडल को प्रशिक्षित करें

estimator_kernel.fit(input_fn=train_input_fn, steps=2000) 

मॉडल का मूल्यांकन करें

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)