@Override public boolean isSparse() { return vector.isSparse(); }
@Override public boolean isSparse() { return vector.isSparse(); }
@Override public boolean isSparse() { return this.mainVector.isSparse(); }
@Override public double measureDistance(DoubleVector vec1, DoubleVector vec2) { if (vec1.isSparse() || vec2.isSparse()) { return FastMath.sqrt(vec2.subtract(vec1).pow(2).sum()); } else { // dense vectors usually doesn't do a defensive copy, so it is faster than // the implementation above. return measureDistance(vec1.toArray(), vec2.toArray()); } }
/** * Transforms the given vector into this vector. * * @param vec a double vector. */ public DenseDoubleVector(DoubleVector vec) { this.vector = new double[vec.getDimension()]; if (vec.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = vec.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); this.vector[next.getIndex()] = next.getValue(); } } else { System.arraycopy(vec.toArray(), 0, this.vector, 0, this.vector.length); } }
@Override public double measureDistance(DoubleVector vec1, DoubleVector vec2) { if (vec1.isSparse() || vec2.isSparse()) { return FastMath.sqrt(vec2.subtract(vec1).pow(2).sum()); } else { // dense vectors usually doesn't do a defensive copy, so it is faster than // the implementation above. return measureDistance(vec1.toArray(), vec2.toArray()); } }
protected DoubleVector newInstance(DoubleVector v) { if (v.isSparse()) { return new SparseDoubleVector(v.getDimension()); } else { return new DenseDoubleVector(v.getDimension()); } }
@Override public double dot(DoubleVector s) { double dotProduct = 0.0d; if (s.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = s.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); dotProduct += this.get(next.getIndex()) * next.getValue(); } } else { for (int i = 0; i < getLength(); i++) { dotProduct += this.get(i) * s.get(i); } } return dotProduct; }
@Override public DoubleVector subtract(DoubleVector other) { SequentialSparseDoubleVector result = new SequentialSparseDoubleVector(this); if (other.isSparse() && other instanceof SequentialSparseDoubleVector) { SequentialSparseDoubleVector vec = (SequentialSparseDoubleVector) other; result.mapping.merge(vec.mapping, (l, r) -> l - r); } else { Iterator<DoubleVectorElement> iter = other.iterateNonZero(); while (iter.hasNext()) { DoubleVectorElement e = iter.next(); int index = e.getIndex(); result.set(index, result.get(index) - e.getValue()); } } return result; }
/** * Constructs a new {@link SequentialSparseDoubleVector}. * * @param v the given vector to copy. */ public SequentialSparseDoubleVector(DoubleVector v) { this(v.getDimension(), v.getLength()); if (v.isSparse()) { SequentialSparseDoubleVector vx = (SequentialSparseDoubleVector) v; mapping.copyInternalState(vx.mapping); } else { Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); mapping.set(next.getIndex(), next.getValue()); } } }
/** * Generates a single-row matrix with the given first column value (usually * used as a bias) and the given vector as the appendant. * * @param firstColumnValue the value at dimension 0. * @param vector the vector for the following dimensions (1..n+1) */ public DenseDoubleMatrix(double firstColumnValue, DoubleVector vector) { this(1, vector.getDimension() + 1); set(0, 0, firstColumnValue); if (vector.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = vector.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); set(0, next.getIndex() + 1, next.getValue()); } } else { System.arraycopy(vector.toArray(), 0, this.matrix, 1, vector.getDimension()); } }
@Override public DoubleVector apply(DoubleVector vector) { DoubleVector newInstance = newInstance(vector); if (vector.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = vector.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); newInstance.set(next.getIndex(), apply(next.getValue())); } } else { for (int i = 0; i < vector.getDimension(); i++) { newInstance.set(i, apply(vector.get(i))); } } return newInstance; }
@Override public DoubleVector gradient(DoubleVector vector) { DoubleVector newInstance = newInstance(vector); if (vector.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = vector.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); newInstance.set(next.getIndex(), gradient(next.getValue())); } } else { for (int i = 0; i < vector.getDimension(); i++) { newInstance.set(i, gradient(vector.get(i))); } } return newInstance; }
@Override public void funnel(DoubleVector from, PrimitiveSink into) { if (from.isSparse()) { Iterator<DoubleVectorElement> iterator = from.iterateNonZero(); while (iterator.hasNext()) { DoubleVectorElement next = iterator.next(); into.putInt(next.getIndex()); into.putDouble(next.getValue()); } } else { final int dimension = from.getDimension(); // traverse backwards, because sparse vectors are iterated descending, so // we get the same funneling for same vectors of different types. for (int i = dimension - 1; i >= 0; i--) { into.putInt(i); into.putDouble(from.get(i)); } } }
@Override public DoubleVector multiplyVectorRow(DoubleVector v) { DoubleVector vector = new DenseDoubleVector(this.getRowCount()); for (int row = 0; row < numRows; row++) { double sum = 0.0d; if (v.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); sum += (matrix[translate(row, next.getIndex(), numRows)] * next .getValue()); } } else { for (int col = 0; col < numColumns; col++) { sum += (matrix[translate(row, col, numRows)] * v.get(col)); } } vector.set(row, sum); } return vector; }
@Override public DoubleVector multiply(DoubleVector v) { DoubleVector newv = new DenseDoubleVector(this.getLength()); if (v.isSparse()) { Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); newv.set(next.getIndex(), this.get(next.getIndex()) * next.getValue()); } } else { for (int i = 0; i < v.getLength(); i++) { newv.set(i, this.get(i) * v.get(i)); } } return newv; }
@Override public final DoubleVector add(DoubleVector v) { DoubleVector newv = null; if (v.isSparse()) { newv = new DenseDoubleVector(vector); Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); newv.set(next.getIndex(), this.get(next.getIndex()) + next.getValue()); } } else { newv = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { newv.set(i, this.get(i) + v.get(i)); } } return newv; }
@Override public final DoubleVector subtract(DoubleVector v) { DoubleVector newv = null; if (v.isSparse()) { newv = new DenseDoubleVector(vector); Iterator<DoubleVectorElement> iterateNonZero = v.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); newv.set(next.getIndex(), this.get(next.getIndex()) - next.getValue()); } } else { newv = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { newv.set(i, this.get(i) - v.get(i)); } } return newv; }
@Override public DoubleVector predict(DoubleVector features) { if (features.isSparse()) { SparseDoubleVector tmp = new SparseDoubleVector( features.getDimension() + 1); tmp.set(0, 1d); Iterator<DoubleVectorElement> iterateNonZero = features.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); tmp.set(next.getIndex() + 1, next.getValue()); } features = tmp; } else { features = new DenseDoubleVector(1d, features.toArray()); } return new DenseDoubleVector(new double[]{SIGMOID.get().apply( features.dot(theta))}); }
@Override public void train(DoubleVector[] features, DoubleVector[] outcome) { Preconditions .checkArgument( features.length == outcome.length && features.length > 0, "There wasn't at least a single featurevector, or the two array didn't match in size."); this.classes = outcome[0].getDimension() == 1 ? 2 : outcome[0] .getDimension(); DoubleMatrix mat = null; if (features[0].isSparse()) { mat = new SparseDoubleRowMatrix(features); } else { mat = new DenseDoubleMatrix(features); } ConditionalLikelihoodCostFunction func = new ConditionalLikelihoodCostFunction( mat, new DenseDoubleMatrix(outcome)); DenseDoubleVector vx = new DenseDoubleVector(mat.getColumnCount() * classes); DoubleVector input = minimizer.minimize(func, vx, numIterations, verbose); theta = DenseMatrixFolder.unfoldMatrix(input, classes, (int) (input.getLength() / (double) classes)); }