package jsat.distributions.kernels;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jsat.DataSet;
import jsat.classifiers.ClassificationDataSet;
import jsat.distributions.Distribution;
import jsat.distributions.LogUniform;
import jsat.linear.Vec;
import jsat.linear.distancemetrics.DistanceMetric;
import jsat.linear.distancemetrics.EuclideanDistance;
import jsat.utils.DoubleList;
import jsat.utils.IntList;
import jsat.utils.ListUtils;
/**
* This class provides a generalization of the {@link RBFKernel} to arbitrary
* {@link DistanceMetric distance metrics}, and is of the form
* exp(-d(x, y)2/(2 {@link #setSigma(double) σ}2
* )). So long as the distance metric is valid, the resulting kernel trick
* will be a valid kernel.
*
* If the {@link EuclideanDistance} is used, then this becomes equivalent to the
* {@link RBFKernel}.
*
* Note, that since the {@link KernelTrick} has no concept of training - the
* distance metric can not require training either. A pre-trained metric can
* be admissible thought.
*
* @author Edward Raff
*/
public class GeneralRBFKernel extends DistanceMetricBasedKernel
{
private static final long serialVersionUID = 1368225926995372017L;
private double sigma;
private double sigmaSqrd2Inv;
/**
* Creates a new Generic RBF Kernel
* @param d the distance metric to use
* @param sigma the standard deviation to use
*/
public GeneralRBFKernel(DistanceMetric d, double sigma)
{
super(d);
setSigma(sigma);
}
/**
* Sets the kernel width parameter, which must be a positive value. Larger
* values indicate a larger width
*
* @param sigma the sigma value
*/
public void setSigma(double sigma)
{
if(sigma <= 0 || Double.isNaN(sigma) || Double.isInfinite(sigma))
throw new IllegalArgumentException("Sigma must be a positive constant, not " + sigma);
this.sigma = sigma;
this.sigmaSqrd2Inv = 0.5/(sigma*sigma);
}
/**
*
* @return the width parameter to use for the kernel
*/
public double getSigma()
{
return sigma;
}
@Override
public KernelTrick clone()
{
return new GeneralRBFKernel(d.clone(), sigma);
}
@Override
public double eval(Vec a, Vec b)
{
double dist = d.dist(a, b);
return Math.exp(-dist*dist * sigmaSqrd2Inv);
}
@Override
public double eval(int a, Vec b, List qi, List extends Vec> vecs, List cache)
{
double dist = d.dist(a, b, qi, vecs, cache);
return Math.exp(-dist*dist * sigmaSqrd2Inv);
}
@Override
public double eval(int a, int b, List extends Vec> vecs, List cache)
{
double dist = d.dist(a, b, vecs, cache);
return Math.exp(-dist*dist * sigmaSqrd2Inv);
}
/**
* Guess the distribution to use for the kernel width term
* {@link #setSigma(double) σ} in the General RBF kernel.
*
* @param d the data set to get the guess for
* @return the guess for the σ parameter in the General RBF Kernel
*/
public Distribution guessSigma(DataSet d)
{
return guessSigma(d, this.d);
}
/**
* Guess the distribution to use for the kernel width term
* {@link #setSigma(double) σ} in the General RBF kernel.
*
* @param d the data set to get the guess for
* @param dist the distance metric to assume is being used in the kernel
* @return the guess for the σ parameter in the General RBF Kernel
*/
public static Distribution guessSigma(DataSet d, DistanceMetric dist)
{
//we will use a simple strategy of estimating the mean sigma to test based on the pair wise distances of random points
//to avoid n^2 work for this, we will use a sqrt(n) sized sample as n increases so that we only do O(n) work
List allVecs = d.getDataVectors();
int toSample = d.getSampleSize();
if (toSample > 5000)
toSample = 5000 + (int) Math.floor(Math.sqrt(d.getSampleSize() - 5000));
DoubleList vals = new DoubleList(toSample*toSample);
if (d instanceof ClassificationDataSet && ((ClassificationDataSet) d).getPredicting().getNumOfCategories() == 2)
{
ClassificationDataSet cdata = (ClassificationDataSet) d;
List class0 = new ArrayList(toSample / 2);
List class1 = new ArrayList(toSample / 2);
IntList randOrder = new IntList(d.getSampleSize());
ListUtils.addRange(randOrder, 0, d.getSampleSize(), 1);
Collections.shuffle(randOrder);
//collet a random sample of data
for (int i = 0; i < randOrder.size(); i++)
{
int indx = randOrder.getI(i);
if (cdata.getDataPointCategory(indx) == 0 && class0.size() < toSample / 2)
class0.add(cdata.getDataPoint(indx).getNumericalValues());
else if (cdata.getDataPointCategory(indx) == 1 && class0.size() < toSample / 2)
class1.add(cdata.getDataPoint(indx).getNumericalValues());
}
int j_start = class0.size();
class0.addAll(class1);
List cache = dist.getAccelerationCache(class0);
for (int i = 0; i < j_start; i++)
for (int j = j_start; j < class0.size(); j++)
vals.add(dist.dist(i, j, allVecs, cache));
}
else
{
Collections.shuffle(allVecs);
if (d.getSampleSize() > 5000)
allVecs = allVecs.subList(0, toSample);
List cache = dist.getAccelerationCache(allVecs);
for (int i = 0; i < allVecs.size(); i++)
for (int j = i + 1; j < allVecs.size(); j++)
vals.add(dist.dist(i, j, allVecs, cache));
}
Collections.sort(vals);
double median = vals.get(vals.size()/2);
return new LogUniform(Math.exp(Math.log(median)-4), Math.exp(Math.log(median)+4));
}
@Override
public boolean normalized()
{
return true;
}
}
Ads help maintain this website.