memmory problem

con.kt

        val conf = NeuralNetConfiguration.Builder()
                .seed(rngseed)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .iterations(1)
                .learningRate(0.006)
                .updater(Updater.NESTEROVS)
                .regularization(true).l2(1e-4)
                .list()
                .layer(0, DenseLayer.Builder()
                        .nIn(height * width)
                        .nOut(12 * width)
                        .activation(Activation.SIGMOID)
                        .weightInit(WeightInit.SIGMOID_UNIFORM)
                        .build())
                .layer(1, DenseLayer.Builder()
                        .nIn(12 * width)
                        .nOut(8 * width)

                        .activation(Activation.SIGMOID)
                        .weightInit(WeightInit.SIGMOID_UNIFORM)
                        .build())
                .layer(2, DenseLayer.Builder()
                        .nIn(8 * width)
                        .nOut(4 * width)
                        .activation(Activation.SIGMOID)
                        .weightInit(WeightInit.SIGMOID_UNIFORM)
                        .build())
                .layer(3, OutputLayer.Builder(LossFunctions.LossFunction.MSE)
                        .nIn(4 * width)
                        .nOut(width)
                        .activation(Activation.SIGMOID)
                        .weightInit(WeightInit.SIGMOID_UNIFORM)
                        .build())

                .pretrain(false).backprop(true)
                .setInputType(InputType.convolutional(height, width, channel))
                .build()

        val model = MultiLayerNetwork(conf)

exception.java

Exception in thread "main" java.lang.OutOfMemoryError: Cannot allocate new FloatPointer(1435082400): totalBytes = 5G, physicalBytes = 6G
	at org.bytedeco.javacpp.FloatPointer.<init>(FloatPointer.java:76)
	at org.nd4j.linalg.api.buffer.BaseDataBuffer.<init>(BaseDataBuffer.java:541)
	at org.nd4j.linalg.api.buffer.FloatBuffer.<init>(FloatBuffer.java:61)
	at org.nd4j.linalg.api.buffer.factory.DefaultDataBufferFactory.createFloat(DefaultDataBufferFactory.java:255)
	at org.nd4j.linalg.factory.Nd4j.createBuffer(Nd4j.java:1468)
	at org.nd4j.linalg.api.ndarray.BaseNDArray.<init>(BaseNDArray.java:260)
	at org.nd4j.linalg.cpu.nativecpu.NDArray.<init>(NDArray.java:122)
	at org.nd4j.linalg.cpu.nativecpu.CpuNDArrayFactory.createUninitialized(CpuNDArrayFactory.java:267)
	at org.nd4j.linalg.factory.Nd4j.createUninitialized(Nd4j.java:5054)
	at org.nd4j.linalg.api.rng.distribution.impl.UniformDistribution.sample(UniformDistribution.java:197)
	at org.nd4j.linalg.factory.Nd4j.rand(Nd4j.java:3082)
	at org.deeplearning4j.nn.weights.WeightInitUtil.initWeights(WeightInitUtil.java:82)
	at org.deeplearning4j.nn.weights.WeightInitUtil.initWeights(WeightInitUtil.java:61)
	at org.deeplearning4j.nn.params.DefaultParamInitializer.createWeightMatrix(DefaultParamInitializer.java:151)
	at org.deeplearning4j.nn.params.DefaultParamInitializer.createWeightMatrix(DefaultParamInitializer.java:139)
	at org.deeplearning4j.nn.params.DefaultParamInitializer.init(DefaultParamInitializer.java:88)
	at org.deeplearning4j.nn.conf.layers.DenseLayer.instantiate(DenseLayer.java:58)
	at org.deeplearning4j.nn.multilayer.MultiLayerNetwork.init(MultiLayerNetwork.java:620)
	at org.deeplearning4j.nn.multilayer.MultiLayerNetwork.init(MultiLayerNetwork.java:539)
	at org.deeplearning4j.nn.multilayer.MultiLayerNetwork.setListeners(MultiLayerNetwork.java:1581)
	at org.deeplearning4j.nn.multilayer.MultiLayerNetwork.setListeners(MultiLayerNetwork.java:1636)
	at com.yarh.starpd.dl4j.xor.CreateD_C_C.create(CreateD_C_C.kt:86)
	at com.yarh.starpd.dl4j.xor.CreateDsKt.main(CreateDs.kt:11)
Caused by: java.lang.OutOfMemoryError: Native allocator returned address == 0
	at org.bytedeco.javacpp.FloatPointer.<init>(FloatPointer.java:70)
	... 22 more

lanet.kt

    private fun alexnetModel(): MultiLayerNetwork {
        /**
         * AlexNet model interpretation based on the original paper ImageNet Classification with Deep Convolutional Neural Networks
         * and the imagenetExample code referenced.
         * http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf
         */

        val nonZeroBias = 1.0
        val dropOut = 0.5

        val conf = NeuralNetConfiguration.Builder()
                .seed(CreateDs.seed)
                .weightInit(WeightInit.DISTRIBUTION)
                .dist(NormalDistribution(0.0, 0.01))
                .activation(Activation.RELU)
                .updater(Nesterovs(0.7))
                .iterations(CreateDs.iterations)
                .gradientNormalization(GradientNormalization.RenormalizeL2PerLayer) // normalize to prevent vanishing or exploding gradients
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .learningRate(1e-2)
                .biasLearningRate(1e-2 * 2)
                .learningRateDecayPolicy(LearningRatePolicy.Step)
                .lrPolicyDecayRate(0.1)
                .lrPolicySteps(100000.0)
                .regularization(true)
                .l2(5 * 1e-4)
                .miniBatch(false)
                .list()
                .layer(0, convInit("cnn1", CreateDs.channels, 96, intArrayOf(11, 11), intArrayOf(4, 4), intArrayOf(3, 3), 0.0))
                .layer(1, LocalResponseNormalization.Builder().name("lrn1").build())
                .layer(2, maxPool("maxpool1", intArrayOf(3, 3)))
                .layer(3, conv5x5("cnn2", 256, intArrayOf(1, 1), intArrayOf(2, 2), nonZeroBias))
                .layer(4, LocalResponseNormalization.Builder().name("lrn2").build())
                .layer(5, maxPool("maxpool2", intArrayOf(3, 3)))
                .layer(6, conv3x3("cnn3", 384, 0.0))
                .layer(7, conv3x3("cnn4", 384, nonZeroBias))
                .layer(8, conv3x3("cnn5", 256, nonZeroBias))
                .layer(9, maxPool("maxpool3", intArrayOf(3, 3)))
                .layer(10, fullyConnected("ffn1", 4096, nonZeroBias, dropOut, GaussianDistribution(0.0, 0.005)))
                .layer(11, fullyConnected("ffn2", 4096, nonZeroBias, dropOut, GaussianDistribution(0.0, 0.005)))
                .layer(12, OutputLayer.Builder(LossFunctions.LossFunction.MSE)
                        .name("output")
                        .nOut(CreateDs.width)
                        .activation(Activation.SIGMOID)
                        .build())
                .backprop(true)
                .pretrain(false)
                .setInputType(InputType.convolutional(CreateDs.height, CreateDs.width, CreateDs.channels))
                .build()

        return MultiLayerNetwork(conf)

    }