Cómo crear una red neuronal con Python y Tensorflow

¿QUÉ ES UNA RED NEURONAL?

Una red neuronal es un modelo computacional inspirado en el funcionamiento del cerebro humano. Está compuesta por un conjunto de nodos (neuronas artificiales) organizados en capas que procesan información y aprenden a realizar tareas como clasificación, predicción o reconocimiento de patrones.

Estructura de una red neuronal:

• Capa de entrada: Recibe los datos de entrada (por ejemplo, imágenes, texto, números).
• Capas ocultas: Procesan la información aplicando transformaciones matemáticas mediante pesos y funciones de activación.
• Capa de salida: Genera el resultado final, como una clasificación (por ejemplo, "perro" o "gato") o un valor numérico (por ejemplo, una predicción de precios).

Tipos de redes neuronales:

• Redes Neuronales Artificiales (ANN): Usadas en tareas generales de aprendizaje supervisado.
• Redes Convolucionales (CNN): Especializadas en visión por computadora.
• Redes Recurrentes (RNN): Manejan datos secuenciales, como texto o series de tiempo.
• Redes Generativas (GAN): Crean nuevos datos realistas a partir de ejemplos.

Las redes neuronales son la base del aprendizaje profundo (Deep Learning) y se utilizan en aplicaciones como reconocimiento facial, asistentes virtuales, vehículos autónomos y mucho más.

La Inteligencia Artificial y las Redes Neuronales están de moda.

1.- ELEMENTOS NECESARIOS PARA ESTE TUTORIAL

• Cuenta en Google
• Conexión a Internet

2.- CONCEPTOS BÁSICOS ANTES DE PROGRAMAR

Básicamente, lo que queremos conseguir es una red neuronal básica que convierta metros a pies, en función de una serie de datos de entrada y datos de salida.

Escenario inicial

En la siguiente imagen, podemos ver un ejemplo muy básico de una red neuronal artificial, diseñada para convertir una medida en metros a su equivalente en pies. 

En el lado izquierdo, vemos la capa de entrada, que en este caso consta de una sola neurona encargada de recibir un valor numérico en metros. Este valor será el que la red utilice como base para hacer sus cálculos. A medida que la información avanza hacia la derecha, pasa por una o varias capas ocultas -que en la imagen aparecen difuminadas-. 

En la parte derecha de la imagen encontramos la capa de salida, que también contiene una sola neurona. Esta neurona entrega el resultado final: el valor en pies correspondiente al dato original en metros. Durante el entrenamiento, la red ajusta sus parámetros internos hasta que logra predecir con precisión esta conversión. Dado que la relación entre metros y pies es lineal (1 metro ≈ 3.28084 pies), este modelo se puede resolver incluso sin capas ocultas.

Capas y neuronas

En la siguiente imagen, vemos una red neuronal artificial de tipo perceptrón multicapa (MLP) y muestra de forma clara los elementos más importantes que la componen: las capas, las neuronas y las conexiones entre ellas. Es una forma visual muy útil para entender cómo se organiza internamente una red neuronal, especialmente cuando se quiere aplicar a tareas como clasificación, predicción o regresión.

A la izquierda vemos la Capa 1, que representa la capa de entrada. En este caso, hay tres neuronas (círculos amarillos), lo que indica que esta red recibe tres valores de entrada, como podrían ser características de un conjunto de datos: por ejemplo, altura, peso y edad. Cada uno de estos valores se envía a todas las neuronas de la Capa 2, que es una capa oculta compuesta también por tres neuronas (círculos verdes). Como su nombre indica, esta capa no está directamente conectada con la entrada o la salida del sistema, pero es clave en el procesamiento interno: en ella se aplican funciones matemáticas que permiten a la red detectar patrones complejos en los datos.

Finalmente, a la derecha está la Capa 3, que actúa como capa de salida y está formada por dos neuronas (círculos azules). Esta configuración sugiere que la red está diseñada para dar dos resultados al final del procesamiento, como podrían ser dos posibles clases en un problema de clasificación binaria, o dos valores numéricos si estamos resolviendo una tarea de regresión múltiple.

Todas las neuronas de una capa están conectadas con todas las neuronas de la siguiente, lo que se conoce como una red totalmente conectada o densa. Estas conexiones están representadas por las flechas negras y cada una de ellas tiene asociado un peso, que es lo que la red ajusta durante el entrenamiento para aprender la relación entre entradas y salidas. En resumen, esta imagen es una representación más completa de cómo trabaja una red neuronal artificial para procesar información y aprender a partir de ejemplos.

Capas, neuronas y conexiones

Esta imagen damos un paso más. No solo vemos las capas y las conexiones, sino que ahora entendemos que cada conexión entre neuronas lleva un valor numérico asociado, llamado peso, que determina la importancia de esa conexión. Además, también observamos que las neuronas de salida tienen números (3 y 2.5) que podrían representar los valores de activación, resultado del procesamiento completo.

La red está organizada en tres capas, como en las imágenes anteriores. En la Capa 1 (a la izquierda), hay tres neuronas de entrada, que podrían representar tres características de entrada de un problema real. Estas neuronas están conectadas con las tres neuronas de la Capa 2, que es una capa oculta. Las líneas que conectan estas neuronas están etiquetadas con números como 2, 1, 0.5, lo cual indica los pesos que se aplican a cada conexión. Por ejemplo, si un valor de entrada es 5 y se multiplica por un peso de 2, el valor transmitido será 10.

Luego, las neuronas de la capa oculta también están conectadas con las neuronas de la Capa 3 (la de salida). Nuevamente, cada línea lleva un peso. Aquí es donde se suman las señales multiplicadas por sus pesos y, posiblemente, se añade un sesgo (bias), aunque no se indica explícitamente en esta imagen. Finalmente, el resultado se pasa por una función de activación (como ReLU o sigmoide, aunque no se muestra) para obtener el valor final que aparece en cada neurona de salida.

Conexiones, pesos y sesgos

Para saber como funciona, haremos un pequeño ejemplo. Como entrada meteremos 10 metros, multiplicado por el peso 1.5 = 15 + sesgo = 18 pies. Tanto el peso como los sesgos se asignan aleatoriamente al inicializar la red neuronal. Pero, 10 metros son realmente 32.8084 pies, por tanto... ¿conseguirá la red neuronal aprender los resultados correctos?

Cómo funcionan las predicciones

3.- GOOGLE COLAB

Google Colab es una herramienta gratuita de Google que permite escribir y ejecutar código en Python directamente desde el navegador. Está especialmente pensada para aprendizaje automático, ciencia de datos y análisis de datos, aunque también se puede usar para programación general en Python.

Características principales de Google Colab:

• Entorno de notebooks: podréis escribir texto, ecuaciones, código y ver los resultados todo en el mismo documento.
• Basado en la nube: no necesitáis instalar nada, todo corre en los servidores de Google.
• Almacenamiento en Google Drive: podréis guardar y compartir notebooks fácilmente.
• Acceso a GPUs y TPUs gratis: ideal para tareas que requieren mucha potencia de cálculo como entrenar modelos de IA.
• Colaboración en tiempo real: como en Google Docs, varias personas pueden editar el mismo notebook al mismo tiempo.

¿Para qué se usa normalmente?

• Cursos de programación y ciencia de datos.
• Experimentos rápidos con machine learning.
• Probar bibliotecas de Python sin tener que instalar nada localmente.
• Crear prototipos de modelos de inteligencia artificial.

Web Google Colab:  https://colab.research.google.com/

4.- IMPORTAR LAS HERRAMIENTAS

Lo primero que debemos hacer es crear un nuevo fichero en Google Colab e ir añadiendo bloques de código. En el primero, lo que haremos es importar las librerías y bibliotecas necesarias para crear nuestra primera red neuronal:

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Aquí cargamos las bibliotecas y librerías necesarias:

• tensorflow: Biblioteca para crear y entrenar redes neuronales.
• numpy: Biblioteca para manejar arrays numéricos.
• matplotlib.pyplot: Librería para generar gráficos. 

Importar herramientas

5.- DEFINIR DATOS DE ENTRADA Y SALIDA

En el siguiente bloque de código, será donde ingresemos los datos de entrada en el array metro y los datos de salida en el array pies:

metros = np.array([1,5,10,20,50,100,200], dtype=float)
pies = np.array([3.28084,16.4042,32.8084,65.6168,164.042,328.084,656.168], dtype=float)

Para la conversion se ha utilizado el valor de 1 metro = 3.28084 pies.

Datos de entrada y salida

6.- DEFINIR LA RED NEURONAL

El siguiente paso es definir la red neuronal, el número de capas y las neuronas.

# Crear el modelo secuencial
modelo = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(1,)), # Entrada: un solo valor (la cantidad de metros)
    tf.keras.layers.Dense(units=1) # Capa densa con 1 neurona (salida: cantidad de pies)
])

Usaremos Sequential, lo que significa que las capas se apilan unas tras otra.

• Input layer: Acepta un número (1D), o sea, los metros.
• Dense layer: Tiene 1 neurona, lo que significa que da una sola salida (los pies).
• Tenemos una sola capa y una sola neurona.
• La entrada es un solo número (la cantidad de metros).
• La salida será también un número (los pies).

Definir red neuronal

7.- PREPARAR EL MODELO PARA ENTRENAR

Ahora debemos configurar el modelo antes de entrenarlo.

modelo.compile(
    optimizer=tf.keras.optimizers.Adam(0.1),
    loss='mean_squared_error'
)

• Adam(0.1): Es el optimizador, con una tasa de aprendizaje de 0.1 (algo alta, porque el problema es muy simple).
• mean_squared_error: Función de pérdida (error cuadrático medio) - mide qué tan lejos están las predicciones del valor real.

Preparar el modelo

8.- ENTRENAR LA RED

Ahora es el momento de comenzar el entrenamiento de la red.

print("Comenzando entrenamiento");
historial = modelo.fit(metros, pies, epochs=1000, verbose=False)
print("Modelo entrenado")

• Se entrena el modelo con los datos proporcionados (metros, pies).
• epochs=1000: El modelo verá todos los datos 1000 veces.
• verbose=False: No muestra progreso por consola.

Entrenar la red

9.- PROBAR LA RED CON UN DATO DE ENTRADA

Una vez entrenada la red con los datos de entrada y salida proporcionados, realizaremos una predicción con un dato de entrada, en este caso 15 metros.

print("Hagamos una prediccion")
resultado = modelo.predict(np.array([15]).reshape(-1, 1))
print("El resultado es " + str(resultado) + " pies")

• reshape(-1, 1): Convierte el número en el formato esperado por la red (una columna).
• El modelo devuelve la cantidad de pies.

Hacer una predicción

El resultado de la predicción es:

Hagamos una predicción
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 87ms/step
El resultado es [[49.327248]] pies

10.- VER COMO APRENDIÓ LA RED NEURONAL

plt.xlabel("# Epoca")
plt.ylabel("Magnitud de pérdida")
plt.plot(historial.history["loss"])
plt.show()

• plt.xlabel: Agrega una etiqueta al eje X del gráfico. En este caso, el texto es # Epoca, lo que sugiere que el eje X representa las épocas (iteraciones completas sobre los datos de entrenamiento) en el modelo machine learning.
• plt.ylabel: Esta línea etiqueta el eje Y, y en este caso representa la "magnitud de pérdida" (loss), una métrica que mide qué tan mal lo está haciendo el modelo (cuanto menor, mejor, en general).
• plt.plot: Aquí se dibuja la curva de pérdida. 
• plt.show: Esta línea muestra el gráfico.

Aprendizaje de la red neuronal

Curva de aprendizaje de la red neuronal:

Curva de aprendizaje

ENJOY!