[Tutorial] Uvod u umjetnu inteligenciju, UNM

Vratimo se na trenutak gornjoj jednadžbi korekcije težina. Ta jednadžba još se zove i perceptronovo pravilo učenja. U ovoj formuli w_i(k) predstavlja i-tu težinu u k-tom koraku, a w_i(k+1) tu istu težinu u sljedećem koraku, u k+1-om koraku. Eta (η) je konstanta koja predstavlja faktor ili stopu učenja, t (skraćeno od engl. target) predstavlja stvarnu klasu primjera, o predstavlja predviđenu klasu primjera, a x_i je i-ta vrijednost primjera x. Da bismo malo bolje shvatili kako ova jednadžba funkcionira idemo ugrubo proći kroz jedan primjer.

Pretpostavimo da imamo dva ulaza u neuron. Sjetimo se, treći ulaz je zadani, uvijek je iznosa 1, nikad se ne navodi posebno već se podrazumijeva, a naziva se pomakom ili pristranošću (engl. bias). Neka su x1 = 0.5, x2 = 1 (x0 znamo da je uvijek jednak 1 po definiciji), a sve početne težine neka budu w0 = w1 = w2 = 0.5. Izračunajmo ukupnu pobudu neurona:
net = x0*w0 + x1*w1 + x2*w2 = 1*0.5 + 0.5*0.5 + 1*0.5 = 1.25

Pogledajmo sada definiciju funkcije praga i pogledajmo je li 1.25 iznosom veće od 0? Pa svakako vrijedi da je 1.25 > 0, što znači da će izlaz iz našeg neurona biti f(1.25) = 1. Drugim riječima, naš neuron je okinuo - aktivan je. Sada nam slijedi korekcija težina. Za korekciju težina pretpostavimo da je stvarna klasa ovog našeg primjera x = (x0 x1 x2) = (1 0.5 1) bila 0 jer se prema gornjem pravilu učenja korekcija vrši kad je primjer klasificiran neispravno, a naš neuron je predvidio 1. Korekcija težina obavlja se prema gornjem izrazu za korekciju težina (pretpostavimo da nam je stopa učenja eta = 0.1):
w0(1) = w0(0) + eta * (t - o) * x0 = 0.5 + 0.1 * (0 - 1) * 1 = 0.4
w1(1) = w1(0) + eta * (t - o) * x1 = 0.5 + 0.1 * (0 - 1) * 0.5 = 0.45
w2(1) = w2(0) + eta * (t - o) * x2 = 0.5 + 0.1 * (0 - 1) * 1 = 0.4

Iz ovog računa vidimo da je sljedeći iznos težine w0 jednak zbroju prethodnog iznosa w0 i ovog umnoška koji smo već objasnili. Analogno izračunamo i ostale težine i dobili smo nove težine koje iznose w0 = 0.4, w1 = 0.45, w2 = 0.4. Sad bi dalje nastavili učiti perceptron na način da mu damo sljedeći primjer x = (x0 x1 x2), pa sljedeći i tako u krug dok sve primjere ne klasificira točno što ujedno znači i da više neće biti korekcije težina jer se korekcija vrši samo ukoliko je primjer netočno klasificiran. To se vidi i iz jednadžbe, ukoliko su t i o jednakog iznosa taj čitavi umnožak bit će 0, a nešto + 0 = nešto.

Ono što je bitno ovdje napomenuti je da je ovako definirani neuron zapravo linearni klasifikator, a to znači da je granica na temelju koje odlučuje kojoj klasi pripada neki primjer linearna, tj. u 2D prostoru to je pravac, u 3D prostoru to je ravnina, a u višedimenzionalnom prostoru to je hiperravnina (a to si ne možemo niti zamisliti). Drugim riječima, da bi učenje perceptrona konvergiralo, tj. da dođe do toga da više nema promjena u korekciji težina (jer je u tom slučaju svaki primjer u skupu podataka ispravno klasificiran) taj skup podataka mora biti linearno odvojiv. Da bi bilo jasnije o čemu govorim, pogledajmo sljedeću sliku:

Linearno+odvojivi+i+neodvojivi+skupovi+podataka

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
df.tail()

       0    1    2    3               4
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

Ove dvije linije koda su prilično jasne. Pozovemo pandasovu metodu read_csv() koja će danu putanju pročitati i obraditi kao datoteku CSV, s tim da ju argumentom header=None upućujemo da zaglavlja u podacima nema pa će metoda dodati zaglavlje u obliku numeriranih stupaca (u suprotnom će za zaglavlje uzeti prvi redak što nam ne paše). Sada se podaci nalaze u posebnoj pandasovoj strukturi podataka DataFrame, a to znači da možemo koristiti sve blagodati pandasovih metoda za manipulaciju podacima. Sljedeća linija je metoda tail() koja očigledno pokazuje zadnjih 5 unosa u pandasovom podatkovnom okviru. Da bismo podatke mogli koristiti u svom modelu perceptrona, moramo ih još malo obraditi.

Sjetimo se da u skupu podataka imamo tri vrste perunika s po 50 primjeraka svake vrste što znači da ukupno imamo 150 primjeraka (što se vidi iz rednog broja u izlazu metode tail() - 149, indeksiranje kreće od nule). Ako ste probali otvoriti poveznicu iz argumenta metode read_csv() u pretraživaču (može se, riječ je o običnoj tekstualnoj datoteci) mogli ste primjetiti da su "igrom slučaja" (naravno da nije igrom slučaja, namjerno je tako složeno) primjerci poredani i grupirani upravo po vrstama. Tu činjenicu možemo iskoristiti kod naše dodatne obrade podataka. Naime, nama trebaju samo dvije vrste perunika jer ćemo raditi binarnu klasifikaciju (imat ćemo samo dvije klase). S obzirom da po vrsti ima 50 primjeraka to znači da su prvih 100 primjera u skupu podataka točno dvije vrste. Stoga ćemo odabrati prvih 100 primjera (0:100), samo zadnji stupac (4 - a to su latinska imena perunika) te izvući sirove vrijednosti iz pandasovog podatkovnog okvira (.values) u posebnu varijablu:

y = df.iloc[0:100, 4].values

Ako sada ispišemo y, dobit ćemo ovako nešto:

array(['Iris-setosa', 'Iris-setosa', 'Iris-setosa', ... , 'Iris-versicolor', 'Iris-versicolor'], dtype=object)

Trenutno u polju imamo 50 "Iris-setosi" i 50 "Iris-versicolora", međutim, mi ne možemo baš nešto raditi sa znakovnim nizovima stoga ćemo ove dvije vrste perunika pretvoriti u dvije klase (cijele brojeve): 0 i 1:

y = np.where(y == 'Iris-setosa', 0, 1)

NumPyeva metoda where() jednostavno gleda gdje u polju imamo ispunjen uvjet "y == 'Iris-setosa'" i tamo postavlja 0, a na sva ostala mjesta 1. Kako imamo samo dvije vrste perunika u polju, efektivno smo svakoj odredili njenu klasu - "Iris-setosa" je 0, a "Iris-versicolor" je 1.

Sad kad imamo svoje klase, potrebno je još odrediti i same primjere koji tim klasama pripadaju:

X = df.iloc[0:100, [0, 2]].values

Ništa strašno, opet smo uzeli prvih 100 primjera (0:100), međutim ovaj put smo uzeli prvi i treći stupac ([0, 2] - koji predstavljaju duljinu čašice cvijeta i duljinu latice). Ako sada ispišemo X, trebali bi dobiti ovako nešto:

array([[ 5.1,  1.4],
       [ 4.9,  1.4],
       [ 4.7,  1.3],
       ...
       [ 5.7,  4.1]])

Ovdje imamo matricu 100 x 2 koja predstavlja naše primjere sa značajkama. Ova matrica naziva se ulazni prostor ili prostor primjera. Također imamo i matricu, tj. vektor s oznakama klasa (varijabla y). Zajedno to dvoje tvori nešto što zovemo skup primjera za učenje, a koji se može tablično prikazati ovako:

Skup+primjera+za+učenje

Iscrtani+i+označeni+primjerci

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# dohvat i priprema podataka
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', 0, 1)
X = df.iloc[0:100, [0, 2]].values

# iscrtavanje na grafu
plt.scatter(X[:50, 0], X[:50, 1], color='red', marker='o', label='setosa')
plt.scatter(X[50:100, 0], X[50:100, 1], color='blue', marker='x', label='versicolor')
plt.xlabel('Duljina latica [cm]')
plt.ylabel('Duljina čašice cvijeta [cm]')
plt.legend(loc='upper left')
plt.savefig('iscrtani_primjerci.png')
# plt.show()  # ako se želi prikazati u prozoru

Sada kada smo pokrili osnovnu teoriju i pripremili podatke za naš budući model, možemo krenuti na samu implementaciju modela.

Krenimo s očitim, uvezimo biblioteku NumPy i definirajmo novu klasu zvanu Perceptron:

import numpy as np

class Perceptron(object):
    def __init__(self, eta=0.01, epochs=10):
        self.eta = eta
        self.epochs = epochs

Ovime smo definirali novu klasu Perceptron i napisali njezin konstruktor koji kao argumente prima stopu učenja eta i broj epoha učenja. Jedna epoha definira se kao jedan prolazak kroz sve primjere za učenje u skupu podataka. Zadane vrijednosti (ukoliko konstruktoru ne predamo neke svoje) su 0.01 i 10. Stopu učenja i broj epoha spremamo u varijable self.eta i self.epochs. U Pythonu ključna riječ self znači isto što i u Javi ili C++-u ključna riječ this, međutim, u Pythonu se mora eksplicitno navoditi ("eksplicitno je bolje od implicitnog" - pitonska mudrost) dok se u C++-u/Javi, a i drugim C-olikim jezicima implicitno podrazumijeva.

Prisjetimo se, od čega se sastoji umjetni neuron. Sastoji se od ulaza, težina, "tijela" u kojem se računa net te prijenosne funkcije f koja daje izlaz. Prvo trebamo izračunati net (sad je dobro vrijeme da ponovite množenje matrica/vektora, ukoliko ne znate ili ste zaboravili):

def _net(self, X):
    return np.dot(X, self.weights[1:]) + self.weights[0]

Ovdje smo upotrijebili NumPyevu metodu dot() koja obavlja matrično množenje, u ovom slučaju između matrice X i vektora self.weights[1:]. Matrica X je dimenzija N x 2 (N je neki općenit broj - u našem slučaju je 100), no self.weights je dimenzija 3 x 1 i stoga smo X množili sa self.weights[1:] (bez nulte težine - [1:] znači da odabiremo sve elemente od indeksa 1 do kraja, drugim riječima, indeks 0 smo izostavili) koji je dimenzija 2 x 1, a nultu težinu self.weights[0] smo naknadno zbrojili. Ovo možemo tako napraviti zato što ulaz x0 uz težinu w0 iznosi konstantnih 1, a 1 * w0 = w0. S obzirom da je povratna vrijednost metode dot() vektor, a self.weights[0] je skalar, NumPy interno radi tzv. širenje gdje od tog skalara stvara vektor istih vrijednosti takvih dimenzija da zbrajanje bude moguće - u ovom slučaju N x 1.

Kao rezultat smo dobili vektor dimenzija N x 1 koji predstavlja net za svaki od N primjera. Drugim riječima, izračunali smo net = w0*x0 + w1*x1 + w2*x2 za N primjera odjednom, u jednoj liniji koda bez ikakvih petlji. Ako se sjećate, ranije sam spomenuo da se preferira vektorski zapis, a ovo je jedan od razloga zašto. Sav teret proračuna prebacili smo na veoma optimiranu biblioteku NumPy koja je specijalno namijenjena upravo ovakvim proračunima. Ovu liniju koda je bitno shvatiti, ukoliko vam nije jasna, preporučam na komadu papira napisati matricu 5 x 2 i vektor 2 x 1 te ručno obaviti množenje (možete s brojevima ili bez, kako vam je lakše) da vidite kako će izgledati rezultat (rezultantni vektor mora biti dimenzija 5 x 1). Isti je postupak i u kodu s matricom N x 2, razlika je jedino u veličini.

Sad kad imamo net, tj. netove, možemo napisati metodu za predviđanje kojoj klasi primjer pripada. Ovo je vrlo jednostavna metoda, jedna linija koda. Prisjetimo se definicije: ako je ukupna pobuda <i>net<i> negativna ili jednaka nuli, neuron ne okida, tj. na izlazu daje 0, a ako je pobuda pozitivna neuron će okinuti, tj. na izlazu će dati 1:

def predict(self, X):
    return np.where(self._net(X) > 0.0, 1, 0)

S metodom where() već smo se susreli. Unutar metode where() zovemo ranije definiranu metodu self._net() koja će vratiti netove. Netovi koji su pozitivni (> 0.0) dobit će oznaku 1, a svi ostali oznaku 0. Ova bi linija koda trebala biti jasna sama po sebi.

Napišimo sada metodu za provedbu učenja. Ukoliko ste ikada radili s bibliotekom sklearn ili tek budete, oni u svojim implementacijama modela metodu za učenje nazivaju fit pa ćemo i mi slijediti tu konvenciju:

def fit(self, X, y):
    self.weights = np.zeros(1 + X.shape[1])
    self.errors = []

Za početak, definirali smo varijablu self.weights koja će sadržavati sve težine koje ulaze u naš neuron. Za to smo uzeli drugu dimenziju matrice X i dodali joj 1. Sjetimo se, matrica X je dimenzija N x 2, što znači da X.shape[1] iznosi 2. Na ove dvije težine dodali smo još jednu koja odgovara težini w0 kod koje x0 uvijek iznosi fiksnih 1. Dakle, ukupno imamo tri težine: w0, w1 i w2. Definirali smo i varijablu self.errors koja nam predstavlja broj krivo klasificiranih primjera kako bi kasnije mogli iscrtati iznose tih grešaka. Zanimljivost kod Pythona je to što smo u ovom slučaju podatkovne članove klase (atribute klase) definirali u metodi fit() (Python ih je dinamički stvorio), a ne u konstruktoru, tj. u metodi __init__() kako se to obično mora napraviti u C-olikim jezicima.

Sada nam trebaju dvije petlje, jedna vanjska koja će prolaziti po epohama te jedna unutarnja koja će prolaziti po primjerima. Još samo preostaje perceptronovo pravilo učenja, tj. onu jednadžbu prenijeti u kod:

for _ in range(self.epochs):
    misclassifications = 0
    for x, t in zip(X, y):
        correction = self.eta * (t - self.predict(x))
        self.weights[1:] += correction * x
        self.weights[0] += correction  # može pisati i correction * 1
        misclassifications += int(correction != 0.0)
    self.errors.append(misclassifications)

Analizirajmo pobliže unutarnju petlju. Ona se može napisati i vektorski, međutim ovako je sam proces učenja jednostavnije objasniti i shvatiti. Prolazimo po svakom primjeru x te uz njega uzimamo i pripadnu klasu y (kao varijablu t). Prvo što radimo je računamo ispravak koji je potrebno dodati težinama kako bi ih se popravilo. Nakon toga ispravljamo te težine i to sve po već ranije navedenoj formuli perceptronovog pravila učenja. Težini w0, tj. pristranosti samo dodajemo korekciju jer ako se prisjetimo od ranije, kod pristranosti vrijednost x0 je 1, a umnožak bilo čega s 1 je opet ta ista vrijednost. Zatim računamo pogrešku. Pogreška nam je u ovom slučaju broj krivo klasificiranih primjera. Naime, ako su varijabla t i predviđena vrijednost jednake, varijabla correction bit će 0. Ako su različite, varijabla correction bit će 1 i u tom slučaju pridodajemo jednu pogrešnu klasifikaciju varijabli misclassifications. Sama pogreška, tj. broj krivo klasificiranih primjera nema nikakvog utjecaja na algoritam učenja perceptrona i služi nam samo kao informacija i zanimljivost.

Sada imamo sve potrebne elementa za izgradnju perceptrona. Čitava klasa perceptrona izgleda ovako:

class Perceptron(object):
    def __init__(self, eta=0.01, epochs=10):
        self.eta = eta
        self.epochs = epochs

    def fit(self, X, y):
        self.weights = np.zeros(1 + X.shape[1])
        self.errors = []

        for _ in range(self.epochs):
            misclassifications = 0
            for x, t in zip(X, y):
                correction = self.eta * (t - self.predict(x))
                self.weights[1:] += correction * x
                self.weights[0] += correction
                misclassifications += int(correction != 0.0)
            self.errors.append(misclassifications)

        return self.errors

    def predict(self, X):
        return np.where(self._net(X) > 0.0, 1, 0)

    def _net(self, X):
        # ovo je "privatna" metoda što podvlaka _ prije naziva i naznačava
        return np.dot(X, self.weights[1:]) + self.weights[0]

Svoj perceptron možemo pokrenuti i naučiti na sljedeći način:

p = Perceptron()
p.fit(X, y)

gdje je X matrica svih primjera, a y su pripadne klase.

Predvidjeti u koju klasu spada neki novi primjer možemo pozivanjem metode predict() kojoj predamo taj novi primjer:

prediction = p.predict([3.5, 4])
print(prediction)

Naučimo onda naš perceptron na našim podacimo o perunikama:

# dohvat i priprema podataka
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', 0, 1)
X = df.iloc[0:100, [0, 2]].values

p = Perceptron()
errors = p.fit(X, y)

Zadana vrijednost broja epoha je 10 (postavljena u konstruktoru), stoga će se naš perceptron učiti 10 epoha. Ako se sjetimo teorije o perceptronu, rekli smo da se postupak učenja zaustavlja kad su svi primjeri klasificirani ispravno. No mi smo ovdje implementirali perceptron tako da odradi određeni broj epoha i onda se zaustavlja. Razlog tome je što se kod neuronskih mreža uobičajeno i radi na taj način - postavi se određeni broj epoha za vrijeme kojih se mreža uči. Perceptron je model koji odskače od takve prakse - njegov algoritam učenja zaustavlja se kad su svi primjeri točno klasificirani. To je moguće, kao što smo već ranije rekli, samo ako su svi primjeri linearno odvojivi. U stvarnom svijetu to nije slučaj - podaci su gotovo uvijek linearno neodvojivi. Ovaj kod je trivijalno preinačiti da se postupak učenja zaustavlja kad su svi primjeri točno klasificirani i to ostavljam za vježbu.

Pogledajmo kako izgleda postupak učenja kroz epohe, točnije kako izgleda broj pogrešnih klasifikacija kroz epohe:

Pogrešne klasifikacije kroz epohe

Granica između klasa koju je pronašao perceptron

Čitavi kod našeg perceptrona:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
#  perceptron.py
#

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import plotregije as pr


class Perceptron(object):
    def __init__(self, eta=0.01, epochs=10):
        self.eta = eta
        self.epochs = epochs

    def fit(self, X, y):
        self.weights = np.zeros(1 + X.shape[1])
        self.errors = []

        for _ in range(self.epochs):
            misclassifications = 0
            for x, t in zip(X, y):
                correction = self.eta * (t - self.predict(x))
                self.weights[1:] += correction * x
                self.weights[0] += correction
                misclassifications += int(correction != 0.0)
            self.errors.append(misclassifications)

        return self.errors

    def predict(self, X):
        return np.where(self._net(X) > 0.0, 1, 0)

    def _net(self, X):
        # ovo je "privatna" metoda što podvlaka _ prije naziva i označava
        return np.dot(X, self.weights[1:]) + self.weights[0]


if __name__ == '__main__':
    # dohvat i priprema podataka
    df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
    y = df.iloc[0:100, 4].values
    y = np.where(y == 'Iris-setosa', 0, 1)
    X = df.iloc[0:100, [0, 2]].values

    p = Perceptron()
    errors = p.fit(X, y)
    prediction = p.predict([3.5, 4])

    print(prediction)

S ovim smo završili još jedan vodič kroz umjetnu inteligenciju i obradili još jedan od alata, tj. algoritama vezanih uz umjetnu inteligenciju. Zapravo, samo smo načeli, tek zagrizli komadić najmoćnije tehnologije umjetne inteligencije današnjice - umjetnih (dubokih) neuronskih mreža.

Isprobajte primjer kod sebe, probajte se igrati. Probajte algoritam napisati vektorski, bez petlje. Kao i uvijek, komentirajte, diskutirajte, pitajte!

P.S. Ovaj je vodič nastao (barem 85% njega) još prije par godina. Međutim nikako da nađem vremena (i volje, prije nego vremena) da ga završim i konačno objavim. U to vrijeme (znači, prije 2-3 godine) duboke su neuronske mreže tek dobivale maha na nekoj poštenoj razini. Sve što je tu napisano aktualno je i danas, ali da je tada objavljeno, bilo bi možda i aktualnije. Barem kao literatura jer u ono vrijeme nije bilo previše objašnjenja na ovakvoj nekoj osnovnoj razini. I tako, zbog konferencije .debug i kasnije Bugovog tuluma na kojem sam obećal Miri da ću objaviti nastavak na genetske algoritme, točno četiri godine kasnije stiže i ova tema.

Mislim da sam poispravljao sve, dugo me nije bilo na forumu, već zaboravih koliko je ovo uređivanje teksta ćudljivo.

Da, sve je kopirano jer je unaprijed pripremljeno.

 Mislim da smo se slabo razumjeli. I basic je bio dobar kada je, well, bio dobar. Cisto me zanima ono dalje. Znam ja da je python najbolji trenutno po tom pitanju (ali i js moze (po)sluziti tome kada smo kod toga, da ne spominjem javu koje je danas iznad R), ali zanima me ono dalje. Ima li najava novih "jezika" koji ce to odvesti na visu razinu.

Aha. Pa mislim, BASIC je i dalje dobar, za to za što je dobar. xD

Uglavnom, smatram da ne. Trenutno je Python najrasprostranjeniji i mislim da ne bude još dugo otišel, s obzirom da postoji hrpetina biblioteka (optimiranih i zrelih) pisanih upravo za Python. Jedna takva je i biblioteka NumPy koju sam koristil gore u tutorijalu. Zatim je tu što se strojnog učenja tiče biblioteka sklearn (sa svim svojim statističkim čudesima). Tu su biblioteke za rukovanje podacima poput spomenutog pandasa. Što se tiče dubokog učenja, dvije najrasprostranjenije biblioteke su PyTorch i Tensorflow, obje napisane za Python (imaju i implementacije u C++-u te ostalim jezicima, ali ne toliko potpune kao implementacije u Pythonu).

Ono što vidim da bi se možda moglo dogoditi je da JavaScript postane vrlo korišten jezik jer svjedočimo tome da je od skriptnog jezika za pretraživače postal sveprisutni jezik (počevši s node.js-om). Uz to, ima hrpu novotarija u standardu ES6 i ES7 čime postaje neloš jezik. Međutim, ništa od toga nije toliko bitno jer su svi ti jezici iste imperativne paradigme. Razlika je samo u veličini zajednice i podrški u vidu popratnih biblioteka i alata. A Python tu trenutno prednjači.

Nadalje, tu su i neki novi programski jezici koji su se pojavili kao rivali Pythonu, kao npr. Julia, koja iako je jezik opće namjene, ima određene ugrađene značajke zbog kojih je prikladan jezik za numeričku analizu. No nedostaje joj zaleđa koje ima Python. Java, C#, pa i C++ su tu da bi ubrzali stvari, nipošto da bi se u njima razvijalo. Naime, razviješ model u Pythonu i PyTorchu/Tensorflowu, naučiš ga (što znači, kao što je rečenu u tutorijalu, naći odgovarajuće težine) i onda taj model (tj. skup svih tih težina) upucaš u implementaciju napisanu u nekom bržem jeziku. To je nešto što se redovito radi.

Što se tiče konkretnog "dalje" nakon dubokog učenja, ne znam. Veliki problem dubokog učenja je u tome što je to zapravo plitko područje nauke. Izraz "duboko" se odnosi na arhitekturu mreže: svaka mreža koja ima od nekoliko skrivenih slojeva pa do par stotina ili više naziva se dubokom. Zato je tu ime duboko učenje. No što se tiče teoretske podloge i zaleđa, gotovo pa nema ničega. Postoji teorem o univerzalnoj aproksimaciji (teorem Cybenka, Cybenkov teorem) i to je praktički to. Sve drugo je nabadanje i empirijsko nagađanje. Nema garancije konvergencije modela, nema garancije performansi bilo kakve vrste (kao u srodnim područjima strojnog učenja, tipa jezgrine metode, rijetki linearni modeli i sl.). Vladimir Naumovič Vapnjik koji je zajedno s Aleksejеm Jakovljevičem Červonjenkisom osmislil Vapnjik-Červonjenkisovu teoriju koja se smatra "temeljnom teorijom učenja" (objašnjava proces učenja sa statističkog stajališta) jednom je izjavio: "Najpraktičnija stvar na svijetu, dobra je teorija.". To je ono što mi nemamo. Modeli su gladni za previše označenih podataka, treba im predugo i previše resursa da se nauče, a često i podbace kod učenja. Hiperparametri (točnije, broj slojeva, broj neurona po sloju) su i dalje misterija, crna kutija. Oko toga nema nikakve automatizacije niti ikakvih procjena ili pravila - sve se svodi na intuiciju podatkovnog znanstvenika ili inženjera. Sve su to problemi jer nemamo nikakve čvrste teorije.

Tako da, što se tiče toga "dalje", zapravo to ne ovisi o nikakvim programskim jezicima, oni su tu sporedni, samo su alat koji koristimo. To "dalje" ovisi o teorijskoj podlozi i matematici te podloge.

Nadam se da sam sad uspel odgovoriti na pitanje, barem koliko-toliko. :)

Naravno, pošaljem PP.

 Moze i meni literatura? Unaprijed hvala!