Notation and Mathematical Conventions
This page collects the main symbols used throughout The Mathematics of Modern Computer Vision. The goal is not to force every chapter into one rigid notation, but to give students a reliable reference for the objects that appear repeatedly: images, coordinates, tensors, cameras, probability models, losses, neural networks, attention, diffusion, and multimodal embeddings.
Computer vision combines notation from linear algebra, multivariable calculus, probability, optimization, geometry, signal processing, and machine learning. A symbol may have slightly different meanings in different communities. In this book, the conventions below are used whenever possible.
General Conventions
| Symbol type | Convention | Examples |
|---|---|---|
| Scalars | lowercase italic letters | \(x\), \(y\), \(z\), \(t\), \(\lambda\), \(\sigma\) |
| Vectors | lowercase bold letters | \(\mathbf{x}\), \(\mathbf{u}\), \(\mathbf{v}\), \(\mathbf{z}\) |
| Matrices | uppercase bold letters | \(\mathbf{A}\), \(\mathbf{K}\), \(\mathbf{R}\), \(\mathbf{F}\) |
| Images and fields | uppercase italic letters | \(I\), \(J\), \(D\), \(M\), \(S\) |
| Tensors | uppercase bold or indexed arrays | \(\mathbf{X}\), \(\mathbf{Y}\), \(X_{i,j,c}\) |
| Sets and domains | uppercase calligraphic or Greek letters | \(\Omega\), \(\Gamma\), \(\mathcal{D}\) |
| Parameters | Greek letters or subscripted vectors | \(\theta\), \(\phi\), \(\mathbf{w}\) |
| Estimated quantities | hats | \(\hat{I}\), \(\hat{\theta}\), \(\hat{\mathbf{x}}\) |
| Ground truth | star or superscript label | \(y^*\), \(M^*\), \(\mathbf{x}^{\mathrm{gt}}\) |
| Transpose | superscript \(T\) | \(\mathbf{A}^T\), \(\mathbf{x}^T \mathbf{y}\) |
| Inverse | superscript \(-1\) | \(\mathbf{K}^{-1}\), \(\mathbf{A}^{-1}\) |
| Pseudoinverse | superscript \(+\) | \(\mathbf{A}^+\) |
| Euclidean norm | double bars | \(\|\mathbf{x}\|_2\) |
| Frobenius norm | subscript \(F\) | \(\|\mathbf{A}\|_F\) |
| Inner product | angle brackets or dot product | \(\langle \mathbf{x},\mathbf{y}\rangle\), \(\mathbf{x}^T\mathbf{y}\) |
When an object can be viewed in several ways, the text usually makes the view explicit. For example, an image may be written as an array \(I[i,j]\), a function \(I(x,y)\), a vector \(\mathbf{i}\), or a tensor \(\mathbf{X}\) depending on the chapter.
Image Arrays, Coordinates, and Channels
| Symbol | Meaning |
|---|---|
| \(H\) | image height, usually the number of rows |
| \(W\) | image width, usually the number of columns |
| \(C\) | number of channels |
| \(I \in \mathbb{R}^{H \times W}\) | grayscale image |
| \(I \in \mathbb{R}^{H \times W \times C}\) | multi-channel image |
| \(I[i,j]\) | pixel value at row \(i\), column \(j\) |
| \(I[i,j,c]\) | channel-\(c\) pixel value at row \(i\), column \(j\) |
| \(i\) | row index, increasing downward in image coordinates |
| \(j\) | column index, increasing to the right |
| \((x,y)\) | continuous image coordinate, often horizontal then vertical |
| \(\Omega \subset \mathbb{R}^2\) | continuous image domain |
| \(I: \Omega \to \mathbb{R}^C\) | image as a vector-valued function |
| \(\mathbf{p}=(x,y)^T\) | point in the image plane |
| \(\tilde{\mathbf{p}}=(x,y,1)^T\) | homogeneous image point |
In code, an image array usually follows NumPy convention:
I.shape == (H, W) # grayscale
I.shape == (H, W, C) # color or multichannel
I[i, j] # row i, column j
I[i, j, c] # channel cMathematically, it is often more natural to write a point as \((x,y)\), where \(x\) is horizontal and \(y\) is vertical. In arrays, this corresponds approximately to
\[ x \leftrightarrow j, \qquad y \leftrightarrow i. \]
This distinction matters in plotting, interpolation, geometric transformations, and camera models.
Common Image Operations
| Symbol | Meaning |
|---|---|
| \(I * K\) | convolution of image \(I\) with kernel \(K\) |
| \(I \star K\) | cross-correlation of \(I\) with kernel \(K\) |
| \(K[u,v]\) | filter/kernel coefficient at offset \((u,v)\) |
| \(\nabla I\) | image gradient |
| \(I_x\), \(I_y\) | partial derivatives with respect to \(x\) and \(y\) |
| \(\|\nabla I\|\) | gradient magnitude |
| \(\Delta I\) | Laplacian of the image |
| \(G_\sigma\) | Gaussian kernel with standard deviation \(\sigma\) |
| \(G_\sigma * I\) | Gaussian-smoothed image |
| \(\operatorname{DoG}\) | Difference of Gaussians |
| \(\operatorname{med}(I)\) | median-filtered image |
| \(\phi(I)\) | feature map extracted from image \(I\) |
A typical discrete convolution is written as
\[ (I * K)[i,j] = \sum_u \sum_v I[i-u,j-v]K[u,v]. \]
Many deep learning libraries implement cross-correlation rather than flipped-kernel convolution:
\[ (I \star K)[i,j] = \sum_u \sum_v I[i+u,j+v]K[u,v]. \]
Because kernels are learned in CNNs, this distinction usually does not change the expressive power, but it is important for mathematical derivations.
Linear Algebra Notation
| Symbol | Meaning |
|---|---|
| \(\mathbf{x} \in \mathbb{R}^d\) | vector with \(d\) entries |
| \(\mathbf{A} \in \mathbb{R}^{m \times n}\) | matrix with \(m\) rows and \(n\) columns |
| \(\mathbf{A}\mathbf{x}\) | matrix-vector product |
| \(\operatorname{rank}(\mathbf{A})\) | rank of a matrix |
| \(\operatorname{tr}(\mathbf{A})\) | trace of a square matrix |
| \(\det(\mathbf{A})\) | determinant |
| \(\mathbf{I}\) | identity matrix |
| \(\mathbf{0}\) | zero vector or zero matrix, depending on context |
| \(\operatorname{diag}(\mathbf{s})\) | diagonal matrix with diagonal entries from \(\mathbf{s}\) |
| \(\mathbf{A}^+\) | Moore-Penrose pseudoinverse |
| \(\operatorname{vec}(I)\) | vectorization of image \(I\) |
The singular value decomposition is written as
\[ \mathbf{A}=\mathbf{U}\mathbf{\Sigma}\mathbf{V}^T. \]
For image compression, a grayscale image may be approximated by a rank-\(r\) matrix:
\[ I_r = \sum_{k=1}^r \sigma_k \mathbf{u}_k \mathbf{v}_k^T. \]
For least squares, the standard objective is
\[ \min_{\mathbf{x}} \|\mathbf{A}\mathbf{x}-\mathbf{b}\|_2^2. \]
Fourier and Frequency Notation
| Symbol | Meaning |
|---|---|
| \(\omega\) | angular frequency |
| \(k\), \(\ell\) | discrete frequency indices |
| \(\widehat{I}\) | Fourier transform of \(I\) |
| \(\mathcal{F}\{I\}\) | Fourier transform of \(I\) |
| \(\mathcal{F}^{-1}\) | inverse Fourier transform |
| \(|\widehat{I}|\) | Fourier magnitude spectrum |
| \(\arg(\widehat{I})\) | Fourier phase spectrum |
| \(\operatorname{DFT}\) | discrete Fourier transform |
| \(\operatorname{DCT}\) | discrete cosine transform |
| \(H(\omega)\) | frequency response of a filter |
For a 2D image, the discrete Fourier transform is often written as
\[ \widehat{I}[k,\ell] = \sum_{i=0}^{H-1}\sum_{j=0}^{W-1} I[i,j] \exp\left(-2\pi \sqrt{-1}\left(\frac{ki}{H}+\frac{\ell j}{W}\right)\right). \]
The convolution theorem states that convolution in the image domain corresponds to multiplication in the frequency domain:
\[ \mathcal{F}\{I*K\} = \mathcal{F}\{I\}\,\mathcal{F}\{K\}. \]
Geometry, Cameras, and Projection
| Symbol | Meaning |
|---|---|
| \(\mathbf{X}=(X,Y,Z)^T\) | 3D point in Euclidean coordinates |
| \(\tilde{\mathbf{X}}=(X,Y,Z,1)^T\) | homogeneous 3D point |
| \(\mathbf{x}=(x,y)^T\) | 2D image point |
| \(\tilde{\mathbf{x}}=(x,y,1)^T\) | homogeneous 2D image point |
| \(\mathbf{K}\) | camera intrinsic matrix |
| \(\mathbf{R}\) | rotation matrix |
| \(\mathbf{t}\) | translation vector |
| \([\mathbf{R}\mid \mathbf{t}]\) | extrinsic camera matrix |
| \(\mathbf{P}=\mathbf{K}[\mathbf{R}\mid \mathbf{t}]\) | full camera projection matrix |
| \(f_x\), \(f_y\) | focal lengths in pixel units |
| \((c_x,c_y)\) | principal point |
| \(Z\) | depth in camera coordinates |
| \(\pi(\cdot)\) | perspective projection map |
The pinhole camera model is written in homogeneous form as
\[ \tilde{\mathbf{x}} \sim \mathbf{P}\tilde{\mathbf{X}}, \qquad \mathbf{P}=\mathbf{K}[\mathbf{R}\mid \mathbf{t}], \]
where \(\sim\) means equality up to a nonzero scale. In inhomogeneous coordinates, a camera-coordinate point \((X,Y,Z)\) projects approximately to
\[ x=f_x\frac{X}{Z}+c_x, \qquad y=f_y\frac{Y}{Z}+c_y. \]
Two-View and Multi-View Geometry
| Symbol | Meaning |
|---|---|
| \(\mathbf{F}\) | fundamental matrix |
| \(\mathbf{E}\) | essential matrix |
| \(\mathbf{e}\), \(\mathbf{e}'\) | epipoles |
| \(\mathbf{l}'=\mathbf{F}\tilde{\mathbf{x}}\) | epipolar line in the second image |
| \(\tilde{\mathbf{x}}'^T\mathbf{F}\tilde{\mathbf{x}}=0\) | epipolar constraint |
| \(d\) | disparity in rectified stereo |
| \(B\) | stereo baseline |
| \(Z=fb/d\) | rectified stereo depth formula |
| \(\mathbf{X}_n\) | \(n\)th 3D point |
| \(\mathbf{P}_m\) | \(m\)th camera matrix |
| \(\mathbf{x}_{mn}\) | observation of point \(n\) in camera \(m\) |
Bundle adjustment is written as a nonlinear least-squares problem:
\[ \min_{\{\mathbf{P}_m\},\{\mathbf{X}_n\}} \sum_{(m,n)\in \mathcal{O}} \left\| \mathbf{x}_{mn}-\pi(\mathbf{P}_m,\mathbf{X}_n) \right\|_2^2, \]
where \(\mathcal{O}\) is the set of observed camera-point pairs.
Motion and Optical Flow
| Symbol | Meaning |
|---|---|
| \(I(x,y,t)\) | video intensity as a function of space and time |
| \(u(x,y)\) | horizontal optical-flow component |
| \(v(x,y)\) | vertical optical-flow component |
| \(\mathbf{w}(x,y)=(u,v)^T\) | optical-flow vector field |
| \(I_t\) | time derivative |
| \(I_xu+I_yv+I_t=0\) | optical-flow constraint equation |
| \(\mathbf{J}\) | structure tensor or Jacobian, depending on context |
| \(\rho(\cdot)\) | robust penalty function |
Brightness constancy is commonly written as
\[ I(x+u,y+v,t+1) \approx I(x,y,t). \]
A first-order Taylor expansion gives
\[ I_xu+I_yv+I_t \approx 0. \]
Segmentation, Masks, and Shape
| Symbol | Meaning |
|---|---|
| \(M\) | binary mask |
| \(M[i,j]\in\{0,1\}\) | binary pixel label |
| \(S\) | segmentation label field |
| \(S[i,j]\in\{1,\dots,K\}\) | class label at pixel \((i,j)\) |
| \(P_k[i,j]\) | predicted probability of class \(k\) at pixel \((i,j)\) |
| \(\Gamma\) | curve or object boundary |
| \(\phi\) | level-set function or signed distance function |
| \(\kappa\) | curvature |
| \(\operatorname{IoU}\) | intersection over union |
| \(\operatorname{Dice}\) | Dice score |
| \(\operatorname{PQ}\) | panoptic quality |
For binary masks \(M\) and \(N\),
\[ \operatorname{IoU}(M,N) = \frac{|M\cap N|}{|M\cup N|}, \]
and
\[ \operatorname{Dice}(M,N) = \frac{2|M\cap N|}{|M|+|N|}. \]
A level-set representation describes a boundary as
\[ \Gamma = \{(x,y): \phi(x,y)=0\}. \]
Probability and Statistics
| Symbol | Meaning |
|---|---|
| \(X\) | random variable or random vector |
| \(p(x)\) | probability density or mass function |
| \(p(y\mid x)\) | conditional probability of \(y\) given \(x\) |
| \(\mathbb{E}[X]\) | expectation |
| \(\operatorname{Var}(X)\) | variance |
| \(\operatorname{Cov}(X,Y)\) | covariance |
| \(\mathbf{\Sigma}\) | covariance matrix |
| \(\mathcal{N}(\mu,\sigma^2)\) | normal distribution with mean \(\mu\) and variance \(\sigma^2\) |
| \(\mathcal{N}(\boldsymbol{\mu},\mathbf{\Sigma})\) | multivariate normal distribution |
| \(\ell(\theta)\) | log-likelihood |
| \(\hat{\theta}\) | estimator of parameter \(\theta\) |
| \(\operatorname{MAP}\) | maximum a posteriori estimate |
A common image observation model is
\[ Y = I + \varepsilon, \qquad \varepsilon \sim \mathcal{N}(0,\sigma^2), \]
or, for inverse problems,
\[ Y = A I + \varepsilon, \]
where \(A\) may represent blur, projection, masking, or another measurement operator.
Bayes’ rule is written as
\[ p(\theta \mid y) = \frac{p(y\mid \theta)p(\theta)}{p(y)}. \]
Optimization and Loss Functions
| Symbol | Meaning |
|---|---|
| \(\theta\) | model parameters |
| \(L(\theta)\) | loss or objective function |
| \(\nabla_\theta L\) | gradient with respect to \(\theta\) |
| \(\nabla^2_\theta L\) | Hessian with respect to \(\theta\) |
| \(\eta\) | learning rate or step size |
| \(\lambda\) | regularization parameter |
| \(R(\theta)\) | regularization term |
| \(\rho(r)\) | robust penalty applied to residual \(r\) |
| \(\mathbf{J}\) | Jacobian matrix |
| \(\mathbf{H}\) | Hessian or approximate Hessian |
Empirical risk minimization is written as
\[ \min_\theta \frac{1}{n}\sum_{i=1}^n \ell(f_\theta(x_i),y_i) +\lambda R(\theta). \]
Gradient descent updates parameters by
\[ \theta_{k+1}=\theta_k-\eta \nabla_\theta L(\theta_k). \]
For nonlinear least squares, one often minimizes
\[ \min_\theta \frac12\|\mathbf{r}(\theta)\|_2^2. \]
The Gauss-Newton approximation uses
\[ \mathbf{H}\approx \mathbf{J}^T\mathbf{J}. \]
Classification and Prediction
| Symbol | Meaning |
|---|---|
| \(x\) | input image or feature vector |
| \(y\) | class label |
| \(K\) | number of classes |
| \(f_\theta(x)\) | model output |
| \(z_k\) | logit for class \(k\) |
| \(p_k\) | predicted probability for class \(k\) |
| \(\operatorname{softmax}\) | normalized exponential map from logits to probabilities |
| \(\hat{y}\) | predicted class |
| \(\mathbf{1}\{\cdot\}\) | indicator function |
Softmax probabilities are
\[ p_k = \frac{\exp(z_k)}{\sum_{j=1}^K \exp(z_j)}. \]
The multiclass cross-entropy loss for one example is
\[ \ell(\mathbf{z},y) = -\log p_y. \]
For a one-hot label vector \(\mathbf{y}\), the same loss is
\[ \ell(\mathbf{z},\mathbf{y}) = -\sum_{k=1}^K y_k\log p_k. \]
Neural Network Notation
| Symbol | Meaning |
|---|---|
| \(f_\theta\) | neural network with parameters \(\theta\) |
| \(\mathbf{h}^{(\ell)}\) | hidden representation at layer \(\ell\) |
| \(\mathbf{W}^{(\ell)}\) | weight matrix at layer \(\ell\) |
| \(\mathbf{b}^{(\ell)}\) | bias vector at layer \(\ell\) |
| \(\sigma(\cdot)\) | nonlinear activation function |
| \(\operatorname{ReLU}(z)\) | rectified linear unit, \(\max(0,z)\) |
| \(\operatorname{BN}\) | batch normalization |
| \(\operatorname{LN}\) | layer normalization |
| \(\operatorname{dropout}\) | random unit masking regularization |
A fully connected layer is written as
\[ \mathbf{h}^{(\ell+1)} = \sigma\left(\mathbf{W}^{(\ell)}\mathbf{h}^{(\ell)}+\mathbf{b}^{(\ell)}\right). \]
A residual block is written as
\[ \mathbf{h}^{(\ell+1)} = \mathbf{h}^{(\ell)}+F_\theta(\mathbf{h}^{(\ell)}). \]
CNN Notation
| Symbol | Meaning |
|---|---|
| \(X \in \mathbb{R}^{H\times W\times C_{\text{in}}}\) | input feature map |
| \(Y \in \mathbb{R}^{H'\times W'\times C_{\text{out}}}\) | output feature map |
| \(K\) | convolution kernel or kernel size, depending on context |
| \(C_{\text{in}}\) | number of input channels |
| \(C_{\text{out}}\) | number of output channels |
| \(s\) | stride |
| \(p\) | padding |
| \(d\) | dilation |
| \(r\) | receptive-field size |
For one output channel of a convolutional layer,
\[ Y[i,j] = \sum_{u,v,c} X[i+u,j+v,c]K[u,v,c]+b. \]
The output size for a one-dimensional convolution is commonly
\[ H' = \left\lfloor\frac{H+2p-d(k-1)-1}{s}+1\right\rfloor. \]
The same formula applies to width with \(W\) in place of \(H\).
Transformer and Attention Notation
| Symbol | Meaning |
|---|---|
| \(N\) | number of tokens |
| \(d\) | embedding dimension |
| \(\mathbf{X}\in\mathbb{R}^{N\times d}\) | token matrix |
| \(\mathbf{q}_i\) | query vector for token \(i\) |
| \(\mathbf{k}_i\) | key vector for token \(i\) |
| \(\mathbf{v}_i\) | value vector for token \(i\) |
| \(\mathbf{Q}\) | query matrix |
| \(\mathbf{K}\) | key matrix |
| \(\mathbf{V}\) | value matrix |
| \(\mathbf{A}\) | attention-weight matrix |
| \(d_k\) | key/query dimension |
| \(P\) | patch size in a vision transformer |
| \(\mathbf{e}_{\text{cls}}\) | class token embedding |
| \(\mathbf{E}_{\text{pos}}\) | positional embedding matrix |
Scaled dot-product attention is
\[ \operatorname{Attention}(\mathbf{Q},\mathbf{K},\mathbf{V}) = \operatorname{softmax}\left(\frac{\mathbf{Q}\mathbf{K}^T}{\sqrt{d_k}}\right)\mathbf{V}. \]
For a vision transformer, an image is divided into patches and mapped to tokens:
\[ I \longmapsto (\mathbf{x}_1,\dots,\mathbf{x}_N), \qquad \mathbf{x}_i\in\mathbb{R}^d. \]
Self-Supervised and Contrastive Learning
| Symbol | Meaning |
|---|---|
| \(a\), \(a'\) | random augmentations |
| \(x_i^+=a(x_i)\) | augmented positive view |
| \(z_i\) | normalized embedding |
| \(\tau\) | contrastive temperature |
| \(\operatorname{sim}(z_i,z_j)\) | similarity score, usually cosine similarity |
| \(\ell_{\text{InfoNCE}}\) | contrastive InfoNCE loss |
| \(B\) | batch size |
A common contrastive loss is
\[ \ell_i = -\log \frac{\exp(\operatorname{sim}(z_i,z_i^+)/\tau)} {\sum_j \exp(\operatorname{sim}(z_i,z_j)/\tau)}. \]
Representation quality is often evaluated by linear probing, nearest-neighbor retrieval, clustering, or downstream fine-tuning.
Vision-Language and Multimodal Notation
| Symbol | Meaning |
|---|---|
| \(I\) | image input |
| \(T\) | text input |
| \(g_\theta(I)\) | image encoder |
| \(h_\phi(T)\) | text encoder |
| \(\mathbf{z}_I\) | image embedding |
| \(\mathbf{z}_T\) | text embedding |
| \(\operatorname{sim}(\mathbf{z}_I,\mathbf{z}_T)\) | image-text similarity |
| \(Q\), \(K\), \(V\) | query, key, value matrices in cross-attention |
| \(\alpha_{ij}\) | attention weight from token \(i\) to token \(j\) |
A CLIP-style similarity score may be written as
\[ s(I,T) = \frac{g_\theta(I)^T h_\phi(T)}{\|g_\theta(I)\|_2\,\|h_\phi(T)\|_2}. \]
Zero-shot classification compares an image embedding to text embeddings of class prompts:
\[ \hat{y} = \arg\max_k s(I,T_k). \]
Diffusion Model Notation
| Symbol | Meaning |
|---|---|
| \(x_0\) | clean image or latent variable |
| \(x_t\) | noisy image or latent at diffusion time \(t\) |
| \(T\) | total number of diffusion steps |
| \(\beta_t\) | noise variance schedule |
| \(\alpha_t=1-\beta_t\) | retained signal coefficient |
| \(\bar{\alpha}_t=\prod_{s=1}^t \alpha_s\) | cumulative signal coefficient |
| \(\varepsilon\) | standard Gaussian noise |
| \(\varepsilon_\theta(x_t,t)\) | neural network prediction of noise |
| \(s_\theta(x_t,t)\) | score model, approximating \(\nabla_{x_t}\log p_t(x_t)\) |
| \(c\) | conditioning signal, such as text prompt or class label |
| \(w\) | classifier-free guidance scale |
The forward noising process is
\[ x_t = \sqrt{\bar{\alpha}_t}x_0 + \sqrt{1-\bar{\alpha}_t}\,\varepsilon, \qquad \varepsilon\sim\mathcal{N}(0,\mathbf{I}). \]
A simplified denoising objective is
\[ \min_\theta \mathbb{E}_{x_0,t,\varepsilon} \left[ \|\varepsilon-\varepsilon_\theta(x_t,t)\|_2^2 \right]. \]
Classifier-free guidance combines conditional and unconditional predictions:
\[ \hat{\varepsilon} = \varepsilon_\theta(x_t,t,\varnothing) +w\left( \varepsilon_\theta(x_t,t,c)-\varepsilon_\theta(x_t,t,\varnothing) \right). \]
Data, Datasets, and Splits
| Symbol | Meaning |
|---|---|
| \(\mathcal{D}\) | dataset |
| \(n\) | number of examples |
| \((x_i,y_i)\) | input-label pair |
| \(\mathcal{D}_{\text{train}}\) | training set |
| \(\mathcal{D}_{\text{val}}\) | validation set |
| \(\mathcal{D}_{\text{test}}\) | test set |
| \(B\) | mini-batch size |
| \(\operatorname{Aug}(x)\) | augmented version of \(x\) |
A supervised dataset is written as
\[ \mathcal{D}=\{(x_i,y_i)\}_{i=1}^n. \]
For segmentation, one example may be an image-mask pair
\[ (I_i,M_i). \]
For vision-language learning, one example may be an image-text pair
\[ (I_i,T_i). \]
Metrics
| Symbol | Meaning |
|---|---|
| \(\operatorname{Acc}\) | accuracy |
| \(\operatorname{Prec}\) | precision |
| \(\operatorname{Rec}\) | recall |
| \(F_1\) | harmonic mean of precision and recall |
| \(\operatorname{ROC}\) | receiver operating characteristic curve |
| \(\operatorname{AUC}\) | area under ROC curve |
| \(\operatorname{AP}\) | average precision |
| \(\operatorname{mAP}\) | mean average precision |
| \(\operatorname{ECE}\) | expected calibration error |
| \(\operatorname{EPE}\) | endpoint error for optical flow |
| \(\operatorname{RMSE}\) | root mean squared error |
| \(\operatorname{PSNR}\) | peak signal-to-noise ratio |
| \(\operatorname{SSIM}\) | structural similarity index |
For a regression or reconstruction task, mean squared error is
\[ \operatorname{MSE}(\hat{y},y) = \frac1n\sum_{i=1}^n(\hat{y}_i-y_i)^2. \]
For optical flow, endpoint error is
\[ \operatorname{EPE} = \frac1n\sum_i \left\| \hat{\mathbf{w}}_i-\mathbf{w}_i \right\|_2. \]
Common Operators in Code and Mathematics
| Mathematical operation | Typical Python expression |
|---|---|
| Dot product \(\mathbf{x}^T\mathbf{y}\) | x @ y or np.dot(x, y) |
| Matrix product \(\mathbf{A}\mathbf{B}\) | A @ B |
| Elementwise product \(x_i y_i\) | x * y |
| Transpose \(\mathbf{A}^T\) | A.T |
| Inverse \(\mathbf{A}^{-1}\) | np.linalg.inv(A) |
| Solve \(\mathbf{A}\mathbf{x}=\mathbf{b}\) | np.linalg.solve(A, b) |
| Least squares | np.linalg.lstsq(A, b) |
| SVD | np.linalg.svd(A) |
| Mean over axis | np.mean(X, axis=...) |
| Norm | np.linalg.norm(x) |
| FFT | np.fft.fft2(I) |
| Image gradient | finite differences, Sobel filters, or np.gradient |
When possible, prefer solving linear systems directly instead of forming explicit matrix inverses. For example, write np.linalg.solve(A, b) rather than np.linalg.inv(A) @ b.
Ambiguous Symbols Used with Local Meaning
Some symbols are common enough that they are reused with different meanings in different chapters. The local meaning should always be clear from context.
| Symbol | Possible meanings |
|---|---|
| \(K\) | kernel, number of classes, intrinsic camera matrix when bold \(\mathbf{K}\) |
| \(P\) | projection matrix, patch size, probability when written as \(p\) |
| \(d\) | dimension, disparity, dilation, distance |
| \(B\) | batch size, stereo baseline |
| \(T\) | time horizon, text input, transpose when written as superscript \(T\) |
| \(H\) | image height, Hessian matrix when bold \(\mathbf{H}\) |
| \(F\) | feature map, fundamental matrix when bold \(\mathbf{F}\) |
| \(E\) | expectation when written \(\mathbb{E}\), essential matrix when bold \(\mathbf{E}\) |
| \(\phi\) | feature map, level-set function, neural parameter map |
| \(\theta\) | model parameter, camera angle, optimization variable |
Reading Strategy
When a new formula appears, students should ask four questions:
- What type of object is each symbol? Is it a scalar, vector, matrix, tensor, function, probability distribution, or set?
- What are the dimensions? For example, does a matrix product make sense?
- What is observed and what is unknown? Computer vision often estimates hidden structure from measured images.
- What operation is being performed? Is it projection, convolution, differentiation, optimization, conditioning, sampling, or attention?
This habit turns formulas into computational objects and makes the Python labs easier to understand.
Minimal Dimension Checklist
Before implementing a formula, check dimensions.
| Formula | Dimension check |
|---|---|
| \(\mathbf{A}\mathbf{x}=\mathbf{b}\) | \(\mathbf{A}\in\mathbb{R}^{m\times n}\), \(\mathbf{x}\in\mathbb{R}^n\), \(\mathbf{b}\in\mathbb{R}^m\) |
| \(\mathbf{x}^T\mathbf{y}\) | both vectors have same length |
| \(\mathbf{P}\tilde{\mathbf{X}}\) | \(\mathbf{P}\in\mathbb{R}^{3\times4}\), \(\tilde{\mathbf{X}}\in\mathbb{R}^4\) |
| \(\mathbf{F}\tilde{\mathbf{x}}\) | \(\mathbf{F}\in\mathbb{R}^{3\times3}\), \(\tilde{\mathbf{x}}\in\mathbb{R}^3\) |
| \(\mathbf{Q}\mathbf{K}^T\) | \(\mathbf{Q},\mathbf{K}\in\mathbb{R}^{N\times d_k}\), result in \(\mathbb{R}^{N\times N}\) |
| \(\operatorname{softmax}(\mathbf{z})\) | logits and probabilities have same class dimension |
| \(I*K\) | output size depends on padding, stride, and boundary convention |
Dimension checking is one of the most useful debugging tools in modern computer vision.