Spring AI中的卷积神经网络（CNN）：深度解析与Java实现

<dependencies>
<dependency>
<groupId>org.deeplearning4j</groupId>
<artifactId>deeplearning4j-core</artifactId>
<version>1.0.0-beta7</version>
</dependency>
<dependency>
<groupId>org.nd4j</groupId>
<artifactId>nd4j-native-platform</artifactId>
<version>1.0.0-beta7</version>
</dependency>
<dependency>
<groupId>org.datavec</groupId>
<artifactId>datavec-api</artifactId>
<version>1.0.0-beta7</version>
</dependency>
<!-- 其他依赖项 -->
</dependencies>

import org.datavec.api.split.FileSplit;
import org.datavec.api.split.InputSplit;
import org.datavec.api.records.reader.RecordReader;
import org.datavec.api.records.reader.impl.csv.CSVRecordReader;
import org.datavec.api.records.metadata.RecordMetaData;
import org.datavec.api.split.NumberedFileSplit;
import org.datavec.image.loader.NativeImageLoader;
import org.datavec.image.recordreader.ImageRecordReader;
import org.datavec.image.transform.ImageTransform;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
import org.nd4j.linalg.dataset.api.preprocessor.NormalizerStandardize;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class DataPreprocessing {
public static DataSetIterator getMnistDataIterator(int batchSize, boolean train) throws Exception {
int height = 28;
int width = 28;
int channels = 1;
int numLabels = 10;
File parentDir = new File("path/to/mnist");
File trainDir = new File(parentDir, train ? "train" : "test");
ImageRecordReader recordReader = new ImageRecordReader(height, width, channels, new NativeImageLoader(height, width, channels));
        recordReader.initialize(new NumberedFileSplit(trainDir.getAbsolutePath() + "/%d.png", 0, numLabels));
DataNormalization scaler = new NormalizerStandardize();
        scaler.fit(recordReader);
        recordReader.setPreProcessor(scaler);
DataSetIterator dataIter = new RecordReaderDataSetIterator(recordReader, batchSize, numLabels, numLabels);
return dataIter;
    }
}

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.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.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.lossfunctions.LossFunctions;
public class CnnModel {
public static MultiLayerNetwork buildModel(int height, int width, int channels, int outputNum) {
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .seed(123)
                .updater(new Nesterovs(0.006, 0.9))
                .list()
                .layer(0, new ConvolutionLayer.Builder(5, 5)
                        .nIn(channels)
                        .stride(1, 1)
                        .nOut(20)
                        .activation(Activation.RELU)
                        .build())
                .layer(1, new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX)
                        .kernelSize(2, 2)
                        .stride(2, 2)
                        .build())
                .layer(2, new ConvolutionLayer.Builder(5, 5)
                        .stride(1, 1)
                        .nOut(50)
                        .activation(Activation.RELU)
                        .build())
                .layer(3, new SubsamplingLayer.Builder(SubsamplingLayer.PoolingType.MAX)
                        .kernelSize(2, 2)
                        .stride(2, 2)
                        .build())
                .layer(4, new DenseLayer.Builder().activation(Activation.RELU)
                        .nOut(500).build())
                .layer(5, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                        .nOut(outputNum)
                        .activation(Activation.SOFTMAX)
                        .build())
                .setInputType(InputType.convolutional(height, width, channels))
                .build();
MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
return model;
    }
}

import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
public class TrainCnn {
public static void main(String[] args) throws Exception {
int batchSize = 64;
int nEpochs = 10;
int outputNum = 10;
DataSetIterator mnistTrain = DataPreprocessing.getMnistDataIterator(batchSize, true);
DataSetIterator mnistTest = DataPreprocessing.getMnistDataIterator(batchSize, false);
MultiLayerNetwork model = CnnModel.buildModel(28, 28, 1, outputNum);
        model.setListeners(new ScoreIterationListener(10));
for (int i = 0; i < nEpochs; i++) {
            model.fit(mnistTrain);
        }
        System.out.println("Evaluation....");
Evaluation eval = new Evaluation(outputNum);
while (mnistTest.hasNext()) {
DataSet next = mnistTest.next();
INDArray output = model.output(next.getFeatures());
            eval.eval(next.getLabels(), output);
        }
        System.out.println(eval.stats());
    }
}