AI & ML Math with Python

Define scalars, vectors, and matrices and perform basic operations in NumPy.

Explain matrix multiplication, properties of matrix operations, and the concept of a matrix inverse.

Formulate a system of linear equations in the matrix form Ax=b and solve it using NumPy.

Explain the geometric interpretation of eigenvalues and eigenvectors as the scaling and principal direction of a linear transformation.

Compute eigenvalues and eigenvectors using NumPy and visualize their effect on a vector.

Compute and interpret descriptive statistics (mean, median, variance) using NumPy.

Model binary outcomes using the Bernoulli distribution.

Explain the principle of Maximum Likelihood Estimation (MLE).

Visualize probability distributions and statistics using Matplotlib and Seaborn.

Perform random sampling from a dataset using NumPy.

Evaluate algebraic limits and compute simple derivatives using the limit definition.

Apply product, quotient, and chain rules to differentiate complex functions.

Compute partial derivatives of multivariable functions.

Compute and interpret the gradient of a scalar-valued function.

Calculate directional derivatives using the gradient vector.

Find critical points of multivariable functions by setting the gradient to zero.

Classify critical points of multivariable functions using the Hessian matrix.

Formulate an optimization problem by identifying its objective function, decision variables, and constraints.

Define convex functions and explain the significance of convexity for optimization.

Apply the gradient descent update rule and explain its geometric intuition.

Implement multivariable gradient descent from scratch in NumPy.

Tune learning rates and analyze their effects on convergence.

Compare batch, stochastic, and mini-batch gradient descent.

Implement mini-batch gradient descent from scratch in Python.

Formulate the multiple linear regression model and its assumptions.

Derive the Ordinary Least Squares (OLS) solution using partial derivatives.

Derive the Normal Equation solution for multiple linear regression.

Implement multiple linear regression from scratch using the Normal Equation.

Implement gradient descent for multiple linear regression from scratch.

Compare the computational and practical tradeoffs between the Normal Equation and Gradient Descent.

Evaluate regression models using Mean Squared Error (MSE) and R-squared.

Implement polynomial regression to capture non-linear relationships.

Explain how the sigmoid function maps linear scores to probabilities for binary classification.

Formulate the logistic regression model and its linear decision boundary.

Derive the gradient of the binary cross-entropy loss function with respect to model weights.

Implement logistic regression using mini-batch gradient descent from scratch.

Construct a confusion matrix and calculate model accuracy.

Calculate precision, recall, and F1-score to evaluate performance on imbalanced datasets.

Apply Lagrange multipliers to formulate the Support Vector Machine (SVM) optimization problem.

Implement a simple linear SVM classifier for a toy dataset.

Describe the core components of a feedforward neural network: layers, weights, biases, and activation functions.

Differentiate between binary and multiclass classification problems.

Implement the forward and backward pass for a softmax regression model.

Explain the role of the multivariable chain rule in the backpropagation algorithm.

Compute the Jacobian matrix and explain its role in vector function transformations.

Implement the forward propagation module for a two-layer neural network from scratch.

Implement the backward propagation module for a two-layer neural network from scratch.

Integrate forward and backward propagation into a complete model training loop.

Analyze the bias-variance tradeoff in relation to model complexity.

Diagnose model performance (underfitting vs. overfitting) using learning curves.

Explain how L2 regularization (weight decay) penalizes large model weights to reduce overfitting.

Implement L2 (Ridge) regularization for the linear regression model from scratch.

Explain how L1 regularization promotes model sparsity.

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

Implement dropout as a regularization technique for neural networks.

Create, manipulate, and perform operations on PyTorch tensors.

Apply PyTorch's autograd to compute gradients automatically.

Define a custom neural network architecture using PyTorch's `nn.Module`.

Explain the Adam optimization algorithm by combining the concepts of momentum and adaptive learning rates.

Implement a complete training and evaluation loop in PyTorch using a built-in dataset.

Build, train, and evaluate a Convolutional Neural Network (CNN) for image classification in PyTorch.

Explain the architecture of a Recurrent Neural Network (RNN) for sequence modeling.

Build, train, and evaluate an LSTM-based model for a sequence prediction task in PyTorch.