/// <summary> /// VMP Messages to Uses /// </summary> /// <param name="Uses">Nonconjugate messages from uses</param> /// <param name="Def">Gaussian message from Defintion</param> /// <param name="result">Previous message</param> /// <returns></returns> public static DistributionStructArray<Gaussian,double> UsesAverageLogarithm(DistributionStructArray<NonconjugateGaussian,double>[] Uses, DistributionStructArray<Gaussian,double> Def, DistributionStructArray<Gaussian,double> result) { // multiply the messages together DistributionStructArray<NonconjugateGaussian,double> prod = Uses[0]; for (int i = 1; i < Uses.Length; i++) prod.SetToProduct(prod, Uses[i]); // convert to Gaussians for (int i = 0; i < prod.Count; i++) { result[i] = prod[i].GetGaussian(true); if ((!result[i].IsProper() && !result[i].IsUniform()) || double.IsNaN(result[i].Precision)) throw new ApplicationException("UsesAverageLogarithm "); } result.SetToProduct(result, Def); return result; }
public static DistributionStructArray <TDist, T> ItemsAverageLogarithmInit <TDist>([IgnoreDependency] DistributionStructArray <TDist, T> array, IList <int> indices) where TDist : struct, SettableToProduct <TDist>, SettableToRatio <TDist>, SettableToPower <TDist>, SettableToWeightedSum <TDist>, CanGetLogAverageOf <TDist>, CanGetLogAverageOfPower <TDist>, CanGetAverageLog <TDist>, IDistribution <T>, Sampleable <T> { return(new DistributionStructArray <TDist, T>(indices.Count, i => (TDist)array[indices[i]].Clone())); }
/// <summary>Computations that depend on the observed value of FeatureCount and FeatureValues and InstanceCount and Labels and numberOfIterations and WeightConstraints and WeightPriors</summary> /// <param name="numberOfIterations">The number of times to iterate each loop</param> private void Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8(int numberOfIterations) { if (this.Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8_isDone) { return; } for (int iteration = this.numberOfIterationsDone; iteration < numberOfIterations; iteration++) { for (int FeatureRange = 0; FeatureRange < this.FeatureCount; FeatureRange++) { this.Weights_depth1_rep_F_marginal[FeatureRange] = ReplicateOp_Divide.Marginal <Gaussian>(this.Weights_depth1_rep_B_toDef[FeatureRange], this.Weights_uses_F[1][FeatureRange], this.Weights_depth1_rep_F_marginal[FeatureRange]); } for (int InstanceRange = 0; InstanceRange < this.InstanceCount; InstanceRange++) { for (int FeatureRange = 0; FeatureRange < this.FeatureCount; FeatureRange++) { this.Weights_depth1_rep_F[FeatureRange][InstanceRange] = ReplicateOp_Divide.UsesAverageConditional <Gaussian>(this.Weights_depth1_rep_B[FeatureRange][InstanceRange], this.Weights_depth1_rep_F_marginal[FeatureRange], InstanceRange, this.Weights_depth1_rep_F[FeatureRange][InstanceRange]); this.FeatureScores_F[InstanceRange][FeatureRange] = GaussianProductOpBase.ProductAverageConditional(this.FeatureValues[InstanceRange][FeatureRange], this.Weights_depth1_rep_F[FeatureRange][InstanceRange]); } this.Score_F[InstanceRange] = FastSumOp.SumAverageConditional(this.FeatureScores_F[InstanceRange]); this.NoisyScore_F[InstanceRange] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(this.Score_F[InstanceRange], 1.0); this.NoisyScore_use_B[InstanceRange] = IsPositiveOp_Proper.XAverageConditional(Bernoulli.PointMass(this.Labels[InstanceRange]), this.NoisyScore_F[InstanceRange]); this.Score_B[InstanceRange] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.NoisyScore_use_B[InstanceRange], 1.0); this.FeatureScores_B[InstanceRange] = FastSumOp.ArrayAverageConditional <DistributionStructArray <Gaussian, double> >(this.Score_B[InstanceRange], this.Score_F[InstanceRange], this.FeatureScores_F[InstanceRange], this.FeatureScores_B[InstanceRange]); for (int FeatureRange = 0; FeatureRange < this.FeatureCount; FeatureRange++) { this.Weights_depth1_rep_B[FeatureRange][InstanceRange] = GaussianProductOpBase.BAverageConditional(this.FeatureScores_B[InstanceRange][FeatureRange], this.FeatureValues[InstanceRange][FeatureRange]); this.Weights_depth1_rep_F_marginal[FeatureRange] = ReplicateOp_Divide.MarginalIncrement <Gaussian>(this.Weights_depth1_rep_F_marginal[FeatureRange], this.Weights_depth1_rep_F[FeatureRange][InstanceRange], this.Weights_depth1_rep_B[FeatureRange][InstanceRange]); } } for (int FeatureRange = 0; FeatureRange < this.FeatureCount; FeatureRange++) { this.Weights_depth1_rep_B_toDef[FeatureRange] = ReplicateOp_Divide.ToDef <Gaussian>(this.Weights_depth1_rep_B[FeatureRange], this.Weights_depth1_rep_B_toDef[FeatureRange]); } this.OnProgressChanged(new ProgressChangedEventArgs(iteration)); } for (int _iv = 0; _iv < this.FeatureCount; _iv++) { this.Weights_uses_B[1][_iv] = ArrayHelper.SetTo <Gaussian>(this.Weights_uses_B[1][_iv], this.Weights_depth1_rep_B_toDef[_iv]); } this.Weights_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.WeightPriors, 0, this.Weights_uses_F[0]); this.ModelSelector_selector_cases_0_uses_B[6] = Bernoulli.FromLogOdds(ReplicateOp.LogEvidenceRatio <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.WeightPriors, this.Weights_uses_F)); this.ModelSelector_selector_cases_0_uses_B[7] = Bernoulli.FromLogOdds(ConstrainEqualRandomOp <double[]> .LogEvidenceRatio <DistributionStructArray <Gaussian, double> >(this.Weights_uses_F[0], this.WeightConstraints)); for (int FeatureRange = 0; FeatureRange < this.FeatureCount; FeatureRange++) { this.ModelSelector_selector_cases_0_rep3_uses_B[FeatureRange][1] = Bernoulli.FromLogOdds(ReplicateOp.LogEvidenceRatio <Gaussian>(this.Weights_depth1_rep_B[FeatureRange], this.Weights_uses_F[1][FeatureRange], this.Weights_depth1_rep_F[FeatureRange])); this.ModelSelector_selector_cases_0_rep3_B[FeatureRange] = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep3_uses_B[FeatureRange], this.ModelSelector_selector_cases_0_rep3_B[FeatureRange]); } this.ModelSelector_selector_cases_0_uses_B[12] = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep3_B, this.ModelSelector_selector_cases_0_uses_B[12]); for (int InstanceRange = 0; InstanceRange < this.InstanceCount; InstanceRange++) { this.ModelSelector_selector_cases_0_rep8_B[InstanceRange] = Bernoulli.FromLogOdds(IsPositiveOp.LogEvidenceRatio(this.Labels[InstanceRange], this.NoisyScore_F[InstanceRange])); } this.ModelSelector_selector_cases_0_uses_B[17] = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_rep8_B, this.ModelSelector_selector_cases_0_uses_B[17]); this.ModelSelector_selector_cases_0_B = ReplicateOp_NoDivide.DefAverageConditional <Bernoulli>(this.ModelSelector_selector_cases_0_uses_B, this.ModelSelector_selector_cases_0_B); this.ModelSelector_selector_cases_B[0] = ArrayHelper.SetTo <Bernoulli>(this.ModelSelector_selector_cases_B[0], this.ModelSelector_selector_cases_0_B); this.ModelSelector_selector_B = CasesOp.BAverageConditional(this.ModelSelector_selector_cases_B); this.ModelSelector_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(this.ModelSelector_selector_B, this.vBernoulli0, this.ModelSelector_marginal_F); this.Weights_use_B = ReplicateOp_NoDivide.DefAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_uses_B, this.Weights_use_B); this.Weights_marginal_F = VariableOp.MarginalAverageConditional <DistributionStructArray <Gaussian, double> >(this.Weights_use_B, this.WeightPriors, this.Weights_marginal_F); this.Changed_FeatureCount_FeatureValues_InstanceCount_Labels_numberOfIterations_WeightConstraints_WeightP8_isDone = true; }
/// <summary>Computations that depend on the observed value of Cloudy and WetGrass and Sprinkler</summary> public void Changed_Cloudy_WetGrass_Sprinkler() { if (this.Changed_Cloudy_WetGrass_Sprinkler_iterationsDone == 1) { return; } // The constant 'vBernoulli0' Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0); this.Cloudy_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0); this.Cloudy_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Cloudy_marginal, this.cloudy); // The constant 'vBernoulli5' Bernoulli vBernoulli5 = Bernoulli.FromLogOdds(4.5951198501345889); this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli5); this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass); // The constant 'vBernoulli1' Bernoulli vBernoulli1 = Bernoulli.FromLogOdds(-2.1972245773362191); this.Sprinkler_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); this.Sprinkler_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Sprinkler_marginal, this.sprinkler); // The constant 'vBernoulli3' Bernoulli vBernoulli3 = Bernoulli.FromLogOdds(1.3862943611198908); Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message from use of 'Rain' Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); if (this.cloudy) { // Message to 'Rain' from Copy factor Rain_F = Factor.Copy <Bernoulli>(vBernoulli3); } // The constant 'vBernoulli4' Bernoulli vBernoulli4 = Bernoulli.FromLogOdds(-1.3862943611198906); if (!this.cloudy) { // Message to 'Rain' from Copy factor Rain_F = Factor.Copy <Bernoulli>(vBernoulli4); } // Rain_F is now updated in all contexts if (this.sprinkler) { this.Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor this.Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli5)); // Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages. this.Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { this.Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor this.Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_0_B); } // The constant 'vBernoulli6' Bernoulli vBernoulli6 = Bernoulli.FromLogOdds(2.1972245773362196); if (this.sprinkler) { this.Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor this.Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor this.Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_1_B); this.Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor this.Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_0_selector_cases_B); // Message to 'Rain_use' from Copy factor Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_B); } if (!this.sprinkler) { this.Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor this.Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); // Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages. this.Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { this.Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor this.Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_0_B); } // The constant 'vBernoulli8' Bernoulli vBernoulli8 = Bernoulli.FromLogOdds(Double.NegativeInfinity); if (!this.sprinkler) { this.Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor this.Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli8)); // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor this.Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_1_B); this.Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor this.Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_1_selector_cases_B); // Message to 'Rain_use' from Copy factor Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_B); } // Rain_use_B is now updated in all contexts if (this.cloudy) { // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F); } if (!this.cloudy) { // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, vBernoulli4, this.Rain_marginal_F); } // Rain_marginal_F is now updated in all contexts this.Changed_Cloudy_WetGrass_Sprinkler_iterationsDone = 1; }
/// <summary>Computations that depend on the observed value of Cloudy and WetGrass</summary> public void Changed_Cloudy_WetGrass() { if (this.Changed_Cloudy_WetGrass_iterationsDone == 1) { return; } // The constant 'vBernoulli0' Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0); this.Cloudy_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0); this.Cloudy_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Cloudy_marginal, this.cloudy); // The constant 'vBernoulli5' Bernoulli vBernoulli5 = Bernoulli.FromLogOdds(4.5951198501345889); this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli5); this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass); // The constant 'vBernoulli3' Bernoulli vBernoulli3 = Bernoulli.FromLogOdds(1.3862943611198908); Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to use of 'Rain' Bernoulli Rain_use_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message from use of 'Rain' Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); if (this.cloudy) { // Message to 'Rain' from Copy factor Rain_F = Factor.Copy <Bernoulli>(vBernoulli3); } // The constant 'vBernoulli4' Bernoulli vBernoulli4 = Bernoulli.FromLogOdds(-1.3862943611198906); if (!this.cloudy) { // Message to 'Rain' from Copy factor Rain_F = Factor.Copy <Bernoulli>(vBernoulli4); } // Rain_F is now updated in all contexts if (this.cloudy) { // Message to 'Rain_use' from DerivedVariable factor Rain_use_F = Factor.Copy <Bernoulli>(Rain_F); } Bernoulli Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli5)); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_0_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages. Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_0_B); // The constant 'vBernoulli6' Bernoulli vBernoulli6 = Bernoulli.FromLogOdds(2.1972245773362196); Bernoulli Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_1_B); if (!this.cloudy) { // Message to 'Rain_use' from DerivedVariable factor Rain_use_F = Factor.Copy <Bernoulli>(vBernoulli4); } // Rain_use_F is now updated in all contexts Bernoulli[] Sprinkler_selector_cases_0_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_cases_0_uses' Backwards messages. Sprinkler_selector_cases_0_uses_B = new Bernoulli[5]; for (int _ind = 0; _ind < 5; _ind++) { Sprinkler_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Sprinkler_selector_cases_0_uses' from Cases factor Sprinkler_selector_cases_0_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_0_selector_cases_B, Rain_use_F)); Bernoulli Sprinkler_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Sprinkler_selector_cases_0' from Replicate factor Sprinkler_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_0_uses_B, Sprinkler_selector_cases_0_B); DistributionStructArray <Bernoulli, bool> Sprinkler_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Sprinkler_selector_cases' Backwards messages. Sprinkler_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Sprinkler_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Sprinkler_selector_cases' from Copy factor Sprinkler_selector_cases_B[0] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_0_B); Bernoulli Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_1_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages. Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_0_B); // The constant 'vBernoulli8' Bernoulli vBernoulli8 = Bernoulli.FromLogOdds(Double.NegativeInfinity); Bernoulli Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli8)); // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_1_B); Bernoulli[] Sprinkler_selector_cases_1_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_cases_1_uses' Backwards messages. Sprinkler_selector_cases_1_uses_B = new Bernoulli[5]; for (int _ind = 0; _ind < 5; _ind++) { Sprinkler_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Sprinkler_selector_cases_1_uses' from Cases factor Sprinkler_selector_cases_1_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_1_selector_cases_B, Rain_use_F)); Bernoulli Sprinkler_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Sprinkler_selector_cases_1' from Replicate factor Sprinkler_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_1_uses_B, Sprinkler_selector_cases_1_B); // Message to 'Sprinkler_selector_cases' from Copy factor Sprinkler_selector_cases_B[1] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_1_B); Bernoulli[] Sprinkler_selector_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_uses' Backwards messages. Sprinkler_selector_uses_B = new Bernoulli[2]; // The constant 'vBernoulli1' Bernoulli vBernoulli1 = Bernoulli.FromLogOdds(-2.1972245773362191); for (int _ind = 0; _ind < 2; _ind++) { Sprinkler_selector_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); } // Message to 'Sprinkler_selector_uses' from Cases factor Sprinkler_selector_uses_B[0] = CasesOp.BAverageConditional(Sprinkler_selector_cases_B); Bernoulli Sprinkler_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); if (this.cloudy) { // Message to 'Sprinkler' from Copy factor Sprinkler_F = Factor.Copy <Bernoulli>(vBernoulli1); } if (!this.cloudy) { // Message to 'Sprinkler' from Copy factor Sprinkler_F = Factor.Copy <Bernoulli>(vBernoulli0); } // Sprinkler_F is now updated in all contexts // Message to use of 'Sprinkler' Bernoulli Sprinkler_use_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); if (this.cloudy) { // Message to 'Sprinkler_use' from DerivedVariable factor Sprinkler_use_F = Factor.Copy <Bernoulli>(Sprinkler_F); } if (!this.cloudy) { // Message to 'Sprinkler_use' from DerivedVariable factor Sprinkler_use_F = Factor.Copy <Bernoulli>(vBernoulli0); } // Sprinkler_use_F is now updated in all contexts // Buffer for Replicate2BufferOp.UsesAverageConditional<Bernoulli> Bernoulli Sprinkler_selector_uses_B_marginal = default(Bernoulli); // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.MarginalInit <Bernoulli>(Sprinkler_use_F); // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.Marginal <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_use_F, Sprinkler_selector_uses_B_marginal); Bernoulli[] Sprinkler_selector_uses_F = default(Bernoulli[]); // Create array for 'Sprinkler_selector_uses' Forwards messages. Sprinkler_selector_uses_F = new Bernoulli[2]; for (int _ind = 0; _ind < 2; _ind++) { Sprinkler_selector_uses_F[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); } // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_use_F, Sprinkler_selector_uses_B_marginal, 1, Sprinkler_selector_uses_F[1]); Bernoulli Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_0_selector_cases_B); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler' Backwards messages. Rain_cond_Sprinkler_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _gateind = 0; _gateind < 2; _gateind++) { Rain_cond_Sprinkler_B[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); } // Message to 'Rain_cond_Sprinkler' from Copy factor Rain_cond_Sprinkler_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_B); Bernoulli Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_1_selector_cases_B); // Message to 'Rain_cond_Sprinkler' from Copy factor Rain_cond_Sprinkler_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_B); // Message to 'Rain_use' from EnterPartial factor Rain_use_B = GateEnterPartialOp <bool> .ValueAverageConditional <Bernoulli>(Rain_cond_Sprinkler_B, Sprinkler_selector_uses_F[1], Rain_use_F, new int[2] { 0, 1 }, Rain_use_B); if (this.cloudy) { // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F); } if (!this.cloudy) { // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, vBernoulli4, this.Rain_marginal_F); } // Rain_marginal_F is now updated in all contexts this.Sprinkler_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); Bernoulli Sprinkler_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); // Message to 'Sprinkler_selector' from Replicate factor Sprinkler_selector_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_selector_B); if (this.cloudy) { // Message to 'Sprinkler_marginal' from DerivedVariable factor this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, Sprinkler_F, this.Sprinkler_marginal_F); } if (!this.cloudy) { // Message to 'Sprinkler_marginal' from DerivedVariable factor this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, vBernoulli0, this.Sprinkler_marginal_F); } // Sprinkler_marginal_F is now updated in all contexts this.Changed_Cloudy_WetGrass_iterationsDone = 1; }
/// <summary> /// VMP Messages to Uses /// </summary> /// <param name="Uses">Nonconjugate messages from uses</param> /// <param name="Def">Gaussian message from Defintion</param> /// <param name="result">Previous message</param> /// <returns></returns> public static DistributionStructArray <Gaussian, double> UsesAverageLogarithm(DistributionStructArray <NonconjugateGaussian, double>[] Uses, DistributionStructArray <Gaussian, double> Def, DistributionStructArray <Gaussian, double> result) { // multiply the messages together DistributionStructArray <NonconjugateGaussian, double> prod = Uses[0]; for (int i = 1; i < Uses.Length; i++) { prod.SetToProduct(prod, Uses[i]); } // convert to Gaussians for (int i = 0; i < prod.Count; i++) { result[i] = prod[i].GetGaussian(true); if ((!result[i].IsProper() && !result[i].IsUniform()) || double.IsNaN(result[i].Precision)) { throw new ApplicationException("UsesAverageLogarithm "); } } result.SetToProduct(result, Def); return(result); }
/// <summary> /// VMP message to 'A' /// </summary> /// <param name="sum">Incoming message from 'Sum'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'A'. Must be a proper distribution. If all elements are uniform, the result will be uniform.</param> /// <param name="B">Incoming message from 'B'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanOfB">Buffer 'MeanOfB'.</param> /// <param name="CovarianceOfB">Buffer 'CovarianceOfB'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'A'. /// Because the factor is deterministic, 'Sum' is integrated out before taking the logarithm. /// The formula is <c>exp(sum_(B) p(B) log(sum_Sum p(Sum) factor(Sum,A,B)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sum"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception> public static DistributionStructArray<Bernoulli, bool> AAverageLogarithm([SkipIfUniform] Gaussian sum, [Proper] DistributionStructArray<Bernoulli, bool> A, [Proper] VectorGaussian B, Vector MeanOfB, PositiveDefiniteMatrix CovarianceOfB, DistributionStructArray<Bernoulli, bool> result) { double mu = sum.GetMean(); var Ebbt = new PositiveDefiniteMatrix(A.Count, A.Count); Ebbt.SetToSumWithOuter(CovarianceOfB, 1, MeanOfB, MeanOfB); var ma = A.Select(x => x.GetMean()).ToArray(); for (int i = 0; i < A.Count; i++) { double term1 = 0.0; for (int j = 0; j < A.Count; j++) if (j != i) term1 += ma[i] * Ebbt[i, j]; var ri = result[i]; ri.LogOdds = -.5 * sum.Precision * (2.0 * term1 + Ebbt[i, i] - 2.0 * mu * MeanOfB[i]); result[i] = ri; } return result; }
/// <summary> /// VMP message to 'Sum' /// </summary> /// <param name="A">Incoming message from 'A'.</param> /// <param name="B">Constant value for 'B'.</param> /// <returns>The outgoing VMP message to the 'Sum' argument</returns> /// <remarks><para> /// The outgoing message is a distribution matching the moments of 'Sum' as the random arguments are varied. /// The formula is <c>proj[sum_(A) p(A) factor(Sum,A,B)]</c>. /// </para></remarks> public static Gaussian SumAverageLogarithm(DistributionStructArray<Bernoulli, bool> A, [SkipIfUniform] Vector B) { Gaussian result = new Gaussian(); // p(x|a,b) = N(E[a]'*E[b], E[b]'*var(a)*E[b] + E[a]'*var(b)*E[a] + trace(var(a)*var(b))) Vector ma = Vector.Zero(A.Count); Vector va = Vector.Zero(A.Count); for (int i = 0; i < A.Count; i++) { ma[i] = A[i].GetMean(); va[i] = A[i].GetVariance(); } // Uses John Winn's rule for deterministic factors. // Strict variational inference would set the variance to 0. var MeanOfBSquared = Vector.Zero(B.Count); MeanOfBSquared.SetToFunction(B, x => x * x); result.SetMeanAndVariance(ma.Inner(B), va.Inner(MeanOfBSquared)); return result; }
/// <summary>Computations that depend on the observed value of Sprinkler and WetGrass</summary> public void Changed_Sprinkler_WetGrass() { if (this.Changed_Sprinkler_WetGrass_iterationsDone == 1) { return; } // The constant 'vBernoulli1' Bernoulli vBernoulli1 = Bernoulli.FromLogOdds(-2.1972245773362191); this.Sprinkler_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli1); this.Sprinkler_marginal = Distribution.SetPoint <Bernoulli, bool>(this.Sprinkler_marginal, this.sprinkler); // The constant 'vBernoulli5' Bernoulli vBernoulli5 = Bernoulli.FromLogOdds(4.5951198501345889); this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli5); this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass); // The constant 'vBernoulli3' Bernoulli vBernoulli3 = Bernoulli.FromLogOdds(1.3862943611198908); Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // The constant 'vBernoulli0' Bernoulli vBernoulli0 = Bernoulli.FromLogOdds(0); this.Cloudy_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0); Bernoulli[] Cloudy_selector_cases_0_uses_B = default(Bernoulli[]); // Create array for 'Cloudy_selector_cases_0_uses' Backwards messages. Cloudy_selector_cases_0_uses_B = new Bernoulli[7]; for (int _ind = 0; _ind < 7; _ind++) { Cloudy_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Cloudy_selector_cases_0_uses' from Random factor Cloudy_selector_cases_0_uses_B[6] = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.sprinkler, vBernoulli1)); Bernoulli Cloudy_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Cloudy_selector_cases_0' from Replicate factor Cloudy_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Cloudy_selector_cases_0_uses_B, Cloudy_selector_cases_0_B); DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_B = default(DistributionStructArray <Bernoulli, bool>[]); // Create array for 'Cloudy_selector_cases_uses' Backwards messages. Cloudy_selector_cases_uses_B = new DistributionStructArray <Bernoulli, bool> [3]; for (int _ind = 0; _ind < 3; _ind++) { // Create array for 'Cloudy_selector_cases_uses' Backwards messages. Cloudy_selector_cases_uses_B[_ind] = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_uses_B[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } } // Message to 'Cloudy_selector_cases_uses' from Copy factor Cloudy_selector_cases_uses_B[0][0] = Factor.Copy <Bernoulli>(Cloudy_selector_cases_0_B); DistributionStructArray <Bernoulli, bool> Rain_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Cloudy' Forwards messages. Rain_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _gateind = 0; _gateind < 2; _gateind++) { Rain_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); } // Message to 'Rain_cond_Cloudy' from Copy factor Rain_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(vBernoulli3); // The constant 'vBernoulli4' Bernoulli vBernoulli4 = Bernoulli.FromLogOdds(-1.3862943611198906); // Message to 'Rain_cond_Cloudy' from Copy factor Rain_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli4); if (this.sprinkler) { this.Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor this.Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli5)); // Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages. this.Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { this.Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor this.Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_0_B); } // The constant 'vBernoulli6' Bernoulli vBernoulli6 = Bernoulli.FromLogOdds(2.1972245773362196); if (this.sprinkler) { this.Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor this.Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor this.Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_cases_1_B); this.Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor this.Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_0_selector_cases_B); } // Message from use of 'Rain' Bernoulli Rain_use_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); if (this.sprinkler) { // Message to 'Rain_use' from Copy factor Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_0_selector_B); } if (!this.sprinkler) { this.Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor this.Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli6)); // Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages. this.Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { this.Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor this.Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_0_B); } // The constant 'vBernoulli8' Bernoulli vBernoulli8 = Bernoulli.FromLogOdds(Double.NegativeInfinity); if (!this.sprinkler) { this.Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor this.Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli8)); // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor this.Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_cases_1_B); this.Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor this.Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(this.Rain_cond_Sprinkler_1_selector_cases_B); // Message to 'Rain_use' from Copy factor Rain_use_B = Factor.Copy <Bernoulli>(this.Rain_cond_Sprinkler_1_selector_B); } // Rain_use_B is now updated in all contexts // Message to 'Cloudy_selector_cases_uses' from Exit factor Cloudy_selector_cases_uses_B[1] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(Rain_use_B, Rain_cond_Cloudy_F, Cloudy_selector_cases_uses_B[1]); Bernoulli[] Cloudy_selector_cases_1_uses_B = default(Bernoulli[]); // Create array for 'Cloudy_selector_cases_1_uses' Backwards messages. Cloudy_selector_cases_1_uses_B = new Bernoulli[7]; for (int _ind = 0; _ind < 7; _ind++) { Cloudy_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Cloudy_selector_cases_1_uses' from Random factor Cloudy_selector_cases_1_uses_B[6] = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.sprinkler, vBernoulli0)); Bernoulli Cloudy_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Cloudy_selector_cases_1' from Replicate factor Cloudy_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Cloudy_selector_cases_1_uses_B, Cloudy_selector_cases_1_B); // Message to 'Cloudy_selector_cases_uses' from Copy factor Cloudy_selector_cases_uses_B[2][1] = Factor.Copy <Bernoulli>(Cloudy_selector_cases_1_B); DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Cloudy_selector_cases' Backwards messages. Cloudy_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_B[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Cloudy_selector_cases' from Replicate factor Cloudy_selector_cases_B = ReplicateOp.DefAverageConditional <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_B); Bernoulli Cloudy_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli0); // Message to 'Cloudy_selector' from Cases factor Cloudy_selector_B = CasesOp.BAverageConditional(Cloudy_selector_cases_B); // Message to 'Cloudy_marginal' from Variable factor this.Cloudy_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(Cloudy_selector_B, vBernoulli0, this.Cloudy_marginal_F); DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Cloudy_selector_cases' Forwards messages. Cloudy_selector_cases_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_F[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_F = default(DistributionStructArray <Bernoulli, bool>[]); // Create array for 'Cloudy_selector_cases_uses' Forwards messages. Cloudy_selector_cases_uses_F = new DistributionStructArray <Bernoulli, bool> [3]; for (int _ind = 0; _ind < 3; _ind++) { // Create array for 'Cloudy_selector_cases_uses' Forwards messages. Cloudy_selector_cases_uses_F[_ind] = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_uses_F[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } } // Message to 'Cloudy_selector_cases' from Cases factor Cloudy_selector_cases_F = CasesOp.CasesAverageConditional <DistributionStructArray <Bernoulli, bool> >(vBernoulli0, Cloudy_selector_cases_F); // Buffer for Replicate2BufferOp.UsesAverageConditional<DistributionStructArray<Bernoulli,bool>> DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_uses_B_marginal = default(DistributionStructArray <Bernoulli, bool>); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.MarginalInit <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_F); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 1, Cloudy_selector_cases_uses_F[1]); this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli3); // Message to 'Rain' from Exit factor Rain_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(Rain_use_B, Cloudy_selector_cases_uses_F[1], Rain_cond_Cloudy_F, Rain_F); // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Rain_use_B, Rain_F, this.Rain_marginal_F); this.Changed_Sprinkler_WetGrass_iterationsDone = 1; }
/// <summary> /// VMP message to 'A' /// </summary> /// <param name="sum">Incoming message from 'Sum'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'A'. Must be a proper distribution. If all elements are uniform, the result will be uniform.</param> /// <param name="B">Constant value for 'B'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'A' with 'Sum' integrated out. /// The formula is <c>sum_Sum p(Sum) factor(Sum,A,B)</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sum"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception> public static DistributionStructArray <Bernoulli, bool> AAverageLogarithm([SkipIfUniform] Gaussian sum, [SkipIfAllUniform] DistributionStructArray <Bernoulli, bool> A, Vector B, DistributionStructArray <Bernoulli, bool> result) { double mu = sum.GetMean(); var ma = A.Select(x => x.GetMean()).ToArray(); for (int i = 0; i < A.Count; i++) { double term1 = 0.0; for (int j = 0; j < A.Count; j++) { if (j != i) { term1 += ma[i] * B[i] * B[j]; } } var ri = result[i]; ri.LogOdds = -.5 * sum.Precision * (2.0 * term1 + B[i] * B[i] - 2.0 * mu * B[i]); result[i] = ri; } return(result); }
public static DistributionStructArray <Bernoulli, bool> AAverageLogarithm([SkipIfUniform] double sum, [SkipIfAllUniform] DistributionStructArray <Bernoulli, bool> A, Vector B) { throw new NotSupportedException(NotSupportedMessage); }
/// <summary> /// VMP message to 'A' /// </summary> /// <param name="sum">Incoming message from 'Sum'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'A'. Must be a proper distribution. If all elements are uniform, the result will be uniform.</param> /// <param name="B">Incoming message from 'B'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanOfB">Buffer 'MeanOfB'.</param> /// <param name="CovarianceOfB">Buffer 'CovarianceOfB'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'A'. /// Because the factor is deterministic, 'Sum' is integrated out before taking the logarithm. /// The formula is <c>exp(sum_(B) p(B) log(sum_Sum p(Sum) factor(Sum,A,B)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sum"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="B"/> is not a proper distribution</exception> public static DistributionStructArray <Bernoulli, bool> AAverageLogarithm([SkipIfUniform] Gaussian sum, [SkipIfAllUniform] DistributionStructArray <Bernoulli, bool> A, [SkipIfUniform] VectorGaussian B, Vector MeanOfB, PositiveDefiniteMatrix CovarianceOfB, DistributionStructArray <Bernoulli, bool> result) { double mu = sum.GetMean(); var Ebbt = new PositiveDefiniteMatrix(A.Count, A.Count); Ebbt.SetToSumWithOuter(CovarianceOfB, 1, MeanOfB, MeanOfB); var ma = A.Select(x => x.GetMean()).ToArray(); for (int i = 0; i < A.Count; i++) { double term1 = 0.0; for (int j = 0; j < A.Count; j++) { if (j != i) { term1 += ma[i] * Ebbt[i, j]; } } var ri = result[i]; ri.LogOdds = -.5 * sum.Precision * (2.0 * term1 + Ebbt[i, i] - 2.0 * mu * MeanOfB[i]); result[i] = ri; } return(result); }
/// <summary>Computations that depend on the observed value of numberOfIterations and vint__0 and vint__1</summary> /// <param name="numberOfIterations">The number of times to iterate each loop</param> private void Changed_numberOfIterations_vint__0_vint__1(int numberOfIterations) { if (this.Changed_numberOfIterations_vint__0_vint__1_isDone) { return; } DistributionStructArray <Gaussian, double> vdouble__0_F; Gaussian vdouble__0_F_reduced; // Create array for 'vdouble__0' Forwards messages. vdouble__0_F = new DistributionStructArray <Gaussian, double>(5); // Message to 'vdouble__0' from GaussianFromMeanAndVariance factor vdouble__0_F_reduced = GaussianFromMeanAndVarianceOp.SampleAverageConditional(6.0, 9.0); for (int index1 = 0; index1 < 5; index1++) { vdouble__0_F[index1] = vdouble__0_F_reduced; vdouble__0_F[index1] = vdouble__0_F_reduced; } // Create array for 'vdouble__0_marginal' Forwards messages. this.vdouble__0_marginal_F = new DistributionStructArray <Gaussian, double>(5); DistributionStructArray <Gaussian, double> vdouble__0_use_B; // Create array for 'vdouble__0_use' Backwards messages. vdouble__0_use_B = new DistributionStructArray <Gaussian, double>(5); for (int index1 = 0; index1 < 5; index1++) { vdouble__0_use_B[index1] = Gaussian.Uniform(); } DistributionStructArray <Gaussian, double>[] vdouble__0_uses_F; // Create array for 'vdouble__0_uses' Forwards messages. vdouble__0_uses_F = new DistributionStructArray <Gaussian, double> [2]; // Create array for 'vdouble__0_uses' Forwards messages. vdouble__0_uses_F[1] = new DistributionStructArray <Gaussian, double>(5); for (int index1 = 0; index1 < 5; index1++) { vdouble__0_uses_F[1][index1] = Gaussian.Uniform(); } DistributionStructArray <Gaussian, double> vdouble__0_uses_F_1__marginal; // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor vdouble__0_uses_F_1__marginal = GetItemsOp <double> .MarginalInit <DistributionStructArray <Gaussian, double> >(vdouble__0_uses_F[1]); DistributionStructArray <Gaussian, double> vdouble__0_itemvint__1_index0__F; // Create array for 'vdouble__0_itemvint__1_index0_' Forwards messages. vdouble__0_itemvint__1_index0__F = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble__0_itemvint__1_index0__F[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble11_F' DistributionStructArray <Gaussian, double> vdouble11_F = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble11_F[index0] = Gaussian.Uniform(); } // Create array for 'vdouble__0_uses' Forwards messages. vdouble__0_uses_F[0] = new DistributionStructArray <Gaussian, double>(5); for (int index1 = 0; index1 < 5; index1++) { vdouble__0_uses_F[0][index1] = Gaussian.Uniform(); } DistributionStructArray <Gaussian, double> vdouble__0_uses_F_0__marginal; // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor vdouble__0_uses_F_0__marginal = GetItemsOp <double> .MarginalInit <DistributionStructArray <Gaussian, double> >(vdouble__0_uses_F[0]); DistributionStructArray <Gaussian, double> vdouble__0_itemvint__0_index0__F; // Create array for 'vdouble__0_itemvint__0_index0_' Forwards messages. vdouble__0_itemvint__0_index0__F = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble__0_itemvint__0_index0__F[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble8_F' DistributionStructArray <Gaussian, double> vdouble8_F = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble8_F[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble12_F' DistributionStructArray <Gaussian, double> vdouble12_F = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble12_F[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble12_B' DistributionStructArray <Gaussian, double> vdouble12_B = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble12_B[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble8_use_B' DistributionStructArray <Gaussian, double> vdouble8_use_B = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble8_use_B[index0] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble11_use_B' DistributionStructArray <Gaussian, double> vdouble11_use_B = new DistributionStructArray <Gaussian, double>(6); for (int index0 = 0; index0 < 6; index0++) { vdouble11_use_B[index0] = Gaussian.Uniform(); } for (int iteration = this.numberOfIterationsDone; iteration < numberOfIterations; iteration++) { // Message to 'vdouble__0_uses' from Replicate factor vdouble__0_uses_F[1] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_F, 1, vdouble__0_uses_F[1]); // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor vdouble__0_uses_F_1__marginal = GetItemsOp <double> .Marginal <DistributionStructArray <Gaussian, double>, Gaussian>(vdouble__0_uses_F[1], this.vdouble__0_uses_B[1], vdouble__0_uses_F_1__marginal); // Message to 'vdouble__0_uses' from Replicate factor vdouble__0_uses_F[0] = ReplicateOp_NoDivide.UsesAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_F, 0, vdouble__0_uses_F[0]); // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor vdouble__0_uses_F_0__marginal = GetItemsOp <double> .Marginal <DistributionStructArray <Gaussian, double>, Gaussian>(vdouble__0_uses_F[0], this.vdouble__0_uses_B[0], vdouble__0_uses_F_0__marginal); for (int index0 = 0; index0 < 6; index0++) { // Message to 'vdouble__0_itemvint__1_index0_' from GetItems factor vdouble__0_itemvint__1_index0__F[index0] = GetItemsOp <double> .ItemsAverageConditional <DistributionStructArray <Gaussian, double>, Gaussian>(this.vdouble__0_itemvint__1_index0__B[index0], vdouble__0_uses_F[1], vdouble__0_uses_F_1__marginal, this.Vint__1, index0, vdouble__0_itemvint__1_index0__F[index0]); // Message to 'vdouble11' from GaussianFromMeanAndVariance factor vdouble11_F[index0] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__0_itemvint__1_index0__F[index0], 1.0); // Message to 'vdouble__0_itemvint__0_index0_' from GetItems factor vdouble__0_itemvint__0_index0__F[index0] = GetItemsOp <double> .ItemsAverageConditional <DistributionStructArray <Gaussian, double>, Gaussian>(this.vdouble__0_itemvint__0_index0__B[index0], vdouble__0_uses_F[0], vdouble__0_uses_F_0__marginal, this.Vint__0, index0, vdouble__0_itemvint__0_index0__F[index0]); // Message to 'vdouble8' from GaussianFromMeanAndVariance factor vdouble8_F[index0] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__0_itemvint__0_index0__F[index0], 1.0); // Message to 'vdouble12' from Difference factor vdouble12_F[index0] = DoublePlusOp.AAverageConditional(vdouble8_F[index0], vdouble11_F[index0]); // Message to 'vdouble12' from IsPositive factor vdouble12_B[index0] = IsPositiveOp_Proper.XAverageConditional(Bernoulli.PointMass(true), vdouble12_F[index0]); // Message to 'vdouble8_use' from Difference factor vdouble8_use_B[index0] = DoublePlusOp.SumAverageConditional(vdouble12_B[index0], vdouble11_F[index0]); // Message to 'vdouble__0_itemvint__0_index0_' from GaussianFromMeanAndVariance factor this.vdouble__0_itemvint__0_index0__B[index0] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(vdouble8_use_B[index0], 1.0); // Message to 'vdouble11_use' from Difference factor vdouble11_use_B[index0] = DoublePlusOp.BAverageConditional(vdouble8_F[index0], vdouble12_B[index0]); // Message to 'vdouble__0_itemvint__1_index0_' from GaussianFromMeanAndVariance factor this.vdouble__0_itemvint__1_index0__B[index0] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(vdouble11_use_B[index0], 1.0); } // Message to 'vdouble__0_uses' from GetItems factor this.vdouble__0_uses_B[0] = GetItemsOp <double> .ArrayAverageConditional <Gaussian, DistributionStructArray <Gaussian, double> >(this.vdouble__0_itemvint__0_index0__B, this.Vint__0, this.vdouble__0_uses_B[0]); // Message to 'vdouble__0_uses' from GetItems factor this.vdouble__0_uses_B[1] = GetItemsOp <double> .ArrayAverageConditional <Gaussian, DistributionStructArray <Gaussian, double> >(this.vdouble__0_itemvint__1_index0__B, this.Vint__1, this.vdouble__0_uses_B[1]); this.OnProgressChanged(new ProgressChangedEventArgs(iteration)); } // Message to 'vdouble__0_use' from Replicate factor vdouble__0_use_B = ReplicateOp_NoDivide.DefAverageConditional <DistributionStructArray <Gaussian, double> >(this.vdouble__0_uses_B, vdouble__0_use_B); for (int index1 = 0; index1 < 5; index1++) { this.vdouble__0_marginal_F[index1] = Gaussian.Uniform(); // Message to 'vdouble__0_marginal' from Variable factor this.vdouble__0_marginal_F[index1] = VariableOp.MarginalAverageConditional <Gaussian>(vdouble__0_use_B[index1], vdouble__0_F_reduced, this.vdouble__0_marginal_F[index1]); } this.Changed_numberOfIterations_vint__0_vint__1_isDone = true; }
/// <summary> /// The marginal distribution is the same as the message to uses. /// </summary> /// <param name="Uses"></param> /// <param name="Def"></param> /// <param name="result"></param> /// <returns></returns> public static DistributionStructArray <Gaussian, double> MarginalAverageLogarithm(DistributionStructArray <NonconjugateGaussian, double>[] Uses, DistributionStructArray <Gaussian, double> Def, DistributionStructArray <Gaussian, double> result) { return(UsesAverageLogarithm(Uses, Def, result)); }
/// <summary>Computations that depend on the observed value of vVector__330 and vdouble__990</summary> private void Changed_vVector__330_vdouble__990() { if (this.Changed_vVector__330_vdouble__990_iterationsDone == 1) { return; } this.vVector__330_marginal = new PointMass <Vector[]>(this.VVector__330); this.vdouble__990_marginal = new DistributionStructArray <Gaussian, double>(5622, delegate(int index330) { return(Gaussian.Uniform()); }); this.vdouble__990_marginal = Distribution.SetPoint <DistributionStructArray <Gaussian, double>, double[]>(this.vdouble__990_marginal, this.Vdouble__990); // The constant 'vVectorGaussian330' VectorGaussian vVectorGaussian330 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] { 0.0, 0.0, 0.0 }), new PositiveDefiniteMatrix(new double[3, 3] { { 1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, 0.0, 1.0 } })); this.vVector991_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian330); // Message from use of 'vdouble__991' DistributionStructArray <Gaussian, double> vdouble__991_use_B = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__991_use' Backwards messages. vdouble__991_use_B = new DistributionStructArray <Gaussian, double>(5622); for (int index330 = 0; index330 < 5622; index330++) { vdouble__991_use_B[index330] = Gaussian.Uniform(); // Message to 'vdouble__991_use' from GaussianFromMeanAndVariance factor vdouble__991_use_B[index330] = GaussianFromMeanAndVarianceOp.MeanAverageConditional(this.Vdouble__990[index330], 0.1); } DistributionRefArray <VectorGaussian, Vector> vVector991_rep_B = default(DistributionRefArray <VectorGaussian, Vector>); // Create array for 'vVector991_rep' Backwards messages. vVector991_rep_B = new DistributionRefArray <VectorGaussian, Vector>(5622); for (int index330 = 0; index330 < 5622; index330++) { vVector991_rep_B[index330] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian330); // Message to 'vVector991_rep' from InnerProduct factor vVector991_rep_B[index330] = InnerProductOp.AAverageConditional(vdouble__991_use_B[index330], this.VVector__330[index330], vVector991_rep_B[index330]); } // Buffer for ReplicateOp_Divide.Marginal<VectorGaussian> VectorGaussian vVector991_rep_B_toDef = default(VectorGaussian); // Message to 'vVector991_rep' from Replicate factor vVector991_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian330); // Message to 'vVector991_rep' from Replicate factor vVector991_rep_B_toDef = ReplicateOp_Divide.ToDef <VectorGaussian>(vVector991_rep_B, vVector991_rep_B_toDef); // Message to 'vVector991_marginal' from Variable factor this.vVector991_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector991_rep_B_toDef, vVectorGaussian330, this.vVector991_marginal_F); DistributionStructArray <Gaussian, double> vdouble__991_F = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__991' Forwards messages. vdouble__991_F = new DistributionStructArray <Gaussian, double>(5622); for (int index330 = 0; index330 < 5622; index330++) { vdouble__991_F[index330] = Gaussian.Uniform(); } DistributionRefArray <VectorGaussian, Vector> vVector991_rep_F = default(DistributionRefArray <VectorGaussian, Vector>); // Create array for 'vVector991_rep' Forwards messages. vVector991_rep_F = new DistributionRefArray <VectorGaussian, Vector>(5622); for (int index330 = 0; index330 < 5622; index330++) { vVector991_rep_F[index330] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian330); } // Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian> VectorGaussian vVector991_rep_F_marginal = default(VectorGaussian); // Message to 'vVector991_rep' from Replicate factor vVector991_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian330); // Message to 'vVector991_rep' from Replicate factor vVector991_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector991_rep_B_toDef, vVectorGaussian330, vVector991_rep_F_marginal); // Buffer for InnerProductOp.InnerProductAverageConditional // Create array for replicates of 'vVector991_rep_F_index330__AMean' Vector[] vVector991_rep_F_index330__AMean = new Vector[5622]; for (int index330 = 0; index330 < 5622; index330++) { // Message to 'vdouble__991' from InnerProduct factor vVector991_rep_F_index330__AMean[index330] = InnerProductOp.AMeanInit(vVector991_rep_F[index330]); } // Buffer for InnerProductOp.AMean // Create array for replicates of 'vVector991_rep_F_index330__AVariance' PositiveDefiniteMatrix[] vVector991_rep_F_index330__AVariance = new PositiveDefiniteMatrix[5622]; for (int index330 = 0; index330 < 5622; index330++) { // Message to 'vdouble__991' from InnerProduct factor vVector991_rep_F_index330__AVariance[index330] = InnerProductOp.AVarianceInit(vVector991_rep_F[index330]); // Message to 'vVector991_rep' from Replicate factor vVector991_rep_F[index330] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector991_rep_B[index330], vVector991_rep_F_marginal, index330, vVector991_rep_F[index330]); } // Create array for 'vdouble__991_marginal' Forwards messages. this.vdouble__991_marginal_F = new DistributionStructArray <Gaussian, double>(5622); for (int index330 = 0; index330 < 5622; index330++) { this.vdouble__991_marginal_F[index330] = Gaussian.Uniform(); // Message to 'vdouble__991' from InnerProduct factor vVector991_rep_F_index330__AVariance[index330] = InnerProductOp.AVariance(vVector991_rep_F[index330], vVector991_rep_F_index330__AVariance[index330]); // Message to 'vdouble__991' from InnerProduct factor vVector991_rep_F_index330__AMean[index330] = InnerProductOp.AMean(vVector991_rep_F[index330], vVector991_rep_F_index330__AVariance[index330], vVector991_rep_F_index330__AMean[index330]); // Message to 'vdouble__991' from InnerProduct factor vdouble__991_F[index330] = InnerProductOp.InnerProductAverageConditional(vVector991_rep_F_index330__AMean[index330], vVector991_rep_F_index330__AVariance[index330], this.VVector__330[index330]); // Message to 'vdouble__991_marginal' from DerivedVariable factor this.vdouble__991_marginal_F[index330] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__991_use_B[index330], vdouble__991_F[index330], this.vdouble__991_marginal_F[index330]); } this.Changed_vVector__330_vdouble__990_iterationsDone = 1; }
/// <summary> /// The marginal distribution is the same as the message to uses. /// </summary> /// <param name="Uses"></param> /// <param name="Def"></param> /// <param name="result"></param> /// <returns></returns> public static DistributionStructArray<Gaussian, double> MarginalAverageLogarithm(DistributionStructArray<NonconjugateGaussian, double>[] Uses, DistributionStructArray<Gaussian, double> Def, DistributionStructArray<Gaussian, double> result) { return UsesAverageLogarithm(Uses, Def, result); }
/// <summary>Computations that depend on the observed value of vVector__251</summary> private void Changed_vVector__251() { if (this.Changed_vVector__251_iterationsDone == 1) { return; } this.vVector__251_marginal = new PointMass <Vector[]>(this.VVector__251); // The constant 'vVectorGaussian251' VectorGaussian vVectorGaussian251 = VectorGaussian.FromNatural(DenseVector.FromArray(new double[3] { 1547829870.0, 525077980.0, 200270.0 }), new PositiveDefiniteMatrix(new double[3, 3] { { 4254590363351.0, 1127383488860.0, 433199230.0 }, { 1127383488860.0, 482723521821.0, 146764360.0 }, { 433199230.0, 146764360.0, 56221.0 } })); this.vVector753_marginal_F = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian251); // Buffer for ReplicateOp_Divide.Marginal<VectorGaussian> VectorGaussian vVector753_rep_B_toDef = default(VectorGaussian); // Message to 'vVector753_rep' from Replicate factor vVector753_rep_B_toDef = ReplicateOp_Divide.ToDefInit <VectorGaussian>(vVectorGaussian251); // Message to 'vVector753_marginal' from Variable factor this.vVector753_marginal_F = VariableOp.MarginalAverageConditional <VectorGaussian>(vVector753_rep_B_toDef, vVectorGaussian251, this.vVector753_marginal_F); DistributionStructArray <Gaussian, double> vdouble__753_F = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__753' Forwards messages. vdouble__753_F = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { vdouble__753_F[index251] = Gaussian.Uniform(); } DistributionStructArray <Gaussian, double> vdouble__754_F = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__754' Forwards messages. vdouble__754_F = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { vdouble__754_F[index251] = Gaussian.Uniform(); } DistributionRefArray <VectorGaussian, Vector> vVector753_rep_F = default(DistributionRefArray <VectorGaussian, Vector>); DistributionRefArray <VectorGaussian, Vector> vVector753_rep_B = default(DistributionRefArray <VectorGaussian, Vector>); // Create array for 'vVector753_rep' Forwards messages. vVector753_rep_F = new DistributionRefArray <VectorGaussian, Vector>(1); // Create array for 'vVector753_rep' Backwards messages. vVector753_rep_B = new DistributionRefArray <VectorGaussian, Vector>(1); for (int index251 = 0; index251 < 1; index251++) { vVector753_rep_B[index251] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian251); vVector753_rep_F[index251] = ArrayHelper.MakeUniform <VectorGaussian>(vVectorGaussian251); } // Buffer for ReplicateOp_Divide.UsesAverageConditional<VectorGaussian> VectorGaussian vVector753_rep_F_marginal = default(VectorGaussian); // Message to 'vVector753_rep' from Replicate factor vVector753_rep_F_marginal = ReplicateOp_Divide.MarginalInit <VectorGaussian>(vVectorGaussian251); // Message to 'vVector753_rep' from Replicate factor vVector753_rep_F_marginal = ReplicateOp_Divide.Marginal <VectorGaussian>(vVector753_rep_B_toDef, vVectorGaussian251, vVector753_rep_F_marginal); // Buffer for InnerProductOp.InnerProductAverageConditional // Create array for replicates of 'vVector753_rep_F_index251__AMean' Vector[] vVector753_rep_F_index251__AMean = new Vector[1]; for (int index251 = 0; index251 < 1; index251++) { // Message to 'vdouble__754' from InnerProduct factor vVector753_rep_F_index251__AMean[index251] = InnerProductOp.AMeanInit(vVector753_rep_F[index251]); } // Buffer for InnerProductOp.AMean // Create array for replicates of 'vVector753_rep_F_index251__AVariance' PositiveDefiniteMatrix[] vVector753_rep_F_index251__AVariance = new PositiveDefiniteMatrix[1]; for (int index251 = 0; index251 < 1; index251++) { // Message to 'vdouble__754' from InnerProduct factor vVector753_rep_F_index251__AVariance[index251] = InnerProductOp.AVarianceInit(vVector753_rep_F[index251]); // Message to 'vVector753_rep' from Replicate factor vVector753_rep_F[index251] = ReplicateOp_Divide.UsesAverageConditional <VectorGaussian>(vVector753_rep_B[index251], vVector753_rep_F_marginal, index251, vVector753_rep_F[index251]); } // Create array for 'vdouble__754_marginal' Forwards messages. this.vdouble__754_marginal_F = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { this.vdouble__754_marginal_F[index251] = Gaussian.Uniform(); } // Message from use of 'vdouble__754' DistributionStructArray <Gaussian, double> vdouble__754_use_B = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__754_use' Backwards messages. vdouble__754_use_B = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { vdouble__754_use_B[index251] = Gaussian.Uniform(); // Message to 'vdouble__754' from InnerProduct factor vVector753_rep_F_index251__AVariance[index251] = InnerProductOp.AVariance(vVector753_rep_F[index251], vVector753_rep_F_index251__AVariance[index251]); // Message to 'vdouble__754' from InnerProduct factor vVector753_rep_F_index251__AMean[index251] = InnerProductOp.AMean(vVector753_rep_F[index251], vVector753_rep_F_index251__AVariance[index251], vVector753_rep_F_index251__AMean[index251]); // Message to 'vdouble__754' from InnerProduct factor vdouble__754_F[index251] = InnerProductOp.InnerProductAverageConditional(vVector753_rep_F_index251__AMean[index251], vVector753_rep_F_index251__AVariance[index251], this.VVector__251[index251]); // Message to 'vdouble__754_marginal' from DerivedVariable factor this.vdouble__754_marginal_F[index251] = DerivedVariableOp.MarginalAverageConditional <Gaussian>(vdouble__754_use_B[index251], vdouble__754_F[index251], this.vdouble__754_marginal_F[index251]); } // Create array for 'vdouble__753_marginal' Forwards messages. this.vdouble__753_marginal_F = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { this.vdouble__753_marginal_F[index251] = Gaussian.Uniform(); } // Message from use of 'vdouble__753' DistributionStructArray <Gaussian, double> vdouble__753_use_B = default(DistributionStructArray <Gaussian, double>); // Create array for 'vdouble__753_use' Backwards messages. vdouble__753_use_B = new DistributionStructArray <Gaussian, double>(1); for (int index251 = 0; index251 < 1; index251++) { vdouble__753_use_B[index251] = Gaussian.Uniform(); // Message to 'vdouble__753' from GaussianFromMeanAndVariance factor vdouble__753_F[index251] = GaussianFromMeanAndVarianceOp.SampleAverageConditional(vdouble__754_F[index251], 0.1); // Message to 'vdouble__753_marginal' from Variable factor this.vdouble__753_marginal_F[index251] = VariableOp.MarginalAverageConditional <Gaussian>(vdouble__753_use_B[index251], vdouble__753_F[index251], this.vdouble__753_marginal_F[index251]); } this.Changed_vVector__251_iterationsDone = 1; }
/// <summary>Computations that depend on the observed value of numberOfIterationsDecreased and WetGrass</summary> /// <param name="numberOfIterations">The number of times to iterate each loop</param> public void Changed_numberOfIterationsDecreased_WetGrass(int numberOfIterations) { if (this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone == numberOfIterations) { return; } // The constant 'vBernoulli23' Bernoulli vBernoulli23 = Bernoulli.FromLogOdds(4.5951198501345889); this.WetGrass_marginal = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli23); this.WetGrass_marginal = Distribution.SetPoint <Bernoulli, bool>(this.WetGrass_marginal, this.wetGrass); Bernoulli Rain_F = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); // The constant 'vBernoulli18' Bernoulli vBernoulli18 = Bernoulli.FromLogOdds(0); this.Cloudy_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli18); DistributionStructArray <Bernoulli, bool> Rain_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Cloudy' Forwards messages. Rain_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _gateind = 0; _gateind < 2; _gateind++) { Rain_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); } // Message to 'Rain_cond_Cloudy' from Copy factor Rain_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(this.vBernoulli21); // The constant 'vBernoulli22' Bernoulli vBernoulli22 = Bernoulli.FromLogOdds(0.28185115214098749); // Message to 'Rain_cond_Cloudy' from Copy factor Rain_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli22); DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Cloudy_selector_cases' Forwards messages. Cloudy_selector_cases_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_F[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Cloudy_selector_cases' from Cases factor Cloudy_selector_cases_F = CasesOp.CasesAverageConditional <DistributionStructArray <Bernoulli, bool> >(vBernoulli18, Cloudy_selector_cases_F); // The constant 'vBernoulli19' Bernoulli vBernoulli19 = Bernoulli.FromLogOdds(-2.1972245773362191); DistributionStructArray <Bernoulli, bool> Sprinkler_cond_Cloudy_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Sprinkler_cond_Cloudy' Forwards messages. Sprinkler_cond_Cloudy_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _gateind = 0; _gateind < 2; _gateind++) { Sprinkler_cond_Cloudy_F[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); } // Message to 'Sprinkler_cond_Cloudy' from Copy factor Sprinkler_cond_Cloudy_F[0] = Factor.Copy <Bernoulli>(vBernoulli19); // Message to 'Sprinkler_cond_Cloudy' from Copy factor Sprinkler_cond_Cloudy_F[1] = Factor.Copy <Bernoulli>(vBernoulli18); Bernoulli Rain_cond_Sprinkler_0_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_0' from Random factor Rain_cond_Sprinkler_0_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli23)); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_0_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler_0_selector_cases' Backwards messages. Rain_cond_Sprinkler_0_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Rain_cond_Sprinkler_0_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor Rain_cond_Sprinkler_0_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_0_B); // The constant 'vBernoulli24' Bernoulli vBernoulli24 = Bernoulli.FromLogOdds(2.1972245773362196); Bernoulli Rain_cond_Sprinkler_0_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_0_selector_cases_1' from Random factor Rain_cond_Sprinkler_0_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli24)); // Message to 'Rain_cond_Sprinkler_0_selector_cases' from Copy factor Rain_cond_Sprinkler_0_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_cases_1_B); Bernoulli[] Sprinkler_selector_cases_0_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_cases_0_uses' Backwards messages. Sprinkler_selector_cases_0_uses_B = new Bernoulli[5]; for (int _ind = 0; _ind < 5; _ind++) { Sprinkler_selector_cases_0_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } Bernoulli Sprinkler_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); DistributionStructArray <Bernoulli, bool> Sprinkler_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Sprinkler_selector_cases' Backwards messages. Sprinkler_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Sprinkler_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } Bernoulli Rain_cond_Sprinkler_1_selector_cases_0_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_0' from Random factor Rain_cond_Sprinkler_1_selector_cases_0_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli24)); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_1_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler_1_selector_cases' Backwards messages. Rain_cond_Sprinkler_1_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _ind0 = 0; _ind0 < 2; _ind0++) { Rain_cond_Sprinkler_1_selector_cases_B[_ind0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor Rain_cond_Sprinkler_1_selector_cases_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_0_B); // The constant 'vBernoulli26' Bernoulli vBernoulli26 = Bernoulli.FromLogOdds(-2.4423470353692043); Bernoulli Rain_cond_Sprinkler_1_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); // Message to 'Rain_cond_Sprinkler_1_selector_cases_1' from Random factor Rain_cond_Sprinkler_1_selector_cases_1_B = Bernoulli.FromLogOdds(UnaryOp <bool> .LogEvidenceRatio <Bernoulli>(this.wetGrass, vBernoulli26)); // Message to 'Rain_cond_Sprinkler_1_selector_cases' from Copy factor Rain_cond_Sprinkler_1_selector_cases_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_cases_1_B); Bernoulli[] Sprinkler_selector_cases_1_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_cases_1_uses' Backwards messages. Sprinkler_selector_cases_1_uses_B = new Bernoulli[5]; for (int _ind = 0; _ind < 5; _ind++) { Sprinkler_selector_cases_1_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } Bernoulli Sprinkler_selector_cases_1_B = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); Bernoulli[] Sprinkler_selector_uses_B = default(Bernoulli[]); // Create array for 'Sprinkler_selector_uses' Backwards messages. Sprinkler_selector_uses_B = new Bernoulli[2]; for (int _ind = 0; _ind < 2; _ind++) { Sprinkler_selector_uses_B[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); } Bernoulli Sprinkler_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); // Buffer for Replicate2BufferOp.UsesAverageConditional<DistributionStructArray<Bernoulli,bool>> DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_uses_B_marginal = default(DistributionStructArray <Bernoulli, bool>); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.MarginalInit <DistributionStructArray <Bernoulli, bool> >(Cloudy_selector_cases_F); DistributionStructArray <Bernoulli, bool>[] Cloudy_selector_cases_uses_F = default(DistributionStructArray <Bernoulli, bool>[]); // Create array for 'Cloudy_selector_cases_uses' Forwards messages. Cloudy_selector_cases_uses_F = new DistributionStructArray <Bernoulli, bool> [4]; for (int _ind = 0; _ind < 4; _ind++) { // Create array for 'Cloudy_selector_cases_uses' Forwards messages. Cloudy_selector_cases_uses_F[_ind] = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_uses_F[_ind][_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } } Bernoulli Sprinkler_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); // Buffer for Replicate2BufferOp.UsesAverageConditional<Bernoulli> Bernoulli Sprinkler_selector_uses_B_marginal = default(Bernoulli); // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.MarginalInit <Bernoulli>(Sprinkler_F); Bernoulli[] Sprinkler_selector_uses_F = default(Bernoulli[]); // Create array for 'Sprinkler_selector_uses' Forwards messages. Sprinkler_selector_uses_F = new Bernoulli[2]; for (int _ind = 0; _ind < 2; _ind++) { Sprinkler_selector_uses_F[_ind] = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); } Bernoulli Rain_cond_Sprinkler_0_selector_B = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); // Message to 'Rain_cond_Sprinkler_0_selector' from Cases factor Rain_cond_Sprinkler_0_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_0_selector_cases_B); DistributionStructArray <Bernoulli, bool> Rain_cond_Sprinkler_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Rain_cond_Sprinkler' Backwards messages. Rain_cond_Sprinkler_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _gateind = 0; _gateind < 2; _gateind++) { Rain_cond_Sprinkler_B[_gateind] = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); } // Message to 'Rain_cond_Sprinkler' from Copy factor Rain_cond_Sprinkler_B[0] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_0_selector_B); Bernoulli Rain_cond_Sprinkler_1_selector_B = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); // Message to 'Rain_cond_Sprinkler_1_selector' from Cases factor Rain_cond_Sprinkler_1_selector_B = CasesOp.BAverageConditional(Rain_cond_Sprinkler_1_selector_cases_B); // Message to 'Rain_cond_Sprinkler' from Copy factor Rain_cond_Sprinkler_B[1] = Factor.Copy <Bernoulli>(Rain_cond_Sprinkler_1_selector_B); for (int iteration = this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone; iteration < numberOfIterations; iteration++) { // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 1, Cloudy_selector_cases_uses_F[1]); // Message to 'Rain' from Exit factor Rain_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(this.Rain_use_B, Cloudy_selector_cases_uses_F[1], Rain_cond_Cloudy_F, Rain_F); // Message to 'Sprinkler_selector_cases_1_uses' from Cases factor Sprinkler_selector_cases_1_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_1_selector_cases_B, Rain_F)); // Message to 'Sprinkler_selector_cases_1' from Replicate factor Sprinkler_selector_cases_1_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_1_uses_B, Sprinkler_selector_cases_1_B); // Message to 'Sprinkler_selector_cases' from Copy factor Sprinkler_selector_cases_B[1] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_1_B); // Message to 'Sprinkler_selector_cases_0_uses' from Cases factor Sprinkler_selector_cases_0_uses_B[4] = Bernoulli.FromLogOdds(CasesOp.LogEvidenceRatio(Rain_cond_Sprinkler_0_selector_cases_B, Rain_F)); // Message to 'Sprinkler_selector_cases_0' from Replicate factor Sprinkler_selector_cases_0_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_cases_0_uses_B, Sprinkler_selector_cases_0_B); // Message to 'Sprinkler_selector_cases' from Copy factor Sprinkler_selector_cases_B[0] = Factor.Copy <Bernoulli>(Sprinkler_selector_cases_0_B); // Message to 'Sprinkler_selector_uses' from Cases factor Sprinkler_selector_uses_B[0] = CasesOp.BAverageConditional(Sprinkler_selector_cases_B); // Message to 'Sprinkler_selector' from Replicate factor Sprinkler_selector_B = ReplicateOp.DefAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_selector_B); // Message to 'Cloudy_selector_cases_uses' from Exit factor this.Cloudy_selector_cases_uses_B[3] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(Sprinkler_selector_B, Sprinkler_cond_Cloudy_F, this.Cloudy_selector_cases_uses_B[3]); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_B_marginal = Replicate2BufferOp.Marginal <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal); // Message to 'Cloudy_selector_cases_uses' from Replicate factor Cloudy_selector_cases_uses_F[3] = Replicate2BufferOp.UsesAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_F, Cloudy_selector_cases_uses_B_marginal, 3, Cloudy_selector_cases_uses_F[3]); // Message to 'Sprinkler' from Exit factor Sprinkler_F = GateExitOp <bool> .ExitAverageConditional <Bernoulli>(Sprinkler_selector_B, Cloudy_selector_cases_uses_F[3], Sprinkler_cond_Cloudy_F, Sprinkler_F); // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_B_marginal = Replicate2BufferOp.Marginal <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_F, Sprinkler_selector_uses_B_marginal); // Message to 'Sprinkler_selector_uses' from Replicate factor Sprinkler_selector_uses_F[1] = Replicate2BufferOp.UsesAverageConditional <Bernoulli>(Sprinkler_selector_uses_B, Sprinkler_F, Sprinkler_selector_uses_B_marginal, 1, Sprinkler_selector_uses_F[1]); // Message to 'Rain_use' from EnterPartial factor this.Rain_use_B = GateEnterPartialOp <bool> .ValueAverageConditional <Bernoulli>(Rain_cond_Sprinkler_B, Sprinkler_selector_uses_F[1], Rain_F, new int[2] { 0, 1 }, this.Rain_use_B); // Message to 'Cloudy_selector_cases_uses' from Exit factor this.Cloudy_selector_cases_uses_B[1] = GateExitOp <bool> .CasesAverageConditional <Bernoulli, DistributionStructArray <Bernoulli, bool> >(this.Rain_use_B, Rain_cond_Cloudy_F, this.Cloudy_selector_cases_uses_B[1]); this.OnProgressChanged(new ProgressChangedEventArgs(iteration)); } DistributionStructArray <Bernoulli, bool> Cloudy_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'Cloudy_selector_cases' Backwards messages. Cloudy_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv0 = 0; _iv0 < 2; _iv0++) { Cloudy_selector_cases_B[_iv0] = ArrayHelper.MakeUniform <Bernoulli>(new Bernoulli()); } // Message to 'Cloudy_selector_cases' from Replicate factor Cloudy_selector_cases_B = ReplicateOp.DefAverageConditional <DistributionStructArray <Bernoulli, bool> >(this.Cloudy_selector_cases_uses_B, Cloudy_selector_cases_B); Bernoulli Cloudy_selector_B = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli18); // Message to 'Cloudy_selector' from Cases factor Cloudy_selector_B = CasesOp.BAverageConditional(Cloudy_selector_cases_B); // Message to 'Cloudy_marginal' from Variable factor this.Cloudy_marginal_F = VariableOp.MarginalAverageConditional <Bernoulli>(Cloudy_selector_B, vBernoulli18, this.Cloudy_marginal_F); this.Rain_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(this.vBernoulli21); // Message to 'Rain_marginal' from DerivedVariable factor this.Rain_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(this.Rain_use_B, Rain_F, this.Rain_marginal_F); this.Sprinkler_marginal_F = ArrayHelper.MakeUniform <Bernoulli>(vBernoulli19); // Message to 'Sprinkler_marginal' from DerivedVariable factor this.Sprinkler_marginal_F = DerivedVariableOp.MarginalAverageConditional <Bernoulli>(Sprinkler_selector_B, Sprinkler_F, this.Sprinkler_marginal_F); this.Changed_numberOfIterationsDecreased_WetGrass_iterationsDone = numberOfIterations; }
/// <summary> /// VMP message to 'B' /// </summary> /// <param name="sum">Incoming message from 'Sum'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'A'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the exponential of the average log-factor value, where the average is over all arguments except 'B'. /// Because the factor is deterministic, 'Sum' is integrated out before taking the logarithm. /// The formula is <c>exp(sum_(A) p(A) log(sum_Sum p(Sum) factor(Sum,A,B)))</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sum"/> is not a proper distribution</exception> public static VectorGaussian BAverageLogarithm([SkipIfUniform] Gaussian sum, DistributionStructArray<Bernoulli, bool> A, VectorGaussian result) { if (result == default(VectorGaussian)) result = new VectorGaussian(A.Count); // E[log N(x; ab, 0)] = -0.5 E[(x-ab)^2]/0 = -0.5 (E[x^2] - 2 E[x] a' E[b] + trace(aa' E[bb']))/0 // message to a = N(a; E[x]*inv(var(b)+E[b]E[b]')*E[b], var(x)*inv(var(b)+E[b]E[b]')) // result.Precision = (var(b)+E[b]*E[b]')/var(x) // result.MeanTimesPrecision = E[x]/var(x)*E[b] = E[b]*X.MeanTimesPrecision Vector ma = Vector.FromArray(A.Select(x => x.GetMean()).ToArray()); Vector va = Vector.FromArray(A.Select(x => x.GetVariance()).ToArray()); result.Precision.SetToDiagonal(va); result.Precision.SetToSumWithOuter(result.Precision, 1, ma, ma); result.Precision.SetToProduct(result.Precision, sum.Precision); result.MeanTimesPrecision.SetToProduct(ma, sum.MeanTimesPrecision); return result; }
/// <summary>Computations that depend on the observed value of numberOfIterationsDecreased and vGamma__1 and vGaussian__1 and vDirichlet1</summary> /// <param name="numberOfIterations">The number of times to iterate each loop</param> private void Changed_numberOfIterationsDecreased_vGamma__1_vGaussian__1_vDirichlet1(int numberOfIterations) { if (this.Changed_numberOfIterationsDecreased_vGamma__1_vGaussian__1_vDirichlet1_iterationsDone == numberOfIterations) { return; } // Create array for 'vdouble__3_marginal' Forwards messages. this.vdouble__3_marginal_F = new DistributionStructArray <Gaussian, double>(2); for (int index2 = 0; index2 < 2; index2++) { this.vdouble__3_marginal_F[index2] = Gaussian.Uniform(); } this.vVector1_marginal_F = ArrayHelper.MakeUniform <Dirichlet>(this.VDirichlet1); Discrete vint9_F = ArrayHelper.MakeUniform <Discrete>(Discrete.Uniform(2)); Discrete[] vint9_selector_uses_B = default(Discrete[]); // Create array for 'vint9_selector_uses' Backwards messages. vint9_selector_uses_B = new Discrete[3]; for (int _ind = 0; _ind < 3; _ind++) { vint9_selector_uses_B[_ind] = ArrayHelper.MakeUniform <Discrete>(Discrete.Uniform(2)); } DistributionStructArray <Bernoulli, bool>[] vint9_selector_cases_uses_B = default(DistributionStructArray <Bernoulli, bool>[]); // Create array for 'vint9_selector_cases_uses' Backwards messages. vint9_selector_cases_uses_B = new DistributionStructArray <Bernoulli, bool> [2]; for (int _ind = 0; _ind < 2; _ind++) { // Create array for 'vint9_selector_cases_uses' Backwards messages. vint9_selector_cases_uses_B[_ind] = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv = 0; _iv < 2; _iv++) { vint9_selector_cases_uses_B[_ind][_iv] = Bernoulli.Uniform(); } } DistributionStructArray <Bernoulli, bool>[] vint9_selector_cases_depth1_uses_B = default(DistributionStructArray <Bernoulli, bool>[]); // Create array for 'vint9_selector_cases_depth1_uses' Backwards messages. vint9_selector_cases_depth1_uses_B = new DistributionStructArray <Bernoulli, bool> [2]; for (int _iv = 0; _iv < 2; _iv++) { // Create array for 'vint9_selector_cases_depth1_uses' Backwards messages. vint9_selector_cases_depth1_uses_B[_iv] = new DistributionStructArray <Bernoulli, bool>(10); for (int _ind = 0; _ind < 10; _ind++) { vint9_selector_cases_depth1_uses_B[_iv][_ind] = Bernoulli.Uniform(); } } // Create array for replicates of 'vdouble17__index2__F' DistributionStructArray <Gaussian, double> vdouble17__index2__F = new DistributionStructArray <Gaussian, double>(2); for (int index2 = 0; index2 < 2; index2++) { vdouble17__index2__F[index2] = Gaussian.Uniform(); } // Message from use of 'vdouble17' Gaussian vdouble17_use_B = Gaussian.Uniform(); // Message to marginal of 'vdouble17__index2_' // Create array for replicates of 'vdouble17__index2__marginal_F' DistributionStructArray <Gaussian, double> vdouble17__index2__marginal_F = new DistributionStructArray <Gaussian, double>(2); for (int index2 = 0; index2 < 2; index2++) { vdouble17__index2__marginal_F[index2] = Gaussian.Uniform(); } // Create array for replicates of 'vdouble__4_index2__B' DistributionStructArray <Gamma, double> vdouble__4_index2__B = new DistributionStructArray <Gamma, double>(2); for (int index2 = 0; index2 < 2; index2++) { vdouble__4_index2__B[index2] = Gamma.Uniform(); } // Create array for 'vdouble__4_marginal' Forwards messages. this.vdouble__4_marginal_F = new DistributionStructArray <Gamma, double>(2); for (int index2 = 0; index2 < 2; index2++) { this.vdouble__4_marginal_F[index2] = Gamma.Uniform(); } DistributionStructArray <Bernoulli, bool> vint9_selector_cases_depth1_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'vint9_selector_cases_depth1' Backwards messages. vint9_selector_cases_depth1_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv = 0; _iv < 2; _iv++) { vint9_selector_cases_depth1_B[_iv] = Bernoulli.Uniform(); } DistributionStructArray <Bernoulli, bool> vint9_selector_cases_B = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'vint9_selector_cases' Backwards messages. vint9_selector_cases_B = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv = 0; _iv < 2; _iv++) { vint9_selector_cases_B[_iv] = Bernoulli.Uniform(); } this.vint9_marginal_F = ArrayHelper.MakeUniform <Discrete>(Discrete.Uniform(2)); // Create array for replicates of 'vdouble__3_index2__B' DistributionStructArray <Gaussian, double> vdouble__3_index2__B = new DistributionStructArray <Gaussian, double>(2); for (int index2 = 0; index2 < 2; index2++) { vdouble__3_index2__B[index2] = Gaussian.Uniform(); // Message to 'vdouble__3_marginal' from Variable factor this.vdouble__3_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gaussian>(this.vdouble__3_use_B[index2], this.VGaussian__1[index2], this.vdouble__3_marginal_F[index2]); // Message to 'vdouble__4_marginal' from Variable factor this.vdouble__4_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gamma>(this.vdouble__4_use_B[index2], this.VGamma__1[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble17__index2_' from Gaussian factor vdouble17__index2__F[index2] = GaussianOp.SampleAverageLogarithm(this.vdouble__3_marginal_F[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble17__index2__marginal' from Variable factor vdouble17__index2__marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gaussian>(vdouble17_use_B, vdouble17__index2__F[index2], vdouble17__index2__marginal_F[index2]); } // Message to 'vVector1_marginal' from Variable factor this.vVector1_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Dirichlet>(this.vVector1_use_B, this.VDirichlet1, this.vVector1_marginal_F); // Message to 'vint9' from Discrete factor vint9_F = DiscreteFromDirichletOp.SampleAverageLogarithm(this.vVector1_marginal_F, vint9_F); // Message to 'vint9_marginal' from Variable factor this.vint9_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Discrete>(this.vint9_selector_B, vint9_F, this.vint9_marginal_F); for (int iteration = this.Changed_numberOfIterationsDecreased_vGamma__1_vGaussian__1_vDirichlet1_iterationsDone; iteration < numberOfIterations; iteration++) { for (int index2 = 0; index2 < 2; index2++) { // Message to 'vdouble__4_marginal' from Variable factor this.vdouble__4_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gamma>(this.vdouble__4_use_B[index2], this.VGamma__1[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble__3_index2_' from Gaussian factor vdouble__3_index2__B[index2] = GaussianOp.MeanAverageLogarithm(vdouble17__index2__marginal_F[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble__3_use' from EnterOne factor this.vdouble__3_use_B[index2] = GateEnterOneOp <double> .ValueAverageLogarithm <Gaussian>(vdouble__3_index2__B[index2], this.vint9_marginal_F, index2, this.vdouble__3_use_B[index2]); // Message to 'vdouble__3_marginal' from Variable factor this.vdouble__3_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gaussian>(this.vdouble__3_use_B[index2], this.VGaussian__1[index2], this.vdouble__3_marginal_F[index2]); // Message to 'vdouble17__index2_' from Gaussian factor vdouble17__index2__F[index2] = GaussianOp.SampleAverageLogarithm(this.vdouble__3_marginal_F[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble17__index2__marginal' from Variable factor vdouble17__index2__marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gaussian>(vdouble17_use_B, vdouble17__index2__F[index2], vdouble17__index2__marginal_F[index2]); // Message to 'vint9_selector_cases_depth1_uses' from Variable factor vint9_selector_cases_depth1_uses_B[index2][8] = Bernoulli.FromLogOdds(VariableVmpOp.AverageLogFactor <Gaussian>(vdouble17__index2__marginal_F[index2])); // Message to 'vint9_selector_cases_depth1_uses' from Gaussian factor vint9_selector_cases_depth1_uses_B[index2][7] = Bernoulli.FromLogOdds(GaussianOp.AverageLogFactor(vdouble17__index2__marginal_F[index2], this.vdouble__3_marginal_F[index2], this.vdouble__4_marginal_F[index2])); } for (int _iv = 0; _iv < 2; _iv++) { // Message to 'vint9_selector_cases_depth1' from Replicate factor vint9_selector_cases_depth1_B[_iv] = ReplicateOp.DefAverageLogarithm <Bernoulli>(vint9_selector_cases_depth1_uses_B[_iv], vint9_selector_cases_depth1_B[_iv]); // Message to 'vint9_selector_cases_uses' from Copy factor vint9_selector_cases_uses_B[0][_iv] = ArrayHelper.SetTo <Bernoulli>(vint9_selector_cases_uses_B[0][_iv], vint9_selector_cases_depth1_B[_iv]); } // Message to 'vint9_selector_cases' from Replicate factor vint9_selector_cases_B = ReplicateOp.DefAverageLogarithm <DistributionStructArray <Bernoulli, bool> >(vint9_selector_cases_uses_B, vint9_selector_cases_B); // Message to 'vint9_selector_uses' from CasesInt factor vint9_selector_uses_B[0] = IntCasesOp.IAverageLogarithm(vint9_selector_cases_B, vint9_selector_uses_B[0]); // Message to 'vint9_selector' from Replicate factor this.vint9_selector_B = ReplicateOp.DefAverageLogarithm <Discrete>(vint9_selector_uses_B, this.vint9_selector_B); // Message to 'vVector1_marginal' from Variable factor this.vVector1_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Dirichlet>(this.vVector1_use_B, this.VDirichlet1, this.vVector1_marginal_F); // Message to 'vint9' from Discrete factor vint9_F = DiscreteFromDirichletOp.SampleAverageLogarithm(this.vVector1_marginal_F, vint9_F); // Message to 'vint9_marginal' from Variable factor this.vint9_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Discrete>(this.vint9_selector_B, vint9_F, this.vint9_marginal_F); for (int index2 = 0; index2 < 2; index2++) { // Message to 'vdouble__4_index2_' from Gaussian factor vdouble__4_index2__B[index2] = GaussianOp.PrecisionAverageLogarithm(vdouble17__index2__marginal_F[index2], this.vdouble__3_marginal_F[index2]); // Message to 'vdouble__4_use' from EnterOne factor this.vdouble__4_use_B[index2] = GateEnterOneOp <double> .ValueAverageLogarithm <Gamma>(vdouble__4_index2__B[index2], this.vint9_marginal_F, index2, this.vdouble__4_use_B[index2]); } // Message to 'vVector1_use' from Discrete factor this.vVector1_use_B = DiscreteFromDirichletOp.ProbsAverageLogarithm(this.vint9_marginal_F, this.vVector1_use_B); this.OnProgressChanged(new ProgressChangedEventArgs(iteration)); } for (int index2 = 0; index2 < 2; index2++) { // Message to 'vdouble__3_index2_' from Gaussian factor vdouble__3_index2__B[index2] = GaussianOp.MeanAverageLogarithm(vdouble17__index2__marginal_F[index2], this.vdouble__4_marginal_F[index2]); // Message to 'vdouble__3_use' from EnterOne factor this.vdouble__3_use_B[index2] = GateEnterOneOp <double> .ValueAverageLogarithm <Gaussian>(vdouble__3_index2__B[index2], this.vint9_marginal_F, index2, this.vdouble__3_use_B[index2]); // Message to 'vdouble__3_marginal' from Variable factor this.vdouble__3_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gaussian>(this.vdouble__3_use_B[index2], this.VGaussian__1[index2], this.vdouble__3_marginal_F[index2]); // Message to 'vint9_selector_cases_depth1_uses' from Gaussian factor vint9_selector_cases_depth1_uses_B[index2][7] = Bernoulli.FromLogOdds(GaussianOp.AverageLogFactor(vdouble17__index2__marginal_F[index2], this.vdouble__3_marginal_F[index2], this.vdouble__4_marginal_F[index2])); } for (int _iv = 0; _iv < 2; _iv++) { // Message to 'vint9_selector_cases_depth1' from Replicate factor vint9_selector_cases_depth1_B[_iv] = ReplicateOp.DefAverageLogarithm <Bernoulli>(vint9_selector_cases_depth1_uses_B[_iv], vint9_selector_cases_depth1_B[_iv]); // Message to 'vint9_selector_cases_uses' from Copy factor vint9_selector_cases_uses_B[0][_iv] = ArrayHelper.SetTo <Bernoulli>(vint9_selector_cases_uses_B[0][_iv], vint9_selector_cases_depth1_B[_iv]); } // Message to 'vint9_selector_cases' from Replicate factor vint9_selector_cases_B = ReplicateOp.DefAverageLogarithm <DistributionStructArray <Bernoulli, bool> >(vint9_selector_cases_uses_B, vint9_selector_cases_B); // Message to 'vint9_selector_uses' from CasesInt factor vint9_selector_uses_B[0] = IntCasesOp.IAverageLogarithm(vint9_selector_cases_B, vint9_selector_uses_B[0]); // Message to 'vint9_selector' from Replicate factor this.vint9_selector_B = ReplicateOp.DefAverageLogarithm <Discrete>(vint9_selector_uses_B, this.vint9_selector_B); // Message to 'vint9_marginal' from Variable factor this.vint9_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Discrete>(this.vint9_selector_B, vint9_F, this.vint9_marginal_F); for (int index2 = 0; index2 < 2; index2++) { // Message to 'vdouble__4_index2_' from Gaussian factor vdouble__4_index2__B[index2] = GaussianOp.PrecisionAverageLogarithm(vdouble17__index2__marginal_F[index2], this.vdouble__3_marginal_F[index2]); // Message to 'vdouble__4_use' from EnterOne factor this.vdouble__4_use_B[index2] = GateEnterOneOp <double> .ValueAverageLogarithm <Gamma>(vdouble__4_index2__B[index2], this.vint9_marginal_F, index2, this.vdouble__4_use_B[index2]); // Message to 'vdouble__4_marginal' from Variable factor this.vdouble__4_marginal_F[index2] = VariableVmpOp.MarginalAverageLogarithm <Gamma>(this.vdouble__4_use_B[index2], this.VGamma__1[index2], this.vdouble__4_marginal_F[index2]); } // Message to 'vVector1_use' from Discrete factor this.vVector1_use_B = DiscreteFromDirichletOp.ProbsAverageLogarithm(this.vint9_marginal_F, this.vVector1_use_B); // Message to 'vVector1_marginal' from Variable factor this.vVector1_marginal_F = VariableVmpOp.MarginalAverageLogarithm <Dirichlet>(this.vVector1_use_B, this.VDirichlet1, this.vVector1_marginal_F); this.vdouble17_F = Gaussian.Uniform(); DistributionStructArray <Bernoulli, bool> vint9_selector_cases_F = default(DistributionStructArray <Bernoulli, bool>); // Create array for 'vint9_selector_cases' Forwards messages. vint9_selector_cases_F = new DistributionStructArray <Bernoulli, bool>(2); for (int _iv = 0; _iv < 2; _iv++) { vint9_selector_cases_F[_iv] = Bernoulli.Uniform(); } // Message to 'vint9_selector_cases' from CasesInt factor vint9_selector_cases_F = IntCasesOp.CasesAverageLogarithm <DistributionStructArray <Bernoulli, bool> >(this.vint9_marginal_F, vint9_selector_cases_F); // Message to 'vdouble17' from Exit factor this.vdouble17_F = GateExitOp <double> .ExitAverageLogarithm <Gaussian>(vint9_selector_cases_F, vdouble17__index2__marginal_F, this.vdouble17_F); this.Changed_numberOfIterationsDecreased_vGamma__1_vGaussian__1_vDirichlet1_iterationsDone = numberOfIterations; }
/// <summary> /// VMP message to 'A' /// </summary> /// <param name="sum">Incoming message from 'Sum'. Must be a proper distribution. If uniform, the result will be uniform.</param> /// <param name="A">Incoming message from 'A'. Must be a proper distribution. If all elements are uniform, the result will be uniform.</param> /// <param name="B">Constant value for 'B'.</param> /// <param name="result">Modified to contain the outgoing message</param> /// <returns><paramref name="result"/></returns> /// <remarks><para> /// The outgoing message is the factor viewed as a function of 'A' with 'Sum' integrated out. /// The formula is <c>sum_Sum p(Sum) factor(Sum,A,B)</c>. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sum"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="A"/> is not a proper distribution</exception> public static DistributionStructArray<Bernoulli, bool> AAverageLogarithm([SkipIfUniform] Gaussian sum, [Proper] DistributionStructArray<Bernoulli, bool> A, Vector B, DistributionStructArray<Bernoulli, bool> result) { double mu = sum.GetMean(); var ma = A.Select(x => x.GetMean()).ToArray(); for (int i = 0; i < A.Count; i++) { double term1 = 0.0; for (int j = 0; j < A.Count; j++) if (j != i) term1 += ma[i] * B[i] * B[j]; var ri = result[i]; ri.LogOdds = -.5 * sum.Precision * (2.0 * term1 + B[i]*B[i] - 2.0 * mu * B[i]); result[i] = ri; } return result; }
public static DistributionStructArray <Bernoulli, bool> AAverageLogarithm(double sum, [Proper] DistributionStructArray <Bernoulli, bool> A, Vector B) { throw new NotSupportedException(NotSupportedMessage); }