Automatisk differensiering

Automatisk differensiering ( AD ), også kjent som algoritmisk differensiering eller beregningsdifferensiering , [ 1] er et sett med teknikker for automatisk beregning av deriverte av en matematisk funksjon implementert av et dataprogram . Automatisk differensiering utnytter det faktum at implementeringen av en funksjon , uansett hvor kompleks den er, reduseres til utførelse av en rekke aritmetiske operasjoner (addisjon, subtraksjon, multiplikasjon, divisjon, etc.) og elementære funksjoner ( eksponentielle , trigonometriske funksjoner , etc.). Ved å bruke kjederegelen gjentatte ganger på slike operasjoner, kan den deriverte av en vilkårlig kompleks funksjon beregnes automatisk, med beregningspresisjonen i bruk, og raskt, ved å bruke et antall operasjoner som maksimalt tilsvarer en liten og konstant faktor med hensyn til antall operasjoner brukt i den opprinnelige funksjonen.

Automatisk differensiering skal ikke forveksles med symbolsk differensiering , som utføres ved å manipulere uttrykkene representert i symbolsk form, og heller ikke med numerisk differensiering , som tilnærmer den deriverte med en endelig forskjell . Den første metoden er vanligvis mye tregere og begrenset av vanskeligheten med å konvertere vilkårlige funksjoner til symbolsk form, mens den andre metoden introduserer numeriske diskretiseringsfeil som har en tendens til å forplante seg og begrense numerisk stabilitet . Videre er begge metodene trege til å beregne partielle deriverte av funksjoner med et stort antall variabler, et problem som ofte oppstår i gradientnedstigningsbaserte optimaliseringsmetoder . Slike metoder underbygger implementeringen av mange maskinlæringsteknikker , spesielt dyp læring , og de fleste rammeverk for dyp læring implementerer automatisk differensiering for automatisk gradientberegning . [2] [3] [4]

Kjederegel og akkumulering fremover og bakover

Kjederegelen lar deg dekomponere et derivat til en rekke enklere derivater. For en sammensetning gir kjederegelen som et resultat ${\ displaystyle y = f (g (h (x))) = f (g (h (w_ {0}))) = f (g (w_ {1})) = f (w_ {2}) = w_ {3}}$

{\ displaystyle {\ frac {dy} {dx}} = {\ frac {dy} {dw_ {2}}} {\ frac {dw_ {2}} {dw_ {1}}} {\ frac {dw_ {1 }} {dx}}}

Den automatiske differensieringen kan betjenes på to forskjellige måter, foroverakkumulering ( foroverakkumulering eller forovermodus ) og inversakkumulering ( reversakkumulering eller reversmodus ). Den fremadgående akkumuleringen går gjennom operasjonskjeden fra innsiden og ut (i eksemplet beregner først , deretter og til slutt ), mens den inverse akkumuleringen innebærer å krysse kjeden fra utsiden til innsiden (beregner først , deretter og til slutt og til slutt ). Oppsummert har vi at foroverakkumuleringen beregner den rekursive relasjonen ${\ displaystyle dw_ {1} / dx}$ ${\ displaystyle dw_ {2} / dx}$ ${\ displaystyle dy / dx}$ ${\ displaystyle dy / dw_ {2}}$ ${\ displaystyle dy / dw_ {1}}$ ${\ displaystyle dy / dx}$

{\ displaystyle {\ frac {dw_ {i}} {dx}} = {\ frac {dw_ {i}} {dw_ {i-1}}} {\ frac {dw_ {i-1}} {dx}} }

med , mens invers akkumulering beregner ${\ displaystyle w_ {3} = y}$

{\ displaystyle {\ frac {dy} {dw_ {i}}} = {\ frac {dy} {dw_ {i + 1}}} {\ frac {dw_ {i + 1}} {dw_ {i}}} }

med . Generelt sett er begge metodene spesielle tilfeller av bruken av programsammensetningsoperatøren , og setter på riktig måte ett av de to argumentene . ${\ displaystyle w_ {0} = x}$ ${\ displaystyle (w, y)}$

Videresend akkumulering

Ved foroverakkumulering er de uavhengige variablene der differensieringen beregnes faste, deretter utføres beregningen av de deriverte av underuttrykkene rekursivt. Dette kan gjøres ved å gjentatte ganger erstatte de deriverte av de interne funksjonene i kjederegelen:

{\ displaystyle {\ frac {\ delvis y} {\ delvis x}} = {\ frac {\ delvis y} {\ delvis w_ {n-1}}} {\ frac {\ delvis w_ {n-1}} {\ delvis x}} = {\ frac {\ delvis y} {\ delvis w_ {n-1}}} \ venstre ({\ frac {\ delvis w_ {n-1}} {\ delvis w_ {n-2 }}} {\ frac {\ delvis w_ {n-2}} {\ delvis x}} \ høyre) = {\ frac {\ delvis y} {\ delvis w_ {n-1}}} \ venstre ({\ frac {\ delvis w_ {n-1}} {\ delvis w_ {n-2}}} \ venstre ({\ frac {\ delvis w_ {n-2}} {\ delvis w_ {n-3}}} { \ frac {\ delvis w_ {n-3}} {\ delvis x}} \ høyre) \ høyre) = \ cdots}

Prosedyren er generalisert til tilfellet i flere variabler, som et produkt av jakobianske matriser .

I motsetning til invers akkumulering, er foroverakkumulering mer naturlig og lettere å implementere, ettersom flyten av informasjon i beregningen av den deriverte faller sammen med evalueringsrekkefølgen, og øker hver variabel med den numeriske verdien av dens deriverte, $w$ ${\ displaystyle {\ prikk {w}}}$

{\ displaystyle {\ dot {w}} = {\ frac {\ delvis w} {\ delvis x}}}

Derivatene blir deretter beregnet synkronisert med uttrykksevalueringstrinnene, og kombinert med andre derivater via kjederegelen.

La for eksempel funksjonen gis

{\ displaystyle {\ begynne {justert} z & = f (x_ {1}, x_ {2}) \\ & = x_ {1} x_ {2} + \ sin x_ {1} \\ & = w_ {1 } w_ {2} + \ sin w_ {1} \\ & = w_ {3} + w_ {4} \\ & = w_ {5} \ end {justert}}}

hvor, for klarhetens skyld, hvert enkelt underuttrykk er merket med en variabel . Valget av uavhengige variabler bestemmer startverdiene og (kalt frø ). For eksempel, hvis du ønsker å beregne den deriverte av funksjonen med hensyn til , settes startverdiene til $w_ {i}$ ${\ displaystyle {\ dot {w}} _ {1}}$ ${\ displaystyle {\ dot {w}} _ {2}}$ $x_1$

{\ displaystyle {\ begynne {justert} {\ prikk {w}} _ {1} = {\ frac {\ delvis x_ {1}} {\ delvis x_ {1}}} = 1 \\ {\ prikk {w }} _ {2} = {\ frac {\ delvis x_ {2}} {\ delvis x_ {1}}} = 0 \ end {justert}}}

Med disse frøene forplantes derivatene gjennom kjederegelen, som vist i følgende tabell og i beregningsgrafen i figuren til siden.

{\ displaystyle {\ begynne {array} {l | l} {\ text {Operasjoner for å beregne uttrykket}} & {\ text {Operasjoner for å beregne den deriverte}} \\\ hline w_ {1} = x_ {1 } & {\ prikk {w}} _ {1} = 1 {\ tekst {(frø)}} \\ w_ {2} = x_ {2} & {\ prikk {w}} _ {2} = 0 { \ tekst {(frø)}} \\ w_ {3} = w_ {1} \ cdot w_ {2} og {\ dot {w}} _ {3} = w_ {2} \ cdot {\ dot {w} } _ {1} + w_ {1} \ cdot {\ dot {w}} _ {2} \\ w_ {4} = \ sin w_ {1} & {\ dot {w}} _ {4} = \ cos w_ {1} \ cdot {\ dot {w}} _ {1} \\ w_ {5} = w_ {3} + w_ {4} & {\ dot {w}} _ {5} = {\ dot { w}} _ {3} + {\ dot {w}} _ {4} \ end {array}}}

For å beregne gradienten til funksjonen, er det nødvendig med ytterligere kryssinger av beregningsgrafen, ved å bruke passende frø, for eksempel for å beregne den deriverte med hensyn til . ${\ displaystyle {\ prikk {w}} _ {1} = 0; {\ prikk {w}} _ {2} = 1}$ $x_2$

Beregningskompleksiteten til hver kryssing av grafen er proporsjonal med kompleksiteten til den opprinnelige funksjonen. Foroverakkumulering er mer effektiv enn invers for funksjoner i form med , da det kun kreves kryssinger, sammenlignet med de som kreves ved invers akkumulering. ${\ displaystyle f: \ mathbb {R} ^ {n} \ til \ mathbb {R} ^ {m}}$ $m \ d n$ $n$ $m$

Invers akkumulering

Ved invers akkumulering er de avhengige variablene som differensieringen beregnes med, faste, deretter beregnes den deriverte rekursivt med hensyn til hvert underuttrykk. Tilsvarende erstattes den deriverte av den ytterste funksjonen i kjederegelen

{\ displaystyle {\ frac {\ delvis y} {\ delvis x}} = {\ frac {\ delvis y} {\ delvis w_ {1}}} {\ frac {\ delvis w_ {1}} {\ delvis x }} = \ venstre ({\ frac {\ delvis y} {\ delvis w_ {2}}} {\ frac {\ delvis w_ {2}} {\ delvis w_ {1}}} \ høyre) {\ frac { \ delvis w_ {1}} {\ delvis x}} = \ venstre (\ venstre ({\ frac {\ delvis y} {\ delvis w_ {3}}} {\ frac {\ delvis w_ {3}} {\ delvis w_ {2}}} \ høyre) {\ frac {\ delvis w_ {2}} {\ delvis w_ {1}}} \ høyre) {\ frac {\ delvis w_ {1}} {\ delvis x}} = \ cdots}

Mengden som brukes i beregningen ved invers akkumulering kalles en adjoint , betegnet med en skråstrek ( ), og er den deriverte av en avhengig variabel med hensyn til underuttrykket : ${\ displaystyle {\ bar {w}}}$ $w$

{\ displaystyle {\ bar {w}} = {\ frac {\ delvis y} {\ delvis w}}}

Den inverse akkumuleringen krysser kjeden fra utsiden mot innsiden, det vil si at den krysser beregningsgrafen (figur på siden) fra topp til bunn. Én grafovergang er nødvendig for hver komponent av funksjonen , så bare én for skalarfunksjoner . Dette genererer en avveining mellom kostnad i rom og i tid med hensyn til foroverakkumulering: mens invers akkumulering kan kreve færre grafkryssinger, er det imidlertid nødvendig å lagre de mellomliggende variablene (vanligvis ved å bruke en Wengert-liste ), [5] [6 ] som kan representere en uholdbar kostnad når det gjelder minne hvis beregningsgrafen er veldig stor. Dette problemet reduseres delvis ved å lagre bare en del av de mellomliggende verdiene, og rekonstruere resten gjennom ytterligere beregninger (en metode kjent som sjekkpunkt ). $w_ {i}$

Operasjonene som kreves for å beregne den deriverte ved invers akkumulering i dette eksemplet er:

{\ displaystyle {\ begynne {array} {l} {\ tekst {Operasjoner for å beregne den deriverte}} \\\ hline {\ bar {w}} _ {5} = 1 {\ tekst {(frø)}} \ \ {\ bar {w}} _ {4} = {\ bar {w}} _ {5} \\ {\ bar {w}} _ {3} = {\ bar {w}} _ {5} \ \ {\ bar {w}} _ {2} = {\ bar {w}} _ {3} \ cdot w_ {1} \\ {\ bar {w}} _ {1} = {\ bar {w } } _ {3} \ cdot w_ {2} + {\ bar {w}} _ {4} \ cdot \ cos w_ {1} \ end {array}}}

Beregningsgrafen kan manipuleres for å beregne gradienten til den opprinnelige operasjonen, ved å forsterke hver node med en ekstra node, og med toppunktene mellom de adderte nodene orientert i motsatt retning av toppunktene mellom de opprinnelige nodene. Disse adderte nodene representerer multiplikasjonen med den deriverte av uttrykket beregnet i den opprinnelige noden. For eksempel vil en node som inneholder funksjonen ha uttrykket i den tilsvarende noden lagt til. $y = f (x)$ ${\ displaystyle {\ bar {x}} = {\ bar {y}} f (x)}$

Invers akkumulering er mer effektiv enn foroverakkumulering for funksjoner i form med , da det krever traverser av beregningsgrafen, sammenlignet med traverser som kreves av foroverakkumulering. ${\ displaystyle f: \ mathbb {R} ^ {n} \ til \ mathbb {R} ^ {m}}$ ${\ displaystyle m \ ll n}$ $m$ $n$

Den omvendte akkumuleringen ble først publisert i 1970 av Seppo Linnainmaa i sin M.Sc. , [7] [8] [9] og brukes ofte til å implementere feilutbredelse bakover i kunstige nevrale nettverk .

Andre metoder

Forover- og bakoverakkumuleringer er bare to ekstreme metoder for å krysse kjeden av derivater. Problemet med å beregne den jakobiske matrisen med et minimum antall operasjoner er kjent som det optimale jakobiske akkumuleringsproblemet (OJA), og det er et NP-komplett problem . [10]

Automatisk differensiering med to tall

Foroverakkumulering kan implementeres ved å utvide algebraen til reelle tall , der hvert tall er assosiert med en ekstra nilpotent komponent som representerer den deriverte av funksjonen som er evaluert i det tallet. Aritmetiske operasjoner kan utvides til denne nye algebraen, kjent som dobbelttallsalgebra . Denne formuleringen kan generaliseres ytterligere, i det som er kjent som teorien om operasjonell kalkulus .

Utvidet aritmetikk kan konstrueres ved å erstatte et hvilket som helst reelt tall med kvantitet , der det er et reelt tall og er et uendelig , et nilpotent abstrakt tall slik at . Fra denne definisjonen får vi det $x$ ${\ displaystyle x + x '\ varepsilon}$ $x '$ $\ varepsilon$ ${\ displaystyle \ varepsilon ^ {2} = 0}$

{\ displaystyle {\ begynne {justert} (x + x '\ varepsilon) + (y + y' \ varepsilon) & = x + y + (x '+ y') \ varepsilon \\ (x + x '\ varepsilon) ) \ cdot (y + y '\ varepsilon) & = xy + xy' \ varepsilon + yx '\ varepsilon + x'y' \ varepsilon ^ {2} = xy + (xy '+ yx') \ varepsilon \ end { justert} }}

og andre operasjoner kan defineres på lignende måte.

Det er mulig å definere polynomer i denne utvidede aritmetikken. Hvis , da ${\ displaystyle P (x) = p_ {0} + p_ {1} x + p_ {2} x ^ {2} + \ cdots + p_ {n} x ^ {n}}$ ${\ displaystyle {\ begynne {justert} P (x + x '\ varepsilon) & = p_ {0} + p_ {1} (x + x' \ varepsilon) + \ cdots + p_ {n} (x + x ' \ varepsilon) ^ {n} \\ & = p_ {0} + p_ {1} x + \ cdots + p_ {n} x ^ {n} + p_ {1} x '\ varepsilon + 2p_ {2} xx' \ varepsilon + \ cdots + np_ {n} x ^ {n-1} x '\ varepsilon \\ & = P (x) + P ^ {(1)} (x) x' \ varepsilon \ end {aligned}} }$

hvor er den deriverte av med hensyn til det første argumentet, og , kalt seed , kan tildeles vilkårlig. ${\ displaystyle P ^ {(1)}}$ $P.$ $x '$

Denne nye aritmetikken består av ordnede par , med vanlig aritmetikk i den første komponenten og førstederiverte aritmetikk i den andre komponenten. Ved å utvide de tidligere resultatene fra polynomer til analytiske funksjoner får vi en ny elementær aritmetikk: ${\ displaystyle \ langle x, x '\ rangle}$

{\ displaystyle {\ begynne {justert} \ venstre \ langle u, u '\ høyre \ rangle + \ venstre \ langle v, v' \ høyre \ rangle & = \ venstre \ langle u + v, u '+ v' \ høyre \ rangle \\\ venstre \ langle u, u '\ høyre \ rangle - \ venstre \ langle v, v' \ høyre \ rangle & = \ venstre \ langle uv, u'-v '\ høyre \ rangle \\\ venstre \ langle u, u '\ høyre \ rangle * \ venstre \ langle v, v' \ høyre \ rangle & = \ venstre \ langle uv, u'v + uv '\ høyre \ rangle \\\ venstre \ langle u, u '\ høyre \ rangle / \ venstre \ langle v, v' \ høyre \ rangle & = \ venstre \ langle {\ frac {u} {v}}, {\ frac {u'v-uv '} {v ^ {2}}} \ høyre \ rangle \ quad (v \ neq 0) \\\ sin \ venstre \ langle u, u '\ høyre \ rangle & = \ venstre \ langle \ sin (u), u' \ cos ( u) \ høyre \ rangle \\\ cos \ venstre \ langle u, u '\ høyre \ rangle & = \ venstre \ langle \ cos (u), - u' \ sin (u) \ høyre \ rangle \\\ exp \ venstre \ langle u, u '\ høyre \ rangle & = \ venstre \ langle \ exp u, u' \ exp u \ høyre \ rangle \\\ log \ venstre \ langle u, u '\ høyre \ rangle & = \ venstre \ langle \ log (u), u '/ u \ høyre \ rangle \ quad (u> 0) \\\ venstre \ langle u, u' \ høyre \ rangle ^ {k} & = \ venstre \ langle u ^ {k}, ku ^ {k-1} u '\ høyre \ rangle \ quad (u \ neq 0) \\\ venstre | \ venstre \ langle u, u' \ høyre \ rangle \ høyre | & = \ venstre \ langle \ venstre | u \ høyre |, u '{\ mbox {sign}} u \ høyre \ rangle \ quad (u \ neq 0) \ end {aligned}}}

og generelt, for en funksjon vi har $g$

{\ displaystyle g (\ langle u, u '\ rangle, \ langle v, v' \ rangle) = \ langle g (u, v), g_ {u} (u, v) u '+ g_ {v} ( u, v) v '\ rangle}

hvor og er derivatene av respekt for henholdsvis det første og andre argumentet. ${\ displaystyle g_ {u}}$ ${\ displaystyle g_ {v}}$ $g$

En elementær binær operasjon kan utvides til konstanter, og applikasjonen til et dobbelttall og en konstant (reelt tall) utføres ved å promotere konstanten til dobbelttallet . Det er mulig å beregne den deriverte av en funksjon i , ved å beregne i denne aritmetikken, hvis resultat er . ${\ displaystyle \ langle u, u '\ rangle}$ $c$ ${\ displaystyle \ langle c, 0 \ rangle}$ ${\ displaystyle f: \ mathbb {R} \ høyrepil \ mathbb {R}}$ $x_0$ ${\ displaystyle f (\ langle x_ {0}, 1 \ rangle)}$ ${\ displaystyle \ langle f (x_ {0}), f '(x_ {0}) \ rangle}$

Vektor- og multivariabelfunksjoner

Multivariable vektorfunksjoner kan behandles med lignende effektivitet ved å bruke den samme mekanismen for envariabelfunksjoner, ved å definere en retningsderivert operatør som beregner , retningsderiverten av at i retning , som kan beregnes som å bruke den samme aritmetikken definert i forrang . Evalueringer er nødvendig for å beregne gradienten . ${\ displaystyle y '= \ nabla f (x) \ cdot x'}$ ${\ displaystyle y '\ i \ mathbb {R} ^ {m}}$ ${\ displaystyle f: \ mathbb {R} ^ {n} \ høyrepil \ mathbb {R} ^ {m}}$ ${\ displaystyle x \ in \ mathbb {R} ^ {n}}$ ${\ displaystyle x '\ i \ mathbb {R} ^ {n}}$ ${\ displaystyle (\ langle y_ {1}, y '_ {1} \ rangle, \ ldots, \ langle y_ {m}, y' _ {m} \ rangle) = f (\ langle x_ {1}, x '_ {1} \ rangle, \ ldots, \ langle x_ {n}, x' _ {n} \ rangle)}$ $\ nabla f$ $n$

Høyere ordens derivater

Aritmetikken definert for den første deriverte kan utvides til å beregne høyere ordens deriverte. Men når rekkefølgen øker, blir uttrykkene mye mer komplekse, og kostnaden er kvadratisk i rekkefølgen til den høyeste deriverte. Du kan definere en lignende algebra på avkortede Taylor-polynomer , slik at du kan utføre beregninger raskere. En generell og streng formulering er definert i sammenheng med den operasjonelle beregningen .

Driftsberegning

Operasjonell kalkulus i programrom [11] generaliserer begrepet automatisk differensiering, generaliserer algebraen av doble tall med en tensoralgebra , og gir et strengt grunnlag for matematikken som brukes i dyp læring .

Implementering

Fremoverakkumulering kan implementeres gjennom en ikke-standard tolkning av programmet, der hvert reelt tall erstattes med et dobbelttall, konstanter erstattes med dobbelttall med uendelig del null, og operasjoner på reelle er erstattet med operasjoner på dualer. Ikke-standard tolkning kan generelt implementeres med to tilnærminger: kildekodetransformasjon og operatøroverbelastning .

Kildekodetransformasjon

Kildekoden til en funksjon erstattes med den automatisk genererte koden til en funksjon som sammenfletter de originale instruksjonene med tilleggsinstruksjonene for beregning av deriverte. Denne tilnærmingen kan implementeres på alle språk, og muliggjør et større antall automatiske optimaliseringer av kompilatoren, men implementeringen av det automatiske generasjonsverktøyet er ganske komplekst.

Operatør overbelastning

Denne metoden kan brukes på språk som støtter operatøroverbelastning . Det krever vanligvis ikke å endre rekkefølgen av operasjoner i programmet, men krever definisjon av flere numeriske datatyper . Det er enklere å implementere, og kan også brukes til omvendt akkumulering, men det gjør automatisk kodeoptimalisering mer kompleks. Eksempler på biblioteker med automatisk differensiering gjennom operatøroverbelastning er Adept og Stan .

Merknader

^ Richard D. Neidinger, Introduction to Automatic Differentiation and MATLAB Object-Oriented Programming ( PDF ), i SIAM Review , vol. 52, n. 3, 2010, s. 545–563, DOI : 10.1137 / 080743627 .
^ Ivrig henrettelse , på tensorflow.org .
^ Automatisk differensieringspakke - torch.autograd , på pytorch.org .
^ Derivater i Theano-Theano 1.0.0 dokumentasjon , på deeplearning.net .
^ RE Wengert, Et enkelt automatisk derivatevalueringsprogram , i Comm. ACM , vol. 7, 1964, s. 463–464, DOI : 10.1145 / 355586.364791 .
^ Michael Bartholomew-Biggs, Steven Brown, Bruce Christianson og Laurence Dixon, Automatisk differensiering av algoritmer , i Journal of Computational and Applied Mathematics , vol. 124, n. 1-2, 2000, s. 171-190, DOI : 10.1016 / S0377-0427 (00) 00422-2 .
^ Linnainmaa, Seppo (1970). Representasjonen av den kumulative avrundingsfeilen til en algoritme som en Taylor-utvidelse av de lokale avrundingsfeilene. Masteroppgave (på finsk), Univ. Helsinki, 6-7.
^ Linnainmaa, Seppo (1976). Taylor utvidelse av den akkumulerte avrundingsfeilen. BIT Numerisk matematikk, 16 (2), 146-160.
^ Griewank, Andreas (2012). Hvem oppfant den omvendte differensieringsmodusen? Optimaliseringshistorier, Documenta Matematica, Extra Volume ISMP (2012), 389-400.
^ Uwe Naumann, Optimal Jacobian-akkumulering er NP-fullstendig , i Mathematical Programming , vol. 112, n. 2, april 2008, s. 427–441, DOI : 10.1007 / s10107-006-0042-z .
^ Žiga Sajovic og Martin Vuk, Operational calculus on programmering spaces , 24. oktober 2016.

Bibliografi

Louis B. Rall, Automatic Differentiation: Techniques and Applications , Lecture Notes in Computer Science, vol. 120, Springer , 1981, ISBN 3-540-10861-0 .
Andreas Griewank og Andrea Walther, Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation , Other Titles in Applied Mathematics, vol. 105, 2nd, SIAM , 2008, ISBN 978-0-89871-659-7 (arkivert fra originalen 23. mars 2010) .
Richard Neidinger, Introduction to Automatic Differentiation and MATLAB Object-Oriented Programming ( PDF ), i SIAM Review , vol. 52, n. 3, 2010, s. 545–563, DOI : 10.1137 / 080743627 . Hentet 15. mars 2013 .

Eksterne lenker

( NO ) www.autodiff.org
( NO ) Automatisk differensiering av parallelle OpenMP-programmer
( NO ) Automatisk differensiering, C ++-maler og fotogrammetri
( EN ) Beregn analytiske derivater av et hvilket som helst Fortran77-, Fortran95- eller C-program gjennom et nettbasert grensesnitt
JuliaDiff , automatiske differensieringsverktøy i Julia