【专知-Java Deeplearning4j深度学习教程05】无监督特征提取神器—AutoEncoder:图文+代码

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
5.4,3.9,1.7,0.4,Iris-setosa

import org.deeplearning4j.datasets.iterator.impl.IrisDataSetIterator;
import org.deeplearning4j.nn.api.OptimizationAlgorithm;
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.optimize.listeners.ScoreIterationListener;
import org.math.plot.Plot2DPanel;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.dataset.api.preprocessor.DataNormalization;
import org.nd4j.linalg.dataset.api.preprocessor.NormalizerMinMaxScaler;
import org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.swing.*;
import java.awt.*;
import java.util.List;


/**
 *
 * 本教程由专知提供：http://www.zhuanzhi.ai/
 *
 * 本教程演示如何用Deeplearning4j构建AutoEncoder
 * 除了DL4J所需的基础库，还需要导入JMathPlot的Maven依赖：
 *   https://mvnrepository.com/artifact/com.github.yannrichet/JMathPlot
 *
 * 本教程用DL4J在Iris数据集上学习AutoEncoder
 * 将Iris数据集的4维的原始特征变换为2维的优质特征
 * 最后用JMathPlot绘制学习到的特征
 *
 * @author hu
 */
public class AutoEncoderExample {

    private static Logger log = LoggerFactory.getLogger(AutoEncoderExample.class);

    public static void main(String[] args) throws Exception {
        int inputDim = 4; // 输入数据维度，即原始特征数量
        final int hiddenDim = 2; //隐藏层维度，即学习到的特征的维度

        int batchSize = 150; // 这里用整个数据集的大小作为batchSize
        int rngSeed = 123; // 随机种子，保证每次运行程序获得同样的结果
        int numEpochs = 1000; // epoch数量，扫描一遍数据集为一个epoch

        //用DL4J自带的Iris数据集
        DataSetIterator irisDataSet = new IrisDataSetIterator(batchSize, 150);
        //将Iris数据集归一化到-1和1之间
        //本示例用tanh激活输出层，所以用-1到1
        DataNormalization norm = new NormalizerMinMaxScaler(-1,1);
        norm.fit(irisDataSet);
        irisDataSet.setPreProcessor(norm);


        log.info("Build model....");
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .seed(rngSeed) //设置随机种子，保证每次运行程序获得同样的结果
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .iterations(1)
                .learningRate(3e-2) //学习速率
                .regularization(true).l2(1e-4)
                .list()
                //构建Encoder
                .layer(0, new DenseLayer.Builder()
                        .nIn(inputDim)
                        .nOut(hiddenDim)
                        .activation(Activation.TANH)
                        .build())
                //构建Decoder
                .layer(1, new OutputLayer.Builder(LossFunction.MSE)
                        .nIn(hiddenDim)
                        .nOut(inputDim)
                        .activation(Activation.TANH)
                        .build())
                .pretrain(false).backprop(true)
                .build();

        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        //每50个Iteration就print一次score
        model.setListeners(new ScoreIterationListener(50));

        log.info("Train model....");
        //训练
        for( int i=0; i<numEpochs; i++ ){
            irisDataSet.reset();
            while(irisDataSet.hasNext()){
                INDArray inputs = irisDataSet.next().getFeatures();
                //将网络的输入和Label都设置为样本原始特征
                model.fit(inputs, inputs);
            }
        }

        log.info("Plot learned features....");
        irisDataSet.reset();
        //取一个batch的数据，这里batchSize为数据集大小
        //因此这里会取出所有的数据
        DataSet plotDataSet = irisDataSet.next();
        //获取原始特征
        INDArray inputs = plotDataSet.getFeatures();
        //前向传播到第0层（即隐藏层）
        //返回的是一个数组，数组包含前向传播到指定层所经过的所有层的激活值（包括指定层）
        List<INDArray> activationList = model.feedForwardToLayer(0,inputs,false);
        //取出数组中的最后一层激活值（也就是隐藏层的激活值）
        INDArray features = activationList.get(activationList.size() - 1);
        //取出原始数据的Label，原始数据的Label用one hot格式，因此需要用argMax(1)将其转换为普通数值Label
        INDArray labels = plotDataSet.getLabels().argMax(1);

        //使用JMathPlot绘制特征2D图
        //用2个坐标轴表示学习到的特征的2个维度
        //用颜色表示样本的类别
        Plot2DPanel plot = new Plot2DPanel();
        Color[] colors = new Color[]{Color.red, Color.green, Color.blue};
        for(int i = 0;i<features.shape()[0];i++){
            Color color = colors[labels.getInt(i)];
            double x = features.getDouble(i,0);
            double y = features.getDouble(i,1);
            plot.addScatterPlot("iris", color,new double[]{x},new double[]{y});
        }
        //将JMathPlot嵌套在JFrame里展示
        JFrame frame = new JFrame("a plot panel");
        frame.setBounds(200,200,800,800);
        frame.setContentPane(plot);
        frame.setVisible(true);

    }

}