PyTorch是一种面向深度学习的深度学习框架，可用于许多不同的机器学习任务，包括端到端分类。以下是一个端到端分类任务的示例代码，其中包括1000个样本，每个样本都有形状为(1, 2000)的输入序列和形状为(1, 2000)的标签序列，标签从0到4进行五分类。

好的，以下是一个简单的PyTorch示例代码，用于进行端到端分类任务：

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

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(2000, 100)
        self.fc2 = nn.Linear(100, 5)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 定义数据集
class MyDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

    def __getitem__(self, index):
        x = torch.tensor(self.data[index], dtype=torch.float32)
        y = torch.tensor(self.targets[index], dtype=torch.long)
        return x, y

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

# 定义超参数
batch_size = 32
learning_rate = 0.01
num_epochs = 10

# 加载数据集
data = torch.randn(1000, 1, 2000)
targets = torch.randint(0, 5, (1000, 1, 2000))
dataset = MyDataset(data, targets)
loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 定义模型和优化器
model = Net()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for batch_idx, (data, target) in enumerate(loader):
        optimizer.zero_grad()
        output = model(data.squeeze())
        loss = nn.functional.cross_entropy(output.permute(0, 2, 1), target.squeeze())
        loss.backward()
        optimizer.step()
        if batch_idx % 10 == 0:
            print('Epoch [{}/{}], Batch [{}/{}], Loss: {:.4f}'.format(
                epoch+1, num_epochs, batch_idx+1, len(loader), loss.item()))

该代码中定义了一个名为`Net`的简单神经网络模型，包括两个全连接层。然后定义了一个名为`MyDataset`的数据集类，用于将输入序列和标签序列封装成PyTorch数据集对象。接着定义了一些超参数，包括批量大小、学习率和训练轮数。然后使用PyTorch的`DataLoader`将数据集加载到内存中，并使用Adam优化器进行模型优化，使用交叉熵损失函数计算损失。最后，在训练过程中打印训练损失。