Learn Keras and Deep Learning with Deep Lizard

Welcome to the Deep Lizard Keras course! This comprehensive guide will teach you how to use Keras, a powerful neural network API written in Python and integrated with TensorFlow. Each lesson focuses on a specific deep learning concept, complete with code implementations using the Keras API.

Course Overview

We'll start with the basics of organizing and preprocessing data, and then progress to building and training artificial neural networks. You'll learn to build networks from scratch and finetune pretrained, stateoftheart models using custom datasets. The course is designed to provide practical, handson experience with Keras.

Prerequisites

While we provide brief introductions to each deep learning concept, beginners are encouraged to first complete the Deep Learning Fundamentals course on Deeplizard.com. If you're eager to code, you can take both courses simultaneously. For this Keras course, you'll only need basic programming skills and some Python experience.

Check out the Deep Learning Learning Path on Deeplizard.com to see where this Keras course fits within our comprehensive deep learning content.

Course Resources

In addition to YouTube videos, you'll find video and text resources on Deeplizard.com. Each episode has a corresponding blog and quiz to test your knowledge. You can even contribute your own quiz questions! All code resources are regularly tested and maintained, with updates and bug fixes. Download access to the code files is available to members of the Deep Lizard Hive Mind.

Why Keras?

Keras was developed with a focus on **enabling fast user experimentation**, allowing you to go from idea to implementation quickly. While learning multiple neural network APIs is recommended, Keras is a great place to start.

Knowing more than one API will showcase your experience, enabling you to compare and contrast their differences. This makes you a more valuable candidate for job prospects.

Keras and TensorFlow

Keras is now **fully integrated with the TensorFlow API**. Historically, Keras was a highlevel API that could run against TensorFlow, Theano, or CNTK. Now, it's bundled directly with TensorFlow.

This course focuses on the highlevel Keras API, with limited use of the lowerlevel TensorFlow API.

Installation

Installing Keras is simple! Because it's part of TensorFlow, just run pip install tensorflow from your command line. Check TensorFlow's website for system requirements.

GPU Support

A GPU is **not required** to follow this course. Running on a CPU is perfectly fine. However, if you want to use a GPU, a setup guide is available on Deeplizard.com.

It's recommended to complete the course using a CPU first. Then, set up your GPU and rerun the code to observe the performance improvements.

Preparing and Processing Data

To train any neural network in a supervised learning task, you first need a data set of samples along with the corresponding labels for those samples. Deep learning may refer to samples as inputs or input data. Labels may be referred to as targets or target data.

The first type of neural network that we'll be working with is called a sequential model from the Keras API. The sequential model receives data during training whenever we call the fit function on it.

The fit function expects X which is our input data to be in a NumPy array, a TensorFlow tensor, a dict, mapping, a TF dot data data set or a Keras generator. The Y parameter or the target data needs to be in the same format as X.

Data normalization or standardization techniques can make the data more efficient for the model to learn from.

Building a Neural Network

A sequential model can be described as a linear stack of layers. The input layer is not explicitly defined using Keras, the input data is what creates the input layer itself. The model knows what type of input data to expect or the shape of the input data, through the input shape parameter that we pass to our first dense layer.

Training Your Model

After building your model, you will call the model.compile function, which prepares the model for training. In the compile function, you specify the optimizer you want to use, the type of loss, and the metrics you want to see.

Training occurs whenever we call the fit function. The first parameter, X is our input data. Y is our target data. Next, you specify the batch size you want to use for training and the number of epochs.

Using a Validation Set

To create a validation set, you can choose to take a subset of the training set, and then separate it into a separate set labeled as validation data. During the training process, the model will only train on the training data, and then validate on the separated validation data. By validating we mean that after the model has gone through the actual training process, it will take what it's learned from the training data, and then validate by predicting on the data in the validation set, using only what it's learned from the training data. This allows us to see how general our model is. When we have an overfitting problem, we see that the model is giving really good results for the training set, but less than good results for the validation set.

To create and use a validation set with a Keras sequential model, you can have a completely separate validation set from the training set. The second way of creating and using a validation set, is to get Keras to create it for us. By using a parameter validation_split.

Inference with Test Data

Inference is a process where the model takes what it learned during training, and then uses that knowledge to infer things about data that it hasn't seen before. Typically, after the model has been trained and validated, we take the model and use it for inference purposes against the test set. If you have corresponding labels for your test set, we can visualize the prediction results by plotting them to a confusion matrix.

Saving and Loading Models

You have a few different options when it comes to saving and loading a Keras sequential model. One option is just by calling the Save function on it. This saves the architecture of the model, allowing us to be able to recreate it with the same number of learnable parameters and layers and nodes. It also saves the weights of the model. Training configuration is also saved.

Using the function toJson, you can only save the architecture of the model. You don't want to set its weights or the training configuration. You can call save_weights function and save solely model's weights.

Image Processing & CNNs

CNN's are convolutional neural networks. We can first organize the data into train valid and test directories, which correspond to our training validation and test sets. And you have a set of directory structures that are in the same format that the Keras sequential model expects.

VGG16

VGG16 is a model that won the 2014 image net competition. Using Keras, you can import this VGG 16 model, and then fine tune it to not classify on one of the 1000 categories for which it was originally trained, but instead only on two categories, cat and dog. VGG16 used the pre processing of subtracting the mean RGB value computing on the trade computed on the training set from each pixel.

MobileNets

MobileNets are a class of small, low power, low latency models that can be used for things like classification, detection, and other things that CNNs are typically good for. These models are considered great for mobile devices. While MobileNets are faster and smaller than the competitors of these big hefty models like VGG 16, there is a catch or a trade off, and that trade off is accuracy.

Data Augmentation

Data augmentation occurs when we create new data by making modifications to some existing data. Image data data augmentation would include things like flipping the image, either horizontally or vertically. It could include rotating the image, it could include changing the color of the image, and so on. One of the major reasons we want to use data augmentation is to simply just get access to more data.