- •List of Tables
- •List of Figures
- •Table of Notation
- •Preface
- •Boolean retrieval
- •An example information retrieval problem
- •Processing Boolean queries
- •The extended Boolean model versus ranked retrieval
- •References and further reading
- •The term vocabulary and postings lists
- •Document delineation and character sequence decoding
- •Obtaining the character sequence in a document
- •Choosing a document unit
- •Determining the vocabulary of terms
- •Tokenization
- •Dropping common terms: stop words
- •Normalization (equivalence classing of terms)
- •Stemming and lemmatization
- •Faster postings list intersection via skip pointers
- •Positional postings and phrase queries
- •Biword indexes
- •Positional indexes
- •Combination schemes
- •References and further reading
- •Dictionaries and tolerant retrieval
- •Search structures for dictionaries
- •Wildcard queries
- •General wildcard queries
- •Spelling correction
- •Implementing spelling correction
- •Forms of spelling correction
- •Edit distance
- •Context sensitive spelling correction
- •Phonetic correction
- •References and further reading
- •Index construction
- •Hardware basics
- •Blocked sort-based indexing
- •Single-pass in-memory indexing
- •Distributed indexing
- •Dynamic indexing
- •Other types of indexes
- •References and further reading
- •Index compression
- •Statistical properties of terms in information retrieval
- •Dictionary compression
- •Dictionary as a string
- •Blocked storage
- •Variable byte codes
- •References and further reading
- •Scoring, term weighting and the vector space model
- •Parametric and zone indexes
- •Weighted zone scoring
- •Learning weights
- •The optimal weight g
- •Term frequency and weighting
- •Inverse document frequency
- •The vector space model for scoring
- •Dot products
- •Queries as vectors
- •Computing vector scores
- •Sublinear tf scaling
- •Maximum tf normalization
- •Document and query weighting schemes
- •Pivoted normalized document length
- •References and further reading
- •Computing scores in a complete search system
- •Index elimination
- •Champion lists
- •Static quality scores and ordering
- •Impact ordering
- •Cluster pruning
- •Components of an information retrieval system
- •Tiered indexes
- •Designing parsing and scoring functions
- •Putting it all together
- •Vector space scoring and query operator interaction
- •References and further reading
- •Evaluation in information retrieval
- •Information retrieval system evaluation
- •Standard test collections
- •Evaluation of unranked retrieval sets
- •Evaluation of ranked retrieval results
- •Assessing relevance
- •A broader perspective: System quality and user utility
- •System issues
- •User utility
- •Results snippets
- •References and further reading
- •Relevance feedback and query expansion
- •Relevance feedback and pseudo relevance feedback
- •The Rocchio algorithm for relevance feedback
- •Probabilistic relevance feedback
- •When does relevance feedback work?
- •Relevance feedback on the web
- •Evaluation of relevance feedback strategies
- •Pseudo relevance feedback
- •Indirect relevance feedback
- •Summary
- •Global methods for query reformulation
- •Vocabulary tools for query reformulation
- •Query expansion
- •Automatic thesaurus generation
- •References and further reading
- •XML retrieval
- •Basic XML concepts
- •Challenges in XML retrieval
- •A vector space model for XML retrieval
- •Evaluation of XML retrieval
- •References and further reading
- •Exercises
- •Probabilistic information retrieval
- •Review of basic probability theory
- •The Probability Ranking Principle
- •The 1/0 loss case
- •The PRP with retrieval costs
- •The Binary Independence Model
- •Deriving a ranking function for query terms
- •Probability estimates in theory
- •Probability estimates in practice
- •Probabilistic approaches to relevance feedback
- •An appraisal and some extensions
- •An appraisal of probabilistic models
- •Bayesian network approaches to IR
- •References and further reading
- •Language models for information retrieval
- •Language models
- •Finite automata and language models
- •Types of language models
- •Multinomial distributions over words
- •The query likelihood model
- •Using query likelihood language models in IR
- •Estimating the query generation probability
- •Language modeling versus other approaches in IR
- •Extended language modeling approaches
- •References and further reading
- •Relation to multinomial unigram language model
- •The Bernoulli model
- •Properties of Naive Bayes
- •A variant of the multinomial model
- •Feature selection
- •Mutual information
- •Comparison of feature selection methods
- •References and further reading
- •Document representations and measures of relatedness in vector spaces
- •k nearest neighbor
- •Time complexity and optimality of kNN
- •The bias-variance tradeoff
- •References and further reading
- •Exercises
- •Support vector machines and machine learning on documents
- •Support vector machines: The linearly separable case
- •Extensions to the SVM model
- •Multiclass SVMs
- •Nonlinear SVMs
- •Experimental results
- •Machine learning methods in ad hoc information retrieval
- •Result ranking by machine learning
- •References and further reading
- •Flat clustering
- •Clustering in information retrieval
- •Problem statement
- •Evaluation of clustering
- •Cluster cardinality in K-means
- •Model-based clustering
- •References and further reading
- •Exercises
- •Hierarchical clustering
- •Hierarchical agglomerative clustering
- •Time complexity of HAC
- •Group-average agglomerative clustering
- •Centroid clustering
- •Optimality of HAC
- •Divisive clustering
- •Cluster labeling
- •Implementation notes
- •References and further reading
- •Exercises
- •Matrix decompositions and latent semantic indexing
- •Linear algebra review
- •Matrix decompositions
- •Term-document matrices and singular value decompositions
- •Low-rank approximations
- •Latent semantic indexing
- •References and further reading
- •Web search basics
- •Background and history
- •Web characteristics
- •The web graph
- •Spam
- •Advertising as the economic model
- •The search user experience
- •User query needs
- •Index size and estimation
- •Near-duplicates and shingling
- •References and further reading
- •Web crawling and indexes
- •Overview
- •Crawling
- •Crawler architecture
- •DNS resolution
- •The URL frontier
- •Distributing indexes
- •Connectivity servers
- •References and further reading
- •Link analysis
- •The Web as a graph
- •Anchor text and the web graph
- •PageRank
- •Markov chains
- •The PageRank computation
- •Hubs and Authorities
- •Choosing the subset of the Web
- •References and further reading
- •Bibliography
- •Author Index
10 |
|
|
1 Boolean retrieval |
Brutus |
−→ |
1 |
→ 2 → 4 → 11 → 31 → 45 → 173 → 174 |
Calpurnia |
−→ |
2 |
→ 31 → 54 → 101 |
Intersection |
= |
2 |
→ 31 |
Figure 1.5 Intersecting the postings lists for Brutus and Calpurnia from Figure 1.3.
b. Draw the inverted index representation for this collection, as in Figure 1.3 (page 7).
Exercise 1.3 |
[ ] |
For the document collection shown in Exercise 1.2, what are the returned results for these queries:
a.schizophrenia AND drug
b.for AND NOT(drug OR approach)
1.3Processing Boolean queries
How do we process a query using an inverted index and the basic Boolean SIMPLE CONJUNCTIVE retrieval model? Consider processing the simple conjunctive query:
QUERIES
(1.1) Brutus AND Calpurnia
over the inverted index partially shown in Figure 1.3 (page 7). We:
1.Locate Brutus in the Dictionary
2.Retrieve its postings
3.Locate Calpurnia in the Dictionary
4.Retrieve its postings
5.Intersect the two postings lists, as shown in Figure 1.5.
POSTINGS LIST The intersection operation is the crucial one: we need to efficiently intersect INTERSECTION postings lists so as to be able to quickly find documents that contain both POSTINGS MERGE terms. (This operation is sometimes referred to as merging postings lists: this slightly counterintuitive name reflects using the term merge algorithm for a general family of algorithms that combine multiple sorted lists by interleaved advancing of pointers through each; here we are merging the lists
with a logical AND operation.)
There is a simple and effective method of intersecting postings lists using the merge algorithm (see Figure 1.6): we maintain pointers into both lists
Online edition (c) 2009 Cambridge UP
1.3 Processing Boolean queries |
11 |
INTERSECT( p1, p2)
1answer ← h i
2 while p1 6= NIL and p2 6= NIL
3do if docID( p1) = docID( p2)
4then ADD(answer, docID( p1))
5p1 ← next( p1)
6p2 ← next( p2)
7else if docID( p1) < docID( p2)
8 |
then p1 |
← next( p1) |
9 |
else p2 |
← next( p2) |
10return answer
Figure 1.6 Algorithm for the intersection of two postings lists p1 and p2.
and walk through the two postings lists simultaneously, in time linear in the total number of postings entries. At each step, we compare the docID pointed to by both pointers. If they are the same, we put that docID in the results list, and advance both pointers. Otherwise we advance the pointer pointing to the smaller docID. If the lengths of the postings lists are x and y, the intersection takes O(x + y) operations. Formally, the complexity of querying is Θ(N), where N is the number of documents in the collection.6 Our indexing methods gain us just a constant, not a difference in Θ time complexity compared to a linear scan, but in practice the constant is huge. To use this algorithm, it is crucial that postings be sorted by a single global ordering. Using a numeric sort by docID is one simple way to achieve this.
We can extend the intersection operation to process more complicated queries like:
(1.2) (Brutus OR Caesar) AND NOT Calpurnia
QUERY OPTIMIZATION Query optimization is the process of selecting how to organize the work of answering a query so that the least total amount of work needs to be done by the system. A major element of this for Boolean queries is the order in which postings lists are accessed. What is the best order for query processing? Consider a query that is an AND of t terms, for instance:
(1.3) Brutus AND Caesar AND Calpurnia
For each of the t terms, we need to get its postings, then AND them together. The standard heuristic is to process terms in order of increasing document
6. The notation Θ(·) is used to express an asymptotically tight bound on the complexity of an algorithm. Informally, this is often written as O(·), but this notation really expresses an asymptotic upper bound, which need not be tight (Cormen et al. 1990).
Online edition (c) 2009 Cambridge UP
12 |
1 Boolean retrieval |
INTERSECT(ht1, . . . , tni)
1 terms ← SORTBYINCREASINGFREQUENCY(ht1, . . . , tni)
2 result ← postings( f irst(terms))
3terms ← rest(terms)
4while terms 6= NIL and result 6= NIL
5 do result ← INTERSECT(result, postings( f irst(terms)))
6terms ← rest(terms)
7return result
Figure 1.7 Algorithm for conjunctive queries that returns the set of documents containing each term in the input list of terms.
frequency: if we start by intersecting the two smallest postings lists, then all intermediate results must be no bigger than the smallest postings list, and we are therefore likely to do the least amount of total work. So, for the postings lists in Figure 1.3 (page 7), we execute the above query as:
(1.4) (Calpurnia AND Brutus) AND Caesar
This is a first justification for keeping the frequency of terms in the dictionary: it allows us to make this ordering decision based on in-memory data before accessing any postings list.
Consider now the optimization of more general queries, such as:
(1.5) (madding OR crowd) AND (ignoble OR strife) AND (killed OR slain)
As before, we will get the frequencies for all terms, and we can then (conservatively) estimate the size of each OR by the sum of the frequencies of its disjuncts. We can then process the query in increasing order of the size of each disjunctive term.
For arbitrary Boolean queries, we have to evaluate and temporarily store the answers for intermediate expressions in a complex expression. However, in many circumstances, either because of the nature of the query language, or just because this is the most common type of query that users submit, a query is purely conjunctive. In this case, rather than viewing merging postings lists as a function with two inputs and a distinct output, it is more efficient to intersect each retrieved postings list with the current intermediate result in memory, where we initialize the intermediate result by loading the postings list of the least frequent term. This algorithm is shown in Figure 1.7. The intersection operation is then asymmetric: the intermediate results list is in memory while the list it is being intersected with is being read from disk. Moreover the intermediate results list is always at least as short as the other list, and in many cases it is orders of magnitude shorter. The postings
Online edition (c) 2009 Cambridge UP
|
1.3 Processing Boolean queries |
13 |
|
intersection can still be done by the algorithm in Figure 1.6, but when the |
|
|
difference between the list lengths is very large, opportunities to use alter- |
|
|
native techniques open up. The intersection can be calculated in place by |
|
|
destructively modifying or marking invalid items in the intermediate results |
|
|
list. Or the intersection can be done as a sequence of binary searches in the |
|
|
long postings lists for each posting in the intermediate results list. Another |
|
|
possibility is to store the long postings list as a hashtable, so that membership |
|
|
of an intermediate result item can be calculated in constant rather than linear |
|
|
or log time. However, such alternative techniques are difficult to combine |
|
|
with postings list compression of the sort discussed in Chapter 5. Moreover, |
|
|
standard postings list intersection operations remain necessary when both |
|
|
terms of a query are very common. |
|
? |
Exercise 1.4 |
[ ] |
For the queries below, can we still run through the intersection in time O(x + y), |
||
where x and y are the lengths of the postings lists for Brutus and Caesar? If not, what |
||
|
can we achieve? |
|
|
a. Brutus AND NOT Caesar |
|
|
b. Brutus OR NOT Caesar |
|
|
Exercise 1.5 |
[ ] |
|
Extend the postings merge algorithm to arbitrary Boolean query formulas. What is |
|
|
its time complexity? For instance, consider: |
|
|
c. (Brutus OR Caesar) AND NOT (Antony OR Cleopatra) |
|
|
Can we always merge in linear time? Linear in what? Can we do better than this? |
|
|
Exercise 1.6 |
[ ] |
|
We can use distributive laws for AND and OR to rewrite queries. |
|
|
a. Show how to rewrite the query in Exercise 1.5 into disjunctive normal form using |
|
|
the distributive laws. |
|
|
b. Would the resulting query be more or less efficiently evaluated than the original |
|
|
form of this query? |
|
|
c. Is this result true in general or does it depend on the words and the contents of |
|
|
the document collection? |
|
|
Exercise 1.7 |
[ ] |
Recommend a query processing order for
d. (tangerine OR trees) AND (marmalade OR skies) AND (kaleidoscope OR eyes) given the following postings list sizes:
Online edition (c) 2009 Cambridge UP