Ядро Гауса в машинному навчанні: Python Методи ядра

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

Перетворення ознак
Навчіть класифікатор ядра за допомогою Tensorflow

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

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

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

import numpy as np
  import matplotlib.pyplot as plt
  from mpl_toolkits.mplot3d import Axes3D

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

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

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

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

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

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

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

Ви визначаєте функцію в ядрі Гауса Python щоб створити нові карти функцій

Ви можете використовувати нумпі щоб закодувати наведену вище формулу:

Formula	Еквівалентний код Numpy
x	x[:,0]**
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	x[:,1]**2

### illustration purpose
def mapping(x, y):    
	x = np.c_[(x, y)]				
    if len(x) >	2:        
    	x_1 = x[:,0]**2        
        x_2 = np.sqrt(2)*x[:,0]*x[:,1]        
        x_3 = x[:,1]**2								
    else:            
    	x_1 = x[0]**2        
        x_2 = np.sqrt(2)*x[0]*x[1]        
        x_3 = x[1]**2			    
   trans_x = np.array([x_1, x_2, x_3])				
   return trans_x

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

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Давайте створимо новий графік із трьома вісями x, y та z відповідно.

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

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

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

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

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

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

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

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

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

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

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

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

Перетворіть x1 і x2 у новий вимір
Обчисліть скалярний добуток: спільний для всіх ядер
Перетворіть x1 і x2 у новий вимір

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

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

Вихід

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

Обчислити скалярний добуток

Ви можете використовувати об’єкт dot із 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 має вбудований оцінювач для обчислення нового простору функцій. Функція фільтра Гауса є наближенням ядерної функції Гауса.

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

Навчання класифікатора Gaussian Kernel за допомогою TensorFlow

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

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

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

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

Перед тренуванням і оцінкою моделі ви виконайте наведені нижче дії.

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

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

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

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

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

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

Тепер, коли навчальний і тестовий набір визначено, ви можете змінити мітку стовпця з рядка на ціле число. 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 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

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

estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],
                                          n_classes=2,
                                          model_dir = "kernel_log"
                                         )

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'kernel_log', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a2003f780>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Ви тренуватимете логістичну регресію за допомогою міні-пакетів розміром 200.

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

Ви можете навчити модель за допомогою 1.000 ітерацій

estimator.train(input_fn=train_input_fn, steps=1000)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into kernel_log/model.ckpt.
INFO:tensorflow:loss = 138.62949, step = 1
INFO:tensorflow:global_step/sec: 324.16
INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)
INFO:tensorflow:global_step/sec: 267.092
INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)
INFO:tensorflow:global_step/sec: 292.679
INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)
INFO:tensorflow:global_step/sec: 225.582
INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)
INFO:tensorflow:global_step/sec: 209.975
INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)
INFO:tensorflow:global_step/sec: 241.648
INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)
INFO:tensorflow:global_step/sec: 305.193
INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)
INFO:tensorflow:global_step/sec: 396.295
INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)
INFO:tensorflow:global_step/sec: 359.857
INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec)
INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt.
INFO:tensorflow:Loss for final step: 67.79706.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>

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

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

# Evaluation
test_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"features": X_test},
    y=y_test,
    batch_size=16281,
    num_epochs=1,
    shuffle=False)
estimator.evaluate(input_fn=test_input_fn, steps=1)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/1]
INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577

{'accuracy': 0.82353663,
 'accuracy_baseline': 0.76377374,
 'auc': 0.84898686,
 'auc_precision_recall': 0.67214864,
 'average_loss': 0.3877216,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 6312.495,
 'precision': 0.7362797,
 'prediction/mean': 0.21208474,
 'recall': 0.39417577}

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

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

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

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

RandomFourierFeatureMapper
KernelLinearClassifier

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

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

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

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

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

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

input_dim = 14
output_dim = 5000
stddev=4

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

Вам потрібно створити програму відображення ядра, використовуючи створені раніше стовпці функцій: feat_column

### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

Крок B) Встановіть гіперпараметр L2

Щоб запобігти переобладнанню, ви штрафуєте функцію втрат за допомогою регуляризатора L2. Ви встановлюєте гіперпараметр L2 на 0.1 і швидкість навчання на 5

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

Крок C) Побудуйте модель

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

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

Крок D) Тренуйте модель

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

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

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

KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})

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

Не в останню чергу ви оцінюєте продуктивність своєї моделі. Ви повинні бути в змозі подолати логістичну регресію.

# Evaluate and report metrics.
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

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

Остаточна точність становить 84%, це на 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)

Вам може сподобатися:

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

СТАТТІ ПО ТЕМІ

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

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

Навчання класифікатора Gaussian Kernel за допомогою TensorFlow

Підсумки

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