^jE9dZddlmZddlmZddlZddlmZm Z erddl m Z gdZ Gdd Z dd Z dd Z dd Zdd ZddZddZdd ddZy)aPython access to ATen's TensorIterator build pipeline. :class:`TensorIterator` builds an iterator from a set of operands and flags that mirror ``at::TensorIteratorConfig``, then exposes the post-build shape / dtype / device / stride information for inspection. This is a build-pipeline-only surface: there is no ``for_each`` here. Use it to debug shape and dtype inference, validate custom-op contracts, or inspect how ATen would lay out a kernel's iteration. Construction is canonical, *not* a faithful replay of arbitrary ``TensorIteratorConfig`` call sequences. Operands are always registered in the order ``outputs -> inputs -> const_inputs`` and setters are applied in one fixed order. Notably: * The C++ builder distinguishes ``add_input(a); add_const_input(b)`` from ``add_const_input(b); add_input(a)`` -- ``input(0)`` refers to different operands. This Python surface cannot express that distinction: every ``inputs[i]`` precedes every ``const_inputs[j]``. * Some C++ setters have order-dependent side effects (e.g. ``promote_inputs_to_common_dtype(true)`` also flips ``check_all_same_dtype`` to ``false``). The Python surface materializes the *final* boolean state of each knob, not the call order, so it can't reproduce a sequence where an intermediate setter observed a since-overwritten value. Every in-tree caller of ``at::TensorIteratorConfig`` fits the canonical- recipe shape; the lossiness is theoretical, not practical. ) annotations) TYPE_CHECKINGN)_TensorIterator_TensorIteratorSpec)Sequence)TensorIterator binary_opbinary_float_op comparison_opunary_opunary_float_op nullary_op reduce_opcteZdZdZddddddddddddddddddd ddZeddZedd Zedd Zedd Z edd Z edd Z eddZ eddZ eddZddZdddZdddZdd dZdd!dZd"dZd#dZd$dZy)%raA built TensorIterator. Read-only view of the build-pipeline result. Constructor kwargs mirror ``at::TensorIteratorConfig``; defaults match the C++ defaults. See module docstring for canonical-recipe caveats. Examples -------- Build a TI for a binary op with type promotion and inspect the result:: >>> import torch >>> from torch._tensor_iterator import TensorIterator >>> a = torch.zeros(3, 4, dtype=torch.float32) >>> b = torch.zeros(3, 4, dtype=torch.float64) >>> it = TensorIterator( ... outputs=[None], ... const_inputs=[a, b], ... promote_inputs_to_common_dtype=True, ... cast_common_dtype_to_outputs=True, ... ) >>> it.common_dtype torch.float64 >>> it.numel 12 >>> it.ndim # contiguous (3, 4) collapses to a single dim 1 Declare a static shape (the iterator skips broadcast/coalesce):: >>> a = torch.zeros(2, 6) >>> out = torch.empty(2, 6) >>> it = TensorIterator( ... outputs=[out], ... const_inputs=[a], ... resize_outputs=False, ... static_shape=(2, 6), ... ) Build a reduction TI (output must be pre-allocated to the reduced shape):: >>> a = torch.zeros(3, 4) >>> out = torch.empty(3, 1) >>> it = TensorIterator( ... outputs=[out], ... const_inputs=[a], ... resize_outputs=False, ... is_reduction=True, ... ) Inspect post-coalesce strides (in bytes; use ``element_strides`` for element units):: >>> a = torch.zeros(3, 4) >>> b = torch.zeros(3, 4) >>> it = TensorIterator(outputs=[None], const_inputs=[a, b]) >>> tuple(it.strides(0)) # output byte strides (4,) >>> it.element_strides(0) # ... in elements (1,) NTF)outputsinputs const_inputscheck_all_same_dtypecheck_all_same_devicepromote_inputs_to_common_dtypepromote_integer_inputs_to_floatcast_common_dtype_to_outputsenforce_safe_casting_to_outputenforce_linear_iterationresize_outputscheck_mem_overlapallow_cpu_scalars is_reduction static_dtype static_device static_shape squash_dimsct}| t|ng|_| t|ng|_| t|ng|_||_||_||_||_||_ | |_ | |_ | |_ | |_ | |_||_|||_|||_| t||_t||_|j)|_yN)_CTensorIteratorSpeclistrrrrrrrrrrrrrrr r!r"r#build_impl)selfrrrrrrrrrrrrrrr r!r"r#specs a/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/_tensor_iterator.py__init__zTensorIterator.__init__ws,$%(/(;tG} &,&8d6lb 2>2JD.PR$8!%:".L+/N,,H).L+(@%,!2!2(  # ,D   $!.D   # $\ 2D #K0D '+zz| c.|jjSr%)r)ndimr*s r,r0zTensorIterator.ndimszzr.c.|jjS)aIterator shape (post coalesce/reorder), as a zero-copy ``memoryview`` of ``int64`` elements. The view holds a reference to this iterator and keeps it alive for as long as the view is reachable; copy via ``tuple(it.shape)`` if you need a snapshot you can outlive the iterator with. Hot-path readers (dispatch conditionals) get index access without an allocation.)r)shaper1s r,r3zTensorIterator.shapeszzr.c.|jjSr%)r)numelr1s r,r5zTensorIterator.numelszzr.c.|jjSr%)r)ntensorsr1s r,r7zTensorIterator.ntensorszz"""r.c.|jjSr%)r)ninputsr1s r,r:zTensorIterator.ninputsszz!!!r.c.|jjSr%)r)noutputsr1s r,r<zTensorIterator.noutputsr8r.c.|jjSr%)r) is_contiguousr1s r,r>zTensorIterator.is_contiguouszz'''r.c.|jjSr%)r) is_trivial_1dr1s r,rAzTensorIterator.is_trivial_1dr?r.c.|jjS)aLThe inferred computation dtype, or ``None`` if no single dtype was inferred. Populated whenever TensorIterator can resolve a common dtype -- under promotion flags, or when every input already shares a dtype. ``None`` does not mean "promotion was not requested"; it means inference produced no answer.)r) common_dtyper1s r,rCzTensorIterator.common_dtypeszz&&&r.c8|jj|S)atReturn the iterator's current operand at ``index``. Note: under ``promote_inputs_to_common_dtype`` / ``cast_common_dtype_to_outputs`` (CPU paths), this may be a promoted/cast kernel temporary rather than the tensor that was registered with the config -- it's the iterator's view of the operand a kernel would actually iterate over.)r)tensorr*indexs r,rEzTensorIterator.tensorszz  ''r.c8|jj|S)zbReturn the iterator's current input. See :meth:`tensor` for the promoted-temporary caveat.)r)inputrFs r,rIzTensorIterator.inputszz&&r.c8|jj|S)z_Return the iterator's current output. See :meth:`tensor` for the cast-temporary caveat.)r)outputrFs r,rKzTensorIterator.outputszz  ''r.c8|jj|Sr%)r)dtyperFs r,rMzTensorIterator.dtypeszz&&r.c8|jj|Sr%)r)devicerFs r,rOzTensorIterator.deviceszz  ''r.c8|jj|S)aKPer-operand strides in bytes (post reorder/coalesce), as a zero-copy ``memoryview`` of ``int64`` elements. The view holds a reference to this iterator and keeps it alive for as long as the view is reachable; copy via ``tuple(it.strides(i))`` if you need a snapshot you can outlive the iterator with.)r)stridesrFs r,rQzTensorIterator.stridess zz!!%((r.c8|jj|S)zPer-operand strides in elements (byte stride / element size). Allocates a fresh tuple on every call. Don't use on a hot path: cache the result, or read :meth:`strides` once and divide by :meth:`element_size` of the operand inline.)r)element_stridesrFs r,rSzTensorIterator.element_stridess zz))%00r.c,t|jSr%)reprr)r1s r,__repr__zTensorIterator.__repr__sDJJr.)&rz list[torch.Tensor | None] | Nonerlist[torch.Tensor] | NonerrWrboolrrXrrXrrXrrXrrXrrXrrXrrXrrXrrXr torch.dtype | Noner!ztorch.device | Noner"zSequence[int] | Noner#z Sequence[int]returnNone)rZint)rZ memoryview)rZrX)rZrY)rGr\rZ torch.Tensor)r)rGr\rZz torch.dtype)rGr\rZz torch.device)rGr\rZr])rGr\rZztuple[int, ...])rZstr)__name__ __module__ __qualname____doc__r-propertyr0r3r5r7r:r<r>rArCrErIrKrMrOrQrSrVrr.r,rr:s:~59,026%)&*/405-2/4).#"&"'"+/-1-1%')/42/4* /4 0 /4 # /4 $/4)-/4*./4'+/4)-/4#'/4/4 /4 /4 !/4")#/4$+%/4&+'/4(#)/4* +/4b    ##""##((((''(' ( '()1 r.rc*t|g||gddddS)z0Equivalent of ``at::TensorIterator::binary_op``.T)rrrrrrroutabs r,r r s) V'+%)'+  r.c ,t|g||gdddddS)z6Equivalent of ``at::TensorIterator::binary_float_op``.T)rrrrrrrrfrgs r,r r s, V'+%)'+(, r.c|tjnd}|duxr|jtjk7}t|g||gdd||S)aHEquivalent of ``at::TensorIterator::comparison_op``. When ``out`` is ``None``, the output dtype is forced to bool. When ``out`` is a defined non-bool tensor, the common dtype is cast back to its dtype via ``cast_common_dtype_to_outputs``. The bool-output case skips that cast as a performance optimization. NT)rrrrrr )torchrXrMr)rhrirjr cast_to_outputss r,r r 'sS"%5::$LoA#))uzz*AO V'+%4!  r.c t|g|gS)z/Equivalent of ``at::TensorIterator::unary_op``.)rrrfrhris r,r r =s 3%qc ::r.c(t|g|gddddS)z5Equivalent of ``at::TensorIterator::unary_float_op``.T)rrrrrrrfrps r,r r Bs% S'+%)'+(,  r.c:| tdt|gddS)zEquivalent of ``at::TensorIterator::nullary_op``. Unlike the binary/unary factories, ``out`` must be a defined tensor; the C++ named constructor takes a non-undefined output. zAnullary_op requires a defined output tensor; None is not allowed.F)rrr) TypeErrorr)rhs r,rrNs3  { O   " r.)out2c6||j|jcxk(r|jk(s4ntd|jd|jd|j|j|jk7r-td|jd|j|j|jk7s!|j |j k7r tdt ||g|gdddd St |g|gdddd S) aEquivalent of ``at::TensorIterator::reduce_op``. Pass ``out2`` for the two-output reduction overload (e.g. ``min`` returning values + indices). The output tensor(s) must be pre-allocated and shaped correctly: this factory does not allocate or resize. With ``out2``, both outputs must live on ``a``'s device and share its sizes/strides -- the C++ named constructor asserts this and the same checks are mirrored here. zAreduce_op: out, out2, and the input must share a device, got out=z, out2=z, a=z4reduce_op: out and out2 must have the same dim, got z and z=reduce_op: out and out2 must have identical sizes and stridesFT)rrrrrr)rrrrrr)rO RuntimeErrordimr3strider)rhrirts r,rr_s( zzQXX44::,gdkk]$qxxjJ  779 "F779+U488:,0  99 "cjjldkkm&CO $K!& #    S'+  r.)rhtorch.Tensor | Nonerir^rjr^rZr)rhryrir^rZr)rhr^rZr)rhr^rir^rtryrZr)rc __future__rtypingrrmtorch._Cr_CTensorIteratorrr&collections.abcr__all__rr r r r r rrrr.r,rs<#  ( H H `   !- 2>     !- 2>   !-2>,; *!% 2 22  2  2r.