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

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:

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

)