.. _l-graph-api:

GraphBuilder: common API for ONNX

This is a very common way to build ONNX graph. There are some

annoying steps while building an ONNX graph. The first one is to

give unique names to every intermediate result in the graph. The second

is the conversion from numpy arrays to onnx tensors. A *graph builder*,

here implemented by class

:class:`GraphBuilder <onnx_array_api.graph_api.GraphBuilder>`

usually makes these two frequent tasks easier.

..runpython::

import numpy as np

from onnx_array_api.graph_api import GraphBuilder

from onnx_array_api.plotting.text_plot import onnx_simple_text_plot

g = GraphBuilder()

g.make_tensor_input("X", np.float32, (None, None))

g.make_tensor_input("Y", np.float32, (None, None))

r1 = g.make_node("Sub", ["X", "Y"]) # the name given to the output is given by the class,

# it ensures the name is unique

init = g.make_initializer(np.array([2], dtype=np.int64)) # the class automatically

# converts the array to a tensor

r2 = g.make_node("Pow", [r1, init])

g.make_node("ReduceSum", [r2], outputs=["Z"]) # the output name is given because

# the user wants to choose the name

g.make_tensor_output("Z", np.float32, (None, None))

onx = g.to_onnx() # final conversion to onnx

print(onnx_simple_text_plot(onx))

A more simple versions of the same code to produce the same graph.

..runpython::

import numpy as np

from onnx_array_api.graph_api import GraphBuilder

from onnx_array_api.plotting.text_plot import onnx_simple_text_plot

g = GraphBuilder()

g.make_tensor_input("X", np.float32, (None, None))

g.make_tensor_input("Y", np.float32, (None, None))

r1 = g.op.Sub("X", "Y") # the method name indicates which operator to use,

# this can be used when there is no ambiguity about the

# number of outputs

r2 = g.op.Pow(r1, np.array([2], dtype=np.int64))

g.op.ReduceSum(r2, outputs=["Z"]) # the still wants the user to specify the name

g.make_tensor_output("Z", np.float32, (None, None))

onx = g.to_onnx()

print(onnx_simple_text_plot(onx))

See:ref:`l-numpy-api-onnx`. This API was introduced to create graphs

by using numpy API. If a function is defined only with numpy,

it should be possible to use the exact same code to create the

corresponding onnx graph. That's what this API tries to achieve.

It works with the exception of control flow. In that case, the function

produces different onnx graphs depending on the execution path.

See:ref:`l-graph-api`. This API is very similar to what *skl2onnx* implements.

It is still about adding nodes to a graph but some tasks are automated such as

naming the results or converting constants to onnx classes.

..runpython::

import numpy as np

from onnx_array_api.npximportjit_onnx

from onnx_array_api.graph_apiimportGraphBuilder

from onnx_array_api.plotting.text_plot import onnx_simple_text_plot

return ((x - y) ** 2).sum(keepdims=1)

jitted_myloss =jit_onnx(l2_loss)

dummy = np.array([0], dtype=np.float32)

jitted_myloss(dummy, dummy)

g.make_tensor_input("X", np.float32, (None, None))

r1 =g.op.Sub("X", "Y")

r2 =g.op.Pow(r1,np.array([2], dtype=np.int64))

onx = g.to_onnx()

# get_onnx only works if it was executed once or at least with

# the same input type

model = jitted_myloss.get_onnx()

print(onnx_simple_text_plot(model))

print(onnx_simple_text_plot(onx))

Light API

)

print(onnx_simple_text_plot(model))

numpy API for onnx

See:ref:`l-numpy-api-onnx`. This API was introduced to create graphs

by using numpy API. If a function is defined only with numpy,

it should be possible to use the exact same code to create the

corresponding onnx graph. That's what this API tries to achieve.

It works with the exception of control flow. In that case, the function

produces different onnx graphs depending on the execution path.

..runpython::

import numpy as np

from onnx_array_api.npx import jit_onnx

from onnx_array_api.plotting.text_plot import onnx_simple_text_plot

def l2_loss(x, y):

return ((x - y) ** 2).sum(keepdims=1)

jitted_myloss = jit_onnx(l2_loss)

dummy = np.array([0], dtype=np.float32)

# The function is executed. Only then a onnx graph is created.

# One is created depending on the input type.

jitted_myloss(dummy, dummy)

# get_onnx only works if it was executed once or at least with

# the same input type

model = jitted_myloss.get_onnx()

print(onnx_simple_text_plot(model))

"Mul":1,

"Log":1,

"Or":1,

"Pow":1,

"Relu":1,

"ReduceSum":1,

"Reshape":1,

"Shape":1,

"Slice":1,

rows.extend(r)

return"\n".join(rows)

raiseNotImplementedError(# pragma: no cover

)

raiseNotImplementedError(f"Type{node.op_type!r} cannot be displayed.")

def_append_succ_pred(

)

ifnotsequences:

raiseRuntimeError(# pragma: no cover

raiseRuntimeError(

ifbestisNone:

raiseRuntimeError(# pragma: no cover

raiseRuntimeError(

)

ifverbose:

known|=set(v.output)

iflen(new_nodes)!=len(nodes):

raiseRuntimeError(# pragma: no cover

raiseRuntimeError(

n0s=set(n.nameforninnodes)

n1s=set(n.nameforninnew_nodes)

ifn0s!=n1s:

raiseRuntimeError(# pragma: no cover

raiseRuntimeError(

try:

val=str(to_array(att.t).tolist())

exceptTypeErrorase:

raiseTypeError(# pragma: no cover

raiseTypeError(

% (att.type,str(att))

)frome

ifisinstance(att,str):

rows.append(f"attribute:{att!r}")

else:

raiseNotImplementedError(# pragma: no cover

)

raiseNotImplementedError("Not yet introduced in onnx.")

ifhasattr(model,"initializer"):

try:

nodes=reorder_nodes_for_display(model.node,verbose=verbose)

exceptRuntimeErrorase:# pragma: no cover

exceptRuntimeErrorase:

ifraise_exc:

else:

ifprevious_indentisnotNoneandindent<previous_indent:

ifverbose:

print(# pragma: no cover

)

print(f"[onnx_simple_text_plot] break2{node.op_type}")

ifnotadd_breakandprevious_outisnotNone:

ifnot (set(node.input)&previous_out):