Gaussian Kernel ในการเรียนรู้ของเครื่อง: Python วิธีการเคอร์เนล
เอเวลิน คลาร์ก
⚡ สรุปอย่างชาญฉลาด
วิธีการใช้เคอร์เนลแบบเกาส์เซียนทำให้ข้อมูลที่ไม่สามารถแยกได้ด้วยเส้นตรงสามารถแยกได้โดยไม่ต้องสร้างแผนที่ฟีเจอร์ที่มีมิติสูง บทความนี้จะแสดงแผนที่พหุนามping ด้วยมือ จากนั้นจึงฝึกตัวจำแนกเคอร์เนลฟูริเยร์แบบสุ่มใน TensorFlow
จุดประสงค์ของบทช่วยสอนนี้คือการทำให้ชุดข้อมูลแยกกันเชิงเส้นได้ บทช่วยสอนแบ่งออกเป็นสองส่วน:
- การเปลี่ยนแปลงคุณสมบัติ
- ฝึกฝนตัวจำแนกประเภท Kernel ด้วย 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()
ข้อมูลจากรูปด้านบนอยู่ในระนาบ 2 มิติและไม่สามารถแยกออกจากกันได้ คุณสามารถลองแปลงข้อมูลนี้ให้เป็นสามมิติ ซึ่งหมายความว่าคุณสร้างรูปที่มี 3 แกน
ในตัวอย่าง Gaussian Kernel ของเรา เราจะใช้การแมปพหุนามping เพื่อนำข้อมูลของเราไปสู่มิติที่สาม สูตรในการแปลงข้อมูลมีดังนี้
คุณกำหนดฟังก์ชันใน Gaussian Kernel Python เพื่อสร้างแผนที่ลักษณะใหม่
คุณสามารถใช้ได้ นำพาย เพื่อเขียนโค้ดสูตรข้างต้น แต่ละแถวด้านล่างจะจับคู่คำศัพท์หนึ่งคำจากแผนที่ping โดยใช้สูตรอาร์เรย์ที่สร้างผลลัพธ์นั้น และรูปภาพขนาดเล็กแสดงถึงรากที่สองของตัวประกอบสอง
| สูตร | โค้ด NumPy ที่เทียบเท่า |
|---|---|
| x | เอ็กซ์[:,0] |
| y | เอ็กซ์[:,1] |
| x² | x[:,0]**2 |
 |
np.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)
ทีนี้ลองสร้างกราฟใหม่ที่มี 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 ในการเรียนรู้ของเครื่องคืออะไร?
แนวคิดคือการใช้พื้นที่คุณลักษณะที่มีมิติสูงกว่าเพื่อทำให้ข้อมูลสามารถแยกออกจากกันได้เกือบจะเป็นเส้นตรง ดังแสดงในรูปด้านบน
มีพื้นที่มิติสูงมากมายที่ทำให้จุดข้อมูลแยกออกจากกันได้ ตัวอย่างเช่น เราได้แสดงให้เห็นแล้วว่าแผนที่พหุนามping เป็นการเริ่มต้นที่ดี
เราได้แสดงให้เห็นแล้วว่า การแปลงข้อมูลเหล่านี้ไม่มีประสิทธิภาพเมื่อมีข้อมูลจำนวนมาก แทนที่จะใช้วิธีการแปลงข้อมูลโดยตรง คุณสามารถใช้ฟังก์ชัน Kernel ใน Machine Learning เพื่อปรับเปลี่ยนข้อมูลโดยไม่ต้องย้ายไปยังระนาบคุณลักษณะใหม่
หัวใจสำคัญของเคอร์เนลคือการค้นหาฟังก์ชันที่หลีกเลี่ยงปัญหาทั้งหมดที่เกิดจากการคำนวณในมิติสูง ผลลัพธ์ของเคอร์เนลเป็นค่าสเกลาร์ หรือกล่าวอีกอย่างคือ เรากลับไปสู่พื้นที่หนึ่งมิติอีกครั้ง
หลังจากที่คุณค้นพบฟังก์ชันนี้แล้ว คุณสามารถนำไปใช้ร่วมกับตัวจำแนกเชิงเส้นมาตรฐานได้
นี่คือตัวอย่างที่ทำให้เข้าใจแนวคิดของ Kernel Machine Learning ได้อย่างชัดเจน คุณมีเวกเตอร์สองตัว คือ 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. ]]
คำนวณผลคูณดอท
คุณสามารถใช้จุดวัตถุจาก นำพาย เพื่อคำนวณผลคูณดอทระหว่างเวกเตอร์แรกและเวกเตอร์ที่สองที่เก็บไว้ใน 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 ซึ่งแสดงถึงปฏิสัมพันธ์ของคุณลักษณะต่างๆ | ขอบเขตโค้งเมื่อทราบว่าปฏิสัมพันธ์มีความสำคัญ |
| เกาส์เซียน (RBF) | ความคล้ายคลึงที่วัดจากระยะทาง ซึ่งจะลดลงเข้าใกล้ศูนย์เมื่อจุดต่างๆ อยู่ห่างกันมากขึ้น | โดยทั่วไปแล้ว วิธีนี้จะเป็นตัวเลือกแรกเมื่อไม่ทราบรูปทรงของขอบเขต |
ในตัวอย่างที่ใช้ TensorFlow เราจะใช้ฟีเจอร์ฟูริเยร์แบบสุ่ม TensorFlow มีตัวประมาณค่าในตัวเพื่อคำนวณพื้นที่ฟีเจอร์ใหม่ ตัวแมปเปอร์ฟีเจอร์ฟูริเยร์แบบสุ่มเป็นการประมาณค่าฟังก์ชันเคอร์เนลแบบเกาส์เซียนดังแสดงด้านล่าง
ฟังก์ชันการกรองแบบเกาส์เซียนจะคำนวณความคล้ายคลึงกันระหว่างจุดข้อมูลในพื้นที่มิติที่สูงกว่ามาก
เมื่อเข้าใจทฤษฎีอย่างถ่องแท้แล้ว ส่วนที่เหลือของบทแนะนำนี้จะนำเคอร์เนลแบบเกาส์เซียนไปใช้กับชุดข้อมูลจริง
ฝึกตัวแยกประเภทเคอร์เนล Gaussian ด้วย TensorFlow
วัตถุประสงค์ของอัลกอริทึมคือการจำแนกครัวเรือนที่มีรายได้มากกว่าหรือน้อยกว่า 50 ราย
ขั้นแรก คุณจะประเมินการถดถอยโลจิสติกส์เพื่อใช้เป็นแบบจำลองมาตรฐาน หลังจากนั้น คุณจะฝึกตัวจำแนกประเภทแบบเคอร์เนลเพื่อดูว่าคุณจะได้ผลลัพธ์ที่ดีขึ้นหรือไม่
คุณใช้ตัวแปรต่อไปนี้จากชุดข้อมูลผู้ใหญ่:
- อายุ
- ชั้นเรียน
- Fnlwgt
- การศึกษา
- การศึกษา_num
- สมรส
- อาชีพ
- ความสัมพันธ์
- แข่ง
- เพศ
- ทุน_กำไร
- เงินทุน_ขาดทุน
- ชั่วโมง_สัปดาห์
- พื้นเมือง_ประเทศ
- ฉลาก
ก่อนที่จะฝึกฝนและประเมินโมเดล คุณจะต้องดำเนินการดังต่อไปนี้:
- นำเข้าห้องสมุด
- นำเข้าข้อมูล
- เตรียมข้อมูล
- สร้างแบบจำลองโลจิสติกส์: แบบจำลองพื้นฐาน
- ประเมินแบบจำลอง
- สร้างและประเมินตัวจำแนกประเภทเคอร์เนล
หมายเหตุเกี่ยวกับเวอร์ชัน: โค้ดส่วนย่อยด้านล่างนี้ทั้งหมดกำหนดเป้าหมายไปที่ TensorFlow 1.x เนมสเปซ tf.contrib ซึ่งเป็นแหล่งที่มาของ real_valued_column, RandomFourierFeatureMapper และ KernelLinearClassifier ถูกลบออกไปใน TensorFlow 2.0 และ tf.estimator เองก็ถูกลบออกไปใน TensorFlow 2.16 ในเวอร์ชันปัจจุบัน ให้สร้างไปป์ไลน์เดียวกันโดยใช้เลเยอร์ tf.keras.layers.experimental.RandomFourierFeatures ตามด้วยเลเยอร์เอาต์พุต Dense หรือใช้คู่ RBFSampler และ SGDClassifier จาก scikit-learn
ขั้นตอนที่ 1) นำเข้าไลบรารี
เพื่อนำเข้าและฝึกอบรมโมเดลเคอร์เนล ปัญญาประดิษฐ์คุณต้องนำเข้า 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) นำเข้าข้อมูล
คุณดาวน์โหลดข้อมูลจาก หน้าชุดข้อมูลผู้ใหญ่ของ UCI และนำเข้าเป็น DataFrame ของ pandas
## 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
ฟังก์ชัน 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 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 เพื่อฝึก Kernel Classifier:
- RandomFourierFeatureMapper
- เคอร์เนลลิเนียร์ลักษณนาม
ในหัวข้อแรก คุณได้เรียนรู้แล้วว่าคุณจำเป็นต้องแปลงมิติที่ต่ำกว่าให้เป็นมิติที่สูงกว่าโดยใช้ฟังก์ชันเคอร์เนล โดยเฉพาะอย่างยิ่ง คุณจะใช้คุณลักษณะฟูริเยร์แบบสุ่ม ซึ่งเป็นการประมาณฟังก์ชันเกาส์เซียน TensorFlow 1.x มีฟังก์ชันดังกล่าวให้ใช้งานping โดยใช้ RandomFourierFeatureMapper เป็นตัวแปร และสามารถฝึกฝนโมเดลได้โดยใช้ตัวประมาณค่า KernelLinearClassifier
หากต้องการสร้างแบบจำลอง คุณจะต้องทำตามขั้นตอนเหล่านี้:
- ตั้งค่าฟังก์ชันเคอร์เนลมิติสูง
- ตั้งค่าไฮเปอร์พารามิเตอร์ L2
- สร้างโมเดล
- ฝึกโมเดล
- ประเมินแบบจำลอง
ขั้นตอน ก) ตั้งค่าฟังก์ชันเคอร์เนลที่มีมิติสูง
ชุดข้อมูลปัจจุบันประกอบด้วยคุณลักษณะ 14 ประการที่คุณจะแปลงเป็นเวกเตอร์ใหม่ที่มีมิติ 5,000 มิติ คุณใช้คุณลักษณะฟูริเยร์แบบสุ่มเพื่อให้ได้การแปลง หากคุณจำสูตรเคอร์เนลแบบเกาส์เซียนได้ คุณจะสังเกตเห็นว่ามีพารามิเตอร์ค่าเบี่ยงเบนมาตรฐานที่ต้องกำหนด พารามิเตอร์นี้ควบคุมการวัดความคล้ายคลึงที่ใช้ระหว่างการจำแนกประเภท: ค่าเบี่ยงเบนมาตรฐานน้อยจะทำให้เคอร์เนลพิจารณาเฉพาะจุดที่อยู่ใกล้กันมากว่าคล้ายกัน ในขณะที่ค่าเบี่ยงเบนมาตรฐานมากจะทำให้ขอบเขตการตัดสินใจเรียบขึ้น
คุณสามารถปรับแต่งพารามิเตอร์ทั้งหมดใน RandomFourierFeatureMapper ด้วย:
- input_dim = 14
- output_dim = 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)
ขั้นตอน ค) สร้างแบบจำลอง
ขั้นตอนต่อไปจะคล้ายกับการจำแนกประเภทเชิงเส้น คุณใช้ตัวประมาณค่าในตัว 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) ฝึกฝนโมเดล
เมื่อสร้างตัวจำแนกประเภท Kernel เสร็จแล้ว คุณก็พร้อมที่จะฝึกฝนโมเดล คุณเลือกที่จะฝึกฝนโมเดล 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) มีความสมดุลระหว่างการปรับปรุงความแม่นยำและต้นทุนการคำนวณ คุณต้องพิจารณาว่าการปรับปรุงนั้นคุ้มค่ากับเวลาที่ใช้ไปกับตัวจำแนกที่ซับซ้อนกว่าหรือไม่ และมีผลกระทบที่สำคัญต่อธุรกิจของคุณหรือไม่
