o Xi @s2dZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZmZmZmZmZmZmZddlmZddl mZmZmZmZmZmZmZmZddl Z ddl!Z"ddl#m$Z$m%Z%ddl&Z&ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.e j/rddl0m Z1dd l#m2Z2e j3d ee-j4e-j5fd Z6e j7d kZ8e9e(j:j;e(j:je(j:j?e(j:j@e(j:jAe(j:jBe(j:jCe(j:jDe(j:jEf ZFeGeHZIdddZJdddZKGdddejLe-jMe'jNZOdddZPddd ZQdd#d$ZRdd'd(ZSGd)d&d&eOe-jMee6ZTGd*d+d+eOe-jMZUGd,d-d-eOe-jMZVGd.d/d/eOe-jMZWGd0d1d1eOe-jMee6ZXGd2d3d3e-jYe'jNZZdd7d8Z[ddd?d?e-j]e'jNZ^ddBdCZ_GdDdEdEeZ`ddHdIZaddKdLZbGdMdNdNe-jce'jNZdGdOdPdPe-jee'jNeZfGdQdRdRefZgGdSdTdTefZhGdUdVdVe-jee'jNeZiGdWdXdXeiZjGdYdZdZeiZkGd[d\d\eZldd_d`ZmGdadbdbZnGdcdGdGene-joe'jNZpe%dd    dddldmZqddsdtZrGdudvdve-jseede'jNZtddydzZudd{d|ZvGd}d~d~eede'jNZwGddde-jxe'jNZyGddde-jzeede'jNZ{Gddde-j|e-j}e'jNZ~ ddddZddddZddddZddddZ ddddZddddZddddZddddZddddZ ddddZddddZ ddddZ ddddZejGdddZddddZ ddddZdS)z4data structures for the intermediate representation.) annotationsN) CollectionHashableIterableIteratorMappingMutableSequenceSequence)Set)AnyCallableClassVarGeneric NamedTupleProtocol SupportsIntUnion)TypeIs deprecated)_display_enums_graph_containers _linked_list _metadata_name_authority _protocols _type_casting) TypeGuardTArrayCompatible)boundlittleobjr return%TypeGuard[_protocols.ArrayCompatible]cC t|dS)zUse this function to check if an object is compatible with numpy. Avoid isinstance checks with the ArrayCompatible protocol for performance reasons. __array__hasattrr!r)A/home/ubuntu/.local/lib/python3.10/site-packages/onnx_ir/_core.py_compatible_with_numpy` r+&TypeGuard[_protocols.DLPackCompatible]cCr$)zUse this function to check if an object is compatible with DLPack. Avoid isinstance checks with the DLPackCompatible protocol for performance reasons. __dlpack__r&r(r)r)r*_compatible_with_dlpackhr,r/c@seZdZdZdZ   d,d-d d Zd.ddZd.ddZed/ddZ e j d0ddZ ed/ddZ e j d0ddZ ed1ddZ ed1ddZ ed2dd Zed3d"d#Zd4d$d%Zd&d'd5d*d+ZdS)6 TensorBasezCConvenience Shared methods for classes implementing TensorProtocol.) _doc_stringr_metadata_props_nameNname str | None doc_stringmetadata_propsdict[str, str] | Noner"NonecCsd|_||_||_||_dSN)rr2r3r1)selfr4r6r7r)r)r*__init__zs zTensorBase.__init__strcCs|jd|jS)z:Return a string representation of the shape and data type.,)dtypeshaper;r)r)r*_printable_type_shapez TensorBase._printable_type_shapecCs|jjd|dS)zPBase string for the repr method. Example: Tensor <>) __class____name__rBrAr)r)r* _repr_baseszTensorBase._repr_basecC|jS)zThe name of the tensor.r3rAr)r)r*r4zTensorBase.namevaluecC ||_dSr:rJr;rLr)r)r*r4 cCrI)zThe documentation string.r1rAr)r)r*r6rKzTensorBase.doc_stringcCrMr:rPrNr)r)r*r6rOintcCst|jS)z%The number of elements in the tensor.)mathprodr@numpyrAr)r)r*sizeszTensorBase.sizecCst|jj|jS)"The number of bytes in the tensor.)rRceilr?itemsizerUrAr)r)r*nbytesszTensorBase.nbytesdict[str, str]cC|jduri|_|jS)zThe metadata properties of the tensor. The metadata properties are used to store additional information about the tensor. Unlike ``meta``, this property is serialized to the ONNX proto. Nr2rAr)r)r*r7 zTensorBase.metadata_props_metadata.MetadataStorecC|jdur t|_|jSThe metadata store for intermediate analysis. Write to the :attr:`metadata_props` if you would like the metadata to be serialized to the ONNX proto. Nr MetadataStorerAr)r)r*meta  zTensorBase.metacCs||dS)aJWrite the tensor to a binary file. This method writes the raw bytes of the tensor to a file-like object. The file-like object must have a ``write`` method that accepts bytes. .. versionadded:: 0.1.11 Args: file: A file-like object with a ``write`` method that accepts bytes. N)writetobytes)r;filer)r)r*tofiles zTensorBase.tofileFpagerkboolc Cst}|dur t}n ddl}|jd|}ddlm}|g}| }| t || dt |}t |}t t |} ||} | dt | dt | d|d| d } t t || k|j} | d | d | d |t |} | d t j| ddd\}}| |j||ddddd|}Wdn1swY|durt|dS|rddl}|j}|||WddS1swYdS||dS)NrzComputing tensor stats for ) asciichartpyzMin: z, Max: z , NaN count: z , Inf count: gư>zSparsity (absThe numpy array dtype must be uint8 or ml_dtypes.float8* (not zCThe numpy array dtype must be int8 or uint8 or ml_dtypes.int4 (not z?The numpy array dtype must be uint8 or or ml_dtypes.uint4 (not zDThe numpy array dtype must be uint8 or ml_dtypes.float4_e2m1fn (not zCThe numpy array dtype must be int8 or uint8 or ml_dtypes.int2 (not z>> import numpy as np >>> array = np.array([1, 2, 3]) >>> tensor = Tensor(array) >>> # The tensor itself can be treated as a numpy array because it implements the __array__ method >>> np.allclose(tensor, array) True To get a numpy array from the tensor, call :meth:`numpy`. To convert the tensor to a byte string for serialization, call :meth:`tobytes`. It is recommended to check the size of the tensor first before accessing the underlying data, because accessing the data may be expensive and incur IO overhead. Subclass this class to efficiently handle different types of tensors from different frameworks. Attributes: name: The name of the tensor. shape: The shape of the tensor. dtype: The data type of the elements of the tensor. It is an :class:`ir.DataType` enum. doc_string: Documentation string. raw: The raw data behind this tensor. It can be anything. size: The number of elements in the tensor. nbytes: The number of bytes in the tensor. metadata_props: Metadata that will be serialized to the ONNX file. meta: Metadata store for graph transform passes. _dtype_raw_shapeNr@r4r6r7rLrr?_enums.DataType | Noner@ Shape | Noner4r5r6r7r8r"r9cstj|||dt|st|stdt||dur8t|ds-tdt|dtt |ddd|_ n||_ |j t |t jrKt |}|durbt |t jr^tj|j|_ntd t |t jrmt||||_t |t jr|t||j}||_dS) aaInitialize a tensor. Args: value: The backing data of the tensor. It can be a numpy array compatible object or a DLPack compatible object. When the dtype is not one of the numpy native dtypes, the value can be ``uint8`` (unpacked) or ml_dtypes types for 4-bit and 8-bit data types, and ``uint16`` or ml_dtype.bfloat16 for bfloat16 when the value is a numpy array; ``dtype`` must be specified in this case. dtype: The data type of the tensor. It can be None only when value is a numpy array. Users are responsible for making sure the dtype matches the value when value is not a numpy array. shape: The shape of the tensor. If None, the shape is obtained from the value. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. Raises: TypeError: If the value is not a numpy array compatible or a DLPack compatible object. TypeError: If the value is a numpy array and the dtype is specified but does not match the dtype of the array. ValueError: If the shape is not specified and the value does not have a shape attribute. ValueError: If the dtype is not specified and the value is not a numpy array. r4r6r7)Expected an array compatible object, got Nr@/Expected an object with a shape attribute, but : does not have shape. Please specify the shape explicitly.TfrozenzZThe dtype must be specified when the value is not a numpy array. Value type: {type(value)})superr<r+r/rtyper' ValueErrorShapegetattrrfreeze isinstancergenericrndarrayrrrr?rrrrr;rLr?r@r4r6r7rFr)r*r<s2          zTensor.__init__r rcCsNt|jtjs t|jr|j|St|js!Jdt|jt|jS)N6Bug: Expected DLPack or Numpy compatible objects, got ) rrrrr+r%r/r from_dlpackr;r?r)r)r*r%s    zTensor.__array__streamrcC(t|jr |jj|dS|j|dSNrr/rr.r%r;rr)r)r*r. zTensor.__dlpack__tuple[int, int]cC t|jr |jS|Sr:r/r__dlpack_device__r%rAr)r)r*r   zTensor.__dlpack_device__r=cCs@t|jd}ddd|D}|d|d|jdS)Nrw css|]}|VqdSr:)strip).0liner)r)r* #z"Tensor.__repr__..(, name=))rrsplitrrHr4)r; tensor_lines tensor_textr)r)r*__repr__ szTensor.__repr__rcCrIz'The data type of the tensor. Immutable.rrAr)r)r*r?&rKz Tensor.dtypercCrIz#The shape of the tensor. Immutable.rrAr)r)r*r@+rKz Tensor.shapecCrIz&Backing data of the tensor. Immutable.rrAr)r)r*raw0rKz Tensor.rawcCst|jtjr |jS|SzReturn the tensor as a numpy array. When the data type is not supported by numpy, the dtypes from the ``ml_dtype`` package are used. The values can be reinterpreted as bit representations using the ``.view()`` method. )rrrrr%rAr)r)r*rT5sz Tensor.numpybytescCst|}|S)Returns the value as bytes encoded in little endian. Override this method for more efficient serialization when the raw value is not a numpy array. )rrgr;rr)r)r*rgAszTensor.tobytescCs>t|jtjrt|rt|}||dS||dS)Write the tensor to a binary file. .. versionadded:: 0.1.11 Args: file: A file-like object with a ``write`` method that accepts bytes, or has an ``fileno()`` method. N) rrrrrrrirfrgr;rhrr)r)r*riKsz Tensor.tofiler:)rLrr?rr@rr4r5r6r5r7r8r"r9r?r r"rrr r"r r"rrr"rr"rr"rr"rr"rr)rGrrrrr<r%r.rrrr?r@rrTrgri __classcell__r)r)rr*rs.$  G        cs eZdZdZdZdddddJfddZedKddZejdLddZedKdd Z edMd!d"Z edNd#d$Z edNd%d&Z edOd'd(Z edPd)d*Zd+d,ZdQdRd/d0Zdd1dSd3d4ZdTd6d7ZdMd8d9ZdUd:d;ZdVd=d>ZdWd?d@ZdXdBdCZdWdDdEZdWdFdGZdWdHdIZZS)YExternalTensoraAn immutable concrete tensor with its data store on disk. This class uses memory mapping to avoid loading the tensor into memory, when the data type is supported by numpy. Otherwise, the tensor is loaded into memory lazily when accessed. Calling :attr:`shape` does not incur IO. Checking shape before loading the tensor is recommended if IO overhead and memory usage is a concern. To obtain an array, call :meth:`numpy`. To obtain the bytes, call :meth:`tobytes`. To write the data to a file, call :meth:`tofile`. The :attr:`location` must be a relative path conforming to the ONNX specification. Given the correct :attr:`base_dir`, the :attr:`path` is computed to be the full path to the data file. Users should expect that the :attr:`path` always leads to the correct file. At initialization, paths are not checked. It is the user's responsibility to ensure the paths are valid and accessible. Attributes: location: The location of the data file. It is the path relative to the base directory. base_dir: The base directory for the external data. It is used to resolve relative paths. At serialization, only the :attr:`location` is serialized into the "location" field of the ``TensorProto``. path: The path to the data file. This is computed by joining :attr:`base_dir` and :attr:`location`. offset: The offset in bytes from the start of the file. length: The length of the data in bytes. dtype: The data type of the tensor. shape: The shape of the tensor. name: The name of the tensor. It must be specified. doc_string: The documentation string. metadata_props: The metadata properties. ) _array _base_dirr_length _location_offsetr_validrNrn)r6r7base_dirlocationos.PathLike | stroffset int | Nonelengthr?rr@rr4r=r6r5r7r8r2r"r9c stj|||dtjrtj|rtd||_| |_ ||_ ||_ ||_ ||_ ||_|j||_d|_d|_||_d|_d|_dS)afInitialize an external tensor. Args: location: The location of the data file. It is the path relative to the base directory. offset: The offset in bytes from the start of the file. length: The length of the data in bytes. dtype: The data type of the tensor. shape: The shape of the tensor. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. base_dir: The base directory for the external data. It is used to resolve relative paths. rzFThe location must be a relative path. Please specify base_dir as well.NT)rr<onnx_irDEBUGospathisabsrr/r-r0r.rr4rrr6r,rr2rr1) r;r3r5r7r?r@r4r6r7r2rr)r*r<s(   zExternalTensor.__init__str | os.PathLikecCrIr:r-rAr)r)r*r2rKzExternalTensor.base_dirrLcCrMr:r>rNr)r)r*r2rOcCrIr:)r/rAr)r)r*r3rKzExternalTensor.locationcCstj|j|jSr:)r:r;rr-r/rAr)r)r*r;szExternalTensor.pathcCrIr:)r0rAr)r)r*r5rKzExternalTensor.offsetcCrIr:)r.rAr)r)r*r7rKzExternalTensor.lengthcCrIr:rrAr)r)r*r?rKzExternalTensor.dtypecCrIr:rrAr)r)r*r@rKzExternalTensor.shapecCs~||jdus Jd|jdkr"tj|j|jd|_dSt|j d}t j | dt j d|_ Wdn1s?wY|jtjjtjjtjjtjjtjjhvrittj}|jd|jd}nt|jd}|j}tj|j ||jpd|d|_|j}|jjd krt|j||j|_dS|jjdkrt|j||j|_dS|j||_dS) Nz*Bug: The array should be loaded only once.rr?rb)accessrD)r?r5count)_check_validityr,rUremptyr@rTr?openr;mmapr ACCESS_READrrrrrrrrrr frombufferr5rr unpack_4bitx2r unpack_2bitx4reshape)r;fdtrCr@r)r)r*_loadsD       zExternalTensor._loadr rcCs4||jdur ||jdusJ|j|Sr:)rEr,rPr%rr)r)r*r%s   zExternalTensor.__array__rrcCtdNzqExternalTensor does not support DLPack because it uses memory mapping. Call numpy() to get a numpy array instead.NotImplementedErrorrr)r)r*r.zExternalTensor.__dlpack__rcCrQrRrSrAr)r)r*rrUz ExternalTensor.__dlpack_device__c Cs6|d|jd|jd|jd|jd|jd S)Nz (location='z', name=z , offset=z , length=z , base_dir=r)rHr3r4r5r7r2rAr)r)r*r#szExternalTensor.__repr__cCs.||jdur ||jdusJ|jS)zReturn the tensor as a numpy array. The data will be memory mapped into memory and will not taken up physical memory space. N)rEr,rPrAr)r)r*rT)s  zExternalTensor.numpyrcCsP||jdur ||jdusJ|jpd}|jp|j}|j|||S)zXReturn the bytes of the tensor. This will load the tensor into memory. Nr)rErrPr0r.rY)r;r5r7r)r)r*rg4s   zExternalTensor.tobytescCs|t|jd?}|jdur||j|jp|j}d}|dkrA|t||}| ||t |8}|dks"WddSWddS1sLwYdS)Nr@ir) rErGr;r0seekr.rYreadrrflen)r;rhsrc bytes_to_copy chunk_sizechunkr)r)r*riAs      "zExternalTensor.tofilerlcCrI)zlCheck if the tensor is valid. The external tensor is valid if it has not been invalidated. r1rAr)r)r*validMszExternalTensor.validcCs|s td|ddS)NzThe external tensor 'z7' is invalidated. The data may be corrupted or deleted.)r^rrAr)r)r*rETs  zExternalTensor._check_validitycC d|_dS)z~Invalidate the tensor. The external tensor is invalidated when the data is known to be corrupted or deleted. FNr]rAr)r)r* invalidateZr,zExternalTensor.invalidatecCs(d|_|jdur|jd|_dSdS)zLDelete all references to the memory buffer and close the memory-mapped file.N)r,rcloserAr)r)r*releaseas    zExternalTensor.release)r3r4r5r6r7r6r?rr@rr4r=r6r5r7r8r2r4r"r9)r"r=)rLr=r"r9rr"r6r%r&r:r"r#r$r(r)rr"rl)rGrrrrr<rr2rr3r;r5r7r?r@rPr%r.rrrTrgrir^rEr`rbr*r)r)rr*r+[sF 2         /     r+cseZdZdZdZdddddd5fddZd6d7ddZddd8ddZd9ddZd:dd Z e d;d"d#Z e dd*d+Zd?d-d.Zd@d0d1ZdAd3d4ZZS)B StringTensorzaMultidimensional array of strings (as binary data to match the string_data field in TensorProto).)rrNrrL(Sequence[bytes] | npt.NDArray[np.bytes_]r@rr4r5r6r7r8r"r9cshtj|||d|dur't|dstdt|dtt|ddd|_n||_|j||_ dS)a{Initialize a tensor. Args: value: The backing data of the tensor. It can be a numpy array or a Sequence of bytes. shape: The shape of the tensor. If None, the shape is obtained from the value. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. rNr@rrTr) rr<r'rrrrrrr)r;rLr@r4r6r7rr)r*r<qs   zStringTensor.__init__r?r rcCsPt|jtjr |jSt|jtsJdt|jtj|j|d|j S)NzBug: Expected a sequence, got r?) rrrrr rrrMr@rTrr)r)r*r%s zStringTensor.__array__rrcCs ~tdNz$StringTensor does not support DLPackrrr)r)r*r.szStringTensor.__dlpack__rcCrQrgrhrAr)r)r*rzStringTensor.__dlpack_device__r=cC|d|jd|jdSNrrrrHrr4rAr)r)r*rzStringTensor.__repr__rcCstjjSr)rrSTRINGrAr)r)r*r?szStringTensor.dtypercCrIrrrAr)r)r*r@rKzStringTensor.shaperQcCstdd|DS)rVcs|]}t|VqdSr:rX)r stringr)r)r*r r z&StringTensor.nbytes..)sum string_datarAr)r)r*rYszStringTensor.nbytescCrIrrrAr)r)r*rrKzStringTensor.rawnpt.NDArray[np.bytes_]cC|Sz#Return the tensor as a numpy array.)r%rAr)r)r*rTzStringTensor.numpyrcCrQ)NzAStringTensor does not support tobytes. Use 'string_data' instead.)rrAr)r)r*rgrizStringTensor.tobytesSequence[bytes]cCs"t|jtjr|jS|jS)z%Return the string data of the tensor.)rrrrrtolistrAr)r)r*rsszStringTensor.string_data) rLrfr@rr4r5r6r5r7r8r"r9r:r"r#r$rr%r&r)r"rf)r"rtr))r"rx)rGrrrrr<r%r.rrrr?r@rYrrTrgrsr*r)r)rr*reis.          recseZdZdZdZdddddd5fddZd6ddZd7d8ddZddd9d d!Zd:d#d$Z d;d&d'Z e dd,d-Zd?d.d/Zd@d1d2ZdAfd3d4 ZZS)B LazyTensora#A tensor that lazily evaluates a function to get the actual tensor. This class takes a function returning an `ir.TensorProtocol`, a dtype, and a shape argument. The function is lazily evaluated to get the actual tensor when `tobytes()` or `numpy()` is called. Example:: >>> import numpy as np >>> import onnx_ir as ir >>> weights = np.array([[1, 2, 3]]) >>> def create_tensor(): # Delay applying transformations to the weights ... weights_t = weights.transpose() ... return ir.tensor(weights_t) >>> lazy_tensor = ir.LazyTensor(create_tensor, dtype=ir.DataType.INT64, shape=ir.Shape([1, 3])) >>> print(lazy_tensor.numpy()) [[1] [2] [3]] Attributes: func: The function that returns the actual tensor. dtype: The data type of the tensor. shape: The shape of the tensor. cache: Whether to cache the result of the function. If False, the function is called every time the tensor content is accessed. If True, the function is called only once and the result is cached in memory. Default is False. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. )r_funcr_tensorcacheFN)r}r4r6r7func'Callable[[], _protocols.TensorProtocol]r?rr@rr}rlr4r5r6r7r8r"r9cs4tj|||d||_||_||_d|_||_dS)aInitialize a lazy tensor. Args: func: The function that returns the actual tensor. dtype: The data type of the tensor. shape: The shape of the tensor. cache: Whether to cache the result of the function. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. rN)rr<r{rrr|r})r;r~r?r@r}r4r6r7rr)r*r<s  zLazyTensor.__init___protocols.TensorProtocolcCs(|js|S|jdur||_|jS)z/Evaluate the function to get the actual tensor.N)r}r{r|rAr)r)r* _evaluate s   zLazyTensor._evaluater rcCs||Sr:)rr%rr)r)r*r%zLazyTensor.__array__rrcCs|j|dSr)rr.rr)r)r*r.zLazyTensor.__dlpack__rcC |Sr:)rrrAr)r)r*r zLazyTensor.__dlpack_device__r=cCrj)Nz(func=rr)rHr{r4rAr)r)r*rrmzLazyTensor.__repr__cCrIr:)r{rAr)r)r*r zLazyTensor.rawcCrIrrrAr)r)r*r?$rKzLazyTensor.dtypecCrIrrrAr)r)r*r@)rKzLazyTensor.shapecCrrv)rrTrAr)r)r*rT. zLazyTensor.numpyrcCr)zReturn the bytes of the tensor.)rrgrAr)r)r*rg2rzLazyTensor.tobytescs0|}t|dr||dSt|dS)Nri)rr'rir)r;rhrrr)r*ri6s zLazyTensor.tofile)r~rr?rr@rr}rlr4r5r6r5r7r8r"r9r"rr:r"r#r$r)r"rr%r&r(r)r)rGrrrrr<rr%r.rrrrr?r@rTrgrir*r)r)rr*rzs,          rzcseZdZdZdZddddd6fddZd7d8ddZddd9ddZd:d d!Zd;d#d$Z e dd*d+Z d?d,d-Zd@d/d0ZdAd2d3ZdBd4d5ZZS)C PackedTensorz`A tensor that stores 2bit and 4bit datatypes in packed format. .. versionadded:: 0.1.2 rNrrLrr?rr@Shape | Sequence[int]r4r5r6r7r8r"r9cstj|||dt|st|stdt|t||_|j|j dvr0td|||_ ||_ t |t jrz|jtjksZ|jtjksZ|jtjksZ|jtjksZ|jtjkrctd|jd|j|jkr|td|jd|jd |jd d Sd S) aInitialize a tensor. Args: value: The backing data of the tensor. It can be a numpy array compatible object or a DLPack compatible object. The value MUST be packed in an integer dtype. dtype: The data type of the tensor. Must be one of INT2, UINT2, INT4, UINT4, FLOAT4E2M1. shape: The shape of the tensor. name: The name of the tensor. doc_string: The documentation string. metadata_props: The metadata properties. Raises: TypeError: If the value is not a numpy array compatible or a DLPack compatible object. TypeError: If the value is a numpy array and the dtype is not uint8 or one of the ml_dtypes dtypes. rr)rBrDzIPackedTensor only supports INT2, UINT2, INT4, UINT4, FLOAT4E2M1, but got z5PackedTensor expects the value to be packed, but got zD which is not packed. Please pack the value or use `onnx_ir.Tensor`. Expected the packed array to be  bytes (from shape ), but got  bytesN)rr<r+r/rrrrrrrrrrrr?rrrrrrrUrYrr@rrr)r*r<Ls4            zPackedTensor.__init__Fr copyrlrcCrur:)rT)r;r?rr)r)r*r%rizPackedTensor.__array__rrcCrrrrr)r)r*r.rzPackedTensor.__dlpack__rcCrr:rrAr)r)r*rrzPackedTensor.__dlpack_device__r=cCrjrkrlrAr)r)r*rrmzPackedTensor.__repr__cCrIrrrAr)r)r*r?rKzPackedTensor.dtypercCrIrrrAr)r)r*r@rKzPackedTensor.shapecCrIrrrAr)r)r*rrKzPackedTensor.rawcCs&|}t||j|jSr) numpy_packedrrKr@rTrr?rr)r)r*rTszPackedTensor.numpynpt.NDArray[np.uint8]cCst|jtjs t|jrt|j}nt|js"Jdt|jt|j}|j |j kr?t d|j d|j d|j d| tj S)z$Return the tensor as a packed array.rrrrr)rrrrr+asarrayr/rrrYrr@rrrr)r)r*rs    zPackedTensor.numpy_packedrcCs&|}ts||jd}|S)rrD)rrrr?rrgrr)r)r*rgszPackedTensor.tobytescCsFt|r|}ts||jd}||dS||dS)r rDN) rrrrr?rrirfrgr!r)r)r*ris zPackedTensor.tofile)rLrr?rr@rr4r5r6r5r7r8r"r9NF)r?r rrlr"rr#r$rr%r&r'r()r"rr)r)rGrrrrr<r%r.rrrr?r@rrTrrgrir*r)r)rr*r@s*  7        rc@sTeZdZdZdZdddZdd d ZdddZedddZ dddZ dddZ dS) SymbolicDimzImmutable symbolic dimension that can be shared across multiple shapes. SymbolicDim is used to represent a symbolic (non-integer) dimension in a tensor shape. It is immutable and can be compared or hashed. _valuerLr5r"r9cCst|tr td||_dS)zInitialize a symbolic dimension. Args: value: The value of the dimension. It should not be an int. Raises: TypeError: If value is an int. zrThe value of a SymbolicDim cannot be an int. If you are creating a Shape, use int directly instead of SymbolicDim.N)rrQrrrNr)r)r*r<s  zSymbolicDim.__init__otherobjectrlcCs t|ts |j|kS|j|jkS)z7Check equality with another SymbolicDim or string/None.)rrrLr;rr)r)r*__eq__s   zSymbolicDim.__eq__rQcC t|jS)z0Return the hash of the symbolic dimension value.)hashrLrAr)r)r*__hash__rOzSymbolicDim.__hash__cCrI)z5The value of the symbolic dimension (string or None).rrAr)r)r*rLrKzSymbolicDim.valuer=cC|jSr:rrAr)r)r*__str__rizSymbolicDim.__str__cCs|jjd|jdSNrr)rFrGrrAr)r)r*rzSymbolicDim.__repr__Nrrrr"rlrrr) rGrrrrr<rrrrLrrr)r)r)r*rs     rrLrTypeIs[SupportsInt]cCs t|trdSt|drdSdS)zCheck if the value is compatible with int (i.e., can be safely cast to int). Args: value: The value to check. Returns: True if the value is an int or has an __int__ method, False otherwise. T__int__F)rrQr')rLr)r)r*_is_int_compatibles  rdim,int | SupportsInt | SymbolicDim | str | NoneSymbolicDim | intcCsR|dus t|tr t|St|rt|St|tr|Std|dt|d)a Convert the value to a SymbolicDim if it is not an int. Args: dim: The dimension value, which can be int, str, None, or SymbolicDim. Returns: An int or SymbolicDim instance. Raises: TypeError: If the value is not int, str, None, or SymbolicDim. Nz2Expected int, str, None or SymbolicDim, but value z has type '')rr=rrrQrr)rr)r)r*_maybe_convert_to_symbolic_dims rc@sXeZdZdZdZ  dLdMd dZedNddZedOddZdPddZ dQdRddZ dSddZ dTddZ dSddZ dUd!d"ZejdVd%d&ZejdWd(d&Zd)d&ZdXd,d-ZdYd/d0ZdZd2d3Zd[d5d6Zd[d7d8Zd\d;d<Zd\d=d>Zejd]d@dAZejdOdBdAZd^dOdCdAZejd]dDdEZejdOdFdEZd^dOdGdEZd]dHdIZdOdJdKZdS)_rarRepresents the shape of a tensor, including its dimensions and optional denotations. The :class:`Shape` class stores the dimensions of a tensor, which can be integers, None (unknown), or symbolic dimensions. It provides methods for querying and manipulating the shape, as well as for comparing shapes to other shapes or plain Python lists. A shape can be frozen (made immutable). When the shape is frozen, it cannot be unfrozen, making it suitable to be shared across tensors or values. Call :meth:`freeze` to freeze the shape. To update the dimension of a frozen shape, call :meth:`copy` to create a new shape with the same dimensions that can be modified. Use :meth:`get_denotation` and :meth:`set_denotation` to access and modify the denotations. .. note:: Two shapes can be compared for equality. Be careful when comparing shapes with unknown dimensions (``None``), as they may not be considered semantically equal even if all dimensions are the same. You can use :meth:`has_unknown_dim` to check if a shape has any unknown dimensions. Example:: >>> import onnx_ir as ir >>> shape = ir.Shape(["B", None, 3]) >>> shape.rank() 3 >>> shape.is_static() False >>> shape.is_dynamic() True >>> shape.is_static(dim=2) True >>> shape[0] = 1 >>> shape[1] = 2 >>> shape.dims (1, 2, 3) >>> shape == [1, 2, 3] True >>> shape.frozen False >>> shape.freeze() >>> shape.frozen True Attributes: dims: A tuple of dimensions representing the shape. Each dimension can be an integer, None, or a :class:`SymbolicDim`. frozen: Indicates whether the shape is immutable. When frozen, the shape cannot be modified or unfrozen. )_dims_frozenNF denotationsIterable[str | None] | Nonerrldims6Iterable[int | SupportsInt | SymbolicDim | str | None]r"r9cCsXdd|D|_|durt|ndgt|j|_t|jt|jkr'td||_dS)aInitialize a shape. Args: dims: The dimensions of the shape. Each dimension can be an integer or a SymbolicDim or any Python object. When a ``dim`` is not an integer or a SymbolicDim, it is converted to a SymbolicDim. denotations: The denotations of the dimensions. If None, the denotations are not set. Standard denotation can optionally be used to denote tensor dimensions with standard semantic descriptions to ensure that operations are applied to the correct axis of a tensor. Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition for pre-defined dimension denotations. frozen: If True, the shape is immutable and cannot be modified. This is useful when the shape is initialized by a Tensor or when the shape is shared across multiple tensors. The default is False. cSg|]}t|qSr))rr rr)r)r* sz"Shape.__init__..NzTThe number of denotations, when provided, must be equal to the number of dimensions.)rlistrX _denotationsrr)r;rrrr)r)r*r<is zShape.__init__tuple[int | SymbolicDim, ...]cCr)zAll dimensions in the shape. This property is read-only. Use __getitem__ and __setitem__ to modify the shape or create a new shape. tuplerrAr)r)r*rs z Shape.dimscCrI)aWhether the shape is frozen. When the shape is frozen, it cannot be unfrozen, making it suitable to be shared. Call :meth:`freeze` to freeze the shape. Call :meth:`copy` to create a new shape with the same dimensions that can be modified. rrAr)r)r*rz Shape.frozencCr_)zuFreeze the shape. When the shape is frozen, it cannot be unfrozen, making it suitable to be shared. TNrrAr)r)r*rr,z Shape.freezecCst|j|j|dS)zReturn a copy of the shape.r)rrr)r;rr)r)r*rrCz Shape.copyrQcCr)z-The rank of the tensor this shape represents.rXrrAr)r)r*rankrOz Shape.ranktuple[int, ...]cCs8tdd|jDrtd|dtdd|jDS)Ncss|] }t|t VqdSr:rrQrr)r)r*r zShape.numpy..zCannot convert the shape z to a tuple of intscss|]}|VqdSr:r)rr)r)r*r s)anyrrrrAr)r)r*rTsz Shape.numpycCrr:rrAr)r)r*__len__ z Shape.__len__Iterator[int | SymbolicDim]cCrr:)iterrrAr)r)r*__iter__rzShape.__iter__indexint | SymbolicDimcCdSr:r)r;rr)r)r* __getitem__zShape.__getitem__slicecCrr:r)rr)r)r*rrcCst|j|Sr:rrr)r)r*rrrLint | SymbolicDim | str | NonecCs |jrtdt||j|<dS)a.Set the dimension at the index. Args: index: The index of the dimension. value: The value of the dimension. Raises: TypeError: If the shape is frozen and cannot be modified. TypeError: If the value is not an int or SymbolicDim. z+The shape is frozen and cannot be modified.N)rrrr)r;rrLr)r)r* __setitem__s zShape.__setitem__r5cC |j|S)zReturn the denotation of the dimension at the index. Args: index: The index of the dimension. Returns: The denotation of the dimension. rrr)r)r*get_denotations zShape.get_denotation denotationcCs||j|<dS)zSet the denotation of the dimension at the index. Args: index: The index of the dimension. denotation: The denotation of the dimension. Nr)r;rrr)r)r*set_denotationszShape.set_denotationr=cCs|jjd|jdSr)rFrGrrAr)r)r*rrzShape.__repr__cCsdddd|jDdS)zKReturn a string representation of the shape. E.g. [n,1,3] [r>cSrr)r=rr)r)r*rz!Shape.__str__..])rrrAr)r)r*rsz Shape.__str__rrcCs2t|tr |j|jkSt|tsdS|jt|kS)znReturn True if the shapes are equal. Two shapes are equal if all their dimensions are equal. F)rrrrrrr)r)r*rs   z Shape.__eq__cCs || Sr:)rrr)r)r*__ne__rz Shape.__ne__rcCdS)z'Return True if the dimension is static.Nr)r;rr)r)r* is_staticzShape.is_staticcCr)z)Return True if all dimensions are static.Nr)rAr)r)r*rrcCs*|durtdd|jDSt||tS)zaReturn True if the dimension is static. If dim is None, return True if all dimensions are static.Ncs|]}t|tVqdSr:rrr)r)r*r z"Shape.is_static..)allrrrQrr)r)r*rscCr)z(Return True if the dimension is dynamic.Nr)rr)r)r* is_dynamic rzShape.is_dynamiccCr)z(Return True if any dimension is dynamic.Nr)rAr)r)r*rrcCs|dur | S|| Sr:)rrr)r)r*rs  cCs|j|}t|to|jduS)zReturn True if the dimension is unknown (None). A dynamic dimension without a symbolic name is considered unknown. .. versionadded:: 0.1.10 Args: dim: The index of the dimension. N)rrrrL)r;rdim_objr)r)r*is_unknown_dims zShape.is_unknown_dimcCs d|jvS)zReturn True if any dimension is unknown (None). You can use :meth:`is_unknown_dim` to check if a specific dimension is unknown. .. versionadded:: 0.1.10 N)rrAr)r)r*has_unknown_dim%s zShape.has_unknown_dimr)rrrrlrrr"r9)r"rrdrF)rrlrr"r)r"r)rrQr"r)rrr"r)rrQrLrr"r9)rrQr"r5)rrQrr5r"r9rr)rrQr"rlr:)rGrrrrr<rrrrrrrTrrtypingoverloadrrrrrrrrrrrrr)r)r)r*r2sP4 #                      rrqr=cCs d|dS)zsReturn a quoted string. This function is used to quote value/node names in the IR for better readability. "r))rqr)r)r*_quoted0s rc@"eZdZUdZded<ded<dS)UsagezA usage of a value in a node. Attributes: node: The node that uses the value. idx: The input index of the value in the node. NodenoderQidxNrGrrr__annotations__r)r)r)r*r8s  rxValuecCsR|jdurdS|jjdkr'z |j}Wn ty YdSwd|dSdS)Nrn z{...}{}) const_valuerUrTryr)rdatar)r)r*_short_tensor_str_for_nodeDs    rdomaincCs|dkrdS|S)zNormalize 'ai.onnx' to ''.zai.onnxrnr))rr)r)r*_normalize_domainPrc seZdZdZdZ dkddddddddddlddZdmdd Zdnd!d"Zdnd#d$Ze dod%d&Z e j dpd)d&Z e dnd*d+Z e j dqd,d+Z e drd-d.Z e j dsd/d.Z e dnd0d1Zej dqd2d1Ze dnd3d4Zej dqd5d4Ze dtd7d8Zej dud;d8Zdvd>d?ZdwdAdBZdwdCdDZdxdGdHZdydKdLZdydMdNZe dzdPdQZej d{dRdQZdvdSdTZe d|dVdWZe d}dYdZZe d~d\d]Ze dd_d`Zej ddad`ZddcddZdedfdfdidjZZS)raIR Node. .. tip:: For a more convenient way (that supports Python objects as attributes) to create a node, use the :func:`onnx_ir.node` constructor. If ``graph`` is provided, the node will be added to the graph. Otherwise, the user is responsible for calling ``graph.append(node)`` (or other mutation methods in :class:`Graph`) to add the node to the graph. After the node is initialized, it will add itself as a user of its input values. The output values of the node are created during node initialization and are immutable. To change the output values, create a new node and, for each use of the old outputs (``output.uses()``), replace the input in the consuming node by calling :meth:`replace_input_with`. You can also use the :func:`~onnx_ir.convenience.replace_all_uses_with` method to replace all uses of the output values. .. note:: When the ``domain`` is ``"ai.onnx"``, it is normalized to ``""``. ) _attributes_domain_graph_inputsrr2r3_op_type_outputs _overload_versionr6r)rnN)r num_outputsoutputsversiongraphr4r6r7rr=op_typeinputsIterable[Value | None] attributes#Iterable[Attr] | Mapping[str, Attr]rrr6rSequence[Value] | NonerrGraph | Function | Noner4r5r6r7r8cCs| |_t||_||_t||_||||_t|t r"t| }t j ||d|_ ||_||_d|_| |_d|_| durB| || |_t|jD]\} }|durX||| qJdS)aInitialize a node and add it as a user of the input values. Args: domain: The domain of the operator. For onnx operators, this is an empty string. When it is ``"ai.onnx"``, it is normalized to ``""``. op_type: The name of the operator. inputs: The input values. When an input is ``None``, it is an empty input. attributes: The attributes. RefAttr can be used only when the node is defined in a Function. overload: The overload name when the node is invoking a function. num_outputs: The number of outputs of the node. If not specified, the number is 1. outputs: The output values. If ``None``, the outputs are created during initialization. version: The version of the operator. If ``None``, the version is unspecified and will follow that of the graph. graph: The graph that the node belongs to. If ``None``, the node is not added to any graph. A `Node` must belong to zero or one graph. If a :class:`Function`, the underlying graph of the function is assigned to the node. name: The name of the node. If ``None``, the node is anonymous. The name may be set by a :class:`Graph` if ``graph`` is specified. doc_string: The documentation string. metadata_props: The metadata properties. Raises: TypeError: If the attributes are not :class:`Attr`. ValueError: If ``num_outputs``, when not ``None``, is not the same as the length of the outputs. ValueError: If an output value is ``None``, when outputs is specified. ValueError: If an output value has a producer set already, when outputs is specified. ownerN)r3rrrrr_create_outputsrrrvaluesr Attributesrrrrr2rrr6 enumerate _add_usage)r;rrr r rrrrrr4r6r7i input_valuer)r)r*r<{s.*      z Node.__init__r"tuple[Value, ...]cs|dur|dur|t|krtd|d||durV|D]}|dur+td||dur;td|d|qg}t|D]\}}|_||_||qBt|S|dur\d}|dusbJtfdd t|DS) aCheck the parameters and create outputs for the node. Args: num_outputs: The number of outputs of the node. outputs: The output values of the node. Returns: The output values of the node. Raises: ValueError: If `num_outputs`, when not None, is not the same as the length of the outputs. ValueError: If an output value is None. ValueError: If an output value has a producer set already. NzXnum_outputs must be the same as len(outputs) when num_outputs is specified.num_outputs: z , outputs: z*Output value cannot be None. All outputs: zXSupplied output value cannot have a producer when used for initializing a Node. Output: z. All outputs: c3s|] }t|dVqdS)rNrr rrAr)r*r rz'Node._create_outputs..) rXrproducerr _producer_indexrrrange)r;rroutputresultrr)rAr*rs>   zNode._create_outputscCs|jd|jd|j|jdk}dddd|jDd}|jr7d dd d|jDd nd}dd d |jD}|d|||S)N:::rnr, cSsFg|]}|durd|jrt|jndtt|t|ndqS)N% anonymous:r9)r4rr=idrr rr)r)r*rs .z Node.__str__..rz {cSsg|] \}}|d|qS)=r))r kvr)r)r*rsrcsror:rr)r)r)r*r  r zNode.__str__..u ⬅️ )rrrrrritemsr)r;node_type_text inputs_textattributes_text outputs_textr)r)r*rs& $z Node.__str__cCsV|jjd|jd|jd|jd|jd|jd|jd|jd|j d |j d S) N(name=z , domain=z , op_type= , inputs= , attributes=z , overload=z , outputs=z , version=z , doc_string=r) rFrGr3rrrrrrrr6rAr)r)r*rs z Node.__repr__cCrI)zOptional name of the node.rJrAr)r)r*r4rKz Node.namerLr9cCrMr:rJrNr)r)r*r4rOcCrI)zThe domain of the operator. For onnx operators, this is an empty string. .. note: When domain is `"ai.onnx"`, it is normalized to `""`. rrAr)r)r*r sz Node.domaincCt||_dSr:rrrNr)r)r*r)cCrI)aUOpset version of the operator called. If ``None``, the version is unspecified and will follow that of the graph. This property is special to ONNX IR to allow mixed opset usage in a graph for supporting more flexible graph transformations. It does not exist in the ONNX serialization (protobuf) spec. rrAr)r)r*r- z Node.versioncCrMr:r9rNr)r)r*r8rOcCrI)z The name of the operator called.rrAr)r)r*r<rKz Node.op_typecCrMr:r;rNr)r)r*rArOcCrI)z7The overload name when the node is invoking a function.rrAr)r)r*rErKz Node.overloadcCrMr:r<rNr)r)r*rJrOSequence[Value | None]cCrI)aThe input values of the node. The inputs are immutable. To change the inputs, create a new node and replace the inputs of the using nodes of this node's outputs by calling :meth:`replace_input_with` on the using nodes of this node's outputs. rrAr)r)r*r Nrz Node.inputs_r cCrQ)Nz_Node.inputs cannot be assigned to. Please use 'resize_inputs' and 'replace_input_with' instead.AttributeErrorr;r?r)r)r*r Xnew_sizerQcCsft|j}||kr dS||kr't||D]}||dq|jd||_dS|jd|||_dS)aResize the inputs of the node. If the new size is greater than the current size, new inputs are added as None. If the new size is less than the current size, the extra inputs are removed. After ``inputs`` is resized, you can use :meth:`replace_input_with` to set the new inputs. .. versionadded:: 0.1.13 Args: new_size: The new number of inputs. Nr:)rXrr replace_input_with)r;rD current_sizerr)r)r* resize_inputs_s zNode.resize_inputsSequence[Node]cCs8i}|jD]}|dur|}durd||<qt|S)zQReturn the predecessor nodes of the node, deduplicated, in a deterministic order.N)r rr)r; predecessorsrLrr)r)r*rIxs  zNode.predecessorscCs@i}|jD]}|dusJd|D]}d||j<qqt|S)zOReturn the successor nodes of the node, deduplicated, in a deterministic order.Nz.Bug: Output values are not expected to be None)rusesrr)r; successorsrLusager)r)r*rKs   zNode.successorsr Value | Nonecs~dks t|jkrtd|j}tfddt|jD|_|dur1||dur=|dSdS)z"Replace an input with a new value.rzIndex out of range: c3s$|] \}}|kr n|VqdSr:r))r r old_inputrrLr)r*r s z*Node.replace_input_with..N)rXr rrrr _remove_usager)r;rrLrNr)rOr*rEs   zNode.replace_input_withnodesNode | Iterable[Node]cC$|jdur td|j||dS)aInsert a node before this node in the list of nodes in the graph. It is the same as calling ``graph.insert_before(self, nodes)``. Example:: Before: previous_node -> self previous_node' -> node -> next_node' After: previous_node -> node -> self previous_node' -> next_node' Args: nodes: A node or a sequence of nodes to put before this node. Nz4The node to prepend to does not belong to any graph.)rr insert_beforer;rQr)r)r*prepend z Node.prependcCrS)aInsert a node after this node in the list of nodes in the graph. It is the same as calling ``graph.insert_after(self, nodes)``. Example:: Before: previous_node -> self previous_node' -> node -> next_node' After: previous_node -> self -> node previous_node' -> next_node' Args: nodes: A node or a sequence of nodes to put after this node. Nz3The node to append to does not belong to any graph.)rr insert_afterrUr)r)r*rrWz Node.appendSequence[Value]cCrI)aThe output values of the node. The outputs are always attached to this node once initialized (immutable), except that the list can be resized to remove or add outputs. Use :meth:`resize_outputs` to change the number of outputs of the node. rrAr)r)r*rr:z Node.outputscCrQ)Nz]Node.outputs cannot be assigned to. Please use 'resize_outputs' or create a new node instead.r@rBr)r)r*rrCcstj}||kr dS||krCj|dD]}|r(td|d|qj|dD]}d|_d|_q0jd|_dSfddt||D}jt|_dS)aResize the outputs of the node. If the new size is greater than the current size, new output values are created. If the new size is less than the current size, the extra output values are removed. The removed output values must not have any uses. .. versionadded:: 0.1.13 Args: new_size: The new number of outputs. Raises: ValueError: If the new size is less than the current size and the removed outputs have uses. NzCannot remove output z because it has uses: csg|]}t|dqS)rrrrAr)r*rz'Node.resize_outputs..)rXrrJrrrr r)r;rDrFr! new_outputsr)rAr*resize_outputss zNode.resize_outputs_graph_containers.AttributescCrI)aThe attributes of the node as ``dict[str, Attr]`` with additional access methods. Use it as a dictionary with keys being the attribute names and values being the :class:`Attr` objects. Use ``node.attributes.add(attr)`` to add an attribute to the node. Use ``node.attributes.get_int(name, default)`` to get an integer attribute value. Refer to the :class:`~onnx_ir._graph_containers.Attributes` for more methods. rrAr)r)r*r s zNode.attributesr^cCr_r`rbrAr)r)r*rdrez Node.metarZcCr[)zThe metadata properties of the node. The metadata properties are used to store additional information about the node. Unlike ``meta``, this property is serialized to the ONNX proto. Nr\rAr)r)r*r7 r]zNode.metadata_props Graph | NonecCrI)zsThe graph that the node belongs to. If the node is not added to any graph, this property is None. rrAr)r)r*rsz Node.graphcCrMr:rbrNr)r)r*rrO_protocols.OperatorIdentifiercC|j|j|jfS)zReturn the operator identifier of the node. The operator identifier is a tuple of the domain, op_type and overload. )rrrrAr)r)r* op_identifier"szNode.op_identifierFrjrkrlcs8td|j|jrtd|jtj|ddS)zfPretty print the node. This method is used for debugging and visualization purposes. zNode: zDoc: rjN)rr4r6rr)r;rkrr)r*r)sz Node.display)r))rr=rr=r r r r rr=rr6rr rr6rrr4r5r6r5r7r8)rr6rr r"rrrrrLr=r"r9rc)rLr6r"r9)r"r=)r?r r"r9)rDrQr"r9r"rH)rrQrLrMr"r9)rQrRr"r9)r"rY)r?rYr"r9r"r_rrr"ra)rLrar"r9r"rcr) rGrrrrr<rrrrr4rrrrrr rGrIrKrErVrrr^r rdr7rrerr*r)r)rr*rUs I 0                   $      rc@sneZdZdZdZdddd d Zedd dZejd ddZedddZ d!ddZ d"ddZ d#ddZ dS)$_TensorTypeBasez*Tensor types that are non recursive types.rrNrr?rrr5r"r9cC||_||_dSr:rl)r;r?rr)r)r*r<:s z_TensorTypeBase.__init__cCrIr:rrAr)r)r*r?>rz_TensorTypeBase.dtyperLcCrMr:rrNr)r)r*r?BrOcCrI)z+Return the element type of the tensor type.r?rAr)r)r* elem_typeFrKz_TensorTypeBase.elem_typerQcC tt|Sr:rrrAr)r)r*rKrz_TensorTypeBase.__hash__rrrlcCs|j|jurdS|j|jkSr)rFr?rr)r)r*rNs  z_TensorTypeBase.__eq__r=cC"|jjdd}|d|jdSNrr)rFrGr?r; short_namer)r)r*rSz_TensorTypeBase.__repr__)r?rrr5r"r9r%rLrr"r9rrr rGrrrrr<rr?rrorrrr)r)r)r*rk5s     rkc@seZdZdZdddZdS) TensorTypez A type that represents a tensor.r"r=cCrr:r?rAr)r)r*r\rizTensorType.__str__Nr)rGrrrrr)r)r)r*rzYsrzc@eZdZdZdS)SparseTensorTypez'A type that represents a sparse tensor.NrGrrrr)r)r)r*r|`r|c@sneZdZdZdZdddd d Zed ddZejd!ddZed"ddZ d#ddZ d$ddZ d%ddZ dS)&_RecursiveTypeBasez4Base for recursive types like Optional and Sequence. _elem_typerNrmro_protocols.TypeProtocolrr5r"r9cCrnr:r)r;rorr)r)r*r<is z_RecursiveTypeBase.__init__rcC|jjSr:rr?rAr)r)r*r?orwz_RecursiveTypeBase.dtyperLcC ||j_dSr:rrNr)r)r*r?srcCrIr:)rrAr)r)r*rowrz_RecursiveTypeBase.elem_typerQcCrpr:rqrAr)r)r*r{rz_RecursiveTypeBase.__hash__rrrlcCs*t|tsdS|j|jkrdS|j|jkSr)rrrFrorr)r)r*r~s   z_RecursiveTypeBase.__eq__r=cCrrrs)rFrGrorur)r)r*rrwz_RecursiveTypeBase.__repr__)rorrr5r"r9r%rx)r"rrrrryr)r)r)r*rds     rc@r{) SequenceTypez.A type that represents a sequence of elements.Nr}r)r)r)r*rr~rc@r{) OptionalTypez+A type that represents an optional element.Nr}r)r)r)r*rr~rc@sBeZdZdZdddZdddZddd Zdd d Zdd d ZdS)_OpHandlerProtocolaPProtocol for an object that can handle magic methods on Values. .. note:: Only the basic arithmetic magic methods are supported on Values. Importantly, ``__eq__`` is not included because Values may need to be compared for identity. For consistency, none of the other comparison operators are included. r"rcCrr:r)r;lhsrhsr)r)r*Addrz_OpHandlerProtocol.AddcCrr:r)rr)r)r*Subrz_OpHandlerProtocol.SubcCrr:r)rr)r)r*Mulrz_OpHandlerProtocol.MulcCrr:r)rr)r)r*Divrz_OpHandlerProtocol.DivcCrr:r))r;operandr)r)r*Negrz_OpHandlerProtocol.NegN)r"r) rGrrrrrrrrr)r)r)r*rs   rhandler_OpHandlerProtocol | NonecCstj}|t_|S)aSet the magic handler for Value arithmetic methods. Framework authors can implement custom context managers that set the magic handler to enable arithmetic operations on Values. Example:: class MyOpHandler: def Add(self, lhs, rhs): # Implement addition logic here pass ... @contextlib.contextmanager def graph_context(graph): old_handler = onnx_ir.set_value_magic_handler(MyOpHandler(graph)) try: yield finally: onnx_ir.set_value_magic_handler(old_handler) Args: handler: The magic handler to set. Returns: The previous magic handler. )WithArithmeticMethods_magic_handler)r old_handlerr)r)r*set_value_magic_handlersrc@sneZdZUdZdZded<ddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZdS)rzMixin class that adds arithmetic methods to Value. This class is used to add arithmetic methods to Value that support arithmetic operations. Nz#ClassVar[_OpHandlerProtocol | None]rcCs|jdur td|jS)NzWNo magic handler is set. Please use 'onnx_ir.set_value_magic_handler' to set a handler.)rrrAr)r)r*_get_magic_handlers z(WithArithmeticMethods._get_magic_handlercC|||Sr:rrrr)r)r*__add__rzWithArithmeticMethods.__add__cCrr:rrrr)r)r*__sub__rzWithArithmeticMethods.__sub__cCrr:rrrr)r)r*__mul__rzWithArithmeticMethods.__mul__cCrr:rrrr)r)r* __truediv__rz!WithArithmeticMethods.__truediv__cCs||Sr:)rrrAr)r)r*__neg__rzWithArithmeticMethods.__neg__cC|||Sr:rrr)r)r*__radd__rzWithArithmeticMethods.__radd__cCrr:rrr)r)r*__rsub__rzWithArithmeticMethods.__rsub__cCrr:rrr)r)r*__rmul__rzWithArithmeticMethods.__rmul__cCrr:rrr)r)r* __rtruediv__rz"WithArithmeticMethods.__rtruediv__)rGrrrrrrrrrrrrrrrr)r)r)r*rs   rc @seZdZdZdZ d\ddddddddd]ddZd^ddZd^ddZd^ddZe d_d d!Z d`d#d$Z dad%d&Z dbd(d)Z dcd*d+Zddd-d.Zded2d3Zded4d5Ze dfd6d7Zejdgd9d7Ze dhd:d;Zejdidd?ZejdkdAd?Ze dldBdCZejdmdDdCZe dndEdFZejdodGdFZe dpdIdJZe dqdLdMZd`dNdOZd`dPdQZd`dRdSZ TdrdsdWdXZdtdZd[ZdS)uraIR Value. A value is a named entity that can be used to represent an input or output of a graph, a function, or a node. The information it stores generalizes over ``ValueInfoProto`` in the ONNX specification. A :class:`Value` is always not owned or owned by exactly one node. When the value is not owned, it must be an input of a graph or a function. ``producer`` and ``index`` are ``None``. When the value is owned by a node, it is an output of the node. The node that produces the value can be accessed with :meth:`producer`. The index of the output of the node that produces the value can be accessed with :meth:`index`. To find all the nodes that use this value as an input, call :meth:`uses`. Consuming nodes can be obtained with :meth:`consumers`. To check if the value is an is an input, output or initializer of a graph, use :meth:`is_graph_input`, :meth:`is_graph_output` or :meth:`is_initializer`. Use :attr:`graph` to get the graph that owns the value. .. note:: Magic methods Only the basic arithmetic magic methods are supported on Values. Importantly, ``__eq__`` is not included because Values may need to be compared for identity. For consistency, none of the other comparison operators are included. .. versionadded:: 0.1.14 Value now supports arithmetic magic methods when a handler is set via :func:`onnx_ir.set_value_magic_handler`. ) _const_valuerr_is_graph_input_is_graph_output_is_initializerrr2r3rr_type_usesr6N)rr4r@rr6rr7r Node | Nonerr6r4r5r@rr_protocols.TypeProtocol | Noner6r _protocols.TensorProtocol | Noner7r8r"r9c CsX||_||_d|_||_||_||_||_||_i|_||_ d|_ d|_ d|_ d|_ dS)aInitialize a value. When assigning a name to the value, the name of the backing `const_value` (Tensor) will also be updated. If the value is an initializer of a graph, the initializers dictionary of the graph will also be updated. .. versionchanged:: 0.1.10 Assigning a name to the value will also update the graph initializer entry if the value is an initializer of a graph. Args: producer: The node that produces the value. It can be ``None`` when the value is initialized first than its producer. index: The index of the output of the defining node. name: The name of the value. shape: The shape of the value. type: The type of the value. doc_string: The documentation string. const_value: The constant tensor if the value is constant. metadata_props: Metadata that will be serialized to the ONNX file. NF)rrrr2r3rrrrr6rrrr) r;rrr4r@rr6rr7r)r)r*r<% s! zValue.__init__r=c Cs|jr|jndtt|}|jdurd|jnd}|jdur&d|jnd}|}|dur3d}n|jdur@d|jd}ndt|}|durTd|nd}|}|rad |}|jj d ||||||d S) Nr'z, type=rnz, shape=z , producer='rz, producer=anonymous_node:z, index=z, const_value=r2r) r4r=r(rr@rr_constant_tensor_partrFrG)r; value_name type_text shape_textr producer_text index_textconst_value_textr)r)r*r_ s  (zValue.__repr__c Cst|jdur|jndtt|}|jdurt|jnd}|jdur&t|jnd}dt|d|d|d|S)Nr'?r&rDr>rE)r4r=r(r@rrr)r;rrrr)r)r*rp s "z Value.__str__cCs:|jdur|jjdkrd|jdSd|jjjdSdS)z@Display string for the constant tensor attached to str of Value.Nrrrz(...)}rn)rrUrFrGrAr)r)r*r{ s  zValue._constant_tensor_partracCs&|jdur|jS|jdur|jjSdS)aKReturn the graph that defines this value. When the value is an input/output/initializer of a graph, the owning graph is that graph. When the value is an output of a node, the owning graph is the graph that the node belongs to. When the value is not owned by any graph, it returns ``None``. N)rrrrAr)r)r*r s  z Value.graphrlcCs(|jp|jp|j}|r|jdusJ|S)z-Return True if the value is owned by a graph.N)rrrr)r;r"r)r)r*_owned_by_graph szValue._owned_by_graphcCrI)aThe node that produces this value. When producer is ``None``, the value does not belong to a node, and is typically a graph input or an initializer. You can use :meth:`graph`` to find the graph that owns this value. Use :meth:`is_graph_input`, :meth:`is_graph_output` or :meth:`is_initializer` to check if the value is an input, output or initializer of a graph. )rrAr)r)r*r rzValue.producerrHcCstdd|jDS)z8Return the nodes (deduplicated) that consume this value.cSsi|]}|jdqSr:)r)r rLr)r)r* rz#Value.consumers..rrrAr)r)r* consumers szValue.consumerscCrI)z-The index of the output of the defining node.)rrAr)r)r*r rz Value.indexCollection[Usage]cCr)zReturn a set of uses of the value. The set contains tuples of ``(Node, index)`` where the index is the index of the input of the node. For example, if ``node.inputs[1] == value``, then the use is ``(node, 1)``. rrAr)r)r*rJ s z Value.usesuserrQcCsd|jt||<dS)ztAdd a usage of this value. This is an internal method. It should only be called by the Node class. N)rrr;rrr)r)r*r szValue._add_usagecCs|jt||dS)zRemove a node from the uses of this value. This is an internal method. It should only be called by the Node class. N)rpoprrr)r)r*rP szValue._remove_usagecCrIr:rJrAr)r)r*r4 rz Value.namerLcCs|j|krdS|}|r5|durtd|j}|dusJ||jvr5|j||ur5td|d|d|jdur>||j_|j}||_|rj|dusNJd|j}|dusWJ|dus]J|j|||j|<dSdS)NzhInitializer value cannot have name set to None. Please pop() the value from initializers first to do so.zCannot rename initializer 'z' to 'z0': an initializer with that name already exists.zdebug: Should be guarded above)r3is_initializerrr initializersrr4r)r;rLrrold_namer)r)r*r4 s4      cCrI)zThe type of the tensor. Example types can be ``TensorType``, ``SparseTensorType``, ``SequenceType``, ``OptionalType``. To obtain the data type of the tensor, use ``type.dtype`` or conveniently :attr:`dtype`. rrAr)r)r*r rz Value.typecCrMr:rrNr)r)r*r rOrcCs|jdurdS|jjS)zThe data type of the tensor.N)rr?rAr)r)r*r? s z Value.dtypercCs$|jdur t||_dS||j_dS)zSet the data type of the tensor. If the type is not set, it will be initialized to a new TensorType. To set the type as other types like ``SequenceType``, initialize the type then set :attr:`type` instead. N)rrzr?rNr)r)r*r? s  cCrIr:rrAr)r)r*r@ rz Value.shapecCs:|dur d|_dSt|tr||_dStdt|d)Nz+Expected value to be a Shape or None, got 'r)rrrrrrNr)r)r*r@ s cCrI)aJThe backing constant tensor for the value. If the ``Value`` has a ``const_value`` and is part of a graph initializers dictionary, the value is an initialized value. Its ``const_value`` will appear as an ``initializer`` in the GraphProto when serialized. If the ``Value`` is not part of a graph initializers dictionary, the ``const_value`` field will be ignored during serialization. ``const_value`` can be backed by different raw data types, such as numpy arrays. The only guarantee is that it conforms TensorProtocol. )rrAr)r)r*r szValue.const_valuecCs8tjr|durt|tjstdt|d||_dS)Nz4Expected value to be a TensorProtocol or None, got 'r)r8r9rrTensorProtocolrrrrNr)r)r*r2 s  r^cCr_r`rbrAr)r)r*rd> rez Value.metarZcCr[)zThe metadata properties of the value. The metadata properties are used to store additional information about the value. Unlike ``meta``, this property is serialized to the ONNX proto. Nr\rAr)r)r*r7I r]zValue.metadata_propscCrI)z)Whether the value is an input of a graph.)rrAr)r)r*is_graph_inputT rzValue.is_graph_inputcCrI)z*Whether the value is an output of a graph.)rrAr)r)r*is_graph_outputX rzValue.is_graph_outputcCrI)z/Whether the value is an initializer of a graph.)rrAr)r)r*r\ rzValue.is_initializerFreplace_graph_outputs replacementcCs||r-|j}|dus J|st|d|jdt|jD] \}}||ur,||j|<q|D] \}}|||q1dS)a:Replace all uses of this value with another value. .. 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. To replace usage of a sequence of values with another sequence of values, consider using :func:`onnx_ir.convenience.replace_all_uses_with`. .. versionadded:: 0.1.12 Args: replacement: The value to replace all uses with. replace_graph_outputs: If True, graph outputs that reference this value will also be updated to reference the replacement. Raises: ValueError: When ``replace_graph_outputs`` is False && when the value to replace is a graph output. Nz is an output of graph zh. Set replace_graph_outputs=True or replace the graph output frist before calling replace_all_uses_with.)rrrr4rrrJrE)r;rrrrr! user_noderr)r)r*replace_all_uses_with` s%  zValue.replace_all_uses_withrcsdurdSj}|dur_dS|jr|}t|tkr-tddfdd}tt|D] \}\}}|||||<q;|_dS)aMerge the shape of this value with another shape to update the existing shape, with the current shape's dimensions taking precedence. Two dimensions are merged as follows: * If both dimensions are equal, the merged dimension is the same. * If one dimension is SymbolicDim and the other is concrete, the merged dimension is the concrete one. * If both dimensions are SymbolicDim, a named symbolic dimension (non-None value) is preferred over an unnamed one (None value). * In all other cases where the dimensions differ, the current shape's dimension is taken (a warning is emitted when both are concrete integers). .. versionadded:: 0.1.14 Args: other: The other shape to merge with. Returns: A new shape that is the result of merging this shape with the other shape. Raises: ValueError: If the shapes have different ranks. ValueError: If there are conflicting concrete dimensions. Nz)Shapes must have the same rank, got self=z, other=c sp||kr|St|tr!t|tr!td|d|ddd t|ts(|St|ts/|S|jdur6|S|S)NzConflicting dimensions z and z when merging shapes r)rrQrrrL)dim1dim2rr;r)r* merge_dims s"   z&Value.merge_shapes..merge_dims)r@rrrrXrrzip)r;r merged_shaperrrrr)rr* merge_shapes s  zValue.merge_shapesr:)rrrr6r4r5r@rrrr6r5rrr7r8r"r9rrird)r"rrgrc)r"r)rrrrQr"r9rr)r"r)rLrr"r9)r"rrx)r"r)rLrr"r9)r"r)rLrr"r9rrr)rrlrrr"r9)rrr"r9)rGrrrrr<rrrrrrrrrrJrrPr4rrr?r@rrdr7rrrrrr)r)r)r*rsn" :          $             7z9Input is deprecated since 0.1.9. Use ir.val(...) instead.r4r5r@rrrr6cCst||||dS)zCreate an input of a Graph or a Function. This is equivalent to calling ``Value(name=name, shape=shape, type=type, doc_string=doc_string)``. r4r@rr6rrr)r)r*Input s rr to_removeAbstractSet[Node] graph_outputsAbstractSet[Value]csX|jD]&}||vrtd|dfdd|D}|r)td|d|dqdS) a Check if a node is safe to remove. 1. It checks to make sure there are no users of the node that are not to be removed before removing it. 2. It checks the node does not contribute to any graph outputs. This check is typically O(1) assuming the number of uses of the node is small Args: node: The node to check. to_remove: A set of nodes that are to be removed. This set is used to check if the node is still being used by other nodes that are not to be removed. graph_outputs: A set of values that are outputs of the graph. Raises: ValueError: If the node does not belong to this graph or if there are users of the node. ValueError: If the node is still being used by other nodes not to be removed. zNode 'zG' is still an output of the graph and cannot be removed when safe=True.csg|] \}}|vr|qSr)r))r userr?rr)r*r z._check_node_safe_to_remove..zOutput value 'zm' is still being used by other nodes that are not to be removed. All of its users that is not being removed: zD. Please make sure these nodes are no longer using the output value.N)rrrJ)rrrr!uses_not_to_remover)rr*_check_node_safe_to_remove s  rc@seZdZdZdZdddddddiddZedjddZedjddZedkddZ dld!d"Z edmd#d$Z e j dnd%d$Z edod'd(Z ejdpd,d-Zejdqd0d-Zd1d-Zdrd2d3Zdsd5d6Zdsd7d8Zd9d:Zdtd.)r4r GraphInputsr GraphOutputsrGraphInitializersrr1rrr2rDoublyLinkedSetrr NameAuthority:_set_input_and_initializer_value_names_into_name_authorityextend) r;r rrQrr6rr4r7r)r)r*r<3 s    zGraph.__init__r"MutableSequence[Value]cCrIr:r>rAr)r)r*r T rz Graph.inputscCrIr:rZrAr)r)r*rX rz Graph.outputs#_graph_containers.GraphInitializerscCrI)aThe initializers of the graph as a ``dict[str, Value]``. The keys are the names of the initializers. The values are the :class:`Value` objects. This property additionally supports the ``add`` method, which takes a :class:`Value` and adds it to the initializers if it is not already present. .. note:: When setting an initializer with ``graph.initializers[key] = value``, if the value does not have a name, it will be assigned ``key`` as its name. )rrAr)r)r*r\ szGraph.initializersrLrr9cCsp|js td||j|jvr#|j|j|ur#td|jd||jdur0td|d|j|dS)avRegister an initializer to the graph. This is a convenience method to register an initializer to the graph with checks. Args: value: The :class:`Value` to register as an initializer of the graph. It must have its ``.const_value`` set. Raises: ValueError: If a value of the same name that is not this value is already registered. ValueError: If the value does not have a name. ValueError: If the initializer is produced by a node. ValueError: If the value does not have its ``.const_value`` set. Initializer must have a name: z Initializer 'zi' is already registered, but it is not the same object: existing={self._initializers[value.name]!r}, new=NzValue 'z5' must have its const_value set to be an initializer.)r4rrraddrNr)r)r*register_initializerl s    zGraph.register_initializercCrIr:rPrAr)r)r*r6 rzGraph.doc_stringcCrMr:rPrNr)r)r*r6 rOdict[str, int]cCrIr:)rrAr)r)r*r rzGraph.opset_importsrrQrcCrr:r)rr)r)r*r rzGraph.__getitem__rrHcCrr:r)rr)r)r*r rcCrr:rrr)r)r*r rcCrr:rXrrAr)r)r*r rz Graph.__len__Iterator[Node]cCrr:rrrAr)r)r*r rzGraph.__iter__cCrr:reversedrrAr)r)r* __reversed__ rzGraph.__reversed__cCs8|jD]}|j|q|jD]}|j|qdSr:)r rregister_or_name_valuerrrNr)r)r*r s z@Graph._set_input_and_initializer_value_names_into_name_authorityrcCsR|jdur|j|urtd|d|j||jD]}|j|q||_|S)zcSet the graph reference for the node and assign names to it and its outputs if they don't have one.N The node 'zG' belongs to another graph. Please remove it first with Graph.remove().)rrrregister_or_name_noderr)r;rrLr)r)r*(_set_node_graph_to_self_and_assign_names s   z.Graph._set_node_graph_to_self_and_assign_names index_or_name int | strcCs>t|tr ||S|D] }|j|kr|Sq td|d)aGet a node by index or name. This is an O(n) operation. Getting nodes on the ends of the graph (0 or -1) is O(1). .. note:: If you need repeated random access, consider turning it into a list with ``list(graph)`` . Or a dictionary for repeated access by name: ``{node.name for node in graph}`` . When a name is provided and if there are multiple nodes with the same name, the first node with the name is returned. Args: index_or_name: The index or name of the node. Returns: The node if found. Raises: IndexError: If the index is out of range. ValueError: If the node with the given name is not found. zNode with name 'z ' not found.)rrQr4r)r;rrr)r)r*r s  z Graph.nodecCt|S)a8Get the number of nodes in the graph in O(1) time. Note that this method returns the number of nodes this graph directly contains. It does not count nodes in subgraphs. This is an alias for ``len(graph)``. Use this if you prefer a more descriptive name for readability. rprAr)r)r* num_nodes s zGraph.num_nodescC tj|SaJGet all nodes in the graph and its subgraphs in O(#nodes + #attributes) time. This is an alias for ``onnx_ir.traversal.RecursiveGraphIterator(graph)``. Consider using :class:`onnx_ir.traversal.RecursiveGraphIterator` for more advanced traversals on nodes. .. versionadded:: 0.1.2 r8 traversalRecursiveGraphIteratorrAr)r)r* all_nodes  zGraph.all_nodesIterator[Graph]c#>idfdd }tjj|dD]}qEdHdS)ziGet all subgraphs in the graph in O(#nodes + #attributes) time. .. versionadded:: 0.1.2 r"r9cB|urdSt|tstdt|d|vrd|<dSdSNzExpected a Graph, got z. The model may be invalidrrrrr seen_graphsr;r)r*enter_subgraph   z'Graph.subgraphs..enter_subgraph enter_graphNrr8rrkeysr;rr?r)rr* subgraphs s  zGraph.subgraphsFallow_outer_scope_valuesrlcCs*ddlm}|jiiid|d}||S)auCreate a deep copy of this graph in O(#nodes + #values) time. All nodes, values, and subgraphs are cloned. The cloned graph will have the same structure as this graph, but all nodes and values will be different objects. Tensors in initializers and constant values will be shared. .. versionadded:: 0.1.14 .. versionadded:: 0.1.15 Added ``allow_outer_scope_values`` argument. Args: allow_outer_scope_values: When True, values that are from outer scopes (not defined in this graph) will not be cloned. Instead, the cloned graph will reference the same outer scope values. This is useful when cloning subgraphs that reference values from the outer graph. When False (default), values from outer scopes will cause an error if they are referenced in the cloned graph. Returns: A deep copy of this graph. Raises: ValueError: If ``allow_outer_scope_values`` is False and the graph references values from outer scopes. r_clonerF)attr_map value_mapr7resolve_ref_attrsrr8rCloner clone_graph)r;rrclonerr)r)r*clone s  z Graph.clonecCs|||j|dS)aAppend a node to the graph in O(1) time. Unique names will be assigned to the node and its values if any name is ``None``. Args: node: The node to append. Raises: ValueError: If the node belongs to another graph. N)rrrr;rr)r)r*r2 s z Graph.appendcs"fdd|D}j|dS)a5Extend the graph with the given nodes in O(#new_nodes) time. Unique names will be assigned to the node and its values if any name is ``None``. Args: nodes: The nodes to extend the graph with. Raises: ValueError: If any node belongs to another graph. cg|]}|qSr)rr rrAr)r*rK z Graph.extend..N)rrrUr)rAr*r@ s z Graph.extendsaferRcCst|ts |h}nt|}t|j}|D]}|j|ur#td|d|r+t|||q|D]}|rBtt|j D]}| |dq9d|_|j |q.dS)aRemove nodes from the graph in O(#num of nodes to remove) time. If any errors are raise, to ensure the graph is not left in an inconsistent state, the graph is not modified. Args: nodes: The node to remove. safe: If True, performs the following actions before removal: 1. It checks to make sure there are no users of the node that are not to be removed before removing it. 2. It checks the node does not contribute to any graph outputs. 3. It removes references to all inputs so it is no longer a user of other nodes. Raises: ValueError: If any node to remove does not belong to this graph. ValueError: (When ``safe=True``) If the node does not belong to this graph or if there are users of the node. ValueError: (When ``safe=True``) If the node is still being used by other nodes not to be removed. rz ' does not belong to this graph.N) rr frozensetrrrrr rXr rErremove)r;rQr* nodes_setrrrr)r)r*r,N s"    z Graph.remove new_nodesIterable[Node] | Nodec4t|tr|f}fdd|D}j||dS)aZInsert new nodes after the given node in O(#new_nodes) time. Unique names will be assigned to the node and its values if any name is ``None``. Args: node: The node to insert after. new_nodes: The new nodes to insert. Raises: ValueError: If any node belongs to another graph. cr&r)r'r(rAr)r*r r)z&Graph.insert_after..N)rrrrXr;rr.r)rAr*rXv  zGraph.insert_aftercr0)a\Insert new nodes before the given node in O(#new_nodes) time. Unique names will be assigned to the node and its values if any name is ``None``. Args: node: The node to insert before. new_nodes: The new nodes to insert. Raises: ValueError: If any node belongs to another graph. cr&r)r'r(rAr)r*r r)z'Graph.insert_before..N)rrrrTr1r)rAr*rT r2zGraph.insert_beforecsttj|}dddd|DD}t|ddd|Dddt|Ddfdd }|D]N}|jD]}|dur@q9|}|||q9|j D]2}t |t sWqO|j tjjkrj|jD]}|||qaqO|j tjjkr|jD] }|D]}|||qxqtqOq4fdd|D} t| d} | rt| \} } | jdusJ|| j| | d7} | D]}|d8<|dkrt| ||fq| s| t|krtd|D] \} }| t|qdS)awPerform a topological sort of this graph and all subgraphs in O(#nodes + #values) time. This sort is stable. It preserves the original order as much as possible. Reference: https://github.com/madelson/MedallionTopologicalSort#stable-sort Raises: ValueError: If the graph contains a cycle, making topological sorting impossible. cSi|]}|gqSr)r))r rr)r)r*r szGraph.sort..cSsh|] }|jdur|jqSr:rr(r)r)r* rzGraph.sort..rcSr3r)r)r(r)r)r*r scSsi|]\}}|| qSr)r))r rrr)r)r*r r\childr predecessorrr"r9cs.|durdS|||d7<dS)zHAdd a predecessor of a node, and increment the depth of the predecessor.Nr)r)r5r6) node_depthnode_predecessorsr)r*add_predecessor sz#Graph.sort..add_predecessorNcs$g|]}|dkr||fqS)rr)r()neg_node_indexr7r)r*r szGraph.sort..rz9Graph contains a cycle, topological sort is not possible.)r5rr6rr"r9)rr8rrdictfromkeysrr rr rrAttrrr AttributeTypeGRAPHrLGRAPHSheapqheapifyheappoprrheappushrXrr-rr)r;rQsorted_nodes_by_graphr9rrpredecessor_nodeattrattribute_graphpriority_queuenum_of_sorted_nodesr? current_noder sorted_nodesr))r:r7r8r*sort sf                z Graph.sortr^cCr_r`rbrAr)r)r*rd rez Graph.metarZcCr[)zThe metadata properties of the graph. The metadata properties are used to store additional information about the graph. Unlike ``meta``, this property is serialized to the ONNX proto. Nr\rAr)r)r*r7 r]zGraph.metadata_propsr=cCrr: _graph_strrAr)r)r*r riz Graph.__str__cCrr: _graph_reprrAr)r)r*r rizGraph.__repr__r rYrrYrQrrrYr6r5rrr4r5r7r8r"r)r"r)rLrr"r9rrr"rrrQr"rrrr"rHrr"r)rrr"r)rrr"rr"r r)rrlr"rrrr"r9rQrr"r9r*rlrQrRr"r9rrr.r/r"r9rrrr)%rGrrrrr<rr rrrr6rrrrrrrrrrrrrrr$rrr,rXrTrMrdr7rrr)r)r)r*r sb !                (   (  e   rrGraph | GraphViewc Csdddd|jD}dddd|jD}ddd|jD}|r3dt|dd }d |jp>d tt |d t|d dt|d dt|dd }t |}t t|}g}t |D]5\}} | jrq| jndt | } d| d| } t| d|d} | } | |d|d| qgddd|jD} dtd|dtd| dd}|d|S)z,Return a string representation of the graph.rw, csror:rr)r)r)r*r  r z_graph_str..csror:rr)r)r)r*r  r csror:rr)r)r)r*r  r  initializers=(   ),zgraph( name=anonymous_graph:, inputs=(  ), outputs=( ), ):anonymous_node:# rrDrE | r%csror:rr)r)r)r*r 6 r {  return  })rr rrrtextwrapindentr4r=r(rXrr r)rr/r1initializers_text signature node_count number_width node_linesrr node_name node_textindented_node_textreturnsbodyr)r)r*rO sD    rOc Csdddd|jD}dddd|jD}ddd|jD}|r3dt|dd }|jjd |j pBd t t |d t|d dt|d dt|ddt |d S)z#Return an repr string of the graph.rwr^csror:rr)r)r)r*r C r z_graph_repr..csror:rr)r)r)r*r D r csror:rr)r)r)r*r E r r_r`raz ( name=rbrcrdrerfz len()=rg) rr rrrrnrorFrGr4r=r(rX)rr/r1rpr)r)r*rQA s$   rQc@seZdZdZdZddddddd4ddZejd5ddZejd6ddZddZd7dd Z d8d"d#Z d8d$d%Z e d9d'd(Z e d:d*d+Zd;d-d.Zd;d/d0Zd.) rrrrrrr6r~rr2) r;rrrrrrr6rr7r)r)r*r< s  zModel.__init__-dict[_protocols.OperatorIdentifier, Function]cCrIr:)r~rAr)r)r*rrzModel.functionsrcCrr:)rrrAr)r)r*rrwzModel.opset_importsr^cCr_r`rbrAr)r)r*rdrez Model.metarZcCr[)zThe metadata properties of the model. The metadata properties are used to store additional information about the model. Unlike ``meta``, this property is serialized to the ONNX proto. Nr\rAr)r)r*r7%r]zModel.metadata_propsr=c Csrd|jd|jd|jd|jd|jd|jd }t|j}dd d |j D}|d |d|S) Nz< ir_version=, opset_imports=, producer_name=, producer_version= , domain=, model_version=z, >z csror:rrr)r)r*r <r z Model.__str__..rw) rrrrrrr=rrrr)r;rq graph_textfunctions_textr)r)r*r0s  z Model.__str__cCsVd|jd|jd|jd|jd|jd|jd|jdtt |j d  d S) NzModel( ir_version=rrrrrz, functions=z , graph=r`rg) rrrrrrrrnrorrr rAr)r)r*r?s" zModel.__repr__Iterable[Graph]ccs|jV|jEdHdS)zGet all graphs and subgraphs in the model. This is a convenience method to traverse the model. Consider using :class:`onnx_ir.traversal.RecursiveGraphIterator` for more advanced traversals on nodes. N)rrrAr)r)r*graphsLs z Model.graphsc CsN|j}dd|jD}t||j|j|j|j|j |j |t |j d }|S)aCreate a deep copy of this model. All graphs, nodes, values, and subgraphs are cloned. The cloned model will have the same structure as this model, but all graphs, nodes, and values will be different objects. Tensors in initializers and constant values will be shared. .. versionadded:: 0.1.14 Returns: A deep copy of this model. cSsg|]}|qSr))r$rr)r)r*rkrzModel.clone..)rrrrrr6rr7) rr$rrr}rrrrrr6r;r7)r; new_graph new_functions new_modelr)r)r*r$\s  z Model.clone)rrrrQrr5rr5rr5rr6r6r5rrr7r8r"r9)r"rrTrrr)r"r)r"r})rGrrrr<rrrrdr7rrrr$r)r)r)r*r} s.       r}c@seZdZdZdZ dedfddZdgddZedhddZej diddZedhddZ e j diddZ edhddZ e j diddZ edjddZ edjd d!Z edkd#d$Zedld%d&Zej dmd*d+Zej dnd.d+Zd/d+Zdod0d1Zdpd3d4Zdpd5d6Zedqd8d9Zej drd:d9Zedsd.enter_subgraphrNrrrr)rr*rs  zFunction.subgraphscsZddlm}|jiiidd|j}fdd|jD}t|j|j |j ||dS)aCreate a deep copy of this function in O(#nodes + #values) time. All nodes, values, and subgraphs are cloned. The cloned function will have the same structure as this function, but all nodes and values will be different objects. Tensors in initializers and constant values will be shared. .. versionadded:: 0.1.14 Returns: A deep copy of this function. rrFr{csg|] }|j|qSr)) clone_attrr4r rGr#r)r*rLsz"Function.clone..)rr4rrr ) r8rr!r"rrrrrr3r)r;rrnew_attributesr)rr*r$5s$   zFunction.clonercC|j|dS)z+Append a node to the function in O(1) time.N)rrr%r)r)r*rXrzFunction.appendrQrcCr)z?Extend the function with the given nodes in O(#new_nodes) time.N)rrrUr)r)r*r\rzFunction.extendFr*rlrRcCs|jj||ddS)aRemove nodes from the graph in O(#num of nodes) time. If any errors are raise, to ensure the graph is not left in an inconsistent state, the graph is not modified. Args: nodes: The node to remove. safe: If True, performs the following actions before removal: 1. It checks to make sure there are no users of the node that are not to be removed before removing it. 2. It checks the node does not contribute to any graph outputs. 3. It removes references to all inputs so it is no longer a user of other nodes. Raises: ValueError: If any node to remove does not belong to this graph. ValueError: (When ``safe=True``) If the node does not belong to this graph or if there are users of the node. ValueError: (When ``safe=True``) If the node is still being used by other nodes not to be removed. )r*N)rr,)r;rQr*r)r)r*r,`szFunction.remover.r/cC|j||dS)z.csror:rr)r)r)r*r r css8|]}|jd|jd|j|jduVqdS)z: z = N)r4rrLrr)r)r*r s & z attributes={ r`rmz< opset_imports=z, > def z( inputs=( rdrfz outputs=( z ), )rhrirwrrDrErjr%csror:rr)r)r)r*r r rkrl)rr4rrr rr rrnrorrXr=rr(r r)r; full_namer/r1r0rqrrrsrtrrrurvrwrxryr)r)r*rsN(     zFunction.__str__cCs>|jjd|jd|jd|jd|jd|jd|jdS)Nrr%r3r4z ), outputs=r)rFrGrr4rr r rrAr)r)r*rs>zFunction.__repr__N)rn) rr=r4r=rr=rrr r r"r9rjrrfrSrhr|rUrVrrWrrrTrrrX)r"rrYrZrr[r\r)$rGrrrrr<rrr4rrrr rr rrrrrrr6rrdr7rrr$rrr,rXrTrMrrr)r)r)r*r{sn                        #      ,rc@s eZdZdZdZ dFdddGddZedHddZejdIddZedJddZ edKddZ edLddZ edMddZ dNdd Z dOd#d$ZdHd%d&ZdHd'd(ZdPd*d+ZdQd-d.ZdHd/d0ZdRd2d3ZdSd5d6ZdTd8d9ZdUd;d<ZdVd>d?ZdWdAdBZdXdDdEZdS)Yr=z-Base class for ONNX attributes or references.)rr3_ref_attr_namerrr6Nr6r4r=r_enums.AttributeTyperLr ref_attr_namer5r6r"r9cCs|durnJ|tjjkrt|}n?|tjjkrt|}n4|tjjkr+tdd|D}n$|tjjkr;tdd|D}n|tjj tjj tjj tjj hvrOt|}||_ ||_||_||_||_d|_dS)Ncsror:)rQr r,r)r)r*r r z Attr.__init__..csror:)floatrr)r)r*r r )rr>INTrQFLOATrINTSrFLOATSSTRINGSTENSORSr@ TYPE_PROTOSr3rrrr6r)r;r4rrLrr6r)r)r*r<s.       z Attr.__init__cCrIr:rJrAr)r)r*r4rz Attr.namecCrMr:rJrNr)r)r*r4rOcCrIr:rrAr)r)r*rrz Attr.typecCrIr:rrAr)r)r*rLrz Attr.valuecCrIr:)rrAr)r)r*rrzAttr.ref_attr_namer^cCr_r`rbrAr)r)r*rdrez Attr.metarlcCs |jduS)z1Check if this attribute is a reference attribute.N)rrAr)r)r*is_ref rOz Attr.is_refrrcCsTt|tjsdS|j|jkrdS|j|jkrdS|j|jkr dS|j|jkr(dSdS)NFT)rrAttributeProtocolr4rrLr6rr)r)r*rs     z Attr.__eq__cCsB|r d|jS|jtjjkrtdt|j dSt |j S)N@rwr`) rrrrr>r?rnror=rLrrAr)r)r*rs   z Attr.__str__cCsT|r|jjd|jd|jd|jdS|jjd|jd|jd|jdS)Nrr%z, ref_attr_name=r)rrFrGr4rrrLrAr)r)r*r%s&&z Attr.__repr__rcC,|jtjjkrtd|jd|j|jS)z#Get the attribute value as a float. Attribute 'z%' is not of type FLOAT. Actual type: )rrr>rrr4rLrAr)r)r*as_float+ z Attr.as_floatrQcCr)z"Get the attribute value as an int.rz#' is not of type INT. Actual type: )rrr>rrr4rLrAr)r)r*as_int4rz Attr.as_intcCJ|jtjjkrtd|jd|j|j}t|ts#td|d|S)z$Get the attribute value as a string.rz&' is not of type STRING. Actual type: Value of attribute 'z' is not a string.) rrr>rnrr4rLrr=rNr)r)r* as_string= zAttr.as_stringrcCsL|jtjjkrtd|jd|j|j}t|tj s$td|d|S)z$Get the attribute value as a tensor.rz&' is not of type TENSOR. Actual type: rz' is not a tensor.) rrr>TENSORrr4rLrrrrNr)r)r* as_tensorHs zAttr.as_tensorrcCr)z#Get the attribute value as a graph.rz%' is not of type GRAPH. Actual type: rz' is not a graph.) rrr>r?rr4rLrrrNr)r)r*as_graphSrz Attr.as_graphtuple[float, ...]cCr)z0Get the attribute value as a sequence of floats.rz&' is not of type FLOATS. Actual type: )rrr>rrr4rLrAr)r)r* as_floats^rzAttr.as_floatsrcCr)z.Get the attribute value as a sequence of ints.rz$' is not of type INTS. Actual type: )rrr>rrr4rLrAr)r)r*as_intsgrz Attr.as_intstuple[str, ...]cCsV|jtjjkrtd|jd|jtjr(tdd|j Ds(td|d|j S)z1Get the attribute value as a sequence of strings.rz'' is not of type STRINGS. Actual type: csrr:)rr=r)r)r)r*r wrz"Attr.as_strings..rz' is not a Sequence of strings.) rrr>rrr4r8r9rrLrAr)r)r* as_stringspszAttr.as_strings%tuple[_protocols.TensorProtocol, ...]cCZ|jtjjkrtd|jd|jtjr(tdd|j Ds(td|dt |j S)z1Get the attribute value as a sequence of tensors.rz'' is not of type TENSORS. Actual type: css|] }t|tjVqdSr:)rrrr)r)r)r*r rz"Attr.as_tensors..rz' is not a Sequence of tensors.) rrr>rrr4r8r9rrLrrAr)r)r* as_tensors| zAttr.as_tensorstuple[Graph, ...]cCr)z0Get the attribute value as a sequence of graphs.rz&' is not of type GRAPHS. Actual type: csrr:)rrr)r)r)r*r rz!Attr.as_graphs..rz' is not a Sequence of graphs.) rrr>r@rr4r8r9rrLrrAr)r)r* as_graphsrzAttr.as_graphsr:) r4r=rrrLr rr5r6r5r"r9rrf)r"r)r"r rrrdr)r"rrrr|)r"rr)r"r)r"r)r"r)rGrrrrr<rr4rrrLrrdrrrrrrrrrrrrrrr)r)r)r*r=sB)            r=rrcCst||d||dS)aCreate a reference attribute. Args: name: The name of the attribute. type: The type of the attribute. ref_attr_name: The name of the referenced attribute. doc_string: Documentation string. Returns: A reference attribute. N)rr6)r=)r4rrr6r)r)r*RefAttrsrfloat | np.floatingcCt|tjj||dS)zCreate a float attribute.r)r=rr>rr4rLr6r)r)r* AttrFloat32 rint | np.integercCr)zCreate an int attribute.r)r=rr>rrr)r)r* AttrInt64rrcCr)zCreate a str attribute.r)r=rr>rnrr)r)r* AttrStringrrrcCr)zCreate a tensor attribute.r)r=rr>rrr)r)r* AttrTensor rcCr)zCreate a graph attribute.r)r=rr>r?rr)r)r* AttrGraphrrSequence[float]cCr)z"Create a float sequence attribute.r)r=rr>rrr)r)r* AttrFloat32srr Sequence[int]cCr)z!Create an int sequence attribute.r)r=rr>rrr)r)r* AttrInt64srr Sequence[str]cCr)z#Create a string sequence attribute.r)r=rr>rrr)r)r* AttrStringsrr#Sequence[_protocols.TensorProtocol]cCr)z#Create a tensor sequence attribute.r)r=rr>rrr)r)r* AttrTensorsrrSequence[Graph]cCr)z"Create a graph sequence attribute.r)r=rr>r@rr)r)r* AttrGraphsrr_protocols.SparseTensorProtocolcCr)z!Create a sparse tensor attribute.r)r=rr> SPARSE_TENSORrr)r)r*AttrSparseTensor rr)Sequence[_protocols.SparseTensorProtocol]cCr)z*Create a sparse tensor sequence attribute.r)r=rr>SPARSE_TENSORSrr)r)r*AttrSparseTensors-rrc@r) TypeAndShapez?Type and shape. Useful for constructing a type proto. rrrr@Nrr)r)r)r*r:s  rcCr)zCreate a type attribute.r)r=rr> TYPE_PROTOrr)r)r* AttrTypeProtoErrSequence[TypeAndShape]cCr)z!Create a type sequence attribute.r)r=rr>rrr)r)r*AttrTypeProtosPrr)r!r r"r#)r!r r"r-)rrr?rr"r9)rrr?rr"r)rhr r"rl)rrr"r)rLrr"r)rrr"r)rqr=r"r=)rrr"r=)rr=r"r=)rrr"r)NNNN) r4r5r@rrrr6r5r"r)rrrrrrr"r9)rr]r"r=r:) r4r=rr=rrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLr=r6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r4r=rLrr6r5r"r=)r __future__rabcry dataclassesrAloggingrRrHr:sysrnrcollections.abcrrrrrrr r AbstractSetr r r rrrrrrrTrtyping_extensionsrrr8rrrrrrrr TYPE_CHECKING numpy.typingnptrTypeVarArrayCompatibleDLPackCompatibler byteorderrr+rrrrrrrrrrrrr getLoggerrGloggerr+r/ABCrPrettyPrintabler0rrrrrr+rerzrSymbolicDimProtocolrrr ShapeProtocolrrrrr NodeProtocolr TypeProtocolrkrzr|rrrrrr ValueProtocolrrr GraphProtocolrrOrQrz ModelProtocolr}FunctionProtocolrrReferenceAttributeProtocolr=rrrrrrrrrrrrr dataclassrrrr)r)r)r*s $ ( (        F % @[| /   c$(  ,c $  '  ;i