Kernel Gaussian dalam Pembelajaran Mesin: Contoh Metode Kernel

Daftar Isi:

Anonim

Tujuan dari tutorial ini adalah membuat kumpulan data dapat dipisahkan secara linier. Tutorial ini dibagi menjadi dua bagian:

  1. Transformasi fitur
  2. Latih pengklasifikasi kernel dengan Tensorflow

Di bagian pertama, Anda akan memahami ide di balik metode Kernel dalam Machine Learning, sedangkan di bagian kedua, Anda akan melihat cara melatih pengklasifikasi kernel dengan Tensorflow. Anda akan menggunakan kumpulan data dewasa. Dataset ini bertujuan untuk mengklasifikasikan pendapatan di bawah dan di atas 50k, dengan mengetahui perilaku setiap rumah tangga.

Dalam tutorial ini Anda akan belajar-

  • Mengapa Anda membutuhkan Metode Kernel?
  • Apa itu Kernel dalam pembelajaran mesin?
  • Jenis Metode Kernel
  • Latih pengklasifikasi Kernel Gaussian dengan TensorFlow

Mengapa Anda membutuhkan Metode Kernel?

Tujuan dari setiap pengklasifikasi adalah untuk memprediksi kelas dengan benar. Untuk itu sebaiknya dataset tersebut dapat dipisahkan. Lihat plot di bawah ini; cukup sederhana untuk melihat bahwa semua titik di atas garis hitam adalah milik kelas satu dan titik lainnya milik kelas dua. Namun, sangat jarang memiliki kumpulan data yang sesederhana itu. Dalam banyak kasus, data tidak dapat dipisahkan. Metode kernel dalam Pembelajaran Mesin menyulitkan pengklasifikasi yang naif seperti regresi logistik.

import numpy as npimport matplotlib.pyplot as pltfrom mpl_toolkits.mplot3d import Axes3D 
x_lin = np.array([1,2,3,4,5,6,7,8,9,10])y_lin = np.array([2,2,3,2,2,9,6,8,8,9])label_lin = np.array([0,0,0,0,0,1,1,1,1,1])fig = plt.figure()ax=fig.add_subplot(111)plt.scatter(x_lin, y_lin, c=label_lin, s=60)plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2)ax.set_xlim([-5,15])ax.set_ylim([-5,15])plt.show()

Pada gambar di bawah ini, kami memplot kumpulan data yang tidak dapat dipisahkan secara linier. Jika kita menggambar garis lurus, sebagian besar poin tidak akan diklasifikasikan dalam kelas yang benar.

Salah satu cara untuk mengatasi masalah ini adalah dengan mengambil dataset dan mentransformasikan data ke peta fitur lain. Artinya, Anda akan menggunakan fungsi untuk mengubah data di rencana lain, yang harus dapat linier.

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 adalah dalam rencana Kernel Gaussian 2D yang tidak dapat dipisahkan. Anda dapat mencoba mengubah data tersebut menjadi tiga dimensi, artinya Anda membuat gambar dengan 3 sumbu.

Dalam contoh Kernel Gaussian kami, kami akan menerapkan pemetaan polinomial untuk membawa data kami ke dimensi 3D. Rumus untuk mengubah data adalah sebagai berikut.

Anda mendefinisikan sebuah fungsi di Gaussian Kernel Python untuk membuat peta fitur baru

Anda dapat menggunakan numpy untuk mengkodekan rumus di atas:

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

Pemetaan baru harus dengan 3 dimensi dengan 16 titik

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

Mari buat plot baru masing-masing dengan 3 sumbu, x, y dan z.

# plotfig = plt.figure()ax = fig.add_subplot(111, projection='3d')ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)ax.view_init(30, 185)ax.set_xlabel('X Label')ax.set_ylabel('Y Label')ax.set_zlabel('Z Label')plt.show()

Kami melihat peningkatan tetapi jika kami mengubah orientasi plot, jelas bahwa dataset sekarang dapat dipisahkan

# plotfig = plt.figure()ax = fig.add_subplot(111, projection='3d')ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60)ax.view_init(0, -180)ax.set_ylim([150,-50])ax.set_zlim([-10000,10000])ax.set_xlabel('X Label')ax.set_ylabel('Y Label')ax.set_zlabel('Z Label')plt.show()

Untuk memanipulasi kumpulan data besar dan Anda mungkin harus membuat lebih dari 2 dimensi, Anda akan menghadapi masalah besar menggunakan metode di atas. Faktanya, Anda perlu mengubah semua poin 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 kernel .

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 dimensi yang 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 banyak 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 tersirat oleh komputasi berdimensi tinggi. Hasil dari kernel adalah skalar, atau dengan kata lain kita kembali ke ruang satu dimensi

Setelah Anda menemukan fungsi ini, Anda dapat menyambungkannya 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 produk titik dari peta fitur baru. Dari cara di atas, Anda perlu:

  1. Ubah x1 dan x2 menjadi dimensi baru
  2. Hitung produk titik: umum untuk semua kernel
  3. Ubah x1 dan x2 menjadi dimensi baru

Anda dapat menggunakan fungsi yang dibuat di atas untuk menghitung dimensi yang lebih tinggi.

## Kernelx1 = 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 titik

Anda dapat menggunakan titik objek 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

Keluarannya adalah 8100. Anda lihat masalahnya, Anda perlu menyimpan dalam memori peta fitur baru untuk menghitung perkalian titik. Jika Anda memiliki kumpulan data dengan jutaan catatan, itu secara komputasi tidak efektif.

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 menjadi dimensi yang lebih tinggi. Dengan kata lain, fungsi kernel menghitung hasil perkalian titik dari ruang fitur lain.

Anda dapat menulis fungsi kernel polinomial dengan Python sebagai berikut.

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

Ini adalah pangkat dari perkalian titik dari 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 bekerja cukup baik untuk klasifikasi teks. Kernel lainnya adalah:

  • Kernel polinomial
  • Kernel Gaussian

Dalam contoh dengan TensorFlow, kita akan menggunakan Random Fourier. TensorFlow memiliki penaksir bawaan untuk menghitung ruang fitur baru. Fungsi filter Gaussian adalah perkiraan dari 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 pendapatan rumah tangga lebih atau kurang dari 50k.

Anda akan mengevaluasi Pembelajaran Mesin Regresi Kernel logistik untuk memiliki model benchmark. 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.dll
  • pendidikan
  • education_num
  • pernikahan
  • pendudukan
  • hubungan
  • ras
  • seks
  • keuntungan dalam bentuk uang
  • capital_loss
  • hours_week
  • negara Asal
  • label

Anda akan melanjutkan sebagai berikut sebelum melatih dan mengevaluasi model:

  • Langkah 1) Impor perpustakaan
  • Langkah 2) Impor data
  • Langkah 3) Siapkan data
  • Langkah 4) Buat input_fn
  • Langkah 5) Buat model logistik: Model dasar
  • Langkah 6) Evaluasi model
  • Langkah 7) Buatlah pengklasifikasi Kernel
  • Langkah 8) Evaluasi pengklasifikasi Kernel

Langkah 1) Impor perpustakaan

Untuk mengimpor dan melatih model Kernel dalam Artificial Intelligence, Anda perlu mengimpor tensorflow, pandas, dan numpy

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

Langkah 2) Impor data

Anda mengunduh data dari situs web berikut dan Anda mengimpornya sebagai bingkai data panda.

## Define path dataCOLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label']PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"PATH_test ="https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"## Importdf_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

Sekarang setelah rangkaian rangkaian latihan dan pengujian 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 data

Dataset berisi fitur kontinu dan kategorikal. Praktik yang baik adalah menstandarkan nilai variabel kontinu. Anda dapat menggunakan fungsi StandardScaler dari sci-kit learn. Anda juga membuat fungsi yang ditentukan pengguna untuk mempermudah konversi rangkaian rangkaian dan pengujian. Perhatikan bahwa, Anda menggabungkan variabel kontinu dan kategori ke kumpulan data umum dan array harus berjenis: float32

COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']from sklearn.preprocessing import StandardScalerfrom sklearn import preprocessingdef prep_data_str(df):scaler = StandardScaler()le = preprocessing.LabelEncoder()df_toscale = df[COLUMNS_INT]df_scaled = scaler.fit_transform(df_toscale.astype(np.float64))X_1 = df[CATE_FEATURES].apply(le.fit_transform)y = df['label'].astype(np.int32)X_conc = np.c_[df_scaled, X_1].astype(np.float32)return X_conc, y

Fungsi transformator sudah siap, Anda dapat mengubah dataset 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 selanjutnya, Anda akan melatih regresi logistik. Ini akan memberi Anda akurasi dasar. Tujuannya adalah untuk mengalahkan baseline dengan algoritma yang berbeda yaitu Kernel classifier.

Langkah 4) Buat model logistik: Model dasar

Anda membangun 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 Estimator TensorFlow, Anda menginstruksikan kolom fitur dan tempat untuk 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': , '_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 logisitc menggunakan batch mini berukuran 200.

# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_train},y=y_train,batch_size=200,num_epochs=None,shuffle=True)

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 = 1INFO:tensorflow:global_step/sec: 324.16INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)INFO:tensorflow:global_step/sec: 267.092INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)INFO:tensorflow:global_step/sec: 292.679INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)INFO:tensorflow:global_step/sec: 225.582INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)INFO:tensorflow:global_step/sec: 209.975INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)INFO:tensorflow:global_step/sec: 241.648INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)INFO:tensorflow:global_step/sec: 305.193INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)INFO:tensorflow:global_step/sec: 396.295INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)INFO:tensorflow:global_step/sec: 359.857INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec)INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt.INFO:tensorflow:Loss for final step: 67.79706.

Langkah 6) Evaluasi model

Anda menentukan penaksir numpy untuk mengevaluasi model. Anda menggunakan seluruh set data untuk evaluasi

# Evaluationtest_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_test},y=y_test,batch_size=16281,num_epochs=1,shuffle=False)estimator.evaluate(input_fn=test_input_fn, steps=1)
INFO:tensorflow:Calling model_fn.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [1/1]INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663,'accuracy_baseline': 0.76377374,'auc': 0.84898686,'auc_precision_recall': 0.67214864,'average_loss': 0.3877216,'global_step': 1000,'label/mean': 0.23622628,'loss': 6312.495,'precision': 0.7362797,'prediction/mean': 0.21208474,'recall': 0.39417577}

Anda memiliki akurasi 82 ​​persen. Di bagian selanjutnya, Anda akan mencoba mengalahkan pengklasifikasi logistik dengan pengklasifikasi Kernel

Langkah 7) Buat pengklasifikasi Kernel

Estimator kernel tidak begitu berbeda dari 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 dari fungsi Gaussian. Untungnya, Tensorflow memiliki fungsi di library-nya: RandomFourierFeatureMapper. Model dapat dilatih menggunakan estimator KernelLinearClassifier.

Untuk membangun model, Anda akan mengikuti langkah-langkah berikut:

  1. Atur fungsi Kernel berdimensi tinggi
  2. Setel hyperparameter L2
  3. Bangun modelnya
  4. Latih modelnya
  5. Evaluasi modelnya

Langkah A) Atur fungsi Kernel berdimensi 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 perhatikan 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:

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

Anda perlu membuat mapper kernel dengan menggunakan kolom fitur yang dibuat sebelumnya: feat_column

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

Langkah B) Setel hyperparameter L2

Untuk mencegah overfitting, Anda menghukum fungsi kerugian dengan pengatur L2. Anda menyetel hyperparameter L2 ke 0,1 dan kecepatan pemelajaran 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 penaksir bawaan KernelLinearClassifier. Perhatikan bahwa Anda menambahkan mapper kernel yang ditentukan sebelumnya dan mengubah direktori model.

### Prep estimatorestimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train")
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.Instructions for updating:Please switch to tf.contrib.estimator.*_head.WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.Instructions for updating:Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.Instructions for updating:When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': , '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options {per_process_gpu_memory_fraction: 1.0}, '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}

Langkah D) Latih modelnya

Sekarang setelah pengklasifikasi kernel dibuat, Anda siap untuk melatihnya. Anda memilih untuk mengulang model 2000 kali

### estimateestimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.Instructions for updating:When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into kernel_train/model.ckpt.INFO:tensorflow:loss = 0.6931474, step = 1INFO:tensorflow:global_step/sec: 86.6365INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)INFO:tensorflow:global_step/sec: 80.1986INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)INFO:tensorflow:global_step/sec: 79.6376INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)INFO:tensorflow:global_step/sec: 95.8442INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)INFO:tensorflow:global_step/sec: 93.7799INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)INFO:tensorflow:global_step/sec: 94.7071INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)INFO:tensorflow:global_step/sec: 90.7402INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)INFO:tensorflow:global_step/sec: 94.4924INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)INFO:tensorflow:global_step/sec: 95.3472INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)INFO:tensorflow:global_step/sec: 97.2928INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)INFO:tensorflow:global_step/sec: 85.6761INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)INFO:tensorflow:global_step/sec: 91.4194INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)INFO:tensorflow:global_step/sec: 82.5954INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)INFO:tensorflow:global_step/sec: 89.8748INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)INFO:tensorflow:global_step/sec: 76.9761INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)INFO:tensorflow:global_step/sec: 73.7192INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)INFO:tensorflow:global_step/sec: 83.0573INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)INFO:tensorflow:global_step/sec: 71.7029INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)INFO:tensorflow:global_step/sec: 73.2663INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec)INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt.INFO:tensorflow:Loss for final step: 0.37795097.KernelLinearClassifier(params={'head': , 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': , 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): []}})

Langkah E) Evaluasi model

Terakhir, Anda mengevaluasi kinerja model Anda. Anda harus bisa mengalahkan regresi logistik.

# Evaluate and report metrics.eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:50INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [1/1]INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004

Akurasi akhir adalah 84%, ini merupakan peningkatan 2% dibandingkan dengan regresi logistik. Ada tradeoff antara peningkatan akurasi dan biaya komputasi. Anda perlu memikirkan apakah peningkatan 2% sepadan dengan waktu yang dihabiskan oleh pengklasifikasi yang berbeda dan jika itu memiliki dampak yang menarik pada bisnis Anda.

Ringkasan

Kernel adalah alat yang hebat untuk mengubah data non-linier menjadi (hampir) linier. Kekurangan dari metode ini adalah komputasi yang memakan waktu dan biaya yang mahal.

Di bawah ini, Anda dapat menemukan kode paling penting untuk melatih pengklasifikasi kernel

Atur fungsi Kernel berdimensi tinggi

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

Setel hyperparameter L2

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

Bangun modelnya

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)