Logistic regression : Accuracy of 1.0 (is there an error in my code ?) about djl HOT 7 OPEN

Translator translator = new NoopTranslator();
Predictor predictor = model.newPredictor(translator);

for(Batch b: validationSet.getData(manager)) {
    NDList data = b.getData();
    NDArray prediction = ((NDList) predictor.predict(data)).singletonOrThrow();
    NDArray truelabel = b.getLabels().singletonOrThrow();

    System.out.println("Predicted is: " + prediction.toString());
    System.out.println("True value is: " + truelabel.toString());
}

for(Batch b: validationSet.getData(manager)) {
    NDList data = b.getData();
    NDArray prediction = ((NDList) predictor.predict(data)).singletonOrThrow();
    NDArray prediction_binary = Activation.sigmoid(prediction);
    NDArray truelabel = b.getLabels().singletonOrThrow();

    System.out.println("Predicted is: " + prediction_binary.toString());
    System.out.println("True value is: " + truelabel.toString());
}

package machine_learning;

import java.io.IOException;
import java.util.Random;

import tech.tablesaw.api.Table;
import ai.djl.Model;
import ai.djl.ndarray.NDManager;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDList;
import ai.djl.ndarray.types.DataType;
import ai.djl.nn.SequentialBlock;
import ai.djl.nn.core.Linear;
import ai.djl.nn.Parameter;
import ai.djl.nn.Activation;
import ai.djl.training.dataset.ArrayDataset;
import ai.djl.training.dataset.RandomAccessDataset;
import ai.djl.training.loss.Loss;
import ai.djl.training.loss.SigmoidBinaryCrossEntropyLoss;
import ai.djl.training.tracker.Tracker;
import ai.djl.training.optimizer.Optimizer;
import ai.djl.training.TrainingConfig;
import ai.djl.training.DefaultTrainingConfig;
import ai.djl.training.Trainer;
import ai.djl.training.evaluator.Accuracy;
import ai.djl.training.evaluator.BinaryAccuracy;
import ai.djl.training.TrainingResult;
import ai.djl.training.listener.TrainingListener;
import ai.djl.training.dataset.Batch;
import ai.djl.training.EasyTrain;
import ai.djl.training.initializer.ConstantInitializer;
import ai.djl.metric.Metrics;
import ai.djl.ndarray.types.Shape;
import ai.djl.translate.TranslateException;
import ai.djl.translate.Translator;
import ai.djl.translate.NoopTranslator;
import ai.djl.inference.Predictor;
import ai.djl.util.Pair;

public class LogisticRegression {

    public static void main(String[] args) throws IOException, TranslateException {
        Table spambase = Table.read().csv("spambase.csv");
        Table inputs = spambase.copy().removeColumns("is_spam");
        Table outputs = spambase.copy().retainColumns("is_spam");
        NDManager manager = NDManager.newBaseManager();
        NDArray x = manager.create(inputs.as().floatMatrix());
        NDArray scaled_x = Utils.normalize(x);

        NDArray y = manager.create(outputs.as().intMatrix());
        int batchSize = inputs.rowCount();
        ArrayDataset dataset = Utils.loadArray(scaled_x, y, batchSize, true);
        RandomAccessDataset[] datasets_split = dataset.randomSplit(80, 20);
        ArrayDataset trainingSet = (ArrayDataset) datasets_split[0];
        ArrayDataset testingSet = (ArrayDataset) datasets_split[1];

        Model model = Model.newInstance("logistic");
        SequentialBlock net = new SequentialBlock();
        Linear linearBlock = Linear.builder().optBias(true).setUnits(1).build();
        net.add(linearBlock);
        //net.setInitializer(new ConstantInitializer(0), Parameter.Type.WEIGHT);
        //net.initialize(manager, DataType.FLOAT32, x.getShape());

        model.setBlock(net);
        Loss loss = new SigmoidBinaryCrossEntropyLoss();

        float lr = 0.01f;

        Tracker lrt = Tracker.fixed(lr);
        Optimizer sgd = Optimizer.sgd().setLearningRateTracker(lrt).build();

        TrainingConfig config = new DefaultTrainingConfig(loss)
            .optOptimizer(sgd) // Optimizer
            .optDevices(manager.getEngine().getDevices(0)) // CPU
            .addEvaluator(new BinaryAccuracy()) // Model Accuracy
            .addTrainingListeners(TrainingListener.Defaults.logging()); // Logging

        Trainer trainer = model.newTrainer(config);

        trainer.initialize(new Shape(1, inputs.columnCount())); 
        Metrics metrics = new Metrics();
        trainer.setMetrics(metrics);

        int numEpochs = 1000; // only 10 with initialization of weights to 0
        EasyTrain.fit(trainer, numEpochs, trainingSet, testingSet);
    }
}

package machine_learning;

import ai.djl.training.dataset.Record;
import ai.djl.ndarray.NDArray;
import ai.djl.ndarray.NDManager;
import ai.djl.training.dataset.ArrayDataset;

public class Utils {
    public static ArrayDataset loadArray(NDArray features, NDArray labels, int batchSize, boolean shuffle) {
        return new ArrayDataset.Builder()
                    .setData(features) // set the features
                    .optLabels(labels) // set the labels
                    .setSampling(batchSize, shuffle) // set the batch size and random sampling
                    .build();
    }

    public static NDArray mean(NDArray X) {
        return X.mean(new int[]{0});
    }

    public static NDArray std(NDArray X) {
        NDArray mean = mean(X);
        NDArray squaredDiff = X.sub(mean).pow(2);
        NDArray variance = squaredDiff.mean(new int[]{0}); 
        return variance.sqrt(); 
    }

    public static NDArray normalize(NDArray X) {
        return X.sub(mean(X)).div(std(X));
    }
}