Gaussian Kernel ในการเรียนรู้ของเครื่อง: Python วิธีการเคอร์เนล

โดย: เอเวลิน คลาร์ก เอเวลิน คลาร์ก
Hours วันที่อัพเดท

จุดประสงค์ของบทช่วยสอนนี้คือการทำให้ชุดข้อมูลแยกกันเชิงเส้นได้ บทช่วยสอนแบ่งออกเป็นสองส่วน:

  1. การเปลี่ยนแปลงคุณสมบัติ
  2. ฝึกตัวแยกประเภทเคอร์เนลด้วย 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()

วิธีเคอร์เนล

ข้อมูลจากภาพด้านบนอยู่ในแผน 2D Gaussian Kernel ซึ่งไม่สามารถแยกออกได้ คุณสามารถลองแปลงข้อมูลเหล่านี้เป็นสามมิติได้ ซึ่งหมายความว่าคุณสร้างตัวเลขที่มี 3 แกน

ในตัวอย่าง Gaussian Kernel เราจะใช้การแมปพหุนามเพื่อนำข้อมูลของเราไปสู่มิติ 3 มิติ สูตรการแปลงข้อมูลมีดังนี้

วิธีเคอร์เนล

คุณกำหนดฟังก์ชันใน Gaussian Kernel Python เพื่อสร้างแผนที่คุณลักษณะใหม่

คุณสามารถใช้ได้ มึน เพื่อเขียนโค้ดสูตรด้านบน:

สูตร รหัส Numpy ที่เทียบเท่ากัน
x x[:,0]**
y เอ็กซ์[:,1]
x2 x[:,0]**2
วิธีเคอร์เนล np.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 มิติ คุณจะประสบปัญหาใหญ่หากใช้วิธีการข้างต้น ในความเป็นจริง คุณต้องแปลงจุดข้อมูลทั้งหมด ซึ่งเห็นได้ชัดว่าไม่ยั่งยืน คุณจะต้องใช้เวลานาน และคอมพิวเตอร์ของคุณอาจมีหน่วยความจำไม่เพียงพอ

วิธีที่พบบ่อยที่สุดในการแก้ไขปัญหานี้คือการใช้ เมล็ด.

บทความที่เกี่ยวข้อง

Kernel ในการเรียนรู้ของเครื่องคืออะไร?

แนวคิดคือการใช้พื้นที่คุณลักษณะที่มีมิติสูงกว่าเพื่อทำให้ข้อมูลแทบจะแยกออกจากกันเป็นเส้นตรงดังแสดงในรูปด้านบน

มีพื้นที่มิติที่สูงกว่ามากมายเพื่อทำให้จุดข้อมูลแยกกันได้ ตัวอย่างเช่น เราได้แสดงให้เห็นว่าการทำแผนที่พหุนามเป็นการเริ่มต้นที่ดี

เรายังแสดงให้เห็นด้วยว่าเมื่อมีข้อมูลจำนวนมาก การเปลี่ยนแปลงเหล่านี้จึงไม่มีประสิทธิภาพ แต่คุณสามารถใช้ฟังก์ชันเคอร์เนลใน Machine Learning เพื่อแก้ไขข้อมูลโดยไม่ต้องเปลี่ยนแผนคุณลักษณะใหม่ได้

ความมหัศจรรย์ของเคอร์เนลคือการหาฟังก์ชันที่หลีกเลี่ยงปัญหาทั้งหมดที่เกิดจากการคำนวณมิติสูง ผลลัพธ์ของเคอร์เนลคือสเกลาร์ หรือพูดอีกอย่างว่าเรากลับไปสู่อวกาศหนึ่งมิติ

หลังจากที่คุณพบฟังก์ชันนี้แล้ว คุณสามารถเสียบเข้ากับตัวแยกประเภทเชิงเส้นมาตรฐานได้

มาดูตัวอย่างเพื่อทำความเข้าใจแนวคิดของ Kernel Machine Learning คุณมีเวกเตอร์สองตัว, 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.        ]]

คำนวณผลคูณดอท

คุณสามารถใช้จุดวัตถุจาก 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

ประเภทของวิธีการเคอร์เนล

มีเทคนิค Kernel ที่แตกต่างกันมากมาย ที่ง่ายที่สุดคือเคอร์เนลเชิงเส้น ฟังก์ชั่นนี้ใช้งานได้ค่อนข้างดีสำหรับการจัดหมวดหมู่ข้อความ เคอร์เนลอื่นคือ:

  • เคอร์เนลพหุนาม
  • เคอร์เนลเกาส์เซียน

ในตัวอย่างด้วย TensorFlowเราจะใช้สุ่มฟูเรียร์ TensorFlow มีตัวประมาณค่าในตัวเพื่อคำนวณพื้นที่ฟีเจอร์ใหม่ ฟังก์ชันตัวกรองแบบเกาส์เซียนเป็นการประมาณฟังก์ชันเคอร์เนลแบบเกาส์เซียน

ประเภทของวิธีการเคอร์เนล

ฟังก์ชันการกรองแบบเกาส์เซียนจะคำนวณความคล้ายคลึงกันระหว่างจุดข้อมูลในพื้นที่มิติที่สูงกว่ามาก

ฝึกตัวแยกประเภทเคอร์เนล Gaussian ด้วย TensorFlow

วัตถุประสงค์ของอัลกอริทึมคือการจำแนกครัวเรือนที่มีรายได้มากกว่าหรือน้อยกว่า 50 ราย

คุณจะประเมินการเรียนรู้ของเครื่องลอจิสติก Kernel Regression เพื่อให้มีแบบจำลองการวัดประสิทธิภาพ หลังจากนั้น คุณจะฝึก Kernel Classifier เพื่อดูว่าคุณจะได้ผลลัพธ์ที่ดีขึ้นหรือไม่

คุณใช้ตัวแปรต่อไปนี้จากชุดข้อมูลผู้ใหญ่:

  • อายุ
  • ชั้นเรียน
  • Fnlwgt
  • การศึกษา
  • การศึกษา_num
  • สมรส
  • อาชีพ
  • ความสัมพันธ์
  • แข่ง
  • เพศ
  • ทุน_กำไร
  • เงินทุน_ขาดทุน
  • ชั่วโมง_สัปดาห์
  • พื้นเมือง_ประเทศ
  • ฉลาก

คุณจะดำเนินการดังต่อไปนี้ก่อนที่คุณจะฝึกและประเมินโมเดล:

  • ขั้นตอนที่ 1) นำเข้าไลบรารี
  • ขั้นตอนที่ 2) นำเข้าข้อมูล
  • ขั้นตอนที่ 3) เตรียมข้อมูล
  • ขั้นตอนที่ 4) สร้าง input_fn
  • ขั้นตอนที่ 5) สร้างแบบจำลองลอจิสติกส์: แบบจำลองพื้นฐาน
  • ขั้นตอนที่ 6) ประเมินแบบจำลอง
  • ขั้นตอนที่ 7) สร้างตัวแยกประเภทเคอร์เนล
  • ขั้นตอนที่ 8) ประเมินตัวแยกประเภทเคอร์เนล

ขั้นตอน 1) นำเข้าห้องสมุด

เพื่อนำเข้าและฝึกอบรมโมเดลเคอร์เนล ปัญญาประดิษฐ์คุณต้องนำเข้าเทนเซอร์โฟลว์ หมีแพนด้า และจำนวน

#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 จาก sci-kit learn ได้ คุณสร้างฟังก์ชันที่ผู้ใช้กำหนดเช่นกันเพื่อให้ง่ายต่อการแปลงชุดรถไฟและชุดทดสอบ โปรดทราบว่าคุณเชื่อมตัวแปรต่อเนื่องและเป็นหมวดหมู่เข้ากับชุดข้อมูลทั่วไป และอาร์เรย์ควรเป็นประเภท: 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

ฟังก์ชั่น Transformer พร้อมแล้ว คุณสามารถแปลงชุดข้อมูลและสร้างฟังก์ชัน 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': <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) ประเมินแบบจำลอง

คุณกำหนดตัวประมาณค่าตัวเลขเพื่อประเมินโมเดล คุณใช้ชุดข้อมูลทั้งหมดสำหรับการประเมิน

# 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 เพื่อฝึก Kernel Classifier:

  • RandomFourierFeatureMapper
  • เคอร์เนลลิเนียร์ลักษณนาม

คุณได้เรียนรู้ในส่วนแรกว่าคุณต้องแปลงมิติต่ำให้เป็นมิติสูงโดยใช้ฟังก์ชันเคอร์เนล แม่นยำยิ่งขึ้น คุณจะใช้ Random Fourier ซึ่งเป็นค่าประมาณของฟังก์ชัน Gaussian โชคดีที่ Tensorflow มีฟังก์ชันในไลบรารี: RandomFourierFeatureMapper สามารถฝึกโมเดลได้โดยใช้ตัวประมาณค่า KernelLinearClassifier

หากต้องการสร้างแบบจำลอง คุณจะต้องทำตามขั้นตอนเหล่านี้:

  1. ตั้งค่าฟังก์ชันเคอร์เนลมิติสูง
  2. ตั้งค่าไฮเปอร์พารามิเตอร์ L2
  3. สร้างโมเดล
  4. ฝึกโมเดล
  5. ประเมินแบบจำลอง

ขั้นตอน ก) ตั้งค่าฟังก์ชันเคอร์เนลมิติสูง

ชุดข้อมูลปัจจุบันประกอบด้วยคุณลักษณะ 14 ประการที่คุณจะแปลงเป็นมิติสูงใหม่ของเวกเตอร์ 5.000 มิติ คุณใช้ฟีเจอร์ฟูเรียร์แบบสุ่มเพื่อให้เกิดการเปลี่ยนแปลง หากคุณจำสูตร Gaussian Kernel ได้ คุณจะทราบว่ามีค่าพารามิเตอร์ส่วนเบี่ยงเบนมาตรฐานที่ต้องกำหนด พารามิเตอร์นี้ควบคุมสำหรับการวัดความคล้ายคลึงกันซึ่งใช้ในระหว่างการจำแนกประเภท

คุณสามารถปรับแต่งพารามิเตอร์ทั้งหมดใน RandomFourierFeatureMapper ด้วย:

  • input_dim = 14
  • เอาท์พุท_สลัว= 5000
  • stddev=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 Regularizer คุณตั้งค่าไฮเปอร์พารามิเตอร์ L2 เป็น 0.1 และอัตราการเรียนรู้เป็น 5

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

ขั้นตอน ค) สร้างโมเดล

ขั้นตอนต่อไปจะคล้ายกับการจำแนกเชิงเส้น คุณใช้ KernelLinearClassifier ตัวประมาณค่าบิวด์อิน โปรดทราบว่าคุณเพิ่มเคอร์เนล mapper ที่กำหนดไว้ก่อนหน้านี้และเปลี่ยนไดเร็กทอรีโมเดล

### 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% คุ้มค่ากับเวลาที่ตัวแยกประเภทต่างๆ ใช้ไปหรือไม่ และจะมีผลกระทบที่น่าสนใจต่อธุรกิจของคุณหรือไม่

สรุป

เคอร์เนลเป็นเครื่องมือที่ยอดเยี่ยมในการแปลงข้อมูลที่ไม่ใช่เชิงเส้นให้เป็นเชิงเส้น (เกือบ) ข้อบกพร่องของวิธีนี้คือใช้เวลานานในการคำนวณและมีค่าใช้จ่ายสูง

ด้านล่างนี้ คุณจะพบโค้ดที่สำคัญที่สุดในการฝึกตัวแยกประเภทเคอร์เนล

ตั้งค่าฟังก์ชันเคอร์เนลมิติสูง

  • input_dim = 14
  • เอาท์พุท_สลัว= 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)

ที่คุณอาจชอบ: