Regresión lineal con TensorFlow [Ejemplos]
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 muchos algoritmos de aprendizaje automático. Esta es la API de alto nivel. TensorFlow los llama estimadores
- API de bajo nivel: Construye la arquitectura, la optimización del modelo desde cero. Es complicado para un principiante
- API de alto nivel: defina el algoritmo. Es 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á sólo los estimadores. Los cálculos son más rápidos y son más fáciles de implementar. En la primera parte del tutorial se explica cómo utilizar el optimizador de descenso de gradiente para entrenar una regresión lineal. En una segunda parte, usará el dataset de Boston para predecir el precio de una casa usando el estimador TensorFlow.
En este tutorial, aprenderá:
- 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 de Tensorflow
Cómo entrenar un modelo de regresión lineal
Antes de comenzar a entrenar el modelo, echemos un vistazo a lo que es una regresión lineal.
Imagine que tiene dos variables, x e y y su tarea es predecir el valor de conocer el valor de. Si traza los datos, puede ver una relación positiva entre la variable independiente, x y la variable dependiente y.
Puede observar, si x=1, y será aproximadamente igual a 6 y si x=2, y estará 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 tiene que escribir esta ecuación, será:
Con:
es el sesgo. es decir, si x=0, y=
es el peso asociado a x
es el residual o el error del modelo. Incluye lo que el modelo no puede aprender de los datos
Imagine que se ajusta al modelo y encuentra 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 para y. Es decir, puede reemplazar x con cualquier valor que desee predecir y. En la imagen de abajo, hemos reemplazado x en la ecuación con todos los valores del dataset y trazar 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 cualquiera que pertenece a la línea roja. También puede predecir valores de x mayor que 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 mira 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, género, estado civil).
El análisis tradicional intentará predecir la venta calculando el promedio de cada variable y tratando de estimar la venta para diferentes escenarios. Esto conducirá a predicciones deficientes y restringirá el análisis al escenario elegido.
Si usa 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 y
reemplazará el valor de x para obtener el valor previsto de y. Si el dataset tiene 100 observaciones, el algoritmo calcula 100 valores predichos.
Podemos calcular el error, señalado del modelo, que es la diferencia entre el valor previsto 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.
Su 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 cuadrado medio, también llamado MSE. Matemáticamente, es:
Dónde:
son los pesos por lo
que se refiere al valor predicho
- y es los valores reales
- m es el número de observaciones
Tenga en cuenta que significa que usa la transposición de las matrices. El
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 usar un optimizador. El optimizador tradicional se llama Descenso degradado.
El descenso de gradiente toma el derivado y disminuye o aumenta el peso. Si el derivado es positivo, el peso disminuye. Si el derivado es negativo, 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 denomina 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, tomará mucho tiempo para que el algoritmo converja (es decir, requiere muchas iteraciones). Si la tasa de aprendizaje es demasiado alta, es posible que el algoritmo nunca converja.
Se 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. Significa que el modelo hace 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 siguiente video 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 estimador proporcionada por TensorFlow para entrenar su primera regresión lineal.
Utilizará el conjunto de datos de Boston, que incluye las siguientes variables
tasa | criminalidad per cápita por ciudad |
---|---|
zn | proporción de terrenos residenciales en zonas 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 |
age | proporción de unidades ocupadas por sus propietarios construidas antes de 1940 |
dis | distancias ponderadas a cinco centros de empleo de Boston |
tax | tasa de impuesto a la propiedad valor completo por dólares 10.000 |
ptratio | Proporción alumnos/maestro por ciudad |
medv | Valor medio de las viviendas ocupadas por sus propietarios en miles de dólares |
Creará tres conjuntos de datos diferentes:
dataset | objetivo | forma |
---|---|---|
Formación | Entrenar el modelo y obtener los pesos | 400, 10 |
Evaluación | Evaluar el desempeño del modelo sobre datos no vistos | 100, 10 |
Predecir | Utilice el modelo para predecir el valor de la casa en los 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á a usar TensorFlow con tres formas diferentes de importar los datos:
- Con Pandas
- Con Numpy
- Sólo TF
Tenga en cuenta que, todas las opciones proporcionan los mismos resultados.
Aprenderá a usar la API de alto nivel para construir, entrenar a evaluar un modelo de regresión lineal. Si estaba usando la API de bajo nivel, tenía que definir a mano el:
- 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 principiantes.
Pandas
Debe importar las bibliotecas necesarias para entrenar el modelo.
1 2 3 4 |
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools |
Paso 1) Importar los datos con panda.
Defina los nombres de las columnas y los almacene en COLUMNAS. Puede utilizar pd.read_csv () para importar los datos.
1 2 |
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=Columnas)
test_set = pd.read_csv (“E: /boston_test.csv”, skipInitialSpace=True, skiprows=1, names=Columnas)
prediction_set = pd.read_csv (“E: /boston_predict.csv”, skipInitialSpace=True, skiprows=1, names=Columnas)
Puede imprimir la forma de los datos.
1 |
print(training_set.shape, test_set.shape, prediction_set.shape) |
Salida
1 |
(400, 10) (100, 10) (6, 10) |
Tenga en cuenta que la etiqueta, es decir, su y, está incluida en el conjunto de datos. Por lo tanto, debe definir otras dos listas. Uno que contiene sólo las entidades y otro con el nombre de la etiqueta solamente. Estas dos listas le indicarán a su estimador cuáles son las entidades en el dataset y qué nombre de columna es la etiqueta
Se hace con el siguiente código.
1 2 3 |
FEATURES = ["crim", "zn", "indus", "nox", "rm", "age", "dis", "tax", "ptratio"] LABEL = "medv" |
Paso 2) Convertir los datos
Necesita convertir las variables numéricas en el formato adecuado. Tensorflow proporciona un método para convertir variable continua: tf.feature_column.numeric_column ().
En el paso anterior, se define una lista de una función que se desea incluir en el modelo. Ahora puede usar esta lista para convertirlos en datos numéricos. Si desea excluir entidades en su modelo, no dude en soltar una o más variables en la lista FACTIONS antes de construir el feature_cols
Tenga en cuenta que utilizará la comprensión de la lista de Python con la lista FACTIONS para crear una nueva lista llamada feature_cols. Le ayuda a evitar escribir nueve veces tf.feature_column.numeric_column (). Una comprensión de listas es una forma más rápida y limpia de crear nuevas listas
1 |
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES] |
Paso 3) Definir el estimador
En este paso, debe definir el estimador. Tensorflow proporciona actualmente 6 estimadores preconstruidos, incluidos 3 para la tarea de clasificación y 3 para la tarea de regresión:
- Retrocedor
- No regresor
- Linealregresor
- DNNLineaCombinedRegressor
- Clasificador
- Clasificador DNN
- LinearClassifier
- DNNLineaCombinedClassifier
En este aprendizaje, utilizará el Retrocesor lineal. Para acceder a esta función, debe usar 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 usar esta ruta para acceder al Tensorboard.
1 2 3 |
estimator = tf.estimator.LinearRegressor( feature_columns=feature_cols, model_dir="train") |
Salida
1 2 3 4 5 6 7 8 9 |
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 difícil con TensorFlow es la forma de alimentar el modelo. Tensorflow está diseñado para trabajar con computación paralela y un conjunto de datos muy grande. 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 registros. Si no agrega 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, 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 el número de iteración de tiempo.
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 el patrón específico del dataset. Si el modelo aprende los detalles del patrón subyacente de los datos, tendrá dificultades para generalizar la predicción de datos no vistos. Esto se llama sobreajuste. El modelo funciona bien en los datos de entrenamiento, pero no puede predecir correctamente los datos no vistos.
TensorFlow hace que estos dos pasos sean fáciles de hacer. Cuando los datos van a la canalización, sabe cuántas observaciones necesita (lote) y si tiene que barajar los datos.
Para indicar a Tensorflow cómo alimentar el modelo, puede usar pandas_input_fn. Este objeto necesita 5 parámetros:
- x: datos de entidad
- y: datos de etiqueta
- batch_size: lote. Por defecto 128
- num_epoch: Número de épocas, por defecto 1
- shuffle: aleatoria o no los datos. De forma predeterminada, Ninguno
Necesita alimentar el modelo muchas veces para definir una función para repetir este proceso. toda esta función get_input_fn.
1 2 3 4 5 6 7 |
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:
- Entrenar el modelo
- Evaluar el modelo en un dataset diferente
- Hacer predicción
El estimador Tensorflow proporciona tres funciones diferentes para llevar a cabo estos tres pasos fácilmente.
Paso 4): Entrenar el modelo
Puede utilizar el tren estimador para evaluar el modelo. El estimador del tren necesita una input_fn y una serie de pasos. Puede utilizar la función creada anteriormente para alimentar el modelo. A continuación, indica al modelo que itere 1000 veces. Tenga en cuenta que, no se especifica el número de épocas, se deja que el modelo itera 1000 veces. Si establece el número de épocas en 1, el modelo iterará 4 veces: hay 400 registros en el conjunto de entrenamiento y el tamaño del lote es 128
- 128 filas
- 128 filas
- 128 filas
- 16 filas
Por lo tanto, es más fácil establecer el número de época en none y definir el número de iteración.
1 2 3 4 5 |
estimator.train(input_fn=get_input_fn(training_set, num_epochs=None, n_batch = 128, shuffle=False), steps=1000) |
Salida
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
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. |
Puede comprobar que el Tensorboard será el siguiente comando:
1 2 3 4 5 |
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train |
Paso 5) Evalúe su modelo
Puede evaluar el ajuste de su modelo en el conjunto de pruebas con el siguiente código:
1 2 3 4 5 |
ev = estimator.evaluate( input_fn=get_input_fn(test_set, num_epochs=1, n_batch = 128, shuffle=False)) |
Salida
1 2 3 4 5 6 7 8 9 10 |
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:
1 2 |
loss_score = ev["loss"] print("Loss: {0:f}".format(loss_score)) |
Salida
1 |
Loss: 3215.895996 |
El modelo tiene una pérdida de 3215. Puede consultar la estadística de resumen para tener una idea de lo grande que es el error.
1 |
training_set['medv'].describe() |
Salida
1 2 3 4 5 6 7 8 9 |
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 |
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 miles y máximo de 50 mil. El modelo hace un error típico de 3k dólares.
Paso 6) Hacer la predicción
Finalmente, se puede utilizar el estimador predicen para estimar el valor de 6 casas de Boston.
1 2 3 4 5 |
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 usar este código:
1 2 |
predictions = list(p["predictions"] for p in itertools.islice(y, 6)) print("Predictions: {}".format(str(predictions))) |
Salida
1 2 3 4 5 6 7 |
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 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 sabemos el verdadero valor de. En el tutorial de aprendizaje profundo, tratarás de vencer al modelo lineal
Solución Numpy
En esta sección se explica cómo entrenar el modelo usando un estimador numpy para alimentar los datos. El método es el mismo exept que usará numpy_input_fn estimador.
training_set_n = pd.read_csv (“E: /boston_train.csv”) .values
test_set_n = pd.read_csv (“E: /boston_test.csv”) .values
prediction_set_n = pd.read_csv (“E: /boston_predict.csv”) .values
Paso 1) Importar los datos
En primer lugar, debe diferenciar las variables de entidad 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.
1 2 3 4 |
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 entidades del dataset de entrenar/evaluar
1 2 |
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n) |
Debe excluir la última columna del dataset de predicción porque contiene solo NaN
1 |
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,).
1 |
print(X_train.shape, y_train.shape, x_predict.shape) |
Salida
1 |
(400, 9) (400,) (6, 9) |
Puede construir las columnas de entidades de la siguiente manera:
1 |
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])] |
El estimador se define como antes, indica las columnas de entidades y dónde guardar el gráfico.
1 2 3 |
estimator = tf.estimator.LinearRegressor( feature_columns=feature_columns, model_dir="train1") |
Salida
1 2 3 4 5 6 7 8 9 10 |
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 usar el estimapor 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.
1 2 3 4 5 6 7 |
# 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
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> |
Replicar el mismo paso con un estimador diferente para evaluar el modelo
1 2 3 4 5 6 7 |
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
1 2 3 4 5 6 7 8 9 10 11 12 |
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.
1 2 3 4 5 6 7 8 |
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
1 2 3 4 5 6 7 8 9 |
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 Tensorflow
La última sección está dedicada a una solución TensorFlow. Este método es ligeramente más complicado que el otro.
Tenga en cuenta que si usa Jupyter notebook, 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, construirá la función input_fn usted mismo.
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 pruebas.
1 |
import tensorflow as tf |
1 |
df_train = "E:/boston_train.csv" |
1 |
df_eval = "E:/boston_test.csv" |
Luego, debe definir las columnas que desea usar desde el archivo csv. Lo usaremos todo. Después de eso, debe declarar el tipo de variable que es.
Las variables flotantes se definen por [0.]
1 2 3 |
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:
- Importar los datos
- Crear el iterador
- Consumir los datos
A continuación se muestra el código overal para definir la función. El código se explicará después de
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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 de conjunto de datos lee una línea a la vez. Para crear el conjunto de datos, debe usar el objeto TextLineDataSet. Su dataset tiene un encabezado por lo que necesita 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 entidades 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 va a crear con el fin de instruir cómo transformar los datos.En pocas palabras, es necesario pasar los datos en el objeto TextLineDataSet, excluir el encabezado y aplicar una transformación que se indica por una explicación function.Code
- tf.data.TextLineDataSet (data_file): Esta línea lee el archivo csv
- .skip (1): omita el encabezado
- .map (parse_csv)): analizar los registros en los tensorsEs necesario definir una función para indicar el objeto de 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 entidades se pueden declarar como un diccionario o una tupla. Utilice el método de diccionario porque es más conveniente.Explicación de código
- tf.decode_csv (valor, record_defaults= RECORDS_ALL): el método decode_csv utiliza la salida del TextLineDataSet para leer el archivo csv. record_defaults instruye a TensorFlow sobre el tipo de columnas.
- dict (zip (_CSV_COLUMNS, columns)): Rellene el diccionario con todas las columnas extraídas durante este procesamiento de datos
- features.pop (‘median_house_value’): Excluya la variable de destino de la variable de entidad y cree 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 dataset continúe indefinidamente para alimentar 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 batch. Significa que le dice al dataset 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) Crear el iterador
Ahora está listo para el segundo paso: cree un iterador para devolver los elementos en el dataset.
La forma más simple de crear un operador es con el método make_one_shot_iterator.
Después de eso, puede crear las entidades 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 entidades en un diccionario y la etiqueta como una matriz.
Se mostrará la primera línea del archivo csv. Puede intentar ejecutar este código muchas veces con diferentes tamaños de lote.
1 2 3 4 |
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
1 2 3 4 5 |
({'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 entidades
Debe definir las columnas numéricas de la siguiente manera:
1 2 3 4 5 6 7 8 9 |
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 necesita combinar todas las variables en un bucket
1 |
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9] |
Paso 5) Construir el modelo
Puede entrenar el modelo con el estimador LinearRegresor.
1 |
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3') |
Salida
1 2 3 4 5 6 7 8 9 |
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 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.
1 2 |
# Train the estimatormodel.train(steps =1000, input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None)) |
Salida
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
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 pruebas con el siguiente código:
1 2 3 |
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
1 2 3 4 5 6 7 8 9 10 11 12 |
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 basado en el valor de, las matrices de las entidades. 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 elemento que está contenido en el archivo df_predict csv.
Necesita escribir una nueva función input_fn porque no hay etiqueta en el dataset. Puede usar la API from_tensor desde el conjunto de datos.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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) |
Por fin, imprime las predicciones.
1 2 |
for pred in enumerate(pred_results): print(pred) |
Salida
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
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 a un modelo, necesita:
- Definir las características: Variables independientes: X
- Definir la etiqueta: Variable dependiente: y
- Construir un tren o conjunto de pruebas
- 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 épocas
- Tamaño del lote
En este tutorial, aprendió a utilizar la API de alto nivel para un estimador de regresión lineal. Necesita definir:
- Columnas de entidades. Si es continuo: tf.feature_column.numeric_column (). Puede rellenar una lista con la comprensión de la lista de python
- El estimador: tf.estimator.lineRetrassor (feature_columns, model_dir)
- Una función para importar los datos, el tamaño del lote y la época: input_fn ()
Después de eso, usted está listo para entrenar, evaluar y hacer predicciones con train (), evaluate () y predict ()
Leave a Reply
Want to join the discussion?Feel free to contribute!