Un primer ejemplo explicado de TensorFlow

Demostramos, a través de un ejemplo explicado de TensorFlow, la forma de trabajar con ésta biblioteca de desarrollo de modelos de Machine Learning.

¿Qué es TensorFlow?

TensorFlow es una biblioteca código abierto para aprender a desarrollar y entrenar modelos de Machine Learning; cuenta con herramientas y recursos que permiten impulsar un aprendizaje automático innovador.

Ejemplo explicado de TensorFlow en Python

A continuación vamos a crear un modelo que nos permitirá convertir grados celsius a grados Fahrenheit sin utilizar una fórmula. Le proporcionaremos al modelo una serie de unos 30 datos de ejemplos de conversión y con base en ellos, el modelo “aprenderá” cómo convertir de grados celsius a grados fahrenheit.

Instalación de TensorFlow en Python

Puedes instalar TensorFlow en Python utilizando el siguiente comando:

pip install tensorflow

o bien

pip3 install tensoflow

Código del ejemplo explicado de TensorFlow

Paso 1. Importar las librerías

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import tensorflow as tf

Las librerías que utilizaremos son:

Pandas, para leer el archivo que contiene los datos

Seaborn y Matplotlib para la visualización de gráficos

Tensorflow para crear un modelo de machine learning

Paso 2. Obtención de los datos

print ("Leyendo CSV")
temperature_df = pd.read_csv("celsius_a_fahrenheit.csv")

# Visualización
sns.scatterplot(temperature_df['Celsius'], temperature_df['Fahrenheit'])
plt.show()

Primero, leemos los datos que se encuentran en el archivo celsius_a_fahrenheit.csv.

El archivo está disponible en: https://drive.google.com/file/d/1InzN9ULPJJvPEgy4kslLJMj2zKOq20P8/view?usp=sharing

Además, se utiliza scatterplot para mostrar que los datos están correlacionados.

Paso 3. Selección de las variables independiente y objetivo

#Cargando Set de Datos
print ("Seleccionando las columnas")
X_train = temperature_df['Celsius']
y_train = temperature_df['Fahrenheit']

Los datos obtenidos contienen dos columnas. La primer llamada Celsius, será nuestra variable independiente. La segunda, llamada Fahrenheit, será la variable objetivo. Es decir, una vez entrenado, el modelo será capaz de indicar los grados fahrenheit si le proporcionamos los grados celsius.

Paso 4. Creación del modelo

#Creando el Modelo
print ("Creando el modelo")
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(units=1, input_shape=[1]))

En ésta parte del código utilizamos Keras. Keras es una biblioteca escrita en Python que nos permite crear redes neuronales. Keras nos permite acceder a varios frameworks de machine learning, entre ellos, TensorFlow.

keras.Sequential nos permite crear una red neuronal en keras a la que se le agregan “capas” en forma secuencial. Un modelo en keras se considera “como una secuencia de capas que cada una de ellas va “destilando” gradualmente los datos de entrada para obtener la salida deseada” (Torres, 2018).

add agrega una capa al modelo. Cuando un modelo tiene capas densamente conectadas, todas las neuronas de cada capa están conectadas con todas las neuronas de la capa siguiente.

Paso 5. Compilación del modelo

#Compilado
print ("Compilando el modelo")
model.compile(optimizer=tf.keras.optimizers.Adam(1), loss='mean_squared_error')

Antes de que el modelo sea entrenado, se agregan configuraciones adicionales durante el paso de compilación. En éste caso se configura un optimizador y una función de pérdida, que mide qué tan exacto es el modelo. La función de pérdida utiliza es el “error cuadrado promedio” que básicamente mide el error cuadrado promedio de nuestras predicciones. El modelo tratará de minimizar ésta función para dirigir el modelo a la dirección adecuada.

Paso 6. Entrenamiento del modelo

#Entrenando el modelo
print ("Entrenando el modelo")
epochs_hist = model.fit(X_train, y_train, epochs = 100)

Usamos fit para entrenar el modelo. Le pasamos como parámetros la variable independiente (Grados Celsius) y la variable objetivo (Grados Fahrenheit) . También le indicamos que deseamos 100 epochs. Un epoch representa una iteración completa del conjunto  de entrenamiento. El número de epochs es la cantidad de veces que se ejecutará el algoritmo.

A continuación evaluaremos el modelo.

#Evaluando modelo
print ("Evaluando el modelo entrenado")
print ("Keys:")
print(epochs_hist.history.keys())
	
#Grafico
plt.plot(epochs_hist.history['loss'])
plt.title('Progreso de Pérdida durante Entrenamiento del Modelo')
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.legend('Training Loss')
plt.show()

Primero utilizamos epochs_hist.history.keys()  para mostrar el nombre de las llaves. Observamos que el nombre es “loss”. Después, procedemos a graficar ese dato.

La gráfica obtenida es similar a la siguiente:

Observamos que la pérdida (Training_loss) va disminuyendo a medida que se realizan más iteraciones (epoch).

Realizar una predicción utilizando el modelo entrenado

Temp_C = 0
Temp_F = model.predict([Temp_C])
print("Temperatura de Prediccion: " + str(Temp_F))

Teniendo nuestro modelo entrenado, ya podemos realizar una predicción. En éste caso, le damos una valor en grados Celsius (Temp_C) y el modelo nos devuelve el resultado que el cree correcto en grados Fahrenheit (Temp_F).

Temp_F = 9/5 * Temp_C + 32
print("Temperatura de Ecuacion: " + str(Temp_F))

Adicionalmente, mostramos el resultado utilizando la fórmula matemática, para corroborar qué tan cercana fue la predicción que el modelo arrojó.

Espero que éste ejemplo te haya permitido conocer un poco sobre ésta biblioteca para Machine Learning que es TensorFlow.

Referencias:

1. Torres(2018). Deep Learning. Introducción práctica con Keras. Disponible en: [https://torres.ai/deep-learning-inteligencia-artificial-keras/] consultado el [15-11-2020]

Te puede interesar:

Tu comentario

opiniones