org.jpmml.evaluator.FieldValueUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pmml-evaluator Show documentation
Show all versions of pmml-evaluator Show documentation
JPMML class model evaluator
/*
* Copyright (c) 2013 Villu Ruusmann
*
* This file is part of JPMML-Evaluator
*
* JPMML-Evaluator is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* JPMML-Evaluator is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with JPMML-Evaluator. If not, see fieldValues = dataField.getValues();
for(int i = 0, max = fieldValues.size(); i < max; i++){
Value fieldValue = fieldValues.get(i);
Value.Property property = fieldValue.getProperty();
switch(property){
case VALID:
{
hasValidSpace = true;
if(!compatible){
continue;
}
}
// Falls through
case INVALID:
case MISSING:
{
boolean equals = equals(dataType, value, fieldValue.getValue());
if(equals){
return property;
}
}
break;
default:
throw new UnsupportedFeatureException(fieldValue, property);
}
}
} // End if
if(!compatible){
return Value.Property.INVALID;
} // End if
if(dataField.hasIntervals()){
PMMLObject locatable = miningField;
OpType opType = miningField.getOpType();
if(opType == null){
locatable = dataField;
opType = dataField.getOpType();
}
switch(opType){
case CONTINUOUS:
{
RangeSet validRanges = getValidRanges(dataField);
Double doubleValue = (Double)TypeUtil.parseOrCast(DataType.DOUBLE, value);
// "If intervals are present, then a value that is outside the intervals is considered invalid"
return (validRanges.contains(doubleValue) ? Value.Property.VALID : Value.Property.INVALID);
}
case CATEGORICAL:
case ORDINAL:
// "Intervals are not allowed for non-continuous fields"
throw new InvalidFeatureException(dataField);
default:
throw new UnsupportedFeatureException(locatable, opType);
}
}
// "If a field contains at least one Value element where the value of property is valid, then the set of Value elements completely defines the set of valid values"
if(hasValidSpace){
return Value.Property.INVALID;
}
// "Any value is valid by default"
return Value.Property.VALID;
}
static
private FieldValue createInputValue(Field field, MiningField miningField, Object value){
if(value == null){
return null;
}
DataType dataType = field.getDataType();
OpType opType = field.getOpType();
// "A MiningField overrides a DataField"
if(miningField != null){
opType = firstNonNull(miningField.getOpType(), opType);
}
return create(dataType, opType, value);
}
static
private FieldValue createMissingInputValue(Field field, MiningField miningField){
return createInputValue(field, miningField, miningField.getMissingValueReplacement());
}
static
private FieldValue createTargetValue(Field field, MiningField miningField, Target target, Object value){
if(value == null){
return null;
}
DataType dataType = field.getDataType();
OpType opType = field.getOpType();
// "A MiningField overrides a DataField, and a Target overrides a MiningField"
if(miningField != null){
opType = firstNonNull(miningField.getOpType(), opType);
if(target != null){
opType = firstNonNull(target.getOpType(), opType);
}
}
return create(dataType, opType, value);
}
static
public FieldValue create(Object value){
return create((DataType)null, (OpType)null, value);
}
static
public List createAll(List values){
Function function = new Function(){
@Override
public FieldValue apply(Object value){
return create(value);
}
};
return Lists.transform(values, function);
}
static
public FieldValue create(Field field, Object value){
FieldValue result = create(field.getDataType(), field.getOpType(), value);
if(field instanceof TypeDefinitionField){
return enhance((TypeDefinitionField)field, result);
}
return result;
}
static
public FieldValue create(DataType dataType, OpType opType, Object value){
if(value == null){
return null;
} // End if
if(value instanceof Collection){
Collection collection = (Collection)value;
if(dataType == null){
Object firstElement = Iterables.getFirst(collection, null);
if(firstElement != null){
dataType = TypeUtil.getDataType(firstElement);
} else
{
dataType = DataType.STRING;
}
} // End if
if(opType == null){
opType = TypeUtil.getOpType(dataType);
}
} else
{
if(dataType == null){
dataType = TypeUtil.getDataType(value);
} else
{
value = TypeUtil.parseOrCast(dataType, value);
} // End if
if(opType == null){
opType = TypeUtil.getOpType(dataType);
}
}
switch(opType){
case CONTINUOUS:
return ContinuousValue.create(dataType, value);
case CATEGORICAL:
return CategoricalValue.create(dataType, value);
case ORDINAL:
return OrdinalValue.create(dataType, value);
default:
break;
}
throw new EvaluationException();
}
static
public FieldValue refine(Field field, FieldValue value){
FieldValue result = refine(field.getDataType(), field.getOpType(), value);
if((field instanceof TypeDefinitionField) && (result != value)){
return enhance((TypeDefinitionField)field, result);
}
return result;
}
static
public FieldValue refine(DataType dataType, OpType opType, FieldValue value){
if(value == null){
return null;
}
DataType valueDataType = value.getDataType();
OpType valueOpType = value.getOpType();
DataType refinedDataType = firstNonNull(dataType, valueDataType);
OpType refinedOpType = firstNonNull(opType, valueOpType);
if((refinedDataType).equals(valueDataType) && (refinedOpType).equals(valueOpType)){
return value;
}
return create(refinedDataType, refinedOpType, value.getValue());
}
static
private FieldValue enhance(TypeDefinitionField field, FieldValue value){
if(value == null){
return null;
} // End if
if(value instanceof OrdinalValue){
OrdinalValue ordinalValue = (OrdinalValue)value;
ordinalValue.setOrdering(getOrdering(field, ordinalValue.getDataType()));
}
return value;
}
static
public Object getValue(FieldValue value){
return (value != null ? value.getValue() : null);
}
static
public V getValue(Class clazz, FieldValue value){
return TypeUtil.cast(clazz, getValue(value));
}
static
public Value getValidValue(TypeDefinitionField field, Object value){
if(value == null){
return null;
} // End if
if(field.hasValues()){
DataType dataType = field.getDataType();
OpType opType = field.getOpType();
value = TypeUtil.parseOrCast(dataType, value);
if(field instanceof HasParsedValueMapping){
HasParsedValueMapping hasParsedValueMapping = (HasParsedValueMapping)field;
return getValidValue(hasParsedValueMapping, dataType, opType, value);
}
List fieldValues = field.getValues();
for(int i = 0, max = fieldValues.size(); i < max; i++){
Value fieldValue = fieldValues.get(i);
Value.Property property = fieldValue.getProperty();
switch(property){
case VALID:
{
boolean equals = equals(dataType, value, fieldValue.getValue());
if(equals){
return fieldValue;
}
}
break;
case INVALID:
case MISSING:
break;
default:
throw new UnsupportedFeatureException(fieldValue, property);
}
}
}
return null;
}
static
private Value getValidValue(HasParsedValueMapping hasParsedValueMapping, DataType dataType, OpType opType, Object object){
FieldValue value;
try {
value = FieldValueUtil.create(dataType, opType, object);
} catch(IllegalArgumentException | TypeCheckException e){
return null;
}
Map fieldValues = hasParsedValueMapping.getValueMapping(dataType, opType);
return (Value)fieldValues.get(value);
}
static
public List getValidValues(TypeDefinitionField field){
if(field.hasValues()){
List fieldValues = field.getValues();
List result = new ArrayList<>(fieldValues.size());
for(int i = 0, max = fieldValues.size(); i < max; i++){
Value fieldValue = fieldValues.get(i);
Value.Property property = fieldValue.getProperty();
switch(property){
case VALID:
result.add(fieldValue);
break;
case INVALID:
case MISSING:
break;
default:
throw new UnsupportedFeatureException(fieldValue, property);
}
}
return result;
}
return Collections.emptyList();
}
static
public List getTargetCategories(TypeDefinitionField field){
return CacheUtil.getValue(field, FieldValueUtil.targetCategoryCache);
}
static
public RangeSet getValidRanges(DataField dataField){
return CacheUtil.getValue(dataField, FieldValueUtil.validRangeCache);
}
static
private boolean equals(DataType dataType, Object value, String referenceValue){
try {
return TypeUtil.equals(dataType, value, TypeUtil.parse(dataType, referenceValue));
} catch(IllegalArgumentException | TypeCheckException e){
// The String representation of invalid or missing values (eg. "N/A") may not be parseable to the requested representation
try {
return TypeUtil.equals(DataType.STRING, value, referenceValue);
} catch(TypeCheckException tce){
// Ignored
}
throw e;
}
}
static
private V firstNonNull(V value, V defaultValue){
if(value != null){
return value;
}
return defaultValue;
}
static
private RangeSet parseValidRanges(DataField dataField){
RangeSet result = TreeRangeSet.create();
List intervals = dataField.getIntervals();
for(Interval interval : intervals){
Range range = DiscretizationUtil.toRange(interval);
result.add(range);
}
return result;
}
static
private List getOrdering(TypeDefinitionField field, final DataType dataType){
List values = getValidValues(field);
if(values.isEmpty()){
return null;
}
Function function = new Function(){
@Override
public Object apply(Value value){
return TypeUtil.parse(dataType, value.getValue());
}
};
return Lists.newArrayList(Iterables.transform(values, function));
}
private static final LoadingCache> targetCategoryCache = CacheUtil.buildLoadingCache(new CacheLoader>(){
@Override
public List load(TypeDefinitionField field){
List values = getValidValues(field);
Function function = new Function(){
@Override
public String apply(Value value){
String result = value.getValue();
if(result == null){
throw new InvalidFeatureException(value);
}
return result;
}
};
return ImmutableList.copyOf(Iterables.transform(values, function));
}
});
private static final LoadingCache> validRangeCache = CacheUtil.buildLoadingCache(new CacheLoader>(){
@Override
public RangeSet load(DataField dataField){
return ImmutableRangeSet.copyOf(parseValidRanges(dataField));
}
});
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy