Java Node.addNodes方法代码示例

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
private static PMML buildDummyClassificationModel(int numTrees) {
  PMML pmml = PMMLUtils.buildSkeletonPMML();

  List<DataField> dataFields = new ArrayList<>();
  DataField predictor =
      new DataField(FieldName.create("color"), OpType.CATEGORICAL, DataType.STRING);
  predictor.addValues(new Value("yellow"), new Value("red"));
  dataFields.add(predictor);
  DataField target =
      new DataField(FieldName.create("fruit"), OpType.CATEGORICAL, DataType.STRING);
  target.addValues(new Value("banana"), new Value("apple"));
  dataFields.add(target);
  DataDictionary dataDictionary =
      new DataDictionary(dataFields).setNumberOfFields(dataFields.size());
  pmml.setDataDictionary(dataDictionary);

  List<MiningField> miningFields = new ArrayList<>();
  MiningField predictorMF = new MiningField(FieldName.create("color"))
      .setOpType(OpType.CATEGORICAL)
      .setUsageType(MiningField.UsageType.ACTIVE)
      .setImportance(0.5);
  miningFields.add(predictorMF);
  MiningField targetMF = new MiningField(FieldName.create("fruit"))
      .setOpType(OpType.CATEGORICAL)
      .setUsageType(MiningField.UsageType.PREDICTED);
  miningFields.add(targetMF);
  MiningSchema miningSchema = new MiningSchema(miningFields);

  double dummyCount = 2.0;
  Node rootNode = new Node().setId("r").setRecordCount(dummyCount).setPredicate(new True());

  double halfCount = dummyCount / 2;

  Node left = new Node().setId("r-").setRecordCount(halfCount).setPredicate(new True());
  left.addScoreDistributions(new ScoreDistribution("apple", halfCount));
  Node right = new Node().setId("r+").setRecordCount(halfCount)
      .setPredicate(new SimpleSetPredicate(FieldName.create("color"),
                                           SimpleSetPredicate.BooleanOperator.IS_NOT_IN,
                                           new Array(Array.Type.STRING, "red")));
  right.addScoreDistributions(new ScoreDistribution("banana", halfCount));

  rootNode.addNodes(right, left);

  TreeModel treeModel = new TreeModel(MiningFunction.CLASSIFICATION, miningSchema, rootNode)
      .setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT)
      .setMissingValueStrategy(TreeModel.MissingValueStrategy.DEFAULT_CHILD);

  if (numTrees > 1) {
    MiningModel miningModel = new MiningModel(MiningFunction.CLASSIFICATION, miningSchema);
    List<Segment> segments = new ArrayList<>();
    for (int i = 0; i < numTrees; i++) {
      segments.add(new Segment()
          .setId(Integer.toString(i))
          .setPredicate(new True())
          .setModel(treeModel)
          .setWeight(1.0));
    }
    miningModel.setSegmentation(
        new Segmentation(Segmentation.MultipleModelMethod.WEIGHTED_MAJORITY_VOTE, segments));
    pmml.addModels(miningModel);
  } else {
    pmml.addModels(treeModel);
  }

  return pmml;
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
public static PMML buildDummyRegressionModel() {
  PMML pmml = PMMLUtils.buildSkeletonPMML();

  List<DataField> dataFields = new ArrayList<>();
  dataFields.add(new DataField(FieldName.create("foo"), OpType.CONTINUOUS, DataType.DOUBLE));
  dataFields.add(new DataField(FieldName.create("bar"), OpType.CONTINUOUS, DataType.DOUBLE));
  DataDictionary dataDictionary =
      new DataDictionary(dataFields).setNumberOfFields(dataFields.size());
  pmml.setDataDictionary(dataDictionary);

  List<MiningField> miningFields = new ArrayList<>();
  MiningField predictorMF = new MiningField(FieldName.create("foo"))
      .setOpType(OpType.CONTINUOUS)
      .setUsageType(MiningField.UsageType.ACTIVE)
      .setImportance(0.5);
  miningFields.add(predictorMF);
  MiningField targetMF = new MiningField(FieldName.create("bar"))
      .setOpType(OpType.CONTINUOUS)
      .setUsageType(MiningField.UsageType.PREDICTED);
  miningFields.add(targetMF);
  MiningSchema miningSchema = new MiningSchema(miningFields);

  double dummyCount = 2.0;
  Node rootNode = new Node().setId("r").setRecordCount(dummyCount).setPredicate(new True());

  double halfCount = dummyCount / 2;

  Node left = new Node()
      .setId("r-")
      .setRecordCount(halfCount)
      .setPredicate(new True())
      .setScore("-2.0");
  Node right = new Node().setId("r+").setRecordCount(halfCount)
      .setPredicate(new SimplePredicate(FieldName.create("foo"),
                                        SimplePredicate.Operator.GREATER_THAN).setValue("3.14"))
      .setScore("2.0");

  rootNode.addNodes(right, left);

  TreeModel treeModel = new TreeModel(MiningFunction.REGRESSION, miningSchema, rootNode)
      .setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT)
      .setMissingValueStrategy(TreeModel.MissingValueStrategy.DEFAULT_CHILD)
      .setMiningSchema(miningSchema);

  pmml.addModels(treeModel);

  return pmml;
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
private void encodeNode(Node node, RGenericVector tree, Schema schema){
	RIntegerVector nodeId = (RIntegerVector)tree.getValue("nodeID");
	RBooleanVector terminal = (RBooleanVector)tree.getValue("terminal");
	RGenericVector psplit = (RGenericVector)tree.getValue("psplit");
	RGenericVector ssplits = (RGenericVector)tree.getValue("ssplits");
	RDoubleVector prediction = (RDoubleVector)tree.getValue("prediction");
	RGenericVector left = (RGenericVector)tree.getValue("left");
	RGenericVector right = (RGenericVector)tree.getValue("right");

	node.setId(String.valueOf(nodeId.asScalar()));

	if((Boolean.TRUE).equals(terminal.asScalar())){
		node = encodeScore(node, prediction, schema);

		return;
	}

	RNumberVector<?> splitpoint = (RNumberVector<?>)psplit.getValue("splitpoint");
	RStringVector variableName = (RStringVector)psplit.getValue("variableName");

	if(ssplits.size() > 0){
		throw new IllegalArgumentException();
	}

	Predicate leftPredicate;
	Predicate rightPredicate;

	FieldName name = FieldName.create(variableName.asScalar());

	Integer index = this.featureIndexes.get(name);
	if(index == null){
		throw new IllegalArgumentException();
	}

	Feature feature = schema.getFeature(index);

	if(feature instanceof CategoricalFeature){
		CategoricalFeature categoricalFeature = (CategoricalFeature)feature;

		List<String> values = categoricalFeature.getValues();
		List<Integer> splitValues = (List<Integer>)splitpoint.getValues();

		leftPredicate = createSimpleSetPredicate(categoricalFeature, selectValues(values, splitValues, true));
		rightPredicate = createSimpleSetPredicate(categoricalFeature, selectValues(values, splitValues, false));
	} else

	{
		ContinuousFeature continuousFeature = feature.toContinuousFeature();

		String value = ValueUtil.formatValue((Double)splitpoint.asScalar());

		leftPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.LESS_OR_EQUAL, value);
		rightPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.GREATER_THAN, value);
	}

	Node leftChild = new Node()
		.setPredicate(leftPredicate);

	encodeNode(leftChild, left, schema);

	Node rightChild = new Node()
		.setPredicate(rightPredicate);

	encodeNode(rightChild, right, schema);

	node.addNodes(leftChild, rightChild);
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
private <P extends Number> void encodeNode(Node node, int i, ScoreEncoder<P> scoreEncoder, List<? extends Number> leftDaughter, List<? extends Number> rightDaughter, List<? extends Number> bestvar, List<Double> xbestsplit, List<P> nodepred, Schema schema){
	Predicate leftPredicate;
	Predicate rightPredicate;

	int var = ValueUtil.asInt(bestvar.get(i));
	if(var != 0){
		Feature feature = schema.getFeature(var - 1);

		Double split = xbestsplit.get(i);

		if(feature instanceof BooleanFeature){
			BooleanFeature booleanFeature = (BooleanFeature)feature;

			if(split != 0.5d){
				throw new IllegalArgumentException();
			}

			leftPredicate = createSimplePredicate(booleanFeature, SimplePredicate.Operator.EQUAL, booleanFeature.getValue(0));
			rightPredicate = createSimplePredicate(booleanFeature, SimplePredicate.Operator.EQUAL, booleanFeature.getValue(1));
		} else

		if(feature instanceof CategoricalFeature){
			CategoricalFeature categoricalFeature = (CategoricalFeature)feature;

			List<String> values = categoricalFeature.getValues();

			leftPredicate = createSimpleSetPredicate(categoricalFeature, selectValues(values, split, true));
			rightPredicate = createSimpleSetPredicate(categoricalFeature, selectValues(values, split, false));
		} else

		{
			ContinuousFeature continuousFeature = feature.toContinuousFeature();

			String value = ValueUtil.formatValue(split);

			leftPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.LESS_OR_EQUAL, value);
			rightPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.GREATER_THAN, value);
		}
	} else

	{
		P prediction = nodepred.get(i);

		node.setScore(scoreEncoder.encode(prediction));

		return;
	}

	int left = ValueUtil.asInt(leftDaughter.get(i));
	if(left != 0){
		Node leftChild = new Node()
			.setId(String.valueOf(left))
			.setPredicate(leftPredicate);

		encodeNode(leftChild, left - 1, scoreEncoder, leftDaughter, rightDaughter, bestvar, xbestsplit, nodepred, schema);

		node.addNodes(leftChild);
	}

	int right = ValueUtil.asInt(rightDaughter.get(i));
	if(right != 0){
		Node rightChild = new Node()
			.setId(String.valueOf(right))
			.setPredicate(rightPredicate);

		encodeNode(rightChild, right - 1, scoreEncoder, leftDaughter, rightDaughter, bestvar, xbestsplit, nodepred, schema);

		node.addNodes(rightChild);
	}
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
@Test
public void transform(){
	Node node1a = new Node();

	Node node2a = new Node();
	Node node2b = new Node();

	node1a.addNodes(node2a, node2b);

	Node node3a = new Node();

	node2a.addNodes(node3a);

	assertTrue(node1a.getNodes() instanceof ArrayList);
	assertTrue(node2a.getNodes() instanceof ArrayList);

	TreeModel treeModel = new TreeModel(MiningFunction.CLASSIFICATION, new MiningSchema(), node1a);

	ArrayListTransformer transformer = new ArrayListTransformer();
	transformer.applyTo(treeModel);

	assertTrue(node1a.getNodes() instanceof DoubletonList);
	assertTrue(node2a.getNodes() instanceof SingletonList);
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
@Test
public void find(){
	Node node1a = new Node();

	Node node2a = new Node();
	Node node2b = new Node();
	Node node2c = new Node();

	node1a.addNodes(node2a, node2b, node2c);

	Node node3a = new Node();
	Node node3b = new Node();

	node2b.addNodes(node3a);
	node2c.addNodes(node3b);

	Node node4a = new Node();

	node3a.addNodes(node4a);

	TreeModel treeModel = new TreeModel(MiningFunction.CLASSIFICATION, new MiningSchema(), node1a);

	TreePathFinder finder = new TreePathFinder();
	finder.applyTo(treeModel);

	Map<Node, List<Node>> paths = finder.getPaths();

	assertEquals(3, paths.size());

	assertEquals(Arrays.asList(node1a, node2a), paths.get(node2a));
	assertEquals(Arrays.asList(node1a, node2b, node3a, node4a), paths.get(node4a));
	assertEquals(Arrays.asList(node1a, node2c, node3b), paths.get(node3b));
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
private void encodeNode(Node node, int index, ScoreEncoder scoreEncoder, RNumberVector<?> leftChildIDs, RNumberVector<?> rightChildIDs, RNumberVector<?> splitVarIDs, RNumberVector<?> splitValues, RGenericVector terminalClassCounts, Schema schema){
	int leftIndex = ValueUtil.asInt(leftChildIDs.getValue(index));
	int rightIndex = ValueUtil.asInt(rightChildIDs.getValue(index));

	Number splitValue = splitValues.getValue(index);
	RNumberVector<?> terminalClassCount = (terminalClassCounts != null ? (RNumberVector<?>)terminalClassCounts.getValue(index) : null);

	if(leftIndex == 0 && rightIndex == 0){
		scoreEncoder.encode(node, splitValue, terminalClassCount);

		return;
	}

	Predicate leftPredicate;
	Predicate rightPredicate;

	int splitVarIndex = ValueUtil.asInt(splitVarIDs.getValue(index));

	Feature feature = schema.getFeature(splitVarIndex - 1);

	if(feature instanceof CategoricalFeature){
		CategoricalFeature categoricalFeature = (CategoricalFeature)feature;

		int splitLevelIndex = ValueUtil.asInt(Math.floor(splitValue.doubleValue()));

		List<String> values = categoricalFeature.getValues();

		leftPredicate = createSimpleSetPredicate(categoricalFeature, values.subList(0, splitLevelIndex));
		rightPredicate = createSimpleSetPredicate(categoricalFeature, values.subList(splitLevelIndex, values.size()));
	} else

	{
		ContinuousFeature continuousFeature = feature.toContinuousFeature();

		String value = ValueUtil.formatValue(splitValue);

		leftPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.LESS_OR_EQUAL, value);
		rightPredicate = createSimplePredicate(continuousFeature, SimplePredicate.Operator.GREATER_THAN, value);
	}

	Node leftChild = new Node()
		.setPredicate(leftPredicate);

	encodeNode(leftChild, leftIndex, scoreEncoder, leftChildIDs, rightChildIDs, splitVarIDs, splitValues, terminalClassCounts, schema);

	Node rightChild = new Node()
		.setPredicate(rightPredicate);

	encodeNode(rightChild, rightIndex, scoreEncoder, leftChildIDs, rightChildIDs, splitVarIDs, splitValues, terminalClassCounts, schema);

	node.addNodes(leftChild, rightChild);
}
 

import org.dmg.pmml.tree.Node; //导入方法依赖的package包/类
private void encodeNode(Node node, int index, int depth, List<Integer> nodeStatus, List<Integer> nodeSize, List<Integer> leftDaughter, List<Integer> rightDaughter, List<Integer> splitAtt, List<Double> splitValue, Schema schema){
	int status = nodeStatus.get(index);
	int size = nodeSize.get(index);

	node.setId(String.valueOf(index + 1));

	// Interior node
	if(status == -3){
		int att = splitAtt.get(index);

		ContinuousFeature feature = (ContinuousFeature)schema.getFeature(att - 1);

		String value = ValueUtil.formatValue(splitValue.get(index));

		Predicate leftPredicate = createSimplePredicate(feature, SimplePredicate.Operator.LESS_THAN, value);

		Node leftChild = new Node()
			.setPredicate(leftPredicate);

		int leftIndex = (leftDaughter.get(index) - 1);

		encodeNode(leftChild, leftIndex, depth + 1, nodeStatus, nodeSize, leftDaughter, rightDaughter, splitAtt, splitValue, schema);

		Predicate rightPredicate = createSimplePredicate(feature, SimplePredicate.Operator.GREATER_OR_EQUAL, value);

		Node rightChild = new Node()
			.setPredicate(rightPredicate);

		int rightIndex = (rightDaughter.get(index) - 1);

		encodeNode(rightChild, rightIndex, depth + 1, nodeStatus, nodeSize, leftDaughter, rightDaughter, splitAtt, splitValue, schema);

		node.addNodes(leftChild, rightChild);
	} else

	// Terminal node
	if(status == -1){
		node.setScore(ValueUtil.formatValue(depth + avgPathLength(size)));
	} else

	{
		throw new IllegalArgumentException();
	}
}