Tallinna Ülikool
Kvalitatiivne digihumanitaaria
Jaagup Kippar
Tallinn 2019
________________
Sisukord
Andmepuud 6
Vajaliku leidmine 6
Harjutus 7
Järgnevustest moodustatud puu 7
XML 8
Harjutus 9
JSON 11
Harjutus 11
Puu loomine programmiga 12
Harjutus 13
Sõnaliikide puu 14
Harjutus 15
Väljundi kohendamine 15
Harjutus 17
XML-väljund 17
Harjutus 21
Lauseliikmete puu 21
Harjutus 24
Algandmete näitamine puus 24
Täiendused uues versioonis. 27
Harjutus 30
Andmepuu regiviiside näitel 31
Tabelarvutusleht 31
Ligipääs programmeerimiskeelega 33
Väärtuste loendamine 34
Harjutus 37
Harjutus - puu koostamine 37
Andmepuu väljatrükk 39
Harjutus 43
Järjestuste sagedused 43
Harjutus 45
Erinevuse üldistatavus 45
Kahe teksti tähepaaride võrdlemine 46
Harjutus 49
Libisevalt leitud lõigud 50
Rõhutatud kohtadest algavad lõigud 52
Harjutus 53
Graaf ehk võrgustik 54
Gephi 54
Harjutus 57
Seoste faili genereerimine 57
Harjutus 61
Viisilõik graafina 61
Algus ja ots 63
Harjutus 64
Koordinaatide järgi paigutus 64
GeoLayouti installimine 66
Harjutus 67
Animatsioon graafiga 67
Seoste ajatelg 69
Ajavahemikud 71
Harjutus 73
Seosed vastavalt löögile 73
Harjutus 79
Veebiteenused 79
Leht lehes 80
Harjutus 81
JSON 81
Harjutus 82
Leht vastavalt parameetrile 83
Harjutus 83
RSSi lugemine 85
Harjutus 89
Kaardirakendused 89
Maa-ameti kaardid Leafletiga 89
Harjutus 92
OpenStreetMap 92
Hüpikmenüü 93
Harjutus 95
Koordinaadid nimetuse järgi 95
Koordinaatide kuvamine kaardile 101
Harjutus 104
Valitud algusnootidega viiside asukohad 104
Harjutus 108
MIDI helid 108
Harjutus 110
Valitud helistiku noodid 111
Järjestikku kõlavad noodid 112
Harjutus 113
Regiviisi mängimine 114
Viisi andmepuu koostamine 117
Jooniste koostamine 123
Algusnäide 123
Harjutus 125
Regiviiside intervallide sagedused tulpdiagrammina 125
Harjutus 127
Graafijoonis Cytoscape abil 127
Graafi andmete muutmine 130
Harjutus 133
Viisi nootide järgnevus 133
Chart.js 136
Harjutus 137
Värvide lisamine, mitu andmerida 137
Harjutus 140
Sektordiagramm 140
Harjutus 142
Joonis veebist loetud andmete põhjal 143
Kordamisküsimused 148
Kokkuvõte 149
________________
Sissejuhatus
Kvalitatiivse uurimisviisi puhul saab andmeid mitmel moel esitades ja võrreldes ka siis kasutatava tulemuseni jõuda, kui meil ühele statistilisele meetodile toetudes pole võimalik piisavat usaldusväärset järeldust saavutada. Digivaldkonna areng pakub märgatavalt võimalusi andmete illustreerimiseks, seoste leidmiseks ja esitamiseks ning sealtkaudu mõistmiseks, et mil moel miski protsess toimib ning millised variatsioonid sel on. Siinses materjalis näidatakse, kuidas ümber käia andmepuude ja -võrgustikega, kuidas nende abil välja tuua seoseid, mis tabeli või loeteluna andmetele peale vaadates ehk kohe välja ei paista. Õpitakse andmete esitamiseks animatsioone looma, kus aja- või mõnel muul teljel väärtusi vahetades näeb protsesside ja nendega kaasnevate nähtuste suunda. Paljude andmetega käib kaasas asukoht - nii tutvutakse kaardirakenduse võimalustega. Muusikat saab nii uurida kui illustreerimisel kasutada. Märgatav osa näiteid toetub Eesti Kirjandusmuuseumi Eesti Rahvaluule Arhiivist kasutamiseks antud eesti regiviiside andmebaasi koopiale ning autor tänab Arhiivi näidete mitmekesistamise võimaluse eest.
________________
Andmepuud
Uurijad püüavad leitut süstematiseerida - ikka selleks, et parem ülevaade oleks ning kättesaadavate vahendite abil õnnestuks muidu segaseks jääma kippuvat andmestikku hallata.
Vajaliku leidmine
Andmepuu on hea moodus suure hulga teabe sees orienteerumiseks. Tüüpiliseks näiteks on veebilehestik. Avalehele saab kirjutada tutvustuse ja tähtsamad andmed. Vähegi keerukamas lehestikus aga kasutaja paratamatult ei vaja kõiki andmeid kohe kätte. Menüüvalikuga kannatab lisada mõned alateemad, selgema süsteemiga menüü puhul ka mõnikümmend teemaviidet avalehele nii, et sealt suudab sobivalt edasi liikuda.
Disainerid rõhutavad vahel "kolme kliki reeglit" - ehk siis kasutajale tundub veebileht mugav, kui ta saab omale vajaliku lehe kätte avalehelt kolme klõpsuga. Sealtkaudu veidi arvutades leiab, et erisuguse hargnemisteguri ehk lehtedel olevate viidete arvu puhul võib avalehelt kolme klõpsuga jõutavate lehtede arv päris erinev olla. Kui pealehel vaid ligikaudu viis suuremat valikut nagu väiksematel tutvustuslehtedel tavaks, siis pääseb esimese vajutusega viiele, teisega 5x5 ehk 25le ning kolmandaga 125 lehe peale. Aruka läbi mõtlemise peale õnnestub päris palju kasutajale vajalikku teavet veidi rohkem kui sajale lehele paigutada.
Kus andmekogused suuremad, seal tuleb nende kättesaadavamaks muutmiseks ka igale lehele rohkem valikuid anda. Otsimislehe neti.ee avalehel on vähemasti viiskümmend valikut ning alanejate juures ligikaudu sama palju. Nii pääseb kolme klõpsuga juba 50x50x50 ehk 125000 lehe peale, mis on märgatavalt suurem kogus.
Kui tõsiselt tarviliku sisu jaoks ollakse valmis veel teised kolm klõpsu ka tegema, siis ühtlaselt jaotatud ja puusse paigutatud andmestiku korral on võimalik orienteeruda andmetes, kus veebilehti on rohkem kui inimesi maakeral.
Harjutus
* Otsi mõni puukujuline andmestik, vaata, mida on sealt võimalik välja lugeda
* Jälgi, mitmeks harunetakse iga taseme juures, mis on vähim ja suurim hargnemistegur
* Koosta omapoolne puukujuline andmestik
Järgnevustest moodustatud puu
Üheks mooduseks andmetega lähemaks tutvumiseks on sarnaste osade või lõikude otsimine olgu kirjalike tekstide, meloodiate või arvuliste mõõtmistulemuste jada juures. Kindla pikkusega lõike on hea võrrelda, loendada ja järjestada. Sellisel puhul loetakse täiesti erinevaks aga ka juba ühe elemendi võrra erinevat jada. Andmepuu võimaldab hakkama saada erisuguste lõigupikkustega ning nendegi juures levinumad kohad välja tuua ja ettepoole järjestada.
Tutvustuseks mõned näited. Jadaks on tähed sõnas - hiljem saab aga sarnaselt järjestada sõnaliike, lauseliikmeid, noote või tööoperatsioone. Esitatavateks sõnadeks siin “tere” ja “tervis”. Ehk siis esimesed kolm tähte samad, edasi tuleb hargnemine.
tere
tervis
Taande kaudu puusse tõstetuna näevad sõnad välja nõnda
t
e
r
e
v
i
s
Juurde kannatab kirjutada ka iga koha sageduse
t 2
e 2
r 2
e 1
v 1
i 1
s 1
XML
Andmete mugavamaks lugemiseks silmade ja masinaga loodi 2000. aastaks XML keel
Näeb välja eelmisest kirjum, kuid nõnda on igasugu lisaandmete tarbeks kohad olemas. Ühtlasi võimaldab veebilehitseja XML puu harusid kokku ja lahku klõpsida vastavalt vajadusele.
Allolevas näites alates v-st hargnev alampuu on kinni.
Harjutus
* Paiguta tekstina puu kujuliselt sõnad "tere", "tervis" ja "tervitus"
* Kopeeri sõnade "tere" ja "tervis" tähtede XML-esitus omaette faili. Veendu, et saad tagumist sõnapoolt brauseris avada ja sulgeda. Faili laiendiks .xml
* Lisa puusse sõna "tervitus"
* Koosta uus tühi puu. Pane näitele sarnaselt XML-andmepuusse sõnade te-re, ter-vis ning ter-vi-tus silbid
Sõnade tere, tervis ja tervitus tähed
Sõnade tere, tervis ja tervitus silbid
Puu Microsoft Wordi Smart Art vahenditega. Ülaltasemeks on alustamiseks punkt, taanded tehtud tabulaatoritega. Smart Art kuvab puu joonisena
Sisend:
.
ter
vi
tus
vis
te
re
Tulemuseks tehtud joonis:
JSON
XMList veidi lühem on JSON (JavaScript Object Notation), kus samuti võimalik masinale arusaadavalt andmete struktuur üles märkida ning pärast sobivad väärtused välja küsida. Sama kahe sõna näide, iga tähe alamelemendiks (tähele vastavaks objektiks) on vastava tähe esinemise kogus (praegu lõpus) ning loetelu tema sees olevatest tähtedest. Sellisena suudab andmed sisse võtta näiteks Pythoni keel ning siis all näites küsitakse, et mitu korda vastavat järgnevust (praegu “te”) esines.
andmed={
't':{
'e':{
'r':{
'e':{
'kogus':1
},
'v':{
'i':{
's':{
't':{
'kogus':1
},'kogus':1
},'kogus':1
},'kogus':1
},'kogus':2
},'kogus':2
},'kogus':2
},'kogus':2
}
print(andmed["t"]["e"]["kogus"])
jaagup@praktika1 ~/public_html/2018/kval/18puu $ python3.5 puu2.py
2
Sulge lugedes ja süvenedes paistab, et “te” kogus on kõrvuti elemendiga ‘r’ - samuti, nagu “ter”-i kogus on kõrvuti elementidega ‘e’ ja ‘v’. Ehk siis praeguse üleskirjutuskuju puhul peame arvestama, et "kogus" on erilise nimega väli, mis ütleb, mitu korda vastavat tähte oli, mille elemendi sees kogus kirjas on.
Harjutus
* Pane eelmisega sarnaselt JSON-puusse sõnade te-re, ter-vis ja ter-vi-tus silbid.
* Kuva silbi "ter" esinemiskordade arv
* Kuva silbijärjendi "ter"-"vi" esinemiskordade arv
Puu loomine programmiga
Mõne või suurema püsivuse korral ka mõnesaja järgnevuse andmete puusse sättimine tuleb käsitsi välja. Suurematest andmestikest aga tuhandete või kümnete tuhandete sarnasuste leidmiseks on kasulik tarkvara luua või kasutada. Kuna põhioperatsioonid saab mõne(teistkümne) käsu abil programmeerimiskeele abil ette anda, siis siin seda teed pidi läheme, koostame puud loovat programmi lihtsamast keerulisema poole. Hiljem saab vastavalt andmete tüübile vajalikke täiendusi teha.
Algus võimalikult lihtne ja lühike. Muutujasse nimega andmed hakkame koguma sõnade tähtede andmepuud. Muutuja plokk tegeleb selle kohaga, kus parajasti andmepuus ollakse. Et alustame puu juurest, siis algul plokk=andmed. Puusse paigutatavaks täheks on kõigepealt sõna esimene täht (Pythonis järjekorranumbriga 0). Tuleviku huvides siia tingimus, et kui täht on juba olemas, siis saab selle tähe koguse loendurit suurendada. Esialgu aga selle asemel käsklus pass ehk käsk puudub. Kui tähte plokis ei ole (nagu praegu alguses), siis minnakse else-ossa, luuakse ploki sisse võti parasjagu paigutatava tähe (praegu ‘h’) väärtusega ning määratakse selle tähe koguseks 1.
andmed={}
sona="hei"
taht=sona[0]
plokk=andmed
if taht in plokk:
pass
else:
plokk[taht]={'kogus':1}
print(andmed)
Väljatrüki tulemus:
jaagup@praktika1 ~/public_html/2018/kval/18puu $ python3.5 puu3.py
{'h': {'kogus': 1}}
Täiendusena suurendatakse tähe olemasolul plokis vastava tähe kogust. Nt. kui puusse paigutatakse kaks h-tähega algavat sõna, siis saab puu juurest väljuva h-tähe haru koguseks 2. Pärast tähe paigutamist puus suunatakse muutuja plokk näitama selle tähe kohale
plokk=plokk[taht]
Nii on võimalik väärtused koos kogustega puusse kirjutada. Väljatrükiks tuleb küsida võtmed sobivas järjekorras ning lõppu kogus vastavate korduste arvu teada saamiseks
print(andmed["h"]["e"]["kogus"])
Kood tervikuna
andmed={}
sona="hei"
plokk=andmed
for taht in sona:
if taht in plokk:
plokk[taht][kogus]+=1
else:
plokk[taht]={'kogus':1}
plokk=plokk[taht]
print(andmed)
print(andmed["h"]["e"]["kogus"])
ja väljund. Sulge lugedes näha, et h sees on e ning e sees i, juures kõigil kogus väärtusega 1
jaagup@praktika1 ~/public_html/2018/kval/18puu $ python3.5 puu4.py
{'h': {'kogus': 1, 'e': {'kogus': 1, 'i': {'kogus': 1}}}}
1
Sama koodilõik näitega, kus puusse paigutatakse sõnad “hei” ja “hi”. Järjestuse “h” koguseks tuleb siis 2, “he” puhul aga 1.
andmed={}
sonad=["hei", "hi"]
for sona in sonad:
plokk=andmed
for taht in sona:
if taht in plokk:
plokk[taht]["kogus"]+=1
else:
plokk[taht]={'kogus':1}
plokk=plokk[taht]
print(andmed)
print(andmed["h"]["kogus"])
print(andmed["h"]["e"]["kogus"])
jaagup@praktika1 ~/public_html/2018/kval/18puu $ python3.5 puu5.py
{'h': {'i': {'kogus': 1}, 'e': {'i': {'kogus': 1}, 'kogus': 1}, 'kogus': 2}}
2
1
Harjutus
* Pane näited käima
* Vaata ühe sõnaga näite tulemust mõne muu sõna puhul
* Pane teise näitesse mitu omapoolset sõna sisse ja jälgi tulemust.
Sõnaliikide puu
Eelnev näide tehti lihtsuse mõttes sõnade tähtede peal. Sarnased puusse paigutamised tulevad aga ette igal pool, kus järgnevustega tegemist. Järgnevused aga digihumanitaarias tähtis mõõdetav/võrreldav nähtus - olgu tegemist sündmustüüpidega filmis või ajaloos, nootide/intervallidega muusikapalas või keele uuringu juures ette tulevate üksustega. Puu harude sageduste leidmine võimaldab meil ennustada jada järgmist elementi või siis lihtsalt iseloomustada ja võrrelda nähtusi.
Alustuseks paar lauset, milles leiduvate sõnade liigid välja trükitakse.
Klass Text paketist estnltk võimaldab küsida sõnade liigid lausete kaupa.
from estnltk import Text
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "jookseb linna"]
for lause in laused:
print(Text(lause).postags)
jaagup@praktika1 ~/public_html/2018/kval/17graaf $ python3.5 sonaliigid1.py
['H', 'V', 'S']
['H', 'V', 'V', 'S']
['V', 'S']
Sõnaliikide seletused:
H - pärisnimi
V - tegusõna (verb)
S - nimisõna (substantiiv)
ehk siis lause “Juku tuli kooli” puhul on “Juku” H ehk pärisnimi, “tuli” tegusõna ning “kooli” nimisõna.
Nende põhjal loodud puu näeb välja järgmine:
H
V
S
V
S
V
S
Programmilõik töötab sarnaselt eelmisele, ainult et endise tähtederea asemel on nüüd sõnaliikide rida ning puu teeks juurest leheni on endise sõna asemel terve lause.
from estnltk import Text
laused=["Juku tuli kooli", "Juku tuli joostes kooli"]
andmed={}
for lause in laused:
plokk=andmed
for sonaliik in Text(lause).postags:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
print(andmed)
jaagup@praktika1 ~/public_html/2018/kval/18puu $ python3.5 puu6.py
{'H': {'V': {'V': {'kogus': 1, 'S': {'kogus': 1}}, 'kogus': 2, 'S': {'kogus': 1}}, 'kogus': 2}}
Sama vastus loetavuse huvides trepituna
{'H':
{'kogus': 2,
'V': {'kogus': 2,
'S': {'kogus': 1},
'V':
{'kogus': 1,
'S': {'kogus': 1}}
}
},
'V':
{'kogus': 1,
'S': {'kogus': 1}
}
}
Harjutus
* Pane näide käima
* Katseta tööd ja tulemust omapoolse paari veidi sarnase lausega
Väljundi kohendamine
Mälus oleva andmepuu saab print-käsu abil eelnevalt näha oleva JSONi kujul välja trükkida. Eriti aga suuremate andmete puhul tasub parema ülevaate saamiseks sealt sobivaid väljavõtteid teha. Siin näites luuakse eraldi alamprogramm nimega tryki, kus kuvatakse puus etteantud koha (sõlme) alamsõlmed koos nende kogustega. Allpool kuvatakse vasted juurelemendile (kahel korral pärisnimi, ühel korral verb, järjekord pole esialgu tähtis), siis pärisnime alamelement (verb kahel korral) ning lõpuks järgnevuse HV alamelemendid (ühel korral S ja ühel korral V)
from estnltk import Text
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "jookseb linna"]
andmed={}
for lause in laused:
plokk=andmed
for sonaliik in Text(lause).postags:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
print(andmed)
def tryki(solm):
for voti in solm:
if not voti=="kogus":
print(voti+"("+str(solm[voti]["kogus"])+")")
tryki(andmed)
print()
tryki(andmed["H"])
print()
tryki(andmed["H"]["V"])
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus1.py
{'V': {'S': {'kogus': 1}, 'kogus': 1}, 'H': {'kogus': 2, 'V': {'S': {'kogus': 1}, 'kogus': 2, 'V': {'S': {'kogus': 1}, 'kogus': 1}}}}
V(1)
H(2)
V(2)
S(1)
V(1)
Viimatises näites näeb korraga vaid ühe taseme elemente ning nad kõik on vastu rea vasakut serva. Puus või alampuus alamelementide jälgimiseks on nad mugav servast sobivale kaugusele treppida - nii pääseb ülalt alla vaadates jälgima, et mis samale tasemele kuulub. Funktsiooni tryki viimase käsuna kutsutakse sama funktsioon uuesti välja - ainult et ühe taseme võrra sügavamalt - muidugi ainult juhul, kui seal veel andmeid on.
from estnltk import Text
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "jookseb linna"]
andmed={}
for lause in laused:
plokk=andmed
for sonaliik in Text(lause).postags:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
print(andmed)
def tryki(solm, tase):
for voti in solm:
if not voti=="kogus":
print((tase*" ")+voti+"("+str(solm[voti]["kogus"])+")")
tryki(solm[voti], tase+1)
tryki(andmed, 0)
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus2.py
{'H': {'kogus': 2, 'V': {'kogus': 2, 'S': {'kogus': 1}, 'V': {'kogus': 1, 'S': {'kogus': 1}}}}, 'V': {'kogus': 1, 'S': {'kogus': 1}}}
H(2)
V(2)
S(1)
V(1)
S(1)
V(1)
S(1)
Harjutus
* Pane näited käima. Lisa paar lauset ja vaata puud.
* Loe sisend tekstifailist. Koosta sõna tähtede puu ja trüki see trepituna välja.
XML-väljund
Eelnevalt tutvustatud XML-kuju on mugav vorming andmete jaoks, mida peavad lugema nii masinad kui ka inimesed. Alustuseks väike näide andmete sisse lugemise ja välja kirjutamise kohta. Pythonis XMLiga toimetamise juures on mugav kasutada paketti nimega xml.dom.minidom. Sealne käsklus parseString teeb etteantud ja korrektsel kujul XML-tekstist XML-andmete objekti. Hiljem tagasi teksti kujule saab selle käsuga toxml().
from xml.dom.minidom import parseString
p=parseString("")
print(p.toxml())
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus3.py
Nagu näha, pandi XML-failile kohustuslik versiooninumbriga päis ka juurde.
Järgmine veidi pikem näide tühja dokumendi loomise ning sinna külge elementide paigutamise kohta.
Luuakse tühi dokument
d=xml.dom.minidom.Document()
tehakse alamelement nimega s
p=d.createElement("s")
pannakse talle atribuudid nimedega kogus ja sisu väärtustega 2 ja algus
p.setAttribute("kogus", "2")
p.setAttribute("sisu", "algus")
seatakse eraldi loodud s-element puu juureks.
d.appendChild(p)
luuakse teine sarnane element
p2=d.createElement("s")
p2.setAttribute("sisu", "V")
p2.setAttribute("kogus", "1")
pannakse see esimese külge
p.appendChild(p2)
kuvatakse kogu dokument
print(d.toxml())
Kood tervikuna
import xml.dom.minidom
d=xml.dom.minidom.Document()
p=d.createElement("s")
p.setAttribute("kogus", "2")
p.setAttribute("sisu", "algus")
d.appendChild(p)
p2=d.createElement("s")
p2.setAttribute("sisu", "V")
p2.setAttribute("kogus", "1")
p.appendChild(p2)
print(d.toxml())
Väljund
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus4.py
Tekstifaili saadetud väljund
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus4.py > vastus1.xml
Selle vaatamine brauseris
Nüüd näitena kaks eelmist võimalust kokku. Ehk siis kõigepealt koostatakse lause sõnaliikidest puu ning edasi kantakse see üle XML-kujule. Funktsioon kannaYle saab üheks parameetriks koha algses mälupuus ning teiseks andmepuu sama koha XMLi puus. Esialgu tõstab üle ainult selle koha otsesed alamelemendid ning kommentaaridena on alles veel varasemad väljatrükikäsklused
from estnltk import Text
import xml.dom.minidom
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "jookseb linna"]
andmed={}
for lause in laused:
plokk=andmed
for sonaliik in Text(lause).postags:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
#print(andmed)
d=xml.dom.minidom.Document()
p=d.createElement("s")
p.setAttribute("sisu", "algus")
d.appendChild(p)
def kannaYle(solm, xmlSolm):
for voti in solm:
if not voti=="kogus":
#print((tase*" ")+voti+"("+str(solm[voti]["kogus"])+")")
p2=d.createElement("s")
p2.setAttribute("sisu", voti)
p2.setAttribute("kogus", str(solm[voti]["kogus"]))
xmlSolm.appendChild(p2)
# tryki(solm[voti], tase+1)
kannaYle(andmed, p)
print(d.toxml())
Funktsiooni väljakutsel anti ette andmepuu ning tühja XML-i puu juurelement. Esimesest kopeeriti teise sealsed alamelemendid koos kogustega
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus5.py
Koodilõigu täiendatud versioon. Funktsioon kannaYle kannab üle etteantud kohast alamelemendid XML-puusse süvitsi, kuni puu lõpuni. Selleks kutsub funktsioon välja iseenese, andes tsükli sees ükshaaval parameetriteks koha alamelementide kohad.
from estnltk import Text
import xml.dom.minidom
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "jookseb linna"]
andmed={}
for lause in laused:
plokk=andmed
for sonaliik in Text(lause).postags:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
d=xml.dom.minidom.Document()
p=d.createElement("s")
p.setAttribute("sisu", "algus")
d.appendChild(p)
def kannaYle(solm, xmlSolm):
for voti in solm:
if not voti=="kogus":
p2=d.createElement("s")
p2.setAttribute("sisu", voti)
p2.setAttribute("kogus", str(solm[voti]["kogus"]))
xmlSolm.appendChild(p2)
kannaYle(solm[voti], p2)
kannaYle(andmed, p)
print(d.toxml())
Väljund:
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus6.py
ja tulemus trepituna
jaagup@praktika1 ~/public_html/2018/kval/19puu2 $ python3.5 valjastus6.py > vastus3.xml
Harjutus
* Pane näited käima
* Koosta sarnane XML-puu sõnade tähtedest
Lauseliikmete puu
Puid saab tehnilise poole pealt ehitada igasugu järgnevate andmete põhjal. Tasub lihtsalt vaadata, et mis võiksid ülesande puhul kasulikuks osutuda.
Lauseid uurides jälgitakse mõnikord, et mis rollis mõni sõna on lauses - näiteks nimisõna võib olla nii alus, sihitis kui määrus. Keele automaatne parser annab sõnade kohta hulga teavet - märgendite kirjeldused leiab
https://korpused.keeleressursid.ee/syntaks/dokumendid/syntaksiliides_ee.pdf
Praeguse näite jaoks tähtsad on
@SUBJ subjekt / alus
@FMV finiitne põhiverb / öeldis (pöördeline vorm)
@OBJ objekt / sihitis
@ADVL adverbiaal / määrus
Kõigepealt näide, et kuidas andmed lausete kohta kätte saada. Parser tuleb keskkonda eraldi installida. Kui kõik läheb õnneks, siis on võimalik VISLCG3Parser import-käsklusega sisse lugeda.
from estnltk.syntax.parsers import VISLCG3Parser
from estnltk import Text
sisend="Juku tuli kooli. Juku tuli joostes kooli. Jookseb linna"
parser=VISLCG3Parser()
vahetulemus=parser.parse_text(Text(sisend), return_type='vislcg3')
print(vahetulemus)
print("\n".join(vahetulemus))
Parserist tulnud vahetulemus kuvatakse praegu nii massiivina kui reavahetustega eraldatud tekstina.
jaagup@praktika1 ~/public_html/2018/kval/20puujupid $ python3.5 tekstiandmed1.py
['""', '', '""', '\t"Juku" L0 S prop sg nom @SUBJ #1->2', '""', '\t"tule" Li V main indic impf ps3 sg ps af @FMV #2->0', '""', '\t"kool" L0 S com sg adit @ADVL #3->2', '"<.>"', '\t"." Z Fst #4->4', '""', '', '""', '', '""', '\t"Juku" L0 S prop sg nom @SUBJ #1->2', '""', '\t"tule" Li V main indic impf ps3 sg ps af @FMV #2->0', '""', '\t"joostes" L0 D @ADVL #3->2', '""', '\t"kool" L0 S com sg adit @ADVL #4->2', '"<.>"', '\t"." Z Fst #5->5', '""', '', '""', '', '""', '\t"jooks" Lb V main indic pres ps3 sg ps af @FMV #1->0', '""', '\t"linn" L0 S com sg adit @ADVL #2->1', '""', '', '']
""
""
"Juku" L0 S prop sg nom @SUBJ #1->2
""
"tule" Li V main indic impf ps3 sg ps af @FMV #2->0
""
"kool" L0 S com sg adit @ADVL #3->2
"<.>"
"." Z Fst #4->4
""
""
""
"Juku" L0 S prop sg nom @SUBJ #1->2
""
"tule" Li V main indic impf ps3 sg ps af @FMV #2->0
""
"joostes" L0 D @ADVL #3->2
""
"kool" L0 S com sg adit @ADVL #4->2
"<.>"
"." Z Fst #5->5
""
""
""
"jooks" Lb V main indic pres ps3 sg ps af @FMV #1->0
""
"linn" L0 S com sg adit @ADVL #2->1
""
Regulaaravaldise abil otsime igale sõna kohta välja @-märgiga algava tunnuse ehk vaste lauseliikmena.
from estnltk.syntax.parsers import VISLCG3Parser
from estnltk import Text
import re
sisend="Juku tuli kooli. Juku tuli joostes kooli. Jookseb linna"
parser=VISLCG3Parser()
vahetulemus=parser.parse_text(Text(sisend), return_type='vislcg3')
for rida in vahetulemus:
if rida=='""': print("lause algus")
m=re.findall("@[A-Z]+", rida)
if m: print(m[0])
Tulemus:
jaagup@praktika1 ~/public_html/2018/kval/20puujupid $ python3.5 tekstiandmed2.py
lause algus
@SUBJ
@FMV
@ADVL
lause algus
@SUBJ
@FMV
@ADVL
@ADVL
lause algus
@FMV
@ADVL
Nüüd juba mitu toimetust üheskoos. Iga lause kohta koostatakse lauseliikmete jada. Jada põhjal luuakse mällu andmepuu ning siis teisendatakse see XML-i kujule ja kuvatakse
from estnltk.syntax.parsers import VISLCG3Parser
from estnltk import Text
import xml.dom.minidom
import re
sisend="Juku tuli kooli. Juku tuli joostes kooli. Jookseb linna"
parser=VISLCG3Parser()
vahetulemus=parser.parse_text(Text(sisend), return_type='vislcg3')
laused=[]
for rida in vahetulemus:
if rida=='""': margendid=[]
m=re.findall("@[A-Z]+", rida)
if m: margendid.append(m[0])
if rida=='""': laused.append(margendid)
#print(laused)
andmed={}
for margendid in laused:
plokk=andmed
for sonaliik in margendid:
if sonaliik in plokk:
plokk[sonaliik]['kogus']+=1
else:
plokk[sonaliik]={'kogus':1}
plokk=plokk[sonaliik]
#print(andmed)
d=xml.dom.minidom.Document()
p=d.createElement("s")
p.setAttribute("sisu", "algus")
d.appendChild(p)
def kannaYle(solm, xmlSolm):
for voti in solm:
if not voti=="kogus":
p2=d.createElement("s")
p2.setAttribute("sisu", voti)
p2.setAttribute("kogus", str(solm[voti]["kogus"]))
xmlSolm.appendChild(p2)
kannaYle(solm[voti], p2)
kannaYle(andmed, p)
print(d.toxml())
Valminud puu:
Harjutus
* Pane näide tööle
* Kuva oma sisestatud sõna lauseliikmed
* Loe tekst sisse failist. Kuva teksti lauseliikmete puu
Algandmete näitamine puus
Puu aitab välja tuua andmete struktuuri, selle juures aga on õpetlik näha, et milliste andmete põhjal sarnane struktuur on tekkinud. Siin näites koostame puu sõnaliikidest, pärast aga vaatame iga haru juures, et milliste lausealguste järgi vastav koht puus tekkis. Et kõrvuti vaja nii sõnu endid kui sõnaliike, kasutame andmete hoidmisel Pandase dataframe, millena suudab estnltk Text-klass väärtused välja anda. Ploki võtmeks endiselt vastaval kohal olev sõnaliik, puus alanevad elemendid nende sõnaliikide võtmetega nagu ennegi, ploki metaanded aga alamelemendis nimega meta, sealseteks väärtusteks kogus ja sisu. Esimene loendab puu selle kohani jõudnud lausete arvu, teine aga on massiiv, kuhu pannakse vastavad lausealgused. Andmepuu väljatrükk näha pärast programmikoodi.
Hiljem trükitakse andmepuu välja HTMLina. Iga sõlm ul (unordered list) elemendina, seesolevad sõnaliigid li (list item) elemendina. Kuna puu sügavus sõltub lausete pikkustest ning koodiga ei ole piiratud, siis võtme väärtuse (sõnaliigi) väljatrüki järel kutsutakse kuva-funktsioon uuesti välja võimalike alamelementide sisu näitamiseks.
from estnltk import Text
laused=["Juku tuli kooli", "Juku tuli joostes kooli", "Kati jooksis koju"]
andmed={}
for lause in laused:
plokk=andmed
df=Text(lause).get.word_texts.postags.as_dataframe
lausealgus=""
for reanr in range(len(df)):
sonaliik=df["postags"][reanr]
lausealgus+=df["word_texts"][reanr]+" "
if sonaliik in plokk:
plokk[sonaliik]['meta']['kogus']+=1
plokk[sonaliik]['meta']['sisu'].append(lausealgus)
else:
plokk[sonaliik]={
'meta':{
'kogus': 1,
'sisu':[lausealgus]
}
}
plokk=plokk[sonaliik]
print(andmed)
f=open("vastus2.html", "w")
f.write("
Andmepuu
")
def kuva(solm):
f.write("
")
for voti in solm:
if not voti=="meta":
f.write("
"+voti+"
")
kuva(solm[voti])
f.write("
")
kuva(andmed)
f.write("")
f.close()
Tekstiekraani väljund
jaagup@praktika1 ~/public_html/2018/kval/21puuandmed $ python3.5 puu2.py
{'H': {'meta': {'kogus': 3, 'sisu': ['Juku ', 'Juku ', 'Kati ']}, 'V': {'S': {'meta': {'kogus': 2, 'sisu': ['Juku tuli kooli ', 'Kati jooksis koju ']}}, 'meta': {'kogus': 3, 'sisu': ['Juku tuli ', 'Juku tuli ', 'Kati jooksis ']}, 'V': {'S': {'meta': {'kogus': 1, 'sisu': ['Juku tuli joostes kooli ']}}, 'meta': {'kogus': 1, 'sisu': ['Juku tuli joostes ']}}}}}
Sama andmestruktuuri esitus trepituna, meta-elemendid on arusaadavuse mõttes iga elemendi puhul esimeseks tõstetud. Pärisnimega (H) algab kolm lauset. Sealse meta-elemendi juures on seetõttu koguseks 3 ning massiivis näha, milliste nimedega laused hakkasid. Praegusel juhul kõikide lausete puhul järgneb nimisõnale tegusõna (V), näha ka vastavad algused. Kolmandaks elemendiks on kahel korral nimisõna (S) koos vastavate lausealgustega, ühel korral tegusõna, millele omakorda järgneb nimisõna - nii need ka andmepuus nähtavad.
{'H': {'meta': {'kogus': 3, 'sisu': ['Juku ', 'Juku ', 'Kati ']},
'V': { 'meta': {'kogus': 3, 'sisu': ['Juku tuli ', 'Juku tuli ', 'Kati jooksis ']},
'S': {'meta': {'kogus': 2, 'sisu': ['Juku tuli kooli ', 'Kati jooksis koju ']}},
'V': {'meta': {'kogus': 1, 'sisu': ['Juku tuli joostes ']},
'S': {'meta': {'kogus': 1, 'sisu': ['Juku tuli joostes kooli ']}}
}
}
}
}
HTML-i väljund faili
Andmepuu
H
V
S
V
S
Sama tekst trepituna. Rudimendina on sees tühjad ul-elemendid lause viimaste sõnade puhul, nendele aga leiame järgmises näites parema lahenduse
Andmepuu
H
V
S
V
S
Tulemus veebilehitseja ekraanil
Täiendused uues versioonis.
Aktiivsest sõlmest võetakse kõik alamelemendid peale meta, et saada vastavalt kohalt jätkuvad sõnaliigid. Neist luuakse massiiv, kus esimeseks elemendiks on vastaval kohal selle sõnaliigiga lausete arv ning teisel sõnaliik ise. Käsklus sorted järjestab massiividena olevad elemendid esimese elemendi (ehk praegusel juhul koguse) järgi kasvavas järjekorras, kui pole eraldi määratud teisiti. Kuna soovime levinumaid järgnevusi ettepoole, siis pöörame järjekorra reverse-käskluse abil ümber
jarjestatud=sorted([[solm[voti]["meta"]["kogus"], voti]
for voti in solm if not voti=="meta"])
jarjestatud.reverse()
Uuest järjestatud järjestatud loetelust küsime välja võtmed (ehk andmepaari elemendi kohal 1, kohal 0 on kogus). Selle võtme järgi saame meta-ploki sisu elemendist kätte massiivi sinna ulatuvate lausetega, mille join-käskluse abil järjest ridadele pandud tekstiks sätime.
for voti in [paar[1] for paar in jarjestatud]:
f.write("
"+voti+
" ("+str(solm[voti]["meta"]["kogus"])+")
")
Kui sõlmel on alamelemente (peale meta), siis kutsume kuvamisfunktsiooni uuesti välja
if len(solm[voti])>1: kuva(solm[voti])
Kood tervikuna
from estnltk import Text
laused=["Sinine vagun","Juku tuli kooli", "rõõmus juku tuli joostes kooli",
"Kati jooksis koju", "Istub kodus", "Jookseb õues", "ka", "Katrin"]
andmed={}
for lause in laused:
plokk=andmed
df=Text(lause).get.word_texts.postags.as_dataframe
lausealgus=""
for reanr in range(len(df)):
sonaliik=df["postags"][reanr]
lausealgus+=df["word_texts"][reanr]+" "
if sonaliik in plokk:
plokk[sonaliik]['meta']['kogus']+=1
plokk[sonaliik]['meta']['sisu'].append(lausealgus)
else:
plokk[sonaliik]={
'meta':{
'kogus': 1,
'sisu':[lausealgus]
}
}
plokk=plokk[sonaliik]
print(andmed)
f=open("vastus5.html", "w")
f.write("
Andmepuu
")
def kuva(solm):
f.write("
")
jarjestatud=sorted([[solm[voti]["meta"]["kogus"], voti]
for voti in solm if not voti=="meta"])
jarjestatud.reverse()
for voti in [paar[1] for paar in jarjestatud]:
if solm[voti]["meta"]["kogus"]>0:
f.write("
"+voti+
" ("+str(solm[voti]["meta"]["kogus"])+")
")
if len(solm[voti])>1: kuva(solm[voti])
f.write("
Sama trepituna. Lühiduse mõttes reavahetused lauselõikude vahelt välja võetud, ehkki nõnda ei teki nad lausete vahele ka veebilehitsejas
Andmepuu
H (3)
V (2)
S (2)
V (2)
S (2)
A (2)
S (2)
V (1)
V (1)
S (1)
D (1)
Tulemus brauseris. Kui minna hiirega puu elemendi kohale, siis näeb seal, milliste lausealguste abil vastavasse kohta jõuti
Näites piirdusime puu loomise juures paari lausega. Tekstides mustrite leidmiseks kasutatakse aga pigem sadu ja tuhandeid lauseid, vahel isegi kümneid tuhandeid sõnu. Neist ligi pooled järgnevused jäävad ühekordseteks, ülejäänust pool mõnekordseteks ning ka suure andmestiku korral koorub üldjuhul lõpuks välja hallatava suurusega tuumikpuu, milles leiduvad mustrid näitavad välja enam levinud järgnevused.
Puu suuruse piiramiseks lisasime rasvases kirjas märgitud tingimuslause - puu harusse minnakse kuvamiseks sisse vaid siis, kui märgitud kogus on piisavalt suur, praegusel juhul suurem kui üks.
def kuva(solm):
f.write("
")
jarjestatud=sorted([[solm[voti]["meta"]["kogus"], voti]
for voti in solm if not voti=="meta"])
jarjestatud.reverse()
for voti in [paar[1] for paar in jarjestatud]:
if solm[voti]["meta"]["kogus"]>1:
f.write("
"+voti+
" ("+str(solm[voti]["meta"]["kogus"])+")
")
if len(solm[voti])>1: kuva(solm[voti])
f.write("
\n")
Kuvatav puu tuleb niimoodi mõnevõrra väiksem, kergemini vaadatav ning näitlaused endiselt sees näha.
Harjutus
* Pane näited käima
* Kuva sõnade tähtedest sageduste järgi järjestatud puu
Andmepuu regiviiside näitel
Eesti Kirjandusmuuseumi Eesti Rahvaluule Arhiivis on talletatud hulgaliselt regilaulude viise. Andmebaasi meloodiatest väljavõtte leiab aadressilt
http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt
Tabelarvutusleht
Esmaseks uurimiseks sobib see importida tabelarvutussüsteemi - näiteks Libre Office Calc programmi. Tulpade eraldajaks koma.
Kui sisse võtmine läks edukalt, jõuavad andmed tabelisse. Veidi uurides paistab, et viis ise algab tulbast pealkirjaga P1 - lihtsamal juhul eemaldame eelnevad tulbad ning järjestame viisid tähestikuliselt
Tulemuseks koonduvad samasuguse algusega viisid kokku. Algusesse jäid mitmesugused eripärased märgistused, pärast sajandat rida hakkavad aga tavalised noodid - praeguses kohas teise oktaavi C-st. Esimesed kuus viisi algavad kolme 2c-ga, järgmise nelja puhul on algusnootideks 2c-2c-2d. Nõnda näeb väiksemate koguste puhul silmaga ära, et millised algused levinumad on.
Ligipääs programmeerimiskeelega
Viisidele pääseb ligi ka programmeerimiskeele abil. Kui Pythoni kood käivitub andmefailiga samas kataloogis, siis saab faili selle nime järgi avada. Esimene rida on pealkirjade rida - selle loeme ja jätame praeguse seisuga kasutamata. Edasi saab juba soovi järgi konkreetseid väärtusi lugeda ja kasutada. Käsklus split tükeldab teksti lõikudeks, praegusel juhul koma koha pealt. Viisi algustulp (P1) on üheteistkümnes, Pythoni moodi nullist lugedes järjekorranumbriga kümme. Nii saabki esimese viisi esimese noodi (2d) kätte.
f=open("regiviisid.txt")
f.readline()
print(f.readline().split(",")[10])
Käivitus
$ python3.5 noodid1.py
2d
Andmemajanduseks on Pythonil pandas-teek. Selle käsklus read_csv võimaldab komadega eraldatud tabeli tervikuna sisse lugeda. Edasi on võimalik juba tulba nime järgi pöörduda üksikute väärtuste poole tabelis. Kui anda ette ka rea järjekorranumber, siis saab kätte üksiku väärtuse (2d nagu eelmises näites), muul juhul tuleb välja terve tulp korraga.
import pandas as pd
df=pd.read_csv("regiviisid.txt")
#print(df["P1"][0])
print(df["P1"])
Käivitus näitab välja esimeste viiside avanoodid.
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/0904 $ python3.5 noodid2.py
0 2d
1 2d
2 2d
3 g
4 h
Esimeste erinevate nootide sageduste kokku lugemiseks sobib pandase dataframe tulba käsklus value_counts
import pandas as pd
df=pd.read_csv("regiviisid.txt")
print(df["P1"].value_counts())
Nii näeb, et enim lugusid algab g-noodiga, aga leidub ka muid salapäraseid kirjapanekumooduseid.
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/0904 $ python3.5 noodid2.py
g 1151
2d 827
h 674
2c 564
a 560
2e 203
e 189
f 144
c 101
d 97
kodeeritult kuskil olemas 88
-3 31
Tagasi "tavalise" Pythoni juurde. Tulba käik väärtused saab kätte tsükli abil
f=open("regiviisid.txt")
f.readline()
for rida in f:
print(rida.split(",")[10])
Võti more käivitamise juures hoolitseb, et noodihulk pärast ekraani täitmist me silmade ette pidama jääb ning alles klahvivajutusega on võimalik edasi liikuda.
python3.5 noodid3.py | more
2d
2d
2d
g
h
2d
Väärtuste loendamine
Alustuseks ridade arvu lugemine. Muutuja nimeks puu selle mõttega, et hiljem võiks sellest andmepuu välja kasvada ning puu juurelemendina loendame kõikide viiside arvu.
puu={"kogus":0}
f=open("regiviisid.txt")
f.readline()
for rida in f:
puu["kogus"]+=1
print(puu["kogus"])
Vastus
4941
Edasi teeme iga alamelemendi ehk loo esimese noodi väärtuse kohta koguse, et mitu korda see esineb. Kui vastavat nooti veel puu juure küljes pole, siis lisatakse see sinna kogusega 1, kui juba olemas, siis suurendatakse kogust ühe võrra.
puu={"kogus":0}
f=open("regiviisid.txt")
f.readline()
for rida in f:
puu["kogus"]+=1
noot1=rida.split(",")[10]
if noot1 not in puu:
puu[noot1]={"kogus":1}
else:
puu[noot1]["kogus"]+=1
print(puu["kogus"])
print(puu["g"]["kogus"])
print(puu)
Käivitamisel paistab, et kogu puus on 4941 viisi, millest g-noodiga algab 1151. Edasi järgneb üksikute algusnootide koguste loetelu. Nagu näha, siis 2 oktaavi d-ga algab 827 lugu, järgmiseks elemendiks on üldkogus ning siis tulevad üksikute algusnootide kogused riburadapidi järele
python3.5 noodid3.py
4941
1151
{'2d': {'kogus': 827}, 'kogus': 4941, '2c[a]': {'kogus': 3}, 'e[g]': {'kogus': 1}, '[2]]-3]': {'kogus': 1}, '2d[2f]': {'kogus': 1}, '[0][-3]': {'kogus': 1}, '2g': {'kogus': 4}, 'g[h]': {'kogus': 23}, '2': {'kogus': 6}, '[-5][0]': {'kogus': 1}, '1g': {'kogus': 1}, '3': {'kogus': 18}, '1h[d]': {'kogus': 1}, 'a\\2d': {'kogus': 1}, '(2c)h': {'kogus': 1}, 'd[c]': {'kogus': 4}, 'h[g]': {'kogus': 9}, '3\\1': {'kogus': 2}, 'e[d\\e][f]': {'kogus': 1}, 'a': {'kogus': 560}, '1a': {'kogus': 2}, 'e\\d\\d': {'kogus': 1}, 'g': {'kogus': 1151}, 'h\\2c': {'kogus': 2}, 'h[a]': {'kogus': 2}, '#2c': {'kogus': 1}, '4': {'kogus': 3}, '[-4][-2]': {'kogus': 1}, '[-3][3]': {'kogus': 1}, 'e[e/d]': {'kogus': 1}, 'g[d]': {'kogus': 3}, '-1\\-3': {'kogus': 2}, 'e': {'kogus': 189}, 'h': {'kogus': 674}, '3e': {'kogus': 1}, 'd': {'kogus': 97}, '-3\\-5': {'kogus': 1}, '2d[2c]': {'kogus': 4}, '2e': {'kogus': 203}, '2d\\2c': {'kogus': 1}, 'g[f]': {'kogus': 1}, '2c\\2d': {'kogus': 1}, '-4': {'kogus': 23}, 'c[e]': {'kogus': 1}, 'h/a': {'kogus': 1}, 'f[d]': {'kogus': 1}, 'g[2c]': {'kogus': 2}, 'a[a\\2c]': {'kogus': 1}, 'kus viis hulgub?': {'kogus': 12}, '2c[h]': {'kogus': 2}, 'kodeeritult kuskil olemas': {'kogus': 88}, '3\\2': {'kogus': 1}, 'otsi orig-st': {'kogus': 1}, 'a\\2c': {'kogus': 3}, '[-2][-3]': {'kogus': 1}, '2d\\h[h]': {'kogus': 4}, '???': {'kogus': 1}, 'h[h/g]': {'kogus': 1}, '2f': {'kogus': 5}, 'c[d]': {'kogus': 1}, '[3][-3]': {'kogus': 1}, '-1': {'kogus': 3}, '2c[2e]': {'kogus': 1}, 'h[2c]': {'kogus': 2}, '2d[h]': {'kogus': 6}, 'g[2d]': {'kogus': 29}, 'h/2d': {'kogus': 1}, '[-5][3': {'kogus': 1}, '-2\\-3': {'kogus': 2}, 'e\\c': {'kogus': 1}, '[-4][3]': {'kogus': 2}, '2c': {'kogus': 564}, '2c\\h': {'kogus': 2}, 'f': {'kogus': 144}, '2d[g]': {'kogus': 7}, 'd[1h]': {'kogus': 2}, '-3': {'kogus': 31}, 'a[e][g]': {'kogus': 3}, 'h\\a': {'kogus': 2}, '-5': {'kogus': 8}, 'f[f\\f]': {'kogus': 1}, '1h': {'kogus': 6}, '0': {'kogus': 16}, 'e[d]': {'kogus': 1}, 'g[g\\a]': {'kogus': 1}, 'g[a]': {'kogus': 4}, 'a[h]': {'kogus': 4}, 'd\\f': {'kogus': 1}, 'h\\g': {'kogus': 1}, 'f\\d': {'kogus': 1}, 'h\\2d': {'kogus': 2}, '2d\\h': {'kogus': 1}, 'c': {'kogus': 101}, 'h[2e]': {'kogus': 4}, 'g\\h': {'kogus': 1}, 'h[f]': {'kogus': 1}, 'a\\h': {'kogus': 4}, '-2': {'kogus': 11}, 'f[g]': {'kogus': 4}, '[-3][-4]': {'kogus': 1}, 'd\\e': {'kogus': 1}, 'a[f]': {'kogus': 2}, 'g\\a': {'kogus': 1}, 'a[a\\h]': {'kogus': 1}, '2\\0\\-2': {'kogus': 1}}
Esialgsest segamini järjekorras andmestikust on tulemusi tülikas välja lugeda. Sortides algusnoodid nende esinemise koguste järgi, leiab haruldasemad ja levinumad alguskohad kergemini kätte. Nii võetakse puu juurest välja kõik noodid (kogus on erinimi, mis jäetakse välja) ning tehakse andmepaarid (kaheelemendilised massiivid), kus esimeseks väärtuseks kogus ja teiseks noodi nimi. Käsklus sorted järjestab massiivi esimese elemendi järgi, nii tulevad andmed koguste järgi ritta.
print(list(sorted([puu[noot]["kogus"], noot] for noot in puu if not noot=="kogus")))
Nagu näha, siis lõpus on suuremad kogused
[[1, '#2c'], [1, '(2c)h'], [1, '-3\\-5'], [1, '1g'], [1, '1h[d]'], [1, '2\\0\\-2'], [1, '2c[2e]'], [1, '2c\\2d'], [1, '2d[2f]'], [1, '2d\\2c'], [1, '2d\\h'], [1, '3\\2'], [1, '3e'], [1, '???'], [1, '[-2][-3]'], [1, '[-3][-4]'], [1, '[-3][3]'], [1, '[-4][-2]'], [1, '[-5][0]'], [1, '[-5][3'], [1, '[0][-3]'], [1, '[2]]-3]'], [1, '[3][-3]'], [1, 'a[a\\2c]'], [1, 'a[a\\h]'], [1, 'a\\2d'], [1, 'c[d]'], [1, 'c[e]'], [1, 'd\\e'], [1, 'd\\f'], [1, 'e[d\\e][f]'], [1, 'e[d]'], [1, 'e[e/d]'], [1, 'e[g]'], [1, 'e\\c'], [1, 'e\\d\\d'], [1, 'f[d]'], [1, 'f[f\\f]'], [1, 'f\\d'], [1, 'g[f]'], [1, 'g[g\\a]'], [1, 'g\\a'], [1, 'g\\h'], [1, 'h/2d'], [1, 'h/a'], [1, 'h[f]'], [1, 'h[h/g]'], [1, 'h\\g'], [1, 'otsi orig-st'], [2, '-1\\-3'], [2, '-2\\-3'], [2, '1a'], [2, '2c[h]'], [2, '2c\\h'], [2, '3\\1'], [2, '[-4][3]'], [2, 'a[f]'], [2, 'd[1h]'], [2, 'g[2c]'], [2, 'h[2c]'], [2, 'h[a]'], [2, 'h\\2c'], [2, 'h\\2d'], [2, 'h\\a'], [3, '-1'], [3, '2c[a]'], [3, '4'], [3, 'a[e][g]'], [3, 'a\\2c'], [3, 'g[d]'], [4, '2d[2c]'], [4, '2d\\h[h]'], [4, '2g'], [4, 'a[h]'], [4, 'a\\h'], [4, 'd[c]'], [4, 'f[g]'], [4, 'g[a]'], [4, 'h[2e]'], [5, '2f'], [6, '1h'], [6, '2'], [6, '2d[h]'], [7, '2d[g]'], [8, '-5'], [9, 'h[g]'], [11, '-2'], [12, 'kus viis hulgub?'], [16, '0'], [18, '3'], [23, '-4'], [23, 'g[h]'], [29, 'g[2d]'], [31, '-3'], [88, 'kodeeritult kuskil olemas'], [97, 'd'], [101, 'c'], [144, 'f'], [189, 'e'], [203, '2e'], [560, 'a'], [564, '2c'], [674, 'h'], [827, '2d'], [1151, 'g']]
Parameeter reverse=True keerab sorteerimisjärjestuse ümber
print(list(sorted(([puu[noot]["kogus"], noot] for noot in puu if not noot=="kogus"), reverse=True)))
loetelus nõnda suuremad sagedused ees
[[1151, 'g'], [827, '2d'], [674, 'h'], [564, '2c'], [560, 'a'], [203, '2e'], [189, 'e'], [144, 'f'], [101, 'c'], [97, 'd'], [88, 'kodeeritult kuskil olemas'], [31, '-3'], [29, 'g[2d]'], [23, 'g[h]'], [23, '-4'], [18, '3'], [16, '0'], [12, 'kus viis hulgub?'], [11, '-2'], [9, 'h[g]'], [8, '-5'], [7, '2d[g]'], [6, '2d[h]'], [6, '2'], [6, '1h'], [5, '2f'], [4, 'h[2e]'], [4, 'g[a]'], [4, 'f[g]'], [4, 'd[c]'], [4, 'a\\h'], [4, 'a[h]'], [4, '2g'], [4, '2d\\h[h]'], [4, '2d[2c]'], [3, 'g[d]'], [3, 'a\\2c'], [3, 'a[e][g]'], [3, '4'], [3, '2c[a]'], [3, '-1'], [2, 'h\\a'], [2, 'h\\2d'], [2, 'h\\2c'], [2, 'h[a]'], [2, 'h[2c]'], [2, 'g[2c]'], [2, 'd[1h]'], [2, 'a[f]'], [2, '[-4][3]'], [2, '3\\1'], [2, '2c\\h'], [2, '2c[h]'], [2, '1a'], [2, '-2\\-3'], [2, '-1\\-3'], [1, 'otsi orig-st'], [1, 'h\\g'], [1, 'h[h/g]'], [1, 'h[f]'], [1, 'h/a'], [1, 'h/2d'], [1, 'g\\h'], [1, 'g\\a'], [1, 'g[g\\a]'], [1, 'g[f]'], [1, 'f\\d'], [1, 'f[f\\f]'], [1, 'f[d]'], [1, 'e\\d\\d'], [1, 'e\\c'], [1, 'e[g]'], [1, 'e[e/d]'], [1, 'e[d]'], [1, 'e[d\\e][f]'], [1, 'd\\f'], [1, 'd\\e'], [1, 'c[e]'], [1, 'c[d]'], [1, 'a\\2d'], [1, 'a[a\\h]'], [1, 'a[a\\2c]'], [1, '[3][-3]'], [1, '[2]]-3]'], [1, '[0][-3]'], [1, '[-5][3'], [1, '[-5][0]'], [1, '[-4][-2]'], [1, '[-3][3]'], [1, '[-3][-4]'], [1, '[-2][-3]'], [1, '???'], [1, '3e'], [1, '3\\2'], [1, '2d\\h'], [1, '2d\\2c'], [1, '2d[2f]'], [1, '2c\\2d'], [1, '2c[2e]'], [1, '2\\0\\-2'], [1, '1h[d]'], [1, '1g'], [1, '-3\\-5'], [1, '(2c)h'], [1, '#2c']]
Puhtamaks välja lugemiseks levinumad paarid
for paar in sorted(([puu[noot]["kogus"], noot] for noot in puu if not noot=="kogus"), reverse=True):
if paar[0]>100:
print(paar[1], ' - ', paar[0])
Tekkinud loetelu
g - 1151
2d - 827
h - 674
2c - 564
a - 560
2e - 203
e - 189
f - 144
c - 101
Harjutus
Koosta tekstifail mõne silbitatud sõnaga. Nt
ma-gus
ma-ga-ma
kap-sa-uss
* Loe programmi abil kokku, mitu korda millist esimest silpi on
* Kuva silbid koos sagedustega kahanevas järjekorras
f=open("silbid1.txt")
puu={"kogus":0}
for rida in f:
puu["kogus"]+=1
silp=rida.split("-")[0]
if not silp in puu:
puu[silp]={"kogus":1}
else:
puu[silp]["kogus"]+=1
print(puu)
for paar in sorted([[puu[silp]["kogus"], silp] for silp in puu if not silp=="kogus"], reverse=True):
print(paar[1], "-", paar[0])
Käivitus
python3.5 silbid1.py
{'kogus': 3, 'ma': {'kogus': 2}, 'kap': {'kogus': 1}}
ma - 2
kap - 1
Harjutus - puu koostamine
* Tutvu näitega alampeatüki "Puu loomine programmiga" lõpus. Käivita, koosta puid erisuguste sõnade tähtedega
* Võta sisendiks tekstifail silbitatud sõnadega. Koosta sõnasilpide puu. Kuva
Eripäraks et nüüd on juures muutuja aktiivse ploki meeles pidamiseks. Nii on võimalik puud koostada keskendudes korraga vaid ühele sõlmele ning selle juures andmete paika sättimisel liikuda edasi järgmise sõlme juurde. Uue sõna või muu üksuse analüüsil hakatakse aktiivse plokiga taas puu juurest peale ning liigutakse edasi senikaua, kuni sisendil väärtusi (praegusel juhul sõnal silpe) jagub
andmed={"kogus":0}
f=open("silbid1.txt")
for sona in f:
plokk=andmed
plokk["kogus"]+=1
for silp in sona.strip().split("-"):
if silp in plokk:
plokk[silp]["kogus"]+=1
else:
plokk[silp]={"kogus":1}
plokk=plokk[silp]
print(andmed)
Sisendfail
silbid.txt
ma-gus
ma-ga-ma
kap-sa-uss
väljund
python tahed1.py
{'kogus': 3, 'kap': {'kogus': 1, 'sa': {'kogus': 1, 'uss': {'kogus': 1}}}, 'ma': {'kogus': 2, 'gus': {'kogus': 1}, 'ga': {'kogus': 1, 'ma': {'kogus': 1}}}}
Sama viisipuuga
andmed={"kogus":0}
f=open("regiviisid.txt")
f.readline()
for rida in f:
plokk=andmed
plokk["kogus"]+=1
for noot in rida.strip().split(",")[10:13]:
if noot in plokk:
plokk[noot]["kogus"]+=1
else:
plokk[noot]={"kogus":1}
plokk=plokk[noot]
print(andmed)
Puu tuli nõnda päris suur, näha vaid väike lõik sellest
python viisipuu.py
{'2c\\2d': {'kogus': 1, '2e': {'kogus': 1, '2e': {'kogus': 1}}}, '[0][-3]': {'kogus': 1, '[0][-3': {'kogus': 1, '0': {'kogus': 1}}}, '1h[d]': {'kogus': 1, 'd[f]': {'kogus': 1, 'd[e]': {'kogus': 1}}},
Andmete kätte saamine
Kõigepealt puu juurtaseme noodid. Langjoon for-tsükli real selleks, et saaks käsu sees rida vahetada
minkogus=100
def kuva(plokk):
for kogus, noot in sorted([[plokk[noot]["kogus"], noot] \
for noot in plokk if not noot=="kogus"], reverse=True):
if kogus>=minkogus:
print(noot, kogus)
kuva(andmed)
Tulemus
python viisipuu2.py
g 1151
2d 827
h 674
2c 564
a 560
2e 203
e 189
f 144
c 101
Andmepuu väljatrükk
Siinses näites koostame puu viisi esimese kolme noodiga - tulbad 10-13 (viimane välja arvatud. Väljatrüki puhul juures pealtnäha väike, aga sisu poolest tähtis lisandus: lisaks noodi kuvamisel kutsutakse kuva-funktsioon uuest välja parajasti väljatrükitava noodi kohalt. Niimoodi paigutatakse vastava koha väljund ka sobivasse kohta. Tulemuse saadame faili, et vastus oleks loetav ka pikemate andmete puhul. Iga väljatrüki juures ühe tabulaatori võrra suurem taane - nii näha, et mis mille alla kuulub. Praeguses näites väljatrüki miinimumkoguseks 140 - nii püsib nootide/sõlmede arv silma ees veel jälgitav.
andmed={"kogus":0}
f=open("regiviisid.txt")
f.readline()
for rida in f:
plokk=andmed
plokk["kogus"]+=1
for noot in rida.strip().split(",")[10:13]:
if noot in plokk:
plokk[noot]["kogus"]+=1
else:
plokk[noot]={"kogus":1}
plokk=plokk[noot]
f.close()
minkogus=140
f2=open("vastus.txt", "w")
print(".\r", file=f2)
def kuva(plokk, taane):
for kogus, noot in sorted([[plokk[noot]["kogus"], noot] \
for noot in plokk if not noot=="kogus"], reverse=True):
if kogus>=minkogus:
print(taane*"\t"+noot+"_"+str(kogus)+"\r", file=f2)
kuva(plokk[noot], taane+1)
kuva(andmed, 1)
f2.close()
Tulemusfail, kus näha levinumad viisialgused. Näha noot ning selle esinemise sagedus.
vastus.txt
.
g_1151
g_511
g_175
h_218
a_148
2d_827
2d_344
h_310
h_674
h_275
2d_151
2c_564
2c_173
h_144
a_560
a_245
2e_203
e_189
f_144
Microsoft Wordi SmartArt võimaldab sellise puu kaudu joonise kuvada
Koodi ja andmeid veidi kohandades kuvame välja g-põhitooniga viiside g-ga algavad meloodialõigud - nii saab juba ühest alamosast parasjagu selgema pildi.
andmed={"kogus":0}
f=open("regiviisid.txt")
f.readline()
for rida in f:
if rida.strip().split(",")[6]=='g':
plokk=andmed
plokk["kogus"]+=1
for noot in rida.strip().split(",")[10:18]:
if noot in plokk:
plokk[noot]["kogus"]+=1
else:
plokk[noot]={"kogus":1}
plokk=plokk[noot]
f.close()
minkogus=20
f2=open("vastus.txt", "w")
#print(".\r", file=f2)
def kuva(plokk, taane):
for kogus, noot in sorted([[plokk[noot]["kogus"], noot] \
for noot in plokk if not noot=="kogus"], reverse=True):
if kogus>=minkogus:
print(taane*"\t"+noot+"_"+str(kogus)+"\r", file=f2)
kuva(plokk[noot], taane+1)
kuva(andmed, 0)
f2.close()
Väljundfail, kus noodid nähtaval
g_845
g_370
g_149
g/a_75
h_39
a_39
a_39
g_39
h/a_36
a_36
a/g_36
a/g_36
a_23
a_87
h_58
2c_30
h_24
2d_23
2c_22
h_22
a_21
h_75
h_25
a_20
2d_20
2c_32
h_183
2d_77
2d_43
2c_21
h_43
g_29
a_109
h_92
a_44
g/a_43
h_38
a_36
h_36
a_36
a_35
g_35
f_26
g_24
h_20
2d_20
h_20
2c_20
Sama andmepuu põhjal koostatud SmartArt-i joonis
Harjutus
* Pane näide käima
* Kuva välja G-duuri 2d-ga algavate viiside puu
Järjestuste sagedused
Järjestuste leidmise kohta leiab pikema seletatud näite allolevast Digihumanitaaria tehnoloogiate konspektist peatükist tähepaarid
https://docs.google.com/document/d/1hsTX22h82cZqIynxdGgKkLdTI9aJYpTYuzmDXE5nl_Q
Selle näite põhjal leiame kahetähelised järjendid sõnast "allveesport"
sona="allveesport"
jadapikkus=2
jadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
print(jadad)
tulemus
python3.5 paarid1.py
['al', 'll', 'lv', 've', 'ee', 'es', 'sp', 'po', 'or', 'rt']
Sama koodilõik kolmetäheliste jadadega
sona="allveesport"
jadapikkus=3
jadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
print(jadad)
tulemus
python3.5 paarid1.py
['all', 'llv', 'lve', 'vee', 'ees', 'esp', 'spo', 'por', 'ort']
Edasi näide mitme sõna juures jadade leidmiseks. Tsükliga käiakse sõnad läbi, iga sõna kohta leitakse jadad ning liidetakse üheks suureks jadaks kokku.
sonad=["allveesport", "sportlane", "meeskonnasport", "tugitoolisport"]
jadapikkus=3
koikjadad=[]
for sona in sonad:
sonajadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
koikjadad+=sonajadad
print(koikjadad)
Tulemus
python3.5 paarid2.py
['all', 'llv', 'lve', 'vee', 'ees', 'esp', 'spo', 'por', 'ort', 'spo', 'por', 'ort', 'rtl', 'tla', 'lan', 'ane', 'mee', 'ees', 'esk', 'sko', 'kon', 'onn', 'nna', 'nas', 'asp', 'spo', 'por', 'ort', 'tug', 'ugi', 'git', 'ito', 'too', 'ool', 'oli', 'lis', 'isp', 'spo', 'por', 'ort']
Samale koodile juurde analüüsiosa. Klass nimega Counter võimaldab loetelus leiduvate eri väärtuste sagedused kokku lüüa. Tulemusena näha, et "ort", "spo" ja "por" tõusevad tugevasti esile.
sonad=["allveesport", "sportlane", "meeskonnasport", "tugitoolisport"]
jadapikkus=3
koikjadad=[]
for sona in sonad:
sonajadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
koikjadad+=sonajadad
print(koikjadad)
from collections import Counter
c=Counter(koikjadad)
print(c)
Tulemus
python3.5 paarid2.py
['all', 'llv', 'lve', 'vee', 'ees', 'esp', 'spo', 'por', 'ort', 'spo', 'por', 'ort', 'rtl', 'tla', 'lan', 'ane', 'mee', 'ees', 'esk', 'sko', 'kon', 'onn', 'nna', 'nas', 'asp', 'spo', 'por', 'ort', 'tug', 'ugi', 'git', 'ito', 'too', 'ool', 'oli', 'lis', 'isp', 'spo', 'por', 'ort']
Counter({'ort': 4, 'spo': 4, 'por': 4, 'ees': 2, 'all': 1, 'isp': 1, 'vee': 1, 'kon': 1, 'oli': 1, 'lve': 1, 'llv': 1, 'ugi': 1, 'mee': 1, 'ool': 1, 'tug': 1, 'ito': 1, 'ane': 1, 'nna': 1, 'lan': 1, 'lis': 1, 'too': 1, 'tla': 1, 'nas': 1, 'onn': 1, 'git': 1, 'esp': 1, 'rtl': 1, 'sko': 1, 'esk': 1, 'asp': 1})
Harjutus
* Pane näited käima
* Leia levinumad tähtede kolmikud sõnadest laulma, regilaul, laulupidu
* Leia levinumad tähtede paarid samadest sõnadest
Erinevuse üldistatavus
Järjendite või sõnade suhteline sagedus ikka mõnevõrra kõigub. Testi abil aga saab hinnata, kuivõrd erinevus on üldistatav. Üheks mooduseks on 2x2 hii-ruut-test. Pythoni scipy-paketi stats mooduli chi2_contingency käskluse puhul tuleb andmed sisse anda kujul, kus mõlema uuritava andmestiku kohta on kirjas vaatluse all olevate järjendite arv ning kõigi muude järjendite arv. Siin näites võrdleme kahes tekstis sõna "kui" esinemissagedust
kui muu
tekst1 3 5
tekst2 0 7
ehk siis paar [kui1, mittekui1] on [3, 5] ning [kui2, mittekui2] on [0, 7]
Käsk anna väljundina loetelu, mille element nr 1 on võrdluse p-väärtus, ehk tõenäosus, et mõõdetava üksuse (praegusel juhul sõna "kui") sageduse erinevus on juhuslik (nullhüpotees).
from scipy import stats
tekst1="nii sina kui tema kui meie kui teie".split(" ")
tekst2="juhan vana naljahammas pikad saapad jalga tombas".split(" ")
kui1=tekst1.count("kui")
kui2=tekst2.count("kui")
mittekui1=len(tekst1)-kui1
mittekui2=len(tekst2)-kui2
print(kui1, kui2, mittekui1, mittekui2)
print(stats.chi2_contingency([[kui1, mittekui1], [kui2, mittekui2]])[1])
Käivitus:
$ python3.5 paarid3.py
3 0 5 7
0.244227262957
Vastusest paistab, et sarnaselt "kui"-sid kasutavate tekstide puhul võib 24% tõenäosusega juhtuda selline erinevus sageduses. See annab küll vihje, et siin võib olla midagi erinevat, aga veerandiga eksimisvõimalus on liiga suur millegi kindlama väitmiseks. Tüüpiliselt piirdutakse 5%, vahel ka 1% eksimisvõimalusega. Muutes esimest teksti veelgi kui-rikkamaks, näidatakse juhusliku sattumise tulemuseks 2,77%, mis ütleb, et nõnda suur sageduste erinevus juba naljalt kogemata ei teki.
tekst1="nii sina kui tema kui meie kui teie kui kui kui kui kui".split(" ")
0.0277372888154
Kui tekstid on pikemad ja andmeid rohkem, siis muutub ka juba väiksema suhtelise erinevuse puhul uuritava järjendi erinevus üldistatavaks.
Kahe teksti tähepaaride võrdlemine
Sõnade kasutuse üldistatava erinevuse uurimist nimetatakse võtmesõnade leidmiseks - näeb, millised sõnad kus tekstis üldistatavalt sagedamini esile tulevad. Sarnaselt aga saab võrrelda tähepaare/kolmikuid, silpe, nootide järjestust, pöörangu- ja teivasjaamade asetumist ning pea kõike üksiku või järjestuslõikude kaupa loendatavat.
Alustuseks küsime välja tähepaarid Kungla rahva laulu sõnadest. Asendame kõik peale tähtede tühikutega ning siis tükeldame teksti tühikute kohalt.
import urllib.request
import re
jadapikkus=2
def jadad(aadress):
tekst=urllib.request.urlopen(aadress).read().decode("utf8").lower()
tekst=re.sub(r'[^a-zõäöü]', ' ', tekst)
print(tekst)
sonad=tekst.split(' ')
koikjadad=[]
for sona in sonad:
sonajadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
koikjadad+=sonajadad
return koikjadad
jadad1=jadad("http://www.tlu.ee/~jaagup/andmed/keel/kunglarahvas.txt")
print(jadad1)
Väljundiks tekst
kui kungla rahvas kuldsel aal kord istus maha sööma siis vanemuine murumaal läks kandle lugu lööma läks aga metsa mängima läks aga laande lauluga sealt saivad lind ja lehepuu ja loomad laululugu siis laulis mets ja mere suu ja eesti rahva sugu siis kõlas kaunis lauluviis ja pärjad pandi pähe ja murueide tütreid siis sai eesti rahvas näha ma laulan mättal mäe peal ja õhtu hilja õues ja vanemuise kandle hääl see põksub minu põues
ja paarid
['ku', 'ui', 'ku', 'un', 'ng', 'gl', 'la', 'ra', 'ah', 'hv', 'va', 'as', 'ku', 'ul', 'ld', 'ds', 'se', 'el', 'aa', 'al', 'ko', 'or', 'rd', 'is', 'st', 'tu', 'us', 'ma', 'ah', 'ha', 'sö', 'öö', 'öm', 'ma', 'si', 'ii', 'is', 'va', 'an', 'ne', 'em', 'mu', 'ui', 'in', 'ne', 'mu', 'ur', 'ru', 'um', 'ma', 'aa', 'al', 'lä', 'äk', 'ks', 'ka', 'an', 'nd', 'dl', 'le', 'lu', 'ug', 'gu', 'lö', 'öö', 'öm', 'ma', 'lä', 'äk', 'ks', 'ag', 'ga', 'me', 'et', 'ts', 'sa', 'mä', 'än', 'ng', 'gi', 'im', 'ma', 'lä', 'äk', 'ks', 'ag', 'ga', 'la', 'aa', 'an', 'nd', 'de', 'la', 'au', 'ul', 'lu', 'ug', 'ga', 'se', 'ea', 'al', 'lt', 'sa', 'ai', 'iv', 'va', 'ad', 'li', 'in', 'nd', 'ja', 'le', 'eh', 'he', 'ep', 'pu', 'uu', 'ja', 'lo', 'oo', 'om', 'ma', 'ad', 'la', 'au', 'ul', 'lu', 'ul', 'lu', 'ug', 'gu', 'si', 'ii', 'is', 'la', 'au', 'ul', 'li', 'is', 'me', 'et', 'ts', 'ja', 'me', 'er', 're', 'su', 'uu', 'ja', 'ee', 'es', 'st', 'ti', 'ra', 'ah', 'hv', 'va', 'su', 'ug', 'gu', 'si', 'ii', 'is', 'kõ', 'õl', 'la', 'as', 'ka', 'au', 'un', 'ni', 'is', 'la', 'au', 'ul', 'lu', 'uv', 'vi', 'ii', 'is', 'ja', 'pä', 'är', 'rj', 'ja', 'ad', 'pa', 'an', 'nd', 'di', 'pä', 'äh', 'he', 'ja', 'mu', 'ur', 'ru', 'ue', 'ei', 'id', 'de', 'tü', 'üt', 'tr', 're', 'ei', 'id', 'si', 'ii', 'is', 'sa', 'ai', 'ee', 'es', 'st', 'ti', 'ra', 'ah', 'hv', 'va', 'as', 'nä', 'äh', 'ha', 'ma', 'la', 'au', 'ul', 'la', 'an', 'mä', 'ät', 'tt', 'ta', 'al', 'mä', 'äe', 'pe', 'ea', 'al', 'ja', 'õh', 'ht', 'tu', 'hi', 'il', 'lj', 'ja', 'õu', 'ue', 'es', 'ja', 'va', 'an', 'ne', 'em', 'mu', 'ui', 'is', 'se', 'ka', 'an', 'nd', 'dl', 'le', 'hä', 'ää', 'äl', 'se', 'ee', 'põ', 'õk', 'ks', 'su', 'ub', 'mi', 'in', 'nu', 'põ', 'õu', 'ue', 'es']
Eristuvate üksuste leidmiseks tuleb üht andmestikku võrrelda teisega. Siinsel juhul võtame Kungla rahva loo võrdluseks naljajutu lambipirni kohta. Sama alamprogramm aitab tekstist paarid leida, edasi tuleb iga paari kohta kokku lugeda, mitu seda kummaski tekstis leidub ning hii-ruudu valemi järgi vaadata, kas erinevus on üldistatav.
import urllib.request
import re
from collections import Counter
from scipy import stats
jadapikkus=2
def jadad(aadress):
tekst=urllib.request.urlopen(aadress).read().decode("utf8").lower()
tekst=re.sub(r'[^a-zõäöü]', ' ', tekst)
print(tekst)
sonad=tekst.split(' ')
koikjadad=[]
for sona in sonad:
sonajadad=[sona[arv:arv+jadapikkus] for arv in range(len(sona)-(jadapikkus-1))]
koikjadad+=sonajadad
return koikjadad
jadad1=jadad("http://www.tlu.ee/~jaagup/andmed/keel/kunglarahvas.txt")
jadad2=jadad("http://www.tlu.ee/~jaagup/andmed/keel/lambipirn.txt")
kogused1=Counter(jadad1)
kogused2=Counter(jadad2)
for jada in kogused1.keys():
jada1=kogused1[jada]
mittejada1=len(jadad1)-jada1
jada2=0
mittejada2=len(jadad2)
if jada in kogused2:
jada2=kogused2[jada]
mittejada2=len(jadad2)-jada2
print(stats.chi2_contingency([[jada1, mittejada1], [jada2, mittejada2]])[1], jada)
Näites võrdlen esialgu vaid Kungla rahva juures esinenud paare teise tekstiga. Nagu algusotsast näha, siis au on hästi eristuv, lä ka, samas mi ning so esinevad mõlemis tekstis võrreldavalt ning mõõdetavat erisust ei teki.
0.0449309837046 lä
0.832911553834 mi
0.420355516352 sö
0.00112842065061 au
…
Mõnevõrra täiendatud koodi teine pool: tsüklis vaatan ühisosa mõlema teksti tähepaaridest. Arvutan paaride osakaalu kummaski tekstis ning hiljem järjestan osakaalude vahe järgi. Nii on võimalik jälgida, kas neid on Kungla rahva loos rohkem või vähem. Kõigi massiivi elementide välja trükkimisel print(*r) abil asendab tärn listi r üksikud liikmed print käsu parameetriteks. Kirjapilt tähendab sama, kui print(r[0], r[1], r[2], r[3])
jadad1=jadad("http://www.tlu.ee/~jaagup/andmed/keel/kunglarahvas.txt")
jadad2=jadad("http://www.tlu.ee/~jaagup/andmed/keel/lambipirn.txt")
kogused1=Counter(jadad1)
kogused2=Counter(jadad2)
hoidla=[]
for jada in set(kogused1.keys()).union(set(kogused2.keys())):
jada1=0
mittejada1=len(jadad1)
jada2=0
mittejada2=len(jadad2)
if jada in kogused1:
jada1=kogused1[jada]
mittejada1=len(jadad1)-jada1
if jada in kogused2:
jada2=kogused2[jada]
mittejada2=len(jadad2)-jada2
sarnasustoenaosus=stats.chi2_contingency([[jada1, mittejada1], [jada2, mittejada2]])[1]
if sarnasustoenaosus<=0.1:
osakaal1=round(jada1/len(jadad1), 3)
osakaal2=round(jada2/len(jadad2), 3)
suund="+" if osakaal1>osakaal2 else "-"
hoidla.append([jada, suund, osakaal1, osakaal2, round(sarnasustoenaosus, 3)])
for r in sorted(hoidla, key=lambda rida: rida[2]-rida[3]):
print(*r)
Silp te paistab olema loetelus ainus, mis lambipirni jutus suurema sagedusega silma paistab - Kungla rahvas see puudub ning Lambipirni loos on sagedusega 1,5%. Tõenäosusega 7,4% on erinevus juhuslik, teistpidi siis vähemasti 90% kindlusega võime väita, et erinevus näitab lambipirni teksti eripära.
te - 0.0 0.015 0.074
öö + 0.007 0.001 0.043
dl + 0.007 0.0 0.001
öm + 0.007 0.0 0.001
ha + 0.007 0.0 0.001
me + 0.011 0.002 0.071
lä + 0.011 0.002 0.045
ui + 0.011 0.002 0.071
äk + 0.011 0.001 0.001
mä + 0.011 0.001 0.005
ug + 0.014 0.003 0.021
ue + 0.011 0.0 0.0
hv + 0.011 0.0 0.0
mu + 0.014 0.003 0.021
nd + 0.018 0.006 0.054
ii + 0.018 0.005 0.022
lu + 0.018 0.002 0.0
au + 0.021 0.004 0.001
an + 0.025 0.007 0.004
ja + 0.035 0.016 0.031
is + 0.032 0.012 0.017
la + 0.032 0.011 0.009
ul + 0.025 0.004 0.0
Harjutus
* Leia regiviiside tabelist kolm esimest nooti lugudel, mille tugiheli on g http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt
* Leia regiviiside tabelist kolm esimest nooti lugudel, mille tugiheli on c
* Leia alguskolmikute sagedused kummagi helistiku juures
* Leia Hii-ruut võrdluse abil, millised on kummagi helistiku jaoks eristuvad alguskolmikud
* Võrdle kummagi tugiheliga lugude juures libisevalt nelja nooti - leia eristavad järgnevused
Alguskolmikud
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode("utf8").split("\n")[1:]
gviisikolmikud=[rida.split(',')[10:13] for rida in viisid if rida.split(',')[6]=='g']
print(gviisikolmikud[:5])
[['2d', 'h', 'h'], ['2d', '2d', '2c'], ['2d', '2d', '2d'], ['g', 'd', '2c'], ['h', '2d', 'h']]
Alguskolmikud ja nende sagedused g ja c-duuris. Counteri objekt lubab levinumad sagedused välja kuvada most_common käsuga. Andmestikust vastava jada sageduste ja ülejäänud elementide sageduste välja näitamiseks lisati funktsioon jahei - nii ei pea sama lõiku mitmel korral kirjutama.
import urllib.request
from collections import Counter
from scipy import stats
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode("utf8").split("\n")[1:]
gviisikolmikud=["-".join(rida.split(',')[10:13])
for rida in viisid if rida.split(',')[6]=='g']
gkogused=Counter(gviisikolmikud)
print(gkogused.most_common(5))
cviisikolmikud=["-".join(rida.split(',')[10:13])
for rida in viisid if rida.split(',')[6]=='c']
ckogused=Counter(cviisikolmikud)
print(ckogused.most_common(5))
def jahei(jada, kogused, kolmikud):
jah=kogused[jada] if jada in kogused else 0
ei=len(kolmikud)-jah
return [jah, ei]
for jada in set(gkogused+ckogused):
jeg=jahei(jada, gkogused, gviisikolmikud)
jec=jahei(jada, ckogused, cviisikolmikud)
p=stats.chi2_contingency([jeg, jec])[1]
if p<0.01: print(jada, p, jeg, jec)
Eri helistike viiside algusnoodid eristuvad hästi - nii kuvame välja vaid need algused, mis vähemasti 99% tõenäosusega on vastavale helistikule eripärased võrreldes paariliseks valitud helistikule. Nagu aga näha, siis g-g-a on aga mõlemi helistiku puhul jällegi suhteliselt levinud algus - seega eristavate alla ei kuulu.
$ python3.5 viisijupid2.py
[('g-g-g', 149), ('g-a-h', 92), ('g-g-a', 87), ('2d-2d-2c', 83), ('2d-h-2d', 80)]
[('c-e-g', 35), ('2c-h-2c', 27), ('g-g-a', 20)]
g-h-2d 8.02231221191e-05 [77, 2169] [1, 536]
g-e-c 6.07235470694e-05 [0, 2246] [5, 532]
c-e-c 6.88961171888e-06 [0, 2246] [6, 531]
2d-h-h 0.000119138698246 [74, 2172] [1, 536]
g-a-h 0.000223128304399 [92, 2154] [4, 533]
2c-2e-2c 2.61656797782e-10 [4, 2242] [15, 522]
2e-2d-2c 1.18993385422e-07 [3, 2243] [11, 526]
Libisevalt leitud lõigud
Viimatises näites piirduti viiside algustega. Teistmoodi ülevaate viisi liikumisest saab, kui võtta ette viisist lõigud "akendena". Neljase akna puhul noodid 1-4, 2-5, 3-6 jne kuni lõpuni välja, 13-16. Nii tulevad kõrvuti olevad järjestused välja sõltumata nende asukohast viisis.
andmed={"kogus":0}
f=open("regiviisid.txt")
f.readline()
jadapikkus=4
viisipikkus=16
for rida in f:
if rida.strip().split(",")[6]=='g':
viis=rida.strip().split(",")[10:10+viisipikkus]
jadad=[viis[arv:arv+jadapikkus] for arv in range(viisipikkus-(jadapikkus-1))]
for jada in jadad:
plokk=andmed
plokk["kogus"]+=1
for noot in jada:
if noot in plokk:
plokk[noot]["kogus"]+=1
else:
plokk[noot]={"kogus":1}
plokk=plokk[noot]
f.close()
minkogus=100
f2=open("vastus.txt", "w")
#print(".\r", file=f2)
def kuva(plokk, taane):
for kogus, noot in sorted([[plokk[noot]["kogus"], noot] \
for noot in plokk if not noot=="kogus"], reverse=True):
if kogus>=minkogus:
print(taane*"\t"+noot+"_"+str(kogus)+"\r", file=f2)
kuva(plokk[noot], taane+1)
kuva(andmed, 0)
f2.close()
Väljundi algusots
a_6445
a_1915
g_689
g_476
h_151
a_459
a_129
f_180
2c_176
h_174
g_1545
g_980
g_824
h_218
a_125
h_1068
g_309
g_189
a_281
g_111
2c_220
h_126
2c_641
h_254
a_177
2c_129
f_504
a_209
g_113
2d_262
h_6213
a_1957
a_670
g_391
a_128
Väljund tervikuna näha aadressil
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/noodipuu1.txt
Nagu paistab, siis g-duuri viiside juures on levinuimad hoopis a-noodi ehk teise astmega algavad neljalised lõigud, neile järgnevad h-noodi ehk kolmanda astmega algavad lõigud ning alles kolmandana tulevad g-noodi enesega algavad lõigud.
G-ga algavatest lõikudest tehti aga suuremas kirjas illustreeriv puu, kus levinumad neljanoodilised järjestused näha. Ehkki need algavad viisist suvalistel kohtadel, siis mõttes läbi ümisedes tunduvad kõik meeldivad ja loogilised olema.
Rõhutatud kohtadest algavad lõigud
Eelmises näites võeti jadadeks kõik sobiva pikkusega lõigud ning viisilõigud tundusid juba seal meeldivad olema. Andmestikus olevad kaherealised kuueteistkümnenoodilised viisid jagunevad aga kõigepealt kaheks kaheksanoodiliseks reaks ning edasi sageli kumbki rida
kaheks omaette rõhutatud pooleks. Nii võtame siin näites jadade alguseks iga neljanda noodi, ehk noodid nullist lugedes järjekorranumbritega 0, 4, 9 ja 12
jadad=[viis[arv:arv+jadapikkus] for arv in [0, 4, 9, 12]]
Viisilõike eelnevaga võrreldes märgatavalt vähem, samas need nüüd enamikus rõhulise algusega kohtadest võetud ning võiksid seetõttu terviklikuma neljanoodilise lõigu välja anda. Väljundit puhastades jäeti praegu sisse vaid harud, mida nelja noodi ulatuses leidus vähemalt kahekümnel korral - nii võimalik neid oma kõrvadele terviklikumalt ja järjest läbi laulda.
Harjutus
* Tee näited läbi
* Tee samad näited läbi C-duuri põhiheliga viisidega. Näita, milline andmepuu tekib viisialguste puhul, milline libisevate jadade ning milline 1., 4., 9. ja 12. löögil algavate lõikude puhul
________________
Graaf ehk võrgustik
Puu näitab hästi hargnevaid andmejadasid. Kui punktid on läbisegi üksteisega seotud, siis üheks võimaluseks seoseid näha on graaf.
Gephi
Üheks levinud graafiandmetega tutvumise rakenduseks on vabalt installitav rakendus Gephi (gephi.org). Näidisena paneme sinna sisse kaheksa regilauluviisi kaks esimest nooti. Tulpade pealkirjadeks Gephi soovide järgi Source ning Target - ehk siis kust ja kuhu viis liigub. Kui andmeid vaadata, siis viis paari on 2d ja h vahel, kaks viisi algavad kahe 2d-ga ning üks seob omavahel g ja d.
Source,Target
2d,h
2d,2d
2d,2d
g,d
h,2d
2d,h
2d,h
2d,h
Andmete rakenduse sisse saamiseks tuleb fail salvestada csv-laiendiga - näiteks seosed1.csv. Luua Gephis uus projekt, valida sealt Data Laboratory -> Edges ning Import Spreadsheet
Näidatakse, millised tulbad failist leiti.
Lõpus küsitakse üle, kuhu saadud andmed paigutada. Esialgu võib valida "New workspace". Kui hiljem tahetakse samasse projekti ja töölehele andmeid juurde tuua, siis tuleb võtta alumine valik olemasolevatele andmetele lisamiseks.
Vajutades Overview peale, kuvatakse tekkinud joonis. Võib aimata, et jämedamad jooned on tugevamate seoste vahel.
Noodinimede nägemiseks tuleb Nodes sakilt valida "Copy data to other column" ning kopeerida Id-tulba andmed Label-tulpa. Siis saab Overview alt T-tähe juurest tekstid sisse lülitada ninga paistab lähemalt, et millega tegu.
Hiirega rullikuga kerides võimalik pilti lähemalt uudistada, samuti vastavalt soovidele värvida.
Kui seostele (edges) kirjutada tabelisse Label-ossa väärtused, siis saab needki joonistel kuvama panna.
Mõnevõrra sättides saab tulemuse silmale paremini loetavamaks.
Harjutus
* Tee näide läbi
* Leia tähepaarid sõnas kalamaja, paiguta csv-faili. Näita Gephi abil seosed tähtede vahel
Seoste faili genereerimine
Algusotsa proovisime käsitsi. Kogu regilaulude faili läbi käimiseks on aga koodilõik sõbralik abiline. Kuvatakse kõik G-duuri viiside kahest esimesest noodist tekkivad seosed
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode('utf8').split("\n")[1:]
f=open("seosed2.csv", "w")
print("Source,Target", file=f)
for viis in viisid:
m=viis.split(",")
if m[6]=="g":
print(m[10]+","+m[11], file=f)
f.close()
Tulemus
Source,Target
2d,h
2d,2d
2d,2d
g,d
h,2d
2d,h
2d,h
2d,h
2d,h
h,2d
h,2d
h,2d
Esimese hooga sisse lugedes tuleb pilt mõnevõrra kirju, siiski näha mõned suuremad nooled levinumate seoste kohta
Data Laboratory alt jätame alles vaid seosed, mida on rohkem - nii saab ka pildi selgemaks. Seosed saab kaalu (ehk praegusel juhul arvu) järgi järjestada ning siis alumised maha kustutada.
Pilt saab selgemaks
Lähemalt välja suurendades paistab, kuidas seosed G-noodi juurest liiguvad.
Enamkasutatavate sõlmede jaoks saab paremalt välja arvutada "Average Degree" - ehk kui palju ühendusi millise sõlme juures on.
Tulemusena tekib iga sõlme juurde tulp "Degree", mille järgi leiab üles levinumad sõlmed ja võib nad alles jätta.
Harjutus
* Tee näide läbi
* Koosta programm, mis salvestab etteantud tekstist tähepaarid faili. Koosta nendest Gephi abil joonis
Viisilõik graafina
Võrgustik võimaldab näidata, et kui palju ühest kõrguselt teise üleminekuid millise noodi juures on. Selleks valime g-duuri viisid ning märgime esimese nelja noodi juures noodipaarid. Sõlmed tähistame koos löögi järjekorranumbriga. Paarid 2d_1,h_2
ning h_2,h_3 tähendavad, et viisi esimene noot oli 2d, teine h ning kolmas ka h - kokku moodustavad nad kaks järjestikust paari.
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode('utf8').split("\n")[1:]
f=open("seosed4.csv", "w")
print("Source,Target", file=f)
for viis in viisid:
m=viis.split(",")
if m[6]=="g":
for algus in range(10, 14):
print(m[algus]+"_"+str(algus-9)+","+m[algus+1]+"_"+str(algus-8), file=f)
f.close()
Tulemus:
Source,Target
2d_1,h_2
h_2,h_3
h_3,g_4
g_4,h_5
2d_1,2d_2
2d_2,2c_3
2c_3,h_4
h_4,2d_5
2d_1,2d_2
2d_2,2d_3
2d_3,2c_4
2c_4,h_5
g_1,d_2
d_2,2c_3
Kui graaf Gephi abil välja joonistada, levinumad sõlmed alles jätta ning sõlmed löökide järgi paika tõsta, saab ligikaudu sarnase tulemuse:
Nagu näha, on loo algul levinud noodipaarid g-g ning 2d-h. Edasi saab samuti vaadata, et kui levinult viisid liiguvad.
Algus ja ots
Lõigu alguse ja lõpu selgemaks kuvamiseks ning sõlmede mugavamaks tõstmiseks on vahel hea luua eraldi "olematud" sõlmed alguse ja otsa tarbeks. Et ei peaks käsitsi haruldasemaid sõlmi eraldama, jätame koodi vaid kontrolli, millise nimega sõlmedest seosed alles jätta.
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode('utf8').split("\n")[1:]
alles={"g", "a", "h", "2c", "2d", "algus", "ots"}
f=open("seosed5.csv", "w")
print("Source,Target", file=f)
for viis in viisid:
m=viis.split(",")
if m[6]=="g":
for algus in range(10, 13):
if m[algus] in alles and m[algus+1] in alles:
if algus==10: print("algus,"+m[algus]+"_1", file=f)
print(m[algus]+"_"+str(algus-9)+","+m[algus+1]+"_"+str(algus-8), file=f)
if algus==12: print(m[algus+1]+"_4,ots", file=f)
f.close()
Tulemus
Source,Target
algus,2d_1
2d_1,h_2
h_2,h_3
h_3,g_4
g_4,ots
algus,2d_1
2d_1,2d_2
2d_2,2c_3
2c_3,h_4
h_4,ots
algus,2d_1
2d_1,2d_2
2d_2,2d_3
2d_3,2c_4
2c_4,ots
Kuvamise ajal on võimalik algus ja ots soovitud paikadesse tõsta ning siis kohtadele kinnitada. Selleks tuleb sõlme peal valida hiire parema klahviga "Settle". Edasi näiteks Force Atlas 2 paigutus tõstab ülejäänud sõlmed enamvähem sobilikultpaika, mõnevõrra saab neid veel hiirega järele sättida.
Harjutus
* Tee näide läbi
* Leia mõned a-tähega algavad neljatähelised sõnad. Koosta nendest programmi abil sarnane sisendfail ja graaf
Koordinaatide järgi paigutus
Alles jäävatele sõlmedele määrame juba koodi sees y-koordinaadi. Nii need pärast hea samale kõrgusele sättida. Koostame nii seoste kui sõlmede faili.
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode('utf8').split("\n")[1:]
alles={"g":0, "a":10, "h":20, "2c":30, "2d":40}
f=open("seosed5.csv", "w")
print("Source,Target", file=f)
for viis in viisid:
m=viis.split(",")
if m[6]=="g":
for algus in range(10, 13):
if m[algus] in alles and m[algus+1] in alles:
if algus==10: print("algus,"+m[algus]+"_1", file=f)
print(m[algus]+"_"+str(algus-9)+","+m[algus+1]+"_"+str(algus-8), file=f)
if algus==12: print(m[algus+1]+"_4,ots", file=f)
f.close()
f2=open("solmed5.csv", "w")
print("Id,Label,x,y", file=f2)
print("algus,algus,0,20", file=f2)
for nr in range(1, 5):
for noot in alles:
print(noot+"_"+str(nr)+","+noot+","+str(nr*10)+","+str(alles[noot]),file=f2)
print("ots,ots,50,20", file=f2)
f2.close()
Tulemus:
seosed5.csv
Source,Target
algus,2d_1
2d_1,h_2
h_2,h_3
h_3,g_4
g_4,ots
algus,2d_1
2d_1,2d_2
2d_2,2c_3
2c_3,h_4
h_4,ots
algus,2d_1
2d_1,2d_2
2d_2,2d_3
2d_3,2c_4
2c_4,ots
2c_3,2c_4
2c_4,ots
….
solmed5.csv
Id,Label,x,y
algus,algus,0,20
2c_1,2c,10,30
h_1,h,10,20
a_1,a,10,10
g_1,g,10,0
2d_1,2d,10,40
2c_2,2c,20,30
h_2,h,20,20
a_2,a,20,10
g_2,g,20,0
2d_2,2d,20,40
2c_3,2c,30,30
h_3,h,30,20
a_3,a,30,10
g_3,g,30,0
2d_3,2d,30,40
2c_4,2c,40,30
h_4,h,40,20
a_4,a,40,10
g_4,g,40,0
2d_4,2d,40,40
ots,ots,50,20
GeoLayouti installimine
Gephil on mitukümmend lisamoodulit. Neid lisada saab Tools-menüü Plugins käsu abil. Available loetelust leiab Geo Layout'i, mille siis paigaldada saab.
Tools->Plugins->Available-> Geo Layout - install
Layout -> Geo Layout. Latitude - y, Longitude - x
Võrreldese eelmise joonisega näeb joonis nüüd süstemaatilisem välja
Harjutus
* Koostage tekstifail sarnase kõlaga neljatähelistest sõnadest
* Koostage sõna tähtedest eelnenud viisinäitega sarnane graaf, kus näha, millistel kohtadel on rohkem üleminekuid ühest tähest teise.
Animatsioon graafiga
Gephi võimaldab panna ühe parameetri (näiteks aja) muutuma ning siis kuvada jooniseid vastavalt sellele muutumisele. Isikute failis märgime kolme isiku tegutsemise ajad. Nagu näha, siis Juku ajavahemik on kõige pikem. Temaga koos asus tegutsema kõigepealt Kati. Mõne aja pärast lisandus Mati ning Kati lahkus.
isikud.csv
Id,Label,alates,kuni
Juku,Juku,1998,2005
Kati,Kati,1999,2002
Mati,Mati,2001,2005
Et Gephi võtaks aastaid ajavahemikuna, tuleb pärast andmete sisse saamist "alates" ja "kuni" tulp ühendada üheks ajaintervalli tulbaks. Selleks tuleb valida Merge columns ning Join strategy alt time interval.
Selle peale tekib lehe alla rohelise nupuga märk Enable Timeline. Sellele vajutades ning Overview peale minnes näeb all ajatelge, kus on võimalik omale sobiv lõik valida. Paistab, et aasta 2000 keskel tegutsesid koos Juku ja Kati.
Uuel aastal lisandus ka Mati
Seoste ajatelg
Graafis on lisaks sõlmedele tähtsal kohal seosed. Ka sinna saab panna ajavahemiku.
seosed.csv
Source,Target,alates,kuni
Juku,Mati,2001,2002
Juku,Mati,2004,2005
Nagu näha, siis Juku ja Mati tegutsesid koos kahes eraldi lõigus. Samamoodi tulpade ühendamisega saab need ajaintervalliks määrata.
Vastavalt ajaakna paigutusele näeb siis, et kas Juku ja Mati tegutsevad parajasti koos või mitte. 2001. aastal jah
2002. aastal mitte
ning 2004. aastal taas.
Ajavahemikud
Alguse ja otsa tulbaga saab igale sõlmele määrata vaid ühe ajavahemiku. Sama tegelane võib aga areenil olla korduvalt. Vahepeal ära kaduda ning siis jälle tagasi tulla. Gephis on sarnaste kirjapanekute jaoks tulp nimega timeset (väikese tähega). Noolsulgude <> ning seal sees omakorda veel ükshaaval semikoolonitega eraldatult kandiliste sulgude vahele pandud aegadega saab määrata, millistel vahemikel on märgitud sõna näha.
CSV-faili näide:
Id Label timeset
Juku Juku <[1980,1980];[1990,1993]>
Kati Kati <[1984,1986];[1992,1992]>
Andmestiku saab lehele sisse lugeda
ning siis kinnitada, et just vastavate tulpadega tahetakse tegelda
Sisse loeteluna saab Gephi aru, et tegemist intervalliga.
Edasi on nimi näha vastavalt ajajoonel tehtud valikule.
Harjutus
* Tee näide läbi
* Lisa mõned isikud ja ajavahemikud, veendu toimimises
Seosed vastavalt löögile
Seosed nootide vahel võivad erineda vastavalt sellele, millise viisi osaga on tegemist. Kuvamiseks koostame kõigepealt noodipaaride tabeli, kus iga paari puhul näha, milliste järjestikuste löökide vahel see moodustatud.
Source,Target,alates,kuni
2d,h,1,2
h,h,2,3
2d,2d,1,2
2d,2c,2,3
2d,2d,1,2
2d,2d,2,3
Vastavalt ajaaknale on näha aktiivsed seosed
Loetelu sõlmedest ehk nootidest
Sarnase tulemuse koostamiseks programmilõik. Üks fail tehakse noodiseostega ning teine nootide koordinaatidega.
import urllib.request
viisid=urllib.request.urlopen("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt"
).read().decode('utf8').split("\n")[1:]
alles={"g":[0, 0], "a":[10, 20], "h":[30, 30], "2c":[50, 20], "2d":[60, 0]}
f=open("noodiseosed1.csv", "w")
print("Source,Target,alates,kuni", file=f)
nihe=10
pikkus=4
for viis in viisid[:5]:
m=viis.split(",")
if m[6]=="g":
for algus in range(nihe, nihe+pikkus-1):
if m[algus] in alles and m[algus+1] in alles:
print(m[algus]+","+m[algus+1]+","+str(algus-nihe)+","+str(algus-nihe+1), file=f)
f.close()
f2=open("noodid1.csv", "w")
print("Id,Label,x,y", file=f2)
for noot in alles:
print(noot+","+noot+","+str(alles[noot][0])+","+str(alles[noot][1]), file=f2)
f2.close()
Valminud failid:
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1009 $ more noodiseosed1.csv
Source,Target,alates,kuni
2d,h,0,1
h,h,1,2
h,g,2,3
2d,2d,0,1
2d,2c,1,2
2c,h,2,3
2d,2d,0,1
2d,2d,1,2
2d,2c,2,3
2c,2c,2,3
h,2d,0,1
2d,h,1,2
h,2c,2,3
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1009 $ more noodid1.csv
Id,Label,x,y
2c,2c,50,20
2d,2d,60,0
a,a,10,20
h,h,30,30
g,g,0,0
Joonis vastavalt taktiaknale
Harjutus
* Pane näited tööle
* Koosta sarnane muudetav joonis a-ga algavate neljatäheliste sõnade tähtedevaheliste seoste kohta
Veebiteenused
Rakendusi soovitakse mõnikord omavahel ühendada - kõike ei saa ja pea alati ise tegema ning mõnigikord on vaja välisest allikast iga mõne aja tagant uusi ja värskeid andmeid, et neid näiteks enese omadega võrdlusena kuvada. Sageli on võõras rakendus kirjutatud teistsuguses keeles, asub turvapiirangute taga või muul puhul ei pääse sellele kuigi lihtsalt ligi. Tänapäeval toimib märgatav osa lahendusi veebis ning veebiteenused on üks mugav moodus võõrsilt omale killukeste juurde haakimiseks ning vajalike arvutuste ja lisanduste teha laskmiseks. Milline on lahenduse oma poole ning võõrsilt juurde hangitud võimaluste vahekord, see sõltub juba loodavast lahendusest.
Oma lehele väljapoolt pildi lisamiseks tuleb kõigepealt kindlaks teha lisatava pildi aadress. Veebiseiluri parem hiireklõps aitab sellele vahel kaasa.
Edasi võimalik see aadress oma html-faili lisada
Pildid
Piltide leht
ja lehte vaadata
Leht lehes
Teise lehe lisamiseks oma lehe sisse sobib iframe käsklus
Pildid
Piltide leht
Pilt võetud lehestikust ajapaik.ee
Leht koostatud kursusel:
Tulemusena ongi üks leht teise lehe sees. Nõnda võib lisada mitmesuguseid valmislahendusi - graafikuid, tabeleid, mänge ja muid rakendusi.
Harjutus
* Tee näide läbi
* Koosta ise väike veebileht, kus sees tekst, pilt ning teine veebilehekülg
JSON
Mitmekülgsete andmete üheks sobivaks ülekandevormiks on JSON (JavaScript Object Notation). Seal on iga väärtuse juurde omadusena kirjutatud, et millega tegemist. Üks JSONi näide ajapaik.ee lehelt pildi andmete küsimise kohta. Aadress:
https://opendata.ajapaik.ee/photos/148348/geotags/?format=json
Ja tulemus
[{"id":215856,"lat":59.4362959945468,"lon":24.7426373215637,"geography":"SRID=4326;POINT (24.7426373215637 59.4362959945468)","azimuth":298.996843617767,"azimuth_line_end_lat":59.4364662079086,"azimuth_line_end_lon":24.7423302086315,"zoom_level":18,"origin":0,"type":0,"map_type":2,"hint_used":false,"photo_flipped":false,"is_correct":true,"azimuth_correct":true,"score":391,"azimuth_score":100,"trustworthiness":0.973063973063973,"created":"2018-09-23T06:56:15.996981Z","modified":"2018-09-23T06:56:17.216411Z","user":1150476,"photo":148348}]
Välimised kantsulud näitavad, et tuleb andmete loetelu (mis praegu koosneb vaid ühest kirjest). Edasi looksulgude vahel kirje omadused, kätte püüame saada laius- ja pikkuskraadi. Käsklus json_decode suudab PHP puhul JSON-failist sobiva objekti tekitada, mille seest siis edasi andmeid küsida.
lat." ".$obj[0]->lon;
Tulemus:
59.436295994547
24.742637321564
Foto üldisemad andmed saab ilma parameetrit geotags lisamata.
https://opendata.ajapaik.ee/photos/148348/?format=json
Tulemuse näide:
{"id":148348,"rephotos":[],"similar_photos":[],"geotags":"https://opendata.ajapaik.ee/photos/148348/geotags/","image":"https://opendata.ajapaik.ee/media/uploads/muis_sLh7NnQ.jpg","image_unscaled":null,"image_no_watermark":null,"height":558,"width":800,"aspect_ratio":null,"flip":false,"invert":false,"stereo":false,"rotated":null,"date":null,"date_text":null,"title":null,"title_et":null,"title_en":null,"title_ru":null,"title_fi":null,"title_sv":null,"title_nl":null,"title_de":null,"title_no":null,"description":"Tema Pühadus paavst Johannes Paulus II oma legendaarsel kuulikindlast klaasist pealisehitisega Mercedesel läbi linna sõitmas.","description_et":"Tema Pühadus paavst Johannes Paulus II oma legendaarsel kuulikindlast klaasist pealisehitisega Mercedesel läbi linna sõitmas.", …
Andmete kuvamine lehel:
description;
Tulemus:
Tema Pühadus paavst Johannes Paulus II oma legendaarsel kuulikindlast klaasist pealisehitisega Mercedesel läbi linna sõitmas.
Harjutus
* Pane näide PHP-võimelises kohas tööle
* Küsi andmed välja fotolt aadressiga https://opendata.ajapaik.ee/photos/198312/?format=json
Leht vastavalt parameetrile
Oma lehele saab samuti sobivaid andmeid ette anda - praegusel juhul kuvatava foto numbri. See omakorda pannakse veebiaadressile, kust pilti vaadatakse.
description;
http://praktika1.cs.tlu.ee/~jaagup/2019/kvalitatiivne_digihumanitaaria/1016/json3.php?nr=100000
Väljund:
Linnavaade. Marja tn 30 Tartus 1992a.
Harjutus
* Koostage veebileht, kus aadressireale pildinumbri sisestamisega kuvatakse ajapaik.ee serverist vastava koodiga pildi kirjeldus ja koordinaadid
* Lisa võimalusel ka pilt ise leheküljele
description." ";
$obj=json_decode(file_get_contents("https://opendata.ajapaik.ee/photos/$nr/geotags/?format=json"));
echo $obj[0]->lat." ".$obj[0]->lon;
Avamine:
http://praktika1.cs.tlu.ee/~jaagup/2019/kvalitatiivne_digihumanitaaria/1016/json4.php?nr=100000
Tulemus:
Linnavaade. Marja tn 30 Tartus 1992a.
58.387397972468
26.713786780595
Andmete korjamisel muutujatesse saab neid edasi kergemini lehe sees välja näidata.
description;
$pildiaadress=$obj->image;
$obj=json_decode(file_get_contents("https://opendata.ajapaik.ee/photos/$nr/geotags/?format=json"));
$asukoht=$obj[0]->lat." ".$obj[0]->lon;
?>
Pildi leht
Kirjeldus:
Asukoht:
Vaatamine:
http://praktika1.cs.tlu.ee/~jaagup/2019/kvalitatiivne_digihumanitaaria/1016/json5.php?nr=100000
Failid võivad ka edasi näidata. Siin saadakse kõigepealt opendata.ajapaik.ee avalehelt piltide loetelu viidete ja pealkirjadega ning edasi pildile vajutades kuvatakse eraldi lehel vastav pilt koos andmetega.
Piltide andmete loetelu
Tulemus:
* Maarjamägi 1962 pildistatud Lasnamäe paekaldalt
* Axams (878m) gegen Nordkette (Tirol)
* Mikonkatu 9,11,13,15,17. Etualalla ravintola Planet Hollywood.
* Kauppatori, kävelysilta Keisarinluodonlaiturille. Taustalla Pohjoisesplanadi 1,3,5,7,9.
* Pitkänsillanranta ja Pitkäsilta. Uusi kivisilta valmistui 1912 puisen tilalle.
* Kaivokatu 9, 7 (= Asema-aukio). Hillerin korttelin taloja, jotka purettiin uuden rautatieaseman tieltä.
* Kaivokatu 12,10. Etualalla Helsingin Kaupungin Liikennelaitoksen infotaulu.
* Rautatientori, oikealla Mikonkatu 15,17,19.
* Helsingin rautatieasema Kaivokadun puolelta nähtynä.
* Mannerheimintie 9, Kaivokadun ja Mannerheimintien risteys.
RSSi lugemine
Uudistevorming on aastaid populaarne moodus andmete edastamiseks. Näitena Postimehe RSS
https://www.postimees.ee/rss
RSS Generator 2.1.1http://www.rssboard.org/rss-specificationPostimeesetMon, 28 Oct 2019 13:12:36 +0000
https://www.postimees.ee
Postimees: Värsked uudised Eestist ja välismaalt. Loe lähemalthttps://f.pmo.ee/logos/81/6f1c8d9387ad9a7bfa5c20eb59287380.svgPostimees
https://www.postimees.ee
23045Postimees: Värsked uudised Eestist ja välismaalt. Loe lähemaltArgus ja Ellermann esinesid edukalt Helsingi horse showlNädalavahetusel Helsingis toimunud nimekal horse show’l võistlesid maailmatippude kõrval ka Paul-Richard Argus ja Dina Ellermann, kes naasesid võistluselt mitmete võitude ja auhinnaliste kohtadega.
https://pmo.ee/6812233
pm#6812233Mon, 28 Oct 2019 15:10:58 +0200Eesti Ratsaspordi LiitSportRatsutamineTakistussõitEesti-Läti koostööfilm «Surematu» kogub auhinduJuuli alguses Karlovy Vary A-klassi festivalil esilinastunud ja dokumentaalfilmi Grand Prix võitnud «Surematu» võitis ühe nädala jooksul kaks peaauhinda. Ksenija Ohhapkina Oscarile kandideeriv dokumentaalfilm tunnistati parimaks Astra rahvusvahelisel festivalil Rumeenias ja nädal hiljem ArtDokfesti võistlusprogrammis Riia filmifestivalil.
https://pmo.ee/6812232
pm#6812232Mon, 28 Oct 2019 15:07:41 +0200KultuuritoimetusKultuurFilmTea Danilov: pension eile, täna ja hommeRiiklikud pensionisüsteemid, nagu me neid Euroopas tunneme, on mitmete arengute tõttu surve all, nende «parim enne» hakkab mööda saama, kirjutab Arenguseire Keskuse juhataja Tea Danilov.
https://pmo.ee/6812226
pm#6812226Mon, 28 Oct 2019 14:59:48 +0200Tea DanilovArvamus
Sealt saab pealkirjad kätte järgneva koodiga
Uudised
Postimehe värsked uudised
channel->item as $uudis){
echo "
$uudis->title
";
}
?>
Tulemus:
Pealkirjale RSSist vajutatav viide ka juurde
Uudised
Trükitavatele ridadele sai juurde ka reavahetus - nii HTMLi lähtekood paremini loetav.
Harjutus
* Uurige, millistelt lehtedelt on võimalik JSON-i, XMLi või muul kujul andmeid kätte saada
* Koostage oma leht, kus kasutatakse mujalt tõmmatud andmeid
Kaardirakendused
Asukohaandmed toetavad andmestikku mitmesuguste valdkondade juures. Kaardi pealt paistab leidude paiknemine mõnigikord selgemalt välja kui kirjelduste juurest.
Maa-ameti kaardid Leafletiga
Arvutiga hakati üksikuid kaardiandmeid töötlema juba 1960ndatel, vabamalt ja laiemalt ja veebis sai kaardirakendusi kokku panna aga alles pärast sajandivahetust. Maaamet oli selles suhtes usin ning 2005. aasta paiku pääses nende kaudu ligi juba mitmetele kaardikihtidele ning sai kasutada riigipoolseid lahendusi ja luua omi. Maaameti lehe näide:
https://geoportaal.maaamet.ee/docs/WMS/leaflet.html
Mugavaks kaardiandmete näitajaks on tõusnud JavaScripti teek Leaflet. Teegil endal kaardiandmeid pole, tuleb näidata eri kohtadest pakutavaid kaarte. Siin näitena maaameti kaardiandmete kuvamine.
Kuvamiseks tuleb luua kaardi objekt
kaart = L.map('kaardikiht').setView([59.43, 24.75], 13);
Esimese parameetrina näha asukoht (laius- ja pikkuskraad), teisena suurendus. Mida suurem number, seda lähem vaade. Suurenduse 6 juures jääb peale enamvähem terve Euroopa, suurenduse 16 puhul maja ja tänavanurk.
Edasi määrata, milliselt aadressilt ja milliste parameetritega saadakse kätte kaarditükid. Antakse ette suurendus ning asupaiga koordinaadid. Maaameti sooviks on, et parameetril näidataks ära, millise asutuse ja alamosaga on kaartide küsijana tegemist - nii saavad nad hiljem omapoolseid kokkuvõtteid teha.
https://tiles.maaamet.ee/tm/tms/1.0.0/hybriid@GMC/11/1164/1448.png&ASUTUS=TLU&ERIALA=DIGIHUMANITAARIA
kuvab näiteks enamiku Aegna saarest
Kaarti kuvav kood tervikuna
Kaart
ning nähtav tulemus.
Harjutus
* Pane näide tööle
* Kuva kaardil oma kodumaakond
OpenStreetMap
Sarnane kaart mapbox.com-i kaudu kättesaadava OpenStreetMap kaardipakkuja andmetega. Sealse võtme saamiseks tuleb end aga keskkonnas registreerida. Muu sama, vaid aadress teine pole vaja määrata, et kaarditükid tulevad TMS-projektsioonis. Kohustuslikult viisakas on näidata kaardiandmete pakkujat kaardil.
Kaart
Hüpikmenüü
Leafletiga tuleb kaasa objekt nimega L, mil küljes mitmesuguseid käske. Käsklus popup() loob hüpikmenüü.
hypik=L.popup();
kaart.on("click", vajutus);
Kaardi peal hiireklõpsu peale käivitub funktsioon vajutus(), mis saab kaasa vajutuse andmed. Ühtlasi kuvatakse sealtkaudu laius- ning pikkuskraad.
function vajutus(e){
hypik.setLatLng(e.latlng).
setContent("Vajutasid "+e.latlng.toString()).openOn(kaart);
}
Kood tervikuna
Kaart
Töö tulemus
Kaardile saab lisada markereid, ringe ja muud kraami (jooned, pinnad). Ringi lisamiseks sobib käsklus
L.circle([59.439047, 24.772159], 100).addTo(kaart);
Harjutus
* Pane näide tööle
* Paiguta hüpikmenüü maa-ameti kaardile
Koordinaadid nimetuse järgi
Käsistsi ükshaaval asukohtade leidmiseks on mugav veebileht
https://www.latlong.net/convert-address-to-lat-long.html
Kui aadresse on vaja rohkem küsida, siis sobib teenus api.opencagedata.com. Selle pruukimiseks peab võtme registreerima ning võtmega saab päevas tasuta küsida 2500 vastet. Vastuse vorminguteks XML ning JSON.
https://api.opencagedata.com/geocode/v1/json?q=Kuusalu&key=77ca3d44a80c40b6adac3efbaa8db31a&language=en&pretty=1
Tuleb vastuseks päris pikk tekst, kust vaja siis sobivad väärtused üles otsida.
{
"documentation" : "https://opencagedata.com/api",
"licenses" : [
{
"name" : "see attribution guide",
"url" : "https://opencagedata.com/credits"
}
],
"rate" : {
"limit" : 2500,
"remaining" : 2493,
"reset" : 1573516800
},
"results" : [
{
"annotations" : {
"DMS" : {
"lat" : "59\u00b0 26' 42.63288'' N",
"lng" : "25\u00b0 26' 3.80796'' E"
},
"MGRS" : "35VMF1122190668",
"Maidenhead" : "KO29rk26du",
"Mercator" : {
"x" : 2831343.463,
"y" : 8240405.148
},
"OSM" : {
"edit_url" : "https://www.openstreetmap.org/edit?relation=355276#map=16/59.44518/25.43439",
"url" : "https://www.openstreetmap.org/?mlat=59.44518&mlon=25.43439#map=16/59.44518/25.43439"
},
"UN_M49" : {
"regions" : {
"EE" : "233",
"EUROPE" : "150",
"NORTHERN_EUROPE" : "154",
"WORLD" : "001"
},
"statistical_groupings" : [
"MEDC"
]
},
"callingcode" : 372,
"currency" : {
"alternate_symbols" : [],
"decimal_mark" : ",",
"html_entity" : "€",
"iso_code" : "EUR",
"iso_numeric" : "978",
"name" : "Euro",
"smallest_denomination" : 1,
"subunit" : "Cent",
"subunit_to_unit" : 100,
"symbol" : "\u20ac",
"symbol_first" : 1,
"thousands_separator" : "."
},
"flag" : "\ud83c\uddea\ud83c\uddea",
"geohash" : "udd44v8v0rbw67sdc9s7",
"qibla" : 158.61,
"roadinfo" : {
"drive_on" : "right",
"speed_in" : "km/h"
},
"sun" : {
"rise" : {
"apparent" : 1573452180,
"astronomical" : 1573443480,
"civil" : 1573449420,
"nautical" : 1573446360
},
"set" : {
"apparent" : 1573480860,
"astronomical" : 1573489560,
"civil" : 1573483680,
"nautical" : 1573486680
}
},
"timezone" : {
"name" : "Europe/Tallinn",
"now_in_dst" : 0,
"offset_sec" : 7200,
"offset_string" : "+0200",
"short_name" : "EET"
},
"what3words" : {
"words" : "snaps.others.meddled"
},
"wikidata" : "Q2668988"
},
"bounds" : {
"northeast" : {
"lat" : 59.45018,
"lng" : 25.455839
},
"southwest" : {
"lat" : 59.4407034,
"lng" : 25.4135192
}
},
"components" : {
"ISO_3166-1_alpha-2" : "EE",
"ISO_3166-1_alpha-3" : "EST",
"_type" : "neighbourhood",
"city_district" : "Kuusalu alevik",
"continent" : "Europe",
"country" : "Estonia",
"country_code" : "ee",
"county" : "Kuusalu vald",
"political_union" : "European Union"
},
"confidence" : 8,
"formatted" : "Kuusalu alevik, Kuusalu vald, Estonia",
"geometry" : {
"lat" : 59.4451758,
"lng" : 25.4343911
}
}
]}
Faili tervikkuju kättesaadav aadressil
http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviis_asukoht_kuusalu.txt
Pythonil on õnneks JSON-kujul tekstist sobivate andmete eraldamiseks sobiv teek olemas. Sisendfaili uurides paistab, et Kuusalu koordinaadid leiab massiivi results sektsioonist geometry.
import json
obj=json.loads(open("regiviis_asukoht_kuusalu.txt").read())
asukoht=obj["results"][0]["geometry"]
print(asukoht["lat"], asukoht["lng"])
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1104 $ python3.5 loe_json.py
59.4451758 25.4343911
Kõikide kihelkonnanimede leidmiseks ühendame viisid ja nende metaandmed tulpade FKey ja ID kaudu
import pandas as pd
viisid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt")
viisidmeta=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisidmeta.txt")
koos=viisid.merge(viisidmeta, left_on="FKey", right_on="ID")
print(list(sorted(set(filter(lambda t: isinstance(t, (str)),koos["kihelkond"].values.tolist())))))
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1104 $ python3.5 asukohad3.py
['?', 'Ambla', 'Ambla>Jõhvi', 'Ambla>Kadrina', 'Ambla>Väike-Maarja', 'Anna', 'Anseküla', 'Antsla?', 'Audru', 'Audru>Järva-Madise', 'Emmaste', 'Haljala', 'Haljala>Kadrina', 'Haljala>Rakvere', 'Halliste', 'Hanila', 'Hanila>Varbla', 'Hargla', 'Hargla>Pärnu', 'Hargla>Rõuge', 'Harju-Jaani', 'Harju-Jaani [tänap. Jõelähtme v.]', 'Harju-Jaani>Ambla', 'Harju-Jaani>Kadrina', 'Harju-Jaani>Kuusalu', 'Harju-Jaani>Rakvere', 'Harjumaa', 'Helme', 'Helme? kust seegi info?', 'Häädemeeste', 'Häädemeeste k/n', 'Iisaku', 'Iisaku>Jõhvi', 'Jaani', 'Juuru', 'Juuru>Rapla', 'Jämaja', 'Järva-Jaani', 'Järva-Jaani [?Väika-Maarja]', 'Järva-Jaani>Ambla', 'Järva-Jaani>Narva', 'Järva-Jaani>Väike-Maarja', 'Järva-Madise', 'Järva-Madise>Ambla', 'Järva-Madise>Järva-Jaani?', 'Järvamaa', 'Jõelähtme', 'Jõhvi', 'Jõhvi>Iisaku', 'Jüri>Kuusalu', 'Kaarma', 'Kadria', 'Kadrina', 'Kadrina > Väike-Maarja', 'Kadrina>Ambla', 'Kadrina>Haljala', 'Kadrina>Rakvere', 'Kadrina>Väike-Maarja', 'Kadrina>Väikr-Maarja', 'Kambja', 'Kambja>Kanepi', 'Kanepi', 'Kanepi>Otepää', 'Karja', 'Karja>Vormsi', 'Karksi', 'Karksi>Halliste', 'Karula', 'Karula>Pilistvere', 'Karula>Suure-Jaani', 'Karuse', 'Karuse [Kullamaa?]', 'Karuse>Hanila', 'Karuse>Häädemeeste', 'Kaukasus', 'Keila', 'Kihelkonna', 'Kihelkonna>Anseküla', 'Kihnu', 'Kihnu?>Kodavere', 'Kingissepa', 'Kirbla', 'Kodavere', 'Kodavere>Jõhvi', 'Koeru', 'Koeru>Järva-Madise', 'Koeru>Jõhvi', 'Koeru>Laiuse', 'Koeru>Narva', 'Koeru>Peetri', 'Koeru>Simuna', 'Koeru>Väike-Maarja', 'Koeru?/Järva-Madise?', 'Koeru?>Ambla', 'Kolga-Jaani', 'Kolga-Jaani>Kodavere', 'Kolga-Jaani>Laiuse', 'Kolga-Jaani>Rannu', 'Kose', 'Kose>Harju-Jaani', 'Kose>Järva-Madise', 'Kraasna', 'Krimm', 'Kullamaa', 'Kullamaa>Haapsalu', 'Kursi', 'Kuusalu', 'Kuusalu>Jamburi-Simititsa', 'Kuusalu>Mustamere r.', 'Käina', 'Kärla', 'Kõpu', 'Kõrgepalu', 'Laiuse', 'LaiuseMaarja-Magdaleena', 'Laiuse>Torma', 'Leivu', 'Lihula', 'Lihula>Kullamaa', 'Lihula>Rapla', 'Lutsi', 'Lääne-Nigula', 'Läänemaa', 'Läänemaa (ranna Läänemaa)', 'Lüganuse', 'Lüganuse>Jõhvi', 'Maarja-Magdaleena', 'Martna', 'Martna>Rapla', 'Mihkli', 'Muhu', 'Muhu>Karuse', 'Muhu?', 'Mustjala', 'Mustjala>Anseküla', 'Mustjala>Kärla', 'Märjamaa', 'Märjamaa>Hageri', 'Nissi', 'Noarootsi', 'Noarootsi>Lääne-Nigula', 'Nõo', 'Nõo>Tartu-Maarja?', 'Otepää', 'Otepää>Haapsalu', 'Otepää>Mihkli', 'Paistu', 'Paistu>Halliste', 'Paistu>Helme', 'Paistu>Koeru', 'Paistu>Suure-Jaani', 'Paistu>Türi', 'Palamuse', 'Peetri', 'Peetri>Järva-Jaani', 'Peetri>Rakvere', 'Peetri>Torma', 'Peterburg', 'Petserimaa', 'Pilistvere', 'Pilistvere>Ambla', 'Pilistvere>Peterburg', 'Pilistvere>Rakvere', 'Pilisvere', 'Puhja', 'Puhja>Nõo', 'Puhja>Tartu', 'Pärnu', 'Pärnu-Jaagupi', 'Pärnumaa', 'Põhja-Kaukaasia eesti asundus', 'Põltsamaa', 'Põltsamaa>Kursi', 'Põltsamaa>Lüganuse>Jõhvi', 'Põlva', 'Põlva>Räpina', 'Pöide', 'Püha>Harju-Jaani', 'Pühalepa', 'Rakvere', 'Rannu', 'Rapla', 'Reigi', 'Ridala', 'Ridala>Haapsalu', 'Risti', 'Ruhnu', 'Räpina', 'Rõngu', 'Rõuge', 'Rõuge>Setu', 'Rõuge?', 'Rõuge?=Vastseliina?', 'Saarde', 'Sangaste', 'Sangaste>Otepää', 'Setu', 'Setu, Järvesuu v.', 'Setu, Meremäe v.', 'Setu, Meremäe v.>Misso', 'Setu, Misso v.', 'Setu, Misso v.>Kambja', 'Setu, Misso v.>Nõo al.', 'Setu, Mäe v.', 'Setu, Petseri v.', 'Setu, Saatse v.', 'Setu, Saatse v.>MMg', 'Setu, Saatse v.>Sangaste', 'Setu, Vilo v.', 'Setu, Vilo v.>Räpina', 'Setu>Karula', 'Setu>Rõuge', 'Simuna', 'Simuna>Haljala', 'Simuna>Jõhvi', 'Suure-Jaani', 'Suure-Jaani>Järva-Madise', 'Suure-Jaani>Türi', 'Tallinn', 'Tallinn>Laiuse-Tähtvere', 'Tallinn>Orarino', 'Tartu', 'Tartu l.', 'Tartu-Maarja', 'Tartu/Paistu', 'Tartumaa', 'Tarvastu', 'Tarvastu>Kambja', 'Tarvastu>Puhja', 'Tarvastu>Rõuge', 'Tarvastu>Tallinn', 'Tarvastu>Türi', 'Tori', 'Tori>Suure-Jaani', 'Torma', 'Tõstamaa', 'Tõstamaa/Audru', 'Tõstamaa? Hanila?', 'Tõstamaa? Hanila? Mihkli?', 'Türi', 'Türi>Ambla', 'Türi>Jõhvi', 'Türi>Peetri', 'Türi>Pilistvere', 'Türi>Rapla', 'Urvaste', 'Urvaste(Karula', 'Vaivara', 'Vaivara>Jõhvi', 'Vana-Antsla v.', 'Varbla', 'Varbla>Tõstamaa', 'Vastseliina', 'Vastseliina?=Rõuge?', 'Vigala', 'Vigala/Karuse', 'Vigala>Kullamaa', 'Vigala>Märjamaa', 'Viljandi', 'Viljandi>Pillistvere', 'Viljandi?>Tartu', 'Viru-Jaagupi', 'Viru-Jaagupi>Väike-Maarja', 'Viru-Nigula', 'Viru-Nigula>Haljala', 'Viru-Nigula>Rakvere', 'Vormsi', 'Väike-Maarja', 'Väike-Maarja>Ambla', 'Väike-Maarja>Kadrina', 'Vändra', 'Vändra>Kose', 'Vändra>Pärnu-Jaagupi', 'Vändra?', 'Võnnu', 'Võru v.>Vastseliina', 'Võrumaa', 'karksi', 'Äksi', 'Äksi>Jõhvi']
Veebiaadressis kasutamiseks tuleb erisümbolid asendada nende jaoks vajalike tähekombinatsioonidega. Seda mõistab käsklus urllib.parse.quote
>>> import urllib.parse
>>> urllib.parse.quote("Koeru>Väike-Maarja")
'Koeru%3EV%C3%A4ike-Maarja'
Kahe näite koostöös valmib fail, kus iga eri asukoha tarbeks küsitakse selle koordinaadid opencagedata.com lehelt ning salvestatakse tulemus faili
import urllib.parse
import urllib.request
import json
import pandas as pd
viisid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt")
viisidmeta=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisidmeta.txt")
koos=viisid.merge(viisidmeta, left_on="FKey", right_on="ID")
paiganimed=list(sorted(set(filter(lambda t: isinstance(t, (str)),koos["kihelkond"].values.tolist()))))
f=open("koordinaadid.txt", "w")
for paiganimi in paiganimed:
try:
print(paiganimi)
veebiaadress="https://api.opencagedata.com/geocode/v1/json?q="+urllib.parse.quote(paiganimi)+"&key=77ca3d44a80c40b6adac3efbaa8db31a&language=en&pretty=1"
veebisisu=urllib.request.urlopen(veebiaadress).read().decode("utf-8")
obj=json.loads(veebisisu)
asukoht=obj["results"][0]["geometry"]
f.write(paiganimi+","+str(asukoht["lat"])+","+str(asukoht["lng"])+"\n")
except:
print("vigane ", paiganimi)
f.close()
Käivitus
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1104 $ python3.5 asukohad3.py
?
vigane ?
Ambla
Ambla>Jõhvi
...
ja valminud fail
Ambla,59.1776682,25.7162154
Ambla>Jõhvi,59.35917,27.42111
Ambla>Kadrina,59.33472,26.145
Ambla>Väike-Maarja,59.12639,26.25
Anna,10.416667,77.666667
Anseküla,58.096624,22.2180925
Antsla?,57.8754879,26.491877
Audru,58.4094616,24.3438522
Audru>Järva-Madise,59.11639,25.65861
Emmaste,58.7021644,22.5801435
tervikuna nähtav
http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid_koordinaadid.txt
Kontroll lugemiseks, et kas saadakse andmed kätte. Vastatakse, et real 178 on sellega probleem.
>>> import pandas as pd
>>> kohad=pd.read_csv("koordinaadid.txt")
Traceback (most recent call last):
File "", line 1, in
File "/usr/local/lib/python3.5/dist-packages/pandas/io/parsers.py", line 655, in parser_f
pandas.errors.ParserError: Error tokenizing data. C error: Expected 3 fields in line 178, saw 4
Setu, Vilo v.>Räpina,58.09806,27.46361
Lähemal uurimisel paistab, et tegemist reaga, kus ka aadressis eneses on sees koma - nii ei saa csv-lugeja aru, kus on tulpade vahe. Lihtsama lahendusena eemaldame koma aadressist. Kui sarnaseid aadresse oleks palju, siis tuleks aga miski süstemaatilisem lahendus välja mõelda - olgu kõikide aadressisiseste komade eemaldamine või aadressile jutumärkide ümber panek
>>> kohad=pd.read_csv("koordinaadid.txt")
Setu Vilo v.>Räpina,58.09806,27.46361
Koordinaatide kuvamine kaardile
Alustuseks näide, kus kuvatakse kaart ning loetakse serverist kihelkondade koordinaadid
Kaart
Leht toimivana aadressil
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/kaart_asukohad1.html
Juurde osa, kus iga koha marker paigutatakse kaardile
Kaart
Tulemus veebilehena
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/kaart_asukohad2.html
Harjutus
* Pane näide tööle
* Jäta tekstifaili vaid kodumaakonna paari kihelkonna koordinaadid. Kuva kaart ekraanile koos nende kohta käivate markeritega
Valitud algusnootidega viiside asukohad
Siiani oli koordinaatide failis vaid kihelkonna või küla asukoht. Nüüd aga püüame iga viisi juurde märkida koordinaadid, kust see üles kirjutatud. Loome iga algusnoodi kohta eri faili. Siin näites h-noodiga algavad viisid ja nende asukohad.
import pandas as pd
viisid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt")
viisidmeta=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisidmeta.txt")
koordinaadid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid_koordinaadid.txt", header=None).rename(columns={0:"kohanimi",1:"laiuskraad",2:"pikkuskraad"})
koos=viisid.merge(viisidmeta, left_on="FKey", right_on="ID")
koos=koos.merge(koordinaadid, left_on="kihelkond", right_on="kohanimi")
koos[koos["P1"]=="h"][["kohanimi", "laiuskraad", "pikkuskraad"]].to_csv("algush.txt", index=False)
Tulemus järgmine:
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1113 $ more algush.txt
kohanimi,laiuskraad,pikkuskraad
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
Ambla,59.17766820000001,25.7162154
ehk siis sama koha peale tuleb mitu viisi.
Kuvamine:
Kaart
Viisid, mille esimeseks noodiks on h:
Viisid, mille algusnoodiks on 2d:
Pikema alguslõigu järgi filtreerimiseks tuleb lihtsalt mitut nooti võrrelda.
import pandas as pd
viisid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid.txt")
viisidmeta=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisidmeta.txt")
koordinaadid=pd.read_csv("http://www.tlu.ee/~jaagup/andmed/muu/muusika/regiviisid_koordinaadid.txt", header=None).rename(columns={0:"kohanimi",1:"laiuskraad",2:"pikkuskraad"})
koos=viisid.merge(viisidmeta, left_on="FKey", right_on="ID")
koos=koos.merge(koordinaadid, left_on="kihelkond", right_on="kohanimi")
algus=["g", "g", "a", "h"]
koos[(koos["P1"]==algus[0]) & (koos["P2"]==algus[1]) & (koos["P3"]==algus[2]) & (koos["P4"]==algus[3])][["kohanimi", "laiuskraad", "pikkuskraad"]].to_csv("algusggah.txt", index=False)
Nagu failisuuruste järgi näha, siis tuli fail märgatavalt lühem:
[jaagup@lin2 kvalitatiivne_digihumanitaaria]$ ls -la algus*
-rw-rw-r-- 1 jaagup jaagup 31435 Nov 13 15:10 algus2d.txt
-rw-rw-r-- 1 jaagup jaagup 3128 Nov 13 15:43 algusggah.txt
-rw-rw-r-- 1 jaagup jaagup 24886 Nov 13 15:42 algush.txt
Joonise järgi näha, et ggah-algusega viisid on üles kirjutatud peamiselt idapoolsest Eestist, mõni üksik heledam ring leida ka mujalt.
Harjutus
* Pane näited tööle
* Lisa loetellu g-algusega viisid
* Leia g-tugiheliga viiside hulgast kümme leivinuimat algusnelikut. Koosta kaart, kus saab valida neliku ning näha nende viiside paiknemisi.
MIDI helid
Kuivõrd muusika ja kunstid kuuluvad humanitaarvaldkonna alla, selle üle vahel vaieldakse. Mõningane seos neil omavahel igatahes on - näiteks lauludes saavad kokku nii teksti- kui viisipool.
Digivaldkonnas vanaks ja lihtsaks helilõikude esitamise mooduseks on MIDI - Musical Instrument Digital Interface. Lihtsamal kujul antakse teada, millisel kõrgusel ja millal noot kõlab. Süntesaatori - olgu siis riist- või tarkvaralise - ülesandeks on valitud pilliga vastav noot kõlama panna.
Veebis on MIDI-häälte kõlama panekuks levinud vahend nimega Midi.js.
https://github.com/mudcube/MIDI.js/
Laeme alla
Pakime lahti
jaagup@praktika1 ~/public_html/2019/kvalitatiivne_digihumanitaaria/1118 $ unzip MIDI.js-master.zip
Käivitamiseks peab see olema veebiserveris, kohalikust kataloogist ei saa brauser vajalikke faile kätte. Kataloogis examples leiab paar töötavat näidet. Neist saab mõne aluseks võtta, kus näha, et millised failid vaja käivitamiseks sisse lugeda. Tekib objekt nimega MIDI, millele tuleb siis pärast lehe laadimist öelda:
MIDI.loadPlugin({soundfontUrl: "./soundfont/",
instrument: "acoustic_grand_piano"});
Klaver on kohe olemas, teisi instrumente peab hiljem vajadusel juurde laadima.
Lihtsam näide heli tekitamise kohta. Iga nupuvajutuse kohta kõlab C-noot, ehk noot helikõrgusega 60 MIDI-süsteemis.
Harjutus
* Koostage leht viie nupuga (C D E F G), pange igaühe vajutamisel helisema vastava MIDI-kõrgusega noot (60 62 64 65 67). Mängige nt. Rongisõitu nende nuppude peal
Lahendus:
Väljanägemine
ja kasutusaadress
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/noot2.html
Valitud helistiku noodid
Täiendus lehele. Rippmenüüst saab valida, et millise helistikuga on tegu ning nupu peale vajutades võetakse sellest helistikust niimitmes aste.
Proovimiskoht
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/noot3.html
Järjestikku kõlavad noodid
Mitme noodi järjest kõlama panekuks võib MIDI.noteOn käsule viimaseks parameetriks anda ooteaja sekundites. C-duuri üksikute nootidega kolmkõla tarbeks praegusel juhul C ehk 60 hakkab kõlama kohe vajutuse peale. E ehk 64 poole sekundi pärast ning G ehk 67 terve sekundi pärast.
Veebiaadress:
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/noot4.html
Harjutus
* Lisage nupp mollkolmkõla tarbeks. Keskmine noot on poole tooni ehk ühe MIDI numbri võrra madalam
* Pange eelmisest näitest tagasi helistiku valik. Algusnoot, mis siin näites on 60, tuleb vastavalt rippmenüüst valitud helistiku tähele. C-60, D-62, E-64. Muud noodid ka samavõrra kõrgemad
Veebiaadress
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/noot5.html
Regiviisi mängimine
Andmed saab kätte tekstifailist XMLHttpRequesti kaudu. Tükeldatakse kõigepealt reavahetuste koha pealt iga viisi kaupa eraldi ning siis komade koha pealt nootide kaupa eraldi. Viisinoodid on kohtadel 10-26. Et enamik viise G-duuris, siis f-i MIDI-koodiks on pandud f# oma 66 - põhjalikumal juhul tasuks andmestikust järgi vaadata, et millistele nootidele vaja kõrgendused panna. Praegusel juhul mängitakse vaid esimene viis, realt number 1 - rida 0 on tulpade pealkirjade jaoks. Iga järgmine noot eelmisest poole sekundi jagu hilisem.
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/viis1.html
Üleskirjutuste juures mitmel pool on jäänud valik mitme noodi vahel - et kuidas laulja seda parasjagu välja andis või kuivõrd me tempereeritud noodijoonestik oma ja küla kõrvade järgi kasvanud laulikuga kokku sobib. Et sageli on teine võimalik noot kantsulgudes järel, arvuti aga sellist valikuga nooti ei mõista kergesti mängida, siis jätame praegu mängides alles vaid esimese valiku.
function helikorgus(rida, koht){
let s=rida[koht];
if(s.indexOf("[")>=0){
s=s.substring(0, s.indexOf("["));
console.log(s);
}
return helikorgused[s];
}
Kui noodi üleskirjutuses on kandiline sulg, siis võetakse vaid sellele sulule eelnev tekst. Lõpuks leitakse helikõrguste hulgast tähele sobiv väärtus. Mitmenda viisiga tegemist, valitakse rippmenüüst.
Veebiviide:
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/viis2.html
Viisi andmepuu koostamine
Sarnaselt eespool Pythoni abil kokku pandud puule, kannatab selle ka JavaScripti abil veebilehel teha. Siin näites võetakse aluseks g-duuris ning g-noodiga algavad viisid, igast viisist neli algusnooti. Globaalmuutuja andmed on kättesaadav kogu lehe ulatuses. Puu ehitamiseks on abimuutujaks plokk, mis viitab parasjagu sellele kohale, kus viisipuu ehitamisega ollakse. Sarnaselt Pythoni näitele peetakse ka siin alammuutujas kogus meeles, et mitu viisi puus sellesse kohta jõuavad. Pärastine käsklus kuvaPuu(plokk) loob HTML-i vaste puu etteantud kohale/plokile. Kusjuures alamharude HTML-kujule panekuks kasutab sama funktsiooni väljakutset ehk rekursiooni.
Väljund:
Vasakul näha andmepuu veebikujul, paremal console.log abil mälutõmmisena.
ja veebiaadress:
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/viis3.html
Mõned täiendused juurde. Puu levinumaid harusid võib olla kasulik varem näha - selleks järjestame iga haru alamväärtused nende koguste järgi kahanevalt. Ploki seest kõsime alemelemendid ehk võtmed. Noodid on need, mis pole nimega "kogus". Omakorda järjestame võtmed nende alamelementide "kogus" väärtuste järgi.
let votmed=Object.keys(plokk).filter(function(voti){return voti!="kogus"}).
sort(function(v1, v2){return plokk[v2].kogus-plokk[v1].kogus});
for(let nr=0; nr10){
HTMLpuu+="
";
}
Viiside juures on ilus ja hariv nende kõla kuulata. Et nootide nimed juba puus, siis tuleb need sealt välja korjata ja maha mängida. Pärast kuvaPuu funktsiooni tööd näeb HTML-i puu-osa välja järgnev:
g 845
g 370
g 149
g/a 75
a 23
h 19
...
Ehk siis iga noot on omaette
, alamnoodid li-de sees ning noodi nimi omaette span-i sees. Nii on võimalik sellele span-ile vajutamisele reageerida. Eelnevate nootide kätte saamiseks tuleb aga puus liikuda ülespoole. Vajutusfunktsiooni juures this on see span, millele vajutati. Sõlmest taseme ülespoole saab küsida funktsiooniga parentNode. Kontrollimaks, et kas on võimalik veel puus ülespoole liikuda, kontrollime, et kas kolm taset kõrgemal on li-nimeline element (vahepeal asub ul). Nootide nimed paigutatakse vastavanimelisse massiivi ning enne maha mängimist pööratakse massiiv ümber - sest noote asuti lisama lõpust.
function vajutus(solm){
var noodid=[solm.innerText];
while(solm.parentNode.parentNode.parentNode.nodeName=="LI"){
solm=solm.parentNode.parentNode.parentNode.getElementsByTagName("span")[0];
noodid.push(solm.innerText);
}
noodid=noodid.reverse();
for(let i=0; i
Veebiaadress:
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/viis6.html
Jooniste koostamine
Mõni tulemus ja seletus paistab paremini tekstina, mõni tabelina mõni pildina. Veebilehel jooniste kuvamine on hea moodus andmete ja mõtete illustreerimiseks. Lähemate aastate jooksul pidavat veebilehe lõuendile (canvas) loodav graafika üha levinumaks muutuma.
Algusnäide
Joonis pannakse tekkima kohe veebilehe avanemisel.
Joonis
Kuvamiseks kasutatakse graafilist konteksti, mil sees parasjagu kasutatav värv, kirja suurus ja muud vajalikud näitajad. x-telg on ekraanil vasakult paremale, y-telg ülalt alla. Käsklus fillRect loob ristküliku. Parameetriteks kaugus vasakult servast, kaugus ülevalt servast, ristküliku laius ja kõrgus. Soovitav värv tuleb graafilise konteksti külge panna enne kujundi joonistamist. Joone ja ringi loomine tuleb alustada beginPath -käsuga, lõplik vormistus vastavalt stroke või fill vastavalt sellele, kas tõmmatakse piirjooned või täidetakse seest.
Tulemus:
ja veebileht:
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/joonis1.html
Harjutus
* Pane näide tööle
* Vaheta kujundite värve ja asukohti
* Joonista joonest ja ringist koosnev noot
Regiviiside intervallide sagedused tulpdiagrammina
Kõigepealt leitakse nootide helikõrgused, seejärel kõrvutiste nootide kõrguste vahed ehk intervallid ning siis loetakse kokku, mitu iga helikõrgust on. Edasi kuvatakse väiksemad ja ühtlasi levinumad intervallid joonisele, kõiki andmeid näeb konsooliaknast
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/intervallid1.html
Harjutus
* Pane näide tööle
* Kujuta iga intervalli sagedus vastava suurusega noodina
Graafijoonis Cytoscape abil
Graafiandmete veebis kuvamiseks on üheks kättesaadavaks ja mugavaks vahendiks Cytoscape, veebiaadress js.cytoscape.org.
Teegi võib sisse lugeda CDN-i kaudu ning kohe kasutama hakata. Graafi kuvamiseks veebilehel tuleb talle ette anda kasutatav kiht (div), mille sees siis cytoscapel lubatud vabalt toimetada. Elementidest piirdume praegu ühega, mille id on algus. Stiiliga määratakse, millisena seda kuvatakse. Omadus 'label':'data(id)' tähendab, et nähtavaks tekstiks on data-elemendi alamelement id väärtus.
Graaf
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/graaf1.html
Rohkemate elementide näitamiseks võib need lihtsalt ritta laduda. Seoste (edge) puhul tuleb määrata, et kust algavad ja kuhu lõppevad. Lõpus paigutuskäsklus
graaf.layout({name: 'circle'}).run()
määrab, et sõlmed tuleb paigutada ringjoonele.
Graaf
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/graaf2.html
Graafi andmete muutmine
Ülalpool ehitasime laulu andmestiku eraldi valmis ning alles siis püüdsime seda kuvada. Siin aga on võimalik graafi ehitada koos andmetega ja kohe ka tulemust näha. Esialgu tõmmatakse andmed kohale nagu mõnes varasemas näites. Funktsiooni lisaAlgusnoot(noot) ülesandeks on lisada graafi noot kui seda veel pole ning alustuseks määrata alguse ja vastava noodi seose tugevuseks 1. Järgmisel korral suurendatakse seose omadust width ühe võrra. Noodi lisamine
graaf.add({group:'nodes', data:{id:noot}});
Seose lisamine
graaf.add({group:'edges', data:{source:'algus', target:noot, width:1}});
Seoste küsimine, mille sihtkohaks on soovitud noot
let e=graaf.edges("[target='"+noot+"']");
Omaduse width suurendamine ühe võrra. Ehk siis küsitakse vana väärtus, arvutatakse üks juurde ning paigutatakse samale kohale tagasi
e.data("width", e.data("width")+1);
Funktsioon tervikuna
function lisaAlgusnoot(noot){
if(kasutusel.includes(noot)){
if(graaf.getElementById(noot).length==0){
graaf.add({group:'nodes', data:{id:noot}});
graaf.add({group:'edges', data:{source:'algus', target:noot, width:1}});
} else {
let e=graaf.edges("[target='"+noot+"']");
e.data("width", e.data("width")+1);
}
}
}
Seose peal teksti kuvamiseks tuleb lihtsalt määrata, millisest tunnusest see võetakse
{selector: 'edge', style:{'label': 'data(width)'}}
Rakenduse kood tervikuna
Graaf
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/graaf4.html
Harjutus
* Pane näited tööle
* Koosta veebilehel tähtede järgnevusseoste graaf sõnadele "sina", "siia" ja "saia".
Viisi nootide järgnevus
Veidi pikem näide veebilehel töötava graafi võimaluste kohta. Koostatakse lugude soovitud arvust algusnootidest, pildi selguse huvides määratakse kasutusel olevad ehk nähtavad noodid. Noodisõlmede ning nendevaheliste seoste suurus sõltub esinemiskordade arvust. Seoste puhul kasutatakse logaritmi, et eri suurusega seosed näha jääksid. Praegu piirdutakse g-duuri viisidega. Seose peal hiirega vajutades näeb seose esinemiskordade arvu.
Graaf
Kasutatav aadressil
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/graaf5.html
Chart.js
Joonised aitavad arve ilmestada. Püsivate andmetega joonised saab pildina teksti sisse panna. Kui algandmed täienevad või kasutaja tasub pakkuda võimalus andmetega mängida ja neid mitmest küljest vaadata, siis aitavad veebilehel genereeritud joonised. Üheks lihtsaks põhijooniseid pakkuvaks JavaScripti teegiks on Chart.js.
Joonise saamiseks tuleb teegi kood CDNi ehk koodipakkuja juurest sisse lugeda, määrata joonise arvud ja selgitavad sõnad, koostada lehel element joonise paigutamiseks ja siduda see joonisega.
Joonis
Nii võibki tulemust imetleda
Harjutus
* Tee näide läbi
* Koosta tulpdiagramm sõnade ja nende tähtede arvudega
Värvide lisamine, mitu andmerida
Andmestiku all muutuja datasets on massiiv, sinna alla saab paigutada mitu andmerida, igaühega neist kaasa anda ka soovitud taustavärvi
Joonis
Mõned seadistused: legend peitu ning y-telje loendamine algab nullist. Nii paremini aru saada, kui üks tulp on teisest mingi arv kordi suurem või väiksem. Kogu joonisele ka pealkiri.
Joonis
Tulemus:
Harjutus
* Tee näide läbi
* Koosta sõnadest tulpdiagramm, kus iga sõna kohta üks tulp näitab täishäälikute arvu ja teine sulghäälikute arvu
* Pane tulpade skaala algama nullist
Sektordiagramm
Kasutatakse, kui soovitakse näidata, kui suure osa moodustab iga väärtus tervikust. Tehniliselt loomine tulpdiagrammi moodi, ainult et joonise tüübiks tuleb valida "pie".
Joonis
Jooniste andmestikku saab jooniste näitamise ajal muuta. All näites lisatakse tunnuseks lausemärk ning tema väärtuseks 11. Käsu update() peale kuvatakse joonis uute andmetega.
Joonis
Pildid seisust enne ja pärast:
Harjutus
* Koostage sektordiagramm sõnadega "rahvas" ja "kui", sektori suurus vastab sõna tähtede arvule.
* Kasutaja saab tekstiväljast ükshaaval lisada sõnu, sõna jõuab sektordiagrammile, sektori suurus vastab sõna tähtede arvule.
Joonis
Joonis veebist loetud andmete põhjal
XmlHttpRequest-i kaudu loetud andmetest saab koha peal arvutada sobivad väärtused ning need joonisena välja kuvada. Siin kuvatakse tulpdiagrammina soovitud arvu levinumate algusnootide sagedused
Joonis
Tulemus:
Leht nähtav aadressil
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/joonis6.html
Andmetega mängimiseks saab kasutaja valida algusnoodi ning tulpdiagrammil näidatakse talle loo teise noodi esinemise sagedused tulpdiagrammina.
Joonis
Algusnoot:
Tulemus veebis
http://www.tlu.ee/~jaagup/dh/kvalitatiivne_digihumanitaaria/examples/joonis7.html
Kordamisküsimused
Märksõnu seminariks, kvalitatiivne digihumanitaaria
Andmepuude kasutamine järjestatud andmete seaduspärade leidmiseks ja esitamiseks.
Bi-, tri- ja tetragramid. (Suhteliste) sageduste võrdlemine, autori andmete tuvastamine
Puukujuliste andmete esitamise vormingud: json, XML.
Andmepuu loomise algoritm
Näiteid eri tüüpi andmetest koostatud puudest -
tähed, silbid, sõnaliigid, lauseliikmed, viisinoodid
Teksti lauseliikmete leidmine, kasutamine puu koostamisel.
Puu harudes jälgimine, mille põhjal vastav haru moodustati
Puus elementide kuvamine sageduse järjekorras
Regiviiside andmestikust nootide eraldamine
XML-väljund, xml.dom.minidom.
HTML-väljund
,
Smart Art-i abil andmepuu kuvamine
Iseloomulike väärtuste esile toomine hii-ruut testi abil (võtmesõnad)
Graafi kasutamine andmete esitamisel ja uurimisel, näiteid
Gephi abil graafide loomine, paigutusmoodused Gephis
Viisijärgnevuste esitamine graafina
Graafidega seotud animatsioonide loomine
Graafid veebilehel
Väliste veebiandmete kasutamine oma rakenduste juures
Teenuste näiteid
Tehnilisi kasutusnäiteid
Oma andmete veebi kaudu kättesaadavaks tegemine
Kaardirakendused, kasutatavad vahendid, võimalused
Koordinaatide leidmise moodused
Interaktiivse kaardirakenduse koostamine
MIDI helid (veebilehel)
Graaf veebilehel
Joonised veebilehel
Kokkuvõte
Kvalitatiivsed meetodid võimaldavad samu nähtusi kirjeldada mitmest suunast ning saada tulemustele kinnitusi mitmel moel samadele järeldustele jõudmise kaudu. Või ka saada vaadeldes erisuguseid tulemusi ning sealtkaudu teha järeldusi, et uuritav aines on esmapilgul paistvast keerukam ning mitmekülgsemaks kasutamiseks vajab pikemat süvenemist. Aastatega arenevad digivahendid võimaldavad nüüdseks ka humanitaaridel oma tööle kasulikke abijõude leida selleks samas liialt tehnilistesse üksikasjadesse uppumata. Siinse kirjutise näited annavad mõne suuna jaoks ette otsesed vahendid pealispinna alla piilumiseks, teisalt jälle loodetavasti julgustavad konkreetsele mure lahendamiseks sobivaid abivahendeid otsima.