LLM wrappers in Prompt Engineering / GenAI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple LLM wrapper that calls the model's generate method.

Prompt Engineering / GenAI

response = llm.[1](prompt)

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

Afit

Bgenerate

Ctrain

Dcompile

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'train' or 'fit' instead of 'generate'.

Trying to compile the model instead of generating text.

The generate method is used to get the model's output for a given prompt.

2fill in blank

medium

Complete the code to initialize an LLM wrapper with a specific model name.

Prompt Engineering / GenAI

llm = LLMWrapper(model_name=[1])

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

ATrue

B12345

C'gpt-3.5-turbo'

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a number or boolean instead of a string.

Using None which means no model specified.

The model_name must be a string identifying the model, like 'gpt-3.5-turbo'.

3fill in blank

hard

Fix the error in the code to correctly call the LLM wrapper's generate method with a prompt.

Prompt Engineering / GenAI

output = llm.[1](input_text=prompt)

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

Atrain

Bpredict

Cfit

Dgenerate

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'predict' which is common in ML but not for LLM wrappers.

Using 'fit' or 'train' which are for model training.

The generate method accepts the prompt as input_text to produce output text.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps prompts to their generated outputs using the LLM wrapper.

Prompt Engineering / GenAI

results = {prompt: llm.[1](prompt) for prompt in prompts if len(prompt) [2] 0}

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

Agenerate

B>

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '>' to filter prompts.

Using a wrong method name instead of generate.

We use generate to get outputs and filter prompts with length greater than zero.

5fill in blank

hard

Fill all three blanks to create a list comprehension that generates outputs for prompts longer than 5 characters using the LLM wrapper.

Prompt Engineering / GenAI

outputs = [llm.[1](prompt) for prompt in prompts if len(prompt) [2] 5 and prompt.[3]('!')]

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

Agenerate

B>

Cendswith

Dstartswith

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'startswith' instead of 'endswith'.

Using '<' instead of '>' for length comparison.

We generate outputs for prompts longer than 5 characters that end with '!'.

Practice

1. What is the main purpose of an LLM wrapper in working with language models?

easy

A. To replace the language model with a simpler algorithm

B. To train the language model from scratch

C. To add extra features like logging and formatting around the model

D. To store large datasets for training

Solution

1. Step 1: Understand what an LLM wrapper does

   An LLM wrapper is a tool that surrounds a language model to add helpful features without changing the model itself.

2. Step 2: Identify the main use of wrappers

   Wrappers add things like logging, formatting, or connecting to other systems to make the model easier to use.

3. Final Answer:

   To add extra features like logging and formatting around the model -> Option C

4. Quick Check:

   LLM wrapper purpose = add features [OK]

Hint: Wrappers add helpers around models, not replace or train them [OK]

Common Mistakes:

• Thinking wrappers train the model
• Confusing wrappers with data storage
• Believing wrappers replace the model

2. Which of the following is the correct way to create a simple LLM wrapper function in Python that adds logging before calling the model's generate method?

easy

A. def wrapper(model, prompt): return print('Calling model', model.generate(prompt))

B. def wrapper(model, prompt): model.generate(prompt); print('Calling model')

C. def wrapper(model, prompt): print('Calling model') model.generate(prompt)

D. def wrapper(model, prompt): print('Calling model'); return model.generate(prompt)

Solution

1. Step 1: Check function syntax and order

   The function should print a message before calling model.generate(prompt) and return the result.

2. Step 2: Identify correct syntax and return usage

   def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) prints first, then returns the model output correctly. def wrapper(model, prompt): model.generate(prompt); print('Calling model') prints after calling but does not return the output properly. def wrapper(model, prompt): return print('Calling model', model.generate(prompt)) returns the print result (None). def wrapper(model, prompt): print('Calling model') model.generate(prompt) misses a semicolon or newline between statements.

3. Final Answer:

   def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) -> Option D

4. Quick Check:

   Print then return output = def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) [OK]

Hint: Print before return, and return model output directly [OK]

Common Mistakes:

• Returning print() instead of model output
• Missing return statement
• Incorrect statement order or syntax

3. Given this Python code using an LLM wrapper, what will be printed and returned?

class SimpleModel:
    def generate(self, prompt):
        return f"Response to: {prompt}"

def wrapper(model, prompt):
    print(f"Input prompt: {prompt}")
    result = model.generate(prompt)
    print(f"Model output: {result}")
    return result

model = SimpleModel()
output = wrapper(model, "Hello")
print(f"Final output: {output}")

medium

A. Input prompt: Hello
Model output: Response to: Hello
Final output: Response to: Hello

B. Model output: Response to: Hello
Input prompt: Hello
Final output: Response to: Hello

C. Final output: Response to: Hello
Input prompt: Hello
Model output: Response to: Hello

D. Input prompt: Hello
Final output: Response to: Hello
Model output: Response to: Hello

Solution

1. Step 1: Trace the wrapper function calls

   The wrapper first prints the input prompt, then calls model.generate which returns a string, then prints the model output, and finally returns the result.

2. Step 2: Check the order of prints and final output

   The prints happen in order: input prompt, model output, then outside the wrapper the final output is printed.

3. Final Answer:

   Input prompt: Hello Model output: Response to: Hello Final output: Response to: Hello -> Option A

4. Quick Check:

   Print order matches Input prompt: Hello Model output: Response to: Hello Final output: Response to: Hello [OK]

Hint: Follow print statements in code order to find output [OK]

Common Mistakes:

• Mixing print order
• Confusing return value with print output
• Ignoring the final print outside wrapper

4. This code tries to wrap an LLM call but has an error. What is the error?

def wrapper(model, prompt):
    print('Calling model')
    output = model.generate(prompt)
    print('Output:', output)

model = SomeModel()
result = wrapper(model, 'Test')

medium

A. The wrapper function does not return the model output

B. The model object is not defined

C. The print statements have syntax errors

D. The prompt argument is missing in the wrapper call

Solution

1. Step 1: Check the wrapper function's return behavior

   The wrapper prints messages and calls model.generate but does not return the output, so result will be None.

2. Step 2: Verify other parts of the code

   The model is assumed defined as SomeModel(), print statements are correct, and the prompt is passed correctly.

3. Final Answer:

   The wrapper function does not return the model output -> Option A

4. Quick Check:

   Missing return in wrapper = The wrapper function does not return the model output [OK]

Hint: Always return model output from wrapper to use it outside [OK]

Common Mistakes:

• Forgetting to return output from wrapper
• Assuming print returns value
• Confusing variable names

5. You want to create an LLM wrapper that formats the prompt by adding a prefix, logs the prompt and output, and caches results to avoid repeated calls. Which approach best combines these features?

hard

A. Write separate functions for formatting, logging, and caching and call them outside the wrapper

B. Create a wrapper class with methods to format, log, and cache results internally

C. Modify the original model's generate method to add formatting and logging

D. Use a global variable to store all prompts and outputs without wrapping

Solution

1. Step 1: Understand the need for combining features in one place

   To keep code organized and flexible, a wrapper class can hold formatting, logging, and caching together.

2. Step 2: Evaluate options for maintainability and clarity

   Create a wrapper class with methods to format, log, and cache results internally uses a class to encapsulate all features, making it easy to manage. Write separate functions for formatting, logging, and caching and call them outside the wrapper scatters logic outside, making code messy. Modify the original model's generate method to add formatting and logging changes the model itself, which is not recommended. Use a global variable to store all prompts and outputs without wrapping uses globals, which is error-prone.

3. Final Answer:

   Create a wrapper class with methods to format, log, and cache results internally -> Option B

4. Quick Check:

   Wrapper class for combined features = Create a wrapper class with methods to format, log, and cache results internally [OK]

Hint: Use a class wrapper to keep related features together [OK]

Common Mistakes:

• Changing the original model code
• Scattering logic outside wrapper
• Using global variables for caching