import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler; //导入依赖的package包/类
/**
 * This method returns the iterator. Scales all intensity values: it divides them by 255.
 *
 * @param data the dataset to use
 * @param seed the seed for the random number generator
 * @param batchSize the batch size to use
 * @return the iterator
 * @throws Exception
 */
@Override
public DataSetIterator getDataSetIterator(Instances data, int seed, int batchSize)
    throws Exception {

  batchSize = Math.min(data.numInstances(), batchSize);
  validate(data);
  ImageRecordReader reader = getImageRecordReader(data);

  final int labelIndex = 1; // Use explicit label index position
  final int numPossibleLabels = data.numClasses();
  DataSetIterator tmpIter =
      new RecordReaderDataSetIterator(reader, batchSize, labelIndex, numPossibleLabels);
  DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
  scaler.fit(tmpIter);
  tmpIter.setPreProcessor(scaler);
  return tmpIter;
}
 

import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler; //导入依赖的package包/类
private void predictImage(BufferedImage img ) throws IOException {
	ImagePreProcessingScaler imagePreProcessingScaler = new ImagePreProcessingScaler(0, 1);
	INDArray image = loader.asRowVector(img);
	imagePreProcessingScaler.transform(image);
	INDArray output = model.output(image);
	String putStr = output.toString();
	lblResult.setText("Prediction: " + model.predict(image)[0] + "\n " + putStr);
}
 

import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler; //导入依赖的package包/类
private DataSetIterator createInternal(InputSplit inputSplit) throws IOException {
    ImageTransform imageTransform = imageTransformFactory.create();
    int width = imageTransformConfigurationResource.getScaledWidth();
    int height = imageTransformConfigurationResource.getScaledHeight();
    int channels = imageTransformConfigurationResource.getChannels();
    int batchSize = networkConfigurationResource.getBatchSize();
    int outputs = networkConfigurationResource.getOutputs();
    ImageRecordReader recordReader = new ImageRecordReader(height, width, channels, pathLabelGenerator);
    recordReader.initialize(inputSplit, imageTransform);
    RecordReaderDataSetIterator recordReaderDataSetIterator = new RecordReaderDataSetIterator(recordReader, batchSize, 1, outputs);
    DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
    scaler.fit(recordReaderDataSetIterator);
    recordReaderDataSetIterator.setPreProcessor(scaler);
    return recordReaderDataSetIterator;
}
 

import org.nd4j.linalg.dataset.api.preprocessor.ImagePreProcessingScaler; //导入依赖的package包/类
public void evaluateModel(File file) throws IOException {
  log.info("Evaluate model....");
  NativeImageLoader nativeImageLoader = new NativeImageLoader(height, width, channels);
  INDArray image = nativeImageLoader.asMatrix(file);   // testImage is of Mat format
  // 0-255 to 0-1
  DataNormalization scaler = new ImagePreProcessingScaler(0, 1);
  scaler.transform(image);
  // Pass through to neural Net
  INDArray output = network.output(image);
  System.out.println(output);
  System.out.println(networkLabels);
  // TODO: I suppose we could create a map of probabilities and return that ...
  // this map could be large
}