Master Deep Learning using Case Studies : Beginner-Advance

Explore artificial neural networks from perceptron basics to feedforward structures. Learn backpropagation, optimization techniques, and hyperparameter tuning for tasks such as image and video recognition.

Explore deep learning foundations by tracing neural networks from perceptrons to artificial neurons, using inputs, weights, dendrites, and activation functions to generate outputs and show how learning strengthens connections.

Explore using a perceptron as a binary classifier, with input vectors X and weights W, bias, and sign activation to decide outcomes like heart disease risk or a restaurant choice.

Explore how a perceptron uses weights and bias to separate data with W^T X + B > 0 for positives and < 0 for negatives, defining a decision line.

Discover how homogeneous coordinates simplify perceptron training by augmenting input vectors with a bias term, turning W^T X plus bias into a simple vector operation.

Explore Rosenblatt's perceptron training algorithm, iteratively updating weights to correct misclassified points using a simple dot-product rule, with homogeneous coordinates handling the bias.

Explore neural networks as layers of artificial neurons with nonlinear activation functions, extending perceptron beyond step function and using input and output layers, weights, and bias for classification or regression.

Explore the output layer by comparing sigmoid and softmax activations for binary and multiclass classification. Learn how to compute class probabilities using e^(w^T x) and the sum across output neurons.

Explore the sigmoid function as a binary classification tool. Understand its relation to softmax with one output neuron and probabilistic outputs using exponentials.

Six core neural network assumptions include layered architecture, dense interlayer connections, non interacting neurons within a layer, input enters the input layer, weights and biases, and uniform activation per layer.

Explore how neural networks train by learning weights and biases and using gradient descent, set hyperparameters like layers and neurons, and map input to a 10-class output via dense connections.

Master neural network notations, including X as input, Y as labels, W and B as weights and biases, and probability outputs with softmax and sigmoid across layers.

Explore how a neuron's output is computed by activation functions from cumulative input, emphasizing smoothness and nonlinearity, and compare sigmoid, tanh, and ReLU families with forward propagation.

Explore how information flows in a feedforward neural network, from input to output layers, using weight matrices, biases, dot products, and activation functions to perform forward propagation.

Explore how forward propagation processes a simple image: count ones in pixels, amplify counts through two hidden layers, and backtrack weights with a zero bias.

Explore dimensions in a multi-layer network by identifying input size, weight matrices, bias vectors, and hidden layer outputs, and compute the total number of learnable parameters.

Train a neural network from scratch by minimizing loss through back propagation and gradient descent, tuning weights and biases to reduce average loss across training data.

Minimize neural network loss by updating weights and biases with gradient descent using a learning rate alpha. Understand the cost function and its multivariate gradients.

Explore backpropagation in a three-layer network, focusing on updating weights and biases to minimize the average loss. Learn feedforward, loss, gradient calculation, and parameter updates for training neural networks.

Explore forward propagation and the cross-entropy loss in a multi-class network, defining gradients for backward propagation to minimize error and improve probability predictions.

The lecture explains computing gradients for backpropagation through a three-weight network, applying the chain rule to derive loss derivatives with respect to weights and outputs, and using gradient descent.

Demonstrate backpropagation by computing gradients for a multi-layer network, linking forward propagation to backward derivatives and updating weights through the gradient descent process.

Explore sigmoid backpropagation for binary classification using a single-output neuron, derive cross-entropy loss gradients, and apply the chain rule to compute backpropagation steps.

Master backpropagation by computing gradients and derivatives to update weights, with simplified softmax gradients and a two-neuron output layer.

Compute the gradient of the loss with respect to W1, W2, and W3 using the chain rule and intermediate variables, then update the weights with the learning rate alpha.

Follow the back propagation training part 8, using the chain rule to compute derivatives and gradients of the loss with respect to the network weights, addressing two questions.

Demonstrates computing backpropagation updates for w1, w2, and w3 using sigmoid activations, deriving gradients, and expressing them in vector form, while noting libraries handle these computations in practice.

Trace the forward pass through a three-layer network from input to output probabilities and outline the backpropagation gradient computations for each layer, preparing for pseudocode in the next lecture.

Define the backpropagation pseudocode for a deep learning model, outlining the forward pass, loss function, gradient calculations, and batch weight updates across layers.

Learn how stochastic gradient descent uses mini-batches to update weights and biases efficiently. Define epochs, batch sizes, and reshuffling to enable robust training on large datasets.

Explore how gradient descent can trap in local minima and improve finding the global minimum by exploring multiple starting points for W and B.

Learn how to perform backpropagation for batches, compute the average loss across a batch, and update weights and biases accordingly.

Apply dropout to neural networks per layer to combat overfitting by randomly masking connections during training with bernoulli-based masks and probabilistic alpha vectors.

Explore batch normalization as a regularisation technique that stabilizes training by decoupling layer updates in backpropagation and addressing nonlinear dependencies across weight matrices.

This lecture explains batch normalization by normalizing the output vectors across the batch using the batch mean and standard deviation, applying the normalization to each column of the data matrix.

Learn how videos are processed as sequences of frames by applying a CNN to extract per-frame features and producing a video feature vector via a sequential network for classification.

Discover how Keras provides a wrapper around TensorFlow to simplify deep learning, while TensorFlow underpins numerical computation with dataflow graphs, placeholders, and sessions.

Learn how Keras provides a high-level API on top of TensorFlow to build and deploy deep learning models with just a few lines of Python, using a six-step workflow.

Discover how CNNs enable object localization and semantic segmentation, perform optical character recognition, and support medical imaging, radiology, cardiology, and gastroenterology, plus insurance surveillance and disaster assessment.

Explore cnn architecture at a high level using regnet as a simple example, showing how an image passes through convolution and pooling to produce a classification.

Explore how convolutional neural networks extract features from images through convolution, relu, and max pooling, reducing spatial size and building feature maps for softmax classification.

Treat video as a sequence of frames, use CNNs to extract per-frame features, then a sequential network to produce a video feature vector for classification with a softmax function.

Apply convolution with filters to detect edges and features in images, exploring vertical, horizontal, and diagonal edges with Sobel-like kernels and multiple filters for richer feature extraction.

Learn how stride controls how many steps the filter moves across an image during convolution, and how padding preserves edge information by using zero or last-value padding.

Padding in convolutional networks preserves the input size, preventing information loss, and explains how kernel size and padding determine output dimensions.

Derive a generic convolution output size formula using input size, padding, filter size, and stride, and apply it to 24x24 inputs to determine possible outputs.

See how a deep cnn uses convolution with multiple filters to create feature maps, applies pooling and relu activation, flattens outputs, and stacks layers toward a fully connected network.

Learn hands-on deep learning in Google Colab with GPU, using dropout, batch normalization, and convolutional nets on a CIFAR dataset; tune filters, regularization, and evaluate with cross-entropy and accuracy.

Examine dropout after each convolutional layer with L2 regularization and batch normalization, and test an extra convolutional layer to compare accuracy and training time.

Increase the convolutional feature maps from 32 to 64 and 128, compare with adding a convolutional layer, and apply l2 while observing 92% training vs 84% validation, hinting at overfitting.

Demonstrate an end-to-end cnn training pipeline through hands-on case studies, from flower classification to chest x-ray imaging, with preprocessing, augmentation, and model tuning.

Load a two-class flower dataset, use glob for file listing, preprocess with the escape image library, and plot random sample images to illustrate CNN data preparation.

Explore image preprocessing for natural and non-natural images, including resizing, RGB to grayscale conversion, binary masks, and morphological operations such as thresholding, erosion, dilation, opening, and closing for segmentation.

Explore morphology operations (erosion, dilation, opening, and closing) and learn how to remove dark spots and connect bright regions in images, including brain x-ray examples.

Demonstrates applying translation and linear transformations to images, including flips, zoom, scaling, 45-degree rotation around the center, and shear; adds noise and explores normalization with 25th and 75th percentiles.

Apply and verify image transformations in a deep learning case study: left-right and up-down flips, normalize between 25 and 75 percent, and perform a 90-degree rotation with fourfold zoom.

Explore building your own customized data generator for deep learning, enabling train–validation–test splits, batch processing (32 images), shuffling, and returning (x, y) batches while applying transformations only to training data.

Investigate overfitting of training data by training across epochs, observe loss decline and accuracy growth, and adjust activation functions, learning rate, optimizer (Adam), Xavier initialization, and network architecture.

Learn how to tune hyperparameters and leverage Keras callbacks to monitor losses, save models, and adjust learning rate for efficient deep learning training.

Apply training-time augmentation via a custom data generator by rotating, shifting, and flipping images. Use a callback to track a robust metric per epoch rather than accuracy on imbalanced data.

Develop deep learning models to detect early lung abnormalities from x-ray images by fusing normal and abnormal images, using Keras, aiming to save lives.

Explore case study driven deep learning for X-ray bone images, focusing on mindful data augmentation, rotations and flips, and min-max normalization to prepare data and build a robust model.

Explore an end-to-end deep learning case study pipeline with data augmentation, cross-entropy loss, and model checkpointing guided by validation accuracy to predict medical images and detect early disease signs.

Explore AlexNet's eight-layer CNN, with five convolutional and three fully connected layers using 11x11 and 5x5 kernels, and how small 3x3 filters enable deeper networks like Google Net.

Understand Google Net's inception module, which parallelizes 1x1, 3x3, and 5x5 convolutions to deepen networks while reducing parameters from 60 million to four million, with only the final softmax.

Trace the rise of deep networks from 2012 to 2014, examine residual networks and skip connections, and see how deeper models up to 150 layers improve training and accuracy.

Apply transfer learning to reuse skills from one task to a related one, explaining why data abundance or limited compute motivates this approach, with driverless car and pre-trained model examples.

Apply transfer learning with pre-trained convolutional networks, reuse generic initial-layer features and tailor the final layers for new image classifications.

Utilize transfer learning by leveraging a pre-trained model's general features and replacing the last layer for task-specific learning with limited data, using video frames for classification.

Explore practical transfer learning strategies: freeze initial layers and train only newly added layers, or retrain the full network with a reduced learning rate to adapt pretrained models.

Explore when to apply transfer learning using pretrained networks or your own models, freeze initial layers and retrain the last layers, and decide based on task similarity.

Learn transfer learning in python using a google dataset with five classes and a pretrained resnet, exploring freezing strategies, data preprocessing, augmentation, and on-the-fly data generation.

Learn how data augmentation increases training data variance through rotations, flips, zooms, and color tweaks, using data generators that batch and preprocess augmented images, while validation remains unaugmented.

We demonstrate transfer learning experiments by freezing the initial layers and retraining the rest with added pooling and softmax, achieving about 98.6% accuracy in few epochs.

Analyze practical considerations for deep learning models beyond accuracy, comparing architectures on memory footprint, number of parameters, operation count, and power consumption for mobile, real-time phase detection.

identify the hyperbolic trade-off between accuracy and interface time, note power consumption is independent of body size and architecture, and recognize inet as architecture where network operations estimate interface time.