ShowModelFeatureDetailsCommand Class Reference

#include <DdlCommandExecutor.h>

Inheritance diagram for ShowModelFeatureDetailsCommand:

Collaboration diagram for ShowModelFeatureDetailsCommand:

Public Member Functions
	ShowModelFeatureDetailsCommand (const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)
ExecutionResult	execute (bool read_only_mode) override
Public Member Functions inherited from DdlCommand
	DdlCommand (const DdlCommandData &ddl_data, std::shared_ptr< Catalog_Namespace::SessionInfo const > session_ptr)

Private Member Functions
std::vector< TargetMetaInfo >	prepareLabelInfos () const
std::pair< std::vector< double > , std::vector< std::vector < double > > >	extractExtraMetadata (std::shared_ptr< AbstractMLModel > model, std::vector< TargetMetaInfo > &label_infos) const
std::vector < RelLogicalValues::RowValues >	prepareLogicalValues (const MLModelMetadata &model_metadata, const std::vector< std::vector< std::string >> &cat_sub_features, std::vector< double > &extra_metadata, const std::vector< std::vector< double >> &eigenvectors, const std::vector< int64_t > &inverse_permutations) const

Additional Inherited Members
Protected Attributes inherited from DdlCommand
const DdlCommandData &	ddl_data_
std::shared_ptr < Catalog_Namespace::SessionInfo const >	session_ptr_

Detailed Description

Definition at line 295 of file DdlCommandExecutor.h.

Constructor & Destructor Documentation

ShowModelFeatureDetailsCommand::ShowModelFeatureDetailsCommand	(	const DdlCommandData &	ddl_data,
		std::shared_ptr< Catalog_Namespace::SessionInfo const >	session_ptr
	)

Definition at line 2197 of file DdlCommandExecutor.cpp.

References g_enable_ml_functions, and g_restrict_ml_model_metadata_to_superusers.

    : DdlCommand(ddl_data, session_ptr) {
  if (!g_enable_ml_functions) {
    throw std::runtime_error(
        "Cannot show model feature details. ML functions are disabled.");
  }
  if (g_restrict_ml_model_metadata_to_superusers) {
    // Check if user is super user
    const auto& current_user = session_ptr->get_currentUser();
    if (!current_user.isSuper) {
      throw std::runtime_error(
          "Cannot show model feature details. Showing model information to "
          "non-superusers is "
          "disabled.");
    }
  }
}

Member Function Documentation

ExecutionResult ShowModelFeatureDetailsCommand::execute ( bool  read_only_mode )

overridevirtual

Executes the DDL command corresponding to provided JSON payload.

Parameters

_return

result of DDL command execution (if applicable)

Implements DdlCommand.

Definition at line 2347 of file DdlCommandExecutor.cpp.

References CHECK, ResultSetLogicalValuesBuilder::create(), DdlCommand::ddl_data_, extractExtraMetadata(), anonymous_namespace{DdlCommandExecutor.cpp}::extractPayload(), g_ml_models, legacylockmgr::getExecuteReadLock(), MLModelMap::getModel(), prepareLabelInfos(), and prepareLogicalValues().

Referenced by heavydb.cursor.Cursor::executemany().

                                                                           {
  auto execute_read_lock = legacylockmgr::getExecuteReadLock();
  auto& ddl_payload = extractPayload(ddl_data_);
  CHECK(ddl_payload.HasMember("modelName")) << "Model name missing.";
  const auto model_name = ddl_payload["modelName"].GetString();
  const auto model = g_ml_models.getModel(model_name);
  const auto model_metadata = model->getModelMetadata();
  // const auto& features = model_metadata.getFeatures();
  // const auto model_type = model_metadata.getModelType();
  const auto& feature_permutations = model_metadata.getFeaturePermutations();

  std::vector<int64_t> inverse_permutations(feature_permutations.size());
  for (int64_t perm_idx = 0; perm_idx < static_cast<int64_t>(feature_permutations.size());
       ++perm_idx) {
    inverse_permutations[feature_permutations[perm_idx]] = perm_idx;
  }

  auto label_infos = prepareLabelInfos();
  auto [extra_metadata, eigenvectors] = extractExtraMetadata(model, label_infos);

  // Todo(todd): Make cat_sub_features accessible from MLModelMetadata so we don't have to
  // access and pass it separately
  const auto& cat_sub_features = model->getCatFeatureKeys();
  auto logical_values = prepareLogicalValues(model_metadata,
                                             cat_sub_features,
                                             extra_metadata,
                                             eigenvectors,
                                             inverse_permutations);

  // Create ResultSet
  std::shared_ptr<ResultSet> rSet = std::shared_ptr<ResultSet>(
      ResultSetLogicalValuesBuilder::create(label_infos, logical_values));

  return ExecutionResult(rSet, label_infos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< std::vector< double >, std::vector< std::vector< double > > > ShowModelFeatureDetailsCommand::extractExtraMetadata ( std::shared_ptr< AbstractMLModel >  model, std::vector< TargetMetaInfo > &  label_infos  ) const

private

Definition at line 2227 of file DdlCommandExecutor.cpp.

References CHECK_EQ, LinearRegressionModel::getCoefs(), PcaModel::getEigenvalues(), kDOUBLE, kTEXT, LINEAR_REG, PCA, and RANDOM_FOREST_REG.

Referenced by execute().

                                                  {
  std::vector<double> extra_metadata;
  std::vector<std::vector<double>> eigenvectors;

  switch (model->getModelType()) {
    case MLModelType::LINEAR_REG: {
      label_infos.emplace_back("coefficient", SQLTypeInfo(kDOUBLE, true));
      const auto linear_reg_model =
          std::dynamic_pointer_cast<LinearRegressionModel>(model);
      extra_metadata = linear_reg_model->getCoefs();
      break;
    }
#ifdef HAVE_ONEDAL
    case MLModelType::RANDOM_FOREST_REG: {
      const auto random_forest_reg_model =
          std::dynamic_pointer_cast<RandomForestRegressionModel>(model);
      extra_metadata = random_forest_reg_model->getVariableImportanceScores();
      if (!extra_metadata.empty()) {
        label_infos.emplace_back("feature_importance", SQLTypeInfo(kDOUBLE, true));
      }
      break;
    }
    case MLModelType::PCA: {
      label_infos.emplace_back("eigenvalue", SQLTypeInfo(kDOUBLE, true));
      label_infos.emplace_back("eigenvector", SQLTypeInfo(kTEXT, true));
      const auto pca_model = std::dynamic_pointer_cast<PcaModel>(model);
      extra_metadata = pca_model->getEigenvalues();
      eigenvectors = pca_model->getEigenvectors();
      CHECK_EQ(eigenvectors.size(), extra_metadata.size());
      break;
    }
#endif  // HAVE_ONEDAL
    default: {
      break;
    }
  }

  return std::make_pair(std::move(extra_metadata), std::move(eigenvectors));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< TargetMetaInfo > ShowModelFeatureDetailsCommand::prepareLabelInfos ( ) const

private

Definition at line 2217 of file DdlCommandExecutor.cpp.

References kBIGINT, and kTEXT.

Referenced by execute().

                                                                                  {
  std::vector<TargetMetaInfo> label_infos;
  label_infos.emplace_back("feature_id", SQLTypeInfo(kBIGINT, true));
  label_infos.emplace_back("feature", SQLTypeInfo(kTEXT, true));
  label_infos.emplace_back("sub_feature_id", SQLTypeInfo(kBIGINT, true));
  label_infos.emplace_back("sub_feature", SQLTypeInfo(kTEXT, true));
  return label_infos;
}

Here is the caller graph for this function:

std::vector< RelLogicalValues::RowValues > ShowModelFeatureDetailsCommand::prepareLogicalValues ( const MLModelMetadata &  model_metadata, const std::vector< std::vector< std::string >> &  cat_sub_features, std::vector< double > &  extra_metadata, const std::vector< std::vector< double >> &  eigenvectors, const std::vector< int64_t > &  inverse_permutations  ) const

private

Definition at line 2270 of file DdlCommandExecutor.cpp.

References anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralBigInt(), anonymous_namespace{DdlCommandExecutor.cpp}::genLiteralDouble(), genLiteralStr(), MLModelMetadata::getFeatures(), MLModelMetadata::getModelType(), and LINEAR_REG.

Referenced by execute().

                                                          {
  std::vector<RelLogicalValues::RowValues> logical_values;
  const auto model_type = model_metadata.getModelType();
  if (model_type == MLModelType::LINEAR_REG) {
    logical_values.emplace_back(RelLogicalValues::RowValues{});
    logical_values.back().emplace_back(genLiteralBigInt(0));
    logical_values.back().emplace_back(genLiteralStr("intercept"));
    logical_values.back().emplace_back(genLiteralBigInt(1));
    logical_values.back().emplace_back(genLiteralStr(""));
    logical_values.back().emplace_back(genLiteralDouble(extra_metadata[0]));
    extra_metadata.erase(extra_metadata.begin());
  }
  const auto& features = model_metadata.getFeatures();
  const int64_t num_features = static_cast<int64_t>(features.size());
  std::vector<int64_t> physical_feature_idx_prefix_sums = {0};
  for (int64_t feature_idx = 1; feature_idx < num_features; ++feature_idx) {
    if (feature_idx - 1 < static_cast<int64_t>(cat_sub_features.size())) {
      physical_feature_idx_prefix_sums.emplace_back(
          physical_feature_idx_prefix_sums.back() +
          static_cast<int64_t>(cat_sub_features[feature_idx - 1].size()));
    } else {
      physical_feature_idx_prefix_sums.emplace_back(
          physical_feature_idx_prefix_sums.back() + 1);
    }
  }
  for (int64_t original_feature_idx = 0; original_feature_idx < num_features;
       ++original_feature_idx) {
    const auto feature_idx = inverse_permutations.empty()
                                 ? original_feature_idx
                                 : inverse_permutations[original_feature_idx];
    int64_t num_sub_features =
        feature_idx >= static_cast<int64_t>(cat_sub_features.size())
            ? 0
            : static_cast<int64_t>(cat_sub_features[feature_idx].size());
    const bool has_sub_features = num_sub_features > 0;
    num_sub_features = num_sub_features == 0 ? 1 : num_sub_features;
    int64_t physical_feature_idx = physical_feature_idx_prefix_sums[feature_idx];
    for (int64_t sub_feature_idx = 0; sub_feature_idx < num_sub_features;
         ++sub_feature_idx) {
      logical_values.emplace_back(RelLogicalValues::RowValues{});
      // Make feature id one-based
      logical_values.back().emplace_back(genLiteralBigInt(original_feature_idx + 1));
      logical_values.back().emplace_back(genLiteralStr(features[original_feature_idx]));
      logical_values.back().emplace_back(genLiteralBigInt(sub_feature_idx + 1));
      if (has_sub_features) {
        logical_values.back().emplace_back(
            genLiteralStr(cat_sub_features[feature_idx][sub_feature_idx]));
      } else {
        logical_values.back().emplace_back(genLiteralStr(""));
      }
      if (!extra_metadata.empty()) {
        logical_values.back().emplace_back(
            genLiteralDouble(extra_metadata[physical_feature_idx]));
      }
      if (!eigenvectors.empty()) {
        std::ostringstream eigenvector_oss;
        eigenvector_oss << "[";
        for (size_t i = 0; i < eigenvectors[physical_feature_idx].size(); ++i) {
          if (i > 0) {
            eigenvector_oss << ", ";
          }
          eigenvector_oss << eigenvectors[physical_feature_idx][i];
        }
        eigenvector_oss << "]";
        logical_values.back().emplace_back(genLiteralStr(eigenvector_oss.str()));
      }
      physical_feature_idx++;
    }
  }
  return logical_values;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Catalog/DdlCommandExecutor.h
• /home/jenkins-slave/workspace/core-os-doxygen/Catalog/DdlCommandExecutor.cpp