Tutorial 4 (duplicate detection)

Duplicate detection
Kira Radinsky
Based on the Standford slides by Christopher Manning
and Prabhakar Raghavan

Duplication
• ~30% of the content on the Web is near-duplicate pages
– Pages with content that is nearly identical to that of other
pages
• Issues:
– Index duplicate content only once
– Return only one version in the search results
– How can near-duplicate pages be identified in a scalable
and reliable manner?

Duplicate/Near-Duplicate Detection
• Duplication: Exact match can be detected
with fingerprints
• Near-Duplication: Approximate match
– Compute syntactic similarity with an edit-distance
measure
– Use similarity threshold to detect near-duplicates
• E.g., Similarity > 80% => Documents are near
duplicates
• Not transitive though sometimes used transitively

Computing Similarity - Shingles
Features for Similarity (Shingles (Word N-Grams))
• Segments of a document (natural or artificial breakpoints)
• K-shingling of a document transforms the document into a
set containing all windows of k contiguous terms
• E.g., 4-shingling of
“My name is Inigo Montoya. You killed my father. Prepare to die”:
{
my name is inigo
name is inigo montoya
is inigo montoya you
inigo montoya you killed
montoya you killed my,
you killed my father
killed my father prepare
my father prepare to
father prepare to die
}

Computing Similarity – distance metric
Similarity Measurement
• Denote by Sk(d) the k-shingling of document d
• Definition: the resemblance of d1 and d2,
R(d1,d2) = |Sk(d1)  Sk(d2)| / |Sk(d1)  Sk(d2)|
• The distance measure Δ(d1,d2) = 1-R(d1,d2) is a
metric

Shingles + Set Intersection
1. Computing exact set intersection of shingles
between all pairs of documents is
expensive/intractable
– Approximate using a cleverly chosen subset of
shingles from each (a sketch)
2. Estimate (size_of_intersection /
size_of_union) based on a short sketch
Doc
A Shingle set A Sketch A
Doc B
Shingle set B Sketch B
Jaccard

Sketch of a document
Create a sketch vector (of size ~200) for each document
– Documents that share ≥ t (usually 80%) corresponding
vector elements will be considered near duplicates
– Definitions:
• Let f map all k-shingles in the universe to 0..2m (e.g., f =
fingerprinting)
• Let p be a random permutation on 0..2m
– For doc D, sketchD is as follows:
• Sketch Option 1:
Fm(d)=minm(Π(Sk(d)) be the m smallest numbers after
applying Π to the k-shingling of d
• Sketch Option 2:
Vn(d) = { t ε Π(Sk(d)) | t = 0 mod n }

From Shingles to Sketches (cont.)
• A function X is an unbiased estimator of a value Y if E(X)=Y
• Theorem: when choosing Π u.a.r., the following functions are
unbiased estimators of R(d1,d2):
• | minm(Fm(d1)  Fm(d2))  Fm(d1)  Fm(d2) | /
| minm(Fm(d1)  Fm(d2)) |
• | Vn(d1)  Vn(d2) | / | Vn(d1)  Vn(d2) |
• Either Fm(d) or Vn(d) can be chosen as d’s sketch
– Fm(d) has the advantage that it is of fixed size
– Vn(d) is easier to compute

Multiple Sketches
• Let pi be a random permutation on 0..2m
• For doc D, sketchD[ i ] is as follows:
– Let f map all shingles in the universe to 0..2m (e.g.,
f = fingerprinting)
– Let pi be a random permutation on 0..2m
– Pick MIN {pi(f(s))} over all shingles s in D

Computing Sketch[i] for Doc1
Document 1
264
264
264
264
Start with 64-bit f(shingles)
Permute on the number line
with pi
Pick the min value

Test if Doc1.Sketch[i] = Doc2.Sketch[i]
Document 1 Document 2
264
264
264
264
264
264
264
264
Are these equal?
Test for 200 random permutations: p1, p2,… p200
A B

However…
Document 1 Document 2
264
264
264
264
264
264
264
264
A = B iff the shingle with the MIN value in the union of Doc1 and Doc2 is
common to both (i.e., lies in the intersection)
Claim: This happens with probability
Size_of_intersection / Size_of_union
Why?
BA

Set Similarity of sets Ci , Cj
• View sets as columns of a matrix A
– one row for each element in the universe.
– aij = 1 indicates presence of item i in set j
• Example
ji
ji
ji
CC
CC
)C,Jaccard(C



C1 C2
0 1
1 0
1 1 Jaccard(C1,C2) = 2/5 = 0.4
0 0
1 1
0 1

Key Observation
• For columns Ci, Cj, four types of rows
Ci Cj
A 1 1
B 1 0
C 0 1
D 0 0
• Let A = # of rows of type A
• Claim
CBA
A
)C,Jaccard(C ji



Min Hashing
• Randomly permute rows
• Hash h(Ci) = index of first row with 1 in
column Ci
• Surprising Property
• Why?
– Both are A/(A+B+C)
– Look down columns Ci, Cj until first non-Type-D
row
– h(Ci) = h(Cj)  type A row
   jiji C,CJaccard)h(C)h(CP 

Min-Hash sketches
• Pick P random row permutations
• MinHash sketch
SketchD = list of P indexes of first rows with 1 in
column C
• Similarity of signatures
– Let sim[sketch(Ci),sketch(Cj)] = fraction of
permutations where MinHash values agree
– Observe E[sim(sig(Ci),sig(Cj))] = Jaccard(Ci,Cj)

Example
C1 C2 C3
R1 1 0 1
R2 0 1 1
R3 1 0 0
R4 1 0 1
R5 0 1 0
Signatures
S1 S2 S3
Perm 1 = (12345) 1 2 1
Perm 2 = (54321) 4 5 4
Perm 3 = (34512) 3 5 4
Similarities
1-2 1-3 2-3
Col-Col 0.00 0.50 0.25
Sig-Sig 0.00 0.67 0.00

Algorithm for Clustering Near-Duplicate
Documents
1. Compute the sketch of each document
2. From each sketch, produce a list of <shingle, docID> pairs
3. Group all pairs by shingle value
4. For any shingle that is shared by more than one document, output a
triplet <smaller-docID, larger-docID, 1> for each pair of docIDs sharing
that shingle
5. Sort and aggregate the list of triplets, producing final triplets of the
form <smaller-docID, larger-docID, # common shingles>
6. Join any pair of documents whose number of common shingles
exceeds a chosen threshold using a “Union-Find” algorithm
7. Each resulting connected component of the UF algorithm is a cluster
of near-duplicate documents
Implementation nicely fits the “map-reduce” programming paradigm

Tutorial 4 (duplicate detection)

Implementation Trick
• Permuting universe even once is prohibitive
• Row Hashing
– Pick P hash functions hk: {1,…,n}{1,…,O(n)}
– Ordering under hk gives random permutation of
rows
• One-pass Implementation
– For each Ci and hk, keep slot for min-hash value
– Initialize all slot(Ci,hk) to infinity
– Scan rows in arbitrary order looking for 1’s
• Suppose row Rj has 1 in column Ci
• For each hk,
– if hk(j) < slot(Ci,hk), then slot(Ci,hk)  hk(j)

Example
C1 C2
R1 1 0
R2 0 1
R3 1 1
R4 1 0
R5 0 1
h(x) = x mod 5
g(x) = 2x+1 mod 5
h(1) = 1 1 -
g(1) = 3 3 -
h(2) = 2 1 2
g(2) = 0 3 0
h(3) = 3 1 2
g(3) = 2 2 0
h(4) = 4 1 2
g(4) = 4 2 0
h(5) = 0 1 0
g(5) = 1 2 0
C1 slots C2 slots

Tutorial 4 (duplicate detection)

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Tutorial 4 (duplicate detection) (20)

More from Kira (13)

Recently uploaded (20)

Tutorial 4 (duplicate detection)