Gaussian Kernel dalam Pembelajaran Mesin: Kaedah Kaedah Kernel

Isi kandungan:

Anonim

Tujuan tutorial ini adalah untuk membuat set data yang dapat dipisahkan secara linear. Tutorial terbahagi kepada dua bahagian:

  1. Transformasi ciri
  2. Latih kelas Kernel dengan Tensorflow

Pada bahagian pertama, anda akan memahami idea di sebalik kaedah Kernel dalam Pembelajaran Mesin manakala di bahagian kedua, anda akan melihat bagaimana melatih pengelasan kernel dengan Tensorflow. Anda akan menggunakan set data dewasa. Objektif kumpulan data ini adalah untuk mengklasifikasikan pendapatan di bawah dan di atas 50k, mengetahui tingkah laku setiap isi rumah.

Dalam tutorial ini anda akan belajar-

  • Mengapa anda memerlukan Kaedah Kernel?
  • Apakah Kernel dalam pembelajaran mesin?
  • Jenis Kaedah Kernel
  • Latih pengeluar Kernel Gaussian dengan TensorFlow

Mengapa anda memerlukan Kaedah Kernel?

Tujuan setiap pengklasifikasi adalah untuk meramalkan kelas dengan betul. Untuk itu, set data harus dipisahkan. Lihat plot di bawah; agak mudah untuk melihat bahawa semua titik di atas garis hitam tergolong dalam kelas pertama dan titik lain ke kelas kedua. Walau bagaimanapun, sangat jarang mempunyai set data yang mudah. Dalam kebanyakan kes, data tidak dapat dipisahkan. Kaedah kernel dalam Pembelajaran Mesin memberikan pengkelasan naif seperti regresi logistik sukar.

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

Dalam rajah di bawah, kami memetakan dataset yang tidak dapat dipisahkan secara linear. Sekiranya kita melukis garis lurus, kebanyakan titik tidak akan dikelaskan dalam kelas yang betul.

Salah satu cara untuk mengatasi masalah ini adalah dengan mengambil set data dan mengubah data dalam peta ciri lain. Ini bermaksud, anda akan menggunakan fungsi untuk mengubah data dalam rancangan lain, yang seharusnya dapat diluruskan.

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 terdapat dalam rancangan Gaussian Kernel 2D yang tidak dapat dipisahkan. Anda boleh cuba mengubah data ini dalam tiga dimensi, ini bermaksud, anda membuat angka dengan 3 paksi.

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

Anda menentukan fungsi dalam Gaussian Kernel Python untuk membuat peta ciri baru

Anda boleh menggunakan numpy untuk membuat kod formula di atas:

Formula Kod Numpy 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 dengan masing-masing 3 paksi, 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 bahawa kumpulan data kini 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 set data yang besar dan anda mungkin perlu membuat lebih dari 2 dimensi, anda akan menghadapi masalah besar menggunakan kaedah di atas. Sebenarnya, anda perlu mengubah semua titik data, yang jelas tidak dapat dikekalkan. Ini akan memakan masa anda lama, dan komputer anda mungkin kehabisan memori.

Cara yang paling biasa untuk mengatasi masalah ini adalah dengan menggunakan kernel .

Apakah Kernel dalam pembelajaran mesin?

Ideanya adalah menggunakan ruang ciri dimensi yang lebih tinggi untuk menjadikan data hampir terpisah secara linear seperti yang ditunjukkan pada gambar di atas.

Terdapat banyak ruang dimensi yang lebih tinggi untuk menjadikan titik data dapat dipisahkan. Sebagai contoh, kami telah menunjukkan bahawa pemetaan polinomial adalah permulaan yang baik.

Kami juga telah menunjukkan bahawa dengan banyak data, transformasi ini tidak cekap. Sebagai gantinya, anda boleh menggunakan fungsi Kernel di Machine Learning untuk mengubah data tanpa menukar ke rancangan fitur baru.

Keajaiban kernel adalah mencari fungsi yang dapat mengelakkan semua masalah yang ditimbulkan oleh pengiraan dimensi tinggi. Hasil dari kernel adalah skalar, atau dikatakan berbeza kita kembali ke ruang satu dimensi

Selepas anda menemui fungsi ini, anda boleh memasangkannya ke pengkelasan linear standard.

Mari lihat contoh untuk memahami konsep Pembelajaran Mesin Kernel. Anda mempunyai dua vektor, x1 dan x2. Objektifnya adalah untuk mewujudkan dimensi yang lebih tinggi dengan menggunakan pemetaan polinomial. Keluarannya sama dengan produk titik peta ciri baru. Dari kaedah di atas, anda perlu:

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

Anda boleh 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)

Pengeluaran

[[ 9. 100. ][ 25.45584412 141.42135624][ 36. 100. ]]

Kira produk titik

Anda boleh menggunakan titik objek dari numpy untuk menghitung produk titik antara vektor pertama dan kedua yang disimpan dalam x_1.

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

Keluarannya 8100. Anda melihat masalahnya, anda perlu menyimpan dalam peta peta ciri baru untuk mengira produk titik. Sekiranya anda mempunyai set data dengan berjuta-juta rekod, maka pengiraannya tidak berkesan.

Sebagai gantinya, anda boleh menggunakan kernel polinomial untuk mengira produk titik tanpa mengubah vektor. Fungsi ini menghitung produk titik x1 dan x2 seolah-olah kedua-dua vektor ini telah diubah menjadi dimensi yang lebih tinggi. Dengan kata lain, fungsi kernel menghitung hasil produk titik dari ruang ciri lain.

Anda boleh menulis fungsi kernel polinomial di Python seperti berikut.

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

Ini adalah kekuatan produk titik dua vektor. Di bawah, anda mengembalikan tahap kedua kernel polinomial. Keluarannya sama dengan kaedah lain. Ini adalah keajaiban kernel.

polynomial_kernel(x1, x2, p=2)8100

Jenis Kaedah Kernel

Terdapat banyak teknik Kernel yang berbeza. Yang paling mudah ialah kernel linier. Fungsi ini berfungsi dengan baik untuk pengelasan teks. Kernel lain adalah:

  • Kernel polinomial
  • Kernel Gaussian

Dalam contoh dengan TensorFlow, kita akan menggunakan Random Fourier. TensorFlow mempunyai build in estimator untuk menghitung ruang ciri baru. Fungsi penapis Gaussian adalah penghampiran fungsi kernel Gaussian.

Fungsi penapisan Gaussian mengira persamaan antara titik data dalam ruang dimensi yang jauh lebih tinggi.

Latih pengeluar Kernel Gaussian dengan TensorFlow

Objektif algoritma adalah untuk mengklasifikasikan pendapatan isi rumah lebih atau kurang daripada 50k.

Anda akan menilai Pembelajaran Mesin Regresi Kernel logistik untuk mempunyai model penanda aras. Selepas itu, anda akan melatih pengkelasan Kernel untuk melihat apakah anda dapat memperoleh hasil yang lebih baik.

Anda menggunakan pemboleh ubah berikut dari kumpulan data dewasa:

  • umur
  • kelas kerja
  • fnlwgt
  • pendidikan
  • pendidikan_num
  • perkahwinan
  • pekerjaan
  • hubungan
  • perlumbaan
  • seks
  • modal_mendapat
  • kerugian_ modal
  • jam_ minggu
  • negara asal
  • label

Anda akan meneruskan seperti berikut sebelum melatih dan menilai model:

  • Langkah 1) Import perpustakaan
  • Langkah 2) Import data
  • Langkah 3) Sediakan data
  • Langkah 4) Bina input_fn
  • Langkah 5) Bina model logistik: Model asas
  • Langkah 6) Nilaikan model
  • Langkah 7) Bentukkan pengkelasan Kernel
  • Langkah 8) Nilaikan pengelasan Kernel

Langkah 1) Import perpustakaan

Untuk mengimport dan melatih model Kernel dalam Artificial Intelligence, anda perlu mengimport tensorflow, panda dan numpy

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

Langkah 2) Import data

Anda memuat turun data dari laman web berikut dan anda mengimportnya sebagai kerangka 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)

Setelah kereta api dan set ujian ditentukan, anda boleh menukar label lajur dari rentetan menjadi bilangan bulat. tensorflow tidak menerima nilai rentetan 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) Sediakan data

Set data mengandungi ciri berterusan dan kategoris. Amalan yang baik adalah menyeragamkan nilai pemboleh ubah berterusan. Anda boleh menggunakan fungsi StandardScaler dari sci-kit belajar. Anda membuat fungsi yang ditentukan pengguna juga untuk mempermudah menukar kereta api dan set ujian. Perhatikan bahawa, anda menggabungkan pemboleh ubah berterusan dan kategoris ke set data biasa dan susunannya mestilah jenis: 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 transformer sudah siap, anda boleh menukar set 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 seterusnya, anda akan melatih regresi logistik. Ini akan memberi anda ketepatan asas. Objektifnya adalah mengalahkan garis dasar dengan algoritma yang berbeza, iaitu pengkelasan Kernel.

Langkah 4) Bina model logistik: Model asas

Anda membina lajur ciri dengan kolom objek_berharga_data. Ini akan memastikan semua pemboleh ubah adalah data berangka padat.

feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)

Penganggar ditentukan menggunakan TensorFlow Estimator, anda mengarahkan lajur ciri dan tempat menyimpan graf.

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 logisitik menggunakan kumpulan kecil 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 boleh melatih model dengan 1.000 lelaran

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) Nilaikan model

Anda menentukan penganggar numpy untuk menilai model. Anda menggunakan keseluruhan set data untuk penilaian

# 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 mempunyai ketepatan 82 peratus. Pada bahagian seterusnya, anda akan cuba mengalahkan pengklasifikasi logistik dengan pengelasan Kernel

Langkah 7) Bentukkan pengkelasan Kernel

Penganggar kernel tidak begitu berbeza dengan pengkelasan linear tradisional, sekurang-kurangnya dari segi pembinaan. Idea di belakang adalah menggunakan kekuatan kernel eksplisit dengan pengkelasan linear.

Anda memerlukan dua penganggar yang telah ditentukan di TensorFlow untuk melatih Kernel Classifier:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Anda belajar di bahagian pertama bahawa anda perlu mengubah dimensi rendah menjadi dimensi tinggi menggunakan fungsi kernel. Lebih tepatnya, anda akan menggunakan Random Fourier, yang merupakan penghampiran fungsi Gaussian. Nasib baik, Tensorflow mempunyai fungsi di perpustakaannya: RandomFourierFeatureMapper. Model boleh dilatih menggunakan penganggar KernelLinearClassifier.

Untuk membina model, anda akan mengikuti langkah-langkah berikut:

  1. Tetapkan fungsi Kernel dimensi tinggi
  2. Tetapkan hiperparameter L2
  3. Bina model
  4. Latih model
  5. Nilaikan model

Langkah A) Tetapkan fungsi Kernel dimensi tinggi

Set data semasa mengandungi 14 ciri yang akan anda ubah menjadi dimensi tinggi vektor 5.000 dimensi baru. Anda menggunakan ciri Fourier rawak untuk mencapai transformasi. Sekiranya anda mengingat formula Gaussian Kernel, anda perhatikan bahawa terdapat parameter sisihan piawai untuk ditentukan. Parameter ini mengawal ukuran kesamaan yang digunakan semasa klasifikasi.

Anda boleh menyesuaikan 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 membina mapper kernel dengan menggunakan lajur ciri yang dibuat sebelumnya: feat_column

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

Langkah B) Tetapkan hyperparameter L2

Untuk mengelakkan overfitting, anda menghukum fungsi kerugian dengan pengatur L2. Anda menetapkan hiperparameter L2 ke 0.1 dan kadar pembelajaran menjadi 5

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

Langkah C) Bina model

Langkah seterusnya adalah serupa dengan klasifikasi linear. Anda menggunakan penganggar terbina dalam KernelLinearClassifier. Perhatikan bahawa anda menambahkan mapper kernel yang ditentukan sebelumnya dan menukar 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 model

Setelah pengelasan Kernel dibina, anda sudah bersedia untuk melatihnya. Anda memilih untuk mengulang 2000 kali model

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

Akhir sekali, anda menilai prestasi model anda. Anda harus dapat mengatasi 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

Ketepatan terakhir adalah 84%, ia adalah peningkatan 2% berbanding dengan regresi logistik. Terdapat pertukaran antara peningkatan ketepatan dan kos pengiraan. Anda perlu memikirkan apakah peningkatan sebanyak 2% bernilai masa yang digunakan oleh pengkelasan yang berbeza dan jika ia memberi kesan yang menarik pada perniagaan anda.

Ringkasan

Kernel adalah alat yang hebat untuk mengubah data bukan linear kepada (hampir) linear. Kekurangan kaedah ini adalah secara komputasi memakan masa dan mahal.

Di bawah, anda dapat mencari kod yang paling penting untuk melatih pengelasan kernel

Tetapkan fungsi Kernel dimensi 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')

Tetapkan hiperparameter L2

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

Bina model

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train")

Latih model

estimator_kernel.fit(input_fn=train_input_fn, steps=2000)

Nilaikan model

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)