How to use

org.jpmml.converter.ContinuousFeature

constructor

  @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));