package jsat.regression;

import static java.lang.Math.pow;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.logging.Level;
import java.util.logging.Logger;
import jsat.classifiers.DataPoint;
import static jsat.linear.DenseVector.toDenseVec;
import jsat.linear.*;
import jsat.parameters.*;
import jsat.utils.SystemInfo;
import jsat.utils.concurrent.ParallelUtils;

/**
 * An implementation of Ordinary Kriging with support for a uniform error 
 * measurement. When an {@link #getMeasurementError() error} value is applied, Kriging 
 * becomes equivalent to Gaussian Processes Regression. 
 * 
 * @author Edward Raff
 */
public class OrdinaryKriging implements Regressor, Parameterized
{

    private static final long serialVersionUID = -5774553215322383751L;
    private Variogram vari;
    /**
     * The weight values for each data point
     */
    private Vec X;
    private RegressionDataSet dataSet;
    private double errorSqrd;
    private double nugget;
    
    /**
     * The default nugget value is {@value #DEFAULT_NUGGET}
     */
    public static final double DEFAULT_NUGGET = 0.1;
    /**
     * The default error value is {@link #DEFAULT_ERROR}
     */
    public static final double DEFAULT_ERROR = 0.1;
    
    /**
     * Creates a new Ordinary Kriging. 
     * 
     * @param vari the variogram to fit to the data
     * @param error the global measurement error
     * @param nugget the nugget value to add to the variogram
     */
    public OrdinaryKriging(Variogram vari, double error, double nugget)
    {
        this.vari = vari;
        setMeasurementError(error);
        this.nugget = nugget;
    }
    
    /**
     * Creates a new Ordinary Kriging 
     * @param vari the variogram to fit to the data
     * @param error the global measurement error
     */
    public OrdinaryKriging(Variogram vari, double error)
    {
        this(vari, error, DEFAULT_NUGGET);
    }
    
    /**
     * Creates a new Ordinary Kriging with a small error value
     * @param vari the variogram to fit to the data
     */
    public OrdinaryKriging(Variogram vari)
    {
        this(vari, DEFAULT_ERROR);
    }

    /**
     * Creates a new Ordinary Kriging with a small error value using the 
     * {@link PowVariogram power} variogram. 
     */
    public OrdinaryKriging()
    {
        this(new PowVariogram());
    }
    
    @Override
    public double regress(DataPoint data)
    {
        Vec x = data.getNumericalValues();
        int npt = X.length()-1;
        double[] distVals = new double[npt+1];
        for (int i = 0; i < npt; i++)
            distVals[i] = vari.val(x.pNormDist(2, dataSet.getDataPoint(i).getNumericalValues()));
        distVals[npt] = 1.0;
       
        return X.dot(toDenseVec(distVals));
    }

    @Override
    public void train(RegressionDataSet dataSet, boolean parallel)
    {
        this.dataSet = dataSet;
        /**
         * Size of the data set
         */
        int N = dataSet.getSampleSize();
        /**
         * Stores the target values
         */
        Vec Y = new DenseVector(N+1);
        
        Matrix V = new DenseMatrix(N+1, N+1);
        
        vari.train(dataSet, nugget);
        
        setUpVectorMatrix(N, dataSet, V, Y, parallel);
        
        for(int i = 0; i < N; i++)
            V.increment(i, i, -errorSqrd);
        
        LUPDecomposition lup;
        if(parallel)
            lup = new LUPDecomposition(V, ParallelUtils.CACHED_THREAD_POOL);
        else
            lup = new LUPDecomposition(V);
        
        X = lup.solve(Y);
        if(Double.isNaN(lup.det()) || Math.abs(lup.det()) < 1e-5)
        {
            SingularValueDecomposition svd = new SingularValueDecomposition(V);
            X = svd.solve(Y);
        }
    }

    private void setUpVectorMatrix(final int N, final RegressionDataSet dataSet, final Matrix V, final Vec Y, boolean parallel)
    {
        ParallelUtils.run(parallel, N, (i)->
        {
            DataPoint dpi = dataSet.getDataPoint(i);
            Vec xi = dpi.getNumericalValues();
            for (int j = 0; j < N; j++)
            {
                Vec xj = dataSet.getDataPoint(j).getNumericalValues();
                double val = vari.val(xi.pNormDist(2, xj));
                V.set(i, j, val);
                V.set(j, i, val);
            }
            V.set(i, N, 1.0);
            V.set(N, i, 1.0);
            Y.set(i, dataSet.getTargetValue(i));
        });
        
        V.set(N, N, 0);
    }
    
    @Override
    public boolean supportsWeightedData()
    {
        return false;
    }

    @Override
    public OrdinaryKriging clone()
    {
        OrdinaryKriging clone = new OrdinaryKriging(vari.clone());
        
        clone.setMeasurementError(getMeasurementError());
        clone.setNugget(getNugget());
        if(this.X != null)
            clone.X = this.X.clone();
        if(this.dataSet != null)
            clone.dataSet = this.dataSet;
        
        return clone;
    }

    /**
     * Sets the measurement error used for Kriging, which is equivalent to 
     * altering the diagonal values of the covariance. While the measurement 
     * errors could be per data point, this implementation provides only a 
     * global error. If the error is set to zero, it will perfectly interpolate
     * all data points. 
* Increasing the error smooths the interpolation, and has a large impact on * the regression results. * * @param error the measurement error for all data points */ public void setMeasurementError(double error) { this.errorSqrd = error*error; } /** * Returns the measurement error used for Kriging, which is equivalent to * altering the diagonal values of the covariance. While the measurement * errors could be per data point, this implementation provides only a * global error. If the error is set to zero, it will perfectly interpolate * all data points. * * @return the global error used for the data */ public double getMeasurementError() { return Math.sqrt(errorSqrd); } /** * Sets the nugget value passed to the variogram during training. The * nugget allows the variogram to start from a non-zero value, and is * equivalent to alerting the off diagonal values of the covariance.
* Altering the nugget value has only a minor impact on the output * * @param nugget the new nugget value * @throws ArithmeticException if a negative nugget value is provided */ public void setNugget(double nugget) { if(nugget < 0 || Double.isNaN(nugget) || Double.isInfinite(nugget)) throw new ArithmeticException("Nugget must be a positive value"); this.nugget = nugget; } /** * Returns the nugget value passed to the variogram during training. The * nugget allows the variogram to start from a non-zero value, and is * equivalent to alerting the off diagonal values of the covariance. * * @return the nugget added to the variogram */ public double getNugget() { return nugget; } public static interface Variogram extends Cloneable { /** * Sets the values of the variogram * @param dataSet the data set to learn the parameters from * @param nugget the nugget value to add tot he variogram, may be * ignored if the variogram want to fit it automatically */ public void train(RegressionDataSet dataSet, double nugget); /** * Returns the output of the variogram for the given input * @param r the input value * @return the output of the variogram */ public double val(double r); public Variogram clone(); } public static class PowVariogram implements Variogram { private double alpha; private double beta; public PowVariogram() { this(1.5); } public PowVariogram(double beta) { this.beta = beta; } @Override public void train(RegressionDataSet dataSet, double nugget) { int npt=dataSet.getSampleSize(); double num=0,denom=0, nugSqrd = nugget*nugget; for (int i = 0; i < npt; i++) { Vec xi = dataSet.getDataPoint(i).getNumericalValues(); double yi = dataSet.getTargetValue(i); for (int j = i + 1; j < npt; j++) { Vec xj = dataSet.getDataPoint(j).getNumericalValues(); double yj = dataSet.getTargetValue(j); double rb = pow(xi.pNormDist(2, xj), beta); num += rb* (0.5* pow(yi-yj, 2)-nugSqrd); denom += rb*rb; } } alpha = num / denom; } @Override public double val(double r) { return alpha*pow(r, beta); } @Override public Variogram clone() { PowVariogram clone = new PowVariogram(beta); clone.alpha = this.alpha; return clone; } } }

Ads help maintain this website.