/** * Element wise minimum function between 2 INDArrays * * @param first * @param second * @return */ public static INDArray min(INDArray first, INDArray second) { return min(first, second, true); }
/** * Maximum function with a scalar * * @param ndArray tbe ndarray * @param k * @return */ public static INDArray min(INDArray ndArray, double k) { return min(ndArray, k, true); }
private INDArray scoreArray(INDArray labels, INDArray preOutput, IActivation activationFn, INDArray mask) { if (labels.size(1) != preOutput.size(1)) { throw new IllegalArgumentException( "Labels array numColumns (size(1) = " + labels.size(1) + ") does not match output layer" + " number of outputs (nOut = " + preOutput.size(1) + ") "); } INDArray output = activationFn.getActivation(preOutput.dup(), true); // Clip output and labels to be between Nd4j.EPS_THREsHOLD and 1, i.e. a valid non-zero probability output = Transforms.min(Transforms.max(output, Nd4j.EPS_THRESHOLD, false), 1, false); labels = Transforms.min(Transforms.max(labels, Nd4j.EPS_THRESHOLD, true), 1, false); INDArray logRatio = Transforms.log(output.rdivi(labels), false); INDArray scoreArr = logRatio.muli(labels); if (mask != null) { LossUtil.applyMask(scoreArr, mask); } return scoreArr; }
} else { Transforms.min(runningLower, batchMin, false); Transforms.max(runningUpper, batchMax, false);
hAdjusted.put(forward,min(h.get(forward),upperBound2.get(forward).mul(0.5).divi(numSteps))); oneSided.put(forward,Nd4j.scalar(1.0)); hAdjusted.put(backward,min(h.get(backward),lowerDist.get(backward).mul(0.5).divi(numSteps))); oneSided.put(backward,Nd4j.scalar(1.0)); INDArray minDist = min(upperBound2,lowerDist).divi(numSteps); INDArray adjustedCentral = and(not(central),lessThanOrEqual(abs(hAdjusted),minDist)); hAdjusted.put(adjustedCentral,minDist.get(adjustedCentral));
/** * Maximum function with a scalar * * @param ndArray tbe ndarray * @param k * @return */ public static INDArray min(INDArray ndArray, double k) { return min(ndArray, k, Nd4j.copyOnOps); }
/** * Element wise minimum function between 2 INDArrays * * @param first * @param second * @return */ public static INDArray min(INDArray first, INDArray second) { return min(first, second, Nd4j.copyOnOps); }
@Override public DoubleTensor minInPlace(DoubleTensor min) { if (min.isScalar()) { Transforms.min(tensor, min.scalar(), false); } else { tensor = INDArrayShim.min(tensor, unsafeGetNd4J(min)); } return this; }
@Override public IntegerTensor minInPlace(IntegerTensor min) { if (min.isScalar()) { Transforms.min(tensor, min.scalar(), false); } else { tensor = INDArrayShim.min(tensor, unsafeGetNd4J(min)); } return this; }
private INDArray scoreArray(INDArray labels, INDArray preOutput, IActivation activationFn, INDArray mask) { if (labels.size(1) != preOutput.size(1)) { throw new IllegalArgumentException("Labels array numColumns (size(1) = " + labels.size(1) + ") does not match output layer" + " number of outputs (nOut = " + preOutput.size(1) + ") "); } INDArray output = activationFn.getActivation(preOutput.dup(), true); // Clip output and labels to be between Nd4j.EPS_THREsHOLD and 1, i.e. a valid non-zero probability output = Transforms.min(Transforms.max(output, Nd4j.EPS_THRESHOLD, false), 1, false); labels = Transforms.min(Transforms.max(labels, Nd4j.EPS_THRESHOLD, true), 1, false); INDArray logRatio = Transforms.log(output.rdivi(labels), false); INDArray scoreArr = logRatio.muli(labels); if (mask != null) { LossUtil.applyMask(scoreArr, mask); } return scoreArr; }
} else { Transforms.min(runningLower, batchMin, false); Transforms.max(runningUpper, batchMax, false);
public INDArray scoreArray(INDArray labels, INDArray preOutput, IActivation activationFn, INDArray mask) { INDArray scoreArr; INDArray output = activationFn.getActivation(preOutput.dup(), true); INDArray mMinuss = Nd4j.zeros(output.shape()).addi(mMinus); INDArray positiveExamples = output.mul(labels); positiveExamples = averageOverCorrectClasses(labels, positiveExamples); INDArray positiveExp = positiveExamples.rsubi(mPlus).muli(gamma); INDArray positiveE = Transforms.exp(positiveExp); INDArray leftLog = Transforms.log(positiveE.addi(1)); INDArray negativeExp = mMinuss.addi(output).muli(gamma); INDArray negativeE = Transforms.exp(negativeExp); INDArray negativeExamples = output.addi(labels.mul(positiveClassExclusionFactor)); INDArray maxNeg = negativeExamples.argMax(1); INDArray rightLog = Transforms.log(negativeE.addi(1)); INDArray negWithHighestScore = Nd4j.zeros(preOutput.shape()); for(int i = 0; i < maxNeg.length(); i++) { int index = maxNeg.getInt(i); negWithHighestScore.put(i, index, 1); } leftLog = leftLog.muli(Transforms.min(labels.sum(1),1)); rightLog = rightLog.muli(negWithHighestScore); scoreArr = leftLog.addi(rightLog.sum(1)); if(mask != null) { scoreArr.muliColumnVector(mask); } return scoreArr; }
public INDArray computeDlDx(INDArray labels, INDArray predictedScores) { INDArray mPluss = Nd4j.zeros(predictedScores.shape()).addi(mPlus); INDArray mMinuss = Nd4j.zeros(predictedScores.shape()).addi(mMinus); INDArray gammaDivNumCorrectLabels = Transforms.max(labels.sum(1), 1).rdivi(gamma); INDArray positiveExamples = predictedScores.mul(labels); INDArray leftHandExp = Transforms.exp((positiveExamples.sum(1).rsubi(mPlus)).muli(gammaDivNumCorrectLabels)); INDArray leftHandNumerator = leftHandExp.mulColumnVector(gammaDivNumCorrectLabels); INDArray leftHandDenominator = leftHandExp.addi(1); INDArray leftHand = leftHandNumerator.divi(leftHandDenominator); leftHand = labels.mulColumnVector(leftHand.negi()); INDArray rightHandExp = Transforms.exp((mMinuss.addi(predictedScores)).muli(gamma)); INDArray rightHandNumerator = rightHandExp.mul(gamma); INDArray rightHandDenominator = rightHandExp.addi(1); INDArray rightHand = rightHandNumerator.divi(rightHandDenominator); predictedScores = predictedScores.addi(labels.mul(positiveClassExclusionFactor)); INDArray maxNegative = predictedScores.argMax(1); INDArray negWithHighestScoreMask = Nd4j.zeros(predictedScores.shape()); for(int i = 0; i < maxNegative.length(); i++) { int index = maxNegative.getInt(i); negWithHighestScoreMask.put(i, index, 1); } leftHand = leftHand.muli(labels); rightHand = rightHand.muli(negWithHighestScoreMask); rightHand = rightHand.mulColumnVector(Transforms.min(labels.sum(1),1)); // ignore examples without correct label. return leftHand.addi(rightHand); }