Class SPA

JSAT/src/jsat/classifiers/linear/SPA.java:34–307

Support class Passive Aggressive (SPA) is a multi class generalization of PassiveAggressive. It works in the same philosophy, and can obtain better multi class accuracy then PA used with a meta learner. SPA is more sensitive to small values for the {@link #setC(double) aggressiveness p

 * @author Edward Raff
 */
public class SPA extends BaseUpdateableClassifier implements Parameterized, SimpleWeightVectorModel
{

    private static final long serialVersionUID = 3613279663279244169L;
    private Vec[] w;
    private double[] bias;
    private double C = 1;
    private boolean useBias = false;
    private PassiveAggressive.Mode mode;

    /**
     * Creates a new Passive Aggressive learner that does 10 epochs and uses
     * PA2. 
     */
    public SPA()
    {
        this(10, PassiveAggressive.Mode.PA2);
    }
    
    /**
     * Creates a new Passive Aggressive learner
     * 
     * @param epochs the number of training epochs to use during batch training
     * @param mode which version of the update to perform 
     */
    public SPA(int epochs, PassiveAggressive.Mode mode)
    {
        setEpochs(epochs);
        setMode(mode);
    }

    /**
     * Sets whether or not the implementation will use an implicit bias term 
     * appended to the inputs or not. 
     * @param useBias {@code true} to add an implicit bias term, {@code false} 
     * to use the data as given
     */
    public void setUseBias(boolean useBias)
    {
        this.useBias = useBias;
    }

    /**
     * Returns true if an implicit bias term will be added, false otherwise
     * @return true if an implicit bias term will be added, false otherwise
     */
    public boolean isUseBias()
    {
        return useBias;
    }
    
    /**
     * Set the aggressiveness parameter. Increasing the value of this parameter 
     * increases the aggressiveness of the algorithm. It must be a positive 
     * value. This parameter essentially performs a type of regularization on 
     * the updates
     * <br>
     * An infinitely large value is equivalent to being completely aggressive,