Propagación hacia atrás

La propagación hacia atrás de errores o retropropagación (del inglés backpropagation) es un algoritmo de aprendizaje supervisado que se usa para entrenar redes neuronales artificiales. El algoritmo consiste en minimizar un error (comúnmente cuadrático) por medio de gradiente descendiente, por lo que la parte esencial del algoritmo es cálculo de las derivadas parciales de dicho error con respecto a los parámetros de la red neuronal.

Minimización del Error

Los algoritmos en Aprendizaje Automático pueden ser clasificados en dos categorías: supervisados y no supervisados. Los algoritmos en aprendizaje supervisado son usados para construir "modelos" que generalmente predicen un ciertos valores deseados. Para ello, los algoritmos supervisados requieren que se especifiquen los valores de salida (output) u objetivo (target) que se asocian a ciertos valores de entrada (input). Ejemplos de objetivos pueden ser valores que indican éxito/fallo, venta/no-venta, pérdida/ganancia, o bien ciertos atributos multi-clase como cierta gama de colores o las letras del alfabeto. El conocer los valores de salida deseados permite determinar la calidad de la aproximación del modelo obtenido por el algoritmo.

La especificación de los valores entrada/salida se realiza con un conjunto consistente en pares de vectores con entradas reales de la forma $({\boldsymbol {x}},{\boldsymbol {t}})$, conocido como conjunto de entrenamiento o conjunto de ejemplos. Los algoritmos de aprendizaje generalmente calculan los parámetros ${\boldsymbol {W}}$ de una función $N({\boldsymbol {x}};{\boldsymbol {W}})$ que permiten aproximar los valores de salida en el conjunto de entrenamiento.

Si $({\boldsymbol {x}}^{(q)},{\boldsymbol {t}}^{(q)})$, $q=1,\ldots ,p$, son los elementos del conjunto de entrenamiento, la calidad de la aproximación en el ejemplo $q$ se puede medir a través del error cuadrático:

$E({\boldsymbol {x}}^{(q)};{\boldsymbol {W}})={\frac {1}{2}}\|N({\boldsymbol {x}}^{(q)};{\boldsymbol {W}})-{\boldsymbol {t}}^{(q)}\|^{2}$,

donde $\|\cdot \|$ es la norma euclidiana.

El error total es la suma de los errores de los ejemplos:

$E({\boldsymbol {W}})=\sum _{q=1}^{p}E({\boldsymbol {x}}^{(q)};{\boldsymbol {W}})$.

Un método general para minimizar el error es el actualizar los parámeros de manera iterativa. El valor nuevo de los parámetros se calcula al sumar un incremento $\Delta {\boldsymbol {W}}$ al valor actual:

${\boldsymbol {W}}:={\boldsymbol {W}}+\Delta {\boldsymbol {W}}$

El algoritmo se detiene cuando ${\boldsymbol {W}}$ converge o bien cuado el error alcanza un mínimo valor deseado.

Si la función $N({\boldsymbol {x}};{\boldsymbol {W}})$ usada para aproximar los valores de salida es diferenciable respecto a los parámetros ${\boldsymbol {W}}$, podemos usar como algoritmo de aprendijaze el método de gradiende descendiente. En este caso, el incremento de los parámetros se expresa como

$\Delta {\boldsymbol {W}}=-\gamma {\frac {\partial E({\boldsymbol {W}})}{\partial {\boldsymbol {W}}}},$

donde $0<\gamma <1$ es un parámetro conocido como factor de aprendizaje.

Antes de continuar introduciremos un poco de notación. Definimos ${\bar {\boldsymbol {v}}}=(v_{1},\ldots ,v_{n},1)^{T}$ como el vector extendido del vector ${\boldsymbol {v}}=(v_{1},\ldots ,v_{n})^{T}$. El par $({\boldsymbol {x}},{\boldsymbol {t}})$ representará a un elemento del conjunto de entrenamiento y una relación de entrada-salida, a menos que se indique otra cosa.

Red Neuronal con una Capa Oculta

La función la usaremos para aproximar los valores de salida de una red neuronal artificial con una capa oculta. La red está constituida por una capa de entrada (input layer), una capa oculta (hidden layer) y una capa de salida (output layer), tal como se ilustra con la siguiente figura:

Los elementos que constituyen a la red neuronal son los siguientes:

• $s$ es una función de valores reales, conocida como la función de transferencia.

• ${\bar {\boldsymbol {o}}}^{(0)}$ es la capa de entrada, considerado como el vector extendido del ejemplo ${\boldsymbol {o}}^{(0)}={\boldsymbol {x}}=(x_{1},\ldots ,x_{n})^{T}$.

• ${\bar {\boldsymbol {o}}}^{(1)}$ es la capa oculta, el vector extendido de ${\boldsymbol {o}}^{(1)}=(o_{1}^{(1)},\ldots ,o_{k}^{(1)})^{T}$.

• ${\boldsymbol {o}}^{(2)}=(o_{1},\ldots ,o_{m})^{T}$ es la capa de salida, considerado como el vector que aproxima al valor deseado ${\boldsymbol {t}}=(t_{1},\ldots ,t_{m})^{T}$.

• ${\boldsymbol {W}}^{(1)}$ es una matriz de tamaño $(n+1)\times k$ cuyos valores $W_{ij}^{(1)}$ son los pesos de la conexión entre las unidades ${\bar {o}}_{i}^{(0)}$ y $o_{j}^{(1)}$.

• ${\boldsymbol {W}}^{(2)}$ es una matriz de tamaño $(k+1)\times m$ cuyos valores $W_{ij}^{(2)}$ son los pesos de la conexión entre las unidades ${\bar {o}}_{i}^{(1)}$ y $o_{j}^{(2)}$.

De estos elementos, únicamente las matrices ${\boldsymbol {W}}^{(l)}$ son consideradas como los parámetros de la red, ya que los valores ${\bar {\boldsymbol {o}}}^{(l)}$ son el resultado de cálculos que dependen de las matrices de pesos, del valor de entrada ${\bar {\boldsymbol {x}}}$ y de la función de transferencia $s$.

La función de transferencia $s$ que consideraremos en nuestro algoritmo es conocida como función sigmoidal, y esta definida como

$s(u)={\frac {1}{1+\exp(-u)}}$

esta función además de ser diferenciable, tiene la particularidad de que su derivada se puede expresar en términos de sí misma:

${\frac {ds(u)}{du}}=s(u)(1-s(u)).$

esto nos servirá para simplificar los cálculos en el algoritmo de aprendizaje aquí descrito.

Descripción del Algoritmo

A grandes rasgos:

1. Calcular la salida de la red ${\boldsymbol {o}}^{(2)}$ a partir de uno de los conjuntos de valores de prueba $x$.
2. Comparar con la salida correcta $t$ y calcular el error según la fórmula:

   $E({\boldsymbol {x}};{\boldsymbol {W}}^{(1)},{\boldsymbol {W}}^{(2)})={\frac {1}{2}}\sum _{i=1}^{m}(o_{i}^{(2)}-t_{i})^{2}.$

3. Calcular las derivadas parciales del error con respecto a los pesos ${\boldsymbol {W}}^{(2)}$ que unen la capa oculta con la de salida.
4. Calcular las derivadas parciales del error con respecto a los pesos ${\boldsymbol {W}}^{(1)}$ que unen la capa de entrada con la oculta.
5. Ajustar los pesos de cada neurona para reducir el error.
6. Repetir el proceso varias veces por cada par de entradas-salidas de prueba.

Enlaces externos

• Implementación del algoritmo en C#

• Implementación del algoritmo en Ruby

• Implementación del algoritmo en C

• Explicación gráfica del algoritmo

Referencias

1. D. Michie, D.J. Spiegelhalter, C.C. Taylor (eds). Machine Learning, Neural and Statistical Classification, 1994. [1]
2. R. Rojas. Neural Networks: A Systematic Introduction, Springer, 1996.ISBN 3-540-60505-3.