मशीन लर्निंग में गॉसियन कर्नेल: Python कर्नेल विधियाँ

द्वारा: एवलिन क्लार्क एवलिन क्लार्क
Hours Updated

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

  1. सुविधा परिवर्तन
  2. टेन्सरफ्लो के साथ कर्नेल क्लासिफायर को प्रशिक्षित करें

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

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

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

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()

कर्नेल विधि

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

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

कर्नेल विधि

आप गॉसियन कर्नेल में एक फ़ंक्शन परिभाषित करते हैं Python नए फीचर मानचित्र बनाने के लिए

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

सूत्र समतुल्य Numpy कोड
x x[:,0]**
y एक्स[:,1]
x2 x[:,0]**2
कर्नेल विधि एनपी.sqrt(2)*
xy x[:,0]*x[:,1]
y2 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

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

x_1  = mapping(x, y)
x_1.shape
(3, 16)

आइए क्रमशः 3 अक्षों, 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()

कर्नेल विधि

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

इस समस्या से निपटने का सबसे आम तरीका है गिरी.

संबंधित आलेख

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

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

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

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

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

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

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

  1. x1 और x2 को एक नए आयाम में रूपांतरित करें
  2. डॉट उत्पाद की गणना करें: सभी कर्नेल के लिए सामान्य
  3. 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.        ]]

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

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

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

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

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

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

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

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

polynomial_kernel(x1, x2, p=2)			
8100

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

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

  • बहुपद कर्नेल
  • गॉसियन कर्नेल

उदाहरण में TensorFlow, हम रैंडम फूरियर का उपयोग करेंगे। TensorFlow में नए फीचर स्पेस की गणना करने के लिए एक बिल्ट इन एस्टीमेटर है। गॉसियन फ़िल्टर फ़ंक्शन गॉसियन कर्नेल फ़ंक्शन का एक अनुमान है।

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

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

TensorFlow के साथ Gaussian Kernel क्लासिफायर को प्रशिक्षित करें

इस एल्गोरिथ्म का उद्देश्य 50 हजार से अधिक या कम आय वाले परिवारों को वर्गीकृत करना है।

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

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

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

मॉडल को प्रशिक्षित करने और उसका मूल्यांकन करने से पहले आप निम्नानुसार आगे बढ़ेंगे:

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

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

कर्नेल मॉडल को आयात और प्रशिक्षित करने के लिए Artificial Intelligence, आपको tensorflow आयात करने की आवश्यकता है, पांडा और numpy

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

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

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

डेटासेट में निरंतर और श्रेणीबद्ध दोनों विशेषताएं शामिल हैं। निरंतर चर के मानों को मानकीकृत करना एक अच्छा अभ्यास है। आप sci-kit learn से StandardScaler फ़ंक्शन का उपयोग कर सकते हैं। आप ट्रेन और टेस्ट सेट को परिवर्तित करना आसान बनाने के लिए एक उपयोगकर्ता-परिभाषित फ़ंक्शन भी बनाते हैं। ध्यान दें कि, आप निरंतर और श्रेणीबद्ध चर को एक सामान्य डेटासेट में जोड़ते हैं और सरणी इस प्रकार की होनी चाहिए: 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 अनुमानक का उपयोग करके परिभाषित किया जाता है, आप फीचर कॉलम और ग्राफ को कहाँ सहेजना है, इसका निर्देश देते हैं।

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>

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

आप मॉडल का मूल्यांकन करने के लिए 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 प्रतिशत है। अगले भाग में, आप कर्नेल क्लासिफायर के साथ लॉजिस्टिक क्लासिफायर को मात देने की कोशिश करेंगे

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

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

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

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

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

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

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

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

वर्तमान डेटासेट में 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]}

चरण बी) L2 हाइपरपैरामीटर सेट करें

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

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

चरण सी) मॉडल बनाएं

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

### Prep estimator
estimator_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': <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'}

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

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

### 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>]}})

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

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

# 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% है, यह लॉजिस्टिक रिग्रेशन की तुलना में 2% सुधार है। सटीकता सुधार और कम्प्यूटेशनल लागत के बीच एक समझौता है। आपको यह सोचने की ज़रूरत है कि क्या 2% सुधार अलग-अलग क्लासिफायर द्वारा खर्च किए गए समय के लायक है और क्या इसका आपके व्यवसाय पर कोई आकर्षक प्रभाव है।

सारांश

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

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

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

  • इनपुट_डिम = 14
  • आउटपुट_डिम= 5000
  • मानक देव=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)