Book Image

Java Deep Learning Cookbook

By : Rahul Raj
Book Image

Java Deep Learning Cookbook

By: Rahul Raj

Overview of this book

Java is one of the most widely used programming languages in the world. With this book, you will see how to perform deep learning using Deeplearning4j (DL4J) – the most popular Java library for training neural networks efficiently. This book starts by showing you how to install and configure Java and DL4J on your system. You will then gain insights into deep learning basics and use your knowledge to create a deep neural network for binary classification from scratch. As you progress, you will discover how to build a convolutional neural network (CNN) in DL4J, and understand how to construct numeric vectors from text. This deep learning book will also guide you through performing anomaly detection on unsupervised data and help you set up neural networks in distributed systems effectively. In addition to this, you will learn how to import models from Keras and change the configuration in a pre-trained DL4J model. Finally, you will explore benchmarking in DL4J and optimize neural networks for optimal results. By the end of this book, you will have a clear understanding of how you can use DL4J to build robust deep learning applications in Java.

Related Content you might be interested in

Current Title:

Small book image
Java Deep Learning Cookbook
Rahul Raj
Nov, 2019 | 304 pages
Small book image
Hands-On Deep Learning with Apache Spark
Guglielmo Iozzia
Jan, 2019 | 322 pages
Small book image
Java Deep Learning Projects
Md Rezaul Karim
Jun, 2018 | 436 pages
Small book image
Deep Learning with Hadoop
Dipayan Dev
Feb, 2017 | 206 pages
Table of Contents (14 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Sections
Get in touch
Free Chapter
1
Introduction to Deep Learning in Java
Introduction to Deep Learning in Java
Technical requirements
Deep learning intuition
Determining the right network type to solve deep learning problems
Determining the right activation function
Combating overfitting problems
Determining the right batch size and learning rates
Configuring Maven for DL4J
Configuring DL4J for a GPU-accelerated environment
Troubleshooting installation issues
2
Data Extraction, Transformation, and Loading
Data Extraction, Transformation, and Loading
Technical requirements
Reading and iterating through data
Performing schema transformations
Building a transformation process
Serializing transforms
Executing a transform process
Normalizing data for network efficiency
3
Building Deep Neural Networks for Binary Classification
Building Deep Neural Networks for Binary Classification
Technical requirements
Extracting data from CSV input
Removing anomalies from the data
Applying transformations to the data
Designing input layers for the neural network model
Designing hidden layers for the neural network model
Designing output layers for the neural network model
Training and evaluating the neural network model for CSV data
Deploying the neural network model and using it as an API
4
Building Convolutional Neural Networks
Building Convolutional Neural Networks
Technical requirements
Extracting images from disk
Creating image variations for training data
Image preprocessing and the design of input layers
Constructing hidden layers for a CNN
Constructing output layers for output classification
Training images and evaluating CNN output
Creating an API endpoint for the image classifier
5
Implementing Natural Language Processing
Implementing Natural Language Processing
Technical requirements
Reading and loading text data
Tokenizing data and training the model
Evaluating the model
Generating plots from the model
Saving and reloading the model
Importing Google News vectors
Troubleshooting and tuning Word2Vec models
Using Word2Vec for sentence classification using CNNs
Using Doc2Vec for document classification
6
Constructing an LSTM Network for Time Series
Constructing an LSTM Network for Time Series
Technical requirements
Extracting and reading clinical data
Loading and transforming data
Constructing input layers for the network
Constructing output layers for the network
Training time series data
Evaluating the LSTM network's efficiency
7
Constructing an LSTM Neural Network for Sequence Classification
Constructing an LSTM Neural Network for Sequence Classification
Technical requirements
Extracting time series data
Loading training data
Normalizing training data
Constructing input layers for the network
Constructing output layers for the network
Evaluating the LSTM network for classified output
8
Performing Anomaly Detection on Unsupervised Data
Performing Anomaly Detection on Unsupervised Data
Technical requirements
Extracting and preparing MNIST data
Constructing dense layers for input
Constructing output layers
Training with MNIST images
Evaluating and sorting the results based on the anomaly score
Saving the resultant model
9
Using RL4J for Reinforcement Learning
Using RL4J for Reinforcement Learning
Technical requirements
Setting up the Malmo environment and respective dependencies
Setting up the data requirements
Configuring and training a DQN agent
Evaluating a Malmo agent
10
Developing Applications in a Distributed Environment
Developing Applications in a Distributed Environment
Technical requirements
Setting up DL4J and the required dependencies
Creating an uber-JAR for training
CPU/GPU-specific configuration for training
Memory settings and garbage collection for Spark
Configuring encoding thresholds
Performing a distributed test set evaluation
Saving and loading trained neural network models
Performing distributed inference
11
Applying Transfer Learning to Network Models
Applying Transfer Learning to Network Models
Technical requirements
Modifying an existing customer retention model
Fine-tuning the learning configurations
Implementing frozen layers
Importing and loading Keras models and layers
12
Benchmarking and Neural Network Optimization
Benchmarking and Neural Network Optimization
Technical requirements
DL4J/ND4J-specific configuration
Setting up heap spaces and garbage collection
Using asynchronous ETL
Using arbiter to monitor neural network behavior
Performing hyperparameter tuning
13
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Configuring Maven for DL4J

We need to add DL4J/ND4J Maven dependencies to leverage DL4J capabilities. ND4J is a scientific computation library dedicated to DL4J. It is necessary to mention the ND4J backend dependency in your pom.xml file. In this recipe, we will add a CPU-specific Maven configuration in pom.xml.

Getting ready

Let's discuss the required Maven dependencies. We assume you have already done the following:

  • JDK 1.7, or higher, is installed and the PATH variable is set.
  • Maven is installed and the PATH variable is set.
A 64-bit JVM is required to run DL4J.

Set the PATH variable for JDK and Maven:

  • On Linux: Use the export command to add Maven and JDK to the PATH variable:
export PATH=/opt/apache-maven-3.x.x/bin:$PATH
export PATH=${PATH}:/usr/java/jdk1.x.x/bin

Replace the version number as per the installation.

  • On Windows: Set System Environment variables from system Properties:
set PATH="C:/Program Files/Apache Software Foundation/apache-maven-3.x.x/bin:%PATH%"
 set PATH="C:/Program Files/Java/jdk1.x.x/bin:%PATH%"

Replace the JDK version number as per the installation.

How to do it...

  1. Add the DL4J core dependency:
<dependency>
 <groupId>org.deeplearning4j</groupId>
 <artifactId>deeplearning4j-core</artifactId>
 <version>1.0.0-beta3</version>
 </dependency>
  1. Add the ND4J native dependency:
<dependency>
 <groupId>org.nd4j</groupId>
 <artifactId>nd4j-native-platform</artifactId>
 <version>1.0.0-beta3</version>
 </dependency>
  1. Add the DataVec dependency to perform ETL (short for Extract, Transform and Load) operations:
<dependency>
 <groupId>org.datavec</groupId>
 <artifactId>datavec-api</artifactId>
 <version>1.0.0-beta3</version>
 </dependency>
  1. Enable logging for debugging:
<dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-simple</artifactId>
 <version>1.7.25</version> //change to latest version
 </dependency>
Note that 1.0.0-beta 3 is the current DL4J release version at the time of writing this book, and is the official version used in this cookbook. Also, note that DL4J relies on an ND4J backend for hardware-specific implementations.

How it works...

After adding DL4J core dependency and ND4J dependencies, as mentioned in step 1 and step 2, we are able to create neural networks. In step 2, the ND4J maven configuration is mentioned as a necessary backend dependency for Deeplearnign4j. ND4J is the scientific computation library for Deeplearning4j.


ND4J is a scientific computing library written for Java, just like NumPy is for Python.

Step 3 is very crucial for the ETL process: that is, data extraction, transformation, and loading. So, we definitely need this as well in order to train the neural network using data.

Step 4 is optional but recommended, since logging will reducee the effort involved in debugging.

Previous Section
End of Section 8
Next Section