@Override public Expression createExpression(FieldRef fieldRef){ return PMMLUtil.createApply("lessOrEqual", fieldRef, PMMLUtil.createConstant(0d)); } };
@Override public Expression createExpression(FieldRef fieldRef){ return PMMLUtil.createApply("-", PMMLUtil.createConstant(0.5d), PMMLUtil.createApply("pow", PMMLUtil.createConstant(2d), PMMLUtil.createApply("*", PMMLUtil.createConstant(-1d), fieldRef))); } };
@Override public Expression createExpression(FieldRef fieldRef){ return PMMLUtil.createApply("lessOrEqual", fieldRef, PMMLUtil.createConstant(0d)); } };
@Override public Expression createExpression(FieldRef fieldRef){ return PMMLUtil.createApply("pow", PMMLUtil.createConstant(2d), PMMLUtil.createApply("*", PMMLUtil.createConstant(-1d), fieldRef)); } };
static private Apply createHingeFunction(int dir, Feature feature, double cut){ Expression expression; switch(dir){ case -1: expression = PMMLUtil.createApply("-", PMMLUtil.createConstant(cut), feature.ref()); break; case 1: expression = PMMLUtil.createApply("-", feature.ref(), PMMLUtil.createConstant(cut)); break; default: throw new IllegalArgumentException(); } return PMMLUtil.createApply("max", expression, PMMLUtil.createConstant(0d)); } }
@Override public Expression createExpression(FieldRef fieldRef){ double maxSamples = getMaxSamples(); double averagePathLength = (corrected ? correctedAveragePathLength(maxSamples) : averagePathLength(maxSamples)); return PMMLUtil.createApply("/", fieldRef, PMMLUtil.createConstant(averagePathLength)); } };
@Override public Expression createExpression(FieldRef fieldRef){ return PMMLUtil.createApply("/", fieldRef, PMMLUtil.createConstant(avgPathLength(xrow.asScalar()))); } };
public Apply encodeApply(String function, Feature feature, int index, String term){ Constant constant = PMMLUtil.createConstant(term, DataType.STRING); return PMMLUtil.createApply(function, feature.ref(), constant); }
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ Number threshold = getThreshold(); List<Feature> result = new ArrayList<>(); for(int i = 0; i < features.size(); i++){ Feature feature = features.get(i); ContinuousFeature continuousFeature = feature.toContinuousFeature(); // "($name <= threshold) ? 0 : 1" Apply apply = PMMLUtil.createApply("threshold", continuousFeature.ref(), PMMLUtil.createConstant(threshold)); DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("binarizer", continuousFeature), apply); result.add(new ContinuousFeature(encoder, derivedField)); } return result; }
@Override public Apply createApply(){ Number weight = getWeight(); Apply apply = super.createApply() .addExpressions(PMMLUtil.createConstant(weight)); return apply; }
@Override public Expression createExpression(FieldRef fieldRef){ String behaviour = getBehaviour(); double threshold; // SkLearn 0.19 if(behaviour == null){ threshold = getThreshold(); } else // SkLearn 0.20+ { if(("old").equals(behaviour)){ threshold = getThreshold(); } else { throw new IllegalArgumentException(behaviour); } } return PMMLUtil.createApply("lessOrEqual", fieldRef, PMMLUtil.createConstant(threshold)); } };
@Override public List<Feature> encodeFeatures(SparkMLEncoder encoder){ Binarizer transformer = getTransformer(); Feature feature = encoder.getOnlyFeature(transformer.getInputCol()); ContinuousFeature continuousFeature = feature.toContinuousFeature(); Apply apply = new Apply("if") .addExpressions(PMMLUtil.createApply("lessOrEqual", continuousFeature.ref(), PMMLUtil.createConstant(transformer.getThreshold()))) .addExpressions(PMMLUtil.createConstant(0d), PMMLUtil.createConstant(1d)); DerivedField derivedField = encoder.createDerivedField(formatName(transformer), OpType.CATEGORICAL, DataType.DOUBLE, apply); return Collections.singletonList(new CategoricalFeature(encoder, derivedField, Arrays.asList("0", "1"))); } }
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ List<? extends Number> scale = getScale(); ClassDictUtil.checkSize(features, scale); List<Feature> result = new ArrayList<>(); for(int i = 0; i < features.size(); i++){ Feature feature = features.get(i); Number value = scale.get(i); if(ValueUtil.isOne(value)){ result.add(feature); continue; } ContinuousFeature continuousFeature = feature.toContinuousFeature(); // "$name / scale" Apply apply = PMMLUtil.createApply("/", continuousFeature.ref(), PMMLUtil.createConstant(value)); DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("max_abs_scaler", continuousFeature), apply); result.add(new ContinuousFeature(encoder, derivedField)); } return result; }
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ List<? extends Number> min = getMin(); List<? extends Number> scale = getScale(); ClassDictUtil.checkSize(features, min, scale); List<Feature> result = new ArrayList<>(); for(int i = 0; i < features.size(); i++){ Feature feature = features.get(i); Number minValue = min.get(i); Number scaleValue = scale.get(i); if(ValueUtil.isOne(scaleValue) && ValueUtil.isZero(minValue)){ result.add(feature); continue; } ContinuousFeature continuousFeature = feature.toContinuousFeature(); // "($name * scale) + min" Expression expression = continuousFeature.ref(); if(!ValueUtil.isOne(scaleValue)){ expression = PMMLUtil.createApply("*", expression, PMMLUtil.createConstant(scaleValue)); } // End if if(!ValueUtil.isZero(minValue)){ expression = PMMLUtil.createApply("+", expression, PMMLUtil.createConstant(minValue)); } DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("mix_max_scaler", continuousFeature), expression); result.add(new ContinuousFeature(encoder, derivedField)); } return result; }
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ GregorianCalendar epoch = getEpoch(); String function = getFunction(); ZoneId epochZoneId = ZoneId.systemDefault(); TimeZone epochTimeZone = epoch.getTimeZone(); if(epochTimeZone != null){ epochZoneId = epochTimeZone.toZoneId(); } LocalDateTime epochDateTime = LocalDateTime.ofInstant(epoch.toInstant(), epochZoneId); if(epochDateTime.getMonthValue() != 1 || epochDateTime.getDayOfMonth() != 1){ throw new IllegalArgumentException(String.valueOf(epochDateTime)); } List<Feature> result = new ArrayList<>(); for(int i = 0; i < features.size(); i++){ ObjectFeature objectFeature = (ObjectFeature)features.get(i); Apply apply = PMMLUtil.createApply(function, objectFeature.ref(), PMMLUtil.createConstant(epochDateTime.getYear(), DataType.INTEGER)); DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("days_since_year", objectFeature), OpType.CONTINUOUS, DataType.INTEGER, apply); result.add(new ContinuousFeature(encoder, derivedField)); } return result; }
@Override public Apply encodeApply(String function, Feature feature, int index, String term){ TfidfTransformer transformer = getTransformer(); Apply apply = super.encodeApply(function, feature, index, term); Boolean useIdf = transformer.getUseIdf(); if(useIdf){ Number weight = transformer.getWeight(index); apply.addExpressions(PMMLUtil.createConstant(weight)); } return apply; }
Apply apply = PMMLUtil.createApply("/", continuousFeature.ref(), PMMLUtil.createConstant(factor));
@Override public ContinuousFeature toContinuousFeature(){ Supplier<Apply> applySupplier = () -> { Feature feature = getFeature(); Number factor = getFactor(); return PMMLUtil.createApply("*", (feature.toContinuousFeature()).ref(), PMMLUtil.createConstant(factor)); }; return toContinuousFeature(name, DataType.DOUBLE, applySupplier); } };
public Apply createApply(){ DefineFunction defineFunction = getDefineFunction(); Feature feature = getFeature(); String value = getValue(); Constant constant = PMMLUtil.createConstant(value, DataType.STRING); return PMMLUtil.createApply(defineFunction.getName(), feature.ref(), constant); }
@Override public DefineFunction encodeDefineFunction(){ TfidfTransformer transformer = getTransformer(); DefineFunction defineFunction = super.encodeDefineFunction(); Expression expression = defineFunction.getExpression(); Boolean sublinearTf = transformer.getSublinearTf(); if(sublinearTf){ expression = PMMLUtil.createApply("+", PMMLUtil.createApply("log", expression), PMMLUtil.createConstant(1d)); } // End if Boolean useIdf = transformer.getUseIdf(); if(useIdf){ ParameterField weight = new ParameterField(FieldName.create("weight")); defineFunction.addParameterFields(weight); expression = PMMLUtil.createApply("*", expression, new FieldRef(weight.getName())); } defineFunction.setExpression(expression); return defineFunction; }