0 - Katedra Informatyki > Home
Download
Report
Transcript 0 - Katedra Informatyki > Home
W. Bartkiewicz
Wprowadzenie do budowy usług
informacyjnych
Wykład 3. Model wektorowy wyszukiwania informacji
Rankingowanie
• W modelu boolowskim dokument albo odpowiadał zapytaniu, albo nie.
– Dobre dla doświadczonych użytkowników, dobrze rozumiejących swoje
potrzeby, dziedzinę wyszukiwania i bazę dokumentów.
– Nieodpowiednie dla (większości) użytkowników, którzy nie potrafią
sformułować swoich potrzeb w postaci wyrażeń logicznych.
• Alternatywą jest ocena stopnia relewancji dokumentu dla danego
zapytania (scoring).
– Dzięki temu dokument może odpowiadać zapytaniu w pewnym stopniu, co
pozwala często uzyskać satysfakcjonujące użytkownika wyniki, nawet jeśli
potrzeba informacyjna sformułowana jest nie do końca precyzyjnie.
• Wynikiem zapytania jest ranking dokumentów, posortowany malejąco
według stopnia relewancji.
– Najbardziej relewantne dokumenty prezentowane są użytkownikowi na
początku rankingu, najmniej relewantne – na końcu.
– Ułatwia to przeglądanie wyników zapytania złożonych z wielu dokumentów.
Wyszukiwanie topologiczne
• W wyszukiwaniu topologicznym zapytania formułowane są w postaci
tzw. zapytania prostego lub „worka słów” (bag of words), czyli zestawu
termów (słów kluczowych) nie połączonych żadnymi operatorami
logicznymi.
– Użytkownik w zapytaniach po prostu określa słowa kluczowe, które
odzwierciedlają jego potrzeby informacyjne.
• Wyszukiwarka znajduje przechowywane w systemie dokumenty, które
opisane są zestawem słów kluczowych „podobnym” do podanych przez
użytkownika w zapytaniu.
• Podobieństwo to zazwyczaj określane jest z wykorzystaniem miar
opartych na podstawie liczby słów kluczowych występujących
jednocześnie w opisie dokumentu i w zapytaniu.
• Wyszukiwarka tworzy ranking znalezionych dokumentów, prezentując je
w kolejności od najbardziej do najmniej podobnych.
Wyszukiwanie topologiczne
QD
2
QD
Współczynnik dopasowania prostego
Współczynnik Dice’a
Problem – nie
uwzględnia długości
dokumentu i zapytania
D Q
QD
Współczynnik Jaccarda
DQ
QD
D
Q
Współczynnik cosinusoidalny
Model wektorowy
Zapytanie i dokumenty reprezentowane są jako wektory q = [q1, q2,..., qn],
dj = [w1j, w2j,..., wnj] w przestrzeni Rn, gdzie n jest liczbą wszystkich
termów indeksujących (rozmiar słownika).
1
qi
0
1
w ij
0
gdy term
i wystepuje
w przeciwnym
gdy term
w zapytaniu
q
przypadku
i wystepuje
w przeciwnym
w dokumencie
przypadku
n
Współczynnik
cosinusoidalny
Q D
D
Q
qw
i
=
ij
i 1
n
i 1
n
q
2
i
i 1
2
w ij
dj
Model wektorowy
Macierz termów/dokumentów
Term\Dokument
Blaster
Czarna dziura
Grawitacja
Gwiazda
Indianie
Kosmos
Kowboj
Nadprzestrzeń
Obserwacja
Planeta
Podróż
Rewolwerowiec
Teleskop
1
1
0
0
1
0
0
0
1
0
0
1
0
0
2
0
0
0
1
0
0
1
0
0
0
1
1
0
3
0
0
1
0
1
0
1
0
1
0
0
1
0
4
0
1
1
0
0
1
0
0
1
1
0
0
1
5
1
1
0
1
0
1
0
1
0
0
0
0
0
6
0
0
1
1
0
1
0
0
1
0
1
0
1
7
0
1
1
0
0
1
0
1
0
0
0
0
1
8
0
0
0
1
0
1
0
0
1
1
1
0
0
9
0
0
0
0
1
0
1
0
0
1
1
1
0
10
0
1
1
1
0
1
0
0
0
1
0
0
1
11
0
0
0
1
1
1
0
0
0
0
1
1
1
12
1
0
0
1
0
1
1
1
0
0
0
0
1
n x N = liczba termów x liczba dokumentów
Model wektorowy
Tworzenie rankingu
Term\Dokument
Blaster
Czarna dziura
Grawitacja
Gwiazda
Indianie
Kosmos
Kowboj
Nadprzestrzeń
Obserwacja
Planeta
Podróż
Rewolwerowiec
Teleskop
n
qw
i
1
1
0
0
1
0
0
0
1
0
0
1
0
0
2
0
0
0
1
0
0
1
0
0
0
1
1
0
3
0
0
1
0
1
0
1
0
1
0
0
1
0
4
0
1
1
0
0
1
0
0
1
1
0
0
1
5
1
1
0
1
0
1
0
1
0
0
0
0
0
6
0
0
1
1
0
1
0
0
1
0
1
0
1
7
0
1
1
0
0
1
0
1
0
0
0
0
1
8
0
0
0
1
0
1
0
0
1
1
1
0
0
ij
i 1
n
2
qi
i 1
10
0
1
1
1
0
1
0
0
0
1
0
0
1
11
0
0
0
1
1
1
0
0
0
0
1
1
1
12
1
0
0
1
0
1
1
1
0
0
0
0
1
3
2
1
3
4
4
4
3
1
4
3
3
0,61 0,41 0,18 0,50 0,73 0,67 0,73 0,55 0,18 0,67 0,50 0,50
i 1
n
9
0
0
0
0
1
0
1
0
0
1
1
1
0
2
w ij
5
7
6
10
1
1
0
0
1
0
1
1
1
0
0
0
0
1
Model wektorowy
Wagi termów
• Jak dotąd zakładaliśmy, że zarówno wektor zapytania q = [q1, q2,..., qn]
jak i opisy dokumentów dj = [w1j, w2j,..., wnj] mają charakter binarny, i
zawierają wyłącznie współrzędne 0 i 1.
• Wartości binarne oznaczają:
– Dany term może wystąpić w dokumencie (zapytaniu) lub nie.
– Wszystkie termy w opisie dokumentu (albo zapytaniu) traktowane są
równoważnie.
– Nie ma możliwości wyspecyfikowania informacji, że pewien term jest
bardziej istotny dla treści dokumentu niż inny.
• Ponieważ model wektorowy ma (w przeciwieństwie do boolowskiego)
charakter algebraiczny, a nie logiczny, możemy łatwo zrezygnować z
tego ograniczającego założenia.
– Dla wyznaczenia cosinusoidalnej miary podobieństwa (podobnie zresztą jak
i dla innych stosowanych miar) nie ma znaczenia czy analizowane wektory
mają współrzędne binarne, czy rzeczywiste.
Model wektorowy
Wagi termów
n
qw
i
sim ( q , d j )
ij
i 1
n
i 1
n
q
2
i
2
w ij
i 1
• W modelu wektorowym wyszukiwania informacji zarówno wektory
zapytania q = [q1, q2,..., qn], jak i opisu dokumentu dj = [w1j, w2j,..., wnj]
mogą być dowolnymi wektorami w przestrzeni Rn.
• Term i w opisie dokumentu (zapytania) j, reprezentowany jest przez
pewną nieujemną liczbę rzeczywistą wij, nazywaną „wagą”:
– Im większa wartość wagi termu, tym bardziej jest on istotny dla opisu treści
dokumentu.
– Wartość wij = 0 oznacza, że dany term w opisie dokumentu nie występuje.
Model wektorowy
Wagi termów
• Wagi termów zazwyczaj tworzone są przy wykorzystaniu tzw. formuły
tf*idf, uwzględniającej dwa podstawowe elementy oceny istotności
termu:
– Częstość termu tf (term frequency)
• Liczba wystąpień termu w dokumencie lub inna miara znaczenia termu
dla treści konkretnego dokumentu.
– Odwrotność częstości dokumentu idf (inverse document frequency)
• Miara wartości informacyjnej termu, czyli jego przydatności dla
rozróżniania treści różnych dokumentów w kolekcji.
• Jeśli term występuje w wielu dokumentach, to jego wartość
dyskryminacyjna jest relatywnie niższa.
• Może więc być to po prostu odwrotność liczby dokumentów w których
występuje dany term: 1/df(i).
• Zazwyczaj jednak stosuje się przyjętą na drodze empirycznej nieco
zmodyfikowaną miarę idf(i) = log(N/df(i)), gdzie N jest liczbą
dokumentów w kolekcji.
Model wektorowy
Wagi termów
w ij tf ij idf
i
N
tf ij log
df
i
tfij – (term frequency) częstość termu i w dokumencie j,
idfi – (inverse document frequency) odwrotność częstości dokumentów
N – liczba dokumentów w kolekcji
dfi – liczba dokumentów zawierających term i.
(1 mln dok.)
df
idf
1
100
1 000
10 000
100 000
1 000 000
6
4
3
2
1
0
Model wektorowy
Macierz termów/dokumentów
Term\Dokument
Blaster
Czarna dziura
Grawitacja
Gwiazda
Indianie
Kosmos
Kowboj
Nadprzestrzeń
Obserwacja
Planeta
Podróż
Rewolwerowiec
Teleskop
1
3
0
0
5
0
0
0
2
0
0
1
0
0
2
0
0
0
1
0
0
10
0
0
0
3
6
0
3
0
0
1
0
8
0
5
0
1
0
0
3
0
4
0
10
6
0
0
3
0
0
1
4
0
0
1
5
1
2
0
4
0
2
0
5
0
0
0
0
0
2
0
0
7
0
4
1
3
0
0
0
0
2
0
7
0
1
2
0
0
7
0
4
0
0
0
0
2
8
0
0
0
8
0
1
0
0
1
9
2
0
0
9
0
0
0
0
7
0
3
0
0
1
5
2
0
10
0
6
9
5
0
2
0
0
0
3
0
0
2
11
0
0
0
2
5
1
0
0
0
0
7
5
1
12
2
0
0
7
0
4
1
3
0
0
0
0
2
df
3
4
5
8
3
8
4
4
4
4
6
4
6
idf
0,60
0,48
0,38
0,18
0,60
0,18
0,48
0,48
0,48
0,48
0,30
0,48
0,30
Model wektorowy
Macierz termów/dokumentów
Term\Dokument
Blaster
Czarna dziura
Grawitacja
Gwiazda
Indianie
Kosmos
Kowboj
Nadprzestrzeń
Obserwacja
Planeta
Podróż
Rewolwerowiec
Teleskop
1
1,81
0,00
0,00
0,88
0,00
0,00
0,00
0,95
0,00
0,00
0,30
0,00
0,00
2
3
4
5
0,00 0,00 0,00 0,60
0,00 0,00 4,77 0,95
0,00 0,38 2,28 0,00
0,18 0,00 0,00 0,70
0,00 4,82 0,00 0,00
0,00 0,00 0,53 0,35
4,77 2,39 0,00 0,00
0,00 0,00 0,00 2,39
0,00 0,48 0,48 0,00
0,00 0,00 1,91 0,00
0,90 0,00 0,00 0,00
2,86 1,43 0,00 0,00
0,00 0,00 0,30 0,00
6
0,00
0,00
3,42
1,06
0,00
0,70
0,00
0,00
2,39
0,00
0,60
0,00
1,20
7
8
9
0,00 0,00 0,00
0,48 0,00 0,00
0,76 0,00 0,00
0,00 1,41 0,00
0,00 0,00 4,21
1,23 0,18 0,00
0,00 0,00 1,43
1,91 0,00 0,00
0,00 0,48 0,00
0,00 4,29 0,48
0,00 0,60 1,51
0,00 0,00 0,95
0,60 0,00 0,00
10
0,00
2,86
3,42
0,88
0,00
0,35
0,00
0,00
0,00
1,43
0,00
0,00
0,60
11
0,00
0,00
0,00
0,35
3,01
0,18
0,00
0,00
0,00
0,00
2,11
2,39
0,30
12
1,20
0,00
0,00
1,23
0,00
0,70
0,48
1,43
0,00
0,00
0,00
0,00
0,60
Model wektorowy
Cosinusoidalna miara podobieństwa
n
qw
i
sim ( q , d j )
ij
i 1
n
i 1
n
q
2
i
w
2
ij
q d
j
q d
j
Cosinus kąta między
wektorem zapytania i
wektorem dokumentu
i 1
t3
q
dj
θ
t1
t2
Model wektorowy
Indeks odwrotny
Term\Dokument
Blaster
Czarna dziura
Grawitacja
Blaster
Czarna dziura
Grawitacja
1
3
0
0
3
4
5
2
0
0
0
3
0
0
1
4
0
10
6
5
1
2
0
6
0
0
9
7
0
1
2
8
0
0
0
9
0
0
0
10
0
6
9
11
0
0
0
12
2
0
0
1 3
5 1
12 3
4 10
5 2
7 1
10 6
3 1
4 6
6 9
7 2
df idf
3 0,60
4 0,48
5 0,38
10 9
dfi
tfij
Wagi termów wij=tfij*idfi obliczamy w locie podczas wyszukiwania
– dodając nowe dokumenty nie trzeba ich przeliczać
Model wektorowy
Realizacja zapytań
n
• Po znalezieniu w słowniku indeksu
q i w ij
q d j
odwrotnego
wszystkich
termów
i 1
n
n
występujących w zapytaniu, należy dla
q dj
2
2
wszystkich dokumentów występujących w
q i w ij
i 1
i 1
listach odsyłaczy tych termów obliczyć
współczynniki cosinusów określające ich
podobieństwo do zapytania, a następnie stworzyć ranking zawierający k
najlepszych dokumentów.
• Długości dokumentów |dj| nie zależą od zapytania q. Mogą więc być
obliczone wcześniej, tak by skrócić czas realizacji zapytania.
– Obliczone długości dokumentów mogą być przechowywane dodatkowo w
indeksie, poza strukturą inwersyjną. Podczas realizacji zapytania obliczony
współczynnik cosinusów skalujemy zapamiętaną długością dokumentu.
Ponieważ robimy to tylko raz, więc dodatkowe nakłady obliczeniowe są
niewielkie.
– W indeksie odwrotnym zamiast „surowych” częstości termów tfij, możemy
przechowywać ich znormalizowane wartości tfij/|dj|.
Model wektorowy
Realizacja zapytań
• Możliwych jest cały szereg strategii i algorytmów realizacji rankingu.
Generalnie jednak wymagają one wykonania następujących operacji:
– Dla każdego dokumentu tworzymy i inicjujemy wartością 0, akumulator –
zmienną w której będziemy sumować miarę podobieństwa. W zależności od
implementacji akumulatory mogą być przechowywane w statycznej lub
dynamicznej strukturze danych.
– Dla wszystkich odsyłaczy dokumentów we wszystkich termach
indeksujących zapytania, dodajemy do akumulatora odpowiedniego
dokumentu kolejne wyrazy qi*wij.
– Po przeliczeniu wszystkich odsyłaczy, wybieramy akumulatory o wartościach
większych od 0.
– Porównując wartości wybranych akumulatorów wyszukujemy k najwyższych
wyników.
– Sortujemy otrzymane k akumulatorów w porządku malejącym i zwracamy
odpowiadające im dokumenty jako wynik zapytania.
Model wektorowy
Realizacja zapytań
TO_S(q)
ALOCATE tablicę akumulatorów A
foreach a[j]A
a[j].doc = k, a[j].s = 0
foreach termu zapytania q[i]q
FIND q[i] w słowniku indeksu odwrotnego
foreach dokumentu d[j] w liście odsyłaczy termu q[i]
a[j].s += w[i][j]*q[i]
ALOCATE strukturę danych wynik
INSERT k najlepszych akumulatorów do wynik
SORT akumulatory malejąco względem a.s
return wynik
Według
termów
Statyczna
tablica
akumulatorów
• W najprostszej postaci algorytmu akumulatory mogą być wybierane do
zwykłej tablicy.
– Wybieramy akumulatory o wartości a[j].s > 0 do tablicy roboczej i sortujemy.
Do tablicy wynik przepisujemy k pierwszych elementów tablicy roboczej.
• Dużą poprawę efektywności uzyskuje się jednak stosując jakąś
„samosortującą” się strukturę danych, np. drzewo, kolejka priorytetowa.
– Przepisujemy niezerowe akumulatory do struktury danych. Następnie
pobieramy k pierwszych do tablicy wynik.
Model wektorowy
Realizacja zapytań - przykład
Blaster
Czarna dziura
Grawitacja
3
4
5
1 3
5 1
12 3
4 10
5 2
7 1
10 6
3 1
4 6
6 9
7 2
• Zapytanie: Czarna dziura, Grawitacja.
– Zakładamy, że wagi termów qi występujących w zapytaniu
są równe 1, pozostałych równe 0 – częsta praktyka.
• Inicjujemy tablicę akumulatorów A.
• Znajdujemy w słowniku indeksu term „Czarna dziura”.
– Obliczamy idf = log(N/df) = log(12/4) = log(3) 0,5.
• Przetwarzamy po kolei listę odsyłaczy termu czarna
dziura.
10 9
A
1
2
3
4
5
6
7
8
9
10
11
12
0
0
0
0
0
0
0
0
0
0
0
0
Model wektorowy
Realizacja zapytań - przykład
Czarna dziura
4
4 10
tf*idf = 10*0.5 = 5
4 10
5 2
1
2
3
4
5
6
7
8
9
10
11
12
7 1
1*0.5 = 0.5
A
0
0
0
5
0
0
0
0
0
0
0
0
1
2
3
4
5
6
7
8
9
10
11
12
10 6
7 1
2*0.5 = 1
A
5 2
10 6
6*0.5 = 3
A
0
0
0
5
1
0
0
0
0
0
0
0
1
2
3
4
5
6
7
8
9
10
11
12
A
0
0
0
5
1
0
0.5
0
0
0
0
0
1
2
3
4
5
6
7
8
9
10
11
12
0
0
0
5
1
0
0.5
0
0
3
0
0
Model wektorowy
Realizacja zapytań - przykład
Grawitacja
5
3 1
4 6
6 9
7 2
10 9
idf = log(12/5) 0,4
3 1
4 6
1*0.4 = 0.4 6*0.4 = 2.4
A
1
2
3
4
5
6
7
8
9
10
11
12
6 9
9*0.4 = 3.6
A
0
0
0.4
5
1
0
0.5
0
0
3
0
0
1
2
3
4
5
6
7
8
9
10
11
12
7 2
2*0.4 = 0.8
A
0
0
0.4
7.4
1
0
0.5
0
0
3
0
0
1
2
3
4
5
6
7
8
9
10
11
12
10 9
9*0.4 = 3.6
A
0
0
0.4
7.4
1
3.6
0.5
0
0
3
0
0
1
2
3
4
5
6
7
8
9
10
11
12
A
0
0
0.4
7.4
1
3.6
1.3
0
0
3
0
0
1
2
3
4
5
6
7
8
9
10
11
12
0
0
0.4
7.4
1
3.6
1.3
0
0
6.6
0
0
Model wektorowy
Realizacja zapytań - przykład
Wyszukujemy powiedzmy 4 dokumenty (k = 4)
A
1
2
3
4
5
6
7
8
9
10
11
12
A
0
0
0.4
7.4
1
3.6
1.3
0
0
6.6
0
0
2,2
5,6
5,6
5,7
2,8
4,6
2,5
4,6
4,8
4,8
4,4
2,5
1
2
3
4
5
6
7
8
9
10
11
12
0,0
0
0,1
1,3
0,4
0,8
0,5
0,0
0,0
1,4
0,0
0,0
Wybór
>0
Długości dokumentów
rob
3 0,1
4 1,3
5 0,4
6 0,8
7 0,5
10 1,4
Sorto
wanie
rob
10 1,4
4 1,3
6 0,8
7 0,5
5 0,4
2 0,1
3 0,1
Wybór
4
wynik
10 1,4
4 1,3
6 0,8
7 0,5
Model wektorowy
Realizacja zapytań - przykład
Wyszukujemy powiedzmy 4 dokumenty (k = 4)
A
1
2
3
4
5
6
7
8
9
10
11
12
0,0
0
0,1
1,3
0,4
0,8
0,5
0,0
0,0
1,4
0,0
0,0
1.4 10
Wybór
>0
Wybór
4
1.3 4
0.8 6
0.1 3
wynik
10 1,4
4 1,3
6 0,8
7 0,5
0.4 5
0.5 7
Np.
Drzewo binarne w którym
każdy potomek jest nie
większy od rodzica
Model wektorowy
Realizacja zapytań
• Stosowanie tablicy akumulatorów staje się problematyczne dla dużych
kolekcji:
– Każdy dokument w kolekcji musi mieć swój akumulator – w przypadku
kolekcji o rozmiarach milionów dokumentów, rozmiary tablicy mogą być
nieakceptowalne.
– Wiele akumulatorów będzie niewykorzystanych – będą miały wartość 0.
• Alternatywą dla przechowywania akumulatorów jest zastosowanie
dynamicznej struktury danych.
– Dostęp musi być optymalizowany ze względu na identyfikator dokumentu.
– Zazwyczaj stosowane są struktury danych pochodzące od drzew B+ lub
indeksów haszujących.
• Jest to rozwiązanie wyraźnie gorsze pod względem efektywności
przetwarzania zapytania.
– Ale pod warunkiem, że identyfikatory dokumentów mogą zostać
wykorzystane do indeksowania odwołań do tablicy akumulatorów. W innym
przypadku dostęp do tablicy akumulatorów również musimy indeksować.
Model wektorowy
Realizacja zapytań
TO_D(q)
INITIALIZE dynamiczną strukturę akumulatorów D
foreach termu zapytania q[i]q
FIND q[i] w słowniku indeksu odwrotnego
foreach dokumentu d[j] w liście odsyłaczy termu q[i]
if akumulator aD taki że a.doc == d[j]
a.s += w[i][j]
else
ALLOCATE nowy akumulator a
a.doc = d[j], a.s = w[i][j]*q[i]
D = D {a}
ALOCATE strukturę danych wynik
INSERT k najlepszych akumulatorów do wynik
SORT akumulatory malejąco względem a.s
return wynik
Według
termów
Dynamiczna
alokacja
akumulatorów
Model wektorowy
Realizacja zapytań - przykład
Blaster
Czarna dziura
Grawitacja
3
4
5
1 3
5 1
12 3
4 10
5 2
7 1
10 6
3 1
4 6
6 9
7 2
10 9
• Zapytanie: Czarna dziura, Grawitacja.
– Zakładamy, że wagi termów qi występujących w zapytaniu są równe 1,
pozostałych równe 0 – częsta praktyka.
• Inicjujemy strukturę akumulatorów D (w naszym przykładzie tablica
haszująca mod 4).
• Znajdujemy w słowniku indeksu term „Czarna dziura”.
– Obliczamy idf = log(N/df) = log(12/4) = log(3) 0,5.
• Przetwarzamy po kolei listę odsyłaczy termu czarna dziura.
Model wektorowy
Realizacja zapytań - przykład
Czarna dziura
4 10
4
tf*idf = 10*0.5 = 5
D
0
1
2
3
7 1
5 2
4 10
D
0
1
2
3
5 2
4
5
7 1
2*0.5 = 1
D
0
1
2
3
10 6
1*0.5 = 0.5
4
5
5
1
D
0
1
2
3
4
5
5
1
7
0.5
Model wektorowy
Realizacja zapytań - przykład
Czarna dziura
4 10
4
5 2
10 6
6*0.5 = 3
D
0
1
2
3
4
5
5
1
7
0.5
D
0
1
2
3
4
5
5
1
10
3
7
0.5
7 1
10 6
Model wektorowy
Realizacja zapytań - przykład
Grawitacja
5
3 1
4 6
6 9
7 2
10 9
idf = log(12/5) 0,4
3 1
4 6
1*0.4 = 0.4
D
0
1
2
3
4
5
5
1
10
3
7
0.5
6 9
6*0.4 = 2.4
3
0.4
D
0
1
2
3
4
7.4
5
1
10
3
7
0.5
9*0.4 = 3.6
3
0.4
D
0
1
2
3
4
7.4
5
1
10
3
6
3.6
7
0.5
3
0.4
Model wektorowy
Realizacja zapytań - przykład
Grawitacja
5
3 1
4 6
6 9
7 2
10 9
idf = log(12/5) 0,4
7 2
10 9
2*0.4 = 0.8
D
0
1
2
3
4
7.4
5
1
10
3
6
3.6
7
0.5
3
0.4
D
0
1
2
3
9*0.4 = 3.6
4
7.4
5
1
10
3
6
3.6
7
1.3
3
0.4
D
0
1
2
3
4
7.4
5
1
10
6.6
6
3.6
7
1.3
3
0.4
Model wektorowy
Realizacja zapytań
• Druga grupa podejść do przetwarzania zapytania, opiera się na
przetwarzaniu odsyłaczy w porządku dokumentów, a nie termów.
– Odsyłacze przypisane danemu termowi muszą być uporządkowane według
identyfikatora dokumentu.
– Zakłada się również, że liczba termów w zapytaniu jest ograniczona i nie
większa niż pewna z góry założona liczba Q.
• Listy inwersyjne przypisane termom zapytania mogą być wtedy
przetwarzane równolegle, a nie sekwencyjnie, jak w przypadku wcześniej
omawianych strategii opartych na porządku termów.
• W ten sposób jesteśmy w stanie obliczyć całkowity wynik dokumentu,
zanim rozpoczniemy obliczenia dla następnego.
Model wektorowy
Realizacja zapytań
DO(q)
ALOCATE strukturę danych wynik
foreach termu zapytania q[i]q
FIND q[i] w słowniku indeksu odwrotnego
h[i] = pierwszy odsyłacz z listy inwersyjnej dla termu g[i]
while nie koniec wszystkich list inwersyjnych w tablicy h[i]
FIND min takie że h[min].doc = MIN h[i].doc
a.doc = h[min].doc, a.s = 0
foreach h[i]
if a.doc == h[i].doc then
a.sum += h[i].w[i][j]*q[i]
NEXT h[i]
if koniec listy inwersyjnej q[i] then
h[i]=koniec;
SELECT a do wynik
SORT akumulatory malejąco względem a.s
return wynik
Według
dokumentów
Model wektorowy
Realizacja zapytań - przykład
Blaster
Czarna dziura
Grawitacja
3
4
5
1 3
5 1
12 3
4 10
5 2
7 1
10 6
3 1
4 6
6 9
7 2
10 9
• Zapytanie: Czarna dziura, Grawitacja.
– Zakładamy, że wagi termów qi występujących w zapytaniu są równe 1,
pozostałych równe 0 – częsta praktyka.
• Inicjujemy strukturę wynik (w naszym przykładzie
priorytetowa minimum, dla k=4 elementów).
• Znajdujemy w słowniku indeksu term „Czarna dziura”.
– Obliczamy idf = log(N/df) = log(12/4) = log(3) 0,5.
– h[0] = wskaźnik do pierwszego odsyłacza dla tego termu
• Znajdujemy w słowniku term „Grawitacja”.
– Obliczamy idf = log(N/df) = log(12/5) = log(2.4) 0,4.
– h[1] = wskaźnik do pierwszego odsyłacza dla tego termu
kolejka
Model wektorowy
Realizacja zapytań - przykład
h[0]
4 10
5 2
7 1
10 6
h[1]
3 1
4 6
6 9
7 2
min=1
a
Wynik:
3 0
3 0.4
10 9
dla h[1] wij=1*0.4 = 0.4
3 0.1
DocLen = 5.6, 0.4/5.6 = 0.1
h[0]
4 10
5 2
7 1
10 6
h[1]
4 6
6 9
7 2
10 9
Model wektorowy
Realizacja zapytań - przykład
h[0]
4 10
5 2
7 1
10 6
h[1]
4 6
6 9
7 2
10 9
a
min=0
Wynik:
4 0
4 5
dla h[0] wij=10*0.5 = 5
4 7.4
dla h[1] wij=6*0.4 = 2.4
3 0.1
4 1.3
DocLen = 5.7 7.4/5.7 = 1.3
h[0]
5 2
7 1
10 6
h[1]
6 9
7 2
10 9
Model wektorowy
Realizacja zapytań - przykład
h[0]
5 2
7 1
10 6
h[1]
6 9
7 2
10 9
a
min=0
Wynik:
5 0
5 1
dla h[0] wij=2*0.5 = 1
7 1
10 6
h[1]
6 9
7 2
4 1.3
DocLen = 2.8 1/2.8 = 0.4
Wynik:
h[0]
3 0.1
10 9
3 0.1
5 0.4
4 1.3
Model wektorowy
Realizacja zapytań - przykład
h[0]
7 1
10 6
h[1]
6 9
7 2
a
10 9
min=1
Wynik:
3 0.1
5 0.4
4 1.3
6 0
6 3.6
dla h[1] wij=9*0.4 = 3.6 DocLen = 4.6 3.6/4.6 = 0.8
Wynik:
h[0]
7 1
10 6
h[1]
7 2
10 9
3 0.1
5 0.4
6 0.8
4 1.3
Model wektorowy
Realizacja zapytań - przykład
h[0]
7 1
10 6
h[1]
7 2
10 9
a
min=0
Wynik:
7 0
3 0.1
5 0.4
6 0.8
7 0.5
dla h[0] wij=1*0.5 = 0.5 DocLen = 2.5 1.3/2.5 = 0.5
7 1.3
dla h[1] wij=2*0.4 = 0.8 Wynik:
5 0.4
6 0.8
4 1.3
Wynik:
5 0.4
7 0.5
6 0.8
h[0]
10 6
h[1]
10 9
4 1.3
4 1.3
Model wektorowy
Realizacja zapytań - przykład
h[0]
10 6
h[1]
10 9
a
min=0
Wynik:
10 0
5 0.4
7 0.5
6 0.8
4 1.3
DocLen = 4.8 16.6/4.8 = 1.4
10 3
dla h[0] wij=6*0.5 = 3
10 6.6
dla h[1] wij=9*0.4 = 3.6 Wynik:
7 0.5
6 0.8
4 1.3
Wynik:
7 0.5
6 0.8
4 1.3
10 1.4
Model wektorowy
Efektywność przetwarzania zapytań
Krótkie zapytania (1 – 5 termów)
k=10
ok. 2 mln stron WWW (30 GB)
ponad 3 mln. różnych termów
k=1000
wszystkie
>0
Źródło: Cambazoglu, Aykanat, Performance of query processing implementations in ranking-based
text retrieval systems using inverted indices, IP&M, 42 (2006), 875-898.
Model wektorowy
Efektywność przetwarzania zapytań
Średnie zapytania (6 – 25 termów)
k=10
ok. 2 mln stron WWW (30 GB)
ponad 3 mln. różnych termów
k=1000
wszystkie
>0
Źródło: Cambazoglu, Aykanat, Performance of query processing implementations in ranking-based
text retrieval systems using inverted indices, IP&M, 42 (2006), 875-898.
Model wektorowy
Efektywność przetwarzania zapytań
Długie zapytania (21 – 250 termów) ok. 2 mln stron WWW (30 GB)
ponad 3 mln. różnych termów
k=10
k=1000
wszystkie
>0
Źródło: Cambazoglu, Aykanat, Performance of query processing implementations in ranking-based
text retrieval systems using inverted indices, IP&M, 42 (2006), 875-898.
Model wektorowy
Efektywność przetwarzania zapytań
Średnie zapytania (6 – 25 termów)
k = 10
ok. 500 tys.
stron WWW
1.5 mln. termów
ok. 1 mln.
stron WWW
2.2 mln. termów
ok. 2 mln.
stron WWW
3 mln.
termów
Źródło: Cambazoglu, Aykanat, Performance of query processing implementations in ranking-based
text retrieval systems using inverted indices, IP&M, 42 (2006), 875-898.
Model wektorowy
Efektywność przetwarzania zapytań
Średnie zapytania (6 – 25 termów)
Wszystkie akumulatory > 0
ok. 500 tys.
stron WWW
1.5 mln. termów
ok. 1 mln.
stron WWW
2.2 mln. termów
ok. 2 mln.
stron WWW
3 mln.
termów
Źródło: Cambazoglu, Aykanat, Performance of query processing implementations in ranking-based
text retrieval systems using inverted indices, IP&M, 42 (2006), 875-898.
Model wektorowy
Optymalizacje
• Czasy przetwarzania zapytania rzędu kilku (a nawet kilkunastu) sekund
mogą być zbyt kosztowne w przypadku dużych, sieciowych kolekcji
dokumentów, przeglądanych jednocześnie przez wielu użytkowników.
• Jego redukcja jest możliwa, ale wiąże się ona z rezygnacją z
przetwarzania części danych. Nie mamy wówczas gwarancji, że
utworzony ranking rzeczywiście obejmuje k najlepszych dokumentów.
• Do często stosowanych optymalizacji przetwarzania zapytań należą
(między innymi) podejścia oparte na:
– Rezygnacji z przetwarzania odsyłaczy dokumentów w listach inwersyjnych,
które mają już niewielki wpływ na końcową wartość współczynnika
cosinusów.
– Wstępnym pogrupowaniu dokumentów w kolekcji.
– Redukcji wymiaru przestrzeni wektorowej, tzn. przekształceniu termów w
opisach dokumentów i zapytaniach, tak by zredukować liczbę termów.
Model wektorowy
Ranking częściowy
• Wyznaczenie współczynnika cosinusów wymaga posumowania
iloczynów wij*qi. Ranking częściowy polega na redukcji kosztów
obliczeniowych tego procesu poprzez uwzględnienie w końcowych
wyniku wyłącznie tych iloczynów wij*qi, które są dostatecznie duże.
– Możliwe do zastosowania wyłącznie dla algorytmów przetwarzania zapytania
w porządku termów.
– Termy zapytania przetwarzane są w porządku malejących idf.
– Odsyłacze w listach inwersyjnych dla poszczególnych termów w indeksie
uporządkowane są malejąco według tf, a nie identyfikatora dokumentu.
– Jeśli obliczony iloczyn wij*qi jest mniejszy od pewnego założonego progu,
przetwarzanie danej listy inwersyjnej może zostać zakończone (ponieważ z
uporządkowania odsyłaczy wynika, że wszystkie kolejne iloczyny będą
mniejsze równe od niego).
– Niektóre implementacje ograniczają również obliczenia cosinusa wyłącznie
do rzadkich termów (tzn. o dostatecznie dużym idf).
Model wektorowy
Grupowanie dokumentów
• Operacja grupowania (analizy skupień) dokumentów (ang. clustering)
polega na określeniu w kolekcji jednorodnych tematycznie podzbiorów
dokumentów. O grupowaniu będziemy mówili w dalszej części wykładu.
– Każda podgrupa dokumentów reprezentowana może być przez zbiór słów
kluczowych nazywany jej prototypem, albo centroidem.
• Operacja grupowania kolekcji może być wykorzystana (między innymi)
do przyśpieszenia procesu przetwarzania zapytania.
– Wcześniej przeprowadzamy operację grupowania kolekcji dokumentów.
– Liczba podgrup jest dużo mniejsza niż liczba wszystkich dokumentów.
Zamiast wyznaczać podobieństwo przetwarzanego zapytania do dużej liczby
dokumentów, obliczamy je dla znacznie mniejszej liczby centroidów.
– Następnie obliczamy cosinusy i sporządzamy ranking dla dokumentów
należących do podgrup najbardziej podobnych podobnych do zapytania.
Model wektorowy
Redukcja wymiarowości
• Przypomnijmy, że w modelu wektorowym wyszukiwania traktujemy
dokumenty jako wektory w pewnej przestrzeni o wymiarze
odpowiadającym liczbie wszystkich możliwych termów w słowniku.
• Wymiar tej przestrzeni jest więc zazwyczaj bardzo duży.
– W prezentowanych wcześniej wynikach oceny efektywności algorytmów
przetwarzania zapytania, wykorzystywana kolekcja miała blisko 3 miliony
termów.
• Redukcja wymiarowości polega na znalezieniu takiego jej przekształcenia
w przestrzeń o dużo niższym wymiarze (m << n), aby utracić jak
najmniej informacji o różnicach między dokumentami (odległościach
dokumentów).
– Zazwyczaj da się to zrobić – informacja dyskryminacyjna dokumentów jest
mocno redundantna.
– Mniejszy wymiar przestrzeni – mniej termów, co przyśpiesza obliczenia
cosinusów.
– O pewnej standardowej w IR metodzie, LSI (Latent Semantic Indexing)
będziemy mówili w dalszej części wykładu.