Ядро Гаусса в машинному навчанні: приклади методів ядра

Мета цього підручника - зробити набір даних лінійно відокремлюваним. Підручник розділений на дві частини:

1. Трансформація функції
2. Навчіть класифікатор ядра за допомогою Tensorflow

У першій частині ви зрозумієте ідею методу ядра в машинному навчанні, тоді як у другій частині ви побачите, як навчити класифікатор ядра за допомогою Tensorflow. Ви будете використовувати набір даних для дорослих. Метою цього набору даних є класифікація доходу нижче і вище 50 тис., Знаючи поведінку кожного домогосподарства.

У цьому підручнику ви дізнаєтесь-

• Навіщо потрібні методи ядра?
• Що таке ядро ​​в машинному навчанні?
• Типи методів ядра
• Навчіть класифікатор ядра Гауса за допомогою TensorFlow

Навіщо потрібні методи ядра?

Мета кожного класифікатора - правильно передбачити класи. Для цього набір даних повинен бути відокремленим. Подивіться на сюжет нижче; досить просто побачити, що всі точки над чорною лінією належать до першого класу, а інші точки до другого класу. Однак надзвичайно рідко є такий простий набір даних. У більшості випадків дані не можна розділити. Методи ядра в машинному навчанні важко дають наївні класифікатори, як логістична регресія.

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

На малюнку нижче ми побудували набір даних, який не можна лінійно розділяти. Якщо ми проведемо пряму лінію, більшість очок не буде класифіковано у правильному класі.

Один із способів вирішити цю проблему - взяти набір даних і перетворити дані в іншу карту об’єктів. Це означає, що ви будете використовувати функцію для перетворення даних в інший план, який повинен бути лінійним.

x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18])y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1])label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1]) 

fig = plt.figure()plt.scatter(x, y, c=label, s=60)plt.show() 

Дані на малюнку вище містяться у 2D-плані ядра Гауса, який не можна розділити. Ви можете спробувати перетворити ці дані в тривимірну, це означає, що ви створюєте фігуру з 3 осями.

У нашому прикладі ядра Гауса ми застосуємо відображення поліномів, щоб привести наші дані до тривимірного виміру. Формула для перетворення даних така.

Ви визначаєте функцію в Gaussian Kernel Python для створення нових карт функцій

Ви можете використовувати numpy для кодування наведеної вище формули:

Формула	Еквівалентний код Numpy
х	x [:, 0] **
р	x [:, 1]
х 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

Нове відображення має бути тривимірним із 16 точками

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Давайте зробимо новий графік з 3 осями, x, y та 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() 

Ми бачимо покращення, але якщо ми змінимо орієнтацію графіку, очевидно, що набір даних тепер можна розділити

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

Щоб маніпулювати великим набором даних і вам, можливо, доведеться створити більше двох вимірів, ви зіткнетеся з великою проблемою, використовуючи вищезазначений метод. Насправді вам потрібно перетворити всі точки даних, що явно не є стійким. Це займе у вас вік, і пам’ять у комп’ютера може закінчитися.

Найпоширеніший спосіб подолання цієї проблеми - використання ядра .

Що таке ядро ​​в машинному навчанні?

Ідея полягає у використанні простору ознак більшого розміру, щоб зробити дані майже лінійно відокремлюваними, як показано на малюнку вище.

Існує безліч простір вищих розмірів, щоб зробити точки даних відокремлюваними. Наприклад, ми показали, що відображення поліномів - чудовий початок.

Ми також продемонстрували, що з великою кількістю даних це перетворення не є ефективним. Натомість ви можете використовувати функцію ядра в машинному навчанні для модифікації даних без переходу на новий план функцій.

Магія ядра полягає у тому, щоб знайти функцію, яка дозволяє уникнути всіх проблем, спричинених обчисленнями високих розмірів. Результатом ядра є скаляр, або сказано інакше, ми повернулися до одновимірного простору

Знайшовши цю функцію, ви можете підключити її до стандартного лінійного класифікатора.

Давайте подивимось приклад для розуміння концепції машинного навчання ядра. У вас є два вектори, x1 та x2. Завдання полягає у створенні вищого виміру за допомогою відображення поліномів. Вихід дорівнює точковому добутку нової карти об’єктів. З наведеного вище методу вам потрібно:

1. Перетворіть x1 та x2 в новий вимір
2. Обчислити точковий добуток: загальний для всіх ядер
3. Перетворіть x1 та x2 в новий вимір

Ви можете використовувати створену вище функцію для обчислення вищого виміру.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1) 

Вихідні дані

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

Обчислити точковий добуток

Ви можете використовувати об’єктну точку від numpy для обчислення точкового добутку між першим і другим вектором, що зберігається в x_1.

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

Результат - 8100. Ви бачите проблему, вам потрібно зберегти в пам'яті нову карту функцій для обчислення крапкового продукту. Якщо у вас є набір даних з мільйонами записів, це обчислювально неефективно.

Натомість ви можете використовувати ядро поліномів для обчислення крапкового добутку без перетворення вектора. Ця функція обчислює точковий добуток x1 та x2 так, ніби ці два вектори перетворені у вищу розмірність. Інакше сказано, функція ядра обчислює результати крапкового продукту з іншого простору функцій.

Ви можете написати функцію ядра поліномів у Python наступним чином.

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

Це сила крапкового добутку двох векторів. Нижче ви повертаєте другий ступінь ядра поліномів. Вихід дорівнює іншому методу. Це магія ядра.

polynomial_kernel(x1, x2, p=2)8100 

Типи методів ядра

Доступно багато різних методів ядра. Найпростішим є лінійне ядро. Ця функція працює досить добре для класифікації тексту. Інше ядро:

• Поліноміальне ядро
• Ядро Гаусса

У прикладі з TensorFlow ми використаємо випадковий Фур'є. TensorFlow має вбудований оцінювач для обчислення нового простору функцій. Гауссова функція фільтра - це наближення функції ядра Гауса.

Гауссова функція фільтрації обчислює подібність між точками даних у значно вищому розмірному просторі.

Навчіть класифікатор ядра Гауса за допомогою TensorFlow

Метою алгоритму є класифікація домогосподарств, що заробляють більше або менше 50 тис.

Ви оціните логістичне машинне навчання з регресії ядра, щоб отримати базову модель. Після цього ви навчите класифікатор ядра, щоб побачити, чи зможете ви отримати кращі результати.

Ви використовуєте такі змінні з набору даних для дорослих:

• вік
• робочий клас
• fnlwgt
• освіта
• освітня_число
• подружній
• окупація
• відносини
• гонки
• секс
• capital_gain
• втрата капіталу
• години_тижня
• Батьківщина
• етикетці

Перед тим, як тренувати та оцінювати модель, ви будете виконувати наступні дії:

• Крок 1) Імпортуйте бібліотеки
• Крок 2) Імпортуйте дані
• Крок 3) Підготуйте дані
• Крок 4) Побудуйте input_fn
• Крок 5) Побудуйте логістичну модель: Базова модель
• Крок 6) Оцініть модель
• Крок 7) Побудуйте класифікатор ядра
• Крок 8) Оцініть класифікатор ядра

Крок 1) Імпортуйте бібліотеки

Щоб імпортувати та навчати моделі ядра в штучному інтелекті, вам потрібно імпортувати tensorflow, pandas та numpy

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

Крок 2) Імпортуйте дані

Ви завантажуєте дані з наступного веб-сайту та імпортуєте їх як фрейм даних 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) 

Тепер, коли визначено поїзд і набір тестів, ви можете змінити мітку стовпця з рядка на ціле число. tensorflow не приймає значення рядка для мітки.

label = {'<=50K': 0,'>50K': 1}df_train.label = [label[item] for item in df_train.label]label_t = {'<=50K.': 0,'>50K.': 1}df_test.label = [label_t[item] for item in df_test.label]df_train.shape(32561, 15)

Крок 3) Підготуйте дані

Набір даних містить як безперервні, так і категоричні особливості. Хорошою практикою є стандартизація значень неперервних змінних. Ви можете використовувати функцію StandardScaler з sci-kit learn. Ви також створюєте визначену користувачем функцію, щоб полегшити перетворення поїзда та тестового набору. Зверніть увагу, що ви об'єднуєте безперервні та категоріальні змінні у загальний набір даних, і масив повинен мати тип: float32

COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']from sklearn.preprocessing import 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 

Функція трансформатора готова, ви можете перетворити набір даних і створити функцію 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 = 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} 

Ви будете тренувати регресію logisitc, використовуючи міні-партії розміром 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) 

Ви можете навчити модель з ітерацією 1000

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.

Крок 6) Оцініть модель

Ви визначаєте оцінювач numpy для оцінки моделі. Для оцінки використовується весь набір даних

# 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}

Ви маєте точність 82 відсотки. У наступному розділі ви спробуєте перемогти логістичний класифікатор за допомогою класифікатора ядра

Крок 7) Побудуйте класифікатор ядра

Оцінювач ядра не так сильно відрізняється від традиційного лінійного класифікатора, принаймні з точки зору побудови. Ідея полягає у використанні потужності явного ядра з лінійним класифікатором.

Вам потрібні два заздалегідь визначені оцінювачі, доступні в TensorFlow, щоб навчити Класифікатор ядра:

• RandomFourierFeatureMapper
• KernelLinearClassifier

У першому розділі ви дізналися, що вам потрібно перетворити низький розмір у великий, використовуючи функцію ядра. Точніше, ви будете використовувати випадковий Фур'є, який є наближенням функції Гауса. На щастя, Tensorflow має функцію у своїй бібліотеці: RandomFourierFeatureMapper. Модель можна навчити за допомогою оцінювача KernelLinearClassifier.

Щоб побудувати модель, виконайте такі дії:

1. Встановіть функцію ядра високого розміру
2. Встановіть гіперпараметр L2
3. Побудуйте модель
4. Тренуйте модель
5. Оцініть модель

Крок А) Встановіть функцію ядра великих розмірів

Поточний набір даних містить 14 функцій, які ви перетворите на нову велику розмірність 5000-мірного вектора. Ви використовуєте випадкові функції Фур'є для досягнення перетворення. Якщо ви згадуєте формулу ядра Гауса, ви зазначаєте, що існує параметр стандартного відхилення для визначення. Цей параметр контролює показник подібності, який використовується під час класифікації.

Ви можете налаштувати всі параметри в RandomFourierFeatureMapper за допомогою:

• 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') 

Вам потрібно сконструювати зіставлення ядра, використовуючи стовпці об’єктів, створені раніше: feat_column

### Map Kernelkernel_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 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'}

Крок Г) Навчіть модель

Тепер, коли класифікатор ядра побудований, ви готові його навчити. Ви вирішите повторити модель у 2000 разів

### 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): []}}) 

Крок Е) Оцініть модель

І останнє, але не менш важливе: Ви оцінюєте ефективність своєї моделі. Ви повинні мати можливість перемогти логістичну регресію.

# 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

Остаточна точність становить 84%, це поліпшення на 2% порівняно з логістичною регресією. Існує компроміс між підвищенням точності та обчислювальними витратами. Вам потрібно подумати, чи покращення на 2% коштує часу, витраченого різним класифікатором, і чи це має переконливий вплив на ваш бізнес.

Резюме

Ядро - чудовий інструмент для перетворення нелінійних даних у (майже) лінійні. Недоліком цього методу є його обчислення трудомісткий і витратний.

Нижче ви можете знайти найважливіший код для навчання класифікатора ядра

Встановіть функцію ядра високого розміру

• 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') 

Встановіть гіперпараметр L2

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

Побудуйте модель

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

Тренуйте модель

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

Оцініть модель

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