metoda list prostych - Zakład Systemów Informatycznych

metoda list prostych - Zakład Systemów Informatycznych

Systemy Wyszukiwania
Informacji
METODA LIST PROSTYCH
OPRACOWALI:
Marcin Dzięgielewski
Marcin Karwiński
1
INDEKS
SŁOWO WSTĘPNE...............................................................
3
OPIS METODY, PRZYGOTOWANIE KARTOTEKI WYSZUKIWAWCZEJ.........................
4
JAK PRZEBIEGA WYSZUKIWANIE ODPOWIEDZI NA PYTANIE W METODZIE LIST PROSTYCH...
8
PRZYKŁAD 1.................................................................. 10
MODYFIKACJE METODY LIST PROSTYCH............................................ 11
PRZYKŁAD 2.................................................................. 12
PARAMETRY METODY LIST PROSTYCH.............................................. 15
WNIOSKI..................................................................... 16
2
SŁOWO WSTĘPNE
Obok ciężkiej pracy fizycznej wymiana i składowanie informacji należy do najważniejszych
czynników postępu cywilizacyjnego ludzkości. Stąd przykładano zawsze wielka wagę do rozwoju
technik przekazywania informacji (począwszy od starożytności, a nawet czasów neandertalczyka).
Ale obecny rozwój cywilizacyjny doprowadził do paradoksalnej sytuacji, w której człowiek,
niegdyś spragniony informacji, dziś nie jest w stanie skonsumować ich olbrzymiego strumienia. Po
prostu niemozliwe jest objęcie umysłem i "przetrawienie" dostępnych z różnorakich źródeł
informacji. Stąd naglącą stała się potrzeba selekcji informacji dla potrzeb poszczególnych ludzi.
Niezbędnym warunkiem dla możliwości selekcji jest permanentna dostępność źródeł
poszczególnych informacji (przykładowo Internet czy system bazodanowy banku). Ale sama
dostępność informacji nie jest warunkiem wystarczającym. Konieczny jest też element aktywny:
możliwość poszukiwania i znalezienia interesującej informacji. Tę rolę pełnią od lat stale
doskonalone metody wyszukiwania informacji i organizacji jej w systemach informacyjnych.
Jednak wraz z dynamicznym wzrostem popularności technik informatycznych pojawiło sie coraz
więcej użytkowników nieprofesjonalnych. W chwili obecnej zawodowi programiści, czy też
ogólniej osoby, których wykształcenie związane jest choćby pośrednio z informatyką, stanowią już
mniejszość wśród osób korzystających z usług globalnej sieci. Jednocześnie jednak wiedza i
umiejętności techniczne - w szczególności zaś dobra znajomość zasad działania narzędzi takich jak
przeglądarki, systemy wyszukiwawcze, czy też chociażby serwery HTTP - stają się coraz bardziej
przydatne, a w niektórych przypadkach wręcz niezbędne, do efektywnego odnajdywania
potrzebnych użytkownikowi informacji w różnorakich systemach. Główną tego przyczyną wydaje
się być zwiększająca sie w bardzo szybkim tempie liczba dostawców informacji, co w połączeniu z
niezbyt wysoką jakością i aktualnością dostępnych katalogów i narzędzi wyszukiwawczych
powoduje, iż proces odnajdywania danych bywa czasami dość skomplikowany i czasochłonny.
Obecnie używane systemy wyszukiwania informacji mają swoje korzenie w systemach
przeszukiwania klasycznych baz danych (systemy klasyczne do których między innymi należy
metoda list prostych). Dzieki temu są zwykle dość efektywne w indeksowaniu i grupowaniu
informacji, nawet pełnotekstowej, jednakże nie są skuteczne w interpretacji potrzeb informacyjnych
użytkownika końcowego. Są także stosunkowo proste do implementacji, toteż wielu programistów
sięga po te “stare i sprawdzone metody”. Dodatkowo w wielu przypadkach interfejsy użytkownika
w jakie wyposażono te systemy są bardzo niskiej jakości, zaś możliwości specyfikacji kryteriów
wyszukiwania jakie są przez nie udostepniane wydają się być bardziej odpowiednie dla prostych i
krótkich (mało rozbudowanych) baz pełnotekstowych, niż dla bogatego środowiska informacyjnego
w którym działają.
Wiekszość ludzi postrzega obecne systemy informacyjne nie jako całkowicie nowe
narzędzie, ale raczej jako elektroniczną wersję jednego z do tej pory istniejących systemów
archiwizacji i dystrybucji informacji. Nie ma w tym nic dziwnego - w procesie edukacji uczeni
byliśmy jak do tej pory jedynie posługiwania się klasycznymi systemami, wykształcenie to zaś na
tyle silnie wpływa na nasze zachowanie, że instynktownie traktujemy je jako naturalne. Kiedy
korzystamy z systemu, traktujemy go zwykle jak książkę, lub bazę danych, czy też gazetę, wreszcie
używamy jednej z wielu innych metafor, które są dla nas znajome. Wybór ten staje się szczególnie
istotny w momencie, w którym poszukujemy informacji, ponieważ ogranicza rodzaj informacji, o
wyszukaniu którego możemy w ogóle pomyśleć. W efekcie wybrana przez nas metafora, innymi
słowy sposób postrzegania systemu, określa stosowane przez nas podejście do konstruowania
zapytania. Dobrym przykładem bedzie tu traktowanie języka naturalnego jako naturalnego systemu
wprowadzania informacji przez użytkownika, a także jej dla niego wyprowadzania, podczas gdy jest
on znacznie bardziej skomplikowaną i trudniejszą do implementacji metodą składowania i
wyszukiwania informacji. Nie jest bowiem możliwe bezpośrednie użycie zapytań dla nas tak
naturalnych i prostych w istniejących systemach wyszukiwawczych, jako że system który byłby w
3
stanie w pełni zrozumieć semantykę nawet najprostszych zdań nie został jak do tej pory stworzony i
najprawdopodobniej nie powstanie w najbliższej przyszłości. Jest jednak możliwe przetłumaczenie
tych zapytań do bardziej formalnej postaci. Dlatego też już jakiś czas temu wprowadzono i
usystematyzowano wiele z możliwych systemów informacji a także metod ich wyszukiwania.
Metoda list prostych jest historycznie najstarszą z wprowadzonych metod, jednak w tej
dziedzinie nic nie traci na aktualnosci, gdyż problemy z którymi muszą stytkać się systemy
wyszukiwania informacji praktycznie nie zmieniły się. Do powstania nowych metod przyczynił się
rozwój systemów bazodanowych oraz stawiane im kolejno coraz to większe wymagania, których
spełnienie wymagało zmienienia dotychczasowej organizacji systemów bazodanowych.
Budowa klasycznej metody list prostych wygląda w zasadzie jak baza danych każdego
początkującego informatyka-programisty. Obiekty umieszczane są w bazie w sposób naturalny,
czyli w trakcie ich napływania. Usunięcie polega na prostym wykasowaniu obiektu z “naszej bazy” .
Zmiana w opisie obiektu polega na znalezieniu obiektu i zmiany jego cechy odpowiednio na inną.
Samo wyszukanie polega zaś na przeglądnięciu wszystkich elementów (stąd też druga nazwa
metody – metoda przeglądu zupełnego) i porównywanie ich z deskryptorami pytania (np. czy dany
element jest opisany deskryptorem {wzrost, wysoki}? Jeśli nie to szukam dalej). Przy pytaniach
szczegółowych porównujemy każdy element ze wszystkimi deskryptorami z pytania (stąd też we
wniosku zwrócimy uwagę na możliwą nie w pełni 100%ową relewantność wszystkich odpowiedzi
wynikającą np z wykorzystania za mało szczegółowych pytań). Metoda klasyczna list prostych jest
praktycznie jedyną metodą, w której nie muszą być adresowane (indeksowane) jej elementy.
Podczas programowania/implementowania jednak automatycznie wprowadza się różnego rodzaju
adresowanie. Klasyczna metoda list prostych nie uczy więc niczego ponad to, co każdy i tak już
wiedział.
OPIS METODY, PRZYGOTOWANIE KARTOTEKI
WYSZUKIWAWCZEJ
Musimy najpierw zdefiniować system informacyjny:
S = <X,A,V,q>
gdzie:
X – zbiór obiektów systemu S
A – zbiór atrybutów systemu S
V – zbiór wartości atrybutów
q – funkcja informacji
W metodzie list prostych informacje o obiektach systemu S są pamiętane w dowolnej kolejności.
Ponieważ nie kładzie się tu nacisku na jakiekolwiek sortowanie napływających do systemu danych,
to kolejne obiekty dodawane są na koniec listy i tym samym są pamiętane w kolejności ich
napływania do systemu. Jak wiemy informacja o obiekcie jest pewną funkcją, która każdemu
atrybutowi ze zbioru atrybutów systemu przyporządkowuje pewną wartość ze zbioru wartości tegoż
atrybutu. Nas natomiast bardziej interesuje sposób zapisu tej informacji. Wykorzystamy do tego
celu język informacyjny Ls:
tx = (a1,v1) * (a2,v2) * ... * (an,vn)
Taki zapis nazywamy opisem obiektu w języku Ls.
4
Skoro wiemy już jak powinna wyglądać kartoteka wyszukiwawcza dla metody list prostych to
możemy przystąpić do jej przygotowania.
Na poprzednich zajęciach stworzyliśmy niewielką kartotekę wtórną, oto ona:
X\A
P54C
P55C
Covington
Mendocino
Coppermine
Klamath
Deschutes
Katmai
Coppermine2
Tualatin
Willamette
NorthwoodA
NorthwoodB
NorthwoodC
Prestonia
Prescott
P6
DeschutesMP
Tanner
Cascades
Foster
Gallatin
5K86
LittleFoot
Chompers
Sharptooth
Spitfire
Morgan
Pluto
Orion
Thunderbird
Palomino
Thoroughbred
Barton
Applebred
Thorton
SledgeHammer
Newcastle
ClawHammer
Proc Obud
Ltr
Socket L2 FSB
P
S1
b.malo
7
D
0
Pm
S1
b.malo
7
D
1
C
S2
b.malo
S1
M
1
C
S2
Malo
S1
S
1
C
F
Malo
3
S
1
P2
S3
b.duzo
S1
D
1
P2
S3
b.duzo
S1
D
1
P3
S3
b.duzo
S1
D
2
P3
S3 Srednio
S1
S
2
P3
F
Srednio
3
S
2
P4
O2
b.duzo
4a
S
1
P4
F
Tlum
4b
D
2
P4
F
Tlum
4b
D
2
P4
F
Tlum
4b
D
4
P4
F
Wow!
4b
D
4
P4
L
Wow!
7b
O
4
Pro
C
Tlum
8
O
0
P2X O3
Wow!
S2
O
1
P3X
S3
Wow!
S2
O
1
P3X O3 Srednio
4c
S
2
X
P2
Tlum
6
O
1
X
P2
Wow!
6
D
1
K5
P1
b.malo
5
D
0
K6
P1
b.malo
5
D
1
K6
P1
b.malo
7a
D
1
K6
P1 Srednio
7a
D
1
D
C
Srednio
A
S
1
D
C
Srednio
A
S
1
A
CM Srednio
SA
D
1
A
CM Srednio
SA
D
1
A
C
Duzo
A
S
2
AXP O1
Duzo
A
S
2
AXP O1
Duzo
A
S
3
AXP O1
Tlum
A
D
4
D
O1 Srednio
A
M
3
AXP O1
Duzo
A
S
3
A64
O1
Wow!
9a
O
4
A64
O1
Tlum
9b
O
4
A64
O1
Wow!
7c
O
4
5
Clock
b.wolny
b.wolny
b.wolny
b.wolny
Sredni
b.wolny
b.wolny
Wolny
Wolny
Sredni
Sredni
b.szybki
b.szybki
b.szybki
b.szybki
Hyper
b.wolny
b.wolny
Wolny
Wolny
Sredni
b.szybki
b.wolny
b.wolny
Wolny
b.wolny
Wolny
Sredni
Wolny
Wolny
Sredni
Sredni
Szybki
Szybki
Sredni
Szybki
Szybki
Szybki
Szybki
PrT
b.stary
Stary
Stary
Sredni
Nowy
Stary
Sredni
Sredni
Nowy
b.nowy
Nowy
b.nowy
b.nowy
b.nowy
b.nowy
Mikro
Stary
Sredni
Sredni
Nowy
Nowy
b.nowy
Stary
Stary
Sredni
Sredni
Nowy
Nowy
Sredni
Nowy
Nowy
Nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
Tmax Pmax HT MemC
Chlodny
1
0
0
Chlodny
1
0
0
Goracy
1
0
0
Parzy
2
0
0
Zar
2
0
0
Cieply
3
0
0
Zar
2
0
0
Zar
2
0
0
Parzy
2
0
0
Chlodny
2
0
0
Cieply
4
0
0
Cieply
4
0
0
Cieply
5
1
0
Chlodny
5
1
0
Chlodny
6
1
0
Cieply
6
1
0
Parzy
3
0
0
Cieply
3
0
0
Cieply
3
0
0
Lod
3
0
0
Goracy
4
1
0
Cieply
5
1
0
Parzy
1
0
0
Chlodny
2
0
0
Chlodny
2
0
0
Chlodny
2
0
0
Zar
3
0
0
Zar
3
0
0
Chlodny
3
0
0
Chlodny
4
0
0
Zar
4
0
0
Zar
4
0
0
Zar
4
0
0
Parzy
4
0
0
Parzy
3
0
0
Zar
4
0
0
Parzy
5
0
2
Chlodny
5
0
1
Parzy
5
0
1
Zmodyfikujemy teraz jej postać tak, aby można było przeprowadzić w niej wyszukiwanie metodą
list prostych – oto opisy poszczególnych obiektów:
tP54C = (Proc,P1)*(Obud,S1)*(Ltr,b.mało)*(Socket,7)*(L2,D)*(FSB,0)*
(Clock,b.wolny)*(PrT,b.stary)*(Tmax,chlodny)*(Pmax,1)*(HT,)*(MemC,0)
tP55C = (Proc,Pm)*(Obud,S1)*(Ltr,b.mało)*(Socket,7)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,stary)*(Tmax,chlodny)*(Pmax,1)*(HT,)*(MemC,0)
tCovington = (Proc,C)*(Obud,S2)*(Ltr,b.mało)*(Socket,S1)*(L2,M)*(FSB,1)*
(Clock,b.wolny)*(PrT,stary)*(Tmax,goracy)*(Pmax,1)*(HT,0)*(MemC,0)
tMendocino = (Proc,C)*(Obud,S2)*(Ltr,mało)*(Socket,S1)*(L2,S)*(FSB,1)*
(Clock,b.wolny)*(PrT,sredni)*(Tmax,parzy)*(Pmax,2)*(HT,0)*(MemC,0)
tCoppermine = (Proc,C)*(Obud,F)*(Ltr,mało)*(Socket,3)*(L2,S)*(FSB,1)*
(Clock,sredni)*(PrT,nowy)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
tKlamath = (Proc,P2)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,stary)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
tDeschutes = (Proc,P2)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,sredni)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
tKatmai = (Proc,P3)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)*(L2,D)*(FSB,2)*
(Clock,wolny)*(PrT,sredni)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
tCoppermine2 = (Proc,P3)*(Obud,F)*(Ltr,srednio)*(Socket,S1)*(L2,S)*(FSB,2)*
(Clock,wolny)*(PrT,nowy)*(Tmax,parzy)*(Pmax,2)*(HT,0)*(MemC,0)
tTualatin = (Proc,P3)*(Obud,O2)*(Ltr,srednio)*(Socket,3)*(L2,S)*(FSB,1)*
(Clock,sredni)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
tWillamette = (Proc,P4)*(Obud,F)*(Ltr,b.duzo)*(Socket,4a)*(L2,S)*(FSB,2)*
(Clock,sredni)*(PrT,nowy)*(Tmax,cieply)*(Pmax,4)*(HT,0)*(MemC,0)
tNorthwoodA = (Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)*(L2,D)*(FSB,2)*
(Clock,b.szybki)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,4)*(HT,0)*(MemC,0)
tNorthwoodB = (Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)*(L2,D)*(FSB,4)*
(Clock,b.szybki)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,5)*(HT,1)*(MemC,0)
tNorthwoodC = (Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)*(L2,D)*(FSB,4)*
(Clock,b.szybki)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,5)*(HT,1)*(MemC,0)
tPrestonia = (Proc,P4)*(Obud,L)*(Ltr,wow!)*(Socket,4b)*(L2,D)*(FSB,4)*
(Clock,b.szybki)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,6)*(HT,1)*(MemC,0)
tPrescott = (Proc,P4)*(Obud,C)*(Ltr,wow!)*(Socket,7b)*(L2,O)*(FSB,0)*
(Clock,hyper)*(PrT,mikro)*(Tmax,cieply)*(Pmax,6)*(HT,1)*(MemC,0)
tP6 = (Proc,Pro)*(Obud,O3)*(Ltr,tlum)*(Socket,8)*(L2,O)*(FSB,1)*(Clock,b.wolny)*
(PrT,stary)*(Tmax,parzy)*(Pmax,3)*(HT,0)*(MemC,0)
tDeschutesMP = (Proc,P2X)*(Obud,S3)*(Ltr,wow!)*(Socket,S2)*(L2,O)*(FSB,1)*
(Clock,b.wolny)*(PrT,sredni)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
tTanner = (Proc,P3X)*(Obud,O3)*(Ltr,wow!)*(Socket,S2)*(L2,O)*(FSB,2)*
(Clock,wolny)*(PrT,sredni)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
Cascades = (Proc,P3X)*(Obud,P2)*(Ltr,srednio)*(Socket,4c)*(L2,S)*(FSB,1)*
(Clock,wolny)*(PrT,nowy)*(Tmax,lod)*(Pmax,3)*(HT,0)*(MemC,0)
tFoster = (Proc,X)*(Obud,P2)*(Ltr,tlum)*(Socket,6)*(L2,O)*(FSB,1)*(Clock,sredni)
6
*(PrT,nowy)*(Tmax,goracy)*(Pmax,4)*(HT,1)*(MemC,0)
tGallatin = (Proc,X)*(Obud,P1)*(Ltr,wow!)*(Socket,6)*(L2,D)*(FSB,0)*
(Clock,b.szybki)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,5)*(HT,1)*(MemC,0)
t5K86 = (Proc,K5)*(Obud,P1)*(Ltr,b.mało)*(Socket,5)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,stary)*(Tmax,parzy)*(Pmax,1)*(HT,0)*(MemC,0)
tLittleFoot = (Proc,K6)*(Obud,P1)*(Ltr,b.mało)*(Socket,5)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,stary)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
tChompers = (Proc,K6)*(Obud,P1)*(Ltr,b.mało)*(Socket,7a)*(L2,D)*(FSB,1)*
(Clock,wolny)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
tSharptooth = (Proc,K6)*(Obud,C)*(Ltr,srednio)*(Socket,7a)*(L2,D)*(FSB,1)*
(Clock,b.wolny)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
tSpitfire = (Proc,D)*(Obud,C)*(Ltr,srednio)*(Socket,A)*(L2,S)*(FSB,1)*
(Clock,wolny)*(PrT,nowy)*(Tmax,zar)*(Pmax,3)*(HT,0)*(MemC,0)
tMorgan = (Proc,D)*(Obud,CM)*(Ltr,srednio)*(Socket,A)*(L2,S)*(FSB,1)*
(Clock,sredni)*(PrT,nowy)*(Tmax,zar)*(Pmax,3)*(HT,0)*(MemC,0)
tPluto = (Proc,A)*(Obud,CM)*(Ltr,srednio)*(Socket,SA)*(L2,D)*(FSB,1)*
(Clock,wolny)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,3)*(HT,0)*(MemC,0)
tOrion = (Proc,A)*(Obud,C)*(Ltr,srednio)*(Socket,SA)*(L2,D)*(FSB,2)*
(Clock,wolny)*(PrT,nowy)*(Tmax,chlodny)*(Pmax,4)*(HT,0)*(MemC,0)
tThunderbird = (Proc,A)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*(L2,S)*(FSB,2)*
(Clock,sredni)*(PrT,nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
tPalomino = (Proc,AXP)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*(L2,S)*(FSB,3)*
(Clock,sredni)*(PrT,nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
tThoroughbred = (Proc,AXP)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*(L2,S)*(FSB,4)*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
tBarton = (Proc,AXP)*(Obud,O1)*(Ltr,tlum)*(Socket,A)*(L2,D)*(FSB,3)*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,4)*(HT,0)*(MemC,0)
tApplebred = (Proc,D)*(Obud,O1)*(Ltr,srednio)*(Socket,A)*(L2,M)*(FSB,3)*
(Clock,sredni)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,3)*(HT,0)*(MemC,0)
tThorton = (Proc,AXP)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*(L2,S)*(FSB,)*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
tSledgeHammer = (Proc,A64)*(Obud,O1)*(Ltr,wow!)*(Socket,9a)*(L2,O)*(FSB,)4*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,5)*(HT,0)*(MemC,2)
tNewcastle = (Proc,A64)*(Obud,O1)*(Ltr,tlum)*(Socket,9b)*(L2,O)*(FSB,4)*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,5)*(HT,0)*(MemC,1)
tClawHammer = (Proc,A64)*(Obud,O1)*(Ltr,wow!)*(Socket,7c)*(L2,O)*(FSB,4)*
(Clock,szybki)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,5)*(HT,0)*(MemC,1)
Skoro nasza kartoteka wyszukiwawcza jest gotowa - zobaczmy jak powinien przebiegać sam
proces wyszukiwania.
7
JAK PRZEBIEGA WYSZUKIWANIE ODPOWIEDZI NA PYTANIE W
METODZIE LIST PROSTYCH
Aby móc odpowiedzieć na postawione pytanie musimy przyjrzeć się bliżej formie w jakiej do
systemu należy kierować swoje zapytania. Są one w ogólności sumą termów składowych i mają one
postać:
t = t1+t2+...+tm
gdzie
t1..tm – term składowy
Na tak postawione pytanie wyszukiwanie odpowiedzi może przebiegać dwojako:
1 – Przeglądamy kolejne opisy obiektów i wybieramy obiekty zawierające w swoim opisie pierwszy
term składowy pytania.
Odpowiedź na pytanie składowe ti:
ς(ti) = {x € X, ti ≤ tx}
gdzie:
tx – opis obiektu x w systemie S
ti – term składowy pytania
Zbiór obiektów będących sumą kolejno uzyskanych odpowiedzi na termy składowe jest
odpowiedzia na pytanie t:
ς(t) = ς(t1)+...+ς(tm)
czas wyszukiwania:
τ = N*m*τ0
gdzie:
N – liczba obiektów w bazie danych
8
m – liczba termów składowych w pytaniu t
τ0 – średni czas przeglądu jednego dokumentu
2 – Tutaj porównujemy od razu pełne pytanie t z kolejnymi opisami obiektów i wybieramy te z
nich, które w swoim opisie zawierają co najmniej jeden z termów składowych pytania. Można
zauważyc, że ten sposób wyszukiwania odpowiedzi na pytanie zadane do systemu jest nieco
szybszy od sposobu przedstawionego powyżej. W poprzednim sposobie przeglądalismy kartotekę
wyszukiwczą tyle razy ile w pytaniu było termów składowych. Teraz każdy obiekt systemu jest
porównywany od razu z całym termem t co przy nieco wydłużonym czasie porównywania obiektu i
tak daje lepsze wyniki, bo np. Jeśli już pierwszy term składowy jest częscią opisu obiektu to nie
porównujemy juz kolejnych bo i tak obiekt jest już odpowiwdzią na pytanie.
ς(t) = {x € X,ti€t ti ≤ tx}
gdzie
tx – opis obiektu x w systemie S
ti – term składowy pytania
ti€t – oznacza, że term składowy ti występuje w pytaniu t.
czas wyszukiwania:
τ = N*τ0
gdzie:
N – liczba obiektów w bazie danych
τ0 – średni czas przeglądu jednego dokumentu (nieco dłuższy niż p rzypadku 1)
9
PRZYKŁAD 1
Skoro znamy już całą teorię – czas na praktykę!
Zadajemy do naszej bazy danych następujące pytanie:
t = (MemC,0)*(Clock,b.szybki)+(HT,1)
t=
t1
+ t2
Do wyszukania odpowiedzi zastosujemy bardziej optymalna metodę przeglądu kartoteki
wyszukiwawczej (nr2):
t≤tP54C
t≤tP55C
t≤tCovington
t≤tMendocino
t≤tCoppermine
t≤tKlamath
t≤tDeschutes
t≤tKatmai
t≤tCoppermine2
t≤tTualatin
t≤tWillamette
t≤tNorthwoodA
t≤tNorthwoodB
t≤tNorthwoodC
t≤tPrestonia
t≤tPrescott
t≤tP6
t≤tDeschutesMP
t≤tTanner
t≤tCascades
t≤tFoster
t≤tGallatin
t≤t5K86
t≤tLittleFoot
t≤tChompers
t≤tSharptooth
t≤tSpitfire
t≤tMorgan
t≤tPluto
t≤tOrion
t≤tThunderbird
t≤tPalomino
t≤tThoroughbred
t≤tBarton
t≤tApplebred
t≤tThorton
t≤tSledgeHammer
t≤tNewcastle
t≤tClawHammer
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
tak
tak
tak
tak
tak
nie
nie
nie
nie
tak
tak
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
nie
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
bo
t1!≤ tP54C oraz t2!≤ tP54C
t1!≤ tP55C oraz t2!≤ tP55C
t1!≤ tCovington oraz t2!≤ tCovington
t1!≤ tMendocino oraz t2!≤ tMendocino
t1!≤ tCoppermine oraz t2!≤ tCoppermine
t1!≤ tKlamath oraz t2!≤ tKlamath
t1!≤ tDeschutes oraz t2!≤ tDeschutes
t1!≤ tKatmai oraz t2!≤ tKatmai
t1!≤ tCoppermine2 oraz t2!≤ tCoppermine2
t1!≤ tTualatin oraz t2!≤ tTualatin
t1!≤ tWillamette oraz t2!≤ tWillamette
t1 ≤ tNorthwoodA
t1 ≤ tNorthwoodB
t1 ≤ tNorthwoodC
t1 ≤ tPrestonia
t1 ≤ tPrescott oraz t2≤ tPrescott
t1!≤ tP6 oraz t2!≤ tP6
t1!≤ tDeschutesMP oraz t2!≤ tDeschutesMP
t1!≤ tTanner oraz t2!≤ tTanner
t1!≤ tCascades oraz t2!≤ tCascades
t1 ≤ tFoster oraz t2≤ tFoster
t1 ≤ tGallatin oraz t2≤ tGallatin
t1!≤ t5K86 oraz t2!≤ t5K86
t1!≤ tLittleFoot oraz t2!≤ tLittleFoot
t1!≤ tChompers oraz t2!≤ tChompers
t1!≤ tSharptooth oraz t2!≤ tSharptooth
t1!≤ tSpitfire oraz t2!≤ tSpitfire
t1!≤ tMorgan oraz t2!≤ tMorgan
t1!≤ tPluto oraz t2!≤ tPluto
t1!≤ tOrion oraz t2!≤ tOrion
t1!≤ tThunderbird oraz t2!≤ tThunderbird
t1!≤ tPalomino oraz t2!≤ tPalomino
t1!≤ tThoroughbred oraz t2!≤ tThoroughbred
t1!≤ tBarton oraz t2!≤ tBarton
t1!≤ tApplebred oraz t2!≤ tApplebred
t1!≤ tThorton oraz t2!≤ tThorton
t1!≤ tSledgeHammer oraz t2!≤ tSledgeHammer
t1!≤ tNewcastle oraz t2!≤ tNewcastle
t1!≤ tClawHammer oraz t2!≤ tClawHammer
δ(t) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia, Prescott, Foster, Gallatin}
10
MODYFIKACJE METODY LIST PROSTYCH
Ponieważ wadą metody klasycznej sa długie czasy wyszukiwania to starano się wprowadzić pewne
jej modyfikacje w celu zmniejszenia tej wady.
UPORZĄDKOWANIE OPISÓW OBIEKTÓW
Jest to najprostsza z modyfikacji. Polega na uporządkowaniu kolejnosci atrybutów w opisie
obiektów co wymaga utzrymania tejze kolejnościi w zadawanych pytaniach. Modyfikacja ta skraca
nieco czas porównywania jednego obiektu.
GRUPOWANIE OBIEKTÓW WEDŁUG WYBRANEGO ATRYBUTU
Spośród atrybutów systemu wybieramy jeden (ten, o który najczęściej będziemy się pytać – w
praktyce w przypadku, gdy nie wiadomo jaka to będzie cecha dopuszcza się do pracy systemu w
metodzie klasycznej i zlicza się częstość występowania poszczególnych atrybutów w pytaniach) i
ustawiamy go na pierwszym miejscu. Następnie grupujemy obiekty w grupy o jednakowej wartości
tego atrybutu (czyli tak, aby elementy o tej samej wartości wyróżnionej cechy {o takim samym
deskryptorze} leżały obok siebie)... Wskazane jest zatem, aby cecha była możliwie
wielowartościowa, ale bez przesady (np. różna wartość cechy dla każdego elementu) – zachowajmy
“złoty środek”. Jednocześnie tworzy się tablicę adresową. Będzie ona zawierała wartości dla
wyróżnionej cechy, a przy każdej z nich adres pierwszego elementu z tą wartością. Dla pytań z
wyróżnioną cechą na podstawie tablicy znajdujemy obiekty z tym deskryptorem. Dzięki temu przy
wyszukiwaniu odpowiedzi na pytanie sprawdzamy tylko tą grupę obiektów, która ma odpowiednią
wartość tego wyróżnionego atrybutu. Dla pytań szczegółowych jest to jednak dopiero odpowiedź
przybliżona. W takim przypadku przeglądamy elementy z odpowiedzi przybliżonej i usuwamy te,
które nie są odpowiedzią na pozostałe deskryptory pytania. Jeśli jednak wyznaczony przez nas
atrybut nie występuje w pytaniu to musimy dokonać przeglądu zupełnego kartoteki. Jak zatem
widać wybrany przez nas parametr rzeczywiście powinien często występować w pytaniach oraz w
miarę równomiernie dzielić kartoteki na grupy i być wielowartościowy. Tylko wtedy bowiem ta
modyfikacja da odczuwalne rezultaty.
METODA PODZIAŁU POŁÓWKOWEGO
W tej modyfikacji obiekty nie mogą mieć dowolnej kolejności w bazie. Wybieramy cechę
najczęściej występującą w pytaniach i sortujemy elementy na podstawie wielkości tej cechy
(powinna być numeryczna lub alfanumeryczna). Podczas wyszukiwania porównujemy czy dana
cecha zawarta w pytaniu miała wartość mniejszą czy też większą od tej, którą zawiera środkowy
element bazy. Dzielimy bazę na połowę i w zależności od wyniku porównania (większy, mniejszy)
wybieramy tą połowę bazy, w której znajduje się poszukiwany deskryptor. Powtarzamy teraz całą
operację na wybranej połówce bazy (porównujemy deskryptor z pytania ze środkowym elementem
wybranej połówki). Czynność tę należy powtarzać aż na natrafianie na "nasz" element, albo też aż
do znalezienia wystarczająco "zawężonego zbioru poszukiwań" - wtedy ów zbiór przeszukujemy
metodą klasyczną. Dla pytań szczegółowych najpierw wyszukuje się obiekty zawierające daną
wartość wyróżnionej cechy. W wyniku tego otrzymuje się listę elementów - odpowiedzi przybliżone
na pytanie ogólne. Następnie bierze się każdy z tych elementów i przeszukuje go w celu
sprawdzenia czy posiada on w sobie pozostałe deskryptory pytania. Jeżeli tak nie jest, to zostaje on
wykreślany z listy na której znajdą się ostatecznie elementy będące odpowiedzią na całe pytanie
szczegółowe. Gdy zostało zadane pytanie nie zawierające wyróżnionej cechy, to wyszukiwanie
naturalnie przeprowadza się jak w metodzie klasycznej.
11
UWAGA!!!
W przypadku obu powyższych modyfikacji przy zmianach opisu elementu należy sprawdzać, czy
zmieniany deskryptor nie zawiera w sobie wyróżnionego atrybutu. W takim przypadku należy
umieścić taki element w odpowiednim miejscu bazy (przez sortowanie lub pogrupowanie).
Modyfikacje te wprowadzają skrócenie czasu wyszukiwania dla pytań z wyróżnioną cechą.
PRZYKŁAD 2
Zobaczmy jak wygląda wyszukiwanie odpowiedzi na pytanie w oparciu o metodę list prostych z
grupowaniem obiektów według wybranego atrybutu.
Musimy wybrać jeden atrybut który w miarę równo dzieli nam kartotekę wyszukiwawczą, będzie
często używany oraz jest wielowartościowy – powiedzmy ze będzie to atrybut „Clock” - jest jednym
z najważniejszych atrybutów dla procesorów oraz fakt, że wszystkim zależy na tym aby ich procesor
miał jak najwięcej mega/giga hz zapewni, że wystąpi w większości zapytań do naszej bazy danych.
Zanim przystąpimy do zaprezentowania procesu wyszukiwania musimy odpowiednio
zreorganizować naszą kartotekę wyszukiwawczą – prezentujemy ja ponizej.
(LP 1) tP54C = (Clock,b.wolny)*(Proc,P1)*(Obud,S1)*(Ltr,b.mało)*(Socket,7)*
(L2,D)*(FSB,0)*(PrT,b.stary)*(Tmax,chlodny)*(Pmax,1)*(HT,)*(MemC,0)
(LP 2) tP55C = (Clock,b.wolny)*(Proc,Pm)*(Obud,S1)*(Ltr,b.mało)*(Socket,7)*
(L2,D)*(FSB,1)*(PrT,stary)*(Tmax,chlodny)*(Pmax,1)*(HT,)*(MemC,0)
(LP 3) tCovington = (Clock,b.wolny)*(Proc,C)*(Obud,S2)*(Ltr,b.mało)*(Socket,S1)*
(L2,M)*(FSB,1)*(PrT,stary)*(Tmax,goracy)*(Pmax,1)*(HT,0)*(MemC,0)
(LP 4) tMendocino = (Clock,b.wolny)*(Proc,C)*(Obud,S2)*(Ltr,mało)*(Socket,S1)*
(L2,S)*(FSB,1)*(PrT,sredni)*(Tmax,parzy)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 5) tKlamath = (Clock,b.wolny)*(Proc,P2)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)*
(L2,D)*(FSB,1)*(PrT,stary)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 6) tDeschutes = (Clock,b.wolny)*(Proc,P2)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)
*(L2,D)*(FSB,1)*(PrT,sredni)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 7) tP6 = (Clock,b.wolny)*(PrT,stary)*(Proc,Pro)*(Obud,O3)*(Ltr,tlum)*
(Socket,8)*(L2,O)*(FSB,1)*(Tmax,parzy)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 8) tDeschutesMP = (Clock,b.wolny)*(Proc,P2X)*(Obud,S3)*(Ltr,wow!)*
(Socket,S2)*(L2,O)*(FSB,1)*(PrT,sredni)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 9) t5K86 = (Clock,b.wolny)*(Proc,K5)*(Obud,P1)*(Ltr,b.mało)*(Socket,5)*
(L2,D)*(FSB,1)*(PrT,stary)*(Tmax,parzy)*(Pmax,1)*(HT,0)*(MemC,0)
(LP 10) tLittleFoot = (Clock,b.wolny)*(Proc,K6)*(Obud,P1)*(Ltr,b.mało)*
(Socket,5)*(L2,D)*(FSB,1)*(PrT,stary)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 11) tSharptooth = (Clock,b.wolny)*(Proc,K6)*(Obud,C)*(Ltr,srednio)*
(Socket,7a)*(L2,D)*(FSB,1)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 12) tKatmai = (Clock,wolny)*(Proc,P3)*(Obud,S3)*(Ltr,b.duzo)*(Socket,S1)*
(L2,D)*(FSB,2)*(PrT,sredni)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 13) tCoppermine2 = (Clock,wolny)*(Proc,P3)*(Obud,F)*(Ltr,srednio)*
(Socket,S1)*(L2,S)*(FSB,2)*(PrT,nowy)*(Tmax,parzy)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 14) tTanner = (Clock,wolny)*(Proc,P3X)*(Obud,O3)*(Ltr,wow!)*(Socket,S2)*
12
(L2,O)*(FSB,2)*(PrT,sredni)*(Tmax,cieply)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 15) Cascades = (Clock,wolny)*(Proc,P3X)*(Obud,P2)*(Ltr,srednio)*(Socket,4c)*
(L2,S)*(FSB,1)*(PrT,nowy)*(Tmax,lod)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 16) tSpitfire = (Clock,wolny)*(Proc,D)*(Obud,C)*(Ltr,srednio)*(Socket,A)*
(L2,S)*(FSB,1)*(PrT,nowy)*(Tmax,zar)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 17) tChompers = (Clock,wolny)*(Proc,K6)*(Obud,P1)*(Ltr,b.mało)*(Socket,7a)*
(L2,D)*(FSB,1)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 18) tPluto = (Clock,wolny)*(Proc,A)*(Obud,CM)*(Ltr,srednio)*(Socket,SA)*
(L2,D)*(FSB,1)*(PrT,sredni)*(Tmax,chlodny)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 19) tOrion = (Clock,wolny)*(Proc,A)*(Obud,C)*(Ltr,srednio)*(Socket,SA)*
(L2,D)*(FSB,2)*(PrT,nowy)*(Tmax,chlodny)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 20) tCoppermine = (Clock,sredni)*(Proc,C)*(Obud,F)*(Ltr,mało)*(Socket,3)*
(L2,S)*(FSB,1)*(PrT,nowy)*(Tmax,zar)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 21) tTualatin = (Clock,sredni)*(Proc,P3)*(Obud,O2)*(Ltr,srednio)*(Socket,3)*
(L2,S)*(FSB,1)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,2)*(HT,0)*(MemC,0)
(LP 22) tWillamette = (Clock,sredni)*(Proc,P4)*(Obud,F)*(Ltr,b.duzo)*(Socket,4a)
*(L2,S)*(FSB,2)*(PrT,nowy)*(Tmax,cieply)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 23) tFoster = (Clock,sredni)*(Proc,X)*(Obud,P2)*(Ltr,tlum)*(Socket,6)*(L2,O)
*(FSB,1)*(PrT,nowy)*(Tmax,goracy)*(Pmax,4)*(HT,1)*(MemC,0)
(LP 24) tMorgan = (Clock,sredni)*(Proc,D)*(Obud,CM)*(Ltr,srednio)*(Socket,A)*
(L2,S)*(FSB,1)*(PrT,nowy)*(Tmax,zar)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 25) tThunderbird = (Clock,sredni)*(Proc,A)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*
(L2,S)*(FSB,2)*(PrT,nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 26) tPalomino = (Clock,sredni)*(Proc,AXP)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*
(L2,S)*(FSB,3)*(PrT,nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 27) tApplebred = (Clock,sredni)*(Proc,D)*(Obud,O1)*(Ltr,srednio)*(Socket,A)*
(L2,M)*(FSB,3)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,3)*(HT,0)*(MemC,0)
(LP 28) tThoroughbred = (Clock,szybki)*(Proc,AXP)*(Obud,O1)*(Ltr,duzo)*
(Socket,A)*(L2,S)*(FSB,4)*(PrT,b.nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 29) tBarton = (Clock,szybki)*(Proc,AXP)*(Obud,O1)*(Ltr,tlum)*(Socket,A)*
(L2,D)*(FSB,3)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 30) tThorton = (Clock,szybki)*(Proc,AXP)*(Obud,O1)*(Ltr,duzo)*(Socket,A)*
(L2,S)*(FSB,)*(PrT,b.nowy)*(Tmax,zar)*(Pmax,4)*(HT,0)*(MemC,0)
(LP 31) tSledgeHammer = (Clock,szybki)*(Proc,A64)*(Obud,O1)*(Ltr,wow!)*
(Socket,9a)*(L2,O)*(FSB,)4*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,5)*(HT,0)*(MemC,2)
(LP 32) tNewcastle = (Clock,szybki)*(Proc,A64)*(Obud,O1)*(Ltr,tlum)*(Socket,9b)*
(L2,O)*(FSB,4)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,5)*(HT,0)*(MemC,1)
(LP 33) tClawHammer = (Clock,szybki)*(Proc,A64)*(Obud,O1)*(Ltr,wow!)*(Socket,7c)
*(L2,O)*(FSB,4)*(PrT,b.nowy)*(Tmax,parzy)*(Pmax,5)*(HT,0)*(MemC,1)
(LP 34) tGallatin = (Clock,b.szybki)*(Proc,X)*(Obud,P1)*(Ltr,wow!)*(Socket,6)*
(L2,D)*(FSB,0)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,5)*(HT,1)*(MemC,0)
(LP 35) tNorthwoodA = (Clock,b.szybki)*(Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)
*(L2,D)*(FSB,2)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,4)*(HT,0)*(MemC,0)
13
(LP 36) tNorthwoodB = (Clock,b.szybki)*(Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)
*(L2,D)*(FSB,4)*(PrT,b.nowy)*(Tmax,cieply)*(Pmax,5)*(HT,1)*(MemC,0)
(LP 37) tNorthwoodC = (Clock,b.szybki)*(Proc,P4)*(Obud,F)*(Ltr,tlum)*(Socket,4b)
*(L2,D)*(FSB,4)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,5)*(HT,1)*(MemC,0)
(LP 38) tPrestonia = (Clock,b.szybki)*(Proc,P4)*(Obud,L)*(Ltr,wow!)*(Socket,4b)*
(L2,D)*(FSB,4)*(PrT,b.nowy)*(Tmax,chlodny)*(Pmax,6)*(HT,1)*(MemC,0)
(LP 39) tPrescott = (Clock,hyper)*(Proc,P4)*(Obud,C)*(Ltr,wow!)*(Socket,7b)*
(L2,O)*(FSB,0)*(PrT,mikro)*(Tmax,cieply)*(Pmax,6)*(HT,1)*(MemC,0)
Tablica wskaźników
Clock
AP
AK
(Clock,b.wolny)
1
11
(Clock,wolny)
12
19
(Clock,sredni)
20
27
(Clock,szybki)
28
33
(Clock,b.szybki)
34
38
(Clock,hyper)
39
39
Zadajemy do naszej bazy danych następujące pytanie:
t = (Clock,b.szybki)*(Tmax,chlodny)
t=
t1
*
t2
Teraz przeszukujemy tylko odpowiedni fragment bazy odczytany z tablicy wskaźników:
t≤tGallatin
t≤tNorthwoodA
t≤tNorthwoodB
t≤tNorthwoodC
t≤tPrestonia
nie
nie
nie
tak
tak
bo t2!≤
bo t2!≤
bo t2 ≤
bo t2 ≤
δ(t) = {NorthwoodC, Prestonia}
14
bo t2!≤ tGallatin
tNorthwoodA
tNorthwoodB
tNorthwoodC
tPrestonia
PARAMETRY METODY LIST PROSTYCH
1.Struktura bazy danych
W przypadku metody klasycznej bardzo prosta. W przypadku jej modyfikacji nieco się komplikuje
(staje się sztywna).
2.Redundancja
Nie występuje.
3.Proces aktualizacji
W przypadku metody klasycznej nie jest skomplikowany. Dodanie obiektu następuje na końcu listy,
jego modyfikacja polega tylko na odszukaniu obiektu i zmianie wartości atrybutów.
Sytuacja ma się inaczej w przypadku zmodyfikowanej metody list prostych, gdzie usztywniona
struktura kartoteki wyszukiwawczej narzuca pewien tok postepowania. Dodanie elementu do bazy
danych wiąże sie z odpowiednim jego umieszczeniem w kartotece a także z modyfikacją tablicy
wskaźników. Modyfikacja obiektu może także wiązac się z potrzebą przemieszczenia obiektu w
kartotece. Usuniecie obiektu jest także związane z reorganizacją bazy danych.
Jak widać ten parametr uległ wyraźnemu pogorszeniu w stosunku do metody klasycznej.
4.Język wyszukiwawczy
metoda nie narzuca stosowania specjalnego języka wyszukiwania informacji
5.Czas wyszukiwania
Czas potrzebny na wyszukanie interesującej nas informacji jest bardzo długi, gdyż konieczny jest
pełny przegląd bazy danych (metoda klasyczna). Sytuacja uległa poprawie we wprowadzonych
modyfikacjach tej metody.
6.Tryb pracy
Metoda nie narzuca specjalnych wymagań co do trybu pracy systemu (wsadowy lub ciagły).
15
WNIOSKI
O tym jak ważna jest informacja w obecnej rzeczywistości może świadczyć fakt nadania
obecnej epoce miana “epoki informacji”. Prawdą wszak jest, że obecnie to nie miecz, nie czołg jest
najpotężniejszą bronią naszej cywilizacji. Najgroźniejsza i zarazem najważniejsza jest informacja.
Natomiast efektywne odnajdywanie relewantnych danych jest złożonym i trudnym problemem,
który jednocześnie wydaje sie być kluczowym dla użyteczności obecnie stosowanych źródeł
informacji. Dobrą ilustracją jego złożoności są problemy związane z efektywnym konstruowaniem i
interpretacją zapytań w systemach wyszukiwawczych. Najpoważniejszym wyzwaniem wydaje się
jednak być sprostanie wymogom warstwy merytorycznej: zrozumienia potrzeb informacyjnych
użytkownika i ich pełne zaspokojenie.
Przedstawiona tutaj metoda list prostych, jedna z najbardziej naturalnych, pomimo
względnej prostoty i nieskomplikowanego poziomu matematycznego pozwala stosunkowo
efektywnie przeprowadzić tak wyszukiwanie jak i składowanie informacji.
Należy jednak pamiętać, że zazwyczaj we współczesnych systemach faza odnajdywania informacji
przebiega zwykle bardzo efektywnie, jedynym wyjątkiem bywa tutaj prezentacja wyników
wyszukiwania. W idealnym systemie wyszukiwania, wygenerowany wynik zawiera dokładnie tą
informację, która została opisana w koncepcji użytkownika. Jednakże w rzeczywiście istniejących
systemach współczynnik relewancji wyszukiwania rzadko osiąga poziom stu procent. Wynikiem
tego jest "zaśmiecenie" wyniku wyszukiwania informacją nierelewantną, nieistotną z punktu
widzenia użytkownika. Z tego też powodu dalsza obróbka surowych wyników wyszukiwania może
często znacznie poprawić użyteczność systemu.
Dlatego też sądzimy, że warto jest angażować się w rozwój następnych generacji systemów
wyszukiwania informacji. Z jednej strony stanowią one interesujące wyzwanie badawcze zarówno
w dziedzinie sprzętowej, programowej, jak i koncepcyjnej w dziedzinie sztucznej inteligencji,
rozumienia tekstów, maszyn uczących się, baz danych, a ostatnio przetwarzania i rozumienia
obrazów, rozpoznawania słowa mówionego i innych. Z drugiej strony dają wymierne korzyści
praktyczne dla rozwoju społecznego i gospodarczego ludzkości.
16