Aprende Desafío: Entrenamiento del Perceptrón

Sección 1. Capítulo 17

single

Desliza para mostrar el menú

Antes de proceder con el entrenamiento del perceptrón, tenga en cuenta que utiliza la función de pérdida de entropía cruzada binaria discutida anteriormente. El último concepto clave antes de implementar la retropropagación es la fórmula para la derivada de esta función de pérdida con respecto a las activaciones de salida, $a^n$. A continuación se muestran las fórmulas para la función de pérdida y su derivada:

\begin{aligned} L &= -(y \log(\hat{y}) + (1-y) \log(1 - \hat{y}))\\ da^n &= \frac {\hat{y} - y} {\hat{y}(1 - \hat{y})} \end{aligned}

donde $a^n = \hat{y}$

Para verificar que el perceptrón se está entrenando correctamente, el método fit() también imprime la pérdida promedio en cada época. Esto se calcula promediando la pérdida sobre todos los ejemplos de entrenamiento en esa época:

for epoch in range(epochs):
    loss = 0

    for i in range(training_data.shape[0]):
        loss += -(target * np.log(output) + (1 - target) * np.log(1 - output))

average_loss = loss[0, 0] / training_data.shape[0]
print(f'Loss at epoch {epoch + 1}: {average_loss:.3f}')

L = -\frac1N \sum_{i=1}^N (y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i))

Finalmente, las fórmulas para calcular los gradientes en cada capa son las siguientes:

\begin{aligned} dz^l &= da^l \odot f'^l(z^l)\\ dW^l &= dz^l \cdot (a^{l-1})^T\\ db^l &= dz^l\\ da^{l-1} &= (W^l)^T \cdot dz^l \end{aligned}

Detalles de implementación a recordar

Al traducir estas fórmulas a código Python para el método backward(), recuerde las operaciones de NumPy discutidas en los capítulos anteriores:

El operador $\odot$ denota multiplicación elemento a elemento, que se realiza usando el operador estándar * en Python.
El operador $\cdot$ denota un producto punto, implementado usando la función np.dot().
El superíndice $T$ denota una transposición de matriz, gestionada por el atributo .T.
Para calcular $f'^l(z^l)$ , puede llamar dinámicamente a la derivada de la función de activación de la capa usando self.activation.derivative(self.outputs).

Esto hace que la estructura general del método backward() sea la siguiente:

def backward(self, da, learning_rate):
    dz = ... # using da and self.activation.derivative()
    d_weights = ... # using np.dot() and .T
    d_biases = ...
    da_prev = ...

    self.weights -= learning_rate * d_weights
    self.biases -= learning_rate * d_biases

    return da_prev

De manera similar, al integrar todo en el método fit(), recuerde que es necesario iterar a través de la red hacia atrás para propagar el error. La estructura general es la siguiente:

def fit(self, training_data, labels, epochs, learning_rate):
    # ... (Epoch loop and data shuffling) ...
            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output (da^n)
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ... # Call the backward() method of the layer

Los datos de entrenamiento de ejemplo (X_train) junto con las etiquetas correspondientes (y_train) se almacenan como arreglos de NumPy en el archivo utils.py. Además, las instancias de las funciones de activación también se definen allí:

relu = ReLU()
sigmoid = Sigmoid()

Tarea

Desliza para comenzar a programar

El objetivo es completar el proceso de entrenamiento para un perceptrón multicapa implementando el retropropagación y actualizando los parámetros del modelo.

Siga estos pasos cuidadosamente:

Implemente el método backward() en la clase Layer:

Calcule los siguientes gradientes:
dz: derivada de la pérdida con respecto a los valores de preactivación, utilizando la derivada de la función de activación;
d_weights: gradiente de la pérdida con respecto a los pesos, calculado como el producto punto de dz y el vector de entrada transpuesto;
d_biases: gradiente de la pérdida con respecto a los sesgos, igual a dz;
da_prev: gradiente de la pérdida con respecto a las activaciones de la capa anterior, obtenido multiplicando la matriz de pesos transpuesta por dz.
Actualice los pesos y sesgos utilizando la tasa de aprendizaje.

Complete el método fit() en la clase Perceptron:

Calcule la salida del modelo llamando al método forward();
Calcule la pérdida usando la fórmula de entropía cruzada;
Calcule $da^n$ — la derivada de la pérdida con respecto a las activaciones de salida;
Recorra hacia atrás las capas, realizando la retropropagación llamando al método backward() de cada capa.

Verifique el comportamiento del entrenamiento:

Si todo está implementado correctamente, la pérdida debería disminuir de forma constante en cada época al usar una tasa de aprendizaje de 0.01.

Solución

Cambia al escritorio para practicar en el mundo realContinúe desde donde se encuentra utilizando una de las siguientes opciones

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 17

single

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla