back to all

Nuestra primera red neuronal en Tensorflow con todos los detalles

¡Bienvenidos a nuestra guía detallada sobre cómo crear y entrenar una red neuronal en TensorFlow! En este artículo, exploraremos paso a paso la construcción de un clasificador básico utilizando TensorFlow y Keras. A lo largo del camino, explicaremos cada sección del código para que entiendas claramente cada componente y su propósito.

Introducción

TensorFlow es una de las bibliotecas más populares para el desarrollo de modelos de aprendizaje automático y redes neuronales. Con la ayuda de Keras, una API de alto nivel integrada en TensorFlow, podemos construir y entrenar modelos de manera eficiente y sencilla. En este proyecto, crearemos una red neuronal para resolver el problema clásico de XOR.

Preparación del Entorno

Antes de comenzar, asegúrate de tener instaladas las librerías necesarias. Puedes usar poetry o pip para instalar las dependencias:

poetry add tensorflow scikit-learn numpy
# o
pip install tensorflow scikit-learn numpy

Definición de los Datos

Primero, definimos un pequeño conjunto de datos que representa el problema XOR. Este conjunto de datos tiene dos características y una salida binaria.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np

# Datos de ejemplo: XOR problem
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

En este ejemplo, X contiene cuatro pares de entradas binarias y y contiene las salidas correspondientes para la operación XOR.

División de los Datos

Dividimos nuestros datos en conjuntos de entrenamiento y prueba para poder evaluar el rendimiento de nuestro modelo de manera objetiva.

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

La función train_test_split de Scikit-Learn divide los datos en conjuntos de entrenamiento (80%) y prueba (20%). El parámetro random_state=42 asegura que la división sea reproducible.

¿Por qué dividir los datos?

Dividir los datos en conjuntos de entrenamiento y prueba es esencial para evaluar el rendimiento del modelo en datos no vistos, lo cual ayuda a evitar el sobreajuste (overfitting) y proporciona una indicación clara de la capacidad de generalización del modelo.

Estandarización de los Datos

La estandarización es un paso clave en el preprocesamiento que ajusta las características de los datos para que tengan media cero y desviación estándar uno.

# Estandarizar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Usamos StandardScaler para ajustar y transformar los datos de entrenamiento y prueba, asegurando que cada característica tenga una escala comparable.

¿Qué es la media y la desviación estándar?

  • Media: La media es el promedio de todos los valores en el conjunto de datos. Se calcula sumando todos los valores y dividiéndolos por el número total de valores.
  • Desviación Estándar: La desviación estándar mide cuánto se separan los valores de un conjunto de datos respecto a la media. Es una medida de dispersión que proporciona una idea de la variabilidad de los datos.

Ejemplo de Cálculo

Para un conjunto de datos X = [1, 2, 3, 4, 5]:

  • Media:
    \[
    \mu = \frac{1+2+3+4+5}{5} = 3
    \]
  • Desviación Estándar:
    \[
    \sigma = \sqrt{\frac{(1-3)^2 + (2-3)^2 + (3-3)^2 + (4-3)^2 + (5-3)^2}{5}} \approx 1.41
    \]

Creación del Modelo

Construimos una red neuronal con la API Sequential de Keras. Este modelo tendrá dos capas ocultas y una capa de salida.

# Crear el modelo
model = Sequential([
    Dense(4, activation='relu', input_shape=(2,)),
    Dense(4, activation='relu'),
    Dense(1, activation='sigmoid')
])
  • Primera Capa Oculta: 4 neuronas, función de activación relu.
  • Segunda Capa Oculta: 4 neuronas, función de activación relu.
  • Capa de Salida: 1 neurona, función de activación sigmoid, ideal para clasificación binaria.

¿Qué son las capas densas y las funciones de activación?

  • Capa Dense: Una capa totalmente conectada donde cada neurona está conectada a todas las neuronas de la capa anterior y la siguiente.
  • Función de Activación relu: Rectified Linear Unit, una función no lineal que ayuda a la red a aprender características complejas.
  • Función de Activación sigmoid: Transforma la salida en un rango entre 0 y 1, interpretándola como una probabilidad.

Compilación del Modelo

Configuramos el modelo para el entrenamiento especificando el optimizador, la función de pérdida y las métricas de evaluación.

# Compilar el modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
  • Optimizer: adam, un optimizador eficiente y robusto.
  • Loss: binary_crossentropy, adecuado para clasificación binaria.
  • Metrics: accuracy, para evaluar la precisión del modelo.

Detalles de los Componentes

  • Adam: Un optimizador que combina las ventajas de AdaGrad y RMSProp, adaptando la tasa de aprendizaje para cada parámetro.
  • Binary Crossentropy: Mide la diferencia entre las distribuciones de probabilidad verdadera y predicha.
  • Accuracy: Proporción de predicciones correctas sobre el total de predicciones.

Entrenamiento del Modelo

Entrenamos el modelo con los datos de entrenamiento especificando el número de épocas y el tamaño del lote.

# Entrenar el modelo
model.fit(X_train, y_train, epochs=100, batch_size=1, verbose=1)
  • Epochs: 100, el número de iteraciones completas sobre los datos de entrenamiento.
  • Batch Size: 1, actualiza los pesos después de cada muestra.

¿Qué es una época y un lote?

  • Época: Una pasada completa a través de todo el conjunto de datos de entrenamiento.
  • Lote: Un subconjunto de datos utilizado para actualizar los pesos del modelo en cada iteración.

Detalles del Proceso de Entrenamiento

Inicialización: Se inicializan los pesos del modelo.
Forward Pass: El modelo realiza predicciones sobre el lote de datos.
Cálculo de la Pérdida: Se calcula la función de pérdida comparando las predicciones con las etiquetas verdaderas.
Backward Pass: Se calculan los gradientes y se actualizan los pesos del modelo.
Iteración: Este proceso se repite para cada lote en cada época.

Evaluación del Modelo

Finalmente, evaluamos el rendimiento del modelo utilizando el conjunto de datos de prueba.

# Evaluar el modelo loss, accuracy = model.evaluate(X_test, y_test)
print(f’Loss: {loss}, Accuracy: {accuracy}’)

La función evaluate mide la pérdida y la precisión del modelo en los datos de prueba, proporcionando una indicación clara de su capacidad de generalización.

¿Por qué es importante la evaluación?

  • Medición de la Generalización: Evaluar el modelo en un conjunto de datos de prueba no visto durante el entrenamiento proporciona una medida de cómo se desempeña el modelo en datos nuevos.
  • Identificación de Problemas: Ayuda a identificar problemas como sobreajuste o subajuste.

Detalles del Proceso de Evaluación

  1. Predicciones: El modelo realiza predicciones sobre los datos de prueba.
  2. Cálculo de la Pérdida: Se mide la discrepancia entre las predicciones y las etiquetas verdaderas.
  3. Cálculo de la Precisión: Se calcula la proporción de predicciones correctas.

Conclusión

Hemos construido, entrenado y evaluado una red neuronal simple en TensorFlow para resolver el problema XOR. Este proyecto ilustra los conceptos fundamentales del aprendizaje automático, desde la preparación de datos hasta la evaluación del modelo.

Espero que esta guía te haya ayudado a entender los componentes básicos y el flujo de trabajo en TensorFlow y Keras. Con este conocimiento, estás listo para explorar modelos más complejos y aplicaciones avanzadas en el mundo del aprendizaje automático.

#Código completo para tu referencia

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np

# Datos de ejemplo: XOR problem
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Estandarizar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Crear el modelo
model = Sequential([
    Dense(4, activation='relu', input_shape=(2,)),
    Dense(4, activation='relu'),
    Dense(1, activation='sigmoid')
])

# Compilar el modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar el modelo
model.fit(X_train, y_train, epochs=100, batch_size=1, verbose=1)

# Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Loss: {loss}, Accuracy: {accuracy}')

 

Este artículo proporciona una base sólida para comenzar con TensorFlow y Keras. Si tienes alguna pregunta o necesitas más detalles, no dudes en contactarnos. ¡Felices aprendizajes!

Some More Cool Projects