package jsat.datatransform;

import java.util.Comparator;
import jsat.DataSet;
import jsat.classifiers.DataPoint;
import jsat.distributions.Distribution;
import jsat.distributions.discrete.UniformDiscrete;
import jsat.linear.*;
import static jsat.linear.MatrixStatistics.*;

/**
 * An extension of {@link PCA} that attempts to capture the variance, and make 
 * the variables in the output space independent from each-other. An of equal 
 * scale, so that the covariance is equal to {@link Matrix#eye(int) I}. The 
 * results may be further from the identity matrix than desired as the target 
 * dimension shrinks
*
* The Whitened PCA is more computational expensive than the normal PCA * algorithm, but transforming the data takes the same time. * * @author Edward Raff */ public class WhitenedPCA extends DataTransformBase { private static final long serialVersionUID = 6134243673037330608L; /** * Regularization parameter */ protected double regularization; /** * The number of dimensions to project down to */ protected int dimensions; /** * The final transformation matrix, that will create new points * y = transform * x */ protected Matrix transform; /** * Creates a new WhitenedPCA transform that uses up to 50 dimensions for the * transformed space. This may not be optimal for any given dataset. * * @param dims the number of dimensions to project down to */ public WhitenedPCA() { this(50); } /** * Creates a new WhitenedPCA transform * * @param dims the number of dimensions to project down to */ public WhitenedPCA(int dims) { this(1e-4, dims); } /** * Creates a new WhitenedPCA transform * * @param regularization the amount of regularization to add, avoids * numerical instability * @param dims the number of dimensions to project down to */ public WhitenedPCA(double regularization, int dims) { setRegularization(regularization); setDimensions(dims); } /** * Creates a new WhitenedPCA from the given dataset * @param dataSet the data set to whiten * @param regularization the amount of regularization to add, avoids numerical instability * @param dims the number of dimensions to project down to */ public WhitenedPCA(DataSet dataSet, double regularization, int dims) { this(regularization, dims); fit(dataSet); } @Override public void fit(DataSet dataSet) { setUpTransform(getSVD(dataSet)); } /** * Creates a new WhitenedPCA, the dimensions will be chosen so that the * subset of dimensions is of full rank. * * @param dataSet the data set to whiten * @param regularization the amount of regularization to add, avoids numerical instability */ public WhitenedPCA(DataSet dataSet, double regularization) { setRegularization(regularization); SingularValueDecomposition svd = getSVD(dataSet); setDimensions(svd.getRank()); setUpTransform(svd); } /** * Creates a new WhitenedPCA. The dimensions will be chosen so that the * subset of dimensions is of full rank. The regularization parameter will be * chosen as the log of the condition of the covariance. * * @param dataSet the data set to whiten */ public WhitenedPCA(DataSet dataSet) { SingularValueDecomposition svd = getSVD(dataSet); setRegularization(svd); setDimensions(svd.getRank()); setUpTransform(svd); } /** * Creates a new WhitenedPCA. The regularization parameter will be * chosen as the log of the condition of the covariance. * * @param dataSet the data set to whiten * @param dims the number of dimensions to project down to */ public WhitenedPCA(DataSet dataSet, int dims) { SingularValueDecomposition svd = getSVD(dataSet); setRegularization(svd); setDimensions(dims); setUpTransform(svd); } /** * Copy constructor * @param other the transform to make a copy of */ private WhitenedPCA(WhitenedPCA other) { this.regularization = other.regularization; this.dimensions = other.dimensions; this.transform = other.transform.clone(); } /** * Gets a SVD for the covariance matrix of the data set * @param dataSet the data set in question * @return the SVD for the covariance */ private SingularValueDecomposition getSVD(DataSet dataSet) { Matrix cov = covarianceMatrix(meanVector(dataSet), dataSet); for(int i = 0; i < cov.rows(); i++)//force it to be symmetric for(int j = 0; j < i; j++) cov.set(j, i, cov.get(i, j)); EigenValueDecomposition evd = new EigenValueDecomposition(cov); //Sort form largest to smallest evd.sortByEigenValue(new Comparator() { @Override public int compare(Double o1, Double o2) { return -Double.compare(o1, o2); } }); return new SingularValueDecomposition(evd.getVRaw(), evd.getVRaw(), evd.getRealEigenvalues()); } /** * Creates the {@link #transform transform matrix} to be used when * converting data points. It is called in the constructor after all values * are set. * * @param svd the SVD of the covariance of the source data set */ protected void setUpTransform(SingularValueDecomposition svd) { Vec diag = new DenseVector(dimensions); double[] s = svd.getSingularValues(); for(int i = 0; i < dimensions; i++) diag.set(i, 1.0/Math.sqrt(s[i]+regularization)); transform = new SubMatrix(svd.getU().transpose(), 0, 0, dimensions, s.length).clone(); Matrix.diagMult(diag, transform); } @Override public DataPoint transform(DataPoint dp) { Vec newVec = transform.multiply(dp.getNumericalValues()); DataPoint newDp = new DataPoint(newVec, dp.getCategoricalValues(), dp.getCategoricalData(), dp.getWeight()); return newDp; } /** * * @param regularization the regularization to apply to the diagonal of the * decomposition. This can improve numeric stability and reduces noise. */ public void setRegularization(double regularization) { if(regularization < 0 || Double.isNaN(regularization) || Double.isInfinite(regularization)) throw new ArithmeticException("Regularization must be non negative value, not " + regularization); this.regularization = regularization; } /** * * @return the amount of regularization to apply */ public double getRegularization() { return regularization; } @Override public DataTransform clone() { return new WhitenedPCA(this); } private void setRegularization(SingularValueDecomposition svd) { if(svd.isFullRank()) setRegularization(1e-10); else setRegularization(Math.max(Math.log(1.0+svd.getSingularValues()[svd.getRank()])*0.25, 1e-4)); } /** * Sets the number of dimensions to project down to * * @param dimensions the feature size to project down to */ public void setDimensions(int dimensions) { if (dimensions < 1) throw new IllegalArgumentException("Number of dimensions must be positive, not " + dimensions); this.dimensions = dimensions; } /** * Returns the number of dimensions to project down to * * @return the number of dimensions to project down to */ public int getDimensions() { return dimensions; } public static Distribution guessDimensions(DataSet d) { //TODO improve using SVD rank if(d.getNumNumericalVars() < 100) return new UniformDiscrete(1, d.getNumNumericalVars()); return new UniformDiscrete(20, 100); } }

Ads help maintain this website.