Pro: programozási nyelvek és adatbányászat kölcsönhatásai

.
Ugye nem kell hangsúlyoznom, hogy a téma rendes kifejtése PhD-szintű tézis-hegyeket igényel ;) Meg sem kísérlem a téma bemutatását még villantás erejéig sem, ebben a rövid ám annál szubjkektívebb posztban, így augusztus 20-dikai ünnepnapon (amikorra annyi mindent terveztem, csak éppen ezt a blogposztot nem).

Comming Out következik: magam részéről azt gondolnám, hogy Földi Tamás (Starschema, fejlesztési vezető) hatása alól nehéz kivonnia magát az embernek.

Elsőként 2010-ben tapasztalhattam meg ezt, igen fájdalmasan impresszív módon. Együtt dolgoztunk egy párhetes GE-s ETL/DB migrációs projekten ("gyenge" 1.400 migrálandó job-bal). Én mint PlSql-Developer fan meg kellett éljem egy minden optimalizációnak ellenálló végtelenül lassú Oracle-töltésnél (hiszen Tamáshoz már csak végstádiumban betegeskedő job-ok kerültek), hogy a szerintem bár Delphiben íródott ám "orákulumos fejlesztésre alkalmatlan lomha" TOAD for Oracle-ben 6.5 perc alatt kivitelezett tervszerűen és komplexen összefüggő egérklikk és billentyűleütés-interakció-sorozat nyomán kezesbáránnyá szelidült a jobtöltés. PlSql Developerben többet lehetett volna küszködni ezen, de legalább esélyesen eredménytelenül, a szükséges infók megfelelő kicsalogatásának hiányában.

Aztán annó láttam egy Starschemás-álláshirdetést (még a Profession.hu-n), ahol előny volt a jelentkezőknél, ha Clojure, Scala, Haskell, Erlang megvolt nekik. What the fuck? Mit szívtak Tamásék ott a BI-fellegvárban? [Mindegy, nekem dupla adag kell belőle :D]
Én az egyetemen küszködve abszolváltam a LISP funkcionális nyelves kurzust, ha valami távolállt tőlem az ez volt, meg is fogadtam, hogy bármi jöhet, de ezt soha többé ne lássam.
Erre egy magyar álláshirdetésben ezt látom. Halkan, bekezdést bezáróan megjegyezném, hogy hatalmas ütésekkel dörömböl a Starschema-kapun a Clojure-s állásinterjúk világa (az "előnyből" hovatovább elvárás lesz), azaz komoly a dolog, "mivel viccnek kicsit durva lenne" (vö.: a székely favágós vicc)

Aztán egyszercsak azt veszem észre, hogy elvégeztem egy internetes Clojure-s kurzust és imádtam, a szó legszorosabb értelmében (kikapcsolódásnak is, agyserkentésnek is kiváló volt). Terveztem erről írni, egy hosszabb, mélyebb blogposztott, de egyelőre az egyéb másirányú elfoglaltságok ezt elsodorták. Informatikus kollégák láthatóan/érzékelhetően determináló komoly rétege "esküszik" a funkcionális programozási nyelvekre (az évtizedek óta létező LISP napvilágra jöttétől: basszus kulcs egy Autocad internal script nyelve bír lenni.)

Aztán mit kell lássak a Clojure brutális (és jogos) térnyerésén felül? Hogy egyre-másra jelennek meg a Data Analysis/Science könyvek ezekkel a programozási nyelvekkel (Clojure kezdte, Scala folytatta, majd a Haskell és most futottam bele egy Erlangos neurális hálós könyvbe). Nem linkelem őket (az utóbbit leszámítva, hiszen miatta született ez a poszt), neten megtalálhatók. Én bizony azt látom, hogy ez a téma nagyon erős figyelemfókusz-/erőforrás-allokációt követel magának egyre inkább. Mondjon bárki-bármit, ez bizony nem hype-nak tűnik, hanem valós forró témának: az a bizonyos közmondásos csizma nagyon odakerült az asztal közepére.

Nyilván rohamléptekkel fejlődik a programozási nyelvek tudománya is, lassan a magyar nyelvre is lehet compilert írni (kis túlzással). Nagyon fontos az informatikában - adatbányásznak aztán különösen - hogyan fogalmazza meg az abszolválandó  feladatot, és aztán ezt milyen - plaszticitású - nyelven teszi meg, nagyon nem látszik mindegynek.Sosem téveszthetjük szem elöl egy jó kérdés, egy feladatmegfogalmazás / problémafelvetés, sokszor félsiker, azaz érdemes ezt megtámogatni, ha kell nyelv oldaláról is (tök logikusan egyébként, szvsz).

Adatbányászat nagy kihívásai című 2010-es számomra máig talán legkedvesebb blogposztomban 40 tételben szedtem össze a kihívásokat (amiből ugye a funkcionális nyelvek vagy a LISP említése, hogyhogynem kimaradt). Földi Tomi maximális és kizárólagos "bűne", hogy a funkcionális nyelvek számomra (is) elvitathatatlanul odakívánkoznak 41-diknek, a kihívások közé.

Pár idézet-mazsola az említett Erlangos NN-s könyvről, felcsigázásnak.

Handbook of Neuroevolution Through Erlang, 2013, 898 pages
http://www.springer.com/us/book/9781461444626
With 300/4MB example source codes:
https://github.com/CorticalComputer/Book_NeuroevolutionThroughErlang

Erlang-site:
http://www.erlang.org/

Dacker B (2000) Concurrent Functional Programming for Telecommunications: A Case Study of Technology - Introduction. Masters thesis KTH Royal Institute of Technology Stockholm.

A list of features that a neural network based computational intelligence system needs
01.The system must be able to handle very large numbers of concurrent activities.
02.Actions must be performed at a certain point in time or within a certain time.
03.Systems may be distributed over several computers.
04.The system is used to control hardware.
05.The software systems are very large.
06.The system exhibits complex functionality such as, feature interaction.
07.The systems should be in continuous operation for many years.
08.Software maintenance (reconfiguration, etc) should be performed without stopping the system.
09.There are stringent quality, and reliability requirements.
10.Fault tolerance

Erlang was created to 
* develop distributed
* process based
* message passing paradigm oriented
* high availability
* robust
* fault tolerant
* concurrent systems
* used to build massively scalable soft real-time systems.

Joe Armstrong (2003)
Making Reliable Distributed Systems in The Presence of Software Errors.
The Royal Institute of Technology Stockholm, Sweden, (PhD thesis).

Erlang-alkotótól, hogyan támogassa a fentieket az akkoriban új (Erlang) nyelv:

Encapsulation primitives — there must be a number of mechanisms for
limiting the consequences of an error. It should be possible to isolate processes
so that they cannot damage each other.

Concurrency — the language must support a lightweight mechanism to create
parallel process, and to send messages between the processes. Context
switching between process, and message passing, should be efficient.
Concurrent processes must also time-share the CPU in some reasonable
manner, so that CPU bound processes do not monopolize the CPU, and prevent
progress of other processes which are “ready to run.

Fault detection primitives — which allow one process to observe another
process, and to detect if the observed process has terminated for any reason.

Location transparency — If we know the PId of a process then we should be
able to send a message to the process.

Dynamic code upgrade — It should be possible to dynamically change code in
a running system. Note that since many processes will be running the same
code, we need a mechanism to allow existing processes to run “old” code, and
for “new” processes to run the modified code at the same time.

With a set of libraries to provide:

Stable storage — this is storage which survives a crash.

Device drivers — these must provide a mechanism for communication with the
outside world.

Code upgrade — this allows us to upgrade code in a running system.

Infrastructure — for starting, and stopping the system, logging errors, etc.

Itt van a lehető legegyszerűbb NN-program Erlangban, házi feladat C-ben reprodukálni :D

-module(simplest_nn).
-compile(export_all).

create() ->
    Weights = [random:uniform()-0.5,random:uniform()-0.5,random:uniform()-0.5],
    N_PId = spawn(?MODULE,neuron,[Weights,undefined,undefined]),
    S_PId = spawn(?MODULE,sensor,[N_PId]),
    A_PId = spawn(?MODULE,actuator,[N_PId]),
    N_PId ! {init,S_PId,A_PId},
    register(cortex,spawn(?MODULE,cortex,[S_PId,N_PId,A_PId])).

neuron(Weights,S_PId,A_PId) ->
    receive
        {S_PId,forward, Input} ->
            io:format("****Thinking****~n Input:~p~n with Weights:~p~n",[Input,Weights]),
            Dot_Product = dot(Input,Weights,0),
            Output = [math:tanh(Dot_Product)],
            A_PId ! {self(),forward,Output},
            neuron(Weights,S_PId,A_PId);
        {init,New_SPId,New_APId} ->
            neuron(Weights,New_SPId,New_APId);
        terminate ->
            ok
    end.

    dot([I|Input],[W|Weights],Acc) ->
        dot(Input,Weights,I*W+Acc);
    dot([],[],Acc)->
        Acc;
    dot([],[Bias],Acc)->
        Acc + Bias.

sensor(N_PId) ->
    receive
        sync ->
            Sensory_Signal = [random:uniform(),random:uniform()],
            io:format("****Sensing****:~n Signal from the environment ~p~n",[Sensory_Signal]),
            N_PId ! {self(),forward,Sensory_Signal},
            sensor(N_PId);
        terminate ->
            ok
    end.

actuator(N_PId) ->
    receive
        {N_PId,forward,Control_Signal}->
            pts(Control_Signal),
            actuator(N_PId);
        terminate ->
            ok
    end.

    pts(Control_Signal)->
        io:format("****Acting****:~n Using:~p to act on environment.~n",[Control_Signal]).

cortex(Sensor_PId,Neuron_PId,Actuator_PId)->
    receive
        sense_think_act ->
            Sensor_PId ! sync,
            cortex(Sensor_PId,Neuron_PId,Actuator_PId);
        terminate ->
            Sensor_PId ! terminate,
            Neuron_PId ! terminate,
            Actuator_PId ! terminate,
            ok
    end.