JSR 381 and Deep Netts

JSR 381, also known as the Visual Recognition or VisRec specification, defines a standard Java API for building Machine Learning and visual-recognition applications. Deep Netts provides the concrete neural-network functionality used to load data, train models, evaluate them, and make predictions.

The useful distinction is the same one Java developers encounter in APIs such as JDBC: an application can program against shared contracts, while a provider supplies working classes behind those contracts.

At a glance

Specification, implementation, and engine

These layers have different responsibilities:

Java application
      |
      v
JSR 381 / javax.visrec contracts
      |
      v
VisRec implementation or adapter
      |
      v
Deep Netts neural-network engine

• JSR 381 API defines portable interfaces and shared types. It describes what a dataset, classifier, regressor, image classifier, evaluator, or provider must expose.
• VisRec implementation connects those contracts to working Machine Learning functionality. The JSR ships with a separate Reference Implementation and a Technology Compatibility Kit.
• Deep Netts supplies concrete data structures, neural networks, trainers, preprocessing, evaluation, persistence, and inference used throughout this cookbook.

JSR 381 reached Final Release in February 2022. The official JCP page links the specification, Reference Implementation, and TCK: JSR 381 Final Release.

Important interfaces

The API contains small contracts that describe common Machine Learning operations:

import javax.visrec.ml.classification.Classifier;
import javax.visrec.ml.classification.ImageClassifier;
import javax.visrec.ml.data.DataSet;
import javax.visrec.ml.regression.Regressor;

Classifier<Input, Result> classifier;
ImageClassifier<Image> imageClassifier;
Regressor<Input, Number> regressor;
DataSet<Sample> dataSet;

Conceptually:

• DataSet<E> represents an iterable collection of samples and defines operations such as size, shuffle, and split.
• Classifier<T, R> converts an input into a classification result through classify.
• Regressor<I, R> predicts a numeric result through predict.
• ImageClassifier<T> specializes classification for image inputs.
• ServiceProvider and the SPI factory types allow an implementation to expose services to applications.

The complete list of API types is available in the VisRec API Javadoc.

Where Deep Netts fits

Deep Netts 4 exposes its own concrete model API while interoperating with standard VisRec types where they are useful. For example, the cookbook loads a Deep Netts TabularDataSet, then stores the training and test partitions through the JSR 381 DataSet interface:

import deepnetts.data.MLDataItem;
import deepnetts.data.TabularDataSet;
import deepnetts.data.TrainTestSplit;
import javax.visrec.ml.data.DataSet;

TabularDataSet<MLDataItem> dataSet = loadDataSet();
TrainTestSplit split = dataSet.trainTestSplit(0.8);

DataSet<MLDataItem> trainingSet = split.getTrainingSet();
DataSet<MLDataItem> testSet = split.getTestSet();

TabularDataSet extends the VisRec BasicDataSet implementation, so the Deep Netts dataset can be used through the standard DataSet contract. A Deep Netts network then accepts that dataset directly:

FeedForwardNetwork neuralNet = FeedForwardNetwork.builder()
        .addInputLayer(numInputs)
        .addFullyConnectedLayer(16, ActivationType.RELU)
        .addOutputLayer(numOutputs, ActivationType.SIGMOID)
        .build();

neuralNet.train(trainingSet);
EvaluationMetrics metrics = neuralNet.test(testSet);

This is the practical relationship used in the current examples: standard types provide familiar Java contracts, while Deep Netts provides the actual model construction and execution.

Why this matters

• Java developers get recognizable interfaces instead of an engine-specific abstraction for every operation.
• Libraries can implement the same contracts over different Machine Learning engines.
• Applications can separate portable data and prediction concepts from provider-specific configuration.
• Deep Netts users can combine standard VisRec data and evaluation types with Deep Netts-specific neural-network features.

Continue with Loading Data to see these types in a working Deep Netts workflow, or review the public JSR 381 API repository and Reference Implementation.