Gaussian Kernel в машинното обучение: 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()
Данните от фигурата по-горе са в 2D план на ядрото на Гаус, който не може да се раздели. Можете да опитате да трансформирате тези данни в три измерения, което означава, че създавате фигура с 3 оси.
В нашия пример за гаусово ядро ще приложим полиномиално картографиране, за да приведем данните си в 3D измерение. Формулата за трансформиране на данните е следната.
Вие дефинирате функция в Gaussian Kernel Python за създаване на нови карти на функции
Можете да използвате буца за кодиране на горната формула:
| Формула | Еквивалентен код Numpy |
|---|---|
| x | x[:,0]** |
| y | x[:,1] |
| x2 | x[:,0]**2 |
 |
np.sqrt(2)* |
| xy | x[:,0]*x[:,1] |
| y2 | x[:,1]**2 |
### illustration purpose
def mapping(x, y):
x = np.c_[(x, y)]
if len(x) > 2:
x_1 = x[:,0]**2
x_2 = np.sqrt(2)*x[:,0]*x[:,1]
x_3 = x[:,1]**2
else:
x_1 = x[0]**2
x_2 = np.sqrt(2)*x[0]*x[1]
x_3 = x[1]**2
trans_x = np.array([x_1, x_2, x_3])
return trans_x
Новото картографиране трябва да бъде с 3 измерения с 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()
За да манипулирате голям набор от данни и може да се наложи да създадете повече от 2 измерения, ще се сблъскате с голям проблем, като използвате горния метод. Всъщност трябва да трансформирате всички точки от данни, което очевидно не е устойчиво. Това ще ви отнеме години и компютърът ви може да остане без памет.
Най-честият начин за преодоляване на този проблем е използването на a ядро.
Какво е ядро в машинното обучение?
Идеята е да се използва пространство на характеристиките с по-високо измерение, за да се направят данните почти линейно разделими, както е показано на фигурата по-горе.
Има много пространства с по-високи измерения, за да направят точките от данни разделими. Например, ние показахме, че полиномното картографиране е страхотно начало.
Ние също така показахме, че с много данни тези трансформации не са ефективни. Вместо това можете да използвате функция на ядрото в Machine Learning, за да модифицирате данните, без да променяте нов план за функции.
Магията на ядрото е да намери функция, която избягва всички проблеми, свързани с изчисленията с големи размери. Резултатът от ядрото е скаларен, или казано по друг начин, ние се връщаме към едномерното пространство
След като намерите тази функция, можете да я включите към стандартния линеен класификатор.
Нека видим пример, за да разберем концепцията за машинно обучение на ядрото. Имате два вектора, 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
Целта на алгоритъма е да класифицира домакинството, което печели повече или по-малко от 50k.
Ще оцените логистично машинно обучение за регресия на ядрото, за да имате модел за сравнение. След това ще обучите класификатор на ядрото, за да видите дали можете да получите по-добри резултати.
Използвате следните променливи от набора от данни за възрастни:
- възраст
- работен клас
- fnlwgt
- образование
- образование_номер
- брачен
- окупация
- връзка
- раса
- секс
- капиталова_печалба
- капиталова_загуба
- часове_седмица
- родна_страна
- етикет
Ще продължите както следва, преди да обучите и оцените модела:
- Стъпка 1) Импортирайте библиотеките
- Стъпка 2) Импортирайте данните
- Стъпка 3) Подгответе данните
- Стъпка 4) Конструирайте input_fn
- Стъпка 5) Конструирайте логистичния модел: Базов модел
- Стъпка 6) Оценете модела
- Стъпка 7) Конструирайте класификатора на ядрото
- Стъпка 8) Оценете класификатора на ядрото
Стъпка 1) Импортирайте библиотеките
За импортиране и обучение на модели на ядрото Изкуствен интелект, трябва да импортирате tensorflow, панди и numpy
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Стъпка 2) Импортирайте данните
Изтегляте данните от следното уебсайт и го импортирате като рамка от данни на 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 от 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 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}
Ще тренирате logisitc регресията, като използвате мини-партиди с размер 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
- KernelLinearClassifier
В първия раздел научихте, че трябва да трансформирате ниското измерение във високо измерение с помощта на функция на ядрото. По-точно, ще използвате произволната функция на Фурие, която е приближение на функцията на Гаус. За щастие Tensorflow има функцията в своята библиотека: RandomFourierFeatureMapper. Моделът може да бъде обучен с помощта на оценителя KernelLinearClassifier.
За да изградите модела, ще следвате следните стъпки:
- Задайте високоразмерната функция на ядрото
- Задайте хиперпараметър L2
- Изградете модела
- Обучете модела
- Оценете модела
Стъпка А) Задайте високоразмерната функция на ядрото
Текущият набор от данни съдържа 14 функции, които ще трансформирате в ново високо измерение на 5.000-измерния вектор. Използвате произволните функции на Фурие, за да постигнете трансформацията. Ако си спомняте формулата на ядрото на Гаус, забелязвате, че има параметър за стандартно отклонение, който трябва да се дефинира. Този параметър контролира мярката за сходство, използвана по време на класификацията.
Можете да настроите всички параметри в RandomFourierFeatureMapper с:
- input_dim = 14
- изходен_дим = 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Трябва да конструирате картографа на ядрото, като използвате колоните с функции, създадени преди: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Стъпка B) Задайте хиперпараметър L2
За да предотвратите пренастройването, наказвате функцията за загуба с L2 регулатор. Задавате хиперпараметъра L2 на 0.1 и скоростта на обучение на 5
optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)
Стъпка C) Изградете модела
Следващата стъпка е подобна на линейната класификация. Използвате вградения оценител KernelLinearClassifier. Имайте предвид, че добавяте картографа на ядрото, дефиниран по-рано, и променяте директорията на модела.
### Prep estimator
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(
n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
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% си струва времето, изразходвано от различния класификатор, и дали има убедително въздействие върху вашия бизнес.
Oбобщение
Ядрото е страхотен инструмент за трансформиране на нелинейни данни в (почти) линейни. Недостатъкът на този метод е, че отнема много време и е скъп.
По-долу можете да намерите най-важния код за обучение на класификатор на ядрото
Задайте високоразмерната функция на ядрото
- input_dim = 14
- изходен_дим = 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)
