Sequence-to-Sequence Autoencoder (Seq2Seq AE)

The architecture consists of two distinct recurrent or transformer networks. The encoder ingests a variable-length input sequence—such as a user's last N transactions—and compresses it into a fixed-length context vector. The decoder then attempts to reconstruct the original sequence from this compressed representation. This bottleneck forces the model to learn the most salient, normal behavioral patterns. During inference, a fraudulent sequence that deviates from learned norms will be poorly reconstructed, yielding a high reconstruction error that serves as the anomaly score.

The fixed-length vector produced by the encoder is the latent space—a dense, low-dimensional manifold that captures the essence of a transaction sequence. This space encodes complex temporal dynamics such as:

• Transaction velocity and inter-arrival times
• Typical merchant category code (MCC) sequences
• Cyclical spending patterns and amount distributions Normal sequences cluster tightly in this space, while anomalous sequences are mapped to low-density regions. This latent representation can also be used as a sequence embedding for downstream clustering or visualization tasks.

The core fraud detection mechanism is the reconstruction error—the difference between the original input sequence and the decoder's output. Common loss functions include:

• Mean Squared Error (MSE) for continuous features like transaction amounts
• Cross-entropy loss for categorical features like merchant codes A high aggregate error indicates the model could not faithfully reproduce the sequence, signaling a deviation from learned normal behavior. This unsupervised approach requires no labeled fraud data, making it effective against zero-day fraud patterns.

Unlike fixed-size input models, the Seq2Seq AE naturally accommodates sequences of differing lengths. This is critical for financial data where users have varying transaction frequencies. The encoder processes each time step sequentially, and the final hidden state summarizes the entire history regardless of length. Padding and masking techniques ensure that variable-length batches are processed efficiently during training, while the decoder can be conditioned to generate outputs of the same length as the input for direct comparison.

During training, the decoder is typically trained using teacher forcing: instead of feeding its own previous prediction as the next input, it receives the ground-truth token from the training sequence. This stabilizes and accelerates convergence by preventing error propagation through time. At inference, the decoder operates in free-running mode, using its own outputs to generate the next step. The discrepancy between teacher-forced training and free-running inference can be mitigated by scheduled sampling, which gradually transitions from teacher forcing to self-generation during training.

Standard Seq2Seq models compress the entire input into a single fixed-length context vector, creating a bottleneck for long sequences. Attention mechanisms allow the decoder to access all encoder hidden states at each decoding step, creating a dynamic weighted context. This enables the model to:

• Focus on specific past transactions when reconstructing a particular time step
• Better preserve long-range dependencies in extended transaction histories
• Provide interpretable attention weights that highlight which past events most influenced the reconstruction error for a given output step

A specialized recurrent neural network architecture designed to learn long-range temporal dependencies in sequential data. It uses a gating mechanism—comprising an input gate, forget gate, and output gate—to control the flow of information through a cell state, mitigating the vanishing gradient problem. In fraud detection, an LSTM can process a raw sequence of transactions to learn a user's normal behavioral rhythm, serving as the encoder and decoder in a Seq2Seq AE.

• Forget gate: Decides what past information to discard
• Input gate: Selects new information to store in the cell state
• Output gate: Determines the hidden state output for the current time step

A gating mechanism in recurrent neural networks that is computationally more efficient than the LSTM. It uses a reset gate and an update gate to adaptively capture dependencies at different time scales, merging the cell state and hidden state into a single vector. For a Seq2Seq AE, using GRUs reduces the number of parameters, leading to faster training on large transaction datasets while maintaining comparable anomaly detection performance.

• Update gate: Controls how much past state is carried forward
• Reset gate: Determines how to combine new input with previous memory
• No separate cell state: Simplifies the architecture and reduces memory footprint

A deep learning model that relies entirely on a self-attention mechanism to process sequential data in parallel, eliminating recurrence. It captures complex, long-range dependencies between any two transactions in a sequence without the sequential bottleneck of RNNs. In a Seq2Seq AE context, a Transformer-based encoder can learn richer contextual embeddings of a transaction history, and the decoder can reconstruct the sequence autoregressively, often yielding lower reconstruction error for normal patterns.

• Self-attention: Relates every element to every other element
• Multi-head attention: Allows the model to focus on different representation subspaces
• Positional encoding: Injects temporal order information into the parallel architecture

The gradient-based learning algorithm used to train recurrent neural networks. It works by unrolling the network's computation graph over the temporal dimension, creating a deep feed-forward network with shared weights, and then propagating errors backward through each time step. This is the fundamental training mechanism for LSTM and GRU-based Seq2Seq autoencoders, enabling them to learn the temporal structure of normal transaction sequences.

• Unrolling: Expands the RNN into a deep network for a fixed number of time steps
• Truncated BPTT: Limits the unrolling depth to manage computational cost and mitigate vanishing gradients
• Weight sharing: The same weights are used at every time step, enforcing temporal invariance

A training strategy for sequence-to-sequence models where the ground-truth output from a previous time step is fed as input to the current time step, rather than the model's own prediction. This accelerates convergence when training the decoder of a Seq2Seq AE to reconstruct normal transaction sequences. During inference, the model's own predictions are fed back in a loop, and the reconstruction error between the input and output sequences is used as the anomaly score.

• Training: Uses true previous token to stabilize learning
• Inference: Uses predicted previous token, accumulating error for anomalies
• Scheduled sampling: A curriculum that gradually transitions from teacher forcing to self-generation

The process of mapping a variable-length sequence of discrete events—such as merchant category codes (MCCs) or transaction types—into a fixed-length, dense vector representation. This embedding captures the semantic and temporal essence of a user's behavior. In a Seq2Seq AE, the encoder's final hidden state or a pooled representation of its outputs serves as the sequence embedding, which is then used by the decoder to reconstruct the original sequence.

• Learned embeddings: Each discrete token is mapped to a dense vector during training
• Contextualized representation: The embedding of a transaction depends on its surrounding context
• Anomaly detection: The distance between embeddings of normal and suspicious sequences can be used for clustering