Perceptrón es la red neuronal más simple—solo una neurona. Para tareas más complejas, se utiliza un perceptrón multicapa (MLP), que contiene una o más capas ocultas que permiten a la red aprender patrones más complejos.

Un MLP consiste en:

1. Capa de entrada — recibe los datos;
2. Capas ocultas — extraen patrones;
3. Capa de salida — produce las predicciones.

Cada capa tiene múltiples neuronas; la salida de una capa se convierte en la entrada de la siguiente.

Pesos y Sesgos de la Capa

Anteriormente, una neurona almacenaba sus pesos como un vector y el sesgo como un escalar. Sin embargo, una capa contiene muchas neuronas, por lo que sus pesos se convierten en una matriz, donde cada fila almacena los pesos de una neurona. Los sesgos de todas las neuronas forman un vector.

Para una capa con 3 entradas y 2 neuronas:

Aquí, $W_{ij}$ es el peso desde la entrada $j$ hacia la neurona $i$; $b_i$ es el sesgo de la neurona $i$.

Propagación Hacia Adelante

La propagación hacia adelante activa cada neurona calculando una suma ponderada, añadiendo el sesgo y aplicando la función de activación.

Anteriormente, una sola neurona utilizaba:

[ z = W \cdot x + b ]

Ahora, dado que cada fila de (W) es el vector de pesos de una neurona, realizar la multiplicación de matrices entre la matriz de pesos y el vector de entrada calcula automáticamente las sumas ponderadas de todas las neuronas a la vez.

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 este 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

Dado que los MLP se construyen a partir de capas, se define una clase Layer dedicada. Sus atributos:

• inputs: vector de entrada (elementos n_inputs);
• outputs: salidas brutas de las neuronas (elementos n_neurons);
• weights: matriz de pesos;
• biases: vector de sesgos;
• activation_function: función de activación utilizada en la capa.

Los pesos y sesgos se inicializan con valores aleatorios de una distribución uniforme en ([-1, 1]). inputs y outputs se inicializan como arreglos de NumPy llenos de ceros para asegurar formas consistentes durante la retropropagación posterior.

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

Método Forward

La propagación hacia adelante para una capa calcula las salidas sin procesar y aplica la activación:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs: weighted sum + bias
    self.outputs = ...
    # Apply activation
    return ...

Reformar la entrada en un vector columna asegura que se multiplique correctamente con la matriz de pesos y que coincida con las dimensiones esperadas en toda la red.