Intermediate result handling in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this agentic AI code snippet?

Consider an agentic AI system that processes tasks in steps and stores intermediate results in a dictionary. What will be the final content of the results dictionary after running this code?

Agentic AI

results = {}
for step in range(3):
    results[f'step_{step}'] = step * 2
results['final'] = sum(results.values())
print(results)

A {'step_0': 0, 'step_1': 2, 'step_2': 4, 'final': 6}

B {'step_0': 0, 'step_1': 1, 'step_2': 2, 'final': 3}

C {'step_0': 0, 'step_1': 2, 'step_2': 4, 'final': 0}

D {'step_0': 1, 'step_1': 2, 'step_2': 3, 'final': 6}

💡 Hint

Remember that each step multiplies the step number by 2 before storing.

Each step key stores step * 2: step_0=0, step_1=2, step_2=4. The final key sums these values: 0+2+4=6.

❓ Model Choice

intermediate

Which model type best handles intermediate result caching in agentic AI?

You want an AI model that can store and reuse intermediate results during multi-step reasoning to improve efficiency. Which model architecture is best suited for this?

A Recurrent neural network without state preservation

B Simple feedforward neural network without memory

C Convolutional neural network for image processing

D Transformer with attention layers that cache key-value pairs

💡 Hint

Think about models that remember past information efficiently.

Transformers use attention with cached key-value pairs to reuse intermediate computations, ideal for multi-step tasks.

❓ Hyperparameter

advanced

Which hyperparameter adjustment improves intermediate result stability in iterative agentic AI?

In an iterative agentic AI process, which hyperparameter change helps reduce fluctuations in intermediate outputs across iterations?

A Use gradient clipping to limit update size

B Add dropout with high rate

C Increase learning rate significantly

D Remove batch normalization layers

💡 Hint

Think about controlling how much the model changes per step.

Gradient clipping limits update size, stabilizing intermediate results during iterative updates.

❓ Metrics

advanced

Which metric best evaluates the quality of intermediate results in agentic AI?

You want to measure how accurate intermediate results are during a multi-step agentic AI task. Which metric is most appropriate?

A Number of parameters in the model

B Model training loss on final output only

C Mean Squared Error (MSE) between predicted and true intermediate values

D Inference time per step

💡 Hint

Focus on measuring difference between predicted and actual intermediate values.

MSE directly measures the average squared difference between predicted and true intermediate results.

🔧 Debug

expert

Why does this agentic AI code fail to update intermediate results correctly?

Given this code snippet, why does the intermediate result dictionary not update as expected after each iteration? results = {} for i in range(3): temp = results temp['step'] = i print(results)

A The variable 'temp' is a reference to 'results', so updates affect 'results' correctly.

B The dictionary key 'step' is overwritten each iteration, so only the last value remains.

C The loop does not run because range(3) is empty.

D 'temp' is a copy of 'results', so changes to 'temp' do not affect 'results'.

💡 Hint

Check how dictionary keys are updated inside the loop.

Each iteration overwrites the same key 'step', so only the last value (2) remains in results.

Practice

1. What is the main benefit of saving intermediate results during a machine learning training process?

easy

A. It allows resuming training without starting over

B. It makes the model run faster on new data

C. It reduces the size of the training dataset

D. It automatically improves model accuracy

Solution

1. Step 1: Understand the purpose of intermediate results

   Intermediate results store progress so you don't lose work if interrupted.

2. Step 2: Identify the benefit in training context

   Saving allows resuming training from the last saved point, avoiding restart.

3. Final Answer:

   It allows resuming training without starting over -> Option A

4. Quick Check:

   Saving progress = resume training [OK]

Hint: Think about avoiding repeated work by saving progress [OK]

Common Mistakes:

• Confusing saving results with improving accuracy
• Thinking it reduces dataset size
• Assuming it speeds up model inference

2. Which Python code snippet correctly saves a model's intermediate result using pickle?

easy

A. import pickle
pickle.save('model.pkl', model)

B. import pickle
with open('model.pkl', 'r') as f:
pickle.load(model, f)

C. import pickle
with open('model.pkl', 'wb') as f:
pickle.dump(model, f)

D. import pickle
pickle.write('model.pkl', model)

Solution

1. Step 1: Identify correct file mode for saving

   Saving requires 'wb' (write binary) mode, not 'r' (read).

2. Step 2: Use correct pickle function

   pickle.dump(object, file) saves data; pickle.load reads it.

3. Final Answer:

   import pickle with open('model.pkl', 'wb') as f: pickle.dump(model, f) -> Option C

4. Quick Check:

   pickle.dump + 'wb' mode = save [OK]

Hint: Use 'wb' mode and pickle.dump to save objects [OK]

Common Mistakes:

• Using 'r' mode instead of 'wb' for saving
• Confusing pickle.load with saving
• Using non-existent pickle.save or pickle.write

3. Given this code snippet, what will be the printed output?

results = {}
for i in range(3):
    results[i] = i * 2
print(results)

medium

A. {0: 0, 1: 2, 2: 4}

B. [0, 2, 4]

C. {0, 2, 4}

D. [0: 0, 1: 2, 2: 4]

Solution

1. Step 1: Understand the loop and dictionary assignment

   Loop runs i=0,1,2; assigns results[i] = i*2, creating key-value pairs.

2. Step 2: Identify the dictionary structure printed

   results is a dict with keys 0,1,2 and values 0,2,4 respectively.

3. Final Answer:

   {0: 0, 1: 2, 2: 4} -> Option A

4. Quick Check:

   Dict with keys and doubled values = {0:0,1:2,2:4} [OK]

Hint: Remember dict prints as {key: value} pairs [OK]

Common Mistakes:

• Confusing dict with list syntax
• Using set notation instead of dict
• Misreading loop range or values

4. You have this code to save intermediate results but it raises an error:

with open('results.pkl', 'w') as f:
    pickle.dump(data, f)

What is the error and how to fix it?

medium

A. Missing import statement for pickle

B. pickle.dump requires a string, not a file object

C. File path is incorrect; fix by giving full path

D. File opened in text mode; fix by using 'wb' mode

Solution

1. Step 1: Identify file mode issue

   pickle.dump writes binary data, so file must be opened in 'wb' mode, not 'w'.

2. Step 2: Correct the file open mode

   Change 'w' to 'wb' to fix the error and save data properly.

3. Final Answer:

   File opened in text mode; fix by using 'wb' mode -> Option D

4. Quick Check:

   pickle.dump needs binary write mode [OK]

Hint: Use 'wb' mode when saving with pickle [OK]

Common Mistakes:

• Using text mode 'w' instead of binary 'wb'
• Forgetting to import pickle
• Assuming file path causes error

5. You want to save intermediate training metrics (loss and accuracy) after each epoch in a dictionary, then save it to a file. Which approach correctly handles this?

hard

A. Append metrics to a list and save with open('metrics.txt', 'w') using write()

B. Create a dict with epoch keys and metric values, then use pickle.dump with 'wb' mode

C. Save metrics as strings in a text file without structured format

D. Overwrite the same file each epoch without saving intermediate data

Solution

1. Step 1: Structure metrics in a dictionary by epoch

   Use a dict like {epoch: {'loss': val, 'accuracy': val}} to keep data organized.

2. Step 2: Save the dict using pickle.dump in binary mode

   Use pickle.dump with 'wb' mode to save the structured data safely for later reuse.

3. Final Answer:

   Create a dict with epoch keys and metric values, then use pickle.dump with 'wb' mode -> Option B

4. Quick Check:

   Dict + pickle.dump + 'wb' = safe intermediate save [OK]

Hint: Use dict for metrics and pickle.dump with 'wb' to save [OK]

Common Mistakes:

• Saving as plain text without structure
• Using text write mode for binary data
• Not saving intermediate results at all