MLPredictCodegen.cpp File Reference

#include "CodeGenerator.h"
#include "QueryEngine/TableFunctions/SystemFunctions/os/ML/MLModel.h"
#include "TreeModelPredictionMgr.h"
#include <tbb/parallel_for.h>
#include <stack>
#include <vector>

Include dependency graph for MLPredictCodegen.cpp:

Go to the source code of this file.

Functions
std::vector< std::shared_ptr < Analyzer::Expr > >	generated_encoded_and_casted_features (const std::vector< std::shared_ptr< Analyzer::Expr >> &feature_exprs, const std::vector< std::vector< std::string >> &cat_feature_keys, const std::vector< int64_t > &feature_permutations, Executor *executor)

Function Documentation

std::vector<std::shared_ptr<Analyzer::Expr> > generated_encoded_and_casted_features	(	const std::vector< std::shared_ptr< Analyzer::Expr >> &	feature_exprs,
		const std::vector< std::vector< std::string >> &	cat_feature_keys,
		const std::vector< int64_t > &	feature_permutations,
		Executor *	executor
	)

Definition at line 30 of file MLPredictCodegen.cpp.

References CHECK, Datum::doubleval, Datum::intval, kBOOLEAN, kCAST, kDOUBLE, kEQ, kINT, kISNULL, and kONE.

Referenced by CodeGenerator::codegen(), CodeGenerator::codegenLinRegPredict(), and CodeGenerator::codegenTreeRegPredict().

                        {
  std::vector<std::shared_ptr<Analyzer::Expr>> casted_feature_exprs;
  const size_t num_feature_exprs = feature_exprs.size();
  const size_t num_cat_features = cat_feature_keys.size();

  if (num_cat_features > num_feature_exprs) {
    throw std::runtime_error("More categorical keys than features.");
  }

  auto get_int_constant_expr = [](int32_t const_val) {
    Datum d;
    d.intval = const_val;
    return makeExpr<Analyzer::Constant>(SQLTypeInfo(kINT, false), false, d);
  };

  for (size_t original_feature_idx = 0; original_feature_idx < num_feature_exprs;
       ++original_feature_idx) {
    const auto feature_idx = feature_permutations.empty()
                                 ? original_feature_idx
                                 : feature_permutations[original_feature_idx];
    auto& feature_expr = feature_exprs[feature_idx];
    const auto& feature_ti = feature_expr->get_type_info();
    if (feature_ti.is_number()) {
      // Don't conditionally cast to double iff type is not double
      // as this was causing issues for the random forest function with
      // mixed types. Need to troubleshoot more but always casting to double
      // regardless of the underlying type always seems to be safe
      casted_feature_exprs.emplace_back(makeExpr<Analyzer::UOper>(
          SQLTypeInfo(kDOUBLE, false), false, kCAST, feature_expr));
    } else {
      CHECK(feature_ti.is_string()) << "Expected text type";
      if (!feature_ti.is_text_encoding_dict()) {
        throw std::runtime_error("Expected dictionary-encoded text column.");
      }
      if (original_feature_idx >= num_cat_features) {
        throw std::runtime_error("Model not trained on text type for column.");
      }
      const auto& str_dict_key = feature_ti.getStringDictKey();
      const auto str_dict_proxy = executor->getStringDictionaryProxy(str_dict_key, true);
      for (const auto& cat_feature_key : cat_feature_keys[original_feature_idx]) {
        // For one-hot encoded columns, null values will translate as a 0.0 and not a null
        // We are computing the following:
        // CASE WHEN str_val is NULL then 0.0 ELSE
        // CAST(str_id = one_hot_encoded_str_id AS DOUBLE) END

        // Check if the expression is null
        auto is_null_expr = makeExpr<Analyzer::UOper>(
            SQLTypeInfo(kBOOLEAN, false), false, kISNULL, feature_expr);
        Datum zero_datum;
        zero_datum.doubleval = 0.0;
        // If null then emit a 0.0 double constant as the THEN expr
        auto is_null_then_expr =
            makeExpr<Analyzer::Constant>(SQLTypeInfo(kDOUBLE, false), false, zero_datum);
        std::list<
            std::pair<std::shared_ptr<Analyzer::Expr>, std::shared_ptr<Analyzer::Expr>>>
            when_then_exprs;
        when_then_exprs.emplace_back(std::make_pair(is_null_expr, is_null_then_expr));
        // The rest of/core string test logic goes in the ELSE statement
        // Get the string id of the one-hot feature
        const auto str_id = str_dict_proxy->getIdOfString(cat_feature_key);
        auto str_id_expr = get_int_constant_expr(str_id);
        // Get integer id for this row's string
        auto key_for_string_expr = makeExpr<Analyzer::KeyForStringExpr>(feature_expr);

        // Check if this row's string id is equal to the search one-hot encoded id
        std::shared_ptr<Analyzer::Expr> str_equality_expr =
            makeExpr<Analyzer::BinOper>(SQLTypeInfo(kBOOLEAN, false),
                                        false,
                                        kEQ,
                                        kONE,
                                        key_for_string_expr,
                                        str_id_expr);
        // Cast the above boolean results to a double, 0.0 or 1.0
        auto cast_expr = makeExpr<Analyzer::UOper>(
            SQLTypeInfo(kDOUBLE, false), false, kCAST, str_equality_expr);

        // Generate the full CASE statement and add to the casted feature exprssions
        casted_feature_exprs.emplace_back(makeExpr<Analyzer::CaseExpr>(
            SQLTypeInfo(kDOUBLE, false), false, when_then_exprs, cast_expr));
      }
    }
  }
  return casted_feature_exprs;
}

Here is the caller graph for this function: