Why similarity measures find related text in NLP - The Real Reasons

The Big Idea

What if you could instantly find all texts talking about the same thing without reading them all?

The Scenario

Imagine you have hundreds of documents and you want to find which ones talk about the same topic. You try reading each one and comparing them by hand.

The Problem

This manual way is super slow and tiring. You might miss connections or make mistakes because it's hard to remember details from many texts.

The Solution

Similarity measures quickly compare texts by turning words into numbers and checking how close these numbers are. This helps find related texts fast and accurately.

Before vs After

✗ Before

for doc1 in docs:
    for doc2 in docs:
        if doc1 != doc2:
            # read and compare texts manually
            pass

✓ After

similarities = compute_similarity_matrix(docs)
related = find_pairs_above_threshold(similarities, 0.8)

What It Enables

It lets us instantly find and group related texts, unlocking insights hidden in large collections.

Real Life Example

Online stores use similarity to recommend products by finding descriptions like what you searched for.

Key Takeaways

Manual text comparison is slow and error-prone.

Similarity measures turn text into numbers to compare quickly.

This helps find related texts automatically and accurately.

Practice

1. Why do similarity measures help find related text in NLP?

easy

A. Because they compare numeric representations of texts to find closeness

B. Because they translate text into images for comparison

C. Because they count the number of words in each text

D. Because they randomly select texts to compare

Solution

1. Step 1: Understand text representation in NLP

   Texts are converted into numbers (vectors) so computers can compare them easily.

2. Step 2: Role of similarity measures

   Similarity measures calculate how close these numeric vectors are, showing relatedness.

3. Final Answer:

   Because they compare numeric representations of texts to find closeness -> Option A

4. Quick Check:

   Similarity = Numeric comparison [OK]

Hint: Similarity means comparing numbers, not words directly [OK]

Common Mistakes:

• Thinking similarity compares raw words directly
• Confusing similarity with random selection
• Believing similarity translates text into images

2. Which of the following is the correct way to calculate cosine similarity between two vectors A and B in Python?

easy

A. cos_sim = np.linalg.norm(A - B)

B. cos_sim = np.sum(A + B)

C. cos_sim = np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B))

D. cos_sim = np.dot(A, B) * (np.linalg.norm(A) + np.linalg.norm(B))

Solution

1. Step 1: Recall cosine similarity formula

   Cosine similarity = dot product of vectors divided by product of their lengths.

2. Step 2: Match formula to code

   cos_sim = np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B)) matches this formula exactly using numpy functions.

3. Final Answer:

   cos_sim = np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B)) -> Option C

4. Quick Check:

   Cosine similarity formula = cos_sim = np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B)) [OK]

Hint: Cosine similarity = dot product ÷ product of norms [OK]

Common Mistakes:

• Adding vectors instead of dot product
• Multiplying dot product by sum of norms
• Using norm of difference instead of cosine similarity

3. Given two texts converted to sets of words: text1 = {'apple', 'banana', 'cherry'} and text2 = {'banana', 'cherry', 'date'}, what is the Jaccard similarity between them?

medium

A. 0.25

B. 0.6

C. 0.75

D. 0.5

Solution

1. Step 1: Calculate intersection and union of sets

   Intersection = {'banana', 'cherry'} (2 items), Union = {'apple', 'banana', 'cherry', 'date'} (4 items).

2. Step 2: Compute Jaccard similarity

   Jaccard similarity = size of intersection ÷ size of union = 2 ÷ 4 = 0.5.

3. Final Answer:

   0.5 -> Option D

4. Quick Check:

   Jaccard = intersection/union = 0.5 [OK]

Hint: Jaccard = common words ÷ total unique words [OK]

Common Mistakes:

• Counting union incorrectly
• Using sum instead of division
• Confusing intersection with union size

4. The following Python code tries to compute cosine similarity but gives an error. What is the main issue?

import numpy as np
A = np.array([1, 2, 3])
B = np.array([4, 5])
cos_sim = np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B))
print(cos_sim)

medium

A. np.linalg.norm is used incorrectly

B. Vectors A and B have different lengths causing dot product error

C. Division by zero error

D. Missing import statement for numpy

Solution

1. Step 1: Check vector sizes

   Vector A has length 3, vector B has length 2, so dot product is invalid.

2. Step 2: Understand dot product requirements

   Dot product requires vectors of same length; mismatch causes error.

3. Final Answer:

   Vectors A and B have different lengths causing dot product error -> Option B

4. Quick Check:

   Dot product needs equal length vectors [OK]

Hint: Dot product needs vectors of same length [OK]

Common Mistakes:

• Assuming norm causes error
• Thinking division by zero happened
• Ignoring vector length mismatch

5. You want to find related news articles using similarity measures. Which approach best improves accuracy when articles have different lengths and some common words?

hard

A. Use cosine similarity on TF-IDF vectors to reduce common word impact

B. Use raw word counts and Jaccard similarity without preprocessing

C. Compare articles by counting total words only

D. Use random similarity scores to guess relatedness

Solution

1. Step 1: Understand TF-IDF role

   TF-IDF reduces weight of common words, highlighting unique terms in articles.

2. Step 2: Why cosine similarity on TF-IDF helps

   Cosine similarity measures angle between vectors, handling different lengths well.

3. Final Answer:

   Use cosine similarity on TF-IDF vectors to reduce common word impact -> Option A

4. Quick Check:

   TF-IDF + cosine similarity = better relatedness [OK]

Hint: TF-IDF + cosine similarity handles length and common words best [OK]

Common Mistakes:

• Ignoring word importance by using raw counts
• Using Jaccard without preprocessing
• Relying on random scores