Гауссовское ядро ​​в машинном обучении: примеры ядерных методов

Цель этого руководства - сделать набор данных линейно разделяемым. Учебное пособие разделено на две части:

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

Данные на рисунке выше представлены в виде двухмерного плана ядра Гаусса, который не может быть разделен. Вы можете попробовать преобразовать эти данные в трехмерном пространстве, то есть вы создаете фигуру с 3 осями.

В нашем примере с гауссовым ядром мы применим полиномиальное отображение, чтобы перенести наши данные в трехмерное измерение. Формула преобразования данных следующая.

Вы определяете функцию в гауссовском ядре Python для создания новых карт функций.

Вы можете использовать numpy для кодирования приведенной выше формулы:

Формула	Эквивалентный код Numpy
Икс	x [:, 0] **
y	х [:, 1]
х 2	x [:, 0] ** 2
	np.sqrt (2) *
ху	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
• образование
• education_num
• супружеский
• Занятие
• отношение
• раса
• секс
• прирост капитала
• capital_loss
• hours_week
• родная страна
• метка

Перед обучением и оценкой модели вы выполните следующие действия:

• Шаг 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) 

Теперь, когда набор поездов и тестов определены, вы можете изменить метку столбца со строки на целое число. tenorflow не принимает строковое значение для метки.

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

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} 

Вы будете обучать логистическую регрессию, используя мини-пакеты размером 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) 

Вы можете обучить модель за 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 = 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:

• СлучайныйFourierFeatureMapper
• KernelLinearClassifier

В первом разделе вы узнали, что вам нужно преобразовать низкую размерность в высокую с помощью функции ядра. Точнее, вы будете использовать случайный Фурье, который является приближением функции Гаусса. К счастью, в библиотеке Tensorflow есть функция: RandomFourierFeatureMapper. Модель можно обучить с помощью оценщика KernelLinearClassifier.

Чтобы построить модель, выполните следующие действия:

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

Шаг A) Установите функцию ядра высокой размерности

Текущий набор данных содержит 14 объектов, которые вы преобразуете в новое высокое измерение 5.000-мерного вектора. Для преобразования используются случайные функции Фурье. Если вы вспомните формулу ядра Гаусса, вы заметите, что необходимо определить параметр стандартного отклонения. Этот параметр контролирует меру сходства, используемую во время классификации.

Вы можете настроить все параметры в 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]} 

Шаг Б) Установите гиперпараметр L2

Чтобы предотвратить переобучение, вы штрафуете функцию потерь с помощью регуляризатора L2. Вы устанавливаете гиперпараметр L2 на 0,1, а скорость обучения на 5.

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

Шаг C) Постройте модель

Следующий шаг аналогичен линейной классификации. Вы используете встроенный оценщик 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'}

Шаг D) Обучите модель

Теперь, когда классификатор ядра построен, вы готовы его обучать. Вы выбираете повторение модели 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): []}}) 

Шаг E) Оцените модель

И последнее, но не менее важное: вы оцениваете производительность своей модели. Вы должны суметь преодолеть логистическую регрессию.

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