11.Ingeniería 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 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.
.
- 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)
No hay comentarios:
Publicar un comentario