metric_params = {"VI": VI} weights = operator.raw_operator.weights if weights not in ["uniform", "distance"]: raise NotImplementedError( "Hummingbird currently supports only the weights type 'uniform' and 'distance' for KNeighbors" + "Classifier" if is_classifier else "Regressor") train_data = operator.raw_operator._fit_X train_labels = operator.raw_operator._y n_neighbors = operator.raw_operator.n_neighbors return KNeighborsModel( train_data, train_labels, n_neighbors, weights, classes, extra_config[constants.BATCH_SIZE], is_classifier, metric_type, metric_params, ) register_converter("SklearnKNeighborsClassifier", convert_sklearn_kneighbors_classification_model) register_converter("SklearnKNeighborsRegressor", convert_sklearn_kneighbors_regression_model)
# -------------------------------------------------------------------------- from onnxconverter_common.registration import register_converter from .._normalizer_implementations import Normalizer """ Converter for ONNX-ML Normalizer. """ def convert_onnx_normalizer(operator, device=None, extra_config={}): """ Converter for `ai.onnx.ml.Normalizer` Args: operator: An operator wrapping a `ai.onnx.ml.Normalizer` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ raw_operator = operator.raw_operator.origin.attribute[0].s.lower().decode( "UTF-8") # (ex: b'L1' to 'l1') if raw_operator is None or raw_operator == "": raise RuntimeError("Error parsing Normalizer, found unexpected None") return Normalizer(raw_operator, device) register_converter("ONNXMLNormalizer", convert_onnx_normalizer)
Converter for `sklearn.tree.DecisionTreeRegressor`. Args: operator: An operator wrapping a `sklearn.tree.DecisionTreeRegressor` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None operator.raw_operator.estimators_ = [operator.raw_operator] return convert_sklearn_random_forest_regressor(operator, device, extra_config) # Register the converters. register_converter("SklearnDecisionTreeClassifier", convert_sklearn_decision_tree_classifier) register_converter("SklearnDecisionTreeRegressor", convert_sklearn_decision_tree_regressor) register_converter("SklearnExtraTreesClassifier", convert_sklearn_random_forest_classifier) register_converter("SklearnExtraTreesRegressor", convert_sklearn_random_forest_regressor) register_converter("SklearnRandomForestClassifier", convert_sklearn_random_forest_classifier) register_converter("SklearnRandomForestRegressor", convert_sklearn_random_forest_regressor)
def convert_sparkml_bucketizer(operator, device, extra_config): """ Converter for `pyspark.ml.feature.Bucketizer` Args: operator: An operator wrapping a `pyspark.ml.feature.QuantileDiscretizer` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ bin_edges = [operator.raw_operator.getSplits()] max_bin_edges = len(bin_edges[0]) labels = [] for i in range(len(bin_edges)): bin_edges[i][0] = bin_edges[i][0] - 1e-3 bin_edges[i][-1] = bin_edges[i][-1] + 1e-3 labels.append(np.array([i for i in range(len(bin_edges[i]) - 1)])) if len(bin_edges[i]) < max_bin_edges: bin_edges[i] = ( bin_edges[i] + [np.inf for _ in range((max_bin_edges - len(bin_edges[i])))]) return KBinsDiscretizer(None, np.array(bin_edges), labels, device) register_converter("SparkMLBucketizer", convert_sparkml_bucketizer)
extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ if operator.raw_operator.kernel in ["linear", "poly", "rbf", "sigmoid"]: # https://stackoverflow.com/questions/20113206/scikit-learn-svc-decision-function-and-predict kernel = operator.raw_operator.kernel degree = operator.raw_operator.degree classes = operator.raw_operator.classes_ sv = operator.raw_operator.support_vectors_ nv = operator.raw_operator.n_support_ a = operator.raw_operator.dual_coef_ b = operator.raw_operator.intercept_ coef0 = operator.raw_operator.coef0 if hasattr(operator.raw_operator, "_gamma"): gamma = operator.raw_operator._gamma else: # TODO: which versions is this case for, and how to test? gamma = operator.raw_operator.gamma return SVC(kernel, degree, sv, nv, a, b, gamma, coef0, classes, device) else: raise RuntimeError("Unsupported kernel for SVC: {}".format( operator.raw_operator.kernel)) register_converter("SklearnSVC", convert_sklearn_svc_model) register_converter("SklearnNuSVC", convert_sklearn_svc_model)
# license information. # -------------------------------------------------------------------------- """ Converter for ONNX-ML Array Feature Vectorizer. """ from onnxconverter_common.registration import register_converter from .. import constants from .._pipeline_implementations import Concat def convert_onnx_feature_vectorizer(operator, device, extra_config): """ Converter for `ai.onnx.ml.FeatureVectorizer. Args: operator: An operator wrapping a `ai.onnx.ml.FeatureVectorizer` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" return Concat(operator) register_converter("ONNXMLFeatureVectorizer", convert_onnx_feature_vectorizer)
tree_parameters, max_depth, tree_type = get_tree_params_and_type(tree_infos, _get_parameters_for_sklearn_iforest, extra_config) # Generate the tree implementation based on the selected strategy. if tree_type == TreeImpl.gemm: net_parameters = [ get_parameters_for_gemm_common( tree_param.lefts, tree_param.rights, tree_param.features, tree_param.thresholds, tree_param.values, n_features ) for tree_param in tree_parameters ] return GEMMIsolationForestImpl(net_parameters, n_features, classes, extra_config=extra_config) net_parameters = [ get_parameters_for_tree_trav_sklearn( tree_param.lefts, tree_param.rights, tree_param.features, tree_param.thresholds, tree_param.values ) for tree_param in tree_parameters ] if tree_type == TreeImpl.tree_trav: return TreeTraversalIsolationForestImpl(net_parameters, max_depth, n_features, classes, extra_config=extra_config) else: # Remaining possible case: tree_type == TreeImpl.perf_tree_trav return PerfectTreeTraversalIsolationForestImpl(net_parameters, max_depth, n_features, classes, extra_config=extra_config) # Register the converters. register_converter("SklearnIsolationForest", convert_sklearn_isolation_forest)
def convert_sklearn_gaussian_naive_bayes(operator, device, extra_config): """ Converter for `sklearn.naive_bayes.GaussianNB` Args: operator: An operator wrapping a `sklearn.naive_bayes.GaussianNB` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" model = operator.raw_operator classes = model.classes_ if not all([type(x) in [int, np.int32, np.int64] for x in classes]): raise RuntimeError( "Hummingbird supports only integer labels for class labels.") jll_calc_bias = np.log(model.class_prior_.reshape(-1, 1)) - 0.5 * np.sum( np.log(2.0 * np.pi * model.sigma_), 1).reshape(-1, 1) return GaussianNBModel(operator, classes, jll_calc_bias, model.theta_, model.sigma_, device) register_converter("SklearnBernoulliNB", convert_sklearn_bernouli_naive_bayes) register_converter("SklearnGaussianNB", convert_sklearn_gaussian_naive_bayes) register_converter("SklearnMultinomialNB", convert_sklearn_multinomial_naive_bayes)
device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None operator = operator.raw_operator coefficients = intercepts = None for attr in operator.origin.attribute: if attr.name == "coefficients": coefficients = np.array([[np.array(val).astype("float32")] for val in attr.floats]).astype("float32") elif attr.name == "intercepts": intercepts = np.array(attr.floats).astype("float32") if any(v is None for v in [coefficients, intercepts]): raise RuntimeError( "Error parsing LinearRegression, found unexpected None") return LinearModel(coefficients, intercepts, device, is_linear_regression=True) register_converter("ONNXMLLinearClassifier", convert_onnx_linear_model) register_converter("ONNXMLLinearRegressor", convert_onnx_linear_regression_model)
return LinearModel(operator, coefficients, intercepts, device, classes=classes, multi_class=multi_class, loss=loss) def convert_sklearn_linear_regression_model(operator, device, extra_config): """ Converter for `sklearn.linear_model.LinearRegression` Args: operator: An operator wrapping a `sklearn.linear_model.LinearRegression` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" coefficients = operator.raw_operator.coef_.transpose().astype("float32") if len(coefficients.shape) == 1: coefficients = coefficients.reshape(-1, 1) intercepts = operator.raw_operator.intercept_.reshape(1, -1).astype("float32") return LinearModel(operator, coefficients, intercepts, device, is_linear_regression=True) register_converter("SklearnLinearRegression", convert_sklearn_linear_regression_model) register_converter("SklearnLogisticRegression", convert_sklearn_linear_model) register_converter("SklearnLinearSVC", convert_sklearn_linear_model) register_converter("SklearnSGDClassifier", convert_sklearn_linear_model) register_converter("SklearnLogisticRegressionCV", convert_sklearn_linear_model)
import numpy as np from onnxconverter_common.registration import register_converter from .._one_hot_encoder_implementations import OneHotEncoderString, OneHotEncoder def convert_sklearn_one_hot_encoder(operator, device, extra_config): """ Converter for `sklearn.preprocessing.OneHotEncoder` Args: operator: An operator wrapping a `sklearn.preprocessing.OneHotEncoder` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ if all([ np.array(c).dtype == object for c in operator.raw_operator.categories_ ]): categories = [[str(x) for x in c.tolist()] for c in operator.raw_operator.categories_] return OneHotEncoderString(categories, device) else: return OneHotEncoder(operator.raw_operator.categories_, device) register_converter("SklearnOneHotEncoder", convert_sklearn_one_hot_encoder)
weights = operator.raw_operator.coefs_ biases = operator.raw_operator.intercepts_ return MLPClassificationModel(operator, weights, biases, activation, classes, device) def convert_sklearn_mlp_regressor(operator, device, extra_config): """ Converter for `sklearn.neural_network.MLPRegressor` Args: operator: An operator wrapping a `sklearn.neural_network.MLPRegressor` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" activation = operator.raw_operator.activation weights = operator.raw_operator.coefs_ biases = operator.raw_operator.intercepts_ return MLPModel(operator, weights, biases, activation, device) register_converter("SklearnMLPClassifier", convert_sklearn_mlp_classifier) register_converter("SklearnMLPRegressor", convert_sklearn_mlp_regressor)
class KMeans(PhysicalOperator, torch.nn.Module): """ Class implementing Kmeans in PyTorch """ def __init__(self, logical_operator, centroids, device): super(KMeans, self).__init__(logical_operator, regression=True) self.centroids = torch.nn.Parameter(torch.FloatTensor(centroids), requires_grad=False) def forward(self, x): # Compute the Euclidean distance dist = torch.cdist(x, self.centroids, compute_mode="donot_use_mm_for_euclid_dist") label = torch.argmin(dist, dim=1) return label def convert_sklearn_kmeans_model(operator, device, extra_config): assert operator is not None, "Cannot convert None operator" centroids = operator.raw_operator.cluster_centers_ return KMeans(operator, centroids, device) register_converter("SklearnKMeans", convert_sklearn_kmeans_model) register_converter("SklearnMeanShift", convert_sklearn_kmeans_model)
else: return torch.isnan( torch.index_select(x, 1, self.column_indices)).float() else: if self.features == "all": return torch.eq(x, self.missing_values).float() else: return torch.eq(torch.index_select(x, 1, self.column_indices), self.missing_values).float() def convert_sklearn_missing_indicator(operator, device, extra_config): """ Converter for `sklearn.impute.MissingIndicator` Args: operator: An operator wrapping a `sklearn.impute.MissingIndicator` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" return MissingIndicator(operator, device) register_converter("SklearnImputer", convert_sklearn_simple_imputer) register_converter("SklearnSimpleImputer", convert_sklearn_simple_imputer) register_converter("SklearnMissingIndicator", convert_sklearn_missing_indicator)
""" assert operator is not None if "n_features" in extra_config: n_features = extra_config["n_features"] else: raise RuntimeError( 'XGBoost converter is not able to infer the number of input features.\ Please pass "n_features:N" as extra configuration to the converter or fill a bug report.' ) # Get tree information out of the model. tree_infos = operator.raw_operator.get_booster().get_dump() base_prediction = operator.raw_operator.base_score if base_prediction is None: base_prediction = [0.5] if type(base_prediction) is float: base_prediction = [base_prediction] extra_config[constants.BASE_PREDICTION] = base_prediction return convert_gbdt_common(tree_infos, _get_tree_parameters, n_features, extra_config=extra_config) # Register the converters. register_converter("SklearnXGBClassifier", convert_sklearn_xgb_classifier) register_converter("SklearnXGBRanker", convert_sklearn_xgb_regressor) register_converter("SklearnXGBRegressor", convert_sklearn_xgb_regressor)
from onnxconverter_common.registration import register_converter from .. import constants from .._array_feature_extractor_implementations import ArrayFeatureExtractor def convert_onnx_array_feature_extractor(operator, device, extra_config): """ Converter for `ai.onnx.ml.ArrayFeatureExtractor`. Args: operator: An operator wrapping a `ai.onnx.ml.ArrayFeatureExtractor` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" column_indices = [] initializers = extra_config[constants.ONNX_INITIALIZERS] column_indices = list( initializers[operator.raw_operator.origin.input[1]].int64_data) return ArrayFeatureExtractor(operator, column_indices, device) register_converter("ONNXMLArrayFeatureExtractor", convert_onnx_array_feature_extractor)
extra_config={}): """ Converter for `ai.onnx.ml.TreeEnsembleRegressor`. Args: operator: An operator wrapping a `ai.onnx.ml.TreeEnsembleRegressor` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" # Get tree informations from the operator. n_features, tree_infos, _, _ = _get_tree_infos_from_tree_ensemble( operator.raw_operator, device, extra_config) # Generate the model. return convert_gbdt_common(operator, tree_infos, _dummy_get_parameter, n_features, extra_config=extra_config) register_converter("ONNXMLTreeEnsembleClassifier", convert_onnx_tree_ensemble_classifier) register_converter("ONNXMLTreeEnsembleRegressor", convert_onnx_tree_ensemble_regressor)
return Scaler(operator.raw_operator.center_, scale, device) def convert_sklearn_max_abs_scaler(operator, device, extra_config): scale = operator.raw_operator.scale_ if scale is not None: scale = np.reciprocal(scale) return Scaler(0, scale, device) def convert_sklearn_min_max_scaler(operator, device, extra_config): scale = [x for x in operator.raw_operator.scale_] offset = [ -1.0 / x * y for x, y in zip(operator.raw_operator.scale_, operator.raw_operator.min_) ] return Scaler(offset, scale, device) def convert_sklearn_standard_scaler(operator, device, extra_config): scale = operator.raw_operator.scale_ if scale is not None: scale = np.reciprocal(scale) return Scaler(operator.raw_operator.mean_, scale, device) register_converter("SklearnRobustScaler", convert_sklearn_robust_scaler) register_converter("SklearnMaxAbsScaler", convert_sklearn_max_abs_scaler) register_converter("SklearnMinMaxScaler", convert_sklearn_min_max_scaler) register_converter("SklearnStandardScaler", convert_sklearn_standard_scaler)
Converter for `sklearn.preprocessing.KBinsDiscretizer` Args: operator: An operator wrapping a `sklearn.preprocessing.KBinsDiscretizer` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" bin_edges = [] max_bin_edges = 0 labels = [] for x in operator.raw_operator.bin_edges_: temp = x.flatten().tolist() bin_edges.append(temp) max_bin_edges = max(max_bin_edges, len(bin_edges[-1])) for i in range(len(bin_edges)): labels.append(np.array([i for i in range(len(bin_edges[i]) - 1)])) if len(bin_edges[i]) < max_bin_edges: bin_edges[i] = bin_edges[i] + [np.inf for _ in range((max_bin_edges - len(bin_edges[i])))] return KBinsDiscretizer(operator, operator.raw_operator.encode, operator.raw_operator.n_bins_, np.array(bin_edges), labels, device) register_converter("SklearnBinarizer", convert_sklearn_binarizer) register_converter("SklearnKBinsDiscretizer", convert_sklearn_k_bins_discretizer)
""" var = operator.raw_operator.variances_ threshold = operator.raw_operator.threshold indices = np.array([i for i in range(len(var)) if var[i] > threshold]) return ArrayFeatureExtractor(np.ascontiguousarray(indices), device) def convert_sklearn_select_percentile(operator, device, extra_config): """ Converter for `sklearn.feature_selection.SelectPercentile`. Args: operator: An operator wrapping a `sklearn.feature_selection.SelectPercentile` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ indices = np.array([ i for i, val in enumerate(operator.raw_operator.get_support()) if val ]) return ArrayFeatureExtractor(np.ascontiguousarray(indices), device) register_converter("SklearnSelectKBest", convert_sklearn_select_k_best) register_converter("SklearnVarianceThreshold", convert_sklearn_variance_threshold) register_converter("SklearnSelectPercentile", convert_sklearn_select_percentile)
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- """ Converter for scikit-learn Normalizer. """ from onnxconverter_common.registration import register_converter from .._normalizer_implementations import Normalizer def convert_sklearn_normalizer(operator, device, extra_config): """ Converter for `sklearn.preprocessing.Normalizer` Args: operator: An operator wrapping a `sklearn.preprocessing.Normalizer` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ return Normalizer(operator.raw_operator.norm, device) register_converter("SklearnNormalizer", convert_sklearn_normalizer)
# license information. # -------------------------------------------------------------------------- """ Converter for Spark-ML VectorAssembler """ import torch import numpy as np from onnxconverter_common.topology import Variable from onnxconverter_common.registration import register_converter from .._physical_operator import PhysicalOperator from .._pipeline_implementations import Concat def convert_sparkml_vector_assembler(operator, device, extra_config): """ Converter for `pyspark.ml.feature.VectorAssembler` Args: operator: An operator wrapping a `pyspark.ml.feature.VectorAssembler` device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ return Concat(operator) register_converter("SparkMLVectorAssembler", convert_sparkml_vector_assembler)
def convert_onnx_scaler(operator, device=None, extra_config={}): """ Converter for `ai.onnx.ml.Scaler` Args: operator: An operator wrapping a `ai.onnx.ml.Scaler` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ operator = operator.raw_operator offset = scale = None for attr in operator.origin.attribute: if attr.name == "offset": offset = np.array(attr.floats).astype("float32") if attr.name == "scale": scale = np.array(attr.floats).astype("float32") if any(v is None for v in [offset, scale]): raise RuntimeError("Error parsing Scalar, found unexpected None") return Scaler(offset, scale, device) register_converter("ONNXMLScaler", convert_onnx_scaler)
# Generate the model. return Concat() def convert_onnx_reshape(operator, device=None, extra_config={}): """ Converter for `ai.onnx.Reshape`. Args: operator: An operator wrapping a `ai.onnx.Reshape` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None shape = [] initializers = extra_config[constants.ONNX_INITIALIZERS] shape = list(initializers[operator.raw_operator.origin.input[1]].int64_data) # Generate the model. return Reshape(shape) register_converter("ONNXMLCast", convert_onnx_cast) register_converter("ONNXMLConcat", convert_onnx_concat) register_converter("ONNXMLReshape", convert_onnx_reshape)
operator: An operator wrapping a `sklearn.ensemble.HistGradientBoostingRegressor` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None # Get tree information out of the operator. tree_infos = operator.raw_operator._predictors tree_infos = [tree_infos[i][0] for i in range(len(tree_infos))] n_features = operator.raw_operator.n_features_ extra_config[constants.BASE_PREDICTION] = [[ operator.raw_operator._baseline_prediction ]] return convert_gbdt_common(tree_infos, _get_parameters_hist_gbdt, n_features, None, extra_config) # Register the converters. register_converter("SklearnGradientBoostingClassifier", convert_sklearn_gbdt_classifier) register_converter("SklearnGradientBoostingRegressor", convert_sklearn_gbdt_regressor) register_converter("SklearnHistGradientBoostingClassifier", convert_sklearn_hist_gbdt_classifier) register_converter("SklearnHistGradientBoostingRegressor", convert_sklearn_hist_gbdt_regressor)
raise RuntimeError("Error parsing LinearClassifier, found unexpected None") if multi_class is None: # if 'multi_class' attr was not present multi_class = "none" if len(classes) < 3 else "ovr" if operator.op_type == "LinearRegressor": is_linear_regression = True # Now reshape the coefficients/intercepts if len(classes) == 2: # for the binary case, it seems there is a duplicate copy of everything with opposite +/- sign. This just takes the correct copy coefficients = np.array([[np.array(val).astype("float32")] for val in coefficients[len(coefficients) // 2 :]]).astype( "float32" ) intercepts = np.array([[np.array(val).astype("float32")] for val in intercepts[len(intercepts) // 2 :]]).astype( "float32" ) elif len(classes) > 2: # intercepts are OK in this case. # reshape coefficients into tuples tmp = coefficients.reshape(len(classes), (len(coefficients) // len(classes))) # then unzip the zipmap format coefficients = np.array(list(zip(*tmp))) else: raise RuntimeError("Error parsing LinearClassifier, length of classes {} unexpected:{}".format(len(classes), classes)) return LinearModel( coefficients, intercepts, device, classes=classes, multi_class=multi_class, is_linear_regression=is_linear_regression ) register_converter("ONNXMLLinearClassifier", convert_onnx_linear_model)
def convert_sparkml_linear_model(operator, device, extra_config): """ Converter for `pyspark.ml.classification.LogisticRegressionModel` Args: operator: An operator wrapping a `pyspark.ml.classification.LogisticRegressionModel` device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ num_classes = operator.raw_operator.numClasses # Spark ML assumes the label column is encoded such that labels start from zero. classes = [i for i in range(num_classes)] coefficients = operator.raw_operator.coefficientMatrix.toArray().transpose().astype("float32") intercepts = operator.raw_operator.interceptVector.reshape(1, -1).astype("float32") if num_classes > 2: multi_class = "multinomial" else: multi_class = None return LinearModel(operator, coefficients, intercepts, device, classes=classes, multi_class=multi_class) register_converter("SparkMLLogisticRegressionModel", convert_sparkml_linear_model)
from .._label_encoder_implementations import NumericLabelEncoder, StringLabelEncoder def convert_onnx_label_encoder(operator, device=None, extra_config={}): """ Converter for `ai.onnx.ml.LabelEncoder` Args: operator: An operator wrapping a `ai.onnx.ml.LabelEncoder` model device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ for attr in operator.original_operator.origin.attribute: if attr.name == "keys_int64s": return NumericLabelEncoder(np.array(attr.ints), device) elif attr.name == "keys_strings": # Note that these lines will fail later on for pytorch < 1.8 keys = np.array([x.decode("UTF-8") for x in attr.strings]) return StringLabelEncoder(keys, device, extra_config) # If we reach here, we have a parsing error. raise RuntimeError( "Error parsing LabelEncoder, found unexpected None for keys") register_converter("ONNXMLLabelEncoder", convert_onnx_label_encoder)
extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None, "Cannot convert None operator" assert not hasattr(operator.raw_operator, "use_missing") or operator.raw_operator.use_missing assert not hasattr( operator.raw_operator, "zero_as_missing") or not operator.raw_operator.zero_as_missing # Get tree information out of the model. n_features = operator.raw_operator._n_features tree_infos = operator.raw_operator.booster_.dump_model()["tree_info"] if operator.raw_operator._objective == "tweedie": extra_config[constants.POST_TRANSFORM] = constants.TWEEDIE return convert_gbdt_common(operator, tree_infos, _get_tree_parameters, n_features, missing_val=None, extra_config=extra_config) # Register the converters. register_converter("SklearnLGBMClassifier", convert_sklearn_lgbm_classifier) register_converter("SklearnLGBMRanker", convert_sklearn_lgbm_regressor) register_converter("SklearnLGBMRegressor", convert_sklearn_lgbm_regressor)
Returns: A PyTorch model """ return Concat() def convert_sklearn_multiply(operator, device=None, extra_config={}): """ Converter for multiply operators injected when parsing Sklearn pipelines. Args: operator: An empty operator device: String defining the type of device the converted operator should be run on extra_config: Extra configuration used to select the best conversion strategy Returns: A PyTorch model """ assert operator is not None assert hasattr(operator, "operand") score = operator.operand # Generate the model. return Multiply(score) register_converter("SklearnArrayFeatureExtractor", convert_sklearn_array_feature_extractor) register_converter("SklearnConcat", convert_sklearn_concat) register_converter("SklearnMultiply", convert_sklearn_multiply)