org.dmg.pmml.MiningField Java Examples

@Test
public void testBuildMiningSchema() {
  MiningSchema miningSchema = AppPMMLUtils.buildMiningSchema(buildTestSchema());

  List<MiningField> miningFields = miningSchema.getMiningFields();
  assertEquals(4, miningFields.size());

  String[] fieldNames = { "foo", "bar", "baz", "bing" };
  for (int i = 0; i < fieldNames.length; i++) {
    assertEquals(fieldNames[i], miningFields.get(i).getName().getValue());
  }

  assertEquals(MiningField.UsageType.SUPPLEMENTARY, miningFields.get(0).getUsageType());
  assertEquals(MiningField.UsageType.PREDICTED, miningFields.get(1).getUsageType());
  assertEquals(MiningField.UsageType.SUPPLEMENTARY, miningFields.get(2).getUsageType());
  assertEquals(MiningField.UsageType.ACTIVE, miningFields.get(3).getUsageType());

  assertEquals(OpType.CATEGORICAL, miningFields.get(1).getOpType());
  assertEquals(OpType.CONTINUOUS, miningFields.get(3).getOpType());
}
 

static
public FieldValue prepareInputValue(Field<?> field, MiningField miningField, Object value){
	InputTypeInfo typeInfo = getTypeInfo(field, miningField);

	if(value instanceof Collection){
		Collection<?> rawValues = (Collection<?>)value;

		List<Object> pmmlValues = new ArrayList<>(rawValues.size());

		for(Object rawValue : rawValues){
			FieldValue fieldValue = prepareScalarInputValue(typeInfo, rawValue);

			pmmlValues.add(FieldValueUtil.getValue(fieldValue));
		}

		return createInputValue(typeInfo, pmmlValues);
	} else

	{
		return prepareScalarInputValue(typeInfo, value);
	}
}
 

static
private ScalarValue createInvalidInputValue(InputTypeInfo typeInfo, Object value){
	MiningField miningField = typeInfo.getMiningField();

	Object invalidValueReplacement = miningField.getInvalidValueReplacement();
	if(invalidValueReplacement != null){
		return (ScalarValue)createInputValue(typeInfo, invalidValueReplacement);
	}

	ScalarValue fieldValue = (ScalarValue)createInputValue(typeInfo, value);
	if(fieldValue.isValid()){
		fieldValue.setValid(false);
	}

	return fieldValue;
}
 

@Override
public VisitorAction visit(MiningField miningField){
	FieldName name = miningField.getName();
	if(name == null){
		throw new MissingAttributeException(miningField, PMMLAttributes.MININGFIELD_NAME);
	}

	DataType dataType = resolveDataType(name);
	if(dataType != null){
		Object missingValueReplacement = miningField.getMissingValueReplacement();
		if(missingValueReplacement != null){
			missingValueReplacement = safeParseOrCast(dataType, missingValueReplacement);

			miningField.setMissingValueReplacement(missingValueReplacement);
		}

		Object invalidValueReplacement = miningField.getInvalidValueReplacement();
		if(invalidValueReplacement != null){
			invalidValueReplacement = safeParseOrCast(dataType, invalidValueReplacement);

			miningField.setInvalidValueReplacement(invalidValueReplacement);
		}
	}

	return super.visit(miningField);
}
 

protected boolean assessParentCompatibility(){
	List<InputField> inputFields = getInputFields();

	for(InputField inputField : inputFields){
		Field<?> field = inputField.getField();
		MiningField miningField = inputField.getMiningField();

		if(!(field instanceof DataField)){
			continue;
		} // End if

		if(!InputFieldUtil.isDefault(field, miningField)){
			return false;
		}
	}

	return true;
}
 

protected boolean assessPurity(){
	List<InputField> inputFields = getInputFields();

	for(InputField inputField : inputFields){
		Field<?> field = inputField.getField();
		MiningField miningField = inputField.getMiningField();

		if(!InputFieldUtil.isDefault(field, miningField)){
			return false;
		}
	}

	if(hasLocalDerivedFields() || hasOutputFields()){
		return false;
	}

	return true;
}
 

/**
 * @param schema {@link InputSchema} whose information should be encoded in PMML
 * @param importances optional feature importances. May be {@code null}, or else the size
 *  of the array must match the number of predictors in the schema, which may be
 *  less than the total number of features.
 * @return a {@link MiningSchema} representing the information contained in an
 *  {@link InputSchema}
 */
public static MiningSchema buildMiningSchema(InputSchema schema, double[] importances) {
  Preconditions.checkArgument(
      importances == null || (importances.length == schema.getNumPredictors()));
  List<String> featureNames = schema.getFeatureNames();
  List<MiningField> miningFields = new ArrayList<>();
  for (int featureIndex = 0; featureIndex < featureNames.size(); featureIndex++) {
    String featureName = featureNames.get(featureIndex);
    MiningField field = new MiningField(FieldName.create(featureName));
    if (schema.isNumeric(featureName)) {
      field.setOpType(OpType.CONTINUOUS);
      field.setUsageType(MiningField.UsageType.ACTIVE);
    } else if (schema.isCategorical(featureName)) {
      field.setOpType(OpType.CATEGORICAL);
      field.setUsageType(MiningField.UsageType.ACTIVE);
    } else {
      // ID, or ignored
      field.setUsageType(MiningField.UsageType.SUPPLEMENTARY);
    }
    if (schema.hasTarget() && schema.isTarget(featureName)) {
      // Override to PREDICTED
      field.setUsageType(MiningField.UsageType.PREDICTED);
    }
    // Will be active if and only if it's a predictor
    if (field.getUsageType() == MiningField.UsageType.ACTIVE && importances != null) {
      int predictorIndex = schema.featureToPredictorIndex(featureIndex);
      field.setImportance(importances[predictorIndex]);
    }
    miningFields.add(field);
  }
  return new MiningSchema(miningFields);
}
 

@Override
protected FieldValue prepare(FieldName name, Object value){
	ModelEvaluator<?> modelEvaluator = getModelEvaluator();

	DataField dataField = modelEvaluator.getDataField(name);
	if(dataField == null){
		throw new MissingFieldException(name);
	}

	MiningField miningField = modelEvaluator.getMiningField(name);
	if(miningField == null){
		throw new InvisibleFieldException(name);
	}

	MiningField.UsageType usageType = miningField.getUsageType();
	switch(usageType){
		case ACTIVE:
		case GROUP:
		case ORDER:
			{
				return InputFieldUtil.prepareInputValue(dataField, miningField, value);
			}
		case PREDICTED:
		case TARGET:
			{
				return InputFieldUtil.prepareResidualInputValue(dataField, miningField, value);
			}
		default:
			throw new UnsupportedAttributeException(miningField, usageType);
	}
}
 

static
private FieldValue inheritOrPrepareInputValue(Field<?> field, MiningField miningField, FieldValue value){

	if(InputFieldUtil.isDefault(field, miningField)){
		return value;
	}

	return InputFieldUtil.prepareInputValue(field, miningField, FieldValueUtil.getValue(value));
}
 

@Override
public List<InputField> getGroupFields(){

	if(this.groupInputFields == null){
		this.groupInputFields = createInputFields(MiningField.UsageType.GROUP);
	}

	return this.groupInputFields;
}
 

private void processModel(Model model){
	MiningSchema miningSchema = model.getMiningSchema();
	if(miningSchema == null){
		throw new MissingElementException(MissingElementException.formatMessage(XPathUtil.formatElement(model.getClass()) + "/" + XPathUtil.formatElement(MiningSchema.class)), model);
	}

	Map<FieldName, DataType> targetDataTypes = new LinkedHashMap<>();

	if(miningSchema.hasMiningFields()){
		List<MiningField> miningFields = miningSchema.getMiningFields();

		for(MiningField miningField : miningFields){
			FieldName name = miningField.getName();
			if(name == null){
				throw new MissingAttributeException(miningField, PMMLAttributes.MININGFIELD_NAME);
			}

			MiningField.UsageType usageType = miningField.getUsageType();
			switch(usageType){
				case PREDICTED:
				case TARGET:
					DataType dataType = resolveTargetDataType(name);

					targetDataTypes.put(name, dataType);
					break;
				default:
					break;
			}
		}
	}

	this.targetDataTypes.push(targetDataTypes);

	this.dataType = getDataType();
}
 

@Override
public VisitorAction visit(MiningSchema miningSchema){

	if(miningSchema.hasMiningFields()){
		List<MiningField> miningFields = miningSchema.getMiningFields();

		for(ListIterator<MiningField> it = miningFields.listIterator(); it.hasNext(); ){
			it.set(intern(it.next()));
		}
	}

	return super.visit(miningSchema);
}
 

private MiningField intern(MiningField miningField){

		if(miningField == null || miningField.hasExtensions()){
			return miningField;
		} // End if

		if(!InputFieldUtil.isDefault(null, miningField)){
			return miningField;
		}

		return this.cache.intern(miningField);
	}
 

protected List<InputField> createInputFields(MiningField.UsageType usageType){
	M model = getModel();

	MiningSchema miningSchema = model.getMiningSchema();

	List<InputField> inputFields = new ArrayList<>();

	if(miningSchema.hasMiningFields()){
		List<MiningField> miningFields = miningSchema.getMiningFields();

		for(MiningField miningField : miningFields){
			FieldName name = miningField.getName();

			if(!(miningField.getUsageType()).equals(usageType)){
				continue;
			}

			Field<?> field = getDataField(name);
			if(field == null){
				field = new VariableField(name);
			}

			InputField inputField = new InputField(field, miningField);

			inputFields.add(inputField);
		}
	}

	return ImmutableList.copyOf(inputFields);
}
 

static
private ScalarValue createMissingInputValue(InputTypeInfo typeInfo){
	MiningField miningField = typeInfo.getMiningField();

	Object missingValueReplacement = miningField.getMissingValueReplacement();
	if(missingValueReplacement != null){
		return (ScalarValue)createInputValue(typeInfo, missingValueReplacement);
	}

	return (ScalarValue)FieldValues.MISSING_VALUE;
}
 

static
public OpType getOpType(Field<?> field, MiningField miningField){
	OpType opType = field.getOpType();

	// "A MiningField overrides a (Data)Field"
	if(miningField != null){
		opType = miningField.getOpType(opType);
	}

	return opType;
}
 

static
public OpType getOpType(Field<?> field, MiningField miningField, Target target){
	OpType opType = field.getOpType();

	// "A MiningField overrides a (Data)Field, and a Target overrides a MiningField"
	if(miningField != null){
		opType = miningField.getOpType(opType);

		if(target != null){
			opType = target.getOpType(opType);
		}
	}

	return opType;
}
 

static
private ScalarValue performMissingValueTreatment(InputTypeInfo typeInfo){
	MiningField miningField = typeInfo.getMiningField();

	MissingValueTreatmentMethod missingValueTreatmentMethod = miningField.getMissingValueTreatment();
	if(missingValueTreatmentMethod == null){
		missingValueTreatmentMethod = MissingValueTreatmentMethod.AS_IS;
	}

	switch(missingValueTreatmentMethod){
		case AS_IS:
		case AS_MEAN:
		case AS_MODE:
		case AS_MEDIAN:
		case AS_VALUE:
			return createMissingInputValue(typeInfo);
		case RETURN_INVALID:
			Field<?> field = typeInfo.getField();

			Object missingValueReplacement = miningField.getMissingValueReplacement();
			if(missingValueReplacement != null){
				throw new MisplacedAttributeException(miningField, PMMLAttributes.MININGFIELD_MISSINGVALUEREPLACEMENT, missingValueReplacement);
			}

			throw new InvalidResultException("Field " + PMMLException.formatKey(field.getName()) + " requires user input value", miningField);
		default:
			throw new UnsupportedAttributeException(miningField, missingValueTreatmentMethod);
	}
}
 

static
private ScalarValue performInvalidValueTreatment(InputTypeInfo typeInfo, Object value){
	MiningField miningField = typeInfo.getMiningField();

	InvalidValueTreatmentMethod invalidValueTreatmentMethod = miningField.getInvalidValueTreatment();
	switch(invalidValueTreatmentMethod){
		case AS_IS:
			break;
		case AS_MISSING:
		case RETURN_INVALID:
			Object invalidValueReplacement = miningField.getInvalidValueReplacement();
			if(invalidValueReplacement != null){
				throw new MisplacedAttributeException(miningField, PMMLAttributes.MININGFIELD_INVALIDVALUEREPLACEMENT, invalidValueReplacement);
			}
			break;
		default:
			throw new UnsupportedAttributeException(miningField, invalidValueTreatmentMethod);
	} // End switch

	switch(invalidValueTreatmentMethod){
		case RETURN_INVALID:
			Field<?> field = typeInfo.getField();

			throw new InvalidResultException("Field " + PMMLException.formatKey(field.getName()) + " cannot accept user input value " + PMMLException.formatValue(value), miningField);
		case AS_IS:
			return createInvalidInputValue(typeInfo, value);
		case AS_MISSING:
			return createMissingInputValue(typeInfo);
		default:
			throw new UnsupportedAttributeException(miningField, invalidValueTreatmentMethod);
	}
}
 

public InputField(Field<?> field, MiningField miningField){
	super(field);

	setMiningField(Objects.requireNonNull(miningField));

	if(!Objects.equals(field.getName(), miningField.getName())){
		throw new IllegalArgumentException();
	}
}
 

/**
 * @param miningSchema {@link MiningSchema} from a model
 * @return index of the {@link MiningField.UsageType#PREDICTED} feature
 */
public static Integer findTargetIndex(MiningSchema miningSchema) {
  List<MiningField> miningFields = miningSchema.getMiningFields();
  for (int i = 0; i < miningFields.size(); i++) {
    if (miningFields.get(i).getUsageType() == MiningField.UsageType.PREDICTED) {
      return i;
    }
  }
  return null;
}
 

protected static void checkMiningSchema(InputSchema schema, MiningSchema miningSchema) {
  assertNotNull(miningSchema);
  List<MiningField> miningFields = miningSchema.getMiningFields();
  List<String> expectedFeatureNames = schema.getFeatureNames();
  assertEquals("Wrong number of features",
               expectedFeatureNames.size(), miningFields.size());
  for (int i = 0; i < expectedFeatureNames.size(); i++) {
    MiningField miningField = miningFields.get(i);
    String expectedFeature = expectedFeatureNames.get(i);
    String featureName = miningField.getName().getValue();
    assertEquals("Wrong feature at position " + i, expectedFeature, featureName);
    if (schema.isNumeric(expectedFeature) || schema.isCategorical(expectedFeature)) {
      assertEquals("Wrong op type for feature + " + featureName,
                   schema.isNumeric(expectedFeature) ? OpType.CONTINUOUS : OpType.CATEGORICAL,
                   miningField.getOpType());
      if (schema.isTarget(expectedFeature)) {
        assertEquals("Wrong usage type for feature " + featureName,
                     MiningField.UsageType.PREDICTED,
                     miningField.getUsageType());
      } else {
        assertEquals("Wrong usage type for feature " + featureName,
                     MiningField.UsageType.ACTIVE,
                     miningField.getUsageType());
        assertRange(miningField.getImportance().doubleValue(), 0.0, 1.0);
      }
    } else {
      assertEquals("Wrong usage type for feature " + featureName,
                   MiningField.UsageType.SUPPLEMENTARY,
                   miningField.getUsageType());
    }

  }
}
 

@Override
protected List<InputField> createInputFields(MiningField.UsageType usageType){
	InputMapper inputMapper = getInputMapper();

	List<InputField> inputFields = super.createInputFields(usageType);

	if(inputMapper != null){
		inputFields = updateNames(inputFields, inputMapper);
	}

	return inputFields;
}
 

public MiningField getMiningField(FieldName name){

		if(Objects.equals(Evaluator.DEFAULT_TARGET_NAME, name)){
			return null;
		}

		return this.miningFields.get(name);
	}
 

public List<InputField> getActiveFields(){

		if(this.activeInputFields == null){
			this.activeInputFields = createInputFields(MiningField.UsageType.ACTIVE);
		}

		return this.activeInputFields;
	}
 

private DerivedFieldLoader(FieldName name, String column, DerivedField derivedField, MiningField miningField){
	super(name, column);

	setDerivedField(derivedField);
	setMiningField(miningField);
}
 

@Override
public FieldValue prepare(Object value){
	DerivedField derivedField = getDerivedField();
	MiningField miningField = getMiningField();

	if(miningField != null){
		return InputFieldUtil.prepareInputValue(derivedField, miningField, value);
	}

	TypeInfo typeInfo = new TypeInfo(){

		@Override
		public DataType getDataType(){
			DataType dataType = derivedField.getDataType();
			if(dataType == null){
				throw new MissingAttributeException(derivedField, org.dmg.pmml.PMMLAttributes.DERIVEDFIELD_DATATYPE);
			}

			return dataType;
		}

		@Override
		public OpType getOpType(){
			OpType opType = derivedField.getOpType();
			if(opType == null){
				throw new MissingAttributeException(derivedField, org.dmg.pmml.PMMLAttributes.DERIVEDFIELD_OPTYPE);
			}

			return opType;
		}

		@Override
		public List<?> getOrdering(){
			List<?> ordering = FieldUtil.getValidValues(derivedField);

			return ordering;
		}
	};

	return FieldValueUtil.create(typeInfo, value);
}
 

private DataFieldLoader(FieldName name, String column, DataField dataField, MiningField miningField){
	super(name, column);

	setDataField(dataField);
	setMiningField(miningField);
}
 

public MiningField getMiningField(){
	return this.miningField;
}
 

public TargetField(DataField dataField, MiningField miningField, Target target){
	super(dataField);

	setMiningField(miningField);
	setTarget(target);
}