The Score is low when I load the model to predict the testing data.

gistfile1.txt

The train program is as below:
```java
package org.deeplearning4j.examples.feedforward.mnist;

import org.datavec.api.io.labels.ParentPathLabelGenerator;
import org.datavec.api.split.FileSplit;
import org.datavec.image.loader.NativeImageLoader;
import org.datavec.image.recordreader.ImageRecordReader;
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
import org.deeplearning4j.eval.Evaluation;
import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.Updater;
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.deeplearning4j.util.ModelSerializer;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.api.DataSet;
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.lossfunctions.LossFunctions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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


/**
 * Created by Dwayne Glenn on 11/17/16.
 *
 */
public class MnistMultiLayerImageTrainAndSave {


    protected static final Logger log = LoggerFactory.getLogger(MnistMultiLayerImageTrainAndSave.class);

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

        int height = 28;
        int width = 28;
        int channels = 1;
        int numEpochs = 15;
        int rngseed = 123;
        Random randNumGen = new Random(rngseed);
        int batchSize = 128;
        int outputNum = 10;

        //Begin to read image file ,args[0] is the path of train image and args[1] is the path of test image.
        File trainData = new File(args[0]);
        File testData = new File(args[1]);

        //Define the FileSplit(PATH, ALLWOED, FROMATS, RANDOM)
        FileSplit train = new FileSplit(trainData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);
        FileSplit test = new FileSplit(testData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);

        //Extract the parent path as the image label
        ParentPathLabelGenerator labelMaker = new ParentPathLabelGenerator();
        ImageRecordReader recordReader = new ImageRecordReader(height, width, channels, labelMaker);

        //Initialize the record reader
        recordReader.initialize(train);

        //DataSet Iterator
        DataSetIterator trainIter = new RecordReaderDataSetIterator(recordReader, batchSize, 1, outputNum);
        DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
        scaler.fit(trainIter);
        trainIter.setPreProcessor(scaler);
        recordReader.close();
        System.gc();

        log.info("**** BUILD MODEL ****");

        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
            .seed(rngseed)
            .iterations(1)
            .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
            .learningRate(0.006)
            .regularization(true).l2(1e-4)
            .updater(Updater.NESTEROVS).momentum(0.9)
            .list()
            .layer(0, new DenseLayer.Builder()
                .nIn(height*width)
                .nOut(100)
                .activation("relu")
                .weightInit(WeightInit.XAVIER)
                .build())
            .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                .nIn(100)
                .nOut(outputNum)
                .activation("softmax")
                .weightInit(WeightInit.XAVIER)
                .build())
            .backprop(true).pretrain(false).setInputType(InputType.convolutional(height, width, channels))
            .build();

        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        model.setListeners(new ScoreIterationListener(20));


        log.info("**** TRAIN MODEL ****");
        for(int i = 1; i < numEpochs; i++){
            System.gc();
            model.fit(trainIter);
        }


        log.info("**** SAVE TRAINED MODEL ****");
        //Details
        //Where to save model
        File locationToSave = new File("trained_mnist_model.zip");
        //boolean save Updater
        boolean saveUpdater = false;
        ModelSerializer.writeModel(model, locationToSave, saveUpdater);


        log.info("**** EVALUATE MODEL ****");
        //Initialize the record reader
        recordReader.initialize(test);

        //DataSet Iterator
        DataSetIterator testIter = new RecordReaderDataSetIterator(recordReader, batchSize, 1, outputNum);
//        DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
        scaler.fit(testIter);
        testIter.setPreProcessor(scaler);
        System.gc();
//        recordReader.close();

        //Create Eval object with 10 possible classes
        Evaluation eval = new Evaluation(outputNum);
        while(testIter.hasNext()){
            System.gc();
            DataSet next = testIter.next();
            INDArray output = model.output(next.getFeatureMatrix());
            eval.eval(next.getLabels(), output);

        }
        log.info(eval.stats());
        
        log.info("**** Finish Save The Model ****");


    }
}

```

The Load model is as below

package org.deeplearning4j.examples.feedforward.mnist;

import org.datavec.api.io.labels.ParentPathLabelGenerator;
import org.datavec.api.split.FileSplit;
import org.datavec.image.loader.NativeImageLoader;
import org.datavec.image.recordreader.ImageRecordReader;
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
import org.deeplearning4j.eval.Evaluation;
import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.Updater;
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.optimize.listeners.ScoreIterationListener;
import org.deeplearning4j.util.ModelSerializer;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.api.DataSet;
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.lossfunctions.LossFunctions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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


/**
 * Created by Dwayne Glenn on 11/17/16.
 *
 */
public class MnistMultiLayerImageLoad {


    protected static final Logger log = LoggerFactory.getLogger(MnistMultiLayerImageLoad.class);

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

        int height = 28;
        int width = 28;
        int channels = 1;
        int rngseed = 123;
        Random randNumGen = new Random(rngseed);
        int batchSize = 128;
        int outputNum = 10;

        //Begin to read image file ,args[0] is the path of train image and args[1] is the path of test image.
        File trainData = new File(args[0]);
        File testData = new File(args[0]);

//        File testData = new File("/home/yilaguan/IdeaProjects/dl4j-examples/dl4j-examples/src/main/resources/mnist_png/testing");
        //Define the FileSplit(PATH, ALLWOED, FROMATS, RANDOM)
        FileSplit train = new FileSplit(trainData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);
        FileSplit test = new FileSplit(testData, NativeImageLoader.ALLOWED_FORMATS, randNumGen);

        //Extract the parent path as the image label
        ParentPathLabelGenerator labelMaker = new ParentPathLabelGenerator();
        ImageRecordReader recordReader = new ImageRecordReader(height, width, channels, labelMaker);

        log.info("**** LOAD TRAIN MODEL ****");
        File locationToSave = new File("trained_mnist_model.zip");

        MultiLayerNetwork model = ModelSerializer.restoreMultiLayerNetwork(locationToSave);



        log.info("**** EVALUATE MODEL ****");
        recordReader.initialize(test);

        //DataSet Iterator
        DataSetIterator testIter = new RecordReaderDataSetIterator(recordReader, batchSize, 1, outputNum);
        DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
        scaler.fit(testIter);
        testIter.setPreProcessor(scaler);

        //Create Eval object with 10 possible classes
        Evaluation eval = new Evaluation(outputNum);
        while(testIter.hasNext()){
            System.gc();
            DataSet next = testIter.next();
            INDArray output = model.output(next.getFeatureMatrix());
            eval.eval(next.getLabels(), output);

        }
        log.info(eval.stats());



    }
}

The result is as below:

When I use MnistMultiLayerImageTrainAndSave the score is high:
==========================Scores========================================
 Accuracy:  0.9665
 Precision: 0.9656
 Recall:    0.9656
 F1 Score:  0.9656
========================================================================

But when I save the model and reload to predict the testing data, I find the score is as below:
==========================Scores========================================
 Accuracy:  0.0036
 Precision: 0.0037
 Recall:    0.0037
 F1 Score:  0.0037
========================================================================
I did not know why ?