I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
3. Optimizacija hiperparametara SVM-a
Pored hiperparametra $C$, model SVM s jezgrenom funkcijom RBF ima i dodatni hiperparametar $\gamma=\frac{1}{2\sigma^2}$ (preciznost). Taj parametar također određuje složenost modela: velika vrijednost za $\gamma$ znači da će RBF biti uska, primjeri će biti preslikani u prostor u kojem su (prema skalarnome produktu) međusobno vrlo različiti, što će rezultirati složenijim modelima. Obrnuto, mala vrijednost za $\gamma$ znači da će RBF biti široka, primjeri će biti međusobno sličniji, što će rezultirati jednostavnijim modelima. To ujedno znači da, ako odabremo veći $\gamma$, trebamo jače regularizirati model, tj. trebamo odabrati manji $C$, kako bismo spriječili prenaučenost. Zbog toga je potrebno zajednički optimirati hiperparametre $C$ i $\gamma$, što se tipično radi iscrpnim pretraživanjem po rešetci (engl. grid search). Ovakav pristup primjenjuje se kod svih modela koji sadrže više od jednog hiperparametra.
(a)
Definirajte funkciju

grid_search(X_train, X_validate, y_train, y_validate, c_range=(c1,c2), g_range=(g1,g2), error_surface=False)

koja optimizira parametre $C$ i $\gamma$ pretraživanjem po rešetci. Funkcija treba pretražiti hiperparametre $C\in{2^{c_1},2^{c_1+1},\dots,2^{c_2}}$ i $\gamma\in{2^{g_1},2^{g_1+1},\dots,2^{g_2}}$. Funkcija treba vratiti optimalne hiperparametre $(C^,\gamma^)$, tj. one za koje na skupu za provjeru model ostvaruju najmanju pogrešku. Dodatno, ako je surface=True, funkcija treba vratiti matrice (tipa ndarray) pogreške modela (očekivanje gubitka 0-1) na skupu za učenje i skupu za provjeru. Svaka je matrica dimenzija $(c_2-c_1+1)\times(g_2-g_1+1)$ (retci odgovaraju različitim vrijednostima za $C$, a stupci različitim vrijednostima za $\gamma$).
Can you write Python code for it?

from sklearn.metrics import accuracy_score, zero_one_loss

def grid_search(X_train, X_validate, y_train, y_validate, c_range=(0,5), g_range=(0,5), error_surface=False):

    # Vaš kôd ovdje
    pass


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
6. Analiza algoritma k-najbližih susjeda
Algoritam k-nn ima hiperparametar $k$ (broj susjeda). Taj hiperparametar izravno utječe na složenost algoritma, pa je stoga izrazito važno dobro odabrati njegovu vrijednost. Kao i kod mnogih drugih algoritama, tako i kod algoritma k-nn optimalna vrijednost hiperametra $k$ ovisi o konkretnom problemu, uključivo broju primjera $N$, broju značajki (dimenzija) $n$ te broju klasa $K$.
Kako bismo dobili pouzdanije rezultate, potrebno je neke od eksperimenata ponoviti na različitim skupovima podataka i zatim uprosječiti dobivene vrijednosti pogrešaka. Koristite funkciju: mlutils.knn_eval koja trenira i ispituje model k-najbližih susjeda na ukupno n_instances primjera, i to tako da za svaku vrijednost hiperparametra iz zadanog intervala k_range ponovi n_trials mjerenja, generirajući za svako od njih nov skup podataka i dijeleći ga na skup za učenje i skup za ispitivanje. Udio skupa za ispitivanje definiran je parametrom test_size. Povratna vrijednost funkcije jest četvorka (ks, best_k, train_errors, test_errors). Vrijednost best_k je optimalna vrijednost hiperparametra $k$ (vrijednost za koju je pogreška na skupu za ispitivanje najmanja). Vrijednosti train_errors i test_errors  liste su pogrešaka na skupu za učenja odnosno skupu za testiranje za sve razmatrane vrijednosti hiperparametra $k$, dok ks upravo pohranjuje sve razmatrane vrijednosti hiperparametra $k$.
(a)
Na podatcima iz zadatka 5, pomoću funkcije mlutils.plot_2d_clf_problem iscrtajte prostor primjera i područja koja odgovaraju prvoj odnosno drugoj klasi. Ponovite ovo za $k\in[1, 5, 20, 100]$.
NB: Implementacija algoritma KNeighborsClassifier iz paketa scikit-learn vjerojatno će raditi brže od Vaše implementacije, pa u preostalim eksperimentima koristite nju.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
Q: Je li algoritam k-najbližih susjeda osjetljiv na nebitne značajke? Zašto?
Q: Je li ovaj problem izražen i kod ostalih modela koje smo dosad radili (npr. logistička regresija)?
Q: Kako bi se model k-najbližih susjeda ponašao na skupu podataka sa značajkama različitih skala? Detaljno pojasnite.
7. "Prokletstvo dimenzionalnosti"
"Prokletstvo dimenzionalnosti" zbirni je naziv za niz fenomena povezanih s visokodimenzijskim prostorima. Ti fenomeni, koji se uglavnom protive našoj intuiciji, u većini slučajeva dovode do toga da se s porastom broja dimenzija (značajki) smanjenje točnost modela.
Općenito, povećanje dimenzija dovodi do toga da sve točke u ulaznome prostoru postaju (u smislu euklidske udaljenosti) sve udaljenije jedne od drugih te se, posljedično, gube razlike u udaljenostima između točaka. Eksperimentalno ćemo provjeriti da je to doista slučaj. Proučite funkciju metrics.pairwise.pairwise_distances. Generirajte 100 slučajnih vektora u različitim dimenzijama $n\in[1,2,\ldots,50]$ dimenzija te izračunajte prosječnu euklidsku udaljenost između svih parova tih vektora. Za generiranje slučajnih vektora koristite funkciju numpy.random.random. Na istom grafu skicirajte krivulje prosječnih udaljenosti za euklidsku i kosinusnu udaljenost (parametar metric).
Can you write Python code for it?

from sklearn.metrics.pairwise import pairwise_distances
from numpy.random import random

# Vaš kôd ovdje


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
Q: Kako $k$ utječe na izgled granice između klasa?
Q: Kako se algoritam ponaša u ekstremnim situacijama: $k=1$ i $k=100$?
(b)
Pomoću funkcije mlutils.knn_eval, iscrtajte pogreške učenja i ispitivanja kao funkcije hiperparametra $k\in{1,\dots,20}$, za $N={100, 500, 1000, 3000}$ primjera. Načinite 4 zasebna grafikona (generirajte ih u 2x2 polju). U svakoj iteraciji ispišite optimalnu vrijednost hiperparametra $k$ (najlakše kao naslov grafikona; vidi plt.title).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
Q: Kako radi ovo skaliranje?

Q: Dobiveni histogrami su vrlo slični. U čemu je razlika?

(c)
Proučite razred preprocessing.StandardScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane standardnim skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler

x0b = StandardScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = StandardScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(12, 4))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB03-SVM-i-kNN-checkpoint.ipynb".
The first task is:
Q: Kako stršeća vrijednost utječe na SVM?
Q: Kako se linearan SVM nosi s linearno neodvojivim skupom podataka?
2. Nelinearan SVM
Ovaj zadatak pokazat će kako odabir jezgre utječe na kapacitet SVM-a. Na skupu unsep iz prošlog zadatka trenirajte tri modela SVM-a s različitim jezgrenim funkcijama: linearnom, polinomijalnom i radijalnom baznom (RBF) funkcijom. Varirajte hiperparametar $C$ po vrijednostima $C\in{10^{-2},1,10^2}$, dok za ostale hiperparametre (stupanj polinoma za polinomijalnu jezgru odnosno hiperparametar $\gamma$ za jezgru RBF) koristite podrazumijevane vrijednosti. Prikažite granice između klasa (i margine) na grafikonu organiziranome u polje $3x3$, gdje su stupci različite jezgre, a retci različite vrijednosti parametra $C$.
Can you write Python code for it?

C = [10**(-2), 1, 10**2]
jezgra = ['linear', 'poly', 'rbf']
k = 1

figure(figsize(12, 10))
subplots_adjust(wspace=0.1, hspace = 0.2)

for i in C:
    for j in jezgra:

        uns = SVC(C = i, kernel = j, gamma='scale').fit(unsep_X, unsep_y)
        h = uns.predict

        subplot(3,3,k)
        mlutils.plot_2d_svc_problem(unsep_X, unsep_y, uns)
        title(str(i) + ', ' + j);

        k+=1


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
(a)
Boosting, kao vrsta ansambla, također se temelji na kombinaciji više klasifikatora s ciljem boljih prediktivnih sposobnosti. Međutim, ono što ovakav tip ansambla čini zanimljivim jest to da za osnovni klasifikator traži slabi klasifikator (engl. weak classifier), odnosno klasifikator koji radi tek malo bolje od nasumičnog pogađanja. Često korišteni klasifikator za tu svrhu jest panj odluke (engl. decision stump), koji radi predikciju na temelju samo jedne značajke ulaznih primjera. Panj odluke specijalizacija je stabla odluke (engl. decision tree) koje smo već spomenuli. Panj odluke stablo je dubine 1. Stabla odluke implementirana su u razredu tree.DecisionTreeClassifier.
Radi ilustracije, naučite ansambl (AdaBoost) koristeći panj odluke kao osnovni klasifikator, ali pritom isprobavajući različit broj klasifikatora u ansamblu iz skupa $L \in {1, 2, 3, 50}$. Prikažite decizijske granice na danom skupu podataka za svaku od vrijednosti korištenjem pomoćne funkcije mlutils.plot_2d_clf_problem.
NB: Još jedan dokaz da hrvatska terminologija zaista može biti smiješna. :)
Can you write Python code for it?

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
(b)
Prikažite funkciju $\mathcal{L}(\mu|N,m)$ za (1) $N=10$ i $m=1,2,5,9$ te za (2) $N=100$ i $m=1,10,50,90$ (dva zasebna grafikona).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
(b)
Uvjerite se da Vaša implementacija radi jednako onoj u razredu ensemble.VotingClassifier, i to pri oba načina glasovanja (parametar voting). Parametar weights ostavite na pretpostavljenoj vrijednosti. Za ovu provjeru koristite tri klasifikatora logističke regresije s različitom stopom regularizacije i brojem iteracija. Koristite skup podataka dan u nastavku. Ekvivalentnost implementacije najlakše je provjeriti usporedbom izlaza funkcije predict (kod prebrojavanja) i funkcije predict_proba (kod usrednjavanja).
NB: Ne koristimo SVM jer njegova ugrađena (probabilistička) implementacija nije posve deterministička, što bi onemogućilo robusnu provjeru Vaše implementacije.
Can you write Python code for it?

from sklearn.datasets import make_classification
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression

X_voting, y_voting = make_classification(n_samples=1000, n_features=4, n_redundant=0, n_informative=3, n_classes=3, n_clusters_per_class=2)

Logisticka1 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 1, max_iter = 1000).fit(X_voting, y_voting)
Logisticka2 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 100, max_iter = 1000).fit(X_voting, y_voting)
Logisticka3 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 1000, max_iter = 1000).fit(X_voting, y_voting)

clfs = [Logisticka1, Logisticka2, Logisticka3]

moj = VotingClassifierDIY(clfs = clfs)
njihov = VotingClassifier(estimators= [('lr1', Logisticka1), ('lr2', Logisticka2), ('lr3', Logisticka3)])

a = moj.fit(X_voting, y_voting)
a = njihov.fit(X_voting, y_voting)

moj.voting_scheme = moj.SCHEME_COUNTING
print(moj.voting_scheme)
njihov.voting = 'hard'

print(moj.predict(X_voting))
print(njihov.predict(X_voting).all())

moj.voting_scheme = moj.SCHEME_AVERAGING
njihov.voting = 'soft'

print(moj.predict_proba(X_voting) == njihov.predict_proba(X_voting).all)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
(i)
Izračunajte ML-procjene za $(\mu, \sigma^2)$ za svaku od $n=4$ značajki iz skupa Iris. Ispišite log-izglednosti tih ML-procjena.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
(k)
Proučite funkciju cov te izračunajte ML-procjenu za kovarijacijsku matricu za skup Iris. Usporedite pristranu i nepristranu procjenu. Pokažite da se razlika (srednja apsolutna i kvadratna) smanjuje s brojem primjera (npr. isprobajte za $N/4$ i $N/2$ i $N$ primjera).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
1. Ansambli (glasovanje)
(a)
Vaš je zadatak napisati razred VotingClassifierDIY koji implementira glasački ansambl. Konstruktor razreda ima dva parametra: clfs koji predstavlja listu klasifikatora (objekata iz paketa sklearn) i voting_scheme koji označava radi li se o glasovanju prebrojavanjem (SCHEME_COUNTING) ili usrednjavanjem (SCHEME_AVERAGING). Glasovanje prebrojavanjem jednostavno vraća najčešću oznaku klase, dok glasovanje usrednjavanjem uprosječuje pouzdanosti klasifikacije u neku klasu (po svim klasifikatorima) te vraća onu s najvećom pouzdanošću. Primijetite da svi klasifikatori imaju jednake težine. O komplementarnosti klasifikatora vodimo računa tako da koristimo jednake klasifikatore s različitim hiperparametrima.
Razred sadržava metode fit(X, y) za učenje ansambla i dvije metode za predikciju: predict(X) i predict_proba(X). Prva vraća predviđene oznake klasa, a druga vjerojatnosti pripadanja svakoj od klasa za svaki od danih primjera iz X.
NB: Jedan od razreda koji bi Vam mogao biti koristan jest collections.Counter. Također vrijedi i za funkcije numpy.argmax i numpy.dstack.
Can you write Python code for it?

from collections import Counter

class VotingClassifierDIY(object):

    SCHEME_COUNTING = "counting"
    SCHEME_AVERAGING = "averaging"

    def __init__(self, clfs, voting_scheme=SCHEME_COUNTING):
        self.clfs = clfs
        self.voting_scheme = voting_scheme

    def fit(self, X, y):
        [ clf.fit(X,y) for clf in self.clfs ]

    def predict_proba(self, X):
        if self.voting_scheme == self.SCHEME_AVERAGING:
            pred = [ clf.predict_proba(X) for clf in self.clfs ]

            pred_avg = []
            for i in range(0, len(pred[0])):
                prob = [ p[i] for p in pred ]
                pred_avg.append(mean(prod, axis = 0))

            return pred_avg
        else:
            raise Exception("Nemoze")

    def predict(self, X):
        if self.voting_scheme == self.SCHEME_COUNTING:
            pred_cnt = []; pred = []; predd = [];

            for i in range(0, len(self.clfs)):
                predd.append(self.clfs[i].predict(X))

            for i in range(0, shape(predd)[1]): # 0 - 1000
                for j in range(0, len(predd)): # 0 - 3
                    pred.append(predd[j][i])

            for i in range(0, len(pred), 3):
                pred_cnt.append((Counter(pred[i:i+3]).most_common()[0])[0])

            return pred_cnt

        elif self.voting_scheme == self.SCHEME_AVERAGING:
            avg = self.predict_proba(X)
            pred_avg = []
            for i in range(0, len(avg)):
                pred_avg.append(argmax(avg[i]))

            return pred_avg


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Isplati li se koristiti ansambl u obliku boostinga? Idu li grafikoni tome u prilog?<br>
Q: Koja je prednost boostinga nad korištenjem jednog jakog klasifikatora?
4. Procjena maksimalne izglednosti i procjena maksimalne aposteriorne vjerojatnosti
(a)
Definirajte funkciju izglednosti $\mathcal{L}(\mu|\mathcal{D})$ za skup $\mathcal{D}={x^{(i)}}_{i=1}^N$ Bernoullijevih varijabli. Neka od $N$ varijabli njih $m$ ima vrijednost 1 (npr. od $N$ bacanja novčića, $m$ puta smo dobili glavu). Definirajte funkciju izglednosti tako da je parametrizirana s $N$ i $m$, dakle definirajte funkciju $\mathcal{L}(\mu|N,m)$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Kako AdaBoost radi? Ovise li izlazi pojedinih osnovnih modela o onima drugih?
Q: Je li AdaBoost linearan klasifikator? Pojasnite.
(b)
Kao što je i za očekivati, broj klasifikatora $L$ u ansamblu predstavlja hiperparametar algoritma AdaBoost. U ovom zadatku proučit ćete kako on utječe na generalizacijsku sposobnost Vašeg ansambla. Ponovno, koristite panj odluke kao osnovni klasifikator.
Poslužite se skupom podataka koji je dan niže.
Can you write Python code for it?

from sklearn.cross_validation import train_test_split

X_boost, y_boost = make_classification(n_samples=1000, n_features=20, n_redundant=0, n_informative=18, n_classes=3, n_clusters_per_class=1)
X_boost_train, X_boost_test, y_boost_train, y_boost_test = train_test_split(X_boost, y_boost, train_size=0.7, random_state=69)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Koja vrijednost odgovara ML-procjenama i zašto?
(c)
Prikažite funkciju $\mathcal{L}(\mu|N,m)$ za $N=10$ i $m={0,9}$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Koje vrijednosti odgovaraju MAP-procjeni za $\mu$? Usporedite ih sa ML-procjenama.
(f)
Za $N=10$ i $m=1$, na jednome grafikonu prikažite sve tri distribucije: $P(\mu,\mathcal{D})$, $P(\mu|\alpha,\beta)$ i $\mathcal{L}(\mu|\mathcal{D})$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Može li uopće doći do prenaučenosti pri korištenju boosting-algoritama?
(c)
Kao što je rečeno na početku, boosting-algoritmi traže slabe klasifikatore kako bi bili najefikasniji što mogu biti. Međutim, kako se takav ansambl mjeri s jednim jakim klasifikatorom (engl. strong classifier)? To ćemo isprobati na istom primjeru, ali korištenjem jednog optimalno naučenog stabla odluke.
Ispišite pogrešku ispitivanja optimalnog stabla odluke. Glavni hiperparametar stabala odluka jest njihova maksimalna dubina $d$ (parametar max_depth). Iscrtajte krivulje pogrešaka na skupu za učenje i ispitivanje u ovisnosti o dubini stabla $d \in [1,20]$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Možete li, na temelju dobivenih log-izglednosti, zaključiti koja se značajka najbolje pokorava normalnoj distribuciji?
(j)
Proučite funkciju pearsonr za izračun Pearsonovog koeficijenta korelacije. Izračunajte koeficijente korelacije između svih četiri značajki u skupu Iris.
Can you write Python code for it?

from scipy.stats import pearsonr

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Q: Što možete zaključiti iz ovih grafikona?
Q: Kako bagging postiže diverzifikaciju pojedinačnih osnovnih modela?
Q: Koristi li ovaj algoritam složeni ili jednostavni osnovni model? Zašto?
3. Ansambli (boosting)
U ovom zadatku pogledat ćemo klasifikacijski algoritam AdaBoost, koji je implementiran u razredu ensemble.AdaBoostClassifier. Ovaj algoritam tipičan je predstavnik boosting-algoritama.
Najprije ćemo generirati eksperimentalni skup podataka koristeći datasets.make_circles. Ova funkcija stvara dvodimenzijski klasifikacijski problem u kojem su dva razreda podataka raspoređena u obliku kružnica, tako da je jedan razred unutar drugog.
Can you write Python code for it?

from sklearn.datasets import make_circles

circ_X, circ_y = make_circles(n_samples=400, noise=0.1, factor=0.4)
mlutils.plot_2d_clf_problem(circ_X, circ_y)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Razred koji implementira stablo odluke jest tree.DecisionTreeClassifier. Prvo naučite stablo odluke (engl. decision tree) na skupu za učenje, ali tako da je taj model presložen. To možete postići tako da povećate najveću moguću dubinu stabla (parametar max_depth). Ispišite pogrešku na skupu za ispitivanje (pogrešku 0-1; pogledajte paket metrics).
Can you write Python code for it?

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import zero_one_loss

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB04-Ansambli-i-procjena-parametara-checkpoint.ipynb".
The first task is:
Sada isprobajte algoritam slučajnih šuma (dostupan u razredu ensemble.RandomForestClassifier) za različit broj stabala $L \in [1, 30]$. Iscrtajte pogrešku na skupu za učenje i na skupu za ispitivanje u ovisnosti o tom hiperparametru. Ispišite najmanju pogrešku na skupu za ispitivanje.
Can you write Python code for it?

from sklearn.ensemble import RandomForestClassifier

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
(b)
U prošlom smo podzadatku ispisali točnost našeg modela. Ako želimo vidjeti koliko je naš model dobar po ostalim metrikama, možemo iskoristiti bilo koju funkciju iz paketa metrics. Poslužite se funkcijom metrics.classification_report, koja ispisuje vrijednosti najčešćih metrika. (Obavezno koristite naredbu print kako ne biste izgubili format izlaza funkcije.) Ispišite ponovno točnost za usporedbu.
Can you write Python code for it?

from sklearn.metrics import classification_report, accuracy_score

print(classification_report(y_pred=pipeline.predict(spam_X_test), y_true=spam_y_test))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
(g)
Kako vrednovati točnost modela grupiranja ako imamo stvarne oznake svih primjera (a u našem slučaju imamo, jer smo mi ti koji smo generirali podatke)? Često korištena mjera jest Randov indeks koji je zapravo pandan točnosti u zadatcima klasifikacije. Implementirajte funkciju rand_index_score(y_gold, y_predict) koja ga računa. Funkcija prima dva argumenta: listu stvarnih grupa kojima primjeri pripadaju (y_gold) i listu predviđenih grupa (y_predict). Dobro će vam doći funkcija itertools.combinations.
Can you write Python code for it?

import itertools as it
from scipy.special import comb

def rand_index_score2(y_gold, y_predict):
    N = len(y_gold)
    grupa1 = ([ y for i, y in enumerate(y_gold) if y_predict[i] == 0])
    grupa2 = ([ y for i, y in enumerate(y_gold) if y_predict[i] == 1])
    grupa3 = ([ y for i, y in enumerate(y_gold) if y_predict[i] == 2])

    n = [[len([y for y in g if y == i])
            for i in [0,1,2]]
            for g in [grupa1, grupa2, grupa3]]

    a = sum([(comb(nnn, 2)) for nn in n for nnn in nn])

    b = n[0][0] * (n[1][1] + n[1][2] + n[2][1] + n[2][2]) + \
        n[0][1] * (n[1][0] + n[1][2] + n[2][0] + n[2][2]) + \
        n[0][2] * (n[1][0] + n[1][1] + n[2][0] + n[2][1]) + \
        n[1][0] * (n[2][1] + n[2][2]) + \
        n[1][1] * (n[2][0] + n[2][2]) + \
        n[1][2] * (n[2][0] + n[2][1])

    return (a+b) / comb(N,2)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
1. Probabilistički grafički modeli -- Bayesove mreže
Ovaj zadatak bavit će se Bayesovim mrežama, jednim od poznatijih probabilističkih grafičkih modela (probabilistic graphical models; PGM). Za lakše eksperimentiranje koristit ćemo programski paket pgmpy. Molimo Vas da provjerite imate li ovaj paket te da ga instalirate ako ga nemate.
(a)
Prvo ćemo pogledati udžbenički primjer s prskalicom. U ovom primjeru razmatramo Bayesovu mrežu koja modelira zavisnosti između oblačnosti (slučajna varijabla $C$), kiše ($R$), prskalice ($S$) i mokre trave ($W$). U ovom primjeru također pretpostavljamo da već imamo parametre vjerojatnosnih distribucija svih čvorova. Ova mreža prikazana je na sljedećoj slici:

Koristeći paket pgmpy, konstruirajte Bayesovu mrežu iz gornjeg primjera. Zatim, koristeći egzaktno zaključivanje, postavite sljedeće posteriorne upite: $P(w=1)$, $P(s=1|w=1)$, $P(r=1|w=1)$, $P(c=1|s=1, r=1)$ i $P(c=1)$. Provedite zaključivanje na papiru i uvjerite se da ste ispravno konstruirali mrežu. Pomoći će vam službena dokumentacija te primjeri korištenja (npr. ovaj).
Can you write Python code for it?

from pgmpy.models import BayesianModel
from pgmpy.factors.discrete.CPD import TabularCPD
from pgmpy.inference import VariableElimination

model = BayesianModel([('C', 'S'), ('C', 'R'), ('S', 'W'), ('R', 'W')])

cpd_c = TabularCPD(variable='C', variable_card=2, values=[[0.5, 0.5]])
cpd_s = TabularCPD(variable='S', evidence=['C'], evidence_card=[2],
                   variable_card=2,
                   values=[[0.9, 0.5],
                           [0.1, 0.5]])
cpd_r = TabularCPD(variable='R', evidence=['C'], evidence_card=[2],
                   variable_card=2,
                   values=[[0.2, 0.8],
                           [0.8, 0.2]])
cpd_w = TabularCPD(variable='W', evidence=['S', 'R'], evidence_card=[2,2],
                  variable_card=2,
                  values=[[1, 0.1, 0.1, 0.01],
                          [0, 0.9, 0.9, 0.99]])

model.add_cpds(cpd_c, cpd_r, cpd_s, cpd_w)
model.check_model()

infer = VariableElimination(model)
print(infer.query(['W'])['W'])
print(infer.query(['S'], evidence={'W': 1})['S'])
print(infer.query(['R'], evidence={'W': 1})['R'])
print(infer.query(['C'], evidence={'S': 1, 'R': 1})['C'])
print(infer.query(['C'])['C'])


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Iskoristite skup podataka Xp dan gore. Isprobajte vrijednosti hiperparametra $K$ iz $[0,1,\ldots,15]$. Ne trebate dirati nikakve hiperparametre modela osim $K$. Iscrtajte krivulju od $J$ u ovisnosti o broju grupa $K$. Metodom lakta/koljena odredite vrijednost hiperparametra $K$.
Can you write Python code for it?

Ks = range(1,16)

from sklearn.cluster import KMeans

Js = []

for K in Ks:
    J = KMeans(n_clusters=K).fit(Xp).inertia_
    Js.append(J)

plot(Ks, Js)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Iskoristite ugrađenu funkciju scipy.stats.ttest_rel za provedbu uparenog t-testa i provjerite koji od ova modela je bolji kada se koristi 5, 10 i 50 preklopa.
Can you write Python code for it?

from scipy.stats import ttest_rel

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Naučite model k-sredina (idealno pretpostavljajući $K=2$) na gornjim podatcima i prikažite dobiveno grupiranje (proučite funkciju scatter, posebice argument c).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Ponovno, naučite model k-sredina (ovaj put idealno pretpostavljajući $K=3$) na gornjim podatcima i prikažite dobiveno grupiranje (proučite funkciju scatter, posebice argument c).
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Prvo, prilažemo kôd koji to radi "standardnim pristupom":
Can you write Python code for it?

# TF-IDF
vectorizer = TfidfVectorizer(stop_words="english", ngram_range=(1, 2), max_features=500)
spam_X_feat_train = vectorizer.fit_transform(spam_X_train)
# Smanjenje dimenzionalnosti
reducer = TruncatedSVD(n_components=300, random_state=69)
spam_X_feat_train = reducer.fit_transform(spam_X_feat_train)
# Normaliziranje
normalizer = Normalizer()
spam_X_feat_train = normalizer.fit_transform(spam_X_feat_train)
# NB
clf = LogisticRegression(solver='lbfgs')
clf.fit(spam_X_feat_train, spam_y_train)

# I sada ponovno sve ovo za testne podatke.
spam_X_feat_test = vectorizer.transform(spam_X_test)
spam_X_feat_test = reducer.transform(spam_X_feat_test)
spam_X_feat_test = normalizer.transform(spam_X_feat_test)

print(accuracy_score(spam_y_test, clf.predict(spam_X_feat_test)))

x_test123 = ["You were selected for a green card, apply here for only 50 USD!!!",
         "Hey, what are you doing later? Want to grab a cup of coffee?"]
x_test = vectorizer.transform(x_test123)
x_test = reducer.transform(x_test)
x_test = normalizer.transform(x_test)
print(clf.predict(x_test))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Kako biste se gledajući ove slike odlučili za $K$?
Q: Koji su problemi ovog pristupa?
(c)
U ovom i sljedećim podzadatcima fokusirat ćemo se na temeljne pretpostavke algoritma k-sredina te što se događa ako te pretpostavke nisu zadovoljene. Dodatno, isprobat ćemo i grupiranje modelom Gaussovih mješavina (engl. Gaussian Mixture Models; GMM) koji ne nema neke od tih pretpostavki.
Prvo, krenite od podataka X1, koji su generirani korištenjem funkcije datasets.make_blobs, koja stvara grupe podataka pomoću izotropskih Gaussovih distribucija.
Can you write Python code for it?

from sklearn.datasets import make_blobs

X1, y1 = make_blobs(n_samples=1000, n_features=2, centers=[[0, 0], [1.3, 1.3]], cluster_std=[0.15, 0.5], random_state=96)
plt.scatter(X1[:,0], X1[:,1], c=y1, cmap=plt.get_cmap("cool"), s=20)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Kako biste svojim riječima opisali ovaj fenomen, koristeći se ovim primjerom?
(c)
Koristeći BayesianModel.is_active_trail provjerite jesu li varijable oblačnosti ($C$) i mokre trave ($W$) uvjetno nezavisne. Što mora vrijediti kako bi te dvije varijable bile uvjetno nezavisne? Provjerite korištenjem iste funkcije.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Kako možemo na temelju grafa saznati koje dvije varijable su, uz neka opažanja, uvjetno nezavisne?
Q: Zašto bismo uopće htjeli znati koje su varijable u mreži uvjetno nezavisne?
2. Vrednovanje modela (klasifikatora)
Kako bismo se uvjerili koliko naš naučeni model zapravo dobro radi, nužno je provesti evaluaciju modela. Ovaj korak od presudne je važnosti u svim primjenama strojnog učenja, pa je stoga bitno znati provesti evaluaciju na ispravan način.
Vrednovat ćemo modele na stvarnom skupu podataka SMS Spam Collection [1], koji se sastoji od 5,574 SMS-poruka klasificiranih u dvije klase: spam (oznaka: spam) i ne-spam (oznaka: ham). Ako već niste, preuzmite skup podataka s poveznice ili sa stranice kolegija i stavite ga u radni direktorij (otpakirajte arhivu i preimenujte datoteku u spam.csv po potrebi). Sljedeći komad kôda učitava skup podataka i dijeli ga na podskupove za učenje i testiranje.
[1] Almeida, T.A., GÃmez Hidalgo, J.M., Yamakami, A. Contributions to the Study of SMS Spam Filtering: New Collection and Results. Proceedings of the 2011 ACM Symposium on Document Engineering (DOCENG'11), Mountain View, CA, USA, 2011.
Can you write Python code for it?

from sklearn.model_selection import train_test_split
spam_X, spam_y = mlutils.load_SMS_dataset('./spam.csv')

spam_X_train, spam_X_test, spam_y_train, spam_y_test = \
    train_test_split(spam_X, spam_y, train_size=0.7, test_size=0.3, random_state=69)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Koju biste vrijednost hiperparametra $K$ izabrali na temelju ovog grafa? Zašto? Je li taj odabir optimalan? Kako to znate?
Q: Je li ova metoda robusna?
Q: Možemo li izabrati onaj $K$ koji minimizira pogrešku $J$? Objasnite.
(b)
Odabir vrijednosti hiperparametra $K$ može se obaviti na mnoštvo načina. Pored metode lakta/koljena, moguće je isto ostvariti i analizom siluete (engl. silhouette analysis). Za to smo pripremili funkciju mlutils.plot_silhouette koja za dani broj grupa i podatke iscrtava prosječnu vrijednost koeficijenta siluete i vrijednost koeficijenta svakog primjera (kroz grupe).
Vaš je zadatak isprobati različite vrijednosti hiperparametra $K$, $K \in {2, 3, 5}$ i na temelju dobivenih grafova odlučiti se za optimalan $K$.
Can you write Python code for it?


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Koju hipotezu $H_0$ i alternativnu hipotezu $H_1$ testiramo ovim testom?
Q: Koja pretpostavka na vjerojatnosnu razdiobu primjera je napravljena u gornjem testu? Je li ona opravdana?
Q: Koji je model u konačnici bolji i je li ta prednost značajna uz $\alpha = 0.05$?
3. Grupiranje
U ovom zadatku ćete se upoznati s algoritmom k-sredina (engl. k-means), njegovim glavnim nedostatcima te pretpostavkama. Također ćete isprobati i drugi algoritam grupiranja: model Gaussovih mješavina (engl. Gaussian mixture model).
(a)
Jedan od nedostataka algoritma k-sredina jest taj što unaprijed zahtjeva broj grupa ($K$) u koje će grupirati podatke. Ta informacija nam često nije dostupna (kao što nam nisu dostupne ni oznake primjera) te je stoga potrebno nekako izabrati najbolju vrijednost hiperparametra $K$. Jedan od naivnijih pristupa jest metoda lakta/koljena (engl. elbow method) koju ćete isprobati u ovom zadatku.
U svojim rješenjima koristite ugrađenu implementaciju algoritma k-sredina, dostupnoj u razredu cluster.KMeans.
NB: Kriterijska funkcija algoritma k-sredina još se i naziva inercijom (engl. inertia). Za naučeni model, vrijednost kriterijske funkcije $J$ dostupna je kroz razredni atribut inertia_.
Can you write Python code for it?

from sklearn.datasets import make_blobs

Xp, yp = make_blobs(n_samples=300, n_features=2, centers=[[0, 0], [3, 2.5], [0, 4]],
                    cluster_std=[0.45, 0.3, 0.45], random_state=96)
plt.scatter(Xp[:,0], Xp[:,1], c=yp, cmap=plt.get_cmap("cool"), s=20)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Koju zajedničku vjerojatnosnu razdiobu ova mreža modelira? Kako tu informaciju očitati iz mreže?
Q: U zadatku koristimo egzaktno zaključivanje. Kako ono radi?
Q: Koja je razlika između posteriornog upita i MAP-upita?
Q: Zašto je vjerojatnost $P(c=1)$ drugačija od $P(c=1|s=1,r=1)$ ako znamo da čvorovi $S$ i $R$ nisu roditelji čvora $C$?
(b)
Efekt objašnjavanja (engl. explaining away) zanimljiv je fenomen u kojem se događa da se dvije varijable "natječu" za objašnjavanje treće. Ovaj fenomen može se primijetiti na gornjoj mreži. U tom se slučaju varijable prskalice ($S$) i kiše ($R$) "natječu" za objašnjavanje mokre trave ($W$). Vaš zadatak je pokazati da se fenomen zaista događa.
Can you write Python code for it?

print(infer.query(['S'], evidence={'W': 1, 'R': 1})['S'])
print(infer.query(['S'], evidence={'W': 1, 'R': 0})['S'])
print(infer.query(['R'], evidence={'W': 1, 'S': 1})['R'])
print(infer.query(['R'], evidence={'W': 1, 'S': 0})['R'])


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Na temelju ovog primjera objasnite zašto točnost nije uvijek prikladna metrika.
Q: Zašto koristimo F1-mjeru?
(c)
Međutim, provjera za kakvom smo posegli u prošlom podzadatku nije robusna. Stoga se u strojnom učenju obično koristi k-struka unakrsna provjera. Proučite razred model_selection.KFold i funkciju model_selection.cross_val_score te izračunajte procjenu pogreške na cijelom skupu podataka koristeći peterostruku unakrsnu provjeru.
NB: Vaš model je sada cjevovod koji sadrži čitavo pretprocesiranje. Također, u nastavku ćemo se ograničiti na točnost, ali ovi postupci vrijede za sve metrike.
Can you write Python code for it?

from sklearn.model_selection import cross_val_score, KFold

kf = KFold(n_splits=5)

vectorizer = TfidfVectorizer(stop_words="english", ngram_range=(1, 2), max_features=500)
reducer = TruncatedSVD(n_components=300, random_state=69)
normalizer = Normalizer()
clf = LogisticRegression(solver='lbfgs')

pipeline = Pipeline([('vectorizer', vectorizer), ('reducer', reducer), ('normalizer', normalizer), ('clf', clf)])

for train_index, test_index in kf.split(spam_X):
    X_train, X_test = spam_X[train_index], spam_X[test_index]
    y_train, y_test = spam_y[train_index], spam_y[test_index]

    pipeline.fit(X_train, y_train)

    print()
    print(cross_val_score(estimator=pipeline, X=X_test, y=y_test, cv=5))
    print(accuracy_score(spam_y_test, pipeline.predict(spam_X_test)))


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Zašto "obična" unakrsna provjera nije dovoljno robusna?
Q: Što je to stratificirana k-struka unakrsna provjera? Zašto ju često koristimo?
(d)
Gornja procjena pogreške je u redu ako imamo već imamo model (bez ili s fiksiranim hiperparametrima). Međutim, mi želimo koristiti model koji ima optimalne vrijednosti hiperparametara te ih je stoga potrebno optimirati korištenjem pretraživanja po rešetci (engl. grid search). Očekivano, biblioteka scikit-learn već ima ovu funkcionalnost u razredu model_selection.GridSearchCV. Jedina razlika vaše implementacije iz prošlih vježbi (npr. kod SVM-a) i ove jest ta da ova koristi k-struku unakrsnu provjeru.
Prije optimizacije vrijednosti hiperparametara, očigledno moramo definirati i samu rešetku vrijednosti hiperparametara. Proučite kako se definira ista kroz rječnik u primjeru.
Proučite spomenuti razred te pomoću njega pronađite i ispišite najbolje vrijednosti hiperparametara cjevovoda iz podzadatka (a): max_features $\in {500, 1000}$ i n_components $\in { 100, 200, 300 }$ korištenjem pretraživanja po rešetci na skupu za učenje ($k=3$, kako bi išlo malo brže).
Can you write Python code for it?

from sklearn.model_selection import GridSearchCV

# Vaš kôd ovdje...


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Što se dogodilo? Koja je pretpostavka algoritma k-sredina ovdje narušena?
Q: Što biste morali osigurati kako bi algoritam pronašao ispravne grupe?
(d)
Isprobajte algoritam k-sredina na podatcima generiranim korištenjem funkcije datasets.make_circles, koja stvara dvije grupe podataka tako da je jedna unutar druge.
Can you write Python code for it?

from sklearn.datasets import make_circles

X2, y2 = make_circles(n_samples=1000, noise=0.15, factor=0.05, random_state=96)
plt.scatter(X2[:,0], X2[:,1], c=y2, cmap=plt.get_cmap("cool"), s=20)


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Q: Što se dogodilo? Koja je pretpostavka algoritma k-sredina ovdje narušena?
Q: Što biste morali osigurati kako bi algoritam pronašao ispravne grupe?
(e)
Završno, isprobat ćemo algoritam na sljedećem umjetno stvorenom skupu podataka:
Can you write Python code for it?

X31, y31 = make_blobs(n_samples=1000, n_features=2, centers=[[0, 0]], cluster_std=[0.2], random_state=69)
X32, y32 = make_blobs(n_samples=50, n_features=2, centers=[[0.7, 0.5]], cluster_std=[0.15], random_state=69)
X33, y33 = make_blobs(n_samples=600, n_features=2, centers=[[0.8, -0.4]], cluster_std=[0.2], random_state=69)
plt.scatter(X31[:,0], X31[:,1], c="#00FFFF", s=20)
plt.scatter(X32[:,0], X32[:,1], c="#F400F4", s=20)
plt.scatter(X33[:,0], X33[:,1], c="#8975FF", s=20)

# Just join all the groups in a single X.
X3 = np.vstack([X31, X32, X33])
y3 = np.hstack([y31, y32, y33])


I am working on the file "STRUCE/2018/.ipynb_checkpoints/SU-2018-LAB05-0036477171-checkpoint.ipynb".
The first task is:
Vaš zadatak izvesti je dani kôd korištenjem cjevovoda. Proučite razred pipeline.Pipeline.
NB Ne treba vam više od svega nekoliko naredbi.
Can you write Python code for it?

vectorizer = TfidfVectorizer(stop_words="english", ngram_range=(1, 2), max_features=500)
reducer = TruncatedSVD(n_components=300, random_state=69)
normalizer = Normalizer()
clf = LogisticRegression(solver='lbfgs')

pipeline = Pipeline([('vectorizer', vectorizer), ('reducer', reducer), ('normalizer', normalizer), ('clf', clf)])

pipeline.fit(spam_X_train, spam_y_train)
print(accuracy_score(spam_y_test, pipeline.predict(spam_X_test)))
print(pipeline.predict(x_test123))


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(a)
Za ovaj zadatak upotrijebite skup za učenje i skup za testiranje iz zadatka 3b. Trenirajte modele L2-regularizirane polinomijalne regresije stupnja $d=20$, mijenjajući hiperparametar $\lambda$ u rasponu ${1,2,\dots,100}$. Za svaki od treniranih modela izračunajte L{0,1,2}-norme vektora težina $\mathbf{w}$ te ih prikažite kao funkciju od $\lambda$.
Q: Objasnite oblik obiju krivulja. Hoće li krivulja za $\|\mathbf{w}\|_2$ doseći nulu? Zašto? Je li to problem? Zašto?
Q: Za $\lambda=100$, koliki je postotak težina modela jednak nuli, odnosno koliko je model rijedak?
Can you write Python code for it?

from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso

lambda6a = range(1,100)
d6a = 20
X6a_train, X6a_test, y6a_train, y6a_test = train_test_split(x6a, y6a, test_size = 0.5)
Phi6a_train = PolynomialFeatures(d6a).fit_transform(X6a_train.reshape(-1,1))

L0 = [];
L1 = [];
L2 = [];

L1_norm = lambda w: sum(abs(w));
L2_norm = lambda w: math.sqrt(np.dot(w.T, w));

for i in lambda6a:
    w6a = np.dot(np.dot(np.linalg.inv(np.dot(Phi6a_train.T, Phi6a_train) + np.dot(i, np.eye(d6a+1))), Phi6a_train.T), y6a_train);

    L0.append(nonzeroes(w6a))
    L1.append(L1_norm(w6a))
    L2.append(L2_norm(w6a))

plot(lambda6a, L0, lambda6a, L1, lambda6a, L2, linewidth = 1)
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(b)
Glavna prednost L1-regularizirane regresije (ili LASSO regression) nad L2-regulariziranom regresijom jest u tome što L1-regularizirana regresija rezultira rijetkim modelima (engl. sparse models), odnosno modelima kod kojih su mnoge težine pritegnute na nulu. Pokažite da je to doista tako, ponovivši gornji eksperiment s L1-regulariziranom regresijom, implementiranom u klasi  Lasso u modulu sklearn.linear_model.
Can you write Python code for it?

L0 = [];
L1 = [];
L2 = [];

for i in lambda6a:
    lass = Lasso(alpha = i, tol = 0.115).fit(Phi6a_train, y6a_train)
    w6b = lass.coef_

    L0.append(nonzeroes(w6b))
    L1.append(L1_norm(w6b))
    L2.append(L2_norm(w6b))

plot(lambda6a, L0, lambda6a, L1, lambda6a, L2, linewidth = 1)
legend(['L0', 'L1', 'L2'], loc = 'best')
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(b)
Kao u zadataku 3b, razdvojite primjere na skup za učenje i skup za ispitivanje u omjeru 1:1. Prikažite krivulje logaritama pogreške učenja i ispitne pogreške u ovisnosti za model $\mathcal{H}_{d=20,\lambda}$, podešavajući faktor regularizacije $\lambda$ u rasponu $\lambda\in{0,1,\dots,50}$.
Q: Kojoj strani na grafikonu odgovara područje prenaučenosti, a kojoj podnaučenosti? Zašto?
Q: Koju biste vrijednosti za $\lambda$ izabrali na temelju ovih grafikona i zašto?
Can you write Python code for it?

X5a_train, X5a_test, y5a_train, y5a_test = train_test_split(x5a, y5a, test_size = 0.5)
err5a_train = [];
err5a_test = [];
d = 20;
lambda5a = range(0, 50)

for i in lambda5a:
    Phi5a_train = PolynomialFeatures(d).fit_transform(X5a_train.reshape(-1, 1))
    Phi5a_test = PolynomialFeatures(d).fit_transform(X5a_test.reshape(-1, 1))
    w5a_train = np.dot(np.dot(np.linalg.inv(np.dot(Phi5a_train.T, Phi5a_train) + np.dot(i, np.eye(d+1))), Phi5a_train.T), y5a_train);
    h5a_train = np.dot(Phi5a_train, w5a_train)
    h5a_test = np.dot(Phi5a_test, w5a_train)

    err5a_train.insert(i, np.log(mean_squared_error(y5a_train, h5a_train)))
    err5a_test.insert(i, np.log(mean_squared_error(y5a_test, h5a_test)))

plt.figure(figsize=(8,4))
plt.plot(lambda5a, err5a_train, lambda5a, err5a_test);
plt.grid(), plt.xlabel('$\lambda$'), plt.ylabel('err');
plt.legend(['ucenje', 'ispitna'], loc='best');


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(b)
Proučite klasu Ridge iz modula sklearn.linear_model, koja implementira L2-regularizirani regresijski model. Parametar $\alpha$ odgovara parametru $\lambda$. Primijenite model na istim primjerima kao u prethodnom zadatku i ispišite težine $\mathbf{w}$ (atributi coef_ i intercept_).
Q: Jesu li težine identične onima iz zadatka 4a? Ako nisu, objasnite zašto je to tako i kako biste to popravili.
Can you write Python code for it?

from sklearn.linear_model import Ridge

for i in lam:
    w = [];
    w_L22 = Ridge(alpha = i).fit(Phi4a, y)

    w.append(w_L22.intercept_)
    for i in range(0, len(w_L22.coef_[1:])):
        w.append(w_L22.coef_[i])

    print (w)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(b)
Razdvojite skup primjera iz zadatka 2 pomoću funkcije cross_validation.train_test_split na skup za učenja i skup za ispitivanje u omjeru 1:1. Prikažite na jednom grafikonu pogrešku učenja i ispitnu pogrešku za modele polinomijalne regresije $\mathcal{H}_d$, sa stupnjem polinoma $d$ u rasponu $d\in [1,2,\ldots,20]$. Radi preciznosti, funkcije $h(\mathbf{x})$ iscrtajte na cijelom skupu primjera (ali pogrešku generalizacije računajte, naravno, samo na ispitnome skupu). Budući da kvadratna pogreška brzo raste za veće stupnjeve polinoma, umjesto da iscrtate izravno iznose pogrešaka, iscrtajte njihove logaritme.
NB: Podjela na skupa za učenje i skup za ispitivanje mora za svih pet modela biti identična.
Q: Je li rezultat u skladu s očekivanjima? Koji biste model odabrali i zašto?
Q: Pokrenite iscrtavanje više puta. U čemu je problem? Bi li problem bio jednako izražen kad bismo imali više primjera? Zašto?
Can you write Python code for it?

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.5)
err_train = [];
err_test = [];
d = range(0, 20)

for i in d:
    Phi_train = PolynomialFeatures(i).fit_transform(X_train.reshape(-1, 1))
    Phi_test = PolynomialFeatures(i).fit_transform(X_test.reshape(-1, 1))
    w_train = np.dot(np.linalg.pinv(Phi_train), y_train)
    h_train = np.dot(Phi_train, w_train)
    h_test = np.dot(Phi_test, w_train)

    err_train.insert(i, np.log(mean_squared_error(y_train, h_train)))
    err_test.insert(i, np.log(mean_squared_error(y_test, h_test)))

plt.figure(figsize=(10,5))
plt.plot(d, err_train, d, err_test)
plt.grid()


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(b)
Upoznajte se s modulom linalg. Izračunajte težine $\mathbf{w}$ modela linearne regresije kao $\mathbf{w}=(\mathbf{\Phi}^\intercal\mathbf{\Phi})^{-1}\mathbf{\Phi}^\intercal\mathbf{y}$. Zatim se uvjerite da isti rezultat možete dobiti izračunom pseudoinverza $\mathbf{\Phi}^+$ matrice dizajna, tj. $\mathbf{w}=\mathbf{\Phi}^+\mathbf{y}$, korištenjem funkcije pinv.
Can you write Python code for it?

from numpy import linalg

w = np.dot(np.dot(np.linalg.inv(np.dot(np.transpose(Phi), Phi)), np.transpose(Phi)), y)
print(w)

w2 = np.dot(np.linalg.pinv(Phi), y)
print(w2)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(c)
Točnost modela ovisi o (1) njegovoj složenosti (stupanj $d$ polinoma), (2) broju primjera $N$, i (3) količini šuma. Kako biste to analizirali, nacrtajte grafikone pogrešaka kao u 3b, ali za sve kombinacija broja primjera $N\in{100,200,1000}$ i količine šuma $\sigma\in{100,200,500}$ (ukupno 9 grafikona). Upotrijebite funkciju subplots kako biste pregledno posložili grafikone u tablicu $3\times 3$. Podatci se generiraju na isti način kao u zadatku 2.
NB: Pobrinite se da svi grafikoni budu generirani nad usporedivim skupovima podataka, na sljedeći način. Generirajte najprije svih 1000 primjera, podijelite ih na skupove za učenje i skupove za ispitivanje (dva skupa od po 500 primjera). Zatim i od skupa za učenje i od skupa za ispitivanje načinite tri različite verzije, svaka s drugačijom količinom šuma (ukupno 2x3=6 verzija podataka). Kako bi simulirali veličinu skupa podataka, od tih dobivenih 6 skupova podataka uzorkujte trećinu, dvije trećine i sve podatke. Time ste dobili 18 skupova podataka -- skup za učenje i za testiranje za svaki od devet grafova.
Q: Jesu li rezultati očekivani? Obrazložite.
Can you write Python code for it?

N2 = [100, 200, 1000];
sigma = [100, 200, 500];

X_train4c_temp = [];
X_test4c_temp = [];
y_train4c_temp = [];
y_test4c_temp = [];

x_tmp = np.linspace(-5, 5, 1000);
X_train, X_test = train_test_split(x_tmp, test_size = 0.5)

for i in range(0, 3):

    y_tmp_train = list(make_labels(X_train, fun, sigma[i]))
    y_tmp_test = list(make_labels(X_test, fun, sigma[i]))
    for j in range(0,3):
        X_train4c_temp.append(X_train[0:int(N2[j]/2)])
        X_test4c_temp.append(X_test[0:int(N2[j]/2)])
        y_train4c_temp.append(y_tmp_train[0:int(N2[j]/2)])
        y_test4c_temp.append(y_tmp_test[0:int(N2[j]/2)])

err_tr = [];
err_tst = [];

for i in range(0, 9):
    X_train4c = X_train4c_temp[i]
    X_test4c = X_test4c_temp[i]
    y_train4c = y_train4c_temp[i]
    y_test4c = y_test4c_temp[i]

    err_train4c = [];
    err_test4c = [];
    d4c = range(0, 20)

    for j in d4c:
        Phi_train4c = PolynomialFeatures(j).fit_transform(X_train4c.reshape(-1, 1))
        Phi_test4c = PolynomialFeatures(j).fit_transform(X_test4c.reshape(-1, 1))
        w_train4c = np.dot(np.linalg.pinv(Phi_train4c), y_train4c)
        h_train4c = np.dot(Phi_train4c, w_train4c)
        h_test4c = np.dot(Phi_test4c, w_train4c)
        err_train4c.insert(j, np.log(mean_squared_error(y_train4c, h_train4c)))
        err_test4c.insert(j, np.log(mean_squared_error(y_test4c, h_test4c)))

    err_tr.append(err_train4c);
    err_tst.append(err_test4c);

fig = plt.figure(figsize=(15, 10))
fig.subplots_adjust(wspace=0.2, hspace = 0.35)

Nn = [100, 200, 1000, 100, 200, 1000, 100, 200, 1000]
sgm = [100, 100, 100, 200, 200, 200, 500, 500, 500]

for i in range(0, 9):
    ax = fig.add_subplot(3, 3, i+1)
    plt.plot(d, err_tr[i], d, err_tst[i]); grid;
    ax.grid();


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(d)
Uvjerite se da za primjere iz $\mathcal{D}$ težine $\mathbf{w}$ ne možemo naći rješavanjem sustava $\mathbf{w}=\mathbf{\Phi}^{-1}\mathbf{y}$, već da nam doista treba pseudoinverz.
Q: Zašto je to slučaj? Bi li se problem mogao riješiti preslikavanjem primjera u višu dimenziju? Ako da, bi li to uvijek funkcioniralo, neovisno o skupu primjera $\mathcal{D}$? Pokažite na primjeru.
Can you write Python code for it?

try:
    np.dot(np.linalg.inv(Phi), y)
except LinAlgError as err:
    print(err)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
(e)
Proučite klasu LinearRegression iz modula sklearn.linear_model. Uvjerite se da su težine koje izračunava ta funkcija (dostupne pomoću atributa coef_ i intercept_) jednake onima koje ste izračunali gore. Izračunajte predikcije modela (metoda predict) i uvjerite se da je pogreška učenja identična onoj koju ste ranije izračunali.
Can you write Python code for it?

from sklearn.linear_model import LinearRegression

lr = LinearRegression().fit(Phi, y)

w2 = [lr.intercept_, lr.coef_[1]]
h2 = lr.predict(Phi)
error2 = mean_squared_error(y, h)

print ('staro: ')
print (w)
print (h)
print (error)

print('novo: ')
print (w2)
print (h2)
print (error2)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
2. Polinomijalna regresija i utjecaj šuma
(a)
Razmotrimo sada regresiju na većem broju primjera. Koristite funkciju make_labels(X, f, noise=0) koja uzima matricu neoznačenih primjera $\mathbf{X}{N\times n}$ te generira vektor njihovih oznaka $\mathbf{y}{N\times 1}$. Oznake se generiraju kao $y^{(i)} = f(x^{(i)})+\mathcal{N}(0,\sigma^2)$, gdje je $f:\mathbb{R}^n\to\mathbb{R}$ stvarna funkcija koja je generirala podatke (koja nam je u stvarnosti nepoznata), a $\sigma$ je standardna devijacija Gaussovog šuma, definirana parametrom noise. Za generiranje šuma koristi se funkcija numpy.random.normal.
Generirajte skup za učenje od $N=50$ primjera uniformno distribuiranih u intervalu $[-5,5]$ pomoću funkcije $f(x) = 5 + x -2 x^2 -5 x^3$ uz šum  $\sigma=200$:
Can you write Python code for it?

from numpy.random import normal
def make_labels(X, f, noise=0) :
    return map(lambda x : f(x) + (normal(0,noise) if noise>0 else 0), X)

def make_instances(x1, x2, N) :
    return sp.array([np.array([x]) for x in np.linspace(x1,x2,N)])

N = 50
sigma = 200
fun = lambda x :5 + x - 2*x**2 - 5*x**3
x = make_instances(-5, 5, N)
y = list(make_labels(x, fun, sigma))

y6a = y
x6a = x


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
3. Odabir modela
(a)
Na skupu podataka iz zadatka 2 trenirajte pet modela linearne regresije $\mathcal{H}_d$ različite složenosti, gdje je $d$ stupanj polinoma, $d\in{1,3,5,10,20}$. Prikažite na istome grafikonu skup za učenje i funkcije $h_d(\mathbf{x})$ za svih pet modela (preporučujemo koristiti plot unutar for petlje). Izračunajte pogrešku učenja svakog od modela.
Q: Koji model ima najmanju pogrešku učenja i zašto?
Can you write Python code for it?

Phi_d = [];
w_d = [];
h_d = [];
err_d = [];

d = [1, 3, 5, 10, 20]

for i in d:
    Phi_d.append(PolynomialFeatures(i).fit_transform(x.reshape(-1,1)))

for i in range(0, len(d)):
    w_d.insert(i, np.dot(np.linalg.pinv(Phi_d[i]), y))
    h_d.insert(i, np.dot(Phi_d[i], w_d[i]))

for i in range(0, len(d)):
    err_d.insert(i, mean_squared_error(y, h_d[i]))
    print (str(d[i]) + ': ' + str(err_d[i]))

fig = plt.figure(figsize=(15, 20))
fig.subplots_adjust(wspace=0.2)

for i in range(0, len(d)):
    ax = fig.add_subplot(5, 2, i+1)
    ax.scatter(x, y);
    ax.plot(x, h_d[i], 'r', linewidth = 1)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
4. Regularizirana regresija
(a)
U gornjim eksperimentima nismo koristili regularizaciju. Vratimo se najprije na primjer iz zadatka 1. Na primjerima iz tog zadatka izračunajte težine $\mathbf{w}$ za polinomijalni regresijski model stupnja $d=3$ uz L2-regularizaciju (tzv. ridge regression), prema izrazu $\mathbf{w}=(\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I})^{-1}\mathbf{\Phi}^\intercal\mathbf{y}$. Napravite izračun težina za regularizacijske faktore $\lambda=0$, $\lambda=1$ i $\lambda=10$ te usporedite dobivene težine.
Q: Kojih je dimenzija matrica koju treba invertirati?
Q: Po čemu se razlikuju dobivene težine i je li ta razlika očekivana? Obrazložite.
Can you write Python code for it?

lam = [0, 1, 10]
y = np.array([4,1,2,5])

Phi4a = PolynomialFeatures(3).fit_transform(X)
w_L2 = [];

def w_reg(lam):
    t1 = np.dot(Phi4a.T, Phi4a) + np.dot(lam, np.eye(4))
    t2 = np.dot(np.linalg.inv(t1), Phi4a.T)
    return np.dot(t2, y)

for i in range(0, 3):
    w_L2.insert(i, w_reg(lam[i]))
    print (w_reg(lam[i]))


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
5. Regularizirana polinomijalna regresija
(a)
Vratimo se na slučaj $N=50$ slučajno generiranih primjera iz zadatka 2. Trenirajte modele polinomijalne regresije $\mathcal{H}_{\lambda,d}$ za $\lambda\in{0,100}$ i $d\in{2,10}$ (ukupno četiri modela). Skicirajte pripadne funkcije $h(\mathbf{x})$ i primjere (na jednom grafikonu; preporučujemo koristiti plot unutar for petlje).
Q: Jesu li rezultati očekivani? Obrazložite.
Can you write Python code for it?

x5a = linspace(-5, 5, 50);
f = (5 + x5a - 2*(x5a**2) - 5*(x5a**3));
y5a = f + normal(0, 200, 50);

lamd = [0, 100]
dd = [2, 10]
h5a = []

for i in lamd:
    for j in dd:
        Phi5a = PolynomialFeatures(j).fit_transform(x5a.reshape(-1,1))
        w_5a = np.dot(np.dot(np.linalg.inv(np.dot(Phi5a.T, Phi5a) + np.dot(i, np.eye(j+1))), Phi5a.T), y5a);
        h_5a = np.dot(Phi5a, w_5a)
        h5a.append(h_5a)

lamdd = [0, 0, 100, 100]
ddd = [2, 10, 2, 10]

fig = plt.figure(figsize=(15, 10))
fig.subplots_adjust(wspace=0.2, hspace = 0.2)

for i in range(0, len(lamdd)):
    ax = fig.add_subplot(2, 2, i+1)
    plt.plot(x5a, h5a[i], 'r', linewidth = 2)
    plt.scatter(x5a, y5a);


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
7. Značajke različitih skala
Često se u praksi možemo susreti sa podatcima u kojima sve značajke nisu jednakih magnituda. Primjer jednog takvog skupa je regresijski skup podataka grades u kojem se predviđa prosjek ocjena studenta na studiju (1--5) na temelju dvije značajke: bodova na prijamnom ispitu (1--3000) i prosjeka ocjena u srednjoj školi. Prosjek ocjena na studiju izračunat je kao težinska suma ove dvije značajke uz dodani šum.
Koristite sljedeći kôd kako biste generirali ovaj skup podataka.
Can you write Python code for it?

n_data_points = 500
np.random.seed(69)

# Generiraj podatke o bodovima na prijamnom ispitu koristeći normalnu razdiobu i ograniči ih na interval [1, 3000].
exam_score = np.random.normal(loc=1500.0, scale = 500.0, size = n_data_points)
exam_score = np.round(exam_score)
exam_score[exam_score > 3000] = 3000
exam_score[exam_score < 0] = 0

# Generiraj podatke o ocjenama iz srednje škole koristeći normalnu razdiobu i ograniči ih na interval [1, 5].
grade_in_highschool = np.random.normal(loc=3, scale = 2.0, size = n_data_points)
grade_in_highschool[grade_in_highschool > 5] = 5
grade_in_highschool[grade_in_highschool < 1] = 1

# Matrica dizajna.
grades_X = np.array([exam_score,grade_in_highschool]).T

# Završno, generiraj izlazne vrijednosti.
rand_noise = np.random.normal(loc=0.0, scale = 0.5, size = n_data_points)
exam_influence = 0.9
grades_y = ((exam_score / 3000.0) * (exam_influence) + (grade_in_highschool / 5.0) \
            * (1.0 - exam_influence)) * 5.0 + rand_noise
grades_y[grades_y < 1] = 1
grades_y[grades_y > 5] = 5


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
Ponovno, naučite na ovom skupu L2-regularizirani model regresije ($\lambda = 0.01$).
Can you write Python code for it?

w = Ridge(alpha = 0.01).fit(grades_X_fixed_colinear, grades_y_fixed).coef_
print(w)


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
Q: Gledajući grafikone iz podzadatka (a), koja značajka bi trebala imati veću magnitudu, odnosno važnost pri predikciji prosjeka na studiju? Odgovaraju li težine Vašoj intuiciji? Objasnite.
8. Multikolinearnost i kondicija matrice
a)
Izradite skup podataka grades_X_fixed_colinear tako što ćete u skupu grades_X_fixed iz
zadatka 7b duplicirati zadnji stupac (ocjenu iz srednje škole). Time smo efektivno uveli savršenu multikolinearnost.
Can you write Python code for it?

grades_X_fixed_colinear = [[g[0],g[1],g[1]] for g in grades_X_fixed]


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
Sada ponovite gornji eksperiment, ali prvo skalirajte podatke grades_X i grades_y i spremite ih u varijable grades_X_fixed i grades_y_fixed. Za tu svrhu, koristite StandardScaler.
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler

#grades_y.reshape(-1, 1)

scaler = StandardScaler()
scaler.fit(grades_X)
grades_X_fixed = scaler.transform(grades_X)

scaler2 = StandardScaler()
scaler2.fit(grades_y.reshape(-1, 1))
grades_y_fixed = scaler2.transform(grades_y.reshape(-1, 1))


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
Zadatci
1. Jednostavna regresija
Zadan je skup primjera $\mathcal{D}={(x^{(i)},y^{(i)})}_{i=1}^4 = {(0,4),(1,1),(2,2),(4,5)}$. Primjere predstavite matrixom $\mathbf{X}$ dimenzija $N\times n$ (u ovom slučaju $4\times 1$) i vektorom oznaka $\textbf{y}$, dimenzija $N\times 1$ (u ovom slučaju $4\times 1$), na sljedeći način:
Can you write Python code for it?


I am working on the file "STRUCE/2018/SU-2018-LAB01-Regresija.ipynb".
The first task is:
a)
Iscrtajte ovisnost ciljne vrijednosti (y-os) o prvoj i o drugoj značajki (x-os). Iscrtajte dva odvojena grafa.
Can you write Python code for it?

plt.figure()
plot(exam_score, grades_y, 'r+')
grid()

plt.figure()
plot(grade_in_highschool, grades_y, 'g+')
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
(b)
Trenirajte model logističke regresije na skupu seven te na dva odvojena grafikona prikažite, kroz iteracije optimizacijskoga algoritma, (1) izlaz modela $h(\mathbf{x})$ za svih sedam primjera te (2) vrijednosti težina $w_0$, $w_1$, $w_2$.
Can you write Python code for it?

[w4b, w4b_trace] = lr_train(seven_X, seven_y, trace = True)

w0_4b = []; w1_4b = []; w2_4b = [];

for i in range(0, len(w4b_trace), 3):
    w0_4b.append(w4b_trace[i])
    w1_4b.append(w4b_trace[i+1])
    w2_4b.append(w4b_trace[i+2])

h_gl = []

for i in range(0, len(seven_X)):
    h = []

    for j in range(0, len(w4b_trace), 3):
        h.append(lr_h(seven_X[i], w4b_trace[j:j+3]))

    h_gl.append(h)

figure(figsize(7, 14))
subplot(2,1,1)
grid()
for i in range(0, len(h_gl)):
    plot(h_gl[i], label = 'x' + str(i))

legend(loc = 'best') ;

subplot(2,1,2)
grid()
plot(w0_4b); plot(w1_4b); plot(w2_4b);
legend(['w0', 'w1', 'w2'], loc = 'best');


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
(c)
Ponovite eksperiment iz podzadatka (b) koristeći linearno neodvojiv skup podataka unsep iz prvog zadatka.
Q: Usporedite grafikone za slučaj linearno odvojivih i linearno neodvojivih primjera te komentirajte razliku.
Can you write Python code for it?

unsep_y = np.append(seven_y, 0)
[w4c, w4c_trace] = lr_train(unsep_X, unsep_y, trace = True)

w0_4c = []; w1_4c = []; w2_4c = [];

for i in range(0, len(w4c_trace), 3):
    w0_4c.append(w4c_trace[i])
    w1_4c.append(w4c_trace[i+1])
    w2_4c.append(w4c_trace[i+2])

h_gl = []

for i in range(0, len(unsep_X)):
    h = []

    for j in range(0, len(w4c_trace), 3):
        h.append(lr_h(unsep_X[i], w4c_trace[j:j+3]))

    h_gl.append(h)

figure(figsize(7, 14))
subplots_adjust(wspace=0.1)
subplot(2,1,1)
grid()
for i in range(0, len(h_gl)):
    plot(h_gl[i], label = 'x' + str(i))

legend(loc = 'best') ;

subplot(2,1,2)
grid()
plot(w0_4c); plot(w1_4c); plot(w2_4c);
legend(['w0', 'w1', 'w2'], loc = 'best');


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
3. Logistička regresija
Ovaj zadatak bavi se probabilističkim diskriminativnim modelom, logističkom regresijom, koja je, unatoč nazivu, klasifikacijski model.
Logistička regresija tipičan je predstavnik tzv. poopćenih linearnih modela koji su oblika: $h(\mathbf{x})=f(\mathbf{w}^\intercal\tilde{\mathbf{x}})$. Logistička funkcija za funkciju $f$ koristi tzv. logističku (sigmoidalnu) funkciju $\sigma (x) = \frac{1}{1 + \textit{exp}(-x)}$.
(a)
Definirajte logističku (sigmoidalnu) funkciju $\mathrm{sigm}(x)=\frac{1}{1+\exp(-\alpha x)}$ i prikažite je za $\alpha\in{1,2,4}$.
Can you write Python code for it?

def sigm(alpha):
    def f(x):
        return 1 / (1 + exp(-alpha*x))

    return f

ax = list(range(-10, 10))
ay1 = list(map(sigm(1), ax))
ay2 = list(map(sigm(2), ax))
ay3 = list(map(sigm(4), ax))

fig = plt.figure(figsize=(5,15))
p1 = fig.add_subplot(3, 1, 1)
p1.plot(ax, ay1)
p2 = fig.add_subplot(3, 1, 2)
p2.plot(ax, ay2)
p3 = fig.add_subplot(3, 1, 3)
p3.plot(ax, ay3)


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
4. Analiza logističke regresije
(a)
Koristeći ugrađenu implementaciju logističke regresije, provjerite kako se logistička regresija nosi s vrijednostima koje odskaču. Iskoristite skup outlier iz prvog zadatka. Prikažite granicu između klasa.
Q: Zašto se rezultat razlikuje od onog koji je dobio model klasifikacije linearnom regresijom iz prvog zadatka?
Can you write Python code for it?

    logReg4 = LogisticRegression(solver='liblinear').fit(outlier_X, outlier_y)
    mlutils.plot_2d_clf_problem(X=outlier_X, y=outlier_y, h= lambda x : logReg4.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
5. Regularizirana logistička regresija
Trenirajte model logističke regresije na skupu seven s različitim faktorima L2-regularizacije, $\alpha\in{0,1,10,100}$. Prikažite na dva odvojena grafikona (1) pogrešku unakrsne entropije te (2) L2-normu vektora $\mathbf{w}$ kroz iteracije optimizacijskog algoritma.
Q: Jesu li izgledi krivulja očekivani i zašto?
Q: Koju biste vrijednost za $\alpha$ odabrali i zašto?
Can you write Python code for it?

from numpy.linalg import norm

alpha5 = [0, 1, 10, 100]

err_gl = []; norm_gl = [];

for a in alpha5:
    [w5, w5_trace] = lr_train(seven_X, seven_y, alpha = a, trace = True)
    err = []; L2_norm = [];

    for k in range(0, len(w5_trace), 3):
        err.append(cross_entropy_error(seven_X, seven_y, w5_trace[k:k+3]))
        L2_norm.append(linalg.norm(w5_trace[k:k+1]))

    err_gl.append(err)
    norm_gl.append(L2_norm)

figure(figsize(7, 14))
subplot(2,1,1)
grid()
for i in range(0, len(err_gl)):
    plot(err_gl[i], label = 'alpha = '  + str(alpha5[i])  )

legend(loc = 'best') ;

subplot(2,1,2)
grid()
for i in range(0, len(err_gl)):
    plot(norm_gl[i], label = 'alpha = ' + str(alpha5[i]) )

legend(loc = 'best');


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
Kako bi se uvjerili da se u isprobanoj implementaciji ne radi o ničemu doli o običnoj linearnoj regresiji, napišite kôd koji dolazi do jednakog rješenja korištenjem isključivo razreda LinearRegression. Funkciju za predikciju, koju predajete kao treći argument h funkciji plot_2d_clf_problem, možete definirati lambda-izrazom: lambda x : model.predict(x) >= 0.5.
Can you write Python code for it?

lr = LinearRegression().fit(seven_X, seven_y)
predicted_y_2 = lr.predict(seven_X)

mlutils.plot_2d_clf_problem(X=seven_X, y=seven_y, h= lambda x : lr.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
Q: Koji kriterij zaustavljanja je aktiviran?
Q: Zašto dobivena pogreška unakrsne entropije nije jednaka nuli?
Q: Kako biste utvrdili da je optimizacijski postupak doista pronašao hipotezu koja minimizira pogrešku učenja? O čemu to ovisi?
Q: Na koji način biste preinačili kôd ako biste htjeli da se optimizacija izvodi stohastičkim gradijentnim spustom (online learning)?
(d)
Prikažite na jednom grafikonu pogrešku unakrsne entropije (očekivanje logističkog gubitka) i pogrešku klasifikacije (očekivanje gubitka 0-1) na skupu seven kroz iteracije optimizacijskog postupka. Koristite trag težina funkcije lr_train iz zadatka (b) (opcija trace=True). Na drugom grafikonu prikažite pogrešku unakrsne entropije kao funkciju broja iteracija za različite stope učenja, $\eta\in{0.005,0.01,0.05,0.1}$.
Can you write Python code for it?

from sklearn.metrics import zero_one_loss

eta = [0.005, 0.01, 0.05, 0.1]
[w3d, w3d_trace] = lr_train(seven_X, seven_y, trace=True)

Phi = PolyFeat(1).fit_transform(seven_X)
h_3d = lambda x: x >= 0.5

error_unakrs = []
errror_classy = []
errror_eta = []

for k in range(0, len(w3d_trace), 3):
    error_unakrs.append(cross_entropy_error(seven_X, seven_y, w3d_trace[k:k+3]))
    errror_classy.append(zero_one_loss(seven_y, h_3d(sigm(1)(Phi.dot(w3d_trace[k:k+3])))))

for i in eta:
    err = []
    [w3, w3_trace] = lr_train(seven_X, seven_y, i, trace=True)

    for j in range(0, len(w3_trace), 3):
        err.append(cross_entropy_error(seven_X, seven_y, w3_trace[j:j+3]))

    errror_eta.append(err)

figure(figsize(12, 15))
subplots_adjust(wspace=0.1)
subplot(2,1,1)
grid()
plot(error_unakrs); plot(errror_classy);

subplot(2,1,2)
grid()
for i in range(0, len(eta)):
    plot(errror_eta[i], label = 'eta = ' + str(i))
legend(loc = 'best');


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
Q: Zašto je pogreška unakrsne entropije veća od pogreške klasifikacije? Je li to uvijek slučaj kod logističke regresije i zašto?
Q: Koju stopu učenja $\eta$ biste odabrali i zašto?
(e)
Upoznajte se s klasom linear_model.LogisticRegression koja implementira logističku regresiju. Usporedite rezultat modela na skupu seven s rezultatom koji dobivate pomoću vlastite implementacije algoritma.
NB: Kako ugrađena implementacija koristi naprednije verzije optimizacije funkcije, vrlo je vjerojatno da Vam se rješenja neće poklapati, ali generalne performanse modela bi trebale. Ponovno, pripazite na broj iteracija i snagu regularizacije.
Can you write Python code for it?

from sklearn.linear_model import LogisticRegression

reg3e = LogisticRegression(max_iter=2000, tol=0.0001, C=0.01**-1, solver='lbfgs').fit(seven_X,seven_y)
h3e = lambda x : reg3e.predict(x)

figure(figsize(7, 7))
mlutils.plot_2d_clf_problem(seven_X,seven_y, h3e)


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
Q: Zašto model ne ostvaruje potpunu točnost iako su podatci linearno odvojivi?
(c)
Završno, probajte isto na linearno neodvojivom skupu podataka unsep ($N=8$):
Can you write Python code for it?

unsep_X = np.append(seven_X, [[2,2]], axis=0)
unsep_y = np.append(seven_y, 0)

lr3 = LinearRegression().fit(unsep_X, unsep_y)
predicted_y_2 = lr3.predict(unsep_X)

mlutils.plot_2d_clf_problem(X=unsep_X, y=unsep_y, h= lambda x : lr3.predict(x) >= 0.5)


I am working on the file "STRUCE/2018/SU-2018-LAB02-0036477171.ipynb".
The first task is:
Zadatci
1. Linearna regresija kao klasifikator
U prvoj laboratorijskoj vježbi koristili smo model linearne regresije za, naravno, regresiju. Međutim, model linearne regresije može se koristiti i za klasifikaciju. Iako zvuči pomalo kontraintuitivno, zapravo je dosta jednostavno. Naime, cilj je naučiti funkciju $f(\mathbf{x})$ koja za negativne primjere predviđa vrijednost $1$, dok za pozitivne primjere predviđa vrijednost $0$. U tom slučaju, funkcija $f(\mathbf{x})=0.5$ predstavlja granicu između klasa, tj. primjeri za koje vrijedi $h(\mathbf{x})\geq 0.5$ klasificiraju se kao pozitivni, dok se ostali klasificiraju kao negativni.
Klasifikacija pomoću linearne regresije implementirana je u razredu RidgeClassifier. U sljedećim podzadatcima istrenirajte taj model na danim podatcima i prikažite dobivenu granicu između klasa. Pritom isključite regularizaciju ($\alpha = 0$, odnosno alpha=0). Također i ispišite točnost vašeg klasifikacijskog modela (smijete koristiti funkciju metrics.accuracy_score). Skupove podataka vizualizirajte korištenjem pomoćne funkcije plot_clf_problem(X, y, h=None) koja je dostupna u pomoćnom paketu mlutils (datoteku mlutils.py možete preuzeti sa stranice kolegija). X i y predstavljaju ulazne primjere i oznake, dok h predstavlja funkciju predikcije modela (npr. model.predict).
U ovom zadatku cilj je razmotriti kako se klasifikacijski model linearne regresije ponaša na linearno odvojim i neodvojivim podatcima.
Can you write Python code for it?

from sklearn.linear_model import LinearRegression, RidgeClassifier
from sklearn.metrics import accuracy_score


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
(a)
Proučite funkciju za iscrtavanje histograma hist. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ (ovdje i u sljedećim zadatcima koristite bins=50).
Can you write Python code for it?


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
(b)
Kako biste se uvjerili da je Vaša implementacija ispravna, usporedite ju s onom u razredu neighbors.KNeighborsClassifier. Budući da spomenuti razred koristi razne optimizacijske trikove pri pronalasku najboljih susjeda, obavezno postavite parametar algorithm=brute, jer bi se u protivnom moglo dogoditi da Vam se predikcije razlikuju. Usporedite modele na danom (umjetnom) skupu podataka (prisjetite se kako se uspoređuju polja; numpy.all).
Can you write Python code for it?

from sklearn.datasets import make_classification
X_art, y_art = make_classification(n_samples=100, n_features=2, n_classes=2,
                                   n_redundant=0, n_clusters_per_class=2,
                                   random_state=69)
mlutils.plot_2d_clf_problem(X_art, y_art)

from sklearn.neighbors import KNeighborsClassifier

knn = KNN()
knn.fit(X_art, y_art)
predict_knn = knn.predict(X_art)

builtin = KNeighborsClassifier(algorithm = 'brute', n_neighbors = 3).fit(X_art, y_art)
predict_knc = builtin.predict(X_art)

print('diff')
print(norm(predict_knn - predict_knc))


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
(b)
Proučite razred preprocessing.MinMaxScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane min-max skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import MinMaxScaler

x0b = MinMaxScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = MinMaxScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(10, 5))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
(c)
Vratit ćemo se na skupove podataka outlier ($N=8$) i unsep ($N=8$) iz prošle laboratorijske vježbe (dani niže) i pogledati kako se model SVM-a nosi s njima. Naučite ugrađeni model SVM-a (s linearnom jezgrom) na ovim podatcima i iscrtajte decizijsku granicu (skupa s marginom). Također ispišite točnost modela korištenjem funkcije metrics.accuracy_score.
Can you write Python code for it?

from sklearn.metrics import accuracy_score

outlier_X = np.append(seven_X, [[12,8]], axis=0)
outlier_y = np.append(seven_y, -1)

unsep_X = np.append(seven_X, [[2,2]], axis=0)
unsep_y = np.append(seven_y, -1)

outlier = SVC(kernel = 'linear').fit(outlier_X, outlier_y)
outlier_accuracy = accuracy_score(outlier_y, outlier.predict(outlier_X))

print('outlier acc:')
print(outlier_accuracy)

unsep = SVC(kernel = 'linear').fit(unsep_X, unsep_y)
unsep_accuracy = accuracy_score(unsep_y, unsep.predict(unsep_X))

print('unsep acc:')
print(unsep_accuracy)

figure(figsize(12,4))
subplot(1,2,1)
mlutils.plot_2d_svc_problem(outlier_X, outlier_y, outlier)
mlutils.plot_2d_clf_problem(outlier_X, outlier_y, outlier.predict)

subplot(1,2,2)
mlutils.plot_2d_svc_problem(unsep_X, unsep_y, unsep)
mlutils.plot_2d_clf_problem(unsep_X, unsep_y, unsep.predict)


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
1. Klasifikator stroja potpornih vektora (SVM)
(a)
Upoznajte se s razredom svm.SVC, koja ustvari implementira sučelje prema implementaciji libsvm. Primijenite model SVC s linearnom jezgrenom funkcijom (tj. bez preslikavanja primjera u prostor značajki) na skup podataka seven (dan niže) s $N=7$ primjera. Ispišite koeficijente $w_0$ i $\mathbf{w}$. Ispišite dualne koeficijente i potporne vektore. Završno, koristeći funkciju mlutils.plot_2d_svc_problem iscrtajte podatke, decizijsku granicu i marginu. Funkcija prima podatke, oznake i klasifikator (objekt klase SVC).
Izračunajte širinu dobivene margine (prisjetite se geometrije linearnih modela).
Can you write Python code for it?

from sklearn.svm import SVC

seven_X = np.array([[2,1], [2,3], [1,2], [3,2], [5,2], [5,4], [6,3]])
seven_y = np.array([1, 1, 1, 1, -1, -1, -1])

fit = SVC(gamma = 'scale', kernel = 'linear').fit(seven_X, seven_y)
mlutils.plot_2d_svc_problem(seven_X, seven_y, fit)
mlutils.plot_2d_clf_problem(seven_X, seven_y, fit.predict)


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
3. Optimizacija hiperparametara SVM-a
Pored hiperparametra $C$, model SVM s jezgrenom funkcijom RBF ima i dodatni hiperparametar $\gamma=\frac{1}{2\sigma^2}$ (preciznost). Taj parametar također određuje složenost modela: velika vrijednost za $\gamma$ znači da će RBF biti uska, primjeri će biti preslikani u prostor u kojem su (prema skalarnome produktu) međusobno vrlo različiti, što će rezultirati složenijim modelima. Obrnuto, mala vrijednost za $\gamma$ znači da će RBF biti široka, primjeri će biti međusobno sličniji, što će rezultirati jednostavnijim modelima. To ujedno znači da, ako odabremo veći $\gamma$, trebamo jače regularizirati model, tj. trebamo odabrati manji $C$, kako bismo spriječili prenaučenost. Zbog toga je potrebno zajednički optimirati hiperparametre $C$ i $\gamma$, što se tipično radi iscrpnim pretraživanjem po rešetci (engl. grid search). Ovakav pristup primjenjuje se kod svih modela koji sadrže više od jednog hiperparametra.
(a)
Definirajte funkciju

grid_search(X_train, X_validate, y_train, y_validate, c_range=(c1,c2), g_range=(g1,g2), error_surface=False)

koja optimizira parametre $C$ i $\gamma$ pretraživanjem po rešetci. Funkcija treba pretražiti hiperparametre $C\in{2^{c_1},2^{c_1+1},\dots,2^{c_2}}$ i $\gamma\in{2^{g_1},2^{g_1+1},\dots,2^{g_2}}$. Funkcija treba vratiti optimalne hiperparametre $(C^,\gamma^)$, tj. one za koje na skupu za provjeru model ostvaruju najmanju pogrešku. Dodatno, ako je surface=True, funkcija treba vratiti matrice (tipa ndarray) pogreške modela (očekivanje gubitka 0-1) na skupu za učenje i skupu za provjeru. Svaka je matrica dimenzija $(c_2-c_1+1)\times(g_2-g_1+1)$ (retci odgovaraju različitim vrijednostima za $C$, a stupci različitim vrijednostima za $\gamma$).
Can you write Python code for it?

from sklearn.metrics import accuracy_score, zero_one_loss

def grid_search(X_train, X_validate, y_train, y_validate, c_range=(0,5), g_range=(0,5), error_surface=False):

    # Vaš kôd ovdje
    C = []
    G = []

    for c in range(c_range[0], c_range[1] + 1):
        C.append(2**c)
    for g in range(g_range[0], g_range[1] + 1):
        G.append(2**g)

    err_train = 0
    err_validate = 0
    err_minimum = inf
    C_optimal = 0
    G_optimal = 0

    error_train_all = np.zeros((len(C), len(G)));
    error_validate_all = np.zeros((len(C), len(G)));

    for c in C:
        for g in G:
            svm = SVC(C=c, gamma=g).fit(X_train, y_train)

            h_train = svm.predict(X_train)
            err_train = zero_one_loss(y_train, h_train)

            h_validate = svm.predict(X_validate)
            err_validate = zero_one_loss(y_validate, h_validate)

            error_train_all[C.index(c)][G.index(g)] = err_train
            error_validate_all[C.index(c)][G.index(g)] = err_validate

            if err_validate < err_minimum:
                err_minimum = err_validate
                C_optimal = c
                G_optimal = g

    if error_surface:
        return C_optimal, G_optimal, error_train_all, error_validate_all
    else:
        return C_optimal, G_optimal


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
6. Analiza algoritma k-najbližih susjeda
Algoritam k-nn ima hiperparametar $k$ (broj susjeda). Taj hiperparametar izravno utječe na složenost algoritma, pa je stoga izrazito važno dobro odabrati njegovu vrijednost. Kao i kod mnogih drugih algoritama, tako i kod algoritma k-nn optimalna vrijednost hiperametra $k$ ovisi o konkretnom problemu, uključivo broju primjera $N$, broju značajki (dimenzija) $n$ te broju klasa $K$.
Kako bismo dobili pouzdanije rezultate, potrebno je neke od eksperimenata ponoviti na različitim skupovima podataka i zatim uprosječiti dobivene vrijednosti pogrešaka. Koristite funkciju: mlutils.knn_eval koja trenira i ispituje model k-najbližih susjeda na ukupno n_instances primjera, i to tako da za svaku vrijednost hiperparametra iz zadanog intervala k_range ponovi n_trials mjerenja, generirajući za svako od njih nov skup podataka i dijeleći ga na skup za učenje i skup za ispitivanje. Udio skupa za ispitivanje definiran je parametrom test_size. Povratna vrijednost funkcije jest četvorka (ks, best_k, train_errors, test_errors). Vrijednost best_k je optimalna vrijednost hiperparametra $k$ (vrijednost za koju je pogreška na skupu za ispitivanje najmanja). Vrijednosti train_errors i test_errors  liste su pogrešaka na skupu za učenja odnosno skupu za testiranje za sve razmatrane vrijednosti hiperparametra $k$, dok ks upravo pohranjuje sve razmatrane vrijednosti hiperparametra $k$.
(a)
Na podatcima iz zadatka 5, pomoću funkcije mlutils.plot_2d_clf_problem iscrtajte prostor primjera i područja koja odgovaraju prvoj odnosno drugoj klasi. Ponovite ovo za $k\in[1, 5, 20, 100]$.
NB: Implementacija algoritma KNeighborsClassifier iz paketa scikit-learn vjerojatno će raditi brže od Vaše implementacije, pa u preostalim eksperimentima koristite nju.
Can you write Python code for it?

def knn_eval(n_instances=100, n_features=2, n_classes=2, n_informative=2, test_size=0.3, k_range=(1, 20), n_trials=100):

    best_k = 0; train_errors = []; test_errors = [];

    for k in range(k_range[0],k_range[1]+1):

        train_error = []
        test_error = []

        for j in range(0, n_trials):

            X, y = make_classification(n_samples=n_instances, n_features=n_features, n_classes=n_classes, n_informative=n_informative, n_redundant=0, n_clusters_per_class=1)
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = test_size)

            mod = KNeighborsClassifier(algorithm = 'brute', n_neighbors = k).fit(X_train, y_train)
            prediction_train = mod.predict(X_train)
            prediction_test = mod.predict(X_test)

            train_error.append(zero_one_loss(y_train, prediction_train))
            test_error.append(zero_one_loss(y_test, prediction_test))

        train_errors.append(mean(train_error))
        test_errors.append(mean(test_error))

    best_k = k_range[0] + test_errors.index(min(test_errors))

    return (best_k, train_errors, test_errors)


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
Q: Jesu li rezultati očekivani? Obrazložite. <br>
Q: Bi li bilo dobro kada bismo funkciju fit_transform primijenili na cijelom skupu podataka? Zašto? Bi li bilo dobro kada bismo tu funkciju primijenili zasebno na skupu za učenje i zasebno na skupu za ispitivanje? Zašto?
5. Algoritam k-najbližih susjeda
U ovom zadatku promatrat ćemo jednostavan klasifikacijski model imena algoritam k-najbližih susjeda. Najprije ćete ga samostalno isprogramirati kako biste se detaljno upoznali s radom ovog modela, a zatim ćete prijeći na analizu njegovih hiperparametara (koristeći ugrađeni razred, radi efikasnosti).
(a)
Implementirajte klasu KNN, koja implementira algoritam $k$ najbližih susjeda. Neobavezan parametar konstruktora jest broj susjeda n_neighbours ($k$), čija je podrazumijevana vrijednost 3. Definirajte metode fit(X, y) i predict(X), koje služe za učenje modela odnosno predikciju. Kao mjeru udaljenosti koristite euklidsku udaljenost (numpy.linalg.norm; pripazite na parametar axis). Nije potrebno implementirati nikakvu težinsku funkciju.
Can you write Python code for it?

from numpy.linalg import norm
from collections import Counter

class KNN(object):
    def __init__(self, n_neighbors=3):
        self.n_neighbors = n_neighbors
        self.domain = []

    def fit(self, X_train, y_train):
        for x,y in zip(X_train, y_train):
            self.domain.append([x, y])
        return self.domain

    def predict(self, X_test):
        pred = []
        for x in X_test:
            dist = []
            y = []
            counter = []
            for xd, yd in self.domain:
                dist.append(norm(x-xd))
                y.append(yd)

            dat = sorted(zip(dist, y))[0: self.n_neighbors]

            for i in range(0, self.n_neighbors):
                counter.append(dat[i][1])

            pred.append((Counter(counter).most_common()[0])[0])

        return pred


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
Q: Kako radi ovo skaliranje?

Q: Dobiveni histogrami su vrlo slični. U čemu je razlika?

(c)
Proučite razred preprocessing.StandardScaler. Prikažite histograme vrijednosti značajki $x_0$ i $x_1$ ako su iste skalirane standardnim skaliranjem (ukupno dva histograma).
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler

x0b = StandardScaler().fit_transform(X[:,0].reshape(-1,1), y)
x1b = StandardScaler().fit_transform(X[:,1].reshape(-1,1), y)

figure(figsize(10, 5))
subplot(1,2,1)
hist(x0b, bins = 50)
subplot(1,2,2)
hist(x1b, bins = 50)


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
Q: Kako radi ovo skaliranje?

Q: Dobiveni histogrami su vrlo slični. U čemu je razlika?

(d)
Podijelite skup primjera na skup za učenje i skup za ispitivanje u omjeru 1:1. Trenirajte SVM s jezgrenom funkcijom RBF na skupu za učenje i ispitajte točnost modela na skupu za ispitivanje, koristeći tri varijante gornjeg skupa: neskalirane značajke, standardizirane značajke i min-max skaliranje. Koristite podrazumijevane vrijednosti za $C$ i $\gamma$. Izmjerite točnost svakog od triju modela na skupu za učenje i skupu za ispitivanje. Ponovite postupak više puta (npr. 30) te uprosječite rezultate (u svakom ponavljanju generirajte podatke kao što je dano na početku ovog zadatka).
NB: Na skupu za učenje treba najprije izračunati parametre skaliranja te zatim primijeniti skaliranje (funkcija fit_transform), dok na skupu za ispitivanje treba samo primijeniti skaliranje s parametrima koji su dobiveni na skupu za učenje (funkcija transform).
Can you write Python code for it?

from sklearn.model_selection import train_test_split

err_unscaled = []
err_std = []
err_minmax = []

for i in range(0, 30):

    X_train, X_validate, y_train, y_validate = train_test_split(X, y, test_size = 0.5)

    model_unscaled = SVC(gamma = 'scale').fit(X_train, y_train)
    prediction_unscaled = model_unscaled.predict(X_validate)
    err_unscaled.append(accuracy_score(y_validate, prediction_unscaled))

    ss = StandardScaler()
    X_std_train = ss.fit_transform(X_train)
    X_std_valid = ss.transform(X_validate)
    model_standard = SVC(gamma = 'scale').fit(X_std_train, y_train)
    prediction_standard = model_standard.predict(X_std_valid)
    err_std.append(accuracy_score(y_validate, prediction_standard))

    mm = MinMaxScaler()
    X_minmax_train = mm.fit_transform(X_train)
    X_minmax_valid = mm.transform(X_validate)
    model_minmax = SVC(gamma = 'scale').fit(X_minmax_train, y_train)
    prediction_minmax = model_minmax.predict(X_minmax_valid)
    err_minmax.append(accuracy_score(y_validate, prediction_minmax))

print('Unscaled')
print(mean(err_unscaled))
print('Std')
print(mean(err_std))
print('Min max')
print(mean(err_minmax))


I am working on the file "STRUCE/2018/SU-2018-LAB03-0036477171.ipynb".
The first task is:
Q: Kako se mijenja optimalna vrijednost hiperparametra $k$ s obzirom na broj primjera $N$? Zašto?
Q: Kojem području odgovara prenaučenost, a kojem podnaučenost modela? Zašto?
Q: Je li uvijek moguće doseći pogrešku od 0 na skupu za učenje?
(c)
Kako bismo provjerili u kojoj je mjeri algoritam k-najbližih susjeda osjetljiv na prisustvo nebitnih značajki, možemo iskoristiti funkciju datasets.make_classification kako bismo generirali skup primjera kojemu su neke od značajki nebitne. Naime, parametar n_informative određuje broj bitnih značajki, dok parametar n_features određuje ukupan broj značajki. Ako je n_features > n_informative, onda će neke od značajki biti nebitne. Umjesto da izravno upotrijebimo funkciju make_classification, upotrijebit ćemo funkciju mlutils.knn_eval, koja samo preuzime ove parametre, ali nam omogućuje pouzdanije procjene.
Koristite funkciju mlutils.knn_eval na dva načina. U oba koristite $N=1000$ primjera, $n=10$ značajki i $K=5$ klasa, ali za prvi neka su svih 10 značajki bitne, a za drugi neka je bitno samo 5 od 10 značajki. Ispišite pogreške učenja i ispitivanja za oba modela za optimalnu vrijednost $k$ (vrijednost za koju je ispitna pogreška najmanja).
Q: Je li algoritam k-najbližih susjeda osjetljiv na nebitne značajke? Zašto?
Q: Je li ovaj problem izražen i kod ostalih modela koje smo dosad radili (npr. logistička regresija)?
Q: Kako bi se model k-najbližih susjeda ponašao na skupu podataka sa značajkama različitih skala? Detaljno pojasnite.
7. "Prokletstvo dimenzionalnosti"
"Prokletstvo dimenzionalnosti" zbirni je naziv za niz fenomena povezanih s visokodimenzijskim prostorima. Ti fenomeni, koji se uglavnom protive našoj intuiciji, u većini slučajeva dovode do toga da se s porastom broja dimenzija (značajki) smanjenje točnost modela.
Općenito, povećanje dimenzija dovodi do toga da sve točke u ulaznome prostoru postaju (u smislu euklidske udaljenosti) sve udaljenije jedne od drugih te se, posljedično, gube razlike u udaljenostima između točaka. Eksperimentalno ćemo provjeriti da...
Can you write Python code for it?

from sklearn.metrics.pairwise import pairwise_distances
from numpy.random import random, random_sample

dims = []
vals = []
cosine = []

for dim in range(1, 50):
    arrs = random_sample((50, dim))
    arrs2 = random_sample((50, dim))
    # print(arrs)
    dists = norm(pairwise_distances(X=arrs, Y=arrs2))
    #print(dists)
    dims.append(dim)
    vals.append(dists)
    dists = norm(pairwise_distances(X=arrs, Y=arrs2, metric='cosine'))
    cosine.append(dists)

#print(dims)
#print(vals)

plot(dims, vals)
plot(dims, cosine)
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(a)
Boosting, kao vrsta ansambla, također se temelji na kombinaciji više klasifikatora s ciljem boljih prediktivnih sposobnosti. Međutim, ono što ovakav tip ansambla čini zanimljivim jest to da za osnovni klasifikator traži slabi klasifikator (engl. weak classifier), odnosno klasifikator koji radi tek malo bolje od nasumičnog pogađanja. Često korišteni klasifikator za tu svrhu jest panj odluke (engl. decision stump), koji radi predikciju na temelju samo jedne značajke ulaznih primjera. Panj odluke specijalizacija je stabla odluke (engl. decision tree) koje smo već spomenuli. Panj odluke stablo je dubine 1. Stabla odluke implementirana su u razredu tree.DecisionTreeClassifier.
Radi ilustracije, naučite ansambl (AdaBoost) koristeći panj odluke kao osnovni klasifikator, ali pritom isprobavajući različit broj klasifikatora u ansamblu iz skupa $L \in {1, 2, 3, 50}$. Prikažite decizijske granice na danom skupu podataka za svaku od vrijednosti korištenjem pomoćne funkcije mlutils.plot_2d_clf_problem.
NB: Još jedan dokaz da hrvatska terminologija zaista može biti smiješna. :)
Can you write Python code for it?

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

L = [1, 2, 3, 50]

figure(figsize(12, 8))

for i, l in enumerate(L):
    ada = AdaBoostClassifier(base_estimator = DecisionTreeClassifier(max_depth = 1), n_estimators = l).fit(circ_X, circ_y)

    subplot(3,3, i +1)
    mlutils.plot_2d_clf_problem(circ_X, circ_y, ada.predict)


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(b)
Prikažite funkciju $\mathcal{L}(\mu|N,m)$ za (1) $N=10$ i $m=1,2,5,9$ te za (2) $N=100$ i $m=1,10,50,90$ (dva zasebna grafikona).
Can you write Python code for it?


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(b)
Uvjerite se da Vaša implementacija radi jednako onoj u razredu ensemble.VotingClassifier, i to pri oba načina glasovanja (parametar voting). Parametar weights ostavite na pretpostavljenoj vrijednosti. Za ovu provjeru koristite tri klasifikatora logističke regresije s različitom stopom regularizacije i brojem iteracija. Koristite skup podataka dan u nastavku. Ekvivalentnost implementacije najlakše je provjeriti usporedbom izlaza funkcije predict (kod prebrojavanja) i funkcije predict_proba (kod usrednjavanja).
NB: Ne koristimo SVM jer njegova ugrađena (probabilistička) implementacija nije posve deterministička, što bi onemogućilo robusnu provjeru Vaše implementacije.
Can you write Python code for it?

from sklearn.datasets import make_classification
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression

X_voting, y_voting = make_classification(n_samples=1000, n_features=4, n_redundant=0, n_informative=3, n_classes=3, n_clusters_per_class=2)

Logisticka1 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 1, max_iter = 1000).fit(X_voting, y_voting)
Logisticka2 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 100, max_iter = 1000).fit(X_voting, y_voting)
Logisticka3 = LogisticRegression(multi_class = 'auto', solver = 'lbfgs', C = 1000, max_iter = 1000).fit(X_voting, y_voting)

clfs = [Logisticka1, Logisticka2, Logisticka3]

moj = VotingClassifierDIY(clfs = clfs)
njihov = VotingClassifier(estimators= [('lr1', Logisticka1), ('lr2', Logisticka2), ('lr3', Logisticka3)])

a = moj.fit(X_voting, y_voting)
a = njihov.fit(X_voting, y_voting)

moj.voting_scheme = moj.SCHEME_COUNTING
njihov.voting = 'hard'

print(all(moj.predict(X_voting) == njihov.predict(X_voting)))

moj.voting_scheme = moj.SCHEME_AVERAGING
njihov.voting = 'soft'

print(all(moj.predict_proba(X_voting) == njihov.predict_proba(X_voting)))


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(h)
Implementirajte funkciju log-izglednosti za parametre $\mu$ i $\sigma^2$ normalne distribucije.
Can you write Python code for it?

from scipy.stats import norm

def log_izglednost(D, mi_ML, sigm2_ML):
    N = len(D)
    return -1*((N/2)*log(2*pi) + N*log(sqrt(sigm2_ML)) + (1/(2*sigm2_ML))*sum((D - mi_ML)**2))


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(i)
Izračunajte ML-procjene za $(\mu, \sigma^2)$ za svaku od $n=4$ značajki iz skupa Iris. Ispišite log-izglednosti tih ML-procjena.
Can you write Python code for it?

def mi_ML(D):
    return sum(D)/len(D)

def sigm2_ML(D):
    return sum((D - mi_ML(D))**2)/len(D)

for i in range(4):
    D = X[:,i]
    print('n=', i+1, ', mi_ML = ', str(mi_ML(D))[:4], ', sigm2_ML = ', str(sigm2_ML(D))[:7], ', izglednost = ', str(log_izglednost(D, mi_ML(D), sigm2_ML(D)))[:7]  )


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
(k)
Proučite funkciju cov te izračunajte ML-procjenu za kovarijacijsku matricu za skup Iris. Usporedite pristranu i nepristranu procjenu. Pokažite da se razlika (srednja apsolutna i kvadratna) smanjuje s brojem primjera (npr. isprobajte za $N/4$ i $N/2$ i $N$ primjera).
Can you write Python code for it?

N = [int(len(X)/4), int(len(X)/2), len(X)]

for br in N:
    nepristran = cov(X[0:br,], rowvar = False, bias= False)
    pristran = cov(X[0:br,], rowvar = False, bias = True)

    diff_abs = mean(abs(nepristran - pristran))
    diff_sqr = mean(pow((nepristran - pristran),2))

    print('abs diff ', str(diff_abs)[:9], ' square diff ', diff_sqr, ' N ', br)


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
1. Ansambli (glasovanje)
(a)
Vaš je zadatak napisati razred VotingClassifierDIY koji implementira glasački ansambl. Konstruktor razreda ima dva parametra: clfs koji predstavlja listu klasifikatora (objekata iz paketa sklearn) i voting_scheme koji označava radi li se o glasovanju prebrojavanjem (SCHEME_COUNTING) ili usrednjavanjem (SCHEME_AVERAGING). Glasovanje prebrojavanjem jednostavno vraća najčešću oznaku klase, dok glasovanje usrednjavanjem uprosječuje pouzdanosti klasifikacije u neku klasu (po svim klasifikatorima) te vraća onu s najvećom pouzdanošću. Primijetite da svi klasifikatori imaju jednake težine. O komplementarnosti klasifikatora vodimo računa tako da koristimo jednake klasifikatore s različitim hiperparametrima.
Razred sadržava metode fit(X, y) za učenje ansambla i dvije metode za predikciju: predict(X) i predict_proba(X). Prva vraća predviđene oznake klasa, a druga vjerojatnosti pripadanja svakoj od klasa za svaki od danih primjera iz X.
NB: Jedan od razreda koji bi Vam mogao biti koristan jest collections.Counter. Također vrijedi i za funkcije numpy.argmax i numpy.dstack.
Can you write Python code for it?

from collections import Counter

class VotingClassifierDIY(object):

    SCHEME_COUNTING = "counting"
    SCHEME_AVERAGING = "averaging"

    def __init__(self, clfs, voting_scheme=SCHEME_COUNTING):
        self.clfs = clfs
        self.voting_scheme = voting_scheme

    def fit(self, X, y):
        [ clf.fit(X,y) for clf in self.clfs ]

    def predict_proba(self, X):
        if self.voting_scheme == self.SCHEME_AVERAGING:
            pred_avg = []; pred = []; prob = [];

            for i in range(0, len(self.clfs)):
                pred.append(self.clfs[i].predict_proba(X))

            for i in range(0, shape(pred)[1]):
                prob = []
                for j in range(0, len(pred)):
                    prob.append(pred[j][i])
                pred_avg.append(mean(prob, axis = 0))

            return pred_avg

        else:
            raise Exception("Nemoze")

    def predict(self, X):
        if self.voting_scheme == self.SCHEME_AVERAGING:
            avg = self.predict_proba(X)
            return [ argmax(a) for a in avg ]

        elif self.voting_scheme == self.SCHEME_COUNTING:
            pred_cnt = []; pred = []; predd = [];

            predd = [ clf.predict(X) for clf in self.clfs ]

            for i in range(0, shape(predd)[1]): # 0 - 1000
                for j in range(0, len(predd)): # 0 - 3
                    pred.append(predd[j][i])

            for i in range(0, len(pred), 3):
                pred_cnt.append((Counter(pred[i:i+3]).most_common()[0])[0])

            return pred_cnt

        else:
            raise Exception("Nemoze")


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
Iscrtajte krivulje pogrešaka na skupu za učenje i ispitivanje u ovisnosti o hiperparametru $L \in [1,80]$. Koristite pogrešku 0-1 iz paketa metrics. Ispišite najmanju ostvarenu pogrešku na skupu za ispitivanje, te pripadajuću vrijednost hiperparametra $L$.
Can you write Python code for it?

L = list(range(0, 81))
error_train = []
error_test = []

for l in L:
    rfc = AdaBoostClassifier(base_estimator = DecisionTreeClassifier(max_depth = 1), n_estimators=l+1).fit(X_bag_train, y_bag_train)
    h_train = rfc.predict(X_bag_train)
    h_test = rfc.predict(X_bag_test)
    error_train.append(zero_one_loss(y_bag_train, h_train))
    error_test.append(zero_one_loss(y_bag_test, h_test))

minimal_error = min(error_test)
index_of_min = error_test.index(minimal_error)

print(minimal_error)
print(index_of_min)

figure(figsize(10, 5))
plot(L, error_train)
plot(L, error_test)
scatter(L[index_of_min], minimal_error)
grid()