o XiS@sdZddlmZgdZddlZddlmZmZmZddl m Z ddl Z ddl Z ddlmZmZmZmZmZe eeeeeeeeeeje jejejeeje jejeejdfZeeZ d=d d Z! d>d?ddZ"d@ddZ# dAdBd!d"Z$d#d$dCd)d*Z%dDd5d6Z& dAdEd;d<Z'dS)FzConvenience methods for constructing and manipulating the IR. This is an internal only module. We should choose to expose some of the methods in convenience.py after they are proven to be useful. ) annotations)convert_attributeconvert_attributesreplace_all_uses_withcreate_value_mappingreplace_nodes_and_valuesget_const_tensorN)IterableMappingSequence)Union)_core_enums _protocolsserde traversalattrSupportedAttrTypesreturn_enums.AttributeTypecCsvt|tr tjjSt|trtjjSt|trtjjSt|t j r$|j St|t j t jtjfr3tjjSt|t jt jtjfrBtjjSt|t jt jt jtjfrStjjSt|tr|sctdtjjStdd|DrptjjStdd|Dr}tjj Stdd|Drtjj!Stdd|Drtjj"Stdd|Drtjj#Stdd|Drtjj$St%d t |d ) z@Infer the attribute type based on the type of the Python object.z{Attribute type is ambiguous because it is an empty sequence. Please create an Attr with an explicit type. Defaulted to INTScs|]}t|tVqdSN) isinstanceint.0xrQ/home/ubuntu/.local/lib/python3.10/site-packages/onnx_ir/_convenience/__init__.py Nz(_infer_attribute_type..csrr)rfloatrrrrrPr csrr)rstrrrrrrRr cs&|]}t|tjtjtjfVqdSr)rr TensorBaseonnx TensorProtorTensorProtocolrrrrrT  csr#r)rr Graphr% GraphProtor GraphProtocolrrrrrYr(css*|]}t|tjtjtjtjfVqdSr)rr TensorType SequenceType OptionalTyper TypeProtocolrrrrr^s  Unsupported attribute type: '')&rrr AttributeTypeINTr!FLOATr"STRINGr Attrtyper)r%r*rr+GRAPHr$r&r'TENSORr,r-r.r/ TYPE_PROTOr loggerwarningINTSallFLOATSSTRINGSTENSORSGRAPHS TYPE_PROTOS TypeError)rrrr_infer_attribute_type3sT       rEnamer" attr_type_enums.AttributeType | None _core.Attrc Cs|dur|dur tdt||dSt|tjrA|j|kr*td|jd|d|dur?|j|kr?td|jd|d|S|durIt|}|tjj krUt ||S|tjj krat ||S|tjj krmt||S|tjjkryt||S|tjjkrt||S|tjjkrt||S|tjjkrt|tjtjfrt||St|tjrt|t|S|tjjkrg}|D]}t|tjr|t|t|q||qt ||S|tjj!krt|tj"rt#|}t$||S|tjj%kr"g}|D]}t|tj"r|t#|q||qt&||S|tjj'kr/t(||S|tjj)kr>> import onnx_ir as ir >>> import onnx >>> import numpy as np >>> attrs = { ... "int": 1, ... "float": 1.0, ... "str": "hello", ... "ints": [1, 2, 3], ... "floats": [1.0, 2.0, 3.0], ... "strings": ["hello", "world"], ... "tensor": ir.Tensor(np.array([1.0, 2.0, 3.0])), ... "tensor_proto": ... onnx.TensorProto( ... dims=[3], ... data_type=onnx.TensorProto.FLOAT, ... float_data=[1.0, 2.0, 3.0], ... name="proto", ... ), ... "graph": ir.Graph([], [], nodes=[], name="graph0"), ... "graphs": [ir.Graph([], [], nodes=[], name="graph1"), ir.Graph([], [], nodes=[], name="graph2")], ... "type_proto": ir.TensorType(ir.DataType.FLOAT), ... "type_protos": [ir.TensorType(ir.DataType.FLOAT), ir.TensorType(ir.DataType.FLOAT)], ... } >>> convert_attributes(attrs) [Attr('int', INT, 1), Attr('float', FLOAT, 1.0), Attr('str', STRING, 'hello'), Attr('ints', INTS, (1, 2, 3)), Attr('floats', FLOATS, (1.0, 2.0, 3.0)), Attr('strings', STRINGS, ('hello', 'world')), Attr('tensor', TENSOR, Tensor(array([1., 2., 3.]), name=None)), Attr('tensor_proto', TENSOR, TensorProtoTensor(array([1., 2., 3.], dtype=float32), name='proto')), Attr('graph', GRAPH, Graph( name='graph0', inputs=( ), outputs=( ), len()=0 )), Attr('graphs', GRAPHS, (Graph( name='graph1', inputs=( ), outputs=( ), len()=0 ), Graph( name='graph2', inputs=( ), outputs=( ), len()=0 ))), Attr('type_proto', TYPE_PROTO, Tensor(FLOAT)), Attr('type_protos', TYPE_PROTOS, (Tensor(FLOAT), Tensor(FLOAT)))] .. important:: An empty sequence should be created with an explicit type by initializing an Attr object with an attribute type to avoid type ambiguity. For example:: ir.Attr("empty", [], type=ir.AttributeType.INTS) Args: attrs: A dictionary of {: } to convert. Returns: A list of :class:`_core.Attr` objects. Raises: TypeError: If an attribute type is not supported. N)itemsrSr)r^ attributesrFrrrrrs MrFvalues=_protocols.ValueProtocol | Sequence[_protocols.ValueProtocol] replacementsreplace_graph_outputsboolNonecCs^t|ts|f}t|ts|f}t|t|krtdt||D] \}}|j||dq!dS)az Replace all uses of the given values with the replacements. This is useful when nodes in the graph are replaced with new nodes, where the old users need to be updated to use the outputs of the new nodes. For example, suppose we have the following graph:: A -> {B, C} We want to replace the node A with a new node D:: >>> import onnx_ir as ir >>> input = ir.val("input") >>> node_a = ir.Node("", "A", [input]) >>> node_b = ir.Node("", "B", node_a.outputs) >>> node_c = ir.Node("", "C", node_a.outputs) >>> node_d = ir.Node("", "D", [input]) >>> replace_all_uses_with(node_a.outputs, node_d.outputs) >>> len(node_b.inputs) 1 >>> node_b.inputs[0].producer().op_type 'D' >>> len(node_c.inputs) 1 >>> node_c.inputs[0].producer().op_type 'D' >>> len(node_a.outputs[0].uses()) 0 When values and replacements are sequences, they are zipped into pairs. All users of the first value is replaced with the first replacement, and so on. .. note:: Be sure to remove the old nodes from the graph using ``graph.remove()`` if they are no longer needed, or use :class:`onnx_ir.passes.common.RemoveUnusedNodesPass` to remove all unused nodes in the graph. .. tip:: **Handling graph outputs** To also replace graph outputs that reference the values being replaced, either set ``replace_graph_outputs`` to True, or manually update the graph outputs before calling this function to avoid an error being raised when ``replace_graph_outputs=False``. Be careful when a value appears multiple times in the graph outputs - this is invalid. An identity node will need to be added on each duplicated outputs to ensure a valid ONNX graph. You may also want to assign the name of this value to the replacement value to maintain the name when it is a graph output. .. versionadded:: 0.1.12 The ``replace_graph_outputs`` parameter is added. .. versionadded:: 0.1.12 ValueError is raised when ``replace_graph_outputs`` is False && when the value to replace is a graph output. Args: values: The value or values to be replaced. replacements: The new value or values to use as inputs. replace_graph_outputs: If True, graph outputs that reference the values being replaced will also be updated to reference the replacements. Raises: ValueError: When ``replace_graph_outputs`` is False && when the value to replace is a graph output. z1The number of values and replacements must match.rfN)rr lenrJzipr)rcrerfvalue replacementrrrrs I rT)include_subgraphsr]._core.Graph | _core.GraphView | _core.Functionrndict[str, _core.Value]cCsi}t|tjs||j|jD]}|jsq|j|vrq|||j<q|r+t|}n|}|D]/}|jD]}|s9q4|js=q4|j|vrCq4|||j<q4|j D]}|jsRqL|j|vrXqL|||j<qLq/|S)ayReturn a dictionary mapping names to values in the graph. The mapping includes values from subgraphs. Duplicated names are omitted, and the first value with that name is returned. Values with empty names are excluded from the mapping. .. versionchanged:: 0.1.2 Values from subgraphs are now included in the mapping. .. versionadded:: 0.1.14 The ``include_subgraphs`` parameter. Args: graph: The graph to extract the mapping from. include_subgraphs: If True, values from subgraphs are included in the mapping. Returns: A dictionary mapping names to values. ) rr Functionupdate initializersinputsrFrRecursiveGraphIteratoroutputs)r]rnrcinputiteratornoderlrrrrks:            rinsertion_point _core.Node old_nodesSequence[_core.Node] new_nodes old_valuesSequence[_core.Value] new_valuesgraph_or_function_core.Graph | _core.FunctioncCst||D]4\}}|jdur|jn|j|_|jdur|jn|j|_|jdur)|jn|j|_|jdur5|jn|j|_qt||dd||||j|dddS)aReplaces nodes and values in the graph or function. Args: graph_or_function: The graph or function to replace nodes and values in. insertion_point: The node to insert the new nodes after. old_nodes: The nodes to replace. new_nodes: The nodes to replace with. old_values: The values to replace. new_values: The values to replace with. NTri)safe)rkr7shape const_valuerFr insert_afterremove)rrzr|r~rr old_value new_valuerrrrs  rrl _core.Valuepropagate_shape_type _protocols.TensorProtocol | NonecCsd}|jdur |j}n|}|durdS|jdks|jdkr!dSt|jdkr7td|jdt|jdt|jdkrMtd|jdt|jd t t |j \}}| r^dS|jd }|d vrwt jtj|jtjd |jd }n=|dvrt jtj|jtjd |jd }n)|dvrt jtj|jtjd |jd }n|dkr|}n td|d|jd|j|_|dur|r|jdur|j|jkrtd||j|j|j|_t |j}|jdur|j|krtd||j|||_|S)a7Get the constant tensor from a value, if it exists. A constant tensor can be obtained if the value has a ``const_value`` set (as in the case of an initializer) or if the value is produced by a Constant node. This function will not alter the ``const_value`` of the value, but it will propagate the shape and type of the constant tensor to the value if `propagate_shape_type` is set to True. .. versionadded:: 0.1.2 Args: value: The value to get the constant tensor from. propagate_shape_type: If True, the shape and type of the value will be propagated to the Value. Returns: The constant tensor if it exists, otherwise None. Raises: ValueError: If the Constant node does not have exactly one output or one attribute. NConstantzConstant node 'z(' must have exactly one output, but has z outputs.z+' must have exactly one attribute, but has z attributes.r> value_float value_floats)dtype)rF> value_int value_ints> value_string value_stringsrlzUnsupported attribute 'z' in Constant node 'zy'. Expected one of 'value_float', 'value_floats', 'value_int', 'value_ints', 'value_string', 'value_strings', or 'value'.znValue '%s' has a shape %s that differs from the constant tensor's shape %s. The value's shape will be updated.zoValue '%s' has a type '%s' that differs from the constant tensor's type '%s'. The value's type will be updated.)rproducerop_typedomainrjrvrJrFrbnextiterrais_refr Tensornparrayrlfloat32int64 StringTensorbytes_ as_tensorrr;r<r,rr7)rlrtensorry attr_name attr_valueir_valuenew_value_typerrrrsz       r)rrrrr)rFr"rrrGrHrrI)r^r_rr`)F)rcrdrerdrfrgrrh)r]rornrgrrp)rzr{r|r}r~r}rrrrrrrrh)rlrrrgrr)(__doc__ __future__r__all__loggingcollections.abcr r r typingr numpyrr%onnx_irr rrrrr"rr!r'r&r6r+r*r/r getLogger__name__r;rErrrrrrrrrrsN     > VW V 8(