Information retrieval basics in NLP - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of the TF-IDF score in information retrieval?

TF-IDF is a common technique used in information retrieval. What does it primarily help with?

A It measures how important a word is to a document relative to a collection of documents.

B It counts the total number of words in a document.

C It ranks documents based on their length.

D It removes stop words from the text.

💡 Hint

Think about how TF-IDF balances word frequency with rarity across documents.

TF-IDF stands for Term Frequency-Inverse Document Frequency. It scores words higher if they appear often in a document but rarely across all documents, helping to find important words.

❓ Predict Output

intermediate

What is the output of this code computing cosine similarity?

Given two vectors representing documents, what is the cosine similarity output?

NLP

import numpy as np

def cosine_similarity(vec1, vec2):
    dot_product = np.dot(vec1, vec2)
    norm1 = np.linalg.norm(vec1)
    norm2 = np.linalg.norm(vec2)
    return dot_product / (norm1 * norm2)

vec1 = np.array([1, 2, 3])
vec2 = np.array([4, 5, 6])
result = cosine_similarity(vec1, vec2)
print(round(result, 2))

A 0.50

B 0.97

C 1.00

D 0.74

💡 Hint

Recall cosine similarity formula and calculate dot product and norms carefully.

Cosine similarity is the dot product of vectors divided by the product of their magnitudes. For these vectors, the value is approximately 0.9746, rounded to 0.97.

❓ Model Choice

advanced

Which model is best suited for semantic search in information retrieval?

You want to build a search system that understands the meaning of queries and documents beyond exact word matches. Which model would you choose?

A TF-IDF vectorizer

B Simple keyword matching

C Bag-of-Words model

D Pretrained transformer-based embeddings (e.g., BERT)

💡 Hint

Consider models that capture context and meaning, not just word counts.

Transformer-based models like BERT produce embeddings that capture semantic meaning, enabling better understanding of queries and documents for semantic search.

❓ Hyperparameter

advanced

Which hyperparameter affects the number of neighbors considered in k-NN for document retrieval?

In a k-Nearest Neighbors (k-NN) model used for retrieving similar documents, which hyperparameter controls how many neighbors are checked?

A batch size

B learning rate

C k (number of neighbors)

D max depth

💡 Hint

Think about the 'k' in k-NN and what it stands for.

The hyperparameter 'k' specifies how many nearest neighbors the model considers when making a retrieval or classification decision.

❓ Metrics

expert

Which metric best evaluates ranking quality in information retrieval?

You want to measure how well your search engine ranks relevant documents higher than irrelevant ones. Which metric is most appropriate?

A Normalized Discounted Cumulative Gain (NDCG)

B Mean Squared Error (MSE)

C Recall

D Precision at k (P@k)

💡 Hint

Consider metrics that account for both relevance and position in the ranked list.

NDCG measures ranking quality by considering the relevance of documents and their positions, rewarding relevant documents appearing higher in the list.

Practice

1. What is the main goal of information retrieval in natural language processing?

easy

A. To translate text from one language to another

B. To find relevant documents based on a user's query

C. To generate new text automatically

D. To summarize long documents into short ones

Solution

1. Step 1: Understand the purpose of information retrieval

   Information retrieval is about searching and finding documents that match a user's query.

2. Step 2: Compare with other NLP tasks

   Translation, text generation, and summarization are different tasks unrelated to searching documents.

3. Final Answer:

   To find relevant documents based on a user's query -> Option B

4. Quick Check:

   Information retrieval = finding relevant documents [OK]

Hint: Remember: retrieval means finding, not creating [OK]

Common Mistakes:

• Confusing retrieval with translation
• Thinking retrieval generates new text
• Mixing retrieval with summarization

2. Which of the following Python code snippets correctly checks if the word 'apple' is in a document string doc (case-insensitive)?

easy

A. if 'Apple' == doc:

B. if doc.contains('apple'):

C. if 'apple' in doc.lower():

D. if doc.find('apple') == -1:

Solution

1. Step 1: Understand case-insensitive search

   To ignore case, convert the document to lowercase and check if 'apple' is in it.

2. Step 2: Analyze each option

   if 'apple' in doc.lower(): uses doc.lower() and checks membership correctly. if doc.contains('apple'): uses a non-existent method contains. if 'Apple' == doc: compares whole string, not membership. if doc.find('apple') == -1: checks if find returns -1, which means not found, so logic is reversed.

3. Final Answer:

   if 'apple' in doc.lower(): -> Option C

4. Quick Check:

   Use lower() + in for case-insensitive check [OK]

Hint: Use lower() before checking membership [OK]

Common Mistakes:

• Using non-existent string methods
• Comparing whole string instead of membership
• Misinterpreting find() return values

3. Given the following Python code, what will be the output?

documents = ['Apple pie recipe', 'Banana smoothie', 'apple tart']
query = 'apple'
results = [doc for doc in documents if query.lower() in doc.lower()]
print(results)

medium

A. []

B. ['apple tart']

C. ['Apple pie recipe']

D. ['Apple pie recipe', 'apple tart']

Solution

1. Step 1: Understand the list comprehension filtering

   The code checks each document if the lowercase query 'apple' is in the lowercase document string.

2. Step 2: Check each document

   'Apple pie recipe' contains 'apple' ignoring case, so included. 'Banana smoothie' does not contain 'apple'. 'apple tart' contains 'apple'. So results are the first and third documents.

3. Final Answer:

   ['Apple pie recipe', 'apple tart'] -> Option D

4. Quick Check:

   Case-insensitive filter returns matching docs [OK]

Hint: Check each document with lowercase query and doc [OK]

Common Mistakes:

• Ignoring case and missing matches
• Including documents without the query word
• Confusing list comprehension output

4. The following code is intended to find documents containing the word 'data' (case-insensitive), but it returns an empty list. What is the error?

docs = ['Data science', 'Big Data', 'Machine learning']
query = 'data'
results = [d for d in docs if d.find(query) != -1]
print(results)

medium

A. The find method is case-sensitive, so it misses 'Data science'

B. The find method returns -1 when found, so condition is wrong

C. The list comprehension syntax is incorrect

D. The variable query is not defined

Solution

1. Step 1: Understand find behavior

   The find method is case-sensitive, so searching 'data' in 'Data science' returns -1 (not found).

2. Step 2: Identify why results is empty

   The find method is case-sensitive. 'Data science'.find('data') returns -1 because of uppercase 'D'. Similarly, 'Big Data'.find('data') returns -1. 'Machine learning' doesn't contain 'data'. So results is empty.

3. Final Answer:

   The find method is case-sensitive, so it misses 'Data science' -> Option A

4. Quick Check:

   find() is case-sensitive [OK]

Hint: Remember find() is case-sensitive; use lower() [OK]

Common Mistakes:

• Assuming find() ignores case
• Misunderstanding find() return values
• Thinking list comprehension syntax is wrong

5. You have a list of documents:

docs = ['Data Science is fun', 'I love machine learning', 'Deep learning and data']

You want to create a dictionary where keys are unique words (case-insensitive) from all documents, and values are lists of document indices where the word appears. Which code snippet correctly does this?

hard

A. word_docs = {}
for i, doc in enumerate(docs):
for word in doc.lower().split():
word_docs.setdefault(word, []).append(i)

B. word_docs = {}
for i, doc in enumerate(docs):
for word in doc.split():
word_docs[word].append(i)

C. word_docs = {word: i for i, doc in enumerate(docs) for word in doc.lower().split()}

D. word_docs = {}
for doc in docs:
for word in doc.lower().split():
word_docs[word] = doc

Solution

1. Step 1: Understand the goal

   Create a dictionary mapping each unique lowercase word to a list of document indices where it appears.

2. Step 2: Analyze each option

   word_docs = {} for i, doc in enumerate(docs): for word in doc.lower().split(): word_docs.setdefault(word, []).append(i) uses setdefault to initialize lists and appends indices correctly with lowercase words. word_docs = {} for i, doc in enumerate(docs): for word in doc.split(): word_docs[word].append(i) misses initializing lists and ignores case. word_docs = {word: i for i, doc in enumerate(docs) for word in doc.lower().split()} creates a dict with last index only, not lists. word_docs = {} for doc in docs: for word in doc.lower().split(): word_docs[word] = doc overwrites values with document strings, not indices.

3. Final Answer:

   word_docs = {} for i, doc in enumerate(docs): for word in doc.lower().split(): word_docs.setdefault(word, []).append(i) -> Option A

4. Quick Check:

   Use setdefault and lowercase words for correct mapping [OK]

Hint: Use setdefault to build lists for each word [OK]

Common Mistakes:

• Not initializing lists before appending
• Ignoring case normalization
• Overwriting dictionary values instead of appending