Java Code Examples for org.dmg.pmml.FieldName#getValue()

@Override
public DataField updateDataField(DataField dataField, OpType opType, DataType dataType, SkLearnEncoder encoder){
	FieldName name = dataField.getName();

	if(encoder.isFrozen(name)){
		throw new IllegalArgumentException("Field " + name.getValue() + " is frozen for type information updates");
	}

	dataField
		.setDataType(dataType)
		.setOpType(opType);

	encoder.setDomain(name, this);

	return dataField;
}
 

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);
    }
}
 

@Override
public void addDerivedField(DerivedField derivedField){

	try {
		super.addDerivedField(derivedField);
	} catch(RuntimeException re){
		FieldName name = derivedField.getName();

		String message = "Field " + name.getValue() + " is already defined. " +
			"Please refactor the pipeline so that it would not contain duplicate field declarations, " +
			"or use the " + (Alias.class).getName() + " wrapper class to override the default name with a custom name (eg. " + Alias.formatAliasExample() + ")";

		throw new IllegalArgumentException(message, re);
	}
}
 

public void renameFeature(Feature feature, FieldName renamedName){
	FieldName name = feature.getName();

	org.dmg.pmml.Field<?> pmmlField = getField(name);

	if(pmmlField instanceof DataField){
		throw new IllegalArgumentException("User input field " + name.getValue() + " cannot be renamed");
	}

	DerivedField derivedField = removeDerivedField(name);

	try {
		Field field = Feature.class.getDeclaredField("name");

		if(!field.isAccessible()){
			field.setAccessible(true);
		}

		field.set(feature, renamedName);
	} catch(ReflectiveOperationException roe){
		throw new RuntimeException(roe);
	}

	derivedField.setName(renamedName);

	addDerivedField(derivedField);
}
 

public Feature resolveFeature(FieldName name){
	Feature feature = getFeature(name);

	if(feature == null){
		throw new IllegalArgumentException(name.getValue());
	}

	return feature;
}
 

@Override
public String marshal(FieldName value){

	// FieldName corresponds to a simple type in PMML XML Schema. Hence, it is possible to encounter a null instance.
	if(value == null){
		return null;
	}

	return value.getValue();
}
 

static
public String formatKey(Object object){

	if(object instanceof FieldName){
		FieldName name = (FieldName)object;

		object = name.getValue();
	} // End if

	return format(object);
}
 

static
private List<Field> encodeModelFields(List<? extends ModelField> modelFields){
	Function<ModelField, Field> function = new Function<ModelField, Field>(){

		@Override
		public Field apply(ModelField modelField){
			org.dmg.pmml.Field<?> pmmlField = modelField.getField();

			FieldName name = modelField.getName();

			Field field = new Field(name.getValue());
			field.setName(modelField.getDisplayName());
			field.setOpType(modelField.getOpType());
			field.setDataType(modelField.getDataType());

			List<String> values = new ArrayList<>();

			if(pmmlField instanceof HasContinuousDomain){
				values.addAll(encodeContinuousDomain((org.dmg.pmml.Field & HasContinuousDomain)pmmlField));
			} // End if

			if(pmmlField instanceof HasDiscreteDomain){
				values.addAll(encodeDiscreteDomain((org.dmg.pmml.Field & HasDiscreteDomain)pmmlField));
			}

			field.setValues(values);

			return field;
		}
	};

	return modelFields.stream()
		.map(function)
		.collect(Collectors.toList());
}
 

private String filter(String value){
	FieldName name = FieldName.create(value);

	name = filter(name);

	return name.getValue();
}
 

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);

	logger.debug("Evaluation response {} has result: {}", response.getId(), results);

	response.setResults(EvaluatorUtil.decodeAll(results));

	logger.info("Returned {}", response);

	return response;
}