Yj:dZddlmZddlmZddlZddlmZm Z erddl m Z gdZ Gdd ZddZddZddZddZddZddZddddZdS)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_opcbeZdZdZdddddddddddddddddddd=d"Zed>d$Zed?d&Zed>d'Zed>d(Z ed>d)Z ed>d*Z ed@d+Z ed@d,Z edAd-ZdBd0ZdCdBd2ZdCdBd3ZdCdDd5ZdCdEd7ZdFd8ZdGd:ZdHd<ZdS)IraA 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_dimsr list[torch.Tensor | None] | Nonerlist[torch.Tensor] | Nonerrboolrrrrrrrrrrr torch.dtype | Noner!torch.device | Noner"Sequence[int] | Noner# Sequence[int]returnNonect}|t|ng|_|t|ng|_|t|ng|_||_||_||_||_||_ | |_ | |_ | |_ | |_ | |_||_|||_|||_|(t||_t||_||_dSN)_CTensorIteratorSpeclistrrrrrrrrrrrrrrr r!r"r#build_impl)selfrrrrrrrrrrrrrrr r!r"r#specs DC:\Projects\DSCons\.venv\Lib\site-packages\torch\_tensor_iterator.py__init__zTensorIterator.__init__ws,$%%(/(;tG}}} &,&8d6lllb 2>2JD...PR$8!%:".L+/N,,H).L+(@%,!2!2(  # ,D   $!.D   # $\ 2 2D #K00D '+zz|| intc|jjSr.)r2ndimr3s r5r:zTensorIterator.ndims zr7 memoryviewc|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.)r2shaper;s r5r>zTensorIterator.shapeszr7c|jjSr.)r2numelr;s r5r@zTensorIterator.numels zr7c|jjSr.)r2ntensorsr;s r5rBzTensorIterator.ntensors z""r7c|jjSr.)r2ninputsr;s r5rEzTensorIterator.ninputss z!!r7c|jjSr.)r2noutputsr;s r5rGzTensorIterator.noutputsrCr7c|jjSr.)r2 is_contiguousr;s r5rIzTensorIterator.is_contiguous z''r7c|jjSr.)r2 is_trivial_1dr;s r5rLzTensorIterator.is_trivial_1drJr7c|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.)r2 common_dtyper;s r5rNzTensorIterator.common_dtypesz&&r7index torch.Tensorc6|j|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.)r2tensorr3rOs r5rRzTensorIterator.tensorsz  '''r7rc6|j|S)zbReturn the iterator's current input. See :meth:`tensor` for the promoted-temporary caveat.)r2inputrSs r5rUzTensorIterator.inputsz&&&r7c6|j|S)z_Return the iterator's current output. See :meth:`tensor` for the cast-temporary caveat.)r2outputrSs r5rWzTensorIterator.outputsz  '''r7 torch.dtypec6|j|Sr.)r2dtyperSs r5rZzTensorIterator.dtypesz&&&r7 torch.devicec6|j|Sr.)r2devicerSs r5r]zTensorIterator.devicesz  '''r7c6|j|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.)r2stridesrSs r5r_zTensorIterator.stridess z!!%(((r7tuple[int, ...]c6|j|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.)r2element_stridesrSs r5rbzTensorIterator.element_stridess z))%000r7strc*t|jSr.)reprr2r;s r5__repr__zTensorIterator.__repr__sDJr7)&rr$rr%rr%rr&rr&rr&rr&rr&rr&rr&rr&rr&rr&rr&r r'r!r(r"r)r#r*r+r,)r+r8)r+r<)r+r&)r+r')rOr8r+rP)r)rOr8r+rX)rOr8r+r[)rOr8r+r<)rOr8r+r`)r+rc)__name__ __module__ __qualname____doc__r6propertyr:r>r@rBrErGrIrLrNrRrUrWrZr]r_rbrfrr7r5rr:sJ::~59,026%)&*/405-2/4).#"&"'"+/-1-1%')/4/4/4/4/4/4bX   X    X ###X#"""X"###X#(((X((((X('''X'((((''''' ((((( '''''((((())))1111      r7routtorch.Tensor | NonearPbr+c2t|g||gddddS)z0Equivalent of ``at::TensorIterator::binary_op``.T)rrrrrrrrlrnros r5r r s3 V'+%)'+    r7c 4t|g||gdddddS)z6Equivalent of ``at::TensorIterator::binary_float_op``.T)rrrrrrrrqrrs r5r r s6 V'+%)'+(,   r7c| tjnd}|duo|jtjk}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 )torchr&rZr)rlrnror cast_to_outputss r5r r 'sY"%5::$LoA#)uz*AO V'+%4!    r7c(t|g|gS)z/Equivalent of ``at::TensorIterator::unary_op``.)rrrqrlrns r5r r =s 3%qc : : ::r7c0t|g|gddddS)z5Equivalent of ``at::TensorIterator::unary_float_op``.T)rrrrrrrqrxs r5r r Bs/ S'+%)'+(,    r7cJ|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. NzAnullary_op requires a defined output tensor; None is not allowed.F)rrr) TypeErrorr)rls r5rrNsB  { O    "   r7)out2r|cH| |j|jcxkr |jks)ntd|jd|jd|j||kr9td|d||j|jks*||krtdt ||g|gdddd St |g|gd ddd 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. NzAreduce_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)r] RuntimeErrordimr>strider)rlrnr|s r5rr_sx( zQX44444444J:JJ.2kJJ?@xJJ  7799 " "0779900#'88::00  9 " "cjjlldkkmm&C&CO $K!& #      S'+    r7)rlrmrnrProrPr+r)rlrmrnrPr+r)rlrPr+r)rlrPrnrPr|rmr+r)rj __future__rtypingrrutorch._Cr_CTensorIteratorrr/collections.abcr__all__rr r r r r rrrr7r5rsi<#"""""  )((((((   H H H H H H H H `        ,;;;;    *!% 22222222r7