minitorn.tlu.eeminitorn.tlu.ee/~jaagup/oma/too/11/05/Eesti_vahekeele... · Web viewKorpuseks nimetatakse elektroonilist keeleandmekogu, kuhu on valitud tekstid nii, et need annaksid

TALLINNA ÜLIKOOLI HAAPSALU KOLLEDŽ

Rakendusinformaatika

Siim Medijainen

EESTI VAHEKEELE KORPUSE TEKSTIDE MÄRGENDUSMOODULI

ARENDAMINE

Diplomitöö

Juhendajad: Jaagup Kippar,

Erika Matsak

Haapsalu 2011

DiplomitööEesti vahekeele korpuse tekstide märgendusmoodul 2011

SISUKORD

Sissejuhatus.................................................................................................................................3

1 Keelekorpused, nende eesmärk ja kasutamine....................................................................4

2 Olemasolev märgendamine.................................................................................................6

2.1 Eelised.........................................................................................................................7

2.2 Puudused.....................................................................................................................7

3 Korpuse märgendamisega seotud osa tehniline struktuur...................................................8

3.1 Vealiikide salvestamine..............................................................................................8

3.2 Xpathi kasutamine märgendite asukoha salvestamisel...............................................9

3.3 Vigade näitamine......................................................................................................10

3.4 Vajalikud täiendused ja nende eesmärgid.................................................................12

4 Eesti vahekeele korpuse testkeskkonna loomine..............................................................13

4.1 Platvormi spetsifikatsioon.........................................................................................13

4.2 Kasutatud tarkvara....................................................................................................14

4.3 Zope platvormi kirjeldus...........................................................................................14

4.4 PostgreSQL andmebaas............................................................................................15

4.5 Javascript veebiarenduses.........................................................................................15

4.6 Javascripti raamistikud..............................................................................................15

5 Muudatuste tehniline kirjeldus..........................................................................................17

6 Edasiarendusvõimalused...................................................................................................26

7 Tekstimudelid...................................................................................................................27

7.1 Üldistatud märgendus...............................................................................................27

7.2 TEI märgendus..........................................................................................................27

Kokkuvõte.................................................................................................................................29

Kasutatud allikad......................................................................................................................30

Lisa 1. Document.py täiendused...............................................................................................31

Lisa 2. document_view.pt täiendused.......................................................................................32

Lisa 3. document_view.js täiendused.......................................................................................33

TLÜ Haapsalu Kolledž 2Siim Medijainen


Lisa 4. xpath_evaluator.js täiENdused......................................................................................42

SISSEJUHATUS

Diplomitöö teema valikul tuginesin juhendaja soovitustele, kes on varem tegelenud Eesti

vahekeele korpuse tarkvara arendusega. Samuti on teema valik tingitud minu üldisest huvist

veebipõhise tarkvara arendamise ja programmeerimise vastu. Määravaks sai ka konkreetne

vajadus antud lahenduse järele.

Käesoleva diplomitöö eesmärkideks on anda ülevaade keelekorpustest ja nende kasutamisest

ning tutvustada Eesti vahekeele korpuse märgendusmooduli tööpõhimõtet. Tuua esile

positiivseid ja negatiivseid külgi olemasoleva süsteemi juures ning täiustada kasutajaliidese

funktsionaalsust.

Eesmärgist lähtuvalt on ülesandeks luua testkeskkond, mis jäljendaks võimalikult täpselt Eesti

vahekeele korpust. Parandada korpuse kasutajaliidese funktsionaalsust, vastavalt etteantud

spetsifikatsoonile ning kirjeldada tehtud muudatusi. Kirjeldada edaspidiseid vajalikke

parandusi ning edasiarendusvõimalusi.

Töö meetodiks on praktilise lahenduse loomine Eesti vahekeele korpuse tekstide

märgendusmooduli edasiarenduse näol.

Töö koosneb keelekorpuste üldisest kirjeldusest ning kasutusvaldkondadest, hetkeolukorra

kirjeldusest Eesti vahekeele korpuse märgendusmooduli juures, planeeritavate muutuste

kirjeldusest, teostatud muutuste tehnilisest spetsifikatsioonist ning võimalike edasiarenduste

loetelust.


Pille, 03.05.2011,

Pane koma ja järgmine sõna väikese tähega


1 KEELEKORPUSED, NENDE EESMÄRK JA KASUTAMINE

Korpuseks nimetatakse elektroonilist keeleandmekogu, kuhu on valitud tekstid nii, et need

annaksid keelest tõepärase pildi. Esimesed korpused hakkasid tekkima juba 19nda sajandi

teisel poolel, seoses infotehnoloogia kiire arenguga viimastel aastakümnetel on keelekorpuste

kasutamine intensiivistunud.

Tekstikorpus on tekstide kogum, mida iseloomustavad järgmised tunnused:

korpus on koostatud kindlatel eesmärkidel

korpus on koostatud kindlate printsiipide alusel

eesmärgiga iseloomustada keele mingit seisundit või varianti

on lõpliku suurusega kogum arvutiga töödeldavaid tekste.

Korpuste lootegemisel tuleb teha valik ühiskonnas ringlevate tekstide hulgast. Lähtekohtadeks

saab olla kas mingi teoreetiline hüpotees, allkeel või keelevälised kriteeriumid (Hennoste

2001 : 185).

Vahekeele ehk õppijakeelekorpus on autentsete võõrkeele tekstide elektrooniline kogu, mis on

koostatud vastvalt eksplitsiitsetele disainipõhimõtetele ja teise keele õppimise/õpetamise

eesmärkidest lähtuvalt. Korpuse materjalid on kodeeritud, standardiseeritud ja homogeensel

viisil dokumenteeritud olenevalt lähtekohast ja päritolust (Granger 2002 : 3-33 )

Korpused on muutunud asendamatuks nii keeleteaduses, leksikograafias kui ka automaatsete

keeletöötlusvahendite väljatöötamisel. On tekkinud uus rakenduslingvistika haru -

korpuslingvistika. Korpusuuringud ongu juba viinud täiesti uue arusaamani keelest: sõnavara

ja grammatika ei ole kaks eraldiseisvat vaid omavahel lahutamatult seotud tekstiloome osa.

(Kitsnik 2003 : 93-107)

Õppijakeelekorpus (learner corpus, learner corpora) kuulub kaasaegsete elektrooniliste

keeleressursside alla. Sylviane Grangeri määratluse kohaselt on paralleelselt

õppijakeelekorpuse mõistega kasutusel terminid vahekeelekorpus (interlanguage corporusa)

ja teise keele korpus (L2 corporusa). Tegemist on teise keele / võõrkeeleõppija loodud



autentsete kirjalike tekstide või suulise kõnekeele näidete elektroonilise koguga, milles

keelevead on märgendatud ja klassifitseeritud. Korpuse töötlemisel saab kasutada vastavat

lingvistilist standardtarkvara, korpusuuringutele tuginevad oma töös teise keele / võõrkeele

õpetamise spetsialistid (Granger 2003: 465). Õppijakeele võrdlemine autentse kirjakeelega

tõlke- ja paralleelkorpuste andmeid kaasates võib anda üllatavaid tulemusi, mis osutavad alles

kujunema hakkavatele nähtustele ja uutele arengutele sihtkeele grammatikas või

leksikaalgrammatilises perifeerias (Eslon 2007 : 88).



2 OLEMASOLEV MÄRGENDAMINE

Kuna tegemist on vahe- ehk õppijakeelekorpusega, esineb selles suurel hulgal tekste, mille

autorite emakeel ei ole eesti keel. Vahekeele korpuse tekstid märgendatakse kõikvõimalike

keelevigade suhtes, ning vead tõlgendatakse omakorda lingvistiliselt. Ka on võimalik

salvestada infot keelevigade ning teksti autori soo, vanuse, emakeele, päritolu ning eesti keele

kui teise keele valdamise kohta.

Hetkel tööks kasutatavas Eesti vahekeele korpuse tekstide märgendusmoodulis toimub töö

vigade märgendamisega kolmes etapis:

1) vealiikide defineerimine - saab määrata vealiigi ja lisada kirjelduse, vead jagunevad

globaalseteks ning individuaalseteks vigadeks. Globaalsed vead märgendatakse vastavalt

korpuse veataksonoomia alusel, individuaalsed vastavalt uurimistöö kitsamale eesmärgile

2) vigade märgendamine tekstis - toimub tekstis sobiva koha selekteerimisega, avanenud

dialoogiaknas saab valida sobiva veatüübi ning see salvestada. Keskkond võimaldab ka

ekslikult lisatud märgendeid kustutada

3) vigade visualiseerimine vastavalt kasutaja soovile. Selleks on teksti kõrval nimekiri kõikide

märgendatud vealiikidega, kusjuures nimekiri on koostatud korpuse veataksonoomia alusel.

Kuna märgendid reastatakse vealiigi alusel, siis võib samanimelisi valikuid olla mitu ning ühe

sõnakasutuse korral mitu märgendit (vt joonis 1).



Joonis 1. Märgenduste vaatamise keskkond

2.1 Eelised

Olemasoleva märgenduse peamisteks eelisteks on võimalus vaadata üle varem märgitud vead

ning vajadusel need kustutada lisada uusi märgendeid. Vigade näitamisega ühe vea kaupa

tõrkeid ei esine, ning märgendamine on selge ja arusaadav.

2.2 Puudused

Märgendatud vigu on võimalik vaadata ainult ükshaaval, vead on reastatud veatüübi nimetuse

järgi. See tähendab, et kasutajale antakse valikmenüüsse n+1 täpselt sama nimega valikut, mis

on segadusseajav.

Märgendatud tekstidest ei ole võimalik võtta standardiseeritud väljundit, mis kirjeldaks ära

teksti metaandmed ning hõlmaks endas ka kõiki märgendatud vigu. Senini sisestatud tekstid ei

vasta otseselt standarditele, kuid on sarnased XTHMLile.



3 KORPUSE MÄRGENDAMISEGA SEOTUD OSA TEHNILINE

STRUKTUUR

3.1 Vealiikide salvestamine

Märgendamisprotsessi kirjeldamist tuleb alustada märgendi lisamisest. Kui kasutaja lisab

süsteemi uue märgendi, siis selle peale tekitatakse märgendi infot sisaldav fail (olenevalt

sellest, kas tegu on globaalse või kasutajaspetsiifilise märgendiga) ning lisatakse see kausta.

Seejärel valitakse välja tekst, mida soovitakse märgendada. Tekste hoitakse Zope andmebaasi

objektidena kaustas "documents". Iga tekstiga käib kaasas meta-andmete skeem. Meta -

andmed võimaldavad teha hiljem statistikat vastavalt erinevatele autorit puudutavatele

parameetritele.

Teksti sisu on võimalik muuta kuni esimese märgenduse lisamiseni, peale sedaei ole

muutused tekstis enam võimalikud, kuna vigade asukoha arvestamine toimub

struktuuripõhiselt. Peale esimest märgendamist on võimalik märgendeid ainult lisada ja

eemaldada.

Teksti avanedes on võimalik hiirega markeerida vigane sõna või lauseosa. Seejärel avatakse

kasutajale vaheaken, milles on võimalik määrata hetkel märkimises oleva vea liik. Tuletagem

meelde, et valida saab nende vealiikide seast, mis on eelnevalt defineeritud.



Joonis 2. Vigade salvestamise dialoog

Salvestamise käigus tekitatakse andmebaasi tabelisse "errors" sisestus, milles märgitakse ära 5

põhilisemat konkreetse vea identifikaatorit. Nendeks on

viit (pointer) - näitab ära, mis kohas asub viga antud tekstis; tüüpiline viit näeb välja

ligikaudu selline: /p[3]/text()#off:60;/p[3]/text()#off:74.

dokument (document) - viit dokumendile, mille küljes antud viga asub

sisu (content) - vigane osa tekstist, (tekstikujul)

kood (code) - vealiigile omane identifikaator

autor (author) - kasutaja, kes on antud vea märgendanud.

Olgu mainitud, et viit koosneb kahest märgendist, mis on omavahel kokku ühendatud

semikooloniga. Esimene pool väljendist tähistab vea algust ning teine lõppu.

Sellisel viisil võib märgendada ühe dokumendi kohta praktiliselt lõputa arvu vigu.

Märgendeid saab eemaldada, tehes samas märgenduse aknas vea nimetuse peal topeltkliki,

ning eemaldades linnukese veatüübi tagant.

3.2 Xpathi kasutamine märgendite asukoha salvestamisel

Xpath on päringukeel, mis kirjeldab elemendi paiknemist XML standarditele vastavas

dokumendis. Eesti vahekeele korpuse märgendusmooduli juures kastutakse vigade asukoha

kindlakstegemisel Xpathi.



Näiteks lihtsast raamatupoe infot kujutavast XML failist esimese raamatu hinna

teadasaamiseks tuleks tema asukoht defineerida järgmiselt: „/pood/raamat[0]/hind[0]“

<?xml version="1.0" encoding="ISO-8859-1"?><pood><raamat> <autor>Giada De Laurentiis</autor> <aasta>2005</ aasta> <hind>30.00</hind></ raamat >

< raamat > <autor>J K. Rowling</ autor> < aasta >2005</ aasta> <hind>29.99</hind></ raamat ></pood>

Xpathi miinuseks antud probleemistiku kontekstis on vaikimisi eeldus korrektse XML

standarditele vastava struktuuri olemasolule.

Xpath tutorial. http://www.w3schools.com/XPath/default.asp

3.3 Vigade näitamine

Märgendatud vigade näitamine käib üldiselt vastupidiselt nende ülesmärgendamise

protsessile. Liideses on võimalik valida, millist viga soovitakse parasjagu näha. Ning peale

hiirega vea nimetuse kohale liikumist otsitakse üles viit vastavale veale ning edastatakse see

viida hindajale (xpath evaluator). See omakorda otsib olemasolevast algtekstist välja koha,

mida tuleks märgendada, ning paigutab enne ning pärast viga märgendid:

Joonis 3. Vea märgendus tekstis esialgsel kujul

HTML keeles näeb märgendus välja järgnev:



tegutseb Eestis kuskil

<div name="range_2" class="inlineMark ignore_xpath" id="inlineMark">

>>

</div>

kümneliikmeline

<div name="range_2" class="inlineMark ignore_xpath" id="inlineMark">

<<

</div>

Venemaa-aktivistide



3.4 Vajalikud täiendused ja nende eesmärgid

Vajalikud arendussuunad töötati esmalt välja ekspertide grupi poolt, millesse kuulusid

professor Pille Eslon ning dotsent Erika Matsak. Koostati juhend, milles kirjas kõik vajalikud

täiendused, ning illustratiivsed materjalid kasutajaliidese kohta.

Prioriteet täienduste tarbeks on muuta vigade näitamise funktsionaalsust. Muudatuste

tulemusena peaks senine menüü, kus iga viga on esindatud mitmeid kordi, asenduma

menüüga, kus igat vealiiki esineb üks kord. Vealiigi visualiseerimisel näidatakse sel puhul ära

kõik märgendatud vead, mis kuuluvad antud vealiigi alla. Kusjuures erinevad vealiigid

peaksid olema markeeritud erineva värviga. Selle täienduse eesmärk oleks hõlbustada Eesti

vahekeele korpuse kasutamist ning muuta filoloogide töö märgendamise koha pealt

kergemaks. Seejuures on tähtis, et vigade ülesmärkimise funktsionaalsus jääks samaks.

Teiseks on vaja luua valmidus väljundi võtmiseks tekstist, kus oleks näha viga, annotatsioon,

ning vastava vea märgendaja identifikaator. Selle punkti üks võimalikke lahendusi on

kasutada TEI (Text Encoding Initiative) märgendikeelt, mis vastab XML standarditele. TEI

märgenduskeelt kasutavad enamus tänapäevastest keelekorpustest. See XMLi laadne keel on

üks enimkasutatavaid vahendeid, mida kasutatakse inimkeele masinloetavaks tegemisel ning

analüüsimisel. TEI : Learn the TEI. http://www.tei-c.org/Support/Learn/.



4 EESTI VAHEKEELE KORPUSE TESTKESKKONNA LOOMINE

Eesti vahekeele korpus on filoloogide töövahend ning seda kasutatakse pidevalt. Seega selle

peal katsetamine ning tarkvara arendus komplitseeritud. Seega tuli mõelda eraldiseisva

testkeskkonna peale. Platvormiks valisin vabavaralise Linux Debian 2.6.26. Unixil põhinev

platvorm sai valitud seepärast, et Zope serveri produkte toetavaid pakette on sellele

platvormile lihtsam leida, võrreldes näites MS Windowsiga. Distributsiooniks Debian, kuna

sellega olin tuttav koolitundidest, kuigi hetkel tagasivaadates oleks valikuks võinud olla

praktiliselt iga enimlevinud distributsioon.

Esialgselt sai installeeritud baasserveri Zope 2.10 versioon, kuid mõne aja pärast osutus

otstarbekamaks see välja vahetada versiooni 2.11, põhjuseks mõningate produktide

ühilduvusprobleemid. Täistekstotsingu ning indekseerimise tarbeks kasutatakse eesti

vahekeele korpuse juures TextIndexNG3 nimelist komponenti, ning Postgre

andmebaasiühenduse jaoks ZPsycopgDA komponenti. Esimene suurem tagasilöök protsessi

juures oli mõistmine, et need komponendid töötavad vaid arendusversiooniga Pythonist,

kindlasti peavad Python ning komponendid olema kompileeritud sama kompilaatoriga.

Teisel katsel oli testkeskkonna ülesseadmine edukas. Tuleb vaid mainida, et päris 1:1 ei

õnnestunud vaid andmebaasi koopiat luua, kuna eesti vahekeele korpuse puhul on info

salvestatud nii postgre SQL relatsioonilises andmebaasis, kui ka Zope enda objekt-

andmebaasis. Kuid kuna erinevaid tekste oli võimalik kopeerida näiteks ajakirjanudsest, ei

olnud see probleem määrav, ning lõpptulemus sellest ei sõltunud.

4.1 Platvormi spetsifikatsioon

Linux Debian 2.6.26 (Lenny2)

Postgre Andmebaas

Zope veebiserver + zope andmebaas

kastuatud Zope veebiserveri produktid, mis on vajalikud Eesti vahekeele korpuse

tööks:

o TextIndexNG3

o ZPsycopgDA

o Twisted



o Portallangs

Javascripti Mootools raamistik

4.2 Kasutatud tarkvara

Eclipse Helios

FileZilla

Firefox

Firebug

4.3 Zope platvormi kirjeldus

Zope on avatud lähtekoodiga objektidel põhinev veebiplatvorm. Sellega käivad kaasas nii

veebi- kui ka ftp1 serverid, seda saab laiendada ka teistele protokollidele (näiteks POP3,

SMTP ja IMAP2). Zope platvormi on sisse integreeritud objektidel põhinev andmebaas.

Lisaks saab antud platvormi suhteliselt hõlpsalt integreerida teisi andmebaase, näiteks Oracle,

Sysbase, MySQL. Eesti vahekeele korpuses hoitakse Zope andmebaasis objektidena

märgendatavaid tekste, samas kui statistikat, märgendatud vigade tähised ja infot

märgendajate kohta jms hoitakse PostgreSQL andmebaasis. PostgreSQL baas ühendub Zope

platvormiga läbi ZPsycopgDA nimelise produkti. Olgu etteruttavalt öeldud, et Zope

keskkonnas kutsutakse laiendusmooduleid produktideks (Products).

Zope on kirjutatud Pythoni keelt kasutades, mis töötab praktiliselt kõigil UNIXi platvormidel,

samuti ka Windows NT-ga. Seda saab kasutada koos teiste veebiserveritega, kui peaks olema

huvi mitte kasutada Zope platvormiga kaasaskäivat veebiserverit. Veebilehestiku tarbeks

kasutatakse Zopes HTMLi ning DTMLi (Document Template Markup Language). Olgu

öeldud, et viimane on Zope enda märgenduskeel, samuti võib seda teha ka näiteks Pythoni

kaasabil.

1 FTP - failiedastusprotokoll (file transfer protocol) on standardne arvutivõrgu protokoll, mida kasutatakse failide vahetamiseks ja muutmiseks TCP/IP-põhises võrgus, näiteks internetis. FTP põhineb klient-server arhitektuuril. FTP-d saab kasutada salasõna autentimisega või anonüümse kasutajaga. Wikipedia – File Transfer protocol. http://et.wikipedia.org/wiki/File_Transfer_Protocol2 POP3, SMTP, IMAP - standardsed levinumad emaili protokollid



4.4 PostgreSQL andmebaas

PostgreSQL on avatud lähtekoodiga objekt - relatsioonile andmebaas. Nagu paljudele avatud

lähtekoodiga projektidele iseloomulik, ei oma PostgreSQLi üle kontrolli üks kindel firma.

Arendus toimub ülemailmse tarkvaraarendajate võrgustiku kaudu.

4.5 Javascript veebiarenduses

Eesti vahekeele korpuse kasutajaliidese funktsionaalsus tugineb suurel määral javascriptile

ning selle võimalustele. Javascript on viimase dekaadiga veebiarenduses suure arengu läbi

teinud ja muutunud lihtsate efektide vahendajast täisväärtuslikuks programmeerimiskeeleks.

See on saavutatud suurel määral tänu asünkroonsete päringute tegemise võimalusele.

Asünkroonsete päringute all mõtlen siinkohal peale veebilehe laadimist toimuvaid päringuid,

mis ei mõjuta lehe laadimiskiirust ehk veebileht on serverist kliendi veebibrauserisse

kohaletoimetatud, ning sellele lisatakse või eemaldatakse elemente. Andmeid saadakse läbi

XMLHttpRequest objekti, mis omakorda tähendab, et tegelikult kastutatakse andmete

transportimiseks endiselt Http-päringuid.

4.6 Javascripti raamistikud

Mõned javascripti arendajad ei kiida raamistike kasutamist heaks. Heidetakse ette, et

javascripti põhiline funktsionaalsus jääb raamistikke kasutades adumata ning kaob täpne

ettekujutus (koos sellega ka osa kontrollist ), mida parasjagu mingi osa koodist teeb. Ka on

vastuargumentideks koodi (mida ilmselt kunagi ei kasutata) rohkus. Kuna kogu skript tuleb

enne kasutamist alla laadida, läheb lehe kuvamisega lihtsalt kauem aega.

Kuigi hindan väga fundamentaalseid teadmisi javascriptist, ei saa siinkohal raamistike

mittepooldajatega nõustuda. Minu hinnangul on javascripti raamistike tundmine ja

kasutamine nii veebiarenduses, kui ka Eesti vahekeele korpuse laadsete projektide juures

möödapääsmatu, sest aitab kokku hoida väga palju aega. Üks peamisi põhjuseid on kindlasti

eri veebilehtitsejate toetus, enamlevinumad javascripti raamistikud on optimeeritud töötama

sõltumata brauserist (loomulikult on siin mingi piir vahele tõmmatud, ning enamasti Internet

Explorer 5.5-st varasemaks ei minda). Samas ei ole tavaline javascript läbivalt erinevates

veebilehitsejates sama funktsionaalsusega. Selle tagamiseks tuleks puhast javascripti



kirjutades teha väga palju tööd, mis oleks välditav raamistiku kasutuselevõtuga. Lisaks aitab

raamistiku kasutamine tihtipeale koodi loetavamana hoida, kuna suhteliselt keerulised

operatsioonid (harilikku javascripti kasutades) on tihti kokku võetud 1-2 meetodisse, millel on

asjakohane nimi.



5 MUUDATUSTE TEHNILINE KIRJELDUS

Eesti vahekeele korpuse tekstide märgendusmooduli näol on tegu on kasutaja interaktsiooni

võimaldava keskkonnaga, kus toimub vigade näitamine ning märgendamine. Kuna see on

veebis töötav rakendus, siis väljastatakse kõik olemasolevad vead ning tekstid veebilehe sisu

kaudu serverist kasutajale, ning kasutaja poolel hoolitseb vastava info töötlemise ja muutmise

eest Javascript keeles kirjutatud ning Mootools raamistikule toetuv moodul. Peamiseks

kasutatud keeleks on seetõttu Javascript, ning vähemal määral Python ning DTML.

Märgendusmooduli funktsionaalsuse täiendamine toimus mitmes iteratsioonis. Siin ja

edaspidigi nimetan valminud mooduli erinevaid faase iteratsioonideks. Suurem muutus

kaasnes viimase iteratsiooniga, mis kasutab eelmistega võrreldes teistsugust lähenemist.

Põhiprobleemiks mitme elemendi märgendamise juures samas tekstis on teksti struktuuri

pidev muutumine märgendamise käigus. Kuna vead asuvad XHTML standarditest lähtuvalt

tekstijaotiste (text node) sees. Wikipedia – Extensible Hypertext Markup Language.

http://et.wikipedia.org/wiki/XHTML

Peale esimese vea ülesmärgendamist jaotatakse olemasolev tekstijaotis omakorda kuni

kolmeks osaks, seega tekib järgmise vea märgendamisel küsimus, kas eelnev tekst juba

sisaldab märgitud vigasid. Juhul kui esinevad vead, siis tuleks nendesse arvestada ning

järgnevate vigade asukohale vajalik summa otsa liita. Ehk piltlikult öeldes - märgendada

teksti font alajaotuses:

<font class="articleBody">

“Hommikul kell 9 särab päike kõrgel taevas, kui stardin Bekaa oru suunas.

Zahle

linnas on mind ootamas Bekaa oru piirkonna tähtsaim politseikindral

härra Atta.</font>Koodinäide 1. Esialgne tekst HTML kujul.

Märgend viidaga: /font/text()[0]#off:10;/font/text()[0]#off:14. Lisaks märgenduse jaotisele



on lauses veel väljend #off:10, mis tähendab antud jaotise 10ndat tähemärki. Samamoodi on

kirjeldatud ka vea lõpu asukoht. Peale asukoha hindamist, märgitakse vajalikele kohtadele

jaotised koos teabega märgendi alguse ja lõpu kohta. Peale vea ülesmärkimist tekib meil

järgnev struktuur:

<font class="articleBody">

“Hommikul <div name="d17890" class="inlineMark ignore_xpath beginMark

global_129087252631"></div>

kell

<div name="d17890" class="inlineMark endMark ignore_xpath

global_129087252631"></div>

9 särab päike kõrgel taevas, kui stardin Bekaa oru suunas. Zahle

linnas on mind ootamas Bekaa oru piirkonna tähtsaim politseikindral

härra Atta.</font>Koodinäide 2. Tekstid märgendatud viga.

Nagu näha on tekstist eraldatud sõna "kell". Probleem tekib aga siis, kui me tahaksime selles

samas jaotises märkida ära sõna "stardin" mille asukoht oli esialgu samuti jaotises text()[0],

kuid arvestades lisatud märgendeid, peaksime otsima sõna "stardin" nüüd hoopis kolmandast

tekstijaotisest, ehk text()[3] ning lisaks peaksime vea asukohast maha lahutama talle

eelnevate tekstiosade sisu pikkuse. See on tingitud asjaolust, et vea viidas sisalduvad algust

ning lõppu tähistavad numbrid arvestavad ka vea paiknemist, pidades silmas esialgset teksti

struktuuri.

Esimene tekkinud probleem oleks välditav sel moel, et iga uue vea märgendamisel

kontrollitakse, kas valitud teksitjaotises on üldse piisav arv tähemärke, et märkida maha vea

algus ja lõpp. Kui järgneva vea viites kirjeldatud numbriga tähemärki ei leita, hakatakse viga

otsima ülejärgmisest tekstijaotisest. Ning lahutatakse esimese kahe tekstijaotise pikkus

praegusest pikkusest. Kui siis selgub, et vea algus tuleb negatiivse väärtusega, tähendab see,

et tekkinud on olukord, kus kaks viga kattuvad.

Kuna viga kirjeldav viite väärtus esineb süsteemis sõne (string) tüüpi muutujana, siis

kirjutasin tekstijaotise arvu suurendamiseks meetodi increaseTextNodeCounter, mis leiab

regulaaravaldise abil viitest üles sobiva arvväärtuse, ning suurendab seda kahe võrra :



function increaseTextNodeCounter(expression, onlycount){

var p = expression.split('#');

var text = p[0].substring(p[0].lastIndexOf('/')+1);

var mat = text.match(/(.*?)\[(.*?)\]/);

if (mat[1] == 'text()') {

var currentNode = parseInt(mat[2]);

if (onlycount) {

return currentNode;

}

currentNode += 2;

var toReplace = 'text()['+currentNode.toString()+']';

}

else{

alert("error finding proper text node");

}

var newLeft = p[0].slice(0,p[0].lastIndexOf('/')+1);

var NewExp = newLeft + toReplace +'#'+ p[1];

return NewExp;

}

Koodinäide 3. Tekstijaotise loenduri suurendamine 2 võrra



Teiseks probleemiks olid sisestatud teksti struktuuri iseärasused. Kuni kolmanda iteratsioonini

valminud moodul eeldas, et sisestatud tekst on vormindatud vastavalt XML standarditele, ehk

iga element kuulub mingisse kindlasse alajotusesse.

Wikipedia – Extensible Markup Language. http://en.wikipedia.org/wiki/XML

Konkreetse näitena, milles põrus kolmas iteratsioon märgendusmoodulist, tooksin osa

avalikus meedias ilmunud artikli struktuurist. Kuna Eesti vahekeele korpusse võivad sattuda

praktiliselt igasuguse struktuuriga tekstid, on taoline näide mooduli töö testimiseks

põhjendatud.

<p>

Facebook asub koostööd tegema suurimate nimedega riistvaramaailmas – Hewlet

Packard Co, Dell Inc, Advanced Micro Devices ja Intel Corp – et välja anda

„avatud arvutite projekti“. Tegevjuht Mark Zuckerberg sõnul on projekti

eesmärgiks pakkuda spetsifikatsioone ja kavandeid efektiivsemate

internetiteenuste pakkumiseks mõeldud arvutite jaoks.

<br><br>

„Aja jooksul oleme leidnud, et palju massitootjate poolt pakutavast ei ole

olnud päris see mida meil ja teiste sotsiaalsete rakenduste pakkujatel vaja

on,“ ütles Zuckerberg Facebooki Palo Altos asuvas peakontoris toimunud

meediasündmuse käigus neljapäeval. Spetsifikatsioonide ja kavandite

jagamisega loodab Facebook tõsta spetsialiseeritud serverite saadavust ja

nõudlust, vahendab Reuters.

</p>

Koodinäide 4. Näide paragraafist, mis on jagatud kaheks erinevaks tekstijaotisek.s

Sellisel juhul sisaldab ülemjaotis ehk praegusel juhul <p></p> rohkem kui ühte tekstijaotist,

kuid vigu üles märkides alustatakse vigase koha asukoha nummerdamist vastavast

alajaotusest.

Oletagem, et esialgsesse esimesse tekstijaotisse kuulub kaks viga ning teise veel kaks.

Eelmistes iteratsioonides loodud lahendus on suuteline märkima vigu õigesti kuni esimese

tekstijaotiseni, mis asus lisaks eelmisele sama ülemelemendi sees. Kuna tekstides võis

selliseid jaotisi esineda määramata arv, siis tekkis vajadus millegi töökindlama järele, kui seda

oli vigade aimamine ja arvutuskäigud, mis pidid adapteeruma vastavalt eelnevalt märgendatud

vigadele.



Tõstatus õigustatud küsimus, kas vigu poleks võimalik märgendada sel moel, et poleks vaja

jälgida võimalikke eelnevalt sisestatud vigu. Tekkis idee korraldada märgendite lisamine

ümber sel moel, et märgendamine algaks alati teksti lõpust, ning vigasid ei märgitaks

konkreetse vea põhiselt, vaid oleks mingisugune moodul, mis hoiaks endas kõiki dokumenti

kuuluvaid vigu. Lahenduse selgitamiseks koostasin järgmise skeemi (vt joonis 3):



Joonis 4. Märgendusprotsessi selgitav skeem (halliga tähistatud HTML osa, rohelisega javascript)

Dokumenti luuakse kaks jaotist. Esimene sisaldab kõiki dokumendi kohta käivaid vigu

HTML input elementidena, mida siin ja edaspidi nimetan antud elemente märkeskeemiks.

Elmendid kannavad siinkohal vaid andmekandja rolli ning kasutaja nendega kontakti ei satu:



<div class="document_markup_schema">

<input docolor="ae33e3" value="0" counter="0"

xpoint="/font/text()#off:52;/font/text()#off:58" name="siim_130348714515"

type="hidden">

<input docolor="ae33e3" value="0" counter="1"

xpoint="/p/font/text()#off:43;/p/font/text()#off:54"

name="siim_130348714515" type="hidden">

</div>

Koodinäide 5. Näide märgendiskeemil asuvatest märgenditest

Antud elementde mittestandardsetes atribuutides on kirjas, mis värviga peaks olema antud

viga markeeritud, märge selle kohta, kas viga on parasjagu aktiivne, järjekorranumber,

märgendi tüüp ning viit vea asukohale.

Teine jaotis sisaldab endas vealiike ning kasutajale suunatud märkeruutu, mille kaudu

kutsutakse välja funktsioon "updateMarkupSchema", mis muudab eelnevalt kirjeldatud

elementide väärtusi vastavalt valitud märkeruudule. Seega on vigadel kaks olekut: aktiivne ja

mitteaktiivne.

<div class="markwrapper">

<input name="togglemark" onclick="javascript:updateMarkupSchema($

(this).getNext(), 1);" type="checkbox">

<div style="border-bottom: medium none;" class="error_marker_input

mouseenabled" onmouseover="javascript:updateMarkupSchema(this, 2)"

onmouseout="javascript:updateMarkupSchema(this, 0)" docolor="ae33e3"

name="siim_130348714515" id="siim_130348714515">veakoht15</div>

</div>

Koodinäide 6. Näide vealiigi valikust menüüs, ning sellele eelnevast märkeruudust

Funktsioon "updateMarkupSchema" muudab märkeskeemi, vastavalt valitud vigadele,

märkides ära vead, mida tuleb kasutajale välja näidata. Peale sobivate vigade väärtuse

muutmist, kutsutakse omakorda välja funktsioon "displayCurrentErrors".



Funktsioon displayCurrentErrors moodustab parasjagu valitud vigadest massiivi, mille iga

element on omakorda kolme elemendi pikkune massiiv, milles on kirjeldatud viit veale, vea

liik ning värv, millega viga markeeritakse:

var showableMarks = [];$$(".document_markup_schema input").each(function(item){

if (item.get('value') == 1) {showableMarks[item.get('counter')] = [item.get('xpoint'), item.get('name'), item.get('docolor')];

}});

Koodinäide 7. Itereerimine läbi kõigi dokumendis leiduvate vigade, aktiivsete vigade lisamine massiivi

Olgu siinkohal mainitud, et hariliku javascripti kontekstis ebastandardsed operaatorid $ ja $$ tähistavad elementide ja objektide valikuid Mootools raamistiku kontekstis. Ehk lühidalt:

var elems = $$('.bigred');

Seab muutuja elems väärtuseks massiivi kõigist elementidest, mis omavad klassi "bigred".

Seejärel muudetakse vigade järjestus vastupidiseks, et oleks võimalik alustada viimasest veast:

showableMarks.reverse();

Siis eemaldatakse olemasolevad märgendused, see tegevus toimub kahes faasis. Esmalt

eemdaldatakse märgendatud vealt värviga allajoonitud markeering, ning seejärel

eemaldatakse märgendite algused ning lõpud. Järgnevalt itereeritakse läbi kõikide vigade ning

kutsutakse välja funktsioon "showCurrentError", mis omakorda käivitab viida hindamise

objekti ning paigaldab teksti sisse iga vea kohta alguse ja lõpu märgendi. Kui kõik vead on sel

moel läbi käidud, toimub nende markeerimine vastava värviga (vt joonis 4).

Iga kasutaja tehtud valiku peale käiakse läbi kogu olemasolev tekst kahel korral, et eemaldada

seal hetkel asuvad märgendid, seejärel muudetakse märkeskeemi, ning loetakse kõik vead

sisse ja käiakse tekst märgendamiseks kahel korral läbi. Kuna tänapäevaste arvutite

arvutusvõimsus lubab sellist hulka arvutusi teha hetkega, puudub kasutajal praktiliselt

igasugune viide, ning tekkinud muutused on tekstis koheselt näha (vt ka lisa 3).



Joonis 5. Märgendusmooduli uus funktsionaalsus katsetuses



6 EDASIARENDUSVÕIMALUSED

Selles peatükis kirjeldan, millised on põhilised edasised arengusuunad, mis puudutavad Eesti

vahekeele korpuse tekstide märgendusmoodulit. Käesolev diplomitöö sobib pidepunktiks

Eesti vahekeele korpuse tekstide vigade märgendamisega seotud edasisel arendamisel.

Märgendusega seotud osa arenduse loogiline jätk oleks statistikamooduli täiustus, et tekiks

võimalus statistiliselt näidata, millistel kohtadel tekib erinevate vealiikide kuhjumine ning

millised vead jäävad ainukordseks. Antud probleemi lahendina näen märgendusliidesesse

lisatavat salvestusvõimalust, mis otsib tekstist üles kattuvate vealiikide paarid ning salvestab

need eraldi andmebaasi tabelisse juhul, kui seal selliseid paare veel ei eksisteeri. Vastasel

juhul suurendatakse olemasolevate paaridega kaasas käivat loendurit vastav arv kordi. Hiljem,

kui andmeid vealiikide koosesinemise kohta on kogutud piisav hulk, tuleb täiustada

statistikamoodulit nii, et see oleks võimeline väljastama enim koosesinenud veapaare ning

vigade sisu, milles statistiliselt kõige rohkem eksimusi leidus.



7 TEKSTIMUDELID

Tekstimudelid on andmekogud, mis koosnevad peaasjalikult ainult tekstist või tekstide

kogust. Lisainfot, mida vajavad kõik teksti ja sõna töötlevad süsteemid, antakse eriti

varasemates tekstimudelites õige napilt. Füüsiliselt kujutab tekstimudel endast järjestikust

teksti, mida katkestavad mitmesugused abisümbolid. Arvutiprogrammid peavad suutma seda

teksti lugeda st. eristada sümbolijadast vajalikku infot. Selleks vajavad programmid aina

põhjalikumat lisainfot teksti struktuuri ja sisu kohta ning üheks enimlevinud lisainfo andmise

viisiks ongi sõnastikuteksti märgendamine, mille areng on kulgenud lihtsatest kirjastiili

käskudest teksti loogiliste süvakihtide tähistamiseni (Langemets 2000 : 101-126).

7.1 Üldistatud märgendus

Üldistatud märgendamise põhimõtted postuleeriti juba 1970. aastatel: a) märgendamine peab

kirjeldama teksti struktuuri, mitte teksti hilisemat töötlemist; b) märgendatud tekst peab olema

algoritmiliselt töödeldav. Üldistatud märgenduskeele rahvusvaheliseks standardiks kinnitati

1986. aastal Standard Generalized Markup Language, lühendatult SGML (ISO standard

8879) (Langemets 2000 : 101-126).

7.2 TEI märgendus

Üldistatud märgendikeele üheks edasiarenduseks on rahvusvahelise uurimisprojekti Text

Encoding Initiative (TEI) poolt välja töötatud almis kodeerimisskeemid ehk

märgendusmudelid paljude erinevate tekstitüüpide jaoks. Standardseid mudeleid pakutakse nii

korpusetekstide kui ka trükitud sõnaraamatute märgendamiseks (Langemets 2000 : 117).

TEI-s pole tõmmatud selget vahet objektiivse ja subjektiivse info või representatiivse ja

interpretatiivse info vahel. Kuid osad märgendid esitavad selgelt teksti struktuuri (teksti osad,

lõigud, laused) ja osad on interpretatiivsed, nt võimaldab TEI märgendada rõhutamise

eesmärgil esiletõstetud tekstiosi märgendiga <emph>. TEI soovitab igale korpuse tekstile ja

ka kogu korpusele lisada päise (Header), mis identifitseerib, dokumenteerib ja kirjeldab

korpuses olevaid tekste ning mille abil saab uurija valida korpusest talle vajalike omadustega

tekste (Muischnek 2000 : 185).



Väga vähesed märgendid TEI suurest märgendite hulgast on kohustuslikud selleks, et

märgendatud tekst vastaks formaalselt TEI nõuetele. Enamus märgendeid ja nende atribuute

on vabatahtlikud - neid kasutatakse vajadusel ja võimalusel TEI märgendite hierarhia on

järgmine:

tekstiüksuste märgendid (chunks);

lõigud ja teised lõigutasandi märgendid, mis võivad olla kas ainult teksti osad või

teksti alljaotuse (<div>) osad, kuid ei või esineda teiste teksiüksuste märgendite sees;

märgendid, mis võivad esineda ainult lõigumärgendite või teiste lõigutasandite

märgendite sees, mitte väljaspool neid (phrase-level elements);

märgendid, mis võivad esineda kas lõikude vahel võrdselt lõigutasandi märgendite

sees (inter-level elements, nt loendi märgend <list>) (Muischnek 2000 : 185).



KOKKUVÕTE

Käesolevas diplomitöös püstitatud peamised eesmärgid said täidetud. Õnnestus koostada

testkeskkond, mis on sarnane Eesti vahekeele korpusega ning milles teostatud arendused on

võimalik hiljem integreerida originaalsesse Eesti vahekeele korpusesse.

Praktilise lahendusena valminud Eesti vahekeele korpuse tekstide märgendusmoodul

võimaldab visualiseerida märgendatud vigu vealiigi kaupa. Põhilisteks probleemideks mitme

vea märgendamisel ühes tekstis oli fakt, et vigasid salvestatakse originaalsteksti suhtes, ning

iga lisatud märgend muudab teksti struktuuri.

Tulemusena märgendatakse iga vealiik erineva värviga. Vigade kattumisel antakse kasutajale

sellest teada ning kuvatakse info parasjagu kattuva vea kohta. Seega väidan, et tehtud

muudatused vastavad esialgselt väljatöötatud nõuetele soovitud muudatuste kohta.

Tööd koostades sain suurel määral uusi teadmisi veebipõhise kasutajaliidese arendamisest

eelkõige Mootools raamistikku kasutades, ning tutvusin Zope serverile omaste

paradigmadega.

Töö teises pooles on välja toodud võimalikud edasised Eesti vahekeele korpuse tekstide

märgendusmooduli puudutavad arengusuunad. Peamine edasine arengusuund on vahekeele

korpuse statistikaga tegeleva osa parandamine sel moel, et oleks võimalik eristada teksti

osasid, kus vigade tekke tõenäosus on suurem.



KASUTATUD ALLIKAD

Hennoste,T & Muischnek, K.(2000), Eesti kirjakeele korpuse tekstide valiku ja

märgendamise põhimõtted ning kahe allkeele võrdluse katse. - Kogumik "Arvutilingvistikalt

inimesele", Tartu : Tartu ülikooli üldkeeleteaduse õppetooli toimetised 1, 183-218.

Granger, S.(2002). A bird’s-eye view of learner Corpora in SLA research and FLT. –

Computer Learner Corpora, Second Language Acquisition and Foreign Language Teaching.

Amsderdam/Philadelphia: John Benjamins Publishing Company, 3-33.

Kitsnik, M.(2005). Keelekorpused ja võõrkeeleõpe. - Eesti rakenduslingvistika ühingu

aastaraamat 2, 93-107.

Eslon, P. (2007). Õppijakeelekorpused ja keeleõpe. – Tallinna Ülikooli keelekorpuste

optimaalsus, töötlemine ja kasutamine / Toim. P. Eslon. Tallinna Ülikooli eesti filoloogia

osakonna toimetised 9. Tallinn: Tallinna Ülikooli Kirjastus, 87 - 120.

Langemets, M. (2000), Leksikaalse info kodeerimine. - Kogumik "Arvutilingvistikalt

inimesele", Tartu : Tartu ülikooli üldkeeleteaduse õppetooli toimetised 1, 101-126.

TEI : Learn the TEI [2011, aprill 14]. http://www.tei-c.org/Support/Learn/

Wikipedia – Extensible Markup Language [2011, aprill 15].

http://en.wikipedia.org/wiki/XML

Wikipedia – File Transfer protocol [2011, aprill 20].

http://et.wikipedia.org/wiki/File_Transfer_Protocol

Xpath tutorial [2011, aprill 15]. http://www.w3schools.com/XPath/default.asp

Zope.org - What is Zope? [2011, aprill 20]. http://www.zope.org/WhatIsZope

Wikipedia – Extensible Hypertext Markup Language [2011, aprill 15].

http://et.wikipedia.org/wiki/XHTML



LISA 1. DOCUMENT.PY TÄIENDUSED

Funktsioon kõikide vigade tagastamiseks andmebaasist (allUsedCodes) ning funktsioon ainult

eri tüüpi vealiikide loetelu tagaastamiseks (diffUsedCodes).

security.declareProtected(perm_view_document, 'diffUsedCodes')def diffUsedCodes(self, REQUEST):codes = self.Errors.getDocumentMarks(self.getId(), str(REQUEST.AUTHENTICATED_USER))res = []for x in codes:

add=1y = x.getProperty('code').encode('utf-8')for current in res:

if current[0]==y:add=0

if add==1:rcolor1=random.randint(50,255)rcolor1="%02x" % rcolor1rcolor2=random.randint(50,255)rcolor2="%02x" % rcolor2rcolor3=random.randint(50,255);rcolor3="%02x" % rcolor3truecolor=str(rcolor1)+str(rcolor2)+str(rcolor3)res.append([y, self.Marks.prettyCodeTitle(y),

truecolor])return res

security.declareProtected(perm_view_document, 'allUsedCodes') def allUsedCodes(self, REQUEST): codes = self.Errors.getDocumentMarks(self.getId(), str(REQUEST.AUTHENTICATED_USER)) res = [] counter=0 for x in codes: y = x.getProperty('code').encode('utf-8') xpinter = x.getProperty('pointer').encode('utf-8') res.append([y, xpinter, counter, self.Marks.prettyCodeTitle(y)]) counter+=1 return res



LISA 2. DOCUMENT_VIEW.PT TÄIENDUSED

Täiendused dokumendi mallile, kasutatud on Lisaas 1 defineeritud funktsioone.

<h4 i18n:translate="Marks">MĆ¤rgendid</h4> <div class="document_markup_schema"> <span tal:omit-tag="" tal:repeat="code python:context.allUsedCodes(request)"> <input type="hidden" value="0" tal:attributes="name python:code[0]; xpoint python:code[1]; counterpython:code[2]; rel python:code[3]" /> </span> </div> <span tal:omit-tag="" tal:repeat="code python:context.diffUsedCodes(request)">

<div class="markwrapper"><input type="checkbox" name="togglemark" onclick="javascript:updateMarkupSchema($(this).getNext(), 1);"/> <divclass="error_marker_input mouseenabled" onmouseover="javascript:updateMarkupSchema(this, 2)" onmouseout="javascript:updateMarkupSchema(this, 0)" tal:attributes="name python:code[0]; id python:code[0]; docolorpython:code[2]" tal:content="python:code[1]" > </div></div> <input type="hidden" value="0" tal:attributes="name python:code[0]; xpoint python:code[1]; counterpython:code[2]"/> </span>



LISA 3. DOCUMENT_VIEW.JS TÄIENDUSEDJavascripti funktsioonidel toon ära üldise tööjärjekorra ning lühikirjelduse. Lehe laadides

joostakse ühekordselt funktsiooni countStats, mis loeb kokku erinevate vealiikide alla

kuuluvad vead, ning kirjutab iga vealiigi taha sulgudesse numbri, mitu viga antud vealiigi

kohta tekstis esineb.

Edasine töö toimub kasutaja interaktsiooni peale, märkeruudule vajutades kutsutakse välja

funktsioon updateMarkupSchema mis tuvastab vealiigi, mille peale vajutati, ning muudab

veaskeemil vajalikud vead aktiivseks või vastupidi deaktiveerib nad. Kutsub omakorda välja

funktsiooni displayCurrentErrors. Antud funktsiooni poolt kasutatavad funktsioonid toon

välja nimekirjana:

unpaintErrors - eemaldab vigade märgistuseks olevate div kihtide vahelt markeeringu

ehk teksti allajoonimise

removeMarksType - eemaldab vigade märgistuse tekstist

showCurrentError - hindab viitasid kasutades XPTraverser objekti, ning vajadusel

suurendab tekstijaotise loendurit läbi funktsiooni increaseTextNodeCounter. Lisab

tekstile uute vigade märgistused.

paintErrors - vastvalt vigade märgistusele markeerib vigase koha vastavat värvi

alljoonega, vea sisu tühjaks osutumisel on tegemist kattuva veaga ning selle tarbeks

lisatakse sellele klass, mille järgi on võimalik näidata infoakent (tooltip) vigade

kattumise kohta.

var mytips = false;function init_view(event){

countStats(); var att = 0; var add = 0; if (window.attachEvent) { att = 1; } else { add = 1; } errs = document.getElementsByTagName("span"); for ( var i=0; i<errs.length; i++)



{ if (!errs[i].getAttribute('uniq')) { continue; } errs[i].style.display='none'; if (att) { errs[i].attachEvent('onclick', attachForum); } if (add) { errs[i].addEventListener('click', attachForum, false); } } url = window.location.search; if (url.charAt(0)=='?') { url = url.substring(1); uniq = url.split('=')[1]; hilight_uniq(uniq); }}

function countStats(){var stats = [];$$(".document_markup_schema input").each(function(item){

var name = item.get('name');var isin = false;stats.each(function(stat){

if (stat[0] == name) {isin = true;

} });if (isin === false) stats.push([name, 1]);else {

stats.each(function(stat){if (stat[0] == name) {

stat[1] +=1;}

});}

});stats.each(function(one){

$$('.error_marker_input').each(function(current){if ($(current).get('name') == one[0]) {

$(current).set('text', $(current).get('text')+' ( '+ one[1]+' )');

}});

});

}



function removeMarksType(){$$('#contentDiv div.inlineMark').each(function(item){

item.dispose();});var cd = $('contentDiv');

cd.normalize();

$$('.error_marker_input').each(function(element){if(element.get('text').indexOf('(*)') != -1){

element.set('text', element.get('text').slice(0,element.get('text').indexOf('(*)')));

}});

}

function paintErrors(){

$$('#contentDiv div.inlineMark.beginMark').each(function(item){var textcontent = item.nextSibling.nodeValue;var color = $(item).getProperty('name');var remove = false;var errortype = $(item).get('rel');if($type(item.nextSibling) == 'textnode'){

remove = true;var paintedElement = new Element('span', {

'class': 'paintedMark', 'style' : 'border-bottom:3px solid #'+color, 'html': textcontent });

}if ($type(item.nextSibling) == 'whitespace'){

remove = true;var paintedElement = new Element('span', {

'class': 'paintedMark tooltip', 'style' : 'cursor:pointer; color: #FF0000; border-

bottom:3px solid #'+color, 'html': '(*)', 'title': 'Kattuvus veaga -> '+errortype });}if(remove){

item.nextSibling.parentNode.removeChild(item.nextSibling);$(paintedElement).injectAfter(item);

}



});}

function unPaintErrors(id){var cd = $('contentDiv');var spans=$$("#contentDiv span.paintedMark");spans.each(function(item){

if(item.get('text') != '(*)'){item.appendText(item.get('text'),'before');

}else{

item.appendText('','before');}

item.dispose();});cd.normalize();

}

function increaseTextNodeCounter(expression, onlycount){var p = expression.split('#');var text = p[0].substring(p[0].lastIndexOf('/')+1);var mat = text.match(/(.*?)\[(.*?)\]/);

if (mat[1] == 'text()') {var currentNode = parseInt(mat[2]);if (onlycount){

return currentNode;} var toReplace = 'text()['+currentNode.toString()+']';

}else{

alert("error finding proper text node");}

var newLeft = p[0].slice(0,p[0].lastIndexOf('/')+1);var NewExp = newLeft + toReplace +'#'+ p[1];return NewExp;

}function showCurrentError(xPath, id, color, name){

var faults = false;var cd = $('contentDiv');spl = xPath.split(';');

full_start_expr = spl[0]; full_end_expr = spl[1]; start_expr = full_start_expr.split('#')[0]; end_expr = full_end_expr.split('#')[0];



start_off = full_start_expr.split('#')[1].split(':')[1]; end_off = full_end_expr.split('#')[1].split(':')[1];

var show1 = false;var show2 = false;

if (full_start_expr.indexOf('text()#') == -1) {

show1 = increaseTextNodeCounter(full_start_expr, true);} else {

full_start_expr = full_start_expr.replace('text()#','text()[1]#');

}

if (full_end_expr.indexOf('text()#') == -1) {show2 = increaseTextNodeCounter(full_end_expr, true);

} else {full_end_expr = full_end_expr.replace('text()#','text()

[1]#');}

xp = new XPTraverser(cd, full_start_expr, show1); start = xp.resultnode; start_off = xp.newoffset;

xp = new XPTraverser(cd, full_end_expr, show2); end = xp.resultnode; end_off = xp.newoffset;

bet1 = new Element('div', { 'class': 'inlineMark ignore_xpath beginMark '+id, 'name' : color, 'rel' : name, 'html': '' }); bet2 = new Element('div', { 'class': 'inlineMark endMark ignore_xpath '+id, 'name' : color, 'rel' : name, 'html': '' }); if ( start.isSameNode(end) ) { while (!start.nodeValue.charAt(start_off) && show1 == false) {

if(start_off < 0){break;} full_start_expr = increaseTextNodeCounter(full_start_expr, false);



full_end_expr = increaseTextNodeCounter(full_end_expr, false); xp = new XPTraverser(cd, full_start_expr, show1, 0); start = xp.resultnode; start_off = xp.newoffset;

xp = new XPTraverser(cd, full_end_expr, show2, 0); end = xp.resultnode; end_off = xp.newoffset; }

if(start_off < 0){ start_off = end_off = 0; faults = id; } if(end_off > start.nodeValue.length){ start_off = end_off = start.nodeValue.length; faults = id; } if (faults && ($(id).get('text').indexOf('(*)') == -1)){ $(id).set('text',$(id).get('text')+'(*)'); } split_to_three(start, start_off, end_off, bet1, bet2); } else { split_node(start, start_off, bet1); split_node(end, end_off, bet2); }

}function displayCurrentErrors(){

var showableMarks = [];$$(".document_markup_schema input").each(function(item){

if (item.get('value') == 1) {showableMarks[item.get('counter')] =

[item.get('xpoint'), item.get('name'), item.get('docolor'), item.get('rel')];

}

}); unPaintErrors();

removeMarksType(); showableMarks.reverse(); showableMarks.each(function(current){

showCurrentError(current[0], current[1], current[2], current[3]);



}); paintErrors(); mytips = new Tips($$('.tooltip'), {

showDelay: 100,hideDelay: 100

}); mytips.attach('.tooltip');}

function updateMarkupSchema(error_type, action){$$(".document_markup_schema input").each(function(item){

if (item.get('name') == error_type.get('name')) {var state = item.get('value');if (state == 1 && error_type.getPrevious().checked

== true && (action == 2 || action == 0)) return;var newstate = (state == 0) ? 1 : 0;item.set('value', newstate);item.set('docolor',error_type.get('docolor'));if (newstate == 1) {

error_type.set("style","border-bottom:2px solid #"+error_type.get('docolor'));

} else {error_type.set("style","border-bottom:none");

}}

});

displayCurrentErrors();}

function setAttr(event, targ, tid)//@deprecated{ var target; if (event) { target = event.target ? event.target : event.srcElement; //target = target.id; } else { target = tid; } if (!target) return; both_xp = target.getAttribute('xpoint'); cd = $('contentDiv'); first_expr_dr = both_xp.split(';')[0]; second_expr_dr = both_xp.split(';')[1];

xp = new XPTraverser(cd, first_expr_dr); start = xp.resultnode;



first_off = xp.newoffset.toInt();

xp = new XPTraverser(cd, second_expr_dr); end = xp.resultnode; second_off = xp.newoffset.toInt();

bet1 = document.createElement('div'); bet1.setAttribute('class', 'inlineMark'); bet1.setAttribute('id', 'inlineMark'); bet2 = document.createElement('div'); bet2.setAttribute('class', 'inlineMark'); bet2.setAttribute('id', 'inlineMark'); txt1 = document.createTextNode('>>'); bet1.appendChild(txt1); txt2 = document.createTextNode('<<'); bet2.appendChild(txt2);

if ( start.isSameNode(end) ) { split_to_three(start, first_off, second_off, bet1, bet2); } else { split_node(start, first_off, bet1); split_node(end, second_off, bet2); }}function showerror(event){ deHilightAll(); setAttr(event, 'inline');}

function hilight_uniq(uniqid){ spans = document.getElementsByTagName('span'); for (var i=0; i<spans.length; i++) { if ( spans[i].getAttribute('uniq') == uniqid ) spans[i].style.display = 'inline'; }}

function deHilightAll(){ cd = document.getElementById('contentDiv'); var marks = $$(".inlineMark").each(function(item){ $(item).dispose(); });



divs = cd.getElementsByTagName('div'); lenn = divs.length; i = 0; while (divs) { if ( divs[0] ) { if ( divs[0].getAttribute('id') == 'inlineMark' ) { divs[0].parentNode.removeChild(divs[0]); } } else { break; } i++; if ( i> 99) break; } cd.normalize();}



LISA 4. XPATH_EVALUATOR.JS TÄIENDUSED

Xpath_evaluator on põhiline töövahend vigade asukoha teadasaamiseks tekstis, seda

kasutatakse nii vigu algselt märgendades, kui ka hiljem visualiseerides. Seetõttu selle osa

muutmine oli kõige riskantsem, kuna vigade salvetamise juures ei tohtinud midagi muutuda.

Meetod _trav käib rekursiivselt etteantud Xpathi väljendi läbi seni, kuni jõuab tekstijaotsieni.

function getNodes(elem) { elems = elem.childNodes; res = Array(); for ( o=0; o<elems.length; o++ ) { if ( $type(elems[o]) == 'textnode' || $type(elems[o]) == 'whitespace' || elems[o].hasClass('ignore_xpath')) { res.push(elems[o]); } } return res;}/* * /P[2]/text()#off:64 */XPTraverser = function(root, path, show, rrun) { this.newoffset = null;

this.rrun = rrun;this.hasTextnodes = (show) ? (show - 1) : 0;p = path.split('/');

p.reverse(); this.resultnode = this._trav(root, p);}

XPTraverser.prototype.traverseXPath = function(root, path) { p = path.split('/'); p.reverse(); return this._trav(root, p);}

XPTraverser.prototype._trav = function(root, parts) { var r = false; p = parts.pop(); if ( p ) { if ( p.contains('#') ) { p = p.split('#'); offsetraw = p[1]; p = p[0]; offset = offsetraw.split(':')[1]; } if ( p.contains('[') ) {



mat = p.match(/(.*?)\[(.*?)\]/); p = mat[1]; ord = mat[2].toInt(); } else { ord = 1; } if ( p != 'text()' ) { elems = root.getElements(p);

} else { elems = getNodes(root);

if(ord != 1){r = true;} }

this.show = false; ord -= 1;

var textoffset = 0;var marks = 0;var nontext = 0;for ( i=0; i<elems.length; i++ ) {

if ( $type(elems[i]) != 'textnode' && $type(elems[i]) != 'whitespace' && elems[i].hasClass('ignore_xpath') ){

if(elems[i].hasClass('beginMark') && this.hasTextnodes != 0){

marks +=1;if (this.rrun) {

ord += 1;}else{

ord += 2;}

} this.show = true; if($type(elems[i-1]) == 'textnode' &&

textoffset == 0){textoffset += elems[i-1].nodeValue.length;} ord += 1; nontext += 1; continue; }

if ( i == ord ) {

if($type(elems[i-1]) == 'textnode' && this.hasTextnodes != 0){textoffset = 0;}

root = elems[i]; break; }

if ( $type(elems[i]) == 'textnode' && this.show == true){

textoffset += elems[i].nodeValue.length;

if($type(elems[i-1]) == 'textnode' && r==true){textoffset=0;}



} }

if ( p == 'text()' ) { cn = root.childNodes; // are we split node? text_node_index = 0; text_length_count = 0; orgoffset = offset.toInt(); if (textoffset > 0) {orgoffset -= textoffset;}

this.newoffset = orgoffset; } } if ( parts.length ) return this._trav(root, parts); return root;}


TALLINNA ÜLIKOOLI HAAPSALU KOLLEDŽ

Infotehnoloogia osakond Rakendusinformaatika eriala

Tööpealkiri: EESTI VAHEKEELE KORPUSE TEKSTIDE MÄRGENDUSMOODULI ARENDAMINE

Teadusvaldkond: Infotehnoloogia

Uurimuse tasand

Diplomitöö

Aasta ja kuu

2011, Aprill

Lehekülgede arv

30

Referaat

Käesoleva diplomitöö eesmärkideks on anda ülevaade keelekorpustest ja nende kasutamisest

ning tutvustada Eesti vahekeele korpuse märgendusmooduli tööpõhimõtet. Tuua esile positiivseid

ja negatiivseid külgi olemasoleva süsteemi juures ning täiustada kasutajaliidese funktsionaalsust.

Eesmärgist lähtuvalt on ülesandeks luua testkeskkond, mis jäljendaks võimalikult täpselt Eesti

vahekeele korpust. Parandada korpuse kasutajaliidese funktsionaalsust, vastavalt etteantud

spetsifikatsoonile ning kirjeldada tehtud muudatusi. Kirjeldada edaspidiseid vajalikke parandusi

ning edasiarendusvõimalusi.

Töö meetodiks on praktilise lahenduse loomine Eesti vahekeele korpuse tekstide

märgendusmooduli edasiarenduse näol.

Käesolevas diplomitöös püstitatud peamised eesmärgid said täidetud.

Praktilise lahendusena valminud Eesti vahekeele korpuse tekstide märgendusmoodul

võimaldab visualiseerida märgendatud vigu vealiigi kaupa.

Võtmesõnad: Eesti vahekeele korpus, teksti märgendamine, kasutajaliides

Säilitamise koht

TLÜ Haapsalu kolledži raamatukogu

Töö autor: Siim Medijainen allkiri:

Kaitsmisele lubatud:

Juhendajad: Jaagup Kippar, Erika Matsak allkiri:

HAAPSALU COLLEGE OF TALLINN UNIVERSITY

Department of Information Technology APPLIED COMPUTER SCIENCE

Title: IMPROVEMENT OF THE ESTONIAN INTERLANGUAGE CORPUS TEXTS MARKUP MODULE

Science Areas: Information technology

Level

Diploma Thesis

Month and year

2011, April

Number of pages

30

Abstract

The aim of this diploma thesis is to give an overview about language corpuses and their usage,

also to introduce the technical mechnisms behind the Estonian Interlanguace Corpuses markup

module. It is neccessary to describe the pros and cons of the current state of markup and to give

an overview about futher developents possible and needed in order to improve the Corpus.

The main goal is to create a testing environment as identical as possible to the original Corpus

and then to improve the texts markup module as previously specified, also to describe the

changes made in precise technical detail. Method chosen for current thesis would be a practical

solution.

All of the goals arised in the thesis were completed. As a practical solution an improved version

of the Estonian Interlanguage Corpuses markup module was developed and the author hereby

confirms that all of the functionality specified beforehand, is ow part of the Estonian

Interlanguage Corpuses markup module.

Keywords: Estonian Interlanguage Corpus, user interface, markup

Where deposited

Library of Haapsalu College of Tallinn University

Author of diploma thesis: Siim Medijainen signature:

Approved for dissertation:

Academical advisors: Jaagup Kippar, Erika Matsak signature:

Documents

minitorn.tlu.eeminitorn.tlu.ee/~jaagup/oma/too/11/05/Eesti_vahekeele... · Web viewKorpuseks nimetatakse elektroonilist keeleandmekogu, kuhu on valitud tekstid nii, et need annaksid