jsat.classifiers.svm

Class SupportVectorLearner

java.lang.Object

jsat.classifiers.svm.SupportVectorLearner

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

CSKLRBatch, DCSVM, LSSVM, PegasosK, PlattSMO, SBP, SVMnoBias

public abstract class SupportVectorLearner
extends Object
implements Serializable

Base class for support vector style learners. This means that the learner performs batch training on a fixed set of training points using a kernel to project the data into a different space. The final set of vectors used may or may not be sparse. It does not necessarily have to be a Support Vector machine.

This class provides caching mechanism to transparently provide faster kernel.

Author:

Edward Raff

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SupportVectorLearner.CacheMode Determines how the final kernel values are cached.

Field Summary

Fields

Modifier and Type	Field and Description
protected List<Double>	accelCache Kernel evaluation acceleration cache
protected double[]	alphas The array of coefficients associated with each support vector.
protected int	cacheEvictions
protected int	evalCount
protected List<Vec>	vecs The array of vectors.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SupportVectorLearner() This constructor is meant manly for Serialization to work.
	SupportVectorLearner(KernelTrick kernel, SupportVectorLearner.CacheMode cacheMode) Creates a new Support Vector Learner
	SupportVectorLearner(SupportVectorLearner toCopy) Copy constructor

Method Summary

Modifier and Type	Method and Description
protected void	accessingRow(int r) This method allows the caller to hint that they are about to access many kernel values for a specific row.
SupportVectorLearner.CacheMode	getCacheMode() Returns the current caching mode in use
int	getCacheValue() Returns the current cache value
KernelTrick	getKernel()
protected double	k(int a, int b) Internal kernel eval source.
protected double	kEval(int a, int b) Performs a kernel evaluation of the a'th and b'th vectors in the vecs array.
protected double	kEval(Vec a, Vec b) Performs a kernel evaluation of the product between two vectors directly.
protected double	kEvalSum(Vec y) Performs a summation of the form ∑ αi k(xi, y) for each support vector and associated alpha value currently stored in the support vector machine.
protected void	setAlphas(double[] alphas) Sets the final set of alphas, and indicates that the final accelerating structures (if available) should be constructed for performing kernel evaluations against unseen vectors.
void	setCacheMode(SupportVectorLearner.CacheMode cacheMode) Calling this sets the method of caching that will be used.
void	setCacheSize(long N, long bytes) Sets the cache value to one that will use the specified amount of memory.
void	setCacheValue(int cacheValue) Sets the cache value, which may be interpreted differently by different caching schemes.
void	setKernel(KernelTrick kernel) Sets the kernel trick to use
protected void	sparsify() Sparsifies the SVM by removing the vectors with α = 0 from the dataset.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

vecs

protected List<Vec> vecs

The array of vectors. In the training phase, this should be the set of all training vectors. After training, this should contain only the set of support vectors.

alphas

protected double[] alphas

The array of coefficients associated with each support vector. This should be instantiated directly when training. When the set of alphas and support vectors is finalized, setAlphas(double[]) should be called with a reference to itself or the array where the final alphas are stored. This will initialized any accelerating structures so that kEvalSum(jsat.linear.Vec) can be called.

accelCache

protected List<Double> accelCache

Kernel evaluation acceleration cache

evalCount

protected int evalCount

cacheEvictions

protected int cacheEvictions

Constructor Detail

SupportVectorLearner

protected SupportVectorLearner()

This constructor is meant manly for Serialization to work. It uses a linear kernel and no caching.

SupportVectorLearner

public SupportVectorLearner(KernelTrick kernel,
                            SupportVectorLearner.CacheMode cacheMode)

Creates a new Support Vector Learner

Parameters:

kernel - the kernel trick to use

cacheMode - the kernel caching method to use

SupportVectorLearner

public SupportVectorLearner(SupportVectorLearner toCopy)

Copy constructor

Parameters:

toCopy - the object to copy

Method Detail

setAlphas

protected void setAlphas(double[] alphas)

Sets the final set of alphas, and indicates that the final accelerating structures (if available) should be constructed for performing kernel evaluations against unseen vectors.
This may be called multiple times in an online scenario, but calls will involve a re-construction of the whole cache.

Parameters:

alphas - the final array of alphas

setKernel

public void setKernel(KernelTrick kernel)

Sets the kernel trick to use

Parameters:

kernel - the kernel trick to use

setCacheValue

public void setCacheValue(int cacheValue)

Sets the cache value, which may be interpreted differently by different caching schemes.
This is currently only used for SupportVectorLearner.CacheMode.ROWS, where the value indicates how many rows will be cached.

Parameters:

cacheValue - the cache value to be used

setCacheSize

public void setCacheSize(long N,
                         long bytes)

Sets the cache value to one that will use the specified amount of memory. If the amount of memory specified is great enough, this method will automatically set the cache mode to SupportVectorLearner.CacheMode.FULL.

Parameters:

N - the number of data points

bytes - the number of bytes of memory to make the cache

getCacheValue

public int getCacheValue()

Returns the current cache value

Returns:

the current cache value

getCacheMode

public SupportVectorLearner.CacheMode getCacheMode()

Returns the current caching mode in use

Returns:

the current caching mode in use

setCacheMode

public void setCacheMode(SupportVectorLearner.CacheMode cacheMode)

Calling this sets the method of caching that will be used.
This is called called by the implementing class to initialize and clear the caches. Calling this with the current cache mode will initialize the caches. Once training is complete, call again with null to deinitialize the caches.

Parameters:

cacheMode -

getKernel

public KernelTrick getKernel()

kEvalSum

protected double kEvalSum(Vec y)

Performs a summation of the form
∑ α_i k(x_i, y)
for each support vector and associated alpha value currently stored in the support vector machine. It is not necessary to call setAlphas(double[]) before calling this, but kernel evaluations may be slower if this is not done.

Parameters:

y - the vector to perform the kernel product sum against

Returns:

the sum of the scaled kernel products

kEval

protected double kEval(Vec a,
                       Vec b)

Performs a kernel evaluation of the product between two vectors directly. This is the slowest way to do a kernel evaluation, and should be avoided unless there is a specific reason to do so.
These evaluations will not be counted in evalCount

Parameters:

a - the first vector

b - the second vector

Returns:

the kernel evaluation of k(a, b)

kEval

protected double kEval(int a,
                       int b)

Performs a kernel evaluation of the a'th and b'th vectors in the vecs array.

Parameters:

a - the first vector index

b - the second vector index

Returns:

the kernel evaluation of k(a, b)

accessingRow

protected void accessingRow(int r)

This method allows the caller to hint that they are about to access many kernel values for a specific row. The row may be selected out from the cache into its own location to avoid excess LRU overhead. Giving a negative index indicates that we are done with the row, and removes it. This method may be called multiple times with different row values. But when done accessing a specific row, a negative value should be passed in.

Parameters:

r - the row to cache explicitly to avoid LRU overhead. Or a negative value to indicate that we are done with any specific row.

k

protected double k(int a,
                   int b)

Internal kernel eval source. Only call directly if you KNOW you will not be re-using the resulting value and intentionally wish to skip the caching system

Parameters:

a - the first vector index

b - the second vector index

Returns:

the kernel evaluation of k(a, b)

sparsify

protected void sparsify()

Sparsifies the SVM by removing the vectors with α = 0 from the dataset.