Iti0210lab112 - Redigeerimiste ajalugu

PriitJ: /* Kategooriate teisendamine numbriteks */

2018-11-28T18:49:24Z

Kategooriate teisendamine numbriteks

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 20:49
111. rida:		111. rida:
	0 0 1		0 0 1

	Lihtsalt numbritega asendamine ~~ei sobi hästi,~~ näiteks ~~kui ütleme~~, et ''low'' on 0, ''med'' 0.5 ja ''high'' 1,		Lihtsalt numbritega asendamine on ka võimalik (näiteks, ''low'' - 0, ''med'' - 0.5, ''high'' - 1.0), aga üldiselt on abstraktsete nähtuste, nagu suur, väike, punane või roheline, ühele numbrilisele skaalale paigutamine kahtlane idee.
	~~siis tekivad nendele väärtustele ka soovimatud seosed~~, ~~näiteks ''3 * med > high''~~.

	<code>pandas</code> paketiga:		<code>pandas</code> paketiga:

PriitJ: /* Lahenduse esitamine */

2018-11-28T16:06:52Z

Lahenduse esitamine

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 18:06
237. rida:		237. rida:
	== Lahenduse esitamine ==		== Lahenduse esitamine ==

	Tekita oma tegevustest logi, kus on näha kõikide katsetuste numbrilised tulemused (klassifitseerimise tulemused, precision, recall). Kõiki käske/programmikoodi ära logisse kopeeri~~, kuna see on juba juhendis olemas~~ - asenda see lühikese selgitusega, mida tehti.		Tekita oma tegevustest logi, kus on näha kõikide katsetuste numbrilised tulemused (klassifitseerimise tulemused, precision, recall). Kõiki käske/programmikoodi ära logisse kopeeri - asenda see lühikese selgitusega, mida tehti.

	== Mida veel saab teha ==		== Mida veel saab teha ==

PriitJ – 28. november 2018, kell 16:05

2018-11-28T16:05:32Z

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 18:05
10. rida:		10. rida:
	* http://scikit-learn.org/stable/index.html - Python; juhend eeldab, et kasutatakse seda		* http://scikit-learn.org/stable/index.html - Python; juhend eeldab, et kasutatakse seda
	* http://www.cs.waikato.ac.nz/ml/weka/ - Java		* http://www.cs.waikato.ac.nz/ml/weka/ - Java

			Ülesanne koosneb mõnedest katsetest, mille tulemustest tuleb koostada logi või raport ja see moodles esitada.

	=== Andmete kirjeldus ===		=== Andmete kirjeldus ===
225. rida:		227. rida:

	Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.		Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.

	<!--		<!--
	=== Minimaalne võrk ===		=== Minimaalne võrk ===
234. rida:		235. rida:
	nnc = neural_network.MLPClassifier(hidden_layer_sizes=min_shape, max_iter=1000)		nnc = neural_network.MLPClassifier(hidden_layer_sizes=min_shape, max_iter=1000)
	-->		-->
			== Lahenduse esitamine ==

			Tekita oma tegevustest logi, kus on näha kõikide katsetuste numbrilised tulemused (klassifitseerimise tulemused, precision, recall). Kõiki käske/programmikoodi ära logisse kopeeri, kuna see on juba juhendis olemas - asenda see lühikese selgitusega, mida tehti.

	== Mida veel saab teha ==		== Mida veel saab teha ==

PriitJ: /* Kategooriate teisendamine numbriteks */

2018-11-28T15:48:38Z

Kategooriate teisendamine numbriteks

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 17:48
106. rida:		106. rida:
	1 0 0		1 0 0
	0 1 0		0 1 0
	1 0 1		1 0 0
	0 0 1		0 0 1

PriitJ: /* Närvivõrk */

2018-11-28T12:27:03Z

Närvivõrk

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 14:27
226. rida:		226. rida:
	Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.		Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.

			<!--
	=== Minimaalne võrk ===		=== Minimaalne võrk ===

232. rida:		233. rida:
	min_shape = (2,)		min_shape = (2,)
	nnc = neural_network.MLPClassifier(hidden_layer_sizes=min_shape, max_iter=1000)		nnc = neural_network.MLPClassifier(hidden_layer_sizes=min_shape, max_iter=1000)
			-->

	== Mida veel saab teha ==		== Mida veel saab teha ==

PriitJ: /* Närvivõrk */

2018-11-28T12:17:21Z

Närvivõrk

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 14:17
225. rida:		225. rida:

	Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.		Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.

			=== Minimaalne võrk ===

			Milline võiks olla kõige väiksem võrk, mis selle ülesandega hakkama saab? Kui sisendandmeid vaadata, siis idee tundub olevat umbes, et mida odavam ja suurem auto, seda parem. Mis juhtub, kui pressime kõik sisendandmed läbi kahe neuroni (idee oleks, et üks hakkab treenides näitama rahalist sobivust ja teine piisavat suurust):

			min_shape = (2,)
			nnc = neural_network.MLPClassifier(hidden_layer_sizes=min_shape, max_iter=1000)

	== Mida veel saab teha ==		== Mida veel saab teha ==

PriitJ: /* Andmete balansseerimine */

2018-11-28T11:46:56Z

Andmete balansseerimine

←Vanem redaktsioon		Redaktsioon: 28. november 2018, kell 13:46
192. rida:		192. rida:
	=== Andmete balansseerimine ===		=== Andmete balansseerimine ===

	Katsetame hüpoteesi, et andmete tasakaalustatus mõjutab seda, kui edukalt kõige haruldlasemat klassi "vgood" leitakse. Testandmeid me ei puutu, muudame ainult treeningandmeid, mille pealt närvivõrku õpetatakse. Paneme kõikide vähem esinenud klasside kohta ridu juurde, nii et neid oleks võrdselt "unacc" klassiga ja klasside jaotus oleks 25% iga klassi kohta.		Katsetame hüpoteesi, et andmete tasakaalustatus mõjutab seda, kui edukalt kõige haruldlasemat klassi "vgood" leitakse. Ehk siis, võibolla läheb närvivõrk mõnikord lihtsama vastupanu teed ja kipub ennustama muid klasse, kuna "vgood"-i niikuinii eriti ei esine. Testandmeid me ei puutu, muudame ainult treeningandmeid, mille pealt närvivõrku õpetatakse. Paneme kõikide vähem esinenud klasside kohta ridu juurde, nii et neid oleks võrdselt "unacc" klassiga ja klasside jaotus oleks 25% iga klassi kohta.

	Tükeldame treeningandmed:		Tükeldame treeningandmed:

PriitJ: Uus lehekülg: '= Klassifitseerimine: otsustuspuu ja närvivõrk = == Sissejuhatus == Kodutöös proovime otsustuspuu ja närvivõrguga andmete klassifitseerimist. Katsetamiseks on andmestik a...'

2018-11-28T11:40:21Z

Uus lehekülg: '= Klassifitseerimine: otsustuspuu ja närvivõrk = == Sissejuhatus == Kodutöös proovime otsustuspuu ja närvivõrguga andmete klassifitseerimist. Katsetamiseks on andmestik a...'

Uus lehekülg

= Klassifitseerimine: otsustuspuu ja närvivõrk =

== Sissejuhatus ==

Kodutöös proovime otsustuspuu ja närvivõrguga andmete klassifitseerimist. Katsetamiseks on andmestik autode mõnedest parameetritest, iga auto kohta on antud hinnang, kas see on hea või halb ost. Andmestikul on mõningad eripärad: see on sünteetiline, ehk siis mitte korjatud päris klientidelt, vaid tekitatud mingi statistika alusel. Teiseks ei ole andmestik tasakaalus.

Vali masinõppeks sobiv tarkvarapakett. Allolev juhend eeldab, et kasutad Pythonit, muude vahenditega tuleb iseseisvalt hakkama saada.

Soovitatud masinõppe teegid (vali üks):
* http://scikit-learn.org/stable/index.html - Python; juhend eeldab, et kasutatakse seda
* http://www.cs.waikato.ac.nz/ml/weka/ - Java

=== Andmete kirjeldus ===

Väljavõtted [https://archive.ics.uci.edu/ml/machine-learning-databases/car/car.names täielikust kirjeldusest]:

<pre>
Car Evaluation Database was derived from a simple hierarchical
decision model originally developed for the demonstration of DEX
(M. Bohanec, V. Rajkovic: Expert system for decision
making. Sistemica 1(1), pp. 145-157, 1990.). The model evaluates
cars according to the following concept structure:

CAR car acceptability
. PRICE overall price
. . buying buying price
. . maint price of the maintenance
. TECH technical characteristics
. . COMFORT comfort
. . . doors number of doors
. . . persons capacity in terms of persons to carry
. . . lug_boot the size of luggage boot
. . safety estimated safety of the car
</pre>

Statistika:

<pre>
Number of Instances: 1728
(instances completely cover the attribute space)

Number of Attributes: 6
</pre>

Tunnused ja nende väärtused:

<pre>
Attribute Values:

buying v-high, high, med, low
maint v-high, high, med, low
doors 2, 3, 4, 5-more
persons 2, 4, more
lug_boot small, med, big
safety low, med, high

Missing Attribute Values: none
</pre>

Klassid (päris andmetes on "vgood", mitte "v-good"):

<pre>
class N N[%]
-----------------------------
unacc 1210 (70.023 %)
acc 384 (22.222 %)
good 69 ( 3.993 %)
v-good 65 ( 3.762 %)
</pre>

== Ettevalmistus ==

Andmed lae alla [https://archive.ics.uci.edu/ml/machine-learning-databases/car/car.data siit].

Kõigepealt tuleb andmed sisse lugeda. Käsitsi ei ole seda keeruline teha, aga näiteks Anacondaga tuleb kaasa <code>pandas</code> pakett:

<pre>
import pandas

# veergude nimed võetud kirjeldusest
features = ["buying", "maint", "doors", "persons", "lug_boot", "safety"]

car_data = pandas.read_csv("car.data",
header=None,
names=features + ["class"])
</pre>

Tulemuseks on [http://nbviewer.ipython.org/github/jvns/pandas-cookbook/blob/v0.1/cookbook/Chapter%202%20-%20Selecting%20data%20&%20finding%20the%20most%20common%20complaint%20type.ipynb <code>DataFrame</code> tüüpi objekt]. See formaat on <code>scikit-learn</code> paketi poolt hästi toetatud ning paljud meetodid oskavad seda otse sisse süüa.

=== Kategooriate teisendamine numbriteks ===

Osad masinõppe tehnikad nõuavad juba oma olemuselt numbrilist sisendit (närvivõrk), teiste puhul võib see tuleneda implementatsioonist. Korrektne viis kategooriate teisendamiseks on need asendada umbes nii:

Algandmed:
uksi
2
2
4
2
5more

Teisendatud:
uksi_2 uksi_4 uksi_5more
1 0 0
1 0 0
0 1 0
1 0 1
0 0 1

Lihtsalt numbritega asendamine ei sobi hästi, näiteks kui ütleme, et ''low'' on 0, ''med'' 0.5 ja ''high'' 1,
siis tekivad nendele väärtustele ka soovimatud seosed, näiteks ''3 * med > high''.

<code>pandas</code> paketiga:

<pre>
X_text = car_data.loc[:, features]

X = pandas.get_dummies(X_text)
print(X.columns)

y = car_data["class"]
</pre>

== Otsustuspuu ==

Jaotame andmed treening- ja testandmeteks. Selleks on juba valmisfunktsioon. Esialgu teeme andmed lihtsalt kaheks suureks tükiks: 70% treeninguks ja 30% testiks:

from sklearn.model_selection import train_test_split
# no shuffling
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, shuffle=False)

Nüüd treenime otsustuspuu (kui tahad täpsemalt uurida, vt [https://scikit-learn.org/stable/modules/tree.html#tree juhend]):

<pre>
from sklearn import tree
dtc=tree.DecisionTreeClassifier()
dtc.fit(X_train, y_train)

# puu on treenitud, vaatame kiirelt, kui hästi ta testandmeid klassifitseerib:
dtc.score(X_test, y_test)
</pre>

Täpsus on üsna madal. Mis juhtus? Kui vaatad sisendfaili, siis on seal read sorteeritud. Test- ja treeningandmeteks tükeldamisel satuvad ühte poolde rohkem ühesugused näited ja teise poolde teistsugused. See ei ole hea mõte, sest see tähendab, et treenime tahtlikult ebasobivate andmetega. Lubame nüüd <code>train_test_split</code> meetodil read juhuslikult ära segada:

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3)

Puu uuesti treenimisel peaks tulema palju parem klassifitseerimise täpsus.

Tegeleme nüüd teise küsimusega: saadud täpsus on keskmine üle kõigi klasside, mis siis kui meid huvitavad just need autod, mis on "väga head"?

<pre>
from sklearn.metrics import precision_recall_fscore_support

y_predicted = dtc.predict(X_test)
precision, recall, _, _ = precision_recall_fscore_support(
y_predicted, y_test, average=None, labels=["vgood"])
</pre>

Siin <code>precision</code> ütleb meile, kui palju autosid, mille kohta otsustuspuu ütles "väga hea" ehk "vgood", olid õigesti klassifitseeritud - kui see arv ei ole 1.0, oli meil valepositiivseid tulemusi. <code>recall</code> on aga number, mis ütleb, kui suur osa "väga häid" autosid kogu testandmestikust üles leiti. Teisiti öeldes, kas leidus ka valenegatiivseid tulemusi.

== Närvivõrk ==

Jätkame sama treening- ja testandmete jaotusega, et erinevaid tehnikaid omavahel otse võrrelda.

Esimene kiire test (põhjaliku närvivõrkude õpetuse leiad [https://scikit-learn.org/stable/modules/neural_networks_supervised.html#mlp-tips siit]).

from sklearn import neural_network
nnc = neural_network.MLPClassifier(hidden_layer_sizes=(10,))
nnc.fit(X_train, y_train)
nnc.score(X_test, y_test)

Ainukese kasutatud parameetriga <code>hidden_layer_sizes</code> ütlesime ette, et võrk peaks koosnema sisenditest (leitakse automaatselt), 10 neuroniga peidetud kihist ning väljundkihist (tekitatakse automaatselt sõltuvalt treeningandmetest). Võimalik, et treenimisel kaebab närvivõrk, et tal ei olnud piisavalt aega kaalude konvergeerumiseks. Siis lisame iteratsioone:

nnc = neural_network.MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000)

Närvivõrgu võib teha ka ambitsioonikama, näiteks lisame mitu kihti, mis on sama suured kui sisendkiht:

n_features = X_train.shape[1]
nnc_shape = (n_features, n_features, 10)
nnc = neural_network.MLPClassifier(hidden_layer_sizes=nnc_shape, max_iter=1000)

Proovi, kas klassifitseerimise täpsuse skoor kasvas, võrreldes väiksema võrguga.

Otsustuspuu puhul proovisime ka, kui täpselt ühte konkreetset klassi suudetakse leida. Kordame seda katset:

y_nnc = nnc.predict(X_test)
precision, recall, _, _ = precision_recall_fscore_support(y_nnc, y_test, average=None, labels=["vgood"])

=== Andmete balansseerimine ===

Katsetame hüpoteesi, et andmete tasakaalustatus mõjutab seda, kui edukalt kõige haruldlasemat klassi "vgood" leitakse. Testandmeid me ei puutu, muudame ainult treeningandmeid, mille pealt närvivõrku õpetatakse. Paneme kõikide vähem esinenud klasside kohta ridu juurde, nii et neid oleks võrdselt "unacc" klassiga ja klasside jaotus oleks 25% iga klassi kohta.

Tükeldame treeningandmed:

X1 = X_train[y_train == "unacc"]
X2 = X_train[y_train == "acc"]
X3 = X_train[y_train == "good"]
X4 = X_train[y_train == "vgood"]
y1 = y_train[y_train == "unacc"]
y2 = y_train[y_train == "acc"]
y3 = y_train[y_train == "good"]
y4 = y_train[y_train == "vgood"]

Genereerime juhuslikult juurde samasuguseid ridu, kui andmetes juba esineb (uusi "juhtumeid" ei leiutata):

<pre>
from sklearn.utils import resample

biggest_class = X1.shape[0]

X2r, y2r = resample(X2, y2, n_samples=biggest_class)
X3r, y3r = resample(X3, y3, n_samples=biggest_class)
X4r, y4r = resample(X4, y4, n_samples=biggest_class)

print(X4r.shape)
</pre>

Paneme tükid uuesti kokku. Seejuures "unacc" klassi näiteid ei puudutatud.

X_balanced = pandas.concat([X1, X2r, X3r, X4r])
y_balanced = pandas.concat([y1, y2r, y3r, y4r])

Treeni nüüd närvivõrk uuesti <code>*_balanced</code> andmetega ja vaata, mida annab <code>score</code> meetod ning kas paraneb klassi "vgood" leidmine.

== Mida veel saab teha ==

Need viited on huvi pärast edasi uurimiseks, seda osa pole kohustuslik teha.

# [https://scikit-learn.org/stable/modules/tree.html#classification Otsustuspuu joonistamine]
# [http://scikit-learn.org/stable/modules/cross_validation.html#computing-cross-validated-metrics Ristvalideerimine]