Regresión lineal de TensorFlow con Facet & Termino de interaccion

En este tutorial, aprenderá cómo verificar los datos y prepararlos para crear una tarea de regresión lineal simple.

Este tutorial se divide en dos partes:

• Busque interacción
• Prueba el modelo

En el tutorial anterior, usó el conjunto de datos de Boston para estimar el precio medio de una casa. El conjunto de datos de Boston tiene un tamaño pequeño, con solo 506 observaciones. Este conjunto de datos se considera un punto de referencia para probar nuevos algoritmos de regresión lineal.

El conjunto de datos se compone de:

Variable	Descripción
zn	La proporción de terreno residencial dividido en zonas para lotes de más de 25,000 pies cuadrados.
indus	La proporción de acres comerciales no minoristas por ciudad.
nox	concentración de óxidos nítricos
rm	número medio de habitaciones por vivienda
edad	la proporción de unidades ocupadas por sus propietarios construidas antes de 1940
dis	distancias ponderadas a cinco centros de empleo de Boston
impuesto	Tasa de impuesto a la propiedad de valor total por cada $ 10,000
ptratio	la proporción alumno-maestro por ciudad
medv	El valor medio de las viviendas ocupadas por sus propietarios en miles de dólares
crim	tasa de criminalidad per cápita por ciudad
chas	Variable ficticia de Charles River (1 si limita el río; 0 en caso contrario)
B	la proporción de negros por la ciudad

En este tutorial, estimaremos el precio medio mediante un regresor lineal, pero el enfoque está en un proceso particular de aprendizaje automático: "preparación de datos".

Un modelo generaliza el patrón en los datos. Para capturar tal patrón, primero debe encontrarlo. Una buena práctica es realizar un análisis de datos antes de ejecutar cualquier algoritmo de aprendizaje automático.

Elegir las características adecuadas marca la diferencia en el éxito de su modelo. Imagina que intentas estimar el salario de un pueblo, si no incluyes el género como covariable, terminas con una estimación pobre.

Otra forma de mejorar el modelo es observar la correlación entre la variable independiente. Volviendo al ejemplo, puede pensar en la educación como un excelente candidato para predecir el salario pero también la ocupación. Es justo decir que la ocupación depende del nivel de educación, es decir, la educación superior a menudo conduce a una mejor ocupación. Si generalizamos esta idea, podemos decir que la correlación entre la variable dependiente y una variable explicativa se puede magnificar de otra variable explicativa más.

Para captar el efecto limitado de la educación sobre la ocupación, podemos utilizar un término de interacción.

Si observa la ecuación salarial, se convierte en:

Si es positivo, implica que un nivel adicional de educación produce un aumento mayor en el valor medio de una casa para un nivel de ocupación alto. En otras palabras, existe un efecto de interacción entre educación y ocupación.

En este tutorial, intentaremos ver qué variables pueden ser buenas candidatas para términos de interacción. Probaremos si agregar este tipo de información conduce a una mejor predicción de precios.

En este tutorial, aprenderá

• Resumen estadístico
• Resumen de facetas
• Profundización de facetas
• Instalar Facet
• Visión general
• Grafico
• Profundización de facetas
• TensorFlow
• Datos de preparación
• Regresión básica: Benchmark
• Mejorar el modelo: término de interacción

Resumen estadístico

Hay algunos pasos que puede seguir antes de continuar con el modelo. Como se mencionó anteriormente, el modelo es una generalización de los datos. La mejor práctica de ajuste es comprender los datos y hacer una predicción. Si no conoce sus datos, tiene pocas posibilidades de mejorar su modelo.

Como primer paso, cargue los datos como un marco de datos de pandas y cree un conjunto de entrenamiento y un conjunto de pruebas.

Sugerencias: para este tutorial, debe tener matplotlit y seaborn instalados en Python. Puede instalar el paquete Python sobre la marcha con Jupyter. No deberías hacer esto

!conda install -- yes matplotlib

pero

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

Tenga en cuenta que este paso no es necesario si tiene instalado matplotlib y seaborn.

Matplotlib es la biblioteca para crear un gráfico en Python. Seaborn es una biblioteca de visualización estadística construida sobre matplotlib. Proporciona atractivas y hermosas parcelas.

El siguiente código importa las bibliotecas necesarias.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

La biblioteca sklearn incluye el conjunto de datos de Boston. Puede llamar a su API para importar los datos.

boston = load_boston()df = pd.DataFrame(boston.data) 

El nombre de la característica se almacena en el objeto feature_names en una matriz.

boston.feature_names

Producción

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Puede cambiar el nombre de las columnas.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)



Convierte la variable CHAS como una variable de cadena y la etiqueta con sí si CHAS = 1 y no si CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Con los pandas, es sencillo dividir el conjunto de datos. Divide aleatoriamente el conjunto de datos con un conjunto de entrenamiento del 80 por ciento y un conjunto de pruebas del 20 por ciento. Los pandas tienen una función de costo incorporada para dividir una muestra de marco de datos.
El primer parámetro frac es un valor de 0 a 1. Lo establece en 0.8 para seleccionar aleatoriamente el 80 por ciento del marco de datos.
Random_state permite tener el mismo marco de datos devuelto para todos.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Puede obtener la forma de los datos. Debería ser:

Conjunto de trenes: 506 * 0.8 = 405
Juego de prueba: 506 * 0.2 = 101

print(df_train.shape, df_test.shape)
Producción 
(405, 14) (101, 14) 
 
df_test.head(5)
Producción
 

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
EDAD 
 
DIS 
 
RAD 
 
IMPUESTO 
 
PTRATIO 
 
B 
 
LSTAT 
 
PRECIO 
 

 
 
0 
 
0,00632 
 
18.0 
 
2,31 
 
No 
 
0.538 
 
6.575 
 
65,2 
 
4.0900 
 
1.0 
 
296.0 
 
15,3 
 
396,90 
 
4,98 
 
24,0 
 

 
 
1 
 
0.02731 
 
0.0 
 
7.07 
 
No 
 
0,469 
 
6.421 
 
78,9 
 
4.9671 
 
2.0 
 
242.0 
 
17,8 
 
396,90 
 
9.14 
 
21,6 
 

 
 
3 
 
0.03237 
 
0.0 
 
2.18 
 
No 
 
0,458 
 
6,998 
 
45,8 
 
6.0622 
 
3,0 
 
222.0 
 
18,7 
 
394,63 
 
2,94 
 
33,4 
 

 
 
6 
 
0.08829 
 
12,5 
 
7,87 
 
No 
 
0.524 
 
6.012 
 
66,6 
 
5.5605 
 
5,0 
 
311.0 
 
15,2 
 
395.60 
 
12.43 
 
22,9 
 

 
 
7 
 
0.14455 
 
12,5 
 
7,87 
 
No 
 
0.524 
 
6.172 
 
96,1 
 
5.9505 
 
5,0 
 
311.0 
 
15,2 
 
396,90 
 
19.15 
 
27,1 
 

 

 

Los datos son confusos; a menudo está desequilibrado y salpicado de valores atípicos que desvían el análisis y la capacitación en aprendizaje automático.
El primer paso para limpiar el conjunto de datos es comprender dónde debe limpiarse. Limpiar un conjunto de datos puede ser complicado, especialmente en cualquier forma generalizable.
El equipo de investigación de Google ha desarrollado una herramienta para este trabajo llamada Facetas que ayuda a visualizar los datos y dividirlos de muchas maneras. Este es un buen punto de partida para comprender cómo se presenta el conjunto de datos.
Las facetas le permiten encontrar dónde los datos no se ven como usted piensa.
A excepción de su aplicación web, Google facilita la integración del kit de herramientas en un cuaderno Jupyter.
Las facetas constan de dos partes:

Resumen de facetas


Profundización de facetas


Resumen de facetas
Descripción general de facetas ofrece una descripción general del conjunto de datos. Descripción general de facetas divide las columnas de datos en filas de información destacada que muestra

el porcentaje de observación faltante
valores min y max
estadísticas como la media, la mediana y la desviación estándar.
También agrega una columna que muestra el porcentaje de valores que son ceros, lo cual es útil cuando la mayoría de los valores son ceros.
Es posible ver estas distribuciones en el conjunto de datos de prueba, así como en el conjunto de entrenamiento para cada característica. Significa que puede verificar que la prueba tenga una distribución similar a los datos de entrenamiento.

Esto es al menos lo mínimo que debe hacer antes de cualquier tarea de aprendizaje automático. Con esta herramienta, no se pierde este paso crucial y resalta algunas anomalías.

Profundización de facetas
Facets Deep Dive es una herramienta genial. Permite tener algo de claridad en su conjunto de datos y acercar todo el camino para ver un dato individual. Significa que puede facetar los datos por fila y columna en cualquiera de las características del conjunto de datos.
Usaremos estas dos herramientas con el conjunto de datos de Boston.
Nota : no puede utilizar la descripción general de facetas y la inmersión profunda de facetas al mismo tiempo. Primero debe borrar el cuaderno para cambiar la herramienta.

Instalar Facet
Puede utilizar la aplicación web Facet para la mayor parte del análisis. En este tutorial, verá cómo usarlo dentro de un Jupyter Notebook.
En primer lugar, debe instalar nbextensions. Se hace con este código. Copie y pegue el siguiente código en el terminal de su máquina.
pip install jupyter_contrib_nbextensions 
Inmediatamente después de eso, debe clonar los repositorios en su computadora. Tienes dos opciones:
Opción 1) Copie y pegue este código en el terminal (recomendado)
Si no tiene Git instalado en su máquina, vaya a esta URL https://git-scm.com/download/win y siga las instrucciones. Una vez que haya terminado, puede usar el comando git en la terminal para usuarios de Mac o el indicador de Anaconda para usuarios de Windows
git clone https://github.com/PAIR-code/facets 
Opción 2) Vaya a https://github.com/PAIR-code/facets y descargue los repositorios.

Si elige la primera opción, el archivo termina en su archivo de descarga. Puede dejar que el archivo se descargue o arrastrarlo a otra ruta.
Puede verificar dónde se almacenan Facetas con esta línea de comando:
echo `pwd`/`ls facets` 
Ahora que ha localizado Facets, debe instalarlo en Jupyter Notebook. Debe establecer el directorio de trabajo en la ruta donde se encuentran las facetas.
Su directorio de trabajo actual y la ubicación de Facets zip deben ser los mismos.

Debe apuntar el directorio de trabajo a Facet:
cd facets
Para instalar Facets en Jupyter, tiene dos opciones. Si instaló Jupyter con Conda para todos los usuarios, copie este código:
puede usar jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
De lo contrario, use:
jupyter nbextension install facets-dist/ --user
Está bien, ya está todo listo. Abramos la descripción general de facetas.

Visión general
La descripción general utiliza una secuencia de comandos de Python para calcular las estadísticas. Debe importar el script llamado generic_feature_statistics_generator a Jupyter. No te preocupes; el guión se encuentra en los archivos de facetas.
Necesitas localizar su camino. Es fácil de hacer. Abre facetas, abre el archivo facets_overview y luego python. Copiar la ruta

Después de eso, regrese a Jupyter y escriba el siguiente código. Cambie la ruta '/ Users / Thomas / facets / facets_overview / python' a su ruta.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Puede importar el script con el siguiente código.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
En Windows, el mismo código se convierte en
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Para calcular las estadísticas de características, debe usar la función GenericFeatureStatisticsGenerator () y usa el objeto ProtoFromDataFrames. Puede pasar el marco de datos en un diccionario. Por ejemplo, si queremos crear una estadística de resumen para el conjunto de trenes, podemos almacenar la información en un diccionario y usarla en el objeto `` ProtoFromDataFrames``


'name': 'train', 'table': df_train 

Nombre es el nombre de la tabla que se muestra y usted usa el nombre de la tabla en la que desea calcular el resumen. En su ejemplo, la tabla que contiene los datos es df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overviewimport base64gfsg = GenericFeatureStatisticsGenerator()proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},{'name': 'test', 'table': df_test}])#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
Por último, simplemente copie y pegue el código a continuación. El código proviene directamente de GitHub. Debería poder ver esto:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
Grafico
Después de verificar los datos y su distribución, puede trazar una matriz de correlación. La matriz de correlación calcula el coeficiente de Pearson. Este coeficiente está vinculado entre -1 y 1, con un valor positivo indica una correlación positiva y un valor negativo una correlación negativa.
Le interesa ver qué variables pueden ser buenas candidatas para términos de interacción.
## Choose important feature and further check with Dive%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
Producción 

png

Desde la matriz, puede ver:

LSTAT
RM

Están fuertemente correlacionados con PRECIO. Otra característica interesante es la fuerte correlación positiva entre NOX e INDUS, lo que significa que esas dos variables se mueven en la misma dirección. Además, también están correlacionados con el PRECIO. DIS también está altamente correlacionado con IND y NOX.
Tiene un primer indicio de que IND y NOX pueden ser buenos candidatos para el término de intercepción y que DIS también puede ser interesante para enfocarse.
Puede profundizar un poco más trazando una cuadrícula de pares. Ilustrará con más detalle el mapa de correlación que trazó anteriormente.
La cuadrícula de pares la componen de la siguiente manera:

Parte superior: diagrama de dispersión con línea ajustada
Diagonal: gráfico de densidad de kernel
Parte inferior: gráfico de densidad de kernel multivariante

Elige el enfoque en cuatro variables independientes. La elección corresponde a las variables con fuerte correlación con PRICE

INDUS
NOX
RM
LSTAT

además, el PRECIO.
Tenga en cuenta que el error estándar se agrega de forma predeterminada al gráfico de dispersión.
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]g = sns.PairGrid(df[attributes])g = g.map_upper(sns.regplot, color="g")g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)g = g.map_diag(sns.kdeplot)
Producción 

Empecemos por la parte superior:

El precio se correlaciona negativamente con INDUS, NOX y LSTAT; correlacionado positivamente con RM.
Existe una ligera no linealidad con LSTAT y PRICE
Hay una línea recta cuando el precio es igual a 50. De la descripción del conjunto de datos, PRICE se ha truncado en el valor de 50

Diagonal

NOX parece tener dos grupos, uno alrededor de 0,5 y otro alrededor de 0,85.

Para ver más sobre esto, puede mirar la parte inferior. La densidad de kernel multivariante es interesante en el sentido de que colorea donde están la mayoría de los puntos. La diferencia con el gráfico de dispersión dibuja una densidad de probabilidad, aunque no hay ningún punto en el conjunto de datos para una coordenada determinada. Cuando el color es más fuerte, indica una alta concentración de puntos alrededor de esta área.
Si verifica la densidad multivariante para INDUS y NOX, puede ver la correlación positiva y los dos grupos. Cuando la participación de la industria es superior a 18, la concentración de óxidos nítricos es superior a 0,6.
Puede pensar en agregar una interacción entre INDUS y NOX en la relación lineal.
Finalmente, puede utilizar la segunda herramienta creada por Google, Facets Deep Dive. La interfaz se divide en cuatro secciones principales. El área central en el centro es una visualización ampliable de los datos. En la parte superior del panel, hay un menú desplegable donde puede cambiar la disposición de los datos para controlar las facetas, el posicionamiento y el color. A la derecha, hay una vista detallada de una fila específica de datos. Significa que puede hacer clic en cualquier punto de datos en la visualización central para ver los detalles sobre ese punto de datos en particular.
Durante el paso de visualización de datos, le interesa buscar la correlación por pares entre la variable independiente del precio de la casa. Sin embargo, involucra al menos tres variables y es complicado trabajar con gráficos 3D.
Una forma de abordar este problema es crear una variable categórica. Es decir, podemos crear una gráfica 2D con el color del punto. Puede dividir la variable PRECIO en cuatro categorías, cada una de las cuales es un cuartil (es decir, 0,25, 0,5, 0,75). Llamas a esta nueva variable Q_PRICE.
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


Profundización de facetas
Para abrir Deep Dive, debe transformar los datos en formato json. Pandas como objeto para eso. Puede usar to_json después del conjunto de datos de Pandas.
La primera línea de código maneja el tamaño del conjunto de datos.
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])sprite_size = 32 if len(df.index)>50000 else 64jsonstr = df.to_json(orient='records')
El siguiente código proviene de Google GitHub. Después de ejecutar el código, debería poder ver esto:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
Le interesa ver si existe una conexión entre la tasa de la industria, la concentración de óxido, la distancia al centro de trabajo y el precio de la casa.
Para eso, primero divide los datos por rango de industria y color con el cuartil de precios:

Seleccione facetar X y elija INDUS.
Seleccione Pantalla y elija DIS. Coloreará los puntos con el cuartil del precio de la vivienda.

aquí, los colores más oscuros significan que la distancia al primer centro de trabajo es muy grande.
Hasta ahora, muestra de nuevo lo que sabe, una tasa de industria más baja, un precio más alto. Ahora puedes ver el desglose por INDUX, por NOX.

Seleccione facetar Y y elija NOX.

Ahora puede ver que la casa lejos del primer centro de trabajo tiene la participación más baja de la industria y, por lo tanto, la concentración de óxido más baja. Si elige mostrar el tipo con Q_PRICE y hacer zoom en la esquina inferior izquierda, puede ver qué tipo de precio es.
Tiene otra pista de que la interacción entre IND, NOX y DIS pueden ser buenos candidatos para mejorar el modelo.

TensorFlow
En esta sección, estimará el clasificador lineal con la API de estimadores de TensorFlow. Procederá de la siguiente manera:

Prepara los datos
Estimar un modelo de referencia: sin interacción
Estimar un modelo con interacción

Recuerde, el objetivo del aprendizaje automático es minimizar el error. En este caso, ganará el modelo con el error cuadrático medio más bajo. El estimador de TensorFlow calcula automáticamente esta métrica.
Datos de preparación
En la mayoría de los casos, necesita transformar sus datos. Es por eso que Facets Overview es fascinante. A partir de la estadística resumida, vio que hay valores atípicos. Esos valores afectan las estimaciones porque no se parecen a la población que está analizando. Los valores atípicos generalmente sesgaron los resultados. Por ejemplo, un valor atípico positivo tiende a sobreestimar el coeficiente.
Una buena solución para abordar este problema es estandarizar la variable. Estandarización significa una desviación estándar de uno y una media de cero. El proceso de estandarización consta de dos pasos. En primer lugar, resta el valor medio de la variable. En segundo lugar, divide por la varianza para que la distribución tenga una varianza unitaria
La biblioteca sklearn es útil para estandarizar variables. Puede utilizar el módulo de preprocesamiento con la escala de objetos para este propósito.
Puede usar la función a continuación para escalar un conjunto de datos. Tenga en cuenta que no escala la columna de etiqueta ni las variables categóricas.
from sklearn import preprocessingdef standardize_data(df):X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']])X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'])df_scale = pd.concat([X_scaled_df,df['CHAS'],df['PRICE']],axis=1, join='inner')return df_scale
Puede utilizar la función para construir el tren / conjunto de pruebas a escala.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Regresión básica: Benchmark
En primer lugar, entrena y prueba un modelo sin interacción. El propósito es ver la métrica de rendimiento del modelo.
La forma de entrenar el modelo es exactamente como el tutorial sobre API de alto nivel . Usarás el estimador LinearRegressor de TensorFlow.
Como recordatorio, debe elegir:

las características para poner en el modelo
transformar las características
construir el regresor lineal
construir la función input_fn
entrenar al modelo
probar el modelo

Utiliza todas las variables del conjunto de datos para entrenar el modelo. En total, hay variables continuas de nivel y una variable categórica
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Convierte las características en una columna numérica o columna categórica
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
El modelo se crea con linearRegressor. Almacena el modelo en la carpeta train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Producción 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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}
Cada columna del tren o de los datos de prueba se convierte en un tensor con la función get_input_fn
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']LABEL= 'PRICE'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)
Estima el modelo en los datos del tren.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Producción 
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 train_Boston/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.INFO:tensorflow:Loss for final step: 23228.568.
Por último, estima el rendimiento del modelo en el conjunto de prueba.
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Producción 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
La pérdida del modelo es 1650. Esta es la métrica a batir en la siguiente sección.

Mejorar el modelo: término de interacción
Durante la primera parte del tutorial, vio una relación interesante entre las variables. Las diferentes técnicas de visualización revelaron que INDUS y NOS están vinculados y gira para magnificar el efecto sobre el precio. No solo la interacción entre INDUS y NOS afecta el precio, sino que también este efecto es más fuerte cuando interactúa con DIS.
Es hora de generalizar esta idea y ver si se puede mejorar el modelo de predicción del modelo.
Debe agregar dos columnas nuevas a cada conjunto de datos: tren + prueba. Para eso, crea una función para calcular el término de interacción y otra para calcular el término de interacción triple. Cada función produce una sola columna. Una vez creadas las nuevas variables, puede concatenarlas al conjunto de datos de entrenamiento y al conjunto de datos de prueba.
En primer lugar, debe crear una nueva variable para la interacción entre INDUS y NOX.
La función a continuación devuelve dos marcos de datos, entrenar y probar, con la interacción entre var_1 y var_2, en su caso INDUS y NOX.
def interaction_term(var_1, var_2, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]test = t_test.rename(name)return train, test
Almacena las dos nuevas columnas
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
En segundo lugar, crea una segunda función para calcular el término de interacción triple.
def triple_interaction_term(var_1, var_2,var_3, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]test = t_test.rename(name)return train, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Ahora que tiene todas las columnas necesarias, puede agregarlas para entrenar y probar el conjunto de datos. Nombra estos dos nuevos marcos de datos:

df_train_new
df_test_new

df_train_new = pd.concat([df_train_scale,interation_ind_ns_train,interation_ind_ns_dis_train],axis=1, join='inner')df_test_new = pd.concat([df_test_scale,interation_ind_ns_test,interation_ind_ns_dis_test],axis=1, join='inner')df_train_new.head(5)
Producción 

Eso es; puede estimar el nuevo modelo con los términos de interacción y ver cómo es la métrica de rendimiento.
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS']### Define categorical listcontinuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]model = tf.estimator.LinearRegressor(model_dir="train_Boston_1",feature_columns= categorical_features + continuous_features_new)
Producción 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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}
CÓDIGO
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']LABEL= 'PRICE'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)
 
model.train(input_fn=get_input_fn(df_train_new,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Producción 
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 train_Boston_1/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.INFO:tensorflow:Loss for final step: 19598.387.
 
model.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.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
La nueva pérdida es 1515. Con solo agregar dos nuevas variables, pudo disminuir la pérdida. Significa que puede hacer una mejor predicción que con el modelo de referencia.