在Keras/TensorFlow中高效获取单样本损失以实现主动学习

Hey there! I totally get your frustration with evaluating samples one by one—100ms per sample adds up really fast when you're dealing with large datasets for active learning. Let's break down some way better approaches to get per-sample losses efficiently, and I'll clarify that post you mentioned too.

The Core Fix: Use Loss Functions with Reduction.NONE #

The key issue with your current approach is that model.evaluate() is overkill for just getting per-sample losses—it handles metrics, batch averaging, and other overhead that you don't need here. Instead, we can directly compute losses for batches of samples by modifying how the loss function reduces its output.

By default, Keras loss functions return the average loss per batch. If you set reduction=tf.keras.losses.Reduction.NONE, the loss function will return a tensor with one loss value per sample in the batch. This lets us compute losses for entire batches at once, which is way faster than processing samples individually.

Example Implementation #

Here's a straightforward way to compute per-sample losses for your dataset:

import tensorflow as tf
import numpy as np

# Define your loss function with no reduction (returns per-sample values)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(reduction=tf.keras.losses.Reduction.NONE)
# Adjust the loss type to match your task (e.g., CategoricalCrossentropy, MSE)

def get_per_sample_losses(model, x_data, y_data):
    # Run inference (no training updates)
    y_pred = model(x_data, training=False)
    # Calculate loss for each sample
    per_sample_loss = loss_fn(y_data, y_pred)
    # Convert to numpy array for easy handling in active learning logic
    return per_sample_loss.numpy()

You can call this function with entire batches or even your full dataset (if memory allows) to get all losses in one go. For example:

# Assume x_train and y_train are your full dataset arrays
all_losses = get_per_sample_losses(your_trained_model, x_train, y_train)

Handling Large Datasets (Batch Processing) #

If your dataset is too big to load all at once, use TensorFlow's tf.data.Dataset to process it in batches without overwhelming memory:

def compute_all_losses(model, dataset):
    all_losses = []
    for x_batch, y_batch in dataset:
        # Compute losses for the batch
        batch_losses = loss_fn(y_batch, model(x_batch, training=False))
        # Add batch losses to the full list
        all_losses.extend(batch_losses.numpy())
    return np.array(all_losses)

# Usage example with a tf.data.Dataset
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
all_test_losses = compute_all_losses(your_trained_model, test_dataset)

Clarifying That "Keras- Loss per sample within batch" Post #

That post you referenced was using the exact same Reduction.NONE trick! The "print logic" they showed was just demonstrating how to access the per-sample loss values instead of the batch average. The core idea is that by disabling loss reduction, you get granular loss values for every sample in the batch, which is exactly what you need for active learning (e.g., selecting samples with the highest loss).

Why This Is Way Faster #

• TensorFlow optimizes batch operations to leverage GPU/TPU acceleration, so processing 32/64/128 samples at once is exponentially faster than processing one at a time.
• You avoid the overhead of model.evaluate() which includes metric computation, progress bars, and other unnecessary steps for your use case.

内容的提问来源于stack exchange，提问作者randusr