flytekitplugins.onnxscikitlearn.schema

Directory

Classes

Methods

Methods

extract_config()

def extract_config(
    t: Type[ScikitLearn2ONNX],
) -> Tuple[Type[ScikitLearn2ONNX], ScikitLearn2ONNXConfig]

to_onnx()

def to_onnx(
    ctx,
    model,
    config,
)

flytekitplugins.onnxscikitlearn.schema.ScikitLearn2ONNX

Parameters

class ScikitLearn2ONNX(
    model: sklearn.base.BaseEstimator = None,
)

flytekitplugins.onnxscikitlearn.schema.ScikitLearn2ONNXConfig

ScikitLearn2ONNXConfig is the config used during the scikitlearn to ONNX conversion.

Parameters

class ScikitLearn2ONNXConfig(
    initial_types: List[Tuple[str, Type]],
    name: Optional[str] = None,
    doc_string: str = '',
    target_opset: Optional[int] = None,
    custom_conversion_functions: Dict[Callable[..., Any], Callable[..., None]] = <factory>,
    custom_shape_calculators: Dict[Callable[..., Any], Callable[..., None]] = <factory>,
    custom_parsers: Dict[Callable[..., Any], Callable[..., None]] = <factory>,
    options: Dict[Any, Any] = <factory>,
    intermediate: bool = False,
    naming: Optional[Union[str, Callable[..., Any]]] = None,
    white_op: Optional[Set[str]] = None,
    black_op: Optional[Set[str]] = None,
    verbose: int = 0,
    final_types: Optional[List[Tuple[str, Type]]] = None,
)

flytekitplugins.onnxscikitlearn.schema.ScikitLearn2ONNXTransformer

Parameters

def ScikitLearn2ONNXTransformer()

Properties

Methods

assert_type()

def assert_type(
    t: Type[T],
    v: T,
)

from_binary_idl()

def from_binary_idl(
    binary_idl_object: Binary,
    expected_python_type: Type[T],
) -> Optional[T]

This function primarily handles deserialization for untyped dicts, dataclasses, Pydantic BaseModels, and attribute access.｀

For untyped dict, dataclass, and pydantic basemodel: Life Cycle (Untyped Dict as example): python val -> msgpack bytes -> binary literal scalar -> msgpack bytes -> python val (to_literal) (from_binary_idl)

For attribute access: Life Cycle: python val -> msgpack bytes -> binary literal scalar -> resolved golang value -> binary literal scalar -> msgpack bytes -> python val (to_literal) (propeller attribute access) (from_binary_idl)

from_generic_idl()

def from_generic_idl(
    generic: Struct,
    expected_python_type: Type[T],
) -> Optional[T]

TODO: Support all Flyte Types. This is for dataclass attribute access from input created from the Flyte Console.

• This can be removed in the future when the Flyte Console support generate Binary IDL Scalar as input.

get_literal_type()

def get_literal_type(
    t: Type[ScikitLearn2ONNX],
) -> LiteralType

Converts the python type to a Flyte LiteralType

guess_python_type()

def guess_python_type(
    literal_type: LiteralType,
) -> Type[ScikitLearn2ONNX]

Converts the Flyte LiteralType to a python object type.

isinstance_generic()

def isinstance_generic(
    obj,
    generic_alias,
)

schema_match()

def schema_match(
    schema: dict,
) -> bool

Check if a JSON schema fragment matches this transformer’s python_type.

For BaseModel subclasses, automatically compares the schema’s title, type, and required fields against the type’s own JSON schema. For other types, returns False by default — override if needed.

to_html()

def to_html(
    ctx: FlyteContext,
    python_val: T,
    expected_python_type: Type[T],
) -> str

Converts any python val (dataframe, int, float) to a html string, and it will be wrapped in the HTML div

to_literal()

def to_literal(
    ctx: FlyteContext,
    python_val: ScikitLearn2ONNX,
    python_type: Type[ScikitLearn2ONNX],
    expected: LiteralType,
) -> Literal

Converts a given python_val to a Flyte Literal, assuming the given python_val matches the declared python_type. Implementers should refrain from using type(python_val) instead rely on the passed in python_type. If these do not match (or are not allowed) the Transformer implementer should raise an AssertionError, clearly stating what was the mismatch

to_python_value()

def to_python_value(
    ctx: FlyteContext,
    lv: Literal,
    expected_python_type: Type[ONNXFile],
) -> ONNXFile

Converts the given Literal to a Python Type. If the conversion cannot be done an AssertionError should be raised