Perceptrón es el nombre de la red neuronal más simple, que consiste en una sola neurona. Sin embargo, para poder resolver problemas más complejos, crearemos un modelo llamado perceptrón multicapa (MLP). Un perceptrón multicapa consta de una o más capas ocultas. La estructura de un perceptrón multicapa es la siguiente:

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

En general, cada capa consta de múltiples neuronas, y la salida de una capa se convierte en la entrada para la siguiente capa.

Pesos y Sesgos de la Capa

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$ hacia 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 debes 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 separada. Sus atributos incluyen:

• inputs: un vector de entradas (n_inputs es el número de entradas);
• outputs: un vector de valores de salida en bruto (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 posteriormente 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 en función 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 ...