Java DerivedField.getExpression方法代码示例

import org.dmg.pmml.DerivedField; //导入方法依赖的package包/类
protected void fillPreProcessingSteps(DerivedField[] derivedFields) {

        int derivedFieldIndex = derivedFields.length - 1;
        // don't start at the beginning, we might have a pre processing step there already from the mining field
        for (int preProcessingStepIndex = preProcessingSteps.length - derivedFields.length; preProcessingStepIndex < preProcessingSteps
                .length;
             preProcessingStepIndex++) {
            DerivedField derivedField = derivedFields[derivedFieldIndex];
            if (derivedField.getExpression() != null) {
                handleExpression(preProcessingStepIndex, derivedField);

            } else {
                throw new UnsupportedOperationException("So far only Apply implemented.");
            }
            derivedFieldIndex--;
        }
    }
 

import org.dmg.pmml.DerivedField; //导入方法依赖的package包/类
private void handleExpression(int preProcessingStepIndex, DerivedField derivedField) {
    if (derivedField.getExpression() instanceof Apply) {
        for (Expression expression : ((Apply) derivedField.getExpression()).getExpressions()) {
            if (expression instanceof Apply) {
                if (((Apply) expression).getFunction().equals("isMissing")) {
                    // now find the value that is supposed to replace the missing value

                    for (Expression expression2 : ((Apply) derivedField.getExpression()).getExpressions()) {
                        if (expression2 instanceof Constant) {
                            String missingValue = ((Constant) expression2).getValue();
                            preProcessingSteps[preProcessingStepIndex] = new MissingValuePreProcess(derivedField, missingValue);
                            break;
                        }
                    }
                } else {
                    throw new UnsupportedOperationException("So far only if isMissing implemented.");
                }
            }
        }
    } else if (derivedField.getExpression() instanceof NormContinuous) {
        preProcessingSteps[preProcessingStepIndex] = new NormContinousPreProcess((NormContinuous) derivedField
                .getExpression(), derivedField.getName().getValue());
    } else {
        throw new UnsupportedOperationException("So far only Apply expression implemented.");
    }
}
 

import org.dmg.pmml.DerivedField; //导入方法依赖的package包/类
private static String getReferencedFieldName(DerivedField derivedField) {
    String referencedField = null;
    if (derivedField.getExpression() != null) {
        if (derivedField.getExpression() instanceof Apply) {
            // TODO throw uoe in case the function is not "if missing" - much more to implement!
            for (Expression expression : ((Apply) derivedField.getExpression()).getExpressions()) {
                if (expression instanceof FieldRef) {
                    referencedField = ((FieldRef) expression).getField().getValue();
                }
            }
        } else if (derivedField.getExpression() instanceof NormContinuous) {
            referencedField = ((NormContinuous) derivedField.getExpression()).getField().getValue();
        } else {
            throw new UnsupportedOperationException("So far only Apply expression implemented.");
        }
    } else {
        // there is a million ways in which derived fields can reference other fields.
        // need to implement them all!
        throw new UnsupportedOperationException("So far only implemented if function for derived fields.");
    }

    if (referencedField == null) {
        throw new UnsupportedOperationException("could not find raw field name. Maybe this derived field references another derived " +
                "field? Did not implement that yet.");
    }
    return referencedField;
}
 

import org.dmg.pmml.DerivedField; //导入方法依赖的package包/类
void assertTransformedFeature(Transformer transformer, String function){
	SkLearnEncoder encoder = new SkLearnEncoder();

	DataField dataField = encoder.createDataField(FieldName.create("x"));

	Feature inputFeature = new WildcardFeature(encoder, dataField);
	Feature outputFeature = Iterables.getOnlyElement(transformer.encodeFeatures(Collections.singletonList(inputFeature), encoder));

	assertNotSame(inputFeature, outputFeature);

	DerivedField derivedField = (DerivedField)encoder.getField(outputFeature.getName());

	Apply apply = (Apply)derivedField.getExpression();

	assertEquals(function, apply.getFunction());
}