org.dmg.pmml.VisitorAction Java Examples

@Override
public VisitorAction visit(GeneralRegressionModel generalRegressionModel){
	BaseCumHazardTables baseCumHazardTables = generalRegressionModel.getBaseCumHazardTables();

	if(baseCumHazardTables != null){
		FieldName baselineStrataVariable = generalRegressionModel.getBaselineStrataVariable();

		if(baselineStrataVariable != null){
			DataType dataType = resolveDataType(baselineStrataVariable);

			if(dataType != null){
				generalRegressionModel.setBaseCumHazardTables(new RichBaseCumHazardTables(dataType, baseCumHazardTables));
			}
		}
	}

	return super.visit(generalRegressionModel);
}
 

@Override
public VisitorAction visit(DataDictionary dataDictionary){

	if(dataDictionary.hasDataFields()){
		List<DataField> dataFields = dataDictionary.getDataFields();

		for(ListIterator<DataField> it = dataFields.listIterator(); it.hasNext(); ){
			DataField dataField = it.next();

			if(dataField.hasValues()){
				it.set(new RichDataField(dataField));
			}
		}
	}

	return super.visit(dataDictionary);
}
 

@Override
public VisitorAction visit(Node node){
	PMMLObject parent = getParent();

	if(parent instanceof TreeModel){
		TreeModel treeModel = (TreeModel)parent;

		MiningFunction miningFunction = treeModel.getMiningFunction();
		switch(miningFunction){
			case CLASSIFICATION:
				break;
			default:
				return VisitorAction.SKIP;
		}
	}

	node.setScore(parseTargetValue(node.getScore()));

	return super.visit(node);
}
 

@Override
public VisitorAction visit(OutputField outputField){
	ResultFeature resultFeature = outputField.getResultFeature();

	switch(resultFeature){
		case PROBABILITY:
		case CONFIDENCE:
		case AFFINITY:
			{
				outputField.setValue(parseTargetValue(outputField.getTargetField(), outputField.getValue()));
			}
			break;
		default:
			break;
	}

	return super.visit(outputField);
}
 

@Override
public VisitorAction visit(VectorDictionary vectorDictionary){
	check(new CollectionSize(vectorDictionary){

		@Override
		public Integer getSize(){
			return vectorDictionary.getNumberOfVectors();
		}

		@Override
		public Collection<?> getCollection(){
			return vectorDictionary.getVectorInstances();
		}
	});

	return super.visit(vectorDictionary);
}
 

@Override
public VisitorAction visit(NeuralOutputs neuralOutputs){
	check(new CollectionSize(neuralOutputs){

		@Override
		public Integer getSize(){
			return neuralOutputs.getNumberOfOutputs();
		}

		@Override
		public Collection<?> getCollection(){
			return neuralOutputs.getNeuralOutputs();
		}
	});

	return super.visit(neuralOutputs);
}
 

@Override
public VisitorAction visit(Node node){
	Object defaultChild = node.getDefaultChild();

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

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

			Object id = child.getId();
			if(id != null && (id).equals(defaultChild)){
				node.setDefaultChild(child);

				break;
			}
		}
	}

	return super.visit(node);
}
 

@Override
public VisitorAction visit(DataDictionary dataDictionary){
	check(new CollectionSize(dataDictionary){

		@Override
		public Integer getSize(){
			return dataDictionary.getNumberOfFields();
		}

		@Override
		public Collection<?> getCollection(){
			return dataDictionary.getDataFields();
		}
	});

	return super.visit(dataDictionary);
}
 

@Override
public VisitorAction visit(TreeModel treeModel){
	MiningFunction miningFunction = treeModel.getMiningFunction();
	if(miningFunction == null){
		throw new MissingAttributeException(treeModel, PMMLAttributes.TREEMODEL_MININGFUNCTION);
	}

	switch(miningFunction){
		case REGRESSION:
			break;
		default:
			return VisitorAction.SKIP;
	}

	return super.visit(treeModel);
}
 

@Override
public VisitorAction visit(DiscretizeBin discretizeBin){
	Discretize discretize = (Discretize)getParent();

	DataType dataType = discretize.getDataType();
	if(dataType != null){
		Object binValue = discretizeBin.getBinValue();
		if(binValue != null){
			binValue = parseOrCast(dataType, binValue);

			discretizeBin.setBinValue(binValue);
		}
	}

	return super.visit(discretizeBin);
}
 

@Override
public VisitorAction visit(Value value){
	PMMLObject parent = getParent();

	Object simpleValue = value.getValue();
	if(simpleValue == null){
		throw new MissingAttributeException(value, PMMLAttributes.VALUE_VALUE);
	} // End if

	if(parent instanceof Field){
		Field<?> field = (Field<?>)parent;

		DataType dataType = field.getDataType();
		if(dataType != null){
			simpleValue = safeParseOrCast(dataType, simpleValue);

			value.setValue(simpleValue);
		}
	}

	return super.visit(value);
}
 

@Override
public VisitorAction visit(ClusteringModel clusteringModel){
	check(new CollectionSize(clusteringModel){

		@Override
		public Integer getSize(){
			return clusteringModel.getNumberOfClusters();
		}

		@Override
		public Collection<?> getCollection(){
			return clusteringModel.getClusters();
		}
	});

	return super.visit(clusteringModel);
}
 

@Override
public VisitorAction visit(Constant constant){
	boolean missing = constant.isMissing();

	if(!missing){
		Object value = constant.getValue();

		if(!ExpressionUtil.isEmptyContent(value)){
			DataType dataType = constant.getDataType();
			if(dataType == null){
				dataType = TypeUtil.getConstantDataType(value);
			}

			value = parseOrCast(dataType, value);

			constant.setValue(value);
		}
	}

	return super.visit(constant);
}
 

@Override
public VisitorAction visit(Coefficients coefficients){
	check(new CollectionSize(coefficients){

		@Override
		public Integer getSize(){
			return coefficients.getNumberOfCoefficients();
		}

		@Override
		public Collection<?> getCollection(){
			return coefficients.getCoefficients();
		}
	});

	return super.visit(coefficients);
}
 

@Override
public VisitorAction visit(NeuralLayer neuralLayer){
	NeuralNetwork.ActivationFunction activationFunction = neuralLayer.getActivationFunction();

	if(activationFunction != null){

		switch(activationFunction){
			case RADIAL_BASIS:
				report(new UnsupportedAttributeException(neuralLayer, activationFunction));
				break;
			default:
				break;
		}
	}

	return super.visit(neuralLayer);
}
 

@Override
public VisitorAction visit(Itemset itemset){
	check(new CollectionSize(itemset){

		@Override
		public Integer getSize(){
			return itemset.getNumberOfItems();
		}

		@Override
		public Collection<?> getCollection(){
			return itemset.getItemRefs();
		}
	});

	return super.visit(itemset);
}
 

@Override
public VisitorAction visit(Node node){

	if(node.hasScoreDistributions()){
		List<ScoreDistribution> scoreDistributions = node.getScoreDistributions();

		for(ListIterator<ScoreDistribution> it = scoreDistributions.listIterator(); it.hasNext(); ){
			it.set(intern(it.next()));
		}
	}

	return super.visit(node);
}
 

@Override
public VisitorAction visit(SupportVectorMachine supportVectorMachine){
	supportVectorMachine.setTargetCategory(parseTargetValue(supportVectorMachine.getTargetCategory()));
	supportVectorMachine.setAlternateTargetCategory(parseTargetValue(supportVectorMachine.getAlternateTargetCategory()));

	return super.visit(supportVectorMachine);
}
 

@Override
public VisitorAction visit(TargetValue targetValue){
	Target target = (Target)getParent();

	targetValue.setValue(parseTargetValue(target.getField(), targetValue.getValue()));

	return super.visit(targetValue);
}
 

@Override
public VisitorAction visit(Segmentation segmentation){
	LocalTransformations localTransformations = segmentation.getLocalTransformations();

	if(localTransformations != null){
		report(new UnsupportedElementException(localTransformations));
	}

	return super.visit(segmentation);
}
 

@Override
public VisitorAction visit(TestDistributions testDistributions){
	process(testDistributions.getField());
	process(testDistributions.getWeightField());

	return super.visit(testDistributions);
}
 

@Override
public VisitorAction visit(OutputField outputField){
	ResultFeature resultFeature = outputField.getResultFeature();

	switch(resultFeature){
		case TRANSFORMED_VALUE:
		case DECISION:
			{
				String segmentId = outputField.getSegmentId();

				if(segmentId != null){
					Object value = outputField.getValue();

					if(value instanceof String){
						value = filter((String)value);
					}

					outputField.setValue(value);
				}
			}
			break;
		default:
			break;
	}

	return super.visit(outputField);
}
 

@Override
public VisitorAction visit(Field<?> field){
	FieldName name = field.getName();

	if(name != null){
		this.mappings.put(name, hash(name));
	}

	return super.visit(field);
}
 

@Override
public VisitorAction accept(Visitor visitor){
	VisitorAction status = visitor.visit(this);

	if(status == VisitorAction.CONTINUE){
		visitor.pushParent(this);
		visitor.popParent();
	} // End if

	if(status == VisitorAction.TERMINATE){
		return VisitorAction.TERMINATE;
	}

	return VisitorAction.CONTINUE;
}
 

@Override
public VisitorAction visit(Node node){

	if(node.hasScore()){
		Object score = node.getScore();

		if(score instanceof String){
			score = parseScore(score);

			node.setScore(score);
		}
	}

	return super.visit(node);
}
 

@Override
public VisitorAction accept(Visitor visitor){
	VisitorAction status = visitor.visit(this);

	if(status == VisitorAction.CONTINUE){
		visitor.pushParent(this);

		if(hasArguments()){
			List<Argument> arguments = getArguments();

			for(Argument argument : arguments){
				status = PMMLObject.traverse(visitor, argument.getExpression());

				if(status != VisitorAction.CONTINUE){
					break;
				}
			}
		}

		visitor.popParent();
	} // End if

	if(status == VisitorAction.TERMINATE){
		return VisitorAction.TERMINATE;
	}

	return VisitorAction.CONTINUE;
}
 

@Override
public VisitorAction visit(TargetValueCount targetValueCount){
	Object value = targetValueCount.getValue();
	if(value == null){
		throw new MissingAttributeException(targetValueCount, org.dmg.pmml.naive_bayes.PMMLAttributes.TARGETVALUECOUNT_VALUE);
	}

	targetValueCount.setValue(parseTargetValue(value));

	return super.visit(targetValueCount);
}
 

@Override
public VisitorAction visit(CategoricalPredictor categoricalPredictor){
	FieldName name = categoricalPredictor.getField();
	if(name == null){
		throw new MissingAttributeException(categoricalPredictor, org.dmg.pmml.regression.PMMLAttributes.CATEGORICALPREDICTOR_FIELD);
	}

	parseValue(name, categoricalPredictor);

	return super.visit(categoricalPredictor);
}
 

@Override
public VisitorAction accept(Visitor visitor){
	VisitorAction status = visitor.visit(this);

	if(status == VisitorAction.CONTINUE){
		visitor.pushParent(this);
		visitor.popParent();
	} // End if

	if(status == VisitorAction.TERMINATE){
		return VisitorAction.TERMINATE;
	}

	return VisitorAction.CONTINUE;
}
 

protected void validatePMML(PMML pmml) throws Exception {
	List<Visitor> visitors = Arrays.<Visitor>asList(
		new UnsupportedMarkupInspector(),
		new InvalidMarkupInspector(){

			@Override
			public VisitorAction visit(Application application){
				String name = application.getName();

				if(name == null){
					return VisitorAction.SKIP;
				}

				return super.visit(application);
			}

			@Override
			public VisitorAction visit(MiningSchema miningSchema){

				if(!miningSchema.hasMiningFields()){
					return VisitorAction.SKIP;
				}

				return super.visit(miningSchema);
			}
		}
	);

	for(Visitor visitor : visitors){
		visitor.applyTo(pmml);
	}
}