输入是长度为N的时间序列，输出对应N个标签，五分类问题，TCN训练和测试代码实例

下面是一个简单的TCN训练和测试代码实例，假设您已经准备好了时间序列数据和标签数据：

import torch
import torch.nn as nn
import torch.optim as optim

class TCN(nn.Module):
    def __init__(self, input_size, output_size, num_channels, kernel_size=2, dropout=0.2):
        super(TCN, self).__init__()
        self.input_size = input_size
        self.output_size = output_size
        self.num_channels = num_channels
        self.kernel_size = kernel_size
        self.dropout = nn.Dropout(dropout)
        self.conv_layers = nn.ModuleList()
        self.conv_layers.append(nn.Conv1d(in_channels=input_size, out_channels=num_channels, kernel_size=kernel_size))
        for i in range(1, len(num_channels)):
            self.conv_layers.append(nn.Conv1d(in_channels=num_channels[i-1], out_channels=num_channels[i], kernel_size=kernel_size))
        self.linear = nn.Linear(num_channels[-1], output_size)
        
    def forward(self, x):
        for i in range(len(self.conv_layers)):
            x = self.dropout(torch.relu(self.conv_layers[i](x)))
        x = x.permute(0, 2, 1)
        x = self.linear(x)
        return x
        
# 准备数据
# X是一个形状为(N, input_size, L)的张量，N是样本数，L是序列长度
# Y是一个形状为(N, L)的张量，每个元素表示对应时间步的标签
X = ...
Y = ...

# 划分训练集和测试集
train_X, train_Y = X[:800], Y[:800]
test_X, test_Y = X[800:], Y[800:]

# 定义模型和优化器
model = TCN(input_size=X.shape[1], output_size=5, num_channels=[32, 64, 128], kernel_size=3, dropout=0.2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(100):
    running_loss = 0.0
    for i in range(len(train_X)):
        optimizer.zero_grad()
        output = model(train_X[i].unsqueeze(0))
        loss = criterion(output.squeeze(0), train_Y[i])
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}: loss={running_loss/len(train_X)}")

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for i in range(len(test_X)):
        output = model(test_X[i].unsqueeze(0))
        _, predicted = torch.max(output.squeeze(0), dim=1)
        correct += (predicted == test_Y[i]).sum().item()
        total += test_Y[i].shape[0]
    print(f"Accuracy: {correct/total}")

在上面的代码中，我们首先定义了一个TCN模型，其中包括多个卷积层和一个全连接层。在训练时，我们使用交叉熵损失函数和Adam优化器来训练模型。在测试时，我们使用模型对测试集进行预测，并计算模型的准确率。