Creando nuestra red neuronal usando numpy y matemáticas

¿Cómo configurar un entorno para trabajar con NumPy y redes neuronales?

¡Bienvenido! Nos adentramos en el emocionante mundo de las redes neuronales utilizando Python y NumPy. Este camino explorativo nos llevará a implementar funciones básicas como activaciones, pérdidas y entrenamiento con gradient descent. Comencemos con la preparación de nuestro entorno de desarrollo para maximizar la eficiencia.

1. Configurar Google Colab:

   • Renombrar el notebook a "Mi primera red con NumPy".
   • Importar las bibliotecas necesarias como NumPy y Matplotlib para manipulación de matrices y visualización.
   • Conectar a GPU para velocidad en los cálculos si es necesario: !nvidia-smi.

2. Importaciones iniciales:

   import numpy as np
   import matplotlib.pyplot as plt
   from sklearn.datasets import make_gaussian_quantiles

¿Cómo generamos el conjunto de datos para nuestra red neuronal?

Para entrenar redes neuronales necesitamos datos. Utilizaremos un conjunto de datos desde cero empleando make_gaussian_quantiles de scikit-learn para crear datos gaussianos con dos círculos concéntricos.

1. Definir muestras y características:

   • Usaremos mil ejemplos (n = 1000) con dos características y dos clases.

2. Crear los datos:

   n = 1000
   X, y = make_gaussian_quantiles(n_samples=n, n_features=2, n_classes=2, shuffle=True, random_state=None)
   y = y[:, np.newaxis]  # Agregar un axis para la compatibilidad con futuro codificación

3. Visualización de los datos:

   • Un simple gráfico para ver la distribución de los datos.

   plt.scatter(X[:, 0], X[:, 1], c=y[:, 0], s=40, cmap=plt.cm.Spectral)
   plt.show()

¿Cómo definir funciones de activación y pérdida esenciales?

Las redes neuronales dependen de funciones que calculan activaciones y pérdidas para adaptarse a la data. Aquí reutilizaremos algunas funciones conocidas con pequeñas modificaciones para el cálculo de derivadas.

1. Función Sigmoide:

   • Incluye cálculo de la derivada.

   def sigmoid(x, derivada=False):
       if derivada:
           return x * (1 - x)
       return 1 / (1 + np.exp(-x))

2. Función ReLU:

   • Una alternativa popular por su simplicidad y efectividad.

   def relu(x, derivada=False):
       if derivada:
           return np.where(x > 0, 1, 0)
       return np.maximum(0, x)

3. Función de pérdida (mse):

   • Error cuadrático medio como métrica de desempeño.

   def mse(y_true, y_pred):
       return np.mean(np.power(y_true - y_pred, 2))

¿Cómo configuramos la estructura y peso de una red neuronal?

Para que una red neuronal funcione, necesitamos definir su arquitectura y los pesos iniciales aleatorios, que influyen notablemente en el entrenamiento.

1. Inicializar los pesos:

   • Crear una función para definir las capas de entrada, ocultas y de salida.

2. Definición de la estructura:

   def inicializar_pesos(layer_dims):
       np.random.seed(1)
       parameters = {}
       L = len(layer_dims)  # Longitud de la lista de dimensiones
       for l in range(1, L):
           parameters['W' + str(l)] = np.random.rand(layer_dims[l], layer_dims[l-1]) * 2 - 1
           parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
       return parameters

3. Ejemplo de uso:

   • Probar esta configuración inicializando una red con 2 neuronas de entrada, capas ocultas personalizadas, y una sola neurona de salida.

   layer_dims = [2, 4, 8, 1]
   parameters = inicializar_pesos(layer_dims)

Con esto, tenemos los bloques iniciales necesarios para preparar una red neuronal básica en NumPy y realizar operaciones de entrenamiento en el siguiente paso. ¡Sigue adelante y descubre más sobre el fascinante mundo del aprendizaje automático!