Aprende Implementación de Retropropagación

Enfoque general

En la propagación hacia adelante, cada capa $l$ toma las salidas de la capa anterior, $a^{l-1}$ , como entradas y calcula sus propias salidas. Por lo tanto, el método forward() de la clase Layer toma el vector de salidas previas como su único parámetro, mientras que el resto de la información necesaria se almacena dentro de la clase.

En la propagación hacia atrás, cada capa $l$ solo necesita $da^l$ para calcular los gradientes respectivos y devolver $da^{l-1}$ , por lo que el método backward() toma el vector $da^l$ como parámetro. El resto de la información requerida ya está almacenada en la clase Layer.

Derivadas de funciones de activación

Dado que las derivadas de las funciones de activación son necesarias para la retropropagación, funciones de activación como ReLU y sigmoide deben estructurarse como clases en lugar de funciones independientes. Esto nos permite definir tanto:

La propia función de activación (implementada mediante el método __call__()), permitiendo que se aplique directamente en la clase Layer usando self.activation(z);
Su derivada (implementada mediante el método derivative()), lo que permite una retropropagación eficiente y se utiliza en la clase Layer como self.activation.derivative(z).

Al estructurar las funciones de activación como objetos, podemos pasarlas fácilmente a la clase Layer y usarlas de manera dinámica.

ReLu

La derivada de la función de activación ReLU es la siguiente, donde $z_i$ es un elemento del vector de preactivaciones $z$ :

f'(z_i) = \begin{cases} 1, z_i > 0\\ 0, z_i \le 0 \end{cases}

class ReLU:
    def __call__(self, z):
        return np.maximum(0, z)

    def derivative(self, z):
        return (z > 0).astype(float)

Sigmoide

La derivada de la función de activación sigmoide es la siguiente:

f'(z_i) = f(z_i) \cdot (1 - f(z_i))

class Sigmoid:
    def __call__(self, x):
        return 1 / (1 + np.exp(-z))

    def derivative(self, z):
        sig = self(z)
        return sig * (1 - sig)

Para ambas funciones de activación, se aplican al vector completo $z$ , y lo mismo ocurre con sus derivadas. NumPy aplica internamente la operación a cada elemento del vector. Por ejemplo, si el vector $z$ contiene 3 elementos, la derivación es la siguiente:

f'(z) = f'( \begin{bmatrix} z_1\\ z_2\\ z_3 \end{bmatrix} ) = \begin{bmatrix} f'(z_1)\\ f'(z_2)\\ f'(z_3) \end{bmatrix}

El método backward()

El método backward() se encarga de calcular los gradientes utilizando las siguientes fórmulas:

\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}

a^{l-1} y $z^l$ se almacenan como los atributos inputs y outputs en la clase Layer, respectivamente. La función de activación $f$ se almacena como el atributo activation.

Una vez que se han calculado todos los gradientes necesarios, los pesos y sesgos pueden actualizarse ya que no se requieren para cálculos posteriores:

\begin{aligned} W^l &= W^l - \alpha \cdot dW^l\\ b^l &= b^l - \alpha \cdot db^l \end{aligned}

Por lo tanto, learning_rate ( $\alpha$ ) es otro parámetro de este método.

def backward(self, da, learning_rate):
    dz = ...
    d_weights = ...
    d_biases = ...
    da_prev = ...

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

    return da_prev

Nota

El operador * realiza una multiplicación elemento a elemento, mientras que la función np.dot() realiza el producto punto en NumPy. El atributo .T transpone un arreglo.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 8

Pregunte a AI

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

Suggested prompts:

Can you explain how the backward() method uses the stored attributes in the Layer class?

What is the purpose of the activation function's derivative in backpropagation?

Could you provide an example of how to use these activation function classes in a neural network layer?

Awesome!

Completion rate improved to 4

Desliza para mostrar el menú