时间序列对比学习实战：autotcl参数化增强技术入门指南

1次阅读

共计 3554 个字符，预计需要花费 9 分钟才能阅读完成。

时间序列数据在金融、物联网等领域无处不在，比如股票价格、传感器读数、医疗监测数据等。这类数据的特点是具有时间依赖性，前后数据点之间存在复杂的动态关系。传统的对比学习方法在处理时间序列时往往表现不佳，因为它们通常假设数据是独立同分布的，而忽略了时间序列中的时间依赖性。

对比学习的核心思想是通过对比正样本和负样本来学习数据的表示。在时间序列中，正样本通常是对原始序列进行某种变换得到的，负样本则是其他序列或同一序列的不同部分。然而，传统的对比学习方法使用的变换（如随机裁剪、加噪声等）往往是固定的，无法充分捕捉时间序列的动态特性。

autotcl（Auto Time-series Contrastive Learning）是一种参数化增强技术，它通过学习数据驱动的变换来增强时间序列的表示能力。其核心思想是使用可学习的参数化变换来生成正样本，而不是依赖固定的启发式方法。

具体来说，autotcl 通过一个神经网络（称为变换网络）来学习如何对时间序列进行变换。这个变换网络的参数在训练过程中与其他模型参数一起优化，从而能够自适应地生成最适合当前任务的变换。数学上，可以表示为：

x' = f_θ(x)

其中，x 是原始时间序列，f_θ 是参数为 θ 的变换网络，x’ 是变换后的正样本。

autotcl 的整体架构包括以下几个部分：

编码器网络：将原始时间序列映射到低维表示空间。
变换网络：生成正样本的变换。
投影头：将编码后的表示映射到对比学习空间。

编码器和变换网络通常使用类似的结构，比如多层感知机（MLP）或卷积神经网络（CNN），具体选择取决于时间序列的特性。

编码器隐藏层维度：决定编码器的表示能力。
变换网络隐藏层维度：影响变换的复杂度。
温度参数 τ：控制对比损失的敏感度。
学习率：影响优化过程的稳定性。

autotcl 的训练流程如下：

从数据集中采样一个批次的时间序列。
对每个序列，使用变换网络生成正样本。
将原始序列和正样本分别输入编码器，得到它们的表示。
通过投影头映射到对比学习空间。
计算对比损失并更新所有网络参数。

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

# 定义编码器网络
class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(Encoder, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()

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

# 定义变换网络
class TransformNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(TransformNetwork, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, input_dim)
        self.relu = nn.ReLU()

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

# 定义投影头
class ProjectionHead(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(ProjectionHead, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()

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

# 定义 autotcl 模型
class AutoTCL(nn.Module):
    def __init__(self, input_dim, encoder_hidden, encoder_out, transform_hidden, proj_hidden, proj_out):
        super(AutoTCL, self).__init__()
        self.encoder = Encoder(input_dim, encoder_hidden, encoder_out)
        self.transform = TransformNetwork(input_dim, transform_hidden)
        self.projection = ProjectionHead(encoder_out, proj_hidden, proj_out)

    def forward(self, x):
        x_prime = self.transform(x)
        h = self.encoder(x)
        h_prime = self.encoder(x_prime)
        z = self.projection(h)
        z_prime = self.projection(h_prime)
        return z, z_prime

# 定义对比损失
def contrastive_loss(z, z_prime, temperature=0.1):
    batch_size = z.size(0)
    z = nn.functional.normalize(z, dim=1)
    z_prime = nn.functional.normalize(z_prime, dim=1)
    logits = torch.mm(z, z_prime.t()) / temperature
    labels = torch.arange(batch_size).to(z.device)
    loss = nn.CrossEntropyLoss()(logits, labels)
    return loss

# 训练循环
def train(model, dataloader, epochs, lr):
    optimizer = optim.Adam(model.parameters(), lr=lr)
    for epoch in range(epochs):
        total_loss = 0
        for batch in dataloader:
            optimizer.zero_grad()
            z, z_prime = model(batch)
            loss = contrastive_loss(z, z_prime)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
        print(f'Epoch {epoch+1}, Loss: {total_loss/len(dataloader)}')

autotcl 的主要计算开销来自编码器和变换网络的前向传播。假设编码器和变换网络都有 L 层，每层的隐藏单元数为 H，那么每个样本的计算复杂度大致为 O(LH^2)。

为了减少内存占用，可以考虑以下策略：