/// <summary>
/// Constructs a new instance of the <see cref="Exp"/> type.
/// </summary>
/// <param name="arg">The exponent of the function.</param>
public Gp(Term[] args, GaussianProcess gp, int dc)
{
DivCount = dc;
Args = args;
Gpr = gp;
//GeneralMatrix cur = new GeneralMatrix(0, args.Length);
}
public void SetUp()
{
var kernel = new GaussianKernel(1, 1);
_gp = new GaussianProcess(kernel);
_gp.AddDataPoint(new DataPoint(1.02, 0.79));
_gp.AddDataPoint(new DataPoint(1.99, 0.94));
_gp.AddDataPoint(new DataPoint(4.04, 0.65));
}
public override void Run()
{
var prices = GetPrices("SPY").Select(t => t.Item2).ToArray();
var inputs = prices.Take(prices.Length - 1).ToArray();
var inputVectors = inputs.Select(i => Vector.FromArray(new[] { i })).ToArray();
var outputs = prices.Skip(1).ToArray();
// Set up the GP prior, which will be filled in later
var prior = Variable.New<SparseGP>().Named("prior");
// The sparse GP variable - a distribution over functions
var f = Variable<IFunction>.Random(prior).Named("f");
// The locations to evaluate the function
var x = Variable.Observed(inputVectors).Named("x");
var j = x.Range.Named("j");
var y = Variable.Observed(outputs, j).Named("y");
y[j] = Variable.GaussianFromMeanAndVariance(Variable.FunctionEvaluate(f, x[j]), 0.1);
var kf = new SquaredExponential(-0.5);
// The basis
var rand = new Random(Environment.TickCount);
var basis = Enumerable.Range(1, 10).Select(i => Vector.FromArray(new double[1] {i*10})).ToArray();
//var basis = new Vector[] {
// Vector.FromArray(new double[1] {80}),
// Vector.FromArray(new double[1] {90}),
// Vector.FromArray(new double[1] {100})
//};
var gp = new GaussianProcess(new ConstantFunction(0), kf);
prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, basis));
var engine = new InferenceEngine(new ExpectationPropagation());
var sgp = engine.Infer<SparseGP>(f);
var means = sgp.Mean(inputVectors).ToArray();
var stdDevs = inputVectors.Select(iv => Math.Sqrt(sgp.Variance(iv))).ToArray();
this.Series = new[]
{
new LabelledSeries<Tuple<double,double>>(
"input",
Enumerable.Range(0,inputs.Length)
.Select(i=> Tuple.Create((double)i, inputs[i]))),
new LabelledSeries<Tuple<double,double>>(
"infered mean",
Enumerable.Range(0,inputs.Length)
.Select(i=> Tuple.Create((double)i, means[i]))),
new LabelledSeries<Tuple<double,double>>(
"infered stddev",
Enumerable.Range(0,inputs.Length)
.Select(i=> Tuple.Create((double)i, stdDevs[i]))),
};
}
public static (Vector[] dataX, double[] dataY) GenerateRandomData(int numData, double proportionCorrupt)
{
int randomSeed = 9876;
Random rng = new Random(randomSeed);
Rand.Restart(randomSeed);
InferenceEngine engine = Utilities.GetInferenceEngine();
// The points to evaluate
Vector[] randomInputs = Utilities.VectorRange(0, 1, numData, null);
var gaussianProcessGenerator = new GaussianProcessRegressor(randomInputs);
// The basis
Vector[] basis = Utilities.VectorRange(0, 1, 6, rng);
// The kernel
var kf = new SummationKernel(new SquaredExponential(-1)) + new WhiteNoise();
// Fill in the sparse GP prior
GaussianProcess gp = new GaussianProcess(new ConstantFunction(0), kf);
gaussianProcessGenerator.Prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, basis));
// Infer the posterior Sparse GP, and sample a random function from it
SparseGP sgp = engine.Infer <SparseGP>(gaussianProcessGenerator.F);
var randomFunc = sgp.Sample();
double[] randomOutputs = new double[randomInputs.Length];
int numCorrupted = (int)Math.Ceiling(numData * proportionCorrupt);
var subset = Enumerable.Range(0, randomInputs.Length + 1).OrderBy(x => rng.Next()).Take(numCorrupted);
// get random data
for (int i = 0; i < randomInputs.Length; i++)
{
double post = randomFunc.Evaluate(randomInputs[i]);
// corrupt data point if it we haven't exceed the proportion we wish to corrupt
if (subset.Contains(i))
{
double sign = rng.NextDouble() > 0.5 ? 1 : -1;
double distance = rng.NextDouble() * 1;
post = (sign * distance) + post;
}
randomOutputs[i] = post;
}
Console.WriteLine("Model complete: Generated {0} points with {1} corrupted", numData, numCorrupted);
return(randomInputs, randomOutputs);
}
static void FitDataset(bool useSynthetic)
{
Vector[] trainingInputs;
double[] trainingOutputs;
if (!useSynthetic)
{
var trainingData = Utilities.LoadAISDataset();
trainingInputs = trainingData.Select(tup => Vector.FromArray(new double[1] {
tup.x
})).ToArray();
trainingOutputs = trainingData.Select(tup => tup.y).ToArray();
}
else
{
(trainingInputs, trainingOutputs) = GaussianProcessDataGenerator.GenerateRandomData(30, 0.3);
}
InferenceEngine engine = Utilities.GetInferenceEngine();
// First fit standard GP, then fit Student-T GP
foreach (var useStudentTLikelihood in new[] { false, true })
{
var gaussianProcessRegressor = new GaussianProcessRegressor(trainingInputs, useStudentTLikelihood, trainingOutputs);
// Log length scale estimated as -1
var noiseVariance = 0.8;
var kf = new SummationKernel(new SquaredExponential(-1)) + new WhiteNoise(Math.Log(noiseVariance) / 2);
GaussianProcess gp = new GaussianProcess(new ConstantFunction(0), kf);
// Convert SparseGP to full Gaussian Process by evaluating at all the training points
gaussianProcessRegressor.Prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, trainingInputs.ToArray()));
double logOdds = engine.Infer <Bernoulli>(gaussianProcessRegressor.Evidence).LogOdds;
Console.WriteLine("{0} evidence = {1}", kf, logOdds.ToString("g4"));
// Infer the posterior Sparse GP
SparseGP sgp = engine.Infer <SparseGP>(gaussianProcessRegressor.F);
#if NETFULL
string datasetName = useSynthetic ? "Synthetic" : "AIS";
Utilities.PlotPredictions(sgp, trainingInputs, trainingOutputs, useStudentTLikelihood, datasetName);
#endif
}
}
internal void HeteroscedasticGPR()
{
// This model is based on the paper "Most Likely Heteroscedastic Gaussian Process Regression" by Kersting et al, ICML 2007
// Silverman's motorcycle benchmark dataset
double[] inputs = new double[]
{
2.4, 2.6, 3.2, 3.6, 4, 6.2, 6.6, 6.8, 7.8, 8.199999999999999, 8.800000000000001, 8.800000000000001,
9.6, 10, 10.2, 10.6, 11, 11.4, 13.2, 13.6, 13.8, 14.6, 14.6, 14.6, 14.6, 14.6, 14.6, 14.8, 15.4, 15.4,
15.4, 15.4, 15.6, 15.6, 15.8, 15.8, 16, 16, 16.2, 16.2, 16.2, 16.4, 16.4, 16.6, 16.8, 16.8, 16.8, 17.6,
17.6, 17.6, 17.6, 17.8, 17.8, 18.6, 18.6, 19.2, 19.4, 19.4, 19.6, 20.2, 20.4, 21.2, 21.4, 21.8, 22, 23.2,
23.4, 24, 24.2, 24.2, 24.6, 25, 25, 25.4, 25.4, 25.6, 26, 26.2, 26.2, 26.4, 27, 27.2, 27.2, 27.2, 27.6,
28.2, 28.4, 28.4, 28.6, 29.4, 30.2, 31, 31.2, 32, 32, 32.8, 33.4, 33.8, 34.4, 34.8, 35.2, 35.2, 35.4, 35.6,
35.6, 36.2, 36.2, 38, 38, 39.2, 39.4, 40, 40.4, 41.6, 41.6, 42.4, 42.8, 42.8, 43, 44, 44.4, 45, 46.6, 47.8,
47.8, 48.8, 50.6, 52, 53.2, 55, 55, 55.4, 57.6
};
double[] outputs = new double[]
{
0, -1.3, -2.7, 0, -2.7, -2.7, -2.7, -1.3, -2.7, -2.7, -1.3, -2.7, -2.7, -2.7, -5.4,
-2.7, -5.4, 0, -2.7, -2.7, 0, -13.3, -5.4, -5.4, -9.300000000000001, -16, -22.8, -2.7, -22.8, -32.1, -53.5,
-54.9, -40.2, -21.5, -21.5, -50.8, -42.9, -26.8, -21.5, -50.8, -61.7, -5.4, -80.40000000000001, -59, -71,
-91.09999999999999, -77.7, -37.5, -85.59999999999999, -123.1, -101.9, -99.09999999999999, -104.4, -112.5,
-50.8, -123.1, -85.59999999999999, -72.3, -127.2, -123.1, -117.9, -134, -101.9, -108.4, -123.1, -123.1, -128.5,
-112.5, -95.09999999999999, -81.8, -53.5, -64.40000000000001, -57.6, -72.3, -44.3, -26.8, -5.4, -107.1, -21.5,
-65.59999999999999, -16, -45.6, -24.2, 9.5, 4, 12, -21.5, 37.5, 46.9, -17.4, 36.2, 75, 8.1, 54.9, 48.2, 46.9,
16, 45.6, 1.3, 75, -16, -54.9, 69.59999999999999, 34.8, 32.1, -37.5, 22.8, 46.9, 10.7, 5.4, -1.3, -21.5, -13.3,
30.8, -10.7, 29.4, 0, -10.7, 14.7, -1.3, 0, 10.7, 10.7, -26.8, -14.7, -13.3, 0, 10.7, -14.7, -2.7, 10.7, -2.7, 10.7
};
Range j = new Range(inputs.Length);
Vector[] inputsVec = Util.ArrayInit(inputs.Length, i => Vector.FromArray(inputs[i]));
VariableArray <Vector> x = Variable.Observed(inputsVec, j).Named("x");
VariableArray <double> y = Variable.Observed(outputs, j).Named("y");
// Set up the GP prior, which will be filled in later
Variable <SparseGP> prior = Variable.New <SparseGP>().Named("prior");
Variable <SparseGP> prior2 = Variable.New <SparseGP>().Named("prior2");
// The sparse GP variable - a distribution over functions
Variable <IFunction> f = Variable <IFunction> .Random(prior).Named("f");
Variable <IFunction> r = Variable <IFunction> .Random(prior2).Named("r");
Variable <double> mean = Variable.FunctionEvaluate(f, x[j]).Named("mean");
Variable <double> logVariance = Variable.FunctionEvaluate(r, x[j]).Named("logVariance");
Variable <double> variance = Variable.Exp(logVariance);
y[j] = Variable.GaussianFromMeanAndVariance(mean, variance);
InferenceEngine engine = new InferenceEngine();
GaussianProcess gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
GaussianProcess gp2 = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
// Fill in the sparse GP prior
//Vector[] basis = Util.ArrayInit(120, i => Vector.FromArray(0.5*i));
Vector[] basis = Util.ArrayInit(60, i => Vector.FromArray(1.0 * i));
prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, basis));
prior2.ObservedValue = new SparseGP(new SparseGPFixed(gp2, basis));
// Infer the posterior Sparse GP
SparseGP sgp = engine.Infer <SparseGP>(f);
// Check that training set is classified correctly
Console.WriteLine();
Console.WriteLine("Predictions on training set:");
for (int i = 0; i < outputs.Length; i++)
{
Gaussian post = sgp.Marginal(inputsVec[i]);
//double postMean = post.GetMean();
Console.WriteLine("f({0}) = {1}", inputs[i], post);
}
//TODO: change path for cross platform using
using (MatlabWriter writer = new MatlabWriter(@"..\..\HGPR.mat"))
{
int n = outputs.Length;
double[] m = new double[n];
double[] s = new double[n];
for (int i = 0; i < n; i++)
{
Gaussian post = sgp.Marginal(inputsVec[i]);
double mi, vi;
post.GetMeanAndVariance(out mi, out vi);
m[i] = mi;
s[i] = System.Math.Sqrt(vi);
}
writer.Write("mean", m);
writer.Write("std", s);
}
}
public void Initialize(bool skipStringDistributions = false)
{
// DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing
// you are trying to deserialize.
this.pareto = new Pareto(1.2, 3.5);
this.poisson = new Poisson(2.3);
this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] {
{ 22, 21 }, { 21, 23 }
}));
this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] {
{ 16, 15 }, { 15, 17 }
}));
this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3));
this.pointMass = PointMass <double> .Create(1.1);
this.gaussian = new Gaussian(11.0, 12.0);
this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5);
this.gamma = new Gamma(9.0, 10.0);
this.gammaPower = new GammaPower(5.6, 2.8, 3.4);
this.discrete = new Discrete(6.0, 7.0, 8.0);
this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5);
this.dirichlet = new Dirichlet(3.0, 4.0, 5.0);
this.beta = new Beta(2.0, 1.0);
this.binomial = new Binomial(5, 0.8);
this.bernoulli = new Bernoulli(0.6);
this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1));
this.sparseBernoulliList[1] = new Bernoulli(0.9);
this.sparseBernoulliList[3] = new Bernoulli(0.7);
this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0));
this.sparseBetaList[0] = new Beta(3.0, 4.0);
this.sparseBetaList[1] = new Beta(5.0, 6.0);
this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2));
this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4);
this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6);
this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0));
this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5);
this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8);
this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4);
ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian });
vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian });
ga2D = Distribution <double> .Array(new[, ] {
{ this.gaussian, this.gaussian }, { this.gaussian, this.gaussian }
});
vga2D = Distribution <Vector> .Array(new[, ] {
{ this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian }
});
gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } });
vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } });
var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i));
this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis));
this.quantileEstimator = new QuantileEstimator(0.01);
this.quantileEstimator.Add(5);
this.outerQuantiles = OuterQuantiles.FromDistribution(3, this.quantileEstimator);
this.innerQuantiles = InnerQuantiles.FromDistribution(3, this.outerQuantiles);
if (!skipStringDistributions)
{
// String distributions can not be serialized by some formatters (namely BinaryFormatter)
// That is fine because this combination is never used in practice
this.stringDistribution1 = StringDistribution.String("aa")
.Append(StringDistribution.OneOf("b", "ccc")).Append("dddd");
this.stringDistribution2 = new StringDistribution();
this.stringDistribution2.SetToProduct(StringDistribution.OneOf("a", "b"),
StringDistribution.OneOf("b", "c"));
}
}
public ProbabilityOfImprovement(Goal goal, GaussianProcess gp, double[] xs) : base(gp, xs)
{
Goal = goal;
}
public void Run()
{
InferenceEngine engine = new InferenceEngine();
if (!(engine.Algorithm is Algorithms.ExpectationPropagation))
{
Console.WriteLine("This example only runs with Expectation Propagation");
return;
}
// The data
Vector[] inputs = new Vector[]
{
Vector.FromArray(new double[2] {
0, 0
}),
Vector.FromArray(new double[2] {
0, 1
}),
Vector.FromArray(new double[2] {
1, 0
}),
Vector.FromArray(new double[2] {
0, 0.5
}),
Vector.FromArray(new double[2] {
1.5, 0
}),
Vector.FromArray(new double[2] {
0.5, 1.0
})
};
bool[] outputs = { true, true, false, true, false, false };
// Open an evidence block to allow model scoring
Variable <bool> evidence = Variable.Bernoulli(0.5).Named("evidence");
IfBlock block = Variable.If(evidence);
// Set up the GP prior, a distribution over functions, which will be filled in later
Variable <SparseGP> prior = Variable.New <SparseGP>().Named("prior");
// The sparse GP variable - a random function
Variable <IFunction> f = Variable <IFunction> .Random(prior).Named("f");
// The locations to evaluate the function
VariableArray <Vector> x = Variable.Observed(inputs).Named("x");
Range j = x.Range.Named("j");
// The observation model
VariableArray <bool> y = Variable.Observed(outputs, j).Named("y");
Variable <double> score = Variable.FunctionEvaluate(f, x[j]).Named("score");
y[j] = (Variable.GaussianFromMeanAndVariance(score, 0.1) > 0);
// Close the evidence block
block.CloseBlock();
// The basis
Vector[] basis = new Vector[]
{
Vector.FromArray(new double[2] {
0.2, 0.2
}),
Vector.FromArray(new double[2] {
0.2, 0.8
}),
Vector.FromArray(new double[2] {
0.8, 0.2
}),
Vector.FromArray(new double[2] {
0.8, 0.8
})
};
for (int trial = 0; trial < 3; trial++)
{
// The kernel
IKernelFunction kf;
if (trial == 0)
{
kf = new SquaredExponential(-0.0);
}
else if (trial == 1)
{
kf = new SquaredExponential(-0.5);
}
else
{
kf = new NNKernel(new double[] { 0.0, 0.0 }, -1.0);
}
// Fill in the sparse GP prior
GaussianProcess gp = new GaussianProcess(new ConstantFunction(0), kf);
prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, basis));
// Model score
double NNscore = engine.Infer <Bernoulli>(evidence).LogOdds;
Console.WriteLine("{0} evidence = {1}", kf, NNscore.ToString("g4"));
}
// Infer the posterior Sparse GP
SparseGP sgp = engine.Infer <SparseGP>(f);
// Check that training set is classified correctly
Console.WriteLine("");
Console.WriteLine("Predictions on training set:");
for (int i = 0; i < outputs.Length; i++)
{
Gaussian post = sgp.Marginal(inputs[i]);
double postMean = post.GetMean();
string comment = (outputs[i] == (postMean > 0.0)) ? "correct" : "incorrect";
Console.WriteLine("f({0}) = {1} ({2})", inputs[i], post, comment);
}
}
public void Initialize()
{
// DO NOT make this a constructor, because it makes the test not notice complete lack of serialization as an empty object is set up exactly as the thing
// you are trying to deserialize.
this.pareto = new Pareto(1.2, 3.5);
this.poisson = new Poisson(2.3);
this.wishart = new Wishart(20, new PositiveDefiniteMatrix(new double[, ] {
{ 22, 21 }, { 21, 23 }
}));
this.vectorGaussian = new VectorGaussian(Vector.FromArray(13, 14), new PositiveDefiniteMatrix(new double[, ] {
{ 16, 15 }, { 15, 17 }
}));
this.unnormalizedDiscrete = UnnormalizedDiscrete.FromLogProbs(DenseVector.FromArray(5.1, 5.2, 5.3));
this.pointMass = PointMass <double> .Create(1.1);
this.gaussian = new Gaussian(11.0, 12.0);
this.nonconjugateGaussian = new NonconjugateGaussian(1.2, 2.3, 3.4, 4.5);
this.gamma = new Gamma(9.0, 10.0);
this.gammaPower = new GammaPower(5.6, 2.8, 3.4);
this.discrete = new Discrete(6.0, 7.0, 8.0);
this.conjugateDirichlet = new ConjugateDirichlet(1.2, 2.3, 3.4, 4.5);
this.dirichlet = new Dirichlet(3.0, 4.0, 5.0);
this.beta = new Beta(2.0, 1.0);
this.binomial = new Binomial(5, 0.8);
this.bernoulli = new Bernoulli(0.6);
this.sparseBernoulliList = SparseBernoulliList.Constant(4, new Bernoulli(0.1));
this.sparseBernoulliList[1] = new Bernoulli(0.9);
this.sparseBernoulliList[3] = new Bernoulli(0.7);
this.sparseBetaList = SparseBetaList.Constant(5, new Beta(2.0, 2.0));
this.sparseBetaList[0] = new Beta(3.0, 4.0);
this.sparseBetaList[1] = new Beta(5.0, 6.0);
this.sparseGaussianList = SparseGaussianList.Constant(6, Gaussian.FromMeanAndPrecision(0.1, 0.2));
this.sparseGaussianList[4] = Gaussian.FromMeanAndPrecision(0.3, 0.4);
this.sparseGaussianList[5] = Gaussian.FromMeanAndPrecision(0.5, 0.6);
this.sparseGammaList = SparseGammaList.Constant(1, Gamma.FromShapeAndRate(1.0, 2.0));
this.truncatedGamma = new TruncatedGamma(1.2, 2.3, 3.4, 4.5);
this.truncatedGaussian = new TruncatedGaussian(1.2, 3.4, 5.6, 7.8);
this.wrappedGaussian = new WrappedGaussian(1.2, 2.3, 3.4);
ga = Distribution <double> .Array(new[] { this.gaussian, this.gaussian });
vga = Distribution <Vector> .Array(new[] { this.vectorGaussian, this.vectorGaussian });
ga2D = Distribution <double> .Array(new[, ] {
{ this.gaussian, this.gaussian }, { this.gaussian, this.gaussian }
});
vga2D = Distribution <Vector> .Array(new[, ] {
{ this.vectorGaussian, this.vectorGaussian }, { this.vectorGaussian, this.vectorGaussian }
});
gaJ = Distribution <double> .Array(new[] { new[] { this.gaussian, this.gaussian }, new[] { this.gaussian, this.gaussian } });
vgaJ = Distribution <Vector> .Array(new[] { new[] { this.vectorGaussian, this.vectorGaussian }, new[] { this.vectorGaussian, this.vectorGaussian } });
var gp = new GaussianProcess(new ConstantFunction(0), new SquaredExponential(0));
var basis = Util.ArrayInit(2, i => Vector.FromArray(1.0 * i));
this.sparseGp = new SparseGP(new SparseGPFixed(gp, basis));
this.quantileEstimator = new QuantileEstimator(0.01);
this.quantileEstimator.Add(5);
}
public Explorer(GaussianProcess gp, double[] Xs) : base(gp, Xs)
{
}
public void Run()
{
InferenceEngine engine = new InferenceEngine();
if (!(engine.Algorithm is ExpectationPropagation))
{
Console.WriteLine("This example only runs with Expectation Propagation");
return;
}
// The data
Vector[] inputs = new Vector[] {
Vector.FromArray(new double[2] {0, 0}),
Vector.FromArray(new double[2] {0, 1}),
Vector.FromArray(new double[2] {1, 0}),
Vector.FromArray(new double[2] {0, 0.5}),
Vector.FromArray(new double[2] {1.5, 0}),
Vector.FromArray(new double[2] {0.5, 1.0})
};
bool[] outputs = { true, true, false, true, false, false };
// Open an evidence block to allow model scoring
Variable<bool> evidence = Variable.Bernoulli(0.5).Named("evidence");
IfBlock block = Variable.If(evidence);
// Set up the GP prior, which will be filled in later
Variable<SparseGP> prior = Variable.New<SparseGP>().Named("prior");
// The sparse GP variable - a distribution over functions
Variable<IFunction> f = Variable<IFunction>.Random(prior).Named("f");
// The locations to evaluate the function
VariableArray<Vector> x = Variable.Observed(inputs).Named("x");
Range j = x.Range.Named("j");
// The observation model
VariableArray<bool> y = Variable.Observed(outputs, j).Named("y");
Variable<double> score = Variable.FunctionEvaluate(f, x[j]);
y[j] = (Variable.GaussianFromMeanAndVariance(score, 0.1) > 0);
// Close the evidence block
block.CloseBlock();
// The basis
Vector[] basis = new Vector[] {
Vector.FromArray(new double[2] {0.2, 0.2}),
Vector.FromArray(new double[2] {0.2, 0.8}),
Vector.FromArray(new double[2] {0.8, 0.2}),
Vector.FromArray(new double[2] {0.8, 0.8})
};
for (int trial = 0; trial < 3; trial++)
{
// The kernel
IKernelFunction kf;
if (trial == 0)
{
kf = new SquaredExponential(-0.0);
}
else if (trial == 1)
{
kf = new SquaredExponential(-0.5);
}
else
{
kf = new NNKernel(new double[] { 0.0, 0.0 }, -1.0);
}
// Fill in the sparse GP prior
GaussianProcess gp = new GaussianProcess(new ConstantFunction(0), kf);
prior.ObservedValue = new SparseGP(new SparseGPFixed(gp, basis));
// Model score
double NNscore = engine.Infer<Bernoulli>(evidence).LogOdds;
Console.WriteLine("{0} evidence = {1}", kf, NNscore.ToString("g4"));
}
// Infer the posterior Sparse GP
SparseGP sgp = engine.Infer<SparseGP>(f);
// Check that training set is classified correctly
Console.WriteLine("");
Console.WriteLine("Predictions on training set:");
for (int i = 0; i < outputs.Length; i++)
{
Gaussian post = sgp.Marginal(inputs[i]);
double postMean = post.GetMean();
string comment = (outputs[i] == (postMean > 0.0)) ? "correct" : "incorrect";
Console.WriteLine("f({0}) = {1} ({2})", inputs[i], post, comment);
}
}
public AquisitionFunction(GaussianProcess gp, double[] xs)
{
Gp = gp;
Xs = xs;
}
public ExpectedfImprovement(Goal goal, GaussianProcess gp, double[] xs) : base(gp, xs)
{
Goal = goal;
}
