Pop

Curso Tensorflow con Anaconda -12.Combinaciones de atributos

12.Combinaciones de atributos

  • En este capítulo vamos a entender como combinar atributos para entrenar mejor a nuestro modelo.Una combinación de atributos es un atributo sintético formado al multiplicar (combinar) dos o más atributos. La multiplicación de combinaciones de atributos puede proporcionar capacidades  predictivas más allá de las que esos atributos pueden ofrecer de manera individual.
  • En el vídeo os cuento todo esto con más detalle y además vemos un ejemplo de código:

  • Os dejo el código visto en el vídeo:
#Objetivo Mejorar un modelo de regresión lineal con la adición de características sintéticas #adicionales 

from __future__ import print_function

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

tf.logging.set_verbosity(tf.logging.ERROR)
pd.options.display.max_rows = 10
pd.options.display.float_format = '{:.1f}'.format

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

california_housing_dataframe = california_housing_dataframe.reindex(
    np.random.permutation(california_housing_dataframe.index))

def preprocess_features(california_housing_dataframe):
  """Prepara las características de entrada del conjunto de datos de vivienda de California.
  Args:
    california_housing_dataframe: Contenedor que tendrá los datos de vivienda
  Returns:
    Un DataFrame que contiene las características que se utilizarán para el modelo.
  """
  selected_features = california_housing_dataframe[
    ["latitude",
     "longitude",
     "housing_median_age",
     "total_rooms",
     "total_bedrooms",
     "population",
     "households",
     "median_income"]]
  processed_features = selected_features.copy()
    # Crea una característica sintética.
  processed_features["rooms_per_person"] = (
    california_housing_dataframe["total_rooms"] /
    california_housing_dataframe["population"])
  return processed_features

def preprocess_targets(california_housing_dataframe):
  """Prepara características de destino (etiquetas) a partir del conjunto de datos de viviendas de California.
  Args:
    california_housing_dataframe: Contenedor que tendrá los datos de vivienda
  Returns:
   Un DataFrame que contiene la característica de destino.
  """
  output_targets = pd.DataFrame()
  # Ponemos el objetivo (target) en miles de dolares
  output_targets["median_house_value"] = (
    california_housing_dataframe["median_house_value"] / 1000.0)
  return output_targets

# Elegimos los primeros 12000 registros de los 17000 totales para el entrenamiento
training_examples = preprocess_features(california_housing_dataframe.head(12000))
training_targets = preprocess_targets(california_housing_dataframe.head(12000))

# Elegimos los primeros 5000 registros de los 17000 totales para la validación
validation_examples = preprocess_features(california_housing_dataframe.tail(5000))
validation_targets = preprocess_targets(california_housing_dataframe.tail(5000))

print("Resumen registros entrenamiento:")
display.display(training_examples.describe())
print("Resumen registros validación:")
display.display(validation_examples.describe())

print("Resumen targets entrenamiento:")
display.display(training_targets.describe())
print("Resumen targets validaciçon:")
display.display(validation_targets.describe())

def construct_feature_columns():
  """Construye las columnas de la característica TensorFlow.
  Args:
    input_features: Los nombres de las características de entrada numérica a utilizar.
  Returns:
   Un conjunto de columnas de características"""
  households = tf.feature_column.numeric_column("households")
  longitude = tf.feature_column.numeric_column("longitude")
  latitude = tf.feature_column.numeric_column("latitude")
  housing_median_age = tf.feature_column.numeric_column("housing_median_age")
  median_income = tf.feature_column.numeric_column("median_income")
  rooms_per_person = tf.feature_column.numeric_column("rooms_per_person")
  
  # Divide households into 7 buckets.
  bucketized_households = tf.feature_column.bucketized_column(
    households, boundaries=get_quantile_based_boundaries(
      training_examples["households"], 7))

  # Divide longitude into 10 buckets.
  bucketized_longitude = tf.feature_column.bucketized_column(
    longitude, boundaries=get_quantile_based_boundaries(
      training_examples["longitude"], 10))
  
  # Divide latitude into 10 buckets.
  bucketized_latitude = tf.feature_column.bucketized_column(
    latitude, boundaries=get_quantile_based_boundaries(
      training_examples["latitude"], 10))

  # Divide housing_median_age into 7 buckets.
  bucketized_housing_median_age = tf.feature_column.bucketized_column(
    housing_median_age, boundaries=get_quantile_based_boundaries(
      training_examples["housing_median_age"], 7))
  
  # Divide median_income into 7 buckets.
  bucketized_median_income = tf.feature_column.bucketized_column(
    median_income, boundaries=get_quantile_based_boundaries(
      training_examples["median_income"], 7))
  
  # Divide rooms_per_person into 7 buckets.
  bucketized_rooms_per_person = tf.feature_column.bucketized_column(
    rooms_per_person, boundaries=get_quantile_based_boundaries(
      training_examples["rooms_per_person"], 7))
  
  long_x_lat = tf.feature_column.crossed_column(
  set([bucketized_longitude, bucketized_latitude]), hash_bucket_size=1000) 
  
  feature_columns = set([
    bucketized_longitude,
    bucketized_latitude,
    bucketized_housing_median_age,
    bucketized_households,
    bucketized_median_income,
    bucketized_rooms_per_person,
    long_x_lat])
  
  return feature_columns

#función que utilizaremos para tratar 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

def train_model(
    learning_rate,
    steps,
    batch_size,
    feature_columns,
    training_examples,
    training_targets,
    validation_examples,
    validation_targets):
  """Entrena un modelo de regresión lineal de múltiples características.
  Además del entrenamiento, esta función también imprime información sobre el progreso del entrenamiento,
   así como una gráfica de la pérdida de entrenamiento y validación a lo largo del tiempo.
  
  Args:
    learning_rate: Float con la tasa de aprendizaje
    steps:Un int distinto de cero.Es el número total de pasos de entrenamiento. Un paso de entrenamiento
       consiste en un pase hacia adelante y hacia atrás usando un solo lote.
        batch_size: Un int distinto de cero con el tamaño del lote
    feature_columns: Nos indica las columnas a utilizar
   training_examples: Un `DataFrame` que contiene una o más columnas de
       `california_housing_dataframe` para usar como funciones de entrada para el entrenamiento.
    training_targets: Un `DataFrame` que contiene exactamente una columna de
       `california_housing_dataframe` para usar como objetivo para la capacitación.
    validation_examples: Un `DataFrame` que contiene una o más columnas de
       `california_housing_dataframe` para usar como funciones de entrada para la validación.
    validation_targets: Un `DataFrame` que contiene exactamente una columna de
       `california_housing_dataframe` para usar como destino para la validación.
      
  Returns:
    A `LinearRegressor` object trained on the training data.
  """

  periods = 10
  steps_per_period = steps / periods

  # Create a linear regressor object.
  my_optimizer = tf.train.FtrlOptimizer(learning_rate=learning_rate)
  my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
  linear_regressor = tf.estimator.LinearRegressor(
      feature_columns=feature_columns,
      optimizer=my_optimizer
  )
  
  training_input_fn = lambda: my_input_fn(training_examples, 
                                          training_targets["median_house_value"], 
                                          batch_size=batch_size)
  predict_training_input_fn = lambda: my_input_fn(training_examples, 
                                                  training_targets["median_house_value"], 
                                                  num_epochs=1, 
                                                  shuffle=False)
  predict_validation_input_fn = lambda: my_input_fn(validation_examples, 
                                                    validation_targets["median_house_value"], 
                                                    num_epochs=1, 
                                                    shuffle=False)

 # Entrenamos al modelo
  print("Entranando al modelo...")
  print("Error cuadrático medio en los datos de entrenammiento:")
  training_rmse = []
  validation_rmse = []
  for period in range (0, periods):
       # Entrena el modelo, partiendo del estado anterior.
    linear_regressor.train(
        input_fn=training_input_fn,
        steps=steps_per_period
    )
       #calculamos las predicciones.
    training_predictions = linear_regressor.predict(input_fn=predict_training_input_fn)
    training_predictions = np.array([item['predictions'][0] for item in training_predictions])
    validation_predictions = linear_regressor.predict(input_fn=predict_validation_input_fn)
    validation_predictions = np.array([item['predictions'][0] for item in validation_predictions])
    
    # Calcular la pérdida de entrenamiento y validación.
    training_root_mean_squared_error = math.sqrt(
        metrics.mean_squared_error(training_predictions, training_targets))
    validation_root_mean_squared_error = math.sqrt(
        metrics.mean_squared_error(validation_predictions, validation_targets))
   # Mostramos perdida actual
    print("  period %02d : %0.2f" % (period, training_root_mean_squared_error))
    #Agrega las métricas de pérdida de este período a nuestra lista.
    training_rmse.append(training_root_mean_squared_error)
    validation_rmse.append(validation_root_mean_squared_error)
  print("Model training finished.")

  

  plt.ylabel("Error cuadrático medio")
  plt.xlabel("Periodos")
  plt.title("Error cuadrático medio vs. Periodos")
  plt.tight_layout()
  plt.plot(training_rmse, label="training")
  plt.plot(validation_rmse, label="validation")
  plt.legend()

  return linear_regressor
  
def get_quantile_based_boundaries(feature_values, num_buckets):
  boundaries = np.arange(1.0, num_buckets) / num_buckets
  quantiles = feature_values.quantile(boundaries)
  return [quantiles[q] for q in quantiles.keys()]

# Divide households en 7 .
households = tf.feature_column.numeric_column("households")
bucketized_households = tf.feature_column.bucketized_column(
  households, boundaries=get_quantile_based_boundaries(
    california_housing_dataframe["households"], 7))

# Divide longitude en 10 .
longitude = tf.feature_column.numeric_column("longitude")
bucketized_longitude = tf.feature_column.bucketized_column(
  longitude, boundaries=get_quantile_based_boundaries(
    california_housing_dataframe["longitude"], 10))

_ = train_model(
    learning_rate=1.0,
    steps=500,
    batch_size=100,
    feature_columns=construct_feature_columns(),
    training_examples=training_examples,
    training_targets=training_targets,
    validation_examples=validation_examples,
    validation_targets=validation_targets)
en No hay comentarios:

Curso Tensorflow con Anaconda -11.Ingeniería de atributos

11.Ingeniería de atributos

  • En este capítulo vamos a entender la ingeniería de atributos.A diferencia de la programación tradicional, que se centra en el código, los proyectos de aprendizaje automático se enfocan en la representación.En la parte izquierda de la siguiente imagen se muestran datos sin procesar de una fuente de datos de entrada; a la derecha, se muestra un vector de atributos,  que es el conjunto de valores de punto flotante que incluye los ejemplos en el conjunto de datos.  La ingeniería de atributos es la transformación de datos sin procesar en un vector de atributos.


. 
  • Muchos modelos de aprendizaje automático deben representar los atributos como vectores de números reales. 




  • Los datos enteros y de punto flotante no necesitan una codificación especial porque se pueden multiplicar por un peso numérico,pero las cadenas de  texto si la necesitan. Como los modelos no pueden multiplicar strings por los pesos aprendidos podríamos convertir cada string en un valor numérico, pero hay una solución mejor.Como es crear un vector binario para cada atributo categórico de nuestro modelo que represente los valores de la siguiente manera:


    • Os dejo el vídeo donde os cuento todo esto y vemos un ejemplo de código:
    • Os dejo también el código visto en el vídeo:
    #Objetivo es crear un conjunto mínimo de características que se desempeñen tan bien
    #como un conjunto de características más complejo

    from __future__ import print_function

    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

    tf.logging.set_verbosity(tf.logging.ERROR)
    pd.options.display.max_rows = 10
    pd.options.display.float_format = '{:.1f}'.format

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

    california_housing_dataframe = california_housing_dataframe.reindex(
        np.random.permutation(california_housing_dataframe.index))



    def preprocess_features(california_housing_dataframe):
      """Prepara las características de entrada del conjunto de datos de vivienda de California.
      Args:
        california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
        Un DataFrame que contiene las características que se utilizarán para el modelo.
      """
      selected_features = california_housing_dataframe[
        ["latitude",
         "longitude",
         "housing_median_age",
         "total_rooms",
         "total_bedrooms",
         "population",
         "households",
         "median_income"]]
      processed_features = selected_features.copy()
        # Crea una característica sintética.
      processed_features["rooms_per_person"] = (
        california_housing_dataframe["total_rooms"] /
        california_housing_dataframe["population"])
      return processed_features

    def preprocess_targets(california_housing_dataframe):
      """Prepara características de destino (etiquetas) a partir del conjunto de datos de viviendas de California.
      Args:
        california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
       Un DataFrame que contiene la característica de destino.
      """
      output_targets = pd.DataFrame()
      # Ponemos el objetivo (target) en miles de dolares
      output_targets["median_house_value"] = (
        california_housing_dataframe["median_house_value"] / 1000.0)
      return output_targets

    # Elegimos los primeros 12000 registros de los 17000 totales para el entrenamiento
    training_examples = preprocess_features(california_housing_dataframe.head(12000))
    training_targets = preprocess_targets(california_housing_dataframe.head(12000))

    # Elegimos los primeros 5000 registros de los 17000 totales para la validación
    validation_examples = preprocess_features(california_housing_dataframe.tail(5000))
    validation_targets = preprocess_targets(california_housing_dataframe.tail(5000))

    print("Resumen registros entrenamiento:")
    display.display(training_examples.describe())
    print("Resumen registros validación:")
    display.display(validation_examples.describe())

    print("Resumen targets entrenamiento:")
    display.display(training_targets.describe())
    print("Resumen targets validaciçon:")
    display.display(validation_targets.describe())


     #Matriz correlación: Los valores de correlación tienen los siguientes significados:
     #-1.0: perfecta correlación negativa
     #0.0: no hay correlación
     #1.0: correlación positiva perfecta

    correlation_dataframe = training_examples.copy()
    correlation_dataframe["target"] = training_targets["median_house_value"]

    correlation_dataframe.corr()

    def construct_feature_columns(input_features):
      """Construye las columnas de la característica TensorFlow.
      Args:
        input_features: Los nombres de las características de entrada numérica a utilizar.
      Returns:
       Un conjunto de columnas de características
      """ 
      return set([tf.feature_column.numeric_column(my_feature)
                  for my_feature in input_features])

    #función que utilizaremos para tratar 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

    def train_model(
        learning_rate,
        steps,
        batch_size,
        training_examples,
        training_targets,
        validation_examples,
        validation_targets):
      """Entrena un modelo de regresión lineal de múltiples características.
      Además del entrenamiento, esta función también imprime información sobre el progreso del entrenamiento,
       así como una gráfica de la pérdida de entrenamiento y validación a lo largo del tiempo.
      
      Args:
        learning_rate: Float con la tasa de aprendizaje
        steps:Un int distinto de cero.Es el número total de pasos de entrenamiento. Un paso de entrenamiento
           consiste en un pase hacia adelante y hacia atrás usando un solo lote.
        batch_size: Un int distinto de cero con el tamaño del lote
        training_examples: Un `DataFrame` que contiene una o más columnas de
           `california_housing_dataframe` para usar como funciones de entrada para el entrenamiento.
        training_targets: Un `DataFrame` que contiene exactamente una columna de
           `california_housing_dataframe` para usar como objetivo para la capacitación.
        validation_examples: Un `DataFrame` que contiene una o más columnas de
           `california_housing_dataframe` para usar como funciones de entrada para la validación.
        validation_targets: Un `DataFrame` que contiene exactamente una columna de
           `california_housing_dataframe` para usar como destino para la validación.
          
      Returns:
       Un objeto `LinearRegressor` entrenado en los datos de entrenamiento.
      """

      periods = 10
      steps_per_period = steps / periods
      
      # Creamos objeto linear_regressor
      my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
      my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
      linear_regressor = tf.estimator.LinearRegressor(
          feature_columns=construct_feature_columns(training_examples),
          optimizer=my_optimizer
      )
      
      # Creamos funcion de entrada
      training_input_fn = lambda: my_input_fn(
          training_examples, 
          training_targets["median_house_value"], 
          batch_size=batch_size)
      predict_training_input_fn = lambda: my_input_fn(
          training_examples, 
          training_targets["median_house_value"], 
          num_epochs=1, 
          shuffle=False)
      predict_validation_input_fn = lambda: my_input_fn(
          validation_examples, validation_targets["median_house_value"], 
          num_epochs=1, 
          shuffle=False)

      # Entrenamos al modelo dentro de un bucle
      print("Entranando al modelo...")
      print("Error cuadrático medio en los datos de entrenammiento:")
      training_rmse = []
      validation_rmse = []
      for period in range (0, periods):
        # Entrena el modelo, partiendo del estado anterior.
        linear_regressor.train(
            input_fn=training_input_fn,
            steps=steps_per_period,
        )
        #calculamos las predicciones.
        training_predictions = linear_regressor.predict(input_fn=predict_training_input_fn)
        training_predictions = np.array([item['predictions'][0] for item in training_predictions])
        
        validation_predictions = linear_regressor.predict(input_fn=predict_validation_input_fn)
        validation_predictions = np.array([item['predictions'][0] for item in validation_predictions])
        
        
        # Calcular la pérdida de entrenamiento y validación.
        training_root_mean_squared_error = math.sqrt(
            metrics.mean_squared_error(training_predictions, training_targets))
        validation_root_mean_squared_error = math.sqrt(
            metrics.mean_squared_error(validation_predictions, validation_targets))
        # Mostramos perdida actual
        print("  periodo %02d : %0.2f" % (period, training_root_mean_squared_error))
        #Agrega las métricas de pérdida de este período a nuestra lista.
        training_rmse.append(training_root_mean_squared_error)
        validation_rmse.append(validation_root_mean_squared_error)
      print("Entrenamiento del modelo finalizado.")

      plt.ylabel("Error cuadrático medio")
      plt.xlabel("Periodos")
      plt.title("Error cuadrático medio vs. Periodos")
      plt.tight_layout()
      plt.plot(training_rmse, label="training")
      plt.plot(validation_rmse, label="validation")
      plt.legend()

      return linear_regressor

    minimal_features = [
      "median_income",
      "latitude",
    ]

    minimal_training_examples = training_examples[minimal_features]
    minimal_validation_examples = validation_examples[minimal_features]

    _ = train_model(
        learning_rate=0.01,
        steps=500,
        batch_size=5,
        training_examples=minimal_training_examples,
        training_targets=training_targets,
        validation_examples=minimal_validation_examples,
        validation_targets=validation_targets)

    plt.scatter(training_examples["latitude"], training_targets["median_house_value"])

    def select_and_transform_features(source_df):
      LATITUDE_RANGES = zip(range(32, 44), range(33, 45))
      selected_examples = pd.DataFrame()
      selected_examples["median_income"] = source_df["median_income"]
      for r in LATITUDE_RANGES:
        selected_examples["latitude_%d_to_%d" % r] = source_df["latitude"].apply(lambda l: 1.0 if l >= r[0] and l < r[1] else 0.0)
      return selected_examples

    selected_training_examples = select_and_transform_features(training_examples)
    selected_validation_examples = select_and_transform_features(validation_examples)

    _ = train_model(
        learning_rate=0.01,
        steps=500,
        batch_size=5,
        training_examples=selected_training_examples,
        training_targets=training_targets,
        validation_examples=selected_validation_examples,
        validation_targets=validation_targets)
    en No hay comentarios:

    Curso Tensorflow con Anaconda -10. Ejemplo entrenamiento y validación(2)

    10. Ejemplo entrenamiento y validación(2)

    • En el vídeo anterior empezamos con un ejemplo de código donde  veíamos las diferentes formas de entrenar un modelo.En esta entrada vamos a continuar con nuestro ejemplo.  Acabaremos las dos tareas pendientes que nos quedaron en el capítulo anterior:
      • Entrenar y evaluar un modelo
      • Evaluar en los datos de prueba
    • Os dejo el vídeo donde acabo nuestro ejemplo y os lo explico en profundidad:

    • Como siempre os dejo el código visto en el vídeo:
    #Vamos a trabajar con múltiples funciones, así que modularizaremos la lógica para #preprocesarlas funciones
    from __future__ import print_function
    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

    tf.logging.set_verbosity(tf.logging.ERROR)
    pd.options.display.max_rows = 10
    pd.options.display.float_format = '{:.1f}'.format

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

    california_housing_dataframe = california_housing_dataframe.reindex(
    np.random.permutation(california_housing_dataframe.index))

    def preprocess_features(california_housing_dataframe):
      """Prepara las características de entrada del conjunto de datos de vivienda de California.
      Args:
        california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
        Un DataFrame que contiene las características que se utilizarán para el modelo.
      """
      selected_features = california_housing_dataframe[
        ["latitude",
         "longitude",
         "housing_median_age",
         "total_rooms",
         "total_bedrooms",
         "population",
         "households",
         "median_income"]]
      processed_features = selected_features.copy()
        # Crea una característica sintética.
      processed_features["rooms_per_person"] = (
        california_housing_dataframe["total_rooms"] /
        california_housing_dataframe["population"])
      return processed_features

    def preprocess_targets(california_housing_dataframe):
      """Prepara características de destino (etiquetas) a partir del conjunto de datos de viviendas de California.
      Args:
        california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
       Un DataFrame que contiene la característica de destino.
      """
      output_targets = pd.DataFrame()
      # Ponemos el objetivo (target) en miles de dolares
      output_targets["median_house_value"] = (
        california_housing_dataframe["median_house_value"] / 1000.0)
      return output_targets
      
    #Para el conjunto de entrenamiento, elegiremos los primeros 12000 ejemplos, de un total de #17000.
    training_examples = preprocess_features(california_housing_dataframe.head(12000))
    training_examples.describe()

    training_targets = preprocess_targets(california_housing_dataframe.head(12000))
    training_targets.describe()

    #Para el conjunto de validación, elegiremos los últimos 5000 ejemplos, de un total de 17000.
    validation_examples = preprocess_features(california_housing_dataframe.tail(5000))
    validation_examples.describe()

    validation_targets = preprocess_targets(california_housing_dataframe.tail(5000))
    validation_targets.describe()

    plt.figure(figsize=(13, 8))

    ax = plt.subplot(1, 2, 1)
    ax.set_title("Conjunto datos validación")

    ax.set_autoscaley_on(False)
    ax.set_ylim([32, 43])
    ax.set_autoscalex_on(False)
    ax.set_xlim([-126, -112])
    plt.scatter(validation_examples["longitude"],
                validation_examples["latitude"],
                cmap="coolwarm",
                c=validation_targets["median_house_value"] / validation_targets["median_house_value"].max())

    ax = plt.subplot(1,2,2)
    ax.set_title("Conjunto datos entrenamiento")

    ax.set_autoscaley_on(False)
    ax.set_ylim([32, 43])
    ax.set_autoscalex_on(False)
    ax.set_xlim([-126, -112])
    plt.scatter(training_examples["longitude"],
                training_examples["latitude"],
                cmap="coolwarm",
                c=training_targets["median_house_value"] / training_targets["median_house_value"].max())
    _ = plt.plot()

    #función que utilizaremos para tratar 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

    def construct_feature_columns(input_features):
      """Construye las columnas de la característica TensorFlow.
      Args:
        input_features: Los nombres de las características de entrada numérica a utilizar.
      Returns:
       Un conjunto de columnas de características
      """ 
      return set([tf.feature_column.numeric_column(my_feature)
                  for my_feature in input_features])
      
    def train_model(
        learning_rate,
        steps,
        batch_size,
        training_examples,
        training_targets,
        validation_examples,
        validation_targets):
      """Entrena un modelo de regresión lineal de múltiples características.
      Además del entrenamiento, esta función también imprime información sobre el progreso del entrenamiento,
       así como una gráfica de la pérdida de entrenamiento y validación a lo largo del tiempo.
      
      Args:
        learning_rate: Float con la tasa de aprendizaje
        steps:Un int distinto de cero.Es el número total de pasos de entrenamiento. Un paso de entrenamiento
           consiste en un pase hacia adelante y hacia atrás usando un solo lote.
        batch_size: Un int distinto de cero con el tamaño del lote
        training_examples: Un `DataFrame` que contiene una o más columnas de
           `california_housing_dataframe` para usar como funciones de entrada para el entrenamiento.
        training_targets: Un `DataFrame` que contiene exactamente una columna de
           `california_housing_dataframe` para usar como objetivo para la capacitación.
        validation_examples: Un `DataFrame` que contiene una o más columnas de
           `california_housing_dataframe` para usar como funciones de entrada para la validación.
        validation_targets: Un `DataFrame` que contiene exactamente una columna de
           `california_housing_dataframe` para usar como destino para la validación.
          
      Returns:
       Un objeto `LinearRegressor` entrenado en los datos de entrenamiento.
      """

      periods = 10
      steps_per_period = steps / periods
      
      # Creamos objeto linear_regressor
      my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
      my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
      linear_regressor = tf.estimator.LinearRegressor(
          feature_columns=construct_feature_columns(training_examples),
          optimizer=my_optimizer
      )
      
      # Creamos funcion de entrada
      training_input_fn = lambda: my_input_fn(
          training_examples, 
          training_targets["median_house_value"], 
          batch_size=batch_size)
      predict_training_input_fn = lambda: my_input_fn(
          training_examples, 
          training_targets["median_house_value"], 
          num_epochs=1, 
          shuffle=False)
      predict_validation_input_fn = lambda: my_input_fn(
          validation_examples, validation_targets["median_house_value"], 
          num_epochs=1, 
          shuffle=False)

      # Entrenamos al modelo dentro de un bucle
      print("Entranando al modelo...")
      print("Error cuadrático medio en los datos de entrenammiento:")
      training_rmse = []
      validation_rmse = []
      for period in range (0, periods):
        # Entrena el modelo, partiendo del estado anterior.
        linear_regressor.train(
            input_fn=training_input_fn,
            steps=steps_per_period,
        )
        #calculamos las predicciones.
        training_predictions = linear_regressor.predict(input_fn=predict_training_input_fn)
        training_predictions = np.array([item['predictions'][0] for item in training_predictions])
        
        validation_predictions = linear_regressor.predict(input_fn=predict_validation_input_fn)
        validation_predictions = np.array([item['predictions'][0] for item in validation_predictions])
        
        
        # Calcular la pérdida de entrenamiento y validación.
        training_root_mean_squared_error = math.sqrt(
            metrics.mean_squared_error(training_predictions, training_targets))
        validation_root_mean_squared_error = math.sqrt(
            metrics.mean_squared_error(validation_predictions, validation_targets))
        # Mostramos perdida actual
        print("  periodo %02d : %0.2f" % (period, training_root_mean_squared_error))
        #Agrega las métricas de pérdida de este período a nuestra lista.
        training_rmse.append(training_root_mean_squared_error)
        validation_rmse.append(validation_root_mean_squared_error)
      print("Entrenamiento del modelo finalizado.")

      plt.ylabel("Error cuadrático medio")
      plt.xlabel("Periodos")
      plt.title("Error cuadrático medio vs. Periodos")
      plt.tight_layout()
      plt.plot(training_rmse, label="training")
      plt.plot(validation_rmse, label="validation")
      plt.legend()

      return linear_regressor
    linear_regressor = train_model(
        learning_rate=0.00003,
        steps=500,
        batch_size=5,
        training_examples=training_examples,
        training_targets=training_targets,
        validation_examples=validation_examples,
        validation_targets=validation_targets)
    california_housing_test_data = pd.read_csv("https://download.mlcc.google.com/mledu-datasets/california_housing_test.csv", sep=",")

    test_examples = preprocess_features(california_housing_test_data)
    test_targets = preprocess_targets(california_housing_test_data)

    predict_test_input_fn = lambda: my_input_fn(
          test_examples, 
          test_targets["median_house_value"], 
          num_epochs=1, 
          shuffle=False)

    test_predictions = linear_regressor.predict(input_fn=predict_test_input_fn)
    test_predictions = np.array([item['predictions'][0] for item in test_predictions])

    root_mean_squared_error = math.sqrt(
        metrics.mean_squared_error(test_predictions, test_targets))

    print("Error cuadrático medio final en los datos de test: %0.2f" % root_mean_squared_error)

    en No hay comentarios:

    Curso Tensorflow con Anaconda -9. Ejemplo entrenamiento y validación(1)

    9. Ejemplo entrenamiento y validación(1)


    • En el vídeo anterior vimos como utilizar un conjunto de datos de entrenamiento y otro de prueba. Esto nos permitía entrenar un conjunto de ejemplos y luego probar el modelo con un conjunto de ejemplos diferente. En la siguiente  figura  tenemos una posible representación gráfica del uso de este enfoque.Donde "Ajustar el modelo" significa modificar  cualquier aspecto que puedas imaginar del modelo. Al final de este flujo de trabajo, elegimos el modelo que mejor se desempeñe con respecto al conjunto de prueba.


    • Podemos mejorar este enfoque  haciendo tres subconjuntos de datos en lugar de dos. Como vemos en la siguiente figura.  Este flujo de trabajo mejorado, realiza lo siguiente:
      • Selecciona el modelo que mejor se desempeñe con el conjunto de validación.
      • Verifica el modelo con respecto al conjunto de prueba.
      • Este flujo de trabajo es más eficaz porque crea menos exposiciones al conjunto de prueba.

    • Os dejo el vídeo donde vemos un ejemplo de código sobre este tema:

    • Como siempre os dejo el código visto en el vídeo:
    #Vamos a trabajar con múltiples funciones, así que modularizaremos la lógica para preprocesarlas funciones
    from __future__ import print_function
    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

    tf.logging.set_verbosity(tf.logging.ERROR)
    pd.options.display.max_rows = 10
    pd.options.display.float_format = '{:.1f}'.format

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

    california_housing_dataframe = california_housing_dataframe.reindex(
    np.random.permutation(california_housing_dataframe.index))

    def preprocess_features(california_housing_dataframe):
      """Prepara las características de entrada del conjunto de datos de vivienda de California.
      Args:
    california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
    Un DataFrame que contiene las características que se utilizarán para el modelo.
      """
      selected_features = california_housing_dataframe[
    ["latitude",
    "longitude",
    "housing_median_age",
    "total_rooms",
    "total_bedrooms",
    "population",
    "households",
    "median_income"]]
      processed_features = selected_features.copy()
    # Crea una característica sintética.
      processed_features["rooms_per_person"] = (
    california_housing_dataframe["total_rooms"] /
    california_housing_dataframe["population"])
      return processed_features

    def preprocess_targets(california_housing_dataframe):
      """Prepara características de destino (etiquetas) a partir del conjunto de datos de viviendas de California.
      Args:
    california_housing_dataframe: Contenedor que tendrá los datos de vivienda
      Returns:
       Un DataFrame que contiene la característica de destino.
      """
      output_targets = pd.DataFrame()
      # Ponemos el objetivo (target) en miles de dolares
      output_targets["median_house_value"] = (
    california_housing_dataframe["median_house_value"] / 1000.0)
      return output_targets
      
    #Para el conjunto de entrenamiento, elegiremos los primeros 12000 ejemplos, de un total de #17000.
    training_examples = preprocess_features(california_housing_dataframe.head(12000))
    training_examples.describe()

    training_targets = preprocess_targets(california_housing_dataframe.head(12000))
    training_targets.describe()

    #Para el conjunto de validación, elegiremos los últimos 5000 ejemplos, de un total de 17000.
    validation_examples = preprocess_features(california_housing_dataframe.tail(5000))
    validation_examples.describe()

    validation_targets = preprocess_targets(california_housing_dataframe.tail(5000))
    validation_targets.describe()

    plt.figure(figsize=(13, 8))

    ax = plt.subplot(1, 2, 1)
    ax.set_title("Conjunto datos validación")

    ax.set_autoscaley_on(False)
    ax.set_ylim([32, 43])
    ax.set_autoscalex_on(False)
    ax.set_xlim([-126, -112])
    plt.scatter(validation_examples["longitude"],
    validation_examples["latitude"],
    cmap="coolwarm",
    c=validation_targets["median_house_value"] / validation_targets["median_house_value"].max())

    ax = plt.subplot(1,2,2)
    ax.set_title("Conjunto datos entrenamiento")

    ax.set_autoscaley_on(False)
    ax.set_ylim([32, 43])
    ax.set_autoscalex_on(False)
    ax.set_xlim([-126, -112])
    plt.scatter(training_examples["longitude"],
    training_examples["latitude"],
    cmap="coolwarm",
    c=training_targets["median_house_value"] / training_targets["median_house_value"].max())
    _ = plt.plot()
    en No hay comentarios:

    Curso Tensorflow con Anaconda -8. Generalización y sobreajuste

    8. Generalización y sobreajuste

    • En esta entrada del blog trataremos la generalización y los riesgos del sobreajuste. La generalización hace referencia a la capacidad del modelo para adaptarse de manera adecuada a datos nuevos nunca antes vistos, obtenidos de la misma distribución que aquellos utilizados para crear el modelo. Esto lo entenderemos mejor con un ejemplo donde debemos suponer que los puntos azules representan árboles enfermos y los naranjas arboles sanos.


    •  Un determinado modelo de aprendizaje automático separó los árboles enfermos de los sanos de la siguiente manera:

    • Con este modelo se produce una perdida muy baja.Aparentemente es un buen modelo, pero cuando agregamos más datos el modelo se adapta bastante mal a los nuevos datos.Como podemos ver en la siguiente imagen: 

    • El modelo de la segunda imagen sobreajusta los datos con los que se entrenó. Un modelo sobreajustado obtiene una pérdida baja durante el entrenamiento, pero no se desempeña bien al predecir datos nuevos. El sobreajuste se genera al desarrollar un modelo más complejo que lo necesario.
    • Un modelo de aprendizaje automático tiene como objetivo realizar buenas predicciones sobre datos nuevos nunca antes vistos.  Pero, si desarrollas un modelo a partir de tu conjunto de datos, ¿cómo obtendrías los datos nunca antes vistos?  Una forma es dividir el conjunto de datos en dos subconjuntos:
      • Conjunto de entrenamiento: Un subconjunto para entrenar un modelo.
      • Conjunto de prueba: Un subconjunto para probar el modelo.
    • Os dejo el vídeo donde os cuento todo esto y practico con ejemplos:
    en No hay comentarios:

    Curso Tensorflow con Anaconda -7. Ejemplo predicción precios (2)

    7. Ejemplo predicción precios (2)

    • En esta entrada del blog vamos mejorar el código visto en el vídeo anterior. La idea es compactar el código en una única función a la que podremos llamar para entrenar el modelo. Para mejorar nuestro modelo haremos entrenamientos ajustando los hiperparámetros.
    • Los hiperparámetros son valores definidos antes del entrenamiento ,es decir ,los parámetros de entrada de la función que veremos en este capítulo. Son diferentes según los algoritmos y puede estar condicionados entre si.  Los hiperparámetrosse eligen mediante el método de prueba y error.
    • Muchos de los ejercicios de codificación contienen los siguientes hiperparámetros:
    1.  pasos, que es el número total de iteraciones de entrenamiento. Un paso calcula la pérdida de un lote y usa ese valor para modificar los pesos del modelo una vez.
    2.  tamaño del lote, que es el número de ejemplos (elegidos de forma aleatoria) para un solo paso. La  formula aplicada es: total ejemplos entrenados = pasos * tamaño del lote.
    3. También se suelen utilizar los periodos  que controlan el nivel de detalle de los informes. Por ejemplo, si la variable de periodos está ajustada en 7 y el hiperparámetro de paso está ajustado en 70, el ejercicio dará el resultado del valor de la pérdida cada 10 pasos (o 7 veces). 
    • Os dejo el vídeo donde vemos como se hace esta función:
    • Os dejo el código visto en el vídeo:
    def train_model(learning_rate, steps, batch_size, input_feature="total_rooms"):
      """Función para entrenar un modelo de regresión lineal de una característica
      Args:
        learning_rate: Float con la tasa de aprendizaje.
        steps: El número de pasos de un entrenamiento.Debe ser >0
        batch_size: Tamaño del lote.Debe ser >0
        input_feature: Cadena que especifica la característica de entrada
      """
      
      periods = 10
      steps_per_period = steps / periods

      my_feature = input_feature
      my_feature_data = california_housing_dataframe[[my_feature]]
      my_label = "median_house_value"
      targets = california_housing_dataframe[my_label]

      # Creamos columna de caraterísticas
      feature_columns = [tf.feature_column.numeric_column(my_feature)]
      
      # Creamos función de entrada
      training_input_fn = lambda:my_input_fn(my_feature_data, targets, batch_size=batch_size)
      prediction_input_fn = lambda: my_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)
      
      # Creamos el objeto linear_regressor
      my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
      my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
      linear_regressor = tf.estimator.LinearRegressor(
          feature_columns=feature_columns,
          optimizer=my_optimizer
      )

      # Traza el estado de la línea de nuestro modelo en cada período
      plt.figure(figsize=(15, 6))
      plt.subplot(1, 2, 1)
      plt.title("Linea aprendida en este periodo")
      plt.ylabel(my_label)
      plt.xlabel(my_feature)
      sample = california_housing_dataframe.sample(n=300)
      plt.scatter(sample[my_feature], sample[my_label])
      colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]

      # Entrenamos el modelo dentro de un bucle para poder evaluar las métricas de perdida
      print("Entrenando...")
      print("Desviación de la raíz cuadrada media en los datos de entrenamiento:")
      root_mean_squared_errors = []
      for period in range (0, periods):
        # Entrenamos el modelo desde el periodo anterior
        linear_regressor.train(
            input_fn=training_input_fn,
            steps=steps_per_period
        )
        # calcular predicciones.
        predictions = linear_regressor.predict(input_fn=prediction_input_fn)
        predictions = np.array([item['predictions'][0] for item in predictions])
        
        # calcular pérdida..
        root_mean_squared_error = math.sqrt(
            metrics.mean_squared_error(predictions, targets))
        # Mostramos la pérdida actual
        print("  period %02d : %0.2f" % (period, root_mean_squared_error))
      
        root_mean_squared_errors.append(root_mean_squared_error)
        # Rastreamos pesos y sesgos a lo largo del tiempo
        y_extents = np.array([0, sample[my_label].max()])
        
        weight = linear_regressor.get_variable_value('linear/linear_model/%s/weights' % input_feature)[0]
        bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')

        x_extents = (y_extents - bias) / weight
        x_extents = np.maximum(np.minimum(x_extents,
                                          sample[my_feature].max()),
                               sample[my_feature].min())
        y_extents = weight * x_extents + bias
        plt.plot(x_extents, y_extents, color=colors[period]) 
      print("Model training finished.")

      # Mostramos el gráfico de perdida por periodos
      plt.subplot(1, 2, 2)
      plt.ylabel('RMSE')
      plt.xlabel('Periodos')
      plt.title("RMSE vs. Periodos")
      plt.tight_layout()
      plt.plot(root_mean_squared_errors)

      # Mostramos datos
      calibration_data = pd.DataFrame()
      calibration_data["predictions"] = pd.Series(predictions)
      calibration_data["targets"] = pd.Series(targets)
      display.display(calibration_data.describe())

      print("Final RMSE de los datos entrenados: %0.2f" % root_mean_squared_error)
        
    train_model(
        learning_rate=0.00002,
        steps=500,
        batch_size=5
    )
    en No hay comentarios:

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

    6. Ejemplo predicción precios (1)

    • 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.
    • 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()
    en No hay comentarios:

    Curso Tensorflow con Anaconda - 5.Ejemplo de uso de la API Pandas

    5.Ejemplo de uso de la API Pandas

    • Esta entrada la vamos a dedicar a conocer un poco mejora Pandas, que  es una API de análisis de datos orientada a columnas. Es una gran herramienta para manejar y analizar los datos de entrada,  y muchos marcos de machine learning admiten las estructuras de datos panda como entradas. 
    • En el vídeo podemos ver un ejemplo de uso de esta API:
    • Os dejo el código visto en el vídeo:
    from __future__ import print_function

    #importo las librerias necesarias para los ejemplos
    import pandas as pd
    import numpy as np

    #imprime vesión de pandas por pantalla
    pd.__version__


    """
    Las estructuras de datos primarias en pandas se implementan con dos clases:

    DataFrame-->Tabla de datos relacionales, con filas y columnas.
    Serie --> una sola columna.

    Un DataFrame contiene una o más series y un nombre para cada serie.
    El marco de datos es una abstracción comúnmente utilizada para la manipulación de datos.
    Una forma de crear una serie es construir un objeto de serie. Por ejemplo:"""

    pd.Series(['San Francisco', 'San Jose', 'Sacramento'])
    city_names = pd.Series(['San Francisco', 'San Jose', 'Sacramento'])
    population = pd.Series([852469, 1015785, 485199])
    pd.DataFrame({ 'City name': city_names, 'Population': population })

    #importo las librerias necesarias para los ejemplos
    import pandas as pd
    import numpy as np

    #cargamos dataframe via csv
    california_housing_dataframe = pd.read_csv("https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv", sep=",")
    california_housing_dataframe.describe()
    california_housing_dataframe.head()
    california_housing_dataframe.hist('housing_median_age')

    cities = pd.DataFrame({ 'City name': city_names, 'Population': population })
    cities['City name']
    cities['City name'][1]


    cities['Area square miles'] = pd.Series([46.87, 176.53, 97.92])
    cities['Population density'] = cities['Population'] / cities['Area square miles']

    #solucion problema 1
    cities['Is wide and has saint name'] = (cities['Area square miles'] > 50) & cities['City name'].apply(lambda name: name.startswith('San'))
    cities 
    en No hay comentarios:
    Suscribirse a: Entradas (Atom)

    Curso .NET Core en C# - 34.Creamos nuestro propio log

    34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...