package jsat.lossfunctions;
import jsat.classifiers.CategoricalResults;
import jsat.linear.Vec;
/**
* The HingeLoss loss function for classification L(x, y) = max(0, 1-y*x)
* . This also includes the multi-class version of the hinge loss.
*
* This function is only once differentiable.
*
* @author Edward Raff
*/
public class HingeLoss implements LossMC
{
private static final long serialVersionUID = -7001702646530236153L;
/**
* Computes the HingeLoss loss
*
* @param pred the predicted value
* @param y the target value
* @return the HingeLoss loss
*/
public static double loss(double pred, double y)
{
return Math.max(0, 1 - y * pred);
}
/**
* Computes the first derivative of the HingeLoss loss
*
* @param pred the predicted value
* @param y the target value
* @return the first derivative of the HingeLoss loss
*/
public static double deriv(double pred, double y)
{
if (pred * y > 1)
return 0;
else
return -y;
}
public static CategoricalResults classify(double score)
{
CategoricalResults cr = new CategoricalResults(2);
if(score > 0)
cr.setProb(1, 1.0);
else
cr.setProb(0, 1.0);
return cr;
}
@Override
public double getLoss(double pred, double y)
{
return loss(pred, y);
}
@Override
public double getDeriv(double pred, double y)
{
return deriv(pred, y);
}
@Override
public double getDeriv2(double pred, double y)
{
return 0;
}
@Override
public double getDeriv2Max()
{
return 0;
}
@Override
public HingeLoss clone()
{
return this;
}
@Override
public CategoricalResults getClassification(double score)
{
return classify(score);
}
@Override
public double getLoss(Vec processed, int y)
{
double max_not_y = Double.NEGATIVE_INFINITY;
for(int i = 0; i < processed.length(); i++)
if(i != y)
max_not_y = Math.max(max_not_y, processed.get(i));
return Math.max(0, 1.0+max_not_y-processed.get(y));
}
@Override
public void process(Vec pred, Vec processed)
{
if(pred != processed)
pred.copyTo(processed);
}
@Override
public void deriv(Vec processed, Vec derivs, int y)
{
final double proccessed_y = processed.get(y);
double maxVal_not_y = Double.NEGATIVE_INFINITY;
int maxIndx = -1;
for(int i = 0; i < processed.length(); i++)
if(i != y && processed.get(i) > maxVal_not_y)
{
maxIndx = i;
maxVal_not_y = processed.get(i);
}
derivs.zeroOut();
if(1.0 + maxVal_not_y - proccessed_y > 0)
{
derivs.set(y, -1.0);
derivs.set(maxIndx, 1.0);
}
}
@Override
public CategoricalResults getClassification(Vec processed)
{
int maxIndx = 0;
double maxVal_not_y = processed.get(maxIndx);
for(int i = 1; i < processed.length(); i++)
if(processed.get(i) > maxVal_not_y)
{
maxIndx = i;
maxVal_not_y = processed.get(i);
}
CategoricalResults toRet = new CategoricalResults(processed.length());
toRet.setProb(maxIndx, 1.0);
return toRet;
}
@Override
public double getConjugate(double b, double pred, double y)
{
if(b < -1 || b > 0)
return Double.POSITIVE_INFINITY;
//else
return b;
}
@Override
public double lipschitz()
{
//"Both hinge loss and absolute deviation loss are 1-Lipschitz"
//Shalev-Shwartz, S., & Zhang, T. (2012). Stochastic Dual Coordinate Ascent Methods for Regularized Loss Minimization. Journal ofMachine Learning Research, 14, 567–599. Machine Learning; Learning; Optimization and Control. Retrieved from http://arxiv.org/abs/1209.1873
return 1;
}
}
Ads help maintain this website.