My new TensorFlow for Deep Learning course is now live on Udemy

Done a beginner-level ML course? Ready to step up and learn deep learning? Like writing lots of code? This course is for you.

Friends, I’m writing to you from Brisbane’s Northern Beaches. It’s raining here. 4 pm feels like 6 pm.

During lockdowns of 2020, I got TensorFlow Developer Certified. And I made a video about it which people seemed to enjoy.

A lot of questions came in asking how I did it.

I answered with “I read the Hands-on Machine Learning Book end-to-end and then went through the practice questions for the exam.”

Which is true. And you could do the same steps if you wanted to pass the exam. Or you could take my new TensorFlow for Deep Learning course (now on Udemy, use this link for an excellent valued launch deal).

You can also sign up directly on the Zero to Mastery Academy (doing so here will give you access to all ZTM courses).

Specifically, the Zero to Mastery TensorFlow for Deep Learning course will teach you:

  1. Fundamental concepts of deep learning (we teach concepts using code)

  2. How to write TensorFlow code (lots of it)

  3. How to pass the TensorFlow Developer Certification (optional, but requires 1 & 2)

I’m so excited for this launch and am stoked that people are loving it so far.

Certifications are *nice* to have not *need* to have

I got asked whether the certification is necessary in a recent livestream Q&A about the course.

It’s not.

In the tech field, no certification is needed. If you have skills and demonstrate those skills (through a blog, projects of your own, a nice-looking GitHub), that is a certification in itself.

A certification is only one form of proof of skill.

Rather than an official certification, I’m a big fan of starting the job before you have it. For example, if you have some ideal role you’d like to work for a company as. Say, a machine learning engineer. Use your research skills to figure out what a machine learning engineer would do day to day and then start doing those things.

Use courses and certifications as foundational knowledge then use your own projects to build specific knowledge (knowledge that can’t be taught).

How is the course taught?

It’s taught code-first, code-along, apprenticeship style. This means in every video where a new concept is being introduced, it gets introduced using code.

Who should take the course?

This is a beginner-level course.

If you’ve got 1+ years of experience with deep learning/TensorFlow/PyTorch (PyTorch is another deep learning framework like TensorFlow), you shouldn’t take it, use your skills to make something instead.

This course is for coders with ~6-months of experience writing Python code who want to learn about deep learning and how to build neural networks for various problems using TensorFlow.

What are the prerequisites?

Even though it’s for beginners, there are some prerequisites I’d recommend.

  • 6+ months writing Python code. Can you write a Python function that accepts and uses parameters? That’s good enough. If you don’t know what that means, spend another month or two writing Python code and then come back here.

  • At least one beginner machine learning course. Are you familiar with the idea of training, validation and test sets? Do you know what supervised learning is? Have you used pandas, NumPy or Matplotlib before? If no for any of these, I’d go through at least one machine learning course that teaches these first and then coming back.

  • Comfortable using Google Colab/Jupyter Notebooks. This course uses Google Colab throughout. If you have never used Google Colab before, it works very similar to Jupyter Notebooks with a few extra features. If you’re not familiar with Google Colab notebooks, I’d suggest going through the Introduction to Google Colab notebook.

  • Plug: The Zero to Mastery beginner-friendly machine learning course (I also teach this) teaches all of the above (and this course is designed as a follow-on).

With this being said, you can watch the first 14-hours (see notebooks 00, 01, 02 below) of the course on YouTube. If you’re interested, I’d encourage you to try it out and see how you go.

What’s in the course?

You can see all of the materials on the course GitHub (this is the source of truth for the course, all major announcements/updates/Q&A will go here as well).

The course is broken down into 11 notebooks (starting from 0), all of which cover something specific about TensorFlow or deep learning.

Notebook 0 — TensorFlow Fundamentals

  • Introduction to tensors (creating tensors with TensorFlow)

  • Getting information from tensors (tensor attributes)

  • Manipulating tensors (tensor operations)

  • Tensors and NumPy

  • Using @tf.function (a way to speed up your regular Python functions)

  • Using GPUs with TensorFlow

Key takeaways:

  • Learn how to create and manipulate the fundamental building block of deep learning: the tensor

  • Learn to represent data as numbers (so it can be used with a machine learning model)

1 — Neural Network Regression with TensorFlow

  • The architecture of a neural network regression model

  • Input shapes and output shapes of a regression model

    • X: features/data (inputs)

    • y: labels (outputs)

  • Creating custom data to view and fit

  • Steps in modelling with TensorFlow

    • Creating a model

    • Compiling a model

      • Defining a loss function

      • Setting up an optimizer

      • Creating evaluation metrics

    • Fitting a model (getting it to find patterns in our data)

  • Evaluating a regression model

    • Visualizing the model ("visualize, visualize, visualize")

    • Looking at training curves

    • Compare predictions to ground truth (using regression evaluation metrics)

      • MAE — mean average error

      • MSE — mean square error

  • Saving a model (so we can use it later)

  • Loading a model

Key Takeaways:

  • Build TensorFlow sequential models with multiple layers

  • Prepare data for use with a machine learning model

  • Learn the different components which make up a deep learning model (loss function, architecture, optimization function)

  • Learn how to diagnose a regression problem (predicting a number) and build a neural network for it

2 — Neural Network Classification with TensorFlow

  • The architecture of a neural network classification model

  • Input shapes and output shapes of a classification model

    • X: features/data (inputs)

    • y: labels (outputs)

      • "What class do the inputs belong to?"

  • Creating custom data to view and fit

  • Steps in modelling for binary and multi-class classification

    • Creating a model

    • Compiling a model

      • Defining a loss function

      • Setting up an optimizer

        • Finding the best learning rate (a value that decides how fast a model learns)

      • Creating evaluation metrics

    • Fitting a model (getting it to find patterns in our data)

    • Improving a model

  • The power of non-linearity

  • Understand different classification evaluation methods

    • Visualizing the model ("visualize, visualize, visualize")

    • Looking at training curves

    • Compare predictions to ground truth (using classification evaluation metrics)

      • Precision

      • Accuracy

      • Recall

      • F1-score

Key takeaways:

  • Learn how to diagnose a classification problem (predicting whether something is one thing or another)

  • Build, compile & train machine learning classification models using TensorFlow

  • Build and train models for binary and multi-class classification

  • Plot modelling performance metrics against each other

  • Match input (training data shape) and output shapes (prediction data target)

3 — Computer Vision and Convolutional Neural Networks with TensorFlow

  • Getting an image dataset to work with (computer vision models need images of some kind)

  • Architecture of a convolutional neural network (CNN)

  • A quick end-to-end example (what we're working towards)

  • Steps in modelling for binary image classification with CNNs

    • Becoming one with the data (inspecting and understanding your data)

    • Preparing data for modelling (using ImageDataGenerator)

    • Creating a CNN model (starting with a baseline)

    • Fitting a model (getting it to find patterns in our data)

    • Evaluating a model

    • Improving a model

    • Making a prediction with a trained model

  • Steps in modelling for multi-class image classification with CNNs

    • Same as above (but this time with a different dataset)

Key takeaways:

  • Build convolutional neural networks with Conv2D and pooling layers

  • Learn how to diagnose different kinds of computer vision problems

  • Learn how to build computer vision neural networks

  • Learn how to use real-world images with your computer vision models

4 — Transfer Learning with TensorFlow Part 1: Feature Extraction

  • Introduce transfer learning (leveraging what one model has learned somewhere else and how to adjust it to our own problem, a way to beat all of our old self-built models)

  • Using a smaller dataset to experiment faster (10% of training samples of 10 classes of food)

  • Build a transfer learning feature extraction model using TensorFlow Hub

  • Introduce the TensorBoard callback to track model training results

  • Compare model results using TensorBoard

Key takeaways:

  • Learn how to use pre-trained models to extract features from your own data

  • Learn how to use TensorFlow Hub for pre-trained models

  • Learn how to use TensorBoard to compare the performance of several different models

5 — Transfer Learning with TensorFlow Part 2: Fine-tuning

  • Introduce fine-tuning, a type of transfer learning to modify a pre-trained model to be more suited to your data

  • Using the Keras Functional API (a different way to build models in Keras)

  • Using a smaller dataset to experiment faster (10% of training samples of 10 classes of food)

  • Data augmentation (how to make your training dataset more diverse without adding more data)

  • Running a series of modelling experiments on our Food Vision data

    • Model 0: a transfer learning model using the Keras Functional API

    • Model 1: a feature extraction transfer learning model on 1% of the data with data augmentation

    • Model 2: a feature extraction transfer learning model on 10% of the data with data augmentation

    • Model 3: a fine-tuned transfer learning model on 10% of the data

    • Model 4: a fine-tuned transfer learning model on 100% of the data

  • Introduce the ModelCheckpoint callback to save intermediate training results

  • Compare model experiments results using TensorBoard

Key takeaways:

  • Learn how to set up and run several machine learning experiments

  • Learn how to use data augmentation to increase the diversity of your training data

  • Learn how to fine-tune a pre-trained model to your own custom problem

  • Learn how to use Callbacks to add functionality to your model during training

6 — Transfer Learning with TensorFlow Part 3: Scaling Up (Food Vision mini)

  • Downloading and preparing 10% of the Food101 data (10% of training data)

  • Training a feature extraction transfer learning model on 10% of the Food101 training data

  • Fine-tuning our feature extraction model

  • Saving and loading a trained model

  • Evaluating the performance of our Food Vision mini model trained on 10% of the training data

  • Making predictions with our Food Vision mini model on custom images of food

    • Finding the most wrong predictions

Key takeaways:

  • Learn how to scale up an existing model

  • Learn how to evaluate your machine learning models by finding the most wrong predictions

  • Beat the original Food101 paper using only 10% of the data

7 — Milestone Project 1: Food Vision 🍔👁

  • Combine everything you've learned in the previous 6 notebooks to build Food Vision: a computer vision model able to classify images of 101 different kinds of foods

8 — NLP Fundamentals in TensorFlow

  • Learn to diagnose a natural language processing problem

Key takeaways:

  • Learn to:

    • Preprocess natural language text to be used with a neural network

    • Create word embeddings (numerical representations of text) with TensorFlow

    • Build neural networks capable of binary and multi-class classification using:

      • RNNs (recurrent neural networks)

      • LSTMs (long short-term memory cells)

      • GRUs (gated recurrent units)

      • CNNs

  • Learn how to evaluate your NLP models

9 — Milestone Project 2: SkimLit 📄🔥

  • Replicate the model which powers the PubMed 200k paper to classify different sequences in PubMed medical abstracts (which can help researchers read through medical abstracts faster)

10 — Time Series fundamentals in TensorFlow & Milestone Project 3: BitPredict (coming soon)

  • Learn how to diagnose a time series problem (building a model to make predictions based on data across time, e.g. predicting the stock price of AAPL tomorrow)

  • Prepare data for time series neural networks (features and labels)

  • Understanding and using different time series evaluation methods

  • Build time series forecasting models with TensorFlow

Preparing for the certification

As I said before, the certification is optional. And after going through the above sections, you’ll well and truly have the skills to prepare and take on the TensorFlow Developer Certification yourself.

This section will consist of pointing you to various resources to further prepare yourself.

Namely, the TensorFlow Developer Certification Handbook. You should read this and go through each requirement guideline and see if you can replicate it with TensorFlow code (if you can’t, you’ll now have the skills to figure out how).

Get ready to dream in tensors

There’s a celebratory deal going on the Udemy version of the course for the next day or so.

Use the code TF2021LAUNCH to get it (the link above should have it already applied), the code will also work on my beginner-friendly Machine Learning and Data Science course.

Otherwise, you can sign up on the Zero to Mastery Academy and get access to both (as well as all other ZTM courses).

If you have any more questions, I did a live Q&A on YouTube discussing the launch:

Otherwise, leave a note on the GitHub discussions page, that way others can see it too.

Big dogs gotta eat,

Daniel