Clasificación binaria en TensorFlow: ejemplo de clasificador lineal

Las dos tareas de aprendizaje supervisado más comunes son la regresión lineal y el clasificador lineal. La regresión lineal predice un valor mientras que el clasificador lineal predice una clase. Este tutorial se centra en el clasificador lineal.

¿Qué es el clasificador lineal?

Un clasificador lineal en el aprendizaje automático es un método para encontrar la clase de un objeto en función de sus características para la clasificación estadística. Toma una decisión de clasificación basada en el valor de una combinación lineal de características de un objeto. El clasificador lineal se utiliza en problemas prácticos como clasificación de documentos y problemas que tienen muchas variables.

Los problemas de clasificación representan aproximadamente el 80 por ciento de la tarea de aprendizaje automático. La clasificación tiene como objetivo predecir la probabilidad de cada clase dado un conjunto de entradas. La etiqueta (es decir, la variable dependiente) es un valor discreto, llamado clase.

1. Si la etiqueta tiene solo dos clases, el algoritmo de aprendizaje es un clasificador binario.
2. El clasificador multiclase aborda etiquetas con más de dos clases.

Por ejemplo, un problema típico de clasificación binaria es predecir la probabilidad de que un cliente realice una segunda compra. Predecir el tipo de animal que se muestra en una imagen es un problema de clasificación multiclase ya que existen más de dos variedades de animales.

La parte teórica de este tutorial se centra principalmente en la clase binaria. Aprenderá más sobre la función de salida multiclase en un tutorial futuro.

En este tutorial, aprenderá

• ¿Qué es el clasificador lineal?
• ¿Cómo funciona el clasificador binario?
• ¿Cómo medir el rendimiento del clasificador lineal?
• Precisión
• Matriz de confusión
• Precisión y Sensibilidad
• Clasificador lineal con TensorFlow
• Paso 1) Importa los datos
• Paso 2) Conversión de datos
• Paso 3) Entrene al clasificador
• Paso 4) Mejora el modelo
• Paso 5) Hiperparámetro: Lasso & Ridge

¿Cómo funciona el clasificador binario?

Aprendió en el tutorial anterior que una función se compone de dos tipos de variables, una variable dependiente y un conjunto de características (variables independientes). En la regresión lineal, una variable dependiente es un número real sin rango. El objetivo principal es predecir su valor minimizando el error cuadrático medio.

Para el clasificador binario de TensorFlow, la etiqueta puede haber tenido dos posibles valores enteros. En la mayoría de los casos, es [0,1] o [1,2]. Por ejemplo, el objetivo es predecir si un cliente comprará un producto o no. La etiqueta se define de la siguiente manera:

• Y = 1 (el cliente compró el producto)
• Y = 0 (el cliente no compra el producto)

El modelo utiliza las características X para clasificar a cada cliente en la clase más probable a la que pertenece, es decir, comprador potencial o no.

La probabilidad de éxito se calcula mediante regresión logística . El algoritmo calculará una probabilidad basada en la característica X y predice un éxito cuando esta probabilidad es superior al 50 por ciento. Más formalmente, la probabilidad se calcula como se muestra en el siguiente ejemplo de clasificación binaria de TensorFlow:

donde 0 es el conjunto de ponderaciones, las características yb el sesgo.

La función se puede descomponer en dos partes:

• El modelo lineal
• La función logística

Modelo lineal

Ya está familiarizado con la forma en que se calculan los pesos. Los pesos se calculan utilizando un producto escalar: Y es una función lineal de todas las características x _i . Si el modelo no tiene características, la predicción es igual al sesgo, b.

Los pesos indican la dirección de la correlación entre las características x _i y la etiqueta y. Una correlación positiva aumenta la probabilidad de la clase positiva, mientras que una correlación negativa lleva la probabilidad más cerca de 0 (es decir, clase negativa).

El modelo lineal devuelve solo un número real, que es inconsistente con la medida de probabilidad del rango [0,1]. La función logística es necesaria para convertir la salida del modelo lineal en una probabilidad,

Función logística

La función logística, o función sigmoidea, tiene forma de S y la salida de esta función siempre está entre 0 y 1.

Ejemplo de función logística

Es fácil sustituir la salida de la regresión lineal en la función sigmoidea. Da como resultado un nuevo número con una probabilidad entre 0 y 1.

El clasificador puede transformar la probabilidad en una clase.

• Los valores entre 0 y 0,49 se convierten en clase 0
• Los valores entre 0,5 y 1 se convierten en clase 1

¿Cómo medir el rendimiento del clasificador lineal?

Precisión

El rendimiento general de un clasificador se mide con la métrica de precisión. La precisión recopila todos los valores correctos divididos por el número total de observaciones. Por ejemplo, un valor de precisión del 80 por ciento significa que el modelo es correcto en el 80 por ciento de los casos.

Mida el rendimiento del clasificador lineal utilizando la métrica de precisión

Puede notar una deficiencia con esta métrica, especialmente para la clase de desequilibrio. Un conjunto de datos de desequilibrio ocurre cuando el número de observaciones por grupo no es igual. Digamos; intenta clasificar un evento raro con una función logística. Imagine que el clasificador intenta estimar la muerte de un paciente a raíz de una enfermedad. En los datos, fallece el 5 por ciento de los pacientes. Puede entrenar a un clasificador para predecir el número de muertes y usar la métrica de precisión para evaluar las actuaciones. Si el clasificador predice 0 muertes para todo el conjunto de datos, será correcto en el 95 por ciento de los casos.

Matriz de confusión

Una mejor manera de evaluar el desempeño de un clasificador es mirar la matriz de confusión.

Mida el rendimiento del clasificador lineal utilizando la matriz de confusión

La matriz de confusión visualiza la precisión de un clasificador comparando las clases reales y pronosticadas como se muestra en el ejemplo de Clasificador lineal anterior. La matriz de confusión binaria se compone de cuadrados:

• TP: Positivo verdadero: valores predichos correctamente predichos como positivo real
• FP: Los valores predichos predecían incorrectamente un positivo real. es decir, valores negativos predichos como positivos
• FN: Falso Negativo: Valores positivos predichos como negativos
• TN: Negativo verdadero: valores predichos correctamente predichos como negativos reales

A partir de la matriz de confusión, es fácil comparar la clase real y la clase predicha.

Precisión y Sensibilidad

La matriz de confusión proporciona una buena idea de los verdaderos positivos y falsos positivos. En algunos casos, es preferible tener una métrica más concisa.

Precisión

La métrica de precisión muestra la precisión de la clase positiva. Mide la probabilidad de que la predicción de la clase positiva sea correcta.

La puntuación máxima es 1 cuando el clasificador clasifica perfectamente todos los valores positivos. La precisión por sí sola no es muy útil porque ignora la clase negativa. La métrica suele estar emparejada con la métrica de recuperación. El recuerdo también se denomina sensibilidad o tasa de verdaderos positivos.

Sensibilidad

La sensibilidad calcula la proporción de clases positivas detectadas correctamente. Esta métrica da qué tan bueno es el modelo para reconocer una clase positiva.

Clasificador lineal con TensorFlow

Para este tutorial, usaremos el conjunto de datos del censo. El propósito es utilizar las variables del conjunto de datos del censo para predecir el nivel de ingresos. Tenga en cuenta que la renta es una variable binaria

• con un valor de 1 si los ingresos> 50k
• 0 si ingresos <50k.

Esta variable es tu etiqueta

Este conjunto de datos incluye ocho variables categóricas:

• lugar de trabajo
• educación
• marital
• ocupación
• relación
• raza
• sexo
• patria

además, seis variables continuas:

• edad
• fnlwgt
• número_educación
• ganancia capital
• perdida de capital
• hours_week

A través de este ejemplo de clasificación de TensorFlow, comprenderá cómo entrenar clasificadores de TensorFlow lineales con el estimador de TensorFlow y cómo mejorar la métrica de precisión.

Procederemos de la siguiente manera:

• Paso 1) Importa los datos
• Paso 2) Conversión de datos
• Paso 3) Entrene al clasificador
• Paso 4) Mejora el modelo
• Paso 5) Hiperparámetro: Lasso & Ridge

Paso 1) Importa los datos

Primero importa las bibliotecas utilizadas durante el tutorial.

import tensorflow as tfimport pandas as pd 

A continuación, importa los datos del archivo de UCI y define los nombres de las columnas. Utilizará las COLUMNAS para nombrar las columnas en un marco de datos de pandas.

Tenga en cuenta que entrenará al clasificador utilizando un marco de datos de Pandas.

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

Los datos almacenados en línea ya están divididos entre un conjunto de trenes y un conjunto de prueba.

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)

El conjunto de trenes contiene 32,561 observaciones y el conjunto de prueba 16,281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow requiere un valor booleano para entrenar al clasificador. Necesita convertir los valores de cadena a entero. La etiqueta se almacena como un objeto, sin embargo, debe convertirla en un valor numérico. El siguiente código crea un diccionario con los valores para convertir y recorrer el elemento de la columna. Tenga en cuenta que realiza esta operación dos veces, una para la prueba del tren, otra para el equipo de prueba

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]

En los datos del tren, hay 24,720 ingresos por debajo de 50k y 7841 por encima. La relación es casi la misma para el equipo de prueba. Consulte este tutorial sobre Facetas para obtener más información.

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

Paso 2) Conversión de datos

Se requieren algunos pasos antes de entrenar un clasificador lineal con Tensorflow. Debe preparar las funciones para incluirlas en el modelo. En la regresión de referencia, utilizará los datos originales sin aplicar ninguna transformación.

El estimador necesita tener una lista de características para entrenar el modelo. Por lo tanto, los datos de la columna deben convertirse en un tensor.

Una buena práctica es definir dos listas de características según su tipo y luego pasarlas a feature_columns del estimador.

Comenzará por convertir características continuas y luego definirá un depósito con los datos categóricos.

Las características del conjunto de datos tienen dos formatos:

• Entero
• Objeto

Cada característica se enumera en las siguientes dos variables según sus tipos.

## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']### Define the categorical listCATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

Feature_column está equipado con un objeto numeric_column para ayudar en la transformación de las variables continuas en tensor. En el siguiente código, convierte todas las variables de CONTI_FEATURES en un tensor con un valor numérico. Esto es obligatorio para construir el modelo. Todas las variables independientes deben convertirse al tipo adecuado de tensor.

A continuación, escribimos un código para que pueda ver lo que está sucediendo detrás de feature_column.numeric_column. Imprimiremos el valor convertido para la edad. Es con fines explicativos, por lo que no es necesario comprender el código Python. Puede consultar la documentación oficial para comprender los códigos.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif continuous == True:c = tf.feature_column.numeric_column(feature)feature_columns = [c]else:c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)c_indicator = tf.feature_column.indicator_column(c)feature_columns = [c_indicator]## Use input_layer to print the valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(sess.run(input_layer))print_transformation(feature = "age", continuous = True)[[39.][50.][38.]… [58.][22.][52.]]

Los valores son exactamente los mismos que en df_train

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES] 

Según la documentación de TensorFlow, existen diferentes formas de convertir datos categóricos. Si se conoce la lista de vocabulario de una característica y no tiene muchos valores, es posible crear la columna categórica con categorical_column_with_vocabulary_list. Asignará una identificación a toda la lista de vocabulario única.

Por ejemplo, si el estado de una variable tiene tres valores distintos:

• Marido
• Esposa
• Único

Entonces se atribuirán tres ID. Por ejemplo, el esposo tendrá el ID 1, la esposa el ID 2 y así sucesivamente.

Con fines ilustrativos, puede usar este código para convertir una variable de objeto en una columna categórica en TensorFlow.

La característica sexo solo puede tener dos valores: masculino o femenino. Cuando convertiremos la función sexo, Tensorflow creará 2 columnas nuevas, una para hombre y otra para mujer. Si el sexo es igual a masculino, la nueva columna masculino será igual a 1 y femenino a 0. Este ejemplo se muestra en la siguiente tabla:

filas	sexo	después de la transformación	masculino	mujer
1	masculino	=>	1	0
2	masculino	=>	1	0
3	mujer	=>	0	1

En tensorflow:

print_transformation(feature = "sex", continuous = False, size = 2)[[1. 0.][1. 0.][1. 0.]… [0. 1.][1. 0.][0. 1.]]relationship = tf.feature_column.categorical_column_with_vocabulary_list('relationship', ['Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried','Other-relative'])

A continuación, agregamos código Python para imprimir la codificación. Nuevamente, no es necesario que comprenda el código, el propósito es ver la transformación

Sin embargo, una forma más rápida de transformar los datos es utilizar el método categorical_column_with_hash_bucket. Será útil alterar las variables de cadena en una matriz dispersa. Una matriz dispersa es una matriz con casi cero. El método se encarga de todo. Solo necesita especificar el número de depósitos y la columna de clave. La cantidad de depósitos es la cantidad máxima de grupos que puede crear Tensorflow. La columna clave es simplemente el nombre de la columna que se va a convertir.

En el siguiente código, crea un bucle sobre todas las características categóricas.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

Paso 3) Entrene al clasificador

Actualmente, TensorFlow proporciona un estimador para la regresión lineal y la clasificación lineal.

• Regresión lineal: LinearRegressor
• Clasificación lineal: LinearClassifier

La sintaxis del clasificador lineal es la misma que en el tutorial sobre regresión lineal, excepto por un argumento, n_class. Debe definir la columna de características, el directorio del modelo y comparar con el regresor lineal; tienes que definir el número de clase. Para una regresión logit, el número de clases es igual a 2.

El modelo calculará los pesos de las columnas contenidas en continuas_featuras y categorical_features.

model = tf.estimator.LinearClassifier(n_classes = 2,model_dir="ongoing/train",feature_columns=categorical_features+ continuous_features)

PRODUCCIÓN:

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_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}

Ahora que el clasificador está definido, puede crear la función de entrada. El método es el mismo que en el tutorial del regresor lineal. Aquí, usa un tamaño de lote de 128 y mezcla los datos.

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']LABEL= 'label'def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Creas una función con los argumentos requeridos por el estimador lineal, es decir, número de épocas, número de lotes y barajas el conjunto de datos o la nota. Dado que utiliza el método Pandas para pasar los datos al modelo, debe definir las variables X como un marco de datos pandas. Tenga en cuenta que recorre todos los datos almacenados en FUNCIONES.

Entrenemos el modelo con el objeto model.train. Utiliza la función previamente definida para alimentar el modelo con los valores adecuados. Tenga en cuenta que establece el tamaño del lote en 128 y el número de épocas en Ninguno. El modelo se entrenará en mil pasos.

model.train(input_fn=get_input_fn(df_train,num_epochs=None,n_batch = 128,shuffle=False),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 ongoing/train/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.INFO:tensorflow:Loss for final step: 5444.363.

Tenga en cuenta que la pérdida disminuyó posteriormente durante los últimos 100 pasos, es decir, de 901 a 1000.

La pérdida final después de mil iteraciones es 5444. Puede estimar su modelo en el conjunto de prueba y ver el rendimiento. Para evaluar el rendimiento de su modelo, debe utilizar el objeto evaluar. Usted alimenta el modelo con el conjunto de prueba y establece el número de épocas en 1, es decir, los datos irán al modelo solo una vez.

model.evaluate(input_fn=get_input_fn(df_test,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

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-06-02-08:28:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546{'accuracy': 0.7615626,'accuracy_baseline': 0.76377374,'auc': 0.63300294,'auc_precision_recall': 0.50891197,'average_loss': 47.12155,'global_step': 1000,'label/mean': 0.23622628,'loss': 5993.6406,'precision': 0.49401596,'prediction/mean': 0.18454961,'recall': 0.38637546}

TensorFlow muestra todas las métricas que aprendiste en la parte teórica. Sin sorpresa, la precisión es grande debido a la etiqueta desequilibrada. En realidad, el modelo funciona un poco mejor que una suposición aleatoria. Imagine que el modelo predice todos los hogares con ingresos inferiores a 50 mil, entonces el modelo tiene una precisión del 70 por ciento. En un análisis más detallado, puede ver que la predicción y la recuperación son bastante bajas.

Paso 4) Mejora el modelo

Ahora que tiene un modelo de referencia, puede intentar mejorarlo, es decir, aumentar la precisión. En el tutorial anterior, aprendió cómo mejorar el poder de predicción con un término de interacción. En este tutorial, revisará esta idea agregando un término polinomial a la regresión.

La regresión polinomial es fundamental cuando no hay linealidad en los datos. Hay dos formas de capturar la no linealidad en los datos.

• Agregar término polinomial
• Bucketize la variable continua en una variable categórica

Término polinomial

En la siguiente imagen, puede ver qué es una regresión polinomial. Es una ecuación con X variables con diferente potencia. Una regresión polinomial de segundo grado tiene dos variables, X y X al cuadrado. El tercer grado tiene tres variables, X, X ² y X ³

¿Qué es la regresión polinomial?

A continuación, construimos un gráfico con dos variables, X e Y. Es obvio que la relación no es lineal. Si agregamos una regresión lineal, podemos ver que el modelo no puede capturar el patrón (imagen de la izquierda).

Ahora, mire la imagen de la izquierda de la imagen de abajo, agregamos cinco términos a la regresión (es decir, y = x + x ² + x ³ + x ⁴ + x ^5. El modelo ahora captura mucho mejor el patrón. Esto es el poder de la regresión polinomial.

Volvamos a nuestro ejemplo. La edad no tiene una relación lineal con los ingresos. La edad temprana puede tener un ingreso fijo cercano a cero porque los niños o los jóvenes no trabajan. Luego aumenta en la edad laboral y disminuye durante la jubilación. Por lo general, tiene forma de U invertida. Una forma de capturar este patrón es agregar una potencia de dos a la regresión.

Veamos si aumenta la precisión.

Debe agregar esta nueva característica al conjunto de datos y en la lista de características continuas.

Agrega la nueva variable en el conjunto de datos de entrenamiento y prueba, por lo que es más conveniente escribir una función.

def square_var(df_t, df_te, var_name = 'age'):df_t['new'] = df_t[var_name].pow(2)df_te['new'] = df_te[var_name].pow(2)return df_t, df_te

La función tiene 3 argumentos:

• df_t: define el conjunto de entrenamiento
• df_te: define el conjunto de prueba
• var_name = 'age': Define la variable a transformar

Puede usar el objeto pow (2) para cuadrar la variable edad. Tenga en cuenta que la nueva variable se llama 'nueva'

Ahora que la función square_var está escrita, puede crear los nuevos conjuntos de datos.

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age') 

Como puede ver, el nuevo conjunto de datos tiene una característica más.

print(df_train_new.shape, df_test_new.shape)(32561, 16) (16281, 16) 

La variable cuadrada se llama nueva en el conjunto de datos. Debe agregarlo a la lista de funciones continuas.

CONTI_FEATURES_NEW = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

Tenga en cuenta que cambió el directorio del gráfico. No puede entrenar diferentes modelos en el mismo directorio. Significa que debe cambiar la ruta del argumento model_dir. Si no lo hace, TensorFlow arrojará un error.

model_1 = tf.estimator.LinearClassifier(model_dir="ongoing/train1",feature_columns=categorical_features+ continuous_features_new)

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train1', '_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}FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES_NEW}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Ahora que el clasificador está diseñado con el nuevo conjunto de datos, puede entrenar y evaluar el modelo.

model_1.train(input_fn=get_input_fn(df_train,num_epochs=None,n_batch = 128,shuffle=False),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 ongoing/train1/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.INFO:tensorflow:Loss for final step: 28861.898.

model_1.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

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-06-02-08:28:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703{'accuracy': 0.7944229,'accuracy_baseline': 0.76377374,'auc': 0.6093755,'auc_precision_recall': 0.54885805,'average_loss': 111.0046,'global_step': 1000,'label/mean': 0.23622628,'loss': 14119.265,'precision': 0.6682401,'prediction/mean': 0.09116262,'recall': 0.2576703}

La variable al cuadrado mejoró la precisión de 0,76 a 0,79. Veamos si puede hacerlo mejor combinando la agrupación en cubos y el término de interacción juntos.

Bucketización e interacción

Como vio antes, un clasificador lineal no puede capturar correctamente el patrón de ingresos por edad. Eso es porque aprende un solo peso para cada característica. Para que sea más fácil para el clasificador, una cosa que puede hacer es agrupar la característica. El agrupamiento transforma una característica numérica en varias determinadas según el rango en el que se encuentra, y cada una de estas características nuevas indica si la edad de una persona se encuentra dentro de ese rango.

Con estas nuevas características, el modelo lineal puede capturar la relación aprendiendo diferentes pesos para cada segmento.

En TensorFlow, se hace con bucketized_column. Debe agregar el rango de valores en los límites.

age = tf.feature_column.numeric_column('age')age_buckets = tf.feature_column.bucketized_column(age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

Ya sabes que la edad no es lineal con los ingresos. Otra forma de mejorar el modelo es mediante la interacción. En la palabra de TensorFlow, es un cruce de características. El cruce de características es una forma de crear nuevas características que son combinaciones de las existentes, lo que puede ser útil para un clasificador lineal que no puede modelar interacciones entre características.

Puede desglosar la edad con otra característica como la educación. Es decir, es probable que algunos grupos tengan ingresos altos y otros bajos (Piense en el estudiante de doctorado).

education_x_occupation = [tf.feature_column.crossed_column(['education', 'occupation'], hash_bucket_size=1000)]age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column([age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

Para crear una columna de entidades cruzadas, use cross_column con las variables para cruzar entre corchetes. El hash_bucket_size indica las máximas posibilidades de cruce. Para crear interacción entre variables (al menos una variable debe ser categórica), puede usar tf.feature_column.crossed_column. Para usar este objeto, debe agregar entre corchetes la variable para interactuar y un segundo argumento, el tamaño del depósito. El tamaño del depósito es el número máximo de grupos posible dentro de una variable. Aquí lo establece en 1000 ya que no conoce el número exacto de grupos

age_buckets debe cuadrarse antes de agregarlo a las columnas de características. También agrega las nuevas características a las columnas de características y prepara el estimador

base_columns = [age_buckets,]model_imp = tf.estimator.LinearClassifier(model_dir="ongoing/train3",feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

PRODUCCIÓN

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_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}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital','occupation', 'relationship', 'race', 'sex', 'native_country', 'new']def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):return tf.estimator.inputs.pandas_input_fn(x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),y = pd.Series(data_set[LABEL].values),batch_size=n_batch,num_epochs=num_epochs,shuffle=shuffle)

Está listo para estimar el nuevo modelo y ver si mejora la precisión.

model_imp.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),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 ongoing/train3/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.INFO:tensorflow:Loss for final step: 44.18133.

model_imp.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

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-06-02-08:28:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216{'accuracy': 0.8358209,'accuracy_baseline': 0.76377374,'auc': 0.88401634,'auc_precision_recall': 0.69599575,'average_loss': 0.35122654,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.67437,'precision': 0.68986726,'prediction/mean': 0.23320661,'recall': 0.55408216}

El nuevo nivel de precisión es del 83,58 por ciento. Es un cuatro por ciento más alto que el modelo anterior.

Finalmente, puede agregar un término de regularización para evitar el sobreajuste.

Paso 5) Hiperparámetro: Lasso & Ridge

Su modelo puede sufrir un ajuste excesivo o inadecuado .

• Sobreajuste: el modelo no puede generalizar la predicción a nuevos datos
• Ajuste insuficiente: el modelo no puede capturar el patrón de los datos. es decir, regresión lineal cuando los datos no son lineales

Cuando un modelo tiene muchos parámetros y una cantidad relativamente baja de datos, genera predicciones deficientes. Imagínese, un grupo solo tiene tres observaciones; el modelo calculará un peso para este grupo. El peso se usa para hacer una predicción; si las observaciones del conjunto de prueba para este grupo en particular son completamente diferentes del conjunto de entrenamiento, entonces el modelo hará una predicción incorrecta. Durante la evaluación con el conjunto de entrenamiento, la precisión es buena, pero no buena con el conjunto de prueba porque los pesos calculados no son los verdaderos para generalizar el patrón. En este caso, no hace una predicción razonable sobre datos invisibles.

Para evitar el sobreajuste, la regularización le brinda la posibilidad de controlar dicha complejidad y hacerla más generalizable. Hay dos técnicas de regularización:

• L1: lazo
• L2: Cresta

En TensorFlow, puede agregar estos dos hiperparámetros en el optimizador. Por ejemplo, cuanto mayor es el hiperparámetro L2, el peso tiende a ser muy bajo y cercano a cero. La línea ajustada será muy plana, mientras que un L2 cercano a cero implica que los pesos están cerca de la regresión lineal regular.

Puede probar usted mismo los diferentes valores de los hiperparámetros y ver si puede aumentar el nivel de precisión.

Tenga en cuenta que si cambia el hiperparámetro, debe eliminar la carpeta en curso / train4; de lo contrario, el modelo comenzará con el modelo entrenado previamente.

Veamos cómo es la precisión con el bombo.

model_regu = tf.estimator.LinearClassifier(model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,optimizer=tf.train.FtrlOptimizer(learning_rate=0.1,l1_regularization_strength=0.9,l2_regularization_strength=5))

SALIDA

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_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}

model_regu.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

SALIDA

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 ongoing/train4/model.ckpt.INFO:tensorflow:loss = 88.722855, step = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.INFO:tensorflow:Loss for final step: 43.4942.

model_regu.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)

PRODUCCIÓN

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-06-02-08:29:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [100/1000]INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823{'accuracy': 0.83833915,'accuracy_baseline': 0.76377374,'auc': 0.8869794,'auc_precision_recall': 0.7014905,'average_loss': 0.34691378,'global_step': 1000,'label/mean': 0.23622628,'loss': 44.12581,'precision': 0.69720596,'prediction/mean': 0.23662092,'recall': 0.5579823}

Con este hiperparámetro, aumenta ligeramente las métricas de precisión. En el siguiente tutorial, aprenderá cómo mejorar un clasificador lineal usando un método de kernel.

Resumen

Para entrenar un modelo, necesita:

• Definir las características: Variables independientes: X
• Defina la etiqueta: Variable dependiente: y
• Construya un tren / equipo de prueba
• Definir el peso inicial
• Definir la función de pérdida: MSE
• Optimizar el modelo: descenso de gradiente
• Definir:
  • Tasa de aprendizaje
  • Número de época
  • Tamaño del lote
  • Numero de clase

En este tutorial, aprendió a usar la API de alto nivel para un clasificador de regresión lineal. Necesitas definir:

1. Columnas de características. Si es continuo: tf.feature_column.numeric_column (). Puede completar una lista con la comprensión de la lista de Python
2. El estimador: tf.estimator.LinearClassifier (feature_columns, model_dir, n_classes = 2)
3. Una función para importar los datos, el tamaño del lote y la época: input_fn ()

Después de eso, estará listo para entrenar, evaluar y hacer una predicción con train (), evaluar () y predecir ()

Para mejorar el rendimiento del modelo, puede:

• Usar regresión polinomial
• Término de interacción: tf.feature_column.crossed_column
• Agregar parámetro de regularización