Libreria di differenziazione automatica in Schema/Common Lisp/Clojure

Question

Ho sentito che una delle motivazioni originali di McCarthy per l'invenzione di Lisp era scrivere un sistema per la differenziazione automatica. Nonostante questo, le mie ricerche su Google non hanno prodotto librerie/macro per fare ciò. Ci sono delle librerie Scheme/Common Lisp/Clojure (macro) là fuori per prendere una funzione F e restituire una funzione dF/dx che calcola la derivata di F?

Vorrei che supporti F con più argomenti. L'utente dovrebbe scegliere quale di questi è la x da differenziare rispetto a. Idealmente, il differenziatore funzionerebbe anche per F e x di valore vettoriale.

EDIT: Diverse persone hanno menzionato la differenziazione simbolica. La differenza tra differenziazione simbolica e differenziazione automatica è sottile, ma è sintetizzata bene in Wikipedia e in particolare in this picture. Questa distinzione non è così forte in lisp, dove le espressioni simboliche possono essere trasformate in programmi di lavoro così come sono, ma rimane una potenziale difficoltà:

La differenziazione simbolica richiede che l'espressione sia differenziata per essere composta di operazioni con derivate note. Ad esempio, qualcuno ha citato l'esempio di SICP di una macro che agisce attraverso semplici sexps come (+ y (* (x y))), e usa la regola della catena, insieme alla conoscenza di come differenziare + e *, per restituire un sexp che rappresenta la derivata. Avrei bisogno di questo per lavorare con espressioni come (* (foo x y) (bar x)), dove foo e bar possono a loro volta chiamare altre funzioni i cui derivati ​​non sono noti al momento della differenziazione.

Questo sarebbe bene se c'è un modo per prendere un'espressione come (foo x y) e sostituirlo con il suo corpo funzione, sostituendo qualsiasi menzione degli argomenti con x e y in modo igienico. È lì?

Inoltre, nessuno dei problemi di cui sopra riguarda le complicazioni che si verificano quando si differenziano le funzioni con valori vettoriali rispetto agli argomenti con valori vettoriali ... che è ciò per cui sono implementate la maggior parte delle implementazioni di autodifferenziazione.

Answer 1

Esistono altri due pacchetti, entrambi per la differenziazione automatica in Schema. Il secondo è basato sul primo, ma rielaborato come un uovo di gallina. Questi supportano sia la modalità avanti che quella inversa.

• https://github.com/qobi/R6RS-AD
• https://github.com/abarbu/AD

Answer 2

Se stai cercando un sistema simbolico, potresti provare maxima (o here). Funziona su una serie di combinazioni di piattaforme Common-Lisp/OS, ma è più di un sistema completo di una libreria.

L'output della console è OK, ma può produrre un output dall'aspetto piacevole se accoppiato con .

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 

---

EDIT

OK, sembra che ho capito male la domanda. Un po 'di googling suggerisce che ci sono alcuni strumenti per questo in SCMUTILS here, download here, manuale utente here (vedi p24 in poi).

Answer 3

Google per "differenziazione simbolica lisp" e troverete molti esempi, ad es.

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

Answer 4

Alexey Radul scrive:

Beh, c'è il sistema di differenziazione automatica Scmutils

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

(che fa a caso anche la differenziazione simbolica). Non conosco altre implementazioni rilasciate, sebbene sia possibile effettuare il controllo http://autodiff.org/.

C'è anche una bella spiegazione di come implementare da soli in un appendice della struttura e di interpretazione della meccanica classica

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

così come nella letteratura accademica. La modalità particolarmente avanzata è non così difficile, anche se devi fare attenzione ad evitare la perturbazione dello confusione. È possibile consultare le pubblicazioni di Barak Pearlmutter e Jeffrey Mark Siskind, che stanno collaborando su una variante Lisp ad alte prestazioni che incorpora l'annuncio pubblicitario e sono state pubblicate sui problemi relativi a .

http://scholar.google.com/scholar?q=Barak+Pearlmutter+and+Jeffrey+Mark+Siskind

Answer 5

Here è un'implementazione di AD in lisp comune.

Answer 6

Vale la pena di verificare Deriva, che fa differenziazione automatica sia per Clojure e Java:

• https://github.com/lambder/Deriva

Si può anche essere interessato espresso, che è più sulla manipolazione espressione numerica ma ha ancora alcune caratteristiche di differenziazione e probabilmente potrebbe essere adattato alla maggior parte dei casi di utilizzo AD:

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

Answer 7

Può essere di interesse che scmutlis ora è stato portato su Clojure. C'è ancora molto lavoro da fare, ma il codice nei primi capitoli del libro SICM sembra funzionare bene.

Le routine di differenziazione e gli operatori sembrano anche OK con quel piccolo test che ho fatto, ed è anche privo di alcuni bug che sembrano essersi introdotti nelle versioni successive di scmutils.

Penso che gli scmutils coprano le esigenze dell'OP per la differenziazione, dal momento che gestirà correttamente i derivati ​​sia delle funzioni conosciute che di quelle sconosciute (letterali). Questa pagina fornisce i dettagli necessari per vedere quanto bene si adatta ai requisiti: SICM - Derivatives - Notation

Uno dei vantaggi di esecuzione sulla JVM, è che verrà eseguito come un autonomo in caso affermativo richiesto, non c'è bisogno nemmeno di installare Clojure!

È molto vicino allo Schema originale, concessioni minime fatte per la sintassi di Clojure.

Potete vedere qui: https://github.com/littleredcomputer/sicmutils#sicmutils

===

Addendum: Ecco un esempio di differenziazione automatica nel pacchetto SicmUtils Clojure. Questo è un esempio comune che circola su vari siti Internet, il codice deve essere differenziato è

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

Dopo Clojurifying un po 'abbiamo

> (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