pytorch迁移学习时序预测代码

### 使用PyTorch进行时序预测的迁移学习

在时间序列预测领域，迁移学习能够有效提升模型性能，尤其是在目标域数据有限的情况下。通过利用源域的知识，可以在减少新数据需求的同时提高泛化能力。

下面是一个简单的例子，展示如何使用PyTorch实现基于LSTM的时间序列预测迁移学习：

import torch
from torch import nn, optim
from sklearn.preprocessing import MinMaxScaler
import numpy as np


class LSTMModel(nn.Module):
    def __init__(self, input_dim=1, hidden_dim=50, output_dim=1, layers=2):
        super(LSTMModel, self).__init__()
        self.hidden_dim = hidden_dim
        self.lstm = nn.LSTM(input_dim, hidden_dim, layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        h0 = torch.zeros(2, x.size(0), self.hidden_dim).to(x.device)
        c0 = torch.zeros(2, x.size(0), self.hidden_dim).to(x.device)
        out, _ = self.lstm(x, (h0.detach(), c0.detach()))
        out = self.fc(out[:, -1, :])
        return out


def prepare_data(data, seq_length=10):
    scaler = MinMaxScaler(feature_range=(-1, 1))
    data_normalized = scaler.fit_transform(data.reshape(-seq_length-1):
        X.append(data_normalized[i:(i+seq_length), 0])
        y.append(data_normalized[(i+seq_length), 0])

    X = np.array(X)
    y = np.array(y)

    return torch.tensor(X, dtype=torch.float32).unsqueeze(2), \
           torch.tensor(y, dtype=torch.float32)


# 假设source_data和target_data已经准备好
source_X_train, source_y_train = prepare_data(source_data)  # 来自源域的数据
target_X_train, target_y_train = prepare_data(target_data)  # 来自目标域的数据

model = LSTMModel()

# 首先，在源域上训练模型
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters())

for epoch in range(epochs_source):
    model.train()
    outputs = model(source_X_train.unsqueeze(0))  # 添加批次维度
    optimizer.zero_grad()
    loss = criterion(outputs.squeeze(), source_y_train)
    loss.backward()
    optimizer.step()


# 然后冻结部分层参数并微调于目标域
for param in model.lstm.parameters():
    param.requires_grad = False

optimizer_target = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()))

for epoch in range(epochs_target):
    model.train()
    outputs = model(target_X_train.unsqueeze(0))  # 添加批次维度
    optimizer_target.zero_grad()
    loss = criterion(outputs.squeeze(), target_y_train)
    loss.backward()
    optimizer_target.step()

此代码展示了如何构建一个基本的LSTM架构，并分两阶段训练：首先是针对大量可用的源域数据进行全面训练；其次是仅调整全连接层权重以适应少量的目标域数据[^1]。