Гауссово ядро в машинном обучении: 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 осями.

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

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

Вы можете использовать NumPy чтобы закодировать приведенную выше формулу:

Формула	Эквивалентный код Numpy
x	х[:,0]**
y	х[:,1]
x²	х[:,0]**2
	np.sqrt(2)*
xy	х[:,0]*х[:,1]
y²	х[:,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()

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

Самый распространенный способ решить эту проблему — использовать ядро.

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

Идея состоит в том, чтобы использовать пространство признаков более высокого измерения, чтобы сделать данные почти линейно разделимыми, как показано на рисунке выше.

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

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

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

После того, как вы нашли эту функцию, вы можете подключить ее к стандартному линейному классификатору.

Давайте посмотрим пример, чтобы понять концепцию машинного обучения ядра. У вас есть два вектора: 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 имеет встроенный оценщик для вычисления нового пространства признаков. Функция фильтра Гаусса является аппроксимацией функции ядра Гаусса.

Функция фильтрации по Гауссу вычисляет сходство между точками данных в пространстве гораздо большей размерности.

Обучение классификатора гауссовского ядра с помощью TensorFlow

Цель алгоритма — классифицировать домохозяйства с доходом более или менее 50 тысяч.

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

Вы используете следующие переменные из набора данных для взрослых:

возраст
рабочий класс
фнлвгт
образование
образование_номер
брачный
оккупация
отношения
раса
секс
прирост капитала
капитал_убыток
часы_неделя
родная страна
этикетка

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

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

Шаг 1) Импортировать библиотеки

Чтобы импортировать и обучать модели ядра в Искусственный интеллект, вам нужно импортировать тензорный поток, панд и тупица

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

СлучайныйФурьеFeatureMapper
ЯдроЛинейныйКлассификатор

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

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

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

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

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

Вы можете настроить все параметры в RandomFourierFeatureMapper с помощью:

input_dim = 14
вывод_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]}

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

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

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

Шаг С) Построить модель

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

Шаг Д) Тренируй модель

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

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

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

# 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
вывод_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)

Зачем вам нужны методы ядра?

СТАТЬИ ПО ТЕМЕ

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

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

Обучение классификатора гауссовского ядра с помощью TensorFlow

Резюме

Подпишитесь на рассылку

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