public abstract class TFIDFSimilarity extends Similarity
Similarity
with the Vector Space Model.
Expert: Scoring API.
TFIDFSimilarity defines the components of Lucene scoring. Overriding computation of these components is a convenient way to alter Lucene scoring.
Suggested reading: Introduction To Information Retrieval, Chapter 6.
The following describes how Lucene scoring evolves from underlying information retrieval models to (efficient) implementation. We first brief on VSM Score, then derive from it Lucene's Conceptual Scoring Formula, from which, finally, evolves Lucene's Practical Scoring Function (the latter is connected directly with Lucene classes and methods).
Lucene combines Boolean model (BM) of Information Retrieval with Vector Space Model (VSM) of Information Retrieval  documents "approved" by BM are scored by VSM.
In VSM, documents and queries are represented as weighted vectors in a multidimensional space, where each distinct index term is a dimension, and weights are Tfidf values.
VSM does not require weights to be Tfidf values, but Tfidf values are believed to produce search results of high quality, and so Lucene is using Tfidf. Tf and Idf are described in more detail below, but for now, for completion, let's just say that for given term t and document (or query) x, Tf(t,x) varies with the number of occurrences of term t in x (when one increases so does the other) and idf(t) similarly varies with the inverse of the number of index documents containing term t.
VSM score of document d for query q is the
Cosine Similarity
of the weighted query vectors V(q) and V(d):
 

Note: the above equation can be viewed as the dot product of the normalized weighted vectors, in the sense that dividing V(q) by its euclidean norm is normalizing it to a unit vector.
Lucene refines VSM score for both search quality and usability:
Under the simplifying assumption of a single field in the index,
we get Lucene's Conceptual scoring formula:
 

The conceptual formula is a simplification in the sense that (1) terms and documents are fielded and (2) boosts are usually per query term rather than per query.
We now describe how Lucene implements this conceptual scoring formula, and derive from it Lucene's Practical Scoring Function.
For efficient score computation some scoring components are computed and aggregated in advance:
Lucene's Practical Scoring Function is derived from the above. The color codes demonstrate how it relates to those of the conceptual formula:
 

where
ClassicSimilarity
is:
tf(t in d) =

frequency^{½} 
ClassicSimilarity
is:
idf(t) =

1 + log ( 

) 
BoostQuery
.
Notice that there is really no direct API for accessing a boost of one term in a multi term query,
but rather multi terms are represented in a query as multi
TermQuery
objects,
and so the boost of a term in the query is accessible by calling the subquery
getBoost()
.
Similarity.SimScorer
Modifier and Type  Field and Description 

protected boolean 
discountOverlaps
True if overlap tokens (tokens with a position of increment of zero) are
discounted from the document's length.

Constructor and Description 

TFIDFSimilarity()
Sole constructor.

Modifier and Type  Method and Description 

long 
computeNorm(FieldInvertState state)
Computes the normalization value for a field, given the accumulated
state of term processing for this field (see
FieldInvertState ). 
boolean 
getDiscountOverlaps()
Returns true if overlap tokens are discounted from the document's length.

abstract float 
idf(long docFreq,
long docCount)
Computes a score factor based on a term's document frequency (the number
of documents which contain the term).

Explanation 
idfExplain(CollectionStatistics collectionStats,
TermStatistics termStats)
Computes a score factor for a simple term and returns an explanation
for that score factor.

Explanation 
idfExplain(CollectionStatistics collectionStats,
TermStatistics[] termStats)
Computes a score factor for a phrase.

abstract float 
lengthNorm(int length)
Compute an indextime normalization value for this field instance.

Similarity.SimScorer 
scorer(float boost,
CollectionStatistics collectionStats,
TermStatistics... termStats)
Compute any collectionlevel weight (e.g.

void 
setDiscountOverlaps(boolean v)
Determines whether overlap tokens (Tokens with
0 position increment) are ignored when computing
norm.

abstract float 
tf(float freq)
Computes a score factor based on a term or phrase's frequency in a
document.

protected boolean discountOverlaps
public TFIDFSimilarity()
public void setDiscountOverlaps(boolean v)
computeNorm(org.apache.lucene.index.FieldInvertState)
public boolean getDiscountOverlaps()
setDiscountOverlaps(boolean)
public abstract float tf(float freq)
idf(long, long)
factor for each term in the query and these products are then summed to
form the initial score for a document.
Terms and phrases repeated in a document indicate the topic of the
document, so implementations of this method usually return larger values
when freq
is large, and smaller values when freq
is small.
freq
 the frequency of a term within a documentpublic Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics termStats)
The default implementation uses:
idf(docFreq, docCount);Note that
CollectionStatistics.docCount()
is used instead of
IndexReader#numDocs()
because also
TermStatistics.docFreq()
is used, and when the latter
is inaccurate, so is CollectionStatistics.docCount()
, and in the same direction.
In addition, CollectionStatistics.docCount()
does not skew when fields are sparse.collectionStats
 collectionlevel statisticstermStats
 termlevel statistics for the termpublic Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics[] termStats)
The default implementation sums the idf factor for each term in the phrase.
collectionStats
 collectionlevel statisticstermStats
 termlevel statistics for the terms in the phrasepublic abstract float idf(long docFreq, long docCount)
tf(float)
factor for each term in the query and these products are
then summed to form the initial score for a document.
Terms that occur in fewer documents are better indicators of topic, so implementations of this method usually return larger values for rare terms, and smaller values for common terms.
docFreq
 the number of documents which contain the termdocCount
 the total number of documents in the collectionpublic abstract float lengthNorm(int length)
length
 the number of terms in the field, optionally discounting overlaps
public final long computeNorm(FieldInvertState state)
Similarity
FieldInvertState
).
Matches in longer fields are less precise, so implementations of this
method usually set smaller values when state.getLength()
is large,
and larger values when state.getLength()
is small.
Note that for a given termdocument frequency, greater unsigned norms
must produce scores that are lower or equal, ie. for two encoded norms
n1
and n2
so that
Long.compareUnsigned(n1, n2) > 0
then
SimScorer.score(freq, n1) <= SimScorer.score(freq, n2)
for any legal freq
.
0
is not a legal norm, so 1
is the norm that produces
the highest scores.
computeNorm
in class Similarity
state
 current processing state for this fieldpublic final Similarity.SimScorer scorer(float boost, CollectionStatistics collectionStats, TermStatistics... termStats)
Similarity
scorer
in class Similarity
boost
 a multiplicative factor to apply to the produces scorescollectionStats
 collectionlevel statistics, such as the number of tokens in the collection.termStats
 termlevel statistics, such as the document frequency of a term across the collection.Copyright © 20002024 Apache Software Foundation. All Rights Reserved.