PointNet++语义分割：类别数变更后的标签处理与断言错误排查

/opt/conda/conda-bld/pytorch_1614378098133/work/aten/src/THCUNN/ClassNLLCriterion.cu:108: cunn_ClassNLLCriterion_updateOutput_kernel: block: [0,0,0], thread: [10,0,0] Assertion `t >= 0 && t < n_classes` failed.
...
RuntimeError: CUDA error: device-side assert triggered

import numpy as np
from collections import Counter

# 假设你有一个函数来加载数据集的标签
def load_all_labels_from_dataset(dataset_path):
    all_labels = []
    # 模拟从数据集中加载标签
    # 实际操作中，你需要根据你的数据集结构遍历所有样本并提取标签
    # 例如：
    # for data_sample in dataset:
    #     all_labels.extend(data_sample['segmentation_labels'].flatten().tolist())

    # 示例：假设原始标签可能是非连续的，或包含超出新范围的值
    all_labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 18, 20, 22, 12, 0, 15] 
    return all_labels

raw_labels = load_all_labels_from_dataset("your_dataset_path")
unique_raw_labels = sorted(list(set(raw_labels)))
print(f"原始唯一标签: {unique_raw_labels}")
print(f"原始标签分布: {Counter(raw_labels)}")

# 假设新的类别数量
new_num_classes = 17 

# 确保所有原始标签都能被映射
# 假设我们有17个新的类别，并且知道它们对应的原始标签ID
# 这个映射需要根据你的具体数据集和类别定义来手动创建
# 示例：将原始标签 [0,1,2,..,12, 15,18,20,22] 映射到 [0,1,2,...,16]
# 注意：你需要确保原始标签的数量和你想映射到的新类别数量是匹配的
# 如果原始标签数量多于新类别，你需要决定如何合并或丢弃
# 如果原始标签数量少于新类别，你需要确认是否有未被使用的类别
original_to_new_label_map = {
    0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 
    10: 10, 11: 11, 12: 12, # 假设这些是旧的13个类别
    15: 13, # 原始标签15映射到新标签13
    18: 14, # 原始标签18映射到新标签14
    20: 15, # 原始标签20映射到新标签15
    22: 16  # 原始标签22映射到新标签16
}

# 验证映射的有效性
if len(original_to_new_label_map) != new_num_classes:
    print(f"警告：映射字典的键值对数量 ({len(original_to_new_label_map)}) 与新的类别数 ({new_num_classes}) 不匹配。")
if min(original_to_new_label_map.values()) != 0 or max(original_to_new_label_map.values()) != new_num_classes - 1:
    print(f"警告：映射后的标签范围不是 [0, {new_num_classes - 1}]。")

print(f"标签映射关系: {original_to_new_label_map}")

import torch

class CustomSemSegDataset(torch.utils.data.Dataset):
    def __init__(self, data_path, original_to_new_label_map, new_num_classes):
        self.data_path = data_path
        self.label_map = original_to_new_label_map
        self.new_num_classes = new_num_classes
        # 假设这里加载了所有数据路径或索引
        self.data_items = self._load_data_items()

    def _load_data_items(self):
        # 实际加载数据项的逻辑
        # 例如，读取一个文件列表
        return [f"sample_{i}.pts" for i in range(100)]

    def __len__(self):
        return len(self.data_items)

    def __getitem__(self, idx):
        # 模拟加载点云数据和原始标签
        # 实际中，这里会从文件读取
        points = torch.randn(1024, 3) # 示例点云数据
        # 模拟加载的原始标签，可能包含未映射的值
        raw_labels = torch.randint(low=0, high=25, size=(1024,), dtype=torch.long) 

        # 为了演示，确保raw_labels中包含一些需要映射的值
        raw_labels[0] = 15 
        raw_labels[1] = 18
        raw_labels[2] = 20
        raw_labels[3] = 22
        raw_labels[4] = 13 # 模拟一个超出旧范围但未在映射中的标签

        # 应用标签映射
        mapped_labels = torch.full_like(raw_labels, -1) # 初始化为-1，用于检测未映射标签
        for old_label, new_label in self.label_map.items():
            mapped_labels[raw_labels == old_label] = new_label

        # 检查是否有未映射的标签
        if (mapped_labels == -1).any():
            unmapped_indices = (mapped_labels == -1).nonzero(as_tuple=True)[0]
            unmapped_raw_values = raw_labels[unmapped_indices].unique().tolist()
            raise ValueError(f"发现未映射的原始标签值: {unmapped_raw_values}。请检查标签映射字典。")

        # 确保映射后的标签在正确范围内
        if mapped_labels.min() < 0 or mapped_labels.max() >= self.new_num_classes:
            raise ValueError(f"映射后的标签超出预期范围 [0, {self.new_num_classes - 1}]。Min: {mapped_labels.min()}, Max: {mapped_labels.max()}")

        return points, mapped_labels

# 实例化数据集
dataset = CustomSemSegDataset(
    data_path="your_dataset_path", 
    original_to_new_label_map=original_to_new_label_map,
    new_num_classes=new_num_classes
)

# 使用DataLoader加载数据
dataloader = torch.utils.data.DataLoader(dataset, batch_size=4, shuffle=True)

# 验证数据加载
for i, (points, labels) in enumerate(dataloader):
    print(f"Batch {i}: Labels min={labels.min().item()}, max={labels.max().item()}, unique={labels.unique().tolist()}")
    if i > 2: # 只看前几个批次
        break

# 在训练循环中，每次迭代时验证
for epoch in range(num_epochs):
    for batch_idx, (points, target_labels) in enumerate(dataloader):
        # 确保target_labels是long类型，这是交叉熵损失函数的要求
        target_labels = target_labels.long().cuda() 

        # 关键验证点：在传入损失函数之前
        assert target_labels.min() >= 0, f"标签最小值 {target_labels.min().item()} 小于0"
        assert target_labels.max() < new_num_classes, f"标签最大值 {target_labels.max().item()} 大于等于 {new_num_classes}"

        # ... 模型前向传播和损失计算 ...
        # loss = criterion(seg_pred, target_labels, trans_feat, weights)