@Override public ContinuousFeature toContinuousFeature(){ PMMLEncoder encoder = ensureEncoder(); return new ContinuousFeature(encoder, this); } };
@Override public ContinuousFeature toContinuousFeature(){ PMMLEncoder encoder = getEncoder(); DerivedField derivedField = (DerivedField)encoder.toContinuous(getName()); return new ContinuousFeature(encoder, derivedField); } };
public void addFeature(Field<?> field){ Feature feature; OpType opType = field.getOpType(); switch(opType){ case CATEGORICAL: feature = new CategoricalFeature(this, (DataField)field); break; case CONTINUOUS: feature = new ContinuousFeature(this, field); break; default: throw new IllegalArgumentException(); } addFeature(feature); }
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ String expr = getExpr(); Expression expression = ExpressionTranslator.translate(expr, features); DerivedField derivedField = encoder.createDerivedField(FieldName.create("eval(" + expr + ")"), expression); return Collections.singletonList(new ContinuousFeature(encoder, derivedField)); }
@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; }
public void addFeature(DataField dataField){ OpType opType = dataField.getOpType(); switch(opType){ case CONTINUOUS: addFeature(new ContinuousFeature(this, dataField)); break; case CATEGORICAL: addFeature(new CategoricalFeature(this, dataField)); break; default: throw new IllegalArgumentException(); } }
@Override public Feature apply(Model model){ Output output = model.getOutput(); if(output == null || !output.hasOutputFields()){ throw new IllegalArgumentException(); } OutputField outputField = Iterables.getLast(output.getOutputFields()); return new ContinuousFeature(null, outputField.getName(), outputField.getDataType()); } };
@Override public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){ UFunc func = getFunc(); if(func == null){ return features; } List<Feature> result = new ArrayList<>(); for(int i = 0; i < features.size(); i++){ ContinuousFeature continuousFeature = (features.get(i)).toContinuousFeature(); DerivedField derivedField = encoder.ensureDerivedField(FeatureUtil.createName(func.getName(), continuousFeature), OpType.CONTINUOUS, DataType.DOUBLE, () -> encodeUFunc(func, continuousFeature.ref())); result.add(new ContinuousFeature(encoder, derivedField)); } return result; }
@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){ String function = getFunction(); if(features.size() <= 1){ return features; } Apply apply = new Apply(translateFunction(function)); for(Feature feature : features){ apply.addExpressions(feature.ref()); } FieldName name = FeatureUtil.createName(function, features); DerivedField derivedField = encoder.createDerivedField(name, OpType.CONTINUOUS, DataType.DOUBLE, apply); return Collections.singletonList(new ContinuousFeature(encoder, derivedField)); }
@Override public List<OutputField> registerOutputFields(Label label, SparkMLEncoder encoder){ T model = getTransformer(); String predictionCol = model.getPredictionCol(); OutputField predictedField = ModelUtil.createPredictedField(FieldName.create(predictionCol), label.getDataType(), OpType.CONTINUOUS); encoder.putOnlyFeature(predictionCol, new ContinuousFeature(encoder, predictedField)); return Collections.singletonList(predictedField); } }
@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; }
public List<Feature> getFeatures(String column){ List<Feature> features = this.columnFeatures.get(column); if(features == null){ FieldName name = FieldName.create(column); DataField dataField = getDataField(name); if(dataField == null){ dataField = createDataField(name); } Feature feature; DataType dataType = dataField.getDataType(); switch(dataType){ case STRING: feature = new WildcardFeature(this, dataField); break; case INTEGER: case DOUBLE: feature = new ContinuousFeature(this, dataField); break; case BOOLEAN: feature = new BooleanFeature(this, dataField); break; default: throw new IllegalArgumentException("Data type " + dataType + " is not supported"); } return Collections.singletonList(feature); } return features; }
@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; }
feature = new ContinuousFeature(encoder, derivedField);
features.set(i, new ContinuousFeature(encoder, derivedField));
@Override public void addFeature(Feature feature){ FieldName name = FeatureUtil.getName(feature); DataField dataField = getDataField(name); if(dataField != null){ Expression expression = feature.ref(); Expression transformedExpression = encodeExpression(name, expression); if(!(expression).equals(transformedExpression)){ DerivedField derivedField = createDerivedField(FieldName.create("preProcess(" + name.getValue() + ")"), OpType.CONTINUOUS, DataType.DOUBLE, transformedExpression); feature = new ContinuousFeature(PreProcessEncoder.this, derivedField); } } super.addFeature(feature); }
public static PMML encodePMML(FieldName targetField, List<String> targetCategories, FeatureList featureList, List<RegressionTree> regTrees, float base_score){ LSBoostEncoder encoder = new LSBoostEncoder(); if(targetField == null){ targetField = FieldName.create("_target"); } Label label = encodeLabel(targetField, targetCategories, encoder); //todo List<Feature> features = new ArrayList<>(); for (int i=0;i<featureList.size();i++){ FieldName fieldName = new FieldName("feature_"+i); DataField dataField = encoder.createDataField(fieldName, OpType.CONTINUOUS, DataType.FLOAT); Feature feature = new ContinuousFeature(encoder, dataField); features.add(feature); } Schema schema = new Schema(label, features); MiningModel miningModel = encodeMiningModel(regTrees, base_score, schema); PMML pmml = encoder.encodePMML(miningModel); return pmml; }
public static PMML encodePMML(FieldName targetField, List<String> targetCategories, FeatureList featureList, List<List<RegressionTree>> regTrees, float base_score, int numClasses){ LKBoostEncoder encoder = new LKBoostEncoder(); if(targetField == null){ targetField = FieldName.create("_target"); } Label label = encodeLabel(targetField, targetCategories, encoder, numClasses); //todo List<Feature> features = new ArrayList<>(); for (int i=0;i<featureList.size();i++){ FieldName fieldName = new FieldName("feature_"+i); DataField dataField = encoder.createDataField(fieldName, OpType.CONTINUOUS, DataType.FLOAT); Feature feature = new ContinuousFeature(encoder, dataField); features.add(feature); } Schema schema = new Schema(label, features); MiningModel miningModel = encodeMiningModel(regTrees, base_score, schema); PMML pmml = encoder.encodePMML(miningModel); return pmml; }
result.add(new ContinuousFeature(encoder, derivedField));