Python Deep Learning Cookbook

Python Deep Learning Cookbook

By : Indra den Bakker

Buy this Book

Python Deep Learning Cookbook

By: Indra den Bakker

Buy this Book

Overview of this book

Deep Learning is revolutionizing a wide range of industries. For many applications, deep learning has proven to outperform humans by making faster and more accurate predictions. This book provides a top-down and bottom-up approach to demonstrate deep learning solutions to real-world problems in different areas. These applications include Computer Vision, Natural Language Processing, Time Series, and Robotics. The Python Deep Learning Cookbook presents technical solutions to the issues presented, along with a detailed explanation of the solutions. Furthermore, a discussion on corresponding pros and cons of implementing the proposed solution using one of the popular frameworks like TensorFlow, PyTorch, Keras and CNTK is provided. The book includes recipes that are related to the basic concepts of neural networks. All techniques s, as well as classical networks topologies. The main purpose of this book is to provide Python programmers a detailed list of recipes to apply deep learning to common and not-so-common scenarios.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Programming Environments, GPU Computing, Cloud Solutions, and Deep Learning Frameworks

Introduction

Setting up a deep learning environment

Launching an instance on Amazon Web Services (AWS)

Launching an instance on Google Cloud Platform (GCP)

Installing CUDA and cuDNN

Installing Anaconda and libraries

Connecting with Jupyter Notebooks on a server

Building state-of-the-art, production-ready models with TensorFlow

Intuitively building networks with Keras

Using PyTorch’s dynamic computation graphs for RNNs

Implementing high-performance models with CNTK

Building efficient models with MXNet

Defining networks using simple and efficient code with Gluon

Feed-Forward Neural Networks

Introduction

Understanding the perceptron

Implementing a single-layer neural network

Building a multi-layer neural network

Getting started with activation functions

Experiment with hidden layers and hidden units

Implementing an autoencoder

Tuning the loss function

Experimenting with different optimizers

Improving generalization with regularization

Adding dropout to prevent overfitting

Convolutional Neural Networks

Introduction

Applying pooling layers

Optimizing with batch normalization

Understanding padding and strides

Experimenting with different types of initialization

Implementing a convolutional autoencoder

Applying a 1D CNN to text

Recurrent Neural Networks

Introduction

Implementing a simple RNN

Adding Long Short-Term Memory (LSTM)

Using gated recurrent units (GRUs)

Implementing bidirectional RNNs

Character-level text generation

Reinforcement Learning

Introduction

Implementing policy gradients

Implementing a deep Q-learning algorithm

Generative Adversarial Networks

Introduction

Understanding GANs

Implementing Deep Convolutional GANs (DCGANs)

Upscaling the resolution of images with Super-Resolution GANs (SRGANs)

Computer Vision

Introduction

Augmenting images with computer vision techniques

Classifying objects in images

Localizing an object in images

Segmenting classes in images with U-net

Scene understanding (semantic segmentation)

Finding facial key points

Recognizing faces

Transferring styles to images

Natural Language Processing

Introduction

Analyzing sentiment

Translating sentences

Summarizing text

Speech Recognition and Video Analysis

Introduction

Implementing a speech recognition pipeline from scratch

Identifying speakers with voice recognition

Understanding videos with deep learning

Time Series and Structured Data

Introduction

Predicting stock prices with neural networks

Predicting bike sharing demand

Using a shallow neural network for binary classification

Game Playing Agents and Robotics

Introduction

Learning to drive a car with end-to-end learning

Learning to play games with deep reinforcement learning

Genetic Algorithm (GA) to optimize hyperparameters

Hyperparameter Selection, Tuning, and Neural Network Learning

Introduction

Visualizing training with TensorBoard and Keras

Working with batches and mini-batches

Using grid search for parameter tuning

Learning rates and learning rate schedulers

Comparing optimizers

Determining the depth of the network

Adding dropouts to prevent overfitting

Making a model more robust with data augmentation

Network Internals

Introduction

Visualizing training with TensorBoard

Analyzing network weights and more

Freezing layers

Storing the network topology and trained weights

Pretrained Models

Introduction

Large-scale visual recognition with GoogLeNet/Inception

Extracting bottleneck features with ResNet

Leveraging pretrained VGG models for new classes

Fine-tuning with Xception

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Defining networks using simple and efficient code with Gluon

The newest addition to the range of deep learning frameworks is Gluon. Gluon is recently launched by AWS and Microsoft to provide an API simple, easy-to-understand code without the loss of performance. Gluon is already included in the latest release of MXNet and will be available in future releases of CNTK (and other frameworks). Just like Keras, Gluon is a wrapper around other deep learning frameworks. The main difference between Keras and Gluon, is that Gluon will (at first) focus on imperative frameworks.

How to do it...

At the moment, gluon is included in the latest release of MXNet (follow the steps in Building efficient models with MXNet to install MXNet).
After installing, we can directly import gluon as follows:

from mxnet import gluon

Next, we create some dummy data. For this we need the data to be in MXNet's NDArray or Symbol:

import mxnet as mx
import numpy as np
x_input = mx.nd.empty((1, 5), mx.gpu())
x_input[:] = np.array([[1,2,3,4,5]], np.float32)

y_input = mx.nd.empty((1, 5), mx.gpu())
y_input[:] = np.array([[10, 15, 20, 22.5, 25]], np.float32)

With Gluon, it's really straightforward to build a neural network by stacking layers:

net = gluon.nn.Sequential()
with net.name_scope():
    net.add(gluon.nn.Dense(16, activation="relu"))
    net.add(gluon.nn.Dense(len(y_input)))

Next, we initialize the parameters and we store these on our GPU as follows:

net.collect_params().initialize(mx.init.Normal(), ctx=mx.gpu())

With the following code we set the loss function and the optimizer:

softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': .1})

We're ready to start training or model:

n_epochs = 10

for e in range(n_epochs):
    for i in range(len(x_input)):
        input = x_input[i]
        target = y_input[i]
        with mx.autograd.record():
            output = net(input)
            loss = softmax_cross_entropy(output, target)
            loss.backward()
        trainer.step(input.shape[0])

Note

We've shortly demonstrated how to implement a neural network architecture with Gluon. Gluon is a powerful extension that can be used to implement deep learning architectures with clean code. At the same time, there is almost no performance loss when using Gluon.

Python Deep Learning Cookbook

By : Indra den Bakker

Python Deep Learning Cookbook

By: Indra den Bakker

Overview of this book

Related Content you might be interested in

Current Title:

Python Deep Learning Cookbook

Deep Learning with Keras

Neural Networks with Keras Cookbook

Hands-On Neural Networks

Defining networks using simple and efficient code with Gluon

How to do it...

Note