嗨，我来帮你搞定这个多标签光谱图像分类的问题！你的现有代码核心问题在于模型输出层的激活逻辑、损失函数和多标签任务的需求不匹配，下面我一步步给你拆解解决方案，推荐适合的网络层，最后给你完整的可运行代码示例。

多标签（或你这里的多属性分类）任务的核心是每个标签是独立的判断逻辑，不像单标签分类那样要求所有输出的概率和为1。模型的关键调整集中在这两处：

init 函数调整 #

• 最后一层全连接层的输出维度要对应你的标签数量（4个），这部分你原代码已经做对了（nn.Linear(50, 4)），但后续激活逻辑需要修改。
• 如果你的每个标签是多分类任务（比如label_A有3个类别选项），需要为每个标签单独设置输出分支；如果是二分类（0/1），单个输出层就足够。从你的Dataset代码来看，我们先按「4个独立二分类标签」的场景调整。

forward 函数调整 #

• 移除最后的F.log_softmax(x,dim=1)：这是单标签多分类的激活方式，会强制输出和为1，完全不符合多标签独立判断的需求。
• 改为直接返回logits（配合BCEWithLogitsLoss使用，能避免数值不稳定问题），或者用F.sigmoid(x)输出每个标签的概率。
• 特征提取部分可以保留，但要确保池化后的特征展平维度和全连接层输入匹配（比如你原代码的2112，我已经验证过计算是正确的）。

• 卷积层：继续用nn.Conv2d即可，光谱图像的空间特征用普通2D卷积就能有效提取；如果你的光谱有明确的频率/时间维度区分，也可以尝试nn.Conv1d分别处理，但2D卷积已经能覆盖大部分场景。
• 正则化层：保留nn.Dropout2d（卷积后）和nn.Dropout（全连接后）防止过拟合；额外推荐加nn.BatchNorm2d（卷积后）和nn.BatchNorm1d（全连接后），能加速模型收敛并增强泛化能力。
• 池化层：nn.MaxPool2d更适合提取图像中的边缘、纹理等显著特征，比AvgPool2d更适配图像任务，保留原逻辑即可。
• 输出层：如果是二分类多标签，用单一层nn.Linear输出对应标签数的节点；如果是多分类多任务，需要为每个标签单独设置nn.Linear分支。
• 激活函数：卷积和全连接层用ReLU没问题，但输出层不要用softmax，要么直接返回logits，要么用sigmoid输出每个标签的独立概率。

下面是修改后的全流程代码，我标注了关键修改点，同时修正了原代码中的拼写错误和小问题：

修改后的Dataset类 #

import torch
from torch.utils.data import Dataset
import pandas as pd
from PIL import Image
import torchvision.transforms as transforms

class OurDataset(Dataset):
    spectra_dir = "./data/spectrograms_fm"
    metaData_path = "./data/FMAudio/metaData.csv"

    def __init__(self):
        self.audio_labels = pd.read_csv(self.metaData_path)
        self.transform = transforms.Compose([
            transforms.Resize((201, 81)),
            transforms.ToTensor()
        ])

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

    def __getitem__(self, idx):
        # 修正路径拼接逻辑，避免硬编码错误
        img_path = f"{self.spectra_dir}/mutiplelabels/{self.audio_labels.iloc[idx, 8]}.png"
        img = Image.open(img_path).convert("RGB")
        img = self.transform(img)
        
        # 把4个标签合并成一个tensor，方便批量处理
        # 转成float32类型，适配损失函数的输入要求
        labels = torch.tensor([
            self.audio_labels.iloc[idx, 4],
            self.audio_labels.iloc[idx, 5],
            self.audio_labels.iloc[idx, 6],
            self.audio_labels.iloc[idx, 7]
        ], dtype=torch.float32)
        
        return img, labels

修改后的CNN模型 #

import torch.nn as nn
import torch.nn.functional as F

class MultiLabelCNNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 卷积层：保留原结构，新增BatchNorm增强稳定性
        self.conv1 = nn.Conv2d(3, 32, kernel_size=5)
        self.bn1 = nn.BatchNorm2d(32)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        self.bn2 = nn.BatchNorm2d(64)
        self.conv2_drop = nn.Dropout2d(0.25)
        
        # 预计算全连接层输入维度：64*11*3=2112（和原代码一致，验证过池化后的尺寸）
        self.fc1 = nn.Linear(2112, 50)
        self.bn_fc1 = nn.BatchNorm1d(50)
        self.fc2 = nn.Linear(50, 4)  # 输出4个标签的logits

    def forward(self, x):
        # 卷积+池化+激活，加入BatchNorm优化训练
        x = F.relu(F.max_pool2d(self.bn1(self.conv1(x)), 4))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.bn2(self.conv2(x))), 4))
        x = torch.flatten(x, 1)  # 用torch.flatten替代自定义flatten层，更规范
        x = F.relu(self.bn_fc1(self.fc1(x)))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)  # 直接返回logits，配合BCEWithLogitsLoss使用
        return x

修改后的训练函数 #

def train(dataloader, model, loss_fn, optimizer, device):
    model.train()
    size = len(dataloader.dataset)
    total_loss = 0.0
    
    for batch, (img_tensors, labels) in enumerate(dataloader):
        # 数据迁移到指定设备（CPU/GPU），提升训练速度
        img_tensors, labels = img_tensors.to(device), labels.to(device)
        
        optimizer.zero_grad()
        pred_logits = model(img_tensors)
        
        # 使用BCEWithLogitsLoss：自动处理sigmoid转换和损失计算，避免数值不稳定
        loss = loss_fn(pred_logits, labels)
        
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        
        # 每10个batch打印一次训练进度
        if batch % 10 == 0:
            current_loss = loss.item()
            current = (batch + 1) * len(img_tensors)
            print(f"loss: {current_loss:>7f}  [{current:>5d}/{size:>5d}]")
    
    avg_loss = total_loss / len(dataloader)
    print(f"Train avg loss: {avg_loss:>8f}")

主函数（初始化+启动训练） #

def main():
    # 设备配置：优先使用GPU加速
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"Using {device} device")
    
    # 初始化数据集和数据加载器
    dataset = OurDataset()
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
    
    # 初始化模型、损失函数、优化器
    model = MultiLabelCNNet().to(device)
    loss_fn = nn.BCEWithLogitsLoss()  # 完美适配多标签二分类任务
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    
    # 启动训练
    epochs = 10
    for t in range(epochs):
        print(f"\nEpoch {t+1}\n-------------------------------")
        train(dataloader, model, loss_fn, optimizer, device)
    print("Training finished!")

if __name__ == "__main__":
    main()

关键修改说明 #

1. Dataset：将4个标签合并为一个tensor，简化批量处理逻辑；修正了panda拼写错误和路径拼接问题。
2. 模型：新增BatchNorm层优化训练过程；移除了不适合多标签的log_softmax激活，改用直接输出logits的方式。
3. 训练函数：使用BCEWithLogitsLoss替代原损失逻辑，适配多标签任务；新增设备迁移逻辑，支持GPU加速；优化了进度打印，方便监控训练状态。

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