Ядро Гауса в машинному навчанні: Python Методи ядра
Евелін Кларк
⚡ Розумний підсумок
Методи гаусового ядра роблять нероздільні дані лінійно роздільними без побудови багатовимірної карти ознак. У цьому покроковому посібнику показано карту поліноміів.ping вручну, а потім навчає випадковий класифікатор ядра Фур'є в TensorFlow.
Мета цього підручника — зробити набір даних лінійно роздільним. Посібник розділений на дві частини:
- Перетворення ознак
- Навчання класифікатора ядра за допомогою 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()
Дані з рисунка вище лежать у двовимірній площині та не є роздільними. Ви можете спробувати перетворити ці дані у три виміри, тобто створити фігуру з 3 осями.
У нашому прикладі з гаусовим ядром ми застосуємо поліноміальне відображенняping щоб перевести наші дані у третій вимір. Формула для перетворення даних така.
Ви визначаєте функцію в ядрі Гауса Python для створення нових карт ознак.
Ви можете використовувати numpy щоб закодувати наведену вище формулу. Кожен рядок нижче спарює один член картиping з виразом масиву, який його створює, а маленьке зображення позначає квадратний корінь з двох множників.
| 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
Нова картаping має 3 виміри та 16 точок.
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()
Якщо вам доведеться маніпулювати великим набором даних і створювати більше двох вимірів, ви зіткнетеся з великою проблемою, використовуючи вищезгаданий метод. Фактично, вам потрібно перетворити всі точки даних, що явно не є раціональним. Це займе у вас багато часу, і вашому комп'ютеру може закінчитися пам'ять.
Найпоширеніший спосіб подолати цю проблему — використовувати ядро.
Що таке ядро в машинному навчанні?
Ідея полягає у використанні простору ознак вищої вимірності, щоб зробити дані майже лінійно роздільними, як показано на рисунку вище.
Існує безліч просторів вищої вимірності, які роблять точки даних роздільними. Наприклад, ми показали, що поліноміальне відображенняping це чудовий початок.
Ми також продемонстрували, що з великою кількістю даних ці перетворення неефективні. Натомість, ви можете використовувати функцію ядра в машинному навчанні, щоб змінити дані без переходу на нову площину ознак.
Магія ядра полягає в тому, щоб знайти функцію, яка уникає всіх труднощів, пов'язаних з обчисленнями у високій вимірності. Результатом ядра є скаляр, або, іншими словами, ми повертаємося до одновимірного простору.
Після того, як ви знайдете цю функцію, ви можете підставити її у стандартний лінійний класифікатор.
Ось приклад, який конкретизує концепцію машинного навчання ядра. У вас є два вектори, x1 та x2. Мета полягає у створенні вищої вимірності за допомогою поліноміального відображення.pingВихід дорівнює скалярному добутку нової карти ознак. Згідно з наведеним вище методом, вам потрібно:
- Перетворіть 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. ]]
Обчислити скалярний добуток
Ви можете використовувати об'єктну точку з 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
Типи ядерних методів
Існує багато різних методів ядра. Найпростішим є лінійне ядро. Ця функція досить добре працює для класифікації тексту. Інші ядра:
- Поліноміальне ядро
- Ядро Гауса
У таблиці нижче підсумовано, що робить кожен з них і коли фахівці його використовують.
| Ядро | Що воно обчислює | Типове використання |
|---|---|---|
| Лінійний | Простий скалярний добуток у вихідному просторі ознак | Вже роздільні дані та багатовимірні текстові функції |
| Поліноміальний | Скальковий добуток, піднесений до степеня p, що фіксує взаємодію ознак | Вигнуті межі, коли відомо, що взаємодії мають значення |
| Гаусівський (RBF) | Подібність на основі відстані, яка падає до нуля, коли точки віддаляються одна від одної | Звичайний перший вибір, коли форма межі невідома |
У прикладі з TensorFlow ми використовуватимемо випадкові ознаки Фур'є. TensorFlow має вбудовану оцінку для обчислення нового простору ознак. Мета випадкового відображення ознак Фур'є є апроксимацією гауссової функції ядра, показаної нижче.
Функція фільтрації Гауса обчислює подібність між точками даних у просторі набагато вищої розмірності.
Після того, як теорія була визначена, решта цього покрокового керівництва використовує гаусове ядро для роботи з реальним набором даних.
Навчання класифікатора Gaussian Kernel за допомогою TensorFlow
Метою алгоритму є класифікація домогосподарств, які заробляють більше або менше 50 тис.
Спочатку ви оціните логістичну регресію, щоб отримати еталонну модель. Після цього ви навчите класифікатор ядра, щоб побачити, чи можна отримати кращі результати.
Ви використовуєте такі змінні з набору даних для дорослих:
- вік
- робочий клас
- fnlwgt
- освіту
- номер_освіти
- подружній
- окупація
- відносини
- гонки
- секс
- приріст капіталу
- капітал_збиток
- години_тиждень
- Батьківщина
- етикетка
Перш ніж навчати та оцінювати модель, вам потрібно буде виконати такі дії:
- Імпортувати бібліотеки
- Імпортуйте дані
- Підготуйте дані
- Побудуйте логістичну модель: базову модель
- Оцініть модель
- Створити та оцінити класифікатор ядра
Примітка до версії: Кожен фрагмент коду нижче призначений для TensorFlow 1.x. Простір імен tf.contrib, який надає real_valued_column, RandomFourierFeatureMapper та KernelLinearClassifier, було видалено в TensorFlow 2.0, а сам tf.estimator було видалено в TensorFlow 2.16. У поточному випуску створіть той самий конвеєр з шаром tf.keras.layers.experimental.RandomFourierFeatures, а потім вихідним шаром Dense, або з парою RBFSampler та SGDClassifier зі scikit-learn.
Крок 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) Імпортуйте дані
Ви завантажуєте дані з Сторінка набору даних для дорослих UCI та імпортуйте його як pandas DataFrame.
## 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 з scikit-вчитисяВи також створюєте користувацьку функцію, щоб спростити перетворення навчального та тестового наборів. Зверніть увагу, що ви об'єднуєте неперервні та категоріальні змінні в спільний набір даних, а масив повинен мати тип 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)
Оцінювач визначається за допомогою API оцінювача 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': <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>
Крок 5) Оцініть модель
Ви визначаєте вхідну функцію 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 відсотки. У наступному розділі ви спробуєте обіграти логістичний класифікатор за допомогою класифікатора ядра.
Крок 6) Створіть класифікатор ядра
Ядерна оцінка не так сильно відрізняється від традиційного лінійного класифікатора, принаймні з точки зору побудови. Ідея полягає в поєднанні можливостей явного відображення ядраping з лінійним класифікатором.
Вам потрібні два попередньо визначені оцінювачі, доступні в TensorFlow, щоб навчити класифікатор ядра:
- RandomFourierFeatureMapper
- KernelLinearClassifier
У першому розділі ви дізналися, що вам потрібно перетворити нижню розмірність у вищу за допомогою функції ядра. Точніше, ви будете використовувати випадкові ознаки Фур'є, які апроксимують функцію Гауса. TensorFlow 1.x надає це відображенняping як RandomFourierFeatureMapper, а модель можна навчити за допомогою оцінювача KernelLinearClassifier.
Щоб створити модель, виконайте такі дії:
- Встановіть функцію ядра високої розмірності
- Встановіть гіперпараметр L2
- Побудуйте модель
- Тренуйте модель
- Оцініть модель
Крок A) Встановіть функцію ядра високої розмірності
Поточний набір даних містить 14 ознак, які ви перетворите на новий 5,000-вимірний вектор. Для здійснення перетворення ви використовуєте випадкові ознаки Фур'є. Якщо ви пам'ятаєте формулу гаусового ядра, то помічаєте, що потрібно визначити параметр стандартного відхилення. Цей параметр контролює міру подібності, яка використовується під час класифікації: мале значення stddev змушує ядро розглядати лише дуже близькі точки як подібні, тоді як велике значення згладжує межу прийняття рішення.
Ви можете налаштувати всі параметри в 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")
Наведені нижче попередження про застарівання очікуються у TensorFlow 1.x, оскільки модуль kernel_methods побудовано на старіших оцінювачах tf.contrib.learn.
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) Навчання моделі
Тепер, коли класифікатор ядра побудовано, ви готові його навчити. Ви вирішили ітерувати модель 2,000 разів.
### 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%, що приблизно на 1.6 процентних пункти вище базового рівня логістичної регресії (0.83975184 проти 0.82353663). Існує компроміс між покращенням точності та обчислювальними витратами. Вам потрібно подумати, чи варте це покращення часу, витраченого складнішим класифікатором, і чи має воно переконливий вплив на ваш бізнес.
