Deep Learning and Generative Artificial Intelligence

Explore neural networks through an interactive TensorFlow playground that demonstrates why hidden layers and non-linear activation are essential, and how feature engineering shapes learning.

Explore the course code repository on GitHub, open examples in Google Colab, switch runtime to GPU, and run code cells or all cells to align with the shared environment.

Explore convolutional neural networks (CNNs) as an alternative to fully connected neural networks, using input patches to neurons in hidden layers to focus on local features.

See how a convolutional neural network is structured and implemented. Gain insight into CNN concepts through a first general view and a typical code implementation.

Explore how neural networks process images by using ReLU in hidden layers and softmax in the output layer for multi-class classification, with 28x28 grayscale inputs and RGB color encoding.

Learn about ReLU and softmax activation functions in deep learning, where ReLU avoids vanishing gradients and softmax converts output scores into probabilities for multi-class classification.

Explore how a convolutional neural network processes input data, images as pixel grids, grayscale values 0-255, and color channels red, green, blue, for filtering and image recognition.

Explore how computer vision recognizes the same object despite shifted, shrunk, rotated, or deformed appearances by treating images as matrices of numbers and building robust recognition systems.

Convolution performs element-wise multiplication of a filter with image patches and sums results to form a feature map, and a perfect match yields a peak response highlighting diagonal lines.

Slide a three by three filter over the input image, perform element-wise multiplication with each patch, and sum results to form feature map, with filter values learned during CNN training.

Demonstrate the computation of the three by multiplying the filter with the corresponding part of the image, continuing the established process.

CNNs learn filter values during training to detect edges, textures, and patterns, optimizing the network's feature maps for vision tasks.

Apply non-linearity after every convolution operation on feature maps, using ReLU to convert negatives to zero and preserve positives, enabling the network to learn more complex patterns.

The pooling layer downsamples feature maps to reduce dimensionality and computational efficiency, using max pooling over 2x2 areas to preserve important features and achieve spatial invariance.

CNNs, with their architecture, apply to many tasks by combining convolution, ReLU, and pooling layers to learn complex features for classification, object detection, segmentation, and probabilistic control.

Convolutional neural networks detect and locate objects in images, drawing bounding boxes and coordinates to identify cars, people, and more. This capability powers applications such as autonomous driving and surveillance.

Use semantic segmentation with CNNs to precisely segment tumor areas in MRI scans for biomedical image analysis, aiding diagnosis and treatment planning with detailed visual representations.

Explore how the unit convolutional neural network enables image segmentation with a U-shaped design, contracting via downsampling and expanding via upsampling, to produce segmentation maps for MRI brain tumor segmentation.

Engage with interactive playgrounds to test and visualize CNN predictions, deepening your understanding of CNN-based deep learning concepts through hands-on code demos and GitHub-backed experimentation.

Shows a convolutional neural network for mnist digit classification, highlighting training dynamics and hyperparameters: learning rate, batch size, momentum, nesterov momentum; architecture with conv, relu, pooling, softmax, and random crops.

This code demo shows how to fine-tune a pre-trained VGG model on CIFAR-10 using selective layer unfreezing and data augmentation to improve generalization, with practical notes on GPU limitations.

Follow the deep learning process where input data X passes through multiple layers to generate predictions Y', then a loss function guides an optimizer to adjust weights and minimize loss.

Explore recurrent neural networks and how they recognize patterns in sequences, enabling time series forecasting through variable-length data and sharing parameters across the sequence.

Use backpropagation to train time series by computing gradient of the loss with respect to each parameter and updating them to minimize loss; RNNs add complexity from sequential data.

Identify the vanishing gradients problem, where gradients shrink through repeated multiplication of weights less than one, causing updates to vanish and the training process to stall.

RNNs capture differences in sequence order to understand context in time series. They distinguish subtle meaning changes with the same words, a key strength for modeling sequential data.

Explore how LSTM networks overcome standard RNN limits with forget, store, update, and output gates that control the cell state and sustain gradient flow for long-term dependencies.

Utilize an LSTM-based time-series model to predict the S&P 500 index price using historical data since 1990, including volatility, rates, unemployment, sentiment, and new indicators beyond the original paper.

Explore how indicators behave over time in time series data by visualizing historical trends and their relation to closing prices, building an intuitive understanding before modeling.

Interact with the provided code and demos to experiment, tweak, and learn deep learning for time series, using a GitHub copy to reset when needed.

Explore language with transformers in modern artificial intelligence and deep learning, as part of a course covering AI for vision, language processing, and creativity.

Explore transformers as the leading model for language processing since 2017, powering ChatGPT, and extending to image and time sequence processing, while noting emerging successor architectures.

Understand how the transformer model uses an encoder-decoder architecture, with multi-head attention, feed-forward layers, and positional encodings, to compute output probabilities via softmax for efficient language processing.

The transformer uses self-attention in the encoder and decoder, with multi-layer encoders and encoder-decoder attention guiding output. The final probabilities pass through a softmax, enabling accurate, fast language translations.

Explore how word embeddings map semantic relationships in a vector space, showing how similar contexts link words like man and woman, guiding translation and text generation.

Explain how positional encoding in the transformer adds position information to input embeddings, enabling parallel sequence processing and unique sine and cosine encodings for each token position.

Explore the transformer architecture with a focus on multi-head attention, enabling the model to attend to different input parts simultaneously and boost translation and summarization performance.

See how a single attention head in a transformer links the word dog to other words, using query, keys, and values to weight dependencies and focus on sentence parts.

Show how word embeddings like carpe and diem generate query vectors and how each embedding is multiplied by a query weight matrix to determine word relevance in the input sequence.

The transformer generates key vectors from word embeddings using a key weight matrix, enabling comparison with query vectors to compute attention scores.

Explain the final step of the attention mechanism, where value vectors are weighted by attention probabilities and summed to produce the final output, integrating information from the input sequence.

Process input embeddings with positional encodings through self-attention and feed-forward networks in a transformer encoder to capture complex patterns and pass the final result for further processing.

Explore the transformer encoder architecture, including add and normalize layers, residual connections, and the combined power of self-attention and feedforward networks to capture language dependencies.

Explore transformer models in language processing through code demos and transformers beyond code, with playgrounds from various companies and platforms.