How to use

ref

method

in

org.jpmml.converter.Feature

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

  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 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<Feature> encodeFeatures(SparkMLEncoder encoder){
    Tokenizer transformer = getTransformer();

    Feature feature = encoder.getOnlyFeature(transformer.getInputCol());

    Apply apply = PMMLUtil.createApply("lowercase", feature.ref());

    DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("lowercase", feature), OpType.CATEGORICAL, DataType.STRING, apply);

    return Collections.singletonList(new DocumentFeature(encoder, derivedField, "\\s+"));
  }
}

Apply apply = PMMLUtil.createApply("lowercase", feature.ref());

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

Apply apply = PMMLUtil.createApply("if", PMMLUtil.createApply("equal", feature.ref(), PMMLUtil.createConstant(value, feature.getDataType())), PMMLUtil.createConstant(posLabel), PMMLUtil.createConstant(negLabel));

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

@Override
public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){
  String function = getFunction();
  Boolean trimBlanks = getTrimBlanks();
  if(function == null && !trimBlanks){
    return features;
  }
  List<Feature> result = new ArrayList<>();
  for(Feature feature : features){
    Expression expression = feature.ref();
    if(function != null){
      expression = PMMLUtil.createApply(function, expression);
    } // End if
    if(trimBlanks){
      expression = PMMLUtil.createApply("trimBlanks", expression);
    }
    Field<?> field = encoder.toCategorical(feature.getName(), Collections.emptyList());
    // XXX: Should have been set by the previous transformer
    field.setDataType(DataType.STRING);
    DerivedField derivedField = encoder.createDerivedField(FeatureUtil.createName("normalize", feature), OpType.CATEGORICAL, DataType.STRING, expression);
    feature = new StringFeature(encoder, derivedField);
    result.add(feature);
  }
  return result;
}

  @Override
  public List<Feature> encodeFeatures(SparkMLEncoder encoder){
    RegexTokenizer transformer = getTransformer();

    if(!transformer.getGaps()){
      throw new IllegalArgumentException("Expected splitter mode, got token matching mode");
    } // End if

    if(transformer.getMinTokenLength() != 1){
      throw new IllegalArgumentException("Expected 1 as minimum token length, got " + transformer.getMinTokenLength() + " as minimum token length");
    }

    Feature feature = encoder.getOnlyFeature(transformer.getInputCol());

    Field<?> field = feature.getField();

    if(transformer.getToLowercase()){
      Apply apply = PMMLUtil.createApply("lowercase", feature.ref());

      field = encoder.createDerivedField(FeatureUtil.createName("lowercase", feature), OpType.CATEGORICAL, DataType.STRING, apply);
    }

    return Collections.singletonList(new DocumentFeature(encoder, field, transformer.getPattern()));
  }
}

return feature.ref();

case "keep":
    Apply setApply = PMMLUtil.createApply("isIn", feature.ref());
    Apply apply = PMMLUtil.createApply("if", setApply, feature.ref(), PMMLUtil.createConstant(invalidCategory, dataType));

apply.addExpressions(feature.ref());

Expression expression = feature.ref();
expression = PMMLUtil.createApply("if", expression, PMMLUtil.createConstant(replacementValue, feature.getDataType()), feature.ref());