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; }
static private Object getPredictedValue(Object object){ return EvaluatorUtil.decode(object); }
@Override public Object format(Object value){ return org.jpmml.evaluator.EvaluatorUtil.decode(value); }
@Override public String apply(Object object){ object = EvaluatorUtil.decode(object); if(object == null){ return missingValue; } return object.toString(); } };
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; }
private void putPmmlScoresInEvent(Map<FieldName, ?> predScores, Set<String> inserted, StreamlineEventImpl.Builder eventBuilder, List<FieldName> predOrOutFields, String msg) { for (FieldName predOrOutField : predOrOutFields) { final Object targetValue = predScores.get(predOrOutField); final String fieldName = predOrOutField.getValue(); final Object predValue = EvaluatorUtil.decode(targetValue); eventBuilder.put(fieldName, predValue); LOG.debug(msg, fieldName, predValue); inserted.add(fieldName); } } }
/** * <p> * Decouples a {@link Map} instance from the current runtime environment by decoding both its keys and values. * </p> */ static public Map<String, ?> decode(Map<FieldName, ?> map){ Map<String, Object> result = new LinkedHashMap<>(); Collection<? extends Map.Entry<FieldName, ?>> entries = map.entrySet(); for(Map.Entry<FieldName, ?> entry : entries){ FieldName name = entry.getKey(); Object value = entry.getValue(); try { result.put(name != null ? name.getValue() : null, decode(value)); } catch(UnsupportedOperationException uoe){ // Ignored } } return result; }
/** * @see Computable */ static public Object decode(Object object){ if(object instanceof Computable){ Computable computable = (Computable)object; return computable.getResult(); } // End if if(object instanceof Collection){ Collection<?> rawValues = (Collection<?>)object; Collection<Object> decodedValues; // Try to preserve the original contract if(rawValues instanceof Set){ decodedValues = new LinkedHashSet<>(rawValues.size()); } else { decodedValues = new ArrayList<>(rawValues.size()); } for(Object rawValue : rawValues){ decodedValues.add(decode(rawValue)); } return decodedValues; } return object; }
@Override public boolean doEquivalent(Object expected, Object actual){ if(actual instanceof Computable){ actual = EvaluatorUtil.decode(actual); } // End if if(actual instanceof Number){ actual = TypeUtil.parseOrCast(DataType.FLOAT, actual); expected = TypeUtil.parseOrCast(DataType.FLOAT, expected); } return super.doEquivalent(expected, actual); } }
@Override public boolean doEquivalent(Object expected, Object actual){ if(actual instanceof Computable){ actual = EvaluatorUtil.decode(actual); } // End if if(actual instanceof Number){ actual = TypeUtil.parseOrCast(DataType.FLOAT, actual); expected = TypeUtil.parseOrCast(DataType.FLOAT, expected); } return super.doEquivalent(expected, actual); } }
static protected EvaluationResponse evaluate(Evaluator evaluator, EvaluationRequest request){ logger.info("Received {}", request); Map<String, ?> requestArguments = request.getArguments(); EvaluationResponse response = new EvaluationResponse(request.getId()); Map<FieldName, FieldValue> arguments = new LinkedHashMap<>(); List<InputField> inputFields = evaluator.getInputFields(); for(InputField inputField : inputFields){ FieldName inputName = inputField.getName(); String key = inputName.getValue(); Object value = requestArguments.get(key); if(value == null && !requestArguments.containsKey(key)){ logger.warn("Evaluation request {} does not specify an input field {}", request.getId(), key); } FieldValue inputValue = inputField.prepare(value); arguments.put(inputName, inputValue); } logger.debug("Evaluation request {} has prepared arguments: {}", request.getId(), arguments); Map<FieldName, ?> results = evaluator.evaluate(arguments); // Jackson does not support the JSON serialization of <code>null</code> map keys results = replaceNullKey(results); logger.debug("Evaluation response {} has result: {}", response.getId(), results); response.setResults(EvaluatorUtil.decode(results)); logger.info("Returned {}", response); return response; }
@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 Result evaluate(Map<Descriptor, ?> values) throws Exception { org.jpmml.evaluator.Evaluator evaluator = (org.jpmml.evaluator.Evaluator) getModelManager(); Map<FieldName, org.jpmml.evaluator.FieldValue> arguments = new LinkedHashMap<FieldName, org.jpmml.evaluator.FieldValue>(); Map<FieldName, DataField> dataFieldMap = new LinkedHashMap<FieldName, DataField>(); List<Descriptor> descriptors = getDescriptors(); for(Descriptor descriptor : descriptors){ FieldName field = FieldNameUtil.encodeDescriptor(descriptor); DataField dataField = dataFieldMap.get(field); if(dataField == null){ dataField = evaluator.getDataField(field); // For compatibility with generic PMML producer software if(dataField == null){ field = new FieldName(descriptor.getId()); dataField = evaluator.getDataField(field); } // End if if(dataField == null){ throw new IllegalArgumentException(); } dataFieldMap.put(field, dataField); } Object value = values.get(descriptor); org.jpmml.evaluator.FieldValue fieldValue = EvaluatorUtil.prepare(evaluator, field, value); arguments.put(field, fieldValue); } Map<FieldName, ?> result = evaluator.evaluate(arguments); Object targetValue = result.get(evaluator.getTargetField()); return new Result(EvaluatorUtil.decode(targetValue), values); }
@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); }
actual = EvaluatorUtil.decode(actual);
actual = EvaluatorUtil.decode(actual);
Object targetValue = EvaluatorUtil.decode(segmentResult.getTargetValue());
verify(record.get(name), EvaluatorUtil.decode(results.get(name)), verificationField.getPrecision(), verificationField.getZeroThreshold());
Object targetValue = EvaluatorUtil.decode(segmentResult.getTargetValue());