tf::Status SetExamples()

in tensorflow_decision_forests/tensorflow/ops/inference/kernel.cc [823:913]
81 lines of code
16 McCabe index (conditional complexity)

  tf::Status SetExamples(const InputTensors& inputs,
                         const FeatureIndex& feature_index,
                         serving::AbstractExampleSet* examples) const {
    const auto& features = engine_->features();
    examples->FillMissing(engine_->features());

    // Numerical features.
    for (const auto& feature : numerical_features_) {
      for (int example_idx = 0; example_idx < inputs.batch_size;
           example_idx++) {
        const float value =
            inputs.numerical_features(example_idx, feature.tensor_col);
        if (!std::isnan(value)) {
          examples->SetNumerical(example_idx, feature.example_set_id, value,
                                 features);
        } else {
          examples->SetMissingNumerical(example_idx, feature.example_set_id,
                                        features);
        }
      }
    }

    // Categorical int features.
    for (const auto& feature : categorical_int_features_) {
      const int max_value = engine_->features()
                                .data_spec()
                                .columns(feature.dataspec_idx)
                                .categorical()
                                .number_of_unique_values();
      for (int example_idx = 0; example_idx < inputs.batch_size;
           example_idx++) {
        int value =
            inputs.categorical_int_features(example_idx, feature.tensor_col);
        if (value == -1) {
          examples->SetMissingCategorical(example_idx, feature.example_set_id,
                                          features);
        } else {
          if (value < -1 || value >= max_value) {
            value = 0;
          }
          examples->SetCategorical(example_idx, feature.example_set_id, value,
                                   features);
        }
      }
    }

    // Categorical set int features.
    std::vector<int> tmp_values;
    for (const auto& feature : categorical_set_int_features_) {
      const int max_value = engine_->features()
                                .data_spec()
                                .columns(feature.dataspec_idx)
                                .categorical()
                                .number_of_unique_values();
      for (int example_idx = 0; example_idx < inputs.batch_size;
           example_idx++) {
        const auto status =
            ExtractCategoricalSetInt(inputs, feature_index, feature.tensor_col,
                                     max_value, example_idx, &tmp_values);
        if (!status.ok()) {
          return status;
        }

        if (!tmp_values.empty() && tmp_values.front() < 0) {
          examples->SetMissingCategoricalSet(example_idx,
                                             feature.example_set_id, features);
        } else {
          examples->SetCategoricalSet(example_idx, feature.example_set_id,
                                      tmp_values, features);
        }
      }
    }

    // Boolean features.
    for (const auto& feature : boolean_features_) {
      for (int example_idx = 0; example_idx < inputs.batch_size;
           example_idx++) {
        const float value =
            inputs.boolean_features(example_idx, feature.tensor_col);
        if (!std::isnan(value)) {
          examples->SetBoolean(example_idx, feature.example_set_id, value,
                               features);
        } else {
          examples->SetMissingBoolean(example_idx, feature.example_set_id,
                                      features);
        }
      }
    }

    return tf::Status::OK();
  }