Java FieldValue类代码示例

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

	if(tuple.size() == 1){
		byte type = tuple.getType(0);

		switch(type){
			case DataType.TUPLE:
				return loadPrimitiveList(evaluator, (Tuple)tuple.get(0));
			default:
				break;
		}
	}

	return loadPrimitiveList(evaluator, tuple);
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的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.FieldValue; //导入依赖的package包/类
static
private Map<FieldName, FieldValue> loadArguments(Evaluator evaluator, ObjectInspector[] inspectors, GenericUDF.DeferredObject[] objects) throws HiveException {

	if(inspectors.length == 1){
		ObjectInspector inspector = inspectors[0];

		ObjectInspector.Category category = inspector.getCategory();
		switch(category){
			case STRUCT:
				return loadStruct(evaluator, inspectors[0], objects[0]);
			default:
				return loadPrimitiveList(evaluator, inspectors, objects);
		}
	}

	return loadPrimitiveList(evaluator, inspectors, objects);
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的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.FieldValue; //导入依赖的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.FieldValue; //导入依赖的package包/类
static
private BaselineStratum getBaselineStratum(BaseCumHazardTables baseCumHazardTables, FieldValue value){

	if(baseCumHazardTables instanceof HasParsedValueMapping){
		HasParsedValueMapping<?> hasParsedValueMapping = (HasParsedValueMapping<?>)baseCumHazardTables;

		return (BaselineStratum)value.getMapping(hasParsedValueMapping);
	}

	List<BaselineStratum> baselineStrata = baseCumHazardTables.getBaselineStrata();
	for(BaselineStratum baselineStratum : baselineStrata){
		String category = baselineStratum.getValue();
		if(category == null){
			throw new MissingAttributeException(baselineStratum, PMMLAttributes.BASELINESTRATUM_VALUE);
		} // End if

		if(value.equalsString(category)){
			return baselineStratum;
		}
	}

	return null;
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public <V extends Number> Value<V> updateProduct(Value<V> product, FieldValue value){
	Matrix matrix = getMatrix();

	int row = getIndex(value);
	int column = getIndex(getCategory());
	if(row < 0 || column < 0){
		PPCell ppCell = getPPCell();

		throw new InvalidElementException(ppCell);
	}

	Number result = MatrixUtil.getElementAt(matrix, row + 1, column + 1);
	if(result == null){
		throw new InvalidElementException(matrix);
	}

	return product.multiply(result.doubleValue());
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
private Function<Integer, String> createIdentifierResolver(final FieldName name, final Table<Integer, FieldName, FieldValue> table){
	Function<Integer, String> function = new Function<Integer, String>(){

		@Override
		public String apply(Integer row){
			FieldValue value = table.get(row, name);
			if(value == null){
				throw new MissingValueException(name);
			}

			return value.asString();
		}
	};

	return function;
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
static
private Map<Integer, BitSet> loadInstanceFlags(NearestNeighborModelEvaluator modelEvaluator){
	Map<Integer, BitSet> result = new LinkedHashMap<>();

	Map<Integer, List<FieldValue>> valueMap = modelEvaluator.getValue(NearestNeighborModelEvaluator.instanceValueCache, createInstanceValueLoader(modelEvaluator));

	Maps.EntryTransformer<Integer, List<FieldValue>, BitSet> transformer = new Maps.EntryTransformer<Integer, List<FieldValue>, BitSet>(){

		@Override
		public BitSet transformEntry(Integer key, List<FieldValue> value){
			return MeasureUtil.toBitSet(value);
		}
	};
	result.putAll(Maps.transformEntries(valueMap, transformer));

	return result;
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public FieldValue evaluate(List<FieldValue> arguments){
	checkArguments(arguments, 2, true);

	FieldValue left = arguments.get(0);
	FieldValue right = arguments.get(1);

	// "If one of the input fields of a simple arithmetic function is a missing value, then the result evaluates to missing value"
	if(left == null || right == null){
		return null;
	}

	DataType dataType = TypeUtil.getResultDataType(left.getDataType(), right.getDataType());

	Number result;

	try {
		result = evaluate(left.asNumber(), right.asNumber());
	} catch(ArithmeticException ae){
		throw new UndefinedResultException()
			.initCause(ae);
	}

	return FieldValueUtil.create(dataType, OpType.CONTINUOUS, result);
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public FieldValue evaluate(List<FieldValue> arguments){
	checkArguments(arguments, 2);

	int length = (arguments.get(0)).asInteger();
	if(length < 0){
		throw new FunctionException(this, "Invalid length value " + length);
	}

	String string = (arguments.get(1)).asString();

	// Trim leading whitespace characters (but keep trailing whitespace characters)
	string = CharMatcher.WHITESPACE.trimLeadingFrom(string);

	// Truncate to a fixed length
	string = string.substring(0, Math.min(length, string.length()));

	// Convert to all uppercase characters
	string = string.toUpperCase();

	return FieldValueUtil.create(DataType.STRING, OpType.CATEGORICAL, string);
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
private Map<FieldValue, TargetValueCounts> parsePairCounts(DataType dataType, OpType opType){
	Map<FieldValue, TargetValueCounts> result = new LinkedHashMap<>();

	List<PairCounts> pairCounts = getPairCounts();
	for(PairCounts pairCount : pairCounts){
		FieldValue value = FieldValueUtil.create(dataType, opType, pairCount.getValue());

		TargetValueCounts targetValueCounts = pairCount.getTargetValueCounts();
		if(targetValueCounts == null){
			throw new MissingElementException(pairCount, PMMLElements.PAIRCOUNTS_TARGETVALUECOUNTS);
		}

		result.put(value, targetValueCounts);
	}

	return result;
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public FieldValue evaluate(List<FieldValue> arguments){

	if(arguments.size() < 1 || arguments.size() > 2){
		throw new FunctionException(this, "Expected 1 or 2 arguments, got " + arguments.size() + " arguments");
	} // End if

	if(arguments.contains(null)){
		throw new FunctionException(this, "Missing arguments");
	}

	Collection<?> values = FieldValueUtil.getValue(Collection.class, arguments.get(0));

	Boolean biasCorrected = Boolean.FALSE;
	if(arguments.size() > 1){
		biasCorrected = (arguments.get(1)).asBoolean();
	}

	Double result = evaluate(values, biasCorrected);

	return FieldValueUtil.create(DataType.DOUBLE, OpType.CONTINUOUS, result);
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public Data process(Data data) {

    for (InputField activeField : activeFields) {

        Object rawValue = data.get(activeField.toString());

        // The raw value is passed through: type conversion or any other transofrmations applied in sklearn
        FieldValue activeValue = activeField.prepare(rawValue);

        FieldName activeFieldName = activeField.getName();

        arguments.put(activeFieldName, activeValue);
    }

    Map<FieldName, ?> results = modelEvaluator.evaluate(arguments);

    Object targetValue = results.get(targetName);

    log.info("Prediction: " + targetValue);
    try {
        data.put(targetName.getValue(), (Serializable) targetValue);
    } catch (ClassCastException e) {
        log.warn("Cannot cast target type to serializable type");
        data.put(targetName.getValue(), targetValue.toString());
    }

    return data;
}
 

import org.jpmml.evaluator.FieldValue; //导入依赖的package包/类
@Override
public Map<String, List<Object>> scoredTuplePerStream(Tuple input) {
    final Map<FieldName, Object> rawInputs = extractRawInputs(input);
    final Map<FieldName, FieldValue> preProcInputs = preProcessInputs(rawInputs);
    final Map<FieldName, ?> predScores = predictScores(preProcInputs);

    return toStreamLineEvents(predScores, input);
}