Java Code Examples for org.nd4j.linalg.api.ndarray.INDArray#isRowVector()

@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.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2));
    this.v = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.v = Shape.newShapeNoCopy(this.v, gradientShape, gradientOrder == 'f');
    if (m == null || v == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2));
    this.u = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.u = Shape.newShapeNoCopy(this.u, gradientShape, gradientOrder == 'f');
    if (m == null || u == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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");
}
 

@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);
    val n = viewArray.length() / 3;
    this.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, n));
    this.v = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(n, 2*n));
    this.vHat = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(2*n, 3*n));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.v = Shape.newShapeNoCopy(this.v, gradientShape, gradientOrder == 'f');
    this.vHat = Shape.newShapeNoCopy(this.vHat, gradientShape, gradientOrder == 'f');
    if (m == null || v == null || vHat == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2));
    this.v = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.v = Shape.newShapeNoCopy(this.v, gradientShape, gradientOrder == 'f');
    if (m == null || v == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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");
}
 

@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.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2));
    this.v = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.v = Shape.newShapeNoCopy(this.v, gradientShape, gradientOrder == 'f');
    if (m == null || v == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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.m = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(0, length / 2));
    this.v = viewArray.get(NDArrayIndex.point(0), NDArrayIndex.interval(length / 2, length));

    //Reshape to match the expected shape of the input gradient arrays
    this.m = Shape.newShapeNoCopy(this.m, gradientShape, gradientOrder == 'f');
    this.v = Shape.newShapeNoCopy(this.v, gradientShape, gradientOrder == 'f');
    if (m == null || v == null)
        throw new IllegalStateException("Could not correctly reshape gradient view arrays");

    this.gradientReshapeOrder = gradientOrder;
}
 

/**
 * Computes the gradient of the NLL for PL networks w.r.t. the k-th dyad according to equation (28) in [1].
 * @param plNetOutputs  The outputs for M_n dyads generated by a PLNet's output layer in order of their ranking (from best to worst).
 * @param k				The ranking position with respect to which the gradient should be computed. Assumes zero-based indices, unlike the paper.
 * @return				The gradient of the NLL loss w.r.t. the k-th dyad in the ranking.
 */
public static INDArray computeLossGradient(INDArray plNetOutputs, int k) {
	if (!(plNetOutputs.isRowVector()) || plNetOutputs.size(1) < 2 || k < 0 || k >= plNetOutputs.size(1)) {
		throw new IllegalArgumentException("Input has to be a row vector of 2 or more elements. And k has to be a valid index of plNetOutputs.");
	}
	long dyadRankingLength = plNetOutputs.size(1);
	double errorGradient = 0;
	for (int m = 0; m <= k; m++) {
		INDArray innerSumSlice = plNetOutputs.get(NDArrayIndex.interval(m, dyadRankingLength));
		innerSumSlice = Transforms.exp(innerSumSlice);
		double innerSum = innerSumSlice.sum(1).getDouble(0);
		errorGradient += Math.exp(plNetOutputs.getDouble(k)) / innerSum;
	}
	errorGradient -= 1;
	return Nd4j.create(new double[] {errorGradient});
}
 

public void setStateViewArray(INDArray viewArray, long[] gradientShape, char gradientOrder, boolean initialize) {
    if (!viewArray.isRowVector() && !(viewArray.rank() == 2 && viewArray.columns() == 1 && viewArray.rows() == 1))
        throw new IllegalArgumentException("Invalid input: expect row vector input");
    if (initialize)
        viewArray.assign(epsilon);
    this.historicalGradient = viewArray;
    //Reshape to match the expected shape of the input gradient arrays
    this.historicalGradient = Shape.newShapeNoCopy(this.historicalGradient, gradientShape, gradientOrder == 'f');
    if (historicalGradient == null)
        throw new IllegalStateException("Could not correctly reshape gradient view array");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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(epsilon);
    this.historicalGradient = viewArray;
    //Reshape to match the expected shape of the input gradient arrays
    this.historicalGradient = Shape.newShapeNoCopy(this.historicalGradient, gradientShape, gradientOrder == 'f');
    if (historicalGradient == null)
        throw new IllegalStateException("Could not correctly reshape gradient view array");

    this.gradientReshapeOrder = gradientOrder;
}
 

@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(config.getEpsilon());
    this.lastGradient = viewArray;

    //Reshape to match the expected shape of the input gradient arrays
    this.lastGradient = Shape.newShapeNoCopy(this.lastGradient, gradientShape, gradientOrder == 'f');
    if (lastGradient == null)
        throw new IllegalStateException("Could not correctly reshape gradient view array");

    gradientReshapeOrder = gradientOrder;
}
 

/**
 * Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a fixed scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossMCXENT(@JsonProperty("softmaxClipEps") double softmaxClipEps, @JsonProperty("weights") INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    if(softmaxClipEps < 0 || softmaxClipEps > 0.5){
        throw new IllegalArgumentException("Invalid clipping epsilon: epsilon should be >= 0 (but near zero). Got: "
                + softmaxClipEps);
    }
    this.weights = weights;
    this.softmaxClipEps = softmaxClipEps;
}
 

/**
 * Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a fixed scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossMCXENT(@JsonProperty("softmaxClipEps") double softmaxClipEps, @JsonProperty("weights") INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    if(softmaxClipEps < 0 || softmaxClipEps > 0.5){
        throw new IllegalArgumentException("Invalid clipping epsilon: epsilon should be >= 0 (but near zero). Got: "
                + softmaxClipEps);
    }
    this.weights = weights;
    this.softmaxClipEps = softmaxClipEps;
}
 

/**
 * Binary cross entropy where each the output is
 * (optionally) weighted/scaled by a fixed scalar value.
 * Note that the weights array must be a row vector, of length equal to
 * the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param clipEps Epsilon value for clipping. Probabilities are clipped in range of [eps, 1-eps]. Default eps: 1e-5
 * @param weights Weights array (row vector). May be null.
 */
public LossBinaryXENT(@JsonProperty("clipEps") double clipEps, @JsonProperty("weights") INDArray weights){
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    if(clipEps < 0 || clipEps > 0.5){
        throw new IllegalArgumentException("Invalid clipping epsilon value: epsilon should be >= 0 (but near zero)."
                + "Got: " + clipEps);
    }

    this.clipEps = clipEps;
    this.weights = weights;
}
 

@Override
public INDArray getAccumulatedResult() {
    INDArray stack = super.getAccumulatedResult();

    if (aggregationWidth == 1)
        return stack;

    if (stack.isRowVector()) {
        return Nd4j.scalar(stack.sumNumber().doubleValue());
    } else {
        return stack.sum(1);
    }
}
 

/**
 * Mean Absolute Percentage Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossMAPE(INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    this.weights = weights;
}
 

/**
 * L1 loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossL1(INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    this.weights = weights;
}
 

/**
 * Mean Absolute Percentage Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossMAPE(INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    this.weights = weights;
}
 

/**
 * Mean Squared Logarithmic Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
 * Note that the weights array must be a row vector, of length equal to the labels/output dimension 1 size.
 * A weight vector of 1s should give identical results to no weight vector.
 *
 * @param weights Weights array (row vector). May be null.
 */
public LossMSLE(INDArray weights) {
    if (weights != null && !weights.isRowVector()) {
        throw new IllegalArgumentException("Weights array must be a row vector");
    }
    this.weights = weights;
}