Biblioteca de diferenciación automática en esquema / Lisp / Clojure común

https://stackoverflow.com/questions/4892822

28-10-2019
|

Pregunta

He oído que una de las motivaciones originales de McCarthy para inventar Lisp era escribir un sistema para la diferenciación automática. A pesar de esto, mis búsquedas en Google no han arrojado ninguna biblioteca/macros para hacer esto. ¿Hay algún esquema/bibliotecas comunes de lisp/clojure (macros) para tomar una función f y devolver una función df/dx que calcula la derivada de F?

Me gustaría que apoye a F con múltiples argumentos. El usuario elegiría cuál de estos es la X para diferenciar con respecto a. Idealmente, el diferenciador funcionaría incluso para F y X de valores de vectores.

EDITAR: Varias personas han mencionado la diferenciación simbólica. La diferencia entre la diferenciación simbólica y la diferenciación automática es sutil Wikipedia, y particularmente en esta imagen. Esta distinción no es tan fuerte en LISP, donde las expresiones simbólicas se pueden convertir en programas de trabajo como es, pero sigue habiendo una dificultad potencial:

La diferenciación simbólica requiere que la expresión se diferencie para estar compuesta por operaciones con derivados conocidos. Por ejemplo, alguien mencionó el ejemplo de SICP de una macro que se agita a través de sexps simples como (+ y (* (x y))), y utiliza la regla de la cadena, junto con el conocimiento de cómo diferenciar + y *, para devolver un sexp que representa el derivado. Necesitaría que eso funcione con expresiones como (* (foo x y) (bar x)), dónde foo y bar Puede que a su vez llame a otras funciones cuyos derivados no se conocen en el momento de la diferenciación.

Esto estaría bien si hay una manera de tomar una expresión como (foo x y) y reemplazarlo con su cuerpo de función, sustituyendo cualquier mención de los argumentos con x y y de manera higiénica. ¿Esta ahí?

Además, ninguno de los anteriores aborda las complicaciones que se producen al diferenciar las funciones valoradas por vectores con respecto a los argumentos con valores de vectores ... que es lo que la mayoría de las implementaciones de autodiferenciación están orientadas.

Solución

Hay otros dos paquetes, ambos para la diferenciación automática en el esquema. El segundo se basa en el primero, pero reelaborado como un huevo de gallina. Estos admiten el modo hacia adelante y de reverso.

Otros consejos

Alexey Radul escribe:

Bueno, está el sistema de diferenciación automática en scmutils

http://groups.csail.mit.edu/mac/users/gjs/6946/linux-install.htm

(que casualmente también hace diferenciación simbólica). No conozco ninguna otra implementación publicada, aunque podría verificar http://autodiff.org/ .

También hay una buena explicación de cómo implementarlo usted mismo en un apéndice de estructura e interpretación de la mecánica clásica.

http://mitpress.mit.edu/sicm/

así como en la literatura académica. Particularmente el modo de avance no es tan difícil, aunque debe tener cuidado para evitar la confusión de perturbaciones. Puede consultar las publicaciones de Barak Pearlmutter y Jeffrey Mark Siskind, que están colaborando en una variante LISP de alto rendimiento que incorpora AD y ha estado publicando sobre temas circundantes.

http://scholar.google.com/scholar?q=barak+Pearlmitter+and+Jeffrey+Mark+Siskind

Si está buscando un sistema simbólico, puede intentar máximo (o aquí). Se ejecuta en una serie de combinaciones de plataformas comunes/OS, pero es más un sistema completo que una biblioteca.

La salida de la consola está bien, pero puede producir una salida de buen aspecto cuando se combina con Texmacs.

Maxima 5.23.2 http://maxima.sourceforge.net
using Lisp GNU Common Lisp (GCL) GCL 2.6.8 (a.k.a. GCL)
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
The function bug_report() provides bug reporting information.
(%i1) diff(sin(1/x),x);
                                        1
                                     cos(-)
                                         x
(%o1)                              - ------
                                        2
                                       x

EDITAR

Ok, parece que entendí mal la pregunta. Un poco de Google sugiere que hay algunas herramientas para esto en scMutils aquí, descargar aquí, manual de usuario aquí (Ver P24 en adelante).

Puede ser de interés que scmutlis ahora ha sido portado a Clojure. Hay mucho más trabajo por hacer, pero el código en los capítulos de Fist del libro SICM parece estar funcionando bien.

Las rutinas y operadores de diferenciación también parecen estar bien con las pocas pruebas que he hecho, e incluso está libre de algunos errores que parecen haberse deslizado en versiones posteriores de SCMutils.

Creo que los SCMUTILS cubren los requisitos de OP referencia, ya que manejará correctamente las derivadas de las funciones conocidas y desconocidas (literal). Esta página proporciona los detalles necesarios para ver qué tan bien se ajusta a los requisitos:Sicm - derivados - notación

Una de las ventajas de ejecutar en el JVM es que se ejecutará como independiente si es así es necesario, ¡ni siquiera la necesidad de instalar Clojure!

Está muy cerca del esquema original, concesiones mínimas hechas para la sintaxis de Clojure.

Puedes verlo aqui:https://github.com/littleredcomuter/sicmutils#sicmutils

===

Anexo: Aquí hay un ejemplo de diferenciación automática en el paquete SicMutils Clojure. Este es un ejemplo común que circula en varios sitios de Internet, el código que se diferenciará es

    function f(x)
      y = x;
      for i=1...100
        y = sin(x+y);
      return y

Después de clojurificar un poco, tenemos

   > (defn inner [y] (fn[x] (sin (+ x y))))
   > (defn f100 [x] (nth (iterate (inner x) x) 100))
   ;; value of derivative at 6
   > ((D f100) 6)
    => 0.51603111348625
   ;; value of the 4th derivative at 1
   > (((expt D 4) f100) 1)
    => -1.7853200839806143

Aquí es una implementación de AD en LISP común.

Vale la pena revisar Deriva, que hace diferenciación automática tanto para Clojure como para Java:

https://github.com/lambder/deriva

También puede estar interesado en Expresso, que se trata más de manipulación de expresión numérica, pero aún tiene algunas características de diferenciación y probablemente podría adaptarse a la mayoría de los casos de uso de AD:

https://github.com/clojure-numerics/expresso

Google para la 'diferenciación simbólica lisp' y encontrará muchos ejemplos, por ejemplo

http://mitpress.mit.edu/sicp/full-text/sicp/book/node39.html

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow