/**
* Standard 2D tracking model with the following state equation: {@latex[ D_ x_t = G x_ t-1} + A
* \epsilon_t} Also, when angle != null, a constraint matrix is created for the state covariance,
* with perpendicular variance a0Variance.
*
* @param gVariance
* @param aVariance
* @param a0Variance
* @param angle
*/
public Standard2DTrackingFilter(
double gVariance, double aVariance, double a0Variance, Double angle) {
super(
VectorFactory.getDefault().createVector(4),
createStateCovarianceMatrix(1d, aVariance, a0Variance, angle),
MatrixFactory.getDefault().createIdentity(2, 2).scale(gVariance));
this.aVariance = aVariance;
this.gVariance = gVariance;
this.a0Variance = a0Variance;
this.angle = angle;
final LinearDynamicalSystem model = new LinearDynamicalSystem(0, 4);
final Matrix Gct = createStateTransitionMatrix(currentTimeDiff);
final Matrix G = MatrixFactory.getDefault().createIdentity(4, 4);
G.setSubMatrix(0, 0, Gct);
model.setA(G);
model.setB(MatrixFactory.getDefault().createMatrix(4, 4));
model.setC(O);
this.model = model;
}
/** Test of createUniformRandom method, of class MatrixFactory. */
public void testCreateUniformRandom() {
System.out.println("createUniformRandom");
Matrix m = this.createRandomMatrix();
MatrixFactory<?> factory = this.createFactory();
int M = m.getNumRows();
int N = m.getNumColumns();
Matrix mr = factory.createUniformRandom(M, N, -RANGE, RANGE, random);
assertNotNull(mr);
assertNotSame(m, mr);
assertEquals(M, mr.getNumRows());
assertEquals(N, mr.getNumColumns());
boolean nonzero = false;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
double value = mr.getElement(i, j);
if (value != 0.0) {
nonzero = true;
if ((value < -RANGE) || (value > RANGE)) {
fail("Nonzero value outside the given range!");
}
}
}
}
if (!nonzero) {
fail("I didn't find any nonzero values in your random matrix!!");
}
}
public void testCreateMatrixWithInitialValue() {
Matrix matrix = this.createRandomMatrix();
int M = matrix.getNumRows();
int N = matrix.getNumColumns();
MatrixFactory<?> factory = this.createFactory();
double initialValue = this.random.nextGaussian();
Matrix m3 = factory.createMatrix(M, N, initialValue);
assertNotNull(m3);
assertEquals(M, m3.getNumRows());
assertEquals(N, m3.getNumColumns());
boolean hasNonZero = false;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
double value = m3.getElement(i, j);
if (value != 0.0) {
hasNonZero = true;
assertEquals(initialValue, value, 0.0);
}
}
}
assertTrue(hasNonZero);
}
/** Test of copyArray method, of class MatrixFactory. */
public void testCopyArray() {
System.out.println("copyArray");
MatrixFactory<?> instance = this.createFactory();
Matrix matrix = this.createRandomMatrix();
int M = matrix.getNumRows();
int N = matrix.getNumColumns();
double[][] values = new double[M][N];
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
values[i][j] = matrix.getElement(i, j);
}
}
Matrix copy = instance.copyArray(values);
assertNotNull(copy);
assertNotSame(matrix, copy);
assertEquals(matrix, copy);
matrix.scaleEquals(random.nextDouble());
assertFalse(matrix.equals(copy));
Matrix m00 = instance.copyArray(new double[0][0]);
assertEquals(0, m00.getNumRows());
assertEquals(0, m00.getNumColumns());
}
@Override
public Matrix init(int rows, int cols) {
final SparseMatrix rand = (SparseMatrix) smf.createUniformRandom(rows, cols, min, max, random);
final Matrix ret = smf.createMatrix(rows, cols);
for (int i = 0; i < rows; i++) {
if (this.random.nextDouble() > sparcity) {
ret.setRow(i, rand.getRow(i));
}
}
return ret;
}
/** Test of copyMatrix method, of class MatrixFactory. */
public void testCopyMatrix() {
System.out.println("copyMatrix");
MatrixFactory<?> instance = this.createFactory();
Matrix matrix = this.createRandomMatrix();
assertNotNull(matrix);
Matrix copy = instance.copyMatrix(matrix);
assertNotNull(copy);
assertNotSame(matrix, copy);
assertEquals(matrix, copy);
matrix.scaleEquals(random.nextDouble());
assertFalse(matrix.equals(copy));
}
@Override
protected boolean initializeAlgorithm() {
// Due to bizarre inheretance, this.data is the function to minimize...
DifferentiableEvaluator<? super Vector, Double, Vector> f = this.data;
this.result =
new DefaultInputOutputPair<Vector, Double>(
this.initialGuess.clone(), f.evaluate(this.initialGuess));
this.gradient = f.differentiate(this.initialGuess);
// Load up the line function with the current direction and
// the search direction, which is the negative gradient, in other words
// the direction of steepest descent
this.lineFunction =
new DirectionalVectorToDifferentiableScalarFunction(
f, this.result.getInput(), this.gradient.scale(-1.0));
this.dimensionality = this.initialGuess.getDimensionality();
this.hessianInverse =
MatrixFactory.getDefault()
.createIdentity(this.dimensionality, this.dimensionality)
.scale(0.5)
// .scale( Math.sqrt(this.getTolerance()) )
;
return true;
}
/** Path & edge are the same, directions are reverse, neg. to pos. */
@Test
public void testPathStateConvert7() {
final Path startPath =
TestUtils.makeTmpPath(
graph,
true,
new Coordinate(20, -10),
new Coordinate(10, -10),
new Coordinate(10, 0),
new Coordinate(0, 0));
final Matrix covar =
MatrixFactory.getDefault()
.copyArray(new double[][] {new double[] {126.56, 8.44}, new double[] {8.44, 0.56}});
final MultivariateGaussian startBelief =
new AdjMultivariateGaussian(VectorFactory.getDefault().createVector2D(-2.5d, 1d), covar);
final PathStateDistribution currentBelief = new PathStateDistribution(startPath, startBelief);
final Path newPath =
TestUtils.makeTmpPath(graph, false, new Coordinate(10, 0), new Coordinate(0, 0));
final PathStateDistribution result = currentBelief.convertToPath(newPath);
AssertJUnit.assertEquals("distance", 7.5d, result.getMean().getElement(0), 0d);
AssertJUnit.assertEquals("velocity", 1d, result.getMean().getElement(1), 0d);
}
@Test
public void testPathStateConvert2() {
final Path startPath =
TestUtils.makeTmpPath(graph, false, new Coordinate(0, 0), new Coordinate(10, 0));
final Matrix covar =
MatrixFactory.getDefault()
.copyArray(new double[][] {new double[] {126.56, 8.44}, new double[] {8.44, 0.56}});
final MultivariateGaussian startBelief =
new AdjMultivariateGaussian(VectorFactory.getDenseDefault().createVector2D(0d, 1d), covar);
final PathStateDistribution currentBelief = new PathStateDistribution(startPath, startBelief);
final Vector groundLoc =
MotionStateEstimatorPredictor.getOg()
.times(currentBelief.getGroundDistribution().getMean());
AssertJUnit.assertEquals("initial state x", 0d, groundLoc.getElement(0), 0d);
AssertJUnit.assertEquals("initial state y", 0d, groundLoc.getElement(1), 0d);
final Path newPath =
TestUtils.makeTmpPath(
graph,
true,
new Coordinate(20, -10),
new Coordinate(10, -10),
new Coordinate(10, 0),
new Coordinate(0, 0));
final PathStateDistribution result = currentBelief.convertToPath(newPath);
AssertJUnit.assertEquals("distance", -0d, result.getMean().getElement(0), 0d);
AssertJUnit.assertEquals("velocity", -1d, result.getMean().getElement(1), 0d);
}
public class SparseRowRandomInitStrategy implements InitStrategy {
MatrixFactory<? extends Matrix> smf = MatrixFactory.getSparseDefault();
private double min;
private double max;
private Random random;
private double sparcity;
public SparseRowRandomInitStrategy(double min, double max, double sparcity, Random random) {
this.min = min;
this.max = max;
this.random = random;
this.sparcity = sparcity;
}
@Override
public Matrix init(int rows, int cols) {
final SparseMatrix rand = (SparseMatrix) smf.createUniformRandom(rows, cols, min, max, random);
final Matrix ret = smf.createMatrix(rows, cols);
for (int i = 0; i < rows; i++) {
if (this.random.nextDouble() > sparcity) {
ret.setRow(i, rand.getRow(i));
}
}
return ret;
}
}
private static Matrix getVarianceConstraintMatrix(
double aVariance, double a0Variance, Double angle) {
if (angle == null) return MatrixFactory.getDefault().createIdentity(2, 2).scale(aVariance);
final Matrix rotationMatrix = MatrixFactory.getDefault().createIdentity(2, 2);
rotationMatrix.setElement(0, 0, Math.cos(angle));
rotationMatrix.setElement(0, 1, -Math.sin(angle));
rotationMatrix.setElement(1, 0, Math.sin(angle));
rotationMatrix.setElement(1, 1, Math.cos(angle));
final Matrix temp =
MatrixFactory.getDefault()
.createDiagonal(
VectorFactory.getDefault().copyArray(new double[] {a0Variance, aVariance}));
return rotationMatrix.times(temp).times(rotationMatrix.transpose());
}
private static Matrix createStateTransitionMatrix(double timeDiff) {
final Matrix Gct = MatrixFactory.getDefault().createIdentity(4, 4);
Gct.setElement(0, 1, timeDiff);
Gct.setElement(2, 3, timeDiff);
return Gct;
}
@Override
public Matrix init(int rows, int cols) {
final Matrix ret = smf.createMatrix(rows, cols);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (this.random.nextDouble() > sparcity) ret.setElement(i, j, 1d);
}
}
return ret;
}
/**
* Creates a uniform transition-probability Matrix
*
* @param numStates Number of states to create the Matrix for
* @return Uniform probability Matrix.
*/
protected static Matrix createUniformTransitionProbability(int numStates) {
Matrix A = MatrixFactory.getDefault().createMatrix(numStates, numStates);
final double p = 1.0 / numStates;
for (int i = 0; i < numStates; i++) {
for (int j = 0; j < numStates; j++) {
A.setElement(i, j, p);
}
}
return A;
}
/**
* Computes the pair-wise confidence test results
*
* @param data Data from each treatment to consider
* @param pairwiseTest Confidence test used for pair-wise null-hypothesis tests.
*/
protected void computePairwiseTestResults(
final Collection<? extends Collection<? extends Number>> data,
final NullHypothesisEvaluator<Collection<? extends Number>> pairwiseTest) {
ArrayList<? extends Collection<? extends Number>> treatments =
CollectionUtil.asArrayList(data);
final int K = treatments.size();
Matrix Z = MatrixFactory.getDefault().createMatrix(K, K);
Matrix P = MatrixFactory.getDefault().createMatrix(K, K);
ArrayList<ArrayList<ConfidenceStatistic>> stats =
new ArrayList<ArrayList<ConfidenceStatistic>>(K);
for (int i = 0; i < K; i++) {
ArrayList<ConfidenceStatistic> comp = new ArrayList<ConfidenceStatistic>(K);
for (int j = 0; j < K; j++) {
comp.add(null);
}
stats.add(comp);
}
for (int i = 0; i < K; i++) {
// Comparisons to ourselves are perfect
Z.setElement(i, i, 0.0);
P.setElement(i, i, 1.0);
Collection<? extends Number> datai = treatments.get(i);
for (int j = i + 1; j < K; j++) {
Collection<? extends Number> dataj = treatments.get(j);
ConfidenceStatistic comparison = pairwiseTest.evaluateNullHypothesis(datai, dataj);
final double pij = comparison.getNullHypothesisProbability();
final double zij = comparison.getTestStatistic();
Z.setElement(i, j, zij);
Z.setElement(j, i, zij);
P.setElement(i, j, pij);
P.setElement(j, i, pij);
stats.get(i).set(j, comparison);
stats.get(j).set(i, comparison);
}
}
this.testStatistics = Z;
this.nullHypothesisProbabilities = P;
this.pairwiseTestStatistics = stats;
}
/** Test of createMatrix method, of class MatrixFactory. */
public void testCreateMatrix() {
System.out.println("createMatrix");
Matrix matrix = this.createRandomMatrix();
int M = matrix.getNumRows();
int N = matrix.getNumColumns();
MatrixFactory<?> factory = this.createFactory();
Matrix m2 = factory.createMatrix(M, N);
assertNotNull(m2);
assertNotSame(matrix, m2);
assertEquals(M, m2.getNumRows());
assertEquals(N, m2.getNumColumns());
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
assertEquals(0.0, m2.getElement(i, j));
}
}
}
@Override
public void performExperiment() throws IOException {
BilinearLearnerParameters params = new BilinearLearnerParameters();
params.put(BilinearLearnerParameters.ETA0_U, 0.02);
params.put(BilinearLearnerParameters.ETA0_W, 0.02);
params.put(BilinearLearnerParameters.LAMBDA, 0.001);
params.put(BilinearLearnerParameters.BICONVEX_TOL, 0.01);
params.put(BilinearLearnerParameters.BICONVEX_MAXITER, 10);
params.put(BilinearLearnerParameters.BIAS, true);
params.put(BilinearLearnerParameters.ETA0_BIAS, 0.5);
params.put(BilinearLearnerParameters.WINITSTRAT, new SingleValueInitStrat(0.1));
params.put(BilinearLearnerParameters.UINITSTRAT, new SparseZerosInitStrategy());
BillMatlabFileDataGenerator bmfdg =
new BillMatlabFileDataGenerator(new File(BILL_DATA()), 98, true);
prepareExperimentLog(params);
for (int i = 0; i < bmfdg.nFolds(); i++) {
logger.debug("Fold: " + i);
BilinearSparseOnlineLearner learner = new BilinearSparseOnlineLearner(params);
learner.reinitParams();
bmfdg.setFold(i, Mode.TEST);
List<Pair<Matrix>> testpairs = new ArrayList<Pair<Matrix>>();
while (true) {
Pair<Matrix> next = bmfdg.generate();
if (next == null) break;
testpairs.add(next);
}
logger.debug("...training");
bmfdg.setFold(i, Mode.TRAINING);
int j = 0;
while (true) {
Pair<Matrix> next = bmfdg.generate();
if (next == null) break;
logger.debug("...trying item " + j++);
learner.process(next.firstObject(), next.secondObject());
Matrix u = learner.getU();
Matrix w = learner.getW();
Matrix bias = MatrixFactory.getDenseDefault().copyMatrix(learner.getBias());
BilinearEvaluator eval = new RootMeanSumLossEvaluator();
eval.setLearner(learner);
double loss = eval.evaluate(testpairs);
logger.debug(String.format("Saving learner, Fold %d, Item %d", i, j));
File learnerOut = new File(FOLD_ROOT(i), String.format("learner_%d", j));
IOUtils.writeBinary(learnerOut, learner);
logger.debug("W row sparcity: " + SandiaMatrixUtils.rowSparcity(w));
logger.debug("U row sparcity: " + SandiaMatrixUtils.rowSparcity(u));
Boolean biasMode = learner.getParams().getTyped(BilinearLearnerParameters.BIAS);
if (biasMode) {
logger.debug("Bias: " + SandiaMatrixUtils.diag(bias));
}
logger.debug(String.format("... loss: %f", loss));
}
}
}
/** Test of createDiagonal method, of class MatrixFactory. */
public void testCreateDiagonal() {
System.out.println("createDiagonal");
Vector diagonal =
VectorFactory.getDefault()
.copyValues(random.nextGaussian(), random.nextGaussian(), random.nextGaussian());
int M = diagonal.getDimensionality();
MatrixFactory<?> instance = this.createFactory();
Matrix diag = instance.createDiagonal(diagonal);
assertNotNull(diag);
assertEquals(M, diag.getNumRows());
assertEquals(M, diag.getNumColumns());
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
if (i == j) {
assertEquals(diagonal.getElement(i), diag.getElement(i, j));
} else {
assertEquals(0.0, diag.getElement(i, j));
}
}
}
}
/** Test of copyColumnVectors method, of class MatrixFactory. */
public void testCopyColumnVectors_VectorizableArr() {
System.out.println("copyColumnVectors");
Matrix m = this.createRandomMatrix();
int M = m.getNumRows();
int N = m.getNumColumns();
Vector[] cols = new Vector[N];
for (int j = 0; j < N; j++) {
cols[j] = m.getColumn(j);
}
MatrixFactory<?> factory = this.createFactory();
@SuppressWarnings("unchecked")
Matrix mr = factory.copyColumnVectors(cols);
assertNotNull(mr);
assertNotSame(m, mr);
assertEquals(m, mr);
for (int j = 0; j < N; j++) {
assertEquals(m.getColumn(j), mr.getColumn(j));
}
}
/** Test of copyColumnVectors method, of class MatrixFactory. */
public void testCopyColumnVectors_Collection() {
System.out.println("copyColumnVectors");
Matrix m = this.createRandomMatrix();
int M = m.getNumRows();
int N = m.getNumColumns();
ArrayList<Vector> cols = new ArrayList<Vector>(M);
for (int j = 0; j < N; j++) {
cols.add(m.getColumn(j));
}
MatrixFactory<?> factory = this.createFactory();
@SuppressWarnings("unchecked")
Matrix mr = factory.copyColumnVectors(cols);
assertNotNull(mr);
assertNotSame(m, mr);
assertEquals(m, mr);
for (int j = 0; j < N; j++) {
assertEquals(m.getColumn(j), mr.getColumn(j));
}
}
/** Test of copyRowVectors method, of class MatrixFactory. */
public void testCopyRowVectors_VectorizableArr() {
System.out.println("copyRowVectors");
Matrix m = this.createRandomMatrix();
int M = m.getNumRows();
int N = m.getNumColumns();
Vector[] rows = new Vector[M];
for (int i = 0; i < M; i++) {
rows[i] = m.getRow(i);
}
MatrixFactory<?> factory = this.createFactory();
@SuppressWarnings("unchecked")
Matrix mr = factory.copyRowVectors(rows);
assertNotNull(mr);
assertNotSame(m, mr);
assertEquals(m, mr);
for (int i = 0; i < M; i++) {
assertEquals(m.getRow(i), mr.getRow(i));
}
}
/** Test of createIdentity method, of class MatrixFactory. */
public void testCreateIdentity() {
System.out.println("createIdentity");
Matrix matrix = this.createRandomMatrix();
int M = matrix.getNumRows();
int N = matrix.getNumColumns();
MatrixFactory<?> instance = this.createFactory();
Matrix ident = instance.createIdentity(M, N);
assertNotNull(ident);
assertNotSame(matrix, ident);
assertEquals(M, ident.getNumRows());
assertEquals(N, ident.getNumColumns());
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
if (i == j) {
assertEquals(1.0, ident.getElement(i, j));
} else {
assertEquals(0.0, ident.getElement(i, j));
}
}
}
}
private static Matrix createStateCovarianceMatrix(
double timeDiff, double aVariance, double a0Variance, Double angle) {
final Matrix A_half = MatrixFactory.getDefault().createMatrix(4, 2);
A_half.setElement(0, 0, Math.pow(timeDiff, 2) / 2d);
A_half.setElement(1, 0, timeDiff);
A_half.setElement(2, 1, Math.pow(timeDiff, 2) / 2d);
A_half.setElement(3, 1, timeDiff);
final Matrix Q = getVarianceConstraintMatrix(aVariance, a0Variance, angle);
final Matrix A = A_half.times(Q).times(A_half.transpose());
return A;
}
public static Matrix vstack(MatrixFactory<? extends Matrix> matrixFactory, Matrix... matricies) {
int nrows = 0;
int ncols = 0;
for (Matrix matrix : matricies) {
nrows += matrix.getNumRows();
ncols = matrix.getNumColumns();
}
Matrix ret = matrixFactory.createMatrix(nrows, ncols);
int currentRow = 0;
for (Matrix matrix : matricies) {
ret.setSubMatrix(currentRow, 0, matrix);
currentRow += matrix.getNumRows();
}
return ret;
}
public class SparseOnesInitStrategy implements InitStrategy {
MatrixFactory<? extends Matrix> smf = MatrixFactory.getSparseDefault();
private Random random;
private double sparcity;
public SparseOnesInitStrategy(double sparcity, Random random) {
this.random = random;
this.sparcity = sparcity;
}
@Override
public Matrix init(int rows, int cols) {
final Matrix ret = smf.createMatrix(rows, cols);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (this.random.nextDouble() > sparcity) ret.setElement(i, j, 1d);
}
}
return ret;
}
}
@Test(enabled = false, expectedExceptions = IllegalStateException.class)
public void testBadConversion() {
final Path startPath =
TestUtils.makeTmpPath(graph, true, new Coordinate(20, -10), new Coordinate(10, -10));
final Matrix covar =
MatrixFactory.getDefault()
.copyArray(new double[][] {new double[] {126.56, 8.44}, new double[] {8.44, 0.56}});
final MultivariateGaussian startBelief =
new AdjMultivariateGaussian(
VectorFactory.getDefault().createVector2D(-0d, -5d / 30d), covar);
final PathStateDistribution currentBelief = new PathStateDistribution(startPath, startBelief);
final Path newPath =
TestUtils.makeTmpPath(
graph,
true,
new Coordinate(20, -10),
new Coordinate(10, -10),
new Coordinate(10, 0),
new Coordinate(0, 0));
PathUtils.checkAndGetConvertedBelief(currentBelief, newPath);
}
/** Test of getDiagonalDefault method, of class MatrixFactory. */
public void testGetDiagonalDefault() {
System.out.println("getDiagonalDefault");
MatrixFactory<? extends DiagonalMatrix> result = MatrixFactory.getDiagonalDefault();
assertSame(MatrixFactory.DEFAULT_DIAGONAL_INSTANCE, result);
}
/** Test of getSparseDefault method, of class MatrixFactory. */
public void testGetSparseDefault() {
System.out.println("getDefault");
MatrixFactory<? extends Matrix> result = MatrixFactory.getSparseDefault();
assertSame(MatrixFactory.DEFAULT_SPARSE_INSTANCE, result);
}
static {
O = MatrixFactory.getDefault().createMatrix(2, 4);
O.setElement(0, 0, 1);
O.setElement(1, 2, 1);
}
public static Matrix vstack(Matrix... matricies) {
return vstack(MatrixFactory.getDefault(), matricies);
}