private Map<FieldName, ?> evaluateRegression(ModelEvaluationContext context) {
Trail trail = new Trail();
Node node = evaluateTree(trail, context);
if (node == null) {
return TargetUtil.evaluateRegressionDefault(context);
}
Double score = (Double) TypeUtil.parseOrCast(DataType.DOUBLE, node.getScore());
TargetField targetField = getTargetField();
NodeScore nodeScore =
createNodeScore(node, TargetUtil.evaluateRegressionInternal(targetField, score, context));
return Collections.singletonMap(targetField.getName(), nodeScore);
}
private Map<FieldName, ? extends Classification> evaluateClassification(
ModelEvaluationContext context) {
TreeModel treeModel = getModel();
Trail trail = new Trail();
Node node = evaluateTree(trail, context);
if (node == null) {
return TargetUtil.evaluateClassificationDefault(context);
}
double missingValuePenalty = 1d;
int missingLevels = trail.getMissingLevels();
if (missingLevels > 0) {
missingValuePenalty = Math.pow(treeModel.getMissingValuePenalty(), missingLevels);
}
NodeScoreDistribution result = createNodeScoreDistribution(node, missingValuePenalty);
return TargetUtil.evaluateClassification(result, context);
}
private static Object getPredictedDisplayValue(
Object object, DataField dataField, Target target) {
if (object instanceof HasDisplayValue) {
HasDisplayValue hasDisplayValue = TypeUtil.cast(HasDisplayValue.class, object);
return hasDisplayValue.getDisplayValue();
}
object = getPredictedValue(object);
if (target != null) {
TargetValue targetValue = TargetUtil.getTargetValue(target, object);
if (targetValue != null) {
String displayValue = targetValue.getDisplayValue();
if (displayValue != null) {
return displayValue;
}
}
}
OpType opType = dataField.getOpType();
switch (opType) {
case CONTINUOUS:
break;
case CATEGORICAL:
case ORDINAL:
{
Value value = FieldValueUtil.getValidValue(dataField, object);
if (value != null) {
String displayValue = value.getDisplayValue();
if (displayValue != null) {
return displayValue;
}
}
}
break;
default:
throw new UnsupportedFeatureException(dataField, opType);
}
// "If the display value is not specified explicitly, then the raw predicted value is used by
// default"
return object;
}
private Map<FieldName, ?> evaluateRegression(ModelEvaluationContext context) {
SupportVectorMachineModel supportVectorMachineModel = getModel();
List<SupportVectorMachine> supportVectorMachines =
supportVectorMachineModel.getSupportVectorMachines();
if (supportVectorMachines.size() != 1) {
throw new InvalidFeatureException(supportVectorMachineModel);
}
SupportVectorMachine supportVectorMachine = supportVectorMachines.get(0);
double[] input = createInput(context);
Double result = evaluateSupportVectorMachine(supportVectorMachine, input);
return TargetUtil.evaluateRegression(result, context);
}
private Map<FieldName, ? extends Classification> evaluateClassification(
ModelEvaluationContext context) {
SupportVectorMachineModel supportVectorMachineModel = getModel();
List<SupportVectorMachine> supportVectorMachines =
supportVectorMachineModel.getSupportVectorMachines();
if (supportVectorMachines.size() < 1) {
throw new InvalidFeatureException(supportVectorMachineModel);
}
String alternateBinaryTargetCategory =
supportVectorMachineModel.getAlternateBinaryTargetCategory();
Classification result;
SvmClassificationMethodType svmClassificationMethod = getClassificationMethod();
switch (svmClassificationMethod) {
case ONE_AGAINST_ALL:
result = new Classification(Classification.Type.DISTANCE);
break;
case ONE_AGAINST_ONE:
result = new VoteDistribution();
break;
default:
throw new UnsupportedFeatureException(supportVectorMachineModel, svmClassificationMethod);
}
double[] input = createInput(context);
for (SupportVectorMachine supportVectorMachine : supportVectorMachines) {
String targetCategory = supportVectorMachine.getTargetCategory();
String alternateTargetCategory = supportVectorMachine.getAlternateTargetCategory();
Double value = evaluateSupportVectorMachine(supportVectorMachine, input);
switch (svmClassificationMethod) {
case ONE_AGAINST_ALL:
{
if (targetCategory == null || alternateTargetCategory != null) {
throw new InvalidFeatureException(supportVectorMachine);
}
result.put(targetCategory, value);
}
break;
case ONE_AGAINST_ONE:
if (alternateBinaryTargetCategory != null) {
if (targetCategory == null || alternateTargetCategory != null) {
throw new InvalidFeatureException(supportVectorMachine);
}
String label;
long roundedValue = Math.round(value);
// "A rounded value of 1 corresponds to the targetCategory attribute of the
// SupportVectorMachine element"
if (roundedValue == 1) {
label = targetCategory;
} else
// "A rounded value of 0 corresponds to the alternateBinaryTargetCategory attribute of
// the SupportVectorMachineModel element"
if (roundedValue == 0) {
label = alternateBinaryTargetCategory;
} else
// "The numeric prediction must be between 0 and 1"
{
throw new EvaluationException("Invalid numeric prediction " + value);
}
Double vote = result.get(label);
if (vote == null) {
vote = 0d;
}
result.put(label, (vote + 1d));
} else {
if (targetCategory == null || alternateTargetCategory == null) {
throw new InvalidFeatureException(supportVectorMachine);
}
Double threshold = supportVectorMachine.getThreshold();
if (threshold == null) {
threshold = supportVectorMachineModel.getThreshold();
}
String label;
// "If the numeric prediction is smaller than the threshold, it corresponds to the
// targetCategory attribute"
if ((value).compareTo(threshold) < 0) {
label = targetCategory;
} else {
label = alternateTargetCategory;
}
Double vote = result.get(label);
if (vote == null) {
vote = 0d;
}
result.put(label, (vote + 1d));
}
break;
default:
break;
}
}
return TargetUtil.evaluateClassification(result, context);
}
private Map<FieldName, ? extends ClassificationMap<?>> evaluateRuleSet(
ModelManagerEvaluationContext context) {
RuleSetModel ruleSetModel = getModel();
RuleSet ruleSet = ruleSetModel.getRuleSet();
List<RuleSelectionMethod> ruleSelectionMethods = ruleSet.getRuleSelectionMethods();
RuleSelectionMethod ruleSelectionMethod;
// "If more than one method is included, the first method is used as the default method for
// scoring"
if (ruleSelectionMethods.size() > 0) {
ruleSelectionMethod = ruleSelectionMethods.get(0);
} else {
throw new InvalidFeatureException(ruleSet);
}
// Both the ordering of keys and values is significant
ListMultimap<String, SimpleRule> firedRules = LinkedListMultimap.create();
List<Rule> rules = ruleSet.getRules();
for (Rule rule : rules) {
collectFiredRules(firedRules, rule, context);
}
RuleClassificationMap result = new RuleClassificationMap();
RuleSelectionMethod.Criterion criterion = ruleSelectionMethod.getCriterion();
Set<String> keys = firedRules.keySet();
for (String key : keys) {
List<SimpleRule> keyRules = firedRules.get(key);
switch (criterion) {
case FIRST_HIT:
{
SimpleRule winner = keyRules.get(0);
// The first value of the first key
if (result.getEntity() == null) {
result.setEntity(winner);
}
result.put(key, winner.getConfidence());
}
break;
case WEIGHTED_SUM:
{
SimpleRule winner = null;
double totalWeight = 0;
for (SimpleRule keyRule : keyRules) {
if (winner == null || (winner.getWeight() < keyRule.getWeight())) {
winner = keyRule;
}
totalWeight += keyRule.getWeight();
}
result.put(winner, key, totalWeight / firedRules.size());
}
break;
case WEIGHTED_MAX:
{
SimpleRule winner = null;
for (SimpleRule keyRule : keyRules) {
if (winner == null || (winner.getWeight() < keyRule.getWeight())) {
winner = keyRule;
}
}
result.put(winner, key, winner.getConfidence());
}
break;
default:
throw new UnsupportedFeatureException(ruleSelectionMethod, criterion);
}
}
return TargetUtil.evaluateClassification(result, context);
}