Information retrieval basics in NLP

Introduction

Information retrieval helps us find useful information quickly from large collections like the internet or documents.

Searching for a recipe in a large cookbook.

Finding a specific article on a news website.

Looking up a product in an online store.

Finding emails in your inbox by keywords.

Searching for a book in a digital library.

Syntax

NLP

class SimpleSearchEngine:
    def __init__(self, documents):
        self.documents = documents

    def search(self, query):
        results = []
        for index, document in enumerate(self.documents):
            if query.lower() in document.lower():
                results.append((index, document))
        return results

This class stores documents and searches for a query word inside them.

The search method returns documents containing the query, ignoring case.

Examples

Search for 'apple' finds the first document because it contains 'Apple'.

NLP

documents = ["Apple pie recipe", "Banana smoothie", "Cherry tart"]
search_engine = SimpleSearchEngine(documents)
results = search_engine.search("apple")
print(results)

When there are no documents, search returns an empty list.

NLP

documents = []
search_engine = SimpleSearchEngine(documents)
results = search_engine.search("anything")
print(results)

Search works with just one document and finds it if it matches.

NLP

documents = ["Only one document"]
search_engine = SimpleSearchEngine(documents)
results = search_engine.search("document")
print(results)

Search finds documents with the query anywhere in the text.

NLP

documents = ["Start here", "Middle part", "End now"]
search_engine = SimpleSearchEngine(documents)
results = search_engine.search("end")
print(results)

Sample Model

This program creates a simple search engine that looks for a word in a list of documents and prints the matching documents with their indexes.

NLP

class SimpleSearchEngine:
    def __init__(self, documents):
        self.documents = documents

    def search(self, query):
        results = []
        for index, document in enumerate(self.documents):
            if query.lower() in document.lower():
                results.append((index, document))
        return results

# Create a list of documents
documents = [
    "Machine learning basics",
    "Deep learning introduction",
    "Natural language processing overview",
    "Information retrieval techniques",
    "Data science and AI"
]

# Initialize the search engine with documents
search_engine = SimpleSearchEngine(documents)

# Search for the word 'learning'
search_results = search_engine.search("learning")

# Print the results
print("Search results for 'learning':")
for index, doc in search_results:
    print(f"Document {index}: {doc}")

Important Notes

Time complexity of search is O(n * m) where n is number of documents and m is average document length.

Space complexity is O(n) to store documents.

Common mistake: Not handling case differences can miss matches.

Use this simple search for small collections; for large data, use indexes or specialized tools.

Summary

Information retrieval helps find relevant documents from many options.

Simple search checks if query words appear in documents.

Case-insensitive search improves matching results.

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