Creating a Lenet CNN Architecture using ComputationGraph Deeplearning4j

Lenet.md

here

 public static ComputationGraphConfiguration getLenet0() {
       final int[] kernel5x5 = new int[]{5, 5};
       final int[] kernel2x2 = new int[]{2, 2};
       final int[] padd0x0 = new int[]{0, 0};
       final int[] stride1x1 = new int[]{1, 1};
       final int[] stride2x2 = kernel2x2;
       final int width=28;
       final int height=28;
       final int filtersize20=20;
       final int filtersize50=50;
       final SubsamplingLayer.PoolingType PoolingMax=SubsamplingLayer.PoolingType.MAX;
        
        Map<Integer, Double> lrSchedule = new HashMap<>();
        lrSchedule.put(0, 0.06);
        lrSchedule.put(200, 0.05);
        lrSchedule.put(600, 0.028);
        lrSchedule.put(800, 0.0060);
        lrSchedule.put(1000, 0.001);
        
        ComputationGraphConfiguration FIG = new NeuralNetConfiguration.Builder()
                .seed(1234)
//                .gradientNormalization(GradientNormalization.RenormalizeL2PerLayer)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .l2(0.0005)
                .updater(new Nesterovs(new MapSchedule(ScheduleType.ITERATION, lrSchedule)))
                .weightInit(WeightInit.XAVIER_UNIFORM)
                .graphBuilder()
                .addInputs("cnn0")
                .setInputTypes(InputType.convolutional(height, width, channels))
                .setOutputs("numbers")
                .addLayer("cnn1", new ConvolutionLayer.Builder(kernel5x5, stride1x1, padd0x0)
                        .nIn(channels)
                        .nOut(filtersize20)
                        .activation(Activation.IDENTITY)
                        .build(), "cnn0")
                .addLayer("maxpool1", new SubsamplingLayer.Builder(PoolingMax, kernel2x2, stride2x2, padd0x0)
                        .build(), "cnn1")
                .addLayer("cnn2", new ConvolutionLayer.Builder(kernel5x5, stride1x1, padd0x0)
                        .nOut(filtersize50)
                        .activation(Activation.IDENTITY)
                        .build(), "maxpool1")
                .addLayer("maxpool2", new SubsamplingLayer.Builder(PoolingMax, kernel2x2, stride2x2, padd0x0)
                        .build(), "cnn2")
                .addLayer("ffn0", new DenseLayer.Builder()
                        .nOut(500)
                        .activation(Activation.RELU)
                        .build(), "maxpool2")
                .addLayer("numbers", new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                        .nOut(10)
                        .activation(Activation.SOFTMAX)
                        .build(), "ffn0")
                .build();
        return FIG;
    }
  public static MultiLayerConfiguration getLenet1(int labelsize,int channels){
            int width=28;
            int height=28;
            int filtersize20=20,filtersize50=50;

            // iteration #, learning rate
            Map<Integer, Double> lrSchedule = new HashMap<>();
            lrSchedule.put(0, 0.06);
            lrSchedule.put(200, 0.05);
            lrSchedule.put(600, 0.028);
            lrSchedule.put(800, 0.0060);
            lrSchedule.put(1000, 0.001);

            MultiLayerConfiguration lenet = new NeuralNetConfiguration.Builder()
                    .seed(1234)
                    .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                    .l2(0.0005)
                    .weightInit(WeightInit.XAVIER)
                    .updater(new Nesterovs(new MapSchedule(ScheduleType.ITERATION, lrSchedule)))
                    .list()
                    .layer(0, new ConvolutionLayer.Builder(5, 5)
                            .nIn(channels)
                            .stride(1, 1)
                            .nOut(filtersize20)
                            .activation(Activation.IDENTITY)
                            .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(filtersize50)
                            .activation(Activation.IDENTITY)
                            .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(labelsize)
                            .activation(Activation.SOFTMAX)
                            .build())
                    .setInputType(InputType.convolutionalFlat(height, width, channels))//convolutionalFlat cos the channels value=1 indicating greyscale
                    .backprop(true).pretrain(false).build();
            return lenet;
        }