Diferenciación automática

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

En matemática y álgebra computacional, diferenciación automática, o DA, también conocida como diferenciación algorítmica, es un método para la evaluación de derivadas de una función expresada como un programa de computación. Existen dos métodos clásicos para el cálculo de derivadas:

  • derivar simbólicamente la función obteniendo una expresión y evaluarla en un punto dado; o
  • utilizar derivación numérica.

El inconveniente de la derivación simbólica es la lentitud y la dificultad de convertir programas de computación en una única expresión. Además, la complejidad de muchas funciones crece según se calculan derivadas de mayor grado. Dos inconvenientes importantes de las derivadas finitas son los errores de redondeo en cálculos de naturaleza discreta y la cancelación. Los dos métodos clásicos tiene problemas con el cálculo de derivadas de mayor grado, donde la complejidad y los errores se ven incrementados. La diferenciación automática soluciona todos estos problemas.

DA se basa en el hecho de que cualquier programa de computación que implemente una función vectorial y = F(x) (generalmente) se puede descomponer en una secuencia de asignaciones elementales, siendo cada una trivialmente diferenciable utilizando una LUT (LookUp Table o tabla para búsquedas). Estas derivadas parciales básicas, evaluadas utilizando los argumentos, se combinan de acuerdo a regla de la cadena del cálculo de derivadas para formar información derivada para F (como gradientes, tangentes, la matriz Jacobiana, etc.). Este proceso obtiene derivadas exactas (según la precisión numérica). Debido a que la transformación simbólica ocurre sólo en el nivel más básico, DA evita los problemas computacionales inherentes al cálculo simbólico complejo.

Aplicado a ecuaciones diferenciales[editar]

Desarrollo de Taylor para \ x'=f(t,x) en el punto \,x_0 .

Con la notación \ f^{[n]}(t)=\frac{f^{(n)}(t)}{n!} podemos tener el siguiente desarrollo:

\ x(t+h)=x^{[0]}(t)+x^{[1]}(t)h+x^{[2]}(t)h^2+...+x^{[n]}(t)h^n:

  • para orden 0 se usa \ x^{[0]}(t)=x_0
  • para orden 1 se usa \ x^{[1]}(t)=f(t,x_0)

para el resto se aplica los siguientes resultados:

  • \ f'(t)=g(t):
f^{[n]}(t)=\frac{f^{(n)}(t)}{n!}=\frac{g^{(n-1)}(t)}{n!}=\frac{1}{n}\frac{g^{(n-1)}(t)}{(n-1)!}=\frac{1}{n}g^{[n-1]}(t)
  • \ f(t)=g'(t): f^{[n]}(t)=(n+1)g^{[n+1]}(t)
  • \ f(t)=g(t)+h(t): f^{[n]}(t)=g^{[n]}(t)+h^{[n]}(t)
  • \ f(t)=g(t)h(t): f^{[n]}(t)=\sum_{i=0}^n{g^{[n-i]}(t)h^{[i]}(t)}

La regla de la cadena, acumulación hacia adelante y hacia atrás[editar]

Acumulación hacia adelante[editar]

Acumulación hacia atrás[editar]

Computación Jacobiana[editar]

Más allá de la acumulación hacia adelante y hacia atrás[editar]

Derivada en la aritmética aumentada con números duales para el cálculo de la diferenciación automática[editar]

Argumentos y funciones vectoriales[editar]

Derivadas de mayor orden[editar]

Implementación[editar]

La DA hacia adelante se implementa mediante una interpretación no estándar del programa en el cual los números reales son substituidos por números duales, las constantes se convierten en números duales con un coeficiente epsilon igual a cero, y las primitivas numéricas se modifican para que operen con números duales. Esta interpretación no estándar se implementa generalmente mediante dos estrategias: modificación del código fuente o sobrecargando operadores.

Modificación del código fuente[editar]

El código fuente de una función se reemplaza por un código generado automáticamente que incluye instrucciones para el cálculo de las derivadas intercaladas con las instrucciones originales.

La modificación del código fuente se puede implementar para cualquier lenguaje de programación, y es más fácil de optimizar para el compilador. Sin embargo, la implementación de la propia herramienta de DA es más difícil.

Ejemplos:

  • ADIC (C/C++, forward mode)
  • ADIFOR (Fortran77)
  • OpenAD (Fortran77, Fortran95, C/C++)
  • TAPENADE (Fortran77, Fortran95, C)
  • Maple (software) (Lenguaje Maple, puede generar código en C/C++/Java/Visual Basic/Matlab/Fortran)

Sobrecarga de operadores[editar]

La sobrecarga de operadores es una posibilidad para el código fuente escrito en un lenguaje que lo soporte. Los objetos para los números reales y las operaciones matemáticas básicas se deben sobrecargar para corresponder con la aritmética aumentada descrita arriba. No se requiere ningún cambio en el código fuente original de la función para que se pueda derivar.

La sobrecarga de operadores para acumulación hacia adelante es fácil de implementar, siendo también factible para la acumulación hacia atrás. Sin embargo, los compiladores actuales no optimizan tanto el código como en el caso de acumulación hacia adelante.

Ejemplos:

Referencias[editar]

Referencias Bibliográficas[editar]

  • Rall, Louis B. (1981). Automatic Differentiation: Techniques and Applications. Lecture Notes in Computer Science 120. Springer. ISBN 0-540-10861-0 |isbn= incorrecto (ayuda). 
  • Griewank, Andreas (2000). Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. Frontiers in Applied Mathematics 19. SIAM. ISBN 0-89871-451-6. 

Enlaces externos[editar]