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 su 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 implementarse como clases en lugar de funciones independientes. Esta estructura permite definir claramente ambos componentes:

La propia función de activación — implementada usando el método __call__(), de modo que se pueda aplicar directamente en la clase Layer con self.activation(z);
Su derivada — implementada usando el método derivative(), lo que permite un cálculo eficiente durante la retropropagación mediante self.activation.derivative(z).

Representar las funciones de activación como objetos facilita pasarlas a diferentes capas y aplicarlas dinámicamente tanto en la propagación hacia adelante como hacia atrás.

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, la operación se aplica a todo el vector $z$ , así como a su derivada. NumPy realiza automáticamente el cálculo elemento a elemento, lo que significa que cada elemento del vector se procesa de forma independiente.

Por ejemplo, si el vector $z$ contiene tres elementos, la derivada se calcula como:

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

El método backward()

El método backward() es responsable 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 derivative() method in the activation function classes?

Could you provide an example of how forward and backward propagation work together in a simple neural network?

Awesome!

Completion rate improved to 4

Desliza para mostrar el menú