Encoder-Decoder-Transformer für Zeitreihen implementieren

Das Skelett enthält separate Source-/Target-Projektionen, Positionsinformation, batch_first=True, den Transformer und die Rückprojektion auf kontinuierliche Zielkanäle.

import torch
from torch import nn

class TimeSeriesTransformer(nn.Module):
    def __init__(
        self,
        source_dim,
        target_dim,
        d_model=128,
        nhead=8,
        encoder_layers=4,
        decoder_layers=2,
        dropout=0.1,
    ):
        super().__init__()
        self.source_projection = nn.Linear(source_dim, d_model)
        self.target_projection = nn.Linear(target_dim, d_model)
        self.position = nn.Parameter(torch.zeros(1, 2048, d_model))

        self.transformer = nn.Transformer(
            d_model=d_model,
            nhead=nhead,
            num_encoder_layers=encoder_layers,
            num_decoder_layers=decoder_layers,
            dropout=dropout,
            batch_first=True,
        )
        self.output_projection = nn.Linear(d_model, target_dim)

    def forward(self, source, target_in, target_mask=None):
        src_len = source.size(1)
        tgt_len = target_in.size(1)

        source = self.source_projection(source) + self.position[:, :src_len]
        target = self.target_projection(target_in) + self.position[:, :tgt_len]

        hidden = self.transformer(
            source,
            target,
            tgt_mask=target_mask,
        )
        return self.output_projection(hidden)

Vor dem Einsatz muss eine kausale Target-Maske ergänzt und geprüft werden. Form sowie Bool-/Float-Semantik der Maske richten sich nach der konkret verwendeten PyTorch-Version.