Készítette: Oltványi Gábor József PPKE-ITK

Készítette: Oltványi Gábor József PPKE-ITK

KOREFERENCIA-ANNOTÁLÓ ESZKÖZ FEJLESZTÉSE HÁLÓZATI KÖRNYEZETBEN

D I PL O MA T E RV EZ É S

Szak: Szakirány: Témavezető: Év:

műszaki informatikai nyelvtechnológia Dr. Prószéky Gábor 2009.

[diplomaterv-téma bejelentés]

NYI LAT KO ZA T A Z Ö N Á LLÓ MUNKÁRÓL

Alulírott Oltványi Gábor József, a Pázmány Péter Katolikus Egyetem Információs Technológiai Karának hallgatója kijelentem, hogy ezt a diplomatervet meg nem engedett segítség nélkül, saját magam készítettem, és a diplomamunkában csak a megadott forrásokat használtam fel. Minden olyan részt, melyet szó szerint, vagy azonos értelemben, de átfogalmazva más forrásból átvettem, egyértelműen a forrás megadásával megjelöltem. Ezt a Diplomamunkát más szakon még nem nyújtottam be.

_____________________________ Oltványi Gábor József

III.

Oltványi Gábor József - Diplomaterv

Tartalomjegyzék

TART A L O MJ E GY ZÉ K Koreferencia-annotáló eszköz fejlesztése hálózati környezetben............................................ 1 Nyilatkozat az önálló munkáról ................................................................................................. III Tartalomjegyzék ........................................................................................................................ IV Tartalmi kivonat........................................................................................................................ VII Abstract ................................................................................................................................... VIII 1. Bevezetés............................................................................................................................... 1 1.1.

Általános bevezető ..................................................................................................... 1

1.2.

Koreferenciák.............................................................................................................. 2

1.2.1. 1.3.

Zéró névmások ................................................................................................... 3

Annotált korpuszok..................................................................................................... 4

1.3.1.

Szeged Korpusz 2.0 ............................................................................................. 4

1.3.2.

Szeged Treebank 2.0 ........................................................................................... 5

1.3.3.

Koreferenciák annotálása ................................................................................... 7

2. A feladat ................................................................................................................................ 9 2.1.

Megfogalmazása ......................................................................................................... 9

2.2.

Célja .......................................................................................................................... 10

3. Előzmények ......................................................................................................................... 11 3.1.

Irodalom ................................................................................................................... 11

3.2.

Koreferencia-annotáló eszközök .............................................................................. 11

3.2.1.

PALinkA ............................................................................................................. 11

3.2.2.

GATE ................................................................................................................. 12

4. Megvalósítás: „COREF”........................................................................................................ 13

IV.

4.1.

Követelmények, környezet ....................................................................................... 13

4.2.

Futtatás, GUI ............................................................................................................. 14


4.3.

Tartalomjegyzék

Feladat: cikkekre bontás ........................................................................................... 14

4.3.1.

Korábbi megvalósítás: Python program ........................................................... 15

4.4.

XML betöltése, előkészítés ....................................................................................... 15

4.5.

Koreferenciák kezelése ............................................................................................. 16

4.5.1.

Koreferencia kapcsolat létrehozása ................................................................. 16

4.5.2.

Koreferenciák szerkesztése (Edit mode) .......................................................... 17

4.5.3.

Koreferenciák törlése (Delete mode) ............................................................... 18

4.5.4.

Multi-koreferencia ............................................................................................ 18

4.6.

Zéró névmások beillesztése ...................................................................................... 18

4.6.1.

Automatikus zérónévmás-felismerés ............................................................... 19

4.7.

Segédeszköz kereséshez ........................................................................................... 20

4.8.

COREF V1 kiértékelése ................................................................................................ 21

4.8.1.

Memória- és erőforrás-igények ........................................................................ 21

4.8.2.

Felhasználói igények ......................................................................................... 22

4.8.3.

Platformfüggetlen környezet igénye ................................................................ 22

4.8.4.

Hálózati környezet igénye ................................................................................ 23

4.8.5.

Webes alkalmazás?........................................................................................... 24

4.8.6.

Szerver- és kliensoldali logika kérdése ............................................................. 24

4.8.7.

COREF v1 – összegzés......................................................................................... 26

5. Megvalósítás: „COREF v2” ................................................................................................... 27 5.1.

V.

Környezet .................................................................................................................. 28

5.1.1.

HTML, XHTML ................................................................................................... 29

5.1.2.

CSS .................................................................................................................... 29

5.1.3.

JavaScript .......................................................................................................... 30

5.1.4.

AJAX, JQuery ..................................................................................................... 32

5.1.5.

JSON .................................................................................................................. 33

5.1.6.

XML, XPath, DTD ............................................................................................... 33

5.1.7.

PHP ................................................................................................................... 34


5.1.8.

Tartalomjegyzék

MySQL ............................................................................................................... 34

5.2.

Lehetőségek megvalósításra .................................................................................... 34

5.3.

A megvalósítás .......................................................................................................... 36

5.3.1.

Felhasználók, jogosultságok ............................................................................. 36

5.3.2.

Az adatbázis ...................................................................................................... 37

5.3.3.

Menüpontok ..................................................................................................... 38

5.3.4.

XML szerkesztése .............................................................................................. 39

5.3.4.1.

XML-dokumentum kiválasztása (Choose XML) ........................................ 39

5.3.4.2.

XML beolvasása ........................................................................................ 39

5.3.4.3.

XML-dokumentum szerkesztése (Edit XML) ............................................. 40

5.3.4.4.

Koreferenciák törlése ............................................................................... 42

5.3.4.5.

XML mentése, exportálása ....................................................................... 42

5.3.5.

Offline részfeladatok ........................................................................................ 43

5.3.5.1.

Cikkekre bontás ........................................................................................ 44

5.3.5.2.

Betöltés előtti előkészítés ......................................................................... 44

5.3.5.3.

Zérónévmások automatikus beszúrása .................................................... 44

5.3.6.

Kódolás ............................................................................................................. 45

5.4.

Böngésző sajátosságok és megoldások .................................................................... 45

5.5.

Hogy teljes legyen a projekt… .................................................................................. 48

6. Összefoglalás ....................................................................................................................... 50 7. Irodalomjegyzék ................................................................................................................... IX 7.1.

Felhasznált/ajánlott irodalom ................................................................................... IX

7.2.

Felhasznált/ajánlott web linkek.................................................................................. X

8. Mellékletek .......................................................................................................................... XII

VI.


Tartalmi kivonat

TARTALMI KIVONAT Koreferencia-annotáló eszköz fejlesztése hálózati környezetben Digitális szövegek feldolgozása sokrétű lehet. Számítógép segítségével az egészen egyszerű keresési feladatoktól komoly összefüggések automatikus megtalálásáig léteznek megvalósítások. Az annotáció ezekhez egy alapvető segédeszköz, kereshetővé válnak vele a kiemelt részek. A koreferencia egy szövegbeli összefüggés, amikor ugyanarról a dologról beszélünk a szövegben két eltérő helyen. Speciális esetben hiányozhat az egyik egymásra utaló elem, ezt hívjuk zérónévmásnak. Feladatunk, hogy egy koreferencia-annotáló eszközt készítsünk el. A hozzá szükséges korpuszanyagot pedig a Szeged Treebank 2.0 XML-dokumentumai szolgáltassák. Az eszköz legyen felhasználóbarát, mert nagy mennyiségű adatot szeretnénk vele földolgozni. Továbbá tegye lehetővé, hogy egyszerre több felhasználó dolgozhasson a dokumentumokon. Zérónévmás-kiegészítésre is adjon alkalmat. Felhasználásával kutatás indul szövegek automatikus koreferenciaannotálására, ami újabb információkivonatolási kutatásoknak ad lehetőséget. Első megvalósítása a COREF 1, ami .NET környezetben készült C# nyelven egy ablakos alkalmazás formájában. Ez a változat alkalmas a kiírt feladatokra, egyedül a hálózati munkákat nem támogatja. Elkészült a COREF 2 is, ami egy webes alkalmazás, és alapvetően hálózati, több felhasználós elvekre épül. A fölhasznált környezet: XHTML, CSS, JavaScript, AJAX, PHP, MySQL, XML. Ez a változat szintén lehetővé teszi a koreferencia annotálást az adott korpuszon. Fejlesztése során megismerkedtem a webes technikák sajátosságaival is.

VII.


Abstract

ABST RA CT Developing Coreference-Annotating Tool in Network Environment Processing digital scripts can be different. Thanks to computers, we can search easily in large texts, and also can find grave connections inside. Annotation is a basic tool for searching the highlighted parts of a texts. Coreference is a connection between two part of the text, that two part refer to the same object in the world. In a special case one part can be missing, that’s what we call zero pronoun. Our proposion is to create a coreference-annotator tool. The needed text corpus would be the XML-documents of Szeged Treebank 2.0. The tool should be clear and userfriendly, because we have to process a large amount of data by this. In addition the tool have to support networking, so that many user may work at the same time. Inserting zero pronouns should be also one task of the tool. By this a research will start to find coreferences automatically in any script, and then, based on this, more researches will be able to start, like information extracting. First implementation is COREF 1, which is a window form, written in .NET environment, C# language. This tool provides all tasks defined, except the networking parts. COREF 2 is also done, which is a web application, and based on a multiuser expectations. I used the following environment: XHTML, CSS, JavaScript, AJAX, PHP, MySQL, XML. This version also suits the requirements of coreferenceannotating on the given text corpus. During the development, I get acquainted with the specialities of web techniques.

VIII.

1. Bevezetés


1. BEVEZETÉS 1.1. Általános bevezető Mindennapjainkban, különösen a XX. század végétől egyre több leírt szöveggel találkozhatunk. Akár, ha az internet megjelenésére gondolunk, a világ összes leírt szövegmennyisége rúgásszerűen emelkedett, és ez a folyamat növekedése sem apadt. Egyre több minden épül az interneten megtalálható leírásokra, illetve ma már szinte minden helyen alapkövetelmény, hogy digitálisan tárolják a hivatalos dokumentumokat. A múlt század végétől számottevő tehát a digitálisan tárolt szöveg mennyisége – jelen munkában is ezekkel foglalkozunk. Nagy előnye a digitálisan tárolt szövegeknek, hogy számítógéppel könnyedén földolgozhatók, szövegrészek kereshetők benne elég gyorsan – összemérhetetlenül gyorsabban, mintha föllapoznánk egy vastag könyvet… Szövegek feldolgozását lehet többféle mélységben is végezni: az egyszerű vagy összetettebb, módszeres megjelenítéstől kezdve a helyességellenőrzésen keresztül az egész komoly összefüggések automatikus megtalálásáig léteznek igények is és alkalmazások is, amik ezeket a különböző nehézségű feladatokat megvalósítják. A legkomolyabb feladatok azt célozzák, hogy egy mesterséges intelligens eszköz (ágens) „megértse” a szöveg tartalmát, azaz ki tudja belőle nyerni a neki kellő információkat, és így megfelelően tudjon reagálni a környezetében. Nagy segítség tud lenni ez számos kutatásban, például, ha emberi befogadóképességet meghaladó szövegeket kell értelmezni, kiértékelni. A

nyelvtechnológia

többnyire

szövegek

feldolgozásával

foglalkozik.

Összefüggéseket keres különféle szövegekben – akár két különböző (pl. nyelvű) szöveget „szinkronizál” (pl. gépi fordítás), akár egy szöveget értelmez, segít megérthetőbbé tenni (pl. szintaktikai elemzések), akár pedig általánosságokat, információt nyer ki szövegekből (pl. szótárak készítése, adatbányászat). Ezek mellett a nyelvtechnológia magasabb szintű kihívásai közé tartozik, és szintén a

1

1. Bevezetés


szöveg mélyebb szintű ért(elmez)ését segíti, hogy a világ dolgait egy nagy rendszerbe foglalja, föltárja a különféle fogalmak közötti összefüggéseket, kapcsolódási lehetőségeket… Ezek például az ontológiák – és, természetesen, sok más szakterület szakértőivel kell közreműködni a feladat megvalósításában. Jelen munkában viszont nem szaladunk ilyen „messzire”, (az általános területek felé), hanem kiemelünk egy szeletet: egy adott szöveg elemzését segítő eszköz

létrehozása

a

feladat.

Konkrétabban,

egy

olyan

grafikus

szerkesztőprogramot szeretnénk létrehozni, ami támogatja szintaktikailag elemzett szövegeken egy speciális kapcsolat, a koreferenciák bejelölését, annotálását. Általa majd további gépi elemzésekre (gépi tanulás), összefüggések megértésére lesz lehetőség.

1.2. Koreferenciák Koreferenciának azt az azonosságot nevezzük, amikor egy (akár több mondatos) hosszabb szövegrészben két különböző helyen megjelenő szó a világ ugyanarra az objektumára vonatkozik. Vagyis van egy későbbi, visszautaló elem (anafora ), illetve egy, a szövegben korábban előforduló, vele koreferens (azaz, szó szerint:

ugyanoda hivatkozó) szószerkezet (antecedens ), és ezek ugyanarra a való világbeli entitásra vonatkoznak. Másként

megfogalmazva:

természetesnyelvi

szövegekben

az

NP1-

koreferenciák feloldása: egy adott dokumentumban eltérő pontokon megjelenő, de azonos entitásra referáló főnévi csoportok közötti viszonyok azonosítását jelenti. Koreferenciát tehát akkor értelmezünk egy szövegben, ha ugyanaz a valami többször van megemlítve benne, akár ugyanolyan formában, akár más szavakkal kifejezve, pl. bővítve, szinonimájaként vagy névmással, stb. Vegyünk néhány példát a leggyakrabban előforduló koreferencia jelenségekből!

1

NP: Noun Phrase, főnévi csoport, szószerkezet

2

1. Bevezetés


Típus Ismétlés

Példa Tegnap találkoztam egy ismerősömmel . Az ismerősöm nagyon sietett, mindössze pár percet beszéltünk.

Tulajdonnév-

Kovács Jakab tegnap sajtótájékoztatót tartott. Az eseményen

variáns

Kovács úr bejelentette az új termékeket.

Szinonima

Tamás kapott egy biciklit . Én is láttam a kerékpárt.

Hipernima /

Bejött egy puli . Az állat fáradtnak tűnt.

hiponima Névmás

Beszéltem Julival . Megadtam neki a számodat.

Zérónévmás

Viktor ismeri Ferit , de [ő] nem kedveli [őt ] túlságosan.

1. táblázat: Koreferencia típusok példákkal Egy szövegben a koreferenciák ismerete fontos mindazon nyelvtechnológiai alkalmazások számára, amelyek igénylik a feldolgozandó szöveg „mélyebb” megértését, mint például a gépi fordítás, információkivonatolás. A gépi fordításban például a mondatok fogódzópontjaiként tudnak szolgálni.

1.2.1. Zéró névmások Az 1. táblázat egy különös esete, amikor a szövegben nem jelenik meg a koreferencia egyik hivatkozási pontja, viszont a szöveg környezetéből egyértelmű, hogy ott egy rejtett elemre vonatkozik. Nem mindegyik nyelvben lehetséges ez, de anyanyelvünk képes ilyen, úgynevezett zéró elemekre, amit általában névmással oldunk fel. Ez a nyelvi jelenség csak azért fontos számunkra, mert, habár az ember átsiklik fölötte, és „minden gondolkozás nélkül” megérti, de egy gép számára, ami csak a megadott szöveget látja, messze nem egyértelmű feladat. Vajon megoldható-e, hogy föl lehessen a zéró elemeket gépileg ismerni? – Igen, létezik már rá alkalmazás, ahogy erre később utalni fogok (4.6, 5.3.5.3). Majd

annak az eredményével ki kell egészítenünk a munkánkat, hiszen előfordulhat, hogy enélkül nem tudjuk azonosítani a nekünk kellő kapcsolat egyik részét.

3

1. Bevezetés


1.3. Annotált korpuszok Korpusz alatt lényegében digitálisan tárolt írott, vagy beszélt nyelvi anyagot értünk, amin nyelvészeti elemzéseket tudunk végezni. Annotált korpuszról pedig akkor beszélünk, ha valamilyen elemzés során a szöveg egységei meg lettek

jelölve: annotálva – mégpedig nyelvészeti szempontból hasznos módon. Korpuszt szinte bárhonnan lehet gyűjteni, hiszen, ahogy említve volt, írásos forrásból mérhetetlen mennyiség létezik. Az annotálást pedig általában nyelvész szakértők végzik: végighaladnak egy kiválasztott szövegen, és bejelölik benne az egyes egységeknek megfelelő jellemzőket, tulajdonságokat. De előfordul olyan is, hogy az annotálást gép végzi, bizonyos összefüggések ismeretében – a projektnek,

melynek jelen munka is része, távoli célja pedig pont egy ilyen automatikus annotálási lehetőség. Munkámban a szerkesztőprogram egy bizonyos annotálást tesz lehetővé

egyszerű, könnyen elvégezhető, felhasználóbarát módon: pár kattintással létre lehet

hozni,

illetve

szerkeszteni

koreferenciákat.

Mindezt

egy

olyan

szövegkorpuszon teszi, ami már maga eredetileg is tartalmaz egyéb annotációkat, nevezetesen szófajilag egyértelműsítve, továbbá szintaktikailag elemezve van. Ilyen magyar szövegkorpusz a Szeged Korpusz 2.0, illetve, szintaktikai elemzéssel a Szeged Treebank 2.0. Ez utóbbira alapoztuk a munkát.

1.3.1. Szeged Korpusz 2.0 Egészen változatos szövegeken szófaji egyértelműsítést hajtottak végre, vagyis minden szónak meghatározták az éppen aktuális szófaját. Ugyanis elég gyakran ugyanaz

a

szóalak

szövegkörnyezettől).

Így,

többféle a

jelentéssel

többértelműség

is

bírhat

(függetlenül

megakadályozásával,

a

alapvető

fontosságú információkkal szolgálunk a természetesnyelvi feldolgozó rendszerek számára. Nagyjából 2004-re készült el ez a verzió, az 1.0 után, mintegy 1,2 millió szövegszó szerepel benne. A korpusz elemzendő szövegmintái hat különböző témakörből kerültek ki:

4

1. Bevezetés


– három szépirodalmi regény (Rejtő Jenő: Piszkos Fred; Szerb Antal: Utas és holdvilág; George Orwell: 1984), – 14-16 éves korú tanulók fogalmazásai (~850 darab, az országban több helyről, témák: Egy szép napom ; Miért (nem) szeretek iskolába járni ), – újságcikkek (Népszabadság, Népszava, Magyar Hírlap, HVG), – számítástechnikai szövegek (egy könyvből és két magazinból), – jogi szövegek (gazdasági társaságokról és a szerzői jogokról), illetve – gazdasági és pénzügyi rövidhírek (az MTI adatbázisából). Az annotációt XML-formátumban végezték, ami egy szabványos DTD sémának felelt meg (TEIxLite), a jelölésben pedig MSD morfo-szintaktikai

kódokat használták fel. Például az „asztalnak” szó „Nc-sg------” és „Nc-sd-----” kóddal is jelölve lehet, hiszen főnév (N), köznév (c), egyes számú (s), és állhat

birtokos (g), illetve részes (d) esetben is. (A Szeged Korpuszról részletes leírást az

Irodalomjegyzékben ajánlott helyen lehet találni.)

1.3.2. Szeged Treebank 2.0 A Szeged Korpusz 2.0 annotációjára épül, annak ellátása újabb jellemzőkkel: a treebank már szintaktikailag is elemezve van. A magyar nyelv mondataiban a szavak és szószerkezetek, valamint egymáshoz való viszonyuk meghatározó szerepűek. A szintaktikai elemzés és annotálás tehát az egyes szintaktikai egységek (pl. főnévi csoportok, igék és vonzatkeretük) és az egymáshoz való viszonyuk bejelölését jelenti. A Szeged Treebankben is a már több nyelven létező treebank-reprezentációt használták. Mivel a Szeged Korpusz meglévő XMLformátumú elemzéséből indul ki, ez az annotáció is XML formátumban lesz, de már egy általánosabb DTD sémaszabványnak felel meg, ez a TEI P4. Bizonyos meglévő elméletekre alapozva nyelvész szakértők konzisztens szintaktikai szabályrendszereket dolgoztak ki, ami lehetővé tette, hogy a Szeged Korpuszon először egy automatikus előannotálást tudjanak végezni egy programmal. Ezt azután ugyancsak szakértők ellenőrizték és javították. A

treebank

lényege,

hogy

egy

mondatot

fás,

azaz

hierarchikus

szerkezetben ábrázolja, különböző névszói és igei csoportokat létrehozva. Minden

5

1. Bevezetés


csoport kap egy azonosítót (ID-t), így a hierarchia különböző szintjein lévő egységek mindegyike hivatkozhatóvá válik. Például fontos, hogy az igéknél (állítmánynál) megadjuk a hozzá tartozó bővítményeket is, típusukkal és szerepkörükkel együtt. A következő, 1. ábra szemlélteti egy példamondat treebank-elemzését, illetve a 2. ábra ugyanennek az elemzésnek az XMLreprezentációját olvashatjuk.

1. ábra: Treebank mondatszerkezet A treebankben egy-egy gyűjtemény (témakör) egy-egy fájlban van kiterjesztve, melynek cikkei, fejezetei, egy-egy
XML-elem közé vannak zárva. „div”-enként bekezdések (
), azon belül mondatok (<s>) vannak, melyekben CP-k (Clausal Phrase = mondat értékű frázis) adják a mondat alap szerkezetét. Az alapos elemzésnek köszönhetően egy-egy XML dokumentum 10-50 MB méretű. Ezt az átláthatóság és a könnyebb feldolgozás kedvéért praktikus

cikkekre (
-ekre) bontani, így munkánk kiegészítéseként ezt a feladatot is kitűzhetjük.

6

1. Bevezetés


2. ábra: Treebank mondatszerkezet (egyszerűsített) XML-jelöléssel

1.3.3. Koreferenciák annotálása Koreferenciák bejelölése egy szövegbe szintén annotációs feladat. Ilyen annotált korpuszok készítése alapvető fontosságú a gépi (azaz kvázi-automatikus) koreferencia-feloldó rendszerek fejlesztése szempontjából. Hol van szükség arra, hogy legyen sok ilyen annotált példánk? – Mondjuk a prototípus-rendszerek kiértékelésében;

vagy,

gépi

tanulás

alkalmazásakor,

a

tanulóalgoritmus

betanításához. A koreferenciák gépi tanulásával akár automatizálhatóvá is tehető a koreferencia-feloldás. Az utóbbi esetben akár több tízezer tanítópéldára is

szükség lehet – ennek biztosítására a Szeged Treebank pont megfelelő korpusz számunkra. Ha a Szeged Treebank 2.0 XML-dokumentumaiból indulunk ki, akkor nincs is olyan sok változtatnivalónk: egyszerűen az anaforához (visszautaló elem) fölveszünk egy hivatkozási azonosítót (refid attribútum) és egy hivatkozás

7

1. Bevezetés


típust (reftype). Például, ha a fenti példa úgy folytatódna, hogy „A lány nagyon

örült a látogatóknak.”, akkor az „A lány” rész XML-jelölése:

Az annotálást itt is nyelvész szakértők készítenék el, vagyis végighaladnak a szövegeken, és kézzel bejelölik a megfelelő entitások között fennálló koreferencia viszonyokat.

Ehhez a nagy

mennyiségű munkához viszont

elengedhetetlen fontosságú egy olyan annotációt megkönnyítő célszoftver,

amelynek segítségével az annotátori munka hatékonyan végezhető, illetve a nagymennyiségű

munka

szétosztása

egyszerűen

és

automatikusan

menedzselhető. Mivel ilyen szoftver még nem létezik, íme, itt a lehetőség, hogy elkészítsük azt – jelen munka pont ezt valósítja meg. Fogalmazzuk meg tehát a teljes feladatunkat!

8


2. A feladat

2. A FELADAT 2.1. Megfogalmazása Egy olyan grafikus felhasználói felületre (GUI) van szükség, amelynek segítségével az annotátorok a lehető legkevesebb interakcióval (azaz például egyegy egérkattintással) a leggyorsabban a legtöbb munkát el tudják végezni. Továbbá szükség van egy szerver-kliens architektúrára, amely lehetővé teszi, hogy az interneten keresztül szét lehessen osztani a munkát az akár párhuzamosan dolgozó annotátorok között, esetleg, ha több annotátor dolgozott azonos szövegen, az egyes változatok követése, és összehasonlítása nyomon követhető legyen. A projekt, amihez a szoftver készül, a Szeged Treebank 2.0 szintaktikailag elemzett

szövegkorpusz

XML-formátumát

tudja

fölhasználni

(beolvasni,

megjeleníteni, módosítani) – mivel az kellően nagy méretű, és tartalmazza a koreferencia-viszonyok jelöléséhez szükséges szintaktikai annotációt. Egyéb opcióként, mivel egy-egy ilyen XML-dokumentum igen nagy méretű, a projekt egy feladata a cikkekre bontás, vagyis, hogy a program bontsa annyi kisebb XML-fájlra az eredeti XML-t, ahány cikk (
) szerepel benne, a feji részeket megtartva. További részfeladatként, mivel egy koreferencia létrejöhet zérónévmások között is, amelyek nem jelennek meg az eredeti szövegben, a program adjon lehetőséget arra is, hogy az XML korpuszt ki tudjuk egészíteni zérónévmásokkal, illetve, amennyiben ez a folyamat automatizálható, ezt is végezze el. Mindezt megjelenítésében elkülönítve a többi egységtől. A megvalósítási környezetet a lehető legkönnyebben hozzáférhető, de funkcionálisan nem korlátozott módon válasszuk meg. Lényeges, hogy minden könnyen kezelhető legyen. Mivel több annotátor is fog dolgozni, legyen lehetőség felhasználó-kezelésre,

az

adataik

védelmére,

illetve

a

felhasználók

adminisztrációjára, munkáik felülvizsgálására.

9


2. A feladat

2.2. Célja A feladatkiírás indokoltsága, hogy egy jelenlegi kutatási kezdeményezést támogasson, létrehozza a hozzá szükséges rendszert, vagyis ezt a hálózati koreferencia-annotáló eszközt. A jövőben elindulna egy olyan magyar nyelvű nyelvtechnológiai projekt, melynek elsődleges célja a koreferenciák automatikus föloldása és annotálása. Ha léteznének ilyen algoritmusok, tetszőleges magyar szövegekben meg lehetne találni a kapcsolódási pontokat, s ez elősegítené az információkivonatolást is – amire pedig további mesterséges intelligenciai kutatások is épülhetnek. Ha tehát elkészül ez az eszköz, elindulna egy nyelvész-informatikus kutató csoport a Szeged Treebank hatalmas szövegtárának koreferencia-annotálásával. Ha ez is elkészül, elkezdődhet a létrehozott tanulóhalmaz feldolgozása – gépi tanuló

algoritmusok

eredményeként

segítségével

létrejöhet

a

összefüggéseket

koreferenciák

fognak

automatikus

keresni.

Ennek

föloldása,

amivel

megnyílna a tér számos további kutatáshoz… Jelen munka tehát a kézi koreferencia-annotálás hatékonyságának fokozása érdekében készül. Mivel nagy tanulóhalmaz szükséges, gyorsabb, ha minél több ember foglalkozik vele, ezért is szükséges a projekthez a több felhasználós rendszer. Továbbá, mivel a Szeged Treebank változatos szövegösszetételű, majd a betanított mintáknál sokkal kevésbé lesz gond, hogy csak egy adott szakterület koreferenciáinak feloldására lenne alkalmas.

10

3. Előzmények


3. ELŐZMÉNYEK 3.1. Irodalom A magyar nyelvű munkákban eddig leginkább szépirodalmi vagy nyelvtani elemzések, kutatások kapcsán fordult elő a koreferencia, mint nyelvi jelenség. Akár érdekes lehet egy műalkotás, vers szerkezetét a koreferenciáival fölépíteni (erre és a következőkre példák az Felhasznált/ajánlott irodalom fejezetben találhatóak). Illetve lehet róluk retorikai-stilisztikai vizsgálatot is végezni, illetve nyelvfilozófiailag,

kívülről

szemlélni.

Noha

készültek

már

számítógépes

szövegfeldolgozással kapcsolatos cikkek is, de olyan eszköz még nem készült, amivel kooperálva, hálózatban, hatékony koreferencia-annotálást lehetne végezni magyar nyelven, pláne a Szeged Treebankre épülve…

3.2. Koreferencia-annotáló eszközök Angol

nyelvű,

gépi

tanulás

alapú

koreferencia-feloldó

rendszert

már

megvalósítottak, magyar nyelven viszont az eddigiekben nem volt annyi adat, hogy föl lehessen így dolgozni. Koreferencia-annotálásra alkalmas programok is csak angol nyelven léteznek. Ilyen például a PALinkA és a GATE programok (elérhetőségüket lásd a Felhasznált/ajánlott web linkek részben).

3.2.1. PALinkA JAVA-s alkalmazás. Egy beállítási fájl betöltése után lehet egy példa XML-t megnyitni szerkesztésre. Ez igen egyszerű XML formájú, noha egyértelműen be lehet vele jelölni a koreferenciákat. A felhasználói felület nem túl átlátható elrendezésű, lassan jön rá az ember, hogy hova kattintson, ha valamit szeretne csinálni… De már ad lehetőséget zéró névmásokra való hivatkozások bejelölésére is. Egy képernyőkép: 3. ábra.

11

3. Előzmények


3. ábra: PALinkA – koreferencia-annotáló eszköz

3.2.2. GATE Ez egy általános annotációra való, nagyon jól, pl. videókkal dokumentált, szintén JAVA-s program. Bármilyen szöveges vagy XML dokumentumot be tud olvasni, XML esetén egyből be is tölti címkékbe az összes tag-et, illetve az attribútumaikat

is,

mint

annotációkat.

De

saját,

sokféle

annotációt

is

hozzáadhatunk, amihez név-érték párokat is társíthatunk. Koreferencia típusú annotációra is ad lehetőséget.

4. ábra: GATE – általános annotáló program

12


4. Megvalósítás: „COREF”

4. MEGVALÓ SÍ TÁS: „COREF”

5. ábra: A COREF program, szerkesztés közben

4.1. Követelmények, környezet A COREF program egy ablakozós alkalmazás (window form), mely Visual Studio 2008-cal lett fejlesztve C# nyelven. Ennek köszönhetően a futtatásához szükséges a .NET környezet legalább 2.0-s verziója, amely pl. egy Windows XP CD-ről is telepíthető, de a Microsoft oldaláról is letölthető. Futás során maximum 200 MB szabad memóriára van szükség, de általában csak 30-40 MB-ot használ a program.

13



Jelen, első változat nem tartalmaz hálózati elemeket, minden helyi gépen történik. De tervben volt, hogy az XML-dokumentumok változatai adatbázisba tárolódjanak, importálási és exportálási lehetőséggel. A program az említett Szeged Treebank 2.0 szöveggyűjtemény fájljait képes földolgozni. Ehhez minden egyes beolvasáskor szükséges, hogy meglegyen az XML-hez képest egy mappával följebb a szeged_treebank2.dtd nevű sémadefiníciós fájl, ami a TEI P4 szabványt írja le, továbbá a DTD mellett ott legyenek a DTD-ből belinkelt karakter kódlapok (isolat1u, isolat2u, isonumu, isopubu állományok) – az idegen karakterek kezeléséhez.

4.2. Futtatás, GUI Futtatása: egy egyszerű végrehajtható exe fájlt kell elindítani. Nem vár bemeneti paramétert, viszont ha nincs az exe fájl mappájában egy reftypes.txt nevű fájl, akkor kéri a program, hogy töltsük be. Ez a fájl soronként egy-egy koreferenciatípust tartalmaz. A kezdőablak nagyjából két részre osztható: egy halványzöld hátterű panelre, ahová majd a szöveget fogjuk betölteni, illetve egy listázó felületre, ahonnan az annotációt, és ezek szerkesztését fogjuk tudni végezni. Ezek fölött egy menüsor található, illetve egy eszközsor, ahonnan a megfelelő szerkesztési lépéseket

tudjuk

irányítani.

Legalul

pedig

egy

státuszjelző

csík

segít

megjegyzéseivel megérteni a történéseket.

4.3. Feladat: cikkekre bontás Említettük, hogy egy-egy, a treebankből vett XML dokumentum túl nagy méretű, és szükség lenne kisebb egységekre bontani. Mivel minden XML-ben van egy feji rész is, ezért az összes feji információt tartalmaznia kell majd a kis fájloknak is. Az elvárás, a szétbontott fájlokban csak egy
cikk szerepeljen.

14



Ez az opció elérhető: a Tools / Div Splitter menüpontból, vagy a Ctrl+V billentyűkombinációval. Egy kis

ablak

jön

elő,

ahol

ki

kell

választani az eredeti (nagy) XML fájlt, illetve

egy

kimeneti

mappát

kell

megadni, és elindítani a menetet. (Lásd: 6. ábra.) Ha az eredeti fájlnév file.xml volt, akkor az új fájlok nevei file_#.xml lesznek, ahol # a

sorszámát jelenti. A bontás XML-

6. ábra: Div-ekre bontás

alapon történik, tehát helyes XML esetén mindig sikeresen fut le.

4.3.1. Korábbi megvalósítás: Python program Korábban ugyanezt egy Python scripttel oldottam meg, ott viszont sztring alapon történik a szétbontás, így ha egy szóközzel több van egy kritikus helyen, akkor lehet, hogy máris hibásan vagy hiányosan fog történni a bontás… Viszont így sokkal gyorsabb, és kevesebb a memória-, illetve CPU-igénye.

4.4. XML betöltése, előkészítés Helyi meghajtóról lehet az említett követelményeknek megfelelő XML-t betölteni. Ez két vagy három lépésben történik (amit egyszerre is végre lehet hajtani).

Első (kötelező) lépés: Megnyitás (Open) – a megszokott módon File / Open menüpontból, vagy Ctrl + O-val, vagy az ikonra kattintva lehet kiválasztani egy dokumentumot. Ekkor még nem történik semmi, csak meghatároztuk a használandó fájlt.

Második (opcionális) lépés: Előkészítés (Prepare). A Szeged Treebank 2.0 szintaktikai annotációit vizsgálva észrevehetjük, hogy nem mindegyik egység kapott azonosítót (ID-t). A 2. ábra is látható (7. sor), hogy például a „minden” jelzői melléknév XML-elemének nincs ID-je, viszont

15



esetleg elképzelhető, hogy szükség lesz rá, hogy erre hivatkozzunk. Az előkészítés során új ID-k generálódnak az XML-fájlba, ami az első, nem generált ID-val rendelkező ős-node ID-ja + egy generált sorszám „anchestorID.g#” formában, ahol # a sorszám 1-től indulva a dokumentumban lineárisan. Erre a lépésre akkor van szükség, ha nem elégszünk meg a szószerkezetek megfelelő szintű kijelölésével, illetve ha még nem végeztünk eddig előkészítést egy adott XMLdokumentumon.

Harmadik (kötelező) lépés: Adatok betöltése (Load Data). A megnyitott XML-dokumentumban az összes szövegszó (amik eddig még nem említett módon, <w> határoló között jelennek meg) és írásjel ( határolók között) megjelenik a

panelon egyesével. A program szempontjából ezek Label objektumok lesznek, amihez lehet egérkattintás eseményt társítani, (lásd: a következő, Koreferenciák részben), illetve egy olyan eseménnyel is, ha a szó fölé visszük az egeret, a lenti státuszsávon megjelenik egy lista, amiben a szóhoz vagy írásjelhez tartozó összes ID szerepel.

4.5. Koreferenciák kezelése 4.5.1. Koreferencia kapcsolat létrehozása Egy bal és egy jobb egérkattintással kijelölünk a panelon egy-egy szót az antecedens és az anafora számára – ez aláhúzásként fog látszódni. Továbbá a kattintások hatására az ablak közepén a két listadobozban megjelenik egy-egy választási lista, ami a kattintott szóhoz tartozó néhány2 ID-t, majd az ID-nek megfelelő szintaktikai címkét3 (pl. „NP”), illetve az ID-hez tartozó teljes szöveget, azaz az összes szót jeleníti meg. Vagyis egy olyan lista jön létre, amiből pontosan kiválaszthatjuk a hierarchiából, hogy a szóhoz tartozó melyik szintet szeretnénk megjelölni antecedensként vagy anaforaként.

2

néhány: a dokumentum, illetve mondat szerkezeti hierarchiájához képest a legfelső valamennyi* szint kivételével az összes. *valamennyi: ez a mennyiség beállítható az ablak jobb fölső részén, alapértelmezésként 4, vagyis 3 szintet praktikus kihagyni, hiszen az az egész
cikket,
bekezdést, vagy <s> mondatot jelenti (a 4. szint ugyan CP, de az egész mondatot jelenti minden esetben). 3 ez a rész kimaradt a programból…

16



Nepszava.1.1.3.2.g12, ADJP: "hazai"______________. Nepszava.1.1.3.2, NP: "Egyes hazai szakértõk" Nepszava.1.1.3.1, CP: "Egyes hazai szakértõk attól ...

Ha választottunk mindkét listából, illetve jobb szélen a koreferencia típust is kiválasztottuk, akkor a [Make Ref!] gomb megnyomásával létrejön egy koreferencia kapcsolat – egyelőre csak a megjelenítő felületen. Ahhoz, hogy az XML-be is be legyen írva a koreferencia, el kell menteni a dokumentumot (File / Save menüpont vagy Ctrl + S vagy a mentés ikon). A panelban zöld színnel jelenik meg ekkor az antecedens, pirossal az anafora, XML-ben nem tárolt esetben vastag betűkkel, mentés után vékonnyal. A jobb alsó listadobozban pedig mentés szerint csoportosítva megtaláljuk a bejelölt koreferenciákat (lásd: 7. ábra).

7. ábra COREF program – bejelölt koreferenciák listázása

4.5.2. Koreferenciák szerkesztése (Edit mode): Az Edit menüből, vagy az eszközsorról, ill. az ablak közepéről ki és bekapcsolható a szerkesztési mód. Ekkor ki kell jelölni a lenti listából egy koreferenciát, amit szerkeszteni szeretnénk. A fenti választási listákba ekkor betöltődik a kijelölésnek megfelelő listaelem, illetve, ha a „Search

Possible

IDs”

jelölőnégyzetet korábban kipipáltuk, akkor meg is keresi a koreferenciában szereplő összes szóhoz tartozó összes ID-t, ami a beállított mélységbe beleesik, és mind

kilistázza.

Ha

ezt

választottuk,

akkor

innen

is,

vagy

újabb

egérkattintásokkal a panelen kijelölhetjük az új, módosított anaforánkat vagy antecedensünket, illetve a koreferenciatípust. Ha megfelelően kiválasztottuk, akkor egy csak edit módban megjelenő [Save] gomb megnyomásával tudjuk fixálni a koreferencia új értékét. XML-ben tárolt koreferenciák szerkesztésekor egy megerősítést kérő ablak ugrik föl, amit jóváhagyva törlődik az XML-ből az eltárolt koreferencia, és átkerül a nem tároltak közé, ahol újra szerkeszthető és elmentendő lesz…

17



4.5.3. Koreferenciák törlése (Delete mode): Az Edit menüből, vagy az eszközsorról, illetve az ablak közepéről ki és bekapcsolható a Törlési mód. Ekkor a lenti listában minden sor előtt megjelenik egy jelölőnégyzet, amikből tetszőleges számú törlésre szánt elemet kipipálhatunk (segíthet a kijelölés megfordítása (Invert), illetve az All/None kijelölési opció). A törlés végrehajtását egy csak ebben a módban megjelenő [Delete] gomb megnyomásával lehet elindítani. Az összes nem tárolt koreferencia egyből törlődik, a tároltak törlése előtt pedig egyenkénti megerősítést kér a program.

4.5.4. Multi-koreferencia Előfordulhat, hogy van egy olyan anafora, ami több antecedenssel is koreferál. Például ebben a szövegben: „Péter és János a film vége után hazamentek. Aznap mindketten későn feküdtek le.” A ’mindketten’ Péterre és Jánosra is vonatkozik, nekik pedig valószínűleg külön ID-jük van. Ekkor a ’mindketten’-hez tartozó „refid” attribútum szóközökkel tagolja az egyes ID-ket, és a „reftype” is hasonlóan. A program jól kezeli ezek után az adott koreferenciák szerkesztését és törlését is. Megjegyzés: ahhoz, hogy továbbra is érvényes legyen az XML, ezt a módosítást a DTD-ben is jelezni kell: a „refid” attribútum típusa tehát már nem „idref” lesz, hanem „idrefs”, azaz id-hivatkozás-tömb.

4.6. Zéró névmások beillesztése Ha az anafora vagy antecedens egy zérónévmás, vagyis a szövegben nem jelenik meg, szükségünk van a zéró elem

fölvételére

az

XML-be

és

a

megjelenítő felületre is. Erre, illetve zérónévmás

törlésére

szolgál

a

8. ábra: Zérónévmás beszúrása

18



programban a Zero Pronoun Mode, aminek bekapcsolásakor az összes ige és igenév (, , ) dőlt betűs lesz, kattintásukkor egy ablak ugrik elő4, amiben beírhatjuk a megfelelő esetű zérónévmást, illetve kiválaszthatjuk, hogy milyen szerepkörben kapcsolódik az igéhez vagy igenévhez (role). (Lásd: 8. ábra)

4.6.1. Automatikus zérónévmás-felismerés Ez a COREF 1 fejlesztése során nem valósult meg, viszont a következő tervem volt az algoritmusra. Létezik egy nagyméretű vonzatkeret-leírás adatbázis, amely a magyar nyelv legtöbb igéjét és igenevét tartalmazza, annotálva a kötelező és nem kötelező vonzataival. Példaként vegyük a Nepszava.1.1.1.18-as ID-jű CP-t: „nem újítja [ő] meg olajszállítási szerződéseit” (az „[ő]” eredetileg nincs a szövegen, de itt látni fogjuk, miért kell beszúrni). A tagmondatban egyetlen ige van, kikeressük tehát

vonzat-

keret leírásból a

„megújít”

VP=meg|újít:12093 HU.VP = SUBJ + TV(:lex="meg|újít") + OBJ(pos=N, case=ACC) ;ex-base: Vmi megújít vmit.

igét: Ebből azt tudjuk meg, hogy az igének két kötelező vonzata van: egy alany (SUBJ), ami mindig NOM esetű, illetve egy tárgy (OBJ), ami ACC esetben van. Majd megvizsgáljuk a korpuszunkban szereplő, az „újítja” igéhez tartozó annotációkat, és azt látjuk, hogy csak ACC vonzata van (lásd: CHILDREN/NODE-jai között): Mivel az ACC-on kívül egy NOM esetű vonzat is kötelező volt, ezért automatikusan bele kell tennünk egy alanyt, vagyis egy zérónévmást az ige mellé. A zérónévmás számát és személyét (jelenleg: egyes szám 3. személy, jelölve: „3s”) pedig az egyes elemzésekből (<mscat>) tudjuk kiolvasni, erre is vannak leírások (lásd: 1.3.1 részben – a megtalált névmás pedig az „ő” lesz). A megvalósítás elmaradt, helyette lásd a COREF 2 5.3.5.3. fejezetét.

4

Ha nincs a program futtatható exe-jének mappájában egy refroles.txt fájl, akkor kéri, hogy töltsük be.

19



9. ábra: Rejtett alanyú példamondat állítmánya a Szeged Treebank XML-jéből

4.7. Segédeszköz kereséshez Egy segédeszköz is készült a projekt mellé, amivel keresni tudunk ID-kben, illetve a szövegben. Ezt jelenleg a Tools / Show Analysis menüből vagy Ctrl + Hval vagy az IDs eszközsori gomb által tudjuk előhívni: (10. ábra: Segédeszköz kereséshez) Ebben

egyelőre

két

megjelenítési lehetőség van, az egyik egy IDlistát hoz ki, amiben lehet keresni egyrészt az ID-kben, másrészt pedig hozzájuk tartozó szövegben.

A

keresés

eredményét kijelöli, és jobb oldalt kilistázza a tartalmát.

20



A másik nézeti lehetőség az XML DOM (Document Object Model) megjelenítése fa formájában – ezt a második, „XML Tree” fülön lehet megnézni (lásd: 11. ábra). Az előző fülön („Find Text by ID”) utoljára kijelölt ID-kat fogja megtalálni a fában, ahogy fült váltunk, illetve az összes kijelöltnél expandálja (kiterjeszti) a fát. A [<>] gombbal (lásd bal alsó sarok) lehet váltani az előző listában utoljára kijelölt ID-k között, és a fában odaugrik a kijelölés.

11. ábra: XML fa szerkezet néző

4.8. COREF V1 kiértékelése Az alábbiakban azt foglalom össze, hogy a COREF első változatában mik azok a részfeladatok, amik még hiányoztak a feladatkiírás teljes megvalósításához. Továbbá azokat a megfontolásokat, hogy milyen lehetőségek álltak fenn a folytatáshoz.

4.8.1. Memória- és erőforrás-igények A COREF 1-ben sajnos még sok hiányosság maradt, illetve, nyilván, még lehetne az egyes algoritmusokat is optimalizálni (idő és/vagy erőforrás tekintetében).

21



Egy kis memória- és CPU-használati vizsgálatot is végeztem a COREF 1hez, illetve fejlesztés közben mindig figyeltem e rendszerparamétereket. A tapasztalat, hogy gyakran lehetne fölösleges memóriákat fölszabadítani. Például a cikkekre bontás nagy memória- és CPU-igényű, viszont a bontás közben lefoglalt memóriát csak jóval később végzi el automatikusan a C#.NET beépített Garbage Collectorja. Egy dokumentum betöltésekor pedig, ha nagyobb a cikk, egy időre meg is fagy a program, amíg be nem tölti az összeset. Így praktikus lenne egy háttérben futó szálra bízni az XML szavainak

betöltését,

amivel

próbálkoztam is, de nem sikerült.

4.8.2. Felhasználói igények Fontos, hogy a fejlesztő kapcsolatban legyen a felhasználókkal, hiszen nekik készül a program. Mi az, amit gyakrabban használnak, mi az, amit jobban szeretnének átlátni, mi az, amit pedig kevésbé. Hogy a fejlesztő jobban átlássa ezeket, sok tesztelésre, és visszajelzésre volna szükség. Egyáltalán, nem szakértőként, milyen elnevezéseket adjon az egyes gomboknak, milyen feliratok jelenjenek meg, stb. Mindezek viszont csak akkor derülnek ki, ha majd ténylegesen föl fogják használni a COREF valamelyik elkészült változatát…

4.8.3. Platformfüggetlen környezet igénye A .NET környezet Windowsban 3.5-ös verzióig létezik és ajánlott, Linuxon pedig már a 2.0-ás verziónál tartanak, viszont Macintosh és egyéb operációs rendszerekről pedig nem tudok, hogy létezne .NET megvalósítás. Nyilván, célunk az is, hogy bárki (erre jogosult), bárhol tudja használni programunkat. Mégis, a platformfüggőség ellenére, miért választottam a .NET-et? Miért nem JAVA-t vagy egyéb (kvázi-)platformfüggetlen programozási nyelvet? Rövid válaszom: mert a projekt elkezdésekor leginkább a .NET környezetben voltam járatos, illetve a Visual Studio adta fejlesztési lehetőségek nagyon megkönnyítik a programozás hatékonyságát, úgymond „fejlesztőbarát” program (például drag&drop elrendezési lehetőség, automatikus szöveg-kiegészítések, snippetek, beépített kezelők, stb.). Egyébként pedig még mindig a Windows a legelterjedtebb

22



operációs rendszer, ha valaki ezt használja, hozzá van szokva a windows-os programokhoz, ez a program is hasonlít azokhoz, lévén ugyanaz az eszköztára.

4.8.4. Hálózati környezet igénye A COREF 1 fejlesztése során nem jutottam el a hálózati környezet létrehozásáig. Ez úgy nézett volna ki, hogy lett volna egy bejelentkező felület, ahol mindjárt belépéskor ki tudja választani a felhasználó, hogy melyik dokumentumát szeretné használni. Ezt a dokumentumot ugyanis egy szerveren vagy adatbázisban kell tárolni, hogy bármikor, bárhonnan elérhető legyen, esetleg egy dokumentumon többen is tudjanak dolgozni egyszerre. Betöltve a többi lépés nagyjából ugyanígy történne, csak fájlba írás helyett mindig egy kliens-szerver üzenetváltás folyna, például egy-két SQL-utasítás, illetve szerver oldalon az XML módosítás ennek hatására. Továbbá az egyes felhasználók eltárolhatnák maguknak a kedvenc beállításaikat,

például a

kijelölések

színét,

betűtípusát,

stb.

Illetve

az

adminisztrátor felhasználóknak lehetősége lenne egyéb eszközökre is, például két különbözőképpen annotált, eredetileg azonos XML fájl összehasonlítására. A .NET környezet elsősorban a Microsoft SQLServer / SQLExpress adatbázis típust támogatja, illetve még ad lehetőséget Microsoft Access, Oracle vagy

OLE

DB

adatbázisoknak.

Viszont

nem

mindegyik

ingyenes

és

megvalósítható távoli hálózatban. Ezek közül talán az Oracle tűnik a „leghasználhatóbbnak”:

például

tudunk

vele

adatbázisban

tárolt

XML

objektumbeli keresésekre és módosításokra – viszont csak 4 GB méretig ingyenes (és van még egy-két további korlátozása). Ezeken túl használható MySQL és PostgreSQL adatbázis-plugin is .NET-ben, de ezzel az első tesztelés után nem foglalkoztam tovább… A COREF fejlesztésének folytatásakor ugyanezek a kérdések továbbra is fennálltak, tehát egy webszerver és egy adatbázis szerver hozzáférésre volna szükségünk, még akkor is, ha egész más környezetben folytatjuk a fejlesztést. Ez nem fejlesztői feladat, hanem utánajárás, szerver-tulajdonosok megkérdezése, hogy náluk milyen szerver-hozzáférésre volna lehetőség… A későbbiekben kitérek rá, hogy a COREF 2 során hogy sikerült egy ilyen lehetőséget szerezni.

23



4.8.5. Webes alkalmazás? Egy további platformfüggetlen megvalósítás volna egy webböngészős alkalmazás, vagyis a már jól bevált HTTP protokollt lehetne használni a kliensünk és a szerver között – hiszen böngésző minden operációs rendszeren létezik, és (kvázi-) ugyanúgy jelenítenek meg mindent (kivéve, amikor a böngészők egyes funkciói nem kompatibilisek egymással, lásd később…). Eleinte több okból is nem ennek a

lehetőségnek álltam neki, viszont a COREF 2 elkezdésekor mégis ez az irány győzött. A COREF 1 folytatásakor praktikus lehetett volna az ASP.NET környezetre való áttérés, hiszen szinte minden algoritmust egy az egyben át lehetett volna emelni a .NET-es programból, mivel az ASP is a C# (vagy Visual Basic) nyelvet használja webes megjelenítés (HTML) generálására. És nem kellett volna lemondanunk a fejlesztőbarát Visual Studióról sem, továbbá ASP-ben is nagyon könnyű az eseménykezelés. Egy régebbi, ám ingyenes, és könnyen hozzáférhető, illetve sokrétűen (pl. fórumokon is) dokumentált másik lehetőség volt a PHP a szerveroldali működés leprogramozásához. Viszont PHP-ban ez előttig nem voltam járatos – mégis emellett döntöttem, és elmélyedve a PHP rejtelmeiben, elkészült a COREF v2…

4.8.6. Szerver- és kliensoldali logika kérdése Bármilyen környezetet is alkalmazva át kell gondolni, hogy milyen eseményt, pl. kattintást hol kezeljünk le. Webes esetben azt a legegyszerűbb megvalósítani, hogy statikusan elküldjük a változásokat, amit a webszerver földolgoz, és visszaküldi a kliensnek (böngészőprogramnak) a változásokat. De, ugye, ez megterhelő, és néha lassú lenne, pláne, ha elakad út közben az adat. Például, ha egy szövegszó színét meg szeretnénk változtatni, akkor elküldenénk a szervernek, hogy ez a változtatás van, és a szerver visszaküldené az új HTML-kódot, amit generált, majd csak ez után fogadja a böngésző, és újra betöltve megjelenítené újra az oldalt.

24



Pont ezeknek a fölösleges információ-küldések és teljes újra kirajzolások elkerülésére találták ki a dinamikus HTML lehetőségeket, hiszen a HTML önmagában statikus, csak az oldal újra betöltésekor tud megváltozni a kinézete. Legkorábbi dinamikus böngészős lehetőség a JavaScript. Kicsit tekintsük át a böngészés folyamatát, hogy jobban átlássuk a lehetőségeinket! 1. A böngésző (kliens) elküldi az URL-t az esetleges rejtett „post” adatokkal egy HTTP-kérésben a szerver felé. 2. A szerver a kérést földolgozza („szerveroldali logika”): generál egy megjeleníthető HTML-kódot, 3. amit visszaküld. 4. Ezt a böngésző sorban kirajzolja. 4-5. A JavaScript szerepe ekkor lép érvénybe: betöltés/kirajzolás közben, illetve kirajzolás után még módosíthat a kirajzolandó HTML-elemeken – ezt hívjuk kliensoldali logikának. Mindezt az oldal újra betöltése nélkül, bizonyos események hatására teszi, pl. egérkattintás (onClick), az oldal betöltésének befejeződése (onLoad), stb. Szerveroldali logikával (pl. CGI, PHP, ASP függvények) a szervert dolgoztatjuk meg, és mindig kell egy üzenet-válasz leforgása; a kliensoldalon a böngésző dolgozik sokat a szerver tudta nélkül. Vagyis a JavaScript mindig egy kicsit megdolgoztatja a böngészőt. Nekünk viszont pont ilyenre van szükségünk, hiszen

ez tud egy interaktív szerkesztőfelületet biztosítani. Ha továbbmegyünk, és még inkább meg szeretnénk könnyíteni a felhasználók (jelen esetben a koreferencia annotáló nyelvészek) dolgát, és szeretnénk, hogy minél kevesebbet kelljen várakozni az oldal újra betöltésével (noha

manapság

már

adott

a

szélessávú

internet

szinte

mindenütt),

használhatjuk 2005 óta népszerű váló AJAX (Aszinkron JavaScript és XML) programozást, ami a JavaScriptnek egy speciális használata. Segítségével az oldalunkról a kívánt mértékű információt háttérben küldünk a szervernek, aki földolgozza azt és a lap újra kirajzolása nélkül küldi vissza a válaszinformációt, amit ekkor már a JavaScript tud földolgozni, például kiírhat egy válaszüzenetet, vagy egy adott részét akár újra ki is rajzolhatja az oldalnak. AJAX lehetőségei az ASP 2.0-nak is vannak, amik a Microsofttól megszokott módon kissé sajátosak – viszont nem jutottam el a komolyabb szintű megismeréséig.

25



Nemcsak webes fejlesztés esetén, hanem minden szerver-kliens applikáció esetén meg kell határoznunk, hogy szerkesztőprogramunk milyen változásait, eseményeit a szerver vagy a kliens hajtaná végre.

4.8.7. COREF v1 – összegzés A COREF, koreferencia-annotáló eszköz első változata csak helyi használatra alkalmas. Fejlesztésekor mindig a szemem előtt lebegett a felhasználóbarát személet. Javítani, szépíteni még sokat lehetne rajta. Részletesebb dokumentáció sem készült róla, ha igény lenne a COREF 1 továbbfejlesztésére, ekkor ez hátrány. Viszont hatalmas előnye az eszköz elkészítőjének számára, hogy elkészült, és sok kérdést már nem kell újra tisztázni a projekt igénylőjével. A COREF 2 elkészítése után jegyzem meg, hogy abból a szempontból is hasznos, hogy elkészült a COREF 1, hiszen a második verzió elsősorban a hálózati környezeti funkciókra helyezi a hangsúlyt, és így nem mindegyik „offlineszolgáltatása” készült el az eddigiekben. „Offline szolgáltatás”, részfeladat alatt olyan funkciókat érthetünk, amit egyszer kell elvégezni, és utána már nincs szükség, hogy többször is lefuttassuk. Ilyen pl. a cikkekre bontás, az előkészítés, zérónévmás-beillesztés.

26

5. Megvalósítás: „COREF 2”


5. MEGVALÓ SÍ T ÁS: „COREF V2”

12. ábra: COREF v2 szerkesztés közben A 2008/2009-es tanév második félévében folytattam az idáig bemutatott projektet, viszont sok megfontolás után fejlesztői környezetet váltottam. Részben a projekt igénylőjének

kérésére,

részben

pedig,

mert

könnyebben

megérthető,

újrafelhasználható és továbbfejleszthető egy webes alkalmazás, mint egy sajátos rendszert létrehozni… Viszont, ahogy a 4.8.5, és 4.8.6 fejezetekben is már fejtegettem, egy weblapot lehet számtalan féleképpen létrehozni, vagyis további megfontolásokra és döntésekre is szükség volt, mielőtt bele lehetne kezdeni a tényleges fejlesztésbe. Nem utolsó gond a szerver lehetőségének a kérdése, hiszen szerver tulajdonosoktól kell engedélyt kérni, mert nem minden embernek van saját szervere…

27



5.1. Környezet Lássuk, milyen eszközöktárból dolgozik a COREF 2. Mivel webes alkalmazás, HTML-ben fog megjelenni, de ezen felül igyekeztem megfelelni a W3C XHTML ajánlásának is. A kinézet könnyű szerkeszthetőségének érdekében CSS stíluslapokat használtam. Az interaktív lehetőségekért a JavaScript felel, ahogy már a fentebbiekben is említve volt. További interakciók könnyítése érdekében az AJAX-os eszközt is fölhasználtam. A feladatkiírásban is említve volt, hogy a szerkesztendő dokumentumok XML formátumban adottak, amikhez egy DTD sémadefiníciós fájl is adott, valamint az XML-dokumentumban való keresésekhez és módosításokhoz szükség van néhány XPath kifejezésre. Az XML-eket már szerver oldalon tárolom, mégpedig azt az utat választottam, hogy egy-egy adatbázis-rekordban. MySQL adatbázist használok, egy távoli Apache HTTP szerveren pedig PHP szkriptek állítják elő a megjelenítendő lapokat. A projekt használatához tehát semmilyen extra telepítésre nincs szükség, és bármilyen operációs rendszeren hozzáférhető, hiszen csak egy böngésző program szükséges hozzá, ami minden gépen van. A fejlesztéshez pedig mindenképpen szükség volt egy szerverre, de szerencsére léteznek helyi gépen futó szerverprogramok is, és még csak hálózat sem kell hozzá. Eleinte tehát az EasyPHP programot használtam, ami a PHPApache-MySQL hármast teszi lehetővé egy helyi gépen, a többi eszközt pedig a böngésző fel tudja dolgozni. A későbbiekben pedig kaptam egy ideiglenes hozzáférést egyetemünk egyik virtuális szerverén, így a munka immár bármikor elérhető a http://firefly.itk.ppke.hu/~gabrosz/coref/ címről. (Megjegyzem, hogy nem ez lesz a végleges helye a projektnek, egyelőre viszont szabadon használható a hozzáférés.)

Amint látható az eddigiekből, mindezek teljesen ingyenesen letölthető,

telepíthető, és korlátlan alkalmazások, és emiatt pont ezek a legelterjedtebbek is. Továbbá számos helyen elérhető mindenféle dokumentáció, tutorial, sőt fórumok is, amelyekből az egyes problémákra általában találhatunk megoldásokat is. Célunknak: a platformfüggetlenségnek is eleget tesz ez a rendszer. Egy ilyen

28



szerver beüzemelése is egyszerű, bejáratot rendszergazdai feladat, nem úgy, mint ha például Windows Servert kellene karban tartani – így esett ezekre a választás. A továbbiakban ismertetem az egyes felhasznált eszköztárakról megismert tudnivalókat – hiszen a projekt elkészítése során mindegyik tartalmazott számomra kisebb-nagyobb újdonságokat. (Nem szeretnék a részletekbe sem veszni, de amit érdekesnek tartok megemlíteni róluk, azt említem meg itt. A

Felhasznált/ajánlott web linkek fejezetben ajánlom a szabványleírásukat, illetve néhány jól használható tutorialt.)

5.1.1.

HTML, XHTML

(EXtensible) HyperText Markup Language. A HTML az internet szabványos jelölőnyelve. Míg legutóbbi változata, a 4.01-es közel 10 éves, az XML szabványra épülő XHTML 2000 óta versenyzik a HTML-lel. Másfél éve viszont már a HTML 5-ös már teljesen beépíthető az XHTML szabványba, azonosnak tekinthetjük az XHTML5-tel. Lényegében a HTML 4 szigorításaként indult az XHTML, például nincsenek kereszteződő tag-ek, kötelezőek az attribútum értékek is (pl. checked="checked"); valamint hogy ezek "…"-ben legyenek; minden tag-et le

kell zárni, pl. az üres elemeket is:
; a scripteket részek közé kell tenni, hogy helyesen kódolja az értelmező, illetve még számos apróság. Munkámban többnyire igyekeztem követni az XHTML előírásait, hiszen így illik egy komolyabb weblapot létrehozni, viszont a teljesség igénye nélkül tettem ezt, amit a jövőben pótolni fogok.

5.1.2. CSS Cascading Style Sheets. A HTML elemek megjelenését szabályozza, jóval egyszerűbbé teszi a formázások karbantartását. A 2.1-es verzió a támogatott, de a fejlesztés alatt álló 3-as verzió már működőképes több böngészőben is. Lehet konkrétan az egyes HTML elemekre, vagy attribútumaikra (id, class vagy bármelyik) szűkítve is stílust definiálni, illetve néhol az egér-eseményekre is

29



külön. A legnagyobb örömünkre működik a stílusöröklődés is, továbbá, egy stílust többször is lehet definiálni, illetve egy stílusdefiníciót egyszerre több feltételre (selector)

is

meg

lehet

adni

–

vagyis

ezek

révén

rendszerezni

lehet

stílusosztályainkat, ami az átláthatóságot növeli. Például a projektben az egyes szavakra hasznos volt külön stílusosztályokat definiálnom a zölddel, pirossal aláhúzott, vagy aláhúzatlan, továbbá alap vagy mentett és nem mentett bejelölt antecedensre és anaforára… Ha belegondolunk, ez 3x3x2-3=15 állapot, amit nehéz követni, hogy mikor mi van… CSS fájlomban így rendszereztem őket:

13. ábra: CSS példa - a szövegszavak állapot-osztályaira Ezekben

az

egyes

osztályok

a

„/w[BLR][BLR](ns)?/i”

reguláris

kifejezésnek felelnek meg, ahol B az alapbeállítást, R az antecedens/jobbklikk-, L pedig az anafora/balklikk-információra utal, mellette az „ns”, hogy elmentett állapotban van-e vagy sem a bejelölt koreferencia-elem (kivéve: nincs ez a három: „/wB[BRL]ns/i” stílus).

5.1.3. JavaScript A betöltött oldal dinamizmusáért felel, ahogy már említettem. Lényegében minden HTML elemet objektumként értelmez, és egy fa hierarchiába rendez, amit HTML DOM-nak (Document Object Model) hívnak. Itt a „document” a gyökérelem, és minden XML-szerűen fölépített elem, illetve attribútum vagy szöveges érték elérhető a fa bejárásával. Ha az elemnek van „id” attribútuma, akkor

még

egyszerűbben,

a

document.getElementById("id1")

elemhivatkozással is elérhető (lásd: 14. ábra: HTML DOM – JavaScript ). A szülő, gyerekek, csomópont neve, attribútumok, stb. tulajdonságokat mindegyik HTML elemről el tudjuk érni, (pl. a node.childNodes: a node gyerek node-jainak objektum tömbjét adja vissza). Továbbá minden node elemhez hozzáadja a HTML elem tulajdonságait, eseményeit, (pl. színét, stb.), amit könnyedén le lehet

30



kérdezni,

illetve

megváltoztatni.

Pl.:

a

document.getElementsByTagName("span").item(2).style.color="blue";

parancs az oldalon szereplő 3. <span> elem szövegszínét kékké teszi. Lényegében így

tudjuk

átrajzolni

az

oldalunk

bármelyik

elemét,

vagy

a

szövegét

megváltoztatni – mindezeket pedig eseményekhez köthetjük, függvényben megírhatjuk,

pl.:

a

scriptfájlban:

elem.parentNode.removeChild(elem);

function }

illetve

close(elem)

a

{

HTML-oldalon:

<span onClick = "close(this)">eltűnök.

A HTML DOM tehát egy weblap elemeit teljesen objektumorientáltan kezeli. Továbbá definiál egyéb objektumokat, mint például a Document, Location, History, Navigator, stb., illetve a fontosabb elemekre, mint például az űrlapok részeire külön elérést is biztosít, pl. document.forms[0].elements[3].value az első űrlap 4. elemének értékét adja vissza.

14. ábra: HTML DOM – JavaScript Meg kell említenünk, hogy a JavaScript motort nem mindegyik böngésző valósítja meg ugyanúgy, nem csak a verzió támogatottságban (pl. Firefox.3: js1.8; Chrome.1, Safari.4: js1.7; Opera.9: js1.5, IE.6: js1.56, IE8: js1.6) , de néha a JavaScript kódok futásában is eltéréseket tapasztalhatunk. Illetve van néhány olyan dolog, amivel például az Internet Explorer kiegészíti a JavaScript-tárát, és a többi böngészőben nem fut, de ugyanígy vannak a többi böngészőre jellemző sajátosságok is. Jó példák erre az egérkattintás eseményei: egyrészt, az egérgomb lekérdezés is különbözik, másrészt egyes böngészők extra-eseményeket rendelnek pl. a jobbklikkhez, vagy a duplaklikkhez, aztán dupla kattintás során valahol nem váltódik ki az egérgomb fölengedés esemény, míg másutt igen (lásd: irodalom)

31



A projekt fejlesztése során igyekeztem, hogy mind az öt (windows-os) böngészőnél működjön a program, de egy idő után az Internet Explorerről és az Operáról le kellett mondanom… Tapasztalataim alapján a Google Chrome-ot találtam a leghasználhatóbb böngészőnek (persze ennek is sok gyöngéje van), talán azért mert sok olyan eseményre, vagy elérésre is lehetőséget ad, amit a Firefox nem támogat, de például az Internet Explorer bevezetett. Ilyen például egy HTML elem .outerHTML tulajdonsága, vagy az .innerText, ami Firefoxnál .textContent, és kicsit mást jelent…

5.1.4. AJAX, JQuery Asynchronous JavaScript and XML. Az AJAX-ról már említettem, hogy tulajdonképpen ez is csak egy JavaScript függvénytár, aminek speciális használata, hogy az oldal újra betöltése nélkül elküld egy HTTP-kérést a szervernek, és a visszakapott választ földolgozza, akárcsak egy eseményt. Az AJAX 2004-től jutott be a köztudatba a Google Suggest révén, amikor egy kereső mezőbe betűket beírva megjelennek a beírt karakterektől függő keresési javaslatok. Az AJAX alapötlete, hogy egy JavaScript-kódrész az XMLHttpRequest objektum segítségével (aszinkron) kapcsolatba lép a szerverrel, elküld egy kérést, és visszaérkezik egy kis szerver-oldali logika után a válasz, amit aztán föl lehet dolgozni. Tulajdonképpen így el lehet rejteni algoritmusainkat is, mivel nem JavaScriptben, hanem szerveren futtatjuk. Azóta többféle, AJAX-támogatást nyújtó JavaScript könyvtár (azaz függvénycsomag) is született, mint például a JQuery vagy a Prototype, illetve fejlesztő környezeteket egészítettek ki AJAX-elven, így a Ruby on Rails vagy a Google Web Toolkit. A projektben is használtam (eddig) két helyen AJAX-ot. Megvalósítottam, hogy a háttérben is el tudja menteni az oldalon történt változásokat, illetve az XML dokumentum fájlként való letöltésekor (exportálásakor) is a háttérben olvassa ki az adatbázisból a legutóbb elmentett XML dokumentumot, amit föltesz egy ideiglenes mappába a szerveren, és az elérési útját visszaküldi a böngészőnek, ahol egy script megjeleníti a letöltés gomb alatt a megfelelő linket. Mindezt a JQuery könyvtár segítéségével oldottam meg: le kellett tölteni a

32



http://jquery.com/ oldalról a jquery.js fájlt, belinkelni a HTML-ünkbe, és máris meghívhattuk

a

$.post(

URL,

JSONdata,

function(data)

{

dataHandler(data); } ); metódust, ahol az URL a szerveroldali kezelő fájl

elérési útja; a JSONdata egy JSON objektum (lásd: JSON fejezet), ami tartalmazza a küldendő név:érték párokat; a függvényen belül megadott dataHandler(data) pedig a data sztringben visszaérkező választ dolgozza föl,

feltéve, ha ezt a függvény létezik a szkriptjeim között.

5.1.5. JSON JavaScript Object Notation. Ez egy általános adatszerkezet jelölés, amit kiértékelve a fordítóprogram létre tud hozni egy bármilyen komplex objektumot. Számos programozási nyelvre létezik megvalósítása. JavaScriptben például így néz ki: json={"nev1": [ {"tomb11": "ertek11", "tomb12": "ertek12" }, {"tomb21": "ertek21", "tomb22": "ertek22" } ], "nev2": "ertek2" };

Egy ilyen adatszerkezetben küldöm el háttérben mentéskor az űrlap összes mezőjét, illetve azokat a változásokat, amik a szerkesztés eredményei.

5.1.6. XML, XPath, DTD EXtensible Markup Language. Egy nagyon hasznos és elterjedt, hierarchikus információkat tárolni képes jelölő nyelv. Szinte az összes programozási nyelv támogatja a benne való keresést (például XPath-szal), illetve a bejárását. Mindezeket az algoritmusokat megkönnyíti, ha megadunk hozzá egy DTD (Document Type Definiton), vagy egy XSD (XML Schema Definiton) fájlt, ami az XML-ben használt lehetséges tag-ek és attribútumok típusait írja le. Adott volt, hogy XML-t kell földolgoznom: megjeleníteni, illetve módosítani kellett. Kliens oldalon a JavaScript is fel tud dolgozni XML-t, az XHTML akár maga is lehetne az XML tartalmilag (és akkor egy XSLT stíluslap transzformáció segítségével konvertálhatnánk megjeleníthető formában), de szerveroldalon a PHP is ugyanúgy kezelni tudja az XML-t, sőt, ahogy már tettem rá utalást, az Oracle adatbázis már azt is lehetővé teszi, hogy egy XMLType típusú objektumként tároljunk XML-t, és benne lekérdezéseket (XQuery-ket) hajtsunk

33



végre. Vajon melyik szinten volna optimális az XML feldolgozása ebben a projektben?

5.1.7. PHP Hypertext Processor. Ingyenessége, dokumentáltsága, és egyszerű használata miatt talán a legelterjedtebb szerveroldali szkriptnyelv. Az első szerveroldali programozási lehetőség, a CGI-ben használatos Perl nyelvből, és a szintén népszerű

C

nyelvből

kölcsönzi

nyelvi

eszköztára

nagyját.

Számtalan

megvalósított függvénye van, sokszor ugyanarra a jelenségre több függvény is használható. Objektumokat itt is lehet létrehozni, de jóval kevésbé objektumorientált, mint mondjuk a JavaScript. 1995-től létezik, és egy hónapja jelent meg az 5.3-as verzió. A projektben pedig legalább az 5.2-esre van szükség (ami már csaknem 3 éves), mivel az XML kezelését a PHP-ra bíztam, és van néhány olyan XML-kezelő függvény, ami csak az 5.2-es változattól kezdve érhető el.

5.1.8. MySQL Ingyenes, elterjedt, viszont nem túl fejlett, de az alapvető funkciókat biztonsággal ellátó adatbázis-kezelő rendszer. Ebből is az 5. főverzió fut. Több táblát is létre kell hozni a projekt adatbázisához, egyeseket össze is kell kapcsolni, amit a FOREIGN KEY hivatkozással lehetne megoldani. Ezt a parancsot be is írtam a MySQL-nek, és nem is írt ki rá hibát, viszont semmi jelét nem láttam, hogy ez funkcionális volna… Ugyanis a MySQL alapból nem támogatja ezt a funkciót, csak ha kiegészítjük az ún. InnoDB-vel. Ebbe nem mentem bele, mert annyira nem lényeges eleme a projektnek, viszont a későbbiekben lehetne az adatbázist ezzel is följavítani. (Az adatbázisom fölépítéséről később írok.)

5.2. Lehetőségek megvalósításra A COREF 1 program .NET-ben íródott, ami sok szempontból nem volt megfelelő – például telepíteni kell hozzá, és még csak nem is platformfüggetlen. Ezért kellett koncepciót váltani, és egy olyan, még mindig felhasználóbarát környezetben

34



dolgozni tovább, ami a legegyszerűbben követhető, javítható, illetve mindezek mellett még ingyenes és platformfüggetlen is. Eldőlt, hogy egy webes alkalmazás lesz erre a legalkalmasabb. Ám ekkor is még sok nyitott kérdés állt előttünk. A Microsoft ASP.NET-es webtechnikák nagyon vonzóak voltak, de mivel nem ingyenes, és Windows Servert sem sikerült időben beszerezni, a hagyományos, de annál robosztusabb PHP felé kellett fordulni. Még mindig kérdés az adatbázis lehetőség, hiszen az Oracle elég vonzó, és az XML-feldolgozási lehetőségét is kínálja, viszont csak 4 GB adatbázis méretig ingyenes. Ezzel szemben nekünk rengeteg adatra, XML-dokumentumra van szükség, azoknak is különböző változataira, amiket ha adatbázisban akarunk tárolni, jelentősen felduzzasztja az adatbázis méretét. Lényegében emiatt és az EasyPHP minden gond nélküli föltelepíthetősége miatt a későbbiekben már elvetettem minden Oracle-ös gondolatot, noha hozzá képest a MySQL gyakran igen primitív (lásd: foreign key-ek)… Most már csak az a két kérdésünk maradt, hogy hol tároljuk a szerkesztendő és szerkesztett XML dokumentumokat, illetve, hogy a projekt mely funkcióit lássa el a szerver-, és melyeket a kliensoldal. Ha a kliensoldalon akarnánk tárolni az XML-t, amit a JavaScript dolgozna föl, mindig föl és le kellene töltögetni a fájlokat (feltéve, ha magunk között közzé akarjuk tenni), ami minden alkalommal kicsit elavult érzéseket kelt…

Szerveroldalon pedig két

lehetőség adódik: a szerver fájlrendszerében, illetve az adatbázisban tárolni az

XML-jeinket. Talán a levédhetőség és az adatok integritása helyezi mérlegre a nagyobb súlyokat az adatbázis oldalára. Pláne, ha verziókat is követni kell, sokkal egyszerűbb minden XML-lel kapcsolatos információt az adatbázisban tárolni. Tehát, miután a felhasználó bejelentkezett, kiválaszthatja a szerkeszteni kívánt XML dokumentumot, amit kiolvas az adatbázisból a PHP, megkeresi azonosítókkal a szavakat és írásjeleket, amiket lineárisan megjelenít, elküld a kliensnek, ahol kattintgatással összegyűlik egy változtatni-való-lista, amit a dokumentum mentésekor az adatbázisban frissítünk. Praktikus tehát a

35



felhasználó minden módosítási szándékát egy listában összegyűjteni, és csak ezt a listát visszaküldeni a szervernek, amikor menteni szeretnénk. Az XML-ből HTML generálás talán a leghosszabb feladat, ezek mennyiségét is lehet csökkenteni néhány AJAX-os mentéssel. Elénk tárult egy újabb kérdés is: hiszen a PHP az XML dokumentumok kezelésére számos megvalósítást nyújt. Vajon melyiket praktikus használni? Mik ezek a lehetőségek? Egyik a DOM (DOMNode és belőle származtatható elemek, a megfelelő bejáró és lekérdező függvényekkel), egy másik a SimpleXML (tényleg egyszerű,

létrehozzuk

a

SimpleXMLElement

gyökérelemet

és

objektum-

orientáltan bejárhatjuk az egész XML-t, módosítani is tudunk), XML Parser (ez kicsit bonyolultabbnak tűnik, régebbi megvalósítás), illetve az XMLReader és

XMLWriter osztályok (melyekkel a lineáris bejárás és módosítás oldható meg). Munkámban a SimpleXML-t választottam, és ez pont elég is volt a teendőkhöz, nem volt szükség a bonyolításra.

5.3. A megvalósítás Jelenlegi

változat

tehát

a

http://firefly.itk.ppke.hu/~gabrosz/coref/

oldalon

tekinthető meg (egyelőre). Lássuk, hogy mire ad lehetőséget ez a program! (Alapvetően megjegyzem, hogy mivel még nem indult be a projekt, amiben ez az eszköz föl lesz használva, sok helyen még nincs leszögezve a konkrét felhasználói igény, ami miatt a jelen, beadott weblapon több helyen hiányosságok fordulnak elő, vagy a későbbiekben megváltozhat egy-két funkció…)

5.3.1. Felhasználók, jogosultságok Egy szokásos „loginbox” teszi lehetővé, hogy be tudjunk jelentkezni az oldalra (Login), vagy ha még nincs felhasználói fiókunk, hozzunk létre egyet (Register). Ha pedig elfelejtettük bejelentkező jelszavunkat, lehessen valahogy emlékeztetőt kérni, vagy új jelszót generáltatni.

15. ábra: Loginbox - be/kijelentkeztető doboz: a túloldalon

36



Négy (plusz egy) féle felhasználói szintet definiáltam: az adminisztrátor (admin), a főnök (manager), a sima felhasználó (user), és a vendég (guest), illetve be

nem

jelentkezettek

jogosultságaik

vannak,

(not-logged-in). amiket

az

Mindegyik adatbázisból

szintnek

különböző

szabályozhatunk:

engedélyezhetünk és tilthatunk bizonyos szerepköröknek egy-egy funkciót, azaz egy-egy oldal megtekintését. Minden oldal betöltésének az elején egy szkript ellenőrzi az adott felhasználó jogosultságait, és csak akkor engedi tovább, ha van joga megnézni az adott oldalt, egyébként megjelenik a loginbox. (Ezt az opciót az oldal php scriptjének elejére beírt $noVisibilityCheck = true; parancs tiltja le.) Bejelentkezéskor létrejön egy session (munkamenet), ami addig fennáll, amíg a felhasználó ki nem jelentkezik, vagy be nem zárja a böngészőt. Így a „isset($_SESSION['user_uid'])” PHP parancs mindig megmondja, hogy bejelentkezett-e már a felhasználó, és az azonosítója is innen kérhető le. Egyelőre nem titkosított csatornán keresztül történik a bejelentkezés, de a későbbiek folyamán, ha erre lesz igény, hozzátehető a projekthez.

5.3.2. Az adatbázis A projekt adatbázis tábláiról és attribútumairól lásd az egyed-kapcsolat diagramját a 16. ábra. Még igény szerint bővíthető tulajdonságokkal, például, ha majd a felhasználó testre fogja tudni szabni, hogy milyen megjelenésű, nyelvű, stb. legyen a saját oldala. A jelszó ellenőrzése a PASSWORD('***') MySQL függvénnyel történik, ami tapasztalataim szerint MySQL verziónként különbözik, ugyanis amikor a felhasználói adatokat átmásoltam a saját gépemen futó EasyPHP-s adatbázisból a webszerveren futó adatbázisba, ott már nem fogadta el a megfelelő jelszót bejelentkezéskor… Ha ott újra regisztráltam, és megnéztem a kódolt jelszót, egészen más kódolt sztringet kaptam. Hogy ne legyen ebből gond, tesztelési időre megelégedtem azzal, hogy a felhasználói adatok webes adatbázisba másolása után lefuttattam az „UPDATE PASSWORD(ùName`);”

ùser`

SET

ùPwd`

=

SQL-parancsot, amivel minden felhasználó megkapta a saját

felhasználónevét jelszóul. De a későbbiekben lehet még módosítani, általánosítani a jelszó ellenőrzésen.

37



16. ábra: A COREF v2 adatbázisának EK-diagramja

5.3.3. Menüpontok A menüpontok listázására egy külön modult fejlesztettem ki, hogy a felhasználó jogosultságainak megfelelő menüsort adjon neki (e jogosultságok az adatbázis

Rights táblájában adminisztrálhatók, a menü feliratok pedig a Pages táblában). Kijelentkezve (nli, not-logged-in) csak a bejelentkezéssel kapcsolatos menük jelennek meg, illetve a nyitólap és a súgó menü. A vendég felhasználó (guest) meg tudja nézni a saját felhasználói adatait, de még nem tudja szerkeszteni. És tud néhány „demo” XML dokumentumot szerkeszteni is, amit nem tud elmenteni. Egy jóváhagyott felhasználó (user) már tudja szerkeszteni saját adatait, tud saját verziókat létrehozni és elmenteni XML dokumentumokból (a CanEdit adatbázis táblában leírtaknak megfelelően), fel tud tölteni XML-fájlt, (és jelenleg még elérhető neki a zérónévmások automatikus fölismeréséhez szükséges listát generáló oldal is, de ez a funkció még változni fog, lásd később) .

Egy manager szerepkörű felhasználó ezeken túl tud törölni XMLdokumentumokat, össze tudja hasonlítani egy dokumentum többféle szerkesztett változatát, és meg tudja tekinteni az oldalakat „user”-, illetve „guest”-nézetben is.

38



Az admin felhasználó pedig mindezeken túl képes szerkeszteni az egyes felhasználók adatait, vissza tudja állítani a(z ideiglenesen) letörölt XMLdokumentumokat, vagy véglegesíteni tudja a törlést. Mindegyik felhasználó számára elérhető a Help menü, amire kattintva az előzőleg betöltött oldalhoz tartozó súgó menü jelenik meg, aminek az információi a Pages adatbázis táblából olvashatóak ki.

5.3.4. XML szerkesztése Tulajdonképpen ez az a rész, ami már a COREF 1-ben is elkészült, az eddigi menüpontok a hálózati környezet megvalósításáról szóltak.

5.3.4.1. XML-dokumentum kiválasztása (Choose XML) Ezen az oldalon (view.php) megjelenik egy lista, ami az eddig létrehozott dokumentumok alap információit hordozza, vagyis a dokumentum azonosítóját, címét,

verzióját,

létrehozóját,

utolsó

mentését,

és

a

megjegyzését.

Ha

választottunk a listából (dupla kattintással, vagy kijelölve, és alul a jóváhagyó gombra kattintva), akkor fog betöltődni a megadott XML-dokumentum az adatbázisból.

5.3.4.2. XML beolvasása Röviden a szerveroldali algoritmusról, ami az XML-ből beolvasott szöveget megjeleníthető formába generálja: az "//w|//c|//p" XPath kifejezéssel a $wcp változóba mentjük az összes <w> szó vagy írásjel vagy
bekezdés nodeokat az XML-ből, amin sorban végigmegyünk. Ha
a node, akkor új bekezdést szúrunk

be,

ha

,

akkor

kiírjuk

a

whitespace-ektől

megtisztított

szövegtartalmát, ha pedig <w>, akkor generálunk neki egy <span>-t a megfelelő attribútumokkal és eseménykezelőkkel, valamint ezen belül egy nem túl szabályos elemet egy elemlistával, amely listában az adott node minden ős-ID-jét és az ő szintaktikai csoportját jelenítjük meg. Az egyszerűsített PHP-kódrész és egy generált HTML-rész megtekinthető az alábbi szövegdobozban:

39



$x = 0; $data = array(); $wcp = $body->xpath("//w | //c | //p"); while(list( , $node) = each($wcp)) { if ($node->getName()=="p") // data[$x] =
else if ($node->getName()=="w") { // az id-k, aid-ek, class és title attribútumok kikövetkeztetése //<span class="w..." id="" onMouseUp="" onMouseOver="" onMouseOut="" title=""> //... } else if ($node->getName()=="c") $data[$x] = trim($node); $x++; } for ($z=2; $z
<span class="wRB" id="Nepszava.1.1.2.2.g6" onMouseUp="wMouseClick('Nepszava.1.1.2.2.g6', 'NP', event)" onMouseOver="wMouseIn('Nepszava.1.1.2.2.g6', 'NP')" onMouseOut="wMouseOut(this)" title="Nepszava.1.1.2.2.g6 referencing to: Nepszava.1.1.1.15 (REPEATED) Nepszava.1.1.2.2 Nepszava.1.1.2.1 Nepszava.1.1.2 Nepszava.1.1 Nepszava.1">ország
/>

5.3.4.3. XML-dokumentum szerkesztése (Edit XML) Tulajdonképpen ez a leginteraktívabb felület, és a lehető legnagyobb mértékben igyekeztem a COREF 1-hez hasonló mintájú és logikájú szerkesztési lehetőségeket támogatni. Nézzük egy kicsit részletesebben. Egy böngésző információ jelenik meg fölül, ami megmondja, hogy mennyire van támogatva az a böngésző, amivel éppen megjelenítjük a lapot.

40



Baloldalon

a

szópanel jelenik meg, jobboldalon menü

pedig

a

lehetőségek,

illetve alatta a választó listák,

amiből

majd

koreferenciakapcsolatokat létrehozni.

lehet (A

későbbiekre van egy új terv a kinézetre, így módosulni fog az itt leírt elrendezés.) Antecedensnek és

anaforának bal, illetve jobb kattintással lehet megjelölni egy adott szószerkezetet, amik

zöld,

illetve

piros

aláhúzással jelennek meg, és a

jobb

oldali

listákból lesznek

választó

módosíthatóak a

szószerkezetek

egyes szintjei. A zöld, piros és

kék

beállítása

választó

listák

után

[Make

a

CoRef!]

gomb

megnyomásával

lehet

fölvenni a koreferenciát, ám ekkor

még

ideiglenes, formában

csak

nem jön

az

mentett

létre

(vastag

betűs).

A

szópanelon

történő

egér-mozgás

következtében különböző helyeken megjelennek információk az adott szóról, illetve,

ha

van

koreferencia-kapcsolata, akkor kap egy háttérszínt is, ami megkönnyíti az átláthatóságot.

41



5.3.4.4. Koreferenciák törlése

Alul egy táblázat foglalja össze a dokumentumban eddig elmentett vagy még el nem mentett koreferencia kapcsolatokat – ez az információ mindig követi a kattintásokat, tehát egy nagyon dinamikus rész. Ha itt rákattintunk az egyik sorra, fölugrik a megfelelő bekezdéshez a szövegpanelon, és megvilágítja a kattintott koreferencia antecedensét és anaforáját. Továbbá ekkor visszatöltődik a listázó felületekbe is a koreferencia-kapcsolat információja. Ilyenkor lehet

eltávolítani egy koreferenciát, amikor így ki lett jelölve – ha a listázó felület alatti „Remove Coref if exists” szövegre kattintunk. Nem mentett koreferenciát azonnal

eltávolítja,

koreferenciát

a

mentett

dokumentum

mentésekor. Továbbá törölni úgy is lehet, ha az alsó összesítő táblázat

első

előhívjuk

a

oszlopából

jelölőnégyzeteket,

kijelölünk néhány sort, és a jobb szélen megjelenő [Remove All Checked] gombra kattintunk.

5.3.4.5. XML mentése, exportálása Az XML-szerkesztő oldal jobb fölső

mezőjét

megtekintve

láthatjuk a dokumentum címét,

42



verzióját, szerzőjét, és a hozzá fűzött megjegyzést. Ezekből, ami szerkeszthető információ, azt a feliratokra kattintva szerkeszteni tudjuk: egy-egy szövegdoboz jelenik meg a felirat mögött, amiből eltávolítva a fókuszt visszaalakul a megfelelő szövegű felirattá. Ekkor viszont még nincs elmentve a megváltoztatott cím. Oldalt a [Save

XML]

gomb fogja a mentést elindítani, amivel

alapértelmezésben újra be fog töltődni az oldal. Ha viszont kipipáljuk az alatta lévő „in

background” feliratú jelölőnégyzetet, és így

próbálunk menteni, akkor egy AJAX-kéréssel a háttérben fogja az oldalt elmenteni,

aminek

a

sikeréről

kiír

egy

üzenetet

az

oldal

tetején.

Ha le akarjuk tölteni a mentett XML-t, a [Download

XML]

megnyomásával

az

alatta

lévő

szövegmezőbe beírt fájlnevű fájlt fog generálni szintén egy AJAX-kérés a háttérben a szerveren, aminek a linkjét a szövegmező helyett jeleníti meg – ezt jobbklikkel tudjuk lementeni magunknak, bal klikkel pedig töröljük az ideiglenesen generált fájlt. Ha pedig zavarna ez a menü-mező nagy térfoglalása, kattintsunk a jobb fölső sarokban lévő [^] ikonra, és fölgördül a doboz egy csíkká, amit ugyanúgy visszagördíthetünk a [v] ikon segítségével.

5.3.5. Offline részfeladatok Azokat nevezhetjük „offline” feladatnak, amiket egyszer kell végrehajtani a Szeged Treebank földolgozása során, és utána már nem fog kelleni ezeket a újra elővenni.

43



5.3.5.1. Cikkekre bontás A COREF 2-höz eddig még nem készült el a cikkekre bontás, viszont ez elérhető a COREF 1-ből is, ami ott helyesen működik. Talán emiatt nincs is szükség a COREF 2-ben rá. Sőt, a 4.3.1. fejezetben olvashatóan egy Python-script is megteszi ugyanezt.

5.3.5.2. Betöltés előtti előkészítés A COREF 2-höz eddig még nem készült el a betöltés előtti előkészítés (a feladat ismertetését, értelmét lásd a 4.4. fejezetben). Viszont a COREF 1-ben ez is elérhető. Noha nem hajtható végre tömegesen sok fájlra az előkészítés, de helyesen működik. A későbbiekben lehet, hogy bekerül a COREF 2-ben is, vagy legalább egy tömegesen elvégezhető változat a COREF 1-ben.

5.3.5.3. Zérónévmások automatikus beszúrása Az előzetes terveket lásd a COREF 1-nél, a 4.6.1. Automatikus zérónévmás-

felismerés fejezetben. Ez annyiban módosult, hogy a MorphoLogic cégnél elkészült egy program, ami alapvetően gépi fordítást végez, és kiegészült nemrég egy zéró elemeket fölismerő modullal is. Vagyis meg kell neki adni egy mondatot, amit ő lefordít, és a végére kiírja a zéró elemeket. Ha tehát tagmondatokra („CP”-kre) lebontom a szintaktikailag elemzett XML-eimet, és ezeket kigyűjtöm egy fájlban soronként, akkor az említett program elvégzi minden sorra a fordítást, és visszaadja a hiányzó elemet, annak mondattani esetével (NOM, ACC). Ezt a visszakapott információt aztán én tovább földolgozhatom hasonlóan, mint ahogy a 4.6.1. fejezetben terveztem, vagyis megnézve a tagmondat állítmányának számát és személyét, beszúrom mögé a megfelelő számú és személyű, illetve esetű személyes névmást. Egyelőre erről még nem érkeztek meg a tagmondatok fordításai a zéró elemekkel, így csak a tagmondatok generálását oldja meg a projekt „Zero Pronouns” menüpontja. De mivel ez is „offline szolgáltatás”, a későbbiekben

módosulhat a funkciója.

44



5.3.6. Kódolás Mivel a PHP-ben használt XML-kezelő SimpleXML kiterjesztés az UTF-8-as kódolást preferálja, és az adatbázis „illesztésének”, vagyis mezőinek kódolásának lehetőségei közül is az utf8_hungarian_ci van elsősorban támogatva, eleinte fontosnak tartottam, hogy ezt kövessem, hogy ne legyen semmi kódolásbeli gond. Viszont a megadott Szeged Treebank XML-ei Latin 2-es (ISO-8859-2) karakterkészletet használnak, ami ezzel ellenkezik, de sikerült megoldanom, hogy a kellő időben a kellő konverziók (utf8_encode, utf8_decode) végrehajtódjanak, és így visszakapjuk a megfelelő kódolású szövegeket. A HTML-lap kódolása is mindig UTF-8-as a fent említett okok miatt. Mivel

a

forráskód-szerkesztő

programok

alapértelmezésként

ANSII

szövegfájlokat hoznak létre, szükséges minden új weblap-fájlunkat BOM nélküli UTF-8-as kódolásra konvertálni. (BOM: a szövegfájl elejére beilleszti egy Byte Order Mark-ot, ami bizonyos helyeken szükséges, viszont a PHP nem tudja értelmezni, ezért e nélkülivé kell átalakítanunk a szövegfájljainkat…) A későbbiekben lehetne egyszerűsíteni a felhasznált kódolásokon.

5.4. Böngésző sajátosságok és megoldások Ebben a fejezetben az általam használt böngészők megismert és figyelemre méltó sajátosságait,

eltéréseit

foglalom

össze,

illetve

az

ezekre

talált

(pót-)

megoldásokra is kitérek. Ezek hasznosak lehetnek azok számára, akik még nem találkoztak a böngészők számtalan inkompatibilitásával… Az általam használt, tesztelt böngészők: Microsoft Internet Explorer 8.0, Opera 9.64, Mozilla Firefox

3.0.10, Google Chrome 2.0.172, Apple Safari 5.28. Linuxon és Macintoshon még nem teszteltem, de mivel a Firefox, Opera és Safari platformfüggetlen, vélhetően ott is működni fog a weblap. A fejlesztés során elhagytam az Internet Explorer és az Opera támogatását, mivel ezek eléggé különböznek a Netscape-böngészőktől. Internet Explorerben, egy JavaScript fájlban a globális változókat nem tudom simán elérni, mindig meg kell adni, hogy window.GlobalVariable. A statikus vagy beépített változókat/objektumokat, mint pl. az „event”, ha átadjuk

45



egy függvénynek, aminek a paraméterei között megadjuk a neki megfelelő változót, pl. function handler(e) { e.which; event.button; }, akkor a függvényen belül Chrome-mal megérti, ha event-ként hivatkozok az eseményre, a Firefox viszont nem ismeri az event helyi változót. Az egérkattintás eseménykezelésére praktikus egy böngészőfüggetlen függvényt megírni, hiszen minden böngésző máshogy kéri le a gombokat:

17. ábra: Böngészőfüggetlen eseménykezelő függvény a kattintó egérgomb lekérdezésére Az Operában fontos motívum a helyi tartalom szerinti jobbklikk-menü lehetősége. Ezért az egér-jobbklikk hatását, illetve egy szöveg kijelölését sehogy nem lehet letiltani JavaScripttel, amit másutt az oncontextmenu="return false"

illetve

az

attribútummal

onselectstart="return

tudnánk

false"

elérni.

opera:config#UserPrefs|AllowContextMenus, opera:config#System|DisableTextSelect

beállítási

eseménykezelő

Ezeket

az

illetve

az

oldalakon

tudjuk

globálisan engedélyezni vagy letiltani. Továbbá, a bal-duplaklikk hatására egy másik helyi menü jön elő, amit szintén nem lehet letiltani, csak a haladó beállítások eszköztárak menüjében… Még nem jutottam a megvalósításáig, de ötletként fölmerült, hogy az egér eseményeinek általános, dokumentum-szintű kezelésekor lehetne a jobbklikk-helyi menü tiltást beszúrni. Hasonlóan Firefoxban és Safariban nem lehet a letiltani egy weblap vagy egy

részén,

hogy

a

felhasználó

ki

tudjon

jelölni

a

szöveget

(onselectstart="return false"). Ezt egy nem szabványos, böngésző-függő CSS-tulajdonsággal lehet mégis elérni: „-moz-user-select: none; -khtmluser-select: none;”. (Internet Explorerben ugyanez: „user-select: none;”)

Ez oldotta meg azt a Safari-sajátosságot is, hogy jobb kattintásra egy szó kijelölődjön a helyi menü megjelenésével.

46



Ha fix szélességű táblázat cellákat szeretnék megvalósítani, viszont a cellába írandó tartalom meghaladja az adott szélességet, akkor lehetőség adódik az overflow: auto; tulajdonság révén, hogy görgethető legyen a cella tartalma. Ám ezt minden böngésző máshogy értelmezi, például a Chrome kiteszi rendesen a 16 pixel széles scrollbart, a Firefox pedig táblázat-cellára nem engedélyezi ezt a tulajdonságot, hanem a túlcsorduló szöveget a mellette lévő cella fölé írja. Firefoxban lehetne azt is csinálni, hogy a határolókon belülre mégegy
-et teszünk, amire már engedélyezett az overflow: auto tulajdonság, ám

ez fölöslegesnek tűnik. Egyébként ekkor a Firefox nem teszi ki a scrollbart, de a középső egérgombot lenyomva és húzva az egeret, arrébb tud mozdulni a túlcsorduló szöveg. Mindezek miatt egy olyan megoldáshoz folyamodtam, hogy az olyan szöveget, ami túl tudna csordulni egy fix szélességű cellában, betűnként szétválasztom

nulla-szélességű

szóköz

karakterekkel

(ZWSP,

zero-width

whitespace). Ekkor a túlcsorduló karakterek új sorba fognak kerülni minden böngészőben, kivéve Internet Explorerben, de azt egyelőre úgysem támogatjuk a projektben. Nem biztos, hogy ez az ideális megoldás, hiszen ha valaki ki akarja másolni ezt a ZWSP-ekkel tagolt szöveget és máshova beillesztené, akkor az nem mindig lesz jó neki. Erre a későbbiekben keresek megoldást, pl. a vágólapra másolás eseménykezelőjébe kellene beiktatni egy visszatranszformálást… Az Internet Explorer nem ismeri a legördülő menüknél a disable tulajdonságot, amivel le lehetne tiltani, hogy kijelölhető legyen az adott érték. Már említettem a javascriptes HTML-objektumok .innerText, illetve Firefox esetében .textContent tulajdonságának különbözőségét. Egy példa:
id="id1">szövegrész
.

IE és Chrome esetében az

elem=document.getElementById("id1"); elem.innerText értéke a „szöveg”

lesz, Firefoxnál az elem.textContent értéke a „szövegrész”. Az ezekkel való vesződés helyett javaslom a DOM-kifejezéseket: az elem.firstChild(), illetve a for (e in elem.childNodes) elem.childNodes[e]… bejárást.

47



Az aposztrófok bármelyike használható PHP-ban és JavaScriptben is, ám egy praktikum, hogy "" esetben a "\n" sortörést szúr be (míg a '\n' nem), illetve PHP-ban egy változót is megadhatunk ""–ös szövegen belül: "vmi$var vmi". Ha egy HTML-elem id vagy name attribútumának értéke megegyezik az eseménykezelőjében megadott függvénynévvel, akkor nem fogja tudni értelmezni a böngésző, pl.:

Készítette: Oltványi Gábor József PPKE-ITK

Recommend Documents