Artificial Intelligence | GenAI | Course | ChatBot | ChatGPT

Explore how data powers a neural network to predict house cost using inputs such as bedrooms, toilets, square feet, locality. Leverage PyTorch for back propagation and the cost function.

the lecture explains that KL divergence loss equals cross-entropy loss for image and binary classification because one-hot encoding makes the true label log term cancel, leaving cross-entropy.

Explore how linear matrix multiplication yields limited boundaries and how activation functions introduce non-linearity to solve complex, real world data in deep learning; note sigmoid's role as a final layer.

Explore how the sigmoid function clips inputs to 0–1, its derivative around 0.23, and how this leads to vanishing gradients during backpropagation, motivating the use of alternative activation functions.

Understand how regularization and normalization prevent underfitting and overfitting, comparing underfit and memorized models, and learn three methods: L1, L2, and dropout.

Explore data normalization and standardization to align feature scales, using a house dataset and techniques like min-max normalization, batch normalization, and layer normalization.

We take a batch of three values, compute their sum, and divide each value by that sum to normalize all neuron outputs.

Explore layer normalization, which normalizes an entire layer’s output before passing it to the next layer, contrasted with batch normalization in PyTorch, and see its utility for building AI models.

Explore why optimization algorithms matter and learn how gradient descent guides an AI model from any starting point to a cost function's minimum, adjusting weights along the way.

Process a mini batch of 32 data points, compute the loss L32, and backpropagate to update weights; repeat for successive batches and epochs toward the local minimum.

Outline three essentials for building an ai network: data quality and input formatting, model architecture, and training a multilayer perceptron for handwritten mnist digit recognition using pytorch.

Learn to load the MNIST dataset in PyTorch, configure a train loader with batch size 100, and transform data to tensors for 28 by 28 grayscale digit images.

Visualize three MNIST training images from the 28 by 28 grayscale feature by converting tensors to numpy arrays and plotting them with their labels to inspect data quality.

Design a PyTorch neural network with nn.Module and ReLU. Define a 784 input, 400 hidden, 10 output model, use a forward pass, flatten 28x28 images, and note cpu or cuda.

Visualize and debug a PyTorch neural network by flattening 28x28 images to 784 features, performing a forward pass, and inspecting parameters with torch summary.

Explore cross entropy loss with softmax in PyTorch, turning model outputs into probabilities that sum to one and revealing the predicted class.

Apply the Adam optimizer to a fresh model to find the global minima of the model's function and inspect the parameters across 123456 layers.

Train a neural network through ten epochs over 60,000 images, computing cross-entropy loss, backpropagating errors, and updating weights with an optimizer while tracking loss and accuracy up to 99.2 percent.

Test a trained AI model using the test loader to measure accuracy on unseen data, performing inference without training or backpropagation, and explore precision, recall, and F1 as a bonus.

Demonstrates evaluating result metrics by applying softmax, computing argmax, and visualizing the predicted handwritten digit to validate the model.

Ingest your own data from folders or cloud storage and prepare it for AI modeling. Pre-process and manipulate the data before feeding it into AI models.

Learn to build an AI model that distinguishes cats from dogs using a five MB zip of train and test images, with about 190 training and 50 test items.

In Google Colab, upload and unzip the dog versus cat dataset, set training and test paths, and run code to count cat and dog images.

Build a PyTorch cat dog dataset class by loading images with PIL, setting a train directory, applying transforms, and implementing init, len, and get item to return image and label.

Define a dataset that loads images, applies a transforms pipeline from torchvision, and returns an image tensor with its label tensor after resizing to 150 by 150.

Learn to build data batches with a data loader, set batch size to 32 with shuffle, and use a train loader to feed images and labels into a training loop.

Create a minimal CNN with one convolutional layer, kernel, stride, and padding, plus max pooling. Load custom data, run a forward pass, and observe the output.

Run data through the model by feeding grayscale images into a CNN with 2D convolution to generate features and apply max pooling; train epochs with a data loader and backpropagation.

Explore the architecture of convolutional neural networks, understand their intuition, and learn how to build your own cnn model.

Load a pre-trained ResNet-152 from torchvision in PyTorch, preprocess an image with resize, crop, to tensor, and normalize, and inspect the convolutional layer to see how the network represents features.

Learn why convolutional neural networks are specialized for image data, preserving hierarchical features through weight sharing and filters, and building feature maps with batch normalization, ReLU activation, and maxpool.

Explore how convolution in neural networks applies random filters to image regions, slides with stride, and uses padding to preserve input size while the model learns useful features.

Explore how stride controls how many columns the convolution moves in a CNN, showing examples of stride two versus stride one and practical implications for convolution.

Apply a convolutional neural network to image recognition using the mNIST 28 by 28 dataset, with a 3x3 kernel, padding 1, stride 1, and relu that preserves input size.

Understand how batch normalization and ReLU precede max pooling with a 2x2 kernel, shrinking 28x28 to 14x14 across feature maps, then to 7x7 with 64 features for a ten-class classifier.

Learn to build a neural network with torch, vision data set and transformers, define hyperparameters for 28 by 28 grayscale inputs, and create train data loader and test data loader.

Design a convolutional neural network in PyTorch by defining convolutional layers, batch normalization, relu, and max pooling to extract features, then flatten and classify into ten classes with dropout.

Visualize cnn architecture before training, tracing shapes from batch 100 through 32 channels, with batch normalization, relu, pooling, ten outputs and 1.9 million parameters using cross entropy loss and adam.

Train a CNN with a full training loop, switching between train and evaluation mode to track training and test loss and accuracy.

Visualize training and test performance by plotting losses and accuracies, detach from tensors to NumPy arrays for Matplotlib, with training accuracy near 99% and test near 100%.

Demonstrate testing and inferencing a CNN on the mnist-like dataset by inspecting tensor shapes, preparing batch inputs, comparing model predictions with actual labels, and visualizing results in grayscale.

Build your own chatbot using transformer architecture and attention mechanisms, understand why transformers solve context issues in text, and explore theory plus hands-on coding in Google Colab.

Explore the transformer architecture, an encoder–decoder design that processes all inputs at once with self-attention using query, key, and value and multi-head attention, plus input embeddings in PyTorch.

Learn how context drives text generation by moving beyond single input-output models through the attention mechanism and transformer architecture, as highlighted by attention is all you need.

Explore transformer architecture: non-sequential inputs, self-attention with query, value, and key, and multi-head attention across encoders and decoders, plus input embeddings in PyTorch.

Learn how input embeddings convert words into learnable vectors within a batch, using padding and embedding dimensions to shape data, with training updating embedding weights and positional encoding follows.

Learn positional encoding using sine and cosine waves to index positions. Add the positional encoding to word embeddings and scale by the embedding dimension's square root to guide multi-head attention.

Project inputs with positional encoding into q, k, v and split into heads. Apply scaled dot-product attention with softmax, then concatenate and apply a final linear transform.

Explore scaled dot product, its concatenation, and a linear layer in multi-head attention, forming a residual connection with the input embeddings for effective residual learning.

Explore how the transformer encoder block passes a 512 input through a 2048 feed forward network, adds a residual connection, and yields a 512 encoder output across multiple layers.

Explore how the transformer decoder uses masked multi-head attention fed by encoder outputs to predict next words, trained with cross-entropy loss while masking future words.

Pass logits through softmax to create a probability distribution that guides the decoder's output toward the true label, with temperature shaping sampling and embeddings, positional encoding, and loss function.

Explain learning rate warmup for transformers using 1 over sqrt(model dimension) with embeddings around 512, and the min of 1/step and step times warmup rate, coding in PyTorch.

Build a chatbot in PyTorch using a transformer architecture, prepare data from the Cornell movie dialogue corpus, and configure batch size 64, max length 16, and eight heads.

Explore data prep and cleaning by building a word frequency, creating a word map with start, end, padding, and unknown tokens, encoding inputs, and saving the map as JSON.

Explore data preparation and encoding for transformers by creating paired data, handling unknown words via frequency filtering, padding sequences, and saving encoded JSON for dataset building.

The course presents a simple movie dataset class that loads data, converts inputs and targets into long tensors, and demonstrates encoder–decoder setup with custom loaders and batch-based train loader.

Create a mask to prevent peeking at future words, using a padded matrix and its transpose to implement the technique; complete data preparation, then build and train the model.

Learn to build token and positional embeddings, initialize weights, and implement a PyTorch transformer with encoder–decoder and padding/mask logic. Validate with sample shapes and logits to train a chat bot.

Develop a custom Adam optimizer class with warmup and per-step learning rate updates, and implement a label-smoothed loss with temperature alpha for testing.

Define an evaluation function to test a chat bot model using start and end symbols, encoder and decoder inputs, and a prediction loop, and highlight untrained model results.

Train a small transformer model with 200 dimensions, two encoder layers, two feed-forward blocks, and ten epochs, using a starting learning rate at zero, to enable fine-tuning pre-trained chatbots.