Book Image

Hands-On Deep Learning with Go

By : Gareth Seneque, Darrell Chua

Book Image

Hands-On Deep Learning with Go

By: Gareth Seneque, Darrell Chua

Overview of this book

Go is an open source programming language designed by Google for handling large-scale projects efficiently. The Go ecosystem comprises some really powerful deep learning tools such as DQN and CUDA. With this book, you'll be able to use these tools to train and deploy scalable deep learning models from scratch. This deep learning book begins by introducing you to a variety of tools and libraries available in Go. It then takes you through building neural networks, including activation functions and the learning algorithms that make neural networks tick. In addition to this, you'll learn how to build advanced architectures such as autoencoders, restricted Boltzmann machines (RBMs), convolutional neural networks (CNNs), recurrent neural networks (RNNs), and more. You'll also understand how you can scale model deployments on the AWS cloud infrastructure for training and inference. By the end of this book, you'll have mastered the art of building, training, and deploying deep learning models in Go to solve real-world problems.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Section 1: Deep Learning in Go, Neural Networks, and How to Train Them

Section 1: Deep Learning in Go, Neural Networks, and How to Train Them

Introduction to Deep Learning in Go

Introduction to Deep Learning in Go

Overview of ML in Go

What Is a Neural Network and How Do I Train One?

What Is a Neural Network and How Do I Train One?

A basic neural network

Activation functions

Gradient descent and backpropagation

Advanced gradient descent algorithms

Beyond Basic Neural Networks - Autoencoders and RBMs

Beyond Basic Neural Networks - Autoencoders and RBMs

Loading data – MNIST

Building a neural network for handwriting recognition

Building an autoencoder – generating MNIST digits

Building an RBM for Netflix-style collaborative filtering

Further reading

CUDA - GPU-Accelerated Training

CUDA - GPU-Accelerated Training

CPUs versus GPUs

Understanding Gorgonia and CUDA

Building a model in Gorgonia with CUDA support

Performance benchmarking of CPU versus GPU models for training and inference

Section 2: Implementing Deep Neural Network Architectures

Section 2: Implementing Deep Neural Network Architectures

Next Word Prediction with Recurrent Neural Networks

Next Word Prediction with Recurrent Neural Networks

RNNs and vanishing gradients

Augmenting your RNN with GRU/LSTM units

Building an LSTM in Gorgonia

Object Recognition with Convolutional Neural Networks

Object Recognition with Convolutional Neural Networks

Introduction to CNNs

Building an example CNN

Assessing the results

Further reading

Maze Solving with Deep Q-Networks

Maze Solving with Deep Q-Networks

Solving a maze using a DQN in Gorgonia

Further reading

Generative Models with Variational Autoencoders

Generative Models with Variational Autoencoders

Introduction to VAEs

Building a VAE on MNIST

Assessing the results

Further reading

Section 3: Pipeline, Deployment, and Beyond!

Section 3: Pipeline, Deployment, and Beyond!

Building a Deep Learning Pipeline

Building a Deep Learning Pipeline

Exploring Pachyderm

Integrating our CNN

Scaling Deployment

Scaling Deployment

Lost (and found) in the cloud

Building deployment templates

Running a model on a K8s cluster

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Solving a maze using a DQN in Gorgonia

Now, it's time to build our maze solver!

Using a DQN to solve a little ASCII maze is a bit like bringing a bulldozer to the beach to make sandcastles for your kids: it's completely unnecessary, but you get to play with a big machine. However, as a tool for learning about DQNs, mazes are invaluable. This is because the number of states or actions in the game is limited, and the representation of constraints is also simple (such as the walls of our maze that our agent cannot move through). This means that we can step through our program and easily inspect what our network is doing.

We will follow these steps:

Create a maze.go file for this bit of code
Import our libraries and set our data type
Define our Maze{}
Write a NewMaze() function to instantiate this struct

We also need to define our Maze{} helper functions. These include...