基于pytorch代价敏感平衡ICIIDS-2017数据集并用cnn训练的代码

下面是基于PyTorch实现代价敏感平衡ICIIDS-2017数据集并用CNN训练的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from sklearn.utils import class_weight
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, datasets

# 定义数据集类
class IciidsDataset(Dataset):
    def __init__(self, data, target):
        self.data = data
        self.target = target
        self.transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
        ])

    def __getitem__(self, index):
        x = self.data[index]
        y = self.target[index]
        x = self.transform(x)
        return x, y

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

# 加载数据集
train_data = np.load('train_data.npy')
train_target = np.load('train_target.npy')
test_data = np.load('test_data.npy')
test_target = np.load('test_target.npy')

# 计算不同类别的权重
class_weights = class_weight.compute_class_weight('balanced', np.unique(train_target), train_target)

# 创建数据集对象
train_dataset = IciidsDataset(train_data, train_target)
test_dataset = IciidsDataset(test_data, test_target)

# 创建数据加载器对象
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=True)

# 定义CNN模型
class IciidsCNN(nn.Module):
    def __init__(self):
        super(IciidsCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(64 * 8 * 8, 128)
        self.fc2 = nn.Linear(128, 2)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型对象
model = IciidsCNN()

# 定义优化器和代价函数
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss(weight=torch.tensor(class_weights, dtype=torch.float32))

# 训练模型
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        inputs, labels = data
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the test images: %d %%' % (100 * correct / total))

在代码中，我们首先定义了一个ICIIDS数据集类，并在其中对数据进行了预处理（归一化等）。然后，我们加载了数据集，并使用sklearn库中的class_weight.compute_class_weight函数计算不同类别的权重。接着，我们创建了数据集对象和数据加载器对象，并定义了CNN模型、优化器和代价函数。最后，我们使用训练集训练模型，并使用测试集测试模型的性能。在训练和测试过程中，我们传入了class_weights参数，以考虑不同类别的代价。