请帮我写一个使用小波包分解+卷积神经网络完成四分类任务的代码，我现在数据集已经准备好了，为二维数组（5600,1000），以及一个一维数组标签（5600），请写出一个设计合理的小波包分解+CNN的代码

好的，以下是一个简单的小波包分解+CNN的代码实现，使用Pytorch框架：

import numpy as np
import torch
import torch.nn as nn
import pywt

# 数据预处理
data = np.load('data.npy')  # 二维数组（5600,1000）
labels = np.load('labels.npy')  # 一维数组标签（5600）
data = torch.from_numpy(data).float()
labels = torch.from_numpy(labels).long()

# 定义小波包分解函数
def wavelet_packet_decomposition(data, level):
    wp = pywt.WaveletPacket(data=data, wavelet='db2', mode='symmetric', maxlevel=level)
    nodes = [node.path for node in wp.get_level(level, 'freq') if node.path not in wp.get_level(level+1)]
    return np.array([wp[node].data for node in nodes])

# 小波包分解
data_wavelet = wavelet_packet_decomposition(data, level=3)

# 数据划分
train_data = data_wavelet[:4000]
train_labels = labels[:4000]
test_data = data_wavelet[4000:]
test_labels = labels[4000:]

# 定义卷积神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv1d(8, 16, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm1d(16)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool1d(kernel_size=2)
        self.conv2 = nn.Conv1d(16, 32, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm1d(32)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool1d(kernel_size=2)
        self.fc1 = nn.Linear(32*125, 64)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(64, 4)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.pool2(x)
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        x = self.relu3(x)
        x = self.fc2(x)
        return x

# 训练模型
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(20):
    running_loss = 0.0
    for i in range(len(train_data)):
        inputs = train_data[i]
        labels = train_labels[i]
        inputs = torch.from_numpy(inputs).unsqueeze(0).float()
        labels = torch.tensor([labels])
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print('epoch %d loss: %.3f' % (epoch+1, running_loss/len(train_data)))

# 测试模型
correct = 0
total = 0
with torch.no_grad():
    for i in range(len(test_data)):
        inputs = test_data[i]
        labels = test_labels[i]
        inputs = torch.from_numpy(inputs).unsqueeze(0).float()
        labels = torch.tensor([labels])
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += 1
        correct += (predicted == labels).sum().item()
print('Accuracy: %.2f %%' % (100 * correct / total))

其中，`wavelet_packet_decomposition`函数用于对数据进行小波包分解，`Net`类定义了一个简单的卷积神经网络，包含两个卷积层、两个池化层和两个全连接层。

训练过程中，将每个小波包系数序列作为输入，将标签作为输出，使用交叉熵损失函数和Adam优化器进行训练。最后，使用测试集对模型进行评估，计算分类准确率。