import org.dmg.pmml.MiningField; //导入依赖的package包/类
@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());
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
protected static List<VectorRange> getFieldValuesList(TreeModel treeModel, DataDictionary dataDictionary,
                                                      TransformationDictionary transformationDictionary) {
    // walk the tree model and gather all the field name
    Set<String> fieldNames = new HashSet<>();
    Node startNode = treeModel.getNode();
    getFieldNamesFromNode(fieldNames, startNode);
    // create the actual VectorRange objects, copy paste much from GLMHelper
    List<VectorRange> fieldsToValues = new ArrayList<>();
    List<DerivedField> allDerivedFields = ProcessPMMLHelper.getAllDerivedFields(treeModel, transformationDictionary);
    for(String fieldName : fieldNames) {
        List<DerivedField> derivedFields = new ArrayList<>();
        String rawFieldName = ProcessPMMLHelper.getDerivedFields(fieldName, allDerivedFields, derivedFields);
        DataField rawField = ProcessPMMLHelper.getRawDataField(dataDictionary, rawFieldName);
        MiningField miningField = ProcessPMMLHelper.getMiningField(treeModel, rawFieldName);
        fieldsToValues.add(new PMMLVectorRange.FieldToValue(rawField, miningField, derivedFields.toArray(new
                DerivedField[derivedFields.size()])));
    }
    return fieldsToValues;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
public MiningSchema createMiningSchema(Label label){
	MiningSchema miningSchema = new MiningSchema();

	if(label != null){
		FieldName name = label.getName();

		if(name != null){
			MiningField miningField = createMiningField(name, MiningField.UsageType.TARGET);

			miningSchema.addMiningFields(miningField);
		}
	}

	return miningSchema;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
private Set<FieldName> getActiveFields(MiningSchema miningSchema){
	Set<FieldName> result = new LinkedHashSet<>();

	List<MiningField> miningFields = miningSchema.getMiningFields();
	for(MiningField miningField : miningFields){
		MiningField.UsageType usageType = miningField.getUsageType();

		switch(usageType){
			case ACTIVE:
				result.add(miningField.getName());
				break;
			case GROUP:
			case ORDER:
				throw new IllegalArgumentException();
			default:
				break;
		}
	}

	return result;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
public FieldValue prepareTargetValue(DataField dataField, MiningField miningField, Target target, Object value){
	DataType dataType = dataField.getDataType();
	OpType opType = dataField.getOpType();

	if(dataType == null || opType == null){
		throw new InvalidElementException(dataField);
	} // End if

	if(miningField != null){
		String invalidValueReplacement = miningField.getInvalidValueReplacement();
		if(invalidValueReplacement != null){
			throw new MisplacedAttributeException(miningField, PMMLAttributes.MININGFIELD_INVALIDVALUEREPLACEMENT, invalidValueReplacement);
		}

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

	return createTargetValue(dataField, miningField, target, value);
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
public FieldValue performMissingValueTreatment(Field field, MiningField miningField){
	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(field, miningField);
		default:
			throw new UnsupportedAttributeException(miningField, missingValueTreatmentMethod);
	}
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
private FieldValue createInputValue(Field field, MiningField miningField, Object value){

	if(value == null){
		return null;
	}

	DataType dataType = field.getDataType();
	OpType opType = getOpType(field, miningField);

	FieldValue fieldValue = createOrRefine(dataType, opType, value);

	if(field instanceof TypeDefinitionField){
		return enhance((TypeDefinitionField)field, fieldValue);
	}

	return fieldValue;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
private FieldValue createTargetValue(Field field, MiningField miningField, Target target, Object value){

	if(value == null){
		return null;
	}

	DataType dataType = field.getDataType();
	OpType opType = getOpType(field, miningField, target);

	FieldValue fieldValue = createOrRefine(dataType, opType, value);

	if(field instanceof TypeDefinitionField){
		return enhance((TypeDefinitionField)field, fieldValue);
	}

	return fieldValue;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
private SegmentHandler(ModelEvaluator<?> modelEvaluator){
	setModelEvaluator(modelEvaluator);

	boolean compatible = true;

	List<InputField> inputFields = modelEvaluator.getInputFields();
	for(InputField inputField : inputFields){
		Field field = inputField.getField();

		if(field instanceof DataField){
			MiningField miningField = inputField.getMiningField();

			compatible &= MiningFieldUtil.isDefault(miningField);
		}
	}

	setCompatible(compatible);
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
private MiningField getTargetField(Model model){
	MiningSchema miningSchema = model.getMiningSchema();

	MiningField result = null;

	List<MiningField> miningFields = miningSchema.getMiningFields();
	for(MiningField miningField : miningFields){
		MiningField.UsageType usageType = miningField.getUsageType();

		switch(usageType){
			case TARGET:
			case PREDICTED:
				if(result != null){
					throw new UnsupportedElementException(miningSchema);
				}
				result = miningField;
				break;
			default:
				break;
		}
	}

	return result;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
/**
 * @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);
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
/**
 * @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;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
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(), 0.0, 1.0);
      }
    } else {
      assertEquals("Wrong usage type for feature " + featureName,
                   MiningField.UsageType.SUPPLEMENTARY,
                   miningField.getUsageType());
    }

  }
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
static
private FieldName extractTargetField(Model model){
	FieldName targetField = null;

	MiningSchema miningSchema = model.getMiningSchema();

	List<MiningField> miningFields = miningSchema.getMiningFields();
	for(Iterator<MiningField> it = miningFields.iterator(); it.hasNext(); ){
		MiningField miningField = it.next();

		FieldUsageType fieldUsage = miningField.getUsageType();
		switch(fieldUsage){
			case PREDICTED:
			case TARGET:
				{
					if(targetField != null){
						throw new IllegalArgumentException();
					}

					targetField = miningField.getName();

					it.remove();
				}
				break;
			default:
				break;
		}
	}

	return targetField;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
public static MiningField getMiningField(Model model, String rawFieldName) {
    MiningField miningField = null;
    // also pass in the mining schema for additional parameters
    for (MiningField aMiningField : model.getMiningSchema().getMiningFields()) {
        if (aMiningField.getKey().getValue().equals(rawFieldName)) {
            miningField = aMiningField;
        }
    }
    return miningField;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
public static PMMLVectorRange extractVectorRange(Model model, DataDictionary dataDictionary,
                                           TransformationDictionary transformationDictionary,
                                           String fieldName, Provider<Collection<String>> categories,
                                           int position, Map<String, OpType> types) {
    List<DerivedField> allDerivedFields = ProcessPMMLHelper.getAllDerivedFields(model, transformationDictionary);
    List<DerivedField> derivedFields = new ArrayList<>();
    String rawFieldName = ProcessPMMLHelper.getDerivedFields(fieldName, allDerivedFields, derivedFields);
    DataField rawField = ProcessPMMLHelper.getRawDataField(dataDictionary, rawFieldName);
    MiningField miningField = ProcessPMMLHelper.getMiningField(model, rawFieldName);
    PMMLVectorRange featureEntries = getFieldVector(position, derivedFields, rawField, miningField, categories, types);
    return featureEntries;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
public static PMMLVectorRange getFieldVector(int indexCounter, List<DerivedField> derivedFields,
                                       DataField rawField, MiningField miningField,
                                       Provider<Collection<String>> categories,
                                       Map<String, OpType> types) {
    PMMLVectorRange featureEntries;
    OpType opType;
    if (derivedFields.size() == 0) {
        opType = rawField.getOpType();
    } else {
        opType = derivedFields.get(0).getOpType();
    }

    if (opType.equals(OpType.CONTINUOUS)) {
        featureEntries = new PMMLVectorRange.ContinousSingleEntryVectorRange(rawField, miningField,
                derivedFields.toArray(new DerivedField[derivedFields.size()]));
        featureEntries.addVectorEntry(indexCounter, "dummyValue");
    } else if (opType.equals(OpType.CATEGORICAL)) {
        featureEntries = new PMMLVectorRange.SparseCategoricalVectorRange(rawField, miningField,
                derivedFields.toArray(new DerivedField[derivedFields.size()]));
        for (String value : categories.get()) {
            featureEntries.addVectorEntry(indexCounter, value);
            indexCounter++;
        }
    } else {
        throw new UnsupportedOperationException("Only implemented continuous and categorical variables so far.");
    }
    if(types != null) {
        types.put(featureEntries.getLastDerivedFieldName(), opType);
    }
    return featureEntries;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
public PMMLVectorRange(DataField dataField, MiningField miningField, DerivedField[] derivedFields) {
    super(dataField.getName().getValue(),
            derivedFields.length == 0 ? dataField.getName().getValue() : derivedFields[derivedFields.length - 1].getName().getValue(),
            derivedFields.length == 0 ? dataField.getDataType().value() : derivedFields[derivedFields.length - 1].getDataType().value
                    ());
    this.field = dataField.getName().getValue();
    if (miningField.getMissingValueReplacement() != null) {
        preProcessingSteps = new PreProcessingStep[derivedFields.length + 1];
        preProcessingSteps[0] = new MissingValuePreProcess(dataField, miningField.getMissingValueReplacement());
    } else {
        preProcessingSteps = new PreProcessingStep[derivedFields.length];
    }
    fillPreProcessingSteps(derivedFields);
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
public static MiningSchema createMiningSchema(double[] weights) {
    MiningSchema miningSchema = new MiningSchema();
    MiningField[] miningFields = new MiningField[weights.length + 1];
    for (int i = 0; i < weights.length; i++) {
        miningFields[i] = creatMiningField("field_" + Integer.toString(i), FieldUsageType.ACTIVE);
    }
    miningFields[weights.length] = creatMiningField("target", FieldUsageType.TARGET);
    miningSchema.addMiningFields(miningFields);
    return miningSchema;
}
 

import org.dmg.pmml.MiningField; //导入依赖的package包/类
private static MiningField creatMiningField(String name, FieldUsageType fieldUsageType) {
    MiningField field = new MiningField();
    field.setName(new FieldName(name));
    field.setUsageType(fieldUsageType);

    return field;

}