7. Ejemplo predicción precios (2)
- 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 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:
- 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.
- 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.
- 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
)
