@Override public DoubleTensor sample(KeanuRandom random) { return op(inputVertex.sample(random)); }
@Override public DoubleTensor sample(KeanuRandom random) { return getParent().sample(); }
public DoubleVertexSamples generateGaussianSamples(double mu, double sigma, int nSamples) { DoubleVertex gaussian = new GaussianVertex(mu, sigma); List<DoubleTensor> samples = new ArrayList<>(nSamples); for (int i = 0; i < nSamples; i++) { samples.add(gaussian.sample()); } return new DoubleVertexSamples(samples); }
@Test public void whenSampleIsCalledThenKeanuRandomIsPassedToParentSample() { final KeanuRandom random = mock(KeanuRandom.class); final PrintVertex<DoubleTensor> sut = new PrintVertex<>(parent); sut.sample(random); verify(parent).sample(random); }
@Test public void coefficientOfDeterminationIs1HighForSimilarData() { DoubleVertex input = new UniformVertex(new long[]{1, 1000}, -1000, 1000); DoubleVertex noisy = new GaussianVertex(input, 50); DoubleTensor inputSample = input.sample(); input.setAndCascade(inputSample); assertThat(ModelScoring.coefficientOfDetermination(inputSample, noisy.sample()), greaterThan(0.9)); } }
@Test public void coefficientOfDeterminationIs1ForSameData() { DoubleVertex generator = new UniformVertex(new long[]{1, 1000}, -1000, 1000); DoubleTensor sample = generator.sample(); assertThat( ModelScoring.coefficientOfDetermination(sample, sample), closeTo(1, 1e-8)); }
public static void inferHyperParamsFromSamples( Function<List<DoubleVertex>, DoubleVertex> vertexUnderTestCreator, List<DoubleVertex> hyperParamsForSampling, List<DoubleVertex> latentsToInfer, KeanuRandom random) { // SOURCE OF TRUTH DoubleVertex sourceVertex = vertexUnderTestCreator.apply(hyperParamsForSampling); // GENERATE FAKE DATA DoubleTensor samples = sourceVertex.sample(random); DoubleVertex observedDistribution = vertexUnderTestCreator.apply(latentsToInfer); observedDistribution.observe(samples); // INFER HYPER PARAMETERS doInferenceOn(latentsToInfer.get(0), random); for (int i = 0; i < latentsToInfer.size(); i++) { assertEquals(hyperParamsForSampling.get(i).getValue().scalar(), latentsToInfer.get(i).getValue().scalar(), 0.1); } }
public static <V extends DoubleVertex & ProbabilisticDouble> void samplingProducesRealisticMeanAndStandardDeviation(int numberOfSamples, V vertexUnderTest, double expectedMean, double expectedStandardDeviation, double maxError, KeanuRandom random) { List<Double> samples = new ArrayList<>(); for (int i = 0; i < numberOfSamples; i++) { double sample = vertexUnderTest.sample(random).scalar(); samples.add(sample); } SummaryStatistics stats = new SummaryStatistics(); samples.forEach(stats::addValue); double mean = stats.getMean(); double sd = stats.getStandardDeviation(); assertThat("Problem with mean", expectedMean, closeTo(mean, maxError)); assertThat("Problem with standard deviation", expectedStandardDeviation, closeTo(sd, maxError)); }
static TestData generateSingleFeatureData(int numSamples) { DoubleVertex xGenerator = new UniformVertex(new long[]{numSamples, 1}, 0, 10); DoubleVertex mu = xGenerator.multiply(EXPECTED_W1).plus(EXPECTED_B); DoubleVertex yGenerator = new GaussianVertex(mu, 1.0); DoubleTensor xData = xGenerator.sample(); xGenerator.setAndCascade(xData); DoubleTensor yData = yGenerator.sample(); return new TestData(DoubleTensor.scalar(EXPECTED_W1), EXPECTED_B, xData, yData); }
samples[i] = vertexUnderTest.sample(random).scalar();
static TestData generateMultiFeatureData(int featureCount, Function<long[], DoubleVertex> weightVertexFromShape) { long N = 1000; double expectedB = 20; DoubleVertex xGenerator = new UniformVertex(new long[]{N, featureCount}, 0, 100); DoubleVertex weightsGenerator = weightVertexFromShape.apply(new long[]{featureCount,1}); DoubleVertex yGenerator = new GaussianVertex(new long[]{N, 1}, xGenerator.matrixMultiply(weightsGenerator).plus(expectedB), 1.0); DoubleTensor xData = xGenerator.sample(); DoubleTensor weights = weightsGenerator.sample(); xGenerator.setValue(xData); weightsGenerator.setValue(weights); DoubleTensor yData = yGenerator.getValue(); return new TestData(weights, expectedB, xData, yData); }
static TestData generateThreeFeatureDataWithOneUncorrelatedFeature() { DoubleVertex x1Generator = new UniformVertex(new long[]{N, 1}, 0, 10); DoubleVertex x2Generator = new UniformVertex(new long[]{N, 1}, 50, 100); DoubleVertex x3Generator = new UniformVertex(new long[]{N, 1}, 50, 100); DoubleVertex yGenerator = new GaussianVertex( x1Generator.multiply(EXPECTED_W1).plus(x2Generator.multiply(EXPECTED_W2)).plus(EXPECTED_B), 1.0 ); DoubleTensor x1Data = x1Generator.sample(); x1Generator.setAndCascade(x1Data); DoubleTensor x2Data = x1Generator.sample(); x2Generator.setAndCascade(x2Data); DoubleTensor yData = yGenerator.sample(); return new TestData(DoubleTensor.create(EXPECTED_W1, EXPECTED_W2), EXPECTED_B, DoubleTensor.concat(1, x1Data, x2Data, x3Generator.sample()), yData); }
static TestData generateTwoFeatureData(int numSamples) { DoubleVertex x1Generator = new UniformVertex(new long[]{numSamples, 1}, 0, 10); DoubleVertex x2Generator = new UniformVertex(new long[]{numSamples, 1}, 50, 100); DoubleVertex yGenerator = new GaussianVertex( x1Generator.multiply(EXPECTED_W1).plus(x2Generator.multiply(EXPECTED_W2)).plus(EXPECTED_B), 1.0 ); DoubleTensor x1Data = x1Generator.sample(); x1Generator.setAndCascade(x1Data); DoubleTensor x2Data = x1Generator.sample(); x2Generator.setAndCascade(x2Data); DoubleTensor yData = yGenerator.sample(); return new TestData(DoubleTensor.create(EXPECTED_W1, EXPECTED_W2), EXPECTED_B, DoubleTensor.concat(1, x1Data, x2Data), yData); }
public static void main(String[] args) { //%%SNIPPET_START%% SimpleLinearRegressionExample //Define Model Parameters double weight = 2.0; double offset = 20.0; int numberOfSamples = 100; //Define random input data vertex by sampling from uniform probability distribution between 0 and 10 DoubleVertex xGenerator = new UniformVertex(new long[]{1, numberOfSamples}, 0, 10); //Define the desired output vertices DoubleVertex yMu = xGenerator.multiply(weight).plus(offset); //Define a vertex for taking noisy readings of output data DoubleVertex yGenerator = new GaussianVertex(yMu, 1.0); //Sample input data and then sample the corresponding noisy output data DoubleTensor xData = xGenerator.sample(); xGenerator.setAndCascade(xData); DoubleTensor yData = yGenerator.sample(); //Create a simple linear regression model and fit it with our input and output data RegressionModel regressionModel = RegressionModel.withTrainingData(xData, yData) .withRegularization(RegressionRegularization.NONE) .build(); //It is now possible to use regressionModel.predict(value) to get a prediction of the output given an input value. //%%SNIPPET_END%% SimpleLinearRegressionExample } }
@Test public void modelInsideVertexIsRecalculatedOnEachParentSample() { int numSamples = 50; weatherModel.setInputToModel(inputToModel); Map<VertexLabel, Vertex<? extends Tensor>> inputs = ImmutableMap.of(new VertexLabel("Temperature"), inputToModel); ModelVertex model = new LambdaModelVertex(inputs, weatherModel::modelExecution, weatherModel::updateValues); DoubleVertex chanceOfRain = model.getDoubleModelOutputVertex(new VertexLabel("ChanceOfRain")); DoubleVertex humidity = model.getDoubleModelOutputVertex(new VertexLabel("Humidity")); DoubleVertex shouldIBringUmbrella = chanceOfRain.times(humidity); for (int i = 0; i < numSamples; i++) { double inputValue = inputToModel.sample(random).scalar(); inputToModel.setAndCascade(inputValue); double expectedValue = (inputValue * 0.1) * (inputValue * 2); Assert.assertEquals(expectedValue, shouldIBringUmbrella.getValue().scalar(), 1e-6); } }
@Category(Slow.class) @Test public void modelInsideVertexIsRecalculatedOnEachParentSample() { int numSamples = 50; weatherModel.setInputToModel(inputToModel); Map<VertexLabel, Vertex<? extends Tensor>> inputs = ImmutableMap.of(new VertexLabel("Temperature"), inputToModel); ModelVertex model = LambdaModelVertex.createFromProcess(inputs, COMMAND, weatherModel::updateValues); DoubleVertex chanceOfRain = model.getDoubleModelOutputVertex(new VertexLabel("ChanceOfRain")); DoubleVertex humidity = model.getDoubleModelOutputVertex(new VertexLabel("Humidity")); DoubleVertex shouldIBringUmbrella = chanceOfRain.times(humidity); for (int i = 0; i < numSamples; i++) { double inputValue = inputToModel.sample().scalar(); inputToModel.setAndCascade(inputValue); double expectedValue = (inputValue * 0.1) * (inputValue * 2); Assert.assertEquals(expectedValue, shouldIBringUmbrella.getValue().scalar(), 1e-6); } }