Java Machine Learning in 2025: Weka vs Deeplearning4j vs Smile Comparison

<dependency>
    <groupId>nz.ac.waikato.cms.weka</groupId>
    <artifactId>weka-stable</artifactId>
    <version>3.8.6</version>
</dependency>

import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;
import weka.classifiers.trees.RandomForest;
import weka.classifiers.Evaluation;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.NumericToNominal;

import java.util.Random;

public class WekaChurnExample {

    public static void main(String[] args) {
        try {
            System.out.println("Loading data with Weka...");
            // 1. Load Data
            DataSource source = new DataSource("src/main/resources/customer_churn.csv");
            Instances data = source.getDataSet();

            // 2. Set Class Index (The column we want to predict - last column)
            if (data.classIndex() == -1)
                data.setClassIndex(data.numAttributes() - 1);

            // 3. Preprocessing: Convert numeric target to nominal (for Classification)
            // Weka treats numeric classes as regression by default.
            NumericToNominal convert = new NumericToNominal();
            convert.setAttributeIndices("last");
            convert.setInputFormat(data);
            Instances labeledData = Filter.useFilter(data, convert);

            // 4. Configure Classifier (Random Forest)
            RandomForest rf = new RandomForest();
            rf.setNumIterations(100); // Number of trees
            rf.setMaxDepth(0); // Unlimited depth

            // 5. Build Model
            System.out.println("Training Random Forest...");
            rf.buildClassifier(labeledData);

            // 6. Evaluate
            Evaluation eval = new Evaluation(labeledData);
            // 10-fold cross-validation
            eval.crossValidateModel(rf, labeledData, 10, new Random(1));

            System.out.println(eval.toSummaryString("\nResults\n======\n", false));
            System.out.println("Precision: " + eval.precision(1));
            System.out.println("Recall: " + eval.recall(1));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

<properties>
    <dl4j.version>1.0.0-M2.1</dl4j.version>
</properties>

<dependencies>
    <!-- Core DL4J -->
    <dependency>
        <groupId>org.deeplearning4j</groupId>
        <artifactId>deeplearning4j-core</artifactId>
        <version>${dl4j.version}</version>
    </dependency>
    <!-- Native Backend (CPU) - Use nd4j-cuda-11.x for GPU -->
    <dependency>
        <groupId>org.nd4j</groupId>
        <artifactId>nd4j-native-platform</artifactId>
        <version>${dl4j.version}</version>
    </dependency>
    <!-- DataVec for CSV loading -->
    <dependency>
        <groupId>org.datavec</groupId>
        <artifactId>datavec-api</artifactId>
        <version>${dl4j.version}</version>
    </dependency>
</dependencies>

import org.datavec.api.records.reader.RecordReader;
import org.datavec.api.records.reader.impl.csv.CSVRecordReader;
import org.datavec.api.split.FileSplit;
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.learning.config.Adam;
import org.nd4j.linalg.lossfunctions.LossFunctions;

import java.io.File;

public class DL4JChurnExample {

    public static void main(String[] args) throws Exception {
        int batchSize = 50;
        int labelIndex = 8; // Index of 'Exited' column
        int numClasses = 2; // 0 or 1

        // 1. Load Data with DataVec
        System.out.println("Loading data with DataVec...");
        RecordReader rr = new CSVRecordReader(1, ','); // Skip header
        rr.initialize(new FileSplit(new File("src/main/resources/customer_churn.csv")));
        
        DataSetIterator trainIter = new RecordReaderDataSetIterator(rr, batchSize, labelIndex, numClasses);

        // 2. Configure Network Architecture
        // Input: 8 columns. Hidden: 16 neurons. Output: 2 classes.
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .seed(123)
                .updater(new Adam(0.001))
                .list()
                .layer(0, new DenseLayer.Builder()
                        .nIn(8) // Number of input features
                        .nOut(16)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.RELU)
                        .build())
                .layer(1, new DenseLayer.Builder()
                        .nIn(16)
                        .nOut(16)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.RELU)
                        .build())
                .layer(2, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                        .activation(Activation.SOFTMAX)
                        .nIn(16)
                        .nOut(numClasses)
                        .build())
                .build();

        // 3. Initialize Network
        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        model.setListeners(new ScoreIterationListener(10)); // Print score every 10 iterations

        // 4. Train
        System.out.println("Training Neural Network...");
        int nEpochs = 30;
        for (int i = 0; i < nEpochs; i++) {
            model.fit(trainIter);
            trainIter.reset(); // Reset iterator for next epoch
        }

        System.out.println("Training Complete.");
        // (Evaluation code omitted for brevity, similar to other frameworks)
    }
}

<dependency>
    <groupId>com.github.haifengl</groupId>
    <artifactId>smile-core</artifactId>
    <version>3.0.2</version>
</dependency>
<!-- Optional: For CSV loading conveniences -->
<dependency>
    <groupId>com.github.haifengl</groupId>
    <artifactId>smile-io</artifactId>
    <version>3.0.2</version>
</dependency>

import smile.classification.GradientTreeBoost;
import smile.data.DataFrame;
import smile.data.formula.Formula;
import smile.io.Read;
import smile.validation.CrossValidation;
import smile.validation.metric.Accuracy;

import java.util.Properties;

public class SmileChurnExample {

    public static void main(String[] args) throws Exception {
        System.out.println("Loading data with Smile...");

        // 1. Load CSV into a DataFrame
        var csvFormat = org.apache.commons.csv.CSVFormat.DEFAULT.builder()
                .setHeader()
                .setSkipHeaderRecord(true)
                .build();
                
        // Smile automatically infers schema types
        DataFrame df = Read.csv("src/main/resources/customer_churn.csv", csvFormat);

        System.out.println("Schema: " + df.schema());

        // 2. Define Formula (Target ~ Features)
        // "." means all other columns are features
        Formula formula = Formula.lhs("Exited");

        // 3. Train Gradient Boosted Trees
        // Smile allows easy hyperparameter tuning via Properties or direct arguments
        System.out.println("Training GBT...");
        
        GradientTreeBoost model = GradientTreeBoost.fit(
            formula, 
            df,
            500, // Number of trees
            5,   // Max depth
            0.1, // Learning rate
            0.5  // Subsample
        );

        // 4. Cross Validation (Example of Smile's validation tools)
        // Note: CrossValidation in Smile 3.x is slightly different, 
        // often requiring manual splitting or using the Classification interface.
        // Here we demonstrate a simple manual prediction for brevity.
        
        int[] predictions = model.predict(df);
        int[] truth = df.column("Exited").toIntArray();
        
        double accuracy = Accuracy.of(truth, predictions);
        System.out.println("Training Accuracy: " + (accuracy * 100) + "%");
        
        // 5. Inference
        // To predict a single instance, we create a tuple/row matching the schema
        // int pred = model.predict(singleRowTuple);
    }
}