Tutorial de regresión lineal con TensorFlow [Ejemplos]

¿Qué es la regresión lineal?

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 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 muchas máquina de aprendizaje algoritmos. Esta es la API de alto nivel. TensorFlow los llama estimadores

  • API de bajo nivel: construir el architectura, optimización del modelo desde cero. Es complicado para un principiante.
  • API de alto nivel: Defina el algoritmo. Es más fácil. TensorFlow proporciona una herramientabox , que son estimador construir, entrenar, evaluar y hacer una predicción.

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

Descargar el conjunto de datos de Boston

Cómo entrenar un modelo de regresión lineal

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

Imagina que tienes dos variables, x e y, y tu tarea es predecir el valor de kno.wing El valor de . Si traza los datos, puede ver una relación positiva entre su variable independiente, x y su variable dependiente y.

Entrenar un modelo de regresión lineal

Puede observar que si x=1,y será aproximadamente igual a 6 y si x=2,y será aproximadamente 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á:

Entrenar un modelo de regresión lineal

Con:

  • Regresión lineal con TensorFlow es el sesgo. es decir, si x=0, y=Entrenar un modelo de regresión lineal
  • Entrenar un modelo de regresión lineal es el peso asociado a x
  • Entrenar un modelo de regresión lineal es el residual o el error del modelo. Incluye lo que el modelo no puede aprender de los datos.

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

  • Entrenar un modelo de regresión lineal = 3.8
  • Entrenar un modelo de regresión lineal = 2.78

Puedes sustituir esos números en la ecuación y queda:

y= 3.8 + 2.78x

Ahora tienes una mejor manera de encontrar los valores de y. Es decir, puedes reemplazar x con cualquier valor que quieras predecir y. En la imagen a continuación, reemplazamos x en la ecuación con todos los valores en el conjunto de datos y trazamos el resultado.

Entrenar un modelo de regresión lineal

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

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

Veamos un ejemplo. Imagine que quiere 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 e intentará estimar la venta para diferentes escenarios. Conducirá a predicciones deficientes y restringirá el análisis al escenario elegido.

Si usas regresión lineal, puedes escribir esta ecuación:

Entrenar un modelo de regresión lineal

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

Como funciona el algoritmo

Funcionamiento del algoritmo

El algoritmo elegirá un número aleatorio para cada Regresión lineal con TensorFlow y Funcionamiento del algoritmo y reemplace el valor de x para obtener el valor previsto de y. Si el conjunto de datos tiene 100 observaciones, el algoritmo calcula 100 valores predichos.

Podemos calcular el error, observado Funcionamiento del algoritmo del 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.

Funcionamiento del algoritmo

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

Funcionamiento del algoritmo

Lugar:

  • Funcionamiento del algoritmo ¿Son los pesos así? Funcionamiento del algoritmo se refiere al valor predicho
  • y son los valores reales
  • m es el número de observaciones

Tenga en cuenta que Funcionamiento del algoritmo significa que utiliza la transpuesta de las matrices. El Funcionamiento del algoritmo es la notación matemática de la media.

El objetivo es encontrar lo mejor. Funcionamiento del algoritmo que minimizan 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, es necesario utilizar un optimizador. El optimizador tradicional se llama Descenso de gradiente.

El descenso de gradiente toma la derivada y disminuye o aumenta el peso. Si la derivada es positiva, el peso disminuye. 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 cambie. 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 tiempo en converger (es decir, requiere muchas iteraciones). Si la tasa de aprendizaje es demasiado alta, es posible que el algoritmo nunca converja.

Funcionamiento del algoritmo

Puede ver en la imagen de arriba que el modelo repite el proceso unas 20 veces antes de 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 sino que se estabiliza alrededor de 5. Es decir, el modelo comete un error típico de 5. Si desea reducir el error, necesita agregar más información al modelo, como más variables o usar diferentes estimadores. .

¿Recuerdas la primera ecuación?

Funcionamiento del algoritmo

Los pesos finales son 3.8 y 2.78. El siguiente vídeo 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 comprende mejor lo que sucede detrás del capó, está listo para usar la API del estimador proporcionada por TensorFlow para entrenar su primera regresión lineal usando TensorFlow.

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

criminal tasa de criminalidad per cápita por ciudad
zn proporción de terreno residencial zonificado para lotes de más de 25,000 pies cuadrados.
indus Proporción de acres de negocios 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
des distancias ponderadas a cinco centros de empleo de Boston
deuda tasa de impuesto a la propiedad de valor total por dólares 10,000
ptratio ratio alumnos-maestro por localidad
médico Valor medio de las viviendas ocupadas por sus propietarios en miles de dólares

Creará tres conjuntos de datos diferentes:

datos objetivo dar forma a
Formacion Entrena el modelo y obtén los pesos. 400, 10
Evaluación Evaluar el rendimiento del modelo con datos invisibles. 100, 10
Predicción Utilice el modelo para predecir el valor de la vivienda a partir de nuevos datos 6, 10

El objetivo es utilizar las características del conjunto de datos para predecir el valor de la casa.

Durante la segunda parte del tutorial, aprenderá cómo usar TensorFlow con tres formas diferentes de importar datos:

  • Con pandas
  • Con Numpy
  • Sólo TF

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

Aprenderá a utilizar la API de alto nivel para crear, entrenar y evaluar un modelo de regresión lineal de TensorFlow. Si estaba utilizando la API de bajo nivel, debía definir manualmente:

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

Esto es tedioso y más complicado para principiantes.

pandas

Debe importar las bibliotecas necesarias para entrenar el modelo.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Paso 1) Importar los datos con panda.

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

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

conjunto_entrenamiento = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=True,skiprows=1, nombres=COLUMNAS)

test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, nombres=COLUMNAS)

predict_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, nombres=COLUMNAS)

Puede imprimir la forma de los datos.

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

Salida

(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 solo con el nombre de la etiqueta. Estas dos listas le indicarán a su estimador cuáles son las características del 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) Convertir los datos

Debe convertir las variables numéricas al formato adecuado. Tensorflow proporciona un método para convertir variables continuas: tf.feature_column.numeric_column().

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

Tenga en cuenta que utilizará la comprensión de listas de Python con la lista FEATURES para crear una nueva lista llamada feature_cols. Le ayuda a evitar escribir nueve veces tf.feature_column.numeric_column(). La comprensión de listas 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) Definir el estimador

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

  • Regresor
    • DNNRegresor
    • Regresor lineal
    • DNNLineaCombinedRegresor
  • clasificar
    • Clasificador DNN
    • Clasificador lineal
    • DNNLineaCombinedClassifier

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

La función necesita dos argumentos:

  • feature_columns: Contiene las variables a 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 utilizar 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")

Salida

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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_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 ello, debe introducir un lote de datos cada vez. Tenga en cuenta que estamos hablando de un conjunto de datos enorme 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 para cada iteración (10*10).

Cuando el modelo ha visto todos los datos, finaliza uno. é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 una cantidad de iteraciones varias veces.

Una segunda información a 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 el details del patrón subyacente de los datos, tendrá dificultades para generalizar la predicción para datos no vistos. Se llama sobreajuste. El modelo funciona bien con los datos de entrenamiento, pero no puede predecir correctamente los datos invisibles.

TensorFlow facilita estos dos pasos. Cuando los datos van a la tubería, sabe cuántas observaciones necesita (por lotes) 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: datos de la etiqueta
  • tamaño_lote: lote. Por defecto 128
  • num_epoch: número de época, por defecto 1
  • shuffle: Mezcla o no los datos. Por defecto, Ninguno

Debe alimentar el modelo muchas veces para definir 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 desempeño de un modelo es:

  • Entrenar a la 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 estimador para evaluar el modelo. El estimador de trenes necesita un 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 la cantidad de épocas, deja que el modelo repita 1000 veces. Si establece el número de época en 1, el modelo se repetirá 4 veces: hay 400 registros en el conjunto de entrenamiento y el tamaño del lote es 128

  1. Filas 128
  2. Filas 128
  3. Filas 128
  4. Filas 16

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)

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 train/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 238.616
INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)
INFO:tensorflow:global_step/sec: 314.293
INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)
INFO:tensorflow:global_step/sec: 303.863
INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)
INFO:tensorflow:global_step/sec: 308.782
INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)
INFO:tensorflow:global_step/sec: 244.969
INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)
INFO:tensorflow:global_step/sec: 155.966
INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)
INFO:tensorflow:global_step/sec: 263.256
INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)
INFO:tensorflow:global_step/sec: 254.112
INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)
INFO:tensorflow:global_step/sec: 292.405
INFO: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.

Puedes consultar el Tensorboard de la siguiente manera.wing mando:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

Paso 5) Evalúa tu 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))

Salida

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13
INFO: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))

Salida

Loss: 3215.895996

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

training_set['medv'].describe()

Salida

count    400.000000
mean      22.625500
std        9.572593
min        5.000000
25%       16.600000
50%       21.400000
75%       25.025000
max       50.000000
Name: medv, dtype: float64

Del resumen estadístico anterior, sabes que el precio promedio de una casa es de 22 mil, con un precio mínimo de 9 mil y un máximo de 50 mil. El modelo comete un error típico de 3 dólares.

Paso 6) hacer la predicción

Finalmente, puede utilizar el estimador TensorFlow predict 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)))

Salida

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO: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 pronosticó lo siguiente.wing valores:

Hogar 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 valor real de . En el tutorial de aprendizaje profundo, intentarás superar el modelo lineal.

Solución numerosa

Esta sección explica cómo entrenar el modelo utilizando un estimador numpy para alimentar los datos. El método es el mismo excepto que utilizará 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

predict_set_n = pd.read_csv(“E:/boston_predict.csv”).valores

Paso 1) Importar los datos

En primer lugar, es necesario diferenciar las variables de características 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 utilizar la función para dividir la etiqueta de las características del conjunto de datos de entrenamiento/evaluación.

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]

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

Salida

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

Salida

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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_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)

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 train1/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 490.057
INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)
INFO:tensorflow:global_step/sec: 788.986
INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)
INFO:tensorflow:global_step/sec: 736.339
INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)
INFO:tensorflow:global_step/sec: 383.305
INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)
INFO:tensorflow:global_step/sec: 859.832
INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)
INFO:tensorflow:global_step/sec: 804.394
INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)
INFO:tensorflow:global_step/sec: 753.059
INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)
INFO:tensorflow:global_step/sec: 402.165
INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)
INFO:tensorflow:global_step/sec: 344.022
INFO: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]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>

Replicas el mismo paso con un estimador diferente para evaluar tu 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)

Salida

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

Finalmente, puedes 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)))

Salida

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO: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 de flujo tensor

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

Tenga en cuenta que si usa Jupyter cuaderno, necesita 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 creará la función input_fn.

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

En primer lugar, declara 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 utilizar del archivo csv. Usaremos todos. Después de eso, debes 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) Definir la función input_fn

La función se puede dividir en tres partes:

  1. Importar los datos
  2. Crear el iterador
  3. Consumir 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 1				
          def 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 the 
          Dataset 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 3    
          iterator = dataset.make_one_shot_iterator()    
          features, labels = iterator.get_next()    
          return features, labels

**Importar 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. TextLineConjunto de datos. 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 de 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 el mapa.

Este método llama a una función que usted creará para indicarle cómo transformar los datos. En pocas palabras, debe pasar los datos en el TextLineObjeto de conjunto de datos, excluye el encabezado y aplica una transformación instruida por una función. Explicación del código

  • tf.datos.TextLineConjunto de datos (archivo_datos): esta línea lee el archivo csv
  • .skip(1): omite el encabezado
  • .map(parse_csv)): analiza los registros en los tensores. Debe definir una función para instruir al objeto del mapa. Puedes llamar a esta función parse_csv.

Esta función analiza el archivo csv con el método tf.decode_csv y declares 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. Explicación del código

  • tf.decode_csv(value, record_defaults= RECORDS_ALL): el método decode_csv utiliza la salida del TextLineConjunto de datos para leer el archivo csv. record_defaults indica 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.
  • características.pop ('median_house_value'): excluye la variable de destino de la variable de característica y crea una variable de etiqueta

El conjunto de datos necesita más elementos para alimentar iterativamente a los tensores. De hecho, es necesario agregar el método repetir para permitir que el conjunto de datos continúe indefinidamente para alimentar el modelo. Si no agrega el método, el modelo se repetirá solo una vez y luego arrojará un error porque no se ingresan más datos en la tubería.

Después de eso, puedes 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 del 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 funciones y etiquetas desde el iterador.

Paso 4) Consumir los datos

Puedes comprobar qué sucede con la función input_fn. Debe llamar a la función en una sesión para consumir los datos. Pruebe 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)

Salida

({'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) Definir 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

Puedes entrenar el modelo con el estimador LinearRegressor.

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

Salida

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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_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 utilizar una función lambda para permitir escribir el argumento en la función inpu_fn. Si no usas un función lambda, no puedes entrenar el modelo.

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

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 train3/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 72.5646
INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)
INFO:tensorflow:global_step/sec: 101.355
INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)
INFO:tensorflow:global_step/sec: 109.293
INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)
INFO:tensorflow:global_step/sec: 102.235
INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)
INFO:tensorflow:global_step/sec: 104.656
INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)
INFO:tensorflow:global_step/sec: 106.697
INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)
INFO:tensorflow:global_step/sec: 118.454
INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)
INFO:tensorflow:global_step/sec: 114.947
INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)
INFO:tensorflow:global_step/sec: 111.484
INFO: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]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>

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

Salida

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

El último paso es predecir el valor de en función del valor de las matrices de las características. Puedes escribir un diccionario con los valores que deseas 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 código siguiente, escribió los valores de cada característica contenida en el archivo csv df_predict.

Debe escribir una nueva función input_fn porque no hay ninguna 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, imprimes las predicciones.

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

Salida

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO: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, necesitas:

  • Definir las características: Variables independientes: X
  • Defina la etiqueta: Variable dependiente: y
  • Construir un tren/conjunto 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 tutorial, aprendió a usar la API de alto nivel para un estimador de regresión lineal TensorFlow. Necesitas definir:

  1. Columnas de características. Si es continuo: tf.feature_column.numeric_column(). Puede completar una lista con comprensión de 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(), evalua() y predict().