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)
