
    Wj6                       d dl mZ d dlZd dlZd dlZd dlmZmZmZm	Z	 erd dl
mZmZ d dlZd dlmZmZmZ ddlmZmZmZ ddlmZ dd	lmZ dd
lmZ dZdZd ad}dZd~dZ dddZ!	 dddZ" G d d           Z#	 ddd"Z$	 ddd$Z% G d% d&e&          Z' G d' d(e&          Z(dd)l)m*Z* dd.Z+ G d/ d0          Z,e,ej-        fZ. G d1 de,          Z/ G d2 d3e,          Z-ddd8Z0ddd;Z1dd<Z2 G d= d>          Z3ddCZ4ddEZ5ddJZ6d dKl7m8Z8 d dLl9m:Z:  e:e,ej-        e,j;                   e,`<ddPZ=ddQZ> e>dR            e>dS            e>dT            e>dU            e>dV            e>dW            e>dX            e>dY            e>dZ            e>d[            e>d\            e>d]            e>d^d_`            e>dad_`            e>dbdc            e>dddc            e>dedc            e>dfdc            e>dgdc            e>dhdc            e>didc            e>djdc            e>dkdlm            e>dndlm            e>dodc            e>dpddlq            e>drddls            e>dtddls            e>duddls            e>dvddls            e>dwddls            e>dxddls            e>dyddls            e>dzdddl{            e>d|ddls            e8ej?        j@        jA        ddls          ZAdS )    )annotationsN)AnyOptionalTYPE_CHECKINGUnion)CallableSequence)tree_flattentree_maptree_unflatten   )_match_levelsDimEntryndim_of_levels)EnableAllLayers)_PyInstDecoder)
TensorInfoTopcodeOptional[str]returnboolc                J    t          | o|                     d                    S )z4Check if opcode is relevant for variable assignment.STORE_)r   
startswith)r   s    [/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/functorch/dim/__init__.py_relevant_opr      s#    66,,X66777    tensortorch.Tensorc                    | S )z8Handle tensor conversion for torch function integration. )r   s    r   handle_from_tensorr"   !   s    Mr   namestrsizeOptional[int]Dimc                *    t          | ||nd          S )zCreate a new Dim object.N)r'   )r#   r%   s     r   _create_dimr*   &   s    tT-TT2666r   nsizesOptional[list[Optional[int]]]Union[Dim, tuple[Dim, ...]]c                  	
 d}d
t                    }| | }t          j                    }|t          d          |j        }	 |t          d          |j        }|j        }t          ||          	t          j	        dk    r,	
                                dk    r	                                 	                                 t          	
                                          rd
n@	
                                d	k    r(	                                
	                                 |dk    r
dk    rt          d
          
}
|k    rd
d	
fd}5t                    |k    r"t          d| dt                               |dk    r |d          ~S g }t!          |          D ] }|                     ||                     !t%          |          ~S # ~w xY w)a  
    Create and return one or more Dim objects.

    Uses bytecode inspection to determine variable names when possible.

    Args:
        n (int, optional): The number of dimensions to create. Can be omitted if sizes is specified.
        sizes (List[Optional[int]], optional): A list the same size as the number of dimensions to be
          created, specifying each dimensions size, or None to leave the size unset.

    Returns:
        Union[Dim, Tuple[Dim, ...]]: Single Dim if n=1, tuple of Dims otherwise.

    Examples:
        >>> batch, channel, width, height = dims(4)
        >>> batch, channel, width, height = dims(sizes=[None, 3, 224, 224])
        >>> single_dim = dims(1)
    r)   r   NUnable to get current frameUnable to get caller frame      PRECALLr   UNPACK_SEQUENCEzTdims() must be assigned to a sequence of variable names or have argument n specifiediintr   r'   c                    d }| k     r                                 }|sd|  }dn                                 |          nd }t          ||          S Ndr   )r#   nextr*   )r7   r#   r%   decoderfound_ndimsr,   s      r   	genobjectzdims.<locals>.genobjectn   sg    D;||~~ 1ww$0588dDtT***r   	expected  sizes but found )r7   r8   r   r'   )leninspectcurrentframeRuntimeErrorf_backf_codef_lastir   sysversion_infor   r<   r   opargSyntaxError
ValueErrorrangeappendtuple)r+   r,   specified_ndimsframecodelastir?   resultr7   r=   r>   s    `       @@r   dimsrV   +   s;   * OK e**}  ""E}8999LE==;<<<| u--w&&~~9,, 	 (()) 	KK^^!222!--//KLLNNNb  a!j   *O/))K	+ 	+ 	+ 	+ 	+ 	+ 	+ 	+  U!>!>WWW3u::WWXXXa9Q<< E '' 	( 	(AMM))A,,''''V}} EE				s   	EG$ "A G$ $G'c                      e Zd ZU dZded<   ded<   ded<   	 	 d/d0dZd1dZd2dZd3dZd4dZ	d4dZ
d5dZed6d            Zd4dZd7d!Zd8d#Zd8d$Ze	 	 d9d:d.            ZdS );DimLista(  
    A list of first-class dimensions that can be bound to tensor dimensions.

    A DimList can be in one of two states:
    1. Unbound: Created with just a name, no specific dimensions yet
    2. Bound: Either created with specific dimensions/sizes, or bound later via bind() or bind_len()
    r   _namez	list[Dim]_dimsr   _boundNlen_or_dimsOptional[Union[int, Sequence]]r#   c                   || _         g | _        d| _        t          |t                    r|                     |           dS |g }t          |          D ]w\  }}t          |t                    r;| j         r| j          | nd| }|                    t          ||                     U|                    t          |                     x| 	                    |           dS dS )z
        Initialize a new DimList object.

        Args:
            len_or_dims: Optional length (int) or sequence of dimensions/sizes
            name: Optional name for the dimension list
        FNdim)
rY   rZ   r[   
isinstancer8   bind_len	enumeraterO   r'   	_set_dims)selfr\   r#   rV   r7   itemdim_names          r   __init__zDimList.__init__   s     

k3'' 
	!MM+&&&&&$D$[11 + +4dC(( +59ZN$*1a111Y1YYHKKHd 3 34444KKD		****NN4      %$r   rV   listr   Nonec                "    d| _         || _        dS )z%Set the dimensions and mark as bound.TN)r[   rZ   )rd   rV   s     r   rc   zDimList._set_dims   s    


r   r%   r8   c                R   | j         rAt          | j                  |k    r't          dt          | j                   d|           dS d| _         g | _        t	          |          D ]@}| j        r| j         | nd| }| j                            t          |                     AdS )z
        Bind this DimList to a specific length.

        Args:
            size: Number of dimensions to bind to

        Raises:
            DimensionBindError: If already bound to a different size
        zDimlist has size z but it is being bound to size Tr_   N)r[   rB   rZ   DimensionBindErrorrN   rY   rO   r'   )rd   r%   r7   rf   s       r   ra   zDimList.bind_len   s     ; 
	14:$&&(^DJ^^X\^^   '&
 DKDJ4[[ 1 115Jdj-!---q
!!#h--00001 1r   r,   Sequence[int]c                   t          |d          rt          |d          st          d          t          |          }|                     |           t	          |          D ]$\  }}t          |          | j        |         _        %dS )z
        Bind this DimList to specific sizes.

        Args:
            sizes: Sequence of sizes for each dimension

        Raises:
            ValueError: If sizes is not a sequence
        __len____getitem__zexpected a sequenceN)hasattrrM   rB   ra   rb   r8   rZ   r%   )rd   r,   r%   r7   dim_sizes        r   bindzDimList.bind   s     ui(( 	4}0M0M 	423335zzd$U++ 	/ 	/KAx!$XDJqM	/ 	/r   c                V    | j         st          d          t          | j                  S )NDimList not bound)r[   rl   rB   rZ   rd   s    r   _sizezDimList._size   s)    { 	:$%89994:r   c                *    |                                  S )z7Return the size (number of dimensions) of this DimList.rw   rv   s    r   r%   zDimList.size   s    zz||r   bc                    || _         dS )z(Set the bound status (for internal use).Nr[   )rd   rz   s     r   
_set_boundzDimList._set_bound   s    r   c                    | j         S )z&Property to check if DimList is bound.r|   rv   s    r   is_boundzDimList.is_bound   s     {r   c                *    |                                  S )z!Return the length of the DimList.)r%   rv   s    r   ro   zDimList.__len__   s    yy{{r   keyUnion[int, slice]r.   c                   | j         st          d          t          |t                    r:|dk     s|t	          | j                  k    rt          d          | j        |         S t          |t                    rp|                    t	          | j                            \  }}}g }t          |||          D ]"}|
                    | j        |                    #t          |          S t          d          )Nru   r   zindex out of boundszexpected an int or a slice)r[   rl   r`   r8   rB   rZ   
IndexErrorsliceindicesrN   rO   rP   rM   )rd   r   startstopsteprU   r7   s          r   rp   zDimList.__getitem__   s    { 	:$%8999c3 	;Qww#TZ00 !6777:c?"U## 	; #C
OO < <E4F5$-- - -djm,,,,== 9:::r   r$   c                    | j         r(dd                    d | j        D                        dS | j        
d| j         S dS ),Return string representation of the DimList.(z, c              3  4   K   | ]}t          |          V  d S N)repr).0r_   s     r   	<genexpr>z#DimList.__repr__.<locals>.<genexpr>  s(       A Asc A A A A A Ar   )N*z<unbound_dimlist>)r[   joinrZ   rY   rv   s    r   __repr__zDimList.__repr__  sZ    ; 	'Dtyy A Adj A A AAADDDDZ##tz### '&r   c                *    |                                  S )r   )r   rv   s    r   __str__zDimList.__str__  s    }}r   r!   funcr   typesrP   argskwargsOptional[dict]r   c                <    t                               ||||          S r   )_Tensor__torch_function__)clsr   r   r   r   s        r   r   zDimList.__torch_function__  s     ))$tVDDDr   NN)r\   r]   r#   r   )rV   rh   r   ri   )r%   r8   r   ri   )r,   rm   r   ri   r   r8   )rz   r   r   ri   r   r   )r   r   r   r.   r   r$   r!   N
r   r   r   rP   r   rP   r   r   r   r   )__name__
__module____qualname____doc____annotations__rg   rc   ra   rs   rw   r%   r}   propertyr   ro   rp   r   r   classmethodr   r!   r   r   rX   rX      s          LLL 7;"! ! ! ! !:   
1 1 1 1,/ / / /&   
          X   ; ; ; ;"
' 
' 
' 
'    
 !%E E E E [E E Er   rX   )Optional[Union[int, list[Optional[int]]]]c                   t          |           }|vt          |t                    r|                    |           nK|                    t	          |                     t          |          D ]\  }}|||j        |         _        |S )z>Create a DimList object with the given name and optional size.)r#   )rX   r`   r8   ra   rB   rb   rZ   r%   )r#   r%   dimlistr7   ss        r   _create_dimlistr   (  s     4   GdC   	.T"""" SYY'''!$ . .1=,-GM!$)Nr   #Union[DimList, tuple[DimList, ...]]c                <   d}d|t          |          }| | }t          j                    }|t          d          |j        }	 |t          d          |j        }|j        }t          ||          t          j	        dk    r,
                                dk    r                                                                  t          
                                          rdn@
                                d	k    r(                                                                 |dk    rdk    rt          d
          }|k    rddfd}|5t          |          |k    r"t          d| dt          |                     |dk    r& |d          }t!          |||d         nd          ~S g }t#          |          D ]<}	 ||	          }|||	         nd}
|                    t!          ||
                     =t'          |          ~S # ~w xY w)zt
    Create and return one or more DimList objects.

    Similar to dims() but creates DimList objects instead.
    r)   r   Nr0   r1   r2   r5   r   r6   zXdimlists() must be assigned to a sequence of variable names or have argument n specifiedr7   r8   r   r$   c                |    d }| k     r                                 }|sd|  }dn                                 |S r:   )r#   r<   )r7   r#   r=   r>   s     r   r?   zdimlists.<locals>.genobjecto  sJ    D;||~~ 1wwKr   r@   rA   )r7   r8   r   r$   )rB   rC   rD   rE   rF   rG   rH   r   rI   rJ   r   r<   r   rK   rL   rM   r   rN   rO   rP   )r+   r,   rQ   rR   rS   rT   r?   r#   rU   r7   r%   r=   r>   s              @@r   dimlistsr   9  ss    OK e**} ""E}8999LEA=;<<<| u--w&&~~9,, 	 (()) 	KK^^!222!--//KLLNNNb  a!n   *O/))K	 	 	 	 	 	 	 U!>!>WWW3u::WWXXX a9Q<<D"4U5FqDQQ E '' 	7 	7A9Q<<D$0588dDMM/$556666V}} EE				s   E0H :AH Hc                      e Zd ZdS )DimensionMismatchErrorNr   r   r   r!   r   r   r   r             Dr   r   c                      e Zd ZdS )rl   Nr   r!   r   r   rl   rl     r   r   rl   )op_propertiesr   r   r   ri   c                 >   ddl }g }| D ]~}t          |d          rJdt          t          |                    v r,|                    dt          |          j         d           \|                    t          |                     t          |i |d|j        i dS )z;Safe print that avoids recursive torch function dispatches.r   N	__class__torch<>file)rI   rq   r$   typerO   r   printstderr)r   r   rI   	safe_argsargs        r   _safe_printr     s    JJJ I ' '3$$ 	'CS		NN)B)B6c!36667777SXX&&&&	9000SZ000000r   c                      e Zd Zd%dZd&dZed'd            Zed(d	            Zd'd
Ze		 	 d)d*d            Z
ed+d            Zd,dZd-dZd.d"Zd/d$ZdS )0r   r   	list[Any]c                     t          d          )Nz+_get_levels must be implemented by subclassNotImplementedErrorrv   s    r   _get_levelsz_Tensor._get_levels      !"OPPPr   Optional[torch.Tensor]c                     t          d          )Nz+_get_tensor must be implemented by subclassr   rv   s    r   _get_tensorz_Tensor._get_tensor  r   r   r8   c                     t          d          )Nz$ndim must be implemented by subclassr   rv   s    r   ndimz_Tensor.ndim  s    !"HIIIr   tuple[Any, ...]c                X    t          d |                                 D                       S )Nc              3  f   K   | ],}|                                 |                                V  -d S r   )is_positionalr_   r   ls     r   r   z_Tensor.dims.<locals>.<genexpr>  s9      RR@Q@QRQUUWWRRRRRRr   )rP   r   rv   s    r   rV   z_Tensor.dims  s+    RRd&6&6&8&8RRRRRRr   c                    | j         S r   )r   rv   s    r   r_   z_Tensor.dim  s
    yr   r!   Nr   r   r   rP   r   r   r   r   c                2   |i }t           r|t          j        j        u rt	          |          dk    r~|s{t          |d         t          t          j        f          rSt          |d         t          t          j        f          r+t          j        |d         dd          }t          j        |d         dd          }|r|r|j	        |j	        |j	        
                                dk    r|j	        
                                dk    r|j	                                        r|j	                                        rs|j        p|j        }g }|j        D ]}	|	|vr|                    |	           |j        D ]}	|	|vr|                    |	           t                              ||||          S |t          j        j        u rddlm}
  |
| ||||          S |t          j        j        u rYddlm} t	          |          dk    r! ||d         |d         |d                    d S t+          d	t	          |                     |t          j        j        u r|d                             d          S |t          j        u rt1          |i |S |t          j        u rt3          |i |S |t          j        j        u s4|t          j        j        u s!|t          j        j        u s|t          j        u rt5          |i |S t                              ||||          S )
N   r   r   Fensure_batchedensure_present)getitemsetitemr3   z%Expected 3 args for __setitem__, got )DOT_OPTIMIZEDr   Tensor__mul__rB   r`   r   r   creater   r_   is_floating_point
has_devicelevelsrO   create_delayedrp   functorch.dim._getsetitemr   __setitem__r   rM   ro   r%   softmaxstacksplit_VFsplit_with_sizes_torch_function_fallback)r   r   r   r   r   lhs_inforhs_infor   r   levelr   r   s               r   r   z_Tensor.__torch_function__  s`    >F +	UTU\%999 D		Q tAw%,(?@@  tAw%,(?@@  &,GE%   &,GE%  
 U U !3 3 ++--22 ++--22 !99;;U$O==??U
 &.%8%OH<O
!#%-_ 5 5E$F22 &e 4 4 4%-_ 5 5E$F22 &e 4 4 4  &44T4TTT5<+++99999973eT6:::5<+++999999 4yyA~~Qa$q'222t !TT!T!TUUU 5<'''7<<??" 5=  D+F+++ 5;$)&))) EL&&&uy&&uy111u{""$)&)))//eT6JJJr   dictc                ^   t           o| t          j        v }t          ||f          \  }}dg }g |D ]}t	          j        || d          }	|                    |	           |	r|s|	j        t          d          |	j	        r|	j
        |	j        D ]O}
t          |
t                    st          dt          |
                     |
vr                    |
           P|rt          |          D ]`\  }}	|	rY|	j
        R|	j
        }!|	j	        s|                    j                  }t%          ||	j                  }t'          |          ||<   at)          ||          \  }} | |i |}d
fd}t          |t*          j                  r ||          S t/          ||          S t1                    5 t          |          D ]e\  }}	|	r^|	j        W|	j        }!|	j	        s|                    j                  }                    ||	j                   t'          |          ||<   ft)          ||          \  }} | |i |}d
fd	}t          |t*          j                  r ||          cddd           S t/          ||          cddd           S # 1 swxY w Y   dS )zGFallback torch function implementation for non-special-cased functions.NFz-Expected pointwise or batchedtensor to be setzExpected DimEntry, got objr   r   c                x    t          | t          j                  rt                              | d u          S | S r   )r`   r   r   from_positional)r   device_holding_tensorresult_levelss    r   wrap_tensorz5_Tensor._torch_function_fallback.<locals>.wrap_tensorG  sC    c5<00 !11],A,M   
r   c                l    t          | t          j                  r                    | d u          S | S r   )r`   r   r   from_batched)r   r   guards    r   unwrap_tensorz7_Tensor._torch_function_fallback.<locals>.unwrap_tensorc  s:    c5<00 V --c3HPT3TUUU
r   )r   r   r   r   )POINTWISE_OPTIMIZEr   	pointwiser
   r   r   rO   batchedtensorAssertionErrorr   r   r   r`   r   r   rb   todevicer   r"   r   r   r   r   r   inplace_update_layers)r   r   r   r   is_pointwise	flat_argsspecinfosfinfor   r7   r   mlunflat_argsunflat_kwargsrU   r   batchedr  r   r  r   s                       @@@r   r   z _Tensor._torch_function_fallback  s   
 *Mdm6M.M&f~66	4 $"$(* 	4 	4A$QL(8%@@DLL 4$ (:(F(G   )0T_0,0K)![ 4 4E%eX66 V,-TtE{{-T-TUUUM11%,,U333 	5$U++ : :4 :DK3![F,88!'+@+G!H!H&vt{MJJB#5b#9#9IaL)7	4)H)H&KT;8-88F       &%,// 5"{6***V444 ]++ 	7u$U++ ? ?4 ?D.:"0G,88")**-B-I"J"J//EEE#5g#>#>IaL)7	4)H)H&KT;8-88F      
 &%,// 7$}V,,)	7 	7 	7 	7 	7 	7 	7 	7,  v66-	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7 	7s   =B<J"J""J&)J&indexvalueri   c                (    ddl m}  || ||          S )z2Set values in tensor using first-class dimensions.r   r   )r   r   )rd   r  r  r   s       r   r   z_Tensor.__setitem__m  s(    555555wtUE***r   r'   c                   t          j        | dd          }|D ]}t          |t                    st          | t          j                  r.t          | t                    st	          j        j        | g|R  c S |                     t          j        j        t          |           f| f|z             c S |s8|                     t          j        j        t          |           f| f|z             S |j
        }|8|                     t          j        j        t          |           f| f|z             S |j        }g }g }g }|D ]}	|D ]?}
|
                                s)|
                                |	u rt          d|	 d          @|D ]?}|                                s)|                                |	u rt          d|	 d          @|                    t!          |	                     |                    |	j                   |                    d           |                    |           t'          |                                          }t'          |                                          }|                    |           |                    |           |                    |||                                          }t
                              |||j                  }|S )aq  
        Expand tensor by adding new dimensions or expanding existing dimensions.

        If all arguments are Dim objects, adds new named dimensions.
        Otherwise, falls back to regular tensor expansion behavior.

        Args:
            args: Either Dim objects for new dimensions or sizes for regular expansion

        Returns:
            New tensor with expanded dimensions

        Example:
            >>> i, j = dims()
            >>> t = torch.randn(3, 4)
            >>> expanded = t[i].expand(j, k)  # Add j, k dimensions
            >>> expanded2 = t[i].expand(2, 4)  # Regular expand with sizes
        Fr   Nzexpanding dimension z# already exists in tensor with dimsr   )r   r   r`   r'   r   r   r   expandr   r   r   r   r   r_   rl   rO   r   r%   extendrh   stride
as_stridedstorage_offsetr   r   )rd   r   r  r   datar   
new_levels	new_sizesnew_stridesr;   r   	new_level
orig_sizesorig_stridesexpanded_datarU   s                   r   r  z_Tensor.expandv  s
   &  eERRR 	 	Cc3'' dEL11 *T7:S:S  <.t;d;;;;;;22+d4jj]TGdN      	**#d4jj]TGdN  
 {<**#d4jj]TGdN   %'
	 	" 	"A  **,, 1A1A,UqUUU   (  	 ..00 Y]]__5I5I,UqUUU   hqkk***QV$$$q!!!! 	&!!! $))++&&
DKKMM**$$$<((( 	;@S@S@U@UVV ''z4?SSr   rV   CUnion[int, Dim, tuple[Union[int, Dim], ...], list[Union[int, Dim]]]r   sUnion[int, slice, torch.Tensor, tuple[Union[int, slice, torch.Tensor], ...], list[Union[int, slice, torch.Tensor]]]c                V	   % ddl m} ddlm}m} ddlm% ddd}d% fd}d fd}g }	g }
t          |t          t          f          }t          |t          t          f          }|r|r|}|}t          |          t          |          k    r0t          dt          |           dt          |           d          |	                    |           |
                    |           n*|	                    |           |
                    |           t          j         dd          }g }g }g }t!          t          |	                    D ]} ||	|         d          \  }}|rt          |          dk    r"|                    t#                                 Q ||d                   }|                    |           t          |          dk    rt          |          dk    r|                    |j                   g }t!          dt          |                    D ]{} |||                   }d}t!          t          |                    D ]'}||         |k    r|                    |           d} n(|s ||           |                    |           |d}t!          t          |                    D ]}||         |k    r|} n| ||           t)          |          D ]!\  }}|                    |dz   |z   |           "|                    |           |                     ||	|                              t          |          dk    r|j        t/          d           ||j        |j        |          }|                                }g } g }!t!          t          |                    D ]}||         |v rFt          |           dk    r|                     ||                    ;| dxx         ||         z  cc<   R|                     ||                    |!                    ||                    |                    |           |_        |!|_        d}"|
D ]"}#t          |#t          t          f          rd}" n# ||g ||
|"          }$ ||$          S )z<
        Index tensor using first-class dimensions.
        r   )r   )getsetitem_flatinvoke_getitem	_wrap_dimFr   r   check_firstr   r   tuple[Any, bool]c                `    t          | t          t          f          rt          |           dfS dS )NT)NF)r`   rP   rh   )r   r,  s     r   maybe_dimpackz$_Tensor.index.<locals>.maybe_dimpack  s-    #t}-- 'Cyy$&;r   r   c                     | j         d          }|                                rt          dt          |                      |S )NFz)expected a dimension specifyer but found )r   is_none	TypeErrorr   )r   r;   r+  rd   s     r   parse_dim_entryz&_Tensor.index.<locals>.parse_dim_entry  sL    	!TY..Ayy{{ W UDQRGG U UVVVHr   r;   ri   c                    |                                  r5t          d|                                 j        z    dj         d          t          dt	          |                                            d          )N
dimension z not in tensor of z dimensionsz not in tensor)r   r2  positionr   r   r_   )r;   rd   s    r   dim_not_presentz&_Tensor.index.<locals>.dim_not_present  sy       Lc	!9ccTYccc     JT!%%'']] J J JKKKr   zdims (z) and indices (z) must have the same length)r,  r   TNz2Cannot perform dimension flattening on None tensorr)   )F)r   r   r,  r   r   r-  )r   r   r   r   )r;   r   r   ri   )
_dim_entryr   _getsetitemr(  r)  _wrapr+  r`   rP   rh   rB   r2  r  rO   r   r   rN   r   r   poprb   insertr   r  r%   reshape)&rd   rV   r   r   r(  r)  r/  r3  r7  	dims_listindices_listlhs_listrhs_listdims_seqindices_seq	self_infor  
to_flattendims_list_flatr7   m
is_dimpackfirstrestjr;   removedk	first_idxr
rearrangedr,   r  reshape_levelshas_dimpacksidxr  r+  s&   `                                    @r   r  z_Tensor.index  s    	.-----@@@@@@@@$$$$$$	 	 	 	 	
	 	 	 	 	 	 		L 	L 	L 	L 	L 	L ,.	>@dUDM22gt}55 	) 	)H!K8}}K 0 000hS]]hh3{;K;Khhh   X&&&,,,,T"""((( %dE599	 "
 "
 s9~~&& ,	E ,	EA)M)A,EJJJMAz *Eq66Q;;"))(**555'!--%%e,,,q66Q;; z??a''%%i&6777q#a&&)) 
# 
#A'!--A#G"3z??33 " "%a=A--&NN1---&*G!E . # +'***KKNNNN !	s://  A!!}--$%	 . $#OE***%dOO < <DAq%%i!ma&7;;;;!!$''''%%ooil&C&CDDDD z??Q'$H   'y'79I:VVJOO%%E#%IN3z??++ 9 9a=J..9~~**!((q2222!"q1$$U1X..."))*Q-8888)11)<<I-I  	 	C#t}-- #
 
 
 ~d###r   r$   c                h   |                                  |                                 | j        }}}g }|D ]}t          |d          r?|                                r+|                    |                                |z              Qt          |d          r(|                    |                                           t          |d          r|                    |j                   |                    |           | dt          |           dt          |
                                           S )Nr   r_   r  z
with dims=z sizes=)r   r   r   rq   r   rO   r6  r_   r  rP   r%   )rd   r   r   r   	dims_reprr   s         r   r   z_Tensor.__repr__f  s+   #//1143C3C3E3Ety	 		$ 		$Aq/** $q/@/@ $  !45555E"" $  ))))F## $  ((((  ####UUeI&6&6UUuV[[]]?S?SUUUr   r   r   r   r   r   )r   r   r   r   )
r   r   r   rP   r   rP   r   r   r   r   )r  r   r  r   r   ri   )r   r'   r   r   )rV   r%  r   r&  r   r   r   )r   r   r   r   r   r   r   rV   r_   r   r   staticmethodr   r   r  r  r   r!   r   r   r   r     s]       Q Q Q QQ Q Q Q J J J XJ S S S XS    
 !%ZK ZK ZK ZK [ZKx O7 O7 O7 \O7b+ + + +S S S SjY$ Y$ Y$ Y$vV V V V V Vr   r   c                      e Zd ZU ded<   ded<   ded<   ded<   ded<   dddZedd            Zed d            Zedd            Z	e	j
        d!d            Z	ed"d            Zd#dZd#dZd$dZej        ZdS )%r'   r8   _levelr$   rY   rw   r   _range_batchtensorr)   r#   r   r   ri   c                j    || _         || _        t          | _        t          dz  ad | _        d | _        d S Nr   )rY   rw   _n_dims_createdrZ  r[  r\  )rd   r#   r   s      r   rg   zDim.__init__  s6    

%1 r   c                    dS r^  r!   rv   s    r   r   zDim.ndim  s    qr   r   r   r   c                $    t          |          | u S r   r   )r   r   s     r   check_exactzDim.check_exact  s    CyyCr   c                V    | j         dk    rt          d| j         d          | j         S )Nr)   r5  z is unbound)rw   rM   rY   rv   s    r   r%   zDim.size  s3    :A$*AAABBBzr   vc                    | j         dk    r	|| _         d S | j         |k    r*t          dt          |            d| j          d|           d S )Nr)   zDim 'z*' previously bound to a dimension of size z$ cannot bind to a dimension of size )rw   rl   r   )rd   re  s     r   r%   zDim.size  sp    :DJJJZ1__$:T

 : :dj : :67: :   _r   c                    | j         dk    S )z1Return True if this dimension is bound to a size.r)   ry   rv   s    r   r   zDim.is_bound  s     zRr   r   c                Z    | j         t          j        | j                  | _         | j         S )z
        Get a tensor representing the range [0, size) for this dimension.

        Returns:
            A 1D tensor with values [0, 1, 2, ..., size-1]
        )r[  r   aranger%   rv   s    r   
_get_rangezDim._get_range  s'     ;,ty11DK{r   c                    | j         Bt          j        j                            |                                 d| j                  | _         | j         S )z
        Get a batched tensor representation of this dimension.

        Returns:
            A batched tensor created from the range tensor
        Nr   )r\  r   _C
_functorch_add_batch_dimrj  rZ  rv   s    r   _get_batchtensorzDim._get_batchtensor  sH     $ % 3 B B!!1dk! !D   r   c                    | j         S )z&String representation of a Dim object.)rY   rv   s    r   r   zDim.__repr__  s
    zr   N)r)   )r#   r$   r   r8   r   ri   r   )r   r   r   r   )re  r8   r   ri   r   r   r   r   )r   r   r   r   rg   r   r   r   rc  r%   setterr   rj  ro  r   object
__format__r!   r   r   r'   r'   y  sD        KKKJJJJJJ""""((((! ! ! ! !    X       [     X
 
[   [       X 	 	 	 	! ! ! !    "JJJr   c                      e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
ed<   ded<   ed+d            Zed,d            Zed-d            Zed.d            Z	d/d Z
d0d"Zd1d#Zd/d$Zd2d'Zd3d)Zd*S )4r   r   _tensorr\  list[DimEntry]_levelsr   _has_devicez$Optional[Callable[[], torch.Tensor]]_delayedzOptional[Callable]_delayed_origzOptional[tuple]_delayed_argsr   r8   c                >    t          d | j        D                       S )Nc              3  F   K   | ]}|                                 rd ndV  dS )r   r   N)r   r   s     r   r   zTensor.ndim.<locals>.<genexpr>  s5      GGQ))011qGGGGGGr   )sumrx  rv   s    r   r   zTensor.ndim  s!    GG$,GGGGGGr   otherr   c                $    t          |          | u S r   rb  )r   r  s     r   rc  zTensor.check_exact  s    E{{c!!r   r   r   r   r   Union[_Tensor, torch.Tensor]c                r   d}d}|D ]x}|                                 r]|dk    sB|dz   |                                k    s't          d| d|                                           |                                }s|dz  }y|dk    s|dk    st          d|           |s|S  |             }||_        ||_        ||_        d|_        d|_        d|_        d|_	        |
                                t          |          k    r5t          d|
                                 d	t          |           d
          |S )a0  
        Create a functorch Tensor from a regular PyTorch tensor with specified dimension levels.

        This is the primary way to create Tensor objects with first-class dimensions.

        Args:
            tensor: The underlying PyTorch tensor
            levels: List of DimEntry objects specifying the dimension structure
            has_device: Whether the tensor is on a device (not CPU)

        Returns:
            A new Tensor instance with the specified dimensions, or a regular torch.Tensor
            if there are no named dimensions
        r   r   z/Positional dimensions must be consecutive, got z then r)   z0Final positional dimension must be 0 or -1, got NzTensor has z dimensions but z levels provided)r   r6  r  rv  rx  ry  r\  rz  r{  r|  r_   rB   )r   r   r   r   	seen_dimslastr   rU   s           r   r   zTensor.from_positional  sw   $ 	 
	 
	A   			TAX%=%=(d$ddVWV`V`VbVbdd   zz|| Q		 		TRZZ I4II    	M '"## ::<<3v;;&& YfjjllYYCKKYYY   r   origr   r   rP   r   c                     |             }d|_         ||_        ||_        d|_        |_        |_        dfd}||_        |S )zP
        Create a delayed tensor that defers the operation until later.
        Nr   r   c                     g } D ]O}t          |d          r(|                     |                                           :|                     |           P |  S )Nr   )rq   rO   r   )unwrapped_argsr   r   r  s     r   evaluate_delayedz/Tensor.create_delayed.<locals>.evaluate_delayed'  sn    N / /3.. /"))#//*;*;<<<<"))#....4((r   rq  )rv  rx  ry  r\  r{  r|  rz  )r   r  r   r   r   rU   r  s    ``    r   r   zTensor.create_delayed  sp     '"##	) 	) 	) 	) 	) 	) 	) +r   c                    t          | d          r<| j        5| j        .|                                 | _        d| _        d| _        d| _        | j        S )zAGet the underlying tensor, handling delayed operations if needed.rz  N)rq   rz  rv  r{  r|  rv   s    r   r   zTensor._get_tensor4  sV     D*%%
	&)$  ==??DL DM!%D!%D|r   r   c                    | j         S )zGet the dimension levels.)rx  rv   s    r   r   zTensor._get_levelsC  s
    |r   c                    | j         S )z/Get whether this tensor has device information.)ry  rv   s    r   _get_has_devicezTensor._get_has_deviceG  s    r   c                    | j         ?|                     |                                 |                                           | _         | j         S )zDGet the batched tensor representation, creating it lazily if needed.)r\  _add_batch_dimsr   r   rv   s    r   ro  zTensor._get_batchtensorK  sK    $ $ 4 4  ""D$4$4$6$6! !D   r   tlevels_c                   t          |          }	 d}d}t          d          }d}d}t          |          D ]l\  }}	|	                                sS|	                                s:|	                                j        |k     r|	                                j        }|}|}|dz  }m|dk    r|S |t          d          t          j	        j
                            ||t          |                    }t                      ||<   )NTr)   infr   r   zExpected t to be non-None)rh   floatrb   r1  r   r_   rZ  r  r   rl  rm  rn  r8   r   )
rd   r  r  r   min_real_index	min_index	min_valuer7   rO  r   s
             r   r  zTensor._add_batch_dimsS  s     g	0NIeIAA!&))  1yy{{ ??,, +)1K1K$%EEGGN	$%	)*FABy$%@AAA#221iYPPA%-ZZF>"-	0r   rV   c                $    ddl m}  || g|R  }|S )z&Reorder the dimensions of this tensor.r   )order)_orderr  )rd   rV   r  rU   s       r   r  zTensor.orderq  s0    !!!!!!t#d###r   Nr   )r  r   r   r   )r   r   r   rw  r   r   r   r  )
r  r   r   rP   r   rw  r   r   r   r   rW  rV  r   )r  r   r  r   r   r   )rV   r   r   r   )r   r   r   r   r   r   r   rc  r   r   r   r   r  ro  r  r  r!   r   r   r   r     se        ####((((2222%%%%""""H H H XH " " " [" 9 9 9 [9v    [8             ! ! ! !   <     r   r   tensorsnew_dimr_   r8   c                   | st          d          t          |t                    st          j        | |          }|S g }g }| D ]Q}t          j        |dd          }|                    |           |j        D ]}||vr|                    |           Rt          |           |_
        g }	|D ]H}|j        t          d          t          |j        |j        |          }
|	                    |
           It          |          }d}|it          |t                    r|dk    sNdd	lm}  |||d          }	 |                    |          }n"# t           $ r t'          d
| d          dw xY w|}t          j        |	|          }|                    |t+          |                     t,                              |||r|d         j        nd          }|S )a$  
    Stack tensors along a new dimension.

    Args:
        tensors: Sequence of tensors to stack
        new_dim: The new Dim to create for stacking
        dim: The dimension position to insert the new dimension (default: 0)

    Returns:
        Stacked tensor with the new dimension
    z-stack expects a non-empty sequence of tensors)r_   Fr   Nz*Cannot stack tensors with None tensor datar   r   r*  z
Dimension z does not exist in inputsT)rM   r`   r'   r   r   r   r   rO   r   rB   r%   r   r  r   r   r8   r:  r+  r  r2  r<  r   r   r   r   )r  r  r_   rU   r   r  r  r  r   inputsmatched_tensorr   rawdimr+  r;   rS  tensor_results                    r   r   r   y  sB     JHIII gs## W#... ME , , 5OOOT[ 	, 	,EM))$$U+++	,
 w<<GL F & &; !MNNN&t{DKOOn%%%% -((DF

3 4 4$$$$$$Ic4''	S%%a((CC 	S 	S 	SGGGGHHdR	S [((F '!2!2333 **eEuQx22 M s   :E E/split_size_or_sectionsrP   c           	     N   ddl m} t          |t                    }t          |t                    rO|rt          d          t                              t          j	        j
        t          |           f| |fd|i          S g }d}d}|D ]1}|                    |           t          |t                    rd}/d}2|rO|rt          d          t                              t          j	        j
        t          |           f| |fd|i          S |st          d          t          j        | dd          }	|	                                }
|s|
d	k    rt          d
          | |||
d          nt!          |
           }d}t#          |	j                  D ]\  }}||k    r|} n||d	}t          d|           g }d	}g }t#          |          D ]\\  }}|j        r&|                    |j                   ||d         z  }2|                    d	           |                    |           ]|	j        t-          d          |	j                            |          }|rs||k    rt          d| d| d          ||z
  }|t/          |          z   dz
  t/          |          z  }|D ])}t1          ||          }|||         _        |||<   ||z  }*n||k    rt          d| d| d          |	j                            ||          }g }t5          |	j                  }t#          t7          ||                    D ][\  }\  }}t!          |          ||<   |                    t                              |t5          |          |	j                             \t=          |          S )z
    Split tensor along a dimension.

    Can handle both regular integer sizes and Dim objects for split sizes.
    When Dim objects are used, they get bound to the resulting tensor dimensions.
    r   r*  zKwhen dim is specified as a Dim object, split sizes must also be dimensions.r_   TFz-split list must be ints or dims but got a mixr   r   z+split expects at least a 1-dimension tensorNz"tensor does not contain dimension r)   z%Cannot get tensor size on None tensorz+sizes of target dimensions add up to more (z) than source dim (r   z#sum of sizes of target dimensions (z) do not match the source dim ()r:  r+  r`   r'   r8   r2  r   r   r   r   r   r   rO   r   r   r   r   rb   r   r   r%   r   r  rB   minr   rh   zipr   r   rP   )r   r  r_   r+  dim_is_objectr,   all_dimsall_intsre   rD  r   dim_lrS  r7   r   r   
total_sizeunboundsize_dimtensor_sizeremaining_size
chunk_sizeuszresult_tensorsrU   r  result_tensors                               r   r   r     s    !      sC((M (#.. 
 	]   //L&\\O+,CL	
 
 	
 EHH&  TdC   	HHHH 
 	]   //L&\\O+,CL	
 
 	
  IGHHH !&uUUUI>>D GTQYYEFFF ,/?IIc4'''$E Ci.//  5E>>CE  {;CBSBBCCC GJG ''  8 	NN8=)))'"+%JJNN1NN1DEEE"'',,K  
##kjkk]hkkk   %z1$s7||3a7CLLH
 	! 	!AZ00BE!HMGAJb NN		!
 

	"	"k*kk]hkkk
 
 	

 %66wDDN Fi&''J(1#ne2L2L(M(M 
 
$$M8"8,,
3""tJ//1E 	
 	
 	
 	
 ==r   c                n    t          d          }t          | ||                              ||g|          S r^  )rV   r   r  )r  r_   r  r+   s       r   catr  ?  s3    QA!S!!''C':::r   c                  "    e Zd ZdZd	dZd
dZdS )DotPartzA
    Helper class for organizing dimensions in dot products.
    r   ri   c                "    g | _         d| _        d S r^  )rV   r  rv   s    r   rg   zDotPart.__init__I  s    $&	r   	dim_entryr   c                    | j                             |           |                                s)| xj        |                                j        z  c_        dS dS )z#Add a dimension entry to this part.N)rV   rO   r   r  r_   r%   )rd   r  s     r   rO   zDotPart.appendM  sU    	###&&(( 	4OOy}}33OOOO	4 	4r   N)r   ri   )r  r   r   ri   )r   r   r   r   rg   rO   r!   r   r   r  r  D  sF            4 4 4 4 4 4r   r  partslist[DotPart]tensor_infor   c                (   g }d}| D ]6}t          |j                  dk    rd}|                    |j                   7|j        t	          d          t          |j        |j        |          }|s|S d | D             }|                    |          S )zJ
    Prepare tensor for dot product by matching levels and reshaping.
    Fr   TNz)Cannot perform dot product on None tensorc                    g | ]	}|j         
S r!   )r  )r   parts     r   
<listcomp>zdot_prepare.<locals>.<listcomp>h  s    ...DO...r   )rB   rV   r  r   rE   r   r   r=  )r  r  r  needs_reshaper  rU   views          r   dot_preparer  T  s     JM % %ty>>Q M$)$$$$!FGGG;-{/A:NNF  /....D>>$r   r  c                L   g }d}| D ]6}t          |j                  dk    rd}|                    |j                   7|rHg }|D ].}|                    |                                j                   /|                    |          }t                              ||d          }|S )zE
    Finish dot product by reshaping result and creating Tensor.
    Fr   T)	rB   rV   r  rO   r_   r%   r=  r   r   )r  r  r   r  r  new_sizer   r  s           r   
dot_finishr  l  s     MM ( (ty>>Q MTY'''' 8" 	. 	.EOOEIIKK,----%--h77**=-NNMr   lhsrhssum_dimsr  c                   t          j        | dd          }t          j        |dd          }|r|st          j        | |          S |j        |j        t          d          |j                                        |j                                        t                      t                      t                      t                      dfd}dgt          |j	                  z  }t          |j	                  D ]=\  }}d}	t          |j	                  D ]\  }
}||k    r	|
}	d||
<    n ||||	           >t          |j	                  D ]\  }}||         s ||d|           t          j                  t                    k    r)D ]&}||j	        vr||j	        vrt          d|           't          j                  dk    rNt          g|          }t          g|          }t          j        ||          }t          g|          S t          g|          }t          g|          }t          j        ||          }t          g|          S )z
    Perform dot product between two tensors along specified dimensions.

    Args:
        lhs: Left-hand side tensor
        rhs: Right-hand side tensor
        sum_dims: Dimensions to sum over (contract)

    Returns:
        Result of dot product
    Fr   Nz*Cannot perform dot product on None tensorsr;   r   lhs_idxrhs_idxr   ri   c                    | v }||         nd}|
|         nd}|r                     |            dS |dk    |dk    k    r	                     |            dS |dk    r                     |            dS                      |            dS )z?Insert dimension into appropriate part based on stride pattern.Nr   )rO   )r;   r  r  reduced
lhs_stride
rhs_stridelhs_strideslo_dimslr_dimslro_dimsrhs_stridesro_dimsr  s         r   
insert_dimzdot.<locals>.insert_dim  s    x--4-@[))a
-4-@[))a
 	"NN1aZ1_55"""""qq!!!!!q!!!!!r   Tz$summing over non-existent dimension r   )r;   r   r  r   r  r   r   ri   )r   r   r   matmulr   r  r  r  rB   r   rb   rV   rM   r  bmmr  mm)r  r  r  r   r   r  rhs_seenr7   	lhs_levelr  rK  	rhs_levelr;   
lhs_tensor
rhs_tensorrU   r  r  r  r  r  r  s     `             @@@@@@r   dotr    s     U5QQQH U5QQQH & &|C%%%(/"9IJJJ/((**K/((**K yyHiiGiiGiiG" " " " " " " " " " " "" wX_---H "(/22 * *9%ho66 	 	LAyI%%" &
 	
9a)))) "(/22 + +9{ 	+Jy$*** 7<CMM)) 	M 	MA''AX_,D,D !K!K!KLLL 8=Q (GW!=xHH
 (GW!=xHH
:z228Wg6??? !'7!3X>>
 '7!3X>>
*j117G,f555r   )r:  )	wrap_typerd   	positionsrV   c                L   t          | t                    rt                              | ||          S t          j        | dd          }|j        t          d          t                              |j        |j	        |j
                  }t                              |||          S )a  
    Index a regular tensor by binding specified positions to dims.

    This converts a regular tensor to a first-class tensor by binding
    the specified positional dimensions to Dim objects.

    Args:
        positions: Tuple of dimension positions to bind
        dims: Dim objects or tuple of Dim objects to bind to

    Returns:
        First-class tensor with specified dimensions bound
    Fr   NzCannot index None tensor)r`   r   r  r   r   r   r  r   r   r   r   )rd   r  rV   r  rU   s        r   r  r    s     $   4}}T9d333 T%NNND {7888##DKdoNNF ==D111r   c           	         t          t          j        |           }t          t          | t          |g|R i |           d S r   )getattrr   r   setattrr   r:  )r#   r   r   r  s       r   _defr    sC    5<&&DGT577777788888r   meanr  allamaxaminaminmaxanycount_nonzero	logsumexpnanmeannansumprodstdr   )keepdim_offsetvarmax)
single_dimr  argmaxargminkthvaluemedian	nanmedianmodesortF)reduceargsortunbindchunk)
dim_offsetr  cummax)r  r  cummincumprodcumprod_cumsumcumsum_logcumsumexprenorm)r  r  r  r   )r   r   r   r   )r   r   r   r   r   )r#   r$   r%   r&   r   r'   r   )r+   r&   r,   r-   r   r.   )r#   r$   r%   r   r   rX   )r+   r&   r,   r-   r   r   )r   r   r   r   r   ri   )r   )r  r   r  r   r_   r8   r   r   )r   r   r  r   r_   r   r   rP   )r  r   r_   r   r  r   r   r   )r  r  r  r   r   r   )r  r  r  r   r   r   )r  r   r  r   r  r   r   r  )rd   r   r  r   rV   r   r   r   )r#   r$   r   r   r   r   r   ri   )B
__future__r   disrC   rI   typingr   r   r   r   collections.abcr   r	   r   torch.utils._pytreer
   r   r   r8  r   r   r   _enable_all_layersr   _py_inst_decoderr   _tensor_infor   r  r   r_  r   r"   r*   rV   rX   r   r   	Exceptionr   rl    r   r   r   r   
TensorLiker'   r   r   r  r  r  r  r  functorch.dim._wrapr:  functorch.dim.wrap_typer  r   r   r  r  nn
functionalr   r!   r   r   <module>r     s   " " " " " " 



  



 6 6 6 6 6 6 6 6 6 6 6 6  322222222  F F F F F F F F F F ? ? ? ? ? ? ? ? ? ? / / / / / / , , , , , , $ $ $ $ $ $   8 8 8 8
   
7 7 7 7 7 EI` ` ` ` `FWE WE WE WE WE WE WE WEv BF    $ EIV V V V Vr	 	 	 	 	Y 	 	 		 	 	 	 	 	 	 	      1 1 1 1GV GV GV GV GV GV GV GVT u|$
K# K# K# K# K#' K# K# K#bl l l l lW l l l^B B B B BJ~ ~ ~ ~ ~B; ; ; ;
4 4 4 4 4 4 4 4        0   ,U6 U6 U6 U6p & % % % % % - - - - - - 
	'5<!; < < <L2 2 2 2>9 9 9 9
 V U U V V Y U _    [    Y X V U1     U1     Ut     Ut     X$     X$     ZD ! ! ! ! X$     [T " " " " V     VE     Yu     X$     W5 ) ) ) ) X$u - - - - X$u - - - - Y4 . . . . ZD / / / / X$u - - - - Y4 . . . . ^U 3 3 3 3 X!U ; ; ; ; Y4 . . . .
%#+U
K
K
Kr   