Kernel Gaussian dalam Pembelajaran Mesin: Python Metode Kernel
Evelyn Clarke
Tujuan dari tutorial ini adalah untuk membuat dataset dapat dipisahkan secara linier. Tutorialnya dibagi menjadi dua bagian:
- Transformasi fitur
- Latih pengklasifikasi Kernel dengan Tensorflow
Pada bagian pertama, Anda akan memahami ide di balik metode Kernel dalam Machine Learning, sedangkan pada bagian kedua, Anda akan melihat cara melatih pengklasifikasi kernel dengan Tensorflow. Anda akan menggunakan dataset dewasa. Tujuan dari dataset ini adalah untuk mengklasifikasikan pendapatan di bawah dan di atas 50k, dengan mengetahui perilaku setiap rumah tangga.
Mengapa Anda memerlukan Metode Kernel?
Tujuan dari setiap pengklasifikasi adalah untuk memprediksi kelas dengan benar. Untuk itu, dataset harus dapat dipisahkan. Lihatlah alur cerita di bawah ini; cukup mudah untuk melihat bahwa semua titik di atas garis hitam adalah milik kelas pertama dan titik lainnya milik kelas kedua. Namun, sangat jarang ada kumpulan data sesederhana itu. Dalam kebanyakan kasus, data tidak dapat dipisahkan. Metode kernel dalam Pembelajaran Mesin menyulitkan pengklasifikasi naif seperti regresi logistik.
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()
Pada gambar di bawah, kami memplot kumpulan data yang tidak dapat dipisahkan secara linier. Jika kita menggambar garis lurus, sebagian besar titik tidak akan diklasifikasikan dalam kelas yang benar.
Salah satu cara untuk mengatasi masalah ini adalah dengan mengambil kumpulan data dan mengubah data di peta fitur lain. Artinya, Anda akan menggunakan suatu fungsi untuk mengubah data dalam paket lain, yang harus dapat dilinearkan.
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()
Data dari gambar di atas berada dalam rencana Kernel Gaussian 2D yang tidak dapat dipisahkan. Anda bisa mencoba mengubah data tersebut menjadi tiga dimensi, artinya Anda membuat gambar dengan 3 sumbu.
Dalam contoh Kernel Gaussian, kita akan menerapkan pemetaan polinomial untuk membawa data kita ke dimensi 3D. Rumus untuk mengubah data adalah sebagai berikut.
Anda mendefinisikan suatu fungsi di Kernel Gaussian Python untuk membuat peta fitur baru
Anda dapat menggunakan mati rasa untuk mengkodekan rumus di atas:
| Rumus | Kode Numpy yang Setara |
|---|---|
| x | x[:,0]** |
| y | x[:,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
Pemetaan baru harusnya 3 dimensi dengan 16 titik
x_1 = mapping(x, y) x_1.shape
(3, 16)
Mari kita buat plot baru dengan 3 sumbu, x, y dan z masing-masing.
# 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()
Kami melihat adanya peningkatan, namun jika kami mengubah orientasi plot, jelas bahwa kumpulan data kini dapat dipisahkan
# 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()
Untuk memanipulasi dataset yang besar dan Anda mungkin harus membuat lebih dari 2 dimensi, Anda akan menghadapi masalah besar dengan menggunakan cara di atas. Faktanya, Anda perlu mengubah semua titik data, yang jelas tidak berkelanjutan. Ini akan memakan waktu lama, dan komputer Anda mungkin kehabisan memori.
Cara paling umum untuk mengatasi masalah ini adalah dengan menggunakan a inti.
Apa itu Kernel dalam pembelajaran mesin?
Idenya adalah menggunakan ruang fitur berdimensi lebih tinggi untuk membuat data hampir dapat dipisahkan secara linier seperti yang ditunjukkan pada gambar di atas.
Ada banyak ruang berdimensi lebih tinggi untuk membuat titik data dapat dipisahkan. Misalnya, kami telah menunjukkan bahwa pemetaan polinomial adalah awal yang baik.
Kami juga telah menunjukkan bahwa dengan banyaknya data, transformasi ini tidak efisien. Sebagai gantinya, Anda dapat menggunakan fungsi Kernel di Machine Learning untuk mengubah data tanpa mengubah ke paket fitur baru.
Keajaiban kernel adalah menemukan fungsi yang menghindari semua masalah yang ditimbulkan oleh komputasi dimensi tinggi. Hasil dari kernel adalah skalar, atau dengan kata lain kita kembali ke ruang satu dimensi
Setelah Anda menemukan fungsi ini, Anda dapat menghubungkannya ke pengklasifikasi linier standar.
Mari kita lihat contoh untuk memahami konsep Kernel Machine Learning. Anda memiliki dua vektor, x1 dan x2. Tujuannya adalah untuk menciptakan dimensi yang lebih tinggi dengan menggunakan pemetaan polinomial. Outputnya sama dengan perkalian titik dari peta fitur baru. Dari cara di atas, Anda perlu:
- Ubah x1 dan x2 menjadi dimensi baru
- Hitung perkalian titik: umum untuk semua kernel
- Ubah x1 dan x2 menjadi dimensi baru
Anda dapat menggunakan fungsi yang dibuat di atas untuk menghitung dimensi yang lebih tinggi.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
Keluaran
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Hitung produk titiknya
Anda dapat menggunakan objek titik dari numpy untuk menghitung perkalian titik antara vektor pertama dan kedua yang disimpan di x_1.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
Outputnya adalah 8100. Anda melihat masalahnya, Anda perlu menyimpan peta fitur baru di memori untuk menghitung perkalian titik. Jika Anda memiliki kumpulan data dengan jutaan catatan, hal itu tidak efektif secara komputasi.
Sebagai gantinya, Anda dapat menggunakan kernel polinomial untuk menghitung perkalian titik tanpa mengubah vektor. Fungsi ini menghitung perkalian titik dari x1 dan x2 seolah-olah kedua vektor ini telah diubah ke dimensi yang lebih tinggi. Dengan kata lain, fungsi kernel menghitung hasil perkalian titik dari ruang fitur lain.
Anda dapat menulis fungsi kernel polinomial Python sebagai berikut.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Ini adalah pangkat perkalian titik dua vektor. Di bawah ini, Anda mengembalikan tingkat kedua dari kernel polinomial. Outputnya sama dengan metode lainnya. Inilah keajaiban kernel.
polynomial_kernel(x1, x2, p=2) 8100
Jenis Metode Kernel
Ada banyak teknik Kernel berbeda yang tersedia. Yang paling sederhana adalah kernel linier. Fungsi ini berfungsi cukup baik untuk klasifikasi teks. Kernel lainnya adalah:
- Kernel polinomial
- Kernel Gaussian
Dalam contoh dengan TensorFlow, kita akan menggunakan Random Fourier. TensorFlow memiliki estimator bawaan untuk menghitung ruang fitur baru. Fungsi filter Gaussian merupakan perkiraan fungsi kernel Gaussian.
Fungsi pemfilteran Gaussian menghitung kesamaan antara titik data dalam ruang dimensi yang jauh lebih tinggi.
Latih pengklasifikasi Kernel Gaussian dengan TensorFlow
Tujuan dari algoritma ini adalah untuk mengklasifikasikan rumah tangga yang berpenghasilan lebih atau kurang dari 50k.
Anda akan mengevaluasi Pembelajaran Mesin Regresi Kernel logistik untuk memiliki model tolok ukur. Setelah itu, Anda akan melatih pengklasifikasi Kernel untuk melihat apakah Anda bisa mendapatkan hasil yang lebih baik.
Anda menggunakan variabel berikut dari kumpulan data dewasa:
- usia
- kelas kerja
- fnlwgt
- pendidikan
- pendidikan_num
- perkawinan
- pekerjaan
- hubungan
- ras
- seks
- keuntungan dalam bentuk uang
- modal_rugi
- jam_minggu
- negara Asal
- label
Anda akan melanjutkan sebagai berikut sebelum melatih dan mengevaluasi model:
- Langkah 1) Impor perpustakaan
- Langkah 2) Impor data
- Langkah 3) Siapkan datanya
- Langkah 4) Buat input_fn
- Langkah 5) Bangun model logistik: Model dasar
- Langkah 6) Evaluasi modelnya
- Langkah 7) Buat pengklasifikasi Kernel
- Langkah 8) Evaluasi pengklasifikasi Kernel
Langkah 1) Impor perpustakaan
Untuk mengimpor dan melatih model Kernel Kecerdasan Buatan, Anda perlu mengimpor tensorflow, panda dan 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
Langkah 2) Impor data
Anda mengunduh data dari berikut ini situs web dan Anda mengimpornya sebagai kerangka data panda.
## 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)
Sekarang set pelatihan dan pengujian telah ditentukan, Anda dapat mengubah label kolom dari string menjadi integer. tensorflow tidak menerima nilai string untuk label.
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)
Langkah 3) Siapkan datanya
Kumpulan data berisi fitur berkelanjutan dan kategoris. Praktik yang baik adalah dengan membakukan nilai variabel kontinu. Anda dapat menggunakan fungsi StandardScaler dari sci-kit learn. Anda juga membuat fungsi yang ditentukan pengguna untuk mempermudah konversi rangkaian kereta dan pengujian. Perhatikan bahwa, Anda menggabungkan variabel kontinu dan kategorikal ke kumpulan data umum dan arraynya harus bertipe: 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
Fungsi transformator sudah siap, Anda dapat mengonversi kumpulan data dan membuat fungsi 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)
Pada langkah berikutnya, Anda akan melatih regresi logistik. Ini akan memberi Anda akurasi dasar. Tujuannya adalah untuk mengalahkan baseline dengan algoritma yang berbeda, yaitu pengklasifikasi Kernel.
Langkah 4) Bangun model logistik: Model dasar
Anda membuat kolom fitur dengan objek real_valued_column. Ini akan memastikan semua variabel adalah data numerik yang padat.
feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)
Estimator ditentukan menggunakan TensorFlow Estimator, Anda menginstruksikan kolom fitur dan tempat menyimpan grafik.
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}
Anda akan melatih regresi logistik menggunakan mini-batch berukuran 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)
Anda dapat melatih model dengan 1.000 iterasi
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>
Langkah 6) Evaluasi modelnya
Anda menentukan penduga numpy untuk mengevaluasi model. Anda menggunakan seluruh kumpulan data untuk evaluasi
# 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}
Anda memiliki akurasi 82 persen. Di bagian selanjutnya, Anda akan mencoba mengalahkan pengklasifikasi logistik dengan pengklasifikasi Kernel
Langkah 7) Bangun pengklasifikasi Kernel
Estimator kernel tidak jauh berbeda dengan pengklasifikasi linier tradisional, setidaknya dalam hal konstruksi. Ide di baliknya adalah menggunakan kekuatan kernel eksplisit dengan pengklasifikasi linier.
Anda memerlukan dua estimator yang telah ditentukan sebelumnya yang tersedia di TensorFlow untuk melatih Kernel Classifier:
- RandomFourierFeatureMapper
- KernelLinearClassifier
Anda telah mempelajari di bagian pertama bahwa Anda perlu mengubah dimensi rendah menjadi dimensi tinggi menggunakan fungsi kernel. Lebih tepatnya, Anda akan menggunakan Random Fourier, yang merupakan perkiraan fungsi Gaussian. Untungnya, Tensorflow memiliki fungsi di perpustakaannya: RandomFourierFeatureMapper. Model dapat dilatih menggunakan estimator KernelLinearClassifier.
Untuk membangun model, Anda akan mengikuti langkah-langkah berikut:
- Atur fungsi Kernel dimensi tinggi
- Atur hiperparameter L2
- Bangun model
- Latih modelnya
- Evaluasi modelnya
Langkah A) Atur fungsi Kernel dimensi tinggi
Dataset saat ini berisi 14 fitur yang akan Anda ubah ke dimensi tinggi baru dari vektor 5.000 dimensi. Anda menggunakan fitur Fourier acak untuk mencapai transformasi. Jika Anda mengingat rumus Kernel Gaussian, Anda melihat bahwa ada parameter deviasi standar yang harus ditentukan. Parameter ini mengontrol ukuran kesamaan yang digunakan selama klasifikasi.
Anda dapat menyetel semua parameter di RandomFourierFeatureMapper dengan:
- masukan_redup = 14
- keluaran_redup= 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Anda perlu membuat mapper kernel dengan menggunakan kolom fitur yang dibuat sebelumnya: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Langkah B) Atur hiperparameter L2
Untuk mencegah overfitting, Anda menghukum fungsi kerugian dengan pengatur L2. Anda mengatur hyperparameter L2 ke 0.1 dan kecepatan pembelajaran ke 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Langkah C) Bangun model
Langkah selanjutnya mirip dengan klasifikasi linier. Anda menggunakan estimator bawaan KernelLinearClassifier. Perhatikan bahwa Anda menambahkan pemetaan kernel yang ditentukan sebelumnya dan mengubah direktori model.
### 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'}
Langkah D) Latih modelnya
Sekarang setelah pengklasifikasi Kernel dibuat, Anda siap untuk melatihnya. Anda memilih untuk mengulangi model sebanyak 2000 kali
### 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>]}})
Langkah E) Evaluasi modelnya
Terakhir, Anda mengevaluasi performa model Anda. Anda harus mampu mengalahkan regresi logistik.
# 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
Akurasi akhir adalah 84%, peningkatan 2% dibandingkan dengan regresi logistik. Ada trade-off antara peningkatan akurasi dan biaya komputasi. Anda perlu memikirkan apakah peningkatan 2% sepadan dengan waktu yang dihabiskan oleh pengklasifikasi yang berbeda dan apakah hal tersebut memiliki dampak yang menarik pada bisnis Anda.
Kesimpulan
Kernel adalah alat yang hebat untuk mengubah data non-linier menjadi (hampir) linier. Kelemahan dari metode ini adalah memakan waktu dan biaya komputasi yang besar.
Di bawah ini, Anda dapat menemukan kode terpenting untuk melatih pengklasifikasi kernel
Atur fungsi Kernel dimensi tinggi
- masukan_redup = 14
- keluaran_redup= 5000
- stddev=4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Atur hiperparameter L2
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Bangun model
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
Latih modelnya
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
Evaluasi modelnya
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
