12.Combinaciones de atributos
- 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
- 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)
No hay comentarios:
Publicar un comentario