/**
* output the prediction probabilities for each tree
*
* @param trees the trees to predict
* @return the prediction probabilities for each tree
*/
public List<INDArray> output(List<Tree> trees) {
List<INDArray> ret = new ArrayList<>();
for (Tree t : trees) {
forwardPropagateTree(t);
ret.add(t.prediction());
}
return ret;
}
/**
* output the top level labels for each tree
*
* @param trees the trees to predict
* @return the prediction labels for each tree
*/
public List<Integer> predict(List<Tree> trees) {
List<Integer> ret = new ArrayList<>();
for (Tree t : trees) {
forwardPropagateTree(t);
ret.add(Nd4j.getBlasWrapper().iamax(t.prediction()));
}
return ret;
}
private void backpropDerivativesAndError(
Tree tree,
MultiDimensionalMap<String, String, INDArray> binaryTD,
MultiDimensionalMap<String, String, INDArray> binaryCD,
MultiDimensionalMap<String, String, INDArray> binaryINDArrayTD,
Map<String, INDArray> unaryCD,
Map<String, INDArray> wordVectorD,
INDArray deltaUp) {
if (tree.isLeaf()) {
return;
}
INDArray currentVector = tree.vector();
String category = tree.label();
category = basicCategory(category);
// Build a vector that looks like 0,0,1,0,0 with an indicator for the correct class
INDArray goldLabel = Nd4j.create(numOuts, 1);
int goldClass = tree.goldLabel();
if (goldClass >= 0) {
assert goldClass <= numOuts
: "Tried adding a label that was >= to the number of configured outputs "
+ numOuts
+ " with label "
+ goldClass;
goldLabel.putScalar(goldClass, 1.0f);
}
Double nodeWeight = classWeights.get(goldClass);
if (nodeWeight == null) nodeWeight = 1.0;
INDArray predictions = tree.prediction();
// If this is an unlabeled class, transform deltaClass to 0. We could
// make this more efficient by eliminating various of the below
// calculations, but this would be the easiest way to handle the
// unlabeled class
INDArray deltaClass = null;
if (predictions.data().dataType() == DataBuffer.Type.DOUBLE) {
deltaClass =
goldClass >= 0
? Nd4j.getBlasWrapper().scal(nodeWeight, predictions.sub(goldLabel))
: Nd4j.create(predictions.rows(), predictions.columns());
} else {
deltaClass =
goldClass >= 0
? Nd4j.getBlasWrapper()
.scal((float) nodeWeight.doubleValue(), predictions.sub(goldLabel))
: Nd4j.create(predictions.rows(), predictions.columns());
}
INDArray localCD = deltaClass.mmul(Nd4j.appendBias(currentVector).transpose());
double error =
-(Transforms.log(predictions).muli(goldLabel).sum(Integer.MAX_VALUE).getDouble(0));
error = error * nodeWeight;
tree.setError(error);
if (tree.isPreTerminal()) { // below us is a word vector
unaryCD.put(category, unaryCD.get(category).add(localCD));
String word = tree.children().get(0).label();
word = getVocabWord(word);
INDArray currentVectorDerivative =
Nd4j.getExecutioner()
.execAndReturn(
Nd4j.getOpFactory().createTransform(activationFunction, currentVector));
INDArray deltaFromClass = getUnaryClassification(category).transpose().mmul(deltaClass);
deltaFromClass =
deltaFromClass.get(interval(0, numHidden), interval(0, 1)).mul(currentVectorDerivative);
INDArray deltaFull = deltaFromClass.add(deltaUp);
INDArray wordVector = wordVectorD.get(word);
wordVectorD.put(word, wordVector.add(deltaFull));
} else {
// Otherwise, this must be a binary node
String leftCategory = basicCategory(tree.children().get(0).label());
String rightCategory = basicCategory(tree.children().get(1).label());
if (combineClassification) {
unaryCD.put("", unaryCD.get("").add(localCD));
} else {
binaryCD.put(
leftCategory, rightCategory, binaryCD.get(leftCategory, rightCategory).add(localCD));
}
INDArray currentVectorDerivative =
Nd4j.getExecutioner()
.execAndReturn(
Nd4j.getOpFactory().createTransform(activationFunction, currentVector));
INDArray deltaFromClass =
getBinaryClassification(leftCategory, rightCategory).transpose().mmul(deltaClass);
INDArray mult = deltaFromClass.get(interval(0, numHidden), interval(0, 1));
deltaFromClass = mult.muli(currentVectorDerivative);
INDArray deltaFull = deltaFromClass.add(deltaUp);
INDArray leftVector = tree.children().get(0).vector();
INDArray rightVector = tree.children().get(1).vector();
INDArray childrenVector = Nd4j.appendBias(leftVector, rightVector);
// deltaFull 50 x 1, childrenVector: 50 x 2
INDArray add = binaryTD.get(leftCategory, rightCategory);
INDArray W_df = deltaFromClass.mmul(childrenVector.transpose());
binaryTD.put(leftCategory, rightCategory, add.add(W_df));
INDArray deltaDown;
if (useDoubleTensors) {
INDArray Wt_df = getINDArrayGradient(deltaFull, leftVector, rightVector);
binaryINDArrayTD.put(
leftCategory,
rightCategory,
binaryINDArrayTD.get(leftCategory, rightCategory).add(Wt_df));
deltaDown =
computeINDArrayDeltaDown(
deltaFull,
leftVector,
rightVector,
getBinaryTransform(leftCategory, rightCategory),
getBinaryINDArray(leftCategory, rightCategory));
} else {
deltaDown = getBinaryTransform(leftCategory, rightCategory).transpose().mmul(deltaFull);
}
INDArray leftDerivative =
Nd4j.getExecutioner()
.execAndReturn(Nd4j.getOpFactory().createTransform(activationFunction, leftVector));
INDArray rightDerivative =
Nd4j.getExecutioner()
.execAndReturn(Nd4j.getOpFactory().createTransform(activationFunction, rightVector));
INDArray leftDeltaDown = deltaDown.get(interval(0, deltaFull.rows()), interval(0, 1));
INDArray rightDeltaDown =
deltaDown.get(interval(deltaFull.rows(), deltaFull.rows() * 2), interval(0, 1));
backpropDerivativesAndError(
tree.children().get(0),
binaryTD,
binaryCD,
binaryINDArrayTD,
unaryCD,
wordVectorD,
leftDerivative.mul(leftDeltaDown));
backpropDerivativesAndError(
tree.children().get(1),
binaryTD,
binaryCD,
binaryINDArrayTD,
unaryCD,
wordVectorD,
rightDerivative.mul(rightDeltaDown));
}
}