In this (long) post - I try to explain the concept of transformers from first principles. With the rise of GPT and LLMs, transformers are a critical component to know. Yet, they are not easy to understand. Here, I try to explain transformers from first principles. By 'first principles' I mean - I try to explain them by understanding the limitations of RNNs and LSTMs. I also try to explain all related concepts in one document.
The overall flow is as follows:
Understanding long range sequences in NLP
RNNs and LSTMs and how they understand long range sequences
Understanding the limits of RNNs and LSTMs
Understanding how attention mechanism and transformers overcome the limitations of LSTMs
Natural Language Processing (NLP) is a field of study and a subfield of artificial intelligence (AI) that focuses on the interaction between computers and human language. It involves the development of algorithms and models to enable computers to understand, interpret, and generate human language in a way that is meaningful and useful. NLP encompasses a wide range of tasks and applications that involve processing and analyzing natural language data, such as text or speech.
Some of the common NLP tasks include: Text Classification, Named Entity Recognition (NER), Part-of-Speech (POS) Tagging, Machine Translation, Question Answering, Text Summarization and Language Generation
Long range sequences
From a machine learning perspective, NLP typically involves working with long range sequences. Long-range sequences refer to sequences of data that span a significant number of time steps or elements.
Let's consider the example of language modeling, where the task is to predict the next word in a sentence given the previous words. In this case, a long-range sequence could be a sentence or a paragraph.
For instance, let's take the following sentence:"I went to the store, bought a gift, and then visited my friend who lives in a different city because my friend was unwwell and I wanted to cheer him up with the gift. However, I realised that the gift was not ideal for him. I then thought I should catch an earlier train and go to his city and get the gift from a local store in his city"
In this example, the long-range sequence would be the entire sentence. Each word in the sentence depends on the words that come before it to make sense and determine the most probable next word. The RNN would process the words one by one, maintaining an internal hidden state that helps it retain information from earlier words in the sentence. The ability of the RNN to capture long-range dependencies allows it to understand that "city" is a more likely word to follow "a different" than, say, "dog" or "book". By considering the context of the entire sentence, the RNN can make more accurate predictions for the next word. The word city is used three times context of the word ‘city’ gets complex the longer the sequence is.
Here's another example of a long-range sequence in the context of time series data:Let's say we have a dataset containing daily stock prices of a company over a period of several years. Each data point represents the closing price of the stock for a particular day. The goal is to predict the future stock prices based on historical data In this case, a long-range sequence would be a sequence of consecutive daily closing prices over a specific time window. For instance, consider the following sequence of closing prices over 10 days: [100.5, 101.2, 99.8, 102.3, 103.1, 101.9, 100.7, 98.6, 97.2, 99.0]
In this example, the long-range sequence consists of 10 consecutive daily closing prices. The RNN model would take these historical prices as input and try to predict the next closing price or the price trend in the future. By considering the sequence of historical prices, the RNN can capture patterns, trends, and dependencies in the stock price data, allowing it to make more informed predictions about future prices.
The length of the long-range sequence can vary depending on the specific problem and the characteristics of the data. For example, if the above sequence was house prices, you would need a different characteristic for the data.
RNNs and LSTMs - an overview
Recurrent neural networks (RNNs) are a type of neural network commonly used for processing sequential data, where each input in the sequence is processed one step at a time, while also maintaining an internal memory or hidden state.
In an RNN, information from previous time steps or elements is passed on to subsequent steps, allowing the network to capture dependencies and patterns in the sequence.
However, one limitation of basic RNN architectures is that they struggle to effectively capture long-range dependencies in the data.
This is because the gradients that are backpropagated through time tend to either vanish or explode as they are multiplied over many time steps, making it difficult for the network to learn and retain information from earlier parts of the sequence.
To overcome this limitation, several advanced RNN architectures have been developed, such as Long Short-Term Memory (LSTM) and Gated Recurrent Unit (GRU).
These architectures incorporate gating mechanisms that help the network selectively retain and propagate relevant information over longer time intervals.
By allowing the model to remember information from much earlier in the sequence, LSTM and GRU networks are better suited for capturing long-range dependencies.
Basic terminology
A recap of the basic terminology used in this context:
Parameter: A variable in a machine learning model that is estimated from data.
Foundation model AI: A type of large language model that is trained on a massive dataset of text and code.
Unsupervised learning: A type of machine learning that does not require labeled data.
Hallucination: A situation where the generative AI model generates output that is not supported by the input data or is inaccurate.
Transfer learning: A technique for using a generative AI model that has been trained on one task to perform another task.
Prompt-based learning: A technique for training large language models that involves providing the model with a prompt, which is a short piece of text that provides the model with context for the task it is being asked to perform.
Attention: A mechanism that allows a transformer to learn long-range dependencies between different parts of a sequence.
Token: In the context of GPT (Generative Pre-trained Transformer), tokens refer to the basic units or elements that make up the input and output sequences processed by the model. In natural language processing (NLP), tokens typically represent individual words or subwords, although they can also include characters or other linguistic units.GPT operates at the token level, where each token is assigned a unique identifier. These identifiers are usually integers, and they serve as inputs to the model during training and inference. For example, in a sentence like "I love ice cream," the tokens might be "I," "love," "ice," and "cream," each with its corresponding token ID.
Encoder: A transformer layer that takes a sequence of input tokens and produces a sequence of hidden representations.
Decoder: A transformer layer that takes a sequence of hidden representations and produces a sequence of output tokens.
Embedding: A vector representation of a word or other token.
Multihead attention: A type of attention mechanism that uses multiple attention heads to learn different aspects of the long-range dependencies between different parts of a sequence.
Self-attention: A type of attention mechanism that allows a transformer to learn long-range dependencies between different parts of the same sequence.
Transformer: A neural network architecture that uses attention to learn long-range dependencies between different parts of a sequence. Transformer model: A transformer that has been trained on a large dataset of text and code.
Loss function: A function that measures the difference between the model's predictions and the ground truth labels.
The vanishing gradient problem is a challenge that can occur during the training of deep neural networks, particularly recurrent neural networks (RNNs) and deep feedforward neural networks with many layers. It refers to the issue where the gradients, which are used to update the weights of the network during backpropagation, become extremely small as they propagate backward from the output layer to the earlier layers. Consequently, the updates to the weights become insignificant or negligible, leading to slow or ineffective learning. The vanishing gradient problem is especially pronounced in RNNs because the gradients need to be propagated through time, across multiple recurrent connections.When the gradients vanish, the network fails to learn the complex patterns and dependencies present in the data, resulting in poor performance. On the other hand, the opposite problem, called the exploding gradient problem, occurs when the gradients become extremely large, causing unstable learning and convergence issues.
Foundation models
Foundation models refer to large-scale language models that serve as the base architecture or framework for various natural language processing (NLP) tasks.
These models are pre-trained on vast amounts of text data and can then be fine-tuned for specific downstream tasks such as language translation, text summarization, sentiment analysis, question answering, and more.
Foundation models are typically trained using unsupervised learning techniques, where they learn to predict and generate coherent and contextually relevant text.
These models have a deep understanding of grammar, syntax, semantics, and contextual relationships between words and sentences. They can capture the statistical patterns and linguistic structures present in the training data.
Embeddings
An embedding is a vector representation of a word or other token. Embeddings are used to represent the input and output sequences in neural network models for natural language processing (NLP) tasks. Each word is represented as a vector of real numbers. The values in the vector represent the semantic meaning of the word, and they can be used to measure the similarity between words.
Embeddings form the core of NLP.
Embeddings can be thought of as a way of representing the proximity of words in a semantic space. In this space, words that are semantically similar are represented by vectors that are close together. This allows us to measure the similarity between words by measuring the distance between their vectors.For example, the words "car" and "automobile" are semantically similar. They both refer to a four-wheeled vehicle that is used for transportation. In an embedding space, the vectors representing these words would be close together.On the other hand, the words "car" and "tree" are semantically different. They refer to two different objects that have different properties. In an embedding space, the vectors representing these words would be far apart.
RNNs and LSTMs
Understanding RNNs (recurrent neural networks)
Recurrent neural networks (RNNs) are a type of neural network that can process sequences of data. RNNs are made up of a series of nodes, where each node is connected to the nodes that come before and after it. This allows RNNs to learn long-range dependencies between different parts of a sequence.
RNNs are commonly used for natural language processing (NLP) tasks, such as machine translation, text summarization, and question answering. They are also used for speech recognition, image captioning, and other tasks that involve processing sequential data.
RNNs are trained using a technique called backpropagation through time (BPTT). BPTT is a method for training neural networks that process sequences of data. BPTT works by breaking the sequence into smaller chunks, and then training the RNN on each chunk.
RNNs can be difficult to train, because they can suffer from vanishing and exploding gradients.
Components of an RNN
RNNs are designed to capture sequential dependencies by introducing recurrent connections within the network. The key components of an RNN are as follows:
Input Layer: The input layer receives the sequential input data, such as a sequence of words in a sentence or a time series of data points. Each element in the sequence is typically represented as a feature vector.
Hidden Layer: The hidden layer is the core component of an RNN. It contains recurrent connections that allow the network to maintain and update a hidden state or memory. The hidden layer processes the input at each time step and produces an output and an updated hidden state. The output at each time step can be used for predictions or fed back into the network as input for subsequent time steps.
Recurrent Connections: Recurrent connections are connections that allow information to be passed from one time step to the next. These connections enable the network to capture temporal dependencies and retain memory of past inputs. The hidden state at each time step is propagated to the next time step, which influences the processing and output of the network.
Activation Function: An activation function is applied to the output of each hidden layer node to introduce non-linearity. Common activation functions used in RNNs include the sigmoid function (to squash the output between 0 and 1) and the hyperbolic tangent function (to squash the output between -1 and 1). These non-linearities allow the network to model complex patterns and relationships in the sequential data.
Output Layer: The output layer receives the final hidden state or the sequence of hidden states and produces the desired output. The output layer can vary depending on the task at hand. For example, in language modeling, the output layer may be a softmax layer that predicts the probability distribution over the next word in a sequence.
Loss Function: The loss function quantifies the difference between the predicted output of the network and the true output. It serves as a measure of how well the network is performing on the task. The goal of training an RNN is to minimize the loss function by adjusting the weights and biases of the network through a process called backpropagation through time (BPTT).
Backpropagation Through Time (BPTT): BPTT is an extension of the standard backpropagation algorithm for training neural networks. It allows the gradients to flow through time and adjust the parameters of the network based on the error signal at each time step. BPTT considers the dependencies of the network over the entire sequence, making it suitable for training RNNs.
Understanding LSTM
LSTM networks are a type of recurrent neural network (RNN) that are commonly used for natural language processing (NLP) tasks. LSTMs are able to learn long-range dependencies between different parts of a sequence, which makes them well-suited for tasks such as machine translation.
LSTM networks are made up of a series of cells, where each cell has three gates: an input gate, a forget gate, and an output gate. The input gate controls how much of the current input is added to the cell state, the forget gate controls how much of the previous cell state is forgotten, and the output gate controls how much of the cell state is outputted.
LSTM networks are trained using a technique called backpropagation through time (BPTT). BPTT is a method for training neural networks that process sequences of data. BPTT works by breaking the sequence into smaller chunks, and then training the LSTM on each chunk.
LSTM networks can be difficult to train, because they can suffer from vanishing and exploding gradients. Vanishing gradients occur when the gradients of the loss function become very small, which can prevent the LSTM from learning. Exploding gradients occur when the gradients of the loss function become very large, which can cause the LSTM to become unstable.
LSTMs can learn long-range dependencies. This is because the gates in an LSTM allow the model to remember information from previous steps in the sequence. The design of LSTM, with its memory cell and gating mechanisms, enables it to mitigate the vanishing gradient problem. The gating mechanisms control the flow of gradients, allowing relevant information to propagate through time while mitigating the effects of diminishing gradients. The memory cell provides a stable information flow, preserving long-term dependencies and preventing the vanishing of gradients over extended sequences.
Overall, LSTM's ability to selectively update and retain information, coupled with its gating mechanisms, makes it particularly effective at capturing long-term dependencies in sequential data and alleviating the vanishing gradient problem in RNNs.
The Attention concept was introduced in the paper "Attention is All You Need" by Vaswani et al. (2017). Transformers are a type of neural network architecture that are based on attention .
Attention is a mechanism in machine learning that allows a model to focus on specific parts of an input sequence. This is useful for tasks such as machine translation, where the model needs to be able to understand the meaning of the entire input sentence in order to generate a correct output sentence.
Attention is implemented as follows:
A neural network first takes a combination of input sequence and the output sequence as input, and outputs a vector of weights.
These weights are applied to the input sequence, so that the model can focus on the most relevant parts of the sequence.
There are two main types of attention: self-attention and encoder-decoder attention.
Attention is a powerful mechanism that can be used to improve the performance of machine learning models on a variety of tasks. It is particularly useful for tasks that involve understanding long sequences of data.
Attention can help models to learn long-range dependencies. Attention allows models to focus on specific parts of an input sequence, which can help them to learn long-range dependencies between different parts of the sequence. Attention allows models to focus on the most relevant parts of an input sequence, which can help them to be more efficient and avoid wasting time on irrelevant parts of the sequence. It can help models to be more accurate. Attention can help models to be more accurate by allowing them to focus on the most relevant parts of an input sequence.
Self attention
Self-attention, also known as intra-attention or scaled dot-product attention, is a mechanism used in deep learning models, particularly in the field of natural language processing (NLP), to capture dependencies between different elements of a sequence. It allows the model to weigh the importance of different words or tokens in the input sequence when making predictions.
To explain self-attention, let's take an example of a sentence: "The cat sat on the mat." In self-attention, each word in the input sentence is represented as a vector, commonly known as an embedding. These word embeddings capture the semantic meaning of the word. So, we would have word embeddings for "The," "cat," "sat," "on," "the," and "mat."
Now, let's consider the word "sat" and see how self-attention works for this word. The self-attention mechanism will compare the word "sat" to all the other words in the sentence to understand its relationship with them. This comparison is done by computing a similarity score, often referred to as an attention score, between "sat" and each of the other words.
To compute the attention scores, self-attention uses three learned matrices: Query (Q), Key (K), and Value (V). These matrices are obtained by multiplying the word embeddings with corresponding weight matrices.
The attention score quantifies the importance of the word "cat" for the word "sat." If the attention score is high, it means that "sat" pays a lot of attention to "cat" when determining its representation. Similarly, attention scores are computed for "sat" and all other words in the sentence.
Once we have the attention scores, we multiply each attention score with the value vector (V) corresponding to the word being attended to. These multiplied values are then summed up to obtain the final representation of the word "sat" that takes into account its relationship with all the other words in the sentence.
The process described above is repeated for every word in the sentence, allowing each word to attend to other words and learn its context within the sequence. This enables the model to capture long-range dependencies and generate more accurate predictions.
In summary, self-attention allows a model to focus on different parts of the input sequence when making predictions, giving it the ability to understand the relationships and dependencies between words or tokens.
Encoder decoder overview
Encoder-decoder attention, also known as cross-attention, is an extension of the self-attention mechanism used in sequence-to-sequence models. It allows the decoder to attend to different parts of the encoder's input sequence when generating the output sequence.
Consider the following English sentence: "The cat is on the mat." And let's assume we want to translate it to French.
In the encoding phase, the input sentence "The cat is on the mat." is passed through an encoder network, typically composed of multiple layers of self-attention and feed-forward neural networks. The encoder processes the input sentence word by word and generates a set of encoded representations for each word. Let's denote the encoder hidden states as H_enc.
In the decoding phase, the decoder takes the encoded representations (H_enc) from the encoder as input and generates the translated sequence word by word. At each step, the decoder attends to different parts of the input sequence through the encoder-decoder attention mechanism.
Encoder decoder steps
Step 1: The decoder first generates a word embedding for "Le" and passes it through a linear layer to obtain the query vector (Q). This query vector captures the information about the word being generated.
Step 2: The query vector (Q) is then used to compute attention scores with respect to each encoder hidden state (H_enc) using the encoder's key matrix (K_enc). These attention scores represent the relevance or importance of each hidden state in the encoder for the current decoding step.
Step 3: The attention scores are then normalized using a softmax function, which produces a set of weights that sum up to 1. These weights indicate the distribution of attention across the encoder's hidden states.
Step 4: Finally, the attention weights are used to compute a weighted sum of the encoder's hidden states (H_enc). This weighted sum, often referred to as the context vector, captures the information from the encoder that is most relevant for generating the current word.
The context vector is then concatenated with the decoder's input (the word embedding for "Le") and passed through the decoder's internal layers to generate the next word in the translated sequence. The process repeats until the complete translation is generated.
By allowing the decoder to attend to different parts of the encoder's input at each decoding step, the encoder-decoder attention mechanism enables the model to align the source and target sequences and capture the dependencies necessary for accurate translation.
Transformers overcoming the challenges of LSTMs
In comparison to RNNs
RNNs require all of the previous hidden states to be stored in memory, which can be a significant amount of data for long sequences.
They can be difficult to parallelize. This is because the computation of each hidden state depends on the previous hidden states, which means that RNNs cannot be easily divided into smaller tasks that can be processed in parallel.
RNNs can suffer from vanishing and exploding gradients.
Transformers do not use recurrent connections, which means that they do not require all of the previous hidden states to be stored in memory. This makes transformers much more computationally efficient to train and parallelize than RNNs.
Attention allows transformers to learn which parts of a sequence are most relevant to a particular task, and it allows transformers to learn long-range dependencies without suffering from vanishing and exploding gradients.
Components of a transformer model
Attention: Attention is a mechanism that allows transformers to learn which parts of a sequence are most relevant to a particular task. Attention is implemented using a neural network that takes the input sequence and the output sequence as input, and outputs a vector of weights. These weights are used to weight the input sequence, so that the transformer can focus on the most relevant parts of the sequence.
Encoder: The encoder is a transformer layer that takes a sequence of input tokens and produces a sequence of hidden representations. The encoder is made up of a stack of self-attention layers.
Decoder: The decoder is a transformer layer that takes a sequence of hidden representations and produces a sequence of output tokens. The decoder is also made up of a stack of self-attention layers.
Embedding: An embedding is a vector representation of a word or other token. Embeddings are used to represent the input and output sequences in the transformer model.
Positional encoding: Positional encoding is a technique for adding information about the position of each token in a sequence to the embedding of that token. Positional encoding is important for transformers, because they do not use recurrent connections, which means that they cannot learn the order of the tokens in a sequence.
Transformer models are trained using a technique called backpropagation through time (BPTT). BPTT is a method for training neural networks that process sequences of data. BPTT works by breaking the sequence into smaller chunks, and then training the transformer on each chunk.
Transformer models can be used for a variety of NLP tasks, such as: Machine translation, Text summarization, Question answering, Speech recognition and Image captioning:
Transformer architecture flow
The architecture of a transformer is relatively simple.
It consists of an encoder and a decoder, each of which is a stack of self-attention layers.
The encoder takes the input sequence as input and produces a sequence of hidden states.
The decoder then takes the hidden states from the encoder as input and produces the output sequence.
The self-attention layer is the key component of a transformer. It allows the model to learn how each word in the input sequence is related to every other word in the sequence. This is done by calculating a score for each pair of words, which indicates how important the two words are to each other. The scores are then used to weight the hidden states from the encoder, so that the decoder can focus on the most important words when generating the output sequence.
Zero shot one shot and multi shot
Zero-shot learning is a type of machine learning where the model is not trained on any data from the new class. Instead, the model is given a description of the new class, and it must learn to classify data from that class without any examples. For example, let's say you have a model that can classify dogs and cats. You want to train the model to also classify birds. However, you don't have any data of birds. In this case, you can use zero-shot learning. You can give the model a description of birds, such as "a small, feathered animal that flies." The model can then use this description to learn to classify data from the bird class.
One-shot learning is a type of machine learning where the model is trained on only one example from the new class. This is in contrast to traditional machine learning, where the model is trained on a large number of examples from each class. For example, let's say you have a model that can classify dogs and cats. You want to train the model to also classify birds. However, you only have one example of a bird. In this case, you can use one-shot learning. You can give the model the example of a bird, and the model will learn to classify data from the bird class based on this one example.
Multi-shot learning is a type of machine learning where the model is trained on multiple examples from the new class. This is in between zero-shot learning and one-shot learning. For example, let's say you have a model that can classify dogs and cats. You want to train the model to also classify birds. However, you only have a few examples of birds. In this case, you can use multi-shot learning. You can give the model the few examples of birds, and the model will learn to classify data from the bird class based on these few examples.
Predicting from the vocabulary of the corpus in Auto completion classification problem prediction is one-to-many type of sequential networks.
Word embedding models are language agnostic and cosine similarity will help in representing the proximity of words in semantic space.
LSTM solves the vanishing gradient problem of RNN by ensuring that the cell state is never zero and gating mechanism is such that atleast one path always exist for the gradients to flow during the reverse pass of BPTT algorithm.
Encoder-Decoder models are good at conditional language generation as in text sumamrization.
Head of AI @ Cyber Stealth | Math PhD | Scientific Content Creator | Lecturer | Podcast Host(40+ podcasts about AI & math) | Deep Learning(DL) & Data Science(DS) Expert | > 350 DL Paper Reviews | 55K followers |
Leadership | Certified Independent Director | Engineering| Product | Strategy & Roadmap | Retail, Supply Chain-Marketplace Partners & Demand Planning | GCC|Digital Transformation |AI/MLEnthusiast | Ex-Accenture, Ex-Lowes
1yGreat Read indeed!!
PhD | Professor | Data Science | Machine Learning | Deputy Dean (Research)
1yPredicting from the vocabulary of the corpus in Auto completion classification problem prediction is one-to-many type of sequential networks. Word embedding models are language agnostic and cosine similarity will help in representing the proximity of words in semantic space. LSTM solves the vanishing gradient problem of RNN by ensuring that the cell state is never zero and gating mechanism is such that atleast one path always exist for the gradients to flow during the reverse pass of BPTT algorithm. Encoder-Decoder models are good at conditional language generation as in text sumamrization.
Application Engineer at ConformIQ | ConformIQ-Creator | ConformIQ - Visualizer |
1yThis article is very very informative. Amazingly mentioned points. Thank you for sharing this post
Amazing amazing.. Thanks for sharing
Head of AI @ Cyber Stealth | Math PhD | Scientific Content Creator | Lecturer | Podcast Host(40+ podcasts about AI & math) | Deep Learning(DL) & Data Science(DS) Expert | > 350 DL Paper Reviews | 55K followers |
1yHay Hoffman