Progress tracking and reporting in Agentic AI

Introduction

Progress tracking helps you see how well your AI or machine learning model is learning over time. Reporting shows this progress clearly so you can make better decisions.

When training a model to check if it is improving after each step.

When running experiments to compare different models or settings.

When sharing results with teammates or stakeholders to explain how the model is doing.

When debugging to find if the model is stuck or learning too slowly.

When automating AI tasks and needing to monitor progress automatically.

Syntax

Agentic AI

progress_tracker = ProgressTracker()
for epoch in range(num_epochs):
    loss = train_one_epoch(model, data)
    accuracy = evaluate(model, validation_data)
    progress_tracker.update(epoch, loss, accuracy)
progress_report = progress_tracker.report()

The ProgressTracker is a tool to collect and store progress data.

Update it regularly during training to keep track of metrics like loss and accuracy.

Examples

Start tracking after the first epoch and print a simple report.

Agentic AI

progress_tracker = ProgressTracker()
progress_tracker.update(epoch=1, loss=0.5, accuracy=0.8)
print(progress_tracker.report())

Track progress over 5 epochs with made-up loss and accuracy values.

Agentic AI

for epoch in range(5):
    loss = 0.5 / (epoch + 1)
    accuracy = 0.7 + 0.05 * epoch
    progress_tracker.update(epoch, loss, accuracy)
print(progress_tracker.report())

Sample Model

This program simulates training for 5 epochs. It tracks loss and accuracy each epoch and prints a report at the end.

Agentic AI

class ProgressTracker:
    def __init__(self):
        self.records = []
    def update(self, epoch, loss, accuracy):
        self.records.append({'epoch': epoch, 'loss': loss, 'accuracy': accuracy})
    def report(self):
        report_lines = ['Epoch | Loss  | Accuracy']
        for r in self.records:
            report_lines.append(f"{r['epoch']:5} | {r['loss']:.4f} | {r['accuracy']:.4f}")
        return '\n'.join(report_lines)

def train_one_epoch(model, data):
    # Dummy training function
    return 0.5 / (train_one_epoch.counter + 1)
train_one_epoch.counter = 0

def evaluate(model, data):
    # Dummy evaluation function
    return 0.7 + 0.05 * train_one_epoch.counter

progress_tracker = ProgressTracker()
num_epochs = 5
model = None
train_data = None
validation_data = None

for epoch in range(1, num_epochs + 1):
    loss = train_one_epoch(model, train_data)
    accuracy = evaluate(model, validation_data)
    progress_tracker.update(epoch, loss, accuracy)
    train_one_epoch.counter += 1

print(progress_tracker.report())

Important Notes

Tracking progress helps catch problems early, like if loss stops going down.

Reports can be saved to files or shown in graphs for easier understanding.

Use simple tables or charts to make reports clear and useful.

Summary

Progress tracking records how your model learns over time.

Reporting shows this information clearly to help you understand and improve your model.

Regular updates and clear reports make training easier and more effective.

Practice

1. What is the main purpose of progress tracking during machine learning model training?

easy

A. To record how the model improves over time

B. To increase the size of the training data

C. To change the model architecture automatically

D. To speed up the training hardware

Solution

1. Step 1: Understand progress tracking

   Progress tracking means keeping a record of how well the model is learning as it trains.

2. Step 2: Identify the main goal

   The goal is to see improvements over time, not to change data size or hardware.

3. Final Answer:

   To record how the model improves over time -> Option A

4. Quick Check:

   Progress tracking = record improvement [OK]

Hint: Progress tracking = recording learning progress [OK]

Common Mistakes:

• Confusing progress tracking with data augmentation
• Thinking it changes model structure automatically
• Assuming it speeds up hardware

2. Which of the following is the correct way to log training loss after each epoch in Python?

easy

A. print('Loss:', loss)

B. log('Loss:' + loss)

C. print('Loss:' loss)

D. echo 'Loss:' loss

Solution

1. Step 1: Check Python print syntax

   In Python, print() requires arguments separated by commas or concatenated as strings.

2. Step 2: Validate each option

   print('Loss:', loss) uses print with a comma, which is correct. log('Loss:' + loss) uses undefined log function. print('Loss:' loss) misses a comma. echo 'Loss:' loss uses echo, which is not Python.

3. Final Answer:

   print('Loss:', loss) -> Option A

4. Quick Check:

   Correct print syntax = print('Loss:', loss) [OK]

Hint: Use print() with commas to separate text and variables [OK]

Common Mistakes:

• Missing commas in print statements
• Using non-Python functions like echo or log
• Concatenating strings without conversion

3. Given the code below, what will be printed after training for 3 epochs?

losses = []
for epoch in range(3):
    loss = 1 / (epoch + 1)
    losses.append(loss)
    print(f'Epoch {epoch+1}, Loss: {loss:.2f}')
print('Final losses:', losses)

medium

A. Epoch 1, Loss: 1.00
Epoch 2, Loss: 0.50
Epoch 3, Loss: 0.33
Final losses: [1, 2, 3]

B. Epoch 1, Loss: 0.00
Epoch 2, Loss: 0.50
Epoch 3, Loss: 0.33
Final losses: [0, 0.5, 0.3333333333333333]

C. Epoch 1, Loss: 1.00
Epoch 2, Loss: 0.50
Epoch 3, Loss: 0.33
Final losses: [1.0, 0.5, 0.3333333333333333]

D. Epoch 1, Loss: 1.00
Epoch 2, Loss: 0.50
Epoch 3, Loss: 0.33
Final losses: [1, 0.5, 0.33]

Solution

1. Step 1: Calculate loss values for each epoch

   Epoch 1: 1/(1) = 1.0, Epoch 2: 1/(2) = 0.5, Epoch 3: 1/(3) ≈ 0.3333

2. Step 2: Check printed output and final list

   Print shows formatted loss with 2 decimals. Final losses list stores full float values.

3. Final Answer:

   Epoch 1, Loss: 1.00 Epoch 2, Loss: 0.50 Epoch 3, Loss: 0.33 Final losses: [1.0, 0.5, 0.3333333333333333] -> Option C

4. Quick Check:

   Loss calculation and print formatting = Epoch 1, Loss: 1.00 Epoch 2, Loss: 0.50 Epoch 3, Loss: 0.33 Final losses: [1.0, 0.5, 0.3333333333333333] [OK]

Hint: Calculate loss per epoch and check print formatting carefully [OK]

Common Mistakes:

• Confusing integer division with float division
• Rounding losses in the list incorrectly
• Misreading the range function output

4. The following code is meant to track accuracy after each training epoch, but it throws an error. What is the error?

accuracies = []
for epoch in range(5):
    accuracy = 0.8 + epoch * 0.03
    accuracies.append(accuracy)
print('Accuracies:', accuracies)

medium

A. SyntaxError due to missing colon in for loop

B. No error; code runs correctly

C. TypeError because accuracy is not a number

D. IndexError from accessing out-of-range list element

Solution

1. Step 1: Review the code syntax and logic

   The for loop has a colon, accuracy is calculated as a float, and appended to the list.

2. Step 2: Check for runtime errors

   No invalid operations or out-of-range accesses occur.

3. Final Answer:

   No error; code runs correctly -> Option B

4. Quick Check:

   Code syntax and logic correct = No error; code runs correctly [OK]

Hint: Check for syntax and type errors carefully [OK]

Common Mistakes:

• Assuming missing colon when it is present
• Confusing variable types
• Expecting index errors without list access

5. You want to create a report that shows both training loss and accuracy after each epoch in a clear table format. Which approach best helps you track and report this progress effectively?

hard

A. Store losses and accuracies in separate lists and print them after training

B. Print loss and accuracy inside the training loop without storing values

C. Only track loss since accuracy is less important

D. Use a dictionary to store epoch as key and a tuple of (loss, accuracy) as value, then print a formatted table after training

Solution

1. Step 1: Understand the need for clear reporting

   Clear reports require organized data storage and formatted output.

2. Step 2: Evaluate each option

   Store losses and accuracies in separate lists and print them after training stores separately but may be harder to align epochs. Print loss and accuracy inside the training loop without storing values prints without storing, losing history. Use a dictionary to store epoch as key and a tuple of (loss, accuracy) as value, then print a formatted table after training uses a dictionary to link epochs with both metrics, enabling clear table printing. Only track loss since accuracy is less important ignores accuracy, which is important.

3. Final Answer:

   Use a dictionary to store epoch as key and a tuple of (loss, accuracy) as value, then print a formatted table after training -> Option D

4. Quick Check:

   Organized storage + formatted report = Use a dictionary to store epoch as key and a tuple of (loss, accuracy) as value, then print a formatted table after training [OK]

Hint: Use dictionary with epoch keys for clear progress reports [OK]

Common Mistakes:

• Not storing metrics together per epoch
• Printing inside loop without history
• Ignoring accuracy tracking