org.dmg.pmml.OutputField Java Examples

@Override
public List<OutputField> registerOutputFields(Label label, Model pmmlModel, SparkMLEncoder encoder){
	GeneralizedLinearRegressionModel model = getTransformer();

	List<OutputField> result = super.registerOutputFields(label, pmmlModel, encoder);

	MiningFunction miningFunction = getMiningFunction();
	switch(miningFunction){
		case CLASSIFICATION:
			CategoricalLabel categoricalLabel = (CategoricalLabel)label;

			result = new ArrayList<>(result);
			result.addAll(ModelUtil.createProbabilityFields(DataType.DOUBLE, categoricalLabel.getValues()));
			break;
		default:
			break;
	}

	return result;
}
 

@Override
public VisitorAction visit(Output output){

	if(output.hasOutputFields()){
		List<OutputField> outputFields = output.getOutputFields();

		for(ListIterator<OutputField> it = outputFields.listIterator(); it.hasNext(); ){
			OutputField outputField = it.next();

			if(outputField.hasValues()){
				it.set(new RichOutputField(outputField));
			}
		}
	}

	return super.visit(output);
}
 

@Override
public VisitorAction visit(OutputField outputField){
	ResultFeature resultFeature = outputField.getResultFeature();

	switch(resultFeature){
		case PROBABILITY:
		case CONFIDENCE:
		case AFFINITY:
			{
				outputField.setValue(parseTargetValue(outputField.getTargetField(), outputField.getValue()));
			}
			break;
		default:
			break;
	}

	return super.visit(outputField);
}
 

static
private String getEntityId(Object object, OutputField outputField){
	HasEntityId hasEntityId = TypeUtil.cast(HasEntityId.class, object);

	int rank = outputField.getRank();
	if(rank <= 0){
		throw new InvalidAttributeException(outputField, PMMLAttributes.OUTPUTFIELD_RANK, rank);
	} // End if

	if(rank > 1){
		HasEntityIdRanking hasEntityIdRanking = TypeUtil.cast(HasEntityIdRanking.class, object);

		OutputField.RankOrder rankOrder = outputField.getRankOrder();
		switch(rankOrder){
			case DESCENDING:
				break;
			default:
				throw new UnsupportedAttributeException(outputField, rankOrder);
		}

		return getElement(hasEntityIdRanking.getEntityIdRanking(), rank);
	}

	return hasEntityId.getEntityId();
}
 

static
private Field<?> resolveField(FieldName name, MiningModelEvaluationContext context){

	while(context != null){
		OutputField outputField = context.getOutputField(name);
		if(outputField != null){
			return outputField;
		}

		DerivedField localDerivedField = context.getLocalDerivedField(name);
		if(localDerivedField != null){
			return localDerivedField;
		}

		context = context.getParent();
	}

	return null;
}
 

@Test
public void getGetterMethods(){
	Map<Field, Method> getterMethods = ReflectionUtil.getGetterMethods(OutputField.class);

	assertEquals(1 /* PMMLObject */ + 20 /* OutputField */, getterMethods.size());

	try {
		Field field = OutputField.class.getDeclaredField("DEFAULT_RANK");

		ReflectionUtil.getGetterMethod(field);

		fail();
	} catch(ReflectiveOperationException roe){
		fail();
	} catch(RuntimeException re){
		// Ignored
	}
}
 

private List<MLModelField> doGetOutputFieldsForPMMLStream(String pmmlContents) throws SAXException, JAXBException, UnsupportedEncodingException {
    List<MLModelField> fieldNames = new ArrayList<>();
    PMMLManager pmmlManager = new PMMLManager(IOUtil.unmarshal(new ByteArrayInputStream(pmmlContents.getBytes("UTF-8"))));
    Evaluator modelEvaluator = (ModelEvaluator<?>) pmmlManager.getModelManager(null, ModelEvaluatorFactory.getInstance());
    modelEvaluator.getPredictedFields().forEach((f) -> fieldNames.add(getModelField(modelEvaluator.getDataField(f))));

    modelEvaluator.getOutputFields().forEach((f) -> {
        OutputField outputField = modelEvaluator.getOutputField(f);
        ResultFeatureType resultFeatureType = outputField.getFeature();
        if (resultFeatureType != ResultFeatureType.PREDICTED_VALUE &&
                resultFeatureType != ResultFeatureType.PREDICTED_DISPLAY_VALUE) {
            fieldNames.add(getModelField(outputField));
        }
    });

    return fieldNames;
}
 

private List<MLModelField> doGetOutputFieldsForPMMLStream(String pmmlContents) throws SAXException, JAXBException {
    List<MLModelField> fieldNames = new ArrayList<>();
    PMMLManager pmmlManager = new PMMLManager(IOUtil.unmarshal(new ByteArrayInputStream(pmmlContents.getBytes())));
    Evaluator modelEvaluator = (ModelEvaluator<?>) pmmlManager.getModelManager(null, ModelEvaluatorFactory.getInstance());
    modelEvaluator.getPredictedFields().forEach((f) -> fieldNames.add(getModelField(modelEvaluator.getDataField(f))));

    modelEvaluator.getOutputFields().forEach((f) -> {
        OutputField outputField = modelEvaluator.getOutputField(f);
        ResultFeatureType resultFeatureType = outputField.getFeature();
        if (resultFeatureType != ResultFeatureType.PREDICTED_VALUE &&
                resultFeatureType != ResultFeatureType.PREDICTED_DISPLAY_VALUE) {
            fieldNames.add(getModelField(outputField));
        }
    });

    return fieldNames;
}
 

@Override
public SupportVectorMachineModel encodeModel(Schema schema){
	Transformation outlier = new OutlierTransformation(){

		@Override
		public Expression createExpression(FieldRef fieldRef){
			return PMMLUtil.createApply(PMMLFunctions.LESSOREQUAL, fieldRef, PMMLUtil.createConstant(0d));
		}
	};

	SupportVectorMachineModel supportVectorMachineModel = super.encodeModel(schema)
		.setOutput(ModelUtil.createPredictedOutput(FieldName.create("decisionFunction"), OpType.CONTINUOUS, DataType.DOUBLE, outlier));

	Output output = supportVectorMachineModel.getOutput();

	List<OutputField> outputFields = output.getOutputFields();
	if(outputFields.size() != 2){
		throw new IllegalArgumentException();
	}

	OutputField decisionFunctionOutputField = outputFields.get(0);

	if(!decisionFunctionOutputField.isFinalResult()){
		decisionFunctionOutputField.setFinalResult(true);
	}

	return supportVectorMachineModel;
}
 

@Override
public Feature apply(Model model){
    Output output = model.getOutput();

    if(output == null || !output.hasOutputFields()){
        throw new IllegalArgumentException();
    }

    OutputField outputField = Iterables.getLast(output.getOutputFields());

    return new ContinuousFeature(null, outputField.getName(), outputField.getDataType());
}
 

@Override
public VisitorAction visit(OutputField outputField){
	ResultFeature resultFeature = outputField.getResultFeature();

	switch(resultFeature){
		case TRANSFORMED_VALUE:
		case DECISION:
			{
				String segmentId = outputField.getSegmentId();

				if(segmentId != null){
					Object value = outputField.getValue();

					if(value instanceof String){
						value = filter((String)value);
					}

					outputField.setValue(value);
				}
			}
			break;
		default:
			break;
	}

	return super.visit(outputField);
}
 

void putOutputField(FieldName name, OutputField outputField){

		if(this.outputFields == null){
			this.outputFields = new HashMap<>();
		}

		this.outputFields.put(name, outputField);
	}
 

public OutputField getOutputField(FieldName name){

		if(this.outputFields == null){
			return null;
		}

		return this.outputFields.get(name);
	}
 

@Override
public VisitorAction visit(OutputField outputField){
	ResultFeature resultFeature = outputField.getResultFeature();

	switch(resultFeature){
		case STANDARD_ERROR:
			report(new UnsupportedAttributeException(outputField, resultFeature));
			break;
		default:
			break;
	}

	return super.visit(outputField);
}
 

static
private Double getProbability(Object object, OutputField outputField){
	HasProbability hasProbability = TypeUtil.cast(HasProbability.class, object);

	Object value = getCategoryValue(object, outputField);

	return hasProbability.getProbability(value);
}
 

static
private Double getConfidence(Object object, OutputField outputField){
	HasConfidence hasConfidence = TypeUtil.cast(HasConfidence.class, object);

	Object value = getCategoryValue(object, outputField);

	return hasConfidence.getConfidence(value);
}
 

static
private Object getCategoryValue(Object object, OutputField outputField){
	Object value = outputField.getValue();

	// "If the value attribute is not specified, then the predicted categorical value should be returned as a result"
	if(value == null){
		return getPredictedValue(object);
	}

	return value;
}
 

static
public Double getAffinity(Object object, OutputField outputField){
	HasAffinity hasAffinity = TypeUtil.cast(HasAffinity.class, object);

	int rank = outputField.getRank();
	if(rank <= 0){
		throw new InvalidAttributeException(outputField, PMMLAttributes.OUTPUTFIELD_RANK, rank);
	} // End if

	if(rank > 1){
		HasAffinityRanking hasAffinityRanking = TypeUtil.cast(HasAffinityRanking.class, object);

		OutputField.RankOrder rankOrder = outputField.getRankOrder();
		switch(rankOrder){
			case DESCENDING:
				break;
			default:
				throw new UnsupportedAttributeException(outputField, rankOrder);
		}

		return getElement(hasAffinityRanking.getAffinityRanking(), rank);
	}

	Object value = getCategoryValue(object, outputField);

	value = TypeUtil.format(value);

	return hasAffinity.getAffinity((String)value);
}
 

static
public String getReasonCode(Object object, OutputField outputField){
	HasReasonCodeRanking hasReasonCodeRanking = TypeUtil.cast(HasReasonCodeRanking.class, object);

	int rank = outputField.getRank();
	if(rank <= 0){
		throw new InvalidAttributeException(outputField, PMMLAttributes.OUTPUTFIELD_RANK, rank);
	}

	return getElement(hasReasonCodeRanking.getReasonCodeRanking(), rank);
}
 

@Override
public boolean test(OutputField outputField){
	return outputField.isFinalResult();
}
 

@Override
public boolean test(OutputField outputField){
	return true;
}
 

@Override
public List<OutputField> registerOutputFields(Label label, org.dmg.pmml.Model pmmlModel, SparkMLEncoder encoder){
	T model = getTransformer();

	List<Integer> clusters = LabelUtil.createTargetCategories(getNumberOfClusters());

	String predictionCol = model.getPredictionCol();

	OutputField pmmlPredictedOutputField = ModelUtil.createPredictedField(FieldName.create("pmml(" + predictionCol + ")"), OpType.CATEGORICAL, DataType.STRING)
		.setFinalResult(false);

	DerivedOutputField pmmlPredictedField = encoder.createDerivedField(pmmlModel, pmmlPredictedOutputField, true);

	OutputField predictedOutputField = new OutputField(FieldName.create(predictionCol), OpType.CATEGORICAL, DataType.INTEGER)
		.setResultFeature(ResultFeature.TRANSFORMED_VALUE)
		.setExpression(new FieldRef(pmmlPredictedField.getName()));

	DerivedOutputField predictedField = encoder.createDerivedField(pmmlModel, predictedOutputField, true);

	encoder.putOnlyFeature(predictionCol, new IndexFeature(encoder, predictedField, clusters));

	return Collections.emptyList();
}
 

@SuppressWarnings (
	value = {"unchecked"}
)
static
private Object getRuleFeature(HasRuleValues hasRuleValues, AssociationRule associationRule, OutputField outputField, OutputField.RuleFeature ruleFeature){

	switch(ruleFeature){
		case ANTECEDENT:
			return getItemValues(hasRuleValues, associationRule.getAntecedent());
		case CONSEQUENT:
			return getItemValues(hasRuleValues, associationRule.getConsequent());
		case RULE:
			{
				Joiner joiner = Joiner.on(',');

				StringBuilder sb = new StringBuilder();

				String left = joiner.join(getItemValues(hasRuleValues, associationRule.getAntecedent()));
				sb.append('{').append(left).append('}');

				sb.append("->");

				String right = joiner.join(getItemValues(hasRuleValues, associationRule.getConsequent()));
				sb.append('{').append(right).append('}');

				return sb.toString();
			}
		case RULE_ID:
			{
				HasEntityRegistry<AssociationRule> hasEntityRegistry = (HasEntityRegistry<AssociationRule>)hasRuleValues;

				return EntityUtil.getId(associationRule, hasEntityRegistry);
			}
		case CONFIDENCE:
			return associationRule.getConfidence();
		case SUPPORT:
			return associationRule.getSupport();
		case LIFT:
			return associationRule.getLift();
		case LEVERAGE:
			return associationRule.getLeverage();
		case AFFINITY:
			return associationRule.getAffinity();
		default:
			throw new UnsupportedAttributeException(outputField, ruleFeature);
	}
}
 

static
public Object getRuleValue(Object object, OutputField outputField){
	return getRuleValue(object, outputField, outputField.getRuleFeature());
}
 

public List<OutputField> registerOutputFields(Label label, org.dmg.pmml.Model model, SparkMLEncoder encoder){
	return null;
}
 

public org.dmg.pmml.Model registerModel(SparkMLEncoder encoder){
	Schema schema = encodeSchema(encoder);

	Label label = schema.getLabel();

	org.dmg.pmml.Model model = encodeModel(schema);

	List<OutputField> sparkOutputFields = registerOutputFields(label, model, encoder);
	if(sparkOutputFields != null && sparkOutputFields.size() > 0){
		org.dmg.pmml.Model finalModel = MiningModelUtil.getFinalModel(model);

		Output output = ModelUtil.ensureOutput(finalModel);

		List<OutputField> outputFields = output.getOutputFields();

		outputFields.addAll(sparkOutputFields);
	}

	return model;
}
 

public RichOutputField(OutputField outputField){
	ReflectionUtil.copyState(outputField, this);
}
 

@Override
public List<OutputField> registerOutputFields(Label label, Model pmmlModel, SparkMLEncoder encoder){
	T model = getTransformer();

	String predictionCol = model.getPredictionCol();

	Boolean keepPredictionCol = (Boolean)getOption(HasPredictionModelOptions.OPTION_KEEP_PREDICTIONCOL, Boolean.TRUE);

	OutputField predictedOutputField = ModelUtil.createPredictedField(FieldName.create(predictionCol), OpType.CONTINUOUS, label.getDataType());

	DerivedOutputField predictedField = encoder.createDerivedField(pmmlModel, predictedOutputField, keepPredictionCol);

	encoder.putOnlyFeature(predictionCol, new ContinuousFeature(encoder, predictedField));

	return Collections.emptyList();
}
 

@Test
public void inspectFieldAnnotations(){
	PMML pmml = createPMML();

	AssociationModel model = new AssociationModel();

	pmml.addModels(model);

	assertVersionRange(pmml, Version.PMML_3_0, Version.PMML_4_4);

	Output output = new Output();

	model.setOutput(output);

	assertVersionRange(pmml, Version.PMML_4_0, Version.PMML_4_4);

	model.setScorable(Boolean.FALSE);

	assertVersionRange(pmml, Version.PMML_4_1, Version.PMML_4_4);

	model.setScorable(null);

	assertVersionRange(pmml, Version.PMML_4_0, Version.PMML_4_4);

	OutputField outputField = new OutputField()
		.setRuleFeature(OutputField.RuleFeature.AFFINITY);

	output.addOutputFields(outputField);

	assertVersionRange(pmml, Version.PMML_4_1, Version.PMML_4_2);

	outputField.setDataType(DataType.DOUBLE);

	assertVersionRange(pmml, Version.PMML_4_1, Version.PMML_4_4);

	model.setOutput(null);

	assertVersionRange(pmml, Version.PMML_3_0, Version.PMML_4_4);
}
 

@Override
public List<OutputField> registerOutputFields(Label label, Model pmmlModel, SparkMLEncoder encoder){
	T model = getTransformer();

	CategoricalLabel categoricalLabel = (CategoricalLabel)label;

	List<Integer> categories = LabelUtil.createTargetCategories(categoricalLabel.size());

	String predictionCol = model.getPredictionCol();

	Boolean keepPredictionCol = (Boolean)getOption(HasPredictionModelOptions.OPTION_KEEP_PREDICTIONCOL, Boolean.TRUE);

	OutputField pmmlPredictedOutputField = ModelUtil.createPredictedField(FieldName.create("pmml(" + predictionCol + ")"), OpType.CATEGORICAL, categoricalLabel.getDataType())
		.setFinalResult(false);

	DerivedOutputField pmmlPredictedField = encoder.createDerivedField(pmmlModel, pmmlPredictedOutputField, keepPredictionCol);

	MapValues mapValues = PMMLUtil.createMapValues(pmmlPredictedField.getName(), categoricalLabel.getValues(), categories)
		.setDataType(DataType.DOUBLE);

	OutputField predictedOutputField = new OutputField(FieldName.create(predictionCol), OpType.CONTINUOUS, DataType.DOUBLE)
		.setResultFeature(ResultFeature.TRANSFORMED_VALUE)
		.setExpression(mapValues);

	DerivedOutputField predictedField = encoder.createDerivedField(pmmlModel, predictedOutputField, keepPredictionCol);

	encoder.putOnlyFeature(predictionCol, new IndexFeature(encoder, predictedField, categories));

	List<OutputField> result = new ArrayList<>();

	if(model instanceof HasProbabilityCol){
		HasProbabilityCol hasProbabilityCol = (HasProbabilityCol)model;

		String probabilityCol = hasProbabilityCol.getProbabilityCol();

		List<Feature> features = new ArrayList<>();

		for(int i = 0; i < categoricalLabel.size(); i++){
			Object value = categoricalLabel.getValue(i);

			OutputField probabilityField = ModelUtil.createProbabilityField(FieldName.create(probabilityCol + "(" + value + ")"), DataType.DOUBLE, value);

			result.add(probabilityField);

			features.add(new ContinuousFeature(encoder, probabilityField));
		}

		// XXX
		encoder.putFeatures(probabilityCol, features);
	}

	return result;
}