DL4Jの設定記録 – Science To Medicine

1) MAC OS-X でのJava8のJAVA_HOME指定:本当に何年やってもこの厄介なJAVA_HOME指定！
export JAVA_HOME=/usr/libexec/java_home -v 1.8
# JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_05.jdk/Contents/Home

2) Marvenのインストレーション
https://maven.apache.org/download.cgi
/optの下に置く。
Check environment variable value
echo $JAVA_HOME
/Library/Java/JavaVirtualMachines/jdk1.8.0_45.jdk/Contents/Home

Adding to PATH
export PATH=/opt/apache-maven-3.5.4/bin:$PATH

3) Deeplearning4J Examples
https://github.com/deeplearning4j/oreilly-book-dl4j-examples

4)EclipseでのMarven導入に関しては：
http://krr.blog.shinobi.jp/java/eclipseプラグイン：maven-m2eclipse-

5) IntelliJ IDEAの導入
https://www.jetbrains.com/idea/download/#section=mac
とDL4J Examplesの組み込み
https://deeplearning4j.org/docs/latest/deeplearning4j-quickstart#IntelliJ
ーーーーーーーーーーーーーーーーーーーーー
要するにEclipse＋Marvenで行くのか、IntelliJ+Marvenでいくのか、それともコマンドラインで行くのか、というような選択の中で、
IntelliJが良さそうである。

MLPClassifierSaturnを試して解析してみる。
oreilly-book-dl4j-examples/dl4j-examples/src/main/java/org/deeplearning4j/examples/feedforward/classification/MLPClassifierSaturn.java

package org.deeplearning4j.examples.feedforward.classification;

import org.datavec.api.records.reader.RecordReader;
import org.datavec.api.records.reader.impl.csv.CSVRecordReader;
import org.datavec.api.split.FileSplit;
import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
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.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.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.factory.Nd4j;
import org.nd4j.linalg.io.ClassPathResource;
import org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction;

import java.io.File;

/**
 * "Saturn" Data Classification Example
 *
 * Based on the data from Jason Baldridge:
 * 	https://github.com/jasonbaldridge/try-tf/tree/master/simdata
 *
 * @author Josh Patterson
 * @author Alex Black (added plots)
 *
 */
public class MLPClassifierSaturn {


    public static void main(String[] args) throws Exception {
        Nd4j.ENFORCE_NUMERICAL_STABILITY = true;
        int batchSize = 50;
        int seed = 123;
        double learningRate = 0.005;
        //Number of epochs (full passes of the data)
        int nEpochs = 30;

        int numInputs = 2;
        int numOutputs = 2;
        int numHiddenNodes = 20;

        final String filenameTrain  = new ClassPathResource("/classification/saturn_data_train.csv").getFile().getPath();
        final String filenameTest  = new ClassPathResource("/classification/saturn_data_eval.csv").getFile().getPath();

        //Load the training data:
        RecordReader rr = new CSVRecordReader();
        rr.initialize(new FileSplit(new File(filenameTrain)));
        DataSetIterator trainIter = new RecordReaderDataSetIterator(rr,batchSize,0,2);

        //Load the test/evaluation data:
        RecordReader rrTest = new CSVRecordReader();
        rrTest.initialize(new FileSplit(new File(filenameTest)));
        DataSetIterator testIter = new RecordReaderDataSetIterator(rrTest,batchSize,0,2);

        //log.info("Build model....");
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .seed(seed)
                .iterations(1)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .learningRate(learningRate)
                .updater(Updater.NESTEROVS).momentum(0.9)
                .list()
                .layer(0, new DenseLayer.Builder().nIn(numInputs).nOut(numHiddenNodes)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.RELU)
                        .build())
                .layer(1, new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.SOFTMAX)
                        .nIn(numHiddenNodes).nOut(numOutputs).build())
                .pretrain(false).backprop(true).build();


        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        model.setListeners(new ScoreIterationListener(10));    //Print score every 10 parameter updates

        for ( int n = 0; n < nEpochs; n++) {
            model.fit( trainIter );
        }

        System.out.println("Evaluate model....");
        Evaluation eval = new Evaluation(numOutputs);
        while(testIter.hasNext()){
            DataSet t = testIter.next();
            INDArray features = t.getFeatureMatrix();
            INDArray lables = t.getLabels();
            INDArray predicted = model.output(features,false);

            eval.eval(lables, predicted);

        }


        System.out.println(eval.stats());
        //------------------------------------------------------------------------------------
        //Training is complete. Code that follows is for plotting the data & predictions only


        double xMin = -15;
        double xMax = 15;
        double yMin = -15;
        double yMax = 15;

        //Let's evaluate the predictions at every point in the x/y input space, and plot this in the background
        int nPointsPerAxis = 100;
        double[][] evalPoints = new double[nPointsPerAxis*nPointsPerAxis][2];
        int count = 0;
        for( int i=0; i<nPointsPerAxis; i++ ){
            for( int j=0; j<nPointsPerAxis; j++ ){
                double x = i * (xMax-xMin)/(nPointsPerAxis-1) + xMin;
                double y = j * (yMax-yMin)/(nPointsPerAxis-1) + yMin;

                evalPoints[count][0] = x;
                evalPoints[count][1] = y;

                count++;
            }
        }

        INDArray allXYPoints = Nd4j.create(evalPoints);
        INDArray predictionsAtXYPoints = model.output(allXYPoints);

        //Get all of the training data in a single array, and plot it:
        rr.initialize(new FileSplit(new File(filenameTrain)));
        rr.reset();
        int nTrainPoints = 500;
        trainIter = new RecordReaderDataSetIterator(rr,nTrainPoints,0,2);
        DataSet ds = trainIter.next();
        PlotUtil.plotTrainingData(ds.getFeatures(), ds.getLabels(), allXYPoints, predictionsAtXYPoints, nPointsPerAxis);


        //Get test data, run the test data through the network to generate predictions, and plot those predictions:
        rrTest.initialize(new FileSplit(new File(filenameTest)));
        rrTest.reset();
        int nTestPoints = 100;
        testIter = new RecordReaderDataSetIterator(rrTest,nTestPoints,0,2);
        ds = testIter.next();
        INDArray testPredicted = model.output(ds.getFeatures());
        PlotUtil.plotTestData(ds.getFeatures(), ds.getLabels(), testPredicted, allXYPoints, predictionsAtXYPoints, nPointsPerAxis);

        System.out.println("****************Example finished********************");
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

package org.deeplearning4j.examples.feedforward.classification;

import org.datavec.api.records.reader.RecordReader;

import org.datavec.api.records.reader.impl.csv.CSVRecordReader;

import org.datavec.api.split.FileSplit;

import org.deeplearning4j.datasets.datavec.RecordReaderDataSetIterator;

import org.nd4j.linalg.activations.Activation;

import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;

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.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.api.ndarray.INDArray;

import org.nd4j.linalg.dataset.DataSet;

import org.nd4j.linalg.factory.Nd4j;

import org.nd4j.linalg.io.ClassPathResource;

import org.nd4j.linalg.lossfunctions.LossFunctions.LossFunction;

import java.io.File;

/**

* "Saturn" Data Classification Example

* Based on the data from Jason Baldridge:

* https://github.com/jasonbaldridge/try-tf/tree/master/simdata

* @author Josh Patterson

* @author Alex Black (added plots)

public class MLPClassifierSaturn {

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

Nd4j.ENFORCE_NUMERICAL_STABILITY = true;

int batchSize = 50;

int seed = 123;

double learningRate = 0.005;

//Number of epochs (full passes of the data)

int nEpochs = 30;

int numInputs = 2;

int numOutputs = 2;

int numHiddenNodes = 20;

final String filenameTrain = new ClassPathResource("/classification/saturn_data_train.csv").getFile().getPath();

final String filenameTest = new ClassPathResource("/classification/saturn_data_eval.csv").getFile().getPath();

//Load the training data:

RecordReader rr = new CSVRecordReader();

rr.initialize(new FileSplit(new File(filenameTrain)));

DataSetIterator trainIter = new RecordReaderDataSetIterator(rr,batchSize,0,2);

//Load the test/evaluation data:

RecordReader rrTest = new CSVRecordReader();

rrTest.initialize(new FileSplit(new File(filenameTest)));

DataSetIterator testIter = new RecordReaderDataSetIterator(rrTest,batchSize,0,2);

//log.info("Build model....");

MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()

.seed(seed)

.iterations(1)

.optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)

.learningRate(learningRate)

.updater(Updater.NESTEROVS).momentum(0.9)

.list()

.layer(0, new DenseLayer.Builder().nIn(numInputs).nOut(numHiddenNodes)

.weightInit(WeightInit.XAVIER)

.activation(Activation.RELU)

.build())

.layer(1, new OutputLayer.Builder(LossFunction.NEGATIVELOGLIKELIHOOD)

.weightInit(WeightInit.XAVIER)

.activation(Activation.SOFTMAX)

.nIn(numHiddenNodes).nOut(numOutputs).build())

.pretrain(false).backprop(true).build();

MultiLayerNetwork model = new MultiLayerNetwork(conf);

model.init();

model.setListeners(new ScoreIterationListener(10)); //Print score every 10 parameter updates

for ( int n = 0; n < nEpochs; n++) {

model.fit( trainIter );

}

System.out.println("Evaluate model....");

Evaluation eval = new Evaluation(numOutputs);

while(testIter.hasNext()){

DataSet t = testIter.next();

INDArray features = t.getFeatureMatrix();

INDArray lables = t.getLabels();

INDArray predicted = model.output(features,false);

eval.eval(lables, predicted);

}

System.out.println(eval.stats());

//------------------------------------------------------------------------------------

//Training is complete. Code that follows is for plotting the data & predictions only

double xMin = -15;

double xMax = 15;

double yMin = -15;

double yMax = 15;

//Let's evaluate the predictions at every point in the x/y input space, and plot this in the background

int nPointsPerAxis = 100;

double[][] evalPoints = new double[nPointsPerAxis*nPointsPerAxis][2];

int count = 0;

for( int i=0; i<nPointsPerAxis; i++ ){

for( int j=0; j<nPointsPerAxis; j++ ){

double x = i * (xMax-xMin)/(nPointsPerAxis-1) + xMin;

double y = j * (yMax-yMin)/(nPointsPerAxis-1) + yMin;

evalPoints[count][0] = x;

evalPoints[count][1] = y;

count++;

}

INDArray allXYPoints = Nd4j.create(evalPoints);

INDArray predictionsAtXYPoints = model.output(allXYPoints);

//Get all of the training data in a single array, and plot it:

rr.initialize(new FileSplit(new File(filenameTrain)));

rr.reset();

int nTrainPoints = 500;

trainIter = new RecordReaderDataSetIterator(rr,nTrainPoints,0,2);

DataSet ds = trainIter.next();

PlotUtil.plotTrainingData(ds.getFeatures(), ds.getLabels(), allXYPoints, predictionsAtXYPoints, nPointsPerAxis);

//Get test data, run the test data through the network to generate predictions, and plot those predictions:

rrTest.initialize(new FileSplit(new File(filenameTest)));

rrTest.reset();

int nTestPoints = 100;

testIter = new RecordReaderDataSetIterator(rrTest,nTestPoints,0,2);

ds = testIter.next();

INDArray testPredicted = model.output(ds.getFeatures());

PlotUtil.plotTestData(ds.getFeatures(), ds.getLabels(), testPredicted, allXYPoints, predictionsAtXYPoints, nPointsPerAxis);

System.out.println("****************Example finished********************");

}

beatles_all

Science To Medicine

Just My Daily Study Note by ts.anesth.kpum