Code for natural-image in CNN (Accuracy train=84%, test=74% ). Need to improve to make higher accuracy.

NIClassifier.java

package ai.certifai.farhan.midTerm;

import org.datavec.api.io.filters.BalancedPathFilter;
import org.datavec.api.io.labels.ParentPathLabelGenerator;
import org.datavec.api.split.FileSplit;
import org.datavec.api.split.InputSplit;
import org.datavec.image.loader.BaseImageLoader;
import org.datavec.image.recordreader.ImageRecordReader;
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.inputs.InputType;
import org.deeplearning4j.nn.conf.layers.ConvolutionLayer;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.conf.layers.SubsamplingLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.common.io.ClassPathResource;
import org.nd4j.evaluation.classification.Evaluation;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler;
import org.nd4j.linalg.learning.config.Adam;
import org.nd4j.linalg.lossfunctions.LossFunctions;

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

public class NIClassifier {

    private static Random rng = new Random();
    private static String[] allowedExtensions = BaseImageLoader.ALLOWED_FORMATS;
    private static ParentPathLabelGenerator labelMaker = new ParentPathLabelGenerator();
    private static int batchSize = 10;
    private static int nClassess = 6;   // buildings, forest, glacier, mountain, sea, street = 6 label
    private static int seed = 123;
    private static double learningRate = 1e-4;

    public static void main(String[] args) throws IOException {

        // .getFile() = path error, so put [ throws IO Exception ] in main method

        File myFile = new ClassPathResource("NI").getFile();

        // convert directory to file
        FileSplit fSplit = new FileSplit(myFile);

        // helping when data has imbalance input, stop when one of no more source
        BalancedPathFilter bPF = new BalancedPathFilter(rng, allowedExtensions, labelMaker);

        // split our input
        // here sampling happen, choosing samples to be used for modeling
        InputSplit[] allData = fSplit.sample(bPF, 0.8, 0.2); // split train 80%, test 20%
        InputSplit trainData = allData[0]; // 0 = access first item
        InputSplit testData = allData[1];

        // create record reader
        ImageRecordReader trainRR = new ImageRecordReader(60,60,3, labelMaker);
        ImageRecordReader testRR = new ImageRecordReader(60,60,3, labelMaker);

        // initialize recorded reader
        trainRR.initialize(trainData);
        testRR.initialize(testData);

        // due to our low spec laptop
        //
        DataSetIterator trainIterator = new RecordReaderDataSetIterator(trainRR, batchSize, 1, nClassess);
        DataSetIterator testIterator = new RecordReaderDataSetIterator(testRR, batchSize, 1, nClassess);

        // scaling data for better convergence
        DataNormalization scalar = new ImagePreProcessingScaler();

        trainIterator.setPreProcessor(scalar);
        testIterator.setPreProcessor(scalar);

        // here, done loading data


        // 2 CL, 1 PL, 1 DL

        // model / architecture

        MultiLayerConfiguration config = new NeuralNetConfiguration.Builder()
                .seed(seed)
                .updater(new Adam(learningRate))    // .l2(0.001)
                .weightInit(WeightInit.XAVIER)      // .dropOut(0.5/0.75) below than that to much
                .l2(0.001)
                .list()
                .layer(new ConvolutionLayer.Builder()
                        .nIn(3) // input number of channel
                        .nOut(100)  // what ever number
                        .kernelSize(3,3)
                        .stride(1,1)
                        .activation(Activation.RELU)
                        .build())
                .layer(new ConvolutionLayer.Builder()
                        .nOut(20)
                        .kernelSize(3,3)
                        .stride(1,1)
                        .activation(Activation.RELU)
                        .build())
                .layer(new SubsamplingLayer.Builder()
                        .kernelSize(2,2)
                        .stride(2,2)
                        .poolingType(SubsamplingLayer.PoolingType.MAX)
                        .build())
                .layer(new DenseLayer.Builder()
                        .nOut(12)
                        .activation(Activation.RELU)
                        .build())
                .layer(new OutputLayer.Builder()
                        .lossFunction(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD) // MSE use only for regression problem, here is classification
                        .nOut(6)
                        .activation(Activation.SOFTMAX)
                        .build())
                .setInputType(InputType.convolutional(60,60,3))
                .build();

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


        model.setListeners(new ScoreIterationListener(10));

        model.fit(trainIterator,10);

        // Evaluation
        Evaluation evalTrain = model.evaluate(trainIterator);
        Evaluation evalTest = model.evaluate(testIterator);

        // print out everything
        System.out.println("Train Evaluation: \n" + evalTrain.stats());
        System.out.println("Test Evaluation: \n" + evalTest.stats());


    }

}