Artificial Intelligence Masterclass + LLM Prize [2026]

Explore neurons and activation functions, see how neural networks learn through gradient descent and stochastic gradient descent, and analyze an example predicting housing prices to illuminate backpropagation and neural networks.

Explore the neuron as the building block of artificial neural networks, with dendrites, axon, synapses and weights, connecting inputs to hidden and output layers through activation function.

Compare activation functions, including threshold, sigmoid, rectifier, and hyperbolic tangent, in a single neuron, linking weighted sums to outputs and probabilities in the network.

Explore how a trained neural network values a property by processing inputs such as area, bedrooms, distance to the city, and age through input and hidden layers to output price.

Learn how neural networks teach themselves by adjusting shared weights via backpropagation and gradient descent in a single-layer perceptron, guided by a cost function.

Explore how gradient descent adjusts neural network weights to minimize the cost function, moving downhill along the slope rather than brute-forcing millions of weight combinations.

Learn how stochastic gradient descent overcomes non-convex costs by updating weights after each row, avoids local minima, and speeds training compared with batch gradient descent.

Backpropagation updates all weights simultaneously to train neural networks, linking forward propagation, error calculation, learning rate, and optimization methods like stochastic and batch gradient descent.

Explore convolutional neural networks, compare human brain image recognition, and learn the plan of attack: convolution operation, ReLU, pooling, flattening, full connection, and Softmax cross-entropy.

Explore how convolutional neural networks classify images by extracting features, predicting top labels with probabilities, and stacking convolutions, pooling, flattening, and fully connected layers to recognize objects.

Discover how convolution in convolutional neural networks detects image features with a feature detector or filter, applying stride to produce a feature map that reduces size while preserving spatial relationships.

Apply the ReLU (rectified linear unit) on top of the convolution to increase non-linearity and produce feature maps by zeroing negatives while preserving positives.

Apply max pooling to feature maps to achieve spatial invariance and down-sampling. Preserve key features while lowering parameters to help prevent overfitting.

Flatten pooling feature maps into a long column to feed an artificial neural network, after convolution and ReLU, preparing the input vector for the next deep learning steps.

Integrate a full artificial neural network with a convolutional network to combine flattened features, train via backpropagation, and classify images into two outputs for dog or cat using cross entropy.

Learn how convolutional neural networks use feature detectors, ReLU activations, pooling, and flattening to classify images with a trained fully connected network.

Learn how softmax turns CNN output probabilities into a sum-to-one distribution and how cross-entropy loss guides classification, outperforming mean squared error in backpropagation.

Explore auto encoders, their architecture and training, including overcomplete hidden layers. Learn sparse, de-noising, and contractive variants, and gain a high-level overview of stacked and deep auto encoders.

Explore autoencoders as self-supervised deep learning models that encode inputs into a bottleneck and reconstruct outputs identical to inputs, enabling feature detection and compact encoding for recommender systems.

Explore the role of biases in neural networks, focusing on autoencoders and activation functions, where biases add a constant term b to the weighted input, influencing the next layer.

Train an autoencoder to build a movie recommender by encoding user rating vectors into a latent z and decoding to reconstruct inputs, using backpropagation and epochs.

Explore overcomplete hidden layers in autoencoders, learn why larger hidden layers can cheat, and preview three approaches to prevent it while enhancing feature extraction and understanding variations.

Explore sparse autoencoders, where a larger hidden layer learns meaningful features by enforcing sparsity through a loss penalty, preventing trivial copying and enabling robust feature extraction.

Learn how denoising autoencoders use random zeroing of inputs to regularize deep nets, preventing copying through a stochastic process and comparing outputs to originals to extract robust features.

Explore contractive autoencoders, a regularization technique that prevents simply copying inputs in over-complete hidden layers by adding a loss penalty that promotes feature extraction, per Salah Rifai's work.

Explore stacked autoencoders, adding a second hidden layer for two-stage encoding and one decoding stage, yielding powerful representations that can surpass deep belief networks.

Explore deep autoencoders that stack restricted Boltzmann machines, pre-train layer by layer, unroll and fine-tune with backpropagation, and note the distinction from stack autoencoders, plus Hinton's paper on dimensionality reduction.

Learn how variational autoencoders create a stochastic dream by encoding inputs, sampling the latent vector, and decoding to diverse reconstructions that improve AI training.

Explore variational auto encoders by mapping inputs to a mean vector and a standard deviation vector in the latent space, enabling sampling and stochastic decoding for compression.

Explore the reparameterization trick for variational autoencoders, turning sampling into a deterministic path using mu, sigma, and epsilon to enable backpropagation.

Implement the convolutional variational autoencoder to let the model see input frames and generate a dream-like reconstruction, using a 1024-element latent vector and cnn-vae training.

Define and initialize a convolutional VAE (Conv VAE) class in Python, configuring latent size and training parameters, with TensorFlow variable scope, CPU/GPU modes, and graph building.

Build the encoder of the convolutional variational autoencoder within a TensorFlow graph by defining a 64 x 64 x 3 input placeholder, four conv layers (32, 64, 128, 256) with 4 x 4 kernels and ReLU activations, and flatten to 2 x 2 x 256.

Implement the V part of the VAE by sampling the latent vector z from a factored Gaussian with mu and sigma, using dense layers and TensorFlow's random_normal to generate epsilon.

Build the decoder of the variational auto-encoder with a 1024-unit dense layer and reshape for deconvolutions. Use conv2d transpose deconvolutions and a sigmoid activation to reconstruct the final images.

Implement training operations for a variational autoencoder, minimizing mean squared error between predictions self.y and targets self.x and KL loss with the adam optimizer in training mode using a global_step.

Explore recurrent neural networks, confront the vanishing gradient challenge, and dive into long short-term memory architectures with practical intuition and variations for deep learning.

Explore recurrent neural networks, their short-term memory function, how they differ from ANN and CNN, how the temporal loop is unraveled, and applications like image captioning, sentiment analysis, and translation.

Explore the vanishing gradient problem in recurrent neural networks, explaining backpropagation through time, how small recurrent weights slow learning, and how LSTMs and gradient clipping offer remedies.

Trace the history of lstms and their memory cell design, using forget, memory, and output valves to prevent vanishing gradients in recurrent networks.

Learn how LSTMs process text in practical applications by using memory cells and hidden states to track line positions, quotes, and nested expressions, while predicting next characters.

Explore variations of long short-term memory architectures, including peephole connections, combined forget and memory valves, and gated recurrent units (GRUs).

Explore the intuition for using recurrent neural networks and mixture density networks to build a world model that predicts future states with a learned probability distribution.

Discover how mixture density networks output a mixture of gaussian distributions by predicting means, standard deviations, and mixture weights via softmax.

Explore how MDN-RNNs visualize stochastic drawing predictions in a sketch-rnn demo, using mixture density networks to produce non-deterministic outputs and varied futures for Mona Lisa, bicycles, and other sketches.

Initialize and implement the MDN-RNN from scratch, building an RNN with a Gaussian mixture output to stochastically predict the next latent vector Zs for the full world model.

Gather the MDN-RNN parameters, including mixture count, input and output widths, max sequence length, and training state from hps, preparing to build the RNN architecture.

Build the rnn component of the mdn-rnn in three steps by creating an LSTM cell with dropout (recurrent, input, and output) and wrapping it with dynamic_rnn for the full model.

Create TensorFlow placeholders for input, target, and output to format the RNN with batch size and sequence length, and prepare initial state and MDN weights and biases.

Learn how to build a recurrent neural network using dynamic rnn with an LSTM cell, produce deterministic output z and a hidden state, and prepare the MDN output layer.

Construct the MDN component of an MDN-RNN by reshaping the RNN output, applying output weights and biases to form a five-mixture Gaussian hidden layer that yields a stochastic z prediction.

Split the MDN output into three parts to obtain logmix, mean, and logstd, then compute the mixing coefficient and integrate with the MDN model in TensorFlow.

Develop training operations for an mdn-rnn by implementing a lognormal loss with tf_lognormal and get_lossfunc, using mdn parameters logmix, mean, and logstd, and reshaping targets for TensorFlow optimization.

Implement training operations for the full world model by computing loss gradients, applying updates with the Adam optimizer, and clipping gradients with the grad_clip hyperparameter.

Explore reinforcement learning, the first step in this course, by modeling an agent in an environment that learns from actions and rewards, using mazes, omelet, and robodogs to illustrate states.

Explore a pseudocode implementation of the full world model, linking cnn, vae, latent z, mdn-rnn, and a simple controller to optimize reward.