Kernel gaussiano en el aprendizaje automático: ejemplos de métodos de kernel

El propósito de este tutorial es hacer un conjunto de datos separable linealmente. El tutorial se divide en dos partes:

1. Transformación de características
2. Entrena un clasificador de kernel con Tensorflow

En la primera parte, comprenderá la idea detrás de un método Kernel en Machine Learning, mientras que en la segunda parte, verá cómo entrenar un clasificador de kernel con Tensorflow. Utilizará el conjunto de datos para adultos. El objetivo de este conjunto de datos es clasificar los ingresos por debajo y por encima de 50k, conociendo el comportamiento de cada hogar.

En este tutorial aprenderás

• ¿Por qué necesita los métodos Kernel?
• ¿Qué es un kernel en el aprendizaje automático?
• Tipos de métodos de kernel
• Entrenar el clasificador del kernel gaussiano con TensorFlow

¿Por qué necesita los métodos Kernel?

El objetivo de todo clasificador es predecir las clases correctamente. Para eso, el conjunto de datos debe ser separable. Mira el diagrama de abajo; Es bastante sencillo ver que todos los puntos por encima de la línea negra pertenecen a la primera clase y los otros puntos a la segunda clase. Sin embargo, es extremadamente raro tener un conjunto de datos tan simple. En la mayoría de los casos, los datos no son separables. Los métodos de kernel en Machine Learning hacen que los clasificadores ingenuos como una regresión logística sean un momento difícil.

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

En la siguiente figura, trazamos un conjunto de datos que no es separable linealmente. Si trazamos una línea recta, la mayoría de los puntos no se clasificarán en la clase correcta.

Una forma de abordar este problema es tomar el conjunto de datos y transformar los datos en otro mapa de características. Es decir, utilizará una función para transformar los datos en otro plan, que debería ser linealizable.

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

Los datos de la figura anterior están en un plan de kernel gaussiano 2D que no es separable. Puedes intentar transformar estos datos en una dimensión tridimensional, es decir, creas una figura con 3 ejes.

En nuestro ejemplo de kernel gaussiano, aplicaremos un mapeo polinomial para llevar nuestros datos a una dimensión 3D. La fórmula para transformar los datos es la siguiente.

Defina una función en Gaussian Kernel Python para crear los nuevos mapas de características

Puede usar numpy para codificar la fórmula anterior:

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

El nuevo mapeo debería ser de 3 dimensiones con 16 puntos.

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Hagamos una nueva gráfica con 3 ejes, x, y y 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 una mejora, pero si cambiamos la orientación de la gráfica, está claro que el conjunto de datos ahora es separable.

# 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 un conjunto de datos grande y es posible que deba crear más de 2 dimensiones, se enfrentará a un gran problema con el método anterior. De hecho, necesita transformar todos los puntos de datos, lo que claramente no es sostenible. Le llevará años y su computadora puede quedarse sin memoria.

La forma más común de solucionar este problema es utilizar un kernel .

¿Qué es un kernel en el aprendizaje automático?

La idea es utilizar un espacio de características de mayor dimensión para hacer que los datos sean casi linealmente separables, como se muestra en la figura anterior.

Hay muchos espacios de dimensiones superiores para que los puntos de datos sean separables. Por ejemplo, hemos demostrado que el mapeo de polinomios es un gran comienzo.

También hemos demostrado que con muchos datos, esta transformación no es eficiente. En su lugar, puede usar una función de Kernel en Machine Learning para modificar los datos sin cambiar a un nuevo plan de funciones.

La magia del kernel es encontrar una función que evite todos los problemas que implica el cálculo de alta dimensión. El resultado de un kernel es un escalar, o dicho de otra manera, volvemos al espacio unidimensional.

Después de encontrar esta función, puede conectarla al clasificador lineal estándar.

Veamos un ejemplo para entender el concepto de Kernel Machine Learning. Tienes dos vectores, x1 y x2. El objetivo es crear una dimensión superior mediante el uso de un mapeo polinomial. La salida es igual al producto escalar del nuevo mapa de características. Desde el método anterior, necesita:

1. Transforma x1 y x2 en una nueva dimensión
2. Calcule el producto escalar: común a todos los núcleos
3. Transforma x1 y x2 en una nueva dimensión

Puede utilizar la función creada anteriormente para calcular la dimensión superior.

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

Producción

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

Calcule el producto escalar

Puede usar el punto del objeto de numpy para calcular el producto escalar entre el primer y el segundo vector almacenados en x_1.

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

La salida es 8100. Si ve el problema, necesita almacenar en la memoria un nuevo mapa de características para calcular el producto escalar. Si tiene un conjunto de datos con millones de registros, es computacionalmente ineficaz.

En su lugar, puede usar el núcleo polinomial para calcular el producto escalar sin transformar el vector. Esta función calcula el producto escalar de x1 y x2 como si estos dos vectores se hubieran transformado en la dimensión superior. Dicho de otra manera, una función del núcleo calcula los resultados del producto escalar de otro espacio de características.

Puede escribir la función del núcleo polinomial en Python de la siguiente manera.

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

Es la potencia del producto escalar de dos vectores. A continuación, devuelve el segundo grado del núcleo polinomial. La salida es igual a la del otro método. Esta es la magia del kernel.

polynomial_kernel(x1, x2, p=2)8100 

Tipos de métodos de kernel

Hay muchas técnicas diferentes de Kernel disponibles. El más simple es el núcleo lineal. Esta función funciona bastante bien para la clasificación de texto. El otro núcleo es:

• Núcleo polinomial
• Kernel gaussiano

En el ejemplo con TensorFlow, usaremos Random Fourier. TensorFlow tiene un estimador integrado para calcular el nuevo espacio de funciones. La función de filtro de Gauss es una aproximación de la función del núcleo de Gauss.

La función de filtrado gaussiano calcula la similitud entre los puntos de datos en un espacio dimensional mucho mayor.

Entrenar el clasificador del kernel gaussiano con TensorFlow

El objetivo del algoritmo es clasificar el hogar que gana más o menos de 50k.

Evaluará un aprendizaje automático de regresión de kernel logístico para tener un modelo de referencia. Después de eso, entrenará un clasificador de Kernel para ver si puede obtener mejores resultados.

Utiliza las siguientes variables del conjunto de datos de adultos:

• edad
• clase de trabajo
• fnlwgt
• educación
• número_educación
• marital
• ocupación
• relación
• raza
• sexo
• ganancia capital
• perdida de capital
• hours_week
• patria
• etiqueta

Procederá de la siguiente manera antes de entrenar y evaluar el modelo:

• Paso 1) Importar las bibliotecas
• Paso 2) Importa los datos
• Paso 3) Prepare los datos
• Paso 4) Construya el input_fn
• Paso 5) Construya el modelo logístico: modelo de línea de base
• Paso 6) Evaluar el modelo
• Paso 7) Construya el clasificador de kernel
• Paso 8) Evaluar el clasificador de kernel

Paso 1) Importar las bibliotecas

Para importar y entrenar modelos de Kernel en Inteligencia Artificial, necesita importar tensorflow, pandas y numpy

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

Paso 2) Importa los datos

Descarga los datos del siguiente sitio web y los importa como un marco de datos 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) 

Ahora que el tren y el conjunto de prueba están definidos, puede cambiar la etiqueta de la columna de cadena a entero. tensorflow no acepta un valor de cadena para la etiqueta.

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)

Paso 3) Prepare los datos

El conjunto de datos contiene características continuas y categóricas. Una buena práctica es estandarizar los valores de las variables continuas. Puede utilizar la función StandardScaler de sci-kit learn. También crea una función definida por el usuario para facilitar la conversión del tren y el conjunto de prueba. Tenga en cuenta que, concatena las variables continuas y categóricas a un conjunto de datos común y la matriz debe ser del 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 

La función de transformador está lista, puede convertir el conjunto de datos y crear la función 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) 

En el siguiente paso, entrenará una regresión logística. Le dará una precisión de referencia. El objetivo es superar la línea de base con un algoritmo diferente, a saber, un clasificador de kernel.

Paso 4) Construya el modelo logístico: modelo de línea de base

Construye la columna de características con el objeto real_valued_column. Se asegurará de que todas las variables sean datos numéricos densos.

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

El estimador se define mediante el Estimador de TensorFlow, usted indica las columnas de características y dónde guardar el 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} 

Entrenará la regresión logística utilizando mini lotes de tamaño 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) 

Puedes entrenar el modelo con 1.000 iteraciones

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.

Paso 6) Evaluar el modelo

Define el estimador numpy para evaluar el modelo. Utiliza todo el conjunto de datos para la evaluación

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

Tiene una precisión del 82 por ciento. En la siguiente sección, intentará vencer al clasificador logístico con un clasificador de Kernel

Paso 7) Construya el clasificador de kernel

El estimador de kernel no es tan diferente del clasificador lineal tradicional, al menos en términos de construcción. La idea detrás es usar el poder del kernel explícito con el clasificador lineal.

Necesita dos estimadores predefinidos disponibles en TensorFlow para entrenar el clasificador de kernel:

• Al azarFourierFeatureMapper
• KernelLinearClassifier

Aprendió en la primera sección que necesita transformar la dimensión baja en una dimensión alta usando una función de kernel. Más precisamente, utilizará el Fourier aleatorio, que es una aproximación de la función gaussiana. Afortunadamente, Tensorflow tiene la función en su biblioteca: RandomFourierFeatureMapper. El modelo se puede entrenar utilizando el estimador KernelLinearClassifier.

Para construir el modelo, seguirá estos pasos:

1. Establecer la función Kernel de alta dimensión
2. Establecer el hiperparámetro L2
3. Construye el modelo
4. Entrena el modelo
5. Evaluar el modelo

Paso A) Establecer la función Kernel de alta dimensión

El conjunto de datos actual contiene 14 características que transformará a una nueva dimensión alta del vector de 5.000 dimensiones. Utiliza las características aleatorias de Fourier para lograr la transformación. Si recuerda la fórmula del kernel gaussiano, observará que hay que definir el parámetro de desviación estándar. Este parámetro controla la medida de similitud empleada durante la clasificación.

Puede ajustar todos los parámetros en RandomFourierFeatureMapper con:

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

Necesita construir el mapeador del kernel usando las columnas de características creadas antes: feat_column

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

Paso B) Establecer el hiperparámetro L2

Para evitar el sobreajuste, penaliza la función de pérdida con el regularizador L2. Establece el hiperparámetro L2 en 0,1 y la tasa de aprendizaje en 5

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

Paso C) Construye el modelo

El siguiente paso es similar a la clasificación lineal. Utiliza el estimador incorporado KernelLinearClassifier. Tenga en cuenta que agrega el asignador de kernel definido anteriormente y cambia el directorio del 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'}

Paso D) Entrene al modelo

Ahora que el clasificador Kernel está construido, está listo para entrenarlo. Eliges iterar 2000 veces el 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): []}}) 

Paso E) Evaluar el modelo

Por último, pero no menos importante, evalúa el rendimiento de su modelo. Debería poder superar la regresión 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

La precisión final es del 84%, es una mejora del 2% en comparación con la regresión logística. Existe una compensación entre la mejora de la precisión y el costo computacional. Debe pensar si la mejora del 2% vale la pena el tiempo consumido por los diferentes clasificadores y si tiene un impacto convincente en su negocio.

Resumen

Un kernel es una gran herramienta para transformar datos no lineales en (casi) lineales. El inconveniente de este método es que requiere mucho tiempo y es costoso desde el punto de vista computacional.

A continuación, puede encontrar el código más importante para entrenar un clasificador de kernel

Establecer la función Kernel de alta dimensión

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

Establecer el hiperparámetro L2

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

Construye el modelo

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

Entrena el modelo

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

Evaluar el modelo

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