Encoder (Transformer)

Encoder — in machine learning and deep learning, is a component of a neural network whose primary task is to transform an input data sequence (e.g., text or an image) into a rich numerical representation, commonly called a hidden state, context vector, or embedding. This representation captures the key features and semantics of the input data in a form suitable for further processing.

In a broader sense, in information theory, an encoder is any device or algorithm that converts information from one format to another, often for the purpose of compression or transmission.

Concept and Purpose

The primary goal of an encoder in neural networks is to extract useful features from the input data and "encode" them into a dense, fixed-length vector. This process can be viewed as a form of non-linear dimensionality reduction, where high-dimensional and sparse input data (such as text represented by one-hot vectors) are transformed into a low-dimensional yet information-rich vector space (latent space).

This encoded vector can then be used by:

• A decoder to generate a new sequence (e.g., in machine translation).
• A classifier for analysis tasks (e.g., sentiment analysis).
• For tasks that require understanding the entire input context.

Encoder in Different Architectures

Encoder in an Autoencoder

One of the classic examples is the autoencoder architecture. It consists of two parts:

1. Encoder: Compresses the input data into a lower-dimensional hidden representation (the latent code).
2. Decoder: Attempts to reconstruct the original data from this compressed representation.

By training such a network to minimize the reconstruction error, the encoder learns to extract the most important features from the data.

Encoder in Recurrent Neural Networks (RNN/LSTM)

Before the advent of the Transformer architecture, encoders in sequence-to-sequence (seq2seq) tasks were built using recurrent neural networks (RNNs) or their advanced variant, LSTM.

• How it works: An RNN-based encoder processes the input sequence token by token. At each step, it updates its hidden state, incorporating information about the current token and the previous state. The final hidden state, obtained after processing the entire sequence, is considered the vector that encodes the meaning of the whole input sequence. This vector is often called the context vector or "thought vector".

Encoder in the Transformer Architecture

The revolution in natural language processing is associated with the emergence of the encoder based on the Transformer architecture. Unlike RNNs, it processes all tokens in the sequence in parallel.

The Transformer encoder consists of a stack of $N$ identical layers. Each layer has two main sub-layers:

1. Multi-Head Self-Attention: This mechanism allows each token in the input sequence to "attend" to all other tokens and weigh their importance in forming its own contextual representation. This enables the model to capture complex dependencies between words, regardless of their position.
2. Position-wise Feed-Forward Network: Applied to the representation of each token individually for further non-linear transformation.

The key difference between a Transformer encoder and an RNN-based encoder is that its output is not a single context vector but a sequence of contextualized vectors—one for each input token. Each of these vectors contains information about its token in the context of the entire sequence.

Types of Encoder-Based Models

Encoder-Decoder Models

This is the classic architecture for sequence-to-sequence (seq2seq) tasks, such as machine translation or summarization.

• How it works: The encoder processes the entire input sequence (e.g., a sentence in the source language). Its output representations are then passed to the decoder, which uses them to auto-regressively generate the output sequence (a sentence in the target language). The decoder "looks" at the encoder's output using a special mechanism called cross-attention.
• Examples: The original Transformer, T5, BART.

Encoder-Only Models

These models use exclusively the Transformer encoder stack.

• How they work: They are designed for tasks requiring a deep contextual understanding of the entire input text. Thanks to the bidirectional nature of the self-attention mechanism, they create rich contextual representations for each token.
• Applications: They are ideal for Natural Language Understanding (NLU) tasks, such as:
  • Text classification (e.g., sentiment analysis).
  • Named Entity Recognition (NER).
  • Question Answering, where the answer is a span of text from the input.
• Example: BERT and its derivatives (RoBERTa, ALBERT).

Relationship with the Decoder

In an encoder-decoder architecture, the encoder and decoder perform complementary roles:

• The encoder is responsible for understanding the input sequence.
• The decoder is responsible for generating the output sequence.

The key link between them is the cross-attention mechanism within the decoder. At each generation step, the decoder forms a query (Query) based on the already generated part of the output sequence and uses it to "attend" to the encoder's output representations (which serve as the keys and values—Key and Value). This allows the decoder to focus on the most relevant parts of the input sequence to generate the next token.

References

• Hinton, G. E.; Salakhutdinov, R. R. (2006). Reducing the Dimensionality of Data with Neural Networks. Science. DOI:10.1126/science.1127647.
• Cho, K. et al. (2014). Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation. arXiv:1406.1078.
• Sutskever, I.; Vinyals, O.; Le, Q. V. (2014). Sequence to Sequence Learning with Neural Networks. arXiv:1409.3215.
• Bahdanau, D.; Cho, K.; Bengio, Y. (2015). Neural Machine Translation by Jointly Learning to Align and Translate. arXiv:1409.0473.
• Kingma, D. P.; Welling, M. (2014). Auto-Encoding Variational Bayes. arXiv:1312.6114.
• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Devlin, J. et al. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. arXiv:1810.04805.
• Dai, Z. et al. (2019). Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context. arXiv:1901.02860.
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. arXiv:1910.10683.
• Brown, T. B. et al. (2020). Language Models Are Few-Shot Learners. arXiv:2005.14165.
• Dosovitskiy, A. et al. (2020). An Image is Worth 16×16 Words: Transformers for Image Recognition at Scale. arXiv:2010.11929.

See Also

• BERT