@Override public MiningFunction getMiningFunction(){ M model = getModel(); return model.getMiningFunction(); }
/** * <p> * Indicates if this model evaluator is compatible with its parent model evaluator. * </p> * * <p> * A parent compatible model evaluator inherits {@link DataField} declarations unchanged, * which makes it possible to propagate {@link DataField} and global {@link DerivedField} values between evaluation contexts during evaluation. * </p> */ public boolean isParentCompatible(){ if(this.parentCompatible == null){ this.parentCompatible = assessParentCompatibility(); } return this.parentCompatible; }
/** * <p> * Indicates if this model evaluator represents a pure function. * </p> * * <p> * A pure model evaluator does not tamper with the evaluation context during evaluation. * </p> */ public boolean isPure(){ if(this.pure == null){ this.pure = assessPurity(); } return this.pure; }
public TargetField getTargetField(){ List<TargetField> targetFields = getTargetFields(); if(targetFields.size() != 1){ throw createMiningSchemaException("Expected 1 target field, got " + targetFields.size() + " target fields"); } TargetField targetField = targetFields.get(0); return targetField; }
public Map<FieldName, ?> evaluate(ModelEvaluationContext context){ M model = getModel(); case FLOAT: case DOUBLE: valueFactory = ensureValueFactory(); break; default: switch(miningFunction){ case REGRESSION: predictions = evaluateRegression(valueFactory, context); break; case CLASSIFICATION: predictions = evaluateClassification(valueFactory, context); break; case CLUSTERING: predictions = evaluateClustering(valueFactory, context); break; case ASSOCIATION_RULES: predictions = evaluateAssociationRules(valueFactory, context); break; case SEQUENCES: predictions = evaluateSequences(valueFactory, context); break; case TIME_SERIES: predictions = evaluateTimeSeries(valueFactory, context); break; case MIXED: predictions = evaluateMixed(valueFactory, context);
@Override public void verify(){ M model = getModel(); List<InputField> inputFields = getInputFields(); List<TargetField> targetFields = getTargetFields(); List<OutputField> outputFields = getOutputFields(); Map<FieldName, ?> results = evaluate(arguments); verify(record.get(name), results.get(name), verificationField.getPrecision(), verificationField.getZeroThreshold()); verify(record.get(name), EvaluatorUtil.decode(results.get(name)), verificationField.getPrecision(), verificationField.getZeroThreshold());
ModelEvaluator<?> modelEvaluator = context.getModelEvaluator(); Model model = modelEvaluator.getModel(); Predicate<OutputField> outputFilter = modelEvaluator.ensureOutputFilter(); targetName = modelEvaluator.getTargetName(); TargetField targetField = modelEvaluator.findTargetField(targetName); if(targetField == null){ throw new MissingFieldException(targetName, outputField); TargetField targetField = modelEvaluator.findTargetField(targetName); if(targetField == null){ throw new MissingFieldException(targetName, outputField); OutputField reportOutputField = modelEvaluator.getOutputField(reportName); if(reportOutputField == null){ throw new MissingFieldException(reportName);
protected List<InputField> createInputFields(){ List<InputField> inputFields = getActiveFields(); List<OutputField> outputFields = getOutputFields(); if(outputFields.size() > 0){ List<ResidualInputField> residualInputFields = null; targetName = getTargetName(); DataField dataField = getDataField(targetName); if(dataField == null){ throw new MissingFieldException(targetName, pmmlOutputField); MiningField miningField = getMiningField(targetName); if(miningField == null){ throw new InvisibleFieldException(targetName, pmmlOutputField);
Model model = modelEvaluator.getModel(); MiningField miningField = modelEvaluator.getMiningField(name); if(miningField == null){ OutputField outputField = modelEvaluator.getOutputField(name);
MiningField miningField = modelEvaluator.getMiningField(name); DerivedField localDerivedField = modelEvaluator.getLocalDerivedField(name); if(localDerivedField != null){ FieldValue value = ExpressionUtil.evaluateTypedExpressionContainer(localDerivedField, this); DerivedField derivedField = modelEvaluator.getDerivedField(name); if(derivedField != null){ FieldValue value; if(parent != null && modelEvaluator.isParentCompatible()){ value = parent.evaluate(name); } else DataField dataField = modelEvaluator.getDataField(name); if(dataField != null){ Map<FieldName, ?> arguments = getArguments();
protected void checkSchema(ModelEvaluator<?> modelEvaluator){ Model model = modelEvaluator.getModel(); MiningSchema miningSchema = model.getMiningSchema(); List<InputField> inputFields = modelEvaluator.getInputFields(); List<InputField> groupFields = Collections.emptyList(); if(modelEvaluator instanceof HasGroupFields){ HasGroupFields hasGroupFields = (HasGroupFields)modelEvaluator; groupFields = hasGroupFields.getGroupFields(); } // End if if((inputFields.size() + groupFields.size()) > 1000){ throw new InvalidElementException("Model has too many input fields", miningSchema); } List<TargetField> targetFields = modelEvaluator.getTargetFields(); List<OutputField> outputFields = modelEvaluator.getOutputFields(); if((targetFields.size() + outputFields.size()) < 1){ throw new InvalidElementException("Model does not have any target or output fields", miningSchema); } }
protected List<TargetField> createTargetFields(){ M model = getModel(); DataField dataField = getDataField(name); if(dataField == null){ throw new MissingFieldException(name, miningField); Target target = getTarget(name); DataField dataField = getDataField(); Target target = getTarget(dataField.getName());
modelEvaluator.configure(configuration); Iterable<InputField> inputFields = modelEvaluator.getInputFields(); Iterable<ResultField> resultFields = Iterables.concat(modelEvaluator.getTargetFields(), modelEvaluator.getOutputFields());
protected List<OutputField> createOutputFields(){ M model = getModel(); Output output = model.getOutput(); List<OutputField> resultFields = new ArrayList<>(); if(output != null && output.hasOutputFields()){ List<org.dmg.pmml.OutputField> outputFields = output.getOutputFields(); Predicate<org.dmg.pmml.OutputField> outputFilter = ensureOutputFilter(); outputFields: for(org.dmg.pmml.OutputField outputField : outputFields){ if(outputFilter.test(outputField)){ OutputField resultField = new OutputField(outputField); resultFields.add(resultField); } } } return ImmutableList.copyOf(resultFields); }
protected List<InputField> createInputFields(MiningField.UsageType usageType){ M model = getModel(); MiningSchema miningSchema = model.getMiningSchema(); List<InputField> inputFields = new ArrayList<>(); if(miningSchema.hasMiningFields()){ List<MiningField> miningFields = miningSchema.getMiningFields(); for(MiningField miningField : miningFields){ FieldName name = miningField.getName(); if(!(miningField.getUsageType()).equals(usageType)){ continue; } Field<?> field = getDataField(name); if(field == null){ field = new VariableField(name); } InputField inputField = new InputField(field, miningField); inputFields.add(inputField); } } return ImmutableList.copyOf(inputFields); }
@Override protected FieldValue prepare(FieldName name, Object value){ ModelEvaluator<?> modelEvaluator = getModelEvaluator(); DataField dataField = modelEvaluator.getDataField(name); if(dataField == null){ throw new MissingFieldException(name); } MiningField miningField = modelEvaluator.getMiningField(name); if(miningField == null){ throw new InvisibleFieldException(name); } MiningField.UsageType usageType = miningField.getUsageType(); switch(usageType){ case ACTIVE: case GROUP: case ORDER: { return InputFieldUtil.prepareInputValue(dataField, miningField, value); } case PREDICTED: case TARGET: { return InputFieldUtil.prepareResidualInputValue(dataField, miningField, value); } default: throw new UnsupportedAttributeException(miningField, usageType); } }
@Override public void configure(Configuration configuration){ super.configure(configuration); this.segmentModelEvaluators.clear(); }
@Override public List<OutputField> getOutputFields(){ if(this.outputResultFields == null){ this.outputResultFields = createOutputFields(); } return this.outputResultFields; }
@Override public List<InputField> getInputFields(){ if(this.inputFields == null){ this.inputFields = createInputFields(); } return this.inputFields; }
public Set<org.dmg.pmml.ResultFeature> getResultFeatures(){ if(this.resultFeatures == null){ this.resultFeatures = collectResultFeatures(); } return this.resultFeatures; }