Ver el código de «Propagación hacia atrás»

No tienes permiso para modificar esta página, por la siguiente razón:

Tu dirección IP forma parte de un rango de direcciones que se encuentra bloqueado en todas las wikis de Wikimedia.

El bloqueo fue realizado por ‪EPIC‬. El motivo es Open proxy/Webhost: See the help page if you are affected.

Inicio del bloqueo: 08:48 2 jul 2024
Caducidad del bloqueo: 08:48 2 jul 2025

Tu dirección IP es 206.189.44.186. El intervalo bloqueado es 206.189.32.0/20.

Por favor indica todos los datos aquí mostrados en cualquier consulta que hagas.

Si crees que este bloqueo es incorrecto, puedes encontrar información e instrucciones adicionales en la política global de prohibición de proxies abiertos. También puedes solicitar una revisión de este bloqueo en Meta-Wiki. También puede enviar un correo electrónico a la cola VRT de stewards a stewards@wikimedia.org incluyendo todos los detalles anteriores.

Puedes ver y copiar el código fuente de esta página.

{{PA|wikificar|redacción|ciencia|t=20150514}}
En [[Aprendizaje automático|aprendizaje de máquina]], la '''propagación hacia atrás de errores''' o '''retropropagación''' (del inglés ''backpropagation'') es un [[algoritmo]] de [[aprendizaje supervisado]] utilizado para entrenar [[Red neuronal prealimentada|redes neuronales prealimentadas]]. Dado que es un método de cálculo del gradiente el algoritmo generalmente se puede usar en otros tipos de [[Red neuronal artificial|redes neuronales artificiales]] y en general para funciones.<ref group="Nota">{{harvnb|Goodfellow|Bengio|Courville|2016|p=[https://www.deeplearningbook.org/contents/mlp.html#pf25 200]}} "Por lo tanto la propagación hacia atrás con frecuencia se malinterpreta como un ser específico a las redes neuronales multicapa, pero en principio puede calcular derivadas de cualquier función"

''"Furthermore, back-propagation is often misunderstood as being specific to multi-layer neural networks, but in principle it can compute derivatives of any function"''</ref>

El método emplea un ciclo de propagación–adaptación de dos fases, en resumen permite que la información del costo fluya hacia atrás a través de la red para calcular el gradiente.<ref>{{harvnb|Goodfellow|Bengio|Courville|2016|p=[https://www.deeplearningbook.org/contents/mlp.html#pf25 200]}} </ref> 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 entonces 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.

== Estructura del perceptrón==
{{AP|Perceptrón}}
[[Archivo:Perceptrón 5 unidades.svg|miniaturadeimagen|385x385px|Diagrama de un perceptrón con cinco señales de entrada.]]
El [[perceptrón]] es un [[modelo matemático]] de la [[neurona]], busca imitar el proceso de una neurona biológica.  

Sean los <math>p_i</math> las entradas (por las dendritas) a la neurona. Estas sufren un efecto multiplicador <math>w_i</math> por la comunicación de las mismas al núcleo de la neurona, donde se sumaran mediante:

<math>n=\sum^{i=q}_{i=1}(w_i*p_i)+b</math>

Y luego pasa por la [[función de activación]]:

<math>a=f(n)=f(\sum^{i=q}_{i=0}(p_i*w_i)+b)</math>

== Perceptrón Multicapa ==
{{AP|Perceptrón multicapa}}
Un [[Perceptrón multicapa]] es una [[red neuronal artificial]] con alimentación (propagación) hacia delante, compuesta de varias capas de neuronas entre la entrada y la salida de la misma. Esta red permite establecer regiones de decisión mucho más complejas que las de dos semiplanos, como lo hace el Perceptrón de un solo nivel. Las capacidades del Perceptrón multicapa con dos y tres capas y con una única neurona en la capa de salida se muestran en la siguiente figura:
[[Archivo:PerceptrónMulticapa.png|centro]]
Perceptrón simple, activándose su salida para los patrones de un lado del [[hiperplano]], si el valor de los pesos de las conexiones entre las neuronas de la segunda capa y una neurona del nivel de salida son todos igual a 1, y la función de salida es de tipo hardlim, la salida de la red se activará sólo si las salidas de todos los nodos de la segunda capa están activos, esto equivale a ejecutar la función lógica AND en el nodo de salida, resultando una región de decisión intersección de todos los semiplanos formados en el nivel anterior. La región de decisión resultante de la intersección será una región convexa con un número de lados a lo sumo igual al número de neuronas de la segunda capa. A partir de este análisis surge el interrogante respecto a los criterios de selección para las neuronas de las capas ocultas de una red multicapa, este número en general debe ser lo suficientemente grande como para que se forme una región compleja que pueda resolver el problema, sin embargo no debe ser muy grande pues la estimación de los pesos puede ser no confiable para el conjunto de los patrones de entrada disponibles. Hasta el momento no hay un criterio establecido para determinar la configuración de la red y esto depende más bien de la experiencia del diseñador.

== Estructura de la Red ==

[[File:EstructuraRedNeuronal.png]]

Puede notarse que esta red de tres capas equivale a tener tres redes tipo Perceptrón en cascada; la salida de la primera red, es la entrada a la segunda y la salida de la segunda red es la entrada a la tercera. Cada capa puede tener diferente número de neuronas, e incluso distinta [[función de transferencia]].

== Regla de aprendizaje ==
La red retropropagada trabaja bajo aprendizaje supervisado y por tanto necesita un conjunto de entrenamiento que le describa cada salida y su valor de salida esperado de la siguiente forma:

<math>{(p_1,t_1)},{(p_2,t_2)},...,{(p_q,t_q)}   (1)</math>

Donde <math>p_q</math>  es una entrada a la red y <math>t_q</math> es la correspondiente salida deseada para el patrón q-ésimo. El algoritmo debe ajustar los parámetros de la red para minimizar el [[error cuadrático medio]].
Es importante recalcar que no existe una técnica para determinar el número de capas ocultas, ni el número de neuronas que debe contener cada una de ellas para un problema específico, esta elección es determinada por la experiencia del diseñador, el cual debe cumplir con las limitaciones de tipo computacional.
Cada patrón de entrenamiento se propaga a través de la red y sus parámetros para producir una respuesta en la capa de salida, la cual se compara con los patrones objetivo o salidas deseadas para calcular el error en el aprendizaje, este error marca el camino más adecuado para la actualización de los pesos y ganancias que al final del entrenamiento producirán una respuesta satisfactoria a todos los patrones de entrenamiento, esto se logra minimizando el error cuadrático medio en cada iteración del proceso de aprendizaje.

[[File:CapaOculta.png]]

  q: Número de componentes del vector de entrada.
  m: Número de neuronas de la capa oculta.
  l: Número de neuronas de la capa de salida.

Para iniciar el entrenamiento se le presenta a la red un patrón de entrenamiento, el cual tiene q componentes como se describe en la ecuación (2):

<math>
   p =
   \begin{bmatrix}
      p_1 \\
      p_2 \\
      . \\
      . \\
      p_i \\
      . \\
      . \\
      p_q
   \end{bmatrix} (2)
</math> 

Cuando se le presenta a la red un patrón de entrenamiento, este se propaga a través de las conexiones existentes produciendo una entrada neta n en cada una las neuronas de la siguiente capa, la entrada neta a la neurona j de la siguiente capa debido a la presencia de un patrón de entrenamiento en la entrada está dada por la ecuación (3), nótese que la entrada neta es el valor justo antes de pasar por la función de transferencia:

<math>n^{0}_j=\sum^{q}_{i=1}(w^{0}_{ji}*p_i)+b_j^0  (3)</math>

  <math>w^{0}_{ji}</math>:Peso que une la componente i de la entrada con la neurona j de la capa oculta.
  <math>p_i</math>:Componente i del vector p que contiene el patrón de entrenamiento de q componentes.
  <math>b_j^0</math>:Ganancia de la neurona j de la capa oculta.

Donde el 0 representa la capa oculta a la que pertenece cada parámetro. 
Cada una de las neuronas de la capa oculta tiene como salida <math>a_j^0</math>, dada por:

<math>a_j^0=f^0 (\sum^{q}_{i=1}(w_{ji}^0*p_i)+b_j^0 )  (4)</math>

<math>f^0</math>: Función de transferencia de las neuronas de la capa oculta.
Las salidas <math>a_j^0</math> de las neuronas de la capa oculta (de m componentes) son las entradas a los pesos de conexión de la capa de salida, este comportamiento está descrito por:
<math></math>
<math>n_k^s = \sum^{m}_{j=1}(w_{kj}^s*a_j^0)+b_k^s  (5)</math>

  <math>w_{kj}^s</math>: Peso que une la neurona j de la capa oculta con la neurona k de la capa de salida, la cual cuenta con l neuronas.
  <math>a_j^0</math>: Salida de la neurona j de la capa oculta, la cual cuenta con m neuronas.
  <math>b_k^s</math>: Ganancia de la neurona k de la capa de salida.
  <math>n_k^s</math>: Entrada neta a la neurona k de la capa de salida.

La red produce una salida final:
<math>a_k^s = f^s(n^s_k)  (6)</math>

<math>f^s</math>: Función de transferencia de las neuronas de la capa de salida.

La salida de la red de cada neurona <math>a_k^s</math> se compara con la salida deseada <math>t_k</math> para calcular el error en cada unidad:
<math>\delta_k=(t_k-a_k^s)</math>

El error debido a cada patrón p propagado está dado por:

<math>ep^2=1/2  \sum^{l}_{k=1}(\delta_k^2)</math>

<math>ep^2</math>: Error cuadrático medio para cada patrón de entrada p.

<math>\delta_k</math>: Error en la neurona k de la capa de salida con l neuronas.

Este proceso se repite para el número total de patrones de entrenamiento (r), para un proceso de aprendizaje exitoso el objetivo del algoritmo es actualizar todos los pesos y ganancias de la red minimizando el error cuadrático medio total descrito en:

<math>e^2= \sum^{r}_{p=1}(ep^2)</math>

<math>e^2</math>: Error total en el proceso de aprendizaje en una iteración después de haber presentado a la red los r patrones de entrenamiento.
El error que genera una red neuronal en función de sus pesos, genera un espacio de n dimensiones, donde n es el número de pesos de conexión de la red, al evaluar el gradiente del error en un punto de esta superficie se obtendrá la dirección en la cual la función del error tendrá un mayor crecimiento, como el objetivo del proceso de aprendizaje es minimizar el error debe tomarse la dirección negativa del gradiente para obtener el mayor decremento del error y de esta forma su minimización, condición requerida para realizar la actualización de la matriz de pesos en el algoritmo Backpropagation:

== 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 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 <math>(\boldsymbol x,\boldsymbol t)</math>, conocido como conjunto de entrenamiento o conjunto de ejemplos, donde <math>(\boldsymbol x)</math> serán nuestros parámetros de entrada y <math>(\boldsymbol t)</math> los de salida de la red. Los algoritmos de aprendizaje generalmente calculan los parámetros <math>\boldsymbol W</math> de una función <math>N(\boldsymbol x;\boldsymbol W)</math> que permiten aproximar los valores de salida en el conjunto de entrenamiento.


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

<math>
E(\boldsymbol x^{(q)}; \boldsymbol W)=\|N(\boldsymbol x^{(q)};\boldsymbol W) -\boldsymbol t^{(q)}\|^2
</math>,

donde <math>\|\cdot\|</math> es la norma euclidiana. 

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

<math>E(\boldsymbol W)=\sum_{q=1}^p E(\boldsymbol x^{(q)}; \boldsymbol W)</math>.


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

<math>
\boldsymbol W := \boldsymbol W + \Delta\boldsymbol W
</math>

El algoritmo se detiene cuando <math>\boldsymbol W</math> converge o bien cuando el error alcanza un mínimo valor deseado.

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

<math>
\Delta\boldsymbol W=-\gamma\frac{\partial E(\boldsymbol W)}{\partial \boldsymbol W},
</math>

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


Antes de continuar introduciremos un poco de notación. Definimos <math>\bar{\boldsymbol v}=(v_1,\ldots,v_n,1)^T</math> como el vector extendido del vector <math>\boldsymbol v=(v_1,\ldots,v_n)^T</math>.
El par <math>(\boldsymbol x, \boldsymbol t)</math> 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:


[[Archivo:RedNeuronal.png]]

Los elementos que constituyen la red neuronal son los siguientes:

* <math>s</math> es una función de valores reales, conocida como la función de transferencia.

* <math>\bar{\boldsymbol o}^{(0)}</math> es la capa de entrada, considerado como el vector extendido del ejemplo <math>\boldsymbol o^{(0)}=\boldsymbol x=(x_1,\ldots,x_n)^T</math>.

* <math>\bar{\boldsymbol o}^{(1)}</math> es la capa oculta, el vector extendido de <math>\boldsymbol o^{(1)}=(o^{(1)}_1,\ldots,o^{(1)}_k)^T</math>.

* <math>\boldsymbol o^{(2)}=(o_1,\ldots,o_m)^T</math> es la capa de salida, considerado como el vector que aproxima al valor deseado <math>\boldsymbol t=(t_1,\ldots,t_m)^T</math>.

* <math>\boldsymbol W^{(1)}</math> es una matriz de tamaño <math>(n+1)\times k</math> cuyos valores <math>W^{(1)}_{ij}</math> son los pesos de la conexión entre las unidades <math>\bar o^{(0)}_i</math> y <math>o^{(1)}_j</math>.

* <math>\boldsymbol W^{(2)}</math> es una matriz de tamaño <math>(k+1)\times m</math> cuyos valores <math>W^{(2)}_{ij}</math> son los pesos de la conexión entre las unidades <math>\bar o^{(1)}_i</math> y <math>o^{(2)}_j</math>.

De estos elementos, únicamente las matrices <math>\boldsymbol W^{(l)}</math> son consideradas como los parámetros de la red, ya que los valores <math>\bar{\boldsymbol o}^{(l)}</math> son el resultado de cálculos que dependen de las matrices de pesos, del valor de entrada <math>\bar{\boldsymbol x}</math> y de la función de transferencia <math>s</math>. 
<!--Es por ello que podemos indicar el valor de salida de la red con <math>N(\boldsymbol x; \boldsymbol W^{(1)},\boldsymbol W^{(2)}),</math> para así recalcar cómo la red depende de las matrices de pesos.-->


La función de transferencia <math>s</math> que consideraremos en nuestro algoritmo es conocida como función sigmoidal, y está definida como 

<math>
s(u)=\frac{1}{1+\exp(-u)}
</math> 

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

<math>
\frac{d s(u)}{du}=s(u)(1-s(u)).
</math>

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

== Descripción del algoritmo ==

A grandes rasgos:
# Calcular la salida de la red <math>\boldsymbol o^{(2)}</math> a partir de uno de los conjuntos de valores de prueba <math>x</math>.
# Comparar con la salida correcta <math>t</math> y calcular el error según la fórmula:
#: <math>E(\boldsymbol x; \boldsymbol W^{(1)},\boldsymbol W^{(2)})=\frac{1}{2}\sum^{m}_{i=1} (t_{i}-o^{(2)}_{i})^{2}.</math>
# Calcular las derivadas parciales del error con respecto a los pesos <math>\boldsymbol W^{(2)}</math> que unen a la última capa oculta con la de salida.
# Calcular las derivadas parciales del error con respecto a los pesos <math>\boldsymbol W^{(1)}</math> que unen la capa de entrada con la oculta.
# Ajustar los pesos de cada neurona para reducir el error.
# Repetir el proceso varias veces por cada par de entradas-salidas de prueba.

O = Xj*F(netj)<!-- == Cálculo de las Derivadas Parciales ==

== Ajuste de los Pesos ==

== Entrenamiento ''On-Line'' y ''Off-Line'' == -->

== Véase también ==

* [[Red de estado de eco]]

== Notas ==
<references group="Nota" />

== Referencias ==
<references />

== Bibliografía ==
* D. Michie, D.J. Spiegelhalter, C.C. Taylor (eds). Machine Learning, Neural and Statistical Classification, 1994. [http://www.amsta.leeds.ac.uk/~charles/statlog/indexdos.html]
* R. Rojas. ''Neural Networks: A Systematic Introduction,'' Springer, 1996.ISBN 3-540-60505-3.

== Enlaces externos ==
* [http://www.codeproject.com/KB/cs/BackPropagationNeuralNet.aspx Implementación del algoritmo en C#]
* [https://web.archive.org/web/20071215081442/http://ai4r.rubyforge.org/neuralNetworks.html Implementación del algoritmo en Ruby]
* [http://ant-neural-tool.sourceforge.net Implementación del algoritmo en C]
* [http://galaxy.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html Explicación gráfica del algoritmo (en inglés)]

{{control de autoridades}}
[[Categoría:Redes neuronales artificiales]]
[[Categoría:Error]]

Plantillas usadas en esta página:

Plantilla:AP (ver código) (protegida para editores de plantillas)
Plantilla:Aviso (ver código) (protegida para editores de plantillas)
Plantilla:Coincidir (ver código) (protegida para editores de plantillas)
Plantilla:Control de autoridades (ver código) (protegida para editores de plantillas)
Plantilla:Control de autoridades/styles.css (ver código) (protegida para editores de plantillas)
Plantilla:Harvnb (ver código) (protegida para editores de plantillas)
Plantilla:Harvsp (ver código) (protegida para editores de plantillas)
Plantilla:PA (ver código) (semiprotegida)
Plantilla:Problemas artículo (ver código) (protegida para editores de plantillas)
Plantilla:Problemas artículo/contar (ver código) (protegida para editores de plantillas)
Plantilla:Problemas artículo/parámetro (ver código) (protegida para editores de plantillas)
Plantilla:Problemas artículo/validar (ver código) (protegida para editores de plantillas)
Plantilla:Si existe (ver código) (protegida para editores de plantillas)
Plantilla:Str mid (ver código) (protegida para editores de plantillas)
Plantilla:Temas PA (ver código) (protegida para editores de plantillas)
Plantilla:Temas PA/Contar si existen (ver código) (protegida para editores de plantillas)
Plantilla:Temas PA/base (ver código) (protegida para editores de plantillas)
Plantilla:Trim (ver código) (protegida para editores de plantillas)
Módulo:Control de autoridades (ver código) (protegida para editores de plantillas)
Módulo:Navbar (ver código) (protegida para editores de plantillas)
Módulo:Navbar/configuración (ver código) (protegida para editores de plantillas)
Módulo:Navbox (ver código) (protegida para editores de plantillas)
Módulo:No globals (ver código) (protegida para editores de plantillas)
Módulo:String (ver código) (protegida para editores de plantillas)
Módulo:Unsubst (ver código) (protegida para editores de plantillas)

Volver a Propagación hacia atrás.

Obtenido de «https://es.wikipedia.org/wiki/Propagación_hacia_atrás»