PyTorch中每个样本对应多组输入的分类神经网络标准实现方法

Great question—this is a classic multi-modal/multi-view classification problem, and there are several standard, robust approaches that eliminate the messy grouping workaround you're using right now. Let's break them down:

1. Multi-Input Branch Network (The Most Common Standard) #

The core idea here is to treat each of the 4 input groups as a distinct "modal" input, and build a network with separate branches to process each one, then fuse their features to output a single classification result for the patient.

This approach completely avoids grouping issues because each training sample is a single patient's full set of 4 inputs plus their label. You can shuffle samples freely during training, and complex network components (like batch normalization, attention layers) will work as intended since they're operating on valid, independent patient-level samples.

Here's a simplified PyTorch example to illustrate:

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

class PatientClassifier(nn.Module):
    def __init__(self, input_dims=[10, 15, 8, 12], num_classes=2):
        super().__init__()
        # Create a feature extraction branch for each input group
        self.branches = nn.ModuleList()
        for dim in input_dims:
            branch = nn.Sequential(
                nn.Linear(dim, 32),
                nn.ReLU(),
                nn.Linear(32, 16)
            )
            self.branches.append(branch)
        
        # Fusion layer to combine all branch features
        self.fusion = nn.Linear(16 * 4, 64)
        # Final classification head
        self.classifier = nn.Linear(64, num_classes)

    def forward(self, x1, x2, x3, x4):
        # Extract features from each input group
        features = []
        for branch, x in zip(self.branches, [x1, x2, x3, x4]):
            features.append(branch(x))
        
        # Concatenate features and pass through fusion/classification layers
        fused = torch.cat(features, dim=1)
        fused = F.relu(self.fusion(fused))
        return self.classifier(fused)

When training, your dataset will return samples like (x1, x2, x3, x4, patient_label)—no grouping required, no order dependency.

2. Attention-Based Feature Fusion (For Prioritizing Important Inputs) #

If some of the 4 input groups are more predictive than others (or their importance varies per patient), you can add an attention mechanism to the branch network. This lets the model automatically learn how much weight to assign each input group's features.

Modify the forward pass from the example above to include attention:

def forward(self, x1, x2, x3, x4):
    features = []
    for branch, x in zip(self.branches, [x1, x2, x3, x4]):
        features.append(branch(x))
    
    # Stack features to apply attention
    stacked_feats = torch.stack(features, dim=1)  # Shape: (batch_size, 4, 16)
    
    # Learn attention weights for each input group
    attn_weights = nn.Sequential(
        nn.Linear(16, 8),
        nn.ReLU(),
        nn.Linear(8, 1)
    )(stacked_feats)
    attn_weights = F.softmax(attn_weights, dim=1)  # Normalize weights to sum to 1
    
    # Weighted sum of features
    fused = torch.sum(stacked_feats * attn_weights, dim=1)
    fused = F.relu(self.fusion(fused))
    return self.classifier(fused)

This is especially useful if your 4 input groups have varying predictive power—no manual tuning needed, the model figures it out.

3. Shared Feature Extractor (For Homogeneous Input Groups) #

If all 4 input groups are structurally similar (e.g., all are time-series from different sensors), you can use a single shared feature extractor instead of separate branches. This reduces model parameters and helps prevent overfitting:

class SharedBranchClassifier(nn.Module):
    def __init__(self, input_dim=10, num_classes=2):
        super().__init__()
        # Shared feature extractor for all 4 input groups
        self.shared_branch = nn.Sequential(
            nn.Linear(input_dim, 32),
            nn.ReLU(),
            nn.Linear(32, 16)
        )
        
        self.fusion = nn.Linear(16 * 4, 64)
        self.classifier = nn.Linear(64, num_classes)

    def forward(self, x1, x2, x3, x4):
        feat1 = self.shared_branch(x1)
        feat2 = self.shared_branch(x2)
        feat3 = self.shared_branch(x3)
        feat4 = self.shared_branch(x4)
        
        fused = torch.cat([feat1, feat2, feat3, feat4], dim=1)
        fused = F.relu(self.fusion(fused))
        return self.classifier(fused)

Why Your Current Grouping Method Is Risky #

The grouping approach you're using breaks the independence of patient samples—when you shuffle data, the groups get split, and complex network layers that rely on batch-level statistics (like batch norm) will compute incorrect stats, leading to poor generalization. The methods above fix this by keeping each patient's data as a single, self-contained sample.

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