public static FieldValue evaluate(
DefineFunction defineFunction, List<FieldValue> values, EvaluationContext context) {
List<ParameterField> parameterFields = defineFunction.getParameterFields();
if (parameterFields.size() < 1) {
throw new InvalidFeatureException(defineFunction);
} // End if
if (parameterFields.size() != values.size()) {
throw new EvaluationException();
}
FunctionEvaluationContext functionContext = new FunctionEvaluationContext(context);
for (int i = 0; i < parameterFields.size(); i++) {
ParameterField parameterField = parameterFields.get(i);
FieldValue value = FieldValueUtil.refine(parameterField, values.get(i));
functionContext.declare(parameterField.getName(), value);
}
Expression expression = defineFunction.getExpression();
if (expression == null) {
throw new InvalidFeatureException(defineFunction);
}
FieldValue result = ExpressionUtil.evaluate(expression, functionContext);
return FieldValueUtil.refine(defineFunction.getDataType(), defineFunction.getOptype(), result);
}
private double[] createInput(EvaluationContext context) {
SupportVectorMachineModel supportVectorMachineModel = getModel();
VectorDictionary vectorDictionary = supportVectorMachineModel.getVectorDictionary();
VectorFields vectorFields = vectorDictionary.getVectorFields();
List<FieldRef> fieldRefs = vectorFields.getFieldRefs();
double[] result = new double[fieldRefs.size()];
for (int i = 0; i < fieldRefs.size(); i++) {
FieldRef fieldRef = fieldRefs.get(i);
FieldValue value = ExpressionUtil.evaluate(fieldRef, context);
if (value == null) {
throw new MissingValueException(fieldRef.getField(), vectorFields);
}
result[i] = (value.asNumber()).doubleValue();
}
return result;
}
/**
* Evaluates the {@link Output} element.
*
* @param predictions A map of {@link Evaluator#getTargetFields() target field} values.
* @return A map of {@link Evaluator#getTargetFields() target field} values together with {@link
* Evaluator#getOutputFields() output field} values.
*/
@SuppressWarnings(value = {"fallthrough"})
public static Map<FieldName, ?> evaluate(
Map<FieldName, ?> predictions, ModelEvaluationContext context) {
ModelEvaluator<?> modelEvaluator = context.getModelEvaluator();
Model model = modelEvaluator.getModel();
Output output = model.getOutput();
if (output == null) {
return predictions;
}
Map<FieldName, Object> result = new LinkedHashMap<>(predictions);
List<OutputField> outputFields = output.getOutputFields();
outputFields:
for (OutputField outputField : outputFields) {
FieldName targetFieldName = outputField.getTargetField();
Object targetValue = null;
ResultFeature resultFeature = outputField.getResultFeature();
String segmentId = outputField.getSegmentId();
SegmentResult segmentPredictions = null;
// Load the target value of the specified segment
if (segmentId != null) {
if (!(model instanceof MiningModel)) {
throw new InvalidFeatureException(outputField);
}
MiningModelEvaluationContext miningModelContext = (MiningModelEvaluationContext) context;
segmentPredictions = miningModelContext.getResult(segmentId);
// "If there is no Segment matching segmentId or if the predicate of the matching Segment
// evaluated to false, then the result delivered by this OutputField is missing"
if (segmentPredictions == null) {
continue outputFields;
} // End if
if (targetFieldName != null) {
if (!segmentPredictions.containsKey(targetFieldName)) {
throw new MissingValueException(targetFieldName, outputField);
}
targetValue = segmentPredictions.get(targetFieldName);
} else {
targetValue = segmentPredictions.getTargetValue();
}
} else
// Load the target value
{
switch (resultFeature) {
case ENTITY_ID:
{
// "Result feature entityId returns the id of the winning segment"
if (model instanceof MiningModel) {
targetValue = TypeUtil.cast(HasEntityId.class, predictions);
break;
}
}
// Falls through
default:
{
if (targetFieldName == null) {
targetFieldName = modelEvaluator.getTargetFieldName();
} // End if
if (!predictions.containsKey(targetFieldName)) {
throw new MissingValueException(targetFieldName, outputField);
}
targetValue = predictions.get(targetFieldName);
}
break;
}
}
// "If the target value is missing, then the result delivered by this OutputField is missing"
if (targetValue == null) {
continue outputFields;
}
Object value;
// Perform the requested computation on the target value
switch (resultFeature) {
case PREDICTED_VALUE:
{
value = getPredictedValue(targetValue);
}
break;
case PREDICTED_DISPLAY_VALUE:
{
DataField dataField = modelEvaluator.getDataField(targetFieldName);
if (dataField == null) {
throw new MissingFieldException(targetFieldName, outputField);
}
Target target = modelEvaluator.getTarget(targetFieldName);
value = getPredictedDisplayValue(targetValue, dataField, target);
}
break;
case TRANSFORMED_VALUE:
case DECISION:
{
if (segmentId != null) {
String name = outputField.getValue();
if (name == null) {
throw new InvalidFeatureException(outputField);
}
Expression expression = outputField.getExpression();
if (expression != null) {
throw new InvalidFeatureException(outputField);
}
value = segmentPredictions.get(FieldName.create(name));
break;
}
Expression expression = outputField.getExpression();
if (expression == null) {
throw new InvalidFeatureException(outputField);
}
value = FieldValueUtil.getValue(ExpressionUtil.evaluate(expression, context));
}
break;
case PROBABILITY:
{
value = getProbability(targetValue, outputField);
}
break;
case RESIDUAL:
{
FieldValue expectedTargetValue = context.evaluate(targetFieldName);
if (expectedTargetValue == null) {
throw new MissingValueException(targetFieldName, outputField);
}
DataField dataField = modelEvaluator.getDataField(targetFieldName);
OpType opType = dataField.getOpType();
switch (opType) {
case CONTINUOUS:
value = getContinuousResidual(targetValue, expectedTargetValue);
break;
case CATEGORICAL:
value = getCategoricalResidual(targetValue, expectedTargetValue);
break;
default:
throw new UnsupportedFeatureException(dataField, opType);
}
}
break;
case CLUSTER_ID:
{
value = getClusterId(targetValue);
}
break;
case ENTITY_ID:
{
if (targetValue instanceof HasRuleValues) {
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.RULE_ID);
break;
}
value = getEntityId(targetValue, outputField);
}
break;
case AFFINITY:
{
value = getAffinity(targetValue, outputField);
}
break;
case CLUSTER_AFFINITY:
case ENTITY_AFFINITY:
{
String entityId = outputField.getValue();
// Select the specified entity instead of the winning entity
if (entityId != null) {
value = getAffinity(targetValue, outputField);
break;
}
value = getEntityAffinity(targetValue);
}
break;
case REASON_CODE:
{
value = getReasonCode(targetValue, outputField);
}
break;
case RULE_VALUE:
{
value = getRuleValue(targetValue, outputField);
}
break;
case ANTECEDENT:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.ANTECEDENT);
}
break;
case CONSEQUENT:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.CONSEQUENT);
}
break;
case RULE:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.RULE);
}
break;
case RULE_ID:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.RULE_ID);
}
break;
case CONFIDENCE:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.CONFIDENCE);
}
break;
case SUPPORT:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.SUPPORT);
}
break;
case LIFT:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.LIFT);
}
break;
case LEVERAGE:
{
value = getRuleValue(targetValue, outputField, OutputField.RuleFeature.LEVERAGE);
}
break;
case WARNING:
{
value = context.getWarnings();
}
break;
default:
throw new UnsupportedFeatureException(outputField, resultFeature);
}
FieldValue outputValue = FieldValueUtil.create(outputField, value);
// The result of one output field becomes available to other output fields
context.declare(outputField.getName(), outputValue);
result.put(outputField.getName(), FieldValueUtil.getValue(outputValue));
}
return result;
}
