Regresión lineal con TensorFlow (ejemplos)

¿Qué es la regresión lineal?

La regresión lineal es un enfoque en estadística para modelar relaciones entre dos variables. Este modelado se realiza entre una respuesta escalar y una o más variables explicativas. La relación con una variable explicativa se llama regresión lineal simple y para más de una variable explicativa, se llama regresión lineal múltiple.

TensorFlow proporciona herramientas para tener un control total de los cálculos. Esto se hace con la API de bajo nivel. Además de eso, TensorFlow está equipado con una amplia gama de API para realizar muchos algoritmos de aprendizaje automático. Esta es la API de alto nivel. TensorFlow los llama estimadores

• API de bajo nivel: Construye la arquitectura, optimización del modelo desde cero. Es complicado para un principiante
• API de alto nivel: define el algoritmo. Es más fácil de usar. TensorFlow proporciona un estimador de llamadas de caja de herramientas para construir, entrenar, evaluar y hacer una predicción.

En este tutorial, utilizará únicamente los estimadores . Los cálculos son más rápidos y más fáciles de implementar. La primera parte del tutorial explica cómo usar el optimizador de descenso de gradiente para entrenar una regresión lineal en TensorFlow. En una segunda parte, usará el conjunto de datos de Boston para predecir el precio de una casa usando el estimador de TensorFlow.

Descarga Boston DataSet

En este tutorial de regresión de TensorFlow, aprenderá:

• ¿Qué es la regresión lineal?
• Cómo entrenar un modelo de regresión lineal
• Cómo entrenar una regresión lineal con TensorFlow
• Pandas
• Solución Numpy
• Solución Tensorflow

Cómo entrenar un modelo de regresión lineal

Antes de comenzar a entrenar el modelo, veamos qué es una regresión lineal.

Imagina que tienes dos variables, xey, y tu tarea es predecir el valor de conocer el valor de. Si grafica los datos, puede ver una relación positiva entre su variable independiente, x, y su variable dependiente y.

Puede observar, si x = 1, y será aproximadamente igual a 6 y si x = 2, y será alrededor de 8.5.

Este no es un método muy preciso y propenso a errores, especialmente con un conjunto de datos con cientos de miles de puntos.

Una regresión lineal se evalúa con una ecuación. La variable y se explica por una o varias covariables. En su ejemplo, solo hay una variable dependiente. Si tienes que escribir esta ecuación, será:

Con:

• 
• es el peso asociado ax
• es el residuo o el error del modelo. Incluye lo que el modelo no puede aprender de los datos.

Imagina que encajas en el modelo y encuentras la siguiente solución para:

• = 3.8
• = 2,78

Puede sustituir esos números en la ecuación y se convierte en:

y = 3.8 + 2.78x

Ahora tiene una mejor manera de encontrar los valores de y. Es decir, puede reemplazar x con cualquier valor que desee predecir y. En la imagen de abajo, reemplazamos x en la ecuación con todos los valores en el conjunto de datos y graficamos el resultado.

La línea roja representa el valor ajustado, es decir, los valores de y para cada valor de x. No es necesario ver el valor de x para predecir y, para cada x hay alguno que pertenezca a la línea roja. ¡También puede predecir valores de x superiores a 2!

Si desea extender la regresión lineal a más covariables, puede agregar más variables al modelo. La diferencia entre el análisis tradicional y la regresión lineal es que la regresión lineal observa cómo reaccionará y para cada variable x tomada de forma independiente.

Veamos un ejemplo. Imagina que quieres predecir las ventas de una heladería. El conjunto de datos contiene información diferente, como el clima (es decir, lluvioso, soleado, nublado), información del cliente (es decir, salario, sexo, estado civil).

El análisis tradicional intentará predecir la venta, digamos calculando el promedio de cada variable y tratando de estimar la venta para diferentes escenarios. Dará lugar a predicciones deficientes y restringirá el análisis al escenario elegido.

Si usa la regresión lineal, puede escribir esta ecuación:

El algoritmo encontrará la mejor solución para los pesos; significa que intentará minimizar el costo (la diferencia entre la línea ajustada y los puntos de datos).

Cómo funciona el algoritmo

El algoritmo elegirá un número aleatorio para cada uno reemplazará el valor de x para obtener el valor predicho de y. Si el conjunto de datos tiene 100 observaciones, el algoritmo calcula 100 valores predichos.

Podemos calcular el error, observado en el modelo, que es la diferencia entre el valor predicho y el valor real. Un error positivo significa que el modelo subestima la predicción de y, y un error negativo significa que el modelo sobreestima la predicción de y.

Tu objetivo es minimizar el cuadrado del error. El algoritmo calcula la media del error cuadrado. Este paso se denomina minimización del error. Para la regresión lineal es el error cuadrático medio , también llamado MSE. Matemáticamente, es:

Dónde:

• refiere al valor predicho
• y son los valores reales
• m es el número de observaciones

Tenga en cuenta que es la notación matemática de la media.

El objetivo es encontrar lo mejor que minimice el MSE

Si el error promedio es grande, significa que el modelo funciona mal y los pesos no se eligen correctamente. Para corregir los pesos, debe utilizar un optimizador. El optimizador tradicional se llama Gradient Descent .

El descenso de gradiente toma la derivada y disminuye o aumenta el peso. Si la derivada es positiva, se reduce el peso. Si la derivada es negativa, el peso aumenta. El modelo actualizará los pesos y volverá a calcular el error. Este proceso se repite hasta que el error ya no cambia. Cada proceso se llama iteración . Además, los gradientes se multiplican por una tasa de aprendizaje. Indica la velocidad del aprendizaje.

Si la tasa de aprendizaje es demasiado pequeña, el algoritmo tardará mucho en converger (es decir, requiere muchas iteraciones). Si la tasa de aprendizaje es demasiado alta, es posible que el algoritmo nunca converja.

Como puede ver en la imagen de arriba, el modelo repite el proceso unas 20 veces antes para encontrar un valor estable para los pesos, alcanzando así el error más bajo.

Tenga en cuenta que el error no es igual a cero, pero se estabiliza alrededor de 5. Es decir, el modelo comete un error típico de 5. Si desea reducir el error, debe agregar más información al modelo, como más variables o utilizar diferentes estimadores.

Recuerdas la primera ecuación

Los pesos finales son 3.8 y 2.78. El video a continuación le muestra cómo el descenso de gradiente optimiza la función de pérdida para encontrar estos pesos

Cómo entrenar una regresión lineal con TensorFlow

Ahora que tiene una mejor comprensión de lo que está sucediendo detrás del capó, está listo para usar la API de estimador proporcionada por TensorFlow para entrenar su primera regresión lineal con TensorFlow.

Utilizará el conjunto de datos de Boston, que incluye las siguientes variables

crim	tasa de criminalidad per cápita por ciudad
zn	proporción de terreno residencial dividido en zonas para lotes de más de 25,000 pies cuadrados.
indus	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	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	Proporción alumno-maestro por ciudad
medv	Valor medio de las viviendas ocupadas por sus propietarios en miles de dólares

Creará tres conjuntos de datos diferentes:

conjunto de datos	objetivo	forma
Capacitación	Entrena el modelo y obtén los pesos	400, 10
Evaluación	Evaluar el rendimiento del modelo en datos no vistos.	100, 10
Predecir	Utilice el modelo para predecir el valor de la vivienda con datos nuevos	6, 10

Los objetivos son utilizar las características del conjunto de datos para predecir el valor de la casa.

Durante la segunda parte del tutorial, aprenderá a usar TensorFlow con tres formas diferentes de importar los datos:

• Con pandas
• Con Numpy
• Solo TF

Tenga en cuenta que todas las opciones proporcionan los mismos resultados.

Aprenderá a usar la API de alto nivel para compilar, entrenar y evaluar un modelo de regresión lineal de TensorFlow. Si estaba utilizando la API de bajo nivel, tenía que definir a mano:

• Función de pérdida
• Optimizar: descenso de gradiente
• Multiplicación de matrices
• Gráfico y tensor

Esto es tedioso y más complicado para los principiantes.

Pandas

Necesita importar las bibliotecas necesarias para entrenar el modelo.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools 

Paso 1) Importe los datos con panda.

Usted define los nombres de las columnas y las almacena en COLUMNAS. Puede utilizar pd.read_csv () para importar los datos.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

Puede imprimir la forma de los datos.

print(training_set.shape, test_set.shape, prediction_set.shape) 

Producción

(400, 10) (100, 10) (6, 10)

Tenga en cuenta que la etiqueta, es decir, su y, está incluida en el conjunto de datos. Entonces necesitas definir otras dos listas. Uno que contiene solo las características y otro con el nombre de la etiqueta únicamente. Estas dos listas le dirán a su estimador cuáles son las características en el conjunto de datos y qué nombre de columna es la etiqueta.

Se hace con el siguiente código.

FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv" 

Paso 2) Convierte los datos

Necesita convertir las variables numéricas en el formato adecuado. Tensorflow proporciona un método para convertir la variable continua: tf.feature_column.numeric_column ().

En el paso anterior, define una lista de una característica que desea incluir en el modelo. Ahora puede usar esta lista para convertirlos en datos numéricos. Si desea excluir características en su modelo, no dude en colocar una o más variables en la lista CARACTERÍSTICAS antes de construir feature_cols

Tenga en cuenta que utilizará la comprensión de la lista de Python con la lista CARACTERÍSTICAS para crear una nueva lista denominada feature_cols. Le ayuda a evitar escribir nueve veces tf.feature_column.numeric_column (). La comprensión de una lista es una forma más rápida y limpia de crear nuevas listas

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES] 

Paso 3) Defina el estimador

En este paso, debe definir el estimador. Actualmente, Tensorflow proporciona 6 estimadores prediseñados, incluidos 3 para la tarea de clasificación y 3 para la tarea de regresión de TensorFlow:

• Regresor
  • DNNRegresor
  • LinearRegressor
  • DNNLineaCombinedRegressor
• Clasificador
  • DNNClassifier
  • LinearClassifier
  • DNNLineaCombinedClassifier

En este tutorial, usará el regresor lineal. Para acceder a esta función, debe utilizar tf.estimator.

La función necesita dos argumentos:

• feature_columns: contiene las variables para incluir en el modelo
• model_dir: ruta para almacenar el gráfico, guardar los parámetros del modelo, etc.

Tensorflow creará automáticamente un archivo llamado train en su directorio de trabajo. Debe usar esta ruta para acceder a Tensorboard como se muestra en el siguiente ejemplo de regresión de TensorFlow.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train") 

Producción

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': '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}

La parte complicada de TensorFlow es la forma de alimentar el modelo. Tensorflow está diseñado para funcionar con computación paralela y conjuntos de datos muy grandes. Debido a la limitación de los recursos de la máquina, es imposible alimentar el modelo con todos los datos a la vez. Para eso, necesita alimentar un lote de datos cada vez. Tenga en cuenta que estamos hablando de un enorme conjunto de datos con millones o más de registros. Si no agrega el lote, terminará con un error de memoria.

Por ejemplo, si sus datos contienen 100 observaciones y define un tamaño de lote de 10, significa que el modelo verá 10 observaciones por cada iteración (10 * 10).

Cuando el modelo ha visto todos los datos, termina una época . Una época define cuántas veces desea que el modelo vea los datos. Es mejor establecer este paso en ninguno y dejar que el modelo realice la iteración varias veces.

Una segunda información para agregar es si desea mezclar los datos antes de cada iteración. Durante el entrenamiento, es importante mezclar los datos para que el modelo no aprenda un patrón específico del conjunto de datos. Si el modelo aprende los detalles del patrón subyacente de los datos, tendrá dificultades para generalizar la predicción para los datos invisibles. A esto se le llama sobreajuste . El modelo funciona bien con los datos de entrenamiento, pero no puede predecir correctamente los datos que no se ven.

TensorFlow hace que estos dos pasos sean fáciles de realizar. Cuando los datos van a la tubería, sabe cuántas observaciones necesita (lote) y si tiene que mezclar los datos.

Para indicarle a Tensorflow cómo alimentar el modelo, puede usar pandas_input_fn. Este objeto necesita 5 parámetros:

• x: datos de características
• y: etiqueta de datos
• batch_size: lote. Por defecto 128
• num_epoch: Número de época, por defecto 1
• Shuffle: Mezcla o no los datos. Por defecto, Ninguno

Necesita alimentar el modelo muchas veces para que defina una función para repetir este proceso. toda esta función get_input_fn.

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) 

El método habitual para evaluar el rendimiento de un modelo es:

• Entrena el modelo
• Evaluar el modelo en un conjunto de datos diferente
• Hacer predicción

El estimador de Tensorflow proporciona tres funciones diferentes para llevar a cabo estos tres pasos fácilmente.

Paso 4) : Entrena el modelo

Puede utilizar el tren de estimadores para evaluar el modelo. El estimador de trenes necesita input_fn y varios pasos. Puede utilizar la función que creó anteriormente para alimentar el modelo. Luego, le indica al modelo que repita 1000 veces. Tenga en cuenta que, no especifica el número de épocas, deja que el modelo se repita 1000 veces. Si establece el número de época en 1, el modelo iterará 4 veces: hay 400 registros en el conjunto de entrenamiento y el tamaño del lote es 128

1. 128 filas
2. 128 filas
3. 128 filas
4. 16 filas

Por lo tanto, es más fácil establecer el número de época en ninguno y definir el número de iteraciones como se muestra en el siguiente ejemplo de clasificación de TensorFlow.

estimator.train(input_fn=get_input_fn(training_set,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/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.

Puede verificar el Tensorboard con el siguiente comando:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train 

Paso 5) Evalúe su modelo

Puede evaluar el ajuste de su modelo en el conjunto de prueba con el siguiente código:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False)) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Puede imprimir la pérdida con el siguiente código:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score)) 

Producción

Loss: 3215.895996

El modelo tiene una pérdida de 3215. Puede verificar la estadística de resumen para tener una idea de qué tan grande es el error.

training_set['medv'].describe()

Producción

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64 

De la estadística resumida anterior, usted sabe que el precio promedio de una casa es de 22 mil, con un precio mínimo de 9 mil y máximo de 50 mil. El modelo comete un error típico de 3000 dólares.

Paso 6) Haz la predicción

Por último, puede utilizar el estimador de predicciones de TensorFlow para estimar el valor de 6 casas de Boston.

y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False)) 

Para imprimir los valores estimados de, puede utilizar este código:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions))) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

El modelo pronostica los siguientes valores:

casa	Predicción
1	32,29
2	18,96
3	27.27
4	29,29
5	16.43
7	21.46

Tenga en cuenta que no conocemos el verdadero valor de. En el tutorial de deep learning, intentarás superar el modelo lineal

Solución Numpy

Esta sección explica cómo entrenar el modelo usando un estimador numpy para alimentar los datos. El método es el mismo, excepto que usará el estimador numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). valores

test_set_n = pd.read_csv ("E: /boston_test.csv"). valores

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). valores

Paso 1) Importa los datos

En primer lugar, debe diferenciar las variables de función de la etiqueta. Debe hacer esto para los datos de entrenamiento y la evaluación. Es más rápido definir una función para dividir los datos.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train 

Puede usar la función para dividir la etiqueta de las características del conjunto de datos entrenar / evaluar

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n) 

Debe excluir la última columna del conjunto de datos de predicción porque solo contiene NaN

x_predict = prediction_set_n[:, :-2] 

Confirma la forma de la matriz. Tenga en cuenta que la etiqueta no debe tener una dimensión, significa (400,).

print(X_train.shape, y_train.shape, x_predict.shape) 

Producción

(400, 9) (400,) (6, 9) 

Puede construir las columnas de características de la siguiente manera:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])] 

El estimador se define como antes, usted indica las columnas de características y dónde guardar el gráfico.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1") 

Producción

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': '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} 

Puede utilizar el estimador numpy para alimentar los datos al modelo y luego entrenar el modelo. Tenga en cuenta que definimos la función input_fn antes para facilitar la legibilidad.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_train},y=y_train,batch_size=128,shuffle=False,num_epochs=None)estimator.train(input_fn = train_input,steps=5000) 

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 train1/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.INFO:tensorflow:Loss for final step: 5925.985.Out[23]:

Repite el mismo paso con un estimador diferente para evaluar su modelo

eval_input = tf.estimator.inputs.numpy_input_fn(x={"x": X_test},y=y_test,shuffle=False,batch_size=128,num_epochs=1)estimator.evaluate(eval_input,steps=None) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Por último, puede calcular la predicción. Debería ser similar a los pandas.

test_input = tf.estimator.inputs.numpy_input_fn(x={"x": x_predict},batch_size=128,num_epochs=1,shuffle=False)y = estimator.predict(test_input)predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions))) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Solución Tensorflow

La última sección está dedicada a una solución de TensorFlow. Este método es un poco más complicado que el otro.

Tenga en cuenta que si utiliza el cuaderno Jupyter, debe reiniciar y limpiar el kernel para ejecutar esta sesión.

TensorFlow ha creado una gran herramienta para pasar los datos a la canalización. En esta sección, usted mismo construirá la función input_fn.

Paso 1) Defina la ruta y el formato de los datos.

En primer lugar, declaras dos variables con la ruta del archivo csv. Tenga en cuenta que tiene dos archivos, uno para el conjunto de entrenamiento y otro para el conjunto de prueba.

import tensorflow as tf

df_train = "E:/boston_train.csv"

df_eval = "E:/boston_test.csv"

Luego, debe definir las columnas que desea usar desde el archivo csv. Usaremos todos. Después de eso, debe declarar el tipo de variable que es.

Las variables flotantes están definidas por [0.]

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]] 

Paso 2) Defina la función input_fn

La función se puede dividir en tres partes:

1. Importar los datos
2. Crea el iterador
3. Consume los datos

A continuación se muestra el código general para definir la función. El código se explicará después

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def parse_csv(value):columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)features = dict(zip(COLUMNS, columns))#labels = features.pop('median_house_value')labels = features.pop('medv')return features, labels# Extract lines from input files using theDataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file.skip(1) # Skip header row.map(parse_csv))dataset = dataset.repeat(num_epoch)dataset = dataset.batch(batch_size)# Step 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels 

** Importa los datos **

Para un archivo csv, el método del conjunto de datos lee una línea a la vez. Para construir el conjunto de datos, necesita usar el objeto TextLineDataset. Su conjunto de datos tiene un encabezado, por lo que debe usar skip (1) para omitir la primera línea. En este punto, solo lee los datos y excluye el encabezado en la canalización. Para alimentar el modelo, debe separar las características de la etiqueta. El método utilizado para aplicar cualquier transformación a los datos es map.

Este método llama a una función que usted creará para instruir cómo transformar los datos. En pocas palabras, debe pasar los datos en el objeto TextLineDataset, excluir el encabezado y aplicar una transformación que es instruida por una función.

• tf.data.TextLineDataset (data_file): esta línea lee el archivo csv
• .skip (1): omite el encabezado
• .map (parse_csv)): analiza los registros en los tensores Necesita definir una función para instruir al objeto del mapa. Puede llamar a esta función parse_csv.

Esta función analiza el archivo csv con el método tf.decode_csv y declara las características y la etiqueta. Las características se pueden declarar como un diccionario o una tupla. Utiliza el método del diccionario porque es más conveniente.

• tf.decode_csv (value, record_defaults = RECORDS_ALL): el método decode_csv usa la salida del TextLineDataset para leer el archivo csv. record_defaults instruye a TensorFlow sobre el tipo de columnas.
• dict (zip (_CSV_COLUMNS, columnas)): completa el diccionario con todas las columnas extraídas durante este procesamiento de datos
• features.pop ('median_house_value'): excluye la variable de destino de la variable de función y crea una variable de etiqueta

El conjunto de datos necesita más elementos para alimentar iterativamente los tensores. De hecho, debe agregar la repetición del método para permitir que el conjunto de datos continúe indefinidamente alimentando el modelo. Si no agrega el método, el modelo iterará solo una vez y luego arrojará un error porque no se alimentan más datos en la canalización.

Después de eso, puede controlar el tamaño del lote con el método por lotes. Significa que le dice al conjunto de datos cuántos datos desea pasar en la canalización para cada iteración. Si establece un tamaño de lote grande, el modelo será lento.

Paso 3) Crea el iterador

Ahora está listo para el segundo paso: cree un iterador para devolver los elementos en el conjunto de datos.

La forma más sencilla de crear un operador es con el método make_one_shot_iterator.

Después de eso, puede crear las características y etiquetas desde el iterador.

Paso 4) Consumir los datos

Puede comprobar lo que sucede con la función input_fn. Debe llamar a la función en una sesión para consumir los datos. Intenta con un tamaño de lote igual a 1.

Tenga en cuenta que imprime las características en un diccionario y la etiqueta como una matriz.

Mostrará la primera línea del archivo csv. Puede intentar ejecutar este código muchas veces con diferentes tamaños de lote.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)with tf.Session() as sess:first_batch = sess.run(next_batch)print(first_batch) 

Producción

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Paso 4) Defina la columna de características

Debe definir las columnas numéricas de la siguiente manera:

X1= tf.feature_column.numeric_column('crim')X2= tf.feature_column.numeric_column('zn')X3= tf.feature_column.numeric_column('indus')X4= tf.feature_column.numeric_column('nox')X5= tf.feature_column.numeric_column('rm')X6= tf.feature_column.numeric_column('age')X7= tf.feature_column.numeric_column('dis')X8= tf.feature_column.numeric_column('tax')X9= tf.feature_column.numeric_column('ptratio') 

Tenga en cuenta que debe combinar todas las variables en un depósito

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9] 

Paso 5) Construye el modelo

Puede entrenar el modelo con el estimador LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3') 

Producción

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': '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}

Necesita usar una función lambda para permitir escribir el argumento en la función inpu_fn. Si no usa una función lambda, no puede entrenar el modelo.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None)) 

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 train3/model.ckpt.INFO:tensorflow:loss = 83729.64, step = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.INFO:tensorflow:Loss for final step: 5925.9873.Out[8]:

Puede evaluar el ajuste de su modelo en el conjunto de prueba con el siguiente código:

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))for key in results:print(" {}, was: {}".format(key, results[key])) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

El último paso es predecir el valor de basado en el valor de, las matrices de las características. Puede escribir un diccionario con los valores que desea predecir. Su modelo tiene 9 características, por lo que debe proporcionar un valor para cada una. El modelo proporcionará una predicción para cada uno de ellos.

En el siguiente código, escribió los valores de cada característica que está contenida en el archivo csv df_predict.

Necesita escribir una nueva función input_fn porque no hay etiqueta en el conjunto de datos. Puede utilizar la API from_tensor del conjunto de datos.

prediction_input = {'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],'zn': [75.0,0.0,25.0,33.0,0.0,0.0],'indus': [2.95,18.10,5.13,2.18,18.10,9.90],'nox': [0.428,0.713,0.453,0.472,0.700,0.544],'rm': [7.024,6.297,6.762,7.236,5.390,5.782],'age': [15.8,91.8,43.4,41.1,98.9,71.7],'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],'tax': [252,666,284,222,666,304],'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]}def test_input_fn():dataset = tf.data.Dataset.from_tensors(prediction_input)return dataset# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn) 

Finalmente, imprime las predicciones.

for pred in enumerate(pred_results):print(pred) 

Producción

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.(0, {'predictions': array([32.297546], dtype=float32)})(1, {'predictions': array([18.96125], dtype=float32)})(2, {'predictions': array([27.270979], dtype=float32)})(3, {'predictions': array([29.299236], dtype=float32)})(4, {'predictions': array([16.436684], dtype=float32)})(5, {'predictions': array([21.460876], dtype=float32)})INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

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

En este instructivo, aprendió a usar la API de alto nivel para un estimador de TensorFlow 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.LinearRegressor (feature_columns, model_dir)
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 predicciones con train (), evaluar () y predecir ()