Java Node.setScore方法代码示例

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 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 void handleNodePop(Node node){
	String score = node.getScore();
	Predicate predicate = node.getPredicate();

	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包/类
static
private Node encodeClassificationScore(Node node, RDoubleVector probabilities, Schema schema){
	CategoricalLabel categoricalLabel = (CategoricalLabel)schema.getLabel();

	if(categoricalLabel.size() != probabilities.size()){
		throw new IllegalArgumentException();
	}

	Double maxProbability = null;

	for(int i = 0; i < categoricalLabel.size(); i++){
		String value = categoricalLabel.getValue(i);
		Double probability = probabilities.getValue(i);

		if(maxProbability == null || (maxProbability).compareTo(probability) < 0){
			node.setScore(value);

			maxProbability = probability;
		}

		ScoreDistribution scoreDistribution = new ScoreDistribution(value, probability);

		node.addScoreDistributions(scoreDistribution);
	}

	return node;
}
 

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

	final
	RStringVector levels = (RStringVector)forest.getValue("levels");

	ScoreEncoder scoreEncoder = new ScoreEncoder(){

		@Override
		public void encode(Node node, Number splitValue, RNumberVector<?> terminalClassCount){
			int index = ValueUtil.asInt(splitValue);

			if(terminalClassCount != null){
				throw new IllegalArgumentException();
			}

			node.setScore(levels.getValue(index - 1));
		}
	};

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

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

	return miningModel;
}
 

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

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

		if(parentNode == null){
			return;
		}

		List<Node> parentChildren = parentNode.getNodes();
		if(parentChildren.size() != 1){
			return;
		}

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

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

		parentNode.setScore(score);

		if((MiningFunction.REGRESSION).equals(this.miningFunction)){
			// Ignored
		} else

		if((MiningFunction.CLASSIFICATION).equals(this.miningFunction)){
			Double recordCount = node.getRecordCount();
			List<ScoreDistribution> scoreDistributions = node.getScoreDistributions();

			Double parentRecordCount = parentNode.getRecordCount();
			if(parentRecordCount != null){
				throw new IllegalArgumentException();
			}

			parentNode.setRecordCount(recordCount);

			List<ScoreDistribution> parentScoreDistributions = parentNode.getScoreDistributions();
			if(parentScoreDistributions.size() != 0){
				throw new IllegalArgumentException();
			}

			parentScoreDistributions.addAll(scoreDistributions);
		} else

		{
			throw new IllegalArgumentException();
		}
	}
}
 

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

	final
	RStringVector levels = (RStringVector)forest.getValue("levels");

	CategoricalLabel categoricalLabel = (CategoricalLabel)schema.getLabel();

	ScoreEncoder scoreEncoder = new ScoreEncoder(){

		@Override
		public void encode(Node node, Number splitValue, RNumberVector<?> terminalClassCount){

			if(splitValue.doubleValue() != 0d || (terminalClassCount == null || terminalClassCount.size() != levels.size())){
				throw new IllegalArgumentException();
			}

			Double maxProbability = null;

			for(int i = 0; i < terminalClassCount.size(); i++){
				String value = levels.getValue(i);
				Double probability = ValueUtil.asDouble(terminalClassCount.getValue(i));

				if(maxProbability == null || (maxProbability).compareTo(probability) < 0){
					node.setScore(value);

					maxProbability = probability;
				}

				ScoreDistribution scoreDisctibution = new ScoreDistribution(value, probability);

				node.addScoreDistributions(scoreDisctibution);
			}
		}
	};

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

	MiningModel miningModel = new MiningModel(MiningFunction.CLASSIFICATION, ModelUtil.createMiningSchema(categoricalLabel))
		.setSegmentation(MiningModelUtil.createSegmentation(Segmentation.MultipleModelMethod.AVERAGE, treeModels))
		.setOutput(ModelUtil.createProbabilityOutput(DataType.DOUBLE, categoricalLabel));

	return miningModel;
}
 

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包/类
static
private Node encodeRegressionScore(Node node, RDoubleVector probabilities){

	if(probabilities.size() != 1){
		throw new IllegalArgumentException();
	}

	Double probability = probabilities.asScalar();

	node.setScore(ValueUtil.formatValue(probability));

	return node;
}
 

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();
	}
}