Гаусово ядро ​​в машинно обучение: Примери за ядрени методи

Целта на този урок е да направи набор от данни линейно разделим. Урокът е разделен на две части:

1. Трансформация на характеристиките
2. Обучете класификатор на ядрото с Tensorflow

В първата част ще разберете идеята за метод на ядрото в машинното обучение, докато във втората част ще видите как да обучите класификатор на ядрото с Tensorflow. Ще използвате набора от данни за възрастни. Целта на този набор от данни е да класифицира приходите под и над 50 000, като се знае поведението на всяко домакинство.

В този урок ще научите-

• Защо се нуждаете от методи на ядрото?
• Какво представлява ядрото в машинното обучение?
• Видове методи на ядрото
• Обучете класификатора на Gaussian Kernel с 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() 

Данните от фигурата по-горе са в план за 2D гаусово ядро, който не може да се раздели. Можете да опитате да трансформирате тези данни в триизмерност, това означава, че създавате фигура с 3 оси.

В нашия пример за Gaussian Kernel, ние ще приложим полиномно картографиране, за да доведем нашите данни до 3D измерение. Формулата за трансформиране на данните е както следва.

Вие дефинирате функция в Gaussian Kernel Python, за да създадете новите карти на характеристиките

Можете да използвате numpy за кодиране на горната формула:

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

Новото картографиране трябва да бъде с 3 измерения с 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() 

За да манипулирате голям набор от данни и може да се наложи да създадете повече от 2 измерения, ще се сблъскате с голям проблем, използвайки горния метод. Всъщност трябва да трансформирате всички точки от данни, което очевидно не е устойчиво. Това ще ви отнеме години и компютърът ви може да остане без памет.

Най-често срещаният начин за преодоляване на този проблем е използването на ядро .

Какво представлява ядрото в машинното обучение?

Идеята е да се използва пространство от функции с по-голямо измерение, за да се направят данните почти линейно разделими, както е показано на фигурата по-горе.

Има много пространства с по-високи размери, за да направят точките с данни отделими. Например, ние показахме, че полиномното картографиране е чудесно начало.

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

Магията на ядрото е да намери функция, която избягва всички проблеми, породени от изчислението с високи размери. Резултатът от ядрото е скаларен, или казано по друг начин, ние се връщаме в едномерното пространство

След като намерите тази функция, можете да я включите към стандартния линеен класификатор.

Нека да видим пример за разбиране на концепцията за машинно обучение на ядрото. Имате два вектора, 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 ще използваме Random Fourier. TensorFlow има вграден оценител за изчисляване на новото пространство на характеристиките. Гаусовата филтърна функция е приближение на ядрената функция на Гаус.

Гаусовата филтрираща функция изчислява сходството между точките с данни в много по-високомерно пространство.

Обучете класификатора на Gaussian Kernel с TensorFlow

Целта на алгоритъма е да класифицира домакинството, което печели повече или по-малко от 50 000.

Ще оцените логистично ядрено регресионно машинно обучение, за да имате еталонен модел. След това ще обучите класификатор на ядрото, за да видите дали можете да получите по-добри резултати.

Използвате следните променливи от набора от данни за възрастни:

• възраст
• работен клас
• fnlwgt
• образование
• номер на образованието
• брачен
• професия
• връзка
• раса
• секс
• capital_gain
• загуба на капитал
• hours_week
• native_country
• етикет

Ще продължите, както следва, преди да тренирате и оцените модела:

• Стъпка 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 dataframe.

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

Сега, когато влакът и тестовият набор са дефинирани, можете да промените етикета на колоната от низ към цяло число. tensorflow не приема низова стойност за етикета.

label = {'<=50K': 0,'>50K': 1}df_train.label = [label[item] for item in df_train.label]label_t = {'<=50K.': 0,'>50K.': 1}df_test.label = [label_t[item] for item in df_test.label]df_train.shape(32561, 15)

Стъпка 3) Подгответе данните

Наборът от данни съдържа както непрекъснати, така и категорични функции. Добра практика е да се стандартизират стойностите на непрекъснатите променливи. Можете да използвате функцията StandardScaler от sci-kit learn. Създавате и дефинирана от потребителя функция, за да улесните преобразуването на влака и тестовия комплект. Имайте предвид, че обединявате непрекъснатите и категориалните променливи в общ набор от данни и масивът трябва да бъде от типа: float32

COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']from sklearn.preprocessing import 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} 

Ще обучите logisitc регресията, като използвате мини партиди с размер 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:

• RandomFourierFeatureMapper
• KernelLinearClassifier

В първия раздел научихте, че трябва да трансформирате ниското измерение във високо измерение, като използвате функцията на ядрото. По-точно ще използвате Random Fourier, което е приближение на функцията на Гаус. За щастие Tensorflow има функцията в своята библиотека: RandomFourierFeatureMapper. Моделът може да бъде обучен с помощта на оценителя KernelLinearClassifier.

За да изградите модела, ще следвате тези стъпки:

1. Задайте функцията Kernel с висока размери
2. Задайте хиперпараметъра L2
3. Изградете модела
4. Тренирайте модела
5. Оценете модела

Стъпка А) Задайте функцията на ядрото с големи размери

Текущият набор от данни съдържа 14 функции, които ще трансформирате в ново високо измерение на 5000-измерния вектор. Използвате произволните функции на Фурие, за да постигнете трансформацията. Ако си припомните формулата на Gaussian Kernel, ще забележите, че има параметър за стандартно отклонение, който трябва да се дефинира. Този параметър контролира мярката за сходство, използвана по време на класификацията.

Можете да настроите всички параметри в 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]} 

Стъпка B) Задайте хиперпараметъра L2

За да предотвратите пренастройване, вие наказвате функцията за загуба с регулатора L2. Задавате хиперпараметъра L2 на 0,1 и скоростта на обучение на 5

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

Стъпка В) Изграждане на модела

Следващата стъпка е подобна на линейната класификация. Използвате вградения оценител 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'}

Стъпка Г) Обучете модела

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

Стъпка Д) Оценете модела

Не на последно място, вие оценявате работата на вашия модел. Би трябвало да можете да победите логистичната регресия.

# 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% струва времето, отделено от различния класификатор и дали това има убедително въздействие върху вашия бизнес.

Обобщение

Ядрото е чудесен инструмент за трансформиране на нелинейни данни в (почти) линейни. Недостатъкът на този метод е, че изчислително отнема много време и е скъп.

По-долу можете да намерите най-важния код за обучение на класификатор на ядрото

Задайте функцията Kernel с висока размери

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