Summarization in Prompt Engineering / GenAI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to load the summarization pipeline from Hugging Face Transformers.

Prompt Engineering / GenAI

from transformers import pipeline
summarizer = pipeline([1])

Drag options to blanks, or click blank then click option'

A"text-generation"

B"sentiment-analysis"

C"summarization"

D"translation"

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'translation' instead of 'summarization'.

Using 'text-generation' which creates new text, not summaries.

The pipeline type for text summarization is "summarization".

2fill in blank

medium

Complete the code to summarize the input text using the summarizer pipeline.

Prompt Engineering / GenAI

text = "Machine learning helps computers learn from data."
summary = summarizer([1], max_length=20, min_length=5, do_sample=False)
print(summary[0]['summary_text'])

Drag options to blanks, or click blank then click option'

Atext

Btext.split()

Ctext.lower()

Dtext.upper()

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a list of words instead of a string.

Passing an uppercase or lowercase transformed string unnecessarily.

The summarizer expects a string input, so passing 'text' directly is correct.

3fill in blank

hard

Fix the error in the code to correctly get the summary text from the output.

Prompt Engineering / GenAI

result = summarizer(text, max_length=30, min_length=10, do_sample=False)
summary_text = result[1]
print(summary_text)

Drag options to blanks, or click blank then click option'

A[0]

B['summary_text']

C['text']

D[0]['summary_text']

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access 'summary_text' directly from the list.

Using wrong keys like 'text' instead of 'summary_text'.

The summarizer returns a list with one dict; access the first item and then the 'summary_text' key.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each sentence to its summary length.

Prompt Engineering / GenAI

sentences = ["AI is fascinating.", "It can learn patterns.", "Summarization helps understand text."]
summary_lengths = {sentence: len(summarizer(sentence, max_length=10, min_length=5, do_sample=False)[1]) for sentence in sentences if len(sentence) [2] 10}
print(summary_lengths)

Drag options to blanks, or click blank then click option'

A[0]['summary_text']

B>

C<

D[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using '[0]' only returns a dict, not the text string.

Using '<' instead of '>' in the filter condition.

Access the summary text with [0]['summary_text'] and filter sentences longer than 10 characters.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each sentence's uppercase form to its summary.

Prompt Engineering / GenAI

sentences = ["AI is cool.", "It learns fast.", "Summarization is useful."]
summary_info = [1]: [2] for s in sentences if len(s) [3] 8
print(summary_info)

Drag options to blanks, or click blank then click option'

As.upper()

Bsummarizer(s, max_length=15, min_length=5, do_sample=False)[0]['summary_text']

C>

Dlen(s)

Attempts:

3 left

💡 Hint

Common Mistakes

Using s instead of s.upper() as key.

Using '<' instead of '>' in the filter condition.

Use s.upper() as key, summary text as value, and filter sentences longer than 8 characters.

Practice

1. What is the main purpose of text summarization in AI?

easy

A. To count the number of words in a text

B. To translate text into another language

C. To generate new text from scratch

D. To make long text shorter and easier to understand

Solution

1. Step 1: Understand the goal of summarization

   Summarization aims to reduce the length of text while keeping the main ideas clear.

2. Step 2: Compare options with the goal

   Only To make long text shorter and easier to understand describes making text shorter and easier to understand, which matches summarization.

3. Final Answer:

   To make long text shorter and easier to understand -> Option D

4. Quick Check:

   Summarization = shorten text [OK]

Hint: Summarization shortens text for quick understanding [OK]

Common Mistakes:

• Confusing summarization with translation
• Thinking summarization creates new text
• Mixing summarization with word counting

2. Which of the following is the correct way to call a summarization model in Python using a fictional API?

easy

A. summary = model.summarize(text)

B. summary = model.translate(text)

C. summary = model.generate(text)

D. summary = model.count_words(text)

Solution

1. Step 1: Identify the function for summarization

   The function to get a summary should be named something like 'summarize' to match the task.

2. Step 2: Match function names to tasks

   Only 'model.summarize(text)' fits the summarization task; others do translation, generation, or counting.

3. Final Answer:

   summary = model.summarize(text) -> Option A

4. Quick Check:

   Summarize function call = summary = model.summarize(text) [OK]

Hint: Look for 'summarize' function for summarization calls [OK]

Common Mistakes:

• Using translate() instead of summarize()
• Using generate() which creates new text
• Using count_words() which is unrelated

3. Given the code below, what will be the output?

text = "AI helps us by making complex tasks easier."
summary = model.summarize(text)
print(summary)

Assuming the model works correctly, what is the likely output?

medium

A. "AI simplifies complex tasks."

B. "AI translates text."

C. "AI helps us by making complex tasks easier."

D. "AI counts words in text."

Solution

1. Step 1: Understand summarization output

   The summary should be a shorter version of the original text keeping the main idea.

2. Step 2: Compare options to expected summary

   "AI simplifies complex tasks." shortens the sentence while keeping meaning; "AI helps us by making complex tasks easier." is original text, others unrelated.

3. Final Answer:

   "AI simplifies complex tasks." -> Option A

4. Quick Check:

   Summary shortens text = "AI simplifies complex tasks." [OK]

Hint: Summary is shorter but keeps main idea [OK]

Common Mistakes:

• Thinking summary is the same as original text
• Confusing summarization with translation
• Expecting unrelated outputs like word count

4. The following code throws an error. What is the likely cause?

text = "Summarize this text."
summary = model.summarize_text(text)
print(summary)

medium

A. The variable 'text' is not defined

B. The method name 'summarize_text' is incorrect

C. The print statement is missing parentheses

D. The model object is not created

Solution

1. Step 1: Check method name correctness

   The correct method to summarize is likely 'summarize', not 'summarize_text'.

2. Step 2: Verify other code parts

   The variable 'text' is defined, print has parentheses, and model object assumed created.

3. Final Answer:

   The method name 'summarize_text' is incorrect -> Option B

4. Quick Check:

   Method name must be correct = The method name 'summarize_text' is incorrect [OK]

Hint: Check method names carefully for typos [OK]

Common Mistakes:

• Assuming variable 'text' is undefined
• Forgetting print needs parentheses
• Ignoring if model object exists

5. You want to summarize a long article but keep important keywords intact. Which approach is best?

hard

A. Use translation model to convert text language

B. Use generative summarization to rewrite text freely

C. Use extractive summarization to select key sentences

D. Use word count to find important words

Solution

1. Step 1: Understand extractive vs generative summarization

   Extractive picks actual sentences from text, preserving keywords; generative rewrites freely.

2. Step 2: Choose method to keep keywords intact

   Extractive summarization keeps original sentences and keywords, so it fits the need best.

3. Final Answer:

   Use extractive summarization to select key sentences -> Option C

4. Quick Check:

   Keep keywords = extractive summarization [OK]

Hint: Extractive keeps original words; generative rewrites [OK]

Common Mistakes:

• Confusing generative with extractive summarization
• Using translation instead of summarization
• Relying on word count alone for keywords