/** * @param model network for which to choose sampling algorithm. * @return recommended sampling algorithm for this network. */ public PosteriorSamplingAlgorithm withDefaultConfigFor(KeanuProbabilisticModel model) { return withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()); }
default T sampleWithShape(long[] shape) { return sampleWithShape(shape, KeanuRandom.getDefaultRandom()); } }
public static io.improbable.keanu.algorithms.mcmc.nuts.NUTS withDefaultConfig() { return withDefaultConfig(KeanuRandom.getDefaultRandom()); }
default T sample() { return sample(KeanuRandom.getDefaultRandom()); }
default T sampleManyScalars(long[] shape) { return sampleManyScalars(shape, KeanuRandom.getDefaultRandom()); }
public T calculate() { return sample(KeanuRandom.getDefaultRandom()); }
public static io.improbable.keanu.algorithms.mcmc.MetropolisHastings withDefaultConfigFor(KeanuProbabilisticModel model) { return withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()); }
public static io.improbable.keanu.algorithms.mcmc.SimulatedAnnealing withDefaultConfigFor(KeanuProbabilisticModel model) { return withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()); }
@Test public void sampleManyScalarsUsesInputShape() { SamplableWithManyScalars<BooleanTensor> samplable = mockSamplable(Tensor.SCALAR_SHAPE); BooleanTensor result = samplable.sampleManyScalars(SHAPE); verify(samplable).sampleWithShape(SHAPE, KeanuRandom.getDefaultRandom()); assertThat(result, hasShape(SHAPE)); }
@Test public void sampleUsesShapeOfTensor() { SamplableWithManyScalars<BooleanTensor> samplable = mockSamplable(SHAPE); BooleanTensor result = samplable.sample(); verify(samplable).sampleWithShape(SHAPE, KeanuRandom.getDefaultRandom()); assertThat(result, hasShape(samplable.getShape())); }
private static double calculateMeanOfVertex(IntegerVertex vertex) { KeanuProbabilisticModel model = new KeanuProbabilisticModel(vertex.getConnectedGraph()); return MetropolisHastings.withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()) .generatePosteriorSamples(model, Collections.singletonList(vertex)).stream() .limit(2000) .collect(Collectors.averagingInt((NetworkSample state) -> state.get(vertex).scalar())); } }
@Test public void itThrowsIfYouUseItOnADiscreteVariable() { thrown.expect(IllegalStateException.class); thrown.expectMessage("Gaussian proposal function cannot be used for discrete variable"); PoissonVertex poisson = new PoissonVertex(1.); proposalDistribution.getProposal(ImmutableSet.of(poisson), KeanuRandom.getDefaultRandom()); } }
@Test public void youCanSampleAScalarMultipleTimes() { double mu = 10.; double sigma = .5; DoubleVertexSamples samples = generateGaussianSamples(mu, sigma, 2); KDEVertex KDE = GaussianKDE.approximate(samples); int numSamples = 100; DoubleTensor sample = KDE.sample(numSamples, KeanuRandom.getDefaultRandom()); assertThat(sample, hasShape(100)); }
@Test public void gaussianSampleMethodMatchesLogProbMethod() { double mu = 10.; double sigma = .5; DoubleVertexSamples samples = generateGaussianSamples(mu, sigma, 10000); KDEVertex KDE = GaussianKDE.approximate(samples); double from = -3; double to = 3; double bucketSize = 0.1; ProbabilisticDoubleTensorContract.sampleUnivariateMethodMatchesLogProbMethod( KDE, from, to, bucketSize, 1e-2, KeanuRandom.getDefaultRandom(), 1000 ); }
private double[] generateUniformRandomArray(int length) { ContinuousDistribution uniform = Uniform.withParameters(DoubleTensor.ZERO_SCALAR, DoubleTensor.scalar(1000)); return uniform.sample(new long[]{length}, KeanuRandom.getDefaultRandom()).asFlatDoubleArray(); }
@Test public void itWorksWithScalars() { int n = 100; DoubleTensor p = DoubleTensor.create(new double[]{0.01, 0.09, 0.9}, 3, 1); MultinomialVertex multinomial = new MultinomialVertex(n, ConstantVertex.of(p)); IntegerTensor samples = multinomial.sample(KeanuRandom.getDefaultRandom()); assertThat(samples, hasShape(3, 1)); assertThat(samples, allValues(both(greaterThan(-1)).and(lessThan(n)))); }
@Test(expected = IllegalArgumentException.class) public void whenYouSampleYouMustMatchMusShape() { DoubleTensor mu = DoubleTensor.create(new double[]{0, 0}, 2, 1); DoubleTensor sigma = DoubleTensor.create(new double[]{1}, 1); ContinuousDistribution mvg = MultivariateGaussian.withParameters(mu, sigma); mvg.sample(new long[]{2, 2}, KeanuRandom.getDefaultRandom()); } }
@Test public void youCanSampleWithATensorIfNIsScalarAndPIsAColumnVector() { int n = 100; DoubleTensor p = DoubleTensor.create(0.1, 0.2, .3, 0.4).reshape(4, 1); Multinomial multinomial = Multinomial.withParameters(IntegerTensor.scalar(n).reshape(1, 1), p); IntegerTensor samples = multinomial.sample(new long[]{2, 2}, KeanuRandom.getDefaultRandom()); assertThat(samples, hasShape(4, 2, 2)); assertThat(samples, allValues(both(greaterThan(-1)).and(lessThan(n)))); }
@Test(expected = IllegalArgumentException.class) public void itThrowsIfTheSampleShapeDoesntMatchTheShapeOfN() { IntegerTensor n = IntegerTensor.create(100, 200).reshape(1, 2); DoubleTensor p = DoubleTensor.create(new double[]{ 0.1, 0.25, 0.2, 0.25, 0.3, 0.25, 0.4, 0.25 }, 4, 2); Multinomial multinomial = Multinomial.withParameters(n, p); multinomial.sample(new long[]{2, 2}, KeanuRandom.getDefaultRandom()); }
@Test public void resamplingTest() { double mu = 10.; double sigma = .5; DoubleVertexSamples samples = generateGaussianSamples(mu, sigma, 10000); KDEVertex KDE = GaussianKDE.approximate(samples); KDEVertex resampledKDE = GaussianKDE.approximate(samples); int nSamples = 1000; resampledKDE.resample(nSamples, KeanuRandom.getDefaultRandom()); assertEquals(nSamples, resampledKDE.getSampleShape()[0]); }