TensorFlow for Deep Learning Bootcamp: Zero to Mastery

Name: TensorFlow for Deep Learning Bootcamp: Zero to Mastery
Price: -1 USD

via Zero To Mastery

Go to class Write review

Details

Go to class

Provider

Zero To Mastery
Pricing

Paid Course
Languages

English
Certificate

Paid Certificate Available
Duration & workload

64 hours
Sessions

On-Demand

Found in

Overview

Learn TensorFlow. Get Hired as a TensorFlow Developer. This course will take you from a total beginner to becoming a Deep Learning Expert.

Understand how to integrate Machine Learning into tools and applications
Build image recognition, text recognition algorithms with deep neural networks and convolutional neural networks
Applying Deep Learning for Time Series Forecasting
Be recognized as a top candidate for recruiters seeking TensorFlow developers
Build TensorFlow models using Computer Vision, Convolutional Neural Networks, and Natural Language Processing
Increase your skills in Machine Learning and Deep Learning
Learn to build all types of Machine Learning Models using the latest TensorFlow 2
Using real-world images in different shapes and sizes to visualize the journey of an image through convolutions to understand how a computer “sees” information, plot loss and accuracy
Gain the skills you need to become a TensorFlow Developer

Syllabus

Introduction

TensorFlow for Deep Learning: Zero to Mastery
Course Outline
Exercise: Meet Your Classmates and Instructor
All Course Resources + Notebooks
Python + Machine Learning Monthly
ZTM Plugin + Understanding Your Video Player
Set Your Learning Streak Goal

Deep Learning and TensorFlow Fundamentals

What is deep learning?
Why use deep learning?
What are neural networks?
What is deep learning already being used for?
What is and why use TensorFlow?
What is a Tensor?
What we're going to cover throughout the course
How to approach this course
Need A Refresher?
Creating your first tensors with TensorFlow and tf.constant()
Creating tensors with TensorFlow and tf.Variable()
Creating random tensors with TensorFlow
Shuffling the order of tensors
Creating tensors from NumPy arrays
Getting information from your tensors (tensor attributes)
Indexing and expanding tensors
Manipulating tensors with basic operations
Matrix multiplication with tensors part 1
Matrix multiplication with tensors part 2
Matrix multiplication with tensors part 3
Changing the datatype of tensors
Tensor aggregation (finding the min, max, mean & more)
Tensor troubleshooting example (updating tensor datatypes)
Finding the positional minimum and maximum of a tensor (argmin and argmax)
Squeezing a tensor (removing all 1-dimension axes)
One-hot encoding tensors
Trying out more tensor math operations
Exploring TensorFlow and NumPy's compatibility
Making sure our tensor operations run really fast on GPUs
TensorFlow Fundamentals challenge, exercises & extra-curriculum
Let's Have Some Fun (+ Free Resources)

Neural network regression with TensorFlow

Introduction to Neural Network Regression with TensorFlow
Inputs and outputs of a neural network regression model
Anatomy and architecture of a neural network regression model
Creating sample regression data (so we can model it)
Note: Code update for upcoming lecture(s) for TensorFlow 2.7.0+ fix
Endorsements On LinkedIn
The major steps in modelling with TensorFlow
Steps in improving a model with TensorFlow part 1
Steps in improving a model with TensorFlow part 2
Steps in improving a model with TensorFlow part 3
Evaluating a TensorFlow model part 1 ("visualise, visualise, visualise")
Evaluating a TensorFlow model part 2 (the three datasets)
Evaluating a TensorFlow model part 3 (getting a model summary)
Evaluating a TensorFlow model part 4 (visualising a model's layers)
Evaluating a TensorFlow model part 5 (visualising a model's predictions)
Evaluating a TensorFlow model part 6 (common regression evaluation metrics)
Evaluating a TensorFlow regression model part 7 (mean absolute error)
Evaluating a TensorFlow regression model part 7 (mean square error)
Setting up TensorFlow modelling experiments part 1 (start with a simple model)
Setting up TensorFlow modelling experiments part 2 (increasing complexity)
Comparing and tracking your TensorFlow modelling experiments
How to save a TensorFlow model
How to load and use a saved TensorFlow model
(Optional) How to save and download files from Google Colab
Putting together what we've learned part 1 (preparing a dataset)
Putting together what we've learned part 2 (building a regression model)
Putting together what we've learned part 3 (improving our regression model)
Preprocessing data with feature scaling part 1 (what is feature scaling?)
Preprocessing data with feature scaling part 2 (normalising our data)
Preprocessing data with feature scaling part 3 (fitting a model on scaled data)
TensorFlow Regression challenge, exercises & extra-curriculum
Unlimited Updates

Neural network classification in TensorFlow

Introduction to neural network classification in TensorFlow
Example classification problems (and their inputs and outputs)
Input and output tensors of classification problems
Typical architecture of neural network classification models with TensorFlow
Creating and viewing classification data to model
Checking the input and output shapes of our classification data
Building a not very good classification model with TensorFlow
Trying to improve our not very good classification model
Creating a function to view our model's not so good predictions
Note: Updates for TensorFlow 2.7.0
Make our poor classification model work for a regression dataset
Non-linearity part 1: Straight lines and non-straight lines
Non-linearity part 2: Building our first neural network with non-linearity
Non-linearity part 3: Upgrading our non-linear model with more layers
Non-linearity part 4: Modelling our non-linear data once and for all
Non-linearity part 5: Replicating non-linear activation functions from scratch
Getting great results in less time by tweaking the learning rate
Using the TensorFlow History object to plot a model's loss curves
Using callbacks to find a model's ideal learning rate
Training and evaluating a model with an ideal learning rate
Introducing more classification evaluation methods
Finding the accuracy of our classification model
Creating our first confusion matrix (to see where our model is getting confused)
Making our confusion matrix prettier
Putting things together with multi-class classification part 1: Getting the data
Multi-class classification part 2: Becoming one with the data
Multi-class classification part 3: Building a multi-class classification model
Multi-class classification part 4: Improving performance with normalisation
Multi-class classification part 5: Comparing normalised and non-normalised data
Multi-class classification part 6: Finding the ideal learning rate
Multi-class classification part 7: Evaluating our model
Multi-class classification part 8: Creating a confusion matrix
Multi-class classification part 9: Visualising random model predictions
What "patterns" is our model learning?
TensorFlow classification challenge, exercises & extra-curriculum
Course Check-In

Computer Vision and Convolutional Neural Networks in TensorFlow

Introduction to Computer Vision with TensorFlow
Introduction to Convolutional Neural Networks (CNNs) with TensorFlow
Downloading an image dataset for our first Food Vision model
Becoming One With Data
Becoming One With Data Part 2
Becoming One With Data Part 3
Building an end to end CNN Model
Using a GPU to run our CNN model 5x faster
Trying a non-CNN model on our image data
Improving our non-CNN model by adding more layers
Breaking our CNN model down part 1: Becoming one with the data
Breaking our CNN model down part 2: Preparing to load our data
Breaking our CNN model down part 3: Loading our data with ImageDataGenerator
Breaking our CNN model down part 4: Building a baseline CNN model
Breaking our CNN model down part 5: Looking inside a Conv2D layer
Breaking our CNN model down part 6: Compiling and fitting our baseline CNN
Breaking our CNN model down part 7: Evaluating our CNN's training curves
Breaking our CNN model down part 8: Reducing overfitting with Max Pooling
Breaking our CNN model down part 9: Reducing overfitting with data augmentation
Breaking our CNN model down part 10: Visualizing our augmented data
Breaking our CNN model down part 11: Training a CNN model on augmented data
Breaking our CNN model down part 12: Discovering the power of shuffling data
Breaking our CNN model down part 13: Exploring options to improve our model
Downloading a custom image to make predictions on
Writing a helper function to load and preprocessing custom images
Making a prediction on a custom image with our trained CNN
Multi-class CNN's part 1: Becoming one with the data
Multi-class CNN's part 2: Preparing our data (turning it into tensors)
Multi-class CNN's part 3: Building a multi-class CNN model
Multi-class CNN's part 4: Fitting a multi-class CNN model to the data
Multi-class CNN's part 5: Evaluating our multi-class CNN model
Multi-class CNN's part 6: Trying to fix overfitting by removing layers
Multi-class CNN's part 7: Trying to fix overfitting with data augmentation
Multi-class CNN's part 8: Things you could do to improve your CNN model
Multi-class CNN's part 9: Making predictions with our model on custom images
Saving and loading our trained CNN model
TensorFlow computer vision and CNNs challenge, exercises & extra-curriculum
Implement a New Life System

Transfer Learning in TensorFlow Part 1: Feature extraction

What is and why use transfer learning?
Downloading and preparing data for our first transfer learning model
Introducing Callbacks in TensorFlow and making a callback to track our models
Exploring the TensorFlow Hub website for pretrained models
Building and compiling a TensorFlow Hub feature extraction model
Blowing our previous models out of the water with transfer learning
Plotting the loss curves of our ResNet feature extraction model
Building and training a pre-trained EfficientNet model on our data
Different Types of Transfer Learning
Comparing Our Model's Results
TensorFlow Transfer Learning Part 1 challenge, exercises & extra-curriculum

Transfer Learning in TensorFlow Part 2: Fine tuning

Introduction to Transfer Learning in TensorFlow Part 2: Fine-tuning
Importing a script full of helper functions (and saving lots of space)
Exercise: Imposter Syndrome
Downloading and turning our images into a TensorFlow BatchDataset
Discussing the four (actually five) modelling experiments we're running
Comparing the TensorFlow Keras Sequential API versus the Functional API
Note: Fixes for EfficientNetB0 model creation + weight loading
Creating our first model with the TensorFlow Keras Functional API
Compiling and fitting our first Functional API model
Getting a feature vector from our trained model
Drilling into the concept of a feature vector (a learned representation)
Downloading and preparing the data for Model 1 (1 percent of training data)
Building a data augmentation layer to use inside our model
Note: Small fix for next video, for images not augmenting
Visualizing what happens when images pass through our data augmentation layer
Building Model 1 (with a data augmentation layer and 1% of training data)
Building Model 2 (with a data augmentation layer and 10% of training data)
Creating a ModelCheckpoint to save our model's weights during training
Fitting and evaluating Model 2 (and saving its weights using ModelCheckpoint)
Loading and comparing saved weights to our existing trained Model 2
Preparing Model 3 (our first fine-tuned model)
Fitting and evaluating Model 3 (our first fine-tuned model)
Comparing our model's results before and after fine-tuning
Downloading and preparing data for our biggest experiment yet (Model 4)
Preparing our final modelling experiment (Model 4)
Fine-tuning Model 4 on 100% of the training data and evaluating its results
Comparing our modelling experiment results in TensorBoard
How to view and delete previous TensorBoard experiments
Transfer Learning in TensorFlow Part 2 challenge, exercises and extra-curriculum

Transfer Learning with TensorFlow Part 3: Scaling Up

Introduction to Transfer Learning Part 3: Scaling Up
Getting helper functions ready and downloading data to model
Outlining the model we're going to build and building a ModelCheckpoint callback
Creating a data augmentation layer to use with our model
Creating a headless EfficientNetB0 model with data augmentation built in
Fitting and evaluating our biggest transfer learning model yet
Unfreezing some layers in our base model to prepare for fine-tuning
Fine-tuning our feature extraction model and evaluating its performance
Saving and loading our trained model
Downloading a pretrained model to make and evaluate predictions with
Making predictions with our trained model on 25,250 test samples
Unravelling our test dataset for comparing ground truth labels to predictions
Confirming our model's predictions are in the same order as the test labels
Creating a confusion matrix for our model's 101 different classes
Evaluating every individual class in our dataset
Plotting our model's F1-scores for each separate class
Creating a function to load and prepare images for making predictions
Making predictions on our test images and evaluating them
Discussing the benefits of finding your model's most wrong predictions
Writing code to uncover our model's most wrong predictions
Plotting and visualizing the samples our model got most wrong
Making predictions on and plotting our own custom images
Transfer Learning in TensorFlow Part 3 challenge, exercises and extra-curriculum

Milestone Project 1: Food Vision Big™

Introduction to Milestone Project 1: Food Vision Big™
Making sure we have access to the right GPU for mixed precision training
Getting helper functions ready
Introduction to TensorFlow Datasets (TFDS)
Exploring and becoming one with the data (Food101 from TensorFlow Datasets)
Creating a preprocessing function to prepare our data for modelling
Batching and preparing our datasets (to make them run fast)
Exploring what happens when we batch and prefetch our data
Creating modelling callbacks for our feature extraction model
Note: Mixed Precision producing errors for TensorFlow 2.5+
Turning on mixed precision training with TensorFlow
Creating a feature extraction model capable of using mixed precision training
Checking to see if our model is using mixed precision training layer by layer
Training and evaluating a feature extraction model (Food Vision Big™)
Introducing your Milestone Project 1 challenge: build a model to beat DeepFood
Milestone Project 1: Food Vision Big™, exercises and extra-curriculum

NLP Fundamentals in TensorFlow

Welcome to natural language processing with TensorFlow!
Introduction to Natural Language Processing (NLP) and Sequence Problems
Example NLP inputs and outputs
The typical architecture of a Recurrent Neural Network (RNN)
Preparing a notebook for our first NLP with TensorFlow project
Becoming one with the data and visualizing a text dataset
Splitting data into training and validation sets
Converting text data to numbers using tokenisation and embeddings (overview)
Setting up a TensorFlow TextVectorization layer to convert text to numbers
Mapping the TextVectorization layer to text data and turning it into numbers
Creating an Embedding layer to turn tokenised text into embedding vectors
Discussing the various modelling experiments we're going to run
Model 0: Building a baseline model to try and improve upon
Creating a function to track and evaluate our model's results
Model 1: Building, fitting and evaluating our first deep model on text data
Visualizing our model's learned word embeddings with TensorFlow's projector tool
High-level overview of Recurrent Neural Networks (RNNs) + where to learn more
Model 2: Building, fitting and evaluating our first TensorFlow RNN model (LSTM)
Model 3: Building, fitting and evaluating a GRU-cell powered RNN
Model 4: Building, fitting and evaluating a bidirectional RNN model
Discussing the intuition behind Conv1D neural networks for text and sequences
Model 5: Building, fitting and evaluating a 1D CNN for text
Using TensorFlow Hub for pretrained word embeddings (transfer learning for NLP)
Model 6: Building, training and evaluating a transfer learning model for NLP
Preparing subsets of data for model 7 (same as model 6 but 10% of data)
Model 7: Building, training and evaluating a transfer learning model on 10% data
Fixing our data leakage issue with model 7 and retraining it
Comparing all our modelling experiments evaluation metrics
Uploading our model's training logs to TensorBoard and comparing them
Saving and loading in a trained NLP model with TensorFlow
Downloading a pretrained model and preparing data to investigate predictions
Visualizing our model's most wrong predictions
Making and visualizing predictions on the test dataset
Understanding the concept of the speed/score tradeoff
NLP Fundamentals in TensorFlow challenge, exercises and extra-curriculum

Milestone Project 2: SkimLit

Introduction to Milestone Project 2: SkimLit
What we're going to cover in Milestone Project 2 (NLP for medical abstracts)
SkimLit inputs and outputs
Setting up our notebook for Milestone Project 2 (getting the data)
Visualizing examples from the dataset (becoming one with the data)
Writing a preprocessing function to structure our data for modelling
Performing visual data analysis on our preprocessed text
Turning our target labels into numbers (ML models require numbers)
Model 0: Creating, fitting and evaluating a baseline model for SkimLit
Preparing our data for deep sequence models
Creating a text vectoriser to map our tokens (text) to numbers
Creating a custom token embedding layer with TensorFlow
Creating fast loading dataset with the TensorFlow tf.data API
Model 1: Building, fitting and evaluating a Conv1D with token embeddings
Preparing a pretrained embedding layer from TensorFlow Hub for Model 2
Model 2: Building, fitting and evaluating a Conv1D model with token embeddings
Creating a character-level tokeniser with TensorFlow's TextVectorization layer
Creating a character-level embedding layer with tf.keras.layers.Embedding
Model 3: Building, fitting and evaluating a Conv1D model on character embeddings
Discussing how we're going to build Model 4 (character + token embeddings)
Model 4: Building a multi-input model (hybrid token + character embeddings)
Model 4: Plotting and visually exploring different data inputs
Crafting multi-input fast loading tf.data datasets for Model 4
Model 4: Building, fitting and evaluating a hybrid embedding model
Model 5: Adding positional embeddings via feature engineering (overview)
Encoding the line number feature to used with Model 5
Encoding the total lines feature to be used with Model 5
Model 5: Building the foundations of a tribrid embedding model
Model 5: Completing the build of a tribrid embedding model for sequences
Visually inspecting the architecture of our tribrid embedding model
Creating multi-level data input pipelines for Model 5 with the tf.data API
Bringing SkimLit to life!!! (fitting and evaluating Model 5)
Comparing the performance of all of our modelling experiments
Saving, loading & testing our best performing model
Congratulations and your challenge before heading to the next module
Milestone Project 2 (SkimLit) challenge, exercises and extra-curriculum

Time Series fundamentals in TensorFlow + Milestone Project 3: BitPredict

Welcome to time series fundamentals with TensorFlow + Milestone Project 3!
Introduction to Milestone Project 3 (BitPredict) & where you can get help
What is a time series problem and example forecasting problems at Uber
Example forecasting problems in daily life
What can be forecast?
What we're going to cover (broadly)
Time series forecasting inputs and outputs
Downloading and inspecting our Bitcoin historical dataset
Different kinds of time series patterns & different amounts of feature variables
Visualizing our Bitcoin historical data with pandas
Reading in our Bitcoin data with Python's CSV module
Creating train and test splits for time series (the wrong way)
Creating train and test splits for time series (the right way)
Creating a plotting function to visualize our time series data
Discussing the various modelling experiments were going to be running
Model 0: Making and visualizing a naive forecast model
Discussing some of the most common time series evaluation metrics
Implementing MASE with TensorFlow
Creating a function to evaluate our model's forecasts with various metrics
Discussing other non-TensorFlow kinds of time series forecasting models
Formatting data Part 2: Creating a function to label our windowed time series
Discussing the use of windows and horizons in time series data
Writing a preprocessing function to turn time series data into windows & labels
Turning our windowed time series data into training and test sets
Creating a modelling checkpoint callback to save our best performing model
Model 1: Building, compiling and fitting a deep learning model on Bitcoin data
Creating a function to make predictions with our trained models
Model 2: Building, fitting and evaluating a deep model with a larger window size-27
Model 3: Building, fitting and evaluating a model with a larger horizon size
Adjusting the evaluation function to work for predictions with larger horizons
Model 3: Visualizing the results
Comparing our modelling experiments so far and discussing autocorrelation
Preparing data for building a Conv1D model
Model 4: Building, fitting and evaluating a Conv1D model on our Bitcoin data
Model 5: Building, fitting and evaluating a LSTM (RNN) model on our Bitcoin data
Investigating how to turn our univariate time series into multivariate
Creating and plotting a multivariate time series with BTC price and block reward
Preparing our multivariate time series for a model
Model 6: Building, fitting and evaluating a multivariate time series model
Model 7: Discussing what we're going to be doing with the N-BEATS algorithm
Model 7: Replicating the N-BEATS basic block with TensorFlow layer subclassing
Model 7: Testing our N-BEATS block implementation with dummy data inputs
Model 7: Creating a performant data pipeline for the N-BEATS model with tf.data
Model 7: Setting up hyperparameters for the N-BEATS algorithm
Model 7: Getting ready for residual connections
Model 7: Outlining the steps we're going to take to build the N-BEATS model
Model 7: Putting together the pieces of the puzzle of the N-BEATS model
Model 7: Plotting the N-BEATS algorithm we've created and admiring its beauty
Model 8: Ensemble model overview
Model 8: Building, compiling and fitting an ensemble of models
Model 8: Making and evaluating predictions with our ensemble model
Discussing the importance of prediction intervals in forecasting
Getting the upper and lower bounds of our prediction intervals
Plotting the prediction intervals of our ensemble model predictions
(Optional) Discussing the types of uncertainty in machine learning
Model 9: Preparing data to create a model capable of predicting into the future
Model 9: Building, compiling and fitting a future predictions model
Model 9: Discussing what's required for our model to make future predictions
Model 9: Creating a function to make forecasts into the future
Model 9: Plotting our model's future forecasts
Model 10: Introducing the turkey problem and making data for it
Model 10: Building a model to predict on turkey data (why forecasting is BS)
Comparing the results of all of our models and discussing where to go next
TensorFlow Time Series Fundamentals Challenge and Extra Resources