@Override public DifferenceVertex minus(double that) { return minus(new ConstantDoubleVertex(that)); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, IntegerPlaceHolderVertex k) { final DoubleVertex halfK = k.toDouble().div(2.); final DoubleVertex numerator = halfK.minus(1.).times(x.log()).minus(x.div(2.)); final DoubleVertex denominator = halfK.times(LOG_TWO).plus(halfK.logGamma()); return numerator.minus(denominator); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, DoublePlaceholderVertex lambda) { final DoubleVertex negXMinusADivB = x.unaryMinus().div(lambda); final DoubleVertex negXMinusADivBMinusLogB = negXMinusADivB.minus(lambda.log()); return negXMinusADivBMinusLogB.setWithMask(x.toLessThanMask(0.), Double.NEGATIVE_INFINITY); }
@Test public void diffOverSubtraction() { assertDiffIsCorrect(vA, vB, vA.minus(vB)); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, DoublePlaceholderVertex location, DoublePlaceholderVertex scale) { final DoubleVertex negLnScaleMinusLnPi = scale.log().unaryMinus().plus(NEG_LOG_PI); final DoubleVertex xMinusLocationOverScalePow2Plus1 = x.minus(location).div(scale).pow(2.).plus(1.); final DoubleVertex lnXMinusLocationOverScalePow2Plus1 = xMinusLocationOverScalePow2Plus1.log(); return negLnScaleMinusLnPi.minus(lnXMinusLocationOverScalePow2Plus1); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, DoublePlaceholderVertex theta, DoublePlaceholderVertex k) { final DoubleVertex xOverTheta = x.div(theta); final DoubleVertex kLnTheta = k.times(theta.log()); final DoubleVertex kMinus1LogX = k.minus(1.).times(x.log()); final DoubleVertex lgammaK = k.logGamma(); return kMinus1LogX.minus(lgammaK).minus(xOverTheta).minus(kLnTheta); }
@Test public void diffOverPlusMinusMultiplyCombination() { DoubleVertex vC = vA.plus(vB); DoubleVertex vD = vA.minus(vB); MultiplicationVertex vE = vC.multiply(vD); assertDiffIsCorrect(vA, vB, vE); }
@Before public void setup() { A = ConstantVertex.of(2.0); B = ConstantVertex.of(2.0); C = A.log(); D = A.multiply(B); E = C.plus(D); F = D.minus(E); G = F.log(); allVertices = Arrays.asList(A, B, C, D, E, F, G); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, DoublePlaceholderVertex concentration) { final BooleanVertex xMinusOneIsLessThanOrEqualToEpsilon = x .sum().minus(1.).abs().lessThanOrEqualTo(ConstantVertex.of(EPSILON)); xMinusOneIsLessThanOrEqualToEpsilon.assertTrue("Sum of values to calculate Dirichlet likelihood for must equal 1"); final DoubleVertex sumConcentrationLogged = concentration.minus(1.).times(x.log()).sum(); final DoubleVertex sumLogGammaConcentration = concentration.logGamma().sum(); final DoubleVertex logGammaSumConcentration = concentration.sum().logGamma(); return sumConcentrationLogged.minus(sumLogGammaConcentration).plus(logGammaSumConcentration); }
public static ABTestingMaximumAPosteriori run() { DoubleVertex probabilityA = new UniformVertex(0., 1.); DoubleVertex probabilityB = new UniformVertex(0., 1.); DoubleVertex delta = probabilityA.minus(probabilityB); BernoulliVertex observationA = new BernoulliVertex(probabilityA); BernoulliVertex observationB = new BernoulliVertex(probabilityB); // manufacture observations int nObsA = 1500; BooleanTensor observationsA = RANDOM.nextDouble(new long[]{1, nObsA}).lessThan(0.05); observationA.observe(observationsA); int nObsB = 750; BooleanTensor observationsB = RANDOM.nextDouble(new long[]{1, nObsB}).lessThan(0.04); observationB.observe(observationsB); //infer the most probable probabilities KeanuProbabilisticModel model = new KeanuProbabilisticModel(probabilityA.getConnectedGraph()); int sampleCount = 100; NetworkSamples networkSamples = Keanu.Sampling.MetropolisHastings.withDefaultConfigFor(model) .getPosteriorSamples(model, Arrays.asList(probabilityA, probabilityB, delta), sampleCount) .drop(sampleCount/2).downSample(model.getLatentVariables().size()); DoubleVertexSamples pASamples = networkSamples.getDoubleTensorSamples(probabilityA); DoubleVertexSamples pBSamples = networkSamples.getDoubleTensorSamples(probabilityB); //most probable probabilities are the averages of the MH walk in this case double mapPA = pASamples.getAverages().scalar(); double mapPB = pBSamples.getAverages().scalar(); return new ABTestingMaximumAPosteriori(mapPA, mapPB); }
private List<DoubleVertex> addTime(DoubleVertex xt, DoubleVertex yt, DoubleVertex zt, double timestep, double sigma, double rho, double beta) { DoubleVertex rhov = ConstantVertex.of(rho); DoubleVertex xtplus1 = xt.multiply(1 - timestep * sigma).plus(yt.multiply(timestep * sigma)); DoubleVertex ytplus1 = yt.multiply(1 - timestep).plus(xt.multiply(rhov.minus(zt)).multiply(timestep)); DoubleVertex ztplus1 = zt.multiply(1 - timestep * beta).plus(xt.multiply(yt).multiply(timestep)); return Arrays.asList(xtplus1, ytplus1, ztplus1); }
private List<DoubleVertex> addTime(DoubleVertex xt, DoubleVertex yt, DoubleVertex zt, double timestep, double sigma, double rho, double beta) { DoubleVertex rhov = ConstantVertex.of(rho); DoubleVertex xtplus1 = xt.multiply(1 - timestep * sigma).plus(yt.multiply(timestep * sigma)); DoubleVertex ytplus1 = yt.multiply(1 - timestep).plus(xt.multiply(rhov.minus(zt)).multiply(timestep)); DoubleVertex ztplus1 = zt.multiply(1 - timestep * beta).plus(xt.multiply(yt).multiply(timestep)); return Arrays.asList(xtplus1, ytplus1, ztplus1); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex t, IntegerPlaceHolderVertex v) { DoubleVertex vAsDouble = v.toDouble(); DoubleVertex halfVPlusOne = vAsDouble.plus(1.).div(2.); DoubleVertex logGammaHalfVPlusOne = halfVPlusOne.logGamma(); DoubleVertex logGammaHalfV = vAsDouble.div(2.).logGamma(); DoubleVertex halfLogV = vAsDouble.log().div(2.); return logGammaHalfVPlusOne .minus(halfLogV) .minus(HALF_LOG_PI) .minus(logGammaHalfV) .minus( halfVPlusOne.times( t.pow(2.).div(vAsDouble).plus(1.).log() ) ); }
public static DoubleVertex logProbOutput(DoublePlaceholderVertex x, DoublePlaceholderVertex xMin, DoublePlaceholderVertex xMax, double edgeSharpness) { final DoubleVertex bodyWidth = xMax.minus(xMin); final DoubleVertex shoulderWidth = bodyWidth.times(edgeSharpness); final DoubleVertex rightCutoff = xMax.plus(shoulderWidth); final DoubleVertex leftCutoff = xMin.minus(shoulderWidth); final DoubleVertex firstConditional = x .toGreaterThanOrEqualToMask(xMin) .times(x.toLessThanOrEqualToMask(xMax)); final DoubleVertex firstConditionResult = bodyHeightVertex(shoulderWidth, bodyWidth); final DoubleVertex secondConditional = x .toLessThanMask(xMin) .times(x.toGreaterThanMask(leftCutoff)); final DoubleVertex secondConditionalResult = shoulderVertex(shoulderWidth, bodyWidth, x.minus(leftCutoff)); final DoubleVertex thirdConditional = x.toGreaterThanMask(xMax) .times(x.toLessThanMask(rightCutoff)); final DoubleVertex thirdConditionalResult = shoulderVertex(shoulderWidth, bodyWidth, shoulderWidth.minus(x).plus(xMax)); return firstConditional.times(firstConditionResult) .plus(secondConditional.times(secondConditionalResult)) .plus(thirdConditional.times(thirdConditionalResult)) .log(); }
private DoubleCPTVertex doubleCPTNetwork(boolean left, boolean right) { A = new GaussianVertex(new long[]{2}, 0, 1); A.setValue(aValue); DoubleVertex B = new GaussianVertex(0, 1); B.observe(bValue); BooleanVertex leftPredicate = new BernoulliVertex(0.5); leftPredicate.observe(left); BooleanVertex rightPredicate = new BernoulliVertex(0.5); rightPredicate.observe(right); return ConditionalProbabilityTable.of(leftPredicate, rightPredicate) .when(true, true).then(A.times(B)) .when(true, false).then(A.div(B)) .when(false, true).then(A.plus(B)) .orDefault(B.minus(A)); }
@Category(Slow.class) @Test public void calculatesGradientCorrectlyWithAdditionMultiplicationSubtractionDivision() { GaussianVertex A = new GaussianVertex(2.0, 3.0); GaussianVertex B = new GaussianVertex(3.0, 3.0); A.setAndCascade(Nd4jDoubleTensor.scalar(2.2)); B.setAndCascade(Nd4jDoubleTensor.scalar(3.2)); DoubleVertex C = A.plus(B); DoubleVertex D = A.multiply(B); DoubleVertex E = C.minus(D); DoubleVertex F = C.divideBy(D); GaussianVertex eObservation = new GaussianVertex(E, 5.0); eObservation.observe(Nd4jDoubleTensor.scalar(1.2)); GaussianVertex fObservation = new GaussianVertex(F, C); fObservation.observe(Nd4jDoubleTensor.scalar(1.0)); KeanuProbabilisticModelWithGradient model = new KeanuProbabilisticModelWithGradient(A.getConnectedGraph()); FitnessFunctionWithGradient fitness = new FitnessFunctionWithGradient(model, false); assert2DGradientEqualsApproxGradient( new double[]{5, 5}, new double[]{0.1, 0.1}, 0.2, fitness ); }