# Commits

committed 02d1fd1

Veliko novega.

• Participants
• Parent commits 2fc7ffb
• Branches default

# File predavanja/cv.md

• Ignore whitespace
`+K-kratno prečno preverjanje`
`+===========================`
`+`
`+Učne primere razdelimo na K približno enako velikih kosov.`
`+`
`+`
`+1. Napiši funkcijo `logloss(y, P)`, ki implementira`
`+[Multi Class Log Loss](https://www.kaggle.com/wiki/MultiClassLogLoss) - mero,`
`+ki jo želimo na tekmovanju minimizirati.`
`+`
`+        >>> P = majority(X, y, X)`
`+        >>> logloss(y, P)`
`+        1.098612288668108`
`+`
`+        >>> y = np.array([0, 2, 1, 1])`
`+        >>> P = np.array([`
`+        ...     [0.7, 0.1, 0.2],`
`+        ...     [0.1, 0.1, 0.8],`
`+        ...     [0.2, 0.7, 0.1],`
`+        ...     [0.4, 0.5, 0.1],`
`+        ... ])`
`+        >>> logloss(y, P)`
`+        0.407410154937905`
`+`
`+    <div class="solution">`
`+`
`+        def logloss(y, P):`
`+            # Vrstice se morajo sesteti v 1.`
`+            P = P / np.sum(P, axis=1)[:,None]`
`+`
`+            # Iz vsake vrstice izberemo stolpec, ki nas zanima.`
`+            p = P[xrange(y.size), y]`
`+`
`+            # Verjetnosti izven intervala (1e-15, 1 - 1e-15) odscipnemo.`
`+            eps = 1e-15`
`+            p = np.clip(p, eps, 1 - eps)`
`+`
`+            return -np.mean(np.log(p))`
`+    </div>`

• Ignore whitespace
` <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">`
` <style type="text/css">`
`-	body { font-family: Helvetica; margin: auto; width: 960px;}`
`+body {`
`+	font-family: Verdana; `
`+	margin: auto; `
`+	width: 800px;`
`+}`
` </style>`
` <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>`
` <script type="text/javascript">`

# File predavanja/majority.md

• Ignore whitespace
` Večinski klasifikator (Majority)`
` ================================`
` `
`+Večinski klasifikator je prav gotovo eden izmed najbolj preprostih`
`+algoritmov, ki jih srečamo v strojnem učenju. Njegovo delovanje`
`+najlažje razložimo na primeru.  Recimo, da je v učni množici 100`
`+primerov. 60 v prvem razredu, 30 v drugem, preostalih 10 pa v tretjem`
`+razredu. Večinski klasifikator bo za vsak testni primer napovedal`
`+verjetnosti `[0.6, 0.3, 0.1]`, ne glede na atribute primera. `
` `
`+Najbrž je težko videti kdaj bi bil tako preprost algoritem sploh`
`+uporaben. Ponavadi ga boste uporabili, ko boste točnost svojega`
`+klasifikatorja želeli primerjati z nekim osnovnim modelom.`
` `
`-`majority(X, y, X_test)``
` `
`+1. Naloži podatke `iris.data`. Prve štiri stolpce spravi v redko`
`+matriko `X`, zadnjega pa v navaden seznam `y`. Čeprav podatki niso redki,`
`+se bomo delali kot da so.`
` `
`-	def majority(X, y, X_test):`
`-		hist = np.bincount(y)`
`-		hist_normalized = hist / float(np.sum(hist))`
`-		return np.tile(hist_normalized, (X_test.shape[0], 1))`
`+	<div class="solution">`
`+`
`+		data = np.loadtxt('iris.data')`
`+		X, y = sp.csr_matrix(data[:,:-1]), data[:,-1].astype(np.int)`
`+	</div>`
`+`
`+`
`+2. Napiši funkcijo `majority(X, y, X_test)`,`
`+ki implementira večinski klasifikator`
`+([namig](http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html)).`
`+Funkcijo preverite na podatkih iris.`
`+`
`+		>>> P = majority(X, y, X)`
`+		>>> P.shape`
`+		(150, 3)`
`+		>>> P`
`+		array([[ 0.33333333,  0.33333333,  0.33333333],`
`+			   [ 0.33333333,  0.33333333,  0.33333333],`
`+			   ...`
`+			   [ 0.33333333,  0.33333333,  0.33333333]])`
`+`
`+`
`+	<div class="solution">`
`+`
`+		def majority(X, y, X_test):`
`+			hist = np.bincount(y)`
`+			hist_normalized = hist / float(np.sum(hist))`
`+			return np.tile(hist_normalized, (X_test.shape[0], 1))`
`+	</div>`
`+`
`+Večinski klasifikator na EMC podatkih`
`+=====================================`
`+`
`+1. S pomočjo knjižnice`
`+[EMC_IO](http://www.kaggle.com/c/emc-data-science/data), ki so jo`
`+napisali organizatorji, preberite podatke tekmovanja. Redko matriko`
`+`X` sestavite tako, da zložite matriki `70_30_train_data.csv` in`
`+`70_30_test_data.csv` (v tem vrstnem redu), seznam `y` pa zgradite`
`+iz vsebine datoteke `70_30_train_labels.csv`. `
`+`
`+		>>> X.shape`
`+		(175315, 592158)`
`+		>>> type(X)`
`+		<class 'scipy.sparse.csr.csr_matrix'>`
`+		>>> y.shape`
`+		(122663,)`
`+		>>> type(y)`
`+		<type 'numpy.ndarray'>`
`+`
`+	Na koncu vse skupaj`
`+	[zapiklajte](http://docs.python.org/library/pickle.html), da vam ne bo`
`+	treba vsakič znova brati vhodne podatke, s čimer boste pohitrili zagon`
`+	vašega programa.`
`+`
`+	<div class="solution">`
`+`
`+		import pickle`
`+		import EMC_IO`
`+`
`+		X_tr = EMC_IO.EMC_ReadData('70_30_train_data.csv')`
`+		X_te = EMC_IO.EMC_ReadData('70_30_test_data.csv')`
`+		y = EMC_IO.EMC_ReadLabels('70_30_train_labels.csv')`
`+`
`+		# Ne pozabite na tocsr ...`
`+		X = sp.vstack((X_tr, X_te)).tocsr()`
`+`
`+		# ... ali na pickle.HIGHEST_PROTOCOL!`
`+		pickle.dump((X, y), open('data.pkl', 'wb'), pickle.HIGHEST_PROTOCOL)`
`+	</div>`
`+`
`+2. Na učnih podatkih zgradite večinski klasifikator in z njim napovejte`
`+testne podatke. Porazdelitev razredov na učnih podatkih je`
`+`
`+		[ 0.00307346  0.00035871  0.00398653 ...,  0.00031794  0.00064404 0.00178538]`
`+`
`+	<div class="solution">`
`+`
`+		X, y = pickle.load(open('data.pkl', 'rb'))`
`+		num_train = y.size`
`+`
`+		P = majority(X[:num_train], y, X[num_train:])`
`+		print P`
`+	</div>`
`+`
`+3. Napiši funkcijo `submit(P)`, ki sprejme matriko napovedanih verjetnosti`
`+in jih, v csv formatu, zapiše v izhodno datoteko `submission.csv` `
`+([namig](http://docs.scipy.org/doc/numpy/reference/generated/numpy.savetxt.html)).`
`+Dodatne točke dobite, če vam uspe izhodno datoteko skompresirati.`
`+`
`+	<div class="solution">`
`+`
`+		def submit(P):`
`+			np.savetxt('submission.csv.gz', P, delimiter=',')`
`+`
`+		P = majority(X[:num_train], y, X[num_train:])`
`+		submit(P)`
`+	</div>`
`+`
`+4. S programom `validate.py` ocenite kvaliteto večinskega klasifikatorja.`
`+`
`+	\$ validate.py submission.csv.gz`
`+	3.39244154342`

# File predavanja/sparse.md

• Ignore whitespace
` 	import numpy as np`
` 	import scipy.sparse as sp`
` `
`+ter da sta matriki `X` in `Xcsr` definirani tako`
`+`
`+	X = [[1.0, 0, 1.0, 2.0],`
`+		 [6.0, 0, 0  , 0  ],`
`+		 [0  , 0, 0  , 0  ],`
`+		 [0  , 0, 0  , 9.0],`
`+		 [0  , 0, 0  , 0  ]]`
`+		 `
`+	Xcsr = sp.csr_matrix(X)`
`+`
` 1. V `scipy`ju so redke matrike predstavljene s tremi `numpy`jevimi`
` tabelami: `data`, `indices` in `indptr`. Kakšna je njihova vsebina,`
` ko matriko `X` zapišemo v formatu `csr`. Kaj pa v formatu `csc`?`
` `
`-		X = [[1.0, 0, 1.0, 2.0],`
`-		     [6.0, 0, 0  , 0  ],`
`-		     [0  , 0, 0  , 0  ],`
`-		     [0  , 0, 0  , 9.0],`
`-		     [0  , 0, 0  , 0  ]]`
`-`
` 	<div class="solution">`
` `
` 	V formatu `csr`:`
` `
` 	</div>`
` `
`-2. Napiši program, ki izračuna vsoto vseh elementov redke matrike `Xcsr = sp.csr_matrix(X)``
`+2. Napiši program, ki izračuna vsoto vseh elementov redke matrike `Xcsr`.`
` 	`
` 	<div class="solution">`
` `
` 		print Xcsr.toarray()`
` 	</div>`
` `
`-4. Napiši program, ki v matriki `Xcsr` obdrži le stolpce, ki vsebujejo vsaj dve neničelni vrednosti.`
`+4. Podan imaš `numpy`jev seznam `row_indices = np.array([True, False, False, True, True])`.`
`+Napiši program, ki v matriki `Xcsr` obdrži le tisti vrstice, pri katerih je ustrezna`
`+vrednost v seznamu `row_indices` enaka `True`. V primeru iz naloge bi torej obdržali prvo,`
`+četrto in peto vrstico.`
`+`
`+	<div class="solution">`
`+`
`+		Xcsr = Xcsr[np.nonzero(row_indices)[0]]`
`+		print Xcsr.toarray()`
`+	</div>`
`+`
`+5. Napiši program, ki v matriki `Xcsr` obdrži le stolpce, ki vsebujejo vsaj dve neničelni vrednosti.`
` `
` 	<div class="solution">`
` `