onnx_array_api.light_api#

start#

onnx_array_api.light_api.start(opset: int | None = None, opsets: Dict[str, int] | None = None, is_function: bool = False) → OnnxGraph[source]#

Starts an onnx model.

Parameters:

opset – main opset version
is_function – a onnx.ModelProto or a onnx.FunctionProto
opsets – others opsets as a dictionary

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: 9
    opset_import {
      domain: ""
      version: 20
    }
    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 {
            }
          }
        }
      }
    }

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: 9
    opset_import {
      domain: ""
      version: 20
    }
    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 {
            }
          }
        }
      }
    }

OnnxGraph#

class onnx_array_api.light_api.OnnxGraph(opset: int | None = None, opsets: Dict[str, int] | None = None, is_function: bool = False)[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
is_function – a onnx.ModelProto or a onnx.FunctionProto
opsets – others opsets as a dictionary

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

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]) → NodeProto[source]#

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

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

BaseVar#

class onnx_array_api.light_api.var.BaseVar(parent: OnnxGraph)[source]#

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

Parameters:: parent – the graph containing the Variable

bring(*vars: List[str | 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.

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(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

Var#

class onnx_array_api.light_api.Var(parent: OnnxGraph, name: str, elem_type: int | dtype | None = 1, shape: Tuple[int, ...] | None = None)[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]) → 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#

Declares a new output to the graph.

Parameters:

elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var

Vars#

class onnx_array_api.light_api.Vars(parent, *vars: List[str | Var])[source]#

Represents multiple Var.

Parameters:

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

bring(*vars: List[str | 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_name: str) → Var[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: int | dtype = 1, shape: Tuple[int, ...] | None = None) → Var#

Declares a new output to the graph.

Parameters:

elem_type – element_type
shape – shape

Returns:

instance of onnx_array_api.light_api.Var