def preprocess_dataframe_transformer_parser(scope,
model,
inputs,
custom_parsers=None):
if len(inputs) != len(model.args_):
raise RuntimeError(
f"Converter expects {len(model.args_)} inputs but got {len(inputs)}."
)
transformed_result_names = []
for i, col, dt, arg in model.args_:
if dt in (numpy.float32, numpy.float64):
op = scope.declare_local_operator('CustomDiscretizeTransformer')
op.inputs = [inputs[i]]
op.raw_operator = arg
op_var = scope.declare_local_variable(f'output{i}',
Int64TensorType())
op.outputs.append(op_var)
transformed_result_names.append(op.outputs[0])
elif dt == 'category':
transformed_result_names.append(
_parse_sklearn_simple_model(scope,
arg, [inputs[i]],
custom_parsers=custom_parsers)[0])
# Create a Concat ONNX node
concat_operator = scope.declare_local_operator('SklearnConcat')
concat_operator.inputs = transformed_result_names
union_name = scope.declare_local_variable('union', FloatTensorType())
concat_operator.outputs.append(union_name)
return concat_operator.outputs
def lightgbm_parser(scope, model, inputs, custom_parsers=None):
if hasattr(model, "fit"):
raise TypeError( # pragma: no cover
"This converter does not apply on type '{}'."
"".format(type(model)))
if len(inputs) == 1:
wrapped = WrappedBooster(model)
objective = wrapped.get_objective()
if objective.startswith('binary'):
wrapped = WrappedLightGbmBoosterClassifier(wrapped)
return _parse_sklearn_classifier(
scope, wrapped, inputs, custom_parsers=custom_parsers)
if objective.startswith('multiclass'):
wrapped = WrappedLightGbmBoosterClassifier(wrapped)
return _parse_sklearn_classifier(
scope, wrapped, inputs, custom_parsers=custom_parsers)
if objective.startswith('regression'): # pragma: no cover
return _parse_sklearn_simple_model(
scope, wrapped, inputs, custom_parsers=custom_parsers)
raise NotImplementedError( # pragma: no cover
"Objective '{}' is not implemented yet.".format(objective))
# Multiple columns
this_operator = scope.declare_local_operator('LightGBMConcat')
this_operator.raw_operator = model
this_operator.inputs = inputs
var = scope.declare_local_variable(
'Xlgbm', inputs[0].type.__class__([None, None]))
this_operator.outputs.append(var)
return lightgbm_parser(scope, model, this_operator.outputs,
custom_parsers=custom_parsers)
def my_parser(scope, model, inputs, custom_parsers=None):
trace_line.append(model)
return _parse_sklearn_simple_model(scope, model, inputs,
custom_parsers)
