Java Schema.getFeature方法代码示例

import org.jpmml.converter.Schema; //导入方法依赖的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.jpmml.converter.Schema; //导入方法依赖的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.jpmml.converter.Schema; //导入方法依赖的package包/类
private void encodeNode(org.dmg.pmml.tree.Node parent, int index, Schema schema){
	parent.setId(String.valueOf(index + 1));

	Node node = this.nodes.get(index);

	if(!node.is_leaf()){
		int splitIndex = node.split_index();

		Feature feature = schema.getFeature(splitIndex);

		org.dmg.pmml.tree.Node leftChild = new org.dmg.pmml.tree.Node()
			.setPredicate(encodePredicate(feature, node, true));

		encodeNode(leftChild, node.cleft(), schema);

		org.dmg.pmml.tree.Node rightChild = new org.dmg.pmml.tree.Node()
			.setPredicate(encodePredicate(feature, node, false));

		encodeNode(rightChild, node.cright(), schema);

		parent.addNodes(leftChild, rightChild);

		boolean defaultLeft = isDefaultLeft(feature, node);

		parent.setDefaultChild(defaultLeft ? leftChild.getId() : rightChild.getId());
	} else

	{
		float value = node.leaf_value();

		parent.setScore(ValueUtil.formatValue(value));
	}
}
 

import org.jpmml.converter.Schema; //导入方法依赖的package包/类
@Override
public NaiveBayesModel encodeModel(Schema schema){
	int[] shape = getThetaShape();

	int numberOfClasses = shape[0];
	int numberOfFeatures = shape[1];

	List<? extends Number> theta = getTheta();
	List<? extends Number> sigma = getSigma();

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

	BayesInputs bayesInputs = new BayesInputs();

	for(int i = 0; i < numberOfFeatures; i++){
		Feature feature = schema.getFeature(i);

		List<? extends Number> means = CMatrixUtil.getColumn(theta, numberOfClasses, numberOfFeatures, i);
		List<? extends Number> variances = CMatrixUtil.getColumn(sigma, numberOfClasses, numberOfFeatures, i);

		ContinuousFeature continuousFeature = feature.toContinuousFeature();

		BayesInput bayesInput = new BayesInput(continuousFeature.getName())
			.setTargetValueStats(encodeTargetValueStats(categoricalLabel.getValues(), means, variances));

		bayesInputs.addBayesInputs(bayesInput);
	}

	List<Integer> classCount = getClassCount();

	BayesOutput bayesOutput = new BayesOutput(categoricalLabel.getName(), null)
		.setTargetValueCounts(encodeTargetValueCounts(categoricalLabel.getValues(), classCount));

	NaiveBayesModel naiveBayesModel = new NaiveBayesModel(0d, MiningFunction.CLASSIFICATION, ModelUtil.createMiningSchema(categoricalLabel), bayesInputs, bayesOutput)
		.setOutput(ModelUtil.createProbabilityOutput(DataType.DOUBLE, categoricalLabel));

	return naiveBayesModel;
}
 

import org.jpmml.converter.Schema; //导入方法依赖的package包/类
private void encodeNode(org.dmg.pmml.tree.Node parent, int index, Schema schema){
    parent.setId(String.valueOf(index + 1));

    Node node = allNodes.get(index);

    if(!node.isLeaf()){
        int splitIndex = node.getFeatureIndex();

        Feature feature = schema.getFeature(splitIndex);

        org.dmg.pmml.tree.Node leftChild = new org.dmg.pmml.tree.Node()
                .setPredicate(encodePredicate(feature, node, true));

        encodeNode(leftChild, node.getLeftChild().getId(), schema);

        org.dmg.pmml.tree.Node rightChild = new org.dmg.pmml.tree.Node()
                .setPredicate(encodePredicate(feature, node, false));

        encodeNode(rightChild, node.getRightChild().getId(), schema);

        parent.addNodes(leftChild, rightChild);

        boolean defaultLeft = false;

        parent.setDefaultChild(defaultLeft ? leftChild.getId() : rightChild.getId());
    } else

    {
        float value = (float)node.getValue();

        parent.setScore(ValueUtil.formatValue(value));
    }
}
 

import org.jpmml.converter.Schema; //导入方法依赖的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.jpmml.converter.Schema; //导入方法依赖的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();
	}
}