transformer 一维心电信号 时间序列分类 代码

以下是一个使用PyTorch实现基于Transformer进行一维心电信号时间序列分类的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 定义Transformer模型
class TransformerModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_heads, dropout):
        super(TransformerModel, self).__init__()
        self.pos_encoder = PositionalEncoding(hidden_size, dropout)
        self.transformer_encoder = nn.TransformerEncoder(nn.TransformerEncoderLayer(hidden_size, num_heads, hidden_size, dropout), num_layers)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, src):
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src)
        output = output.mean(dim=1) # 对序列维度求平均
        output = self.fc(output)
        return output

# 定义位置编码层
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

# 加载数据
data = np.load('data.npy') # 数据格式为 (num_samples, seq_len, input_size)
labels = np.load('labels.npy') # 标签格式为 (num_samples,)

# 划分训练集和测试集
train_data = data[:800] 
train_labels = labels[:800]
test_data = data[800:]
test_labels = labels[800:]

# 转换为PyTorch的Tensor格式
train_data = torch.from_numpy(train_data).float()
train_labels = torch.from_numpy(train_labels).long()
test_data = torch.from_numpy(test_data).float()
test_labels = torch.from_numpy(test_labels).long()

# 定义模型参数
input_size = 1 # 输入特征维度
output_size = 5 # 输出类别数
hidden_size = 64 # 模型隐藏层维度
num_layers = 4 # 模型层数
num_heads = 8 # 注意力头数
dropout = 0.1 # Dropout概率

# 定义模型、损失函数和优化器
model = TransformerModel(input_size, hidden_size, num_layers, num_heads, dropout)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
batch_size = 32
for epoch in range(num_epochs):
    for i in range(0, len(train_data), batch_size):
        batch_data = train_data[i:i+batch_size]
        batch_labels = train_labels[i:i+batch_size]
        optimizer.zero_grad()
        outputs = model(batch_data)
        loss = criterion(outputs, batch_labels)
        loss.backward()
        optimizer.step()
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for i in range(0, len(test_data), batch_size):
        batch_data = test_data[i:i+batch_size]
        batch_labels = test_labels[i:i+batch_size]
        outputs = model(batch_data)
        _, predicted = torch.max(outputs.data, 1)
        total += batch_labels.size(0)
        correct += (predicted == batch_labels).sum().item()
    print('Test Accuracy: {:.2f}%'.format(100 * correct / total))

以上代码中，使用了PyTorch实现了一个基于Transformer的模型，并使用交叉熵损失函数和Adam优化器进行训练。在训练过程中，使用了批量梯度下降的方法进行优化，同时使用了测试集对模型进行测试和评估。