Como os métodos de kernel se comparam às redes neurais?

Um método de kernel corrige o mapa de características.ping A rede neural aprende antecipadamente apenas os pesos lineares, o que permite um treinamento rápido mesmo com uma quantidade modesta de dados. Uma rede neural aprende sua própria representação, o que resulta em melhor escalabilidade para conjuntos de dados muito grandes e não estruturados, como imagens.

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

⚡ Resumo Inteligente

Os métodos de kernel gaussiano tornam dados não separáveis linearmente separáveis sem nunca construir o mapa de características de alta dimensão. Este passo a passo mostra o mapa polinomial.ping manualmente e, em seguida, treina um classificador de kernel de Fourier aleatório no TensorFlow.

🔘 Problema de separabilidade: Os classificadores lineares falham sempre que não houver uma linha reta que divida as classes no espaço de características original.
☑️ mapa polinomialping: A transformação para x ao quadrado, raiz quadrada de dois xy e y ao quadrado eleva duas dimensões em três e separa os dados da amostra.
✅ Truque do kernel: Um kernel retorna o produto escalar dos vetores mapeados diretamente, portanto, nenhum mapa de características expandido é armazenado.
🧪 Três grãos: Funções lineares são adequadas para classificação de texto, funções polinomiais capturam interações entre características e a função de base radial gaussiana mede a similaridade com base na distância.
🛠️ Compilação do TensorFlow: O RandomFourierFeatureMapper projeta 14 características em 5,000 dimensões antes do KernelLinearClassifier ser treinado com um otimizador Ftrl.
📈 Resultado medido: O classificador de kernel atinge uma precisão de 0.83975184, em comparação com 0.82353663 para a linha de base logística.

Saiba Mais

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

Transformação de recursos
Treine um classificador Kernel com TensorFlow

Na primeira parte, você entenderá a ideia por trás de um método Kernel em Aprendizado de Máquina, enquanto na segunda parte você verá como treinar um classificador Kernel com TensorFlowVocê usará o conjunto de dados de adultos. O objetivo deste conjunto de dados é classificar a renda abaixo e acima de 50 mil, 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. Observe o gráfico abaixo; é bastante simples ver que todos os pontos acima da linha preta pertencem à primeira classe e os demais pontos à segunda classe. No entanto, é extremamente raro encontrar um conjunto de dados tão simples. Na maioria dos casos, os dados não são separáveis, e dados não separáveis dificultam o trabalho de classificadores ingênuos como a 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], &#x27;k-', lw=2)
  ax.set_xlim([-5,15])
  ax.set_ylim([-5,15])plt.show()

Na figura abaixo, representamos graficamente 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 lidar com esse problema é pegar o conjunto de dados e transformá-lo em outro mapa de características. Isso significa usar uma função para mover os dados para outro plano, que deve ser linearmente separável.

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 2D e não são separáveis. Você pode tentar transformar esses dados em três dimensões, o que significa criar uma figura com 3 eixos.

Em nosso exemplo de Kernel Gaussiano, aplicaremos um mapeamento polinomial.ping Para trazer nossos dados para uma terceira dimensão, a fórmula para transformar os dados é a seguinte.

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. Cada linha abaixo emparelha um termo do mapa.ping com a expressão matricial que a produz, e a pequena imagem marca a raiz quadrada de dois fatores.

Fórmula	Código NumPy equivalente
x	x[:,0]
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	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 mapaping Possui 3 dimensões e 16 pontos.

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Agora crie um novo gráfico com 3 eixos, x, y e z respectivamente.

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection=&#x27;3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')
plt.show()

Observamos uma melhoria, mas se alterarmos 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=&#x27;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(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')plt.show()

Se você precisar manipular um conjunto de dados grande e criar mais de duas dimensões, enfrentará um grande problema com o método acima. Na verdade, você precisa transformar todos os pontos de dados, o que claramente não é sustentável. Levará uma eternidade e seu computador poderá ficar sem memória.

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

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

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

Existem muitos espaços de dimensões superiores que tornam os pontos de dados separáveis. Por exemplo, mostramos que o mapa polinomialping é um ótimo começo.

Também demonstramos que, com grandes volumes de dados, essas transformações não são eficientes. Em vez disso, você pode usar uma função Kernel em Aprendizado de Máquina para modificar os dados sem precisar migrar para um novo plano de características.

A mágica do kernel reside em encontrar uma função que evite todos os problemas inerentes à computação de alta dimensionalidade. O resultado de um kernel é um escalar, ou, dito de outra forma, retornamos ao espaço unidimensional.

Depois de encontrar essa função, você pode inseri-la no classificador linear padrão.

Aqui está um exemplo que torna o conceito de Aprendizado de Máquina com Kernel concreto. Você tem dois vetores, x1 e x2. O objetivo é criar uma dimensão superior usando um mapeamento polinomial.pingO resultado é igual ao produto escalar do novo mapa de características. A partir do método acima, você precisa:

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

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 ponto de objeto de NumPy para calcular o produto escalar entre o primeiro e o segundo vetor armazenados em x_1.

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

O resultado é 8100. Veja o problema: você precisa armazenar um novo mapa de características na memória para calcular o produto escalar. Se você tiver um conjunto de dados com milhões de registros, isso se torna computacionalmente ineficiente.

Em vez disso, você pode usar o kernel polinomial para calcular o produto escalar sem transformar o vetor. Essa função calcula o produto escalar de x1 e x2 como se esses dois vetores tivessem sido transformados para a dimensão superior. Dito de outra forma, uma função kernel calcula o resultado do produto escalar a partir de outro espaço de características.

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

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 diversas técnicas de kernel disponíveis. A mais simples é o kernel linear. Essa função funciona muito bem para classificação de texto. Os outros kernels são:

núcleo polinomial
Kernel Gaussiano

A tabela abaixo resume a função de cada um e quando os profissionais recorrem a eles.

Núcleo	O que ele calcula	Uso típico
Linear	O produto escalar simples no espaço de características original	Dados já separáveis e características de texto de alta dimensão
Polinomial	O produto escalar elevado a um grau p, capturando interações de características.	Fronteiras curvas quando se sabe que as interações importam
Gaussiana (RBF)	Uma similaridade baseada na distância que tende a zero à medida que os pontos se afastam.	A primeira escolha usual quando a forma do limite é desconhecida.

No exemplo com TensorFlow, usaremos características de Fourier aleatórias. O TensorFlow possui um estimador integrado para calcular o novo espaço de características. O mapeador de características de Fourier aleatórias é uma aproximação da função kernel gaussiana mostrada abaixo.

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

Com a teoria estabelecida, o restante deste passo a passo coloca um kernel gaussiano para funcionar em um conjunto de dados reais.

Treine o classificador Gaussian Kernel com TensorFlow

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

Primeiramente, você avaliará uma regressão logística para obter um modelo de referência. Em seguida, treinará um classificador Kernel para verificar 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

Antes de treinar e avaliar o modelo, você deverá proceder da seguinte forma:

Importar as bibliotecas
Importar os dados
Prepare os dados
Construir o modelo logístico: modelo de base
Avalie o modelo
Construa e avalie o classificador Kernel.

Nota de versão: Cada trecho de código abaixo é direcionado ao TensorFlow 1.x. O namespace tf.contrib, que fornece as classes real_valued_column, RandomFourierFeatureMapper e KernelLinearClassifier, foi removido no TensorFlow 2.0, e o próprio namespace tf.estimator foi removido no TensorFlow 2.16. Em uma versão atual, compile o mesmo pipeline com a camada tf.keras.layers.experimental.RandomFourierFeatures seguida por uma camada de saída Dense, ou com o par RBFSampler e SGDClassifier do scikit-learn.

Passo 1) Importe as bibliotecas

Para importar e treinar modelos Kernel em Inteligência artificialVocê precisa importar o TensorFlow. pandas e 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

Etapa 2) Importe os dados

Você baixa os dados do Página do conjunto de dados de adultos da UCI e importe-o como um DataFrame do pandas.

## Define path data
COLUMNS = [&#x27;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 os conjuntos de treino e teste estão definidos, você pode alterar o rótulo da coluna de string para inteiro. O TensorFlow não aceita valores de string para o rótulo.

label = {&#x27;<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {&#x27;<=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 variáveis contínuas e categóricas. Uma boa prática é padronizar os valores das variáveis contínuas. Você pode usar a função `StandardScaler` do pacote `package.json`. scikit-learnVocê também cria uma função definida pelo usuário para facilitar a conversão dos conjuntos de treino e teste. Observe que você concatena as variáveis contínuas e categóricas em um conjunto de dados comum, e o array deve ser do tipo float32.

COLUMNS_INT = [&#x27;age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']
CATE_FEATURES = [&#x27;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[&#x27;label'].astype(np.int32)    
    X_conc = np.c_[df_scaled, X_1].astype(np.float32)				
    return X_conc, y

A função de transformação está pronta, então 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.

Etapa 4) Construir 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(&#x27;features', dimension=14)

O estimador é definido usando a API TensorFlow Estimator; você fornece as colunas de recursos e o local para 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: {&#x27;_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 mini-lotes 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>

Etapa 5) Avalie o modelo

Você define a função de entrada NumPy para avaliar o modelo. Você usa todo o conjunto de teste para a 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

{&#x27;accuracy': 0.82353663,
 &#x27;accuracy_baseline': 0.76377374,
 &#x27;auc': 0.84898686,
 &#x27;auc_precision_recall': 0.67214864,
 &#x27;average_loss': 0.3877216,
 &#x27;global_step': 1000,
 &#x27;label/mean': 0.23622628,
 &#x27;loss': 6312.495,
 &#x27;precision': 0.7362797,
 &#x27;prediction/mean': 0.21208474,
 &#x27;recall': 0.39417577}

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

Etapa 6) Construir o classificador 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 dele é combinar o poder de um mapeamento de kernel explícito.ping com o classificador linear.

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

RandomFourierFeatureMapper
KernelLinearClassificador

Na primeira seção, você aprendeu que precisa transformar uma dimensão baixa em uma dimensão alta usando uma função kernel. Mais precisamente, você usará características aleatórias de Fourier, que aproximam a função gaussiana. O TensorFlow 1.x fornece esse mapeamento.ping como RandomFourierFeatureMapper, e o modelo pode ser treinado usando o estimador KernelLinearClassifier.

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

Defina a função Kernel de alta dimensão
Defina o hiperparâmetro L2
Construa o modelo
Treine o modelo
Avalie o modelo

Etapa A) Defina a função Kernel de alta dimensão

O conjunto de dados atual contém 14 características que você transformará em um novo vetor de 5,000 dimensões. Você usará as características aleatórias de Fourier para realizar a transformação. Se você se lembra da fórmula do Kernel Gaussiano, deve ter notado que há um parâmetro de desvio padrão a ser definido. Esse parâmetro controla a medida de similaridade usada durante a classificação: um desvio padrão pequeno faz com que o kernel trate apenas pontos muito próximos como similares, enquanto um desvio padrão grande suaviza a fronteira de decisão.

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

entrada_dim = 14
dimensão_saída = 5000
desvio padrão = 4

### Prep Kernel
kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name=&#x27;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 o sobreajuste, 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) Construir o modelo

O próximo passo é 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")

Os avisos de obsolescência abaixo são esperados no TensorFlow 1.x, pois o módulo kernel_methods é baseado nos estimadores mais antigos do tf.contrib.learn.

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: {&#x27;_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
}
, &#x27;_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) Treinar o modelo

Agora que o classificador Kernel está construído, você está pronto para treiná-lo. Você opta por iterar o modelo 2,000 vezes.

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

WARNING:tensorflow:Casting <dtype: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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={&#x27;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: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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%, cerca de 1.6 ponto percentual acima da linha de base da regressão logística (0.83975184 contra 0.82353663). Existe uma relação de compromisso entre a melhoria da precisão e o custo computacional. Você precisa avaliar se essa melhoria compensa o tempo gasto pelo classificador mais complexo e se ela terá um impacto significativo em seu negócio.

Perguntas Frequentes

O truque do kernel calcula o produto escalar que dois vetores teriam após uma transformação de alta dimensão.ping, sem nunca construir esse mapapingA função polynomial_kernel neste tutorial retorna diretamente 8100, o mesmo valor produzido pela transformação tridimensional explícita.

Não. O tf.contrib foi removido no TensorFlow 2.0 e o tf.estimator no 2.16, portanto, real_valued_column, RandomFourierFeatureMapper e KernelLinearClassifier não estão mais disponíveis. Use a camada tf.keras.layers.experimental.RandomFourierFeatures com uma saída Dense ou RBFSampler com SGDClassifier.

As ferramentas de busca automatizadas examinam o tipo de kernel, o grau, o valor gama ou o desvio padrão e a intensidade da regularização em execuções paralelas e, em seguida, classificam-nos por pontuação de validação cruzada. Elas transformam a seleção de kernel em uma comparação mensurável, embora você ainda defina o orçamento de busca e a métrica de pontuação.

Ele cria rapidamente a estrutura básica: dimensionamento de recursos, chamada do mapeador, estimador e loop de avaliação. Considere as sugestões como uma primeira versão, porque Copiloto do GitHub Reproduz facilmente APIs removidas do TensorFlow 1.x que não são mais importadas nas versões atuais.

Define a largura da curva de similaridade. Um desvio padrão pequeno faz com que apenas pontos muito próximos sejam considerados similares, produzindo um limite estreito e irregular que pode levar ao sobreajuste. Um desvio padrão grande suaviza o limite e aproxima o modelo de um ajuste linear.

É o número de características de Fourier aleatórias usadas para aproximar o kernel gaussiano. Mais características aproximam o kernel mais precisamente e geralmente aumentam a acurácia, ao custo de um vetor de pesos mais amplo e um treinamento mais lento em cada lote.

Um método de kernel exato compara cada par de pontos de treinamento, portanto o custo cresce aproximadamente com o quadrado da quantidade de amostras. As características de Fourier aleatórias contornam isso aproximando o kernel com uma projeção de largura fixa.

Um método de kernel corrige o mapa de características.ping antecipadamente e aprende apenas os pesos lineares, por isso treina rapidamente com dados modestos. rede neural Aprende sua própria representação, que se adapta melhor a conjuntos de dados muito grandes e não estruturados, como imagens.

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

Por que você precisa de métodos Kernel?

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

Transforme x1 e x2 em uma nova dimensão

Calcule o produto escalar

Tipos de métodos de kernel

Treine o classificador Gaussian Kernel com TensorFlow

Passo 1) Importe as bibliotecas

Etapa 2) Importe os dados

Etapa 3) Prepare os dados

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

Etapa 5) Avalie o modelo

Etapa 6) Construir o classificador Kernel

Etapa A) Defina a função Kernel de alta dimensão

Etapa B) Defina o hiperparâmetro L2

Etapa C) Construir o modelo

Etapa D) Treinar o modelo

Etapa E) Avalie o modelo

Perguntas Frequentes

Resuma esta postagem com:

Assine a newsletter

Por que você precisa de métodos Kernel?

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

Transforme x1 e x2 em uma nova dimensão

Calcule o produto escalar

ARTIGOS RELACIONADOS

Tipos de métodos de kernel

Treine o classificador Gaussian Kernel com TensorFlow

Passo 1) Importe as bibliotecas

Etapa 2) Importe os dados

Etapa 3) Prepare os dados

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

Etapa 5) Avalie o modelo

Etapa 6) Construir o classificador Kernel

Etapa A) Defina a função Kernel de alta dimensão

Etapa B) Defina o hiperparâmetro L2

Etapa C) Construir o modelo

Etapa D) Treinar o modelo

Etapa E) Avalie o modelo

Perguntas Frequentes

Resuma esta postagem com:

Assine a newsletter