DOC - KTH

Systembeskrivning
Projekt Intelligent Indexering
Uppdragsgivare:
Harald Kjellin, Institutionen för Data och Systemvetenskap, KTH
Deltagare i projektgruppen:
Biörklund, Mathias
webside ansvarig
Erneholm, Mattias
vice projektledare
Gustrin, Mattias
projektledare
Mankert, Lotta
sekreterare
Pettersson, Ove
dokumentansvarig
Widén, Jacob
dokumentansvarig
www-dokumentation:
http://www.nada.kth.se/projects/proj01/intdex/
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
INNEHÅLLSFÖRTECKNING
1
2
SYSTEMSKISS ................................................................................................................ 3
1.1
FAS 1 ........................................................................................................................... 3
1.2
FAS 2 ........................................................................................................................... 7
1.3
FAS 3 ......................................................................................................................... 10
1.3.1
Steg 1 ................................................................................................................ 11
1.3.2
Steg 2 ................................................................................................................ 14
1.4
COMMON ................................................................................................................... 16
1.5
SETTINGS .................................................................................................................. 17
1.6
SKISS AV ANVÄNDARGRÄNSSNITT ............................................................................. 18
REFERENSER ............................................................................................................... 19
2 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
1
Systembeskrivning
2001-05-06
Systemskiss
Vi har delat in applikationen i tre faser som alla bygger på den föregående fasen. Detta gör vi
för att få en mer överskådlig och lätthanterlig struktur.
Användargränssnitt
Fas 1
Fas 2
Fas 3
Indexfil
HTMLparser
Figur 1
1.1
Fas 1
I denna fas sker insamlingen av URLer till de dokument som kommer att indexeras, även
kallat crawling. Användaren anger en URL varifrån sökningen av URLer skall utgå. Denna
URL läggs till den tomma vektorn av URLer som skall besökas samt till hashtabellen över
URLer som skall besökas. Vidare anger användaren inom vilken domän som sökningen skall
ske.
Sökningen går till på följande sätt:

Så länge vektorn med URLer som skall besökas inte är tom.
 Hämta dokumentet som den första URLen i vektorn refererar till, ta bort URLen från
vektorn över URLer som skall besökas, lägg till URLen till vektorn över URLer som
är besökta samt till hashtabellen över URLer som är besökta.
 Så länge man finner nya URLer i det befintliga dokumentet.

Man kontrollerar så att det är en giltig URL, att det är säkert att söka igenom
sidan som URLen hänvisar till, att URLen inte redan finns i hashtabellerna över
de besökta URLerna eller bland de URLer som skall besökas, att det inte är fråga
om ett relativhopp inom samma dokument, samt att URLen tillhör den domän
som sökningen skall ske inom.


Om URLen uppfyller dessa krav så läggs den sist i vektorn över de URLer som
skall besökas samt till hashtabellen över URLer som skall besökas. Den läggs
även till vektorn över funna URLer och till hashtabellen över funna URLer.
Returnera vektorn över funna URLer.
3 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Det blir alltså frågan om en breddenförstsökning efter nya URLer.
Den ovan beskrivna sökningen utförs av 50 trådar, nedan kallad söktrådar. Crawlingen
övervakas av en tråd i klassen SupervisorThread. Den avbryter crawlingen om alla söktrådar
är döda, vilket inträffar när det inte går att hitta några mer URLer. Söktrådar kan även dö av
andra anledningar, detta registreras dock och crawlingen fortsätter med de fortfarande levande
söktrådarna.
Eftersom man aldrig vet hur en webbsida man läser ser ut så kan det säkert finnas fall där
crawlern stannar upp. Detta löses genom att crawlern har fått en boolesk variabel per loop,
vilken ändras beroende på om en söktråd påbörjar eller avslutar en loop. Om varken de
booleska variablerna, antalet levande söktrådar, antalet sovande söktrådar, antalet döda
söktrådar eller antalet funna URLer har ändrats under 3 minuter kommer crawlern att
avbrytas.
När crawlern avbryts kommer fas 1 att avslutas, vilket innebär att de funna URLerna skrivs
till filen som finns angiven i Settings. Det skapas även en fil som heter faulty_URLs.txt som
innehåller alla felaktiga URLer som har påträffats.
Om användaren väljer att avbryta insamlingen av URLer innan vektorn över URLer som skall
besökas är tom returneras de hittills funna URLerna.
4 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Start URL och
sökdomän
Initiering
Tom lista över URLer
som skall besökas
Nej
Nej
Läs in dokumentet
som den första URLen
hänvisar till och ta bort
första URLen från
listan över URLer som
skall besökas samt
lägg till URLen till
listan och
hashtabellen över
URLer som är besökta
Ja
Skanna igenom
dokumentet efter nya
URLer
Hittar ny URL i
dokumentet
Ja
Nej
Giltig och säker URL,
URLen finns inte i
hashtabellerna över
URLer som är besökta
eller skall besökas,
URLen gör ej ett
relativhopp inom
dokumentet samt att
URLen tillhör
sökdomänen
Ja
Lägg URLen sist i
listan över URLer som
skall besökas samt till
hashtabellen över
URLer som skall
besökas
Returnerar listan med
besökta URLer
Figur 2
Klasser
public class WebCrawler
Det grafiska gränssnittet samt insamlingen av
URLer sköts av denna klass.
class RunThread
Inre klass i WebCrawler för
söktrådexekvering.
5 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
class RunPhase2
Inre klass i WebCrawler för metodanrop mot
fas 2.
public class SupervisorThread
Här sköter en tråd övervakningen av crawlern.
Metoder i WebCrawler
void init()
Här skapas det grafiska gränssnittet samt
initieras datastrukturerna för lagring av
URLerna.
synchronized String popFirstToSearch()
Hämtar nästa URL som skall undersökas.
void start()
Anropas när användaren startar insamlingen av
URLer.
void stop()
Anropas om användaren vill avbryta
insamlingen av URLer innan den sista sidan är
lokaliserad.
void startPhase2()
Startar exekveringen av fas 2.
void saveURLs()
Sparar alla funna URLer.
boolean robotSafe(URL url)
Kontrollerar om det är säkert för crawlern att
besöka en viss URL.
void help()
Visar ett hjälpfönster.
void setStatus(String status)
Uppdaterar statusen i det grafiska gränssnittet
om något inträffar.
void settings()
Visar Settings fönstret.
void actionPerformed(ActionEvent event)
Känner av om användaren vill påverka
crawlern.
void activateStartButton
Aktiverar Start knappen.
Metod i RunThread
void run()
Det är den här metoden alla söktrådar
exekverar. Här sker insamlingen av URLer.
Metod i RunPhase2
void run()
Innehåller metodanrop mot fas 2.
6 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Metod i SupervisorThread
void run()
Kontrollerar om crawlern är klar eller står still.
Datastrukturer
Hashtabell över besökta URLer.
Hashtabell över URLer som skall besökas.
Hashtabell över felaktiga URLer.
Hashtabell över funna URLer, både besökta och obesökta
Vektor över besökta URLer.
Vektor över URLer som skall besökas.
Vektor över felaktiga URLer.
Vektor över funna URLer, både besökta och obesökta.
1.2
Fas 2
Fas 2 skall gå igenom de dokument som fas 1 hittat och räkna totala antalet
förekomster av varje ord. Därefter räknas medelfrekvensen fram enligt formeln:
Medelfrekvensen 
totala _ antalet _ ord _ i _ domänen
antalet _ olika _ ord _ i _ domänen
Medelfrekvensen anger alltså hur många gånger ett ord förekommer i snitt.
Därefter kan den generella frekvensen för varje enskilt ord beräknas enligt:
GenerellaF rekvensen 
antalet _ förekomster _ av _ or det
Medelfrekvensen
Om ett ord förekommer fler gånger än medelfrekvensen kommer Generella frekvensen att var
större än ett. Exempel på detta är alla ”skräpord” t.ex. är, till, som mm.
7 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Gränsen för medelfrekvensen kan justeras med hjälp av parametern General factor i
användargränssnittet. Normalt är detta värde 1.0 men kan ändras om annan karakteristik
önskas.
Om ordet har en generell frekvens över gränsvärdet anses ordet vara för generellt och kommer
inte behandlas, annars sparas generella frekvensen tillsammans med den relativa frekvensen
för ordet. Resultatet sparas i en hashtabell som är indata till fas 3. URL-adresserna till de
genomgångna dokumenten sparas i en fil. Fas 2 skall gå igenom de dokument som fas 1 hittat
och räkna totala antalet förekomster av varje ord. Resultatet sparas i en hashtabell som är
indata till fas 3. URL-adresserna till de genomgångna dokumenten sparas i en fil. Figur 3
visar en schematisk bild över fas 2.
1. Sätt totalräknare till noll.
Skapa hashtabellen för räknarvärden.
Öppna infil.
Skapa utfil.
2. Läs nästa dokument-URL från infil.
Om EOF gå till punkt 7.
3. Koppla upp mot dokument.
Om fel gå till punkt 2.
4. Skapa parserinstans.
5. Läs nästa token från parsern.
Om token är en ”tag” eller en kommentar, läs nästa token.
Om EOF i dokumentet, skriv dokument-URL till utfil och gå till punkt 2.
6. Stega totalräknaren.
Läs ordet.
Om ordet finns i räknar-hashtabellen, stega ordräknaren med 1, annars lägg till ordet
och sätt ordräknaren till 1.
Gå till punkt 5.
7. Stäng utfil och infil.
Räkna ut medelfrekvensen.
Skapa ny hashtabell för ord.
8. Läs nästa ord från räknar-hashtabellen
Om tabellen slut gå till punkt 10.
9. Räkna ut generella frekvensen för ordet.
Om generella frekvensen är mindre än gränsvärdet (General factor),
spara generella och relativa frekvensen i ord-hashtabellen.
Gå till punkt 8.
10. Returnera ord-hashtabellen.
8 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Infil
1. Initiering
2. Läs URL
Fel
3. Koppla upp
mot dokument
Skriv URL till
utfil
4. Skapa
parserinstans
EOF i infil .
5. Läs nästa
token
EOF i dokument.
Ord
6. Läs ordet,
stega räknare
7. Stäng filer,
räkna ut
medelfrekvensen
8. Läs nästa
ord från
tabellen
Tabellen slut
9. Räkna ut
generella
frekvensen
generell frekvens <
gränsvärde
Spara i
hashtabellen
10. Returnera
hashtabellen
Figur 3
Klasser
public class Phase2
All hantering av fas 2 sker i denna klass.
public class HtmlStreamTokenizer
HTML-parser som tar fram ord ur HTMLdokument.
9 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Metoder i Phase2
public Hashtable startPhase2()
Metod som startar fas 2.
Metoder i HtmlStreamTokenizer
public final Stringbuffer getStringValue()
Returnerar ordet.
public int nextToken()
Returnerar nästa token.
Datastrukturer
Hashtabell med alla förekommande ord med frekvenser, samt värdet för totala antalet ord.
1.3
Fas 3
Ett dokument i taget behandlas dvs. filen med URLer stegas igenom. För varje dokument ska
ett diskriminerande värde, Disc(w,doc), för varje ord beräknas. Resultatet lagras i en för
dokumentet temporär hashtabell. Se formler nedan.
Disc ( w, doc) 
Rf ( w, doc)
1
Rf ( w, domain)
där
Rf ( w, doc) 
antal ( w, doc)
antal (ord , doc)
är den relativa frekvensen av ordet w i ett dokument och
Rf ( w, domain) 
antal ( w, domain)
antal (ord , domain)
är den relativa frekvensen av ordet w i alla dokument i domänen.
Om ordet w är lika vanligt i dokumentet som det är i alla andra dokument blir det
diskriminerande värdet Disc(w,doc) = 0 och om det förekommer 10 gånger mer så blir
Disc(x,doc) = 9.
Efter att alla ords individuella diskriminerande värde beräknats för ett dokument, börjar
sökningen efter ord med starka relationer, dvs. parbildningen.
10 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
För att hitta dessa par kommer man att stega igenom hela dokumentet en gång. För varje
mening kommer det första diskriminerande ordet, Da (med dess diskriminerande värde
Disc(Da,doc)) paras ihop med det andra, Db (med dess diskriminerande värde Disc(Db,doc)).
Detta förlopp fortsätter med det andra och tredje ordet, tredje och fjärde o.s.v. ända tills
meningen är slut och sedan vidare med alla meningar i dokumentet. Diskriminerande ord är
bara ord med ett diskriminerande värde större än den förutbestämda Diskrimineringskonstanten. Varje par sätts in i hashtabellen ”ParTabell” med nyckeln ”Da + Db” (där ordet Da
är mindre än Db). För att undvika att samma parkombination fast i omvänd ordning (”Db +
Da”) läggs in i hashtabellen, en annan nyckel på en annan plats, skapas alltid nyckeln med
ordet Da före ordet Db. Om parkombinationen redan finns räknas parametern antal för
parkombinationen upp med 1 (i ”ParTabell” för gällande par).
När hela dokumentet stegats igenom kan det diskriminerande värdet, Disc(Da,Db), för varje
parkombination beräknas. Eftersom vi känner till förekomsten av varje par, Kab, kan det
pardiskriminerande värdet, Disc(Da,Db), nu beräknas (se formler nedan).
K ab 0 kombination( Da , Db ), n  antalmeningar
n
Disc ( Da , Db )  ( Disc ( Da , doc)  Disc ( Db , doc))  Kab
Det diskriminerande värdet, Disc(Da,Db), sparas undan tillsammans med ordparet och URLen
i en för dokumentet temporär hashtabell, ”ParTabell”.
Den temporära hashtabellen, ”ParTabell” överförs sedan till en globala hashtabell,
”GlobalParTabell” och URLen för dokumentet. När alla dokument har behandlats i domänen,
skrivs ”GlobalParTabell” ned på en utfil.
Vi har delat upp detta förlopp i två steg för att göra det lättare, vilka vi redovisar här nedan, se
figur 4 och 5.
1.3.1
Steg 1
Steg 1 skall gå igenom de dokument som finns på filen från fas 2. Steg 1 räknar det totala
antalet förekomster av varje ord i varje dokument. Efter att varje dokument stegats igenom,
beräknas det diskriminerande värdet för varje ord i dokumentet. Därefter går man till steg 2.
När steg 2 är avslutat har diskriminerande par av ord i dokumentet hittats, ett
pardiskriminerande värde för varje par beräknats och resultatet har lagrats i en temporär
hashtabell (ParTabell). När steg 2 genomförts uppdateras den globala hashtabellen
(GlobalParTabell). När samtliga dokument stegats igenom skrivs den globala hashtabellen
(GlobalParTabell) som innehåller alla diskriminerande par i domänen till fil. Figur 4 visar ett
schema över steg 1.
11 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
1. Sätt totalräknare till noll.
Skapa hashtabeller (OrdTabell, ParTabell och GlobalParTabell).
Öppna infil.
Skapa utfil.
2. Läs nästa dokument, dvs. URL från infil.
Om EOF gå till punkt 10.
3. Koppla upp mot dokument.
Om fel gå till punkt 2.
4. Skapa parserinstans.
5. Läs nästa token från parsern.
Om token är en ”tag”, ”.”, ”,”, ”<” eller en kommentar, läs nästa token.
Om EOF i dokumentet gå till punkt 7.
6. Stega totalräknaren.
Läs ordet.
Om ordet finns i hashtabellen ”OrdTabell”, stega ordräknaren med 1, annars lägg till
ordet och sätt ordräknaren till 1.
Gå till punkt 5.
7. Beräkna det diskriminerande värdet för alla ord i dokumentet dvs. ord i ”OrdTabell”,
gå till punkt 8.
8. Gå till fas 3 steg 2.
9. Steg 2 har slutförts och returnerat ”ParTabell”.
Uppdatera ”GlobalParTabell” med ”ParTabell” dvs. Ord1, Ord2 och det
diskriminerande värdet för paret och även med gällande URL.
10. Skriv ”GlobalParTabell” till utfil.
11. Stäng utfil och infil.
12 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Infil
1. Initiering
2. Läs URL
Fel
9. Uppdatera GlobalPartabell
med Partabell och URL'en.
3. Koppla upp
mot dokument
8. Gå till
Steg 2 i Fas 3
4. Skapa
parserinstans
EOF infil
5. Läs nästa
token
EOF
dokument
Ord
6. Läs ordet,
stega räknare,
uppdatera
Ordtabell
10. Skriv GlobalPartabell
till utfil
11. Stäng filer
Figur 4
Klasser
public class Phase3Step1
13 (19)
7. Beräknar
Ord.diskrim
för alla ord i
dok
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Metoder i Phase3Step1
public void startPhase3(WebCrawler crawler,
Hashtable phase2Table)
Genererar en fil med ordpar, dess
gemensamma diskriminerade värde
och URL.
void writeToFile(PrintWriter outFile, Hashtable table)
Skriver ordpar, dikrimineringsvärde
och URL till fil.
int getNumUrls()
Returnerar antal URLer I filen
‘PHASE2_FILE’
Datastrukturer
Hashtabell med alla par av ord, gemensamma diskriminerings värden och samt ordparens
URLer.
1.3.2
Steg 2
Steg 2 skall läsa igenom gällande dokument och hitta diskriminerande par i varje mening.
Kombinationer av ord sparas i en hashtabell ”ParTabell”. Om ett par förekommer flera gånger
dvs. i flera meningar uppdateras parametern antal i ”ParTabell”. Därefter beräknas det
diskriminerande värdet för varje par i dokumentet. I figur 5 visas en schematisk bild över steg
2.
1. Nollställ hashtabellen ”ParTabell”.
Läs från början av parserinstansen.
2. Läs nästa token från parsern.
Om token är en ”tag” eller en kommentar, läs nästa token.
Om token är ett ord med för litet diskriminerande värde, läs nästa token.
Om token är en ”punkt”, ”kommatecken” eller ”<”, gå till punkt 10.
Om EOF i dokumentet gå till punkt 11.
3. Om variabeln Ord1 är tom gå till punkt 4
4. Sätt Ord1 till token, gå till punkt 2.
5. Sätt Ord2 till token.
6. Om kombination Ord1 + Ord2 finns i ”ParTabell”, gå till punkt 8.
7. Sätt in kombination Ord1 + Ord2 i ”ParTabell” och gå till punkt 9.
8. Räkna upp antal med 1 för kombinationen Ord1 + Ord2.
9. Sätt Ord1 till Ord2.
Sätt Ord2 till ” ”.
Gå till punkt 2.
10. Sätt Ord1 och Ord2 till ” ”, gå till punkt 2.
11. Beräkna det diskriminerande värdet för varje par i hashtabellen ”ParTabell”.
12. Tillbaka till steg1, punkt 9.
14 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Från
Fas 3 Steg 1
1. Nollställ ParTabell.
Läs från början av
dokument
2. Läsa nästa
token
".", "," el. "<"
3. Är variabeln
Ord1 tom
Ja/tom
10. Ord1 = " "
Ord2 = " "
4. Ord1= Ord
Nej
9. Ord1 = Ord2
Ord2 = " "
5. Ord2 = Ord
EOF
6. Finns
Ord1+ Ord2
i Partabell?
Ja
Nej.
7. Sätt in
Ord1+ Ord2
i Partabell.
11. Beräknar Par.diskrim
för ParTabell
för alla par i dokumentet
Tillbaka till
Fas 3 Steg 1
Figur 5
Klasser
public class Phase3Step2
15 (19)
8. Räknar upp
Par.antal med 1
i Partabell
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Metoder i Phase3Step2
Public Hashtable startPhas3Step2(Hashtable phase2Table
Hashtable wordTable,
Hashtable globalPairTable,
int docCounter,
String urlName)
Gör ordparsberäkningar
för ett dokument.
boolean endOfPhrase(String word)
Testar om ordet är i
slutet av en mening.
public Hashtable calcDiscPair(Hashtable pairTable,
Hashtable wordTable,
Hashtable globalPairTable,
String urlName)
Beräknar
diskriminerande
värden för alla par.
Datastrukturer
Hashtabell över lokala ordpar.
Hashtabell över globala ordpar.
1.4
Common
Common består av fyra klasser som är gemensamma för de andra modulerna.
Klasser
public class CommonVars
Innehåller globala variabler och konstanter
som används av de andra modulerna.
public class Word
Datastruktur som innehåller datavärden för
ett ord.
public class Pair
Datastruktur som innehåller datavärden för
ett ordpar.
public class HtmlStreamTokenizer
HTML-parser som tar fram ord ur HTMLdokument.
16 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
Systembeskrivning
2001-05-06
Metoder i HtmlStreamTokenizer
public final Stringbuffer getStringValue()
Returnerar ordet.
public int nextToken()
Returnerar nästa token.
Metoder i Word
public float relFreq()
Returnerar relativa frekvensen för ordet.
public float generalFreq()
Returnerar generella frekvensen för ordet.
Metoder i Pair
public String word1()
Returnerar första ordet.
public String word2()
Returnerar andra ordet.
public int numberOfPair
Returnerar räknare numberOfPair
public Vector discValues()
Returnerar en vektor med
diskrimineringsvärden.
public Vector docUrls()
Returnerar en vektor med URL-dokument.
public void incPairCounter()
Ökar parräknaren.
public void addDiscUrl(float discVal, String url) Lägger in värden i vektorerna.
1.5
Settings
Settings är en del av gränssnittet. I settingsfönstret anges inställningar för applikationen.
Klasser
public class Settings
Bygger upp gränssnittet för inställningarna.
public class ButtonListener
Tar hand om knapptryckningar.
public class RadioButtonListener
Tar hand om markeringar av
Radioknappar.
public classCheckBoxListener
Tar hand om markeringar av Checkboxknappar.
17 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
1.6
Systembeskrivning
2001-05-06
Skiss av användargränssnitt
Figur 6.
Figur 7
18 (19)
Kungliga Tekniska Högskolan
Programutvecklingsprojekt 2D1954
2
Systembeskrivning
2001-05-06
Referenser
Arthur Do Consulting; http://www.do.org/products/parser/; 010505
Javas hemsida; http://www.java.sun.com; 010505
The Web Robots Pages; http://www.robotstxt.org/wc/robots.html; 010505
Kjellin, Harald; Institutionen för data- och systemvetenskap, Stockholms universitet;
regelbundet under tiden: 010208 - 010507
19 (19)