onnx_array_api.light_api¶

Main API¶

start¶

onnx_array_api.light_api.start(opset: int | None = None, opsets: Dict[str, int] | None = None, ir_version: int | None = None) → OnnxGraph[source]¶

Starts an onnx model.

Parameters:

opset – main opset version
opsets – others opsets as a dictionary
ir_version – specify the ir_version as well

Returns:

an instance of onnx_array_api.light_api.OnnxGraph

A very simple model:

<<<

from onnx_array_api.light_api import start

onx = start().vin("X").Neg().rename("Y").vout().to_onnx()
print(onx)

>>>

    ir_version: 11
    graph {
      node {
        input: "X"
        output: "Y"
        op_type: "Neg"
        domain: ""
      }
      name: "light_api"
      input {
        name: "X"
        type {
          tensor_type {
            elem_type: 1
            shape {
            }
          }
        }
      }
      output {
        name: "Y"
        type {
          tensor_type {
            elem_type: 1
            shape {
            }
          }
        }
      }
    }
    opset_import {
      domain: ""
      version: 22
    }

Another with operator Add:

<<<

from onnx_array_api.light_api import start

onx = start().vin("X").vin("Y").bring("X", "Y").Add().rename("Z").vout().to_onnx()
print(onx)

>>>

    ir_version: 11
    graph {
      node {
        input: "X"
        input: "Y"
        output: "Z"
        op_type: "Add"
        domain: ""
      }
      name: "light_api"
      input {
        name: "X"
        type {
          tensor_type {
            elem_type: 1
            shape {
            }
          }
        }
      }
      input {
        name: "Y"
        type {
          tensor_type {
            elem_type: 1
            shape {
            }
          }
        }
      }
      output {
        name: "Z"
        type {
          tensor_type {
            elem_type: 1
            shape {
            }
          }
        }
      }
    }
    opset_import {
      domain: ""
      version: 22
    }

g¶

onnx_array_api.light_api.g() → OnnxGraph[source]¶: Starts a subgraph. :return: an instance of onnx_array_api.light_api.OnnxGraph

Classes for the Light API¶

domain¶

..autofunction:: onnx_array_api.light_api.domain

BaseVar¶

class onnx_array_api.light_api.var.BaseVar(*args, **kwargs)[source]¶

Represents an input, an initializer, a node, an output, multiple variables.

Parameters:: parent – the graph containing the Variable

bring(*vars: List[str | Var]) → Var | Vars[source]¶: Creates a set of variable as an instance of onnx_array_api.light_api.Vars.

cst(value: ndarray, name: str | None = None) → Var[source]¶

Adds an initializer

Parameters:

value – constant tensor
name – input name

Returns:

instance of onnx_array_api.light_api.Var

left_bring(*vars: List[str | Var]) → Vars[source]¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the left, self is added to the right.

make_node(op_type: str, *inputs: List[Var | TensorProto | ndarray], domain: str = '', n_outputs: int = 1, output_names: List[str] | None = None, **kwargs: Dict[str, Any]) → Var | Vars[source]¶

Creates a node with this Var as the first input.

Parameters:

op_type – operator type
inputs – others inputs
domain – domain
n_outputs – number of outputs
output_names – output names, if not specified, outputs are given unique names
kwargs – node attributes

Returns:

instance of onnx_array_api.light_api.Var or onnx_array_api.light_api.Vars

right_bring(*vars: List[str | Var]) → Vars[source]¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the right, self is added to the left.

to_onnx() → FunctionProto | GraphProto | ModelProto[source]¶: Creates the onnx graph.

v(name: str) → Var[source]¶

Retrieves another variable than this one.

Parameters:: name – name of the variable
Returns:: instance of onnx_array_api.light_api.Var

vin(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var[source]¶

Declares a new input to the graph.

Parameters:

name – input name
elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

vout(**kwargs: Dict[str, Any]) → Var | Vars[source]¶: This method needs to be overwritten for Var and Vars depending on the number of variable to declare as outputs.

OnnxGraph¶

class onnx_array_api.light_api.OnnxGraph(opset: int | None = None, opsets: Dict[str, int] | None = None, ir_version: int | None = None, proto_type: ProtoType = ProtoType.MODEL)[source]¶

Contains every piece needed to create an onnx model in a single instructions. This API is meant to be light and allows the description of a graph.

Parameters:

opset – main opset version
opsets – other opsets as a dictionary
ir_version – to specify an ir_version
is_function – a onnx.ModelProto or a onnx.FunctionProto

cst(value: ndarray, name: str | None = None) → Var[source]¶

Adds an initializer

Parameters:

value – constant tensor
name – input name

Returns:

instance of onnx_array_api.light_api.Var

has_name(name: str) → bool[source]¶: Tells if a name is already used.

property input_names: List[str]¶: Returns the input names

make_constant(value: ndarray, name: str | None = None) → TensorProto[source]¶: Adds an initializer to the graph.

make_input(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → ValueInfoProto[source]¶

Adds an input to the graph.

Parameters:

name – input name
elem_type – element type (the input is assumed to be a tensor)
shape – shape

Returns:

an instance of ValueInfoProto

Creates a node.

Parameters:

op_type – operator type
inputs – others inputs
domain – domain
n_outputs – number of outputs
output_names – output names, if not specified, outputs are given unique names
kwargs – node attributes

Returns:

NodeProto

make_output(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → ValueInfoProto[source]¶

Adds an output to the graph.

Parameters:

name – input name
elem_type – element type (the input is assumed to be a tensor)
shape – shape

Returns:

an instance of ValueInfoProto

If the checker fails, try shape=[].

property output_names: List[str]¶: Returns the output names

rename(old_name: str, new_name: str)[source]¶

Renames a variable. The renaming does not change anything but is stored in a container.

Parameters:

old_name – old name
new_name – new name

to_onnx() → FunctionProto | GraphProto | ModelProto[source]¶: Converts the graph into an ONNX graph.

true_name(name: str) → str[source]¶: Some names were renamed. If name is one of them, the function returns the new name.

unique_name(prefix='r', value: Any | None = None) → str[source]¶

Returns a unique name.

Parameters:

prefix – prefix
value – this name is mapped to this value

Returns:

unique name

vin(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var[source]¶

Declares a new input to the graph.

Parameters:

name – input name
elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

ProtoType¶

class onnx_array_api.light_api.model.ProtoType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]¶: The same code can be used to output a GraphProto, a FunctionProto or a ModelProto. This class specifies the output type at the beginning of the code.

SubDomain¶

class onnx_array_api.light_api.var.SubDomain(var: BaseVar)[source]¶: Declares a domain or a piece of it (if it contains ‘.’ in its name).

Var¶

class onnx_array_api.light_api.Var(*args, **kwargs)[source]¶

Represents an input, an initializer, a node, an output.

Parameters:

parent – graph the variable belongs to
name – input name
elem_type – element_type
shape – shape

astype(to: int | dtype) → Var[source]¶: Casts a tensor into another element type.

bring(*vars: List[str | Var]) → Var | Vars¶: Creates a set of variable as an instance of onnx_array_api.light_api.Vars.

cst(value: ndarray, name: str | None = None) → Var¶

Adds an initializer

Parameters:

value – constant tensor
name – input name

Returns:

instance of onnx_array_api.light_api.Var

left_bring(*vars: List[str | Var]) → Vars¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the left, self is added to the right.

make_node(op_type: str, *inputs: List[Var | TensorProto | ndarray], domain: str = '', n_outputs: int = 1, output_names: List[str] | None = None, **kwargs: Dict[str, Any]) → Var | Vars¶

Creates a node with this Var as the first input.

Parameters:

op_type – operator type
inputs – others inputs
domain – domain
n_outputs – number of outputs
output_names – output names, if not specified, outputs are given unique names
kwargs – node attributes

Returns:

instance of onnx_array_api.light_api.Var or onnx_array_api.light_api.Vars

property name¶: Returns the name of the variable or the new name if it was renamed.

rename(new_name: str) → Var[source]¶: Renames a variable.

reshape(new_shape: Var | TensorProto | ndarray) → Var[source]¶: Reshapes a variable.

right_bring(*vars: List[str | Var]) → Vars¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the right, self is added to the left.

to(to: int | dtype) → Var[source]¶: Casts a tensor into another element type.

to_onnx() → FunctionProto | GraphProto | ModelProto¶: Creates the onnx graph.

v(name: str) → Var¶

Retrieves another variable than this one.

Parameters:: name – name of the variable
Returns:: instance of onnx_array_api.light_api.Var

vin(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var¶

Declares a new input to the graph.

Parameters:

name – input name
elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

vout(elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var[source]¶

Declares a new output to the graph.

Parameters:

elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

If the checker fails, try shape=[].

Vars¶

class onnx_array_api.light_api.Vars(*args, **kwargs)[source]¶

Represents multiple Var.

Parameters:

parent – graph the variable belongs to
vars – list of names or variables

bring(*vars: List[str | Var]) → Var | Vars¶: Creates a set of variable as an instance of onnx_array_api.light_api.Vars.

cst(value: ndarray, name: str | None = None) → Var¶

Adds an initializer

Parameters:

value – constant tensor
name – input name

Returns:

instance of onnx_array_api.light_api.Var

left_bring(*vars: List[str | Var]) → Vars¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the left, self is added to the right.

make_node(op_type: str, *inputs: List[Var | TensorProto | ndarray], domain: str = '', n_outputs: int = 1, output_names: List[str] | None = None, **kwargs: Dict[str, Any]) → Var | Vars¶

Creates a node with this Var as the first input.

Parameters:

op_type – operator type
inputs – others inputs
domain – domain
n_outputs – number of outputs
output_names – output names, if not specified, outputs are given unique names
kwargs – node attributes

Returns:

instance of onnx_array_api.light_api.Var or onnx_array_api.light_api.Vars

rename(*new_names: List[str]) → Vars[source]¶: Renames variables.

right_bring(*vars: List[str | Var]) → Vars¶: Creates a set of variables as an instance of onnx_array_api.light_api.Vars. *vars is added to the right, self is added to the left.

to_onnx() → FunctionProto | GraphProto | ModelProto¶: Creates the onnx graph.

v(name: str) → Var¶

Retrieves another variable than this one.

Parameters:: name – name of the variable
Returns:: instance of onnx_array_api.light_api.Var

vin(name: str, elem_type: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var¶

Declares a new input to the graph.

Parameters:

name – input name
elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

vout(*elem_type_shape: List[int | dtype | Tuple[int | dtype, Tuple[int, ...] | None]]) → Vars[source]¶

Declares a new output to the graph.

Parameters:: elem_type_shape – list of tuple(element_type, shape)
Returns:: instance of onnx_array_api.light_api.Vars

If the checker fails, try shape=[].

Available operators¶

One input¶

class onnx_array_api.light_api._op_var.OpsVar[source]¶: Operators taking only one input.

Two inputs or more¶

class onnx_array_api.light_api._op_vars.OpsVars[source]¶: Operators taking multiple inputs.