Learning Deep Learning: From Perceptron to Large Language Models (Video Course)

Description

13+ Hours of Video Instruction

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.

Skill Level:

• Beginner
• Intermediate 

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

Who Should Take This Course:

• Those who want to learn what deep learning is all about
• Experienced programmers who want to take advantage of deep learning in applications

Course Requirements:

• Some programming knowledge, preferrably in Python, is needed to understand the programming examples
• To fully understand the neural network learning algorithm (backpropagation), knowledge of calculus is required

Lesson Descriptions:

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.

About Pearson Video Training

Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more.

Learn more about Pearson Video training at http://www.informit.com/video.

Sample Content

Table of Contents

Introduction

Lesson 1:     Deep Learning Introduction

1.1      Deep Learning and Its History

1.2      Prerequisites

Lesson 2:     Neural Network Fundamentals I

2.1      The Perceptron and Its Learning Algorithm

2.2      Programming Example: Perceptron

2.3      Understanding the Bias Term

2.4      Matrix and Vector Notation for Neural Networks

2.5      Perceptron Limitations

2.6      Solving Learning Problem with Gradient Descent

2.7      Computing Gradient with the Chain Rule

2.8      The Backpropagation Algorithm

2.9      Programming Example: Learning the XOR Function

2.1      What Activation Function to Use

2.11    Lesson 2 Summary

Lesson 3:     Neural Network Fundamentals II

3.1      Datasets and Generalization

3.2      Multiclass Classification

3.3      Programming Example: Digit Classification with Python

3.4      DL Frameworks

3.5      Programming Example: Digit Classification with TensorFlow

3.6      Programming Example: Digit Classification with PyTorch

3.7      Avoiding Saturating Neurons and Vanishing GradientsPart I

3.8      Avoiding Saturating Neurons and Vanishing GradientsPart II

3.9      Variations on Gradient Descent

3.1      Programming Example: Improved Digit Classification with TensorFlow

3.11    Programming Example: Improved Digit Classification with PyTorch

3.12    Problem Types, Output Units, and Loss Functions

3.13    Regularization Techniques

3.14    Programming Example: Regression Problem with TensorFlow

3.15    Programming Example: Regression Problem with PyTorch

3.16    Lesson 3 Summary

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

4.1      The CIFAR-10 Dataset

4.2      Convolutional Layer

4.3      Building a Convolutional Neural Network

4.4      Programming Example: Image Classification Using CNN with TensorFlow

4.5      Programming Example: Image Classification Using CNN with PyTorch

4.6      AlexNet

4.7      VGGNet

4.8      GoogLeNet

4.9      ResNet

4.1      Programming Example: Using a Pretrained Network with TensorFlow

4.11    Programming Example: Using a Pretrained Network with PyTorch

4.12    Amplifying Your Data

4.13    Efficient CNNs

4.14    Lesson 4 Summary

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

5.1      Problem Types Involving Sequential Data

5.2      Recurrent Neural Networks

5.3      Programming Example: Forecasting Book Sales with TensorFlow

5.4      Programming Example: Forecasting Book Sales with PyTorch

5.5      Backpropagation Through Time and Keeping Gradients Healthy

5.6      Long Short-Term Memory

5.7      Autoregression and Beam Search

5.8      Programming Example: Text Autocompletion with TensorFlow

5.9      Programming Example: Text Autocompletion with PyTorch

5.1      Lesson 5 Summary

Lesson 6:     Neural Language Models and Word Embeddings

6.1      Language Models

6.2      Word Embeddings

6.3      Programming Example: Language Model and Word Embeddings with TensorFlow

6.4      Programming Example: Language Model and Word Embeddings with PyTorch

6.5      Word2vec

6.6      Programming Example: Using Pretrained GloVe Embeddings

6.7      Handling Out-of-Vocabulary Words with Wordpieces

6.8      Lesson 6 Summary

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

7.1      EncoderDecoder Network for Neural Machine Translation

7.2      Programming Example: Neural Machine Translation with TensorFlow

7.3      Programming Example: Neural Machine Translation with PyTorch

7.4      Attention

7.5      The Transformer

7.6      Programming Example: Machine Translation Using Transformer with TensorFlow

7.7      Programming Example: Machine Translation Using Transformer with PyTorch

7.8      Lesson 7 Summary

Lesson 8:     Large Language Models

8.1      Overview of BERT

8.2      Overview of GPT

8.3      From GPT to GPT4

8.4      Handling Chat History

8.5      Prompt Tuning

8.6      Retrieving Data and Using Tools

8.7      Open Datasets and Models

8.8      Demo: Large Language Model Prompting

8.9      Lesson 8 Summary

Lesson 9:     Multimodal Networks and Image Captioning

9.1      Multimodal learning

9.2      Programming Example: Multimodal Classification with TensorFlow

9.3      Programming Example: Multimodal Classification with PyTorch

9.4      Image Captioning with Attention

9.5      Programming Example: Image Captioning with TensorFlow

9.6      Programming Example: Image Captioning with PyTorch

9.7      Multimodal Large Language Models

9.8      Lesson 9 Summary

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

10.1    Multitask Learning

10.2    Programming Example: Multitask Learning with TensorFlow

10.3    Programming Example: Multitask Learning with PyTorch

10.4    Object Detection with R-CNN

10.5    Improved Object Detection with Fast and Faster R-CNN

10.6    Segmentation with Deconvolution Network and U-Net

10.7    Instance Segmentation with Mask R-CNN

10.8    Lesson 10 Summary

Lesson 11:   Applying Deep Learning        

11.1    Ethical AI and Data Ethics

11.2    Process for Tuning a Network

11.3    Further Studies

Summary     

Updates

Submit Errata