Beginner computer vision from scratch

Compute derivatives of univariate functions using the limit definition and basic differentiation rules (power, product, quotient).

Apply the chain rule to compute derivatives of composite univariate functions.

Compute partial derivatives for multivariable functions.

Calculate the gradient of a scalar-valued multivariable function and interpret it as the direction of steepest ascent.

Compute the Jacobian matrix for vector-valued functions.

Apply the multivariable chain rule to compute gradients of composite functions.

Find local minima and maxima of functions using first and second derivative tests.

Implement a function to numerically approximate the gradient of a multivariable function.

Define probability spaces and events, and apply the axioms of probability.

Apply conditional probability and Bayes' theorem to update beliefs based on evidence.

Define discrete and continuous random variables and their distributions (PMF/PDF).

Compute the expected value and variance of a random variable.

Describe the properties and use cases of key distributions: Bernoulli, Categorical, and Uniform.

Describe the properties of the Gaussian (Normal) distribution and its importance in machine learning.

Define joint, marginal, and conditional probability distributions for multiple random variables.

Compute covariance and correlation to measure the relationship between two random variables.

Formulate a supervised learning problem, distinguishing between features, labels, training, and test sets.

Define common loss functions for regression (Mean Squared Error) and classification (Cross-Entropy).

Derive and implement linear regression using both the closed-form normal equation and gradient descent.

Derive the logistic regression model from the principle of maximum likelihood estimation.

Implement the logistic regression algorithm from scratch using gradient descent for binary classification.

Implement L1 and L2 regularization to prevent overfitting in linear models.

Evaluate classification models using a confusion matrix and metrics such as accuracy, precision, and recall.

Apply k-fold cross-validation for robust model evaluation and hyperparameter tuning.

Define the structure of an artificial neuron and common activation functions (Sigmoid, Tanh, ReLU).

Derive and implement the forward propagation algorithm for a multi-layer perceptron (MLP).

Derive the backpropagation algorithm by applying the chain rule to compute gradients of the loss with respect to network parameters.

Implement the full backpropagation algorithm from scratch for an MLP.

Explain the rationale for weight initialization strategies (e.g., Xavier/Glorot) to aid training.

Analyze the vanishing and exploding gradient problems and the role of activation functions.

Assemble the forward and backward passes into a complete neural network model.

Implement a complete training loop to train the neural network on a dataset using gradient descent.

Differentiate between batch, stochastic (SGD), and mini-batch gradient descent.

Explain and implement momentum to accelerate SGD convergence.

Explain the concept of adaptive learning rates for per-parameter updates.

Describe the Adam optimization algorithm, which combines momentum and adaptive learning rates.

Implement the Adam optimizer from scratch and apply it to a training problem.

Implement dropout regularization to prevent overfitting in neural networks.

Implement batch normalization and explain how it stabilizes training in deep networks.

Apply learning rate scheduling strategies to improve convergence.

Represent digital images as NumPy arrays and perform pixel manipulations.

Perform color space conversions between RGB, Grayscale, and HSV.

Explain and apply image filtering using 2D convolution with a kernel.

Implement edge detection by applying the Sobel operator to approximate image gradients.

Apply geometric transformations to an image, such as scaling, rotation, and translation.

Enhance image contrast using histogram equalization.

Describe the purpose of data augmentation for improving model generalization.

Apply common data augmentation techniques (e.g., random flips, rotations, color jitter) to an image dataset.

Derive the forward pass of a convolutional layer and explain its role in feature extraction.

Compute the output dimensions of a convolutional layer based on input size, kernel size, stride, and padding.

Implement pooling layers (max and average) and explain their function in down-sampling feature maps.

Derive the backpropagation updates for the weights (filters) of a convolutional layer.

Analyze common CNN architectural patterns (e.g., stacking convolutional layers) for building deep models.

Define and build a complete CNN architecture for image classification using a deep learning framework (PyTorch or TensorFlow).

Implement a data loading and preprocessing pipeline for a standard image dataset (e.g., CIFAR-10).

Write a standard training loop to train a CNN, including forward pass, loss computation, backpropagation, and optimizer step.

Describe the concept of transfer learning, including feature extraction and fine-tuning.

Load a pre-trained CNN model and use it for inference on a sample image.

Adapt a pre-trained CNN for a new classification task by replacing and training the final layers (fine-tuning).

Implement early stopping based on validation set performance to prevent overfitting during training.

Visualize the filters learned by the initial layers of a pre-trained CNN.

Visualize the feature maps (activations) of a pre-trained CNN for a given input image to understand what the network 'sees'.

Set up a complete training and evaluation pipeline for fine-tuning a model on a custom dataset.

Compare the performance of a model trained from scratch versus a fine-tuned pre-trained model.

Formulate object detection as a dual task of classification and localization.

Define bounding boxes using coordinate representations (e.g., corner points, center-width-height).

Compute the Intersection over Union (IoU) metric to evaluate the overlap between two bounding boxes.

Explain the sliding window approach and its computational limitations.

Describe the purpose of region proposal methods as an efficient alternative to sliding windows.

Implement the non-maximum suppression (NMS) algorithm to merge overlapping bounding boxes.

Explain the concept of anchor boxes as predefined priors for bounding box regression.

Define and compute Average Precision (AP) and mean Average Precision (mAP) to evaluate object detection models.

Explain the two-stage approach of R-CNN, including its selective search and classification stages.

Describe the improvements of Fast R-CNN, particularly the introduction of ROI Pooling.

Explain the architecture and function of the Region Proposal Network (RPN) in Faster R-CNN.

Describe the complete Faster R-CNN architecture, integrating the RPN and a Fast R-CNN detector.

Explain the single-shot detection approach of YOLO (You Only Look Once).

Describe the YOLO architecture, including its grid-based prediction and unified loss function.

Explain the SSD (Single Shot MultiBox Detector) architecture and its use of multi-scale feature maps.

Compare and contrast the trade-offs (speed vs. accuracy) between two-stage (e.g., Faster R-CNN) and single-shot (e.g., YOLO, SSD) detectors.

Select and prepare a custom dataset for object detection, including image collection and annotation.

Load a pre-trained object detection model (e.g., Faster R-CNN, YOLO) and perform inference on custom images.

Adapt a pre-trained object detection model's architecture for a custom number of classes.

Configure and implement a data loading pipeline for the custom annotated dataset.

Set up and execute a training loop to fine-tune the object detection model on the custom dataset.

Monitor training progress and apply techniques like learning rate adjustment and early stopping.

Evaluate the performance of the fine-tuned model on a custom test set using the mAP metric.

Visualize the model's predictions on test images and analyze common failure modes.