如何将带类别标签的3维数组输入神经网络构建分类模型

第一步：数据预处理 #

• 拆分特征与标签：遍历原始3维数据集，将每个样本的第一个元素（16个浮点数组成的数组）提取为特征集合X，第二个元素（类别标识）提取为标签集合y。处理完成后X的形状为(总样本量, 16)，y的形状为(总样本量,)。
• 标签编码：若你的类别不是从0开始的连续整数，可通过标签编码统一格式，示例代码：

from sklearn.preprocessing import LabelEncoder
y = LabelEncoder().fit_transform(y)

• 数据集拆分：按比例划分为训练集、测试集（可选加入验证集），建议使用分层拆分保证类别分布一致：

from sklearn.model_selection import train_test_split
# 按8:2拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

• 特征标准化（可选）：若16个特征数值分布差异较大，可做标准化提升模型收敛速度：

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

第二步：模型构建与训练 #

轻量方案：传统机器学习分类器 #

如果数据量不大，不需要深度学习也能完成分类，比如随机森林：

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print(f"测试集准确率：{accuracy_score(y_test, y_pred):.2f}")

深度学习方案：全连接神经网络（PyTorch示例） #

如果数据量较大，或者需要更高的精度，可以搭简单的全连接网络：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader

# 数组转PyTorch张量
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.long)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.long)

# 构建数据加载器
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 定义分类模型
class Classifier(nn.Module):
    def __init__(self, input_dim=16, num_classes=替换为你的实际类别数量):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(32, num_classes)
        )
    
    def forward(self, x):
        return self.net(x)

model = Classifier()
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环
epochs = 50
for epoch in range(epochs):
    model.train()
    train_loss = 0.0
    for features, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(features)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item() * features.size(0)
    
    # 每个轮次结束后评估测试集效果
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for features, labels in test_loader:
            outputs = model(features)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    print(f"轮次{epoch+1}/{epochs}, 训练损失: {train_loss/len(train_loader.dataset):.4f}, 测试准确率: {100 * correct / total:.2f}%")

可选优化方向 #

• 如果16个特征存在固定的空间/时序关联，可将特征reshape为(总样本量, 4, 4)的二维张量，使用轻量CNN训练可能获得更好效果
• 若存在类别不平衡问题，可在损失函数中加入类别权重，或对训练集做重采样处理
• 可以通过调整网络层数、神经元数量、 dropout比例、学习率等超参数优化模型效果

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