处理不同形状批次的损失计算：加权平均方法（形状.加权平均.损失.计算.方法...）

引言

正如摘要所述，当处理形状不规则的批次数据时，损失计算需要特别处理。简单地平均每个样本的损失可能会导致偏差，因为较小的批次会与较大的批次产生相同的影响。为了解决这个问题，我们可以使用加权平均，根据每个批次的大小来调整其对整体损失的贡献。

问题描述

在训练过程中，如果每个批次的样本具有不同的长度或形状，则直接堆叠每个样本的损失并计算平均值可能会导致问题。例如，在序列数据处理中，每个序列的长度可能不同，因此每个批次中有效数据的数量也不同。以下代码展示了这个问题：

def training():
    model.train()

    train_mae = []

    progress = tqdm(train_dataloader, desc='Training')
    for batch_index, batch in enumerate(progress):
        x = batch['x'].to(device)
        x_lengths = batch['x_lengths'].to(device)
        y = batch['y'].to(device)
        y_type = batch['y_type'].to(device)
        y_valid_indices = batch['y_valid_indices'].to(device)

        # Zero Gradients
        optimizer.zero_grad()

        # Forward pass
        y_first, y_second = model(x)

        losses = []

        for j in range(len(x_lengths)):
            x_length = x_lengths[j].item()

            if y_type[j].item() == 0:
                predicted = y_first[j]
            else:
                predicted = y_second[j]

            actual = y[j]

            valid_mask = torch.zeros_like(predicted, dtype=torch.bool)
            valid_mask[:x_length] = 1

            # Padding of -1 is removed from y
            indices_mask = y[j].ne(-1)
            valid_indices = y[j][indices_mask]

            valid_predicted = predicted[valid_mask]
            valid_actual = actual[valid_mask]

            loss = mae_fn(valid_predicted, valid_actual, valid_indices)

            losses.append(loss)

        # Backward pass and update
        loss = torch.stack(losses).mean()   # This fails due to different shapes
        loss.backward()

        optimizer.step()

        train_mae.append(loss.detach().cpu().numpy())

        progress.set_description(
            f"mae: {loss.detach().cpu().numpy():.4f}"
        )

    # Return the average MAEs for y type
    return (
        np.mean(train_mae)
    )

在上述代码中，loss = torch.stack(losses).mean() 这一行会因为 losses 列表中的张量形状不同而失败。

解决方案：加权平均

为了解决这个问题，我们可以计算每个批次的平均损失，然后根据批次大小对这些平均损失进行加权平均。这样，较大的批次将对最终损失产生更大的影响，从而更准确地反映模型的性能。

以下是一个示例代码：

PIA

全面的AI聚合平台，一站式访问所有顶级AI模型

226 查看详情

import torch

# 示例数据
losses_perbatch = [torch.randn(8, 1), torch.randn(4, 1), torch.randn(2, 1)]

# 加权平均
total_samples = sum([len(batch) for batch in losses_perbatch])
weighted_mean_perbatch = torch.tensor([batch.sum() for batch in losses_perbatch]) / total_samples

# 或者等价于:
# weighted_mean_perbatch = torch.tensor([batch.mean() * len(batch) for batch in losses_perbatch]) / total_samples

final_weighted_loss = sum(weighted_mean_perbatch)

print(f"Final Weighted Loss: {final_weighted_loss}")

在这个例子中，losses_perbatch 包含不同大小的批次的损失。我们首先计算所有批次的总样本数 total_samples。然后，对于每个批次，我们计算其损失的总和，并将其除以 total_samples，得到加权平均损失。最后，我们将所有批次的加权平均损失相加，得到最终的加权损失。

代码集成

将加权平均方法集成到原始的训练函数中，可以修改如下：

def training():
    model.train()

    train_mae = []

    progress = tqdm(train_dataloader, desc='Training')
    for batch_index, batch in enumerate(progress):
        x = batch['x'].to(device)
        x_lengths = batch['x_lengths'].to(device)
        y = batch['y'].to(device)
        y_type = batch['y_type'].to(device)
        y_valid_indices = batch['y_valid_indices'].to(device)

        # Zero Gradients
        optimizer.zero_grad()

        # Forward pass
        y_first, y_second = model(x)

        losses = []
        batch_sizes = []  # Store the size of each batch

        for j in range(len(x_lengths)):
            x_length = x_lengths[j].item()

            if y_type[j].item() == 0:
                predicted = y_first[j]
            else:
                predicted = y_second[j]

            actual = y[j]

            valid_mask = torch.zeros_like(predicted, dtype=torch.bool)
            valid_mask[:x_length] = 1

            # Padding of -1 is removed from y
            indices_mask = y[j].ne(-1)
            valid_indices = y[j][indices_mask]

            valid_predicted = predicted[valid_mask]
            valid_actual = actual[valid_mask]

            loss = mae_fn(valid_predicted, valid_actual, valid_indices)

            losses.append(loss)
            batch_sizes.append(x_length)  # Store the batch size

        # Calculate weighted loss
        total_samples = sum(batch_sizes)
        weighted_mean_perbatch = torch.tensor([loss.sum() for loss in losses]) / total_samples
        loss = sum(weighted_mean_perbatch)

        # Backward pass and update
        loss.backward()

        optimizer.step()

        train_mae.append(loss.detach().cpu().numpy())

        progress.set_description(
            f"mae: {loss.detach().cpu().numpy():.4f}"
        )

    # Return the average MAEs for y type
    return (
        np.mean(train_mae)
    )

在这个修改后的代码中，我们添加了一个 batch_sizes 列表来存储每个批次的大小。然后，我们使用这些大小来计算加权平均损失，并将其用于反向传播和优化。

注意事项

• 确保 batch_sizes 列表中的大小与 losses 列表中的损失对应。
• 加权平均方法可以更稳定地计算损失，但可能需要更多的计算资源。
• 这种方法特别适用于处理序列数据或其他具有不同形状的批次数据。

总结

当处理不同形状的批次数据时，加权平均是一种有效的损失计算方法。通过考虑每个批次的大小，我们可以更准确地评估模型的性能，并避免简单平均可能导致的偏差。这种方法可以应用于各种机器学习任务，特别是那些涉及序列数据或其他形状不规则的数据的任务。

以上就是处理不同形状批次的损失计算：加权平均方法的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： app ai red 堆 大家都在看： 在social-auth-app-django中通过自定义字段实现社交账户关联 如何监控 App 推送通知？ 如何有效监控同行App的推送通知？ python爬虫怎么爬app python爬虫app怎么用