S ystemy W yszukiwania
I nformacji
METODA LIST PROSTYCH
OPRACOWALI:
Marcin Dzięgielewski
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
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
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.
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 Proc Obud Ltr Socket L2 FSB Clock PrT Tmax Pmax HT MemC
P54C P S1 b.malo 7 D 0 b.wolny b.stary Chlodny 1 0 0
P55C Pm S1 b.malo 7 D 1 b.wolny Stary Chlodny 1 0 0
Covington C S2 b.malo S1 M 1 b.wolny Stary Goracy 1 0 0
Mendocino C S2 Malo S1 S 1 b.wolny Sredni Parzy 2 0 0
Coppermine C F Malo 3 S 1 Sredni Nowy Zar 2 0 0
Klamath P2 S3 b.duzo S1 D 1 b.wolny Stary Cieply 3 0 0
Deschutes P2 S3 b.duzo S1 D 1 b.wolny Sredni Zar 2 0 0
Katmai P3 S3 b.duzo S1 D 2 Wolny Sredni Zar 2 0 0
Coppermine2 P3 S3 Srednio S1 S 2 Wolny Nowy Parzy 2 0 0
Tualatin P3 F Srednio 3 S 2 Sredni b.nowy Chlodny 2 0 0
Willamette P4 O2 b.duzo 4a S 1 Sredni Nowy Cieply 4 0 0
NorthwoodA P4 F Tlum 4b D 2 b.szybki b.nowy Cieply 4 0 0
NorthwoodB P4 F Tlum 4b D 2 b.szybki b.nowy Cieply 5 1 0
NorthwoodC P4 F Tlum 4b D 4 b.szybki b.nowy Chlodny 5 1 0 Prestonia P4 F Wow! 4b D 4 b.szybki b.nowy Chlodny 6 1 0
Prescott P4 L Wow! 7b O 4 Hyper Mikro Cieply 6 1 0
P6 Pro C Tlum 8 O 0 b.wolny Stary Parzy 3 0 0
DeschutesMP P2X O3 Wow! S2 O 1 b.wolny Sredni Cieply 3 0 0
Tanner P3X S3 Wow! S2 O 1 Wolny Sredni Cieply 3 0 0
Cascades P3X O3 Srednio 4c S 2 Wolny Nowy Lod 3 0 0
Foster X P2 Tlum 6 O 1 Sredni Nowy Goracy 4 1 0
Gallatin X P2 Wow! 6 D 1 b.szybki b.nowy Cieply 5 1 0
5K86 K5 P1 b.malo 5 D 0 b.wolny Stary Parzy 1 0 0
LittleFoot K6 P1 b.malo 5 D 1 b.wolny Stary Chlodny 2 0 0
Chompers K6 P1 b.malo 7a D 1 Wolny Sredni Chlodny 2 0 0
Sharptooth K6 P1 Srednio 7a D 1 b.wolny Sredni Chlodny 2 0 0
Spitfire D C Srednio A S 1 Wolny Nowy Zar 3 0 0
Morgan D C Srednio A S 1 Sredni Nowy Zar 3 0 0
Pluto A CM Srednio SA D 1 Wolny Sredni Chlodny 3 0 0
Orion A CM Srednio SA D 1 Wolny Nowy Chlodny 4 0 0
Thunderbird A C Duzo A S 2 Sredni Nowy Zar 4 0 0
Palomino AXP O1 Duzo A S 2 Sredni Nowy Zar 4 0 0
Thoroughbred AXP O1 Duzo A S 3 Szybki b.nowy Zar 4 0 0
Barton AXP O1 Tlum A D 4 Szybki b.nowy Parzy 4 0 0
Applebred D O1 Srednio A M 3 Sredni b.nowy Parzy 3 0 0
Thorton AXP O1 Duzo A S 3 Szybki b.nowy Zar 4 0 0
SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2
Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1
ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy 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)
*(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.
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
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)
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 nie bo t1!≤ tP54C oraz t2!≤ tP54C
t≤tP55C nie bo t1!≤ tP55C oraz t2!≤ tP55C
t≤tCovington nie bo t1!≤ tCovington oraz t2!≤ tCovington
t≤tMendocino nie bo t1!≤ tMendocino oraz t2!≤ tMendocino
t≤tCoppermine nie bo t1!≤ tCoppermine oraz t2!≤ tCoppermine
t≤tKlamath nie bo t1!≤ tKlamath oraz t2!≤ tKlamath
t≤tDeschutes nie bo t1!≤ tDeschutes oraz t2!≤ tDeschutes
t≤tKatmai nie bo t1!≤ tKatmai oraz t2!≤ tKatmai
t≤tCoppermine2 nie bo t1!≤ tCoppermine2 oraz t2!≤ tCoppermine2 t≤tTualatin nie bo t1!≤ tTualatin oraz t2!≤ tTualatin
t≤tWillamette nie bo t1!≤ tWillamette oraz t2!≤ tWillamette
t≤tNorthwoodA tak bo t1 ≤ tNorthwoodA
t≤tNorthwoodB tak bo t1 ≤ tNorthwoodB
t≤tNorthwoodC tak bo t1 ≤ tNorthwoodC
t≤tPrestonia tak bo t1 ≤ tPrestonia
t≤tPrescott tak bo t1 ≤ tPrescott oraz t2≤ tPrescott
t≤tP6 nie bo t1!≤ tP6 oraz t2!≤ tP6
t≤tDeschutesMP nie bo t1!≤ tDeschutesMP oraz t2!≤ tDeschutesMP
t≤tTanner nie bo t1!≤ tTanner oraz t2!≤ tTanner
t≤tCascades nie bo t1!≤ tCascades oraz t2!≤ tCascades
t≤tFoster tak bo t1 ≤ tFoster oraz t2≤ tFoster
t≤tGallatin tak bo t1 ≤ tGallatin oraz t2≤ tGallatin
t≤t5K86 nie bo t1!≤ t5K86 oraz t2!≤ t5K86
t≤tLittleFoot nie bo t1!≤ tLittleFoot oraz t2!≤ tLittleFoot
t≤tChompers nie bo t1!≤ tChompers oraz t2!≤ tChompers
t≤tSharptooth nie bo t1!≤ tSharptooth oraz t2!≤ tSharptooth t≤tSpitfire nie bo t1!≤ tSpitfire oraz t2!≤ tSpitfire
t≤tMorgan nie bo t1!≤ tMorgan oraz t2!≤ tMorgan
t≤tPluto nie bo t1!≤ tPluto oraz t2!≤ tPluto
t≤tOrion nie bo t1!≤ tOrion oraz t2!≤ tOrion
t≤tThunderbird nie bo t1!≤ tThunderbird oraz t2!≤ tThunderbird
t≤tPalomino nie bo t1!≤ tPalomino oraz t2!≤ tPalomino
t≤tThoroughbred nie bo t1!≤ tThoroughbred oraz t2!≤ tThoroughbred
t≤tBarton nie bo t1!≤ tBarton oraz t2!≤ tBarton
t≤tApplebred nie bo t1!≤ tApplebred oraz t2!≤ tApplebred
t≤tThorton nie bo t1!≤ tThorton oraz t2!≤ tThorton
t≤tSledgeHammer nie bo t1!≤ tSledgeHammer oraz t2!≤ tSledgeHammer t≤tNewcastle nie bo t1!≤ tNewcastle oraz t2!≤ tNewcastle
t≤tClawHammer nie bo t1!≤ tClawHammer oraz t2!≤ tClawHammer
δ(t) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia, Prescott, Foster, Gallatin}
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
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)*
(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)*
(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 nie bo t2!≤ tGallatin
t≤tNorthwoodA nie bo t2!≤ tNorthwoodA
t≤tNorthwoodB nie bo t2!≤ tNorthwoodB
t≤tNorthwoodC tak bo t2 ≤ tNorthwoodC
t≤tPrestonia tak bo t2 ≤ tPrestonia
δ(t) = {NorthwoodC, Prestonia}
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).
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.
