skönheten i funktionella språk i djupinlärning-Clojure och Haskell

djupinlärning är en delmängd av maskininlärningsmetoder som bygger på artificiella neurala nätverk. Dessa är inspirerade av informationsbehandling och distribuerade kommunikationsnoder i biologiska system som hjärnan. I deep learning lär sig varje nivå att omvandla ingångsdata till en något mer abstrakt och sammansatt representation. Till exempel i ett ansiktsigenkänningssystem kan pixlar vara ett lager av systemet, medan kanter kan vara ett annat, ögon kan vara ett annat och ansiktet kan vara ett annat. Komplexiteten i djupa inlärningsmetoder gör att använda befintliga paket populära i programmeringsgemenskapen. TensorFlow och PyTorch i Python är populära, liksom Keras-paketet i R. i produktionen av djupinlärningssystem är prestanda och säkerhet dock två frågor som driver företag att välja funktionella programmeringsspråk som Clojure och Haskell istället.

svårigheterna med Deep learning implementationer

för att sätta djupa inlärningssystem i produktion kan neurala nätverk innehålla en miljon parametrar. Data kan snabbt explodera för att träna dessa parametrar. Denna explosion av data kräver prestanda som endast kan uppnås genom ett effektivt programmeringsspråk med säker samtidighet och parallellförmåga. På grund av komplexiteten i neurala nätverk, med data som skickas från lager till lager, är enkelhet och konsistens i hur programmeringsspråket hanterar dessa data viktigt. Säkerhet betyder i detta fall förmågan att bevara tillståndet för originaldata på ett konsekvent sätt, medan enkelhet innebär att man enkelt kan läsa och underhålla kodbasen samtidigt som man maximerar prestanda.

varför funktionell programmering är mer lämplig för djupinlärning

i ett försök att lösa några av de svårigheter som kan uppstå vid implementering av djupinlärning finner programmerare att funktionella programmeringsspråk kan ge lösningar.

i datavetenskap är funktionell programmering ett programmeringsparadigm som behandlar beräkning som utvärdering av matematiska funktioner och undviker att ändra tillstånd och muterbara data. Det är ett programmeringsmönster som ligger närmare matematiskt tänkande.

Djupinlärningsmodeller är i huvudsak matematiska modeller. Till exempel innefattar artificiella neurala nätverk anslutna noder, som var och en utför enkla matematiska operationer. Genom att använda ett funktionellt programmeringsspråk kan programmerare beskriva dessa matematiska operationer på ett språk som ligger närmare själva operationerna. Det uttryckliga sättet dessa program skrivs gör läsning och underhåll av kodbasen mycket enklare.

samtidigt innebär kompositionens karaktär av djupa inlärningsalgoritmer att lagren eller funktionerna vid varje lager av det neurala arbetet tenderar att kedja ihop för att utföra uppgifter. Detta kan enkelt implementeras med hjälp av funktionell kedja av ett funktionellt programmeringsspråk.

dessutom, i djupinlärning, när funktioner tillämpas på data, ändras inte data. Nya värden kan matas ut sekventiellt längs linjen, men själva data förblir konsekventa. Immutability-funktionen i ett funktionellt programmeringsspråk gör det möjligt för programmeraren att skapa en ny dataset varje gång nya värden genereras utan att ändra den ursprungliga oföränderliga datasetet. Detta gör det lättare att upprätthålla konsistensen av data i hela det neurala nätverket.

slutligen innebär det stora antalet parametrar och träningsdata som är involverade i implementeringen av djupt lärande att parallellitet och samtidighet är nycklarna till att skapa djupinlärningssystem på produktionsnivå. Parallellism innebär att man kör trådar på olika processorer för att påskynda inlärningsprocessen. Samtidighet innebär förmågan att hantera trådar för att undvika konflikter. Funktionell programmering möjliggör samtidighet och parallellitet utan kostnad. Detta innebär att funktionell programmering, där den rena funktionen är statslös, till sin natur alltid kommer att producera samma utgång för en viss ingång, leda till förmågan att isolera vilken funktion som helst och utföra när du vill. Detta gör samtidighet och parallellitet mycket lättare att hantera. Du behöver inte hantera frågor som deadlocks och rasförhållanden. Olika trådar som har tillgång till olika processorer kommer att kunna köras oberoende utan några stridigheter.

Clojure

med funktionell programmering som blir populär i djupinlärning, och med de robusta paketen som finns tillgängliga för djupinlärning, är Clojure nu gynnad av företag som Walmart och Facebook. Det är ett dynamiskt funktionellt programmeringsspråk på hög nivå baserat på LISP-programmeringsspråket och det har kompilatorer som gör det möjligt att köra på både Java och.Net runtime environment.

kraften i samtidig programmering i Clojure

Clojure ersätter inte Java-trådsystemet, utan det fungerar med det. Eftersom kärndatastrukturerna är oföränderliga kan de delas lätt mellan trådar. Samtidigt är tillståndsändringar i programmet möjliga, men Clojure tillhandahåller mekanismer för att säkerställa att staterna förblir konsekventa. Om konflikter uppstår mellan 2 transaktioner försöker ändra samma referens, en av dem kommer att gå i pension. Det finns inget behov av explicit låsning.

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

källa

parallellism i Clojure är billigt

i djupinlärning måste modeller träna på stora mängder data. Parallellism innebär att man kör flera trådar på olika processorer. Parallellism som är billig kommer att innebära betydande prestandaförbättringar. Att använda partition i samband med map kan uppnå parallellitet som är billigare.

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

källa

Kedjefunktioner i Clojure betyder klarhet

i Clojure finns det många funktioner för mycket få datatyper. Funktioner kan också överföras som argument till andra funktioner, vilket möjliggör kedjningsfunktioner i djupinlärning. Med implementering närmare den faktiska matematiska modellen kan Clojure-koden vara enkel att läsa och underhålla.

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

källa

identitet och tillstånd i Clojure ger säkerhet

i Clojure har varje modell identitet ett tillstånd när som helst. Detta tillstånd är ett verkligt värde som aldrig förändras. Om identiteten verkar förändras beror det på att den är associerad med ett annat tillstånd. Nya värden är gamla funktioner. Inuti varje lager i det neurala nätverket bevaras alltid tillståndet för de ursprungliga uppgifterna. Varje uppsättning data med nya värden som är utgångar av funktioner kan fungera oberoende. Detta innebär att åtgärder kan utföras på dessa uppsättningar data säkert eller utan hänsyn till strid. Vi kan när som helst hänvisa till det ursprungliga tillståndet för uppgifterna. Därför betyder konsistens i detta fall säkerhet.

bibliotek och begränsningar

historiskt sett innehåller cortex machine learning library allt du behöver för att implementera maskininlärningsalgoritmer i Clojure. Med den senaste tidens ökande populariteten för open-source MXNet framework för deep learning, är det lättare att genomföra deep learning med hjälp av MXNet-Clojure API.

även om det nu finns olika API: er och maskininlärningsbibliotek tillgängliga för Clojure, finns det fortfarande en brant inlärningskurva för att bli flytande i den. Felmeddelanden kan vara kryptiska och företag måste vara villiga att investera i förskott för att använda den för att skala upp sina maskininlärningssystem. När fler exempel på produktionsklara system skrivs i Clojure kommer språket att bli mer populärt under de kommande åren, men bara om antalet och storleken på bibliotek som åtföljer användningen av Clojure växer konsekvent.

Haskell

Haskell är ett funktionellt språk som statiskt skrivs med typ inferens och Lat utvärdering. Det är baserat på semantiken i Miranda programmeringsspråk och anses vara mer uttrycksfullt, snabbare och säkrare för att implementera maskininlärning.

typsäkerhet i Haskell ger säkerhet och flexibilitet

typsäkerhet definierar begränsningar för de typer av värden en variabel kan hålla. Detta kommer att bidra till att förhindra olagliga operationer, ge bättre minnessäkerhet och leda till färre logiska fel. Lat utvärdering innebär att Haskell kommer att fördröja utvärderingen av ett uttryck tills dess värde behövs. Det undviker också upprepade utvärderingar, vilket sparar körtid. Samtidigt möjliggör Lat utvärdering oändliga datastrukturer att definieras. Detta ger en programmerare obegränsade matematiska möjligheter.

enkel explicit kod i Haskell ger tydliga implementeringar

en av de största fördelarna med Haskell är att den kan beskriva algoritmer i mycket explicita matematiska konstruktioner. Du kan representera en modell i några rader kod. Du kan också läsa koden på samma sätt som du kan läsa en matematisk ekvation. Detta kan vara mycket kraftfullt i komplexa algoritmer som djupa inlärningsalgoritmer i maskininlärning. Till exempel visar nedanstående implementering av ett enda lager av ett feed-forward neuralt nätverk hur läsbar koden kan vara.

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)

källa

Multicore parallellism i Haskell ger prestanda

i djupinlärning kommer typiska neurala nätverk att innehålla en miljon parametrar som definierar modellen. Dessutom krävs en stor mängd data för att lära sig dessa parametrar, vilket är beräkningsmässigt mycket tidskrävande. På en enda maskin kan det vara mycket kraftfullt att använda flera kärnor för att dela minnet och processen parallellt när det gäller att implementera djupt lärande. I Haskell är det dock enkelt att implementera multicore-parallellism.

bibliotek och begränsningar

Haskells hlearn-bibliotek innehåller implementeringar av maskininlärningsalgoritmer, medan tensorflödesbindningen för Haskell kan användas för djupinlärning. Parallellt och samtidigt används under tiden för parallellitet och samtidighet.

även om det finns några maskininlärningsbibliotek som utvecklats i Haskell, måste grundbaserade implementeringar fortfarande göras för produktionsklara Haskell-implementeringar. Medan offentliga bibliotek som är tillgängliga för specifika djupinlärnings-och maskininlärningsuppgifter är begränsade, kommer Haskells användning i AI också att begränsas. Företag som Aetion Technologies och Credit Suisse Global Modeling and Analytics Group använder Haskell i sina implementeringar—här är en komplett lista över de organisationer som använder den.

slutsats

Djupinlärningsmodeller är komplexa matematiska modeller som kräver specifik lagring av funktioner. Funktionella programmeringsspråk som Clojure och Haskell kan ofta representera komplexiteten med renare kod som ligger närmare modellens matematik. Detta leder till tidsbesparingar, effektivitet och enkel hantering av kodbasen. Specifika egenskaper för funktionell programmering gör att implementeringarna på dessa språk kan vara säkrare än andra språk. Allteftersom utvecklingen inom AI-tekniken fortskrider kommer utvärdering av dessa språk för behoven hos storskaliga systemutvecklingsprojekt inom AI att bli vanligare.

denna artikel är en del av bakom koden, media för utvecklare, av utvecklare. Upptäck fler artiklar och videor genom att besöka Behind the Code!

vill du bidra? Bli publicerad!

Följ oss på Twitter för att hålla ögonen öppna!

Illustration av Victoria Roussel