import org.dmg.pmml.tree.Node; //导入依赖的package包/类
/**
 * @param trainPointData data to run down trees
 * @param model random decision forest model to count on
 * @return map of predictor index to the number of training examples that reached a
 *  node whose decision is based on that feature. The index is among predictors, not all
 *  features, since there are fewer predictors than features. That is, the index will
 *  match the one used in the {@link RandomForestModel}.
 */
private static Map<Integer,Long> predictorExampleCounts(JavaRDD<LabeledPoint> trainPointData,
                                                        RandomForestModel model) {
  return trainPointData.mapPartitions(data -> {
      IntLongMap featureIndexCount = HashIntLongMaps.newMutableMap();
      data.forEachRemaining(datum -> {
        double[] featureVector = datum.features().toArray();
        for (DecisionTreeModel tree : model.trees()) {
          org.apache.spark.mllib.tree.model.Node node = tree.topNode();
          // This logic cloned from Node.predict:
          while (!node.isLeaf()) {
            Split split = node.split().get();
            int featureIndex = split.feature();
            // Count feature
            featureIndexCount.addValue(featureIndex, 1);
            node = nextNode(featureVector, node, split, featureIndex);
          }
        }
      });
      // Clone to avoid problem with Kryo serializing Koloboke
      return Collections.<Map<Integer,Long>>singleton(
          new HashMap<>(featureIndexCount)).iterator();
  }).reduce(RDFUpdate::merge);
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private static org.apache.spark.mllib.tree.model.Node nextNode(
    double[] featureVector,
    org.apache.spark.mllib.tree.model.Node node,
    Split split,
    int featureIndex) {
  double featureValue = featureVector[featureIndex];
  if (split.featureType().equals(FeatureType.Continuous())) {
    if (featureValue <= split.threshold()) {
      return node.leftNode().get();
    } else {
      return node.rightNode().get();
    }
  } else {
    if (split.categories().contains(featureValue)) {
      return node.leftNode().get();
    } else {
      return node.rightNode().get();
    }
  }
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
static
public TreeModel encodeTreeModel(org.apache.spark.ml.tree.Node node, PredicateManager predicateManager, MiningFunction miningFunction, Schema schema){
	Node root = encodeNode(node, predicateManager, Collections.<FieldName, Set<String>>emptyMap(), miningFunction, schema)
		.setPredicate(new True());

	TreeModel treeModel = new TreeModel(miningFunction, ModelUtil.createMiningSchema(schema.getLabel()), root)
		.setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT);

	String compact = TreeModelOptions.COMPACT;
	if(compact != null && Boolean.valueOf(compact)){
		Visitor visitor = new TreeModelCompactor();

		visitor.applyTo(treeModel);
	}

	return treeModel;
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
static
public <E extends Estimator & HasTree> TreeModel encodeTreeModel(E estimator, PredicateManager predicateManager, MiningFunction miningFunction, Schema schema){
	Tree tree = estimator.getTree();

	int[] leftChildren = tree.getChildrenLeft();
	int[] rightChildren = tree.getChildrenRight();
	int[] features = tree.getFeature();
	double[] thresholds = tree.getThreshold();
	double[] values = tree.getValues();

	Node root = new Node()
		.setId("1")
		.setPredicate(new True());

	encodeNode(root, predicateManager, 0, leftChildren, rightChildren, features, thresholds, values, miningFunction, schema);

	TreeModel treeModel = new TreeModel(miningFunction, ModelUtil.createMiningSchema(schema.getLabel()), root)
		.setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT);

	return treeModel;
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private MiningModel encodeRegression(RGenericVector ranger, Schema schema){
	RGenericVector forest = (RGenericVector)ranger.getValue("forest");

	ScoreEncoder scoreEncoder = new ScoreEncoder(){

		@Override
		public void encode(Node node, Number splitValue, RNumberVector<?> terminalClassCount){
			node.setScore(ValueUtil.formatValue(splitValue));
		}
	};

	List<TreeModel> treeModels = encodeForest(forest, MiningFunction.REGRESSION, scoreEncoder, schema);

	MiningModel miningModel = new MiningModel(MiningFunction.REGRESSION, ModelUtil.createMiningSchema(schema.getLabel()))
		.setSegmentation(MiningModelUtil.createSegmentation(Segmentation.MultipleModelMethod.AVERAGE, treeModels));

	return miningModel;
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private void process(Node node){
	List<Node> path = new ArrayList<>();
	path.add(node);

	Deque<PMMLObject> parents = getParents();
	for(PMMLObject parent : parents){

		if(!(parent instanceof Node)){
			break;
		}

		path.add((Node)parent);
	}

	Collections.reverse(path);

	this.paths.put(node, path);
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private Boolean evaluateNode(Trail trail, Node node, EvaluationContext context){
	EmbeddedModel embeddedModel = node.getEmbeddedModel();
	if(embeddedModel != null){
		throw new UnsupportedElementException(embeddedModel);
	}

	Predicate predicate = PredicateUtil.ensurePredicate(node);

	// A compound predicate whose boolean operator is "surrogate" represents a special case
	if(predicate instanceof CompoundPredicate){
		CompoundPredicate compoundPredicate = (CompoundPredicate)predicate;

		PredicateUtil.CompoundPredicateResult result = PredicateUtil.evaluateCompoundPredicateInternal(compoundPredicate, context);
		if(result.isAlternative()){
			trail.addMissingLevel();
		}

		return result.getResult();
	} else

	{
		return PredicateUtil.evaluate(predicate, context);
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private Trail handleDefaultChild(Trail trail, Node node, EvaluationContext context){

		// "The defaultChild missing value strategy requires the presence of the defaultChild attribute in every non-leaf Node"
		String defaultChild = node.getDefaultChild();
		if(defaultChild == null){
			throw new MissingAttributeException(node, PMMLAttributes.NODE_DEFAULTCHILD);
		}

		trail.addMissingLevel();

		List<Node> children = node.getNodes();
		for(int i = 0, max = children.size(); i < max; i++){
			Node child = children.get(i);

			String id = child.getId();
			if(id != null && (id).equals(defaultChild)){
				// The predicate of the referenced Node is not evaluated
				return handleTrue(trail, child, context);
			}
		}

		// "Only Nodes which are immediate children of the respective Node can be referenced"
		throw new InvalidAttributeException(node, PMMLAttributes.NODE_DEFAULTCHILD, defaultChild);
	}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private Trail handleNoTrueChild(Trail trail){
	TreeModel treeModel = getModel();

	TreeModel.NoTrueChildStrategy noTrueChildStrategy = treeModel.getNoTrueChildStrategy();
	switch(noTrueChildStrategy){
		case RETURN_NULL_PREDICTION:
			return trail.selectNull();
		case RETURN_LAST_PREDICTION:
			Node lastPrediction = trail.getLastPrediction();

			// "Return the parent Node only if it specifies a score attribute"
			if(lastPrediction.hasScore()){
				return trail.selectLastPrediction();
			}
			return trail.selectNull();
		default:
			throw new UnsupportedAttributeException(treeModel, noTrueChildStrategy);
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
/**
 * @param parent The parent Node of the Node that evaluated to the missing value.
 * @param node The Node that evaluated to the missing value.
 */
private Trail handleMissingValue(Trail trail, Node parent, Node node, EvaluationContext context){
	TreeModel treeModel = getModel();

	TreeModel.MissingValueStrategy missingValueStrategy = treeModel.getMissingValueStrategy();
	switch(missingValueStrategy){
		case NULL_PREDICTION:
			return trail.selectNull();
		case LAST_PREDICTION:
			return trail.selectLastPrediction();
		case DEFAULT_CHILD:
			return handleDefaultChild(trail, parent, context);
		case NONE:
			return null;
		default:
			throw new UnsupportedAttributeException(treeModel, missingValueStrategy);
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Test
public void getProbability(){
	Node node = new Node()
		.setScore("ham");

	final
	BiMap<String, Node> entityRegistry = ImmutableBiMap.of("1", node);

	NodeScoreDistribution<Double> classification = new NodeScoreDistribution<Double>(new ValueMap<String, Double>(), node){

		@Override
		public BiMap<String, Node> getEntityRegistry(){
			return entityRegistry;
		}
	};

	classification.put("ham", new DoubleValue(0.75d));
	classification.put("spam", new DoubleValue(0.25d));

	assertEquals(ImmutableSet.of("ham", "spam"), classification.getCategoryValues());

	assertEquals((Double)0.75d, classification.getProbability("ham"));
	assertEquals((Double)0.25d, classification.getProbability("spam"));
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
static
private TreeModelEvaluator createTreeModelEvaluator(MiningFunction miningFunction, MathContext mathContext, Target target){
	Node root = new Node()
		.setPredicate(new False());

	Targets targets = new Targets()
		.addTargets(target);

	TreeModel treeModel = new TreeModel(miningFunction, new MiningSchema(), root)
		.setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT)
		.setMathContext(mathContext)
		.setTargets(targets);

	PMML pmml = new PMML(Version.PMML_4_3.getVersion(), new Header(), new DataDictionary())
		.addModels(treeModel);

	return new TreeModelEvaluator(pmml);
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Override
public VisitorAction visit(Node node){
	TreeModel treeModel = getTreeModel();

	MiningFunction miningFunction = treeModel.getMiningFunction();
	switch(miningFunction){
		case REGRESSION:
			if(node.hasScoreDistributions()){
				List<ScoreDistribution> scoreDistributions = node.getScoreDistributions();

				scoreDistributions.clear();
			}
			break;
		default:
			break;
	}

	return super.visit(node);
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Test
public void clean(){
	Node node = new Node()
		.setPredicate(new True())
		.setScore("1")
		.addScoreDistributions(new ScoreDistribution("0", 0), new ScoreDistribution("1", 100));

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

	ScoreDistributionCleaner cleaner = new ScoreDistributionCleaner();
	cleaner.applyTo(treeModel);

	assertTrue(node.hasScoreDistributions());

	treeModel.setMiningFunction(MiningFunction.REGRESSION);

	cleaner.applyTo(treeModel);

	assertFalse(node.hasScoreDistributions());
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Test
public void intern(){
	ScoreDistribution left = new ScoreDistribution("event", 0.33d);
	ScoreDistribution right = new ScoreDistribution("event", 0.33d);

	Node leftChild = createNode(left);
	Node rightChild = createNode(right);

	Node root = new Node()
		.setPredicate(new True())
		.addNodes(leftChild, rightChild);

	TreeModel treeModel = new TreeModel()
		.setNode(root);

	for(int i = 0; i < 2; i++){
		assertNotSame((leftChild.getScoreDistributions()).get(i), (rightChild.getScoreDistributions()).get(i));
	}

	intern(treeModel);

	for(int i = 0; i < 2; i++){
		assertSame((leftChild.getScoreDistributions()).get(i), (rightChild.getScoreDistributions()).get(i));
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
public TreeModel encodeTreeModel(PredicateManager predicateManager, Schema schema){
	Node root = new Node()
		.setPredicate(new True());

	encodeNode(root, predicateManager, Collections.<FieldName, Set<String>>emptyMap(), 0, schema);

	TreeModel treeModel = new TreeModel(MiningFunction.REGRESSION, ModelUtil.createMiningSchema(schema.getLabel()), root)
		.setSplitCharacteristic(TreeModel.SplitCharacteristic.BINARY_SPLIT)
		.setMissingValueStrategy(TreeModel.MissingValueStrategy.DEFAULT_CHILD);

	return treeModel;
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Override
public void pushParent(PMMLObject object){
	super.pushParent(object);

	if(object instanceof Node){
		handleNodePush((Node)object);
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
@Override
public PMMLObject popParent(){
	PMMLObject object = super.popParent();

	if(object instanceof Node){
		handleNodePop((Node)object);
	}

	return object;
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private void handleNodePop(Node node){
	Double recordCount = node.getRecordCount();
	String score = node.getScore();
	Predicate predicate = node.getPredicate();

	if(recordCount != null){
		node.setRecordCount(null);
	} // End if

	if(predicate instanceof True){
		Node parentNode = getParentNode();

		if(parentNode == null){
			return;
		}

		String parentScore = parentNode.getScore();
		if(parentScore != null){
			throw new IllegalArgumentException();
		}

		parentNode.setScore(score);

		List<Node> parentChildren = parentNode.getNodes();

		boolean success = parentChildren.remove(node);
		if(!success){
			throw new IllegalArgumentException();
		} // End if

		if(node.hasNodes()){
			List<Node> children = node.getNodes();

			parentChildren.addAll(children);
		}
	}
}
 

import org.dmg.pmml.tree.Node; //导入依赖的package包/类
private Node getParentNode(){
	Deque<PMMLObject> parents = getParents();

	PMMLObject parent = parents.peekFirst();
	if(parent instanceof Node){
		return (Node)parent;
	}

	return null;
}