Vadim Karpusenko
Microsoft
A Practical Guide to Machine Learning with TensorFlow 2.0 & Keras
5 hours, 22 minutes CC
Course Description
Understand the evolution of machine learning, deep learning, and now artificial intelligence (AI). In this course, you'll follow a series of practical examples of training machine learning models to come up with accurate predictions. You'll use TensorFlow to create the models and Keras, a high-level Python API for building and training deep learning models on top of TensorFlow. Examples in this course include: identifying animal breeds in photos, analyzing blocks of text to determine which renowned author wrote it, and stylizing images trained by famous painters!
This course and others like it are available as part of our Frontend Masters video subscription.
Preview
CloseLearn Straight from the Experts Who Shape the Modern Web
Your Path to Senior Developer and Beyond
- 200+ In-depth courses
- 18 Learning Paths
- Industry Leading Experts
- Live Interactive Workshops
Table of Contents
Introduction
Section Duration: 12 minutes
Vadim Karpusenko introduces the course, and gives an overview of materials that will be needed to complete the course.
Vadim introduces Jupyter Notebook, and demonstrates how to access local files on the platform.
Machine Learning, Neural Networks & Deep Learning
Section Duration: 58 minutes
Vadim demonstrates how to use PoseNet, a machine learning model which allows for real-time human pose estimation in the browser.
Vadim shares the three books the workshops references, and points out that each book has a Github repository with its corresponding source code.
Vadim discusses the relationship between statistics and machine learning, and explains the concept of feeding. Feeding is when machine learning takes practical information and measurements, and finds distributions and corresponding values.
Vadim analyzes what the relationship between machine learning and neurons is, and explains that machine learning is replicating the processing of information of neurons, it associates neural channels with specific weights, and adds multiple signals together.
Vadim describes the process of how deep learning is generated, which is from multiple layers of neurons being part of a machine learning model.
Vadim explains that each neuron within a network has its own weight, demonstrates that reinforcement is learned by a neural network by penalizing or rewarding the activated neural channels, and shrinking down or increasing the weight associated with each neuron.
Vadim explains that in machine learning, data is fed to a model, processed through a CPU or GPU, then the data is frozen or stored once the training ends. Afterwards, a new image is fed to the model, and with proper training the model should be able to recognize what the image represents.
Vadim explains that when thinking about artificial intelligence, engineers assume that the computer is passing the Turing test and is able to be creative. Once information is processed through deep learning, artificial intelligence determines how to use the data. An example is given of an image's style being processed through deep learning and AI applying that style to another image.
Vadim highlights other examples where AI modeling changes the style of an image after being given data processed through deep learning.
Vadim demonstrates how neural networks can be trained to work on different tasks, and have their work combined.
Linear Regression
Section Duration: 1 hour, 17 minutes
Vadim demonstrates how to import libraries and run code on the Jupyter Notebook.
Vadim gives an overview of how hardware and the compiler work together as a premise to better understanding how tensorflow functions under the hood.
Vadim gives an overview of how Tensorflow is built, explains that Tensorflow used computational graphs to allocated memory, and is now switching to use eager execution which means Tensorflow has access to the code right when it is executed.
Vadim demonstrates how to use the Matplotlib library to depict uniform data. The following sections iterate over the same linear regression model.
Vadim demonstrates how to add noise to a normal distribution, and how to use both the Matplotlib and the numpy libraries for histograms using the linear regression example from the previous section.
Vadim demonstrates how to use TensorFlow to calculate the error between two different plot lines: one representing the solution, and the other being a prediction of the solution. The loss function calculates the difference between the solution and the prediction. This section introduces different types of helper functions used to predict data using TensorFlow.
Vadim explains that in order to improve the loss function, one has to improve the neural network learning rate by modifying the weights and biases within the loss function.
Vadim demonstrates how to use gradients and learning rates to better the training process of a model and get closer to the solution. The more the learning rate increases, the closer the model will get to the line representing the linear regression.
Vadim explains that learning rates and steps are independent hyper parameters that, when combined, lead to more accuracy, and reviews the concept of loss function and how it was applied to this section's linear regression example.
Image Processing & Model Training
Section Duration: 1 hour, 7 minutes
Vadim demonstrates how to build training data, use a dataset, and visualize its images using the Matplotlib library.
Vadim demonstrates how to add layers to model by first creating a sequential model one layer and allocating a specific amount of neurons to the layer.
Vadim compares sigmoid to the rectified linear unit, and explains that calculating one sigmoid value requires iteration, whereas using the rectified linear unit is one quick operation. ReLU is preferred to sigmoid because it calculates faster and does not perform exponential operations.
Vadim explains that the softmax function has an output equal to one. Normalizing the sum of output to one permits to look into neurons as probabilities.
Vadim describes the different layers available in a model, the difference between a flatten and dense layer, and discusses how pixels and neurons interact within each layer.
Vadim explains that, in a model, a solver contains information about how to get to the solution and determines what the loss function should be.
Vadim explains that, after defining the solver and the loss function, the model needs to be trained. To train a model, data is given to the model, the model iterates through multiple trainings, called epochs, and then the model compares its estimations to the validated data.
Vadim explores modifying the number of layers and neurons, and compares the accuracy of each model. A model is divided into a training dataset, a test dataset, and a validation dataset, which has images that were never seen by the model. The validation dataset determines which model is the best one.
Vadim explains that principal component analysis is a mathematical technique that looks at all of the provided data, and analyzes how much useful information is contained per degrees of freedom.
Convolution & Pooling
Section Duration: 1 hour, 2 minutes
Vadim explores two important methods in image processing: convolutions and pooling. Convolution is only partially connected neural networks to pixels. Pooling only takes in consideration the largest pixel within a pool of pixels from a given image.
Vadim demonstrates how to add multiple convolutional layers and how to add a callback function containing an accuracy rate. The accuracy rate is useful when when the correct number of epochs is unknown.
Vadim demonstrates how to plot a model accuracy and a model loss for both the training and the test functions.
Vadim demonstrates how convolutional operations change an image using a filter that modifies its pixels.
Vadim provides different steps that one can take after training a model, accesses individual layers, starts predictions, and visualizes neural networks.
Vadim explores where the convolutional network looks for data when making predictions, introduces the concept of transfer of learning, and answers a question about the use of mini bashes.
Vadim explores training my the model into recognizing a new image, and focuses on where the attention of the neural network is.
Text Analytics
Section Duration: 43 minutes
Vadim explains that a dataset can be overfed with data, and demonstrates how to spot overfeeding and prevent it.
Vadim explains that in language processing, each word is assigned particular coordinates. Tthis way negative and positive words are differentiated. Word embedding is also discussed.
Vadim demonstrates how to train a model to predict if comments are positive or negative, and explains that predictability depends on the given dataset and the preprocessing of the text.
Vadim explores Long Short Term Memory or LSTM ,one of the classes of neural networks , explains how one has to build intuition when working in machine learning and deep learning, highlights the importance of keeping a clean training dataset, and trains a model that recognizes the author of a quote.
Vadim explains what reinforcement learning is, introduces different reinforcement learning example, and introduces the open AI gym, a toolkit for developing and comparing reinforcement learning algorithms.
Wrapping Up
Section Duration: 1 minute
Vadim wraps up the course, thanks the audience, and reviews the main topics of the different sections.
Learn Straight from the Experts Who Shape the Modern Web
- In-depth Courses
- Industry Leading Experts
- Learning Paths
- Live Interactive Workshops