@Override public int getLength() { return this.mainVector.getLength(); }
@Override public int getLength() { return vector.getLength(); }
@Override public int getLength() { return vector.getLength(); }
@Override public Set<Integer> mapDocument(DoubleVector v) { Set<Integer> set = new HashSet<>(v.getLength()); Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); set.add(next.getIndex()); } return set; }
static boolean correctPrediction(int classIndex, DoubleVector outcome) { return outcome.getLength() == 1 ? ((int) outcome.get(0)) == classIndex : outcome.maxIndex() == classIndex; }
/** * @return the average transition probability of the given sequence. */ public double averageTransitionProbability(int[] sequence) { DoubleVector distribution = getTransitionProbabilities(sequence); return FastMath.exp(distribution.sum() / Math.max(1d, distribution.getLength())); }
@Override public int extractPredictedClass(DoubleVector predict) { if (predict.getLength() == 1) { return (int) Math.rint(predict.get(0)); } else { return ArrayUtils.maxIndex(predict.toArray()); } }
/** * Predicts the outcome of the given input by doing a forward pass. Used for * binary classification by a threshold. Everything above threshold will be * considered as 1, the other case as 0. */ public DoubleVector predict(DoubleVector xi, double threshold) { DoubleVector activations = predict(xi); for (int i = 0; i < activations.getLength(); i++) { activations.set(i, activations.get(i) > threshold ? 1.0d : 0.0d); } return activations; }
@Override public int extractPredictedClass(DoubleVector predict, double threshold) { if (predict.getLength() == 1) { if (predict.get(0) <= threshold) { return 0; } else { return 1; } } else { return ArrayUtils.maxIndex(predict.toArray()); } }
@Override public DoubleVector divideFrom(double scalar) { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { if (this.get(i) != 0.0d) { double result = scalar / this.get(i); v.set(i, result); } else { throw new java.lang.ArithmeticException("/ by zero"); } } return v; }
@Override public DoubleVector abs() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.abs(vector[i])); } return v; }
@Override public DoubleVector exp() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.exp(vector[i])); } return v; }
@Override public DoubleVector sqrt() { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.sqrt(vector[i])); } return v; }
@Override public DoubleVector log() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.log(vector[i])); } return v; }
@Override public DoubleVector multiply(double scalar) { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, this.get(i) * scalar); } return v; }
@Override public DoubleVector divideFrom(DoubleVector vector) { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { if (this.get(i) != 0.0d) { double result = vector.get(i) / this.get(i); v.set(i, result); } else { throw new java.lang.ArithmeticException("/ by zero"); } } return v; }
@Override public DoubleVector divide(DoubleVector vector) { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { if (vector.get(i) != 0.0d) { double result = this.get(i) / vector.get(i); v.set(i, result); } else { throw new java.lang.ArithmeticException("/ by zero"); } } return v; }
@Override public DoubleMatrix apply(DoubleMatrix matrix) { DoubleMatrix dm = newInstance(matrix); for (int row = 0; row < matrix.getRowCount(); row++) { DoubleVector apply = apply(matrix.getRowVector(row)); if (apply.getLength() != 0) { dm.setRowVector(row, apply); } } return dm; }
static double computeLogPrior(DoubleVector theta, DoubleVector gradient) { double prior = 0.0; for (int i = 0; i < theta.getLength(); i++) { prior += theta.get(i) * theta.get(i) / 2d / (SIGMA_SQUARED); gradient.set(i, gradient.get(i) + theta.get(i) / (SIGMA_SQUARED)); } return prior; }
@Override public DoubleVector multiply(DoubleVector s) { // take a shortcut by just iterating over the non-zero elements of the // smaller vector of both multiplicants. DoubleVector smallestVector = s.getLength() < getLength() ? s : this; DoubleVector vec = new SequentialSparseDoubleVector(s.getDimension()); DoubleVector largerVector = smallestVector == this ? s : this; Iterator<DoubleVectorElement> it = smallestVector.iterateNonZero(); while (it.hasNext()) { DoubleVectorElement next = it.next(); double otherValue = largerVector.get(next.getIndex()); vec.set(next.getIndex(), next.getValue() * otherValue); } return vec; }