Crea tu primera Red Neuronal Artificial

Paso a paso vamos a describir cada línea de código a fin de comprender con claridad el desarrollo de tu primera Red Neuronal Artificial.

Podría decir que no es necesario ningún conocimiento previo para crear una red neuronal como se suele decir en muchas publicaciones de internet, pero sería mentir; los estudiantes no solo deben copiar y pegar, deben comprender con claridad lo que están haciendo y para este tipo de ejercicios deben contar con una base previa en fundamentos de programación y algoritmia.

Nota: este apunte está orientado a la Carrera de Ingeniería de Software con IA, por tal motivo, parte del procedimiento puede encontrarse personalizado. Se recomienda repasar bien los apuntes relacionados para ponerlo en práctica correctamente.

PASO 1 – Arrancar Jupyter desde la carpeta de trabajo

Para esta práctica se requiere seguir la guía para instalar Jupyter Lab.

Nota: si va a usar Google Colab puede saltar hasta el PASO 3

PASO 2 – Conectar Visual Studio Code a Jupyter

Nota Previa: En Windows la carpeta de trabajo siempre debe ser la misma donde se ejecuta el entorno virtual de Python para Jupyter Lab, esto se debe a que allí se encuentran ya descargadas e instaladas la mayoría de bibliotecas para nuestros proyectos de IA. Se recomienda leer cuidadosamente el apunte de instalación de Jupyter Lab. y el apunte de Mis extensiones usadas en Visual Studio Code.

Con la carpeta de trabajo previamente creada y con Jupyter Lab ejecutándose correctamente, arrastramos la carpeta de trabajo hacia el entorno de Visual Studio Code. Si nos solicita confirmar la confianza en los autores, damos check y clic en Sí, confío en los autores.

Creamos una hoja de Jupyter Notebook con la extensión ipynb.

Imagen Referencial

Al crear un cuaderno de Jupyter Notebook aparecerá esta opción en Visual Studio Code, le damos clic para seleccionar el Kernel.

Escribimos la URL del servidor Jupyter instalado en nuestra máquina.

Tener presente que…

Si tenemos instalado Jupyter en nuestro equipo de forma local, usaremos la URL http://localhost:8888/

Si nos conectaremos a un servidor Jupyter remoto, usaremos la URL http://ipdelservidor:8888/

Jupyter nos solicitará contraseña; tenemos que crear previamente nuestra contraseña personalizada tal como se muestra en este Apunte.

Renombramos la conexión para fines prácticos:

Luego seleccionamos el Kernel Python 3 (ipykernel)

PASO 3 – Creamos nuestra primera Red Neuronal Artificial.

En el archivo ejercicio1.ipynb empezamos a construir nuestro primer algoritmo de IA con la capacidad de calcular «el perímetro de un círculo».

PASO 3.1 – Importamos Librerías tensorflow y numpy

import tensorflow as tf
import numpy as np

Si ejecutamos este fragmento de código, notaremos que es probable que solicite contraseña del servidor Jupyter. Ingresar la clave: 12345678

PASO 3.2

Vamos a crear un arreglo llamado entradacm para los datos de entrada y otro llamado salidacm para los datos de salida. Ambos los usaremos como muestreo para entrenar nuestra red neuronal.

entradacm = np.array([3, 4, 5, 8, 10, 12, 15], dtype=float)
salidacm = np.array([18.85, 25.13, 31.42, 50.27, 62.83, 75.4, 94.25], dtype=float)

PASO 3.3

Ahora diseñamos nuestro modelo de red neuronal, para hacerlo, además de usar TensorFlow, utilizamos el framework Keras, el cual nos permite hacer las redes neuronales de manera simple y nos ahorra muchas líneas de código. En Keras puedo especificar las capas de entrada y salida por separado, o ahorrarme un paso y especificar solo la capa de salida.

Creamos una variable llamada “capa” y la iniciaremos como una capa de tipo densa. En Keras, las capas densas son aquellas que tienen conexiones desde cada neurona hacia todas las neuronas de la siguiente capa. Aquí tenemos solo dos neuronas, entonces no hay mucho más que conectar.

Al registrar la capa, le indico las unidades o neuronas de la capa. Esta capa de salida solo tiene una neurona. Aparte, usamos la variable input_shape, y aquí es donde le decimos que tenemos una entrada con una neurona. Esto nos autorregistra la capa de entrada con una neurona. Estas capas por sí solas no hacen mucho, necesitamos usar un modelo en Keras para conectar las capas y trabajar con ellas.

Hay varios tipos de modelos. En este caso usaré el secuencial. Los otros modelos son para redes neuronales más avanzadas que veremos después. Indiquemos la capa que creamos. Aunque ya tenemos el modelo listo, el siguiente paso es compilarlo, lo cual prepara el modelo para entrenarse.

capa = tf.keras.layers.Dense(units=1, input_shape=[1])
modelo = tf.keras.Sequential([capa])

PASO 3.4

Vamos a usar el algoritmo Adam para el optimizador.

Adam – Keras: La optimización de Adam es un método de descenso de gradiente estocástico que se basa en la estimación adaptativa de momentos de primer y segundo orden.

Permite a la red ajustar los pesos y sesgos de manera eficiente para que aprenda mejor. La tasa de aprendizaje le indica cuánto ajustar estos pesos y sesgos. Si ponemos un número muy pequeño, los ajustes serán muy lentos y la red aprenderá despacio, pero si el número es muy grande, los cambios pueden ser demasiado bruscos y la red no alcanzará los resultados esperados. Colocaremos el valor de 0.1, aunque puedes probar con otros valores después si lo deseas.

Para la función de pérdida, usaremos el «mean squared error» o error cuadrático medio. Aunque su nombre suene complicado, básicamente esta función considera que una pequeña cantidad de errores grandes es peor que una gran cantidad de errores pequeños.

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

PASO 3.5

Muy bien, ya tenemos nuestro modelo compilado y listo para entrenarse. Para entrenar el modelo, usamos la función fit. Le indicamos los datos de entrada y salida esperados, es decir, los radios y perímetros, además de cuántas vueltas (o «epochs») queremos que lo intente. Recordemos que solo tenemos 7 datos, así que una vuelta significa revisará esos 7 datos una sola vez. Tenemos que darle muchas vueltas a esos 7 datos para optimizar lo mejor posible, en nuestro caso le daremos 100 vueltas.

Además, pondré verbose=False para que no imprima demasiada información mientras se entrena. Imprimamos un mensaje agradable para saber que ya terminó de entrenarse

print("Entrenando Modelo, espere ...")
grafica = modelo.fit(entradacm, salidacm, epochs=100, verbose=False)
print("Modelo entrenado!")

PASO 3.6

¡Listo! El modelo ya está entrenado, con ello ya podríamos realizar predicciones; sin embargo, veamos el resultado de la función de pérdida para comprender mejor el proceso de entrenamiento de nuestra Red Neuronal.

Usaremos la biblioteca Matplotlib para presentar los datos en una gráfica.

Matplotlib: es una biblioteca completa para crear visualizaciones estáticas, animadas e interactivas en Python. Una librería infaltable para visualizar el rendimiento de tu modelo y el tratamiento de los datos.

Dibujamos el rendimiento de entrenamiento:

import matplotlib.pyplot as plt
plt.xlabel("# Epoca")
plt.ylabel("Magnitud de pérdida")
plt.plot(grafica.history["loss"])

PASO 3.7

¡Bien, ahora hagamos una predicción!!

Para tal fin, aprovechemos y presentemos mensajes más amigables durante el cálculo.

print("Hola, he sido entrenado para calcular el Perimetro de un Circulo !")
radio = 22
print(f"Estoy Calculando el perimetro de un radio de {radio}cm, espere ...")
resultado = modelo.predict(np.array([radio]))
print(f"El resultado es {resultado} cm")

El resultado es:

El perímetro real de un círculo de radio = 22cm es 138.23 cm, por lo que nuestro Modelo de Red Neuronal Artificial ha sido bastante acertado con un factor de confianza de 97.07% considerando una sola neurona de entrada y salida, para mejorar la predicción podemos agregar capas intermedias y más neuronas, lo cual veremos en este apunte: Red Neuronal Artificial con Capas Intermedias.

PASO 3.8

Podemos ver los pesos asignados…

print("Variables internas del modelo")
print(capa.get_weights())

Finalmente, tener presente …

En muchas ocasiones será necesario reiniciar el kernel de Jupyter para limpiar las variables construidas mientras desarrollas tu modelo de red neuronal artificial, ya que podría entregarte falsos positivos en una etapa de construcción.