An example of running a deep learning machine learning model using Scala

//> using dep "org.deeplearning4j:deeplearning4j-core:1.0.0-M2.1"
//> using dep "org.nd4j:nd4j-native-platform:1.0.0-M2.1"
//> using dep "org.datavec:datavec-api:1.0.0-M2.1"
//

import org.deeplearning4j.datasets.iterator.impl.MnistDataSetIterator;
import org.deeplearning4j.eval.Evaluation;
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.learning.config.Nesterovs;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

println("hello")

//object Hello {
 // def main(args: Array[String]): Unit = {
    val numRows = 28;
    val numColumns = 28;
    val outputNum = 10; // number of output classes
    val batchSize = 128; // batch size for each epoch
    val rngSeed = 123; // random number seed for reproducibility
    val numEpochs = 15; // number of epochs to perform

    //Get the DataSetIterators:
    val mnistTrain: DataSetIterator  = new MnistDataSetIterator(batchSize, true, rngSeed);
    val mnistTest: DataSetIterator  = new MnistDataSetIterator(batchSize, false, rngSeed);


    println("Build model....");
    val conf: MultiLayerConfiguration  = new NeuralNetConfiguration.Builder()
            .seed(rngSeed) //include a random seed for reproducibility
            // use stochastic gradient descent as an optimization algorithm
            .updater(new Nesterovs(0.006, 0.9)) //specify the rate of change of the learning rate.
            .l2(1e-4)
            .list()
            .layer(0, new DenseLayer.Builder() //create the first, input layer with xavier initialization
                    .nIn(numRows * numColumns)
                    .nOut(1000)
                    .activation(Activation.RELU)
                    .weightInit(WeightInit.XAVIER)
                    .build())
            .layer(1, new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD) //create hidden layer
                    .nIn(1000)
                    .nOut(outputNum)
                    .activation(Activation.SOFTMAX)
                    .weightInit(WeightInit.XAVIER)
                    .build())
           // .pretrain(false)
            //.backprop(true) //use backpropagation to adjust weights
            .build();

    val model: MultiLayerNetwork  = new MultiLayerNetwork(conf);
    model.init();
    //print the score with every 1 iteration
    model.setListeners(new ScoreIterationListener(1));

    println("Train model....");
    for(i <- 0 to numEpochs) {
        model.fit(mnistTrain);
    }

    println("Evaluate model....");
    val eval: Evaluation  = new Evaluation(outputNum); //create an evaluation object with 10 possible classes
    while(mnistTest.hasNext()){
        val next:DataSet  = mnistTest.next();
        val output: INDArray  = model.output(next.getFeatures()); //get the networks prediction
        eval.eval(next.getLabels(), output); //check the prediction against the true class
    }

    println(eval.stats());
    println("****************Example finished********************");
  //}
//}