Kernel Gaussiano em Aprendizado de Máquina: Exemplos de Métodos de Kernel

O objetivo deste tutorial é tornar um conjunto de dados linearmente separável. O tutorial é dividido em duas partes:

1. Transformação de recursos
2. Treine um classificador de Kernel com Tensorflow

Na primeira parte, você entenderá a ideia por trás de um método Kernel no Machine Learning, enquanto na segunda parte, você verá como treinar um classificador de kernel com Tensorflow. Você usará o conjunto de dados adulto. O objetivo deste conjunto de dados é classificar a receita abaixo e acima de 50k, conhecendo o comportamento de cada família.

Neste tutorial, você aprenderá-

• Por que você precisa de métodos de kernel?
• O que é um Kernel no aprendizado de máquina?
• Tipos de métodos de kernel
• Treine o classificador de kernel gaussiano com TensorFlow

Por que você precisa de métodos de kernel?

O objetivo de todo classificador é prever as classes corretamente. Para isso, o conjunto de dados deve ser separável. Veja o gráfico abaixo; é bastante simples ver que todos os pontos acima da linha preta pertencem à primeira classe e os outros pontos à segunda classe. No entanto, é extremamente raro ter um conjunto de dados tão simples. Na maioria dos casos, os dados não são separáveis. Os métodos de kernel no Machine Learning dificultam classificadores ingênuos, como uma regressão logística.

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

Na figura abaixo, traçamos um conjunto de dados que não é linearmente separável. Se traçarmos uma linha reta, a maioria dos pontos não será classificada na classe correta.

Uma maneira de resolver esse problema é pegar o conjunto de dados e transformá-los em outro mapa de recursos. Isso significa que você usará uma função para transformar os dados em outro plano, que deve ser linear.

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

Os dados da figura acima estão em um plano de kernel gaussiano 2D que não é separável. Você pode tentar transformar esses dados em uma dimensão tridimensional, ou seja, você cria uma figura com 3 eixos.

Em nosso exemplo de kernel gaussiano, aplicaremos um mapeamento polinomial para trazer nossos dados a uma dimensão 3D. A fórmula para transformar os dados é a seguinte.

Você define uma função no Gaussian Kernel Python para criar os novos mapas de recursos

Você pode usar numpy para codificar a fórmula acima:

Fórmula	Código Numpy Equivalente
x	x [:, 0] **
y	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

O novo mapeamento deve ser com 3 dimensões com 16 pontos

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Vamos fazer um novo gráfico com 3 eixos, x, y e z respectivamente.

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

Vemos uma melhoria, mas se mudarmos a orientação do gráfico, é claro que o conjunto de dados agora é separável

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

Para manipular um grande conjunto de dados e talvez seja necessário criar mais de 2 dimensões, você enfrentará um grande problema usando o método acima. Na verdade, você precisa transformar todos os pontos de dados, o que claramente não é sustentável. Isso levará muito tempo e seu computador pode ficar sem memória.

A maneira mais comum de superar esse problema é usar um kernel .

O que é um Kernel no aprendizado de máquina?

A ideia é usar um espaço de recurso de dimensão superior para tornar os dados quase linearmente separáveis, conforme mostrado na figura acima.

Existem muitos espaços dimensionais superiores para tornar os pontos de dados separáveis. Por exemplo, mostramos que o mapeamento polinomial é um ótimo começo.

Também demonstramos que, com muitos dados, essas transformações não são eficientes. Em vez disso, você pode usar uma função Kernel no Machine Learning para modificar os dados sem mudar para um novo plano de recursos.

A mágica do kernel é encontrar uma função que evite todos os problemas implícitos na computação de alta dimensão. O resultado de um kernel é um escalar, ou dito de outra forma, estamos de volta ao espaço unidimensional

Depois de encontrar essa função, você pode conectá-la ao classificador linear padrão.

Vamos ver um exemplo para entender o conceito de Kernel Machine Learning. Você tem dois vetores, x1 e x2. O objetivo é criar uma dimensão superior usando um mapeamento polinomial. A saída é igual ao produto escalar do novo mapa de recursos. Pelo método acima, você precisa:

1. Transforme x1 e x2 em uma nova dimensão
2. Calcule o produto escalar: comum a todos os kernels
3. Transforme x1 e x2 em uma nova dimensão

Você pode usar a função criada acima para calcular a dimensão superior.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1) 

Resultado

[[ 9. 100. ][ 25.45584412 141.42135624][ 36. 100. ]] 

Calcule o produto escalar

Você pode usar o objeto ponto de numpy para calcular o produto escalar entre o primeiro e o segundo vetor armazenado em x_1.

print(np.dot(x_1[:,0], x_1[:,1]))8100.0 

A saída é 8100. Você vê o problema, você precisa armazenar na memória um novo mapa de recursos para calcular o produto escalar. Se você tem um conjunto de dados com milhões de registros, é computacionalmente ineficaz.

Em vez disso, você pode usar o kernel polinomial para calcular o produto escalar sem transformar o vetor. Esta função calcula o produto escalar de x1 e x2 como se esses dois vetores tivessem sido transformados na dimensão superior. Dito de outra forma, uma função kernel calcula os resultados do produto escalar de outro espaço de recursos.

Você pode escrever a função do kernel polinomial em Python da seguinte maneira.

def polynomial_kernel(x, y, p=2):return (np.dot(x, y)) ** p 

É o poder do produto escalar de dois vetores. Abaixo, você retorna o segundo grau do kernel polinomial. A saída é igual ao outro método. Essa é a magia do kernel.

polynomial_kernel(x1, x2, p=2)8100 

Tipos de métodos de kernel

Existem várias técnicas diferentes de Kernel disponíveis. O mais simples é o kernel linear. Esta função funciona muito bem para classificação de texto. O outro kernel é:

• Núcleo polinomial
• Kernel Gaussiano

No exemplo com TensorFlow, usaremos o Random Fourier. O TensorFlow tem um estimador integrado para calcular o novo espaço de recursos. A função de filtro gaussiana é uma aproximação da função kernel gaussiana.

A função de filtragem gaussiana calcula a similaridade entre os pontos de dados em um espaço dimensional muito mais alto.

Treine o classificador de kernel gaussiano com TensorFlow

O objetivo do algoritmo é classificar o agregado familiar que ganha mais ou menos de 50k.

Você vai avaliar um aprendizado de máquina de regressão logística do kernel para ter um modelo de benchmark. Depois disso, você treinará um classificador de Kernel para ver se consegue melhores resultados.

Você usa as seguintes variáveis ​​do conjunto de dados adulto:

• idade
• classe de trabalho
• fnlwgt
• Educação
• educação_num
• conjugal
• ocupação
• relação
• raça
• sexo
• Ganho de capital
• capital_loss
• horas_semana
• país nativo
• rótulo

Você vai proceder da seguinte forma antes de treinar e avaliar o modelo:

• Etapa 1) Importar as bibliotecas
• Etapa 2) Importar os dados
• Etapa 3) Prepare os dados
• Etapa 4) Construir o input_fn
• Etapa 5) Construir o modelo logístico: modelo de linha de base
• Etapa 6) Avalie o modelo
• Etapa 7) Construir o classificador de kernel
• Etapa 8) Avalie o classificador de kernel

Etapa 1) Importar as bibliotecas

Para importar e treinar modelos de Kernel em Inteligência Artificial, você precisa importar tensorflow, pandas e numpy

#import numpy as npfrom sklearn.model_selectionimport train_test_splitimport tensorflow as tfimport pandas as pdimport numpy as np

Etapa 2) Importar os dados

Você baixa os dados do site a seguir e os importa como um dataframe 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) 

Agora que o trem e o conjunto de teste estão definidos, você pode alterar o rótulo da coluna de string para inteiro. tensorflow não aceita valor de string para o rótulo.

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)

Etapa 3) Prepare os dados

O conjunto de dados contém recursos contínuos e categóricos. Uma boa prática é padronizar os valores das variáveis ​​contínuas. Você pode usar a função StandardScaler do sci-kit learn. Você também cria uma função definida pelo usuário para facilitar a conversão do trem e do conjunto de teste. Observe que, você concatena as variáveis ​​contínuas e categóricas em um conjunto de dados comum e a matriz deve ser do tipo: 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 

A função de transformador está pronta, você pode converter o conjunto de dados e criar a função 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) 

Na próxima etapa, você treinará uma regressão logística. Isso lhe dará uma precisão de linha de base. O objetivo é superar a linha de base com um algoritmo diferente, ou seja, um classificador de Kernel.

Etapa 4) Construir o modelo logístico: modelo de linha de base

Você constrói a coluna de feições com o objeto real_valued_column. Isso garantirá que todas as variáveis ​​sejam dados numéricos densos.

feat_column = tf.contrib.layers.real_valued_column('features', dimension=14) 

O estimador é definido usando TensorFlow Estimator, você instrui as colunas de recursos e onde salvar o gráfico.

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} 

Você treinará a regressão logística usando minilotes de tamanho 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) 

Você pode treinar o modelo com 1.000 iterações

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.

Etapa 6) Avalie o modelo

Você define o estimador numpy para avaliar o modelo. Você usa todo o conjunto de dados para avaliação

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

Você tem uma precisão de 82 por cento. Na próxima seção, você tentará superar o classificador logístico com um classificador de Kernel

Etapa 7) Construir o classificador de kernel

O estimador de kernel não é tão diferente do classificador linear tradicional, pelo menos em termos de construção. A ideia por trás disso é usar o poder do kernel explícito com o classificador linear.

Você precisa de dois estimadores predefinidos disponíveis no TensorFlow para treinar o classificador de kernel:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Você aprendeu na primeira seção que precisa transformar a dimensão baixa em uma dimensão alta usando uma função kernel. Mais precisamente, você usará o Random Fourier, que é uma aproximação da função gaussiana. Felizmente, o Tensorflow tem a função em sua biblioteca: RandomFourierFeatureMapper. O modelo pode ser treinado usando o estimador KernelLinearClassifier.

Para construir o modelo, você seguirá estas etapas:

1. Defina a função de kernel de alta dimensão
2. Defina o hiperparâmetro L2
3. Construir o modelo
4. Treine o modelo
5. Avalie o modelo

Etapa A) Definir a função de kernel de alta dimensão

O conjunto de dados atual contém 14 recursos que você transformará em uma nova dimensão elevada do vetor de 5.000 dimensões. Você usa os recursos aleatórios de Fourier para realizar a transformação. Se você se lembrar da fórmula do kernel gaussiano, notará que há o parâmetro de desvio padrão a ser definido. Este parâmetro controla a medida de similaridade empregada durante a classificação.

Você pode ajustar todos os parâmetros em RandomFourierFeatureMapper com:

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

Você precisa construir o mapeador de kernel usando as colunas de recursos criadas antes: feat_column

### Map Kernelkernel_mappers = {feat_column: [kernel_mapper]} 

Etapa B) Definir o hiperparâmetro L2

Para evitar overfitting, você penaliza a função de perda com o regularizador L2. Você define o hiperparâmetro L2 para 0,1 e a taxa de aprendizagem para 5

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

Etapa C) Construir o modelo

A próxima etapa é semelhante à classificação linear. Use o estimador integrado KernelLinearClassifier. Observe que você adiciona o mapeador de kernel definido anteriormente e altera o diretório do modelo.

### 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'}

Etapa D) Treine o modelo

Agora que o classificador de Kernel está construído, você está pronto para treiná-lo. Você escolhe iterar 2.000 vezes o modelo

### 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): []}}) 

Etapa E) Avalie o modelo

Por último, mas não menos importante, você avalia o desempenho do seu modelo. Você deve ser capaz de vencer a regressão logística.

# 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

A precisão final é de 84%, é uma melhoria de 2% em relação à regressão logística. Existe uma compensação entre a melhoria da precisão e o custo computacional. Você precisa pensar se a melhoria de 2% compensa o tempo consumido pelos diferentes classificadores e se ela tem um impacto convincente em seus negócios.

Resumo

Um kernel é uma ótima ferramenta para transformar dados não lineares em (quase) lineares. A deficiência desse método é demorada e cara do ponto de vista computacional.

Abaixo, você pode encontrar o código mais importante para treinar um classificador de kernel

Defina a função de kernel de alta dimensão

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

Defina o hiperparâmetro L2

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

Construir o modelo

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train") 

Treine o modelo

estimator_kernel.fit(input_fn=train_input_fn, steps=2000) 

Avalie o modelo

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)