I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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/SU-2018-LAB04-0036477171.ipynb".
The first task is:
Q: Kada je prebrojavanje bolje od usrednjavanja? Zašto? A obratno?
Q: Bi li se ovakav algoritam mogao primijeniti na regresiju? Kako?
2. Ansambli (bagging)
U ovom zadatku ćete isprobati tipičnog predstavnika bagging-algoritma, algoritam slučajnih šuma. Pitanje na koje želimo odgovoriti jest kako se ovakvi algoritmi nose s prenaučenošću, odnosno, smanjuje li bagging varijancu modela.
Eksperiment ćete provesti na danom skupu podataka:
Can you write Python code for it?

from sklearn.model_selection import train_test_split

X_bag, y_bag = make_classification(n_samples=1000, n_features=20, n_redundant=1, n_informative=17, n_classes=3, n_clusters_per_class=2)
X_bag_train, X_bag_test, y_bag_train, y_bag_test = train_test_split(X_bag, y_bag, train_size=0.7, test_size = 0.3, random_state=69)


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.ipynb".
The first task is:
Q: Koja je ML-procjena za $\mu$ i što je problem s takvom procjenom u ovome slučaju?
(d)
Prikažite beta-distribuciju $B(\mu|\alpha,\beta)$ za različite kombinacije parametara $\alpha$ i $\beta$, uključivo $\alpha=\beta=1$ te $\alpha=\beta=2$.
Can you write Python code for it?

from scipy.stats import beta

alphas = [ 1, 2, 3, 0.5, 1, 2, 3, 0.5 ]
betas = [ 1, 2, 3, 0.5, 0.5, 3, 2, 1 ]

for a, b in zip(alphas, betas):
    plot(u, beta.pdf(u, a, b))
grid()
axis([0, 1, 0, 3])


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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?

N = 10

figure(figsize(10, 8))
plot(u, L(u, N, 0))
plot(u, L(u, N, 9))
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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?

N = 10
m = 1
a = 4
b = 2

plot(u, beta.pdf(u, a, b))
plot(u, L(u, N, m))
plot(u, P(u, N, m, a, b))
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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?

D = list(range(1, 21))
error_train = []
error_test = []

for d in D:
    rfc = DecisionTreeClassifier(max_depth = d).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(D, error_train)
plot(D, error_test)
scatter(D[index_of_min], minimal_error)
grid()


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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

x = it.combinations(range(0,4), 2)

for i,j in x:
    pear = pearsonr(X[:,i], X[:,j])[0]
    print('from ', i, ' ', j, ' pear: ', pear)


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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/SU-2018-LAB04-0036477171.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

tree1 = DecisionTreeClassifier(max_depth = None).fit(X_bag_train, y_bag_train)
h1 = tree1.predict(X_bag_test)

print(zero_one_loss(y_bag_test, h1))

tree2 = DecisionTreeClassifier(max_depth= 10000000000).fit(X_bag_train, y_bag_train)
h2 = tree2.predict(X_bag_test)

print(zero_one_loss(y_bag_test, h2))


I am working on the file "STRUCE/2018/SU-2018-LAB04-0036477171.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

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

for l in L:
    rfc = RandomForestClassifier(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()


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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

print(ttest_rel(C1_scores_5folds, C2_scores_5folds).pvalue)
print(ttest_rel(C1_scores_10folds, C2_scores_10folds).pvalue)
print(ttest_rel(C1_scores_50folds, C2_scores_50folds).pvalue)


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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?

k_means = KMeans(n_clusters=2).fit(X1)

plt.scatter(X1[:,0], X1[:,1], c=k_means.predict(X1), cmap=plt.get_cmap("cool"), s=20);


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.ipynb".
The first task is:
Ponovno, 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?

k_means = KMeans(n_clusters=2).fit(X2)

plt.scatter(X2[:,0], X2[:,1], c=k_means.predict(X2), cmap=plt.get_cmap("cool"), s=20);


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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?

k_means = KMeans(n_clusters=3).fit(X3)

plt.scatter(X3[:,0], X3[:,1], c=k_means.predict(X3), cmap=plt.get_cmap("cool"), s=20);


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.ipynb".
The first task is:
Potreba za drugim metrikama osim točnosti može se vidjeti pri korištenju nekih osnovnih modela (engl. baselines). Možda najjednostavniji model takvog tipa je model koji svrstava sve primjere u većinsku klasu (engl. most frequent class; MFC) ili označuje testne primjere nasumično (engl. random). Proučite razred dummy.DummyClassifier i pomoću njega stvorite spomenute osnovne klasifikatore. Opet ćete trebati iskoristiti cjevovod kako biste došli do vektorskog oblika ulaznih primjera, makar ovi osnovni klasifikatori koriste samo oznake pri predikciji.
Can you write Python code for it?

from sklearn.dummy import DummyClassifier
rando = DummyClassifier(strategy='uniform')

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

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

mfc = DummyClassifier(strategy='most_frequent')

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

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


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.ipynb".
The first task is:
Q: Koja se metrika optimira pri ovoj optimizaciji?
Q: Kako biste odredili broj preklopa $k$?
(e)
Ako želimo procijeniti pogrešku, ali pritom i napraviti odabir modela, tada se okrećemo ugniježđenoj k-strukoj unakrsnoj provjeri (engl. nested k-fold cross validation). U ovom zadatku ćete ju sami implementirati.
Implementirajte funkciju nested_kfold_cv(clf, param_grid, X, y, k1, k2) koja provodi ugniježđenu k-struku unakrsnu provjeru. Argument clf predstavlja vaš klasifikator, param_grid rječnik vrijednosti hiperparametara (isto kao i u podzadatku (d)), X i y označeni skup podataka, a k1 i k2 broj preklopa u vanjskoj, odnosno unutarnjoj petlji. Poslužite se razredima model_selection.GridSearchCV i  model_selection.KFold.
Funkcija vraća listu pogrešaka kroz preklope vanjske petlje.
Can you write Python code for it?

from sklearn.model_selection import GridSearchCV, KFold

def nested_kfold_cv(clf, param_grid, X, y, k1=10, k2=3):
    err = []
    kfold = KFold(n_splits=k1, shuffle=True, random_state=42)

    for index_train, index_test in kfold.split(X):

        X_train, y_train, X_test, y_test = X[index_train], y[index_train], X[index_test], y[index_test]
        f = GridSearchCV(clf, param_grid, cv=k2).fit(X_train, y_train)
        h = f.best_estimator_.fit(X_train, y_train).predict(X_test)

        err.append(zero_one_loss(y_test, h))

    return err


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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

param_grid = {
    'vectorizer__max_features': [500, 1000],
    'reducer__n_components': [100, 200, 300]
}

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

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

f = GridSearchCV(pipeline, param_grid, cv = 3).fit(spam_X_train)
print(f.best_estimator_.fit(spam_X_train, spam_y_train).predict(spam_X_test))


I am working on the file "STRUCE/2018/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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/SU-2018-LAB05-0036477171.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/SU-2019-LAB01-0036477171.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. Zanemarite upozorenja.
Can you write Python code for it?

# Vaš kôd ovdje
d = 10

l0 = []
l1 = []
l2 = []

xTr, xTest, yTr, yTest = train_test_split(X2, y2, test_size=0.5)

for lambd in range(0,101):

    polyXTrain = PolynomialFeatures(10).fit_transform(xTr)
    polyXTest = PolynomialFeatures(10).fit_transform(xTest)

    r = sklearn.linear_model.Lasso(lambd).fit(polyXTrain, yTr)

    r.coef_[0] = r.intercept_

    l0.append(nonzeroes(r.coef_))
    #print(r.coef_)
    l1.append(numpy.linalg.norm(r.coef_, ord=1))
    l2.append(numpy.linalg.norm(r.coef_, ord=2))

figure(figsize=(10,10))
plot(l0, label="l0")
legend()

figure(figsize=(10,10))
plot(l1, label="l1")
legend()

figure(figsize=(10,10))
plot(l2, label="l2")
legend()


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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=10,\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?

# Vaš kôd ovdje

xTr, xTest, yTr, yTest = train_test_split(X2, y2, test_size=0.5)
figure(figsize=(10,10))
trainError = []
testError = []

#print(xTr)

for lambd in range(0,51):

    polyXTrain = PolynomialFeatures(10).fit_transform(xTr)
    polyXTest = PolynomialFeatures(10).fit_transform(xTest)

    l2 = Ridge(lambd).fit(polyXTrain, yTr)
    h2 = l2.predict(polyXTest)

    E = mt.mean_squared_error(h2, yTest)
    #print('d: ' + str(d) + ' E: ' + str(E))
    testError.append(log( E))

    h2 = l2.predict(polyXTrain)
    E = mt.mean_squared_error(h2, yTr)
    trainError.append(log(E))
    #print(p3)
    #plot(polyXTest, h2, label = str(d))
#print(numpy.log(numpy.array(testError)))
plot(numpy.log(numpy.array(testError)), label="test")
plot(numpy.log(numpy.array(trainError)), label="train")
grid()
legend()


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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 s in ['auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga']:
for l in [0, 1, 10]:

    r = Ridge(l, fit_intercept = False).fit(phi4, y1)
    print(r.coef_)
    print(r.intercept_)

    # Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
(b)
Razdvojite skup primjera iz zadatka 2 pomoću funkcije model_selection.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]$. 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

# Vaš kôd ovdje

xTr, xTest, yTr, yTest = train_test_split(X2, y2, test_size=0.5)

testError = []
trainError = []

for d in range(1,33):

    polyXTrain = PolynomialFeatures(d).fit_transform(xTr)
    polyXTest = PolynomialFeatures(d).fit_transform(xTest)

    l2 = LinearRegression().fit(polyXTrain, yTr)
    h2 = l2.predict(polyXTest)

    E = mt.mean_squared_error(h2, yTest)
    #print('d: ' + str(d) + ' E: ' + str(E))
    testError.append(E)

    h2 = l2.predict(polyXTrain)

    E = mt.mean_squared_error(h2, yTr)
    #print('d: ' + str(d) + ' E: ' + str(E))
    trainError.append(E)
    #print(p3)
    #plot(polyXTest, h2, label = str(d))

plot(numpy.log(numpy.array(testError)), label='test')
plot(numpy.log(numpy.array(trainError)), label='train')
legend()


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
(b)
Trenirajte model polinomijalne regresije stupnja $d=3$. Na istom grafikonu prikažite naučeni model $h(\mathbf{x})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$ i primjere za učenje. Izračunajte pogrešku učenja modela.
Can you write Python code for it?

# Vaš kôd ovdje
import sklearn.linear_model as lm

def polyX(d):

    p3 = PolynomialFeatures(d).fit_transform(X2)
    l2 = LinearRegression().fit(p3, y2)
    h2 = l2.predict(p3)

    E = mt.mean_squared_error(h2, y2)
    print('d: ' + str(d) + ' E: ' + str(E))
    #print(p3)
    plot(X2, h2, label = str(d))

scatter(X2, y2)
polyX(3)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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?

# Vaš kôd ovdje

try:
    w = matmul(inv(phi), y)
    print(w)
except LinAlgError as err:
    print("Exception")
    print(err)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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

# Vaš kôd ovdje
lr = LinearRegression().fit(X, y)
#print(lr.score(X, y))
#print(lr.coef_)
#print(lr.intercept_)
print([lr.intercept_, lr.coef_])

print(wt)

pr = lr.predict(X)
E = mt.mean_squared_error(pr, y)
print(E)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
2. Polinomijalna regresija i utjecaj šuma
(a)
Razmotrimo sada regresiju na većem broju primjera. Definirajte 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 možete koristiti funkciju 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) :
    # Vaš kôd ovdje
    N = numpy.random.normal
    fx = f(X)
    #nois = [N(0, noise) for _ in range(X.shape[0])]
    #print(nois)
    #y = f(X) + nois
    y = [ f(x) + N(0, noise) for x in X ]

    return y

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


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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?

# Vaš kôd ovdje
figure(figsize=(15,10))
scatter(X2, y2)
polyX(1)
polyX(3)
polyX(5)
polyX(10)
polyX(20)

s = plt.legend(loc="center right")


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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?

# Vaš kôd ovdje

N = 50

figure(figsize = (15, 15))
x123 = scatter(X2, y2)

for lambd in [0, 100]:
    for d in [2, 10]:
        phi2 = PolynomialFeatures(d).fit_transform(X2)
        r = Ridge(lambd).fit(phi2, y2)
        h2 = r.predict(phi2)
        #print(d)
        plot(X2, h2, label="lambda " + str(lambd) + " d " + str(d))

x321 = plt.legend(loc="center right")


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
6. L1-regularizacija i L2-regularizacija
Svrha regularizacije jest potiskivanje težina modela $\mathbf{w}$ prema nuli, kako bi model bio što jednostavniji. Složenost modela može se okarakterizirati normom pripadnog vektora težina $\mathbf{w}$, i to tipično L2-normom ili L1-normom. Za jednom trenirani model možemo izračunati i broj ne-nul značajki, ili L0-normu, pomoću sljedeće funkcije koja prima vektor težina $\mathbf{w}$:
Can you write Python code for it?

def nonzeroes(coef, tol=1e-6):
    return len(coef) - len(coef[np.isclose(0, coef, atol=tol)])


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
Prikažite taj skup funkcijom scatter.
Can you write Python code for it?

# Vaš kôd ovdje
N = 50
def f(x):
    return 5 + x - 2*x*x - 5*x*x*x
noise = 200

X2 = make_instances(-5, 5, N)
y2 = make_labels(X2, f, noise)

#print(X)
#print(y)

s = scatter(X2, y2)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
Q: Jesu li rezultati očekivani? Obrazložite.
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?

# Vaš kôd ovdje
phi4 = PolynomialFeatures(3).fit_transform(X1)

def reg2(lambd):
    w = matmul( matmul(inv( matmul(transpose(phi4), phi4) + lambd * identity(len(phi4))), transpose(phi4)), y1)
    print(w)

reg2(0)
reg2(1)
reg2(10)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
Q: Kako regularizacija utječe na stabilnost težina?
Q: Jesu li koeficijenti jednakih magnituda kao u prethodnom pokusu? Objasnite zašto.
c) Koristeći numpy.linalg.cond izračunajte kondicijski broj matrice $\mathbf{\Phi}^\intercal\mathbf{\Phi}+\lambda\mathbf{I}$, gdje je $\mathbf{\Phi}$ matrica dizajna (grades_X_fixed_colinear). Ponovite i za $\lambda=0.01$ i za $\lambda=10$.
Can you write Python code for it?

# Vaš kôd ovdje
#print(grades_X_fixed_colinear)
for l in [0.01, 10]:
    #print(l * identity(len(grades_X_fixed_colinear)))
    mm = matmul(transpose(grades_X_fixed_colinear), grades_X_fixed_colinear)
    matr = mm + l * identity(len(mm))
    print(matr)
    print(np.linalg.cond(matr))


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
Q: Usporedite iznose težina s onima koje ste dobili u zadatku 7b. Što se dogodilo?
b) Slučajno uzorkujte 50% elemenata iz skupa grades_X_fixed_colinear i naučite dva modela L2-regularizirane regresije, jedan s $\lambda=0.01$ i jedan s $\lambda=1000$). Ponovite ovaj pokus 10 puta (svaki put s drugim podskupom od 50% elemenata).  Za svaki model, ispišite dobiveni vektor težina u svih 10 ponavljanja te ispišite standardnu devijaciju vrijednosti svake od težina (ukupno šest standardnih devijacija, svaka dobivena nad 10 vrijednosti).
Can you write Python code for it?

# Vaš kôd ovdje

for lambd in [0.01, 1000]:
    print(lambd)
    ws1 = []
    ws2 = []
    ws3 = []
    for i in range(10):

        xTrain, xTest, yTrain, yTest = train_test_split(grades_X_fixed_colinear, ssY, test_size=0.5)

        print(l2.coef_)
        l2 = Ridge(lambd).fit(xTrain, yTrain)
        ws1.append(l2.coef_[0][0])
        ws2.append(l2.coef_[0][1])
        ws3.append(l2.coef_[0][2])

    print("std dev: " + str(np.std(ws1)))
    print("std dev: " + str(np.std(ws2)))
    print("std dev: " + str(np.std(ws3)))


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.ipynb".
The first task is:
Radi jasnoće, u nastavku je vektor $\mathbf{x}$ s dodanom dummy jedinicom $x_0=1$ označen kao $\tilde{\mathbf{x}}$.
(c)
Prikažite primjere iz $\mathcal{D}$ i funkciju $h(\tilde{\mathbf{x}})=\mathbf{w}^\intercal\tilde{\mathbf{x}}$. Izračunajte pogrešku učenja prema izrazu $E(h|\mathcal{D})=\frac{1}{2}\sum_{i=1}^N(\tilde{\mathbf{y}}^{(i)} - h(\tilde{\mathbf{x}}))^2$. Možete koristiti funkciju srednje kvadratne pogreške mean_squared_error iz modula sklearn.metrics.
Q: Gore definirana funkcija pogreške $E(h|\mathcal{D})$ i funkcija srednje kvadratne pogreške nisu posve identične. U čemu je razlika? Koja je "realnija"?
Can you write Python code for it?

import sklearn.metrics as mt

wt = w #(np.array([w]))

print(wt)
print(phi)

hx = np.dot(phi, w)

E = mt.mean_squared_error(hx, y)
print(E)

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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

# Vaš kôd ovdje
ssX = StandardScaler().fit_transform(grades_X)
ssY = StandardScaler().fit_transform(grades_y.reshape(-1, 1))
r = Ridge(0.01).fit(ssX, ssY)
h2 = r.predict(ssX)
E = mt.mean_squared_error(h2, ssY)
print(E)


I am working on the file "STRUCE/SU-2019-LAB01-0036477171.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?

# Vaš kôd ovdje

figure(figsize=(10,10))
scatter(exam_score, grades_y, label="l2")
legend()

figure(figsize=(10,10))
scatter(grade_in_highschool, grades_y, label="l2")
legend()


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.ipynb".
The first task is:
(a)
Prvo, isprobajte ugrađeni model na linearno odvojivom skupu podataka seven ($N=7$).
Can you write Python code for it?

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, 0, 0, 0])

# Vaš kôd ovdje
rc = RidgeClassifier()
rc.fit(seven_X, seven_y)

print(accuracy_score(seven_y, rc.predict(seven_X)))


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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?


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.ipynb".
The first task is:
(c)
Koristeći funkciju lr_train, trenirajte model logističke regresije na skupu seven, prikažite dobivenu granicu između klasa te  izračunajte pogrešku unakrsne entropije.
NB: Pripazite da modelu date dovoljan broj iteracija.
Can you write Python code for it?


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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?

# Vaš kôd ovdje

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

for a in [1,2,4]:
    #figure()
    r = [i / 10.0 for i in range(-30, 30)]
    plot(r, [sigm(i, a) for i in r])


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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?


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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?


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.ipynb".
The first task is:
Q: Očito je zašto model nije u mogućnosti postići potpunu točnost na ovom skupu podataka. Međutim, smatrate li da je problem u modelu ili u podacima? Argumentirajte svoj stav.
2. Višeklasna klasifikacija
Postoji više načina kako se binarni klasifikatori mogu se upotrijebiti za višeklasnu klasifikaciju. Najčešće se koristi shema tzv. jedan-naspram-ostali (engl. one-vs-rest, OVR), u kojoj se trenira po jedan klasifikator $h_j$ za svaku od $K$ klasa. Svaki klasifikator $h_j$ trenira se da razdvaja primjere klase $j$ od primjera svih drugih klasa, a primjer se klasificira u klasu $j$ za koju je $h_j(\mathbf{x})$ maksimalan.
Pomoću funkcije datasets.make_classification generirajte slučajan dvodimenzijski skup podataka od tri klase i prikažite ga koristeći funkciju plot_2d_clf_problem. Radi jednostavnosti, pretpostavite da nema redundantnih značajki te da je svaka od klasa "zbijena" upravo u jednu grupu.
Can you write Python code for it?

from sklearn.datasets import make_classification

# Vaš kôd ovdje
X, y = make_classification(
    n_classes=3, n_samples=100, n_features=2,
    n_informative=2, n_redundant=0, n_repeated=0, n_clusters_per_class=1)

mlutils.plot_2d_clf_problem(X, y)


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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)

# Vaš kôd ovdje

rc = RidgeClassifier()
rc.fit(unsep_X, unsep_y)

print(accuracy_score(unsep_y, rc.predict(unsep_X)))


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.ipynb".
The first task is:
Trenirajte tri binarna klasifikatora, $h_1$, $h_2$ i $h_3$ te prikažite granice između klasa (tri grafikona). Zatim definirajte $h(\mathbf{x})=\mathrm{argmax}_j h_j(\mathbf{x})$  (napišite svoju funkciju predict koja to radi) i prikažite granice između klasa za taj model. Zatim se uvjerite da biste identičan rezultat dobili izravno primjenom modela RidgeClassifier, budući da taj model za višeklasan problem zapravo interno implementira shemu jedan-naspram-ostali.
Q: Alternativna shema jest ona zvana jedan-naspram-jedan (engl, one-vs-one, OVO). Koja je prednost sheme OVR nad shemom OVO? A obratno?
Can you write Python code for it?

# Vaš kôd ovdje

for i in [0, 1, 2]:
    rc = RidgeClassifier()
    newY = [0 if yy == i else 1 for yy in y]
    rc.fit(X, newY)
    figure(figsize=(7,7))
    mlutils.plot_2d_clf_problem(X, rc.predict(X))


I am working on the file "STRUCE/SU-2019-LAB02-LDM-LR.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/SU-2019-LAB03-SVM-i-kNN.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/SU-2019-LAB03-SVM-i-kNN.ipynb".
The first task is:
(b)
Pomoću funkcije datasets.make_classification generirajte dva skupa podataka od $N=200$ primjera: jedan s $n=2$ dimenzije i drugi s $n=100$ dimenzija. Primjeri neka dolaze iz dviju klasa, s time da svakoj klasi odgovaraju dvije grupe (n_clusters_per_class=2), kako bi problem bio nešto složeniji, tj. nelinearniji. Neka sve značajke budu informativne. Podijelite skup primjera na skup za učenje i skup za ispitivanje u omjeru 1:1.
Na oba skupa optimirajte SVM s jezgrenom funkcijom RBF, u rešetci $C\in{2^{-5},2^{-4},\dots,2^{15}}$ i $\gamma\in{2^{-15},2^{-14},\dots,2^{3}}$. Prikažite površinu pogreške modela na skupu za učenje i skupu za provjeru, i to na oba skupa podataka (ukupno četiri grafikona) te ispišite optimalne kombinacije hiperparametara. Za prikaz površine pogreške modela možete koristiti funkciju mlutils.plot_error_surface.
Can you write Python code for it?

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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)

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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):
    pass


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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/SU-2019-LAB03-SVM-i-kNN.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_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 i krivulju za prosječne kosinusne udaljenosti (parametar metric).
Can you write Python code for it?

from sklearn.metrics.pairwise import pairwise_distances

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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, 250, 750}$ primjera. Načinite 3 zasebna grafikona. Za svaki 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/SU-2019-LAB03-SVM-i-kNN.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?


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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).
Can you write Python code for it?


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.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?


I am working on the file "STRUCE/SU-2019-LAB03-SVM-i-kNN.ipynb".
The first task is:
Q: Razlikuje li se površina pogreške na skupu za učenje i skupu za ispitivanje? Zašto?
Q: U prikazu površine pogreške, koji dio površine odgovara prenaučenosti, a koji podnaučenosti? Zašto?
Q: Kako broj dimenzija $n$ utječe na površinu pogreške, odnosno na optimalne hiperparametre $(C^, \gamma^)$?
Q: Preporuka je da povećanje vrijednosti za $\gamma$ treba biti popraćeno smanjenjem vrijednosti za $C$. Govore li vaši rezultati u prilog toj preporuci? Obrazložite.
4. Utjecaj standardizacije značajki kod SVM-a
U prvoj laboratorijskoj vježbi smo pokazali kako značajke različitih skala mogu onemogućiti interpretaciju naučenog modela linearne regresije. Međutim, ovaj problem javlja se kod mnogih modela pa je tako skoro uvijek bitno prije treniranja skalirati značajke, kako bi se spriječilo da značajke s većim numeričkim rasponima dominiraju nad onima s manjim numeričkim rasponima. To vrijedi i za SVM, kod kojega skaliranje nerijetko može znatno poboljšati rezultate. Svrha ovog zadataka jest eksperimentalno utvrditi utjecaj skaliranja značajki na točnost SVM-a.
Generirat ćemo dvoklasni skup od $N=500$ primjera s $n=2$ značajke, tako da je dimenzija $x_1$ većeg iznosa i većeg raspona od dimenzije $x_0$, te ćemo dodati jedan primjer koji vrijednošću značajke $x_1$ odskače od ostalih primjera:
Can you write Python code for it?

from sklearn.datasets import make_classification

X, y = make_classification(n_samples=500,n_features=2,n_classes=2,n_redundant=0,n_clusters_per_class=1, random_state=69)
X[:,1] = X[:,1]*100+1000
X[0,1] = 3000

mlutils.plot_2d_svc_problem(X, y)


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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)

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.ipynb".
The first task is:
(g)
Pročitajte ove upute o učitavanju oglednih skupova podataka. Učitajte skup podataka Iris. Taj skup sadrži $n=4$ značajke i $K=3$ klase. Odaberite jednu klasu i odaberite sve primjere iz te klase, dok ostale primjere zanemarite (u nastavku radite isključivo s primjerima iz te jedne klase). Vizualizirajte podatke tako da načinite 2D-prikaze za svaki par značajki (šest grafikona; za prikaz je najjednostavnije koristiti funkciju scatter).
NB: Mogla bi Vam dobro dući funkcija itertools.combinations.
Can you write Python code for it?

from sklearn.datasets import load_iris
import itertools as it

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.ipynb".
The first task is:
(h)
Pogledajte opis modul stats te proučite funkciju norm. Implementirajte funkciju log-izglednosti za parametre $\mu$ i $\sigma^2$ normalne distribucije.
Can you write Python code for it?

from scipy.stats import norm

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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):
        # Vaš kôd ovdje
        pass

    def fit(self, X, y):
        # Vaš kôd ovdje
        pass

    def predict_proba(self, X):
        # Vaš kôd ovdje
        pass

    def predict(self, X):
        # Vaš kôd ovdje
        pass


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.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?


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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.model_selection 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/SU-2019-LAB04-Ansambli-i-procjena-parametara.ipynb".
The first task is:
Q: Koja je ML-procjena za $\mu$ i što je problem s takvom procjenom u ovome slučaju?
(d)
Prikažite beta-distribuciju $B(\mu|\alpha,\beta)$ za različite kombinacije parametara $\alpha$ i $\beta$, uključivo $\alpha=\beta=1$ te $\alpha=\beta=2$.
Can you write Python code for it?

from scipy.stats import beta

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.ipynb".
The first task is:
Q: Koje parametere biste odabrali za modeliranje apriornog znanja o parametru $\mu$ za novčić za koji mislite da je "donekle pravedan, ali malo češće pada na glavu"? Koje biste parametre odabrali za novčić za koji držite da je posve pravedan? Zašto uopće koristimo beta-distribuciju, a ne neku drugu?
(e)
Definirajte funkciju za izračun zajedničke vjerojatnosti $P(\mu,\mathcal{D}) = P(\mathcal{D}|\mu) \cdot P(\mu|\alpha,\beta)$ te prikažite tu funkciju za $N=10$ i $m=9$ i nekolicinu kombinacija parametara $\alpha$ i $\beta$.
Can you write Python code for it?


I am working on the file "STRUCE/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB04-Ansambli-i-procjena-parametara.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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?

from sklearn.cluster import KMeans

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.ipynb".
The first task is:
Ponovno, 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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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_test = ["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_test)
x_test = reducer.transform(x_test)
x_test = normalizer.transform(x_test)
print(clf.predict(x_test))


I am working on the file "STRUCE/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.ipynb".
The first task is:
Q: Kako biste odabrali koji su hiperparametri generalno najbolji, a ne samo u svakoj pojedinačnoj unutarnjoj petlji?
Q: Čemu u konačnici odgovara procjena generalizacijske pogreške?
(f)
Scenarij koji nas najviše zanima jest usporedba dvaju klasifikatora, odnosno, je li jedan od njih zaista bolji od drugog. Jedini način kako to možemo zaista potvrditi jest statističkom testom, u našem slučaju uparenim t-testom. Njime ćemo se baviti u ovom zadatku.
Radi bržeg izvođenja, umjetno ćemo generirati podatke koji odgovaraju pogreškama kroz vanjske preklope dvaju klasifikatora (ono što bi vratila funkcija nested_kfold_cv):
Can you write Python code for it?

np.random.seed(1337)
C1_scores_5folds = np.random.normal(78, 4, 5)
C2_scores_5folds = np.random.normal(81, 2, 5)

C1_scores_10folds = np.random.normal(78, 4, 10)
C2_scores_10folds = np.random.normal(81, 2, 10)

C1_scores_50folds = np.random.normal(78, 4, 50)
C2_scores_50folds = np.random.normal(81, 2, 50)


I am working on the file "STRUCE/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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?
1. 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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.ipynb".
The first task is:
Q: Koja se metrika optimira pri ovoj optimizaciji?
Q: Kako biste odredili broj preklopa $k$?
(e)
Ako želimo procijeniti pogrešku, ali pritom i napraviti odabir modela, tada se okrećemo ugniježđenoj k-strukoj unakrsnoj provjeri (engl. nested k-fold cross validation). U ovom zadatku ćete ju sami implementirati.
Implementirajte funkciju nested_kfold_cv(clf, param_grid, X, y, k1, k2) koja provodi ugniježđenu k-struku unakrsnu provjeru. Argument clf predstavlja vaš klasifikator, param_grid rječnik vrijednosti hiperparametara (isto kao i u podzadatku (d)), X i y označeni skup podataka, a k1 i k2 broj preklopa u vanjskoj, odnosno unutarnjoj petlji. Poslužite se razredima model_selection.GridSearchCV i  model_selection.KFold.
Funkcija vraća listu pogrešaka kroz preklope vanjske petlje.
Can you write Python code for it?

from sklearn.model_selection import GridSearchCV, KFold

def nested_kfold_cv(clf, param_grid, X, y, k1=10, k2=3):

    # Vaš kôd ovdje
    pass


I am working on the file "STRUCE/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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

# Vaš kôd ovdje


I am working on the file "STRUCE/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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/SU-2019-LAB05-PGM-NB-Grupiranje-Vrednovanje.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?


I am working on the file "SUBPLOTS_PYT_DS_SAISOFT.ipynb".
The first task is:
Here we're talking to the axes objects more directly by calling "get current axes". Somewhat confusingly, the instances return have an "axes" attribute which points to the same instance, a wrinkle I explore below.  Note the slight difference between the last two lines.
Can you write Python code for it?

for i in range(1, 7):
    plt.subplot(2, 3, i)
    plt.text(0.5, 0.5, str((2, 3, i)),
             fontsize=18, ha='center')
    # synonymous.  gca means 'get current axes'
    plt.gca().get_yaxis().set_visible(False)
    plt.gca().axes.get_xaxis().set_visible(False) # axes optional, self referential
plt.gcf().subplots_adjust(hspace=0.1, wspace=0.1) # get current figure, adjust spacing


I am working on the file "SUBPLOTS_PYT_DS_SAISOFT.ipynb".
The first task is:
Here's subplot in action, creating axes automatically based on how many rows and columns we specify, followed by a sequence number i, 1 through however many (in this case six).
Notice how plt is keeping track of which subplot axes are current, and we talk to said axes through plt.
Can you write Python code for it?

for i in range(1, 7):
    plt.subplot(2, 3, i)
    plt.text(0.5, 0.5, str((2, 3, i)),
             fontsize=18, ha='center')
    plt.xticks([]) # get rid of tickmarks on x axis
    plt.yticks([]) # get rid of tickmarks on y axis


I am working on the file "SUBPLOTS_PYT_DS_SAISOFT.ipynb".
The first task is:
The first distinction to make is between Figure, which is the outer frame of a canvas, and the rectangular XY grids or coordinate systems we place within the figure.  XY grid objects are known as "axes" (plural) and most of the attributes we associate with plots are actually connected to axes.
What may be confusing to the new user is that plt (pyplot) keeps track of which axes we're working on, so we have ways of communicating with axes through plt which obscures the direct connection twixt axes and their attributes.
Below we avoid using plt completely except for initializing our figure, and manage to get two sets of axes (two plots inside the same figure).
Can you write Python code for it?

fig = plt.figure("main", figsize=(5,5)) # name or int id optional, as is figsize
ax1 = fig.add_axes([0.1, 0.5, 0.8, 0.4],
                   xticklabels=[], ylim=(-1.2, 1.2)) # no x axis tick marks
ax2 = fig.add_axes([0.1, 0.1, 0.8, 0.4],
                   ylim=(-1.2, 1.2))

x = np.linspace(0, 10)
ax1.plot(np.sin(x))
_ = ax2.plot(np.cos(x)) # assign to dummy variable to suppress text output

plt.figure?


I am working on the file "SUBPLOTS_PYT_DS_SAISOFT.ipynb".
The first task is:
The script below, borrowed from the matplotlib gallery, shows another common idiom for getting a figure and axes pair.  Call plt.suplots with no arguments.  Then talk to ax directly, for the most part. We're also rotating the x tickmark labels by 45 degrees.  Fancy!
Uncommenting the use('classic') command up top makes a huge difference in the result.  I'm still trying to figure that out.
Can you write Python code for it?

# plt.style.use('classic')
vegetables = ["cucumber", "tomato", "lettuce", "asparagus",
              "potato", "wheat", "barley"]
farmers = ["Farmer Joe", "Upland Bros.", "Smith Gardening",
           "Agrifun", "Organiculture", "BioGoods Ltd.", "Cornylee Corp."]

harvest = np.array([[0.8, 2.4, 2.5, 3.9, 0.0, 4.0, 0.0],
                    [2.4, 0.0, 4.0, 1.0, 2.7, 0.0, 0.0],
                    [1.1, 2.4, 0.8, 4.3, 1.9, 4.4, 0.0],
                    [0.6, 0.0, 0.3, 0.0, 3.1, 0.0, 0.0],
                    [0.7, 1.7, 0.6, 2.6, 2.2, 6.2, 0.0],
                    [1.3, 1.2, 0.0, 0.0, 0.0, 3.2, 5.1],
                    [0.1, 2.0, 0.0, 1.4, 0.0, 1.9, 6.3]])

fig, ax = plt.subplots()
im = ax.imshow(harvest)

# We want to show all ticks...
ax.set_xticks(np.arange(len(farmers)))
ax.set_yticks(np.arange(len(vegetables)))
# ... and label them with the respective list entries
ax.set_xticklabels(farmers)
ax.set_yticklabels(vegetables)

# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
         rotation_mode="anchor")

# Loop over data dimensions and create text annotations.
for i in range(len(vegetables)):
    for j in range(len(farmers)):
        text = ax.text(j, i, harvest[i, j],
                       ha="center", va="center", color="y")

ax.set_title("Harvest of local farmers (in tons/year)")
fig.tight_layout()


I am working on the file "SUPPLEMENTARY - Convolutions with sliding windows.ipynb".
The first task is:
Construct a single Gabor filter kernel with a wavelength of 8 and an angle of 60 degrees and select the imaginary component.
Can you write Python code for it?

WAVELENGTH = 8.0
THETA = np.pi / 3.0
k_complex = gabor_kernel(1.0/WAVELENGTH, THETA, 1.2)
k_imag = np.imag(k_complex)

plt.imshow(k_imag, cmap='gray', interpolation='none')
plt.imsave('images/single_kernel.png', k_imag, cmap='gray')


I am working on the file "SUPPLEMENTARY - Convolutions with sliding windows.ipynb".
The first task is:
Extract 128x128 windows from the image, with a spacing of 32 pixels, convolve with the Gabor kernel constructed above and make a montage of the result:
Can you write Python code for it?

windows = view_as_windows(img_small, (128,128), (32,32))
grid_shape = windows.shape[:2]
windows = windows.reshape((-1, 128,128))

window_feats = [-convolve(1-windows[i], k_imag)   for i in range(windows.shape[0])]

feats_3d = np.concatenate([c[None,:,:]   for c in window_feats], axis=0)
feats_montage = image_montage(feats_3d, padding=10, grid_shape=grid_shape)
plt.imshow(feats_montage, cmap='gray', interpolation='none')
plt.imsave('images/fruit_window_montage.png', feats_montage, cmap='gray')


I am working on the file "SUPPLEMENTARY - Convolutions with sliding windows.ipynb".
The first task is:
Imports:
Can you write Python code for it?

import os

import numpy as np

from matplotlib import pyplot as plt

from scipy.ndimage import convolve

from skimage.filters import gabor_kernel
from skimage.color import rgb2grey
from skimage.util.montage import montage2d
from skimage.util import view_as_windows
from skimage.transform import downscale_local_mean


I am working on the file "SUPPLEMENTARY - Convolutions with sliding windows.ipynb".
The first task is:
Load a photo of some fruit:
Can you write Python code for it?

IMAGE_PATH = os.path.join('images', 'fruit.JPG')
# Extract a square block
img = rgb2grey(plt.imread(IMAGE_PATH)[:1536,:1536])
print img.shape
plt.imshow(img, cmap='gray')
plt.show()


I am working on the file "SUPPLEMENTARY - Convolutions with sliding windows.ipynb".
The first task is:
Some utility functions for making an image montage for display and padding images:
Can you write Python code for it?

def image_montage(im_3d, padding=1, cval=None, grid_shape=None):
    if cval is None:
        return montage2d(np.pad(im_3d, [(0,0), (padding, padding), (padding, padding)], mode='constant'),
                        grid_shape=grid_shape)
    else:
        return montage2d(np.pad(im_3d, [(0,0), (padding, padding), (padding, padding)], mode='constant',
                                constant_values=[(0,0), (cval,cval), (cval,cval)]), grid_shape=grid_shape)

def pad_image(img, shape):
    d0 = shape[0]-img.shape[0]
    d1 = shape[1]-img.shape[1]
    p0a = d0/2
    p0b = d0-p0a
    p1a = d1/2
    p1b = d1-p1a
    return np.pad(img, [(p0a, p0b), (p1a, p1b)], mode='constant')


I am working on the file "SUPPLEMENTARY - Standardisation.ipynb".
The first task is:
A subset of the samples with the mean and standard deviation plotted; the mean as at the centre of the cross and the lines that pass through it extend 1 standard deviation to either side.
PCA whitening
We can use PCA to extract the primary axes of variance and plot them. Note that we retain all axes; we do not use PCA to reduce dimensionality.
Can you write Python code for it?

pca = PCA(n_components=3, whiten=True)
pca.fit(samples_rgb)

fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlabel('R')
ax.set_ylabel('G')
ax.set_zlabel('B')
ax.scatter(z[:,0], z[:,1], z[:,2],
           marker='+', alpha=0.1, c='black')
# Get the mean and principal component axes and scale the axes by the standard deviation
mu = pca.mean_[None,:]
pc0 = pca.components_[0:1,:] * np.sqrt(pca.explained_variance_[0])
pc1 = pca.components_[1:2,:] * np.sqrt(pca.explained_variance_[1])
pc2 = pca.components_[2:3,:] * np.sqrt(pca.explained_variance_[2])

# Create the principal component lines
r = np.append(mu-pc0, mu+pc0, axis=0)
g = np.append(mu-pc1, mu+pc1, axis=0)
b = np.append(mu-pc2, mu+pc2, axis=0)

# Plot the principal components
ax.plot(r[:,0], r[:,1], r[:,2], color='red')
ax.plot(g[:,0], g[:,1], g[:,2], color='green')
ax.plot(b[:,0], b[:,1], b[:,2], color='blue')

ax.set_xlim(-0.25, 1.25)
ax.set_ylim(-0.25, 1.25)
ax.set_zlim(-0.25, 1.25)
ax.view_init(elev=45., azim=-45)


I am working on the file "SUPPLEMENTARY - Standardisation.ipynb".
The first task is:
Create a 3D plot.
Can you write Python code for it?

fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlabel('R')
ax.set_ylabel('G')
ax.set_zlabel('B')
ax.scatter(samples_rgb_subset[:,0], samples_rgb_subset[:,1], samples_rgb_subset[:,2],
           marker='+', alpha=0.1, c='black')
ax.view_init(elev=45., azim=-45)


I am working on the file "SUPPLEMENTARY - Standardisation.ipynb".
The first task is:
Load the entire dataset into an array and scale from the range [0,255] to [0,1].
Can you write Python code for it?

X, y = dataset.get_data(request=range(dataset.num_examples))
X = X / 255.0


I am working on the file "SUPPLEMENTARY - Standardisation.ipynb".
The first task is:
The samples are primarily aligned along the X-axis.
Full PCA whitening
PCA whitening adds one final step; after rotating the samples so that the principal components are aligned with the standard basis axes, the samples are scaled by the reciprocal of the standard deviation so that the distribution has unit variance.
Can you write Python code for it?

# Turn whitening back on.
pca.whiten = True
z_whitened = pca.transform(z)

fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlabel('pcw-0')
ax.set_ylabel('pcw-1')
ax.set_zlabel('pcw-2')
ax.scatter(z_whitened[:,0], z_whitened[:,1], z_whitened[:,2],
           marker='+', alpha=0.1, c='black')
# Get the mean and principal component axes and scale the axes by the standard deviation
mu = np.array([[0,0,0]])
pc0 = np.array([[1,0,0]])
pc1 = np.array([[0,1,0]])
pc2 = np.array([[0,0,1]])

# Create the principal component lines
r = np.append(mu-pc0, mu+pc0, axis=0)
g = np.append(mu-pc1, mu+pc1, axis=0)
b = np.append(mu-pc2, mu+pc2, axis=0)

# Plot the principal components
ax.plot(r[:,0], r[:,1], r[:,2], color='red')
ax.plot(g[:,0], g[:,1], g[:,2], color='green')
ax.plot(b[:,0], b[:,1], b[:,2], color='blue')

# Explicitly set the range that we are plotting to ensure uniform scale
ax.set_xlim(-3, 3)
ax.set_ylim(-3, 3)
ax.set_zlim(-3, 3)
ax.view_init(elev=45., azim=-45)


I am working on the file "SUPPLEMENTARY - Standardisation.ipynb".
The first task is:
The samples with the principal components extracted by PCA.
Rotate the samples onto the standard basis axes.
Use the PCA instance to rotate the samples onto the standard basis axes.
Can you write Python code for it?

# Turn whitening off temporarily so that we don't scale the samples yet.
pca.whiten = False
z_basis = pca.transform(z)

fig = plt.figure(figsize=(12,8))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlabel('pc-0')
ax.set_ylabel('pc-1')
ax.set_zlabel('pc-2')
ax.scatter(z_basis[:,0], z_basis[:,1], z_basis[:,2],
           marker='+', alpha=0.1, c='black')
# Get the mean and principal component axes and scale the axes by the standard deviation
# The mean is now at 0,0,0 since PCA will have subtracted it from each sample, moving
# the mean there
mu = np.array([[0,0,0]])
# The principal components have now been rotated onto the standard basis axes.
# Scale by the standard deviation.
pc0 = np.array([[1,0,0]]) * np.sqrt(pca.explained_variance_[0])
pc1 = np.array([[0,1,0]]) * np.sqrt(pca.explained_variance_[1])
pc2 = np.array([[0,0,1]]) * np.sqrt(pca.explained_variance_[2])

# Create the principal component lines
r = np.append(mu-pc0, mu+pc0, axis=0)
g = np.append(mu-pc1, mu+pc1, axis=0)
b = np.append(mu-pc2, mu+pc2, axis=0)

# Plot the principal components
ax.plot(r[:,0], r[:,1], r[:,2], color='red')
ax.plot(g[:,0], g[:,1], g[:,2], color='green')
ax.plot(b[:,0], b[:,1], b[:,2], color='blue')

# Explicitly set the range that we are plotting to ensure uniform scale
ax.set_xlim(-0.75, 0.75)
ax.set_ylim(-0.75, 0.75)
ax.set_zlim(-0.75, 0.75)
ax.view_init(elev=45., azim=-45)


I am working on the file "SVD Classification of Handwritten Digits.ipynb".
The first task is:
In the below bit of code, I made a function to separate the dataset into just 5 classes for demonstration purposes (only 0, 1, 2, 3, and 4). I also separated each of these digit datasets into a train and test dataset by assigning the first 80% of the dataset to train, and the rest for test. This is for each digit dataset.
I then compute the SVD for each train dataset so that I will have zero_u, one_u, ... , four_u. These will be the left singular vectors which I will use later for classification purposes.
Can you write Python code for it?

def getTrainTest(digit):
    digit_train = digit[0:int(len(digit)*.8)]
    digit_train = digit_train[digit_train.columns[1:]].T
    digit_test = digit[int(len(digit)*.8):]
    digit_test = digit_test[digit_test.columns[1:]]
    return (digit_train,digit_test)

zero = data[data['label']==0]
zero_train,zero_test = getTrainTest(zero)

one = data[data['label']==1]
one_train,one_test = getTrainTest(one)

two = data[data['label']==2]
two_train,two_test = getTrainTest(two)

three = data[data['label']==3]
three_train,three_test = getTrainTest(three)

four = data[data['label']==4]
four_train,four_test = getTrainTest(four)

zero_u,e,v = np.linalg.svd(zero_train,full_matrices=False)
one_u,e,v = np.linalg.svd(one_train,full_matrices=False)
two_u,e,v = np.linalg.svd(two_train,full_matrices=False)
three_u,e,v = np.linalg.svd(three_train,full_matrices=False)
four_u,e,v = np.linalg.svd(four_train,full_matrices=False)

#Regarding full_matrices = False
#If True, U and Vh are of shape (M,M), (N,N).
#If False, the shapes are (M,K) and (K,N), where K = min(M,N).

print zero_u.shape
print e.shape
print v.shape


I am working on the file "SVD Classification of Handwritten Digits.ipynb".
The first task is:
Seeing the singular vectors reconstructed is pretty cool. Especially the '0' one. See below for '3' and '0'.
Can you write Python code for it?

for i in range(4):
    plt.imshow(three_u[:,i].reshape(28,28),cmap='Greys')#first 5 columns of U
    plt.show()

for i in range(4):
    plt.imshow(zero_u[:,i].reshape(28,28),cmap='Greys')#first 5 columns of U
    plt.show()


I am working on the file "SVD Classification of Handwritten Digits.ipynb".
The first task is:
Similarly doing this for the four classifier, we see that it's pretty good but it's confusing 4's for 3's more than 1's,2's, and 0's. I guess the middle line of the '3' digit might be contributing to some confusion.
Can you write Python code for it?


I am working on the file "SVD Classification of Handwritten Digits.ipynb".
The first task is:
So that's what the dataset looks like, each pixel is a column, each row is an image in the dataset. Actually I have a corresponding 'test' dataset but I'll just separate this one into train/test later on since it's big enough.
All values are grayscale 0-255. Here are some images below. I just reshaped each image vector into 28x28 for showing.
Can you write Python code for it?

print data.iloc[1][0]
plt.imshow(data.iloc[1][1:].reshape(28,28),cmap='Greys')
plt.show()
print data.iloc[28][0]
plt.imshow(data.iloc[28][1:].reshape(28,28),cmap='Greys')
plt.show()

np.unique(data['label'],return_counts=True)


I am working on the file "SVD Classification of Handwritten Digits.ipynb".
The first task is:
Woops forgot to print the 4 predictions. The above computation takes a few minutes and really beats up the CPU.
Can you write Python code for it?

print "4: ", four_pred.count(4)/1.0/len(four_pred)


I am working on the file "SVG_Table_Builder.ipynb".
The first task is:
Convert the %quickref Text to a Dictionary
Can you write Python code for it?

from Build_dict import build_dict #to build a dictionary out of the %quickref text file

lines = quickref_text.split('\n')
Quick_ref_dic = build_dict(lines) #this parses the text and builds an ordered dict out of it.

#make a list of all the headings
heading =list(Quick_ref_dic.keys())