package jsat.regression;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import jsat.DataSet;
import jsat.classifiers.DataPoint;
import jsat.distributions.Distribution;
import jsat.distributions.LogUniform;
import jsat.distributions.kernels.KernelTrick;
import jsat.distributions.kernels.RBFKernel;
import jsat.linear.CholeskyDecomposition;
import jsat.linear.DenseMatrix;
import jsat.linear.Matrix;
import jsat.linear.Vec;
import jsat.parameters.Parameter.ParameterHolder;
import jsat.parameters.Parameterized;
import jsat.utils.concurrent.ParallelUtils;
/**
* A kernelized implementation of Ridge Regression. Ridge
* Regression is equivalent to {@link MultipleLinearRegression} with an added
* L2 penalty for the weight vector.
* This algorithm is very expensive to compute O(n3), where n is the
* number of training points.
*
* @author Edward Raff
*/
public class KernelRidgeRegression implements Regressor, Parameterized
{
private static final long serialVersionUID = 6275333785663250072L;
private double lambda;
@ParameterHolder
private KernelTrick k;
private List vecs;
private double[] alphas;
/**
* Creates a new Kernel Ridge Regression learner that uses an RBF kernel
*/
public KernelRidgeRegression()
{
this(1e-6, new RBFKernel());
}
/**
* Creates a new Kernel Ridge Regression learner
* @param lambda the regularization parameter
* @param kernel the kernel to use
* @see #setLambda(double)
*/
public KernelRidgeRegression(double lambda, KernelTrick kernel)
{
setLambda(lambda);
setKernel(kernel);
}
/**
* Copy Constructor
* @param toCopy the object to copy
*/
protected KernelRidgeRegression(KernelRidgeRegression toCopy)
{
this(toCopy.lambda, toCopy.getKernel().clone());
if(toCopy.alphas != null)
this.alphas = Arrays.copyOf(toCopy.alphas, toCopy.alphas.length);
if(toCopy.vecs != null)
this.vecs = new ArrayList<>(toCopy.vecs);
}
/**
* Guesses the distribution to use for the λ parameter
*
* @param d the dataset to get the guess for
* @return the guess for the λ parameter
*/
public static Distribution guessLambda(DataSet d)
{
return new LogUniform(1e-7, 1e-2);
}
/**
* Sets the regularization parameter used. The value of lambda depends on
* the data set and kernel used, with easier problems using smaller lambdas.
* @param lambda the positive regularization constant in (0, Inf)
*/
public void setLambda(double lambda)
{
if(Double.isNaN(lambda) || Double.isInfinite(lambda) || lambda <= 0)
throw new IllegalArgumentException("lambda must be a positive constant, not " + lambda);
this.lambda = lambda;
}
/**
* Returns the regularization constant in use
* @return the regularization constant in use
*/
public double getLambda()
{
return lambda;
}
/**
* Sets the kernel trick to use
* @param k the kernel to use
*/
public void setKernel(KernelTrick k)
{
this.k = k;
}
/**
* Returns the kernel in use
* @return the kernel in use
*/
public KernelTrick getKernel()
{
return k;
}
@Override
public double regress(DataPoint data)
{
Vec x = data.getNumericalValues();
double score = 0;
for(int i = 0; i < alphas.length; i++)
score += alphas[i] * k.eval(vecs.get(i), x);
return score;
}
@Override
public void train(RegressionDataSet dataSet, boolean parallel)
{
final int N = dataSet.getSampleSize();
vecs = new ArrayList<>(N);
//alphas initalized later
Vec Y = dataSet.getTargetValues();
for(int i = 0; i < N; i++)
vecs.add(dataSet.getDataPoint(i).getNumericalValues());
final Matrix K = new DenseMatrix(N, N);
ParallelUtils.run(parallel, N, (i)->
{
K.set(i, i, k.eval(vecs.get(i), vecs.get(i)) + lambda);//diagonal values
for (int j = i + 1; j < N; j++)
{
double K_ij = k.eval(vecs.get(i), vecs.get(j));
K.set(i, j, K_ij);
K.set(j, i, K_ij);
}
});
CholeskyDecomposition cd;
if(parallel)
cd = new CholeskyDecomposition(K, ParallelUtils.CACHED_THREAD_POOL);
else
cd = new CholeskyDecomposition(K);
Vec alphaTmp = cd.solve(Y);
alphas = alphaTmp.arrayCopy();
}
@Override
public boolean supportsWeightedData()
{
return false;
}
@Override
public KernelRidgeRegression clone()
{
return new KernelRidgeRegression(this);
}
}
Ads help maintain this website.