package jsat.lossfunctions;
import static java.lang.Math.*;
import jsat.classifiers.CategoricalResults;
/**
* The LogisticLoss loss function for classification L(x, y) =
* log(1+exp(-y*x)).
*
* This function is twice differentiable.
*
* @author Edward Raff
*/
public class LogisticLoss implements LossC
{
/*
* NOTE: 30 used as a threshold b/c at the small values exp(-30) stradles
* the edge of numerical double precision
*/
private static final long serialVersionUID = -3929171604513497068L;
/**
* Computes the logistic loss
*
* @param pred the predicted value
* @param y the true value
* @return the logistic loss
*/
public static double loss(double pred, double y)
{
final double x = -y * pred;
if (x >= 30)//as x -> inf, L(x) -> x. At 30 exp(x) is O(10^13), getting unstable. L(x)-x at this value is O(10^-14), also avoids exp and log ops
return x;
else if (x <= -30)
return 0;
return log(1 + exp(x));
}
/**
* Computes the first derivative of the logistic loss
*
* @param pred the predicted value
* @param y the true value
* @return the first derivative of the logistic loss
*/
public static double deriv(double pred, double y)
{
final double x = y * pred;
if (x >= 30)
return 0;
else if (x <= -30)
return y;
return -y / (1 + exp(y * pred));
}
/**
* Computes the second derivative of the logistic loss
*
* @param pred the predicted value
* @param y the true value
* @return the second derivative of the logistic loss
*/
public static double deriv2(double pred, double y)
{
final double x = y * pred;
if (x >= 30)
return 0;
else if (x <= -30)
return 0;
final double p = 1 / (1 + exp(y * pred));
return p * (1 - p);
}
public static CategoricalResults classify(double score)
{
CategoricalResults cr = new CategoricalResults(2);
final double p;
if (score > 30)
p = 1.0;
else if (score < -30)
p = 0.0;
else
p = 1 / (1 + Math.exp(-score));
cr.setProb(0, 1 - p);
cr.setProb(1, p);
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 deriv2(pred, y);
}
@Override
public double getDeriv2Max()
{
return 1.0 / 4.0;
}
@Override
public LogisticLoss clone()
{
return this;
}
@Override
public CategoricalResults getClassification(double score)
{
return classify(score);
}
@Override
public double getConjugate(double b, double pred, double y)
{
if(b < 0 || b > 1)
return Double.POSITIVE_INFINITY;
//else
if(0.5-abs(0.5-b) < 1e-13) // you are so close tot he edges of making log(b) return NaN, so lets round you out
return 0;//This is
return b * log(b) + (1-b) * log(1-b); //log(max(1e, b)) done to avoid NaN with -0 inputs
}
@Override
public double lipschitz()
{
return 4;
}
}
Ads help maintain this website.