public JPmmlModelRunner(Evaluator evaluator, ModelOutputs modelOutputs) { this.eval = evaluator; this.modelOutputs = modelOutputs; activeFields = evaluator.getActiveFields(); predictedFields = eval.getPredictedFields(); outputFields = eval.getOutputFields(); }
@Override public Map<FieldName, ?> predictScores(Map<FieldName, FieldValue> preProcInputs) { LOG.debug("Predicting scores for pre processed inputs: = [{}]", preProcInputs); Map<FieldName, ?> predictedScores = eval.evaluate(preProcInputs); LOG.debug("Predicted scores = [{}]", predictedScores); return predictedScores; }
@Override public Map<FieldName, FieldValue> preProcessInputs(Map<FieldName, Object> rawInputs) { LOG.debug("Pre processing raw inputs: = [{}]", rawInputs); final Map<FieldName, FieldValue> preProcInputs = new LinkedHashMap<>(); for (Map.Entry<FieldName, Object> rawEntry : rawInputs.entrySet()) { preProcInputs.putIfAbsent(rawEntry.getKey(), EvaluatorUtil.prepare(eval, rawEntry.getKey(), rawEntry.getValue())); } LOG.debug("Pre processed inputs = [{}]", preProcInputs); return preProcInputs; }
@Override public boolean doEquivalent(Object expected, Object actual){ double precision = getPrecision(); double zeroThreshold = getZeroThreshold(); if(actual instanceof Computable){ actual = EvaluatorUtil.decode(actual); } expected = TypeUtil.parseOrCast(TypeUtil.getDataType(actual), expected); return VerificationUtil.acceptable(expected, actual, precision, zeroThreshold); }
@Override public Evaluator getEvaluator() throws Exception { PMML pmml = getPMML(); EvaluatorBuilder evaluatorBuilder = new ModelEvaluatorBuilder(pmml); Evaluator evaluator = evaluatorBuilder.build(); evaluator.verify(); return evaluator; }
private static ModelOutputs create(PMML pmmlModel, List<String> streams) { final Set<String> fieldNames = new LinkedHashSet<>(); final Evaluator evaluator = JpmmlFactory.newEvaluator(pmmlModel); for (FieldName predictedField : evaluator.getPredictedFields()) { fieldNames.add(predictedField.getValue()); } for (FieldName outputField : evaluator.getOutputFields()) { fieldNames.add(outputField.getValue()); } final Map<String, Fields> toDeclare = streams.stream() .collect(Collectors.toMap(Function.identity(), (x) -> new Fields(new ArrayList<>(fieldNames)))); return new JpmmlModelOutputs(toDeclare); } }
private Map<String, List<Object>> toValuesMap(Map<FieldName, ?> predScores) { final List<Object> scoredVals = new ArrayList<>(); for (FieldName predictedField : predictedFields) { Object targetValue = predScores.get(predictedField); scoredVals.add(EvaluatorUtil.decode(targetValue)); } for (FieldName outputField : outputFields) { Object targetValue = predScores.get(outputField); scoredVals.add(EvaluatorUtil.decode(targetValue)); } final Map<String, List<Object>> valuesMap = new HashMap<>(); for (String stream: modelOutputs.streams()) { valuesMap.put(stream, scoredVals); } return valuesMap; }
@Override public int compareToValue(FieldValue value){ List<?> ordering = getOrdering(); if(ordering == null){ return super.compareToValue(value); } return compare(ordering, getValue(), TypeUtil.parseOrCast(getDataType(), value.getValue())); }
static public FieldValue discretize(Discretize discretize, FieldValue value){ String result = discretize(discretize, value.asDouble()); return FieldValueUtil.create(ExpressionUtil.getDataType(discretize, DataType.STRING), OpType.CATEGORICAL, result); }
public void put(String key, Value<V> value){ ValueMap<String, V> values = getValues(); if(values.containsKey(key)){ throw new EvaluationException("Value for key " + PMMLException.formatKey(key) + " has already been defined"); } values.put(key, value); }
/** * Creates a new {@link Evaluator} object representing the PMML model defined in the {@link PMML} argument */ public static Evaluator newEvaluator(PMML pmml) { Objects.requireNonNull(pmml); final PMMLManager pmmlManager = new PMMLManager(pmml); return (ModelEvaluator<?>) pmmlManager.getModelManager(null, ModelEvaluatorFactory.getInstance()); }
static private Double getProbability(Object object, OutputField outputField){ HasProbability hasProbability = TypeUtil.cast(HasProbability.class, object); String value = getCategoryValue(object, outputField); return hasProbability.getProbability(value); }
protected <V extends Number> Classification<V> createClassification(ValueMap<String, V> values){ if(hasResultFeature(org.dmg.pmml.ResultFeature.PROBABILITY) || hasResultFeature(org.dmg.pmml.ResultFeature.RESIDUAL)){ return new ProbabilityDistribution<V>(values); } else if(hasResultFeature(org.dmg.pmml.ResultFeature.CONFIDENCE)){ return new ConfidenceDistribution<V>(values); } else { return new Classification<V>(Classification.Type.VOTE, values); } }
static private Double getConfidence(Object object, OutputField outputField){ HasConfidence hasConfidence = TypeUtil.cast(HasConfidence.class, object); String value = getCategoryValue(object, outputField); return hasConfidence.getConfidence(value); }
@Override public Value<V> apply(Vector<V> values){ if(this.weightSum.equals(0d)){ throw new UndefinedResultException(); } return (values.sum()).divide(this.weightSum); } };
private void report(String expression) { org.jpmml.evaluator.Report report = getReport(); org.jpmml.evaluator.Report.Entry entry = new org.jpmml.evaluator.Report.Entry(expression, getValue()); report.add(entry); }
protected Report newReport(){ ReportFactory reportFactory = getReportFactory(); if(reportFactory == null){ return new SimpleReport(); } return reportFactory.newReport(); }
private String getExpression() { org.jpmml.evaluator.Report report = getReport(); org.jpmml.evaluator.Report.Entry entry = report.tailEntry(); return entry.getExpression(); }