Attention in deep learning models is a mechanism that allows the model to dynamically focus on specific parts of the input data when making predictions. Unlike traditional models like RNNs or CNNs, which process sequences step-by-step or with fixed filters, attention assigns varying levels of importance (weights) to different input elements. For example, in machine translation, when generating the French word for “apple,” the model might assign higher weight to the input word “pomme” while downplaying unrelated words. These weights are learned during training, enabling the model to adaptively prioritize relevant information. The core idea is to compute a context vector—a weighted sum of inputs—that captures the most useful information for the current task.
A key example is the Transformer architecture, which relies heavily on self-attention. In self-attention, each token (e.g., a word in a sentence) generates a query, key, and value vector. The query of one token is compared to the keys of all other tokens via dot products, producing similarity scores. These scores are scaled, normalized with softmax, and used to weight the value vectors, creating a context-aware representation for each token. Multi-head attention extends this by running multiple self-attention operations in parallel, allowing the model to capture diverse relationships (e.g., syntactic and semantic patterns). For instance, BERT uses this mechanism to bidirectionally encode context, while GPT applies masked self-attention to generate text autoregressively. Vision Transformers (ViTs) also apply similar principles to image patches for tasks like classification.
The practical benefits of attention include parallel computation (no sequential dependencies like RNNs) and the ability to handle long-range dependencies in data. This makes Transformers efficient for training on GPUs and effective for tasks like translating lengthy documents or summarizing text. However, the computational cost grows quadratically with input length (O(n²) for n tokens), which can be a bottleneck. Techniques like sparse attention (limiting the number of token interactions) or kernel approximations have been developed to mitigate this. Despite these challenges, attention remains foundational in modern models, powering applications from code generation to image captioning by enabling context-aware, flexible processing of diverse data types.