Java EvaluatorUtil类代码示例

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Map<FieldName, FieldValue> loadPrimitiveList(Evaluator evaluator, Tuple tuple) throws ExecException {
	Map<FieldName, FieldValue> result = Maps.newLinkedHashMap();

	List<FieldName> activeFields = evaluator.getActiveFields();
	if(activeFields.size() != tuple.size()){
		throw new ExecException();
	}

	int i = 0;

	for(FieldName activeField : activeFields){
		Object object = tuple.get(i);

		FieldValue value = EvaluatorUtil.prepare(evaluator, activeField, object);

		result.put(activeField, value);

		i++;
	}

	return result;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Tuple storeResult(Evaluator evaluator, Map<FieldName, ?> result){
	List<Object> values = Lists.newArrayList();

	List<FieldName> targetFields = evaluator.getTargetFields();
	for(FieldName targetField : targetFields){
		values.add(EvaluatorUtil.decode(result.get(targetField)));
	}

	List<FieldName> outputFields = evaluator.getOutputFields();
	for(FieldName outputField : outputFields){
		values.add(result.get(outputField));
	}

	TupleFactory tupleFactory = TupleFactory.getInstance();

	return tupleFactory.newTuple(values);
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Object[] storeStruct(Evaluator evaluator, Map<FieldName, ?> result){
	List<Object> resultStruct = Lists.newArrayList();

	List<FieldName> targetFields = evaluator.getTargetFields();
	for(FieldName targetField : targetFields){
		resultStruct.add(EvaluatorUtil.decode(result.get(targetField)));
	}

	List<FieldName> outputFields = evaluator.getOutputFields();
	for(FieldName outputField : outputFields){
		resultStruct.add(result.get(outputField));
	}

	return resultStruct.toArray(new Object[resultStruct.size()]);
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Map<FieldName, FieldValue> loadStruct(Evaluator evaluator, ResultSet request) throws SQLException {
	Map<FieldName, FieldValue> result = Maps.newLinkedHashMap();

	Map<String, Integer> columns = parseColumns(request);

	Iterable<FieldName> fields = evaluator.getActiveFields();
	for(FieldName field : fields){
		String label = normalize(field.getValue());

		Integer column = columns.get(label);
		if(column == null){
			continue;
		}

		FieldValue value = EvaluatorUtil.prepare(evaluator, field, request.getObject(column));

		result.put(field, value);
	}

	return result;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Map<FieldName, FieldValue> loadScalarList(Evaluator evaluator, List<?> request){
	Map<FieldName, FieldValue> result = Maps.newLinkedHashMap();

	List<FieldName> fields = evaluator.getActiveFields();
	if(fields.size() != request.size()){
		throw new IllegalArgumentException("Invalid number of arguments");
	}

	int i = 0;

	for(FieldName field : fields){
		FieldValue value = EvaluatorUtil.prepare(evaluator, field, request.get(i));

		result.put(field, value);

		i++;
	}

	return result;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private void storeResult(Evaluator evaluator, Map<FieldName, ?> result, ResultSet response) throws SQLException {
	Map<String, Integer> columns = parseColumns(response);

	Iterable<FieldName> fields = Iterables.concat(evaluator.getTargetFields(), evaluator.getOutputFields());
	for(FieldName field : fields){
		String label = normalize(field.getValue());

		Integer column = columns.get(label);
		if(column == null){
			continue;
		}

		Object value = EvaluatorUtil.decode(result.get(field));
		if(value != null){
			response.updateObject(column, value);
		} else

		{
			response.updateNull(column);
		}
	}
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
@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);
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
private boolean evaluateJPMMLModel(Evaluator evaluator, double[] inputValues) {
  boolean prediction = false;
  Map<FieldName, ?> arguments = prepareArguments(evaluator, inputValues);
  Map<FieldName, ?> result = evaluator.evaluate(arguments);
  ArrayList<FieldName> predictedFields = new ArrayList<FieldName>(evaluator.getPredictedFields());
  FieldName predictedField = predictedFields.get(0); // we are predicting only one field here
  //DataField dataField = evaluator.getDataField(predictedField); //only need for debug output
  Object predictedValue = result.get(predictedField);
  if (EvaluatorUtil.decode(predictedValue).equals("yes")) {
    prediction = true;
  }
  return prediction;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
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);
    }
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
@Override
public void execute(Tuple tuple){
	Evaluator evaluator = getEvaluator();

	Map<FieldName, FieldValue> arguments = new LinkedHashMap<>();

	List<FieldName> activeFields = evaluator.getActiveFields();
	for(FieldName activeField : activeFields){
		FieldValue value = EvaluatorUtil.prepare(evaluator, activeField, tuple.getValueByField(activeField.getValue()));

		arguments.put(activeField, value);
	}

	Map<FieldName, ?> result = evaluator.evaluate(arguments);

	Values values = new Values();

	List<FieldName> targetFields = evaluator.getTargetFields();
	for(FieldName targetField : targetFields){
		Object targetValue = result.get(targetField);

		values.add(EvaluatorUtil.decode(targetValue));
	}

	List<FieldName> outputFields = evaluator.getOutputFields();
	for(FieldName outputField : outputFields){
		Object outputValue = result.get(outputField);

		values.add(outputValue);
	}

	OutputCollector collector = getCollector();

	collector.emit(tuple, values);
	collector.ack(tuple);
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
public <V extends Number> ValueMap<String, V> aggregateVotes(final ValueFactory<V> valueFactory, List<SegmentResult> segmentResults, Segmentation.MultipleModelMethod multipleModelMethod){
	VoteAggregator<String, V> aggregator = new VoteAggregator<String, V>(){

		@Override
		public ValueFactory<V> getValueFactory(){
			return valueFactory;
		}
	};

	for(SegmentResult segmentResult : segmentResults){
		String key;

		try {
			Object targetValue = EvaluatorUtil.decode(segmentResult.getTargetValue());

			key = (String)TypeUtil.cast(DataType.STRING, targetValue);
		} catch(TypeCheckException tce){
			throw tce.ensureContext(segmentResult.getSegment());
		}

		switch(multipleModelMethod){
			case MAJORITY_VOTE:
				aggregator.add(key);
				break;
			case WEIGHTED_MAJORITY_VOTE:
				double weight = segmentResult.getWeight();

				aggregator.add(key, weight);
				break;
			default:
				throw new IllegalArgumentException();
		}
	}

	return aggregator.sumMap();
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private Map<FieldName, FieldValue> decodeArguments(Evaluator evaluator, TupleEntry tuple){
	Map<FieldName, FieldValue> result = new LinkedHashMap<>();

	Fields fields = tuple.getFields();

	for(int i = 0; i < fields.size(); i++){
		FieldName key = FieldName.create((String)fields.get(i));
		Object value = tuple.getObject(key.getValue());

		result.put(key, EvaluatorUtil.prepare(evaluator, key, value));
	}

	return result;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
private TupleEntry encodeResult(Evaluator evaluator, Fields fields, Map<FieldName, ?> map){
	TupleEntry result = new TupleEntry(fields, Tuple.size(fields.size()));

	for(int i = 0; i < fields.size(); i++){
		FieldName key = FieldName.create((String)fields.get(i));
		Object value = map.get(key);

		result.setRaw(key.getValue(), EvaluatorUtil.decode(value));
	}

	return result;
}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
@Override
public Tuple exec(Tuple input) throws IOException {

	// check
	int dummy = 0;
	
	// Initialize Evaluator if null:
	if (this.evaluator == null) {
		try {
			System.out.println("Initializing: "+(dummy++)+" time");
			Schema inputSchema = getInputSchema();
			this.initialize(inputSchema);			// something to check
		} catch (Throwable t) {
			throw new RuntimeException("Backend: Unable to initialize PMML file: ",t);
		}
	}

	// Initialize Output as Input
	Tuple outputTuple = tf.newTuple(this.predictedFields.size() + this.outputFields.size());

	/* ************************
	// BLOCK: Prepare Data
	************************* */
	
	for(FieldName inputField : this.activeFields){

		// Get Object
		Object origBodyCell = (Object) input.get(aliasMap.get(inputField.getValue().toLowerCase()));
		
		Object bodyCell;
		if (origBodyCell instanceof Long) {
			bodyCell = ((Long) origBodyCell).doubleValue();
		} else {
			bodyCell = origBodyCell;
		}

		// Prepare Object for Scoring
		this.preparedRow.put(inputField, EvaluatorUtil.prepare(this.evaluator, inputField, bodyCell));

		// Prepare Object for Scoring
		// CC: Removed this b/c I think the "Long" check above resolves any issues.
		/*
		try {
			this.preparedRow.put(inputField, EvaluatorUtil.prepare(this.evaluator, inputField, bodyCell));
		} catch (Throwable t) {
        	System.err.println("Unable to prepare record, Trouble Parsing: " + inputField.toString() + " (value="+ bodyCell+")");
        	System.err.println(t);
            throw new RuntimeException(t);
		}
		*/

	}

	// Score Data
	Map<FieldName, ?> result = evaluator.evaluate(this.preparedRow);

	// Append Predicted Fields
	int i = 0;
	for(FieldName predictedField : this.predictedFields){
		outputTuple.set(i++,EvaluatorUtil.decode(result.get(predictedField)));
	}

	for(FieldName outputField : this.outputFields){
		outputTuple.set(i++,EvaluatorUtil.decode(result.get(outputField)));
	}

	// Return Tuple:
	return outputTuple;

}
 

import org.jpmml.evaluator.EvaluatorUtil; //导入依赖的package包/类
static
public Object evaluateSimple(Class<?> clazz, Tuple tuple) throws IOException {

	if(tuple == null){
		return null;
	}

	Evaluator evaluator = getEvaluator(clazz);

	Map<FieldName, FieldValue> arguments = loadArguments(evaluator, tuple);

	Map<FieldName, ?> result = evaluator.evaluate(arguments);

	Object targetValue = result.get(evaluator.getTargetField());

	return EvaluatorUtil.decode(targetValue);
}