Refine search
long nSamples = labels.size(0); INDArray output = activationFn.getActivation(preOutput.dup(), false); INDArray gradient = Nd4j.zeros(nSamples, preOutput.columns()); INDArray dLdZMu = Nd4j.create(nSamples, mMixtures, mLabelWidth); for (int k = 0; k < mLabelWidth; k++) { dLdZMu.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.all(), NDArrayIndex.point(k)}, labelsMinusMu.get(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.all(), NDArrayIndex.point(k)}).muli(pi).divi(variance).negi()); dLdZMu = dLdZMu.reshape(nSamples, mMixtures * mLabelWidth); gradient.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.interval(0, mMixtures)}, dLdZAlpha); gradient.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.interval(mMixtures, mMixtures * 2)}, dLdZSigma); gradient.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.interval(mMixtures * 2, (mLabelWidth + 2) * mMixtures)}, dLdZMu); INDArray gradients = activationFn.backprop(preOutput, gradient).getFirst();
static INDArray resize(INDArray arr, int [] shape) { INDArray resized = Nd4j.create(shape); resized.get(NDArrayIndex.createCoveringShape(arr.shape())).assign(arr); return resized; }
static INDArrayIndex[] createIntervalOnDimension(int dimension, boolean inclusive, long... interval) { INDArrayIndex [] indexInterval = new INDArrayIndex[dimension + 1]; for(int i = 0; i <= dimension; i++) { indexInterval[i] = i != dimension ? NDArrayIndex.all() : NDArrayIndex.interval((int)interval[0], (int)interval[1], inclusive); } return indexInterval; } }
private void moveBackward(int index) { int numMoved = size - index - 1; INDArrayIndex[] first = new INDArrayIndex[] {NDArrayIndex.point(0), NDArrayIndex.interval(index ,index + numMoved)}; INDArrayIndex[] getRange = new INDArrayIndex[] {NDArrayIndex.point(0), NDArrayIndex.interval(index + 1 ,index + 1 + numMoved)}; INDArray get = container.get(getRange); container.put(first,get); }
private static INDArray getSubsetForExample(INDArray array, int idx) { //Note the interval use here: normally .point(idx) would be used, but this collapses the point dimension // when used on arrays with rank of 3 or greater //So (point,all,all) on a 3d input returns a 2d output. Whereas, we want a 3d [1,x,y] output here switch (array.rank()) { case 2: return array.get(NDArrayIndex.point(idx), NDArrayIndex.all()); case 3: return array.get(NDArrayIndex.interval(idx, idx, true), NDArrayIndex.all(), NDArrayIndex.all()); case 4: return array.get(NDArrayIndex.interval(idx, idx, true), NDArrayIndex.all(), NDArrayIndex.all(), NDArrayIndex.all()); default: throw new IllegalStateException("Cannot get subset for rank " + array.rank() + " array"); } }
INDArray r = R; if (Nd4j.dataType() != DataBuffer.Type.FLOAT) log.warn("FLOAT getrf called in DOUBLE environment"); INDArray tau = Nd4j.createArrayFromShapeBuffer(Nd4j.getDataBufferFactory().createFloat(N), Nd4j.getShapeInfoProvider().createShapeInformation(new int[] {1, N}).getFirst()); if (Nd4j.getExecutioner() instanceof GridExecutioner) (IntPointer) worksizeBuffer.addressPointer() // we intentionally use host pointer here ); throw new BlasException("cusolverDnSgeqrf_bufferSize failed", stat); int worksize = worksizeBuffer.getInt(0); Pointer workspace = new Workspace(worksize * Nd4j.sizeOfDataType()); r.assign( a.get( NDArrayIndex.interval( 0, a.columns() ), NDArrayIndex.all() ) ) ; for( int i=1 ; i<Math.min( a.rows(), a.columns() ) ; i++ ) { ix[0] = NDArrayIndex.point( i ) ; ix[1] = NDArrayIndex.interval( 0, i ) ; r.put(ix, 0) ;
INDArray oneDArray = Nd4j.create(new float[]{1,2,3,4,5,6} , new int[]{6}); print("One Dimensional Array", oneDArray); print("4x5 Random between zero and one", fourByFiveRandomZeroToOne); INDArray sixBySevenRandomZeroToHundred = Nd4j.rand(new int[] {6, 7}).mul(100); print("6x7 Random between zero and hundred", sixBySevenRandomZeroToHundred); int size = (int)fourByFiveRandomZeroToOne.length(); System.out.println("Array size: " + size); long[] shape = fourByFiveRandomZeroToOne.shape(); System.out.println("Array shape: " + Arrays.toString(shape)); print("Assigned value to array (1x3 => 10)", fourByFiveRandomZeroToOne); INDArray threeValuesArray = fourByFiveRandomZeroToOne.get(NDArrayIndex.interval(0, 3)); print("Get interval from array ([0:3])", threeValuesArray); INDArray threeValuesArrayColumnFour = fourByFiveRandomZeroToOne.get(NDArrayIndex.interval(0, 3), NDArrayIndex.point(4)); print("Get interval from array ([0:3,4])", threeValuesArrayColumnFour); INDArray threeValuesArrayAgain = fourByFiveRandomZeroToOne.get(NDArrayIndex.interval(0, 2)); print("Get interval from array ([:2])", threeValuesArrayAgain); INDArray allRowsIndexOne = fourByFiveRandomZeroToOne.get(NDArrayIndex.all(), NDArrayIndex.point(1)); print("Get interval from array ([:,1])", allRowsIndexOne);
INDArray a = A; if (Nd4j.dataType() != DataBuffer.Type.FLOAT) log.warn("DOUBLE potrf called in FLOAT environment"); if (A.ordering() == 'c') a = A.dup('f'); if (Nd4j.getExecutioner() instanceof GridExecutioner) ((GridExecutioner) Nd4j.getExecutioner()).flushQueue(); int worksize = worksizeBuffer.getInt(0); Pointer workspace = new Workspace(worksize * Nd4j.sizeOfDataType()); A.assign(a); INDArrayIndex ix[] = new INDArrayIndex[ 2 ] ; for( int i=1 ; i<Math.min( A.rows(), A.columns() ) ; i++ ) { ix[0] = NDArrayIndex.point( i ) ; ix[1] = NDArrayIndex.interval( 0, i ) ; A.put(ix, 0) ; INDArrayIndex ix[] = new INDArrayIndex[ 2 ] ; for( int i=0 ; i<Math.min( A.rows(), A.columns()-1 ) ; i++ ) { ix[0] = NDArrayIndex.point( i ) ; ix[1] = NDArrayIndex.interval( i+1, A.columns() ) ; A.put(ix, 0) ;
INDArray sorted = Nd4j.sortRows(pl, 0, false); INDArray isPositive = sorted.getColumn(1); INDArray cumSumPos = isPositive.cumsum(-1); int length = sorted.size(0); INDArray t = Nd4j.create(new int[] {length + 2, 1}); t.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, sorted.getColumn(0)); INDArray linspace = Nd4j.linspace(1, length, length); INDArray precision = cumSumPos.div(linspace.reshape(cumSumPos.shape())); INDArray prec = Nd4j.create(new int[] {length + 2, 1}); prec.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, precision); INDArray rec = Nd4j.create(new int[] {length + 2, 1}); rec.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, cumSumPos.div(countActualPositive)); rec.putScalar(length + 1, 0, 1.0); thresholdOut = t.data().asDouble(); precisionOut = prec.data().asDouble(); recallOut = rec.data().asDouble();
@Override public void setStateViewArray(INDArray viewArray, long[] gradientShape, char gradientOrder, boolean initialize) { if (!viewArray.isRowVector()) throw new IllegalArgumentException("Invalid input: expect row vector input"); if (initialize) viewArray.assign(0); long length = viewArray.length(); this.msg = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2)); this.msdx = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length)); //Reshape to match the expected shape of the input gradient arrays this.msg = Shape.newShapeNoCopy(this.msg, gradientShape, gradientOrder == 'f'); this.msdx = Shape.newShapeNoCopy(this.msdx, gradientShape, gradientOrder == 'f'); if (msg == null || msdx == null) throw new IllegalStateException("Could not correctly reshape gradient view arrays"); }
private void growCapacity(int idx) { if(container == null) { container = Nd4j.create(10); } else if(idx >= container.length()) { val max = Math.max(container.length() * 2,idx); INDArray newContainer = Nd4j.create(max); newContainer.put(new INDArrayIndex[]{NDArrayIndex.interval(0,container.length())},container); container = newContainer; } }
arr.put(new INDArrayIndex[] {NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.all(), NDArrayIndex.all()}, arrays[i]); examplesSoFar += thisNExamples; arr.put(new INDArrayIndex[] {NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.all(), NDArrayIndex.interval(0, thisLength)}, a); NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.interval(0, maskLength)}, origMask); if (maskLength < maxLength) { NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.interval(maskLength, maxLength)}, Nd4j.zeros(thisNExamples, maxLength - maskLength)); NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.interval(thisLength, maxLength)}, arr.put(new INDArrayIndex[] {NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.all(), NDArrayIndex.interval(0, thisLength)}, a); mask.get(NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.all(), NDArrayIndex.interval(0, thisLength)).assign(1); NDArrayIndex.interval(examplesSoFar, examplesSoFar + thisNExamples), NDArrayIndex.all(), NDArrayIndex.interval(0, thisLength)}, m); return new Pair<>(arr, mask);
for(currMinibatchSize = 0; currMinibatchSize < num && this.documentProvider.hasNext(); ++currMinibatchSize) { Pair<String, double[]> p = this.documentProvider.nextSentence(); List<String> tokens = this.tokenizeSentence(p.getFirst()); maxLength = Math.max(maxLength, tokens.size()); tokenizedSentences.add(new Pair(tokens, p.getSecond())); INDArray features = Nd4j.create(featuresShape); INDArrayIndex[] indices = new INDArrayIndex[]{NDArrayIndex.point(i), NDArrayIndex.point(0), null, null}; if(this.sentencesAlongHeight) { indices[2] = NDArrayIndex.point(sentenceLength); indices[3] = NDArrayIndex.all(); } else { indices[2] = NDArrayIndex.all(); indices[3] = NDArrayIndex.point(sentenceLength); features.put(indices, vector); featuresMask = Nd4j.create(currMinibatchSize, maxLength); sentenceLength = ((List)((Pair)tokenizedSentences.get(i)).getFirst()).size(); if(sentenceLength >= maxLength) { featuresMask.getRow(i).assign(Double.valueOf(1.0D)); } else { featuresMask.get(new INDArrayIndex[]{NDArrayIndex.point(i), NDArrayIndex.interval(0, sentenceLength)}).assign(Double.valueOf(1.0D));
public INDArray adjustMasks(INDArray label, INDArray labelMask, int minorityLabel, double targetDist) { labelMask = Nd4j.ones(label.size(0), label.size(2)); INDArray bernoullis = Nd4j.zeros(labelMask.shape()); long currentTimeSliceEnd = label.size(2); INDArray currentWindowBernoulli = bernoullis.get(NDArrayIndex.all(), NDArrayIndex.interval(currentTimeSliceStart, currentTimeSliceEnd)); INDArray currentMask = labelMask.get(NDArrayIndex.all(), NDArrayIndex.interval(currentTimeSliceStart, currentTimeSliceEnd)); INDArray currentLabel; if (label.size(1) == 2) { currentLabel = label.get(NDArrayIndex.all(), NDArrayIndex.point(minorityLabel), NDArrayIndex.interval(currentTimeSliceStart, currentTimeSliceEnd)); } else { currentLabel = label.get(NDArrayIndex.all(), NDArrayIndex.point(0), NDArrayIndex.interval(currentTimeSliceStart, currentTimeSliceEnd)); if (minorityLabel == 0) { currentLabel = Transforms.not(currentLabel); return Nd4j.getExecutioner().exec( new BernoulliDistribution(Nd4j.createUninitialized(bernoullis.shape()), bernoullis), Nd4j.getRandom());
public static List<Pair<INDArray, String>> getSubMatricesWithShape(char ordering, long rows, long cols, long seed) { //Create 3 identical matrices. Could do get() on single original array, but in-place modifications on one //might mess up tests for another Nd4j.getRandom().setSeed(seed); long[] shape = new long[] {2 * rows + 4, 2 * cols + 4}; int len = ArrayUtil.prod(shape); INDArray orig = Nd4j.linspace(1, len, len).reshape(ordering, shape); INDArray first = orig.get(NDArrayIndex.interval(0, rows), NDArrayIndex.interval(0, cols)); Nd4j.getRandom().setSeed(seed); orig = Nd4j.linspace(1, len, len).reshape(shape); INDArray second = orig.get(NDArrayIndex.interval(3, rows + 3), NDArrayIndex.interval(3, cols + 3)); Nd4j.getRandom().setSeed(seed); orig = Nd4j.linspace(1, len, len).reshape(ordering, shape); INDArray third = orig.get(NDArrayIndex.interval(rows, 2 * rows), NDArrayIndex.interval(cols, 2 * cols)); String baseMsg = "getSubMatricesWithShape(" + rows + "," + cols + "," + seed + ")"; List<Pair<INDArray, String>> list = new ArrayList<>(3); list.add(new Pair<>(first, baseMsg + ".get(0)")); list.add(new Pair<>(second, baseMsg + ".get(1)")); list.add(new Pair<>(third, baseMsg + ".get(2)")); return list; }
@Override public INDArray gradient(INDArray x, INDArray preOutDistributionParams) { INDArray output = preOutDistributionParams.dup(); activationFn.getActivation(output, true); int size = output.size(1) / 2; INDArray mean = output.get(NDArrayIndex.all(), NDArrayIndex.interval(0, size)); INDArray logStdevSquared = output.get(NDArrayIndex.all(), NDArrayIndex.interval(size, 2 * size)); INDArray sigmaSquared = Transforms.exp(logStdevSquared, true); INDArray xSubMean = x.sub(mean); INDArray xSubMeanSq = xSubMean.mul(xSubMean); INDArray dLdmu = xSubMean.divi(sigmaSquared); INDArray sigma = Transforms.sqrt(sigmaSquared, true); INDArray sigma3 = Transforms.pow(sigmaSquared, 3.0 / 2); INDArray dLdsigma = sigma.rdiv(-1).addi(xSubMeanSq.divi(sigma3)); INDArray dLdlogSigma2 = sigma.divi(2).muli(dLdsigma); INDArray dLdx = Nd4j.createUninitialized(output.shape()); dLdx.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.interval(0, size)}, dLdmu); dLdx.put(new INDArrayIndex[] {NDArrayIndex.all(), NDArrayIndex.interval(size, 2 * size)}, dLdlogSigma2); dLdx.negi(); //dL/dz return activationFn.backprop(preOutDistributionParams.dup(), dLdx).getFirst(); }
@Override public INDArray sample(int[] shape) { int numRows = 1; for (int i = 0; i < shape.length - 1; i++) numRows *= shape[i]; int numCols = shape[shape.length - 1]; val flatShape = new int[]{numRows, numCols}; val flatRng = Nd4j.getExecutioner().exec(new GaussianDistribution(Nd4j.createUninitialized(flatShape, Nd4j.order()), 0.0, 1.0), random); long m = flatRng.rows(); long n = flatRng.columns(); val s = Nd4j.create(m < n ? m : n); val u = m < n ? Nd4j.create(m, n) : Nd4j.create(m, m); val v = Nd4j.create(n, n, 'f'); Nd4j.getBlasWrapper().lapack().gesvd(flatRng, s, u, v); // FIXME: int cast if (gains == null) { if (u.rows() == numRows && u.columns() == numCols) { return v.get(NDArrayIndex.interval(0, numRows), NDArrayIndex.interval(0, numCols)).mul(gain).reshape(ArrayUtil.toLongArray(shape)); } else { return u.get(NDArrayIndex.interval(0, numRows), NDArrayIndex.interval(0, numCols)).mul(gain).reshape(ArrayUtil.toLongArray(shape)); } } else { throw new UnsupportedOperationException(); } }
INDArray sorted = Nd4j.sortRows(pl, 0, false); INDArray isPositive = sorted.getColumn(1); INDArray isNegative = sorted.getColumn(1).rsub(1.0); INDArray cumSumPos = isPositive.cumsum(-1); int length = sorted.size(0); INDArray t = Nd4j.create(new int[] {length + 2, 1}); t.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, sorted.getColumn(0)); INDArray fpr = Nd4j.create(new int[] {length + 2, 1}); fpr.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, cumSumNeg.div(countActualNegative)); INDArray tpr = Nd4j.create(new int[] {length + 2, 1}); tpr.put(new INDArrayIndex[] {NDArrayIndex.interval(1, length + 1), NDArrayIndex.all()}, cumSumPos.div(countActualPositive)); double[] x_fpr_out = fpr.data().asDouble(); double[] y_tpr_out = tpr.data().asDouble(); double[] tOut = t.data().asDouble(); double[][] temp = p.getFirst(); tOut = temp[0]; x_fpr_out = temp[1];
public Pair<Gradient, INDArray> backpropGradient(INDArray epsilon) { if (helper != null) { Pair<Gradient, INDArray> ret = helper.backpropGradient(input, epsilon, k, n, alpha, beta); if (ret != null) { return ret; } } int channel = input.size(1); INDArray tmp, addVal; Gradient retGradient = new DefaultGradient(); INDArray reverse = activations.mul(epsilon); INDArray sumPart = reverse.dup(); // sumPart = sum(a^j_{x,y} * gb^j_{x,y}) for (int i = 1; i < halfN + 1; i++) { tmp = sumPart.get(NDArrayIndex.all(), interval(i, channel), NDArrayIndex.all(), NDArrayIndex.all()); addVal = reverse.get(NDArrayIndex.all(), interval(0, channel - i), NDArrayIndex.all(), NDArrayIndex.all()); sumPart.put(new INDArrayIndex[] {NDArrayIndex.all(), interval(i, channel), NDArrayIndex.all(), NDArrayIndex.all()}, tmp.addi(addVal)); tmp = sumPart.get(NDArrayIndex.all(), interval(0, channel - i), NDArrayIndex.all(), NDArrayIndex.all()); addVal = reverse.get(NDArrayIndex.all(), interval(i, channel), NDArrayIndex.all(), NDArrayIndex.all()); sumPart.put(new INDArrayIndex[] {NDArrayIndex.all(), interval(0, channel - i), NDArrayIndex.all(), NDArrayIndex.all()}, tmp.addi(addVal)); } // gx = gy * unitScale**-beta - 2 * alpha * beta * sumPart/unitScale * a^i_{x,y} - rearranged for more in-place ops INDArray nextEpsilon = epsilon.mul(scale).subi(sumPart.muli(input).divi(unitScale).muli(2 * alpha * beta)); return new Pair<>(retGradient, nextEpsilon); }
for(currMinibatchSize = 0; this.documentProvider.hasNext(); ++currMinibatchSize) { Pair<String, double[]> p = this.documentProvider.nextSentence(); List<String> tokens = this.tokenizeSentence(p.getFirst()); maxLength = Math.max(maxLength, tokens.size()); tokenizedSentences.add(new Pair(tokens, p.getSecond())); INDArray features = Nd4j.create(featuresShape); INDArrayIndex[] indices = new INDArrayIndex[]{NDArrayIndex.point(i), NDArrayIndex.point(0), null, null}; if(this.sentencesAlongHeight) { indices[2] = NDArrayIndex.point(sentenceLength); indices[3] = NDArrayIndex.all(); } else { indices[2] = NDArrayIndex.all(); indices[3] = NDArrayIndex.point(sentenceLength); features.put(indices, vector);