the Beauty of Functional Languages in Deep Learning – Clojure and Haskell

Deep learning is een subset van machine learning methoden die gebaseerd zijn op kunstmatige neurale netwerken. Deze zijn geà nspireerd door informatieverwerking en gedistribueerde communicatieknooppunten in biologische systemen zoals de hersenen. In deep learning leert elk niveau de inputgegevens om te zetten in een iets meer abstracte en samengestelde representatie. Bijvoorbeeld, in een gezichtsherkenningssysteem kunnen pixels een laag van het systeem zijn, terwijl randen een andere kunnen zijn, ogen een andere, en het gezicht een andere. De complexiteit van deep learning methoden maakt het gebruik van bestaande pakketten populair in de programmeergemeenschap. TensorFlow en PyTorch in Python zijn populair, net als de keras pakket in R. echter, in de productie van deep learning systemen, prestaties en veiligheid zijn twee kwesties die bedrijven rijden om functionele programmeertalen zoals Clojure en Haskell in plaats daarvan te kiezen.

de moeilijkheden van deep learning implementaties

bij het in productie brengen van deep learning systemen kunnen neurale netwerken een miljoen parameters bevatten. Gegevens kunnen snel exploderen om deze parameters te trainen. Deze explosie van gegevens vereist prestaties die alleen kunnen worden bereikt door een efficiënte programmeertaal met veilige concurrency en parallellisme mogelijkheden. Vanwege de complexiteit van neurale netwerken, met gegevens doorgegeven van laag naar laag, eenvoud en consistentie in de manier waarop de programmeertaal omgaat met deze gegevens is belangrijk. Veiligheid, in dit geval, betekent de mogelijkheid om de staat van de oorspronkelijke gegevens op een consistente manier te behouden, terwijl eenvoud betekent dat u de codebasis gemakkelijk kunt lezen en onderhouden terwijl u de prestaties maximaliseert.

waarom functioneel programmeren geschikter is voor deep learning

in een poging een aantal problemen op te lossen die zich kunnen voordoen bij de implementatie van deep learning, vinden programmeurs dat functionele programmeertalen oplossingen kunnen bieden.

in de informatica is functioneel programmeren een programmeerparadigma dat berekening behandelt als de evaluatie van wiskundige functies en vermijdt dat de toestand en veranderlijke gegevens veranderen. Het is een programmeerpatroon dat dichter bij het wiskundig denken staat. Deep learning-modellen zijn hoofdzakelijk wiskundige modellen. Kunstmatige neurale netwerken bestaan bijvoorbeeld uit verbonden knooppunten, die elk eenvoudige wiskundige bewerkingen uitvoeren. Door een functionele programmeertaal te gebruiken, kunnen programmeurs deze wiskundige bewerkingen beschrijven in een taal die dichter bij de bewerkingen zelf staat. De expliciete manier waarop deze programma ‘ s worden geschreven maakt het lezen en onderhouden van de code base veel gemakkelijker.

tegelijkertijd betekent het compositorische karakter van deep learning-algoritmen dat op elke laag van het neurale werk de lagen of de functies elkaar neigen te ketenen om taken uit te voeren. Dit kan eenvoudig worden geïmplementeerd met behulp van de functionele chaining van een functionele programmeertaal.

voorts in diep het leren, wanneer de functies op de gegevens worden toegepast, veranderen de gegevens niet. Nieuwe waarden kunnen worden uitgevoerd opeenvolgend langs de lijn, maar de gegevens zelf blijft consistent. De onveranderbaarheid van een functionele programmeertaal zal de programmeur in staat stellen om een nieuwe dataset te maken elke keer dat nieuwe waarden worden gegenereerd zonder de oorspronkelijke onveranderbare dataset te veranderen. Dit maakt het gemakkelijker om de consistentie van de gegevens in het neurale netwerk te behouden.

ten slotte betekent het grote aantal parameters en opleidingsgegevens die betrokken zijn bij de implementatie van deep learning dat parallellisme en concurrentie de sleutels zijn tot het creëren van deep learning-systemen op productieniveau. Parallellisme betekent het uitvoeren van threads op verschillende CPU ‘ s om het leerproces te versnellen. Concurrency betekent de mogelijkheid om threads te beheren om conflicten te voorkomen. Functionele programmering zorgt voor concurrency en parallellisme zonder kosten. Dit betekent dat functioneel programmeren, waarbij de pure functie staatloos is, altijd dezelfde output zal produceren voor een bepaalde input, leidt tot de mogelijkheid om elke functie te isoleren en uit te voeren wanneer je maar wilt. Dit maakt concurrency en parallellisme veel gemakkelijker te beheren. Je hoeft niet om te gaan met kwesties zoals deadlocks en race voorwaarden. Verschillende threads toegang tot verschillende CPU ‘ s in staat zal zijn om zelfstandig te draaien zonder betwistingen. Clojure

Clojure

nu functioneel programmeren aan populariteit wint in deep learning, en met de robuuste pakketten die beschikbaar zijn voor deep learning, is Clojure nu favoriet bij bedrijven als Walmart en Facebook. Het is een high-level, dynamische functionele programmeertaal gebaseerd op de LISP programmeertaal en het heeft compilers die het mogelijk maken om te draaien op zowel de Java en de.net runtime omgeving.

de kracht van gelijktijdig programmeren in Clojure

Clojure vervangt het Java-threadsysteem niet, maar werkt ermee. Omdat de core datastructuren onveranderlijk zijn, kunnen ze gemakkelijk worden gedeeld tussen threads. Tegelijkertijd zijn statuswijzigingen in het programma mogelijk, maar Clojure biedt mechanismen om ervoor te zorgen dat Staten consistent blijven. Als er conflicten optreden tussen 2 transacties die dezelfde referentie proberen te wijzigen, zal een van hen met pensioen gaan. Er is geen noodzaak voor expliciete vergrendeling.

(import '(java.util.concurrent Executors))(defn test-stm (let (fn (dotimes (dosync (doseq (alter r + 1 t)))))) (range nthreads))] (doseq (.get future)) (.shutdown pool) (map deref refs)))(test-stm 10 10 10000) -> (550000 550000 550000 550000 550000 550000 550000 550000 550000 550000)

bron

parallellisme in Clojure is goedkoop

in deep learning moeten modellen worden opgeleid op grote hoeveelheden gegevens. Parallellisme impliceert het uitvoeren van meerdere threads op verschillende CPU ‘ s. Parallellisme dat goedkoop is zal aanzienlijke prestatieverbeteringen betekenen. Het gebruik van partitie in combinatie met map kan parallellisme bereiken dat minder kostbaar is.

(defn calculate-pixels-2 (let (doall (map (fn (let (get-color (process-pixel (/ row (double *width*)) (/ col (double *height*)))))) x))) work)] (doall (apply concat result))))

bron

Chaining functies in Clojure betekent helderheid

in Clojure zijn er veel functies voor zeer weinig gegevenstypen. De functies kunnen ook als argumenten aan andere functies worden overgegaan, die het chaining functies in diep het leren mogelijk maakt. Met de implementatie dichter bij het werkelijke wiskundige model, kan Clojure code eenvoudig te lezen en te onderhouden.

;; pipe arg to function(-> "x" f1) ; "x1";; pipe. function chaining(-> "x" f1 f2) ; "x12"

bron

identiteit en status in Clojure bieden veiligheid

In Clojure heeft de identiteit van elk model op elk moment één status. Die staat is een echte waarde die nooit verandert. Als de identiteit lijkt te veranderen, is dit omdat het geassocieerd is met een andere staat. Nieuwe waarden zijn oude functies. Binnen elke laag van het neurale netwerk wordt de staat van de oorspronkelijke gegevens altijd bewaard. Elke reeks gegevens met nieuwe waarden die outputs van functies zijn, kan onafhankelijk werken. Dit betekent dat acties kunnen worden uitgevoerd op deze sets van gegevens veilig of zonder rekening te houden met betwisting. We kunnen op elk moment naar de oorspronkelijke staat van de gegevens verwijzen. Daarom betekent consistentie in dit geval veiligheid.

Bibliotheken en beperkingen

historisch gezien bevat de cortex machine learning library alles wat u nodig hebt om machine learning-algoritmen in Clojure te implementeren. Met de recente stijgende populariteit van de open-source mxnet framework for deep learning, is het gemakkelijker om deep learning te implementeren met behulp van de MXNET-Clojure API.

hoewel er nu verschillende API ‘ s en machine-learning bibliotheken beschikbaar zijn voor Clojure, is er nog steeds een steile leercurve om vloeiend te worden. Foutmeldingen kunnen cryptisch zijn en bedrijven moeten bereid zijn om vooraf te investeren om het te gebruiken om hun machine learning-systemen op te schalen. Naarmate meer voorbeelden van productieklare systemen in Clojure worden geschreven, zal de taal de komende jaren aan populariteit winnen, maar alleen als het aantal en de omvang van bibliotheken die het gebruik van Clojure begeleiden consistent groeit.

Haskell

Haskell is een functionele taal die statisch wordt getypt met type gevolgtrekking en luie evaluatie. Het is gebaseerd op de semantiek van de Miranda-programmeertaal en wordt beschouwd als expressiever, sneller en veiliger voor het implementeren van machine learning.

Type veiligheid in Haskell biedt veiligheid en flexibiliteit

Type veiligheid definieert beperkingen op de soorten waarden die een variabele kan bevatten. Dit zal helpen om illegale activiteiten te voorkomen, zorgen voor een betere geheugenveiligheid en leiden tot minder logische fouten. Luie evaluatie betekent dat Haskell de evaluatie van een expressie zal vertragen totdat de waarde ervan nodig is. Het voorkomt ook herhaalde evaluaties, wat de looptijd bespaart. Tegelijkertijd maakt luie evaluatie het mogelijk om oneindige datastructuren te definiëren. Dit geeft een programmeur onbeperkte wiskundige mogelijkheden.

eenvoudige expliciete code in Haskell biedt duidelijke implementaties

een van de grootste voordelen van Haskell is dat het algoritmen kan beschrijven in zeer expliciete wiskundige constructies. U kunt een model vertegenwoordigen in een paar regels code. Je kunt de code ook lezen op dezelfde manier als je een wiskundige vergelijking kunt lezen. Dit kan zeer krachtig in complexe algoritmen zoals diepe het leren algoritmen in machine het leren zijn. Bijvoorbeeld, de onderstaande implementatie van een enkele laag van een feed-forward neuraal netwerk laat zien hoe leesbaar de code kan zijn.

import Numeric.LinearAlgebra.Static.Backproplogistic :: Floating a => a -> alogistic x = 1 / (1 + exp (-x))feedForwardLog :: (KnownNat i, KnownNat o) => Model (L o i :& R o) (R i) (R o)feedForwardLog (w :&& b) x = logistic (w #> x + b)

bron

Multicore parallellisme in Haskell levert prestaties

in deep learning zullen typische neurale netwerken een miljoen parameters bevatten die het model definiëren. Ook is er een grote hoeveelheid gegevens nodig om deze parameters te leren, wat rekenkundig zeer tijdrovend is. Op een enkele machine kan het gebruik van meerdere kernen om het geheugen en proces parallel te delen zeer krachtig zijn als het gaat om het implementeren van deep learning. In Haskell is het implementeren van multicore parallellisme echter eenvoudig.

Bibliotheken en beperkingen

Haskell ‘ s hlearn-bibliotheek bevat algoritmeimplementaties voor machine learning, terwijl de tensor-flow-binding voor Haskell kan worden gebruikt voor deep learning. Parallel en gelijktijdig, ondertussen, worden gebruikt voor parallellisme en concurrency.

hoewel er in Haskell een aantal bibliotheken voor machine learning zijn ontwikkeld, zullen ground-up implementaties nog steeds moeten worden gedaan voor productie-ready Haskell implementaties. Terwijl openbare bibliotheken beschikbaar voor specifieke deep learning en machine learning taken zijn beperkt, Haskell ‘ s gebruik in AI zal ook worden beperkt. Bedrijven zoals Aetion Technologies en Credit Suisse Global Modeling and Analytics Group gebruiken Haskell in hun implementaties-hier is een complete lijst van de organisaties die het gebruiken.

conclusie

Deep learning-modellen zijn complexe wiskundige modellen die een specifieke gelaagdheid van functies vereisen. Functionele programmeertalen zoals Clojure en Haskell kunnen vaak de complexiteit vertegenwoordigen met cleaner code die dichter bij de wiskunde van het model ligt. Dit leidt tot tijdsbesparing, efficiëntie en eenvoudig beheer van de codebasis. Specifieke eigenschappen van functioneel programmeren maken de implementaties in deze talen veiliger dan die van andere talen. Naarmate de ontwikkeling in AI-technologie vordert, zal het evalueren van deze talen voor de behoeften van grootschalige systeem-ontwikkelingsprojecten in AI prevalenter worden.

dit artikel is onderdeel van Behind the Code, de media voor ontwikkelaars, door ontwikkelaars. Ontdek meer artikelen en video ‘ s door achter de Code te bezoeken!

wilt u bijdragen? Gepubliceerd worden!

Volg ons op Twitter om op de hoogte te blijven!

Illustratie door Victoria Roussel