Цель этого руководства — сделать набор данных линейно разделимым. Учебник разделен на две части:
- Преобразование функций
- Обучите классификатор ядра с помощью Tensorflow
В первой части вы поймете идею метода ядра в машинном обучении, а во второй части вы увидите, как обучить классификатор ядра с помощью Tensorflow. Вы будете использовать набор данных для взрослых. Цель этого набора данных — классифицировать доход ниже и выше 50 тысяч, зная поведение каждого домохозяйства.
Contents
Зачем вам нужны методы ядра?
Цель каждого классификатора – правильно предсказать классы. Для этого набор данных должен быть разделимым. Посмотрите на график ниже; довольно просто увидеть, что все точки выше черной линии принадлежат к первому классу, а остальные точки ко второму классу. Однако такой простой набор данных встречается крайне редко. В большинстве случаев данные неразделимы. Методы ядра в машинном обучении создают трудности для наивных классификаторов, таких как логистическая регрессия.
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-мя осями.
В нашем примере ядра Гаусса мы применим полиномиальное отображение, чтобы привести наши данные к трехмерному измерению. Формула преобразования данных выглядит следующим образом.
Вы определяете функцию в Gaussian Kernel Python для создания новых карт объектов.
Вы можете использовать numpy
для кодирования приведенной выше формулы:
| Формула | Эквивалентный код Numpy |
|---|---|
| Икс | х[:,0]** |
| у | х[:,1] |
| х 2 | х[:,0]**2 |
 |
np.sqrt(2)* |
| ху | х[:,0]*х[:,1] |
| у 2 | х[:,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
Новое отображение должно быть трехмерным с 16 точками.
x_1 = mapping(x, y) x_1.shape
(3, 16) Давайте создадим новый график с 3 осями, 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()
Чтобы манипулировать большим набором данных, и вам, возможно, придется создать более двух измерений, вы столкнетесь с большой проблемой, используя описанный выше метод. На самом деле нужно преобразовать все точки данных, что явно нецелесообразно. Это займет у вас целую вечность, и вашему компьютеру может не хватить памяти.
Самый распространенный способ решить эту проблему — использовать ядро .
Что такое ядро в машинном обучении?
Идея состоит в том, чтобы использовать пространство признаков более высокой размерности, чтобы сделать данные почти линейно разделимыми, как показано на рисунке выше.
Существует множество многомерных пространств, чтобы сделать точки данных разделимыми. Например, мы показали, что полиномиальное отображение — отличное начало.
Мы также продемонстрировали, что при большом количестве данных такое преобразование неэффективно. Вместо этого вы можете использовать функцию ядра в машинном обучении для изменения данных без перехода на новый план функций.
Магия ядра заключается в том, чтобы найти функцию, которая позволяет избежать всех проблем, связанных с многомерными вычислениями. Результатом ядра является скаляр, или, иначе говоря, мы вернулись к одномерному пространству.
После того, как вы нашли эту функцию, вы можете подключить ее к стандартному линейному классификатору.
Давайте посмотрим на пример, чтобы понять концепцию машинного обучения ядра. У вас есть два вектора, 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. ]]
Вычислить скалярное произведение
Вы можете использовать точку объекта из 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 тыс.
Вы оцените машинное обучение логистической регрессии ядра, чтобы получить эталонную модель. После этого вы обучите классификатор ядра, чтобы увидеть, сможете ли вы получить лучшие результаты.
Перед обучением и оценкой модели вы будете действовать следующим образом:
- Шаг 1) Импортируйте библиотеки
- Шаг 2) Импорт данных
- Шаг 3) Подготовьте данные
- Шаг 4) Создайте input_fn
- Шаг 5) Построить логистическую модель: Базовая модель
- Шаг 6) Оцените модель
- Шаг 7) Создайте классификатор ядра
- Шаг 8) Оцените классификатор ядра
Шаг 1) Импортируйте библиотеки
Чтобы импортировать и обучать модели ядра в искусственном интеллекте, вам необходимо импортировать tensorflow, pandas и 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 из научного набора. Вы также создаете определяемую пользователем функцию, чтобы упростить преобразование набора поездов и тестов. Обратите внимание, что вы объединяете непрерывные и категориальные переменные в общий набор данных, и массив должен иметь тип: 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
- ЯдроЛинейныйКлассификатор
В первом разделе вы узнали, что вам нужно преобразовать низкое измерение в высокое, используя функцию ядра. Точнее, вы будете использовать случайный Фурье, который является аппроксимацией функции Гаусса. К счастью, в библиотеке Tensorflow есть функция RandomFourierFeatureMapper. Модель можно обучить с помощью оценщика KernelLinearClassifier.
Чтобы построить модель, выполните следующие действия:
- Установите функцию ядра высокой размерности
- Установите гиперпараметр L2
- Построить модель
- Обучите модель
- Оценить модель
Шаг A) Установите функцию ядра высокой размерности
Текущий набор данных содержит 14 объектов, которые вы преобразуете в новое высокое измерение 5000-мерного вектора. Вы используете случайные функции Фурье для достижения преобразования. Если вы помните формулу ядра Гаусса, вы заметите, что есть параметр стандартного отклонения, который необходимо определить. Этот параметр управляет мерой сходства, используемой во время классификации.
Вы можете настроить все параметры в RandomFourierFeatureMapper с помощью:
- input_dim = 14
- output_dim = 5000
- стандартное отклонение = 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
- стандартное отклонение = 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) Статья является переводом guru99-com.
