1 05:22 2 04:39 3 09:39 4 What are neural networks? 10:27 5 What is deep learning already being used for? 08:37 6 What is and why use TensorFlow? 07:57 7 03:38 8 What we're going to cover throughout the course 04:30 9 How to approach this course 05:34 10 Creating your first tensors with TensorFlow and tf.constant() 18:46 11 Creating tensors with TensorFlow and tf.Variable() 07:08 12 Creating random tensors with TensorFlow 09:41 13 Shuffling the order of tensors 09:41 14 Creating tensors from NumPy arrays 11:56 15 Getting information from your tensors (tensor attributes 11:58 16 Indexing and expanding tensors 12:34 17 Manipulating tensors with basic operations 05:35 18 Matrix multiplication with tensors part 1 11:54 19 Matrix multiplication with tensors part 2 13:30 20 Matrix multiplication with tensors part 3 10:04 21 Changing the datatype of tensors 06:56 22 Tensor aggregation (finding the min, max, mean & more) 09:50 23 Tensor troubleshooting example (updating tensor datatypes) 06:14 24 Finding the positional minimum and maximum of a tensor (argmin and argmax) (9:31) 09:32 25 Squeezing a tensor (removing all 1-dimension axes) 03:00 26 05:47 27 Trying out more tensor math operations 04:48 28 Exploring TensorFlow and NumPy's compatibility 05:44 29 Making sure our tensor operations run really fast on GPUs 10:20 30 Introduction to Neural Network Regression with TensorFlow 07:34 31 Inputs and outputs of a neural network regression model 09:00 32 Anatomy and architecture of a neural network regression model 07:56 33 Creating sample regression data (so we can model it) 12:47 34 The major steps in modelling with TensorFlow 20:16 35 Steps in improving a model with TensorFlow part 1 06:03 36 Steps in improving a model with TensorFlow part 2 09:26 37 Steps in improving a model with TensorFlow part 3 12:34 38 Evaluating a TensorFlow model part 1 ("visualise, visualise, visualise") 07:25 39 Evaluating a TensorFlow model part 2 (the three datasets) 11:02 40 Evaluating a TensorFlow model part 3 (getting a model summary) 17:19 41 Evaluating a TensorFlow model part 4 (visualising a model's layers) 07:15 42 Evaluating a TensorFlow model part 5 (visualising a model's predictions) 09:17 43 Evaluating a TensorFlow model part 6 (common regression evaluation metrics) 08:06 44 Evaluating a TensorFlow regression model part 7 (mean absolute error) 05:53 45 Evaluating a TensorFlow regression model part 7 (mean square error) 03:19 46 Setting up TensorFlow modelling experiments part 1 (start with a simple model) 13:51 47 Setting up TensorFlow modelling experiments part 2 (increasing complexity) 11:30 48 Comparing and tracking your TensorFlow modelling experiments 10:21 49 How to save a TensorFlow model 08:20 50 How to load and use a saved TensorFlow model 10:16 51 (Optional) How to save and download files from Google Colab 06:19 52 Putting together what we've learned part 1 (preparing a dataset) 13:32 53 Putting together what we've learned part 2 (building a regression model) 13:21 54 Putting together what we've learned part 3 (improving our regression model) 15:48 55 Preprocessing data with feature scaling part 1 (what is feature scaling?) 09:35 56 Preprocessing data with feature scaling part 2 (normalising our data) 10:58 57 Preprocessing data with feature scaling part 3 (fitting a model on scaled data) 07:41 58 Introduction to neural network classification in TensorFlow 08:26 59 Example classification problems (and their inputs and outputs) 06:39 60 Input and output tensors of classification problems 06:22 61 Typical architecture of neural network classification models with TensorFlow 09:37 62 Creating and viewing classification data to model 11:35 63 Checking the input and output shapes of our classification data 04:39 64 Building a not very good classification model with TensorFlow 12:11 65 Trying to improve our not very good classification model 09:14 66 Creating a function to view our model's not so good predictions 15:09 67 Make our poor classification model work for a regression dataset 12:19 68 Non-linearity part 1: Straight lines and non-straight lines 09:39 69 Non-linearity part 2: Building our first neural network with non-linearity 05:48 70 Non-linearity part 3: Upgrading our non-linear model with more layers 10:19 71 Non-linearity part 4: Modelling our non-linear data once and for all 08:38 72 Non-linearity part 5: Replicating non-linear activation functions from scratch 14:27 73 Getting great results in less time by tweaking the learning rate 14:48 74 Using the TensorFlow History object to plot a model's loss curves 06:12 75 Using callbacks to find a model's ideal learning rate 17:33 76 Training and evaluating a model with an ideal learning rate 09:21 77 Introducing more classification evaluation methods 06:05 78 Finding the accuracy of our classification model 04:18 79 Creating our first confusion matrix (to see where our model is getting confused) 08:28 80 Making our confusion matrix prettier 14:01 81 Putting things together with multi-class classification part 1: Getting the data 10:38 82 Multi-class classification part 2: Becoming one with the data 07:08 83 Multi-class classification part 3: Building a multi-class classification model 15:39 84 Multi-class classification part 4: Improving performance with normalisation 12:44 85 Multi-class classification part 5: Comparing normalised and non-normalised data 04:14 86 Multi-class classification part 6: Finding the ideal learning rate 10:39 87 Multi-class classification part 7: Evaluating our model 13:17 88 Multi-class classification part 8: Creating a confusion matrix 04:27 89 Multi-class classification part 9: Visualising random model predictions 10:43 90 What "patterns" is our model learning? 15:34 91 Introduction to Computer Vision with TensorFlow 09:37 92 Introduction to Convolutional Neural Networks (CNNs) with TensorFlow 08:00 93 Downloading an image dataset for our first Food Vision model 08:28 94 05:06 95 Becoming One With Data Part 2 12:27 96 Becoming One With Data Part 3 04:23 97 Building an end to end CNN Model 18:18 98 Using a GPU to run our CNN model 5x faster 09:18 99 Trying a non-CNN model on our image data 08:52 100 Improving our non-CNN model by adding more layers 09:53 101 Breaking our CNN model down part 1: Becoming one with the data 09:04 102 Breaking our CNN model down part 2: Preparing to load our data 11:47 103 Breaking our CNN model down part 3: Loading our data with ImageDataGenerator 09:55 104 Breaking our CNN model down part 4: Building a baseline CNN model 08:03 105 Breaking our CNN model down part 5: Looking inside a Conv2D layer 15:21 106 Breaking our CNN model down part 6: Compiling and fitting our baseline CNN 07:15 107 Breaking our CNN model down part 7: Evaluating our CNN's training curves 11:46 108 Breaking our CNN model down part 8: Reducing overfitting with Max Pooling 13:41 109 Breaking our CNN model down part 9: Reducing overfitting with data augmentation 06:53 110 Breaking our CNN model down part 10: Visualizing our augmented data 15:05 111 Breaking our CNN model down part 11: Training a CNN model on augmented data 08:50 112 Breaking our CNN model down part 12: Discovering the power of shuffling data 10:02 113 Breaking our CNN model down part 13: Exploring options to improve our model 05:22 114 Downloading a custom image to make predictions on 04:55 115 Writing a helper function to load and preprocessing custom images 10:01 116 Making a prediction on a custom image with our trained CNN 10:09 117 Multi-class CNN's part 1: Becoming one with the data 15:00 118 Multi-class CNN's part 2: Preparing our data (turning it into tensors) 06:39 119 Multi-class CNN's part 3: Building a multi-class CNN model 07:25 120 Multi-class CNN's part 4: Fitting a multi-class CNN model to the data 06:03 121 Multi-class CNN's part 5: Evaluating our multi-class CNN model ( 04:52 122 Multi-class CNN's part 6: Trying to fix overfitting by removing layers 12:20 123 Multi-class CNN's part 7: Trying to fix overfitting with data augmentation 11:47 124 Multi-class CNN's part 8: Things you could do to improve your CNN model 04:24 125 Multi-class CNN's part 9: Making predictions with our model on custom images 09:23 126 Saving and loading our trained CNN model 06:22 127 What is and why use transfer learning? 10:13 128 Downloading and preparing data for our first transfer learning model 14:40 129 Introducing Callbacks in TensorFlow and making a callback to track our models 10:02 130 Exploring the TensorFlow Hub website for pretrained models 09:52 131 Building and compiling a TensorFlow Hub feature extraction model 14:01 132 Blowing our previous models out of the water with transfer learning 09:14 133 Plotting the loss curves of our ResNet feature extraction model 07:36 134 Building and training a pre-trained EfficientNet model on our data 09:43 135 Different Types of Transfer Learning 11:41 136 Comparing Our Model's Results 15:17 137 Introduction to Transfer Learning in TensorFlow Part 2: Fine-tuning 06:17 138 Importing a script full of helper functions (and saving lots of space) 07:36 139 Downloading and turning our images into a TensorFlow BatchDataset 15:39 140 Discussing the four (actually five) modelling experiments we're running 02:16 141 Comparing the TensorFlow Keras Sequential API versus the Functional API 02:35 142 Creating our first model with the TensorFlow Keras Functional API 11:39 143 Compiling and fitting our first Functional API model 10:54 144 Getting a feature vector from our trained model 13:40 145 Drilling into the concept of a feature vector (a learned representation) 03:44 146 Downloading and preparing the data for Model 1 (1 percent of training data) 09:52 147 Building a data augmentation layer to use inside our model 12:07 148 Visualising what happens when images pass through our data augmentation layer 10:56 149 Building Model 1 (with a data augmentation layer and 1% of training data) 15:56 150 Building Model 2 (with a data augmentation layer and 10% of training data) 16:38 151 Creating a ModelCheckpoint to save our model's weights during training 07:26 152 Fitting and evaluating Model 2 (and saving its weights using ModelCheckpoint) 07:15 153 Loading and comparing saved weights to our existing trained Model 2 07:18 154 Preparing Model 3 (our first fine-tuned model) 20:27 155 Fitting and evaluating Model 3 (our first fine-tuned model) 07:46 156 Comparing our model's results before and after fine-tuning 10:27 157 Downloading and preparing data for our biggest experiment yet (Model 4) 06:25 158 Preparing our final modelling experiment (Model 4) 12:01 159 Fine-tuning Model 4 on 100% of the training data and evaluating its results 10:20 160 Comparing our modelling experiment results in TensorBoard 10:47 161 How to view and delete previous TensorBoard experiments 02:05 162 Introduction to Transfer Learning Part 3: Scaling Up 06:20 163 Getting helper functions ready and downloading data to model 13:35 164 Outlining the model we're going to build and building a ModelCheckpoint callback 05:39 165 Creating a data augmentation layer to use with our model 04:40 166 Creating a headless EfficientNetB0 model with data augmentation built in 08:59 167 Fitting and evaluating our biggest transfer learning model yet 07:57 168 Unfreezing some layers in our base model to prepare for fine-tuning 11:29 169 Fine-tuning our feature extraction model and evaluating its performance 08:24 170 Saving and loading our trained model 06:26 171 Downloading a pretrained model to make and evaluate predictions with 06:35 172 Making predictions with our trained model on 25,250 test samples 12:47 173 Unravelling our test dataset for comparing ground truth labels to predictions 06:06 174 Confirming our model's predictions are in the same order as the test labels 05:18 175 Creating a confusion matrix for our model's 101 different classes 12:08 176 Evaluating every individual class in our dataset 14:17 177 Plotting our model's F1-scores for each separate class 07:37 178 Creating a function to load and prepare images for making predictions 12:09 179 Making predictions on our test images and evaluating them 16:07 180 Discussing the benefits of finding your model's most wrong predictions 06:10 181 Writing code to uncover our model's most wrong predictions 11:17 182 Plotting and visualizing the samples our model got most wrong 10:37 183 Making predictions on and plotting our own custom images 09:50 184 Introduction to Milestone Project 1: Food Vision Big™ 05:45 185 Making sure we have access to the right GPU for mixed precision training 10:18 186 Getting helper functions ready 03:07 187 Introduction to TensorFlow Datasets (TFDS) 12:04 188 Exploring and becoming one with the data (Food101 from TensorFlow Datasets) 15:57 189 Creating a preprocessing function to prepare our data for modelling 15:51 190 Batching and preparing our datasets (to make them run fast) 13:48 191 Exploring what happens when we batch and prefetch our data 06:50 192 Creating modelling callbacks for our feature extraction model 07:15 193 Turning on mixed precision training with TensorFlow 10:06 194 Creating a feature extraction model capable of using mixed precision training 12:43 195 Checking to see if our model is using mixed precision training layer by layer 07:57 196 Training and evaluating a feature extraction model (Food Vision Big™) 10:20 197 Introducing your Milestone Project 1 challenge: build a model to beat DeepFood 07:48 198 Introduction to Natural Language Processing (NLP) and Sequence Problems 12:52 199 Example NLP inputs and outputs 07:23 200 The typical architecture of a Recurrent Neural Network (RNN) 09:04 201 Preparing a notebook for our first NLP with TensorFlow project 08:53 202 Becoming one with the data and visualizing a text dataset 16:42 203 Splitting data into training and validation sets 06:27 204 Converting text data to numbers using tokenisation and embeddings (overview) 09:23 205 Setting up a TensorFlow TextVectorization layer to convert text to numbers 17:11 206 Mapping the TextVectorization layer to text data and turning it into numbers 11:03 207 Creating an Embedding layer to turn tokenised text into embedding vectors 12:28 208 Discussing the various modelling experiments we're going to run 08:58 209 Model 0: Building a baseline model to try and improve upon 09:26 210 Creating a function to track and evaluate our model's results 12:15 211 Model 1: Building, fitting and evaluating our first deep model on text data 20:52 212 Visualizing our model's learned word embeddings with TensorFlow's projector tool 20:44 213 High-level overview of Recurrent Neural Networks (RNNs) + where to learn more 09:35 214 Model 2: Building, fitting and evaluating our first TensorFlow RNN model (LSTM) 18:17 215 Model 3: Building, fitting and evaluating a GRU-cell powered RNN 16:57 216 Model 4: Building, fitting and evaluating a bidirectional RNN model 19:35 217 Discussing the intuition behind Conv1D neural networks for text and sequences 19:32 218 Model 5: Building, fitting and evaluating a 1D CNN for text 09:58 219 Using TensorFlow Hub for pretrained word embeddings (transfer learning for NLP) 13:46 220 Model 6: Building, training and evaluating a transfer learning model for NLP 10:46 221 Preparing subsets of data for model 7 (same as model 6 but 10% of data) 10:53 222 Model 7: Building, training and evaluating a transfer learning model on 10% data 10:05 223 Fixing our data leakage issue with model 7 and retraining it 13:43 224 Comparing all our modelling experiments evaluation metrics 13:15 225 Uploading our model's training logs to TensorBoard and comparing them 11:15 226 Saving and loading in a trained NLP model with TensorFlow 10:26 227 Downloading a pretrained model and preparing data to investigate predictions 13:25 228 Visualizing our model's most wrong predictions 08:29 229 Making and visualizing predictions on the test dataset 08:28 230 Understanding the concept of the speed/score tradeoff 15:02 231 Introduction to Milestone Project 2: SkimLit 14:21 232 What we're going to cover in Milestone Project 2 (NLP for medical abstracts) 07:23 233 SkimLit inputs and outputs 11:03 234 Setting up our notebook for Milestone Project 2 (getting the data) 14:59 235 Visualizing examples from the dataset (becoming one with the data) 13:19 236 Writing a preprocessing function to structure our data for modelling 19:51 237 Performing visual data analysis on our preprocessed text 07:56 238 Turning our target labels into numbers (ML models require numbers) 13:16 239 Model 0: Creating, fitting and evaluating a baseline model for SkimLit 09:26 240 Preparing our data for deep sequence models 09:56 241 Creating a text vectoriser to map our tokens (text) to numbers 14:08 242 Creating a custom token embedding layer with TensorFlow 09:15 243 Creating fast loading dataset with the TensorFlow tf.data API 09:50 244 Model 1: Building, fitting and evaluating a Conv1D with token embeddings 17:22 245 Preparing a pretrained embedding layer from TensorFlow Hub for Model 2 10:54 246 Model 2: Building, fitting and evaluating a Conv1D model with token embeddings 11:31 247 Creating a character-level tokeniser with TensorFlow's TextVectorization layer 23:25 248 Creating a character-level embedding layer with tf.keras.layers.Embedding 07:45 249 Model 3: Building, fitting and evaluating a Conv1D model on character embeddings 13:46 250 Discussing how we're going to build Model 4 (character + token embeddings) 06:05 251 Model 4: Building a multi-input model (hybrid token + character embeddings) 15:37 252 Model 4: Plotting and visually exploring different data inputs 07:33 253 Crafting multi-input fast loading tf.data datasets for Model 4 08:42 254 Model 4: Building, fitting and evaluating a hybrid embedding model 13:19 255 Model 5: Adding positional embeddings via feature engineering (overview) 07:19 256 Encoding the line number feature to used with Model 5 12:26 257 Encoding the total lines feature to be used with Model 5 07:57 258 Model 5: Building the foundations of a tribrid embedding model 09:20 259 Model 5: Completing the build of a tribrid embedding model for sequences 14:09 260 Visually inspecting the architecture of our tribrid embedding model 10:26 261 Creating multi-level data input pipelines for Model 5 with the tf.data API 09:01 262 Bringing SkimLit to life!!! (fitting and evaluating Model 5) 10:36 263 Comparing the performance of all of our modelling experiments 09:37 264 Saving, loading & testing our best performing model 07:49 265 Congratulations and your challenge before heading to the next module 12:34 266 Introduction to Milestone Project 3 (BitPredict) & where you can get help 03:54 267 What is a time series problem and example forecasting problems at Uber 07:47 268 Example forecasting problems in daily life 04:53 269 07:58 270 What we're going to cover (broadly) 02:36 271 Time series forecasting inputs and outputs 08:56 272 Downloading and inspecting our Bitcoin historical dataset 14:59 273 Different kinds of time series patterns & different amounts of feature variables 07:40 274 Visualizing our Bitcoin historical data with pandas 04:53 275 Reading in our Bitcoin data with Python's CSV module 10:59 276 Creating train and test splits for time series (the wrong way) 08:38 277 Creating train and test splits for time series (the right way) 07:13 278 Creating a plotting function to visualize our time series data 07:58 279 Discussing the various modelling experiments were going to be running 09:12 280 Model 0: Making and visualizing a naive forecast model 12:17 281 Discussing some of the most common time series evaluation metrics 11:12 282 Implementing MASE with TensorFlow 09:39 283 Creating a function to evaluate our model's forecasts with various metrics 10:12 284 Discussing other non-TensorFlow kinds of time series forecasting models 05:07 285 Formatting data Part 2: Creating a function to label our windowed time series 13:02 286 Discussing the use of windows and horizons in time series data 07:51 287 Writing a preprocessing function to turn time series data into windows & labels 23:36 288 Turning our windowed time series data into training and test sets 10:02 289 Creating a modelling checkpoint callback to save our best performing model 07:26 290 Model 1: Building, compiling and fitting a deep learning model on Bitcoin data 16:59 291 Creating a function to make predictions with our trained models 14:04 292 Model 2: Building, fitting and evaluating a deep model with a larger window size-27 17:44 293 Model 3: Building, fitting and evaluating a model with a larger horizon size 13:16 294 Adjusting the evaluation function to work for predictions with larger horizons 08:35 295 Model 3: Visualizing the results 08:45 296 Comparing our modelling experiments so far and discussing autocorrelation 09:45 297 Preparing data for building a Conv1D model 13:22 298 Model 4: Building, fitting and evaluating a Conv1D model on our Bitcoin data 14:52 299 Model 5: Building, fitting and evaluating a LSTM (RNN) model on our Bitcoin data 16:06 300 Investigating how to turn our univariate time series into multivariate 13:53 301 Creating and plotting a multivariate time series with BTC price and block reward 12:13 302 Preparing our multivariate time series for a model 13:38 303 Model 6: Building, fitting and evaluating a multivariate time series model 09:26 304 Model 7: Discussing what we're going to be doing with the N-BEATS algorithm 09:40 305 Model 7: Replicating the N-BEATS basic block with TensorFlow layer subclassing 18:39 306 Model 7: Testing our N-BEATS block implementation with dummy data inputs 15:03 307 Model 7: Setting up hyperparameters for the N-BEATS algorithm 08:51 308 Model 7: Getting ready for residual connections 12:56 309 Model 7: Outlining the steps we're going to take to build the N-BEATS model 10:06 310 Model 7: Putting together the pieces of the puzzle of the N-BEATS model 22:23 311 Model 7: Plotting the N-BEATS algorithm we've created and admiring its beauty 06:47 312 Model 8: Ensemble model overview 04:44 313 Model 8: Building, compiling and fitting an ensemble of models 20:05 314 Model 8: Making and evaluating predictions with our ensemble model 16:10 315 Discussing the importance of prediction intervals in forecasting 12:57 316 Getting the upper and lower bounds of our prediction intervals 07:58 317 Plotting the prediction intervals of our ensemble model predictions 13:03 318 (Optional) Discussing the types of uncertainty in machine learning 13:42 319 Model 9: Preparing data to create a model capable of predicting into the future 08:25 320 Model 9: Building, compiling and fitting a future predictions model 05:02 321 Model 9: Discussing what's required for our model to make future predictions 08:31 322 Model 9: Creating a function to make forecasts into the future 12:09 323 Model 9: Plotting our model's future forecasts 13:10 324 Model 10: Introducing the turkey problem and making data for it 14:16 325 Model 10: Building a model to predict on turkey data (why forecasting is BS) 13:39 326 Comparing the results of all of our models and discussing where to go next 13:00 327 What is the TensorFlow Developer Certification? 05:29 328 Why the TensorFlow Developer Certification? 06:58 329 How to prepare (your brain) for the TensorFlow Developer Certification 08:15 330 How to prepare (your computer) for the TensorFlow Developer Certification 12:44 331 What to do after the TensorFlow Developer Certification exam 02:14 332 What is Machine Learning? 04:52 333 AI/Machine Learning/Data Science 06:53 334 Exercise: Machine Learning Playground 06:17 335 06:04 336 Exercise: YouTube Recommendation Engine 04:25 337 Types of Machine Learning 04:42 338 What Is Machine Learning? Round 2 04:45 339 01:49 340 02:39 341 Introducing Our Framework 03:09 342 6 Step Machine Learning Framework 05:00 343 Types of Machine Learning Problems 10:33 344 04:51 345 03:32 346 05:59 347 Modelling - Splitting Data 05:23 348 Modelling - Picking the Model 04:36 349 03:18 350 03:36 351 09:33 352 04:01 353 02:28 354 04:30 355 Series, Data Frames and CSVs 13:22 356 Describing Data with Pandas 09:49 357 Selecting and Viewing Data with Pandas 11:09 358 Selecting and Viewing Data with Pandas Part 2 13:07 359 13:57 360 09:57 361 10:13 362 How To Download The Course Assignments 02:41 363 07:44 364 05:18 365 NumPy DataTypes and Attributes 14:06 366 09:23 367 07:18 368 Viewing Arrays and Matrices 09:36 369 11:32 370 09:45 371 Standard Deviation and Variance 07:11 372 07:27 373 Dot Product vs Element Wise 11:46 374 Exercise: Nut Butter Store Sales 03:34 375 13:05 376 06:20 377 Turn Images Into NumPy Arrays 07:38 