Pop

Curso Tensorflow con Anaconda -14 Clasificación

14 Clasificación

  • En este capítulo vemos cómo la regresión logística puede utilizarse para tareas de clasificación y se explora cómo evaluar la efectividad de los modelos de clasificación.En la siguiente imagen podéis ver los componentes básicos de las métricas que utilizaremos para evaluar modelos de clasificación. Nos basamos en la fábula del pastor y del lobo:
  • donde
    • "Lobo" es una clase positiva.
    • "Ningún lobo" es una clase negativa.
  • Un verdadero positivo es un resultado en el que el modelo predice correctamente la clase positiva. De manera similar, un verdadero negativo es un resultado en el que el modelo predice correctamente la clase negativa.Un falso positivo es un resultado en el que el modelo predice incorrectamente la clase positiva. Y un falso negativo es un resultado en el que el modelo predice incorrectamente la clase negativa.
  • Una vez que conocemos esto podemos definir que es la exactitud, la precicsión y la exhaustividad:
    •  La exactitud es la fracción de predicciones que el modelo realizó correctamente
    •  La precisión intenta responder a la siguiente pregunta: ¿Qué proporción de identificaciones positivas fue correcta?La exhaustividad intenta responder a la siguiente pregunta: ¿Qué proporción de positivos reales se identificó correctamente.
  • Normalmente cuando entrenamos un modelo al mejorar la precisión, generalmente se reduce la exhaustividad.
  • En el siguiente vídeo os cuento todo esto y además añado un ejemplo de código:

  • Os dejo el código visto en el vídeo:
#Objetivo  predecir si un bloque de ciudad es un bloque de ciudad de alto costo.

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()
  # Cree una característica  booleana que represente si el median_house_value encima 
 # de unumbral establecido.
  output_targets["median_house_value_is_high"] = (
    california_housing_dataframe["median_house_value"] > 265000).astype(float)
  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())

#¿Cómo sería la regresión lineal?
#Para ver por qué la regresión logística es efectiva, primero entrenemos uno que usa regresión lineal. 
#Este modelo utilizará etiquetas con valores en el conjunto {0, 1} e intentará predecir un valor #continuo lo más cercano posible a 0 o 1. 
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 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()}                                            
  
    ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit
    ds = ds.batch(batch_size).repeat(num_epochs)
    

    if shuffle:
      ds = ds.shuffle(10000)
    
    
    features, labels = ds.make_one_shot_iterator().get_next()
    return features, labels


def train_linear_regressor_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
    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.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
  )
    
  
  training_input_fn = lambda: my_input_fn(training_examples, 
                                          training_targets["median_house_value_is_high"], 
                                          batch_size=batch_size)
  predict_training_input_fn = lambda: my_input_fn(training_examples, 
                                                  training_targets["median_house_value_is_high"], 
                                                  num_epochs=1, 
                                                  shuffle=False)
  predict_validation_input_fn = lambda: my_input_fn(validation_examples, 
                                                    validation_targets["median_house_value_is_high"], 
                                                    num_epochs=1, 
                                                    shuffle=False)

  
  # Entrenamos al modelo
  print("Entrenando 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))
    # Add the loss metrics from this period to our list.
    training_rmse.append(training_root_mean_squared_error)
    validation_rmse.append(validation_root_mean_squared_error)
  print("Model training finished.")
  
  # GRafica
  plt.ylabel("RMSE")
  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_linear_regressor_model(
    learning_rate=0.000001,
    steps=200,
    batch_size=20,
    training_examples=training_examples,
    training_targets=training_targets,
    validation_examples=validation_examples,
    validation_targets=validation_targets)

predict_validation_input_fn = lambda: my_input_fn(validation_examples, 
                                                  validation_targets["median_house_value_is_high"], 
                                                  num_epochs=1, 
                                                  shuffle=False)

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

_ = plt.hist(validation_predictions)

def train_linear_classifier_model(
    learning_rate,
    steps,
    batch_size,
    training_examples,
    training_targets,
    validation_examples,
    validation_targets):
  """Trains a linear classification model.
  
  In addition to training, this function also prints training progress information,
  as well as a plot of the training and validation loss over time.
  
  Args:
    learning_rate: A `float`, the learning rate.
    steps: A non-zero `int`, the total number of training steps. A training step
      consists of a forward and backward pass using a single batch.
    batch_size: A non-zero `int`, the batch size.
    training_examples: A `DataFrame` containing one or more columns from
      `california_housing_dataframe` to use as input features for training.
    training_targets: A `DataFrame` containing exactly one column from
      `california_housing_dataframe` to use as target for training.
    validation_examples: A `DataFrame` containing one or more columns from
      `california_housing_dataframe` to use as input features for validation.
    validation_targets: A `DataFrame` containing exactly one column from
      `california_housing_dataframe` to use as target for validation.
      
  Returns:
    A `LinearClassifier` object trained on the training data.
  """

  periods = 10
  steps_per_period = steps / periods
  
  # Create a linear classifier object.
  my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
  my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)  
  linear_classifier = tf.estimator.LinearClassifier(
      feature_columns=construct_feature_columns(training_examples),
      optimizer=my_optimizer
  )
  
  # Create input functions.
  training_input_fn = lambda: my_input_fn(training_examples, 
                                          training_targets["median_house_value_is_high"], 
                                          batch_size=batch_size)
  predict_training_input_fn = lambda: my_input_fn(training_examples, 
                                                  training_targets["median_house_value_is_high"], 
                                                  num_epochs=1, 
                                                  shuffle=False)
  predict_validation_input_fn = lambda: my_input_fn(validation_examples, 
                                                    validation_targets["median_house_value_is_high"], 
                                                    num_epochs=1, 
                                                    shuffle=False)
  
  # Train the model, but do so inside a loop so that we can periodically assess
  # loss metrics.
  print("Training model...")
  print("LogLoss (on training data):")
  training_log_losses = []
  validation_log_losses = []
  for period in range (0, periods):
    # Train the model, starting from the prior state.
    linear_classifier.train(
        input_fn=training_input_fn,
        steps=steps_per_period
    )
    # Take a break and compute predictions.    
    training_probabilities = linear_classifier.predict(input_fn=predict_training_input_fn)
    training_probabilities = np.array([item['probabilities'] for item in training_probabilities])
    
    validation_probabilities = linear_classifier.predict(input_fn=predict_validation_input_fn)
    validation_probabilities = np.array([item['probabilities'] for item in validation_probabilities])
    
    training_log_loss = metrics.log_loss(training_targets, training_probabilities)
    validation_log_loss = metrics.log_loss(validation_targets, validation_probabilities)
    # Occasionally print the current loss.
    print("  period %02d : %0.2f" % (period, training_log_loss))
    # Add the loss metrics from this period to our list.
    training_log_losses.append(training_log_loss)
    validation_log_losses.append(validation_log_loss)
  print("Model training finished.")
  
  # Output a graph of loss metrics over periods.
  plt.ylabel("LogLoss")
  plt.xlabel("Periods")
  plt.title("LogLoss vs. Periods")
  plt.tight_layout()
  plt.plot(training_log_losses, label="training")
  plt.plot(validation_log_losses, label="validation")
  plt.legend()

  return linear_classifier

linear_classifier = train_linear_classifier_model(
    learning_rate=0.000005,
    steps=500,
    batch_size=20,
    training_examples=training_examples,
    training_targets=training_targets,
    validation_examples=validation_examples,
    validation_targets=validation_targets)

evaluation_metrics = linear_classifier.evaluate(input_fn=predict_validation_input_fn)

print("AUC on the validation set: %0.2f" % evaluation_metrics['auc'])
print("Accuracy on the validation set: %0.2f" % evaluation_metrics['accuracy'])

validation_probabilities = linear_classifier.predict(input_fn=predict_validation_input_fn)
# Get just the probabilities for the positive class.
validation_probabilities = np.array([item['probabilities'][1] for item in validation_probabilities])

false_positive_rate, true_positive_rate, thresholds = metrics.roc_curve(
    validation_targets, validation_probabilities)
plt.plot(false_positive_rate, true_positive_rate, label="our model")
plt.plot([0, 1], [0, 1], label="random classifier")
_ = plt.legend(loc=2)

linear_classifier = train_linear_classifier_model(
    learning_rate=0.000003,
    steps=20000,
    batch_size=500,
    training_examples=training_examples,
    training_targets=training_targets,
    validation_examples=validation_examples,
    validation_targets=validation_targets)

evaluation_metrics = linear_classifier.evaluate(input_fn=predict_validation_input_fn)

print("AUC on the validation set: %0.2f" % evaluation_metrics['auc'])
print("Accuracy on the validation set: %0.2f" % evaluation_metrics['accuracy'])
en

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (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...