Curso Tensorflow con Anaconda - 6. Ejemplo predicción precios (1)

6. Ejemplo predicción precios (1)

• Hola a todos.Vamos continuar con nuestro curso dedicado al aprendizaje automático.Para ello nos basaremos en un curso de google dedicado a este tema. En este enlace tenéis el curso al completo en castellano: https://developers.google.com/machine-learning/crash-course/ml-intro?hl=es

• Una vez que hemos visto un ejemplo de uso de la API Pandas en la anterior entrada del blog. En esta ocasión vamos a empezar a usar la librería Tensorflow. El objeto de este ejemplo es aprender los conceptos fundamentales de TensorFlow. Usaremos la clase LinearRegressor en  para predecir el precio promedio de la vivienda, basado en una característica de entrada.

• Toda la documentación de esta librería la tenemos en https://www.tensorflow.org/tutorials/?hl=es

• En el vídeo vemos como predecir el precio de la vivienda en california en función a unos datos de entrada.

• Os dejo el código visto en el vídeo:

from __future__ import print_function

#Importamos las librerias necesarias para este ejemplo

import math

from IPython import display

from matplotlib import cm

from matplotlib import gridspec

from matplotlib import pyplot as plt

import numpy as np

import pandas as pd

from sklearn import metrics

import tensorflow as tf

from tensorflow.python.data import Dataset

#preparamos los mensajes de registro para la depuración

tf.logging.set_verbosity(tf.logging.ERROR)

pd.options.display.max_rows = 10

pd.options.display.float_format = '{:.1f}'.format

#cargamos el conjunto de datos con el que trabajaremos.Para más detalles ver el vídeo anterior.

california_housing_dataframe = pd.read_csv("https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv", sep=",")

#Haremos una distribución aleatoria de los datos y escalaremos median_house_value para estar en #unidades de miles

#para que pueda aprenderse un poco más fácilmente con las tasas de aprendizaje en un rango que #usualmente usamos.

california_housing_dataframe = california_housing_dataframe.reindex(

np.random.permutation(california_housing_dataframe.index))

california_housing_dataframe["median_house_value"] /= 1000.0

california_housing_dataframe

california_housing_dataframe.describe()

# Como el objetivo o target es predecir el valor medio de la vivienda utilizaremos como característica #de  entrada el número de habitaciones. median_house_value es nuestra etiqueta y total_rooms es #nuestra característca de entrada.

my_feature = california_housing_dataframe[["total_rooms"]]

feature_columns = [tf.feature_column.numeric_column("total_rooms")]

targets = california_housing_dataframe["median_house_value"]

# Configuramos la interfaz LinearRegressor de la API  de tensorflow Estimator

# https://www.tensorflow.org/api_docs/python/tf/estimator/LinearRegressor

# usamosremos el método GradientDescentOptimizer para entrenar al modelo

my_optimizer=tf.train.GradientDescentOptimizer(learning_rate=0.0000001)

my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)

# configuramos modelo de regresión lineal con nuestra columna de característica y el optimizador

linear_regressor = tf.estimator.LinearRegressor(feature_columns=feature_columns,optimizer=my_optimizer)

#función que utilizaremos para trata los datos de entrada

def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):

    """Entrena un modelo de regresión lineal de una característica.

    Parametros de entrada: 

    features: DataFrame de características

      targets:  DataFrame de objetivos

      batch_size: Tamaño de los lotes a pasar al modelo.

      shuffle: Verdadero o falso mezclar los datos 

      num_epochs:Número de iteracciones. None = se repite infinitamanete

    Returns:

      Tupla de (características, etiquetas) para el siguiente lote de datos

    """

  

    # Convertimos en un dict de arrays numpy.

    features = {key:np.array(value) for key,value in dict(features).items()}                                           

    # Lo colocamos como un objeto Dataset de tensorflow,damos un tamaño a cada lote y asignamos el #numero de iteraciones

    ds = Dataset.from_tensor_slices((features,targets))

    ds = ds.batch(batch_size).repeat(num_epochs)

    

    if shuffle:

      ds = ds.shuffle(buffer_size=10000)

    

    # Devolevemos el nuevo lote datos

    features, labels = ds.make_one_shot_iterator().get_next()

    return features, labels

#ENTRENAMIENTO DEL MODELO

#parar empezar a entrenar al modelo llamamos a la función que acabamos de crear

_ = linear_regressor.train(

    input_fn = lambda:my_input_fn(my_feature, targets),

    steps=100

)

#EVALUACIÖN DEL MODELO

# Creamos una función de entrada para nuestras nuestras predicciones

prediction_input_fn =lambda: my_input_fn(my_feature, targets, num_epochs=1, shuffle=False)

# llamamos al método predict que se encargar de hacer las predicciones

predictions = linear_regressor.predict(input_fn=prediction_input_fn)

# Pasamos predicciones a array NumPy para poder ahcer los calculos

predictions = np.array([item['predictions'][0] for item in predictions])

# Mostramos por pantalla el error cuadratico medio y su raiz que es el valor que utilizaremos para #evaluar

mean_squared_error = metrics.mean_squared_error(predictions, targets)

root_mean_squared_error = math.sqrt(mean_squared_error)

print("Error cuadrático medio de los datos entrenados: %0.3f" % mean_squared_error)

print("Raiz Error cuadrático medio de los datos entrenados %0.3f" % root_mean_squared_error)

#para ver si el modelo es bueno o malo comparamos la raíz del error cuadrático medio con el máximo #y minimo de nuestros

#targets y los mostramos por pantalla

min_house_value = california_housing_dataframe["median_house_value"].min()

max_house_value = california_housing_dataframe["median_house_value"].max()

min_max_difference = max_house_value - min_house_value

print("Valor medio de la casa mínimo: %0.3f" % min_house_value)

print("Valor medio de la casa máximo: %0.3f" % max_house_value)

print("Diferencia entre el Min y el Max: %0.3f" % min_max_difference)

print("Raíz del error cuadrático medio: %0.3f" % root_mean_squared_error)

#Ahora el objetivo es reducir el valor del error cuadrático medio. Para ello evaluamos los #resultados utilizando el objeto

#DataFrame y sus metodos  vistos en el capítulo anterior

calibration_data = pd.DataFrame()

calibration_data["predictions"] = pd.Series(predictions)

calibration_data["targets"] = pd.Series(targets)

calibration_data.describe()

# Ahora vamos a mostrar los datos en un gráfica de regresión lineal como vimos el principio del #curso

ejemplo = california_housing_dataframe.sample(n=1000)

# Obtengo los valores máximo y minimo de la columna  total_rooms.

x_0 = ejemplo["total_rooms"].min()

x_1 = ejemplo["total_rooms"].max()

# Retrieve the final weight and bias generated during training.

weight = linear_regressor.get_variable_value('linear/linear_model/total_rooms/weights')[0]

bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')

# obteneemos el peso y sesgo generado durante el entrenamiento (y =mx +b) 

y_0 = weight * x_0 + bias 

y_1 = weight * x_1 + bias

# Pintamos la linea de regresion con el metodo plot de la api pyplot

plt.plot([x_0, x_1], [y_0, y_1], c='r')

# nombre ejes grafica

plt.ylabel("valor medio casa")

plt.xlabel("total habitaciones")

# Trazamos la gráfica de dispersión y mostramos por pantalla

plt.scatter(ejemplo["total_rooms"], ejemplo["median_house_value"])

plt.show()