@Override
public double predict(Example example) throws OperatorException {
int i = 0;
double distance = intercept;
// using kernel for distance calculation
double[] values = new double[example.getAttributes().size()];
for (Attribute currentAttribute : example.getAttributes()) {
values[i] = example.getValue(currentAttribute);
i++;
}
distance += kernel.calculateDistance(values, coefficients);
if (getLabel().isNominal()) {
int positiveMapping = getLabel().getMapping().mapString(classPositive);
int negativeMapping = getLabel().getMapping().mapString(classNegative);
boolean isApplying = example.getAttributes().getPredictedLabel() != null;
if (isApplying) {
example.setConfidence(classPositive, 1.0d / (1.0d + java.lang.Math.exp(-distance)));
example.setConfidence(classNegative, 1.0d / (1.0d + java.lang.Math.exp(distance)));
}
if (distance < 0) {
return negativeMapping;
} else {
return positiveMapping;
}
} else {
return distance;
}
}
private void evaluateSpecialAttributes(ExampleSet exampleSet, Attribute[] specialAttributes) {
Attribute predictedLabel = exampleSet.getAttributes().getPredictedLabel();
Iterator<Example> reader = exampleSet.iterator();
while (reader.hasNext()) {
Example example = reader.next();
double sum = 0;
double[] confidences = new double[specialAttributes.length];
double bestConf = -1;
int bestLabel = 0;
for (int n = 0; n < confidences.length; n++) {
confidences[n] = example.getValue(specialAttributes[n]);
if (confidences[n] > bestConf) {
bestConf = confidences[n];
bestLabel = n;
}
}
example.setValue(
predictedLabel,
predictedLabel.getMapping().mapString(this.getLabel().getMapping().mapIndex(bestLabel)));
for (int n = 0; n < confidences.length; n++) {
confidences[n] = Math.exp(confidences[n] - bestConf);
// remember for normalization:
sum += confidences[n];
}
// Normalize and set confidence values for all classes:
if (Double.isInfinite(sum) || Double.isNaN(sum)) {
int best = (int) example.getPredictedLabel();
for (int k = 0; k < confidences.length; k++) {
confidences[k] = 0;
}
confidences[best] = 1;
} else {
for (int k = 0; k < confidences.length; k++) {
confidences[k] /= sum;
example.setConfidence(predictedLabel.getMapping().mapIndex(k), confidences[k]);
}
}
}
}
private double predictAsLeaf(Example example, ExtendedTree node) {
double dPrediction = 0;
Iterator<String> s = node.getCounterMap().keySet().iterator();
int[] counts = new int[getLabel().getMapping().size()];
int sum = 0;
while (s.hasNext()) {
String className = s.next();
int count = node.getCount(className);
int index = getLabel().getMapping().getIndex(className);
counts[index] = count;
sum += count;
}
for (int i = 0; i < counts.length; i++) {
example.setConfidence(
getLabel().getMapping().mapIndex(i), smoothedConfidence(counts[i], sum));
}
dPrediction = getLabel().getMapping().getIndex(node.getLabel());
return dPrediction;
}
@Override
public ExampleSet performPrediction(ExampleSet exampleSet, Attribute predictedLabel)
throws OperatorException {
Attribute label = this.getLabel();
final int posLabel = label.getMapping().getPositiveIndex();
final int negLabel = label.getMapping().getNegativeIndex();
final String posLabelS = label.getMapping().mapIndex(posLabel);
final String negLabelS = label.getMapping().mapIndex(negLabel);
exampleSet = model.apply(exampleSet);
Iterator<Example> reader = exampleSet.iterator();
while (reader.hasNext()) {
Example example = reader.next();
double predicted = PlattScaling.getLogOddsPosConfidence(example.getConfidence(posLabelS));
double scaledPos =
1.0d / (1.0d + Math.exp(predicted * parameters.getA() + parameters.getB()));
double scaledNeg = 1.0d - scaledPos;
example.setValue(predictedLabel, (scaledPos >= scaledNeg) ? posLabel : negLabel);
example.setConfidence(posLabelS, scaledPos);
example.setConfidence(negLabelS, scaledNeg);
}
return exampleSet;
}