Perceptrón se refiere al tipo más simple de red neuronal, que consiste en solo una neurona. Para abordar problemas más complejos, se utiliza un modelo conocido como perceptrón multicapa (MLP). Un perceptrón multicapa contiene una o más capas ocultas que permiten a la red aprender patrones complejos en los datos.

La estructura de un perceptrón multicapa incluye:

1. Capa de entrada: recibe los datos de entrada;
2. Capas ocultas: procesan los datos y extraen patrones significativos;
3. Capa de salida: produce la predicción o clasificación final.

Cada capa está compuesta por múltiples neuronas, y la salida de una capa sirve como entrada para la siguiente capa.

Pesos y Sesgos de las Capas

Antes de implementar una capa, es importante comprender cómo almacenar los pesos y sesgos de cada neurona dentro de ella. En el capítulo anterior, aprendiste cómo almacenar los pesos de una sola neurona como un vector y su sesgo como un escalar (un solo número).

Dado que una capa consta de múltiples neuronas, es natural representar los pesos como una matriz, donde cada fila corresponde a los pesos de una neurona específica. En consecuencia, los sesgos pueden representarse como un vector, cuya longitud es igual al número de neuronas.

Dada una capa con $3$ entradas y $2$ neuronas, sus pesos se almacenarán en una matriz $2 \times 3$ $W$ y sus sesgos se almacenarán en un vector $2 \times 1$ $b$, que se ven de la siguiente manera:

Aquí, el elemento $W_{ij}$ representa el peso de la entrada $j$ a la neurona $i$, por lo que la primera fila contiene los pesos de la primera neurona y la segunda fila contiene los pesos de la segunda neurona. El elemento $b_i$ representa el sesgo de la neurona $i$ (dos neuronas – dos sesgos).

Propagación hacia adelante

Realizar la propagación hacia adelante para cada capa implica activar cada una de sus neuronas calculando la suma ponderada de las entradas, añadiendo el sesgo y aplicando la función de activación.

Anteriormente, para una sola neurona, implementaste la suma ponderada de las entradas calculando un producto punto entre el vector de entrada y el vector de pesos, y sumando el sesgo.

Dado que cada fila de la matriz de pesos contiene el vector de pesos para una neurona en particular, todo lo que tienes que hacer ahora es simplemente realizar un producto punto entre cada fila de la matriz y el vector de entrada. Afortunadamente, esto es exactamente lo que hace la multiplicación de matrices:

Para añadir los sesgos a las salidas de las neuronas respectivas, también se debe sumar un vector de sesgos:

Finalmente, se aplica la función de activación al resultado — sigmoide o ReLU, en nuestro caso. La fórmula resultante para la propagación hacia adelante en la capa es la siguiente:

donde $a$ es el vector de activaciones (salidas) de las neuronas.

Clase Layer

Los componentes fundamentales del perceptrón son sus capas, por lo tanto, tiene sentido crear una clase Layer independiente. Sus atributos incluyen:

• inputs: un vector de entradas (n_inputs es el número de entradas);
• outputs: un vector de valores de salida sin procesar (antes de aplicar la función de activación) de las neuronas (n_neurons es el número de neuronas);
• weights: una matriz de pesos;
• biases: un vector de sesgos;
• activation_function: la función de activación utilizada en la capa.

Al igual que en la implementación de una sola neurona, los weights y biases se inicializarán con valores aleatorios entre -1 y 1 tomados de una distribución uniforme.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

Los atributos inputs y outputs se utilizarán más adelante en la retropropagación, por lo que tiene sentido inicializarlos como arrays de NumPy llenos de ceros.

La propagación hacia adelante puede implementarse en el método forward(), donde los outputs se calculan a partir del vector inputs utilizando NumPy, siguiendo la fórmula anterior:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...