/** * @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()); }
public static io.improbable.keanu.algorithms.mcmc.nuts.NUTS withDefaultConfig() { return withDefaultConfig(KeanuRandom.getDefaultRandom()); }
private KeanuSavedBayesNet.StoredValue getStoredValue(Vertex vertex, KeanuSavedBayesNet.VertexValue value) { return KeanuSavedBayesNet.StoredValue.newBuilder() .setId(KeanuSavedBayesNet.VertexID.newBuilder().setId(vertex.getId().toString()).build()) .setValue(value) .setIsObserved(vertex.isObserved()) .build(); } }
private KeanuSavedBayesNet.NamedParam getParam(String paramName, Vertex[] param) { KeanuSavedBayesNet.VertexArray.Builder vertexArray = KeanuSavedBayesNet.VertexArray.newBuilder(); for (Vertex vertex : param) { vertexArray.addValues(KeanuSavedBayesNet.VertexID.newBuilder().setId(vertex.getId().toString())); } return getParam(paramName, builder -> builder.setVertexArrayParam(vertexArray.build())); }
private KeanuSavedBayesNet.StoredValue getValue(Vertex vertex, String formattedValue) { KeanuSavedBayesNet.GenericTensor savedValue = KeanuSavedBayesNet.GenericTensor.newBuilder() .addAllShape(Longs.asList(vertex.getShape())) .addValues(formattedValue) .build(); KeanuSavedBayesNet.VertexValue value = KeanuSavedBayesNet.VertexValue.newBuilder() .setGenericVal(savedValue) .build(); return getStoredValue(vertex, value); }
private KeanuSavedBayesNet.NamedParam getParam(String paramName, Vertex parent) { return getParam(paramName, builder -> builder.setParentVertex( KeanuSavedBayesNet.VertexID.newBuilder().setId(parent.getId().toString()) ) ); }
private KeanuSavedBayesNet.StoredValue getValue(IntegerVertex vertex) { KeanuSavedBayesNet.IntegerTensor savedValue = getTensor(vertex.getValue()); KeanuSavedBayesNet.VertexValue value = KeanuSavedBayesNet.VertexValue.newBuilder() .setIntVal(savedValue) .build(); return getStoredValue(vertex, value); }
public static io.improbable.keanu.algorithms.mcmc.MetropolisHastings withDefaultConfigFor(KeanuProbabilisticModel model) { return withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()); }
private KeanuSavedBayesNet.NamedParam getParam(String paramName, Consumer<KeanuSavedBayesNet.NamedParam.Builder> valueSetter) { KeanuSavedBayesNet.NamedParam.Builder paramBuilder = KeanuSavedBayesNet.NamedParam.newBuilder(); paramBuilder.setName(paramName); valueSetter.accept(paramBuilder); return paramBuilder.build(); }
public Model(Data data) { this.data = data; KeanuRandom.setDefaultRandomSeed(1); }
@Override public void saveValue(DoubleVertex vertex) { if (vertex.hasValue()) { KeanuSavedBayesNet.StoredValue value = getValue(vertex); modelBuilder.getNetworkStateBuilder().addDefaultState(value); } }
@Override public void saveValue(BooleanVertex vertex) { if (vertex.hasValue()) { KeanuSavedBayesNet.StoredValue value = getValue(vertex); modelBuilder.getNetworkStateBuilder().addDefaultState(value); } }
private void saveMetadata(Map<String, String> metadata) { if (metadata != null) { KeanuSavedBayesNet.Metadata.Builder metadataBuilder = KeanuSavedBayesNet.Metadata.newBuilder(); String[] metadataKeys = metadata.keySet().toArray(new String[0]); Arrays.sort(metadataKeys); for (String metadataKey : metadataKeys) { metadataBuilder.putMetadataInfo(metadataKey, metadata.get(metadataKey)); } modelBuilder.setMetadata(metadataBuilder); } }
public static io.improbable.keanu.algorithms.mcmc.SimulatedAnnealing withDefaultConfigFor(KeanuProbabilisticModel model) { return withDefaultConfigFor(model, KeanuRandom.getDefaultRandom()); }
private KeanuSavedBayesNet.NamedParam getParam(String paramName, long[] param) { return getParam(paramName, builder -> builder.setLongArrayParam( KeanuSavedBayesNet.LongArray.newBuilder().addAllValues(Longs.asList(param)))); }
private KeanuSavedBayesNet.NamedParam getParam(String paramName, int[] param) { return getParam(paramName, builder -> builder.setIntArrayParam( KeanuSavedBayesNet.IntArray.newBuilder().addAllValues(Ints.asList(param)))); }
private Vertex[] extractVertexArray(KeanuSavedBayesNet.NamedParam param, Map<KeanuSavedBayesNet.VertexID, Vertex> existingVertices) { Vertex[] newVertexArray = new Vertex[param.getVertexArrayParam().getValuesCount()]; for (int i = 0; i < newVertexArray.length; i++) { KeanuSavedBayesNet.VertexID parentId = param.getVertexArrayParam().getValues(i); Vertex parentVertex = existingVertices.get(parentId); if (parentVertex == null) { throw new IllegalArgumentException("Saved Structure references unknown Parent: " + parentId.toString()); } newVertexArray[i] = parentVertex; } return newVertexArray; }
public static void acceptOtherPositionWithProbability(double probability, Tree tree, Tree otherTree, KeanuRandom random) { if (random.nextDouble() < probability) { tree.acceptedPosition = otherTree.acceptedPosition; tree.gradientAtAcceptedPosition = otherTree.gradientAtAcceptedPosition; tree.logOfMasterPAtAcceptedPosition = otherTree.logOfMasterPAtAcceptedPosition; tree.sampleAtAcceptedPosition = otherTree.sampleAtAcceptedPosition; } }
private static int sample(double p, int n, KeanuRandom random) { int sum = 0; for (int i = 0; i < n; i++) { if (random.nextDouble() < p) { sum++; } } return sum; }
public double nextDoubleNonZero() { double randomValue; while ((randomValue = nextDouble()) == 0.0) ; return randomValue; }