@Override public DoubleMatrix deepCopy() { return new SparseDoubleRowMatrix(this); }
private MarkovChain(int numStates) { this(numStates, new SparseDoubleRowMatrix(numStates, numStates)); }
/** * Decodes the given observation sequence (features) with the current HMM. * This discovers the best hidden state sequence Q that is derived by * executing the Viterbi algorithm with the given observations and the HMM's * parameters lambda. This is a proxy to {@link ViterbiUtils} * {@link #decode(DoubleVector[], DoubleVector[])}. * * @param observationSequence the given sequence of features. * @return a matrix containing the predicted hidden state on each row vector. */ public DoubleMatrix decode(DoubleVector[] observationSequence, DoubleVector[] featuresPerHiddenState) { return ViterbiUtils.decode(emissionProbabilityMatrix, new SparseDoubleRowMatrix(observationSequence), new SparseDoubleRowMatrix(featuresPerHiddenState), numHiddenStates); }
public DoubleVector predict(DoubleVector feature, DoubleVector[] featuresPerState) { return ViterbiUtils.decode(theta, new SparseDoubleRowMatrix(Collections.singletonList(feature)), new SparseDoubleRowMatrix(featuresPerState), classes).getRowVector(0); }
@Override public DoubleMatrix transpose() { SparseDoubleRowMatrix m = new SparseDoubleRowMatrix(this.numColumns, this.numRows); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); m.set(e.getIndex(), row, e.getValue()); } } return m; }
@Override public DoubleMatrix slice(int rowOffset, int rowMax, int colOffset, int colMax) { DoubleMatrix m = new SparseDoubleRowMatrix(rowMax - rowOffset, colMax - colOffset); for (int col : columnIndices()) { DoubleVector columnVector = getColumnVector(col); columnVector = columnVector.slice(rowOffset, rowMax); m.setColumnVector(col - colOffset, columnVector); } return m; }
@Override public DoubleMatrix multiply(double scalar) { DoubleMatrix result = new SparseDoubleRowMatrix(this); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); result.set(row, e.getIndex(), get(row, e.getIndex()) * scalar); } } return result; }
@Override public DoubleMatrix subtractBy(double amount) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterate = matrix.get(row).iterate(); while (iterate.hasNext()) { DoubleVectorElement e = iterate.next(); result.set(row, e.getIndex(), amount - e.getValue()); } } return result; }
@Override public DoubleMatrix divide(double scalar) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); result.set(row, e.getIndex(), e.getValue() / scalar); } } return result; }
@Override public DoubleMatrix subtract(double amount) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterate = matrix.get(row).iterate(); while (iterate.hasNext()) { DoubleVectorElement e = iterate.next(); result.set(row, e.getIndex(), e.getValue() - amount); } } return result; }
@Override public DoubleMatrix divide(DoubleVector vec) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { SparseDoubleVector rowVector = matrix.get(row); Iterator<DoubleVectorElement> iterateNonZero = rowVector.iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement next = iterateNonZero.next(); result.set(row, next.getIndex(), next.getValue() / vec.get(row)); } } return result; }
protected DoubleMatrix newInstance(DoubleMatrix mat) { if (mat.isSparse()) { return new SparseDoubleRowMatrix(mat.getRowCount(), mat.getColumnCount()); } else { return new DenseDoubleMatrix(mat.getRowCount(), mat.getColumnCount()); } }
@Override public DoubleMatrix subtract(DoubleMatrix other) { SparseDoubleRowMatrix result = new SparseDoubleRowMatrix( other.getRowCount(), other.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterate = matrix.get(row).iterate(); while (iterate.hasNext()) { DoubleVectorElement e = iterate.next(); result.set(row, e.getIndex(), e.getValue() - other.get(row, e.getIndex())); } } return result; }
@Override public DoubleMatrix add(DoubleMatrix other) { SparseDoubleRowMatrix result = new SparseDoubleRowMatrix( other.getRowCount(), other.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterate = matrix.get(row).iterate(); while (iterate.hasNext()) { DoubleVectorElement e = iterate.next(); result.set(row, e.getIndex(), e.getValue() + other.get(row, e.getIndex())); } } return result; }
@Override public DoubleMatrix multiplyElementWise(DoubleMatrix other) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); result.set(row, e.getIndex(), get(row, e.getIndex()) * other.get(row, e.getIndex())); } } return result; }
@Override public DoubleMatrix subtract(DoubleVector vec) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { SparseDoubleVector rowVec = matrix.get(row); result.setRowVector(row, rowVec.subtract(vec.get(row))); } return result; }
@Override public DoubleMatrix pow(double x) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), this.getColumnCount()); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); if (x != 2d) { result.set(row, e.getIndex(), Math.pow(get(row, e.getIndex()), x)); } else { double res = get(row, e.getIndex()); result.set(row, e.getIndex(), res * res); } } } return result; }
@Override public DoubleMatrix multiply(DoubleMatrix other) { DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(), other.getColumnCount()); for (int row = 0; row < getRowCount(); row++) { for (int col = 0; col < other.getColumnCount(); col++) { double sum = 0; Iterator<DoubleVectorElement> kIterator = getRowVector(row) .iterateNonZero(); while (kIterator.hasNext()) { DoubleVectorElement k = kIterator.next(); double val = other.get(k.getIndex(), col); if (val != 0d) { sum += k.getValue() * val; } } result.set(row, col, sum); } } return result; }
@Override public DoubleMatrix divide(DoubleMatrix other) { SparseDoubleRowMatrix m = new SparseDoubleRowMatrix(other); for (int row : this.matrix.keys()) { Iterator<DoubleVectorElement> iterateNonZero = matrix.get(row) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); m.set(row, e.getIndex(), get(row, e.getIndex()) / other.get(row, e.getIndex())); } } for (int col : other.columnIndices()) { Iterator<DoubleVectorElement> iterateNonZero = other.getColumnVector(col) .iterateNonZero(); while (iterateNonZero.hasNext()) { DoubleVectorElement e = iterateNonZero.next(); m.set(e.getIndex(), col, get(e.getIndex(), col) / other.get(e.getIndex(), col)); } } return m; }
@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)); }