Repository: systemml Updated Branches: refs/heads/master 23df1484f -> 305eb28c4
http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/DnnParameters.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/DnnParameters.java b/src/main/java/org/apache/sysml/runtime/matrix/data/DnnParameters.java new file mode 100644 index 0000000..9836cdb --- /dev/null +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/DnnParameters.java @@ -0,0 +1,160 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.sysml.runtime.matrix.data; + +import java.io.Serializable; + +import org.apache.sysml.hops.Hop; +import org.apache.sysml.runtime.DMLRuntimeException; +import org.apache.sysml.runtime.util.DnnUtils; + +/** + * This class is container that stores parameters required for executing following operations: + * conv2d, conv2d_backward_data, conv2d_backward_filter, maxpooling, maxpooling_backward + */ +public class DnnParameters implements Serializable +{ + private static final long serialVersionUID = -212362627205772829L; + + public int N, C, H, W, K, R, S, P, Q; + public int stride_h, stride_w, pad_h, pad_w; + public int numThreads; + + // Optional variables used by ConvolutionCPInstruction + public boolean enableNative = false; + + public MatrixBlock input1; public MatrixBlock input2; public MatrixBlock output; + + public MatrixBlock bias; + public int [] start_indexes_h, end_indexes_h, start_indexes_w, end_indexes_w; + + public double minValForMaxPoolOperations = -Double.MAX_VALUE; + + public DnnParameters(long N, long C, long H, long W, + long K, long R, long S, long stride_h, long stride_w, + long pad_h, long pad_w, int numThreads) { + this.N = convertToInt(N); + this.C = convertToInt(C); + this.H = convertToInt(H); + this.W = convertToInt(W); + this.K = convertToInt(K); + this.R = convertToInt(R); + this.S = convertToInt(S); + this.stride_h = convertToInt(stride_h); + this.stride_w = convertToInt(stride_w); + this.pad_h = convertToInt(pad_h); + this.pad_w = convertToInt(pad_w); + if(H >= 0 && pad_h >= 0 && R >= 0 && stride_h >= 0) + P = (int) ((H + 2 * pad_h - R) / stride_h + 1); + else + P = -1; + + if(W >= 0 && pad_w >= 0 && S >= 0 && stride_w >= 0) + Q = (int) ((W + 2 * pad_w - S) / stride_w + 1); + else + Q = -1; + + this.numThreads = numThreads; + } + + public DnnParameters(int N, int C, int H, int W, + int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int numThreads) { + this.N = N; + this.C = C; + this.H = H; + this.W = W; + this.K = K; + this.R = R; + this.S = S; + this.stride_h = stride_h; + this.stride_w = stride_w; + this.pad_h = pad_h; + this.pad_w = pad_w; + if(H <= 0 || R <= 0 || stride_h < 0 || pad_h < 0) + P = -1; + else + P = (int) DnnUtils.getP(H, R, stride_h, pad_h); + if(W <= 0 || S <= 0 || stride_w < 0 || pad_w < 0) + Q = -1; + else + Q = (int) DnnUtils.getQ(W, S, stride_w, pad_w); + this.numThreads = numThreads; + } + + private static int convertToInt(long val) { + if( val > Integer.MAX_VALUE ) + throw new DMLRuntimeException("The value for DnnParameters is too large:" + val); + return (int) val; + } + + public boolean compare(DnnParameters that) { + if(this.N == that.N && this.C == that.C && this.H == that.H && this.W == that.W + && this.K == that.K && this.R == that.R && this.S == that.S && this.stride_h == that.stride_h + && this.stride_w == that.stride_w && this.pad_h == that.pad_h + && this.pad_w == that.pad_w && this.numThreads == that.numThreads) { + return true; + } + return false; + } + + @Override + public String toString() { + return "(NCHW=[" + N + " " + C + " " + H + " " + W + "], KCRS=[" + K + " " + R + " " + S + "], stride=[" + stride_h + "," + stride_w + + "], pad=[" + pad_h + "," + pad_w + "])"; + } + + public void setIfUnknown(Hop N, Hop C, Hop H, Hop W, + Hop K, Hop R, Hop S, Hop stride_h, Hop stride_w, Hop pad_h, Hop pad_w, int numThreads) { + if(this.N < 0) this.N = convertToInt(Hop.computeSizeInformation(N)); + if(this.C < 0) this.C = convertToInt(Hop.computeSizeInformation(C)); + if(this.H < 0) this.H = convertToInt(Hop.computeSizeInformation(H)); + if(this.W < 0) this.W = convertToInt(Hop.computeSizeInformation(W)); + if(this.K < 0) this.K = convertToInt(Hop.computeSizeInformation(K)); + if(this.R < 0) this.R = convertToInt(Hop.computeSizeInformation(R)); + if(this.S < 0) this.S = convertToInt(Hop.computeSizeInformation(S)); + if(this.stride_h < 0) this.stride_h = convertToInt(Hop.computeSizeInformation(stride_h)); + if(this.stride_w < 0) this.stride_w = convertToInt(Hop.computeSizeInformation(stride_w)); + if(this.pad_h < 0) this.pad_h = convertToInt(Hop.computeSizeInformation(pad_h)); + if(this.pad_w < 0) this.pad_w = convertToInt(Hop.computeSizeInformation(pad_w)); + if(this.P < 0 && this.H >= 0 && this.R >= 0 && this.stride_h >= 0 && this.pad_h >= 0) { + this.P = (int) DnnUtils.getP(this.H, this.R, this.stride_h, this.pad_h); + } + if(this.Q < 0 && this.W >= 0 && this.S >= 0 && this.stride_w >= 0 && this.pad_w >= 0) { + this.Q = (int) DnnUtils.getQ(this.W, this.S, this.stride_w, this.pad_w); + } + this.numThreads = numThreads; + } + + public boolean isOutputThreadSafe() { + return output.isThreadSafe(); + } + + public boolean isStride1Pad0() { + return (stride_h==1 && stride_w==1 + && pad_h==0 && pad_w==0); + } + + public boolean isAllOnes(Integer...params) { + boolean ret = true; + for(int param : params) + ret &= (param == 1); + return ret; + } +} http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNN.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNN.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNN.java index 8a59414..963bfbf 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNN.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNN.java @@ -34,7 +34,7 @@ import org.apache.sysml.runtime.DMLRuntimeException; import org.apache.sysml.runtime.functionobjects.KahanPlus; import org.apache.sysml.runtime.instructions.cp.KahanObject; import org.apache.sysml.runtime.util.CommonThreadPool; -import org.apache.sysml.runtime.util.ConvolutionUtils; +import org.apache.sysml.runtime.util.DnnUtils; /* * This class allows users to invoke deep learning related operations @@ -144,7 +144,7 @@ public class LibMatrixDNN { * @param outputBlock output of convolution * @param params convolution parameters */ - public static void conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, DnnParameters params) { LibMatrixDNN.checkInputsConv2d(input, filter, outputBlock, params); if(params.bias != null && params.bias.isInSparseFormat()) params.bias.sparseToDense(); // Since bias is extremely small array @@ -165,7 +165,7 @@ public class LibMatrixDNN { * @param params convolution parameters */ - public static void conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { checkInputsConv2dBackwardData(filter, dout, outputBlock, params); long nnz = execute(LibMatrixDNNConv2d.getConv2dBackwardDataWorkers(params), params); @@ -183,7 +183,7 @@ public class LibMatrixDNN { * @param outputBlock output errors * @param params convolution parameters */ - public static void conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { checkInputsConv2dBackwardFilter(input, dout, outputBlock, params); execute(LibMatrixDNNConv2d.getConv2dBackwardFilterWorkers(params), params); @@ -193,7 +193,7 @@ public class LibMatrixDNN { outputBlock.examSparsity(); } - public static void pooling(MatrixBlock input, MatrixBlock output, ConvolutionParameters params, PoolingType poolType) { + public static void pooling(MatrixBlock input, MatrixBlock output, DnnParameters params, PoolingType poolType) { params.input1 = input; params.output = output; @@ -225,7 +225,7 @@ public class LibMatrixDNN { * @param poolType type of pooling */ public static void poolingBackward(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, - ConvolutionParameters params, boolean performReluBackward, PoolingType poolType) { + DnnParameters params, boolean performReluBackward, PoolingType poolType) { params.input1 = input; params.input2 = dout; params.output = outputBlock; @@ -272,7 +272,7 @@ public class LibMatrixDNN { */ public static void reluBackward(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, int numThreads) { int N = input.getNumRows(); - ConvolutionParameters params = new ConvolutionParameters(N, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, numThreads); + DnnParameters params = new DnnParameters(N, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, numThreads); params.input1 = input; params.input2 = dout; params.output = outputBlock; @@ -311,7 +311,7 @@ public class LibMatrixDNN { double [] outputArray = outputBlock.getDenseBlockValues(); if(input.isEmptyBlock()) { for(int n = 0; n < N; n++) - ConvolutionUtils.fillBias(bias, outputArray, n, n+1, N, K, PQ); + DnnUtils.fillBias(bias, outputArray, n, n+1, N, K, PQ); } else { // Handles both dense and sparse inputs and copies it to dense output @@ -671,7 +671,7 @@ public class LibMatrixDNN { int K = bias.getNumRows(); int PQ = input.getNumColumns() / K; - ConvolutionParameters params = new ConvolutionParameters(N, PQ, -1, -1, K, -1, -1, -1, -1, -1, -1, numThreads); + DnnParameters params = new DnnParameters(N, PQ, -1, -1, K, -1, -1, -1, -1, -1, -1, numThreads); params.input1 = input; params.input2 = bias; params.output = outputBlock; @@ -739,7 +739,7 @@ public class LibMatrixDNN { * @param tasks deep learning related tasks * @param params convolution parameters */ - private static long execute(ArrayList<Callable<Long>> tasks, ConvolutionParameters params) { + private static long execute(ArrayList<Callable<Long>> tasks, DnnParameters params) { int k = OptimizerUtils.getConstrainedNumThreads(params.numThreads); long lnnz = 0; try { @@ -774,7 +774,7 @@ public class LibMatrixDNN { throw new DMLRuntimeException(msg + ":" + lhs + " != (" + rhs1 + " * " + rhs2 + " * " + rhs3); } - static void checkInputsConv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + static void checkInputsConv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { params.input1 = filter; params.input2 = dout; params.output = outputBlock; @@ -799,7 +799,7 @@ public class LibMatrixDNN { } } - static void checkInputsConv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + static void checkInputsConv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { params.input1 = input; params.input2 = dout; params.output = outputBlock; @@ -824,7 +824,7 @@ public class LibMatrixDNN { } } - static void checkInputsConv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, ConvolutionParameters params) { + static void checkInputsConv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, DnnParameters params) { params.input1 = input; params.input2 = filter; params.output = outputBlock; @@ -856,7 +856,7 @@ public class LibMatrixDNN { * * @param params parameters required for max_pool and max_pool_backward operations */ - private static void fillIndexesArray(ConvolutionParameters params) { + private static void fillIndexesArray(DnnParameters params) { params.start_indexes_h = new int[params.P]; params.end_indexes_h = new int[params.P]; params.start_indexes_w = new int[params.Q]; http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNConv2d.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNConv2d.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNConv2d.java index 4221ace..b938a0a 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNConv2d.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNConv2d.java @@ -40,7 +40,7 @@ public class LibMatrixDNNConv2d * @param params convolution parameters * @return list of callable tasks for performing conv2d */ - public static ArrayList<Callable<Long>> getConv2dWorkers(ConvolutionParameters params) { + public static ArrayList<Callable<Long>> getConv2dWorkers(DnnParameters params) { ArrayList<Callable<Long>> ret = new ArrayList<>(); // Try to create twice as many tasks as threads for improved load balance @@ -85,7 +85,7 @@ public class LibMatrixDNNConv2d * @param params convolution parameters * @return list of callable tasks for performing conv2d backward filter */ - public static ArrayList<Callable<Long>> getConv2dBackwardFilterWorkers(ConvolutionParameters params) { + public static ArrayList<Callable<Long>> getConv2dBackwardFilterWorkers(DnnParameters params) { ArrayList<Callable<Long>> ret = new ArrayList<>(); // Try to create as many tasks as threads. // Creating more tasks will help in tail, but would have additional overhead of maintaining the intermediate @@ -121,7 +121,7 @@ public class LibMatrixDNNConv2d * @param params convolution parameters * @return list of callable tasks for performing conv2d backward data */ - public static ArrayList<Callable<Long>> getConv2dBackwardDataWorkers(ConvolutionParameters params) { + public static ArrayList<Callable<Long>> getConv2dBackwardDataWorkers(DnnParameters params) { ArrayList<Callable<Long>> ret = new ArrayList<>(); // Try to create as many tasks as threads. @@ -157,9 +157,9 @@ public class LibMatrixDNNConv2d private static class LoopedIm2ColConv2dAllChan implements Callable<Long> { protected final int _rl, _ru; - protected final ConvolutionParameters _params; + protected final DnnParameters _params; - public LoopedIm2ColConv2dAllChan(int rl, int ru, ConvolutionParameters params) { + public LoopedIm2ColConv2dAllChan(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -254,7 +254,7 @@ public class LibMatrixDNNConv2d */ private static class LoopedIm2ColConv2dTransAllChan extends LoopedIm2ColConv2dAllChan { - public LoopedIm2ColConv2dTransAllChan(int rl, int ru, ConvolutionParameters params) { + public LoopedIm2ColConv2dTransAllChan(int rl, int ru, DnnParameters params) { super(rl, ru, params); } @@ -327,8 +327,8 @@ public class LibMatrixDNNConv2d private static class SparseNativeConv2d implements Callable<Long> { public final int _rl, _ru; - private final ConvolutionParameters _params; - public SparseNativeConv2d(int rl, int ru, ConvolutionParameters params) { + private final DnnParameters _params; + public SparseNativeConv2d(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -363,8 +363,8 @@ public class LibMatrixDNNConv2d private static class SparseNativeConv2dBackwardDataDense implements Callable<Long> { public final int _rl, _ru; - private final ConvolutionParameters _params; - public SparseNativeConv2dBackwardDataDense(int rl, int ru, ConvolutionParameters params) { + private final DnnParameters _params; + public SparseNativeConv2dBackwardDataDense(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -395,8 +395,8 @@ public class LibMatrixDNNConv2d private static class Conv2dBackwardData implements Callable<Long> { public final int _rl, _ru; - private final ConvolutionParameters _params; - public Conv2dBackwardData(int rl, int ru, ConvolutionParameters params) { + private final DnnParameters _params; + public Conv2dBackwardData(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -448,8 +448,8 @@ public class LibMatrixDNNConv2d private static class SparseNativeConv2dBackwardFilterDense implements Callable<Long> { public final int _rl, _ru; - private final ConvolutionParameters _params; - public SparseNativeConv2dBackwardFilterDense(int rl, int ru, ConvolutionParameters params) { + private final DnnParameters _params; + public SparseNativeConv2dBackwardFilterDense(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -487,9 +487,9 @@ public class LibMatrixDNNConv2d */ private static class Conv2dBackwardFilter implements Callable<Long> { private final int _rl, _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; - public Conv2dBackwardFilter(int rl, int ru, ConvolutionParameters params) { + public Conv2dBackwardFilter(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -539,9 +539,9 @@ public class LibMatrixDNNConv2d private static class Conv2dBackwardFilterTrans implements Callable<Long> { private final int _rl, _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; - public Conv2dBackwardFilterTrans(int rl, int ru, ConvolutionParameters params) { + public Conv2dBackwardFilterTrans(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } @@ -590,13 +590,13 @@ public class LibMatrixDNNConv2d } } - private static void inplaceAdd(double[] a, ConvolutionParameters params) { + private static void inplaceAdd(double[] a, DnnParameters params) { synchronized (params.output.denseBlock) { LibMatrixMult.vectAdd(a, params.output.getDenseBlockValues(), 0, 0, a.length); } } - private static void inplaceTransAdd(double[] a, ConvolutionParameters params) { + private static void inplaceTransAdd(double[] a, DnnParameters params) { synchronized (params.output.denseBlock) { // Perform transposed addition: output of size [K, CRS] += input of size [CRS,K] double [] c = params.output.getDenseBlockValues(); @@ -646,20 +646,20 @@ public class LibMatrixDNNConv2d // ---------------------------------------------------------------------------------------------- // TODO: Support sparse native convolution operations without dense intermediates + dense matmult // Currently, it will fall back to more optimized sparse Java-based operators. - private static boolean isEligibleForConv2dBackwardFilterSparseDense(ConvolutionParameters params) { + private static boolean isEligibleForConv2dBackwardFilterSparseDense(DnnParameters params) { // NativeHelper.conv2dBackwardFilterSparseDense only if input is sparse. // dout converted to dense if sparse. // return params.enableNative && params.input1.isInSparseFormat(); return false; } - private static boolean isEligibleForConv2dSparse(ConvolutionParameters params) { + private static boolean isEligibleForConv2dSparse(DnnParameters params) { // NativeHelper.conv2dSparse only if filter is dense and input is sparse // return params.enableNative && params.input1.isInSparseFormat() && !params.input2.isInSparseFormat(); return false; } - private static boolean isEligibleForConv2dBackwardDataDense(ConvolutionParameters params) { + private static boolean isEligibleForConv2dBackwardDataDense(DnnParameters params) { // NativeHelper.conv2dBackwardDataDense only if filter is dense. // dout converted to dense if sparse. // return params.enableNative && !params.input1.isInSparseFormat(); http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNHelper.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNHelper.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNHelper.java index 6d92313..af3fcec 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNHelper.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNHelper.java @@ -57,7 +57,7 @@ public class LibMatrixDNNHelper } protected static void singleThreadedMatMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, - boolean recomputeNNZM1, boolean recomputeNNZM2, ConvolutionParameters params) { + boolean recomputeNNZM1, boolean recomputeNNZM2, DnnParameters params) { if( !params.enableNative || m1.sparse || m2.sparse ) { prepNonZerosForMatrixMult(m1, recomputeNNZM1); prepNonZerosForMatrixMult(m2, recomputeNNZM2); http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNIm2Col.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNIm2Col.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNIm2Col.java index 65f53d9..d344c93 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNIm2Col.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNIm2Col.java @@ -28,7 +28,7 @@ import org.apache.sysml.runtime.matrix.data.LibMatrixDNNHelper.CellIndex3; */ public class LibMatrixDNNIm2Col { - public static void im2col(MatrixBlock in, MatrixBlock out, int r, ConvolutionParameters params, boolean trans) { + public static void im2col(MatrixBlock in, MatrixBlock out, int r, DnnParameters params, boolean trans) { im2col(in, out, r, params.C, params.R, params.S, params.H, params.W, params.P, params.Q, params.stride_h, params.stride_w, params.pad_h, params.pad_w, trans); } @@ -193,7 +193,7 @@ public class LibMatrixDNNIm2Col // Therefore, it is provided as utility function rather than an operator (like im2col or rotate180) //Converts input: PQ X CRS matrix and writes to 1 X CHW - public static void col2imOverSingleImage(int outputN, MatrixBlock input, ConvolutionParameters params) { + public static void col2imOverSingleImage(int outputN, MatrixBlock input, DnnParameters params) { if(input.rlen != params.P*params.Q || input.clen != params.C*params.R*params.S) { throw new DMLRuntimeException("Incorrect input dimensions"); } @@ -242,7 +242,7 @@ public class LibMatrixDNNIm2Col // Converts input: PQ X CRS matrix and writes to 1 X CHW if inputN == 0 // Or converts input: NPQ X CRS matrix and writes to N X CHW - private static void col2IMDenseInput(int inputN, int outputN, double [] inputArray, double [] outputArray, ConvolutionParameters params) { + private static void col2IMDenseInput(int inputN, int outputN, double [] inputArray, double [] outputArray, DnnParameters params) { final int outputNOffset = outputN*params.C*params.H*params.W; final int HW = params.H*params.W; final int inputNPQ = inputN*params.P*params.Q; http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNPooling.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNPooling.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNPooling.java index 9e3d8f8..29f949e 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNPooling.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNPooling.java @@ -43,7 +43,7 @@ public class LibMatrixDNNPooling { * @param poolType type of pooling * @return list of callable tasks for performing pooling operation */ - public static ArrayList<Callable<Long>> getPoolingWorkers(ConvolutionParameters params, PoolingType poolType) { + public static ArrayList<Callable<Long>> getPoolingWorkers(DnnParameters params, PoolingType poolType) { ArrayList<Callable<Long>> ret = new ArrayList<>(); // Try to create twice as many tasks as threads for improved load balance int k = OptimizerUtils.getConstrainedNumThreads(params.numThreads); @@ -65,7 +65,7 @@ public class LibMatrixDNNPooling { * @param poolType type of pooling operation to perform * @return list of callable tasks for performing maxpooling backward operation */ - public static ArrayList<Callable<Long>> getPoolingBackwardWorkers(ConvolutionParameters params, boolean performReluBackward, PoolingType poolType) { + public static ArrayList<Callable<Long>> getPoolingBackwardWorkers(DnnParameters params, boolean performReluBackward, PoolingType poolType) { ArrayList<Callable<Long>> ret = new ArrayList<>(); // Try to create twice as many tasks as threads for improved load balance int k = OptimizerUtils.getConstrainedNumThreads(params.numThreads); @@ -99,12 +99,12 @@ public class LibMatrixDNNPooling { private static class DensePooling implements Callable<Long> { private final int _rl, _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; private final PoolingType _poolingType; private final double _poolingMultiplier; - public DensePooling(int rl, int ru, ConvolutionParameters params, PoolingType poolingType) { + public DensePooling(int rl, int ru, DnnParameters params, PoolingType poolingType) { _rl = rl; _ru = ru; _params = params; _poolingType = poolingType; @@ -191,13 +191,13 @@ public class LibMatrixDNNPooling { private static class SparsePooling implements Callable<Long> { private final int _rl, _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; private double [] outputArray; private final int C, P, Q, W, H, CPQ, PQ; private final PoolingType _poolingType; private final double _poolingMultiplier; - public SparsePooling(int rl, int ru, ConvolutionParameters params, PoolingType poolingType) { + public SparsePooling(int rl, int ru, DnnParameters params, PoolingType poolingType) { _rl = rl; _ru = ru; _params = params; outputArray = params.output.getDenseBlockValues(); @@ -285,12 +285,12 @@ public class LibMatrixDNNPooling { private static class AvgPoolingBackwardDense implements Callable<Long> { public int _rl; public int _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; double [] doutArray; MatrixBlock output; final int C; final int CHW; final int P; final int Q; final int HW; final int CPQ; final int PQ; final double _poolingMultiplier; - public AvgPoolingBackwardDense(int rl, int ru, ConvolutionParameters params) { + public AvgPoolingBackwardDense(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; doutArray = params.input2.getDenseBlockValues(); @@ -336,12 +336,12 @@ public class LibMatrixDNNPooling { private static class PoolingBackwardDenseDense implements Callable<Long> { public int _rl; public int _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; boolean performReluBackward; double [] inputArray, doutArray; MatrixBlock output; int C; int CHW; int P; int Q; int HW; int CPQ; int PQ; - public PoolingBackwardDenseDense(int rl, int ru, ConvolutionParameters params, boolean performReluBackward) { + public PoolingBackwardDenseDense(int rl, int ru, DnnParameters params, boolean performReluBackward) { _rl = rl; _ru = ru; _params = params; this.performReluBackward = performReluBackward; @@ -382,12 +382,12 @@ public class LibMatrixDNNPooling { private static class PoolingBackwardDenseSparse implements Callable<Long> { public int _rl; public int _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; MatrixBlock output; boolean performReluBackward; double [] inputArray; MatrixBlock dout; int CHW; int P; int Q; int HW; - public PoolingBackwardDenseSparse(int rl, int ru, ConvolutionParameters params, boolean performReluBackward) { + public PoolingBackwardDenseSparse(int rl, int ru, DnnParameters params, boolean performReluBackward) { _rl = rl; _ru = ru; _params = params; this.performReluBackward = performReluBackward; @@ -433,11 +433,11 @@ public class LibMatrixDNNPooling { private static class AvgPoolingBackwardSparse implements Callable<Long> { public int _rl; public int _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; MatrixBlock output; MatrixBlock dout; int CHW; int P; int Q; int HW; final double _poolingMultiplier; - public AvgPoolingBackwardSparse(int rl, int ru, ConvolutionParameters params) { + public AvgPoolingBackwardSparse(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; dout = params.input2; @@ -488,11 +488,11 @@ public class LibMatrixDNNPooling { private static class PoolingBackwardSparseDense implements Callable<Long> { private final int _rl, _ru; - private final ConvolutionParameters _params; + private final DnnParameters _params; private final boolean reluBack; protected final MatrixBlock doutput, output; - protected PoolingBackwardSparseDense(int rl, int ru, ConvolutionParameters params, boolean relu, MatrixBlock dout, MatrixBlock out) { + protected PoolingBackwardSparseDense(int rl, int ru, DnnParameters params, boolean relu, MatrixBlock dout, MatrixBlock out) { _rl = rl; _ru = ru; _params = params; reluBack = relu; @@ -500,7 +500,7 @@ public class LibMatrixDNNPooling { output = out; } - public PoolingBackwardSparseDense(int rl, int ru, ConvolutionParameters params, boolean relu) { + public PoolingBackwardSparseDense(int rl, int ru, DnnParameters params, boolean relu) { this(rl, ru, params, relu, params.input2, params.output); if (doutput.getDenseBlock() == null || output.getDenseBlock() == null ) throw new RuntimeException("Incorrect usage: empty inputs"); @@ -623,7 +623,7 @@ public class LibMatrixDNNPooling { */ private static class PoolingBackwardSparseSparse extends PoolingBackwardSparseDense { - public PoolingBackwardSparseSparse(int rl, int ru, ConvolutionParameters params, boolean relu) { + public PoolingBackwardSparseSparse(int rl, int ru, DnnParameters params, boolean relu) { super(rl, ru, params, relu, params.input2, params.output); if (output.getDenseBlock() == null ) throw new RuntimeException("Incorrect usage: empty outputs"); @@ -680,7 +680,7 @@ public class LibMatrixDNNPooling { * @param performReluBackward perform ReLU backward * @return index of cell with maximum value */ - private static int getMaxIndex(int p, int q, int inputOffset, double [] inputArray, ConvolutionParameters params, boolean performReluBackward) { + private static int getMaxIndex(int p, int q, int inputOffset, double [] inputArray, DnnParameters params, boolean performReluBackward) { int start_index_h = params.start_indexes_h[p]; int end_index_h = params.end_indexes_h[p]; int start_index_w = params.start_indexes_w[q]; http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRelu.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRelu.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRelu.java index bb0fcf1..9cfb5af 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRelu.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRelu.java @@ -34,7 +34,7 @@ public class LibMatrixDNNRelu * @param params convolution parameters * @return list of callable tasks for performing relu backward operation */ - public static ArrayList<Callable<Long>> getReluBackwardWorkers(ConvolutionParameters params) { + public static ArrayList<Callable<Long>> getReluBackwardWorkers(DnnParameters params) { ArrayList<Callable<Long>> ret = new ArrayList<>(); int k = OptimizerUtils.getConstrainedNumThreads(params.numThreads); int taskSize = (int)(Math.ceil((double)params.N / k)); @@ -49,8 +49,8 @@ public class LibMatrixDNNRelu public static class ReluBackward implements Callable<Long> { public final int _rl, _ru; - private final ConvolutionParameters _params; - public ReluBackward(int rl, int ru, ConvolutionParameters params) { + private final DnnParameters _params; + public ReluBackward(int rl, int ru, DnnParameters params) { _rl = rl; _ru = ru; _params = params; } http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRotate180.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRotate180.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRotate180.java index f4921c4..9d55259 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRotate180.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixDNNRotate180.java @@ -28,7 +28,7 @@ public class LibMatrixDNNRotate180 public static interface Rotate180Worker { public void execute(int inputN, int outputN); public static Rotate180Worker getWorker(MatrixBlock in, MatrixBlock out, - ConvolutionParameters params, boolean zeroOutSparseOutput, boolean trans) { + DnnParameters params, boolean zeroOutSparseOutput, boolean trans) { return in.isInSparseFormat() ? new SparseRotate180Worker(in, out, params, trans) : new DenseRotate180Worker(in, out, params); @@ -40,8 +40,8 @@ public class LibMatrixDNNRotate180 */ private static class DenseRotate180Worker implements Rotate180Worker { private final DenseBlock in, out; - private final ConvolutionParameters params; - public DenseRotate180Worker(MatrixBlock input, MatrixBlock output, ConvolutionParameters params) { + private final DnnParameters params; + public DenseRotate180Worker(MatrixBlock input, MatrixBlock output, DnnParameters params) { this.in = input.getDenseBlock(); this.out = output.getDenseBlock(); this.params = params; @@ -68,11 +68,11 @@ public class LibMatrixDNNRotate180 */ private static class SparseRotate180Worker implements Rotate180Worker { private final MatrixBlock in, out; - private final ConvolutionParameters params; + private final DnnParameters params; private final boolean trans; public SparseRotate180Worker(MatrixBlock input, MatrixBlock output, - ConvolutionParameters params, boolean trans) { + DnnParameters params, boolean trans) { this.in = input; this.out = output; this.params = params; http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixNative.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixNative.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixNative.java index 5fd642e..aa5ba86 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixNative.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixNative.java @@ -153,7 +153,7 @@ public class LibMatrixNative * @param outputBlock output of convolution * @param params convolution parameters */ - public static void conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, DnnParameters params) { LibMatrixDNN.checkInputsConv2d(input, filter, outputBlock, params); params.numThreads = params.numThreads <= 0 ? NativeHelper.getMaxNumThreads() : params.numThreads; if(NativeHelper.isNativeLibraryLoaded() && !input.isInSparseFormat() && !filter.isInSparseFormat()) { @@ -215,7 +215,7 @@ public class LibMatrixNative LibMatrixDNN.conv2d(input, filter, outputBlock, params); } - private static void setNumThreads(ConvolutionParameters params) { + private static void setNumThreads(DnnParameters params) { params.numThreads = OptimizerUtils.getConstrainedNumThreads(params.numThreads); if (!(params.isOutputThreadSafe() && params.numThreads > 1)) params.numThreads = 1; @@ -229,7 +229,7 @@ public class LibMatrixNative * @param outputBlock output errors * @param params convolution parameters */ - public static void conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { LibMatrixDNN.checkInputsConv2dBackwardFilter(input, dout, outputBlock, params); params.numThreads = params.numThreads <= 0 ? NativeHelper.getMaxNumThreads() : params.numThreads; if(NativeHelper.isNativeLibraryLoaded() && !dout.isInSparseFormat() && !input.isInSparseFormat()) { @@ -265,7 +265,7 @@ public class LibMatrixNative * @param outputBlock output errors * @param params convolution parameters */ - public static void conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, ConvolutionParameters params) { + public static void conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params) { LibMatrixDNN.checkInputsConv2dBackwardData(filter, dout, outputBlock, params); params.numThreads = params.numThreads <= 0 ? NativeHelper.getMaxNumThreads() : params.numThreads; if(NativeHelper.isNativeLibraryLoaded() && !dout.isInSparseFormat() && !filter.isInSparseFormat()) { http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/util/ConvolutionUtils.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/util/ConvolutionUtils.java b/src/main/java/org/apache/sysml/runtime/util/ConvolutionUtils.java deleted file mode 100644 index bf66681..0000000 --- a/src/main/java/org/apache/sysml/runtime/util/ConvolutionUtils.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ - -package org.apache.sysml.runtime.util; - -import java.util.Arrays; - -import org.apache.sysml.runtime.matrix.data.MatrixBlock; - - -public class ConvolutionUtils { - - public static String getConv2dOutputMap(String H, String R, String verticalStride, String heightPadding) { - long padX2 = -1; - try { - padX2 = Long.parseLong(heightPadding)*2; - return "" + getP(Long.parseLong(H), Long.parseLong(R), Long.parseLong(verticalStride), Long.parseLong(heightPadding)); - } catch(Exception e) { - if(padX2 == -1) return "((" + H + " + 2*" + heightPadding + " - " + R + ") / " + verticalStride + "+ 1)"; - else if(padX2 == 0) return "((" + H + " - " + R + ") / " + verticalStride + "+ 1)"; - else return "((" + H + " + " + padX2 + " - " + R + ") / " + verticalStride + "+ 1)"; - } - } - - public static long getP(long H, long R, long verticalStride, long heightPadding) { - if(H <= 0 || R <= 0 || heightPadding < 0 || verticalStride < 0) { - throw new RuntimeException("Incorrect parameters: height=" + H + " filter_height=" + R + " stride=" + verticalStride + " pad=" + heightPadding); - } - long padded_image_height = H + 2 * heightPadding; - long ret = (padded_image_height - R) / verticalStride + 1; - if(ret <= 0 || ret > Integer.MAX_VALUE) { - // Check for valid output activation height - if(padded_image_height < R) - throw new RuntimeException("Incorrect parameters: padded image height:" + padded_image_height + " cannot be less than filter_height:" + R); - else - throw new RuntimeException("Incorrect parameters: height=" + H + " filter_height=" + R + " stride=" + verticalStride + " pad=" + heightPadding + " as P=" + ret); - } - return ret; - } - public static long getQ(long W, long S, long horizontalStride, long widthPadding) { - if(W <= 0 || S <= 0 || widthPadding < 0 || horizontalStride < 0) { - throw new RuntimeException("Incorrect parameters: width=" + W + " filter_width=" + S + " stride=" + horizontalStride + " pad=" + widthPadding); - } - long padded_image_width = W + 2 * widthPadding; - long ret = (padded_image_width - S) / horizontalStride + 1; - if(ret <= 0 || ret > Integer.MAX_VALUE) { - // Check for valid output activation width - if(padded_image_width < S) - throw new RuntimeException("Incorrect parameters: padded image width:" + padded_image_width + " cannot be less than filter width:" + S); - else - throw new RuntimeException("Incorrect parameters: width=" + W + " filter_width=" + S + " stride=" + horizontalStride + " pad=" + widthPadding + " as Q=" + ret); - } - return ret; - } - - public static void fillBias(MatrixBlock bias, double [] outputArray, int src_rl, int src_ru, int N, int K, int PQ) { - // bias.getNumColumns() == 1 checked outside - if(bias.isInSparseFormat()) { - for(int k = 0; k < K; k++) { - if( !bias.getSparseBlock().isEmpty(k) ) { - int apos = bias.getSparseBlock().pos(k); - double[] avals = bias.getSparseBlock().values(k); - double val = avals[apos]; - for(int n = src_rl; n < src_ru; n++) { - int fromIndex = n*K*PQ + k*PQ; - Arrays.fill(outputArray, fromIndex, fromIndex + PQ, val); - } - } - } - } - else { - double [] biasArr = bias.getDenseBlockValues(); - for(int n = src_rl; n < src_ru; n++) { - for(int k = 0; k < K; k++) { - int fromIndex = n*K*PQ + k*PQ; - double val = biasArr[k]; - Arrays.fill(outputArray, fromIndex, fromIndex + PQ, val); - } - } - } - } - -} http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/runtime/util/DnnUtils.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/util/DnnUtils.java b/src/main/java/org/apache/sysml/runtime/util/DnnUtils.java new file mode 100644 index 0000000..b1a4c5f --- /dev/null +++ b/src/main/java/org/apache/sysml/runtime/util/DnnUtils.java @@ -0,0 +1,99 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.sysml.runtime.util; + +import java.util.Arrays; + +import org.apache.sysml.runtime.matrix.data.MatrixBlock; + + +public class DnnUtils { + + public static String getConv2dOutputMap(String H, String R, String verticalStride, String heightPadding) { + long padX2 = -1; + try { + padX2 = Long.parseLong(heightPadding)*2; + return "" + getP(Long.parseLong(H), Long.parseLong(R), Long.parseLong(verticalStride), Long.parseLong(heightPadding)); + } catch(Exception e) { + if(padX2 == -1) return "((" + H + " + 2*" + heightPadding + " - " + R + ") / " + verticalStride + "+ 1)"; + else if(padX2 == 0) return "((" + H + " - " + R + ") / " + verticalStride + "+ 1)"; + else return "((" + H + " + " + padX2 + " - " + R + ") / " + verticalStride + "+ 1)"; + } + } + + public static long getP(long H, long R, long verticalStride, long heightPadding) { + if(H <= 0 || R <= 0 || heightPadding < 0 || verticalStride < 0) { + throw new RuntimeException("Incorrect parameters: height=" + H + " filter_height=" + R + " stride=" + verticalStride + " pad=" + heightPadding); + } + long padded_image_height = H + 2 * heightPadding; + long ret = (padded_image_height - R) / verticalStride + 1; + if(ret <= 0 || ret > Integer.MAX_VALUE) { + // Check for valid output activation height + if(padded_image_height < R) + throw new RuntimeException("Incorrect parameters: padded image height:" + padded_image_height + " cannot be less than filter_height:" + R); + else + throw new RuntimeException("Incorrect parameters: height=" + H + " filter_height=" + R + " stride=" + verticalStride + " pad=" + heightPadding + " as P=" + ret); + } + return ret; + } + public static long getQ(long W, long S, long horizontalStride, long widthPadding) { + if(W <= 0 || S <= 0 || widthPadding < 0 || horizontalStride < 0) { + throw new RuntimeException("Incorrect parameters: width=" + W + " filter_width=" + S + " stride=" + horizontalStride + " pad=" + widthPadding); + } + long padded_image_width = W + 2 * widthPadding; + long ret = (padded_image_width - S) / horizontalStride + 1; + if(ret <= 0 || ret > Integer.MAX_VALUE) { + // Check for valid output activation width + if(padded_image_width < S) + throw new RuntimeException("Incorrect parameters: padded image width:" + padded_image_width + " cannot be less than filter width:" + S); + else + throw new RuntimeException("Incorrect parameters: width=" + W + " filter_width=" + S + " stride=" + horizontalStride + " pad=" + widthPadding + " as Q=" + ret); + } + return ret; + } + + public static void fillBias(MatrixBlock bias, double [] outputArray, int src_rl, int src_ru, int N, int K, int PQ) { + // bias.getNumColumns() == 1 checked outside + if(bias.isInSparseFormat()) { + for(int k = 0; k < K; k++) { + if( !bias.getSparseBlock().isEmpty(k) ) { + int apos = bias.getSparseBlock().pos(k); + double[] avals = bias.getSparseBlock().values(k); + double val = avals[apos]; + for(int n = src_rl; n < src_ru; n++) { + int fromIndex = n*K*PQ + k*PQ; + Arrays.fill(outputArray, fromIndex, fromIndex + PQ, val); + } + } + } + } + else { + double [] biasArr = bias.getDenseBlockValues(); + for(int n = src_rl; n < src_ru; n++) { + for(int k = 0; k < K; k++) { + int fromIndex = n*K*PQ + k*PQ; + double val = biasArr[k]; + Arrays.fill(outputArray, fromIndex, fromIndex + PQ, val); + } + } + } + } + +} http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/java/org/apache/sysml/utils/NativeHelper.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/utils/NativeHelper.java b/src/main/java/org/apache/sysml/utils/NativeHelper.java index 2cde065..3f200e6 100644 --- a/src/main/java/org/apache/sysml/utils/NativeHelper.java +++ b/src/main/java/org/apache/sysml/utils/NativeHelper.java @@ -333,17 +333,17 @@ public class NativeHelper { // TODO: case not handled: sparse filters (which will only be executed in Java). Since filters are relatively smaller, this is a low priority. // Returns -1 if failures or returns number of nonzeros - // Called by ConvolutionCPInstruction if both input and filter are dense + // Called by DnnCPInstruction if both input and filter are dense public static native int conv2dDense(double [] input, double [] filter, double [] ret, int N, int C, int H, int W, int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int P, int Q, int numThreads); public static native int dconv2dBiasAddDense(double [] input, double [] bias, double [] filter, double [] ret, int N, int C, int H, int W, int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int P, int Q, int numThreads); public static native int sconv2dBiasAddDense(FloatBuffer input, FloatBuffer bias, FloatBuffer filter, FloatBuffer ret, int N, int C, int H, int W, int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int P, int Q, int numThreads); - // Called by ConvolutionCPInstruction if both input and filter are dense + // Called by DnnCPInstruction if both input and filter are dense public static native int conv2dBackwardFilterDense(double [] input, double [] dout, double [] ret, int N, int C, int H, int W, int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int P, int Q, int numThreads); - // If both filter and dout are dense, then called by ConvolutionCPInstruction + // If both filter and dout are dense, then called by DnnCPInstruction // Else, called by LibMatrixDNN's thread if filter is dense. dout[n] is converted to dense if sparse. public static native int conv2dBackwardDataDense(double [] filter, double [] dout, double [] ret, int N, int C, int H, int W, int K, int R, int S, int stride_h, int stride_w, int pad_h, int pad_w, int P, int Q, int numThreads); http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/main/scala/org/apache/sysml/api/dl/CaffeLayer.scala ---------------------------------------------------------------------- diff --git a/src/main/scala/org/apache/sysml/api/dl/CaffeLayer.scala b/src/main/scala/org/apache/sysml/api/dl/CaffeLayer.scala index 869f1a1..d664f6e 100644 --- a/src/main/scala/org/apache/sysml/api/dl/CaffeLayer.scala +++ b/src/main/scala/org/apache/sysml/api/dl/CaffeLayer.scala @@ -24,7 +24,7 @@ import org.apache.sysml.parser.LanguageException import java.util.HashSet import java.io.File import org.apache.sysml.api.DMLScript -import org.apache.sysml.runtime.util.ConvolutionUtils +import org.apache.sysml.runtime.util.DnnUtils import caffe.Caffe.EltwiseParameter.EltwiseOp import org.apache.sysml.runtime.DMLRuntimeException; import java.util.ArrayList @@ -1069,8 +1069,8 @@ class MaxPooling(val param: LayerParameter, val id: Int, val net: CaffeNetwork) // ------------------------------------------------- def Hin = bottomLayerOutputShape._2 def Win = bottomLayerOutputShape._3 - def Hout = ConvolutionUtils.getConv2dOutputMap(bottomLayerOutputShape._2, kernel_h, stride_h, pad_h) - def Wout = ConvolutionUtils.getConv2dOutputMap(bottomLayerOutputShape._3, kernel_w, stride_w, pad_w) + def Hout = DnnUtils.getConv2dOutputMap(bottomLayerOutputShape._2, kernel_h, stride_h, pad_h) + def Wout = DnnUtils.getConv2dOutputMap(bottomLayerOutputShape._3, kernel_w, stride_w, pad_w) def poolingParam = param.getPoolingParam def numChannels = bottomLayerOutputShape._1 // kernel_size (or kernel_h and kernel_w): specifies height and width of each filter @@ -1306,8 +1306,8 @@ class Convolution(val param: LayerParameter, val id: Int, val net: CaffeNetwork) def numChannels = bottomLayerOutputShape._1 def Hin = bottomLayerOutputShape._2 def Win = bottomLayerOutputShape._3 - def Hout = ConvolutionUtils.getConv2dOutputMap(bottomLayerOutputShape._2, kernel_h, stride_h, pad_h) - def Wout = ConvolutionUtils.getConv2dOutputMap(bottomLayerOutputShape._3, kernel_w, stride_w, pad_w) + def Hout = DnnUtils.getConv2dOutputMap(bottomLayerOutputShape._2, kernel_h, stride_h, pad_h) + def Wout = DnnUtils.getConv2dOutputMap(bottomLayerOutputShape._3, kernel_w, stride_w, pad_w) // ------------------------------------------------- def convParam = param.getConvolutionParam // if depthwise (C, M*Hf*Wf) else (F, C*Hf*Wf) http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/test/java/org/apache/sysml/test/gpu/NeuralNetworkOpTests.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/sysml/test/gpu/NeuralNetworkOpTests.java b/src/test/java/org/apache/sysml/test/gpu/NeuralNetworkOpTests.java index d11af5e..1b978ea 100644 --- a/src/test/java/org/apache/sysml/test/gpu/NeuralNetworkOpTests.java +++ b/src/test/java/org/apache/sysml/test/gpu/NeuralNetworkOpTests.java @@ -24,7 +24,7 @@ import java.util.HashMap; import java.util.List; import org.apache.sysml.api.mlcontext.Matrix; -import org.apache.sysml.runtime.util.ConvolutionUtils; +import org.apache.sysml.runtime.util.DnnUtils; import org.apache.sysml.test.utils.TestUtils; import org.junit.Assert; import org.junit.Ignore; @@ -131,8 +131,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (R > (H + padH) || S > (W + padW)) continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * K * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -218,8 +218,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (R > (H + padH) || S > (W + padW)) Assert.fail(); - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * K * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -284,8 +284,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (filterSize > MAX_OP_SIZE) // filter size continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * K * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -367,8 +367,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (filterSize > MAX_OP_SIZE) // filter size continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * K * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -451,8 +451,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (poolSize > MAX_OP_SIZE) // filter size continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * C * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -529,8 +529,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (poolSize > MAX_OP_SIZE) // filter size continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * C * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size @@ -611,8 +611,8 @@ public class NeuralNetworkOpTests extends GPUTests { if (poolSize > MAX_OP_SIZE) // filter size continue; - int P = (int) ConvolutionUtils.getP(H, R, strideH, padH); - int Q = (int) ConvolutionUtils.getQ(W, S, strideW, padW); + int P = (int) DnnUtils.getP(H, R, strideH, padH); + int Q = (int) DnnUtils.getQ(W, S, strideW, padW); long doutSize = N * C * P * Q * 8l; if (doutSize > MAX_OP_SIZE) // dout/output size http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardDataTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardDataTest.java b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardDataTest.java index 8f01f06..b479b5e 100644 --- a/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardDataTest.java +++ b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardDataTest.java @@ -24,7 +24,7 @@ import org.apache.sysml.api.DMLScript; import org.apache.sysml.api.DMLScript.RUNTIME_PLATFORM; import org.apache.sysml.lops.LopProperties.ExecType; import org.apache.sysml.runtime.matrix.data.MatrixValue.CellIndex; -import org.apache.sysml.runtime.util.ConvolutionUtils; +import org.apache.sysml.runtime.util.DnnUtils; import org.apache.sysml.test.integration.AutomatedTestBase; import org.apache.sysml.test.integration.TestConfiguration; import org.apache.sysml.test.utils.TestUtils; @@ -157,7 +157,7 @@ public class Conv2DBackwardDataTest extends AutomatedTestBase String sparseVal1 = (""+sparse1).toUpperCase(); String sparseVal2 = (""+sparse2).toUpperCase(); - long P = ConvolutionUtils.getP(imgSize, filterSize, stride, pad); + long P = DnnUtils.getP(imgSize, filterSize, stride, pad); programArgs = new String[]{"-explain", "-args", "" + imgSize, "" + numImg, "" + numChannels, "" + numFilters, "" + filterSize, "" + stride, "" + pad, http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardTest.java b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardTest.java index 6a9528b..c45327c 100644 --- a/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardTest.java +++ b/src/test/java/org/apache/sysml/test/integration/functions/tensor/Conv2DBackwardTest.java @@ -24,7 +24,7 @@ import org.apache.sysml.api.DMLScript; import org.apache.sysml.api.DMLScript.RUNTIME_PLATFORM; import org.apache.sysml.lops.LopProperties.ExecType; import org.apache.sysml.runtime.matrix.data.MatrixValue.CellIndex; -import org.apache.sysml.runtime.util.ConvolutionUtils; +import org.apache.sysml.runtime.util.DnnUtils; import org.apache.sysml.test.integration.AutomatedTestBase; import org.apache.sysml.test.integration.TestConfiguration; import org.apache.sysml.test.utils.TestUtils; @@ -193,7 +193,7 @@ public class Conv2DBackwardTest extends AutomatedTestBase { String sparseVal1 = String.valueOf(sparse1).toUpperCase(); String sparseVal2 = String.valueOf(sparse2).toUpperCase(); - long P = ConvolutionUtils.getP(imgSize, filterSize, stride, pad); + long P = DnnUtils.getP(imgSize, filterSize, stride, pad); TestConfiguration config = getTestConfiguration(TEST_NAME); loadTestConfiguration(config); http://git-wip-us.apache.org/repos/asf/systemml/blob/9fa5a09b/src/test/java/org/apache/sysml/test/integration/functions/tensor/PoolBackwardTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/sysml/test/integration/functions/tensor/PoolBackwardTest.java b/src/test/java/org/apache/sysml/test/integration/functions/tensor/PoolBackwardTest.java index 2c661ec..f623666 100644 --- a/src/test/java/org/apache/sysml/test/integration/functions/tensor/PoolBackwardTest.java +++ b/src/test/java/org/apache/sysml/test/integration/functions/tensor/PoolBackwardTest.java @@ -24,7 +24,7 @@ import org.apache.sysml.api.DMLScript; import org.apache.sysml.api.DMLScript.RUNTIME_PLATFORM; import org.apache.sysml.lops.LopProperties.ExecType; import org.apache.sysml.runtime.matrix.data.MatrixValue.CellIndex; -import org.apache.sysml.runtime.util.ConvolutionUtils; +import org.apache.sysml.runtime.util.DnnUtils; import org.apache.sysml.test.integration.AutomatedTestBase; import org.apache.sysml.test.integration.TestConfiguration; import org.apache.sysml.test.utils.TestUtils; @@ -152,7 +152,7 @@ public class PoolBackwardTest extends AutomatedTestBase TestConfiguration config = getTestConfiguration(TEST_NAME); loadTestConfiguration(config); - long P = ConvolutionUtils.getP(imgSize, poolSize1, stride, pad); + long P = DnnUtils.getP(imgSize, poolSize1, stride, pad); String RI_HOME = SCRIPT_DIR + TEST_DIR; fullDMLScriptName = RI_HOME + TEST_NAME + ".dml";
