Sisällön automaattinen moniluokittelu Suunnitteludokumentti v1.01

Transkriptio

1 Sisällön automaattinen moniluokittelu Suunnitteludokumentti v1.01 Helsinki 4. marraskuuta 2002 HELSINGIN YLIOPISTO Tietojenkäsittelytieteen laitos Ohjelmistotuotantoprojekti samo Marko Konttinen Tarmo Pellikka Pia Rantalahti Kari Silén Markku Vahter Pirkko Wahlström

2 Versiohistoria Versio Pvm Kommentti Tekijä(t) Ensimmäinen raakaversio Marko Konttinen, Markku Vahter Lisätty kappaleet(1.2, 1.3, 1.4) Markku Vahter Korjattu ryhmän kommenttien mukaan, Markku Vahter lisätty hakukoneen luokkakaavio ja sen luokkakuvauksia Kappale 2 uusiksi, sekvenssikaaviot Marko Konttinen siirretty, Indexer-lukua päivitetty Indekserin kuvausta tarkennettu Marko Konttinen Ulkoasua korjailtu, hakukoneen kuvausta Markku Vahter tarkennettu Lisätty ontologia, käyttöliittymä. Markku Vahter Tarkennettu hakukoneen kuvausta. Ulkoasua korjailtu Lisätty indekseriin luvut Marko Konttinen Korjailtu virheitä kommenttien mukaan Markku Vahter Korjailtu virheitä kommenttien mukaan Marko Konttinen Lisätty lukuun 1.1. viittaus Lukuun 4: Marko Konttinen Fdg - Lukuun 2 indekserin ja fdg yleiskuvaukset, sekä kuva. - Luku 3 (Indekseri) päivitetty - Luku 4 (Fdg) lisätty Hienosäätöä Markku Vahter Hienosäätöä Marko Konttinen

3 1 Johdanto Dokumentin sisältö Järjestelmän yleiskuvaus Tärkeimmät vaatimukset Ohjelmistovaatimukset Ohjelmointityyli Sanasto Osajärjestelmien yleiskuvaus Indekseri Rajapinnat muihin osajärjestelmiin Tietokanta Käyttöliittymä Luokkien kuvaus Config DocumentRef extends Occurrence Index inferface IndexData Indexer IndexException extends Exception IndexMain Occurrence Predicate extends Occurrence RDFIndexer interface TermPattern Fdg Rajapinnat muihin osajärjestelmiin Rajapinnat ulkoisiin elementteihin Luokkien kuvaus interface Analysis FdgTokenizer Sentence SentenceFactory SentenceParseException extends Exception interface SentenceParser SocketFdg ThreadException Token Hakukone Rajapinnat muihin osajärjestelmiin Rajapinnat ulkoisiin elementteihin Käyttöliittymä Luokkien kuvaus Node NodeAnd NodeNot NodeOr NodeTerm Ontology Parser Processer...49

4 5.4.9 SearchEngine SearchMain Term Käyttöliittymä Rajapinnat muihin osajärjestelmiin Rajapinnat ulkoisiin elementteihin Käyttöliittymä Luokkien kuvaus SearchServlet SearchGui...57 Liite 1: Tietokantataulujen määrittelyt...58 Liite 2: configsystem.dtd...59 Liite 3: configsource.dtd...60

5 1 1 Johdanto Tässä dokumentissa suunnitellaan ohjelmisto, jonka ohjelmistotuotantoryhmä SaMo (Sisällön automaattinen moniluokittelu) toteuttaa Helsingin yliopiston tietojenkäsittelytieteen laitoksen (TKTL) ohjelmistotuotantoprojektissa Samo-ryhmän jäsenet ovat Marko Konttinen, Tarmo Pellikka, Pia Rantalahti, Kari Silén, Markku Vahter ja Pirkko Wahlström. Ryhmän ohjaajana toimii Jenni Valorinta. Ryhmän asiakas on Eero Hyvönen. 1.1 Dokumentin sisältö Luvussa 1 annetaan lyhyt johdanto järjestelmään ja toteutukseen. Luvussa 2 annetaan yleiskuvaus osajärjestelmistä. Luvussa 3 kuvataan indekseri-osajärjestelmä. Luvussa 4 kuvataan Fdg-osajärjestelmä Luvussa 5 kuvataan hakukone-osajärjestelmä. Luvussa 6 kuvataan järjestelmän käyttöliittymä. 1.2 Järjestelmän yleiskuvaus Samo-ryhmän tavoitteena on toteuttaa ohjelmistotuotantoprojekti-kurssin puitteissa proof-of-concept demojärjestelmänä hakukone museoesineistä koostuvaan tietokantaan kohdistuvia kyselyjä varten. Jokaista tällaista museoesinettä kuvaa tietokannassa kortti, johon on kerätty tietoa kyseisestä esineestä. Tieto voi olla esimerkiksi esineen nimi, ikä, käyttötarkoitus jne. Hakukoneella tarkoitetaan tässä järjestelmää, joka osaa hakee tästä tietokannasta käyttäjän määrittelemien hakusanojen perusteella viitteitä museoesineitä kuvaaviin kortteihin. Järjestelmä pyrkii hyödyntämään hakuja suorittaessaan tietoa museoesineiden välisistä suhteista eli ontologioista. Esimerkiksi jos käyttäjä antaa hakusanan huonekalu, voidaan hakea myös kortteja, joissa esiintyy sana pöytä tai tuoli, jotka ovat huonekalun alikäsitteitä. Tämä tieto käsitteiden liittymisestä toisiinsa on koodattu ontologiaan. Jotta tietokantaan pystyttäisiin ylipäätään suorittamaan hakuja, täytyy näistä korteista ensin muodostaa indeksi eli hakemisto. Hakemisto sisältää esinekorteista löytyneiden sanojen lisäksi tiedon siitä, mistä kortista sana on löytynyt. Tähän hakemistoon varsinainen hakukone sitten suorittaa hakuja. Järjestelmää käytetään yksinkertaisesti www-selaimella. Hakulause syötetään sille varattuun kenttään www-sivulla. Käyttäjä voi myös syöttää useampia hakusanoja mutta tällöin ne pitää ryhmitellä Boolen logiikan mukaisesti. Esimerkiksi jos käyttäjä haluaa tietoa kissoista ja koirista niin hakulause on muotoa kissa AND koira. Käyttäjän ei tarvitse antaa sanoja perusmuodossa, sillä järjestelmä osaa muuttaa sanat perusmuotoon. Käyttäjä pystyy myös määrittämään haun syvyyden suhteessa ontologiaan. Tällä tarkoitetaan sitä miten paljon hakua lavennetaan (esimerkkinä yllä oleva haku huonekalu, jota on lavennettu yksi taso alaspäin ontologiassa ja näin saatiin hakusanoiksi myös pöytä ja tuoli).

6 Järjestelmä siis hakee indeksistä hakusanojen viitteet, jotka se järjestää paremmuusjärjestykseen siten, että relevantein viite tulee ensimmäiseksi. Lopuksi tämä viitelista tulostetaan käyttäjän nähtä-väksi www-sivulle. Jokainen viite on linkki museoesinettä kuvaavaan korttiin, jonka käyttäjä saa näkyviin www-sivulle klikkaamalla linkkiä. 1.3 Tärkeimmät vaatimukset Järjestelmän tärkeimmät vaatimukset ovat seuraavat: Järjestelmä pystyy tuottamaan indeksin annetuista RDF-muotoisista museokorteista. Järjestelmä pystyy suorittamaan käyttäjän antaman hakulauseen muotoisen haun indeksistä samalla hyödyntäen ontologian tarjoamaa tietoa käsitteiden välisistä suhteista. 1.4 Ohjelmistovaatimukset Hakukonetta käytetään www-selaimen kautta. Yhteensopivat selaimet ovat ainakin Mozilla 1.0 ( ja Internet Explorer 5.5 ( Ontologioiden käsittelyyn käytetään Hewlett-Packard Labs:n Jena-toolkit versiota 1.5 ( Luonnollisen kielen prosessointiin käytetään Connexorin Fdg3 morfologista analysaattoria, ( Indeksoinnin tuottamat hakusanat talletetaan PostgreSQL-tietokantaan ( XML-dokumenttien käsittelyyn käytetään apache xml-työkaluja ( ) Sekä hakukoneen, että indekserin tarvitsemat konfiguraatiotiedot annetaan XMLmuotoisina tiedostoina (ks. liitteet). 1.5 Ohjelmointityyli Järjestelmän toteuttamiseen käytetään Java-kielen versiota ( Seuraavassa huomioita ohjelmointityylistä: Luokkien, metodien ja muuttujien nimet kirjoitetaan englanniksi. Metodien nimet aloitetaan pienellä kirjaimella, luokkien nimet suurella. Väliä kuvataan aloittamalla seuraava sana suurella kirjaimella. Kommentointikielenä käytetään suomea. Java-ohjelmakoodin ulkoasu on Sun Microsystemsin Java Code Conventions-spesifikaation mukaista ( 2

7 3 1.6 Sanasto Ontologia RDF RDF(S) Termi URI URL XML Ontologialla tarkoitetaan käsitehierarkiaa tai luokittelujärjestelmää, jonka perusteella maailma jakautuu eri näkökulmiin eli näkymiin Resource Description Framework, lisätietoja Resource Description Framework (Schema), lisätietoja Indeksiin talletettuja hakusanoja kutsutaan termeiksi Uniform Resource Identifier, lisätietoja Uniform Resource Locator, lisätietoja Extensible Markup Language, lisätietoja 2 Osajärjestelmien yleiskuvaus Järjestelmä on organisoitu kolmeksi osajärjestelmäksi: Fdg, indekseri ja hakukone. Kuvassa 1 on esitetty luokkakaavio järjestelmän tärkeimmistä luokista. Luokkien kaikkia metodeja ei ole esitetty kuvassa, ne käyvät ilmi osajärjestelmien kuvauksista. Indekseri osajärjestelmän tehtävänä on tuottaa hakemisto joukosta RDF-tiedostoja. RDF-tiedostot koostuvat joukosta resurssien kuvauksia eli yksi RDF-tiedosto voi sisältää tietoa useasta resurssista. Yksittäistä resurssia koskeva metatieto on kuvaus (Description), joka sisältää ko. resurssista joukon lausumia, joiden kaikkien subjekti (Subject) tuo resurssi on. Lausuma kertoo resurssilla olevan jokin ominaisuus (Property) jonka yhteydessä kerrotaan sen arvo/kohde (Object). Järjestelmä ei suoranaisesti tue reifikaatiota (Statement), eli 'lausumia lausumista' tai 'metatiedon metatietoa'. (semanttinen RDF kuvaustekniikka ja sen käsitteet on tarkemmin esitelty World Wide Web Consortiumin (W3C) asianomaisella www-sivustolla: ) Käsiteitä indeksoida t. laittaa indeksiin ja hakea indeksistä käytetään myöhemmin dokumentissa runsaasti, joten niiden merkityksen täsmentäminen lienee tässä paikallaan vaikka asia useimmille varmasti on intuitiivisesti selvä: Indeksi on yleisesti käytetty sana, joka suomennettuna on hakemisto. Hakemistossa on joukko sanoja, jotka viittaavat tiettyyn osaan indeksoitua aineistoa. Kun hakemistoon eli indeksiin lisätään pari (hakusana, viite) voidaan tästä käyttää ilmaisua indeksoida -kohteena viitattu aineisto. Yhdellä hakusanalla voidaan luonnollisesti viitata useampaan kohteeseen. Vastaavasti, kun luettelosta haetaan viiteitä hakusanan perusteella käytetään ilmaisua hakea indeksistä. Em. käsitteitä käytetään kuvatussa merkityksessä myös tässä dokumentissa, lukuunottamatta pientä poikkeusta: Koska käsiteltävä aineisto on joukko kuvauksia (Description) metatietoa -, viittaavat hakemiston viitteet resursseihin, joita annettu metatieto koskee. Eli hakemistossa on pareja (hakusana, subjektin nimi), jossa subjektin nimi siis viittaa kuvattuun resurssiin. Indeksin ja

8 4 indeksoinnin toteutus tässä järjestelmässä on kuvattu tarkemmin Indexer -osajärjestelmän yhteydessä, luvussa 3. Komentorivipohjaiselle käyttöliittymälle IndexMain:lle syötetään kahden määrittelytiedoston, systemconfig ja sourceconfig (ks. liitteet), osoitteet. Kumpikin määrittelytiedosto, niiden rakenne ja käyttö esitellään tarkemmin luvussa 3, Indexer osajärjestelmän yhteydessä. Mainittakoon niistä tässä kuitenkin pari seikkaa: sourceconfig-tiedostossa tulee kertoa indeksoitavien RDF-tiedostojen sijainnit ja systemconfig-tiedostossa kerrotaan, mitkä ominaisuudet halutaan indeksoida. Mitkä ominaisuudet halutaan indeksoida, kerrotaan antamalla lista ominaisuuksien (Property) tunnuksia. Tunnukset ovat ureja, jotka koostuvat nimiavaruus-osasta (namespace) ja ominaisuuden varsinaisesta nimestä tuossa nimiavaruudessa. Indeksoinnin kohteena olevista RDF-tiedostoista indeksoidaan kaikki kuvauksen kohteena olevat resurssit. Näistä resursseista haetaan hakusanat eli termit niiden ominaisuuksien (Property) kohteista (Object), jotka on määritelty systemconfig -konfiguraatiotiedostossa. Indexer osajärjestelmä käyttää Fdg osajärjestelmän SentenceParser luokkaa jäsentämään predikaattien sisältämä luonnollisen kielen teksti. SentenceParser on rajapinta luonnollisen kielen jäsentimeen, joka analysoi tekstin virketasolla ja tuottaa virkkeen sanoille vähintään morfologisen tason analyysin. Jäsennyksen tuloksena saadaan jäsennetty virke, joiden sanoille on kiinnitetty morfologiset piirteet. Tässä työssä käytetään Connexorin Fdg3 analysaattoria luonnollisen kielenjäsentimenä. Fdg osajärjestelmä etsii virkkeistä termejä, eli hakusanoja. Termien etsiminen perustuu termihahmojen tunnistamiseen virkkeistä [12]. Termihahmolla tarkoitetaan sanojen muodostamaa jonoa, jossa sanoilla on tietty morfologinen piirre. Esimerkkejä termihahmoista voisi olla vaikkapa substantiivi (N) tai adjektiivi (A) + substantiivi (N). Ensimmäinen hahmo tunnistaa kaikki virkkeen substantiivit termeiksi, jälkimmäinen tunnistaa kaksisanaiset termit, joista ensimmäinen sana on adjektiivi ja toinen substantiivi. Termien kanonisena muotona käytetään perusmuotoa. Esimerkiksi jälkimmäinen hahmo voisi tunnistaa jostain virkkeestä sanat punaiset kissat, tällöin termin kanoninen muoto on punainen kissa. Hakuja suoritetaan www-selaimeen liittyvän käyttöliittymän kautta. Asiakas voi yksittäisten hakusanojen lisäksi yhdistellä sanoja boolen logiikalla. Lisäksi käyttäjä voi määritellä haun lavennuksen syvyyden ontologiassa. SearchEngine saa käyttöliittymältä hakulauseen, jonka se jäsentää ensin hakupuuksi. Koska indeksiin tallennetut hakusanat ovat perusmuodossa, pitää hakukoneen suorittaa ennen muita toimenpiteitä niiden perusmuotoon muuttaminen. Tähän se käyttää SentenceParser-luokkaa, joka taas käyttää Fdg3-ohjelmaa. Seuraavaksi suoritetaan homonyymien etsintä. Homonyymillä tarkoitetaan tässä sitä, että jollekin hakusanalle löytyy ontologiasta enemmän kuin yksi yläkäsite. Esimerkkinä tästä voi olla vaikkapa sana harakka, joka voidaan tulkita joko linnuksi tai hatuksi. Homonyymien etsintää hakukone käyttää Ontology-luokan tarjoamaa palvelua homonyymien selvittämiseen. Mikäli hakusana on homonyymi, niin silloin kyseistä hakusanaa ei lavenneta. Seuraavana on synonyymien selvittäminen. Tähänkin käytetään hyväksi ontologiaa. Synonyymien selvittämisen jälkeen etsitään hakusanoille alikäsitteitä niin monelta tasolta kuin käyttäjä määritteli hakua tehdessään. Ontologiaa käytetään tähän toimenpiteeseen. Lopulta kun kaikki hakusanat ovat lavennettu, voidaan aloittaa varsinainen haun suorittaminen. Hakupuuta käydään läpi ja jokaiselle hakutermille etsitään indeksistä viitteitä. Samalla kun viitteitä löytyy niille lasketaan painokerroin. Näiden kertoimien mukaan viitteet voidaan lopulta järjestää paremmuusjärjestykseen. Kun kaikille hakupuun termeille on viitteet löydetty, aloitetaan puun karsinta. Solmuja yhdistetään siten, että aina yhden boolen logiikan mukaisen solmun lapsille suoritetaan sen tyyppinen matemaattinen operaatio millainen kyseinen

9 solmu on. Esimerkiksi jos meillä on hakulause kissa AND talo niin tällöin valitaan sanaan kissa ja talo liittyvistä viitteistä ne, joissa esiintyy molemmat sanat. Tällä tavoin käsitellään koko puu ja lopulta jäljelle jää yksi viitejoukko, joka vielä järjestetään painokertoimien mukaiseen järjestykseen siten, että suurimman kertoimen omaava viite sijoitetaan ensimmäiseksi. Tämä järjestetty viitejoukko palautetaan käyttöliittymälle, joka generoi siitä html-sivun, joka tulostetaan käyttäjälle. 5

10 6 Kuva 1Osajärjestelmien keskeisimmät luokat 3 Indekseri Indekseri -osajärjestelmän tehtävänä on muodostaa hakemisto joukosta RDF dokumentteja. Tekstimuotoisen käyttöliittymän indekseriin tarjoaa IndexMain, joka saa parametreina osoitteet XML-muotoisiin konfiguraatiotiedostoihin systemconfig ja sourceconfig (liitteinä). Indekseri aloittaa indeksoinnin joka kerta 'puhtaalta pöydältä: vanhat tiedot hävitetään ja uusi tieto laitetaan tilalle. Tietokannan käyttö selostetaan yksityiskohtaisemmin myöhemmin. Konfiguraatiotiedostojen syntaksi on määritelty vastaavissa dtd:eissä configsystem.dtd ja configsource.dtd (liitteinä). Konfiguraatiotiedostojen tulee olla hyvinmuodostunutta xml:ää ja

11 noudattaa syntaksiltaan em. määrittelujä. IndexMain käyttää systeemiasetusten lukemiseen systemconfig-konfiguraatiotiedostosta luokkaa Config. IndexMain käyttää RDFIndexer:iä, joka käyttää RDQL-kyselykieltä indeksoitavan aineiston hakemiseen kohdetiedostoista. Kohdetiedostojen sijainnit on ilmoitettu sourceconfigkonfiguraatiotiedostossa. - Konfiguraatiotiedoston rakenne on määritelty seuraavasti: <!ELEMENT source ((file_uri)+)> <!ELEMENT file_uri (#PCDATA)> - Esim. sourceconfig konfiguraatiotiedoston sisällöstä: <?xml version= 1.0 encoding= ISO ?> <source> <file_uri> <file_uri> <file_uri> </source> Kohdetiedostojen tulee olla syntaksiltaan xm/rdf:ää, jotta niitä pystytään käsittelemään Jenalla. Kohdetiedostoista käsitellään kaikki kuvaukset (Description) ja kustakin kuvauksesta käytetään indeksointiin hakusanoja, jotka löytyvät haluttujen ominaisuuksien (Property) objekteista (Object). Vain literaalimuotoiset (merkkijonot) objektit käsitellään. Käsiteltävät ominaisuudet ilmoitetaan systemconfig-konfiguraatiotiedostossa. Ote systemconfig:n määrittelystä: <!ELEMENT properties (namespace+)> <!ELEMENT namespace (property+)> <!ELEMENT property (#PCDATA)> <!ATTLIST namespace name #REQUIRED> <!ATTLIST property weight #REQUIRED> 7 Esim. Haluttujen ominaisuuksien listaus: <?xml version= 1.0 encoding= ISO ?> <properties> <namespace name= > <property weight= 0.20 >property1</property> <property weight= 0.20 >property2</property> </namespace> <namespace name= > <property weight= 0.20 >property1</property> <property weight= 0.20 >property2</property> </namespace> </properties> Tämän konfiguraation mukaan käsiteltäisiin kaikki resursseista löytyneet ominaisuudet nimeltään

12 Näiden ominaisuuksien literaalimuotoiset kohteet (Object) syötetään Indexer:lle, joka hyödyntää morfologista analysaattoria Fdg -paketin kautta. Indexer tuottaa annetusta tekstistä joukon IndexData -olioita, joista kukin vastaa yhtä tekstistä saatua termiä. IndexMain siis käyttää RDFIndexer:iä, joka käyttää RDQL-kyselykieltä indeksoitavan aineiston hakemiseen kohdetiedostoista. RDF-muotoinen data käsitellään Jenan avulla. IndexMain käy läpi sourceconfig-tiedoston ja syöttää siinä luetellut kohdetiedostot yksi kerrallaan RDFIndexerille. RDFIndekser antaa indeksoitavat tiedot Index:lle, joka lisää ne tietokantaan. Tietokannan käyttö rajoittuu luokan Index sisälle. Indeksistä voi hakea termin perusteella viiteitä dokumentteihin (DocumentRef), joista termi on löytynyt. Indekseri käyttää hukkasanalistaa suodattamaan turhat sanat pois. Hukkasanat ovat yleisiä suomenkielen sanoja, jotka kantavat vähän semanttista merkitystä ja ovat funktioltaan pikemminkin syntaktisia. Tällaisia sanoja ovat yleisesti mm. pronominit ja partikkelit. Kokoelmasta käytetään suomessa nimitystä hukkasanalista tai estolista ja englanniksi vastaavasti nimitystä stoplist tai stopwordlist. Hukkasanalistan voi koota esimerkiksi käymällä läpi suuren tekstiaineiston, kuten tuhansia lehtiartikkeleita, ja poimimalla sieltä n yleisintä sanaa. Indexer muuntaa hukkasanalistaan lisättävät sanat perusmuotoonsa, joten yksi sanamuoto kustakin sanasta riittää. Indekseri lukee hukkasanalistan tiedostosta, jossa saa olla vain 1 sana per rivi. Tiedoston sijainti tulee kertoa Indekserille systemconfig -konfiguraatiotiedostossa. Dokumentit voidaan kuvata vektoreina n-ulotteisessa avaruudessa, jonka akselit muodostavat dokumenteissa esiintyvät termit. Vektorin koordinaattien arvot määräytyvät sen mukaan, kuinka tärkeä termi on ko. dokumentille. Dokumenttiviitteille lasketaan normalisoitu TF*IDF paino (term frequency * inversed document frequency). Luonnollisesti, jos hakutermi ei ole esiintynyt jossakin dokumentissa ei tähän dokumenttiin ole viitettä. Tällöin sen painon voidaan ajatella olevan nolla. TF*IDF painojen laskeminen on yleisesti käytetty tilastotieteellinen menetelmä luokitella laajoja dokumenttiaineistoja. (kts. TKTL:n kurssi Laajojen dokumenttiaineistojen käsettely, TF*IDF lasketaan kaavalla f t k, d j log Tr Tr t k missä tk on k:s termi ( 0< k <n ) dj on j:s dokumentti ( 0<j<Tr ) f(tk, dj) kuinka monta kertaa tk esiintyy dj:ssä Tr(tk) kuinka monessa dokumentissa tk esiintyy. Tr dokumenttien lukumäärä Normalisoitu arvo lasketaan kaavalla: tfidf t k, d j s 1to T tfidf t s, d j 2

13 9 Painon laskemisen ohjelmallinen toteutus selitetään Index luokan kuvauksen yhteydessä. Tilastollisen korrelaation toivotaan implikoivan myös semanttista korrelaatiota. Koska indeksoitavan aineiston sisältämä tekstimäärä voi olla hyvinkin pieni, ei tällainen statistinen menetelmä ole välttämättä paras mahdollinen ja saattaa olla altis 'hälylle' (noise). Koska indeksin kuitenkin täytyy olla ontologiasta riippumaton päädyttiin käyttämää em. menetelmää. Muussa tapauksessa voisi olla harkinnan arvoista käyttää esim. menetelmää, joka perustuu käsitteiden etäisyyksien laskemiseen ontologiassa (ns. Link-distance, kts. Narayanan, Bhattacharyya: 'Measuring Similarity of Texts Using Wordnet'). Kuvassa 2 on kuvattu Indekseri -osajärjestelmän rakenne UML-kaaaviona. IndexMain on luokka jota kutsuttaessa Indekseri käynnistyy. IndexMain käyttää Config luokkaa järjestelmän asetusten lukemiseen systemconfig -konfiguraatiotiedostosta. IndexMain käyttää RDFIndexer:iä tietojen indeksoimiseen, joka puolestaan käyttää Indexer:iä indeksoitavien kuvausten sisältämän luonnollisen kielen käsittelyyn. Tässä Indexer hyödyntää Fdg -pakettia, joka on kuvattu omassa luvussaan. Indexer etsii indeksoimiseen käytettävästä tekstistä hakusanoja metodilla index ja palauttaa joukon IndexData olioita, jotka edustavat hakusanoina käytettäviä termejä. Indexer:stä on tässä kuvattu vain indeksoinnin kannalta olennaiset piirteet. Indexer-luokka on tarkemmin kuvattu luvun 3.6 asianomaisessa aliluvussa 'Indexer'. Index:lle annetaan indeksoitava aineisto, jonka Index lisää tietokantaan. Tietokanta on kuvattu tarkemmin luvussa 3.4 ja Index:n toiminta luvun 3.6 asianomaisessa aliluvussa 'Index'. Index:ltä voi pyytää viitteitä tietylle termille metodilla getreferences(string term). Index palauttaa joukon DocRef -olioita, jotka edustavat resursseja, joissa hakutermi on esiintynyt. DocRef oliot luodaan tietokannan tietojen perusteella pyydettäessä, mutta on kätevää ajatella Index:n sisältävän joukon DocRef -olioita. DocRef olio sisältää joukon Predicate olioita, jotka edustavat ominaisuuksia, joiden objekteissa hakutermi on esiintynyt kyseisessä dokumentissa. DocRef ja Predicate ovat luokan Occurrence aliluokkia ja perivät osan sen ominaisuuksista. Occurrence on sisällytetty luokkarakenteeseen, koska DocRef:llä ja Predicate:lla on paljon yhteisiä piirteitä, jotka oli kätevä koota yhteiseen yliluokkaan. Toisaalta, rakenteeseen haluttiin sisällyttää myös luokat, jotka käsitteellisesti ja nimiltään vastaavat paremmin tehtäviään sekä järjestelmän ajatusmaailmaa.

14 Kuva 2Indekserin luokkakaavio 10

15 11 Indekserin toiminta on kuvattu sekvenssikaaviona kuvassa 3. Sekvenssikaaviosta on jätetty luokan Config käyttö pois, mutta sen käyttö on varsin intuitiivista ja tarkemmin kuvattu luvussa 3.6 luokkien IndexMain ja Config kuvausten yhteydessä. Indeksointi käynnistyy kutsuttaessa IndexMain:n main -metodia. IndexMain sisältää järjestelmän tekstipohjaisen käyttöliittymän. IndexMain luo Index- ja RDFIndexer -oliot, joita se käyttää. Ennen kuin indeksointi käynnistetään, poistetaan vanhan tietokannan sisältö kutsumalla Index:n metodia reset() ja kerrotaan RDFIndexer:lle mistä ominaisuuksista tulisi hakusanoja etsiä metodilla setfilter. RDFIndexer:n voi käsitteellisesti ajatella sisältävän suodattimen (filter), joka päästää käsittelyyn vain halutut ominaisuudet kustakin kuvaksesta -kaikki turha aineisto suodatetaan annetusta materiaalista pois, josta metodin setfilter nimi juontuu. Indexer:lle täytyy syöttää myös hukkasanat, jotka saadaan Reader -oliona Config:lta, joka lukee hukkasanalistan systemconfig:ssa url-osoitteena ilmoitetusta tiedoston sijainnista. IndexMain lukee tietovirran sisältöä ja sana kerrallaan lisää Indexer:iin hukkasanoja metodilla addtostopwordlist(string) kunnes koko tietovirta on lisätty. IndexMain antaa RDFIndexer:lle aineistoa indeksoitavaksi tiedosto kerrallaan metodilla index(uri). RDFIndexer käsittelee annetusta tiedostosta kaikki kuvaukset (Description). Jokaisesta kuvauksesta käsitellään halutut ominaisuudet. Ominaisuuksien kohteista (Object) etsitään hakusanat, mikäli objekti on literaalimuotoinen (merkkijono). Indexer palauttaa syötetystä tekstistä joukon sanoja, jotka soveltuvat hakusanoiksi. Viittaukset lisätään indeksiin ominaisuus kerrallaan kutsumalla Index:n metodia add. Hakusanat viittaavat käsiteltävän kuvaksen kohteena olevaan resurssiin. Kun kaikki indeksoinnin kohteena olevat tiedostot on käyty läpi, täytyy viittauksille laskea aikasemmin kuvattu painoarvo. TF*IDF paino voidaan laskea vasta kun koko käsiteltävä aineisto on indeksoitu, joten se tehdään kaikille viittauksille vasta lopuksi. Index laskee painoarvot ja lisää ne tietokantaan kutsuttaessa sen metodia updateweights.

16 12 Kuva 3Indekserin sekvenssikaavio 3.1 Rajapinnat muihin osajärjestelmiin Hakukone hakee indeksistä termin perusteella viittauksia dokumentteihin, joissa termi on esiintynyt. Tähän hakukone käyttää Index:ä. Index palauttaa hakusanaa vastaan viitteet dokumentteihin, joissa annettu hakusana on esiintynyt, joukkona DocRef olioita. Index olio luodaan antamalla konstruktorissa sille tietokannan portti ja osoite (url). Indexer käyttää Fdg pakettia luonnollisen kielen käsittelyyn.

17 Tietokanta Hakusanaluettelo eli indeksi on toteutettu PostgreSQL relaatiotietokantana ( ), jota Index käyttää JDBC rajapinnan ( ) kautta. Tietokannan sisällöstä käytetään tässä luvussa myös nimitystä 'indeksi'. Tietokannan rakenteen määrittävät taulumäärittelyt on annettu tämän dokumentin liitteenä. Koko indeksointi-prosessista käytetään nimitystä 'rakentaa indeksi'. Indeksi rakennetaan aina kerralla annetusta aineistosta. Tämän vuoksi vanha indeksi poistetaan aina kun uutta ryhdytään rakentamaan. Kuvassa 4 on kuvattu tietokannan rakenne luokkakaaviona, jossa tietokannan taulut on kuvattu luokkien tapaan. Tietokannassa on sisältyvyyssuhteiden sijaan viittaussuhteita. Term-tietueet vastaavat indeksin sisältämiä hakusanoja. Term:llä on kentät word ja num_of_references. Kenttä word kertoo hakusanan, jota Term edustaa ja num_of_references kertoo kuinka monessa dokumentissa ko. termi on esiintynyt. Tätä lukua voidaan käyttää termin painoarvon laskemiseen. Aikaisemmin esitellyssä TF*IDF-kaavassa tämä luku kuvattiin funktiona Tr(tk). Kutakin hakusanaa kohti on täsmälleen yksi Term-tietue. Siten termien voidaan ajatella edustavan kuvattavan dokumenttiavaruuden ulottuvuuksia. Samasta syystä word -kenttä soveltuu hyvin Term:n yksiselitteiseksi avaimeksi (primary key). About edustaa viittauksen kohteena olevia resursseja. About:n kenttä uri on kuvaksen kohteena olleen subjektin nimi, joka on uri kuvattavaan resurssiin. Kuhtakin kuvattavaa resurssia edustaa täsmälleen yksi About-tietue. Siksi uri-kenttä soveltuu hyvin About:n yksiselitteiseksi avaimeksi (primary key). DocRef edustaa dokumenttiviittausta. Kutakin viittausta kohti on täsmälleen yksi DocRef-tietue. Yhtä termiä kohden voi olla useita (1...*) dokumenttiiviittauksia. Useampi (1...*) viittaus voi viitata samaan resurssiin (About). Dokumenttiviitteille voidaan myös merkitä painoarvo, joka kertoo kuinka oleellinen ko. hakusana on viitattavalle dokumentille. Tämä tieto talletetaan weight -kenttään. Kenttää about_uri käytetään viittausavaimena (foreign key), jolla viitataan johonkin About -tietueeseen. Kenttää term_word käytetään viittausavaimena, jolla viitataan johonkin Termtietueeseen. Pari (about_uri, term_word) soveltuisi DocRef:n yksiselitteiseksi avaimeksi (primary key), mutta yksinkertaisuuden vuoksi tähän käytetään tunnusnumeroa, joka talletaan kenttään id. Koska hakusana saattaa esiintyä samaa resurssia koskevassa kuvauksessa usean ominaisuuden 'alla' on dokumenttiviittaukset jäsennelty vielä tämän mukaan. Tietokannassa ominaisuuksia edustavat Property -tietueet. Samaan DocRef:iin saatetaan viitata useammasta (1...*) Property:sta. Kentässä name on Propertyn nimi, joka on uri, joka koostuu namespace osasta ja ominaisuuden varsinaisesta nimestä. Kentässä occurrences_of_term kerrotaan, kuinka monta kertaa ko. hakusana on esiintynyt kuvauksessa tämän ominaisuuden 'alla'. Kentällä docref_id viitataan johonkin DocRef:iin. Yksiselitteisen avaimen Property-tietueelle muodostaa pari (name, docref_id).

18 14 Kuva 4Indeksin rakenne luokkakaaviona 3.3 Käyttöliittymä Indekseri-osajärjestelmän tehtävänä on muodostaa hakemisto joukosta RDF dokumentteja. Tekstimuotoisen käyttöliittymän indekseriin tarjoaa IndexMain, joka saa parametreina osoitteet XML-muotoisiin konfiguraatiotiedostoihin configsystem ja configsource. Konfiguraatiotiedostojen syntaksi on määritelty vastaavissa dtd:eissä configsystem.dtd ja configsource.dtd (liitteenä). Tiedoston configsource rakenne ja sisältö esiteltiin jo luvun 3 alussa. Tiedostossa configsystem annetaan järjestelmälle tiedot, joita se tarvitsee toimiakseen. Indekseri tarvitsee erityisesti yhteystiedot (sijainti ja portin numero) morfologiseen analysaattoriin Fdg3 sekä käytettävään tietokantaan. Indekseri ja hakukone käyttävät samaa kofiguraatiotiedostoa. Tämän vuoksi konfiguraatio-tiedostossa annetaan myös ontologian sijainti, vaikkei indekseri sitä käytäkään. Indekseri käynnistetään käynnistämällä IndexMain eli kirjoittamalla: java samo.indexer.indexmain Käynnistyksen yhteydessä on IndexMain:lle annettava komentoriviparametreina konfiguraatiotiedostojen osoitteet. Komentoriviparametrit annetaan nimi-arvo pareina muodossa 'nimi=arvo', jossa siis nimi annetaan ensin ja arvo nimen jälkeen '=' -merkillä nimestä erotettuna. Annettavien parametrien nimet ovat 'configsystem' ja 'configsource'. Esimerkki komentoriviparametreista: - configsystem konfiguraatiotiedoston antaminen:

19 15 configsystem= - configsource konfiguraatiotiedoston antaminen: configsource= 3.4 Luokkien kuvaus Indekseri muodostaa paketin samo.indexer. Seuraavissa aliluvuissa on kuvattu samo.indexer paketin sisältämät luokat ja rajapinnat, joista indekseri osajärjestelmä koostuu. Luokat on kuvattu luokan nimen mukaan leksikograafisessa järjestyksessä Config Lukee systemconfig konfiguraatiotiedoston konstruktorin parametrina annetusta osoitteesta ja tarjoaa get-aksessorit konfiguraatiotiedostossa määritellyille konfiguraatioparametreille. Konfiguraatiotiedostossa määritellään seuraavat tiedot: - xml-dokumentti, jossa annetaan järjestelmälle seuraavat asetukset: - Morfologisen analysaattorin, Fdg3:n sijainti ja portti. - Tietokannan sijainti ja portti - Tiedoston sijainti, jossa ontologia on kuvattu - Käsiteltävien Propertyjen nimet uri-osoitteina - Painot käsiteltävville Propertyille - Hukkasanalistan sijainti Attribuutit: Edellä luetelluille tiedoille on seuraavat attribuutit: private org.w3c.dom.document systemconfig xml-dokumentti, jossa järjestelmän asetukset annetaan. Dokumentti luetaan tiedostosta, jonka url-osoite annetaan Config:lle konstruktorin parametrina. private int indexport Käytettävän tietokannan portin numero private URL indexlocation Käytettävän tietokannan osoite (url) private URL ontologylocation Tiedoston, jossa ontologia on kuvattu, sijainti (url). private int fdgport Morfologisen analysaattorin portin numero private URL fdghostname Morfologisen analysaattorin palvelimen osoite (url) private Map weightsforproperties Assosiaatiotaulu, jossa Propertyn nimi viittaa ko. Propertyn painoon. private Reader stopwordlist Hukkasanalista

20 16 Konstruktori: public Config(String systemconfiglocation) Selitys: Luo uuden Config-olion. Lukee xml-muotoisen konfiguraatiotiedoston parametrina annetusta osoitteesta. Tiedoston oletetaan olevan hyvinmuodostunutta xml:ää ja syntaksiltaan systemconfig.dtd määrittelyn mukainen. Metodit: public int getindexport() Selitys: palauttaa käytettävän tietokannan portin numeron. public URL getindexlocation() Selitys: Palauttaa käytettävän tietokannan osoitteen (url) public URL getontologylocation() Selitys: kertoo tiedoston, jossa käytettävä ontologia on kuvattu, sijainnin. public int getfdgport() Selitys: Kertoo käytettävän morfologisen analysaattorin Fdg3:n portin numeron. public URL getfdghostname() Selitys: Kertoo käytettävän morfologisen analysaattorin Fdg3:n osoitteen (url) public List getwantedpropertynames() Selitys: Kertoo niiden Propertyjen nimet, joiden 'alla' olevista literaalimuotoisista objekteista tulee hakusanoja etsiä. public float getweightforproperty(string propertyname) Selitys: Kertoo Propertyn, jonka nimi annetaan parametrina, painoarvon, jos se on määritelty konfiguraatiotiedostossa. public Reader getstopwordlist() Selitys: Antaa hukkasanalistan Reader -oliona DocumentRef extends Occurrence Index palauttaa joukon DocumentRef -olioita hakusanaa vastaan. DocumentRef edustaa dokumenttiviitettä tietylle hakusanalle. Sisältää joukon Predicate olioita, joissa ko. hakusana on viitattavan dokumentin kuvauksessa esiintynyt. Konstruktori: public DocumentRef(java.lang.String about) Parametrit: about - Sen resurssin uri, johon viitataan. Metodit: public java.lang.string aboutresource()

21 17 Selitys: Palauta Stringinä sen resurssin uri, johon viitataan. public void addpredicate(samo.indexer.predicate predicate) Selitys: Predikaatti olio, joka edustaa tässä resurssissa esiintynyttä predikaattia, jonka 'alla' eli objektissa ko. termi on esiintynyt. public float getweight() Selitys: Palauta ko. termin painoarvo viitattavassa dokumentissa. public void setweight(float _weight) Selitys: Aseta ko. termin painoarvo viitattavassa dokumentissa public java.util.set getpredicates() Selitys: Palauttaa joukon Predicate-olioita, joissa ko. termi on viitattavassa dokumentissa esiintynyt Index Käyttää tietokantaa JDBC rajapinnan kautta. Tarvitsee tietokantapalvelimen osoitteen ja portin numeron. Rakentaa indeksin tietokantaan. Tarjoaa metodit indeksin luomiseen, viitteiden lisäämiseksi indeksiin, viitteiden painoarvon laskemiseen TF*IDF menetelmällä sekä metodin viiteiden hakemiseksi indeksistä hakusanan perusteella. Konstruktori: Index(int dbport, java.net.url dblocation) Selitys: Luo Index -olio. Tarvitsee käytettävän tietokannan osoitteen ja portin numeron. Metodit: public void add(set indexdatatoken, URI about, String predicate) Selitys: Lisää viite tietokantaan. Parametrit: indexdatatokens - Termin esiintymät käsitellyssä tekstissä. about - Indeksoitavan resurssin nimi predicate - Predikaatin nimi, joka sisälsi käsitellyn tekstin. pseudokoodi: for each token in indexdatatokens int occurrences = token.gethowmanytimes(); String term = token.gettermname(); if term not in database already, add it if about not in database already, add it docref that references about and term not in database already, add it add property into database,, which references to docref public void updateweights

22 Selitys:Kun kaikki resurssit on käsitelty, laske termien dokumenttikohtaiset painot käyttäen TF*IDF -kaavaa. Painot normalisoidaan. Päivitetään painoarvot tietokantaan docref-tauluun. 18 pseudokoodi: // first, count TF*IDF int Tr = count( entries for About in database ) // viitattavien dokumenttien lkm for each about-entry 'dj' in database // count term frequency TF: double tf=0; // count L2-length for the vector that 'ref' represents -this is needed for normalizing float length = 0.0; for each term-entry 'tk' in database // count IDF: float idf = log( Tr ) / tk.num_of_references for-each docref-entry 'ref' that references tk and dj for each property entry that references ref tf = tf + property.occurrences_of_term // update weight for ref: for-each docref-entry 'ref' that references tk and dj float tfidf = tf * idf ref.weight = tf * idf length = length + ( tfidf * tfidf ); // finally, normalize the weights: for each term-entry 'tk' in database for-each docref-entry 'ref' that references tk and dj for each property entry that references ref // update weight for ref: for-each docref-entry 'ref' that references tk and dj float normalized_tfidf = tf * idf / length ref.weight = normalized_tfidf public Set getreferences(string term) Selitys: Palauttaa joukon DocumentRef oloita. Joukko sisältää kaikki ne elementit, joihin ko. termi viittaa. pseudokoodi: get references from database : select all from table docref where term_word equals given parameter term for each reference create new DocumentRef-object docref set attributes about and weight for docref according to data from reference get properties for docref: select all from table property where docref_id equals reference.id for each property // create predicate and set data according to property Predicate predicate = new predicate( property.name, property.occurrencesofterm );

23 19 docref.addpredicate( predicate ); public void reset() Selitys: Tyhjennä tietokanta ja alusta se uudestaan. Jos tarvittava taulurakenne on jo olemassa, riittää, että taulut tyhjennetään, muussa tapauksessa luo tarvittava taulurakenne inferface IndexData IndexData rajapinta sisältää metodit, joiden avulla saadaan tieto löydetyistä termeistä. Metodit: public String gettermname() Selitys: Palauttaa termin nimen. public int gethowmanytimes() Selitys: Palauttaa, kuinka monta kertaa termi on esiintynyt tekstissä Indexer Indexer luokka tuottaa termejä tekstistä kutsuttaessa metodia index(string text,map m). Tuloksen metodi tallettaa karttaan m. Avaimena on termin nimi ja sisältönä IndexData olio. Metodi heittää IndexExceptionin, jos jotain poikkeukselista taphtuu indeksoinnin aikana. Indexer käyttää tekstin analysoimiseen SentenceParser oliota, johon se sai viitteen konstruktorin kutsussa. Termien etsimiseen voi vaikuttaa kahdella metodilla: addtostoplist(string) lisää sanan estolistalle ja addtermpattern(termpattern) lisää etsittävän termihahmon indexeriin. Indexer käy jokaisen analysoimansa virkkeen läpi ja etsii indexeriin lisätyt termihahmot virkkeistä. Indekseri etsii termejä sille syötetystä tekstistä. Indexer käyttää TermPattern rajapintaa termien etsimiseen virkkeestä. Tässä työssä ajan puutten vuoksi TermPattern on toteutettu hyvin yksinkertaisesti, eli jokaiselle hahmolle on toteutettu oma luokkansa. Yksi mahdollinen tapa toteuttaa Termpattern hienommin olisi luoda säännöllinenkieli kuvaamaan termihahmot, toteuttaa parseri kielelle, muuntaa säännöllinen ilmaus epädeterministiseksi automaatiksi, determisoida ja lopulta minimoida automaatti. Tällöin hahmojen kuvaaminen tulisi helpommaksi.

24 20 Kuva 5 Indexer osajärjestelmän luokkakaavio Konstruktorit: public Indexer(SentenceParser parser) Selitys: Toimii kuin public Indexer(parser, true). public Indexer(SentenceParser parser, boolean usedefaultpatterns) Selitys: Luo uuden Indexerin. Parametrinaan parseri saa parserin, jota käytetään virkkeiden analyysiin. Jos usedefaultpatterns true, niin käytetään oletus termihahmoja, joita on vain yksi ([&A>]*[NH]). Eli yksi tai useampia adjektiiveja, jonka jälkeen nominaalinen pääsana. Jos se on false, yhtään termihahmoa ei tunnisteta, vaan termihahmot on lisättävä metodilla addtermpatterm(termpattern) create instance variables if (usedefaultpatterns) add default term patters to patterns vector Attribuutit: private SentenceParser parser Selitys: Virkkeiden analyysissä käytettävä parseri. private Set stoplist Selitys: Jos sana esiinttyy estolistalla, sitä ei huomioida terminä.

25 21 private Vector sentences Selitys: Virkkeet talletetaan tähän vektoriin analysoinnin jälkeen. private Vector patters Selitys: Termihahmot, jotka etsitään virkkeistä. Metodit: public void index(string text, Map result) throws IndexException Selitys: Etsii tekstistä text termit ja tallettaa tietorakenteeseen result. Indexer mahdollisesti tulevaisuudessa käyttää uudestaan resultin sisältämät IndexData oliot, joten tulos on talletettava ennen seuraavaa kutsua. Resultin avain on termin nimi ja sisältö sitä vastaava IndexData olio. clear result parser.analyse(text,this); for each Sentence in the sentences findterms(sentence[i],result) public void addtostoplist(string token) Selitys : Lisää sanan token estolistalle. Termejä, jotka löytyvät estolistalta ei lisätä indeksiin. public boolean nextsentence(sentence s) Selitys: Rajapinta analysaattoriin. Tallettaa virkkeet vektoriin sentences public void addtermpattern(termpattern pattern) Selitys: Lisää etsittävän termihahmon Indexeriin. Katso TermPattern luokan kuvaus. private void findterms(sentence s,map result) Selitys: Metodi etsii termit virkkeestä s ja tallettaa ne result hajautustauluun. for (i = 1, i<=s.size) for (j=0,j<=patterns.size) patternlength = patterns[j].find(s, i) if (patternlength > 0) addterm(result, s.getlemma(j,patternslength)) private void addterm(map map,string term) Selitys: Lisää termin term hajautustauluun map, jos sitä ei siellä jo ole. Muutoin kasvatta löytyneiden termien määrää yhdellä. Hajautustaulun avaimena on termin nimi ja arvona IndexData olio. if (map.containskey(term)) IndexDataImpl data = map.get(term) data.onemore() else

26 22 if (!stoplist.contains(term)) map.put(term, new IndexDataImpl(term)) IndexDataImpl implements IndexData Selitys: Indexer luokan sisäinen luokka. Implementaatio rajapinnalle IndexData AdjNHPattern implements TermPattern Selitys: Löytää seuraavan laiset termi hahmot ([&A>]*[NH]). public int find(sentence s, int location) Selitys: Löytää seuraavan laiset termi hahmot ([&A>]*[NH]). state = START_STATE; int startlocation = location while (true) switch (state) case START_STATE: if (s.gettoken(location).containstag("&>a")) state = PREADJ_STATE ++location else if (s.gettoken(location).containstag("nh")) state = NH_STATE ++location else return 0 break case PREADJ_STATE: if (s.gettoken(location).containstag("&>a")) ++location else if (s.gettoken(location).containstag("nh")) state = NH_STATE ++location else return 0 case NH_STATE: return location-startlocation IndexException extends Exception Indeksoinnista tapahtuneet poikkeukset. public IndexException(String reason) Selitys: Luo uuden IndexException olion. Parametrinaan se saa poikkeuksen syyn.

27 IndexMain Komentoriviohjelma, joka saa parametreinaan konfiguraatiotiedostojen systemconfig ja sourceconfig osoitteet. Ohjelma luo uuden tietokannan ja indeksoi määritellyn aineiston käyttäen muita Indekseri ja Fdg osajärjestelmien luokkia. Metodit: public static void main(string[] args) Selitys: Lukee komentoriviparamterit. Välittää systemconfig konfiguraatioparametrina annetun systemconfig konfiguraatiotiedoston osoitteen Config luokalle, joka tarjoaa aksessorit konfiguraatiotiedostossa määritellyille systeemiasetuksille. Välittää Config:lta saamansa systeemiasetukset niitä tarvitseville tahoille ja luo tarvittavat oliot. Indeksoi konfiguraatiotiedostoissa määritellyn aineiston käyttäen RDFIndexer:iä ja Index:iä ja tämän luokan apumetodeita. private void index() Selitys: Lukee sourceconfig konfiguraatiotiedoston. Syöttää sourceconfig konfiguraatiotiedostossa luetellut tiedostot RDFIndexer:lle indeksoitavaksi. Kun kaikki materiaali on käsitelty, päivittää viittausten painoarvot kutsumalla Index:n updateweightsmetodia. createrdfindexer(); parse filelist from sourceconfig for each uri in filelist if(uri points to a directory) add each file in directory to filelist else // uri must point to a file rdfindexer.index( uri ); filelist.remove( uri ); //finally index.updateweights private Indexer createindexer Selitys: Pyydä Config:lta Fdg:n konfiguraatioparametrit. Luo SocketFdg olio Luo Indexer olio -anna SocketFdg konstruktorissa. Luo RDFIndexer rdfindexer -anna Indexer konstruktorissa. Anna RDFIndexerille filtteriasetukset. private Index createindex Selitys: Luo Index index Anna Index:lle systeemiasetukset Alusta index

28 public public public public public public Occurrence Selitys: DocumentRef ja Predicate luokkien geneerinen yliluokka. Occurrence edustaa ilmentymää. Occurrence oliolla on nimi ja painoarvo ja voi sisältää joukon Occurrence-olioita, jotka edustavat aliesiintymiä. Attribuutit: String name float weight Set occurrences Selitys: nimi Selitys: Ilmentymän painoarvo Selitys: ilmentymän aliesiintymät. Konstruktori: Config(String name) Selitys: luo uusi ilmentymä. Anna ilmentymän nimi parametrina. Metodit: Attribuuteille tarjotaan asianmukaiset aksessorit: void setweight(float weight) Selitys: aseta ilmentymän painoarvo float getweight() Selitys: palautta ilmentymän painoarvon String getname() Selitys: palautta ilmentymän nimen void addoccurrence(occurrence occurrence) Selitys: lisää aliesiintymä. Set getoccurrences() Selitys: palauttaa kaikki aliesiintymät Predicate extends Occurrence Index palauttaa, kutsuttaessa sen metodia getreferences paramterina annettua hakusanaa vastaan joukon DocRef olioita, jotka edustavat viittauksia resursseihin, joiden kuvauksessa hakusana on esiintynyt. DocRef olio sisältää joukon Predicate -olioita jotka edustavat ominaisuuksia (Property), joiden 'alla' literaalimuotoisissa objekteissa termi on esiintynyt. Index luo DocRef ja Predicate oliot tietokannan tietojen perusteella ja asettaa DocRefille sille kuuluvat Predicate:t kutsumalla toistuvasti DocRef:n metodia addpredicate(predicate). Attribuutit: name Selitys: RDF kuvauksessa ominaisuuden nimi koostuu nimiavaruus- ja nimi-osasta.tämä on myös vastaavan Predicate -olion nimi, joka sille annetaan konstruktorissa. occurrencesofterm Selitys: tieto siitä, kuinka monta kertaa hakusana on esiintynyt Predicaten edustaman

29 public public public public public 25 ominaisuuden objektissa. weight Selitys: Predicatelle voidaan asettaa painoarvo. Konstruktori: Predicate(java.lang.String name, int occurrencesofterm) Selitys: luo uusi Predicate -olio. Anna paramtreina nimi ja termin esiintymäkertojen lukumäärä. Metodit: Attribuuteille tarjotaan asianmukaiset aksessorit: float getweight() Selitys: Palauttaa ko. predikaatin painoarvon. void setweight(float _weight) Selitys: Aseta ko. predikaatin painoarvo. int getoccurrencesofterm() Selitys: Palauttaa tiedon siitä, kuinka monta kertaa ko. termi on esiintynyt tämän predikaatin objektissa. java.lang.string getname() Selitys: Kertoo ko. predikaatin nimen RDFIndexer RDFIndexer käyttää RDQL-kyselykieltä indeksoitavan aineiston hakemiseen kohdetiedostoista. Kohdetiedostot annetaan RDFIndekser:lle käsiteltäväksi metodilla index(url fileuri), jonka paramterina annettu url osoite viittaa käsiteltävään tiedostoon. RDF-muotoinen data käsitellään Jenan avulla. Kohdetiedostojen tulee olla syntaksiltaan xm/rdf:ää, jotta niitä pystytään käsittelemään Jenalla. Ennen indeksointia, täytyy RDFIndekser:lle kertoa niiden ominaisuuksien nimet joiden objekteista halutaan termejä hakea. RDFIndexer:n voi käsitteellisesti ajatella sisältävän suodattimen (filter), joka päästää käsittelyyn vain halutut ominaisuudet kustakin kuvaksesta -kaikki turha aineisto suodatetaan annetusta materiaalista pois -, josta metodin setfilter nimi juontuu. Kohdetiedostoista käsitellään kaikki kuvaukset (Description) ja kustakin kuvauksesta käytetään indeksointiin hakusanoja, jotka löytyvät haluttujen ominaisuuksien (Property) objekteista (Object). Vain literaalimuotoiset (merkkijonot) objektit käsitellään. Käsiteltävät ominaisuudet ilmoitetaan systemconfig-konfiguraatiotiedostossa. RDFIndexer käyttää Indexer:iä indeksoitavien kuvausten sisältämän luonnollisen kielen käsittelyyn. RDFIndekser antaa indeksoitavat tiedot Index:lle, joka lisää ne tietokantaan.

30 26 Konstruktori: public RDFIndexer(samo.indexer.Index index, samo.indexer.indexer indexer) Alusta RDFIndexer. Parametrit: index - Käytettävä index-olio. indexer - Käytettävä indekseri. Metodit: public void setfilter(java.util.list wantedproperties) Selitys: Anna listassa niiden predikaattien nimet, joiden sisällöt (objektit ) indeksoitavista resursseista halutaan indeksiin. public void index(java.net.url fileuri) Selitys: Käsittelee tiedostosta, johon annettu uri osoittaa, kaikki resurssit ja indeksoi ne. Annetun urin tulee osoittaa rdf-tiedostoon. parse Model model from fileuri for each resource in model about = get name of resource // name of subject for-each predicatename in wantedproperties content = query content of property // triplet: ( about, predicatename,? ) if resource has property by predicatename i.e. content is not null Set indexdatatokens = indexer.index( content ); index.add(indexdatatokens, about, predicate) interface TermPattern Indexer käyttää TermPattern rajapintaa termien etsimiseen virkkeestä. Ideana on, että termillä on jokin hahmo, joita etsitään virkkeistä. Esimerkki termi hahmosta voisi olla vaikkapa ([&A>]*[NH]), eli etuatribuutti nolla tai useamman kerran ja lopulta nominaalinen pääsana. Metodit: public int find(sentence s, int location) Selitys: Metodi etsii virkkeen s kohdasta location hahmoansa vastaavan termin. Metodi palauttaa termin pituuden tai 0, jos hahmoa vastaavaa termiä ei löytynyt kohdasta location

31 27 4 Fdg Fdg osajärjestelmän tehtävänä on tarjota rajapinta Connexorin ( luonnollisen kielen analysaattoriin Fdg3. Analysaattori pätkii sille tuotetun tekstin virkkeiksi. Se tuottaa virkkeen sanoille sekä morfologista informaatiota, että informaatiota sanojen suhteesta toisiinsa. Esimerkiksi virkeen Tämä on testi. analyysi on tekstimuodossa esitettynä seuraava: 1 Tämä tämä subj:>2 &NH PRON SG NOM 2 on olla main:>0 &+MV V ACT IND PRES SG3 3 testi testic comp:>2 &NH N SG NOM 4.. Eli kullakin rivillä on virkkeen yksi sana. Virke alkaa riviltä, jonka ensimmäinen kenttä on 1 ja loppuu rivelle, jonka toinen kenttä on joko <s> tai <p>. Kenttien erottimina on tabulaattori. Kenttien merkitykset ovat järjestyksessä: numeraalinen osoite, sanamuoto, perusmuoto, dependenssilinkki ja luenta. Yhdessä luennassa on sanan morfologiset ja pintasyntaktiset tägit. Lisätietoa tägeistä löytyy Fdg3 analysaattorin manuaalista. Luentoja voi olla myös useampia kuin yksi, jos analyysi on moniselitteinen. Fdg3:n tuottaman virke voidaan nähdä kahdella tavalla: 1) Se on sanojen muodostama lineaarinen rakenne, jossa sana seuraa toista. 2) Virke on puu, jonka solmuja ovat sanat ja sanoja yhdistävät dependenssikaaret. Kuvassa 6 on esitetty esimerkkivirke puuna. Tuloksen neljäs kenttä kertoo sanan funktion suhteessa sen pääsanaan. Eli neljäs kenttä on muotoa funktio>pääsanan osoite. Root main.: on comp: subj: Tämä testi Kuva 6 Fdg3 analysaattorin muodostama virke esitettynä puuna Kuvassa 7 on esitetty fdg paketin luokkakaavio. Paketti sisältää luokat, jotka tarvitaan tekstin morfologiseen analysoimiseen. SentenceParser on rajapinta analysaattoriin, joka analysoi tekstin virkeittäin.

32 28 SentenceParserin tehtävä on tuottaa Sentence olioita sille syötetystä tekstistä. SentenceParserin analyse metodit saavat parametrinaan analysoitavan tekstin ja Analysis olion. Analysoitava teksti välitetään joko tekstinä tai Reader oliona parserille. Parseri tuottaa Sentence oliota ja välittää ne eteenpäin rajapinnassa Analysis määritellyn metodin boolean nextsentence(sentence s) avulla. Jos tämä metodi palauttaa false, analyysi keskeytetään. Muutoin sitä jatketaan, kunnes koko teksti on syötetty parserille. Kaikki SentenceParserin metodit heittävät poikkeuksen SentenceParseException, jos jotain poikkeuksellista tapahtuu analysoinnin kuluessa. Mahdollisia poikkeustapauksia ovat ainakin input/output virheet ja virheet kommunikoitaessa palvelimen kanssa. SentenceParser mahdollistaa myös perusmuodon generoimisen sille syötetystä sanasta metodilla getlemma(string). SenteceParser tuottaa Sentence olioita eli virkkeitä. Virke on sanojen eli Tokenien muodostama lineaarinen rakenne. Token voi sisältää myös usemman kuin yhden sanan. Virkkeen rakenne vastaa Connexorin Fdg3:n tuottaman virkkeen rakennetta, paitsi, että tässä toteutuksessa ei ole toteutettu dependenssi linkkejä ja Token luokkaan mahtuu vain yksi luenta eli moniselitteisiä analyyseja ei voi tallettaa virkkeeseen. Virkkeen ensimmäinen Token on virkkeen juuri, joka ei ole varsinainen sana. SocketFdg on SentenceParserin totetus käyttäen Connexorin Fdg3 pistoke-palvelinta. Palvelin on käynnistettävä teksti tilassa käyttäen vipusta --text. Kutsuttaessa analyse tai getlemma metodia, SocketFdg ottaa yhteyden palvelimeen ja lähettää analysoitavan tekstin säikeessä palvelimelle. Virheiden välittämiseen kutsuvalle metodille säikeestä luokka käyttää ThreadException luokkaa. SocketFdg käyttää virkkeiden tuottamiseen palvelimen tuloksesta SentenceParser luokkaa. Tämä luokka käyttää tuloksen jäsentämiseen FdgTokenizer luokkaa. Luokka vastaa StringTokenizer luokkaa, paitsi että se palauttaa tyhjän merkkijonon, jos seuraava token ei sisällä mitään. Kuvassa 8 on esitetty, mitä tapahtuu kun kutsutaan SocketFdgn analyse(reader, Analysis) metodia. Metodi saa parametrinaan tekstitiedoston ja Analysis instanssin, jolle analysoidut virkkeen välitetään. Ensin luodaan yhteys palvelimeen. Sen jälkeen kutsutaan plug metodia, joka saa parametrinaan tekstitiedoston (Reader), pistoke - (Socket) ja ThreadException instanssin. Plugmetodin kutsu on asynkroninen eli metodi luo uuden säikeen, joka lähettää tekstitiedoston palvelimelle. Jos säikeen suorituksen ainana tapahtuu poikkeus, metodi tallettaa poikkeuksen ThreadException instanssiin. Plug metodin kutsun jälkeen analyse metodi kutsuu SentenceFactoryn createsentence(bufferedreader) metodia kunnes metodi palauttaa null. CreateSentence-metodi saa parametrinaan palvelimelta tulevan tiedoston. SentenceFactory lukee tiedostosta seuraavan virkeen, tokenisoi sen käyttäen FdgTokenizer instanssia, luo uuden virkkeen ja palauttaa sen. Analyse metodi välittää luodun virkkeen Analysis instanssille.

33 Kuva 7: Fdg paketin luokkakaavi. Kuvassa on esitetty harmaalla ne luokat, jotka näkyvät paketin ulkopuolelle. 29

34 30 Kuva 8: Sekvessikaavio siitä, mitä tapahtuu kun kutsutaan SocketFdg:n analyse metodia. 4.1 Rajapinnat muihin osajärjestelmiin Indexer osajärjestelmän Indexer-luokka käyttää SentenceParser-luokan analyse(string,analysis)- metodia jäsentämään tekstin Sentence olioiksi. Sen jälkeen Indexer luokka etsii Sentence olioista termit käyttäen sanojen kieliopillista tietoa. Katso tarkempi kuvaus Indexer luokan kuvauksesta. Hakukone osajärjestelmä käyttää SentenceParser-luokan getlemma(string) metodia palauttamaan käyttäjän antamat hakutermit perusmuotoon. Hakutermit täytyy palauttaa perusmuotoon, koska Indexer tuottaa termit perusmuodossa. 4.2 Rajapinnat ulkoisiin elementteihin SocketFdg käyttää Connexorin Fdg3 sokettipalvelinta. Palvelin toimii Linux koneessa ja se on käynnistettävä seuraavasti fi-fdg port=<portti> --text. Portti on soketin portti, johon FdgSocket ottaa yhteyttä. Optio text käynnistää palvelimen tekstimoodissa. 4.3 Luokkien kuvaus

35 interface Analysis Rajapinta virke analyysille. SentenceParser välitää analysoimansa virkkeet tämän rajapinnan välityksellä. Metodit: public boolean nextsentence(sentence s) Selitys: Ilmoitus siitä, että seuraava virke on analysoitu. Parametrinaan metodi saa analysoidun virkkeen. Metodi palauttaa true, jos vastaanottaja halutaa vielä virkkeitä, muuten false. FdgTokenizer FdgTokenizer Yksinkertainen tokenizer merkkijonojen tokenisoimiseen. Eroaa javan standardikirjaston vastaavasta luokasta StringTokenizer siinä, että next() palauttaa tyhjän merkkijon siinä tapauksessa, että seuraavaksi vuorossa oleva kenttä on tyhjä. Konstruktori: public FdgTokenizer(String text,char delimiter) Selitys: Luo uuden tokenisoijan, joka tokenisoi tekstin text käyttäen erotinta delimiter. Metodit: public boolean hasnext() Selitys: Palauttaa true, jos tältä tokenizerilta voidaan pyytää vielä seuraava token. public String next() throws NoSuchElementException Selitys: Palauttaa seuraavan tokenin tästä tokenizerista. Heittää poikkeuksen, jos yhtään elementtiä ei ole enää jäljellä. public int tokencount() Selitys: palauttaaa tokenien määrän alusssa. Ei muutu kutsutaessa next() metodia. private void tokenize(string text, char delimiter, int position) Selitys: Tokenisoi tekstin text käyttäen erotinta delimiter alkaen positiosta position. Muodostaa sanojen linkitetyn listan Sentence Virke muodostuu sanoista (Token). Virke on sanojen muodostama lineaarinen rakenne. Virkkeen ensimmäinen Token on virkkeen juuri. Ensimmäinen varsinainen Token on positiossa 1. Virkkeen

36 rakenne vastaa Fdg3:n tuottamaa virkkeen rakennetta, seuraavin poikkeuksin, Sentence luokassa ei ole toteutettu dependenssilinkkejä ja Sentence luokkaan mahtuu tällä hetkellä vain yksi luenta. Tämä tarkoittaa sitä, että Sentence luokassa on vain yksi joukko tägeille, mutta Fdg3 voi tuottaa useita erilaisia morfologisia analyyseja yhdestä sanasta. Atribuutit: Token[] tokens Selitys: Token oliot taulukossa. Konstruktori: Sentence(int numoftokens ) Selitys: Luo uuden virkkeen. Parametrinaan konstruktori saa sanojen määrän virkkeessä. Metodit: public Token gettoken(int i) Selitys: Palauttaa sanan positiossa i. public String getlemma(int from, int to) Selitys: Palauttaa sanojen from - to perusmuodon. Esimerkiksi jos virke on "Punaiset kukat ovat kauniita.", ja tätä metodia kutsutaan parametrein (1,3), palauttaa metodi "punainen kukka". s= for i = from, i<to if (i!=from) s+= ; s+=gettoken(i).getword(); return s public int size() Selitys: Palauttaa sanojen määrän virkkeessä. void setword(int index,string word) Selitys: Asettaa Tokenin sanamuodon. Parametrinaan metodi saa Tokenin indeksin, jonka sanamuoto asetetaan ja asettavan sanamuodon. void setlemma(int index,string lemma) Selitys: Asettaa Tokenin perusmuodon. Parametrinaan metodi saa Tokenin indeksin, jonka perusmuoto asetetaan ja asettavan perusmuodon. void addtag(int index,string tag) Selitys: Lisää morfologisen tägin tokenille.parametrinaan metodi saa Tokenin indeksin, johon tägi lisätään ja lisättävän tägin SentenceFactory 32

37 33 SentenceFactoryn muodostaa virkkeitä Connexorin Fdg3:n tekstimuotoisesta outputista. Atribuutit: private Vector lines Selitys: Palvelimelta luettu virke. Vektorin yksi rivi vastaa virkkeen yhtä sanaa. Metodit: synchronized Sentence createsentence(bufferedreader br) throws IOException Selitys: Lukee seuraavan virkken tiedostosta br ja palauttaa siitä muodostetun Sentence instanssin. Jos virkkeitä ei ole enää jäljellä, palauttaa null. Heittää IOExceptionin, jos input output virhe tapahui luettaessa seuraavaa virkettä. sentence = null more = readnext() if (more) sentence = new Sentence(lines vektorin koko +1) for each line in the lines vector tokenizer = new FdgTokenizer(line,'\t') while (more tokens) pos 0 : jätä huomiotta pos 1 : sentence.setword(currentindex, token) pos 2 : sentence.setlemma(currentindex, token) pos 3 : jätä huomiotta pos >4: tagtokenizer = new FdgTokenizer(token,' ') while (more tokens) sentence.addtag(currentindex, token); return sentence; private static boolean readnext(bufferedreader br,vector lines) throws IOException Selitys: Lukee seuraavan virkkeen tiedostosta br. Tallettaa rivit vektoriin lines. Palauttaa true, jos virke saatiin luettua, muuten palauttaa false. Heittää IOExceptionin jos input output poikkeus tapahtui luettaessa tiedostoa. tyhjennä lines vektori vanhoista virkkeistä line = Etsi rivi, joka alkaa 1:llä if (line on null) return false; if (endofsen(line)) return true; do lisää line vektoriin lines while ((line=readline())!= null &&!endofsen(line)) return true; private static boolean endofsen(string line) Selitys: Palauttaa true, jos rivi on virkkeen loppu. Muuten false.

38 34 return (line alkaa "? \t<p>" tai line alkaa "? \t<s>") //Kysymysmerkki on mikä tahansa merkki SentenceParseException extends Exception Virkkeiden analysointiin liittyvä poikkeus. Konstruktori: public SentenceParseException(String reason) Selitys: Luo uuden SentenceParseException poikkeuksen. Parametrinaan se saa syyn, miksi poikkeus tapahtui interface SentenceParser Rajapinta parseriin, joka tuottaa sille syötetystä tekstistä virkkeitä. Analysoidut virkkeet välitetään kutsujalle rajapinnan Analysis välityksellä. Kaikki rajapinnan metodit heittävät SentenceParseException poikkeuksen, jos jotain poikkeuksellista tapahtuu analyysin aikana. Poikkeustapauksia ovat ainakin input/output virheet. Metodit: public void analyse(reader file, Analysis a) throws SentenceParseException Selitys: Analysoi tekstin, joka luetaan tiedostosta file. Analysoidut virkkeet välitetään rajapinnan Analysis instanssille a. Analyysi keskeytetään, jos nextsentence(sentence) palauttaa false. Analyse-metodin kutsu on synkroninen, se ei pääty ennenkuin analyysi on päättynyt. public void analyse(string text, Analysis a) throws SentenceParseException Selitys: Toimii kuten analyse(reader,analysis), mutta analysoi tiedoston sijaan tekstin text. public String getlemma(string token) throws SentenceParseException Selitys: Palauttaa sanan token perusmuodon SocketFdg SocketFdg tarjoaa pistokeyhteyden Connexorin Fdg3 palvelimeen. Atribuutit: private SentenceFactory sentencefactory Selitys: Tehdas, jota käytetään virkkeiden muodostamiseen palvelimen tuottamasta tuloksesta. Konstruktorit: public SocketFdg(String host, int port) Selitys: Luo uuden SocketFdg parserin. Parametrinaan konstruktori saa palvelimen nimen ja portin.

39 35 Metodit: public void analyse(reader file, Analysis a) throws SentenceParseException Selitys: Katso SentenceParser luokka vastaava metodi. luo uusi pistoke yhteys palvelimeen luo uusi ThreadException instanssi lähetä analysoitava teksti serverille käyttäen plug metodia r = pistoke.getreader() while (s = sentencefactory.createsentence(r)!= null) if (!a.nextsentence(s)) break; sulje palvelin yhteys sulje tiedosto tarkista poikkeukset public void analyse(string text, Analysis a) throws SentenceParseException Selitys: Katso SentenceParser vastaava metodi analyse(new StringReader(text),a) public String getlemma(string token) throws SentenceParseException Selitys: Palauttaa sanan token perusmuodon. analyse(token, analysis) s = ota vastaan yksi virke analysis olioon ja palauta false return s.getlemma(1,s.size()) private static void plug(final BufferedReader reader, final Socket server, final ThreadException tex) throws IOException, UnknownHostException Selitys: Metodi lähettää tiedostosta reader lukemaansa tekstiä palvelimelle server säikeessä. Jos lähettämisen aikana tapahtuu poikkeuksellista, poikkeus talletetaa tex instanssiin. out = server.getoutputstream(), luo uusi säie lähetä teksti tiedosta reader pistokkeseen server lähetä EOF merkki pistokkeseen if (tapahtuu poikkeus) tex.setexception(poikkeus) ThreadException Säikeen run metodi ei voi heittää poikkeusta, koska sitä ei ole määritelty säikeen rajapinnassa. ThreadException tarjoaa tavan välittää säikeen suorituken aikana tapahtunut poikkeus metodin kutsujalle. Jos metodi luo ja käynnistää uuden säikeen, niin tällöin yksi metodin parametreista on ThreadException instanssi. Jos säikeen suorituksen aikana tapahtuu poikkeus, säikeessä kutsutaan metodia setexception(exception). Kun säikeen suoritus on loppunut, metodin kutsuja tarkistaa, onko poikkeusta tapahtunut metodilla getexception(). Jos metodi palautta null, ei poikkeusta ole tapahtunut, muuten on.

40 36 Atribuutit: private Exception ex Selitys: Tapahtunut poikkeus, null jos poikkeusta ei tapahtunut. Metodit: public Exception getexception() Selitys: Palauttaa tapahtuneen poikkeuksen. public void setexception(exception ex) Selitys: Asettaa poikkeuksen Token Virke muodostuu Tokeneista (sanoista). Jokaisella Tokenilla on sanamuoto, perusmuoto ja sijainti virkkeessä. Lisäksi tokenilla on joukko morfologisia tägejä, jotka Fdg3 analysaattori on tuottanut. Atribuutit: private int pos Selitys: Sanan positio virkkeessä, johon sana kuuluu. private String word Selitys: Sanan sanamuoto. private String lemma. Selitys: Sanan perusmuoto. private TreeSet tagset Selitys: Joukko morfologisia tägejä. Konstruktorit: Token(int position) Selitys: Luo uuden sanan. Paramertinaan konstruktori saa position virkkeessä. Metodit: public String getword() Selitys: Palauttaa sanan sanamuodon. public boolean containstag(string tag) Selitys: Palauttaa true, jos Tokenenin tägisetti sisältää tägin tag. public String getlemma() Selitys: Palauttaa sanan perusmuodon.

41 37 public int getposition() Selitys: Palauttaa sanan position virkkeessä. void setlemma(string lemma) Selitys: Asettaa sanan perusmuodon. Parametrinaan funktio saa asettavan perusmuodon. void setword(string word) Selitys: Asettaa sanan sanamuodon. Parametrinaan funktio saa asettavan sanamuodon. void addtag(string tag) Selitys: Lisää morfologisen tägin tag sanan tägijoukkoon. 5 Hakukone Hakukoneeseen kuuluvat luokat on esitetty kuvassa 9. Hakukoneesta näkyy muihin osajärjestelmiin vain luokka SearchEngine, joka käyttöliittymä kutsuu. SearchMain-luokka perii SearchEngine-luokan ja ohjaa hakukoneen sisäistä toimintaa. Parser-luokka muodostaa hakulausetta vastaavan binääripuun, jonka solmut vastaavat hakulauseen termejä ja operaattoreita. Yläluokka Noden toteutukset, NodeAnd, NodeOr, NodeNot, NodeTerm, vastaavat hakulausetta kuvaavan binääripuun solmuja ja Term-luokka NodeTerm-tyyppiseen solmuun liittyvää hakutermiä. Processer-luokka sisältää erilaisia työkaluja hakupuun käsittelyyn. Metodeja käytetään hyväksi termien perusmuotoon palauttamisessa, synonyymien etsinnässä, homonyynien selvättämisessä ja alikäsitteiden hakemisessa. Processer-luokka käyttää apunaan ontologiaa(ontology), indeksiä(index) ja SentenceParser-luokkaa. Ontology-luokka tarjoaa Processer-luokalle palveluja homonyymien, synonyymien ja alikäsitteiden hakemiseen.

42 38 SearchEngine -root : Node -ontology : Ontology -sentenceparser : SentenceParser -index : Index -weights : Hashtable +search( ) +setontology( ) +setsentenceparser( ) +setindex( ) +setweight( ) Parser +parsetree( ) +printtree( ) +parseoperator( ) +parsesentence( ) +nexttoken( ) +emovespaces( ) +getoperator( ) +exit( ) NodeAnd +cut( ) uses creates NodeNot +not( ) SearchMain -depth : int -searchstring : String has Node_ -type : int -parent : Node -left : Node -right : Node -references : Set +processnode( ) +preprocess( ) NodeOr +union( ) uses uses NodeTerm -terms : List Processer +countweight( ) +term2basic( ) +findhononyms( ) +findsynonyms( ) +findhyponyms( ) +findreferences( ) +sortreferences( ) uses Ontology +parsefromrdfs( ) +getsynonyms( ) +gethomonyms( ) +getsubclasses( ) Term_ 1..* -term : String -type : int -level : int -references : Set Kuva 9 Hakukoneen luokkakaavio Hakukoneen käyttöliittymä luo SearchEngine-olion lisäksi Ontologia-, sentenceparser- ja Index oliot, jotka se välittää hakukoneelle. Hakukone käyttää käyttöliittymän luomaa Ontologia-oliota ontologian lukemiseen, sentenceparser-oliota hakutermien perusmuotoon palauttamiseen sekä Index-oliota etsimään viitteet indeksitietokannasta. Lisäksi käyttöliittymä välittää SearchEngine-luokalle konfiguraatiotiedostosta lukemansa hakutuloksen painotukseen liittyvät tiedot: Kun RDF-muotoiset esinekortit indeksoidaan, talletetaan indeksiin termin lisäksi tieto siitä, missä esinekortin kentässä termi on esiintynyt. Hakukone käyttää tätä tietoa hyväksi järjestäessään hakujen tuloksena löytyneitä viitteitä painoarvon mukaiseen järjestykseen. Konfiguraatiotiedostossa eri kenttien painoarvo määritellään kentän nimi (String) painoarvo (float) pareina eli esimerkiksi asiasana-kenttä voi saada painoarvon 1 ja vapaateksti-kenttä painoarvon 2. Tällöin viittauksista relevanteimpia olisivat ne, joissa hakutermi on esiintynyt asiasana-kentässä. Nämä viittaukset myös näytettäisiin hakutuloksessa ensimmäisenä. Painoarvojen laskemiseen käytetään kuitenkin muitakin muuttujia kuin vain konfiguraatiotiedossa määritellyt yksittäisten kenttien painoarvot. Painojen laskemista ja hakutuloksen järjestämistä on kuvattu tarkemmin Processer-luokan countweight-metodin yhteydessä luvussa Asetettuaan yllä mainitut muuttujat hakukoneen käyttöön, käyttöliittymä kutsuu search-metodia, joka saa parametreikseen käyttäjän antaman hakulauseen (String) ja tiedon siitä, kuinka syvälle ontologiassa hakua laajennetaan (int). Käyttäjän antama hakulause voi olla vain yksi hakutermi tai se voi koostua useasta Boolen operaattoreilla (JA, TAI ja EI) yhdistetystä hakutermistä. Hakutermien ja Boolen operaattorien lisäksi hakulause voi sisältää sulkeita, joilla osoitetaan operaattorien suoritusjärjestystä sekä lainausmerkkejä fraasien (esimerkiksi Suomen lippu ) esittämiseen.

43 Abstrakti search-metodi toteutetaan SearchMain-luokassa. Aluksi search-metodi luo Processer-luokasta olion. Processer-luokka sisältää työkaluja hakupuun käsittelyä varten. Seuraavaksi kutsutaan Parser-luokan metodia parsetree. ParseTree-metodi käy läpi käyttäjän antaman hakulauseen ja tutkii, että se on oikeanmuotoinen. Metodi luo hakulausetta vastaavan binääripuurakenteen, jossa hakutermejä ja Boolen operaattoreita vastaavat Node-oliot NodeAnd, NodeOr, NodeNot ja NodeTerm. NodeTerm-tyyppiseen binääripuun solmuun liittyy lista Term-olioita. Tässä vaiheessa listaan lisätään alkuperäinen käyttäjän antama hakutermi. Mikäli hakulause ei ole muodoltaan oikein, palautuu käyttöliittymälle siitä poikkeus (exception: virheellinen hakulause ). Kun hakulauseesta on jäsennetty puu, kutsutaan Node-luokan metodia preprocess. Tämä metodi suorittaa NodeTerm-olioille ns. esikäsittelyn eli se selvittää termien perusmuodot, mahdolliset homonyymit, synonyymit ja alikäsitteet. Näiden selvittämi-seen käytetään Processer-luokan metodeja. Jokainen hakusana muutetaan perusmuotoon. Tähän käytetään term2basic-metodia, joka käyttää SentenceParser-luokan tarjoamaan palvelua sanan muuttamiseksi perusmuotoon. Homonyymit selvitetään findhomonyms-metodilla. Mikäli termi on homonyymi, niin sitä ei laajenneta vaan tietokannasta haetaan viitteet ainoastaan termin perusmuodolla. Mikäli termi ei ole homonyymi tai sitä ei edellä EI-operaattori, niin selvitetään sille sekä synonyymit että alikäsitteet, jotka talletetaan NodeTerm-olioon liittyvään terms-listaan. Alikäsitteitä etsitään ontologiasta niin monta hierarkiatasoa alaspäin kuin käyttäjä on määritellyt haun syvyydeksi. Näiden alikäsitteiden ja synonyymien selville saamiseksi Processer-luokka käyttää Ontology-luokan tarjoamia palveluja. Seuraava askel haun suorittamisessa on termien viitteiden haku tietokannasta ja niiden käsittely. Tähän käytetään metodia process. Tämä toteutetaan jokaisessa Node-luokassa erilailla. NodeAnd-luokan process-metodi suorittaa matemaattisen leikkaus-operaation kumpaankin lapseen liittyville joukoille ja palauttaa tämän ylöspäin hakupuussa. NodeOr-luokassa metodi suorittaa matemaattisen yhdiste-operaatio molempiin lapsiin liittyville joukoille ja NodeNot-luokassa tehdään vastaavasti not-operaatio. NodeTerm-luokassa process-metodi kutsuu Processer-luokan findreferences-metodia parametrinaan Term-olioita sisältävä lista terms. FindReferences käy listaa läpi ja hakee tietokannasta jokaiselle listan termille viitteet. Samalla viittteille lasketaan paino käyttämällä Processer-luokan metodia countweight. Kyseinen DocumentRef-olio lisätään attribuuttiin final, joka on tyyppiä Set. Tämä on joukko, johon kerätään kyseiseen NodeTerm-olion termeihin liittyviä viitteitä. Mikäli kyseinen viite on jo joukossa final, päivitetään joukossa olevan viitteet painoa lisäämällä sen painoon juuri laskettu paino. Näin ollen kyseisen viitteen paino nousee, koska kyseisestä esinekortista löytyy hakusanoja, jotka ontologian mukaan liittyvät siihen. Kun kaikki NodeTerm-olioon liittyvät termit on käsitelty, on jäljellä yksi joukko(final), joka palautetaan. Processer-luokan metodi sortreferences saa syötteenään tämän joukon, josta se muodostaa listan painokertoimien mukaan siten, että korkeimman kertoimen omaava viite tulee listan kärkeen. Tämä lista palautetaan edelleen käyttöliittymälle. 5.1 Rajapinnat muihin osajärjestelmiin Vain SearchEngine-luokka on kutsuttavissa hakukoneen ulkopuolelta. SearchEngine-luokalla on metodi search, jota SearchServlet eli haun käyttöliittymä kutsuu ja joka saa parametrinaan käyttäjän antamat hakutiedot eli String-tyyppisen hakulauseen sekä int-tyyppisen arvon, joka kertoo, kuinka monelta tasolta ontogiasta etsitään. Metodi palauttaa hakutuloksen eli painokertoimien mukaan 39

44 40 järjestetyn URI-listan. Jos haulla ei löydy mitään, palautetaan tyhjä lista. Jos haun epäonnistumiseen on järjestelmästä johtuva syy, palautetaan poikkeus (Exception). SearchEnginellä on lisäksi metodeja, joilla käyttöliittymä asettaa hakukoneen käyttä-mään konfiguraation mukaista ontologiaa, sentenceparseria, indeksoijaa ja hakutuloksen painotusta. 5.2 Rajapinnat ulkoisiin elementteihin Hakukone käyttää välillisesti ulkoisia elementtejä seuraavien luokkien kautta: Konfiguraatiotiedostoa käyttöliittymäluokan SearchServlet kautta, ks. luku 6. Ontologiaa (Jenaa) Ontology-luokan kautta. Ontologia-luokan toiminta on kuvattu luvussa Fdg3-ohjelmaa SentenceParser-luokan kautta palauttamaan hakutermit perusmuotoon. SentenceParser-luokalla on metodi getlemma, joka saa parametrina termin, joka halutaan muuntaa perusmuotoon, ks. luku Index-luokkaa etsimään viittaukset viitetietokannasta, ks. luku Käyttöliittymä Hakukoneen käyttöliittymän toteuttaa SearchServlet-luokka, joka on kuvattu luvussa Luokkien kuvaus Node Node on yläluokka, jolla on neljä aliluokkaa, jotka toteuttavat sen: NodeAnd, NodeOr, NodeNot, NodeTerm eli puun solmut voivat olla neljää eri tyyppiä. NodeTerm-luokka eroaa siinä mielessä muista, että sen attribuuttina on lisäksi private List terms. Tähän listaan lisätään aluksi varsinainen hakutermi ja sen jälkeen haun syvyyden mukaan ontologiasta haetut synonyymit ja alikäsitteet. Attribuutit: Kaikille Node-luokan aliluokille yhteiset attribuutit ovat: solmun tyyppi (int type), solmun edeltäjä ( Node parent), solmun vasen ja oikea alisolmu (Node left ja Node right) sekä indeksistä löytyneet viittaukset Set-oliona (Set references). Solmun tyyppi kuvataan kokonaislukuna seuraavasti: Metodit: public static final int AND = 0; public static final int OR = 1; public static final int NOT = 2; public static final int WORD = 3; public void preprocess(processer p, int ontologylevel) throws SearcException Selitys: Metodi selvittää sanojen perusmuodot, homonyymit, synonyymit ja alikäsitteet. Varsinainen toteutus NodeTerm-luokassa.

45 41 if (Node.left!= null) Node.left.preProcess(p, ontologylevel) if (Node.right!= null) Node.right.preProcess(p, ontologylevel) public abstract Set processnode(processer p) throws SearchException Selitys: Metodi käsittelee hakupuuta operaattorien JA, TAI, EI tai termin osoittamalla tavalla. Metodin toteutus vaihtelee sen mukaan, minkä tyyppinen solmu on kyseessä NodeAnd Luokka NodeAnd perii luokan Node. NodeAnd-luokan oliot vastaavat hakulausetta kuvaavassa binääripuussa Boolen operaattoria JA. Metodit: public Set processnode(processer p) Selitys: JA-tyyppisen solmun processnode-metodi ottaa käsiteltäväkseen oikeaan ja vasempaan lapseensa liittyvää viitejoukkoja ja vertaa listoja toisiinsa. Jos sama viite löytyy molempien lapsisolmujen joukoista, otetaan kyseinen viite mukaan palautettavaan joukkoon. Set leftchild = Node.left.preProcess(p) Set rightchild = Node.right.preProcess(p) return cut(leftchild, rightchild) private Set cut(set leftchild, Set rightchild) Selitys: Metodi suorittaa matemaattisen leikkaus-operaation kahdelle joukolle NodeNot Luokka NodeNot perii luokan Node. NodeNot-luokan oliot vastaavat hakulausetta kuvaavassa binääripuussa Boolen operaattoria EI. Metodit: public Set processnode(processer p) Selitys: EI-tyyppisen solmun processnode-metodi käsittelee oikean ja vasemman lapsensa palauttamat viitejoukot. Set leftchild = Node.left.processNode(p) Set rightchild = Node.right.processNode(p) return not(leftchild, rightchild) private Set not(set leftchild, Set rightchild) Selitys: Metodi saa parametrinaan kaksi viitejoukkoa, joille se suorittaa matemaattisen NOToperaation. Metodi lisää palautettavaan viitejoukkoon viitteitä leftchild-joukosta, mikäli kyseistä viitettä ei löydy rightchild-joukosta.

46 NodeOr Luokka NodeOr perii luokan Node. NodeOr-luokan oliot vastaavat hakulausetta kuvaavassa binääripuussa Boolen operaattoria TAI. Metodit: public Set processnode(processer p) Selitys: TAI-tyyppisen solmun processnode-metodi käsittelee oikeaan ja vasempaan lapseensa liittyviä viitejoukkoja ja suorittaa niille yhdisteen. Set leftchild = Node.left.processNode() Set rightchild = Node.right.processNode() return union(leftchild, rightchild) private Set union(set leftchild, Set rightchild) Selitys: Metodi suorittaa kahdelle joukolle matemaattisen leikkaus-operaation eli se ottaa mukaan palautettavaan joukkoon viitteet, jotka löytyvät sen vasemmasta tai oikeasta lapsesta NodeTerm Luokka NodeTerm perii luokan Node. Alkuperäisen hakulauseen jokaisesta hakutermistä tulee NodeTerm-tyyppinen solmu hakulausetta kuvaavaan binääripuuhun. Attribuutit: Toisin kuin muut solmu-oliot, NodeTermillä on oma attribuutti, List terms eli lista Term-olioita. Kun jokaisesta hakulauseen termistä tehdään NodeTerm-olio hakulausetta kuvaavaan binääripuuhun, tehdään hakutermistä myös Term-olio, joka liitetään ensimmäiseksi NodeTermin sisältämään terms-listaan. Samaan listaan liitetään Term-olioina myös ontologiasta etsityt synonyymit ja alikäsitteet. Metodit: public void preprocess(processer p, int level) Selitys: Metodi selvittää termin perusmuodon, mahdolliset homonyymit, synonyymit ja alikäsitteet. Perusmuotoon muuttamiseen käytetään Processer-luokan metodia term2basic. Mikäli termi on homonyymi eli sille löytyy enemmän kuin yksi yläkäsite, ei sitä laajenneta ontologiassa. Laajentamista ei tehdä myöskään silloin, kun kyseinen solmu on NodeNOT-tyyppisen solmun oikea lapsi. Muussa tapauksessa selvitetään ensin kyseisen termin synonyymit, jonka jälkeen haetaan termille ontologiasta alikäsitteet käyttäjän määrittelemästä syvyydestä asti. String originalterm = Term.term; String basicterm = p.term2basic(originalterm) if ( originalterm!= basicterm ) Term.term = basicterm; if ( p.findhomonyms(basicterm)!= true AND node.parent!= NodeNOT)

47 43 List synonyms = p.findsynonyms(basicterm) for each String in synonyms list do terms.add(synonyms.getnext) List subclasses = p.findhyponyms() terms.add(subclasses.getnext) public Set processnode(processer p) Selitys: Metodi käyttää hyväksi Processer-luokan metodia findreferences. Kyseinen metodi hakee termeille viitteet indeksistä, laskee niille painokertoimen ja muodostaa kaikista viitteistä yhteisen joukon, jonka se palauttaa. return p.findreferences(terms) Ontology Ontology-luokan tehtävänä on laajentaa käyttäjän antamaa hakua ontologiaa hyväksi käyttäen. Ontologian kuvaamiseen käytetään RDFS-kieltä, jolla kuvataan käsitteiden välisiä riippuvuuksia. Kyselyjä RDFS:ään tehdään Jenan kyselykomentoja käyttäen. Luokan metodi parsefromrdfs lukee ja käsittelee annetun ontologian Ontology-luokan metodien getsynonyms, gethomonyms ja getsubclasses käyttöön. Lisäksi Ontology-luokka ottaa vastaan hakukoneen Processer-luokan findhomonyms, findsynonyms ja findhyponyms-metodien kutsut. Metodien parametrinä on käyttäjän antama String-muotoinen hakusana. Ontology-luokan metodi getsynonyms palauttaa hakusanan synonyymit, getsubclasses palauttaa hakusanan alikäsitteet ja gethomonyms palauttaa hakusanan homonyymit Processer-luokalle. Alikäsitteet, synonyymit ja homonyymit etsitään RDFS-muotoisesta tiedostosta Jenan kyselykomen-toja käyttäen. Konstruktori: public Ontology(String uri) Selitys: Ontology-luokka saa konstruktorissa osoitteen konfiguraatiotiedostoon, jossa on tieto ontologian sijainnista. Ontologia on RDFS-muotoinen tiedosto. Konfiguraatiotiedosto on XML-muotoinen tiedosto(viitteenä). Metodit: public Model parsefromrdfs(string uri) Selitys: Metodilla luetaan Jenan read-metodia käyttäen RDFS-muotoinen tiedosto uri:n ilmoittamasta osoitteesta ja muodostetaan Jenan kyselykomentojen käyttöä varten tarvittava mallin. Model model = new ModelMem() read(model model, java.lang.string url) public List getsynonyms(string hakusana) Selitys: Hakukoneen Processer-luokan metodi findsynonyms kutsuu Ontologyluokan metodia getsynonyms. Ontology-luokan getsynonyms-metodi saa parametriksi String-tyyppisen hakusanan. Hakusanan perusteella haetaan RDFS-

48 44 tiedostosta (ontologiasta) annettua hakusanaa vastaavat synonyymit. Kysely RDFS:ään tehdään Jenan kyselykomentoja käyttäen. Haun tuloksesta valitaan literaalit palautettavaksi hakukoneelle. Jenan kyselyyn kuuluvat seuraavat osat: kyselylause, luodaan kyselyn suoritukseen tarvittavia olioita ja kutsutaan kyselyyn osallistuvia metodeja ja muodostetaan kysely. Lopuksi muodostetaan kyselyn tulos ja tuloksesta lista palautettavaksi Processerluokalle. String querystring = SELECT?o WHERE r=hakusana p=...#synonyymi Query query = new Query(queryString) ; query.setsource(model); QueryExecution qe = new QueryEngine(query) ; QueryResults qres = qe.exec(); QueryResults qres.close(); QueryResults qres.end(); for (Iterator iter = result; iter.hasnext();) { ResultBinding res = (ResultBinding iter.next(); Resource r = (Resource)res.get( ); Literal l =(Literal)res.get( ) } List() List.add() List.getItemCount() List.getIem(String item) public List getsubclasses (String hakusana) Selitys: Hakukoneen Processer-luokan metodi findhyponyms kutsuu Ontologyluokan metodia getsubclasses. Ontology-luokan getsubclasses-metodi saa parametriksi String-tyyppisen hakusanan. Hakusanan perusteella haetaan RDFStiedostosta (ontologiasta) annettua hakusanaa vastaavat alikäsitteet. Kysely RDFS:ään tehdään Jenan kyselykomentoja käyttäen. Haun tuloksesta valitaan literaalit palautettavaksi listana hakukoneelle. Processer-luokan suorittaa metodikutsua käyttäjän antaman haun syvyyttä vastaavan lukumäärän. String querystring = "SELECT? WHERE r=hakusana Query query = new Query(queryString) ; query.setsource(model); QueryExecution qe = new QueryEngine(query) ; QueryResults qres = qe.exec(); QueryResults qres.close(); QueryResults qres.end(); for (Iterator iter = result; iter.hasnext();) { ResultBinding res = (ResultBinding iter.next(); Resource r = (Resource)res.get( );

49 45 Literal l =(Literal)res.get( ) } List() List.add() List.getItemCount() List.getIem(String item) public List gethomonyms(string hakusana) Selitys: Hakukoneen Processer-luokan metodi findhomonyms kutsuu Ontologyluokan metodia gethomonyms. Ontology-luokan gethomonyms-metodi saa parametriksi String-muotoisen hakusanan. Hakusanan perusteella haetaan RDFStiedostosta (ontologiasta) annettua hakusanaa vastaavat homonyymit. Kysely RDFS:ään tehdään Jenan kyselykomentoja käyttäen. Haun tuloksesta valitaan literaalit palautettavaksi listana hakukoneelle. String querystring = SELECT r WHERE r=hakusana o=hakusana Query query = new Query(queryString) ; query.setsource(model); QueryExecution qe = new QueryEngine(query) ; QueryResults qres = qe.exec(); QueryResults qres.close(); QueryResults qres.end(); for (Iterator iter = result; iter.hasnext();) { ResultBinding res = (ResultBinding iter.next(); Resource r = (Resource)res.get( ); Literal l =(Literal)res.get( ) } List() List.add() List.getItemCount() List.getIem(String item) Parser Luokka Parser tuottaa hakulauseesta binääripuun, jossa jokaista hakulauseen termiä ja Boolen operaattoria vastaa NodeAnd, NodeOr, NodeNot tai NodeTerm -luokan olio. Parser käsittelee hakulausetta yksi merkitsevä merkki kerrallaan ja toimii sen mukai-sesti. Parserin algoritmi perustuu kielioppiin, jonka mukaan hakulause voi alkaa vain vasemmalla sulkumerkillä, termillä tai lainausmerkeillä merkityllä fraasilla. Tämän jälkeen hakulauseessa pitää olla Boolen operaattori ja toinen hakulauseen aloittava merkki tai merkkijono. Tekijöinnin jälkeen hakulausetta vastaava kielioppi voidaan esittää muodossa: E = TE E = Operaattori E tyhjä T = fraasi termi (E)

50 46 Kieliopin mukaan esimerkiksi hakulauseen kissa JA (koira TAI haukku) jäsentäminen ja muuntaminen binääripuurakenteeksi etenee seuraavasti: Ensimmäinen parsesentence-metodin lukema merkitsevä merkkijono on termi, josta luodaan NodeTerm-olio. Sen jälkeen luetaan seuraava merkkijono ja jos hakulause jatkuu vielä, on kieliopin mukaan termin jälkeen tultava Boolen operaattori. Seuraavaksi tutkitaan, mikä operaattori on kyseessä ja luodaan operaattorin tyyppiä vastaava NodeAnd-olio ja NodeTerm-oliosta tulee sen vasen lapsi. Sen jälkeen kutsutaan parsesentence-metodia uudelleen, jotta saadaan tietää, mitä solmuolion oikeaan haaraan tulee. Seuraavaksi luetaan vasen sulku, jolloin kutsutaan uudelleen parsesentence-metodia ja jäsennetään sulkujenvälinen osuus samaan tapaan kuin sulkuja ennen ollut osuus: luodaan koiraa vastaava NodeTerm-olio, josta tulee TAI-operaattoria vastaavan NodeOr-olion vasen lapsi ja lopuksi haukkua vastaava NodeTerm-olio, josta tulee NodeOr-olion oikea lapsi. Kun kohdataan viimeinen merkitsevä merkki eli loppusulku, on valmiina koko alipuu koira TAI haukku, joka voidaan liittää puun juuren eli NodeAnd-solmun oikeaksi lapseksi. Hakulausetta vastaava binääripuu näyttäisi tältä: Attribuutit: NodeAnd NodeTerm NodeOr kissa NodeTerm NodeTerm koira haukku Parserilla on sisäinen luokka Token hakulauseen sisältämien merkkijonojen tunnis-tamiseen ja käsittelyyn. class Token { static public final int WORD = 0; static public final int LEFT_PARENTHESIS = 4; static public final int RIGHT_PARENTHESIS = 5; static public final int EOL = 6; } public int type; public String data= ""; Lisäksi Parser-luokalla on attribuutti String searchstring, joka sisältää aina vielä käsittelemättömän osan hakulauseesta. Private Token token attribuutti sisältää aina hakupuun viimeksi käsitellyn osan. Metodit: private void printtree(node n) Selitys: Tulostusmetodia tarvitaan testauksessa. PrintTree-metodi tulostaa hakulausetta kuvaavan puun ja sen vasemman ja oikean haaran ylhäältä alaspäin. Viimeisenä tulostuvat puussa alimpana olevat termit.

51 47 if (n.type!= Node.WORD) print Node n + n. left + n.right printtree(n.left) printtree(n.right) else print WORD public Node parsetree(string searchstring) throws Exception Selitys: Metodi aloittaa hakulauseen käsittelyn poistamalla hakulauseen alusta mahdolliset välilyönnit. Sen jälkeen etsitään hakulauseen alusta seuraava merkitsevä osa Token-olioon ja aloitetaan hakulauseen parsiminen kutsumalla parsesentencemetodia. Metodi saa parametrinaan hakulauseen searchstring (String) ja se palauttaa parsitun puun juurisolmun tai poikkeuksen, jos hakulause ei ole validi. this.searchstring = searchstring; removespaces(); nexttoken(); Node tree = parsesentence(); return tree; private Node parseoperator(node left) throws Exception Selitys: Metodi käyttää getoperator-metodia ratkaisemaan, onko hakulauseesta löydetty operaattori JA-, TAI- vai EI -tyyppinen ja asettaa uuden, luodun operaattorisolmun paikoilleen puuhun. Metodi saa parametrinaan sen NodeTermolion, josta tulee uuden operaattorisolmun vasen lapsi. Sen jälkeen jatketaan parsimista eli tutkitaan, mitä operaattorisolmun oikeaan haaraan mahdollisesti tulee. Metodi palauttaa uuden operaattorisolmun tai poikkeuksen, jos ei löydy oikeanmuotoista operaattoria oikealta paikalta. Node n = getoperator (token data); n.left = left; nexttoken; n.right = parsesentence(); return n; private Node parsesentence() throws Exception Selitys: Metodi on rekursiivinen. Se aloittaa parsimisen hakulauseen alusta tutkimalla, mikä on seuraavan Token-olion tyyppi: lauseen alussa voi olla vain sana, lainausmerkein erotettu fraasi tai sulkumerkki. Metodi palauttaa puun tai alipuun juurisolmun tai poikkeuksen, jos hakulause ei ole validi. switch (toke.type) case WORD: leftword = new NodeTerm nexttoken() if ( token == EOL token == RIGHT_PARENTHESIS) return leftword; return parseoperator (leftword); case LEFT_PARENTHESIS: nexttoken(); Node n = parsesentence(); find RIGHT_PARENTHESIS;

52 48 if (not RIGHT_PARENTHESIS) throw exception if ( token == EOL token == RIGHT_PARENTHESIS) return n; return parseoperator (n); case EOL: return null; default throw exception; return null; private void nexttoken() Selitys: Jos hakulausetta on jäljellä, NextToken-metodi etsii hakulauseen käsittelemättömän osan alusta seuraavan käsiteltävän osan, joka voi olla oikea tai vasen sulkumerkki, lainausmerkillä alkava fraasi tai sana. Osasta luodaan uusi Token-olio ja se poistetaan jäljellä olevasta, vielä käsittelemättömästä hakulauseesta. if (searchstring.length() == 0) return; char c = searchstring.charat(0); if(c == '(') token.type= LEFT.PARENTHESIS searchstring = searchstring-1 if(c == ')') token.type= RIGHT.PARENTHESIS searchstring = searchstring-1 if(c == '"') next_" = find next " token.type = word between '"' and next_" searchstring = searchstring (word between '"' and next_"+2) else token.type == WORD; searchstring = searchstring-word; private void removespaces() Selitys: RemoveSpaces-metodi poistaa kulloisenkin käsittelemättömän hakulauseen osan alusta välilyönnit. while (searchstring.lenght () > 0 && searchstring.charat(0) == ' ') searchstring = searchstring.substring(1); private Node getoperator(string word) throws Exception Selitys: Metodi saa parametrikseen merkkijonon, jonka pitäisi vastata operaattoria. Ensin metodi muuttaa operaattorisanan suuraakkosiksi ja tutkii sitten, onko kyseessä JA-, TAI-, EI -operaattori ja luo sen mukaisen Node-olion. Metodi palauttaa poikkeuksen, jos merkkijono ei vastaa mitään operaattorin tyyppiä. word = word.touppercase(); if (word == "AND") return new NodeAnd(); if (word == "OR") return new NodeOr();

53 49 if (word == "NOT") return new NodeNot(); else throw new Exception ("no operator"); Processer Processer-luokka sisältää erinäisiä työkaluja hakupuun käsittelyä varten. Metodi term2basic saa parametrina merkkijonon, jonka se muuntaa perusmuotoon käyttämällä SentenceParser-luokan getlemma-metodia. FindHomonyms-metodilla selvitetään Ontology-luokan tarjoamaa palvelua hyväksikäyttäen onko kyseinen termi homonyymi. Mikäli näin on, palautetaan true. Myös findsynonyms-metodi käyttää hyväkseen Ontology-luokkaa selvittämään termin synonyymit. Metodi palauttaa synonyymit listana. Termin alikäsitteet selvittää metodi findhyponyms Ontologyluokan metodia getsubclasses, joka palauttaa listana termille löytyneet alikäsitteet. Metodi findrefe-rences käy läpi parametrina saamaansa Term-olioita sisältävää listaa läpi ja hakee jokaiselle termille viitteet tietokannasta. Viitteille lasketaan paino käyttämällä metodia countweight. Viite lisätään palautettavaan joukkoon, mikäli sitä ei sieltä jo löydy. Jos se kuitenkin on jo asetettu sinne, lisätään tämän viitteen paino jo joukossa olevan viitteen painoon. Lopuksi palautetaan tämä muodostettu joukko. Attribuutit: Olio saa luomisessaan parametreina viitteet SentenceParser-luokkaan(private SentenceParser sentenceparser), jota käytetään sanojen perusmuotoon palauttamisessa. Lisäksi saadaan viitteet indeksiin(private Index index), ontologiaan(private Ontology ontology) ja käytettävä painotus(private Hashtable weight). Konstruktori: public Processer(SentenceParser sentenceparser, Index index, Ontology ontology, Hashtable weight) this.sentenceparser = sentenceparser; this.index = index; this.ontology = ontology; this.weight = weight; Metodit: private float countweight(float weight, Set predicates, int level) Selitys: Metodi saa syötteenään viitteen painon lisäksi joukon Predicate-olioita, joissa termi esiintyy ja lisäksi termin tason ontologiassa. Näillä tiedoilla se laskee uuden painon, joka palautetaan. Painon laskemisessa käytetään hyväksi seuraavia tietoja: Indeksoija laskee jokaiselle termille painon TF/IDF-metodilla(ks. luku 3). Tämä lukuarvo on välillä [0..1]. Konfiguraatiotiedostossa on määritelty alkuperäisten esinekorteille erilaiset painot (esimerkiksi asiasana-kenttä on tärkeämpi kuin vapaateksti-kenttä.

54 Alkuperäisessä hakulauseesa esiintyneille termeille ja niiden ontologiasta etsityille synonyymeille annetaan suurempi paino kuin alikäsitteille. Mitä kauampana alkuperäisestä hakutermistä termi käsitehierarkiassa sijaitsee, sitä pienemmän painon se saa. public String term2basic(string term) Selitys: Metodi selvittää termin perusmuodon käyttämällä SentenceParser-luokan metodia getlemma. public boolean findhomonyms(string term) Selitys: Metodi selvittää Ontology-luokan metodia gethomonyms käyttämällä löytyykö parametrina annetulle termille homonyymejä eli löytyykö se useammasta kuin yhdestä kohtaa ontologiasta. Mikäli löytyy palautetaan true, muuten false. public List findsynonyms(string term) Selitys: Metodi selvittää parametrina annetulle termille synonyymit ontologiasta käyttämällä Ontology-luokan metodia getsynonyms-metodia, joka palauttaa tuloksen listana, joka palautetaan edelleen. List synonyms = ontology.getsynonyms(term); return List public List findhyponyms(string term) Selitys: Metodi selvittää Ontology-luokan metodia getsubclasses käyttäen termin alikäsitteet ontologiasta. List hyponyms = ontology.gethyponyms(term); return hyponyms public void findreferences(list terms) throws SearchException Selitys: Metodi hakee viitteenä saamalleen Term-olioita sisältävälle listalle viitteet indeksistä. Lisäksi viitteille lasketaan paino metodilla countweight, jonka palauttama arvo asetetaan kyseisen viitteen painoksi. Metodilla on myös attribuutti final, joka on tyyppiä Set. Tämä on se viitejoukko, johon liitetään kaikki ne viiteet, jotka metodi indeksistä löytää. Viitteen painon selvittämisen jälkeen tarkistetaan löytyykö kysei-nen DocumentRef-olio joukosta final. Mikäli ei löydy, se yksinkertaisesti lisätään siihen. Jos se sensijaan on jo kyseisessä joukossa, niin sitä ei lisätä siihen mutta joukossa jo olevan DocumentRef-olion painoon lisätään tämän viitteen paino. Lopuksi kun koko terms-lista on käsitelty, palautetaan joukko final. Set final; for each Term in terms-list do Term.references = index.getreferences(term.term); for each DocumentRef in references-set do float weight = DocumentRef.getWeight(); Set predicates = DocumentRef.getPredicates(); int level = Term.level; newweight = countweight(weight, predicates, level) DocumentRef.setWeight(newWeight); if this.documentref is not present in final set final.add(this.documentref) 50

55 51 else add this DocumentRefs weight to final public List sortreferences(set referencelist) Selitys: Metodi saa parametrinaan joukon viitteitä, jotka se järjestää painokertoimen mukaisesti järjestykseen ja muuntaa sen listaksi joka palautetaan SearchEngine Hakukoneen käyttöliittymä käyttää hakukonetta SearchEngine-luokan kautta. SearhEngine-luokalla on search-metodin lisäksi metodit, joiden avulla käyttöliittymä asettaa konfiguraatiotiedostossa määritellyt attribuutit SearchEngine-luokan käyttöön: Attribuutit: SearchEngine-luokalla on seuravat attribuutit: binääripuun juurisolmu (protected Node root); käytettävä ontologia (private Ontology ontology); luokka, jonka kautta kutsutaan Fdg3-ohjelmaa palauttamaan termit perusmuotoon (private SentenceParser sentenceparser); luokka, jonka kautta etsitään indeksistä viittaukset (private Index index) sekä tietorakenne, johon talletetaan tieto siitä, miten eri luettelokortin kentistä indeksoidut termit painotetaan (private Hashtable weights). Tämä tietorakenne sisältää pareja kentän nimi (String field) ja kentän painoarvo (Float weight). Metodit: public abstract List search (String searchstring, int level) throws Exception Selitys: Abstrakti metodi search toteutetaan SearchMain-luokassa. public void setontology (Ontology ontology) Selitys: Asettaa SearchEngine-luokan ontologia-attribuutin. public void setsentenceparser (SentenceParser sentenceparser) Selitys: Asettaa SearchEngine-luokan sentenceparser-attribuutin. public void setindex (Index index) Selitys: Asettaa SearchEngine-luokan index-attribuutin. public void setweight (String field, float weight) Selitys: Lisää parametrina annetut arvot SearchEngine-luokan Hashtable weights -attribuuttiin SearchMain SearchEngine välittää käyttöliittymältä saamansa hakutiedot edelleen SearchMain-luokalle, joka toteuttaa varsinaisen hakukoneen. SearchMain-luokkaa perii SearchEngine-luokan ja toteuttaa search-metodin. Attribuutit: Käyttäjän haun käyttöliittymässä syöttämistä hakutiedoista kuinka syvälle ontologiaan hakua laajennetaan (int depth) ja hakulause (String searchstring) - tulee SearchMain-luokan attribuutteja. Metodit:

56 52 public List search (String searchstring, int level) throws SearchException Selitys: Metodi luo ensin Processer-luokasta olion. Seuraavaksi se kutsuu Parserluokan metodia parsetree hakulause parametrina. Tämä luo hakulauseesta hakupuun ja palauttaa juurialkion. Juurialkiolle kutsutaan metodia processnode, jonka lopputuloksena saadaan joukko viitteitä. Lopuksi nämä viitteet järjestetään painokertoimen mukaan nousevaan järjestykseen Processer-luokan metodilla sortreferences ja tämä lista palautetaan käyttöliittymälle. Processer processer = new Processer(sentenceParser, index, ontology, weight); this.searchstring = searchstring; this.depth = depth; Node root = this.parser.parsetree(searchstring); root.preprocess(this.processer, depth); Set s = root.processnode(this.processer); return this.processer.sortreferences(s); Term Sekä alkuperäisen hakulauseen sisältämistä hakutermeistä että myöhemmin ontologiasta etsittävistä synonyymeistä ja alikäsitteistä tehdään Term-luokan olioita. Jokaiseen NodeTerm-luokan olioon liittyy terms-lista, johon Term-oliot talletetaan. Attribuutit: Term-luokan oliot sisältävät itse termin (String term), termin tyypin (alkuperäinen hakutermi, synonyymi, alikäsite) koodattuna kokonaisluvuin (int type) sekä termin esiintymän tason ontologiassa (int level). Termin tyyppi kuvataan kokonaislukuna seuraavasti: alkuperäinen termi kuvataan kokonaisluvulla 1, synonyymi luvulla 2, homonyymi luvulla 3 ja alikäsite luvulla 4. Lisäksi termiin liittyy joukko DocumentRef-olioita, jotka talletetaan muuttujaan references. Konstruktori: public Term(String term, int type, int level) 6 Käyttöliittymä Käyttöliittymä muodostuu seuraavista osista (kuva 10): HTML-sivu, SearchServlet-, SearchGui- ja Config-luokat. Käyttäjä kirjoittaa selaimessa HTML-sivulle hakulauseen, valitsee haun syvyyden ja lähettää tiedot servletille painamalla Hae-nappia (kuva 11). HTML-sivulla on linkki suppeaan käyttöohjeeseen (kuva 12). Hae-napin painallus käynnistää SearchServlet-luokan doget-metodin, joka lukee hakulauseen ja haun syvyyden. SearchServlet luo uuden SearchGui-luokan ilmentymän.

57 SearchGui-luokan metodi config lukee XML-muotoisesta konfiguraatio-tiedostosta hakujärjestelmän tarvitsemat ohjaustiedot ja asettaa ne hakukoneen käyttöön. Haku-kone käynnistetään search-metodilla, joka palauttaa haun tuloksen tai mahdollisen virheilmoituksen. SearchServlet-luokan metodi createhtmlpage muodostaa hakutuloksesta HTML-sivun (kuva 13). 53 javax.servlet.http.httpservlet SearchServlet Config +getfdgport() +getfdghostname() +weightofpredicates() +getontologylocation() +getindexport() +getindexhostname( ) +doget( ) +CreateHTMLPage( ) uses uses Configuration file 1 SearchGui +config( ) +search( ) 0..* uses -> 1 SearchEngine +setontology() +setsentenceparser() +setindex() +setweight() Kuva 10 käyttöliittymän luokkakaavio 6.1 Rajapinnat muihin osajärjestelmiin SearchServlet-luokalla on rajapinta SearchGui- ja javax.servlet.http.httpservlet-luokkiin (HTML-sivu). SearchGui-luokalla on rajapinta SearchEngine- ja Config-luokkiin.

58 Rajapinnat ulkoisiin elementteihin SearchGui-luokka lukee XML-muotoista konfiguraatiotiedostoa config-metodilla. Metodi saa parametrina konfiguraatiotiedoston nimen (sijainnin). 6.3 Käyttöliittymä Käyttöliittymä sisältää HTML-käynnistyssivun (kuva 11), käyttöohjesivun (kuva 12), tulossivun (kuva 13) sekä luokat SearchServlet ja SearchGui. Kuva 11 Hakukoneen käynnistyssivu

59 Kuva 12 Hakukoneen käyttöohje 55

60 56 Kuva 13 hakukoneen tulossivu 6.4 Luokkien kuvaus SearchServlet Tämä on käyttöliittymäservletti samo-projektille, joka ottaa vastaan käyttäjän antaman hakusanan tai hakusanojen yhdistelmän mahdollisine Boolen muuttujineen ja välittää ne hakukoneelle sekä palauttaa painotetun osumalistan (URI) käyttäjälle. Metodit: public void doget(httpservletrequest request, HttpServletResponse response) Selitys: Metodi doget välittää käyttäjän antaman haun hakukoneelle sekä palauttaa listan osumista käyttäjälle. Metodin avulla järjestelmä kommunikoi käyttäjän kanssa. Requestin avulla välitetään käyttäjältä hakulause ja haun syvyys hakukoneelle. public void createhtmlpage (Docrefs[] docs) Selitys: Metodi createhtmlpage kirjoittaa haun tuloksena saadun URI-listan HTML-muotoon käyttäjälle.