package jsat.datatransform.kernel;

import java.util.Random;
import jsat.DataSet;
import jsat.classifiers.DataPoint;
import jsat.datatransform.DataTransformBase;
import jsat.distributions.Distribution;
import jsat.distributions.kernels.RBFKernel;
import jsat.linear.DenseVector;
import jsat.linear.Matrix;
import jsat.linear.RandomMatrix;
import jsat.linear.RandomVector;
import jsat.linear.Vec;
import jsat.utils.random.RandomUtil;
import jsat.utils.random.XORWOW;

/**
 * An Implementation of Random Fourier Features for the {@link RBFKernel}. It 
 * transforms the numerical variables of a feature space to form a new feature 
 * space where the dot product between features approximates the RBF Kernel 
 * product. 
 * 

* See: Rahimi, A.,&Recht, B. (2007). Random Features for Large-Scale * Kernel Machines. Neural Information Processing Systems. Retrieved from * * here * @author Edward Raff */ public class RFF_RBF extends DataTransformBase { private static final long serialVersionUID = -3478216020648280477L; private Matrix transform; private Vec offsets; private double sigma; private int dim; private boolean inMemory; /** * Creates a new RFF RBF object that will use an transformed feature space * with a dimensionality of 512. This constructor should be used with a * parameter search to find a good value for {@link #setSigma(double) sigma} */ public RFF_RBF() { this(1.0); } /** * Creates a new RFF RBF object that will use an transformed feature space * with a dimensionality of 512. * * @param sigma the positive sigma value for the {@link RBFKernel} */ public RFF_RBF(double sigma) { this(sigma, 512); } /** * Creates a new RFF RBF object * * @param sigma the positive sigma value for the {@link RBFKernel} * @param dim the new feature size dimension to project into. */ public RFF_RBF(double sigma, int dim) { this(sigma, dim, true); } /** * Creates a new RFF RBF object * * @param sigma the positive sigma value for the {@link RBFKernel} * @param dim the new feature size dimension to project into. * @param inMemory {@code true} if the internal matrix should be stored in * memory. If {@code false}, the memory will be re-computed as needed, * increasing computation cost but uses no extra memory. */ public RFF_RBF(double sigma, int dim, boolean inMemory) { setSigma(sigma); setDimensions(dim); setInMemory(inMemory); } /** * Creates a new RFF RBF object * @param featurSize the number of numeric features in the original feature * space * @param sigma the positive sigma value for the {@link RBFKernel} * @param dim the new feature size dimension to project into. * @param rand the source of randomness to initialize internal state * @param inMemory {@code true} if the internal matrix should be stored in * memory. If {@code false}, the memory will be re-computed as needed, * increasing computation cost but uses no extra memory. */ public RFF_RBF(int featurSize, double sigma, int dim, Random rand, boolean inMemory) { this(sigma, dim, inMemory); if(featurSize <= 0) throw new IllegalArgumentException("The number of numeric features must be positive, not " + featurSize); if(sigma <= 0 || Double.isInfinite(sigma) || Double.isNaN(sigma)) throw new IllegalArgumentException("The sigma parameter must be positive, not " + sigma); if(dim <= 1) throw new IllegalArgumentException("The target dimension must be positive, not " + dim); transform = new RandomMatrixRFF_RBF(Math.sqrt(0.5/(sigma*sigma)), featurSize, dim, rand.nextLong()); offsets = new RandomVectorRFF_RBF(dim, rand.nextLong()); if(inMemory) { transform = transform.add(0.0);//will copy into a new mutable and add nothing offsets = new DenseVector(offsets); } } @Override public void fit(DataSet data) { int featurSize = data.getNumNumericalVars(); Random rand = RandomUtil.getRandom(); transform = new RandomMatrixRFF_RBF(Math.sqrt(0.5/(sigma*sigma)), featurSize, dim, rand.nextLong()); offsets = new RandomVectorRFF_RBF(dim, rand.nextLong()); if(inMemory) { transform = transform.add(0.0);//will copy into a new mutable and add nothing offsets = new DenseVector(offsets); } } /** * Copy constructor * @param toCopy the object to copy */ protected RFF_RBF(RFF_RBF toCopy) { if(toCopy.transform != null) this.transform = toCopy.transform.clone(); if(toCopy.offsets != null) this.offsets = toCopy.offsets.clone(); this.dim = toCopy.dim; this.inMemory = toCopy.inMemory; this.sigma = toCopy.sigma; } @Override public DataPoint transform(DataPoint dp) { Vec oldX = dp.getNumericalValues(); Vec newX = oldX.multiply(transform); final double coef = Math.sqrt(2.0/transform.cols()); for(int i = 0; i < newX.length(); i++) newX.set(i, Math.cos(newX.get(i)+offsets.get(i))*coef); return new DataPoint(newX, dp.getCategoricalValues(), dp.getCategoricalData(), dp.getWeight()); } @Override public RFF_RBF clone() { return new RFF_RBF(this); } private static class RandomMatrixRFF_RBF extends RandomMatrix { private static final long serialVersionUID = 4702514384718636893L; private double coef; public RandomMatrixRFF_RBF(double coef, int rows, int cols, long seedMult) { super(rows, cols, seedMult); this.coef = coef; } @Override protected double getVal(Random rand) { return coef*rand.nextGaussian(); } } private static class RandomVectorRFF_RBF extends RandomVector { private static final long serialVersionUID = -6132378281909907937L; public RandomVectorRFF_RBF(int length, long seedMult) { super(length, seedMult); } @Override protected double getVal(Random rand) { return rand.nextDouble()*2*Math.PI; } @Override public Vec clone() { return this; } } /** * Sets whether or not the transform matrix is stored explicitly in memory * or not. Explicit storage is often faster, but can be prohibitive for * large feature sizes * @param inMemory {@code true} to explicitly store the transform matrix, * {@code false} to re-create it on the fly as needed */ public void setInMemory(boolean inMemory) { this.inMemory = inMemory; } /** * * @return {@code true} if this object will explicitly store the transform * matrix, {@code false} to re-create it on the fly as needed */ public boolean isInMemory() { return inMemory; } /** * Sets the number of dimensions in the new approximate space to use. This * will be the number of numeric features in the transformed data, and * larger values increase the accuracy of the approximation. * * @param dimensions */ public void setDimensions(int dimensions) { if (dimensions < 1) throw new ArithmeticException("Number of dimensions must be a positive value, not " + dimensions); this.dim = dimensions; } /** * Returns the number of dimensions that will be used in the projected space * * @return the number of dimensions that will be used in the projected space */ public int getDimensions() { return dim; } /** * Sets the σ parameter of the RBF kernel that is being approximated. * * @param sigma the positive value to use for σ * @see RBFKernel#setSigma(double) */ public void setSigma(double sigma) { if (sigma <= 0.0 || Double.isInfinite(sigma) || Double.isNaN(sigma)) throw new IllegalArgumentException("Sigma must be a positive value, not " + sigma); this.sigma = sigma; } /** * Returns the σ value used for the RBF kernel approximation. * * @return the σ value used for the RBF kernel approximation. */ public double getSigma() { return sigma; } /** * Guess the distribution to use for the kernel width term * {@link #setSigma(double) σ} in the RBF kernel being approximated. * * @param d the data set to get the guess for * @return the guess for the σ parameter in the RBF Kernel */ public Distribution guessSigma(DataSet d) { return RBFKernel.guessSigma(d); } }

Ads help maintain this website.