Retropropagación

IA

La retroprogación (backpropagation o propagación hacia atrás) es un método de cálculo del gradiente.

El método emplea un ciclo propagación – adaptación de dos fases. Una vez que se ha aplicado un patrón a la entrada de la red como estímulo, este se propaga desde la primera capa a través de las capas siguientes de la red, hasta generar una salida. La señal de salida se compara con la salida deseada y se calcula una señal de error para cada una de las salidas.

Las salidas de error se propagan hacia atrás, partiendo de la capa de salida, hacia todas las neuronas de la capa oculta que contribuyen directamente a la salida. Sin embargo las neuronas de la capa oculta solo reciben una fracción de la señal total del error, basándose aproximadamente en la contribución relativa que haya aportado cada neurona a la salida original. Este proceso se repite, capa por capa, hasta que todas las neuronas de la red hayan recibido una señal de error que describa su contribución relativa al error total.

La importancia de este proceso consiste en que, a medida que se entrena la red, las neuronas de las capas intermedias se organizan a sí mismas de tal modo que las distintas neuronas aprenden a reconocer distintas características del espacio total de entrada. Después del entrenamiento, cuando se les presente un patrón arbitrario de entrada que contenga ruido o que esté incompleto, las neuronas de la capa oculta de la red responderán con una salida activa si la nueva entrada contiene un patrón que se asemeje a aquella característica que las neuronas individuales hayan aprendido a reconocer durante su entrenamiento.

Los pasos del método de retropropagación son:

  1. Hacer una operación de feedforward.
  2. Comparar la salida del modelo con la deseada.
  3. Calcular el error.
  4. Ejecutar la propagación hacia atrás para distribuir el error a cada uno de los pesos.
  5. Actualizar los pesos y obtener un modelo mejor.
  6. Continuar hasta obtener un modelo suficientemente bueno.

Ejemplo de cálculo de los errores con retropropagación

En el siguiente ejemplo se va a:

  1. Calcular el error de salida de la red.
  2. Calcular el término de error de la capa de salida.
  3. Usar retropropagación para calcular el término de error de la capa oculta.
  4. Calcular el cambio en los pesos (las deltas) que resulta de propagar los errores hacia atrás en la red.
import numpy as np


def sigmoid(x):
    """
    Calculate sigmoid
    """
    return 1 / (1 + np.exp(-x))


x = np.array([0.5, 0.1, -0.2])
target = 0.6
learnrate = 0.5

weights_input_hidden = np.array([[0.5, -0.6],
                                 [0.1, -0.2],
                                 [0.1, 0.7]])

weights_hidden_output = np.array([0.1, -0.3])

## Forward pass
hidden_layer_input = np.dot(x, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)

output_layer_in = np.dot(hidden_layer_output, weights_hidden_output)
output = sigmoid(output_layer_in)

## Backwards pass
## (1) Calculate output error
error = target - output

# (2) Calculate error term for output layer
output_error_term = error * output * (1 - output)

# (3) Calculate error term for hidden layer
hidden_error_term = np.dot(output_error_term, weights_hidden_output) * \
                    hidden_layer_output * (1 - hidden_layer_output)

# (4) Calculate change in weights for hidden layer to output layer
delta_w_h_o = learnrate * output_error_term * hidden_layer_output

# (5) Calculate change in weights for input layer to hidden layer
delta_w_i_h = learnrate * hidden_error_term * x[:, None]

print('Change in weights for hidden layer to output layer:')
print(delta_w_h_o)
print('Change in weights for input layer to hidden layer:')
print(delta_w_i_h)

  Change in weights for hidden layer to output layer:
  [0.00804047 0.00555918]
  Change in weights for input layer to hidden layer:
  [[ 1.77005547e-04 -5.11178506e-04]
   [ 3.54011093e-05 -1.02235701e-04]
   [-7.08022187e-05  2.04471402e-04]]

Implementación de la retropropagación

El término error para la capa de salida es

$$
\delta_k = (y_k – \hat{y}_k) f'(a_k)
$$

y el término error de la capa oculta es

$$
\delta_j = \sum [w_{jk}\delta_k] f'(h_j)
$$

El algoritmo general para actualizar los pesos con retropropagación es el siguiente (consideramos una red simple con una capa oculta y una capa de salida):

  1. Establecer los incrementos de peso de cada capa a cero:
    • Los pesos de la capa de entrada a la capa oculta $\Delta w_{ij} = 0$.
    • Los pesos de la capa oculta a la capa de salida $\Delta W_{ij} = 0$.
  2. Para cada registro en los datos de entrenamiento:
    – Avanzar a través de la red, calculando la salida $\hat{y}$.
    – Calcular el gradiente de error en la unidad de salida, $\delta^0 = (y – \hat{y}) f'(z)$, donde $z=\sum_j W_j a_j$ es la entrada de la unidad de salida.
    – Propagar los errores a la capa oculta $\delta_j^h = \delta^0 W_j f'(h_j)$.
    – Actualizar los incrementos de peso:
    – $\Delta W_j = \Delta W_j + \delta^0 a_j$
    – $\Delta w_{ij} = \Delta w_{ij} + \delta_j^h a_i$
  3. Actualizar los pesos, donde $\eta$ es la tasa de aprendizaje y $m$ es el número de registros:
    • $W_j = W_j + \eta \Delta W_j / m$
    • $w_{ij} = w_{ij} + \eta \Delta w_{ij} / m$
  4. Repetir para $e$ etapas.

Ejemplo

En este ejemplo se va a:

  • Implementar el avance.
  • Implementar el algoritmo de retropropagación.
  • Actualizar los pesos.
import numpy as np
from data_prep import features, targets, features_test, targets_test

np.random.seed(21)

def sigmoid(x):
    """
    Calculate sigmoid
    """
    return 1 / (1 + np.exp(-x))


# Hyperparameters
n_hidden = 2  # number of hidden units
epochs = 900
learnrate = 0.005

n_records, n_features = features.shape
last_loss = None
# Initialize weights
weights_input_hidden = np.random.normal(scale=1 / n_features ** .5,
                                        size=(n_features, n_hidden))
weights_hidden_output = np.random.normal(scale=1 / n_features ** .5,
                                         size=n_hidden)

for e in range(epochs):
    del_w_input_hidden = np.zeros(weights_input_hidden.shape)
    del_w_hidden_output = np.zeros(weights_hidden_output.shape)
    for x, y in zip(features.values, targets):
        ## Forward pass ##
        # TODO: Calculate the output
        hidden_input = np.dot(x, weights_input_hidden)
        hidden_output = sigmoid(hidden_input)

        output = sigmoid(np.dot(hidden_output,
                                weights_hidden_output))

        ## Backward pass ##
        # TODO: Calculate the network's prediction error
        error = y - output

        # TODO: Calculate error term for the output unit
        output_error_term = error * output * (1 - output)

        ## propagate errors to hidden layer

        # TODO: Calculate the hidden layer's contribution to the error
        hidden_error = np.dot(output_error_term, weights_hidden_output)

        # TODO: Calculate the error term for the hidden layer
        hidden_error_term = hidden_error * hidden_output * (1 - hidden_output)

        # TODO: Update the change in weights
        del_w_hidden_output += output_error_term * hidden_output
        del_w_input_hidden += hidden_error_term * x[:, None]

    # TODO: Update weights
    weights_input_hidden += learnrate * del_w_input_hidden / n_records
    weights_hidden_output += learnrate * del_w_hidden_output / n_records

    # Printing out the mean square error on the training set
    if e % (epochs / 10) == 0:
        hidden_output = sigmoid(np.dot(x, weights_input_hidden))
        out = sigmoid(np.dot(hidden_output,
                             weights_hidden_output))
        loss = np.mean((out - targets) ** 2)

        if last_loss and last_loss < loss:
            print("Train loss: ", loss, "  WARNING - Loss Increasing")
        else:
            print("Train loss: ", loss)
        last_loss = loss

# Calculate accuracy on test data
hidden = sigmoid(np.dot(features_test, weights_input_hidden))
out = sigmoid(np.dot(hidden, weights_hidden_output))
predictions = out > 0.5
accuracy = np.mean(predictions == targets_test)
print("Prediction accuracy: {:.3f}".format(accuracy))

Publicaciones Similares

  • Convolutional Neural Network

    Porroberto

    Las Convolutional Neural Networks son redes multicapa que toman su inspiración del cortex visual de los animales. Esta arquitectura es útil en varias aplicaciones, principalmente procesamiento de imágenes, reconocimiento de vídeo y procesamiento del lenguaje natural. La arquitectura consta de varias capas que implementaban la extracción de características y luego clasificar. El siguiente paso es…

  • Regresión logística

    Porroberto

    El algoritmo de regresión logística consiste en: Tomar los datos Elegir un modelo aleatorio Calcular el error Minimizar el error y obtener un modelo mejor

  • Softmax

    Porroberto

    La función Softmax La función Softmax (o función exponencial normalizada)es equivalente a la sigmoide, pero cuando el problema de clasificación en lugar de tener dos clases tiene tres o más. La función está dada por $$ \sigma_j(\vec{z}) = \frac{e^{z_j}}{\sum_{k=1}^K e^{z_k}}, \mbox{ para } j=1,\dots K $$ En python la podríamos definir de la siguiente forma:…

  • Razonamiento y aprendizaje

    Porroberto

    Razonamiento Introducción. Sistemas expertos Un sistema experto es un sistema informático (hardware o software) que simula a expertos humanos en cierta área de especialización dada. Razonamiento aproximado. Tratamiento de la incertidumbre Fuentes de incertidumbre Se pueden clasificar las fuentes de incertidumbre en los siguientes grupos: Deficiencias de la información, características del mundo real, y deficiencias…

  • Entropía cruzada

    Porroberto

    La entropía cruzada conecta las probabilidades con las funciones de error. Está vinculada con la estimación por máxima verosimilitud. Buscaremos modelo cuya entropía sea mínima, porque nos darán la mejor clasificación, ya que son los que tienen una mayor probabilidad (y minimizan la función de error: entropía cruzada). La entropía se define como $-ln(P(x))$. La…

  • Historia de las redes neuronales

    Porroberto

    1958 – Perceptrón 1965 – Perceptrón multicapa 1980’s Neuronas Sigmoidales Redes Feedforward Retropropagación 1989 – Convolutional neural networks (CNN) / Recurent neural networks (RNN) 1997 – Long short term memory (LSTM) 2006 – Deep Belief Networks (DBN): Nace deep learning Restricted Boltzmann Machine Encoder / Decoder = Auto-encoder 2014 – Generative Adversarial Networks (GAN)

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *