public static <V extends DoubleVertex & ProbabilisticDouble> void hasNoGradientWithRespectToItsValueWhenObserved(V vertexUnderTest) { DoubleTensor ones = DoubleTensor.ones(vertexUnderTest.getValue().getShape()); vertexUnderTest.observe(ones); assertNull(vertexUnderTest.dLogProb(ones).get(vertexUnderTest)); }
@Test(expected = UnsupportedOperationException.class) public void youCannotObserveANonProbabilisticDoubleVertex() { DoubleVertex vertex = ConstantVertex.of(1.0); assertFalse(vertex instanceof Probabilistic); vertex.observe(DoubleTensor.scalar(1.0)); }
public static void main(String[] args) { //%%SNIPPET_START%% Overview DoubleVertex x = new UniformVertex(1, 2); DoubleVertex y = x.times(2); DoubleVertex observedY = new UniformVertex(new long[]{1, 2}, y, y.plus(0.5)); observedY.observe(new double[]{4.0, 4.49}); //%%SNIPPET_END%% Overview } }
@Test public void youCanObserveAProbabilisticDoubleVertex() { DoubleVertex vertex = new UniformVertex(1.0, 1.0); assertTrue(vertex instanceof Probabilistic); vertex.observe(DoubleTensor.scalar(1.0)); } }
public static <V extends DoubleVertex & ProbabilisticDouble & Differentiable> void isTreatedAsConstantWhenObserved(V vertexUnderTest) { vertexUnderTest.observe(DoubleTensor.ones(vertexUnderTest.getValue().getShape())); assertTrue(Differentiator.reverseModeAutoDiff(vertexUnderTest, vertexUnderTest).asMap().isEmpty()); }
@Test public void canObserveArrayOfValues() { DoubleVertex gaussianVertex = new GaussianVertex(0, 1); double[] observation = new double[]{1, 2, 3}; gaussianVertex.observe(observation); assertArrayEquals(observation, gaussianVertex.getValue().asFlatDoubleArray(), 0.0); }
@Category(Slow.class) @Test public void findsBothModesForContinuousNetwork() { DoubleVertex A = new UniformVertex(-3.0, 3.0); A.setValue(0.0); DoubleVertex B = A.multiply(A); DoubleVertex C = new GaussianVertex(B, 1.5); C.observe(4.0); BayesianNetwork network = new BayesianNetwork(A.getConnectedGraph()); List<NetworkState> modes = MultiModeDiscovery.findModesBySimulatedAnnealing(network, 30, 1000, random); boolean findsLowerMode = modes.stream().anyMatch(state -> Math.abs(state.get(A).scalar() + 2) < 0.01); boolean findsUpperMode = modes.stream().anyMatch(state -> Math.abs(state.get(A).scalar() - 2) < 0.01); assertTrue(findsLowerMode); assertTrue(findsUpperMode); }
@BeforeClass public static void setup() throws IOException { VertexId.ID_GENERATOR.set(0); DoubleVertex mu = new ConstantDoubleVertex(0); DoubleVertex sigma = new ConstantDoubleVertex(new double[]{3.0, 4.0}); DoubleVertex gaussianVertex = new GaussianVertex(mu, sigma); gaussianVertex.observe(DoubleTensor.ones(2)); gaussianVertex.setLabel("GaussianVertex"); net = new BayesianNetwork(gaussianVertex.getConnectedGraph()); someMetadata = ImmutableMap.of( "Author", "Some Author", "Tag", "MyBayesNet" ); JsonSaver jsonSaver = new JsonSaver(net); jsonSaver.save(outputStream, true, someMetadata); }
public SumGaussianTestCase() { A = new GaussianVertex(20.0, 1.0); B = new GaussianVertex(20.0, 1.0); A.setValue(20.0); B.setValue(20.0); DoubleVertex Cobserved = new GaussianVertex(A.plus(B), 1.0); Cobserved.observe(46.0); model = new BayesianNetwork(Arrays.asList(A, B, Cobserved)); model.probeForNonZeroProbability(100); }
private void assertCanCalculateMaxLikelihood(Function<BayesianNetwork, Optimizer> optimizerMapper) { DoubleVertex A = new GaussianVertex(20.0, 1.0); DoubleVertex B = new GaussianVertex(20.0, 1.0); A.setValue(20.0); B.setAndCascade(20.0); DoubleVertex Cobserved = new GaussianVertex(A.plus(B), 1.0); Cobserved.observe(44.0); BayesianNetwork bayesNet = new BayesianNetwork(Arrays.asList(A, B, Cobserved)); Optimizer optimizer = optimizerMapper.apply(bayesNet); optimizer.maxLikelihood(); double maxA = A.getValue().scalar(); double maxB = B.getValue().scalar(); assertEquals(44, maxA + maxB, 0.1); }
public void assertCanCalculateMaxAPosteriori(Function<BayesianNetwork, Optimizer> optimizerMapper) { DoubleVertex A = new GaussianVertex(20.0, 1.0); DoubleVertex B = new GaussianVertex(20.0, 1.0); A.setValue(21.5); B.setAndCascade(21.5); DoubleVertex Cobserved = new GaussianVertex(A.plus(B), 1.0); Cobserved.observe(46.0); BayesianNetwork bayesNet = new BayesianNetwork(Arrays.asList(A, B, Cobserved)); Optimizer optimizer = optimizerMapper.apply(bayesNet); optimizer.maxAPosteriori(); double maxA = A.getValue().scalar(); double maxB = B.getValue().scalar(); assertEquals(22, maxA, 0.1); assertEquals(22, maxB, 0.1); }
public KeanuProbabilisticModelTest(DoubleTensor initialA, DoubleTensor initialB, DoubleTensor observationD) { this.initialA = initialA; this.initialB = initialB; this.observationD = observationD; A = new GaussianVertex(initialA.getShape(), 0.0, 1.0); B = new GaussianVertex(initialB.getShape(), 0.0, 1.0); C = A.plus(B); D = new GaussianVertex(C, 1.0); A.setValue(initialA); B.setValue(initialB); D.observe(observationD); }
@Before public void setup() { random = new KeanuRandom(1); A = new GaussianVertex(5, 1); A.setValue(5.0); B = new GaussianVertex(2, 1); B.setValue(2.0); C = A.plus(B); D = new GaussianVertex(C, 1); D.observe(7.5); }
@Test public void canUseGradientBasedSamplingWithAssertVertex() { DoubleVertex A = new GaussianVertex(20.0, 1.0); DoubleVertex B = new GaussianVertex(20.0, 1.0); A.setValue(21.5); B.setAndCascade(21.5); A.greaterThan(new ConstantDoubleVertex(20)).assertTrue(); B.greaterThan(new ConstantDoubleVertex(20)).assertTrue(); DoubleVertex Cobserved = new GaussianVertex(A.plus(B), 1.0); Cobserved.observe(46.0); KeanuProbabilisticModel bayesNet = new KeanuProbabilisticModel(Arrays.asList(A, B, Cobserved)); PosteriorSamplingAlgorithm samplingAlgorithm = Keanu.Sampling.MCMC.withDefaultConfigFor(bayesNet); assertThat(samplingAlgorithm, instanceOf(NUTS.class)); }
@Test public void canObserveTensor() { DoubleVertex gaussianVertex = new GaussianVertex(0, 1); DoubleTensor observation = Nd4jDoubleTensor.create(new double[]{1, 2, 3, 4}, new long[]{2, 2}); gaussianVertex.observe(observation); assertArrayEquals(observation.asFlatDoubleArray(), gaussianVertex.getValue().asFlatDoubleArray(), 0.0); assertArrayEquals(observation.getShape(), gaussianVertex.getShape()); }
private void assertOptimizerWorksWithDeterminant(double inputGaussianMu) { final long[] shape = new long[]{2, 2}; final DoubleVertex input = new GaussianVertex(shape, inputGaussianMu, 5); final DoubleVertex determinant = input.matrixDeterminant(); final DoubleVertex output = new GaussianVertex(determinant, 1); output.observe(new double[]{2.0, 2.4}); final BayesianNetwork net = new BayesianNetwork(output.getConnectedGraph()); KeanuOptimizer.of(net).maxLikelihood(); assertEquals(input.getValue().determinant(), 2.2, 0.1); }
@Test public void valuesAreBeingWrittenOut() throws IOException { DoubleVertex unobservedGaussianVertex = new GaussianVertex(0, 1); DoubleVertex observedGammaVertex = new GammaVertex(2, 3); observedGammaVertex.observe(2.5); DoubleVertex gammaMultipliedVertex = observedGammaVertex.times(new ConstantDoubleVertex(4)); Vertex resultVertex = gammaMultipliedVertex.plus(unobservedGaussianVertex); gammaMultipliedVertex.setLabel("Gamma Multiplied"); DotSaver dotSaver = new DotSaver(new BayesianNetwork(resultVertex.getConnectedGraph())); dotSaver.save(outputWriter, true); String expectedOutputWithValues = readFileToString(OUTPUT_WITH_VALUES_FILENAME); checkDotFilesMatch(outputWriter.toString(), expectedOutputWithValues); }
@Test public void calculatesBoundsWhenAllAreSpecified() { DoubleVertex A = new UniformVertex(new long[]{2}, -2, 1); DoubleVertex B = new UniformVertex(new long[]{2}, -2, 1); B.observe(2); DoubleVertex D = A.plus(B); OptimizerBounds bounds = new OptimizerBounds(); bounds.addBound(A.getId(), DoubleTensor.create(-2, -1), 1); ApacheMathSimpleBoundsCalculator boundsCalculator = new ApacheMathSimpleBoundsCalculator(Double.POSITIVE_INFINITY, bounds); ImmutableList<DoubleVertex> latentVertices = ImmutableList.of(A); SimpleBounds simpleBounds = boundsCalculator.getBounds(latentVertices, new double[]{0, 0, 0}); assertArrayEquals(new double[]{-2, -1}, simpleBounds.getLower(), 0.0); assertArrayEquals(new double[]{1, 1}, simpleBounds.getUpper(), 0.0); }
@Ignore public void doesSimpleTensorInferenceExample() { //%%SNIPPET_START%% TensorExample DoubleVertex muA = ConstantVertex.of(new double[]{0.5, 1.5}); DoubleVertex A = new GaussianVertex(new long[]{1, 2}, muA, 1); DoubleVertex B = ConstantVertex.of(new double[]{3, 4}); DoubleVertex C = A.times(B); DoubleVertex CObservation = new GaussianVertex(C, 1); CObservation.observe(new double[]{6, 12}); //Use algorithm to find MAP or posterior samples for A and/or B Optimizer optimizer = KeanuOptimizer.of(new BayesianNetwork(A.getConnectedGraph())); optimizer.maxLikelihood(); //%%SNIPPET_END%% TensorExample assertArrayEquals(new double[]{2.0, 3.0}, A.getValue().asFlatDoubleArray(), 1e-2); }
@Category(Slow.class) @Test public void inferenceWorksOnGraph() { final int NUM_SAMPLES = 50000; final double REAL_HYPER_LOC = 5.1; final double REAL_HYPER_SIZE = 1.0; trueLocation.setValue(9.9); size.setValue(9.9); GaussianVertex sourceOfTruth = new GaussianVertex(new long[]{NUM_SAMPLES, 1}, REAL_HYPER_LOC, REAL_HYPER_SIZE); gaussOutputVertex.observe(sourceOfTruth.sample()); GradientOptimizer optimizer = KeanuOptimizer.Gradient.of(outerNet); optimizer.maxAPosteriori(); assertEquals(trueLocation.getValue().scalar(), REAL_HYPER_LOC, 0.05); assertEquals(size.getValue().scalar(), REAL_HYPER_SIZE, 0.05); }