Notation Used Throughout This Course

To navigate the concepts in this course effectively, we need a common language for the mathematical objects and operations involved. This section establishes the notation used consistently across chapters. While we adhere to standard conventions in machine learning and deep learning literature where possible, clarity and consistency within this course are the primary goals. Familiarizing yourself with this notation will help in understanding the equations describing model architectures, training algorithms, and evaluation metrics.

General Mathematical Conventions

• Scalars: Represented by lowercase italic letters (e.g., $a, x, \lambda, \eta$). These typically denote single numerical values, such as learning rates, regularization parameters, or individual elements of vectors/matrices.
• Vectors: Represented by lowercase bold letters (e.g., $\mathbf{x}, \mathbf{y}, \mathbf{w}, \mathbf{b}$). By default, vectors are assumed to be column vectors. We denote the dimensionality as $\mathbf{x} \in \mathbb{R}^d$, indicating a vector with $d$ real-valued elements. The $i$-th element of $\mathbf{x}$ is $x_i$.
• Matrices: Represented by uppercase bold letters (e.g., $\mathbf{X}, \mathbf{Y}, \mathbf{W}$). We denote the dimensionality as $\mathbf{W} \in \mathbb{R}^{m \times n}$, indicating a matrix with $m$ rows and $n$ columns. The element in the $i$-th row and $j$-th column is $W_{ij}$ or $w_{ij}$. An identity matrix is denoted by $\mathbf{I}$.
• Tensors: Higher-order arrays (rank > 2) are sometimes represented by uppercase calligraphic letters (e.g., $\mathcal{T}$) or uppercase bold letters if the context makes the dimensionality clear (e.g., a batch of matrices). Dimensions will be specified, for instance, $\mathcal{T} \in \mathbb{R}^{d_1 \times d_2 \times \dots \times d_k}$.
• Indices and Summations: Typically use $i, j, k$ for indexing elements or dimensions. $t$ is frequently used to denote a specific position or time step in a sequence. Summation is denoted by $\sum$.
• Sets: Represented by uppercase calligraphic letters (e.g., $\mathcal{D}$ for a dataset, $\mathcal{V}$ for a vocabulary). The size or cardinality of a set $\mathcal{S}$ is denoted by $|\mathcal{S}|$.
• Functions: Standard mathematical functions use italic lowercase (e.g., $f(\cdot), g(\cdot)$). Activation functions are often denoted by Greek letters (e.g., $\sigma(\cdot)$ for sigmoid, $\phi(\cdot)$ for ReLU variants like GeLU). $L(\cdot)$ or $J(\cdot)$ typically represent loss or objective functions.
• Derivatives and Gradients: The gradient of a scalar function $J$ with respect to a vector $\mathbf{w}$ is denoted $\nabla_{\mathbf{w}} J(\mathbf{w})$ or simply $\nabla J$ if the variable is clear from context. Partial derivatives are written as $\frac{\partial f}{\partial x}$.

Specific Notations for Language Models

• Sequences: An input sequence of length $T$ is often represented as a list or tuple of tokens $(x_1, x_2, \dots, x_T)$ or their corresponding embedding vectors $(\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_T)$. $T$ denotes the sequence length.
• Vocabulary and Tokenization: The set of unique tokens (words, subwords) is the vocabulary $\mathcal{V}$. Its size is $|\mathcal{V}|$. $x_t$ often represents the integer index of the token at position $t$.
• Embeddings:
  • Token embedding matrix: $\mathbf{E} \in \mathbb{R}^{|\mathcal{V}| \times d_{model}}$, where $d_{model}$ is the model's hidden dimension.
  • Embedding vector for token index $i$: $\mathbf{e}_i$, which is the $i$-th row of $\mathbf{E}$.
  • Positional encoding vector for position $t$: $\mathbf{p}_t \in \mathbb{R}^{d_{model}}$.
  • Input representation at position $t$: $\mathbf{z}_t = \mathbf{e}_t + \mathbf{p}_t$ (or variations depending on the model).
• Transformer Components:
  • Query, Key, Value matrices for a sequence: $\mathbf{Q}, \mathbf{K}, \mathbf{V} \in \mathbb{R}^{T \times d_k}$ (within a single attention head, or $\mathbb{R}^{T \times d_{model}}$ before projection).
  • Associated weight matrices: $\mathbf{W}^Q, \mathbf{W}^K, \mathbf{W}^V \in \mathbb{R}^{d_{model} \times d_k}$ (per head) or $\mathbb{R}^{d_{model} \times d_{model}}$ (overall projection).
  • Attention scores matrix: $\mathbf{A} \in \mathbb{R}^{T \times T}$.
  • Attention output: $Attention(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{softmax}(\frac{\mathbf{Q}\mathbf{K}^T}{\sqrt{d_k}})\mathbf{V}$.
  • Hidden states at layer $l$: $\mathbf{H}^{(l)} \in \mathbb{R}^{T \times d_{model}}$. The input embeddings are often $\mathbf{H}^{(0)}$.
  • Feed-Forward Network: FFN($\cdot$).
• Model Parameters: The set of all trainable parameters (weights and biases) is denoted by $\theta$.
• Data and Training:
  • Dataset: $\mathcal{D}$.
  • Training example: $(\mathbf{x}, y)$ where $\mathbf{x}$ is input and $y$ is target.
  • Batch of data: $\mathcal{B}$. Batch size $B = |\mathcal{B}|$.
  • Loss function: $\mathcal{L}(\theta)$ or $J(\theta)$. Per-example loss $L(\hat{y}, y)$.
• Probability:
  • Probability distribution: $P(\cdot)$.
  • Conditional probability: $P(Y | X)$.
  • Model's predicted probability for token $y$ given context $\mathbf{c}$: $P_{\theta}(y | \mathbf{c})$.
• Hyperparameters:
  • Learning rate: $\eta$.
  • Number of layers: $L$.
  • Model hidden dimension: $d_{model}$.
  • FFN intermediate dimension: $d_{ff}$.
  • Number of attention heads: $h$.
  • Dimension per head: $d_k = d_{model} / h$.
  • Dropout probability: $p_{drop}$.
  • Weight decay coefficient: $\lambda$.

Mapping to Code (PyTorch Example)

Mathematical notation maps directly to tensor operations in frameworks like PyTorch. Understanding this mapping is helpful for implementation.

• A vector $\mathbf{x} \in \mathbb{R}^d$:

  import torch
  d = 128
  x = torch.randn(d) # Typically a 1D tensor
  # Or explicitly a column vector (2D tensor)
  x_col = torch.randn(d, 1)
  print(f"Vector shape: {x.shape}, Column vector shape: {x_col.shape}")
  

• A matrix $\mathbf{W} \in \mathbb{R}^{m \times n}$:

  m, n = 64, 128
  W = torch.randn(m, n) # A 2D tensor
  print(f"Matrix shape: {W.shape}")
  

• Matrix-vector multiplication $\mathbf{y} = \mathbf{W}\mathbf{x} + \mathbf{b}$, where $\mathbf{W} \in \mathbb{R}^{m \times n}$, $\mathbf{x} \in \mathbb{R}^n$, $\mathbf{b} \in \mathbb{R}^m$, $\mathbf{y} \in \mathbb{R}^m$:

  # Assuming W from above, and matching x, b
  n = 128
  m = 64
  x = torch.randn(n)
  b = torch.randn(m)
  W = torch.randn(m, n)
  
  # Using torch.matmul or @ operator
  y = W @ x + b
  # Alternative: torch.nn.functional.linear
  # import torch.nn.functional as F
  # y_f = F.linear(x, W, b) # Note: F.linear expects W^T implicitly sometimes, check docs
  
  print(f"Input x shape: {x.shape}")
  print(f"Weight W shape: {W.shape}")
  print(f"Bias b shape: {b.shape}")
  print(f"Output y shape: {y.shape}")
  
  

• Batch processing: Often, the first dimension represents the batch size $B$. For example, a batch of sequences might have the shape $(B, T, d_{model})$.

This notation forms the basis for our discussions. Any deviations or context-specific symbols introduced in later chapters will be defined locally. Keep this reference handy as you progress through the material.