/// <summary>
/// Cholesky of Kernel matrix
/// </summary>
/// <param name="kf">Kernel function</param>
/// <param name="xData">Data with which to build the matrix</param>
/// <returns></returns>
public static LowerTriangularMatrix Cholesky(IKernelFunction kf, Dictionary <int, Vector> xData)
{
if (null == kf || null == xData)
{
throw new ArgumentException("Unexpected null arguments");
}
int nData = xData.Count;
// Allocate and fill the Kernel matrix.
PositiveDefiniteMatrix K = new PositiveDefiniteMatrix(nData, nData);
for (int i = 0; i < nData; i++)
{
for (int j = 0; j < nData; j++)
{
// Evaluate the kernel. All hyperparameters, including noise
// variance are handled in the kernel.
K[i, j] = kf.EvaluateX1X2(xData[i], xData[j]);
}
}
LowerTriangularMatrix chol = new LowerTriangularMatrix(nData, nData);
chol.SetToCholesky(K);
K = null;
GC.Collect(0);
return(chol);
}
public static IKernelFunction GetKernelFunction(int index, Parameters param)
{
IKernelFunction kf = (IKernelFunction)allKernelFunctions[index].Clone();
kf.Parameters = param;
return(kf);
}
public static double KFunction(BaseVector x, BaseVector y, SvmParameter param)
{
IKernelFunction kf = param.kernelFunction;
double sx = double.NaN;
double sy = double.NaN;
if (kf.UsesSquares)
{
sx = x.Dot(x);
sy = y.Dot(y);
}
return(kf.Evaluate(x, y, sx, sy));
}
internal SvmKernel(int l, BaseVector[] x1, SvmParameter param)
{
kernelFunction = param.kernelFunction;
x = (BaseVector[]) x1.Clone();
if (kernelFunction.UsesSquares){
xSquare = new double[l];
for (int i = 0; i < l; i++){
xSquare[i] = x[i].Dot(x[i]);
}
} else{
xSquare = null;
}
}
internal SvmKernel(int l, BaseVector[] x1, SvmParameter param)
{
kernelFunction = param.kernelFunction;
x = (BaseVector[])x1.Clone();
if (kernelFunction.UsesSquares)
{
xSquare = new double[l];
for (int i = 0; i < l; i++)
{
xSquare[i] = x[i].Dot(x[i]);
}
}
else
{
xSquare = null;
}
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.Read();
reader.ReadStartElement("Mean");
string meanTypeName = reader.Name;
var meanSerializer = new XmlSerializer(Type.GetType(meanTypeName));
mean = (IFunction)meanSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("Kernel");
string kernelTypeName = reader.Name;
var kernelSerializer = new XmlSerializer(Type.GetType(kernelTypeName));
kernel = (IKernelFunction)kernelSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
}
public static PositiveDefiniteMatrix GramMatrix(IKernelFunction kf, Vector[] xData)
{
int nData = xData.Length;
// Allocate and fill the Kernel matrix.
PositiveDefiniteMatrix K = new PositiveDefiniteMatrix(nData, nData);
for (int i = 0; i < nData; i++)
{
for (int j = 0; j < nData; j++)
{
// Evaluate the kernel. All hyperparameters, including noise
// variance are handled in the kernel.
K[i, j] = kf.EvaluateX1X2(xData[i], xData[j]);
}
}
return(K);
}
public static Vector[] KxD(IKernelFunction kf, Vector[] xData, Vector[] dData)
{
int nData = xData.Length;
var result = new Vector[nData];
for (int i = 0; i < nData; i++)
{
result[i] = Vector.Zero(dData.Length);
for (int j = 0; j < dData.Length; j++)
{
// Evaluate the kernel. All hyperparameters, including noise
// variance are handled in the kernel.
result[i][j] = kf.EvaluateX1X2(xData[i], dData[j]);
}
}
return(result);
}
public void TestKernelFactory()
{
KernelFactory kfact = KernelFactory.Instance;
IKernelFunction kf1 = kfact.CreateKernelFunction("WhiteNoise");
IKernelFunction kf2 = kfact.CreateKernelFunction("SquaredExponential");
IKernelFunction kf3 = kfact.CreateKernelFunction("ARD");
IKernelFunction kf4 = kfact.CreateKernelFunction("LinearKernel");
IKernelFunction kf5 = kfact.CreateKernelFunction("SummationKernel");
IKernelFunction kf6 = kfact.CreateKernelFunction("NNKernel");
Assert.NotNull(kf1);
Assert.NotNull(kf2);
Assert.NotNull(kf3);
Assert.NotNull(kf4);
Assert.NotNull(kf5);
Assert.NotNull(kf6);
Assert.IsType <WhiteNoise>(kf1);
Assert.IsType <SquaredExponential>(kf2);
Assert.IsType <ARD>(kf3);
Assert.IsType <LinearKernel>(kf4);
Assert.IsType <SummationKernel>(kf5);
Assert.IsType <NNKernel>(kf6);
}
/*! \pre the \f$ x \f$ values must be sorted.
* \pre kernel needs a Real operator()(Real x) implementation
*
*/
public KernelInterpolation2D(List <double> xBegin, int size, List <double> yBegin, int ySize,
Matrix zData, IKernelFunction kernel)
{
impl_ = new KernelInterpolation2DImpl <IKernelFunction>(xBegin, size, yBegin, ySize, zData, kernel);
this.update();
}
/// <summary>
/// Constructor from kernel function and basis
/// </summary>
public SparseGPFixed(IKernelFunction kf, IList<Vector> basis)
: this(new GaussianProcess(new ConstantFunction(), kf), basis)
{
}
/// <summary>
/// Constructor from kernel function and basis
/// </summary>
public SparseGPFixed(IKernelFunction kf, IList <Vector> basis)
: this(new GaussianProcess(new ConstantFunction(), kf), basis)
{
}
public GaussianProcess(IFunction mean, IKernelFunction kernel)
{
this.mean = mean;
this.kernel = kernel;
}
/// <summary>
/// Cholesky of Kernel matrix
/// </summary>
/// <param name="kf">Kernel function</param>
/// <param name="xData">Data with which to build the matrix</param>
/// <returns></returns>
public static LowerTriangularMatrix Cholesky(IKernelFunction kf, Dictionary<int, Vector> xData)
{
if (null == kf || null == xData)
throw new ArgumentException("Unexpected null arguments");
int nData = xData.Count;
// Allocate and fill the Kernel matrix.
PositiveDefiniteMatrix K = new PositiveDefiniteMatrix(nData, nData);
for (int i = 0; i < nData; i++) {
for (int j = 0; j < nData; j++) {
// Evaluate the kernel. All hyperparameters, including noise
// variance are handled in the kernel.
K[i, j] = kf.EvaluateX1X2(xData[i], xData[j]);
}
}
LowerTriangularMatrix chol = new LowerTriangularMatrix(nData, nData);
chol.SetToCholesky(K);
K = null;
#if !SILVERLIGHT
GC.Collect(0);
#endif
return chol;
}
/*! \pre the \f$ x \f$ values must be sorted.
* \pre kernel needs a Real operator()(Real x) implementation
*/
public KernelInterpolation(List <double> xBegin, int size, List <double> yBegin, IKernelFunction kernel)
{
impl_ = new KernelInterpolationImpl <IKernelFunction>(xBegin, size, yBegin, kernel);
impl_.update();
}
