Kernel Gaussiano em Aprendizado de Máquina: Python Métodos do kernel

Por: Evelyn Clarke Evelyn Clarke
Hours Atualização do

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

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

Na primeira parte, você entenderá a ideia por trás de um método Kernel em Machine Learning, enquanto na segunda parte 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 domicílio.

Por que você precisa de métodos 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 em aprendizado de máquina dificultam classificadores ingênuos, como uma regressão logística.

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

Método Kernel

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

Uma maneira de resolver esse problema é pegar o conjunto de dados e transformá-los em outro mapa de características. Ou seja, 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()

Método Kernel

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 três dimensões, ou seja, você cria uma figura com 3 eixos.

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

Método Kernel

Você define uma função no Kernel Gaussiano 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]
x2 x[:,0]**2
Método Kernel 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

O novo mapeamento deverá 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.

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

Método Kernel

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

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

Método Kernel

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

A maneira mais comum de superar esse problema é usar um núcleo.

ARTIGOS RELACIONADOS

O que é um kernel em aprendizado de máquina?

A ideia é usar um espaço de recursos 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 esta função, você pode conectá-la ao classificador linear padrão.

Vejamos 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. A partir do 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.

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

saída

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

Calcule o produto escalar

Você pode usar o objeto dot from 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ê tiver um conjunto de dados com milhões de registros, ele será computacionalmente ineficaz.

Em vez disso, você pode usar o núcleo 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 polinomial do kernel em Python como se segue.

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

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

polynomial_kernel(x1, x2, p=2)			
8100

Tipos de métodos de kernel

Existem muitas 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 Fourier Aleatório. 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.

Tipos de métodos de kernel

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

Treine o classificador Gaussian Kernel com TensorFlow

O objetivo do algoritmo é classificar a família que ganha mais ou menos que 50 mil.

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

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

  • idade
  • classe de trabalho
  • fnlwgt
  • educação
  • número_educação
  • marital
  • ocupação
  • relacionamento
  • raça
  • sexo
  • Ganho de capital
  • perda_capital
  • horas_semana
  • país nativo
  • rótulo

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

  • Passo 1) Importe as bibliotecas
  • Etapa 2) Importe os dados
  • Etapa 3) Prepare os dados
  • Etapa 4) Construa 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 Kernel
  • Etapa 8) Avalie o classificador Kernel

Passo 1) Importar as bibliotecas

Para importar e treinar modelos Kernel em Inteligência artificial, você precisa importar o tensorflow, pandas e entorpecido

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Passo 2) Importar os dados

Você baixa os dados do seguinte site do produto e você o importa como um dataframe do 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)

Agora que o conjunto de treinamento e 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)

Passo 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 conjunto de treinamento e teste. Observe que você concatena as variáveis ​​​​contínuas e categóricas a um conjunto de dados comum e o array 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 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

A função transformadora 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 básica. O objetivo é superar a linha de base com um algoritmo diferente, ou seja, um classificador Kernel.

Passo 4) Construa o modelo logístico: modelo de linha de base

Você constrói a coluna de recursos 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 o 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': <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}

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

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 = 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>

Passo 6) Avalie o modelo

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

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

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

Passo 7) Construa o classificador Kernel

O estimador kernel não é tão diferente do classificador linear tradicional, pelo menos em termos de construção. A ideia por trás é 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 Kernel:

  • RandomFourierFeatureMapper
  • KernelLinearClassificador

Você aprendeu na primeira seção que precisa transformar a dimensão baixa em uma dimensão alta usando uma função de kernel. Mais precisamente, você usará o Random Fourier, que é uma aproximação da função gaussiana. Felizmente, o Tensorflow possui 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 Kernel de alta dimensão
  2. Defina o hiperparâmetro L2
  3. Construa o modelo
  4. Treine o modelo
  5. Avalie o modelo

Etapa A) Defina a função 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 obter a transformação. Se você se lembrar da fórmula do Kernel Gaussiano, notará que existe 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:

  • entrada_dim = 14
  • saída_dim= 5000
  • desvio padrão = 4
### Prep Kernel
kernel_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 Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

Etapa B) Defina o hiperparâmetro L2

Para evitar overfitting, você penaliza a função de perda com o regularizador L2. Você define o hiperparâmetro L2 como 0.1 e a taxa de aprendizado como 5

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

Etapa C) Construa o modelo

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

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

Etapa D) Treine o modelo

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

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

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

A precisão final é de 84%, é uma melhoria de 2% em relação à regressão logística. Existe uma compensação entre melhoria de precisão e custo computacional. Você precisa pensar se a melhoria de 2% vale o tempo consumido pelo classificador diferente e se tem um impacto convincente em seu negócio.

Resumo

Um kernel é uma ótima ferramenta para transformar dados não lineares em (quase) lineares. A desvantagem deste método é que ele consome muito tempo e é caro do ponto de vista computacional.

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

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

  • entrada_dim = 14
  • saída_dim= 5000
  • desvio padrão = 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)

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

Você pode gostar: