Best code snippets using org.jpmml.converter.Feature.getName(Showing top 15 results out of 315)

@Override
public int hashCode(){
  int result = 0;
  result = (31 * result) + Objects.hashCode(this.getEncoder());
  result = (31 * result) + Objects.hashCode(this.getName());
  result = (31 * result) + Objects.hashCode(this.getDataType());
  return result;
}

static
public FieldName getName(Feature feature){
  if(feature instanceof HasDerivedName){
    HasDerivedName hasDerivedName = (HasDerivedName)feature;
    return hasDerivedName.getDerivedName();
  }
  return feature.getName();
}

public Predicate createSimpleSetPredicate(Feature feature, List<String> values){
  if(values.size() == 1){
    String value = values.get(0);
    return createSimplePredicate(feature, SimplePredicate.Operator.EQUAL, value);
  }
  Predicate predicate = new InternableSimpleSetPredicate()
    .setField(feature.getName())
    .setBooleanOperator(SimpleSetPredicate.BooleanOperator.IS_IN)
    .setArray(createArray(feature.getDataType(), values));
  return intern(predicate);
}

public Predicate createSimplePredicate(Feature feature, SimplePredicate.Operator operator, String value){
  Predicate predicate = new InternableSimplePredicate()
    .setField(feature.getName())
    .setOperator(operator)
    .setValue(value);
  return intern(predicate);
}

@Override
protected List<String> createInputColumns(List<Feature> features){
  List<String> result = new ArrayList<>();
  for(Feature feature : features){
    FieldName name = feature.getName();
    result.add(XMLUtil.createTagName(name.getValue()));
  }
  return result;
}

protected ToStringHelper toStringHelper(){
  return com.google.common.base.Objects.toStringHelper(this)
    .add("name", getName())
    .add("dataType", getDataType());
}

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

    TypeDefinitionField field = encoder.getField(feature.getName());

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

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

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

public void putFeatures(String column, List<Feature> features){
  List<Feature> existingFeatures = this.columnFeatures.get(column);
  if(existingFeatures != null && existingFeatures.size() > 0){
    if(features.size() != existingFeatures.size()){
      throw new IllegalArgumentException("Expected " + existingFeatures.size() + " features, got " + features.size() + " features");
    }
    for(int i = 0; i < existingFeatures.size(); i++){
      Feature existingFeature = existingFeatures.get(i);
      Feature feature = features.get(i);
      if(!(feature.getName()).equals(existingFeature.getName())){
        throw new IllegalArgumentException();
      }
    }
  }
  this.columnFeatures.put(column, features);
}

@Override
public boolean equals(Object object){
  if(object instanceof Feature){
    Feature that = (Feature)object;
    return (this.getClass()).equals(that.getClass()) && Objects.equals(this.getEncoder(), that.getEncoder()) && Objects.equals(this.getName(), that.getName()) && Objects.equals(this.getDataType(), that.getDataType());
  }
  return false;
}

static
private Predicate encodePredicate(Feature feature, Node node, boolean left){
  FieldName name = feature.getName();
  SimplePredicate.Operator operator;
  String value;

@Override
public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){
  List<?> classes = getClasses();
  ClassDictUtil.checkSize(1, features);
  Feature feature = features.get(0);
  List<String> categories = new ArrayList<>();
  for(int i = 0; i < classes.size(); i++){
    String category = ValueUtil.formatValue(classes.get(i));
    categories.add(category);
  }
  FieldName name = createName(feature);
  DerivedField derivedField = encoder.getDerivedField(name);
  if(derivedField == null){
    DocumentBuilder documentBuilder = DOMUtil.createDocumentBuilder();
    InlineTable inlineTable = new InlineTable();
    List<String> columns = Arrays.asList("input", "output");
    for(int i = 0; i < categories.size(); i++){
      List<String> values = Arrays.asList(categories.get(i), String.valueOf(i));
      Row row = DOMUtil.createRow(documentBuilder, columns, values);
      inlineTable.addRows(row);
    }
    encoder.toCategorical(feature.getName(), categories);
    MapValues mapValues = new MapValues()
      .addFieldColumnPairs(new FieldColumnPair(feature.getName(), columns.get(0)))
      .setOutputColumn(columns.get(1))
      .setInlineTable(inlineTable);
    derivedField = encoder.createDerivedField(name, OpType.CATEGORICAL, DataType.INTEGER, mapValues);
  }
  return Collections.<Feature>singletonList(new CategoricalFeature(encoder, derivedField, categories));
}

    result.add(new BinaryFeature(encoder, feature.getName(), DataType.STRING, category));
  } else
encoder.toCategorical(feature.getName(), categories);

static
public Feature encodeFeature(Feature feature, Object missingValue, Object replacementValue, MissingValueTreatmentMethod missingValueTreatmentMethod, SkLearnEncoder encoder){
  TypeDefinitionField field = encoder.getField(feature.getName());
    encoder.addDecorator(feature.getName(), missingValueDecorator);

@Override
public List<Feature> encodeFeatures(List<Feature> features, SkLearnEncoder encoder){
  List<? extends Number> values = getValues();
  ClassDictUtil.checkSize(1, features);
  Feature feature = features.get(0);
  List<String> categories = new ArrayList<>();
  List<Feature> result = new ArrayList<>();
  for(int i = 0; i < values.size(); i++){
    int value = ValueUtil.asInt(values.get(i));
    String category;
    if(feature instanceof CategoricalFeature){
      CategoricalFeature categoricalFeature = (CategoricalFeature)feature;
      category = categoricalFeature.getValue(value);
    } else
    if(feature instanceof WildcardFeature){
      WildcardFeature wildcardFeature = (WildcardFeature)feature;
      category = ValueUtil.formatValue((Integer)value);
    } else
    {
      throw new IllegalArgumentException();
    }
    categories.add(category);
    result.add(new BinaryFeature(encoder, feature.getName(), DataType.STRING, category));
  }
  encoder.toCategorical(feature.getName(), categories);
  return result;
}

public FieldRef ref(){
  return new FieldRef(getName());
}