Learning Deep Learning: From Perceptron to Large Language Models

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 110 Lessons (13h 23m) | 2.75 GB

A complete guide to deep learning for artificial intelligence

Deep learning (DL) is a key component of today’s exciting advances in machine learning and artificial intelligence. Illuminating both the core concepts and the hands-on programming techniques needed to succeed, this video course is ideal for developers, data scientists, analysts, and othersincluding those with no prior machine learning or statistics experience.

After introducing the essential building blocks of deep neural networks, such as artificial neurons and fully connected, convolutional, and recurrent layers, Magnus Ekman shows how to use them to build advanced architectures, including the Transformer. He describes how these concepts are used to build modern networks for computer vision and natural language processing (NLP), including large language models and multimodal networks. The code repository is located on github.com/NVDLI/LDL.

Learn How To:

• Apply core concepts of perceptrons, gradient-based learning, sigmoid neurons, and backpropagation
• Utilize DL frameworks to make it easier to develop more complicated and useful neural networks
• Utilize convolutional neural networks (CNNs) to perform image classification and analysis
• Apply recurrent neural networks (RNNs) and long short-term memory (LSTM) to text and other variable-length sequences
• Build a natural language translation application using sequence-to-sequence networks based on the transformer architecture
• Use the transformer architecture for other natural language processing (NLP) tasks, and how to engineer prompts for large language models (LLM)
• Combine image and text data and build multimodal networks, including an image captioning application

Lesson 1: Deep Learning Introduction

Lesson 1 starts by introducing what deep learning is and a little bit of its history. It then turns to the prerequisites for the course.

Lesson 2: Neural Network Fundamentals I

Lesson 2 begins with the perceptron and its learning algorithm and shows how it works with a programming example. The perceptron is an artificial neuron. Artificial neurons are basic building blocks in deep learning. The perceptron has a bias term which is discussed further in the next section. Next comes a discussion of how to describe neural networks using matrices and vectors. That is followed by some limitations of the perceptron and how we can overcome them by connecting multiple perceptrons together into a neural network. In order to make such networks solve problems they need to be trained. The learning algorithm for a neural network is gradually introduced in the next three sections beginning with how to solve a learning problem with gradient descent. Parts of this is about computing gradients, and the lesson shows how that can be done using the chain rule of calculus. Next, the lesson puts it all together in the backpropagation algorithm, implementing the algorithm in a programming example. The lesson concludes with a discussion about the design parameter for artificial neurons that is known as an activation function.

Lesson 3: Neural Network Fundamentals II

Lesson 3, the second half of neural network fundamentals, starts by introducing data sets and the concept of generalization. Next comes an introduction to multiclass classification problems implemented with a programming example that classifies images of handwritten digits. The lesson describes what a deep learning framework is and how it can make it easier to experiment with deep learning. The digit classification example is then reimplemented using the deep learning framework, TensorFlow. And then the same example is implemented again but with the other major framework, PyTorch. Next comes discussion of problems related to saturated neurons and vanishing gradients and techniques to mitigate this. This is split up into two sections. First comes description of variations on the learning algorithm, and then the lesson turns to how to use some of the newly introduced techniques to improve the digit classification network, first in TensorFlow and then in PyTorch. The next section discusses how we use different output units and loss functions for different problem types. Discussion then ensues about something known as regularization techniques that help networks to generalize. The lesson concludes with another programming example, this time about regression, both in TensorFlow and in PyTorch.

Lesson 4: Convolutional Neural Networks (CNN) and Image Classification

Lesson 4 begins by introducing the CIFAR-10 data set. It then turns to describing what the convolutional layer looks like and how we can use it to build a convolutional network. Next, a convolutional neural network is used for image classification, both in TensorFlow and in PyTorch. The lesson also presents details of AlexNet, which was published in 2012 and started the DL revolution. It also describes VGGNet and GoogLeNet and, finally, ResNet. This is followed by a demonstration of how to use a pre-trained ResNet using TensorFlow and PyTorch. Finally, the video covers a little bit about how to make better use of your existing data and how to build more efficient convolutional neural networks.

Lesson 5: Recurrent Neural Networks (RNN) and Time Series Prediction

Lesson 5 starts by introducing some problem types that involve sequential data. It then introduces recurrent neural networks that can work on sequential data. Next it demonstrates how to apply such a network to a forecasting problem using TensorFlow and PyTorch. Recurrent neural networks are trained using a technique known as backpropagation through time. The lesson discusses some problems associated with that. It then describes how to address these problems using long short-term memory or LSTM. It introduces the two techniques, auto regression and beam search. They are often used to predict multiple steps into the future. Finally, the lesson demonstrates how to use an LSTM network with autoregression and beam search for text autocompletion with Tensor Flow and with PyTorch.

Lesson 6: Neural Language Models and Word Embeddings

Lesson 6 begins by describing what a language model is. This has to do with natural language processing, not just in the context of deep learning. The lesson describes a way of encoding words known as word embeddings. It then shows how to build a neural language model with word embeddings in TensorFlow and in PyTorch. This is the foundation for looking at large language models later in the course. The lesson then introduces word2vec, which is an algorithm to create word embeddings. Next comes a programming example demonstrating how to use pre-trained word embeddings. Finally, the lesson describes a technique known as wordpieces to be able to handle words that we haven’t seen before.

Lesson 7: Encoder-Decoder Networks, Attention, Transformers, and Neural Machine Translation

Lesson 7 introduces a network architecture known as encoderdecoder architecture and describes how we can use it for neural machine translation where we use a neural network to translate from French to English. This is then implemented with TensorFlow as well as with PyTorch. Magnus describes a concept known as attention that can be used to improve encoderdecoder networks. He then introduces the transformer architecture that is based on the attention mechanism. Finally, an improved version of the machine translation network is implemented by using the transformer, in both TensorFlow and PyTorch.

Lesson 8: Large Language Models

Lesson 8 is about large language models (LLMs) that make use of the transformer architecture. The lesson starts by describing BERT, which was an early large language model. It then describes details of GPT, which was another early large language model. The lesson then turns to the GPT family of models and how it gradually improved from GPT to GPT4. Next the lesson presents how to use a language model to build a chat bot. It shows how to improve the behavior of a pre-trained language model by using prompt tuning. Next the lesson discusses how LLMs can be improved by enabling them to retrieve data or use tools. The lesson also discusses open models a little bit and as well as data. Finally, the lesson ends with a demonstration of trying some different types of prompts with such an open model.

Lesson 9: Multi-modal Networks and Image Captioning

Lesson 9 is about building networks that work with two or more modalities. That is, it works with two or more types of data, for example, text and images. The lesson begins by introducing the concept of multi-modal learning and some associated challenges. Magnus then builds a simple multi-modal network, both in TensorFlow and in PyTorch. Next he describes a more advanced application to produce a textual description of an image, and again implements it with TensorFlow and with PyTorch. The lesson concludes with a description of how to add more modalities to large language models to build multi-modal large language models.

Lesson 10: Multi-task Learning and Computer Vision Beyond Classification

Lesson 10 begins by introducing the concept of multi-task learning. A simple multi-task learning example is then implemented with TensorFlow and with PyTorch. Magnus then describes a more advanced multi-task problem. It is a computer vision problem known as object detection. He shows how it can be solved using a network named R-CNN. The lesson continues by taking a look at improved networks known as fast and faster R-CNN. The lesson then introduces yet another computer vision problem known as segmentation and shows how it can be done using the deconvolution network and U-Net. Finally, the lesson ends with how to do instance segmentation using the Mask R-CNN network.

Lesson 11: Applying Deep Learning

In the final lesson, Magnus talks about some aspects to keep in mind as you start applying your newly gained skills. First he discusses ethical aspects related to artificial intelligence and working with data in general. It is important to think ahead and avoid unintentionally causing harm. He then provides some practical advice on how to approach the problem of tuning a network. Finally, the lesson ends by highlighting some areas that were not discussed in the lessons but that can be interesting for you to learn more about.