Calculus -for Generative AI ,Data Science & Machine Learning

Explore multivariable calculus by extending derivatives to functions of several variables, using partial derivatives with del notation, holding other variables constant, and applying to examples like Netflix recommendations.

Explore the total derivative of multivariable functions, expressed as a sum of partial derivatives with respect to a single parameter, and apply the chain rule and substitution method.

Learn how Jacobians capture partial derivatives of functions of multiple variables, forming a row vector for a single function and a Jacobian matrix for multiple functions, guiding optimization.

Learn the Hessian, a matrix of second-order derivatives for functions with n variables, built from the Jacobian. See a worked example with f(x,y,z)= x^3 y^2 z, noting symmetry when continuous.

Apply the multivariate chain rule to compute the total derivative of F(x1,...,xn) by forming a Jacobian vector of partials and taking its dot product with dx/dt via transpose.

Apply the multivariate chain rule to differentiate through multiple links, using substitution or a two-step approach, and express the result as a jacobian–vector product.

Explore Taylor series to approximate complex functions by summing simpler functions, building intuition across prior topics and reinforcing analytic techniques in calculus.

Learn how Taylor series approximations turn the nonlinear relationship between turkey mass and oven time into a simple linear estimate near a target mass, enabling a recipe-friendly formula.

Develop intuition for Taylor series by visualizing power series around a point, building zeroth, first, and higher order approximations, with truncation improving the function within a region.

Explore Taylor series as a tool for approximating non-polynomial functions with polynomials near a point, using cosine as a guide and matching zeroth, first, and second order derivatives.

Explore how the Taylor (Maclaurin) series represents e^x as a polynomial by deriving coefficients from repeated derivatives at zero, introducing factorials and the general nth term.

Explore how Taylor series generalizes Maclaurin series by reconstructing a function from its value and derivatives at a point, expanding around p in a one-dimensional series.

Explore Maclaurin and Taylor series by deriving and plotting cos x and 1/x in Python, highlighting well-behaved versus badly behaved functions and the impact of domain on approximation.

Explore artificial neural networks as mathematical functions, from weights and biases to activation functions like tanh and sigmoid, and see how the multivariate chain rule enables learning.

Derive compact neural network equations for two outputs and broader multi-output, using weight matrices, bias vectors, and activation functions in a hidden-layer feedforward model.

Explore how multivariate chain rule enables backpropagation in a fully connected neural network, using a cost function and partial derivatives to adjust weights and biases for training.

Explore the intuition of the sigmoid activation function, learn how weights and bias shape the curve, and visualize fitting data by adjusting W and B.

Demonstrate fitting data with a sigmoid model by tuning W and B to align inputs and outputs, plotting, and highlighting underfitting, overfitting, and the need for robust mathematical methods.

Explore loss functions, including squared error, and learn to minimize them using gradient steps with parameters W and B, learning rate eta, and iterative updates in PyTorch or TensorFlow.

Compute partial derivatives for a sigmoid model to optimize weights and bias using gradient-based updates. The lecture derives the loss and the formulas for ∂L/∂W and ∂L/∂B.

Compute the partial derivative with respect to the bias of the squared loss L=(f(x)−y)^2 for a logistic f(x)=1/(1+e^{−(wx+b)}), yielding ∂L/∂b = 2 (f(x)−y) f(x) (1−f(x)).

Apply neural networks as functions, use a sigmoid with w and b, minimize loss via gradient descent, and implement a sigmoid neuron class with fit and gradient computations.

Implement a Python sigmoid function class to manage W and B and compute loss and gradients. Iteratively update parameters to fit data and visualize the evolving sigmoid and loss.

Explore how the Newton-Raphson method finds roots of f(x)=0 by iterating with initial guesses, using derivatives to extrapolate toward zero, and recognizing convergence challenges.

Implement the Newton-Raphson method in Python by writing a function that takes f, its derivative, an initial guess, epsilon, and max iterations, updating x via x - f(x)/f'(x) until convergence.

Explore linear regression from data cleaning to fitting a line using mean squared error and gradient descent, updating M and C with a learning rate for univariate and multivariate cases.

Implement linear regression in Python by training a model with gradient descent to fit a best-fit line to random test data, updating M and C through iterations.

Evaluate model performance using rmse and r2 score with a linear regression class. The video computes rmse, r2, ssr, and sst, yielding rmse 0.2761 and r2 0.96372.

Apply linear regression with the scikit library to fit data, compare parameters and performance to a scratch implementation, and evaluate with mean squared error and R2 score.

Uncover how calculus drives deep neural networks, from forward passes to matrix representations, guiding gradient-based learning with backpropagation, squared error loss, and learning rate.

Implement a sigmoid neuron from scratch in python, performing forward and backward passes, updating gradients, and training on a moons dataset with train-test split and tqdm progress.

Fit a KNN model with 1000 epochs and a 0.5 learning rate, monitor progress with tqdm, and convert sigmoid outputs to binary to report training 0.85 and validation 0.87.

Extend learning from a sigmoid neuron to a deep network. Compute the forward pass with two inputs and two hidden neurons, and derive gradient updates for W1 to W6 and B1 to B3.

Build a deep neural network from scratch with two inputs, two hidden neurons, and a single output, using sigmoid activations, forward passes, gradient computation, and a fit method to train.

Train a deep neural network from scratch in Python using fit with x_train and y_train, 1000 epochs, and a 0.01 learning rate, achieving 0.87 accuracy and hinting at TensorFlow workflows.

Learn how to use TensorFlow, an open source end-to-end machine learning platform, and install it on your system or via Google Colab for hands-on experiments.

Create tf variables with tf.variable to hold persistent parameters, using an initial value, shape, and name; initialize with glorot uniform or zeros and update via assign or assign_ add.

Learn how to work with tensors by determining shape and rank, casting float32 tensors to int32, and converting tf tensors to numpy arrays using tf.cast, tf.shape, tf.rank, and related methods.

Explore matrix multiplication, transpose and reshaping of tensors using tf dot matmul and tf dot transpose, including perm for higher dimensions and versatile reshape patterns.

Explore tensor operations by concatenating with tf.concat and stacking with tf.stack along different axes, then slice and index tensors and apply tf.math.reduce_sum across axes.

Explore how gradients drive parameter updates in deep learning and learn to compute derivatives analytically and numerically with TensorFlow, using f(x)=4x^2-5x at x=2 to get 11 (analytic) and 10.999 (numerical).

Explore gradients of f(x) with respect to input features x1, x2, ..., xn in a linear regression setup with weights w1, w2, ..., wn and zero bias, introducing autograd.

Explore autograd with TensorFlow by recording operations in a gradient tape to compute derivatives like the gradient of 2x^2 with respect to x. Use persistent tapes for multivariate gradients.

This lecture demonstrates computing gradients of a multivariate function u(x,y,z) using tf gradient tape with persistent as true, initializing x,y,z as tf variables, and extracting du/dx, du/dy, and du/dz.