Implementierung von IR-Systemen
Transcript of Implementierung von IR-Systemen
Implementierung von IR-Systemen
Norbert Fuhr
Aufbau von IRS
Dateistruktur eines IRSDialogfunktionen herkömmlicher IRS
Aufbau vonIRSFunktionale Sicht
breakinto words assign doc id’s
term weightingstoplist
stemming
stemming
parse query
ranking
Database
Interface
relevancejudgments
User
Documents
text
words
stemmed words term
document numbersand field numbers
documents
retrieved document set
ranked document set
query terms
stemmedwords
queries documents
query
non−stoplistwords
queries
weights
Dateistruktur eines IRS
Dokument-Datei / Wörterbuch / inverted File
Information
Retrieval
Systeme
Nutzer
Worterbuch
Computer 2 -
3 -
4 -
4 -
2 -
1 31 2 4
1 2 4 5
1 43 5
2 5
Inverted File
nummerDokument-
Autor
Titel
Indexierung
Aspektecomputergestutzter
InformationRetrieval-systeme
ComputerInformationRetrieval-Systeme
1 2 3 4 5
Ash Brown Jones Reynolds Smith
Eine Umfragebei Nutzern
vonInformationRetrieval-systemen
InformationRetrievalNutzer
Geschichteder
Computer-
systeme
Computer
Systeme
Zum Standder Ent-wicklung
von Retrieval-systemen
InformationRetrieval-Systeme
Benutzerneuer
Retrieval-systeme
RetrievalSystemeNutzer
Dialogfunktionen herkömmlicher IRS
I ZugangskontrolleI Auswahl der DatenbasisI Anzeige des Wörterbuchs / ThesaurusI Formulierung von AnfragenI Anzeige von AntwortenI Verwaltung von Suchprofilen
(einschließlich SDI-Läufe/Downloading)I Drucken von Antworten
Zugriffspfade
ScanningInvertierte ListenPAT-TreesSignaturen (Bloom-Filter)
ScanningGenerelle Überlegungen
Verzicht auf Anlegen eines gesonderten Zugriffspfades,stattdessen möglichst effiziente sequentielle Suche→ erspart den Overhead für das Anlegen des Zugriffspfades
Probleme
Aufwand wächst linear mit dem Datenvolumen, daher nur fürkleinere Datenbestände geeignet(insbesondere auch in Texteditoren eingesetzt)
Berücksichtigung von Flexions- und Derivationsendungen erhöhtdie Komplexität und den Berechnungsaufwand derAlgorithmen
Wortreihenfolge und Stoppwortelimination: ditoinformation retrieval — retrieval of information
Rankingalgorithmen: erfordern zwei Durchläufe(inverse Dokumenthäufigkeit steht erst nach dem Durchlaufenaller Dokumente fest)
Anwendungsbereiche:
I hardwaremäßig implementiert:Verarbeitungsgeschwindigkeit ≥ Transferrate derPlattenlaufwerke
I Cloud computing: paralleles, sequenzielles Durchsuchen derKollektion
I Highlighting von Suchbegriffen bei der Anzeige vongefundenen Dokumenten
I Vergleichskomponente in Signatur-Systemen(Signaturen wirken nur als Filter)
Vorbemerkungen zu Scanning-Algorithmen
im folgenden nur Patterns bestehend aus einer festen Zeichenfolgebetrachtet(keine Alternativen, keine “don’t care’s”)Notationen:n Länge des Textesm Länge des Patterns (sei stets m ≤n)c Größe des zugrundeliegenden Alphabets Σ
Cn Erwartungswert für die Anzahl der zeichenweisen Vergleiche ineinem Algorithmus für einen Text der Länge n
Analyse
Analyse basiert auf Annahme einer zufälligen Zeichenkette(Zeichenkette der Länge l besteht aus der Konkatenation von lZeichen, die unabhängig und gleichverteilt zufällig aus Σentnommen werden)
Wahrscheinlichkeit für die Gleichheit von zwei zufällig ausgewähltenZeichen: 1/c
Wahrscheinlichkeit für den match zweier Zeichenfolge der Länge m:1/cm
Erwartungswert der Anzahl Treffer t für ein Pattern der Länge m ineinem String der Länge n:
E (t) =n −m + 1
cm
Der naive Algorithmus
Pattern: abracadabra
aababcabcdabracadabra
ababraabraaabraaaabracadabra
Algorithmus:
1 pub l i c i n t nsea r ch ( char [ ] t e x t , i n t n , char [ ] pat , i n t m) {2 i n t i , j , k , l im ;3 l im = n−m+1;4 f o r ( i = 1 ; ( i <= l im ) ; i++) {5 k = i ;6 f o r ( j = 1 ; ( j <= m && t e x t [ k ] == pat [ j ] ) ; j++)7 k++;8 i f ( j > m) return i ;9 }
10 return NOTFOUND;11 }
Abschätzung des Aufwands:
Erwartungswert für die Anzahl Vergleiche bis zum ersten Treffer:
Cfirstmatch =cm+1
c − 1− c
c − 1Erwartungswert für die Gesamtzahl der Vergleiche:
Cn =c
c − 1
(1− 1
cm
)(n −m + 1) + O(1)
(worst case erfordert m · n Vergleiche)
Verbesserung des naiven Algorithmus’:bestimmte Rechnerarchitekturen bieten speziellen Maschinenbefehlzur Suche nach dem ersten Auftreten eines bestimmten Zeichens(bzw. aus einer Menge von Zeichen)(x86-Architektur: SCAS “Scan String”)
→ Einsatz für die Suche nach dem ersten Zeichen des Patterns
Der Knuth-Morris-Pratt-Algorithmus
Grundidee:wenn bereits eine teilweise Übereinstimmung zwischen Pattern undString gefunden wurde, bevor das erste verschiedene Zeichenauftritt, kann diese Information zur Wahl eines besserenAufsetzpunktes gewählt werden
aababrabrabracadabra
ababr
abracbrac
bracadabra
Beobachtungen:I weniger Aufsetzpunkte als beim naiven AlgorithumsI Zeiger im String muss nie zurückgesetzt werden
Knuth-Morris-Pratt-Algorithmus
1 pub l i c i n t kmpsearch ( char [ ] t e x t , i n t n , char [ ] pat , i n t m) {2 i n t i = 1 ; i n t j = 1 ;3 i n t [ ] nex t = i n i t n e x t ( pat , m) ;4
5 whi le ( i <= n ) {6 whi le ( ( j != 0) && ( pat [ j ] != t e x t [ i ] ) ) {7 j = next [ j ] ;8 }9 i f ( j == m) {
10 return ( i − m + 1 ) ;11 }12 e l s e {13 i ++; j++;14 }15 }16 return NOTFOUND;17 }
Vorprozessierung des Patterns notwendig:Tabelle next[1..m] gibt die nächste Position im Pattern an, mitder bei Ungleichheit verglichen werden muss:
next[j ] = max{i |(pattern[k] = pattern[j − i + k]
for k = 1, . . . , i − 1)
and pattern[i ] 6= pattern[j ]}
(Suche nach dem längsten übereinstimmenden Praefix, so dass dasnächste Zeichen im Pattern verschieden ist von dem Zeichen, beidem die Ungleichheit auftrat)Tabelle next fuer den Pattern abracadabra:
a b r a c a d a b r anext[j] 0 1 1 1 2 1 2 1 2 3 4
next[i]=0 → Zeiger im Text um eins vorrücken und wieder mitdem Anfang des Patterns vergleichen
obere Schranke für den Erwartungswert der Gesamtzahl derVergleiche:(bei großen Alphabeten)
Cn
n≤ 1 +
1c− 1
cm
Verringerung des Aufwands beim KMP-Algorithmus im Verhältniszum naiven:
KMPnaive
≈ 1− 2c2
Der Boyer-Moore-Horspool-Algorithmus
vereinfachte, beschleunigte Variante des Boyer-Moore-Algorithmus’Grundideen:
I Vergleich des Patterns von rechts nach linksI Vorkommensheuristik
ABCDEFABzzzzzzzzABCABCxxxABC
ABCxxxABC
Boyer-Moore-Horespool-Algorithmus
1 pub l i c i n t bmhsearch ( char [ ] t e x t , i n t n , char [ ] pat , i n t m) {2 i n t i = m;3 i n t j ;4
5 Map<Charac te r , I n t e g e r > d = i n i t d ( pat , m) ;6 whi le ( i <= n ) {7 i n t t i=i ;8 f o r ( j = m; ( t e x t [ t i ] == pat [ j ] ) ; ) {9 j−−; t i −−;
10 }11 i f ( j == 0) {12 return t i + 1 ;13 }14 i = i + d (d ,m, t e x t [ i ] ) ;15 }16 return NOTFOUND;17 }
Vorkommensheuristik
Ausrichten der Textposition, an der Ungleichheit auftrat, mit demersten übereinstimmenden Zeichen im PatternDefinition einer über das Textzeichen indizierten Tabelle d (gibtebenfalls Shift im Text an, Vergleich jeweils beginnend mit demletzten Pattern-Zeichen)
d [x ] = min{s|s = m or(0 ≤ s < m and pattern[m − s] = x)}
Beispiel: Tabelle d für den Pattern ABCXXXABC:
d [′A′] = 2 d [′B ′] = 1 d [′C ′] = 6 d [′X ′] = 3
(für alle anderen Zeichen x ist d[x] = 9)
Sonderfall:wenn Text-Zeichen mit dem letzten Zeichen des Patternsübereinstimmt(aber weiter vorne ist eine Ungleichheit aufgetreten):Setze zuerst korrespondierendes Zeichen in der Shift-Tabelle aufden Wert m und berechne dann die Shift-Tabelle für die erstenm − 1 Zeichen des Patterns:
d [x ] = min{s|s = mor (1 ≤ s < m and pattern[m − s] = x)}
Beispiel: Tabelle d für den Pattern ABCXXXABC:
d [′A′] = 2 d [′B ′] = 1 d [′C ′] = 6 d [′X ′] = 3
(für alle anderen Zeichen x ist d[x] = 9)
asymptotischer Aufwand für n und c (mit c � n und m > 4):
Cn
n=
1m
+m + 12mc
+ O(c−2)
Der Boyer-Moore-Algorithmus
Grundideen:I Vergleich des Patterns von rechts nach linksI Vorkommensheuristik (wie bei Boyer-Moore-Horspool)I Match-Heuristiken (ähnlich KMP)
Boyer-Moore-Algorithmus1 pub l i c i n t bmsearch ( char [ ] t e x t , i n t n , char [ ] pat , i n t m) {2 i n t i = m;3 i n t j ;4
5 Map<Charac te r , I n t e g e r > d = i n i t d ( pat , m) ;6 i n t [ ] dd = new in t [ pat . l e n g t h ] ;7 preBmGs ( pat , m, dd ) ;8
9 whi le ( i <= n ) {10 i n t t i=i ;11 f o r ( j = m; ( t e x t [ t i ] == pat [ j ] ) ; ) {12 j−−; t i −−;13 }14 i f ( j == 0) {15 return t i + 1 ;16 }17 i = i + Math . max( d (d ,m, t e x t [ i ] ) , dd [ j ] ) ;18 }19 return NOTFOUND;20 }
Match-Heuristik:
Shift, so dass an der neuen Vergleichsposition1. Pattern alle vorher übereinstimmenden Zeichen matcht2. ein anderes Zeichen als vorher an der Vergleichsposition steht
Beispiel zur Match-Heuristik
ABCDEFABCxxxABCABCxxxABC
ABCxxxABC
Implementierung der Match-Heuristik als Tabelle dd(gibt den Shift im Text an, Vergleich jeweils beginnend mit demletzten Pattern-Zeichen) Berechnung für jede Stelle j im Pattern:1. Suche Anfang des “rightmost plausible reoccurance” rpr(j)2. alignslide = j + 1− rpr(j)3. endslide = m − j4. dd [j ] = alignslide + endslide = m + 1− rpr(j)
Beispiel: Tabelle dd für den Pattern ABCXXXABC:
j: 1 2 3 4 5 6 7 8 9A B C X X X A B C
dd[j] 14 13 12 11 10 9 11 10 1------- ^ -------
1. rpr(6) = 12. dd [6] = 9 + 1− 1 = 9
Algorithmus wählt jeweils den größeren Shift von Match- undVorkommensheuristik(gleiche Shift-Strategie nach einem Treffer)
Aufwandsabschätzungen
I worst case: O(n + rm) mit r = Anzahl Treffer(im ungünstigsten Fall wie naiver Algorithmus)
I untere Schranke für große Alphabete und m� n:
Cn
n≥ 1
m+
m(m + 1)
2m2c+ O(c−2)
I bei ungleicher Auftretenswahrscheinlichkeit der Zeichen giltCn/n < 1 unter der Voraussetzung
c
(1−
c∑i=1
p2i
)> 1
Beispiele:I c = 3, pi = 1/3, → 1I c = 3, p1 = 1/2, p2 = 1/4, p3 = 1/4, → 15/8
Der Shift-Or-Algorithmus
Echtzeit-Algorithmus, ohne Zwischenspeicherung des Textes→ für hardwaremäßige Implementierung geeignet
basiert auf der Theorie der endlichen Automaten:Vektor von m verschiedene Zustandsvariablen,ite Variable gibt den Zustand des Vergleichs zwischen denPositionen 1, . . . , i des Patterns und den Positionen(j − i + 1), . . . , j des Textes an(j = aktuelle Textposition)
Zustandsvektor
ite binäre Zustandsvariable si :=0, falls letzte i Zeichen übereinstimmen=1, sonstRepräsentation des Zustandsvektors state als Binärzahl:
state =m−1∑i=0
si+1 · 2i
Match endend an der aktuellen Position, wenn sm = 0 (bzw.state < 2m−1)
Update des Zustandsvektors
beim Lesen eines neuen Zeichens aus dem Text:I Statusvektor um 1 nach links shiften und s1 = 0 setzenI Aktualisieren des Statusvektors entsprechend dem nächsten
eingelesenen Zeichen(mit Hilfe einer Tabelle T mit Einträgen für jedes Zeichen desAlphabets)neuer Statusvektor ergibt sich aus Oder-Verknüpfung vonaltem Vektor mit Tabelleneintrag
Formal:state = (state << 1) or T [currchar ]
(<< = Linksshift)
Beispiel für Tabelle T :Alphabet: {a, b, c , d} Pattern: ababcT[a]=11010 T[b]=10101 T[c]=01111 T[d]=11111
Definition der Tabelle T : Tx =m−1∑i=0
δ(pati+1 6= x) · 2i
mit δ(C ) = 1, falls die Bedingung C erfüllt ist (sonst 0)
Beispiel für die Suche nach ababc im Text abdabababc:Text : a b d a b a b a b cshift : 11110 11100 11010 11110 11100 11010 10100 01010 10100 01010T[x] : 11010 10101 11111 11010 10101 11010 10101 11010 10101 01111shift-or : 11111 11110 11101 11111 11110 11101 11010 10101 11010 10101 01111
Shift-Or-Algorithmus
1 pub l i c i n t s o s e a r c h ( char [ ] t e x t , i n t n , char [ ] pat , i n t m) {2 long [ ] T = new long [MAXSYM] ;3 i f (m > WORDLEN) return PATTERNTOOLONG;4 f i n a l long a l lWrong = getAl lWrongBitMap (m) ;5 i n i t T ( pat , m, T, a l lWrong ) ;6
7 f i n a l long h i t = ( a l lWrong + 1) / 2 ;8 long s t a t e = al lWrong ;9
10 f o r ( i n t i = 1 ; i <= n ; i++) {11 long s t a t eB e f o r e = s t a t e ;12 s t a t e = ( ( s t a t e << 1) | T[ t e x t [ i ] ] ) & a l lWrong ;13 showData ( t ex t , i , pat , m, T, s t a t eBe f o r e , s t a t e ) ;14 i f ( s t a t e < h i t )15 return ( i − m + 1 ) ;16 }17 return NOTFOUND;18 }
Komplexität: O(dmw en)(dabei ist dmw e der Aufwand zur Berechnung eines Shifts bzw. zurOder-Verknüpfung von Bitstrings der Länge m bei einer Wortlängevon w)
ExperimentelleErgebnisse fürenglischsprachigenText
Shift−Or
Knuth−Morris−Pratt
Naive
Boyer−Moore
Boyer−Moore−Horspool
10
15
20
25
30
35
40
45
50
55
60
65
70
75
80
85
90
95
100
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 202
(sec)
time
Length of Pattern (m)
Erweiterungen des Shift-Or-Algorithmus’
Zeichenklassen:x bestimmtes Zeichen. beliebiges Zeichen
[Z ]Zeichen aus der Menge ZC Komplementmenge der Klasse C
Beispiel:M[ae][ij ].[g − ot − z ] matcht Meier, Majer, Meise, aber nichtMaler oder Maien
Behandlung durch Änderung der Definition der Tabelle T :
Tx =m−1∑i=0
δ(pati+1 6∈ Classi+1) · 2i
→ Modifikation der Präprozessierung des PatternsAlgorithmus sonst unverändert!
Beispiel: T zum Pattern ab[ab]b[a − c]:
T [a] = 11000T [b] = 10011T [c] = 11101T [d ] = 01101
Zeichenkettensuche mit erlaubten Fehlern
Maximalzahl erlaubter Fehler vorgegeben→ ersetze Bits im Statusvektor durch Zähler für Anzahl der Fehler,Addition der Einträge aus T statt OR-Verknüpfung
Beispiel für die Suche nach ababc mit höchstens 2 Fehlern imString abdabababc:
text : a b d a b a b a b cT [x] : 11010 10101 11111 11010 10101 11010 10101 11010 10101 01111shift : 99990 99900 99010 91210 22200 23010 40200 03010 40200 03010shift-or : 99990 99901 99121 92220 32301 34020 50301 14020 50301 04121
* *
Alternative Patterns
Suche nach p1 ∨ . . . ∨ pla) mit eigenem Statusvektor für jedes Pattern
Sei mmax = maxi (|pi |).Aufwand: O(dmmax
w eln)
b) Verkettung aller StatusvektorenSei msum =
∑i |pi |.
Aufwand: O(dmsumw en)
Ähnlichkeit von Zeichenketten
(insbesondere für die Suche nach Eigennamen und zur Korrekturvon Tippfehlern,ersetzt nicht die linguistische Grundform- bzw.Stammformreduktion)
Phonetische Gleichheit
Wörter werden durch einen Phonetisierungsalgorithmus auf eineninternen Code abgebildet, phonetisch gleiche Wörter dabei auf dengleichen Code(z.B. SOUNDEX-Algorithmus bildet den gleichen Code für dieenglischsprachigen Wörter „Dixon“, „Diksen“ und „Dickson“)
aber:ähnlich geschriebene Wörter werden häufig auf unterschiedlicheCodes abgebildetz.B. „Rodgers“ und „Rogers“
Damerau-Levenshtein-Metrik
Ähnlichkeitsmaß für Zeichenketten, soll Zahl der Tippfehlerannähernvier mögliche Fehler: Einfügung, Löschung, Substitution,TranspositionDL-Metrik berechnet für zwei Zeichenketten die minimale AnzahlFehler, mit der diese ineinander überführt werden können
Zeichen Operation KostenM C Substitution 1O E Substitution 1N N = 0S – Einfügung 1T T = 0E R halbe Transpos. 1/2R E halbe Transpos. 1/2
Summe 4
DL-MetrikBerechnung des Minimums durch dynamische Programmierung
Berechne zu jedem Punkt das lokale Minimum durch Übergang vonder Nachbarzelle
I darüber (Löschung)I links (Einfügung) oderI links darüber (Substitution/Transposition)
C E N T R EM 1 2 3 4 5 6O 2 2 3 4 5 6N 3 3 2 3 4 5S 4 4 3 3 4 5T 5 5 4 3 4 5E 6 5 5 4 4 4R 7 6 6 5 4 4
Nachteile der DL-Metrik
I relativ aufwendig zu berechnenI Beschleunigung der best-match-Suche nur durch Clustering
möglich
Ähnlichkeitssuche über Trigrams
(Trigram = Zeichenfolge der Länge 3)einfaches, aber wirkungsvolles Ähnlichkeitsmaß
Wörter werden auf die Menge der enthaltenen Trigrams abgebildet‘MENGE’ → {‘_ME’, ‘MEN’, ‘ENG’, ‘NGE’, ‘GE_’}‘MENAGE’ → {‘_ME’, ‘MEN’, ‘ENA’, ‘NAG’,‘AGE’, ‘GE_’}
Ähnlichkeitssuche = Suche nach Wörtern, die in möglichst vielenTrigrams mit dem gegebenen Wort übereinstimmen
z.B. %(q, d) =|qT ∩ dT ||qT |
%(’MENGE’,’MENAGE’) = 3/6
Beschleunigung durch spezielle Zugriffspfade:invertierte Listen oder Signaturen
Invertierte ListenPrinzipieller Aufbau
aufsteigend sortierte Listen von Dokumentnummern, in denen einTerm vorkommt:t1 d2 d15 d23 d89 . . .
t2 d5 d15 d89 . . .
Speicherplatzbedarf:3 Bytes für d und 1 Byte für fd ,t → 4 Bytes/EintragBeispiel: 2 GB TREC-Kollektion → 733 MB inv. Liste
Anwendung für Boolesches Retrieval:
∨ — Vereinigen der Listen∧ — Schneiden der Listen∧¬ — Differenzbildung
t1 d2 d15 d23 d89 . . .
t2 d5 d15 d89 . . .
Ergebnisliste für t1 ∨ t2d2 d5 d15 d23 d89 . . .
Ergebnisliste für t1 ∧ t2d15 d89 . . .
Ergebnisliste für t1 ∧ ¬t2d2 d23 . . .
Erweiterung der Einträge für die Wortabstandssuche:Angaben über alle Vorkommen in einem Dokument werden mitabgelegt(z.B. Feldkennung, Satznummer, Wortnummer)
t1 d2, (T , 1, 2) | d15, (A, 3, 24), (A, 4, 25) | d23, (T , 1, 5) | d89, (A, 4, 99) | . . .t2 d5, (T , 1, 9) | d15, (A, 1, 4), (A, 2, 10), (A, 3, 23) | d89, (A, 1, 9) | . . .
führt aber zu hohem Speicherplatzbedarf(bis zu 100% der Primärdaten)
Ranking mit invertierten Listen
Aufgabenstellung:Bestimmung der k Dokumente mit dem höchsten RetrievalgewichtAnnahmen:
I Skalarprodukt als RetrievalfunktionI Einträge in der invertierten Liste enthalten zusätzlich das
Indexierungsgewicht des TermsZiel:Anzahl der Plattenzugriffe soll minimiert werden(daher Berechnung nur über die invertierten Listen)
Naiver Algorithmus
Prinzipielle Vorgehensweise:Mischen der invertierten Listen wie bei ODER-Verknüpfung,dabei zusätzlich Berechnung der Retrievalgewichtet1 d2, u12 d15, u115 d23, u123 d89, u189 . . .
t2 d5, u25 d15, u215 d89, u289 . . .
Ergebnis für w1 · t1 + w2 · t2:d2: w1 · u12 , d5: w2 · u25 , d15: w1 · u115 + w2 · u215 ,d23: w1 · u123 , d89: w1 · u189 + w2 · u289
Algorithmus für Skalarprodukt
1. Für jedes Dokument der Kollektion: Setze Akkumulator Ad auf0
2. Für jeden Term der Anfrage:2.1 Hole It , die invertierte Liste für t.2.2 Für jedes Paar 〈 Dokumentnummer d , Indexierungsgewicht
ud,t 〉 in It setze Ad ← Ad + wq,t · ud,t .
3. Bestimme die k höchsten Werte Ad
4. Für jedes dieser k Dokumente d :I a) Hole die Adresse von Dokument d .I b) Hole Dokument d and präsentiere es dem Benutzer.
Komprimierung invertierter Listen
Idee: LauflängencodierungBeispiel:
5, 8, 12, 13, 15, 18, 23, 28, 29, 40, 60
Lauflängen:
5, 3, 4, 1, 2, 3, 5, 5, 1, 11, 20
Codes für Lauflängen
Codierung einer natürlichen Zahl x :γ-Code:
1. blog2 xc+ 1 im 1er-Code(d.h. blog2 xc 1-Bits gefolgt von einem 0-Bit)
2. x − 2blog2 xc im Binärcode
δ-Code:
1. γ-Codierung von blog2 xc+ 12. x − 2blog2 xc im Binärcode
Beispiel:
CodierungsmethodeGolomb,
x γ δ b = 31 0, 0, 0,02 10,0 100,0 0,103 10,1 100,1 0,114 110,00 101,00 10,05 110,01 101,01 10,106 110,10 101,10 10,117 110,11 101,11 110,08 1110,000 11000,000 110,10
I δ-Code benötigtblog2 xc+O(log log x)Bits
I für x < 15 γ-Codemeist besser, danachδ-Code nie schlechter
I γ- und δ-Code sindPräfix-frei(keine zusätzlichenBits, keinBacktracking beiDecodierung)
Generelles Codierungsschema
N Anzahl Dokumente der KollektionV = (v1, v2, v3, . . .) Vektor natürlicher Zahlen mit vj ≤ N
Codierung von Lauflänge x ≥ 1:
1. finde k ≥ 1 mitk−1∑j=1
vj < x ≤k∑
j=1
vj
2. codiere k in geeigneter Repräsentation
3. berechne Rest r = x −k−1∑j=1
vj − 1
4. Codiere r binär:I mit blog2 vkc Bits für r < 2dlog2 vke − vk ,I mit dlog2 vke Bits sonst.
(γ-Code entspricht Codierung mit V = (1, 2, 4, 8, 16, . . .))
Golomb-Code
benutzt Vektor VG = (b, b, b, . . .),k im 1er Code
Codierung ist optimal für b =⌈
log(2−p)−log(1−p)
⌉Annahme: geometrische Verteilung mit p=Wahrscheinlichkeit fürdas Auftreten eines Terms in einem Dokument→ Wahrscheinlichkeit für Lücke der Länge x : (1− p)x−1p
Effektive Komprimierung:I Golomb-Code für LauflängenI γ-Code für Vorkommenshäufigkeiten fd ,t
Boolesches RetrievalAlgorithmus für konjunktive Anfragen
1. For each query term t,1.1 Search the vocabulary for t.1.2 Record ft and the address of It , the inverted list for t.
2. Identify the query term t with the smallest ft .3. Read the corresponding inverted list. Use it to initialize C , the
list of candidates.4. For each remaining term t, in increasing order of ft ,
4.1 Read the inverted list, It .4.2 For each d ∈ C , if d 6∈ It , then set C ← C − {d}.4.3 If |C | = 0, return, since there are no answers.
5. For each d ∈ C ,5.1 Look up the address of document d .5.2 Retrieve document d and present it to the user.
Berechnungsaufwand zur Dekodierung
Prozessierung konjunktiver Anfragen:k Anzahl Dokumente im Zwischenergebnisp Häufigkeit des nächsten zu berücksichtigenden Terms (Anzahl
Einträge in der invertierten Liste)td Rechenzeit zur Decodierung eines EintragsTd Rechenzeit zur Decodierung der invertierten Liste:
Td = tdp
Verbesserung: Zweistufige Struktur invertierter Listen
invertierte Liste:〈5, 1〉〈8, 1〉〈12, 2〉〈13, 3〉〈15, 1〉〈18, 1〉〈23, 2〉〈28, 1〉〈29, 1〉....
Lauflängencodierung:〈5, 1〉〈3, 1〉〈4, 2〉〈1, 3〉〈2, 1〉〈3, 1〉〈5, 2〉〈5, 1〉〈1, 1〉....
Sprünge über je 3 Dokumente:〈〈5, a2〉〉〈5, 1〉〈3, 1〉〈4, 2〉〈〈13, a3〉〉〈1, 3〉〈2, 1〉〈3, 1〉〈〈23, a4〉〉〈5, 2〉〈5, 1〉〈1, 1〉〈〈40, a5〉〉....
Codierung der Adressen als Differenzen, Weglassen der Nummerdes ersten Dokumentes jeder Gruppe:〈〈5, a2〉〉〈1〉〈3, 1〉〈4, 2〉〈〈8, a3 − a2〉〉〈3〉〈2, 1〉〈3, 1〉〈〈10, a4 − a3〉〉〈2〉〈5, 1〉〈1, 1〉〈〈17, a5 − a4〉〉....
Aufwandsabschätzung
k Anzahl Dokumente im Zwischenergebnisp Häufigkeit des nächsten zu berücksichtigenden Terms (Anzahl
Einträge in der invertierten Liste)L Anzahl Einträge pro Gruppep1 Anzahl Sprungeinträge in der Liste: p1 = dp/Letd Rechenzeit zur Decodierung eines Eintrags der inv. ListeTd Rechenzeit zur Decodierung der invertierten Liste:
Annahmen:1. Anzahl zu decodierender Gruppen: k/22. Aufwand zur Decodierung eines Sprung-Eintrags: 2td
Gesamtaufwand zur Decodierung:
Td = p1 · 2td +k2Ltd = td
(p1 · 2 +
k2pLp
)= td
(2p1 +
kp2p1
)wird minimal für
p1 =
√kp2
Beispiel:k = 60, p = 60000, L = 63, td = 2.5µsohne Sprungliste: 0.150 smit Sprungliste: 0.009 s
Berücksichtigung der zusätzlichen Einlesezeit
(für L = 63 wächst invertierte Liste um ca. 3 %)
tr Zeit zum Einlesen eines Eintrages der invertierten ListeT Verweilzeit zum Einlesen und Decodieren einer Liste:
T = td
(2p1 +
kp2p1
)+ tr (p + 2p1)
wird minimal für p1 =
√kp/(1 + tr/td )
2Beispiel:k = 60, p = 60000, L = 63, td = 2.5µs, tr = 0.5µsohne Sprungliste: 0.180 s, mit Sprungliste: 0.040 sunkomprimierte Liste: 0.120 s
Speicherplatzbedarf:komprimierte invertierte Liste: 10% des Textesmit Sprungliste: 11-12% des Textes
Boolesches Retrieval mit Sprunglisten
Beobachtungen
I Verarbeitungszeit sinkt zunächst mit steigender Termzahl(warum?),steigt dann erst erwartungsgemäß an
I Sprunglisten beschleunigen die VerarbeitungI Gewinne erst ab drei TermenI optimale Sprunglänge hängt von der Anzahl Frageterme abI L=1: nur Decodierung der Dokumentnummer (warum?)
Ranking mit invertierten ListenNaiver Algorithmus
(Algorithmus für Cosinusmaß)1. For each document d in the collection, set accumulator Ad to
zero.2. For each term t in the query,
2.1 Retrieve It , the inverted list for t.2.2 For each 〈document number d , word frequency fd,t 〉 pointer
in It set A← Ad + wq,t · fd,t .3. For each document d , calculate Cd ← Ad/Wd , where Wd is
the length of document d , and Cd is the final value ofcosine(d , q).
4. Identify the r highest values of Cd , where r is the number ofrecords to be presented to the user.
5. For each document d so selected,5.1 Look up the address of document d .5.2 Retrieve document d and present it to the user.
Ranking mit Sprunglisten
a) Quit-AlgorithmusIdee: Häufige Terme (mit niedrigem idf-Gewicht) ignorierenK : Maximalzahl zu berücksichtigende Dokumente
1. Order the words in the query from highest to lowest.2. Set A← ∅; A is the current set of accumulators.3. For each term t in the query,
3.1 Retrieve It , the inverted list for t.3.2 For each 〈d , fd,t〉 pointer in It ,
3.2.1 If Ad ∈ A, calculate Ad ← Ad + wq,t · fd,t .3.2.2 Otherwise, set A← A + {Ad}, calculate Ad ← wq,t · fd,t .
3.3 If |A| > K , go to step 4
4. For each document d such that Ad ∈ A, calculateCd ← Ad/Wd .
5. Identify the r highest values of Cd .
b) Continue-Algorithmus
Idee: Häufige Terme nur zur Retrievalwertberechnungberücksichtigen, aber nicht zur Dokumentselektion
1. Order the words in the query from highest to lowest.2. Set A← ∅.3. For each term t in the query,
3.1 Retrieve It .3.2 For each 〈d , fd,t〉 pointer in It ,
3.2.1 If Ad ∈ A, calculate Ad ← A + wq,t · fd,t .3.2.2 Otherwise, set A← A + {Ad}, calculate Ad ← wq,t · fd,t .
3.3 If |A| > K , go to step 44. For each remaining term t in the query,
4.1 Retrieve It .4.2 For each d such that Ad ∈ A,
if 〈d , fd,t〉 ∈ Id , calculate Ad ← Ad + wq,t · wq,t .
5. For each document d such that Ad ∈ A, calculateCd ← Ad/Wd .
6. Identify the r highest values of Cd .
Retrievalqualität
Beobachtungen
I (Zahlen an oberer Kurve: # voll berücksichtigter Frageterme)I Bei quit steigt die Qualität kontinuierlich mit der Anzahl
AkkumulatorenI Bei continue ist die Qualität durchweg besser als bei quitI Bei continue ist die Qualität schon mit wenigen
Akkumulatoren sehr gutI Teilweise liefert continue mit weniger Termen bessere
Ergebnisse als bei vollständiger Berechnung
Effizienz
Beobachtungen
I Continue ist bis zu einer gewissen Anzahl Akkumulatorenschneller als die volle Berechnung, danach langsamer (warum?)
I Ohne Sprunglisten ist Continue kaum schnellerI Bei wenigen Akkumulatoren (<= 3000) sind kürzere
Sprunglisten (L=1000) am bestenI Bei mehr Akkumulatoren hat die Länge der Sprungliste kaum
Einfluss
Google-Ranking
I nur konjunktive Anfragen (aber mit Ranking)I Partitionierung der invertierten Listen nach DokumentenI Anfrage wird jeweils durch ein Cluster von Rechnern bearbeitetI invertierte Listen werden komplett im Hauptspeicher gehaltenI zusätzliche Beschleunigung durch Caching von
Anfrageergebnissen
Dokumentweise Partitionierung invertierter Listen
C1: Dok. 1-100t1 1 20 65 95t3 3t5 20 35
C2: Dok. 101-200t2 101 120 195t3 103t4 120 135t5 111 135 199
C3: Dok. 201-300t1 201 222 295t2 203t5 222 235 295
Anfrage: t1, t5C1: 20C3: 222, 295
PAT-TreesGrundkonzepte
I Dokumentkollektion als ein StringDoc1() Doc2() Doc3( Ch1() Ch2() )Doc4( Tit() Abstr()
Sec1( Subs1() Subs2() ) Sec2() ) Doc5()I Berücksichtigung der Dokumentstruktur bei der Suche möglich
Suche Section, in der “PAT” vorkommtI Position = sistring (semi-infinite string)
Definitionen
I sistring = String ab Position bis Ende des Gesamtstrings,ID=PositionString: THIS IS A SAMPLE STRINGsistrings:01 - THIS IS A SAMPLE STRING02 - HIS IS A SAMPLE STRING03 - IS IS A SAMPLE STRING04 - S IS A SAMPLE STRING05 - IS A SAMPLE STRING06 - IS A SAMPLE STRING07 - S A SAMPLE STRING08 - A SAMPLE STRING...
I lexikographische Ordnung auf den sistrings“A SA...” < “AMP...” < “E ST...”
PAT-Tree = Patricia-Tree aller sistrings eines Textes
PAT-Tree = Patricia-Tree aller sistrings eines TextesPatricia-Tree:
I Binärer DigitalbaumI n Blattknoten mit Schlüsselwerten (IDs)I n − 1 interne Knoten
(Wert = absolute / relative Position im sistring)01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
Algorithmen auf PAT-Trees
Präfix-Suche01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
Prefix = 100
Suche nach 100* liefert Teilbaum mit 3 und 6(Suche muß übersprungene Bits kontrollieren)
Reihenfolge
01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
"01",*,"00"
1. Suche der einzelnen Wörter(liefert Teilbäume)
2. Bildung aller korrekten Kombinationen von externen Knoten
Bereichssuche
01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
"0010 ... 1001"
Längste Wiederholung
01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
Suche nach internem Knoten mit dem größten Abstand zur Wurzel
Häufigkeitssuche
01100100010111 −− Text12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
11
1
Suche nach internem Knoten mit den meisten Knoten imzugehörigen Teilbaumhäufigstes Bigram = 00kommt 3mal vor
Reguläre Ausdrücke
01100100010111 −− Text
12345678901234 −− Position
2
7
3
5
4 8
0 1
0
3
5 1
100 10
0
2
36
0 1
100
4
2
1
0 1
0,1
1
1
Regexp 0 [01]*1 {1,8}
PAT Arrays
I Sortierte sistrings → Array mit IDsI Präfix- und Bereichssuchen als (indirekte) binäre SucheI Andere Operationen aufwändiger
0 1 1 0 0 1 0 0 0 1 0 1 1 1 ...
PAT array
Text
7 4 8 5 1 6 3 2
Signaturen (Bloom-Filter)Das Signaturkonzept
GrundideeAbbildung von Wörtern und Texten auf Bitstrings fester Länge(=Signaturen)Suchoperationen auf Signaturen effizienter als auf den Texten,weitere Beschleunigung durch spezielle Speicherungsformen für dieSignaturen möglich
Signatur:
S :=< b1, b2, . . . , bL > mit bi ∈ {0, 1}, L ∈ N
Erzeugung von Signaturen durch surjektive Abbildung von Wörternauf Bitstrings (i.a. durch Hashing)Homonyme: gleiche Signaturen für verschiedene Wörter
Arten von Signaturen:
a) Binärsignaturen:Abbildung von Wörtern auf alle 2L möglichen SignaturenSignaturoperator =Sprüft die Gleichheit von Anfrage- und Satzsignatur
b) überlagerungsfähige Signaturen:Wert einer Signatur wird nur durch die gesetzten Bits bestimmtg = Signaturgewicht = # gesetzter Bits(für alle Wörter gleich)→ Abbildung von Wörtern auf
(Lg
)verschiedene Signaturen
Überlagerung :
durch ODER-Verknüpfung der Signaturen
text 010010001000 S1search 010000100100 S2methods 100100000001 S3
110110101101 S1 ∨ S2 ∨ S3
Vor- und Nachteile überlagerungsfähiger Signaturen:– Entstehung von Phantomen (gesetzte Bits sind nicht mehr
eindeutig den Ausgangssignaturen zuzuordnen)+ Bildung von Indexstrukturen möglich+ Block Superimposed Coding zur Abbildung einer Menge von
Wörtern auf eine einzige Signatur
Signaturoperator ⊇Sprüft das Enthaltensein der Anfragesignatur in einer Satzsignatur:
S ⊇S SQ ⇔ (∀)((1 ≤ i ≤ L) ∧ ((bQi = 1)⇒ (bi = 1))),
S , SQ ∈ SL.
Zurückführung auf effiziente Bitoperationen:
S ⊇S SQ ⇔ S ∧ SQ = SQ ⇔ (¬S) ∧ SQ = 0S
text search methods 110110101101in search of knowledge-based IR 010110101110an optical system for full text search 010110101100the lexicon and IR 101001001001
Anfrage:text search 010010101100
false drops:
fehlerhafte Antworten (entstehen durch Homonyme und Phantome)
Im Folgenden nur überlagerungsfähiger Signaturen
Prinzipielle Organisation eines Signatur-Systems
Q
Q Q
Q
Zugriffs−
manager
Masken−
generator
Adress−
Auswahl−
Komponente
Vergleichs−
komponente
Signatur−
Datei
Daten−
Datei
R A
Q
S
D
S
R
CodierungsmethodenDisjoint Coding
(auch word coding genannt, wenn auf Wörter angewendet)Jedes Wort wird einzeln auf eine Signatur abgebildet, die in dieserForm gespeichert wird (abgesehen von einer möglichenanschließenden Komprimierung, hier nicht betrachtet)
Notationen:L Länge der Signaturg Signaturgewicht (Anzahl gesetzter 1-Bits)
SP = SP(L, g): Signaturpotential= # verschiedener erzeugbarer Kodierungen
Maximierung des Signaturpotentials
für vorgegebene Signaturlänge L:
SP =
(Lg
)=
L!
g !(L− g)!maximal für g = L
2
Beweisskizze:Da(Lg
)=( LL−g), nur Betrachtung von g ≤ bL2c notwendig.
Annahme, dass SP1 = SP(L, bL2c) und
SP2 = SP(L, bL2c − 1) = SP1 ·g
L− (g − 1).
Wegen g ≤ L2 folgt SP2 ≤ SP1 ·
( ⌊L2
⌋⌊L2
⌋+ 1
)< SP1
Anschließend Induktionsbeweis über g und über L
Fehlerrate
F Fehlerrate = # zu erwartende Fehler(fälschlicherweise gefundene Signaturen)
W Wörterbuchgröße(# Types= #verschiedener Wörter)
N # Satzsignaturen
Abbildung der Wörter auf Signaturen:W verschiedene Wörter auf SP =
( Lb L2 c)verschiedene Signaturen
→ einer Signatur sind im Mittel WSP Types zugeordnet
Retrieval für ein bestimmtes Wort liefert WSP − 1 Signaturen zu
anderen Wörtern→ Erwartete Fehlerrate:
F =
(WSP− 1)
NW
(1)
Festlegung der Signaturlänge für eine bestimmte Anwendung
Signaturpotential als Funktion der Fehlerrate, der Wörterbuchgrößeund des Datenvolumens:
SP =W · N
F ·W + N
daraus Berechnung der Signaturlänge möglich
L g SP8 4 70
16 8 12 87024 12 2 704 15632 16 601 080 390
Blockweise Codierung von WörternAbbildung der Menge der Wörter, die in einem Textblock auftreten,auf eine Folge von SignaturenB Anzahl der Blöckew Anzahl (verschiedener) Wörter pro Block
Fehlerrate bei blockweiser Codierungbei zufälliger Verteilung von x Token eines Wortes über B Blöcke:
I W., dass ein Token nicht in einem bestimmten Block auftritt:1− 1
BI W., dass keines von x Token in einem bestimmten Block
auftritt: 1− (1− 1B )x
I Erwartungswert für die Anzahl Blöcke, in denen das Wortauftritt:
B(1−
(1− 1
B
)x)
Im Mittel B·wSP Token pro Signatur
mit x = B·wSP folgt für erfolglose Anfragen
F ≈ B
(1−
(1− 1
B
)B·wSP)
≈ B(1− exp
(− wSP
))≈ B · w
SP
Fehlerwahrscheinlichkeit:
f ≈ 1− exp(− w
SP
)≈ w
SP
Block Superimposed CodingÜberlagerung mehrerer Signaturen (durch ODER-Verknüpfung)erlaubt Abbildung einer Menge von Wörtern(z.B. eines Textblocks) auf eine einzige Signatur
L Länge der Signaturg Gewicht (= Anzahl gesetzter Bits) für ein einzelnes Wortλ Anzahl überlagerte Wortsignaturent Anzahl gesetzter Bits in der überlagerten Signatur
Wahrscheinlichkeit, dass durch Überlagerung von λ Wortsignaturender Länge L mit Gewicht g eine Signatur entsteht, die an tbestimmten Stellen eine 1 enthält:
p(L, g , λ, t) =t∑
j=1
(−1)j(tj
)((L−jg
)(Lg
) )λ
Für kleine t, λ: p(L, g , λ, t) ≈ [p(L, g , λ, 1)]t = (1− (1− gL
)λ)t
Abschätzung der Fehlerwahrscheinlichkeit
F Anzahl FehlerN Anzahl Datensätze
f (t) Fehlerwahrscheinlichkeit, f (t) = F/N
Annahme dass sich kein Treffer unter den Datensätzen befindet→ f (t) = p(L, g , λ, t)
SpeicherungsstrukturenSequentielle Signaturen
b∗1 b∗
2 b∗3 b∗
4 b∗5 b∗
6 b∗7 b∗
8 @RS1 0 0 1 0 1 0 1 1 @r1S2 1 0 1 1 1 0 0 0 @r2S3 0 1 1 0 0 1 1 0 @r3S4 1 0 0 1 0 1 1 1 @r4S5 1 1 1 0 0 1 0 0 @r5S6 0 1 1 0 0 1 0 1 @r6S7 1 0 0 0 1 0 1 0 @r7S8 0 0 0 1 1 1 0 1 @r8
Sequentielle Speicherung der Signaturen zusammen mit denAdressen der Datensätze
L Länge der Signatur (in Bits)size@ Länge einer Adressesizep Seitengrößesizer Größe eines Datensatzes
N Anzahl Datensätze
M Anzahl Datenseiten =
N⌊sizepsizer
⌋
Platzbedarf für eine Signatur mit Adresse:⌈L
8
⌉+ size@
Anzahl Einträge pro Seite: K =
⌊sizeP⌈L
8
⌉+ size@
⌋Speicherplatzbedarf (in Seiten)
SeqS =
⌈NK
⌉+ M
Anzahl Seitenzugriffe für Datenbank-Operationen
F Anzahl false dropsD Anzahl echter Treffer
Retrieve:
SeqR =
⌈NK
⌉+ F + D
Insert: Bei Freispeicherverwaltung in Listenform je ein Lese-und Schreibzugriff für Signatur- und Datenseite
SeqI = 2 + 2 = 4
Delete: Annahme: Adresse des Datensatzes bekannt →sequentielle Suche in den Signaturseiten
SeqD =
⌈N
2 · K
⌉+ 1 + 2 =
⌈N
2 · K
⌉+ 3
Bitscheibenorganisation
b∗1 b∗
2 b∗3 b∗
4 b∗5 b∗
6 b∗7 b∗
8 @RS1 0 0 1 0 1 0 1 1 @r1S2 1 0 1 1 1 0 0 0 @r2S3 0 1 1 0 0 1 1 0 @r3S4 1 0 0 1 0 1 1 1 @r4S5 1 1 1 0 0 1 0 0 @r5S6 0 1 1 0 0 1 0 1 @r6S7 1 0 0 0 1 0 1 0 @r7S8 0 0 0 1 1 1 0 1 @r8
Speicherung jeder Bitscheibe allein auf einer Seite,Vektor mit Datensatzadressen getrennt
Anfrage: S i ⊇S < 10100000 >
b∗r = b∗1 ∧ b∗3 =
01011010
∧
11101100
=
01001000
Ergebnisbitliste: b∗r =
qγ(SQ)∧j=q1
bj , qi ∈ {q|(1 ≤ q ≤ L) ∧ bQq = 1}
Adresse der Trefferkandidaten: R = {i |bir = 1}
Disjunktive Anfragen
S(Q1) ∨ S(Q2) ∨ . . . S(Qd ):
Im Prinzip getrennte Prozessierung,nur Einsparung bei übereinstimmenden 1-Bits in den S(Qi ) möglich
Anzahl Seitenzugriffe für Datenbank-Operationen
Speicherbedarf für eine Bitscheibe: d N8·sizep e
Retrieve:γ(Q): AnfragegewichtZugriffe auf die angesprochenen Bitscheiben +Zuordnungstabelle und Datenseiten für alle Treffer
BSR =
(γ(Q)
⌈N
8 · sizep
⌉+ Z + F + D
)Z : Anzahl Seitenzugriffe auf die ZuordnungstabelleR : # Seiten der Zuordnungstabelle
R =
N⌊sizepsize@
⌋ Z = R ·
(1−
(1− 1
R
)(F+D))
→ ineffizient bei hohen Anfragegewichten
Insert:γ(S): Signaturgewicht des DatensatzesBitscheibenblöcke vorher mit 0 initialisiert →Zu ändern:γ(S) Bitscheibenseiten + Zuordnungstabelle + Datenseite
BS I = 2 · γ(S) + 2 + 2.
Delete:Suche des Eintrages (mit bekannter Satzadresse) über die SignaturZu ändern:1er-Bitscheibenseiten + Zuordnungstabelle + Datenseite
BSD = γ ·(⌈
N8 · sizep
⌉+ 1)
+ Z + 2
Speicherplatzbedarf (in Seiten):
BSS = L ·⌈
N8 · sizep
⌉+
⌈N · size@
sizep
⌉+ M.
Zweistufiges Signaturverfahren
Kombination von Bitscheiben- und sequentieller OrganisationZwei Signaturen für jeden Datensatz:(mit unabhängigen Signaturfunktionen berechnet)1. Signatur wie bei sequentieller Organisation als Bitstring in
Seiten gespeichert.Signatur-Seiten werden in Segmente unterteilt
2. Signaturen werden segmentweise überlagert, bildenSegmentsignatur.Segmentsignaturen werden in Bitscheibenorganisationverwaltet
Anfrageprozessierung:1. Berechnung der beiden Anfragesignaturen2. Bestimmung der zu durchsuchenden Segmente über die
Segmentsignatur3. Sequentielles Durchsuchen der Segmente mit der 1. Signatur
Quick Filter
Kombination von Signaturen mit HashingI Signaturen sind in Seiten organisiertI Zuordnung der Signaturen zu den Seiten über Hashing
Lineares Hashinglineare Hash-Funktion g bildet Schlüssel auf den Adressraum(0, 1, . . . , n − 1) ab, wobei 2h−1 < n ≤ 2h für ein h ∈ NIh: # Anzahl Stufen der Signaturdateig muß Split-Funktion sein, die für jeden Schlüssel K die Bedingungerfüllt:
g(K , h, n) =
{g(K , h − 1, n) oderg(K , h − 1, n) + 2h
n Primärseitenjede Primärseite hat 0 oder mehr Überlaufseiten (mit derPrimärseite verkettet)
Einfügen eines neuen Schlüssels:
1. Berechnung der Seitennummer p = g(K , h, n).2. Wenn möglich, Einfügen des Schlüssels in die Seite p.3. Sonst Abspeichern in einer Überlaufseite zu p.4. Bei Überlauf wird der Adreßraum von n auf n + 1 vergrößert
Vergrößerung des Adreßraums:SP : Zeiger auf die nächste zu splittende Seite1. Anlegen einer neuen Primärseite n2. Verteilung des Inhalts der Seite SP und der zugehörigen
Überlaufseiten durch neue Hashfunktion auf die Seiten SP undn.
3. n := n + 14. h wird erhöht, wenn die Seite 0 gesplittet werden soll.5. SP := (SP + 1) mod 2h−1
Hash-Funktion für Signaturen
N Signaturen Si =< b1, . . . , bL >
g(Si , h, n) =
{ ∑h−1r=0 bL−r2
r , falls∑h−1
r=0 bL−r2r < n∑h−2
r=0 bL−r2r , sonst
(2)
Quick Filter: Beispiel
S1: 00011110 S2: 11010001 S3: 00111100S4: 11000011 S5: 00110110 S6: 11001001
Zu Beginn sei h = 0, n = 1 und g(Si , 0, 1) = 0
Step 0. P0: empty SP = 0, h = 0, n = 1Step 1. P0: S1 SP = 0, h = 0, n = 1Step 2. P0: S1 S2 SP = 0, h = 0, n = 1Step 3. P0: S1 S3 P1: S2 SP = 0, h = 1, n = 2Step 4. P0: S1 S3 P1: S2 S4 SP = 0, h = 1, n = 2Step 5. P0: S3 P1: S2 S4 P2: S1 S5 SP = 1, h = 2, n = 3Step 6. P0: S3 P1: S2 S6 P2: S1 S5 P3: S4 SP = 0, h = 2, n = 4
P0: 00111100 P1: 11010001 11001001P2: 00011110 00110110 P3: 11000011
Retrieval
Bestimmung der möglichen Signaturseiten aus der Anfragesignatur:Anzahl zu lesender Seiten hängt vom Gewicht der AnfragesignaturQ ab, genauer:enthält Q j Einsen im h-Bit-Suffix h(Q), dann müssen höchstens2h−j Primärseiten und die zugehörigen Überlaufseiten gelesenwerdenAlgorithmus:1. P := g(Q, h, n)
2. if h(Q) ∩ P = h(Q) then {Signaturseite P lesen}3. P := P + 14. if P < n then goto 25. end
Beispiele: Q=xxxxxx11 → P3 lesenQ=xxxxxx01 → P1, P3 lesen
Vergleich der Speicherungsstrukturen
ProfilStruktur Retrieve Insert Delete Speichersequentiell selten dominant! selten dominantBitscheiben dominant wenig wenig wenigzweistufig dominant wenig wenig irrelevantQuick Filter wenig viel viel wenig