Full Stack Generative AI: Deep Learning, CNN, LLM Agentic AI

Explore the difference between generative and discriminative AI, and how generative models synthesize new data like text and images while discriminative models classify inputs with probability.

Compare artificial intelligence with machine learning and deep learning, showing how traditional if-else rules use features like texture and color, while learning models classify data from training samples.

Introduce deep learning foundations by comparing biological and artificial neural networks, detailing neurons, dendrites, axons, synapses, thresholds, weights, and activation functions within convolutional neural networks for handwritten digit tasks.

Set up the Python environment and Anaconda-based workflow, install essential libraries like NumPy, SciPy, Matplotlib, and scikit-learn, and launch Jupyter Notebook for AI development.

Explore Python basics for machine learning by practicing assignment operators, including string, number, and boolean assignments, dynamic typing, and multiple assignment, with none as a placeholder in a Jupyter Notebook.

Learn Python flow control with if else statements, equality versus assignment, and indentation in a practical Jupyter notebook example, including value comparisons and fast or safe outputs.

Practice Python flow control by using for and while loops to repeat actions, exploring range-based iteration from zero to nine or one to ten, with explicit initialization, condition, and increment.

Explore Python basics for machine learning by mastering tuples, lists, and dictionaries; learn immutability, mutability, indexing, appending, and simple for loops.

Learn Python dictionaries: create key-value pairs, access values by key, and iterate with keys() and values(), noting mutability and lack of fixed indexing as a precursor to functions.

Learn how to define and call functions in python to perform simple calculations, pass arguments, return results, and print outputs, with practice in a Jupyter notebook.

Import numpy as np and convert a Python list to a numpy array, then print the array and its shape. Learn to create 1-D and multi-dimensional arrays and perform operations.

Create and manipulate a multidimensional numpy array from a list, access specific rows and elements, print columns, and perform element-wise addition and multiplication.

Explore Matplotlib basics for visualizing data, learn to import the library, create plots with NumPy data, label axes, and display results with the show function.

Explore histograms, bar plots, line plots, and scatter plots in matplotlib, using numpy arrays and auto-generated axes to visualize data relationships and distributions.

Explore pandas basics, including series and data frames, their structures, and how to create and access data using constructors, index, and columns.

Learn to construct a pandas data frame from arrays, set the row names and column names, and access elements by labels, while using pandas to manipulate, clean, and refine data.

Install TensorFlow and Keras via pip, replacing Theano, to enable deep learning across CPU, GPU, and mobile devices, within the Anaconda environment.

Explore the basic structure of a simple artificial neuron and neural network, including inputs, weights, bias, summation, activation, loss function, optimizers, and the input, hidden, and output layers.

Explore activation functions for linear regression and binary or multi-class classification tasks, and note options like sigmoid, softmax, tanh, ReLU, and leaky ReLU, with linear being the default in Keras.

Explore popular activation functions, including linear, sigmoid, tanh, ReLU and its leaky variants, plus softmax, with their input-output ranges and use in linear regression and binary classification.

Discover popular loss functions for deep learning, including mean square error for regression and binary and categorical cross-entropy for classification. The optimizer uses loss to adjust weights.

Explore popular deep learning optimizers including SGD, Adam, and RMSprop, and how they adjust weights, biases, learning rate, and momentum to minimize loss.

Explore popular neural network types, including feedforward, recurrent and convolutional networks, plus LSTM and generative adversarial networks for image, language, and multimedia tasks.

Fetch and load the King County house dataset from Kaggle, then define a sequential multilayer perceptron in Keras to perform regression on house prices.

Conduct exploratory data analysis and data preparation for a King County house price regression using Keras. Use pandas to assess shape, count, describe, and derive registration year and house age.

Remove irrelevant columns such as id, zipcode, latitude, and longitude; visualize distributions, correlations, and outliers with Seaborn plots to guide data preparation.

Define a Keras sequential model for King County house price regression, prepare input x and output y by dropping price, and import TensorFlow and Keras to set up the model.

Define a sequential Keras model with 14 input features, a hidden layer of 4 neurons, and a 1-neuron output. Use model.add and prepare to compile and fit.

Compile and fit a regression model using mean square error and SGD. Explore Adam with ReLU, a 33% validation split, and epochs to improve training and validate price prediction.

Plot training and validation losses with matplotlib to analyze regression training, review the model summary, and explore metrics like mean square error and mean absolute error.

Predict the price of a King County, USA house using a trained model by feeding 14 features and calling model.predict to obtain the estimated price.

Develop a binary classification model to predict heart disease using the UCI heart disease dataset, reduced to 13 key attributes, via a sequential multilayer perceptron in Keras.

Fetches and loads a heart disease dataset from Kaggle, saving it as csv and importing into Python for a binary classification model. Uses Cleveland subset from UCI and begins eda.

Explore your data’s shape, describe stats, and check data types and missing values; visualize outliers with box plots and count plots to prepare for the sequential model.

Visualize healthy versus heart patients using seaborn counter plots and histograms, and compare age, sex, and cholesterol with color-coded distributions.

Define a sequential neural network for binary heart disease classification, splitting data into 13 inputs (X) and target (y), with a 11-neuron ReLU hidden layer and a sigmoid output.

Predict heart disease by applying a trained model to 13 input features, using a 0.5 probability threshold to output binary classification, with hands-on code using numpy and model.predict.

Split the heart disease dataset into training, validation, and testing sets to evaluate a binary classification model, keeping 10% for independent testing.

Repeat the training and validation with a new heart disease dataset, evaluate on independent test data using the model.evaluate, and report about 81 percent accuracy.

Explore multi-class classification to predict red wine quality across ten categories using eleven physiochemical features and a neural network with multiple output neurons.

Fetch and load the red wine quality dataset from Kaggle, then prepare a multi-class classification model by loading the CSV in a Jupyter notebook with pandas.

Perform exploratory data analysis and data preparation on the wine dataset, inspecting shape, stats, and missing values, visualize distributions with box plots, heatmaps, and count plots using Seaborn and Matplotlib.

define a Keras sequential model for multi-class wine quality with 11 inputs, a 5-neuron hidden layer, and a 10-neuron softmax output; prepare to compile and train with fit next.

Compile the model with sparse categorical cross entropy and accuracy, then fit with batch size 100 for 20 epochs, monitor training and validation loss and accuracy, and plot the results.

Predict wine quality with a trained multiclass model using 11 input features and argmax on probabilities from ten outputs, and save the model for future predictions.

Learn how to serialize and save trained models with the Keras save function to h5 files, and reload them later with load_model for quick deployment.

Learn how digital images are represented as numbers, from grayscale pixels 0–255 to RGB three-channel color, organized in a three-dimensional array of height, width, and depth.

Explore basic image manipulation with keras image preprocessing utilities: load an image, convert to and from arrays, and display a 200x200 rgb jpeg cat image in a notebook and viewer.

Master basic image processing with Keras preprocessing utilities, converting between pil images and numpy arrays using img_to_array and array_to_img, then save grayscale images in a cat image workflow.

Explore color channel manipulation in Keras, switching between channels last and channels first formats. Load grayscale images and reorder axes with numpy roll axis for TensorFlow and Theano backends.

This lecture explains image augmentation in Keras with the Image Data Generator, creating on-the-fly augmented images via flow methods, using rotate, shift, shear, zoom, and brightness to improve robustness.

Learn how to generate augmented images from a single image using the Keras ImageDataGenerator flow, applying rotation, width and height shifts, brightness variations, and horizontal flips, and save outputs.

Learn to generate augmented images from a directory using Keras flow from directory, organizing cat and dog classes, configuring batch size, target size, color mode, and optional saving.

Master generating augmented images with Keras flow from dataframe, creating img_labels.csv with cat and dog image names and class ids, and feeding dataframes with pandas to flow_from_dataframe.

Explore how CNNs excel at image analysis, replacing MLPs for image data, and learn convolutional, pooling, and fully connected layers with local receptive fields, filters, feature maps, and ReLU activation.

Explore how convolutional networks use kernels, stride, and zero padding to preserve edge information, produce feature maps from multi-channel inputs, and flatten outputs for a final fully connected layer.

Fetch, load, and prepare the Kaggle flowers dataset for five classes. Build and train a Keras CNN with sequential layers, using flow from directory and 100x100 images to enable predictions.

Divide the flower image dataset into training (70%) and testing (30%) sets, organizing them into train and test folders per class. Prepare data for a baseline cnn for flower classification.

Define a baseline CNN in a sequential model for flowers image classification, using conv and pooling layers, flatten, and dense, with flow from directory data for train and test.

Define a sequential CNN for 100 by 100 RGB images, using conv and pooling, increasing feature maps to 128, then flatten and classify with softmax for five flowers.

Define a CNN by stacking convolution and pooling layers, with 32, 64, and 128 feature maps, 3×3 and 2×2 filters on 100×100×3 input, flatten and add dense layers with softmax.

Train a CNN for multi-class flower classification using directory flow, 100×100 images, batch size 64, eight epochs, categorical cross-entropy loss, and Adam optimizer; visualize training and validation metrics.

Save the flower classification CNN model with model.save and note its size in the models directory. Capture the training iterator's class indices to preserve label order for future predictions.

Load a saved convolutional neural network model, preprocess 100 by 100 images with image to array, and predict the flower class using model.predict and argmax with a class labels dictionary.

Explore dropout regularization in a flowers CNN to prevent overfitting, applying dropout after convolution, pooling, and dense layers, and compare with baseline results.

Explore how padding and increasing filters impact a flowers classification CNN, comparing dropout, padding same, and baseline models, and note that padding improves validation accuracy while training loss declines.

Apply on-the-fly image data augmentation to flowers classification cnn using rescale, horizontal flip, rotation, and shifts. Train with augmented data and save or load the model as an h5 file.

Explore automatic hyperparameter optimization using Keras tuner to tune dense layer units (64, 128, 256, 512), replacing manual trial and error with efficient search strategies.

Explore hyperparameter tuning with Keras tuner using random search, max trials, and best validation accuracy, saving and loading models, and preview transfer learning in deep learning with CNNs.

Explore transfer learning with pretrained convolutional neural networks like VGG16 and VGG19, using ImageNet-trained weights to classify new data and accelerate deep learning workflows.

Explore using pre-trained VGG16 and VGG19 with Keras applications for image classification and feature extraction, including transfer learning and fine-tuning, with images resized to 224 by 224 and decoding predictions.

Explore predictions with VGG16 and VGG19, printing class labels and probabilities from images. Switch between 16 and 19, download weights, and compare outputs like tabby and sports car.

Explore how ResNet-50 uses skip connections to prevent vanishing and exploding gradients, creating a gradient super highway for reliable predictions, using a pretrained ImageNet model in Keras.

Apply transfer learning with VGG16 to classify five flower types, adjusting the model by removing top layers, setting input shape to 224 by 224, and using training augmentation.

Perform transfer learning with a frozen VGG16 base for flower classification, adding custom flatten and dense layers for five categories, training on CPU with four epochs and saving the model.

Leverage VGG16 transfer learning to train and save a flower classifier, then load the model to predict daisy and other flowers using 224×224 RGB images.

Use Google Colab GPU to perform VGG16 transfer learning, and prepare and upload the flowers dataset to Google Drive by creating DL/dataset folders, compressing to zip, and managing paths.

Perform Vgg16 transfer learning on a flower dataset with Google Colab GPU. Train the model and save it to Google Drive for prediction.

Train and predict with VGG19 transfer learning on a flower dataset using google colab gpu, saving the model to google drive and validating predictions with new images.

Train a ResNet 50 transfer learning model using Google Colab GPU and Keras applications, then evaluate predictions and save the trained model in Google Drive for image recognition.

Explore feed forward neural networks, recurrent networks with short-term memory, backpropagation, and convolutional networks for image processing. Survey generative models including GANs, VAEs, autoregressive transformers like ChatGPT, and diffusion models.

Explore generative adversarial networks, where a generator builds high resolution images while a discriminator distinguishes fake from real ones, using upsampling, deconvolution, and transpose convolution to flip traditional CNN downsampling.

Shows a simple transpose convolution (deconvolution) using a 2D conv2d transpose layer in a Keras sequential model to convert a 200x200 image to grayscale and generate a higher-resolution output.

Convert a 200x200 grayscale image to a 1,200,200,1 numpy array for a sample, then build a sequential model with a 1x1 transpose convolution and stride 2x2 to yield 400x400.

Perform deconvolution to upsample a grayscale image, predict with the model, and display a 400 by 400 result; fill gaps with black zeros during 2x2 to 4x4 expansion.

Explore how the generator and discriminator train in a GAN, map Gaussian noise to images, and adjust via binary cross entropy loss to improve realism.

Build a simple fully connected GAN on the MNIST dataset, compare it to DCGAN, and learn to load MNIST via Keras in a Jupyter notebook using 28x28 grayscale images.

Load and explore the mnist dataset in a new Jupyter notebook. Import Keras MNIST, load train and test data, and inspect shapes before displaying a sample 28x28 grayscale image.

Define a generator for a fully connected GAN using keras model with a 100×100 noise input and 128 hidden neurons, applying leaky ReLU and tanh to yield 28×28 mnist images.

Define a fully connected GAN generator in Keras, using a sequential model with 128-neuron input and 100-dim latent vector, leaky ReLU hidden layer, and 784-neuron tanh output reshaped to 28x28.

Define the discriminator for a fully connected gan by flattening 28 by 28 images, feeding a 128-unit feed-forward network, and using a sigmoid output for real or fake classification.

Define the mNIST gan discriminator model for 28 by 28 images, flatten to 784 with 128 neurons, leaky ReLU, and a sigmoid output, pairing with the generator.

Combine the generator and discriminator into a single fully connected GAN by building a sequential model, adding the generator first, then the discriminator, and returning the merged model.

Compile the discriminator and the combined mNIST gan model by setting binary cross entropy loss and the Adam optimizer, with the discriminator kept non-trainable during generator training.

Train the discriminator as a binary real-or-fake mnist classifier by scaling inputs to -1 to 1 for tanh, logging accuracy and loss, with batch size 128 and Adam optimizer.

Implement a for loop to train the discriminator on real and fake images and their labels, shuffling batches and using train on batch to update loss and accuracy.

Train the discriminator with real and fake images, using gaussian noise as input, and compute the average loss and accuracy to guide fully connected GAN training.

Train the composite GAN by updating the generator while holding the discriminator constant, using fake images produced from random noise vectors and real labels to guide learning.

Learn to save and plot gan training metrics at fixed intervals by recording discriminator and generator losses, accuracy, and iteration counts, using lists and tuples, with testing and debugging steps.

Plot accuracy and loss versus iterations with a function to visualize GAN progress, including discriminator and generator losses, after every 100 epochs.

Display generated samples from a fully connected GAN during training by plotting a 4x4 grid of MNIST generator outputs from random noise, using matplotlib with grayscale images.

Plot a 4x4 grid of generated images from a fully connected gan using a 100-d random noise vector, a part 2 tutorial, displayed with matplotlib after rescaling.

Save the trained generator for later use by serializing its structure to JSON and its weights to HDF5, saving progressively in a saved models folder every 1900 iterations.

Load the pre-trained GAN by reading the model JSON, loading weights, and generating images from random noise without retraining. Generate a 4x4 grid of MNIST-like digits.

Compare fully connected and convolutional neural networks, noting cnn input as tensors and downsampling for images, and dcgan deconvolution in image generation.

Demonstrates defining a deep convolutional GAN generator, transforming a random noise vector into a 28×28 grayscale image via transpose convolution, starting from 7×7×128 with leaky ReLU and 4×4 kernels.

Reuse the fully connected generator code. Use a seven by seven by 128 input and a 100-d noise vector to produce a 28 by 28 by 1 image with sigmoid.

Define the dcgan discriminator to classify real versus generated 28x28x1 images by convolving to 14x14x64 and 7x7x64, applying leaky relu and dropout, flattening to 3136, and using a sigmoid output.

Combine the generator and discriminator into a DCGAN, then compile and train with binary cross-entropy and Adam, adjusting learning rate and decay while alternating training with non-trainable components.

train a deep convolutional gan on MNIST, training the discriminator and generator with a 256 batch size and sigmoid activation, using 0–1 scaling for real and fake inputs.

Learn to train a DCGAN on Google Colab GPU, compare GPU versus CPU performance. Save models as JSON and weights for later generation.

Deploy a DCGAN on the fashion-mnist dataset by reusing the mnist-based architecture, loading 28 by 28 grayscale images with 60,000 training and 10,000 testing samples across 10 labels.

Train a DCGAN on the mnist fashion dataset using tanh activation in the generator, save the model as json and h5 weights, and run on Google Colab with GPU.

Explore loading the CIFAR-10 color dataset for a deep convolutional GAN, adapting mNIST-based code to 32 by 32 RGB images with 10 classes and 50k train and 10k test.

Define the CIFAR-10 dcgan generator from a 100-dimensional random latent vector to a 32×32×3 image using dense, reshape, and successive deconvolution layers with leaky relu and tanh.

Define the discriminator of a deep convolutional GAN for CIFAR-10 32x32 color images, with conv downsampling layers, leaky ReLU activations, and a sigmoid output.

Train a deep convolutional GAN for CIFAR-10 by adjusting the generator and discriminator, setting proper data shapes and batch sizes, and monitoring sample images during training.

Train a deep convolutional gan on CIFAR-10 using Google Colab GPU, saving weights and json, adjusting the sample gap, and generating images from the saved model through trial and error.

Compare vanilla gan with conditional gan, showing how conditioning with labels or tags lets the generator produce targeted images and how both networks embed this information during training.

Construct a conditional GAN by establishing a basic generator from the fully connected GAN, using a 100-d noise vector, leaky ReLU, batch normalization, and a tanh output reshaped to 28×28×1.

Embed the conditioning label with a Keras embedding layer. Multiply the embedded label by random noise to form the joint input for a conditional gan generator.

Embed the conditioning label into a vector and multiply with random noise to form a joint representation in a functional Keras generator, enabling branching and visualization with plot_model.

Define a conditional GAN discriminator using a sequential model with dense layers, leaky ReLU activations, dropout, and a sigmoid output to predict real versus fake probabilities.

Embed the conditional label into the discriminator input, producing a joint representation with the 28 by 28 by 1 image, then classify real or fake in the CGAN.

Learn to combine and compile a conditional GAN by training the generator and discriminator, setting binary cross entropy loss and Adam optimizer, using random noise vectors with conditioning labels.

Train the conditional GAN discriminator on MNIST by using real and fake image pairs with corresponding labels, while keeping the generator fixed, and manage metrics with global arrays.

Train the conditional GAN by feeding random noise and conditioned labels to generate images, update generator and discriminator, save the C GAN model and weights, and display sample images.

Implement a conditional gan that displays generated images with ordered sample labels in a 2x5 grid, passing labels to the generator during training and prediction.

Train a conditional GAN on mNIST using Google Colab's GPU, saving models. Generate labeled digits on demand by customizing conditions and noise.

We train a conditional GAN on the fashion MNIST dataset using Google Colab GPU, adapting the code to import fashion MNIST, train the model, and generate controlled fashion images.

Explore variational autoencoders, a probabilistic encoder–decoder model with mean and standard deviation latent vectors that enable sampling to generate new images and support anomaly detection.

Explore how variational autoencoders encode images via an encoder into a probabilistic latent space, then a decoder generates new samples using mean, variance, KL divergence, and reconstruction loss.

Explore building a variational autoencoder on the mNIST dataset using PyTorch in Google Colab, importing core libraries and preparing 28x28 grayscale images.

Build a variational autoencoder by encoding 28×28 images (784 inputs) through a 400-node hidden layer to a 20-dimensional latent space with mean and log-variance, then decode to reconstruct.

Define the decoder to map latent representations to a 784-pixel image using a 20-d latent layer and a 400-unit hidden layer, with ReLU, a sigmoid output, and reparameterize for sampling.

Understand how the reparameterization trick enables backpropagation through randomness in variational autoencoders by separating the random epsilon from the mu and sigma latent vectors.

Define the reparameterization function inside the VAE class to compute mu and sigma from the log variance, sample epsilon, and return mu plus sigma times epsilon for the backward pass.

Define the forward pass within the network class, encoding the input, computing mu and log variance, applying reparameterization in the latent space, and decoding to reconstruct a 28x28 image.

Define the loss function for a variational autoencoder, combining reconstruction loss and kullback-leibler divergence to shape the latent space via reparameterization toward a standard normal distribution.

Define a transform to convert 28x28 images to 784-element vectors with to tensor and a flatten lambda. Load MNIST with a batch loader of size 64 and shuffle.

Train a variational autoencoder in PyTorch, selecting CUDA if available, with Adam on a 64-image train loader across multiple epochs to optimize reconstruction and mean and log variance loss.

Generate digit images from a trained model by sampling a 16 by 20 latent space and decoding into a 4 by 4 grid of 28 by 28 grayscale images.

Learn to generate a specific mnist digit by using a conditional variational autoencoder that concatenates one-hot labels to both the encoder and decoder inputs for controlled digit generation.

Explore autoregressive models that predict the next element from previous context, including transformers and GPT variants, and see how next-word and next-pixel generation powers chatbots like ChatGPT and image generation.

Explore natural language processing and its role in autoregressive models, including sentiment analysis, translation, and essential preprocessing like tokenization, stemming, and lemmatization.

Define a sample text and demonstrate tokenization, stop-word removal, stemming, lemmatization, and parts-of-speech tagging using NLTK, illustrating how preprocessing transforms text into tokens and annotated words.

Explore pure natural language processing to predict the next word with n-grams (unigrams, bigrams, trigrams) in a Colab notebook, using NLTK and a default dictionary, without machine learning.