Getting Started with Deep Java Library (DJL): Architecture & Basics

1. Introduction

Artificial Intelligence has traditionally been dominated by Python libraries such as TensorFlow and PyTorch. But Java developers also need a powerful, production-ready way to build, run, and deploy deep learning solutions without switching ecosystems. Deep Java Library (DJL) solves this.

DJL is an open-source, high-level deep learning framework developed by Amazon, designed to help Java developers work with deep learning models without the complexity of other ML ecosystems. It supports training, inference, pre-trained models, multiple engines, and seamless integration into backend, microservices, and enterprise applications.

2. What is Deep Java Library?

DJL is a Java-native deep learning framework providing:

• Simple API for training and inference
• Pre-built model zoo
• Support for multiple DL engines
• Easy integration with Java applications
• Production-ready tools for serving ML

Why Deep Java Library?

• No need to learn Python
• No need to manage low-level ML operations
• Enterprise-ready + scalable
• JVM-friendly and optimized for high performance

3. Key Highlights of DJL

3.1 Multi-Engine Support

DJL supports multiple deep learning engines:

• PyTorch
• TensorFlow
• ONNX Runtime
• Apache MXNet
• PaddlePaddle
• XGBoost
• TensorRT

DJL abstracts engine differences, so you can easily switch engines without rewriting code.

3.2 Wide Model Zoo Support

DJL provides over 300+ pre-trained models for:

• NLP (BERT, GPT, DistilBERT)
• Computer Vision (ResNet, YOLO, FasterRCNN)
• Recommendation Systems
• OCR & Speech Models
• Embedding-based semantic search

A Java developer can load a pre-trained YOLOv5 model and detect objects in images using just a few lines of code.

3.3 Java Friendly API

Everything is intuitive for Java developers:

• Uses familiar OOP patterns
• Builder patterns for model loading
• No complex tensor manipulations
• Works with Maven/Gradle easily

3.4 Basic Setup

Project Setup:

To run our first deep learning model in Java, we only need to add three DJL dependencies: API, PyTorch Engine, and Model Zoo.
DJL automatically downloads the required model when we run the program.

<dependencies>
    <!-- DJL Core API -->
    <dependency>
        <groupId>ai.djl</groupId>
        <artifactId>api</artifactId>
        <version>0.35.0</version>
    </dependency>

    <!-- PyTorch Engine -->
    <dependency>
        <groupId>ai.djl.pytorch</groupId>
        <artifactId>pytorch-engine</artifactId>
        <version>0.35.0</version>
    </dependency>

    <!-- PyTorch Model Zoo -->
    <dependency>
        <groupId>ai.djl.pytorch</groupId>
        <artifactId>pytorch-model-zoo</artifactId>
        <version>0.35.0</version>
    </dependency>

    <!-- DJL Basic Model Zoo (ResNet etc.) -->
    <dependency>
        <groupId>ai.djl</groupId>
        <artifactId>model-zoo</artifactId>
        <version>0.35.0</version>
    </dependency>
</dependencies>

Folder Structure:

We place the input image inside the resources folder, and DJL handles image loading and preprocessing automatically.

Basic Image Classification Code:

Criteria<Image, Classifications> criteria =
        Criteria.builder()
                .optApplication(Application.CV.IMAGE_CLASSIFICATION)
                .setTypes(Image.class, Classifications.class)
                .optFilter("layers", "50")
                .optEngine("PyTorch")
                .build();

In this simple Java program, DJL loads a pre-trained ResNet model and predicts the class of the input image.

Output:

Prediction: {“className”: “n02123045 tabby, tabby cat”, “probability”: 0.52}

DJL prints the class label along with its prediction probability. This output comes from the ImageNet class labels packaged with the model.

In the next section, we will understand how DJL internally manages models, engines, tensors, and memory — through its layered architecture.

4. DJL (Deep Java Library) Architecture

The DJL architecture follows a layered and modular design, ensuring that Java developers can use deep learning models without interacting directly with low-level ML components such as CUDA, tensor operations, or engine-specific code. Each layer has a dedicated responsibility and contributes to building a clean, production-ready workflow.

DJL architecture is commonly understood through these five layers:

4.1 Application Layer

This is where your Java code communicates with DJL.
Developers interact with the library through:

• Predictors (for inference)
• Training loops
• ModelZoo API
• Dataset utilities

Real-life example:
A Spring Boot REST API receives an image → uses predictor.predict(image) → returns classification results to the frontend.

4.2 Model Zoo Layer

The Model Zoo is a curated collection of pre-trained models packaged with:

• Model architecture
• Metadata
• Required preprocessing (via Translators)
• Versioning and signatures

It enables developers to load complex models with only a few lines of code.

Real-life example:
A retail analytics system loads a YOLO-based object detection model from Model Zoo to identify products on store shelves — without needing to train anything.

4.3 Engine Layer

This layer contains the actual deep-learning engines that execute the model:

• PyTorch
• TensorFlow
• ONNX Runtime
• MXNet

The engine handles:

• Tensor operations
• Automatic differentiation
• GPU acceleration
• Optimized inference paths

DJL communicates with the engine behind the scenes, abstracting away all engine-specific complexities.

Real-life example:
Your Java application loads a BERT model. DJL internally uses ONNX Runtime for CPU-based inference — you don’t need to write engine-specific code.
Switching to GPU using PyTorch requires zero code changes in your application.

4.4 NDManager Layer

NDManager manages the lifecycle of NDArray, which represents tensors in DJL.

It ensures:

• Efficient memory allocation
• Automatic cleanup (especially critical for GPU memory)
• Hierarchical NDManager creation for structured memory usage

Real-life example:
A video analytics pipeline processes hundreds of frames per second. NDManager automatically releases tensor memory after each frame is analyzed, preventing memory leaks or crashes.

4.5 Utility Layer (Dataset, Image, Text, Metrics)

This layer provides essential utilities required to prepare data for models:

• Dataset loaders
• Image preprocessing (resize, normalize, crop)
• Text processing (tokenization, vocabulary handling)
• Shuffling and batching
• Training metrics

Real-life example:
A sentiment analysis system prepares user reviews by:
→ cleaning text
→ tokenizing sentences
→ converting tokens to indices
→ feeding them into a transformer model

All these steps occur through DJL utilities.

Why This Architecture Matters?

DJL’s layered architecture ensures that:

• Java developers stay focused on application logic
• All ML complexity stays behind clean, unified APIs
• Models run efficiently regardless of engine (ONNX, PyTorch, TensorFlow)
• Switching engines does not require code changes
• Enterprises can deploy AI models within JVM-based systems easily

This architecture makes DJL one of the most production-ready AI frameworks available for Java.

5. DJL Supported Engines & Frameworks

DJL is engine-agnostic and supports:

• PyTorch
• TensorFlow
• ONNX Runtime
• Apache MXNet
• DJL’s own built-in engines

This provides:

• Better performance tuning
• Access to thousands of pre-trained models
• Freedom from vendor lock-in

For enterprise systems, engine independence is a major advantage.

6. Limitations of DJL

While DJL is powerful and production-focused, it has certain limitations:

• Training Support Is Evolving: DJL supports training, but features like dynamic graph operations, advanced optimizers, and research experimentation are more mature in Python frameworks.

• Smaller Community: DJL’s user community is significantly smaller than those of PyTorch or TensorFlow, which means fewer tutorials or third-party examples.

• Limited Access to Cutting-Edge Research Models: Many latest research papers release models first in Python. It may take time before they become available in DJL-compatible formats.

• Engine-Specific Configuration Variations: Different engines (e.g., PyTorch vs ONNX) sometimes require different configuration options, which developers must understand during deployment.
• Despite these limitations, DJL excels in enterprise scenarios, where stability, JVM integration, and production infrastructure matter more than research experimentation.

7. Conclusion

Deep Java Library is a powerful, production-ready solution for integrating machine learning into Java applications. Its engine-agnostic architecture, rich model zoo, and intuitive Java-first API make it an excellent choice for enterprises adopting AI without rebuilding their technology stack.This article established foundational concepts of DJL, including its architecture, capabilities, and supported engines.The next blogs in this series will explore:

• Loading pre-trained models
• Building inference pipelines
• Using Translators effectively
• Integrating DJL with Spring Boot and Angular
• Best practices for deploying ML features in Java applications

DJL enables Java developers to adopt AI confidently—directly within the ecosystem they already use.