or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.mdneural-networks.md
tile.json

tessl/maven-org-deeplearning4j--deeplearning4j-parent

DeepLearning4j is a comprehensive deep learning library for the JVM that provides neural network implementations, data processing capabilities, and distributed computing integrations.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.deeplearning4j/deeplearning4j-parent@0.9.x

To install, run

npx @tessl/cli install tessl/maven-org-deeplearning4j--deeplearning4j-parent@0.9.0

index.mddocs/

DeepLearning4j

DeepLearning4j is a comprehensive, Apache 2.0-licensed deep learning library for the JVM that provides neural network implementations, data processing capabilities, and distributed computing integrations. It supports both CPU and GPU execution, integrates with Hadoop and Spark, and offers a complete ecosystem for enterprise-grade deep learning applications.

Package Information

  • Package Name: deeplearning4j-parent
  • Package Type: maven
  • Language: Java
  • Installation: Add dependency to your pom.xml:
<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>deeplearning4j-core</artifactId>
    <version>0.9.1</version>
</dependency>

<!-- Backend - choose one based on your hardware -->
<!-- CPU Backend -->
<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-native</artifactId>
    <version>0.9.1</version>
</dependency>

<!-- GPU Backend (requires CUDA 8.0) -->
<dependency>
    <groupId>org.nd4j</groupId>
    <artifactId>nd4j-cuda-8.0</artifactId>
    <version>0.9.1</version>
</dependency>

<!-- For Spark integration -->
<dependency>
    <groupId>org.deeplearning4j</groupId>
    <artifactId>dl4j-spark_2.11</artifactId>
    <version>0.9.1</version>
</dependency>

System Requirements:

  • Java 7+ (Java 8+ recommended)
  • Maven 3.0+ for building
  • For GPU: CUDA-compatible GPU with compute capability 3.0+ (Kepler or newer)
  • For GPU: CUDA 8.0 toolkit installed

Core Imports

// Core network classes
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.graph.ComputationGraph;

// Configuration
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.ComputationGraphConfiguration;

// Common layers
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.conf.layers.ConvolutionLayer;
import org.deeplearning4j.nn.conf.layers.LSTM;

// Utilities and evaluation
import org.deeplearning4j.util.ModelSerializer;
import org.deeplearning4j.eval.Evaluation;

// Data handling (ND4J)
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.api.ndarray.INDArray;

// Loss functions and optimization (ND4J)
import org.nd4j.linalg.lossfunctions.LossFunctions;
import org.deeplearning4j.optimize.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.Updater;

Basic Usage

import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.optimize.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.Updater;
import org.nd4j.linalg.lossfunctions.LossFunctions;

// Create a simple feedforward neural network
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
    .seed(123)
    .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
    .updater(Updater.NESTEROVS)
    .list()
    .layer(0, new DenseLayer.Builder()
        .nIn(784)
        .nOut(100)
        .activation("relu")
        .build())
    .layer(1, new OutputLayer.Builder()
        .nIn(100)
        .nOut(10)
        .activation("softmax")
        .lossFunction(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
        .build())
    .pretrain(false)
    .backprop(true)
    .build();

MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();

// Train the model
model.fit(trainingData);

// Evaluate the model
Evaluation eval = model.evaluate(testData);
System.out.println(eval.stats());

Architecture

DeepLearning4j is built around several key components:

  • Core Network Types: MultiLayerNetwork for sequential architectures and ComputationGraph for complex graph-based networks
  • Configuration System: Builder pattern for network configuration with NeuralNetConfiguration and layer-specific builders
  • Layer Types: Comprehensive layer implementations including dense, convolutional, recurrent, and normalization layers
  • Data Handling: Integration with ND4J for n-dimensional arrays and DataVec for data preprocessing
  • Backend Abstraction: Support for both CPU (nd4j-native) and GPU (nd4j-cuda) execution via ND4J
  • Distribution Support: Native integration with Apache Spark and Hadoop for distributed training
  • Model Management: Serialization, import/export, and model zoo for pre-trained networks

Capabilities

Neural Networks

Core neural network construction with support for both sequential (MultiLayerNetwork) and graph-based (ComputationGraph) architectures.

// Sequential networks
public class MultiLayerNetwork implements Serializable, Classifier, Layer, NeuralNetwork {
    public MultiLayerNetwork(MultiLayerConfiguration conf);
    public void fit(DataSetIterator iterator);
    public INDArray output(INDArray input);
    public Evaluation evaluate(DataSetIterator iterator);
}

// Graph networks  
public class ComputationGraph implements Serializable, Model, NeuralNetwork {
    public ComputationGraph(ComputationGraphConfiguration configuration);
    public void fit(MultiDataSetIterator iterator);
    public INDArray[] outputSingle(INDArray... input);
    public Evaluation evaluate(DataSetIterator iterator);
}

Neural Networks

Network Configuration

Comprehensive configuration system using builder patterns for network architecture definition.

public class NeuralNetConfiguration {
    public static class Builder {
        public Builder seed(long seed);
        public Builder optimizationAlgo(OptimizationAlgorithm optimizationAlgo);
        public Builder updater(Updater updater);
        public Builder learningRate(double learningRate);
        public MultiLayerConfiguration.Builder list();
    }
}

public class MultiLayerConfiguration {
    public static class Builder {
        public Builder layer(int layerIndex, Layer layer);
        public Builder pretrain(boolean pretrain);
        public Builder backprop(boolean backprop);
        public MultiLayerConfiguration build();
    }
}

Configuration

Layer Types

Comprehensive collection of layer implementations for various neural network architectures.

// Dense layers
public class DenseLayer extends FeedForwardLayer {
    public static class Builder extends FeedForwardLayer.Builder<Builder> {
        public Builder nIn(int nIn);
        public Builder nOut(int nOut);
        public Builder activation(String activation);
    }
}

// Convolutional layers
public class ConvolutionLayer extends SameDiffLayer {
    public static class Builder {
        public Builder kernelSize(int... kernelSize);
        public Builder stride(int... stride);
        public Builder padding(int... padding);
        public Builder nIn(int nIn);
        public Builder nOut(int nOut);
    }
}

// Recurrent layers
public class LSTM extends BaseRecurrentLayer {
    public static class Builder extends BaseRecurrentLayer.Builder<Builder> {
        public Builder forgetGateBiasInit(double forgetGateBiasInit);
        public Builder gateActivationFunction(String gateActivationFunction);
    }
}

Layers

Model Management

Model serialization, loading, and persistence utilities for production deployment.

public class ModelSerializer {
    public static void writeModel(Model model, String path, boolean saveUpdater) throws IOException;
    public static void writeModel(Model model, File file, boolean saveUpdater) throws IOException;
    public static MultiLayerNetwork restoreMultiLayerNetwork(String path) throws IOException;
    public static MultiLayerNetwork restoreMultiLayerNetwork(File file) throws IOException;
    public static ComputationGraph restoreComputationGraph(String path) throws IOException;
    public static ComputationGraph restoreComputationGraph(File file) throws IOException;
}

Model Management

Evaluation and Metrics

Comprehensive evaluation metrics and performance measurement tools.

public class Evaluation implements IEvaluation<Evaluation> {
    public Evaluation(int numClasses);
    public void eval(INDArray labels, INDArray predictions);
    public double accuracy();
    public double precision();
    public double recall();
    public double f1();
    public String stats();
    public String confusionToString();
}

public class RegressionEvaluation implements IEvaluation<RegressionEvaluation> {
    public RegressionEvaluation(int numColumns);
    public void eval(INDArray labels, INDArray predictions);
    public double meanSquaredError(int column);
    public double meanAbsoluteError(int column);
    public double correlationR2(int column);
}

Evaluation

Data Handling

Data loading, preprocessing, and batch management for training and inference.

// Core data structures
public interface DataSetIterator extends Iterator<DataSet> {
    boolean hasNext();
    DataSet next();
    DataSet next(int num);
    int totalExamples();
    int inputColumns();
    int totalOutcomes();
    void reset();
    int batch();
}

// Built-in dataset loaders
public class MnistDataSetIterator implements DataSetIterator {
    public MnistDataSetIterator(int batchSize, boolean train, int seed) throws IOException;
}

public class CifarDataSetIterator implements DataSetIterator {
    public CifarDataSetIterator(int batchSize, boolean train) throws IOException;
}

Data Handling

Distributed Computing

Native integration with Apache Spark and Hadoop for distributed training and inference.

public class SparkDl4jMultiLayer {
    public SparkDl4jMultiLayer(JavaSparkContext sc, MultiLayerConfiguration conf, TrainingMaster tm);
    public MultiLayerNetwork fit(JavaRDD<DataSet> trainingData);
    public JavaRDD<INDArray> predict(JavaRDD<INDArray> data);
    public Evaluation evaluate(JavaRDD<DataSet> data);
}

public class SparkComputationGraph {
    public SparkComputationGraph(JavaSparkContext sc, ComputationGraphConfiguration conf, TrainingMaster tm);
    public ComputationGraph fit(JavaRDD<MultiDataSet> trainingData);
    public JavaRDD<INDArray[]> predict(JavaRDD<INDArray[]> data);
}

Distributed Computing

Types

// Core interfaces
public interface NeuralNetwork {
    INDArray output(INDArray input);
    void fit(DataSetIterator iterator);
    Evaluation evaluate(DataSetIterator iterator);
}

public interface Model extends Serializable {
    void fit(DataSetIterator iterator);
    INDArray output(INDArray input);
    void save(File file) throws IOException;
}

// Network types
public interface Layer extends Serializable, Cloneable {
    INDArray activate(INDArray input, boolean training, LayerWorkspaceMgr workspaceMgr);
    long numParams();
    void setParams(INDArray params);
    INDArray getParams();
}

// Optimization
public enum OptimizationAlgorithm {
    STOCHASTIC_GRADIENT_DESCENT,
    CONJUGATE_GRADIENT,
    LBFGS,
    LINE_GRADIENT_DESCENT
}