1;ji JddlZddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZejrddlZddlmZddlmZddlmZmZmZe dZe eeed fgefZe eefZejZ d Z!d Z"d Z#d eedefdZ$dedeefdZ%dZ&ee eee eeeee eefe eeefZ'eeeefd fZ(eeeefZ)GddZ*de*deede)de'fdZ+ej,de+Z-de*dedede(def dZ.de*dedede(def dZ/ej,d d!ed"ed#eed fd$ede*f d%Z0d!ed"ed#eed fde ee*ffd&Z1de eeefd!ed'ede def d(Z2de eeefd!ede defd)Z3de eeefd!ede defd*Z4d+ed!ede5fd,Z6d-Z7eZ8dede8fd.Z9d/Z:ej,d d!edefd0Z;ej<ded!edefd1Z=ej<d2ed3ed!edefd4Z=ej<d2ed3ed5ed!edef d6Z=ej<d2ed3ed5ed7ed!edef d8Z=d9e eefdefd:Z=dS);N) OrderedDict) SetTupleListDictUnionCallableOptionalTypeVarcastAny) EinopsError) get_backend)ParsedExpression _ellipsis AnonymousAxisTensor.)minmaxsummeanprodanyalliiaysequencereturncd}|D]}||z}|S)zSminimalistic product that works both with numbers and symbols. Supports empty listsr)rresultelements G/root/voice-cloning/.venv/lib/python3.11/site-packages/einops/einops.py_productr#s' F' Mreduction_type reduced_axesct|r||t|S|tvsJ|dkr$||st d|||t|S)Nrz5reduce_mean is not available for non-floating tensors)callabletuple _reductions is_float_typeNotImplementedErrorreduce)tensorr%r&backends r" _reduce_axesr0%s K~feL&9&9:::,,,, V # #((00 c)*abbb~~fneL6I6IJJJr$c| ttztksJttttdz dddD]}|dz|dzkrp|dz }d  dzdz dz xx|zcc<d|dztd|dzdDzfd}|}ttdz dddD]}|| ||dz||dz||dzkr|dz }t fdt D} t fdDd  dzdz dz xx|zcc<} g| D]=} | | kr | | kr| %| dz >|}|fS)Nrc3 K|] }|dz V dSrNr).0axiss r" z+_optimize_transformation..?s&8d8dd8d8d8d8d8d8dr$ci}ttD]\}|vrd||< td|D}t |||<]|S)Nc3K|]}|duV dSNr)r5xs r"r7zB_optimize_transformation..build_mapping..Hs&%T%Tatm%T%T%T%T%T%Tr$)rangelenrvalueslistindex) init_to_finalr6after_reductionaxes_reordering init_shapesr&s r" build_mappingz/_optimize_transformation..build_mappingBs #k**++ S SD|##&* d##"%%T%T]=Q=Q=S=S%T%T%T"T"T&*?&;&;&A&A/&R&R d##r$c3 K|]}|vV dSr;r)r5r<r&s r"r7z+_optimize_transformation..Vs(.b.bq /D.b.b.b.b.b.br$c32K|]}|kr|n|dz VdSr4r)r5r6 removed_axiss r"r7z+_optimize_transformation..Xs5 d dt )<)<$( d d d d d dr$)r>r)sortedr=rappend) rEr&rD final_shapesiremoved_lengthrFinit_axis_to_final_axis init_axisremoved_axis_after_reductionold_reorderingr6rIs ``` @r"_optimize_transformationrS2s   #l"3"3 3s;7G7G G G G G --..L 3|$$q( ) )$$B$ /ee ?Q ,q1u"5 5 5'A.L(6N%m|m4{L*.eDItCy4H.I)JLs)L L"cN#L( $DI)LLLLLLr$rUr_shape axes_dimscbd}t|j|D]\}}||j|<t|jD]-\}\}}||} t |dkrt |dkr | |d<Cd} |D] }| |z} t |dkrFt | tr0t | tr| | krtd| d| nZt | tr3t | tr| | zdkrtd| d| |d} | | z} | | <t |t |zdkrd}/|rd t |j nd } d}g}|j D]G}fd |D}| t|t |dkrd}Hfd |j D}tt|jt |j }t |t |j z}|j }|j ttt |j krd }|r|nd }| |||||fS) z Reconstruct all actual parameters using shape. Shape is a tuple that may contain integers, shape symbols (tf, theano) and UnknownSize (tf, previously mxnet) known axes can be integers or symbols, but not Nones. FrrzShape mismatch, z != z,Shape mismatch, can't divide axis of length z in chunks of TNc g|] }| Srr)r5elementary_axis axes_lengthss r" z4_reconstruct_from_shape_uncached..sQQQ_<0QQQr$c(i|]\}}||Srr)r5pospos_in_elementaryrls r" z4_reconstruct_from_shape_uncached..s3"""1G6G\+ ,"""r$)r@rVrW enumeraterXr> isinstancererrYr\rKr#r[itemsr=rZ)r_rgrhneed_init_reshaper6dim input_axis known_axes unknown_axeslength known_product unknown_axisinferred_lengthrEneed_final_reshaperLgroupinglengthsr[r&n_axes_after_adding_axesrD _final_shapesrls @r" _reconstruct_from_shape_uncachedrs1#4#?@@LAA c=@ T3D9::2;D<`2a2a%%. .Zz" z??a  C $5$5$:$:,2La )   0 0D \$/ /MM |   ! !&#&& R:mS+I+I RfXeNeNe!"PV"P"P"P"PQQQ&#&& x:mS+I+I xfWdNdhiNiNi!"vQW"v"vgt"v"vwww'?L#)]#:O)8L & z??S.. .! 3 3 $  Vg'p|4Pc$:O6P6P4P'Q'QlpK L.&&QQQQQQQHW--... w<<1  !% """"KO?K`K`KbKb"""J d5s4;P7Q7QRRSSL":T5J1K1KK+/+@O U3t/D+E+E%F%F G GGG$6@LLDM z=Rj jjr$ireciper.rlc  t||||\}}}}} } n=#t$r0t||||} | \}}}}} } YnwxYw||||}||||}t |dkrt||||}t |dkr||| |}| ||| }|S)Nr)r%r&r/)n_axespos2len) _reconstruct_from_shaperg TypeErrorrreshape transposer>r0add_axes) r/rr.r%rlrErDr&r[rLn_axes_w_added_results r" _apply_recipers:i_v GMM&))<` ` \ _lJ nn iii267==;P;PR^__ah^o|Z~~~i55"""6?;; <1f^R^hoppp :!!&!TT66 Ms+.7A('A(ct||j|\}}}}} } ||||}||||}t |dkr\t |r||t |}n3|tvsJt|||t |}t |dkrz| D]\} } | || }t|j} | D] \} } | | | < | || }| ||| }|S)Nr)r6) rrgr permute_dimsr>r(r)r*getattrrt expand_dimsr@ broadcast_to)xprr.r%rlrErDr&r[rLr axis_position axis_length final_shapes r"_apply_recipe_array_apirs\s l\\XK, L.FK00"99 <1 N # # S#^FE,,?,?@@FF"[00000WR00eL>Q>QRRRF :*4*:*:*<*< @ @ &M;^^F^??FF6<(( *4*:*:*<*< 5 5 &M;)4K & &55FL11 Mr$pattern operation axes_namesndimc  !"#|d\}}t|!t|#!js)#jr"td|!jr)!jr"td||dkry!js#jrtdt!j #j }t|dkr"td|ne|dkrt !j #j }t|dkr"td |t d #j Dh!j |}t|dkr"td |n|tvst|r\t #j !j }t|dkr#td ||n(td |t!jrt!jdz }||krtd|d|d||z } dt| D} g} !jD]>} | t kr| D]} | | g)| | ?g}#jD]{} | t kr| D]} || g)g}| D]8} | t kr|| #|| 9|||!j | !j t #jr9#j | #j t nN|t!jkr(tdt!jd|d!j} #j}t+| D]1} | D],}t-|t.r |j|<"t2|<-2g}#j D]E}|vr?t-|t.r |j|<n t2|<||Fdt5D |D]V}tj|std||vr"td|t8|<Wg}t5| D]\}} fd| D}fd| D}t|dkr"td|t|t|zt| ksJ| fd|D fd|Dfi}t;j| D]}|#j vrt|||< fdt5|D}t?t;j| "t?t;j|}#fd"D}!fd|D|z}"fd|D} !fd t5|D}t|t|z }tAt?! fd!|D|||||"S)#zPerform initial parsing of pattern and provided supplementary info axes_lengths is a tuple of tuples (axis_name, axis_length) ->z?Ellipsis found in right side, but not left side of a pattern {}z?Ellipsis inside parenthesis in the left side is not allowed: {} rearrangezQNon-unitary anonymous axes are not supported in rearrange (exception is length 1)rzBIdentifiers only on one side of expression (should be on both): {}repeatz5Unexpected identifiers on the left side of repeat: {}c<h|]}t|t|Sr)rsr)r5axs r" z1_prepare_transformation_recipe..?s' P P PB*R2O2O PR P P Pr$z(Specify sizes for new axes in repeat: {}z9Unexpected identifiers on the right side of reduce {}: {}z'Unknown reduction {}. Expect one of {}.rzWrong shape: expected >=z dims. Received z -dim tensor.c<g|]}tt|zSr)rrf)r5rMs r"rmz2_prepare_transformation_recipe..Ps#EEE1IA&EEEr$zWrong shape: expected ci|]\}}|| Srr)r5positionnames r"rqz2_prepare_transformation_recipe..saaa^Xt$aaar$zInvalid name for an axisz Axis {} is not used in transformc6h|]}|tk|Sr_unknown_axis_lengthr5r6axis_name2known_lengths r"rz1_prepare_transformation_recipe..s+sssD>TUY>Z^r>r>r4>r>r>rr$c6h|]}|tk|Srrrs r"rz1_prepare_transformation_recipe..s+uuud@VW[@\`t@t@tT@t@t@tr$zCould not infer sizes for {}c g|] }| Srrr5r6axis_name2positions r"rmz2_prepare_transformation_recipe..s 9 9 94 & 9 9 9r$c g|] }| Srrrs r"rmz2_prepare_transformation_recipe..s ;i;i;iY]..s===d D !===r$r)r5rMcomposite_axisrs r"rmz2_prepare_transformation_recipe..s?---BS!^====n===---r$c&g|] }|jv |Sr identifiers)r5r6rghts r"rmz2_prepare_transformation_recipe..s&WWWT$dFV:V:VD:V:V:Vr$c&g|] }|jv |Srr)r5r6lefts r"rmz2_prepare_transformation_recipe..s& ` ` `$ttO_G_G_G_G_G_r$c:g|]}|Sr)rA)r5r6ordered_axis_lefts r"rmz2_prepare_transformation_recipe..s(\\\$)//55\\\r$c:i|]\}}|jv||Srr)r5rM axis_namerrs r"rqz2_prepare_transformation_recipe..s= Ay D, , , i ( , , ,r$c"i|] }|| Srrrs r"rqz2_prepare_transformation_recipe..s!"Y"Y"Yd4);D)A"Y"Y"Yr$r^)"splitr has_ellipsisrformathas_ellipsis_parenthesizedhas_non_unitary_anonymous_axessetsymmetric_differencerr> differencer*r( compositionr=rrKextendupdateremoverrsrvaluerrrcheck_axis_name_expected_axis_length itertoolschainr@rUr?)$rrrrleft_strrght_strraxes_without_size n_other_dims ellipsis_ndimell_axesleft_compositionrr6rght_compositiongrouprrepeat_axes_namesrkinput_axes_known_unknownrMknownunknownaxis_position_after_reductionresult_axes_groupingordered_axis_rghtr&order_after_transpositionrYr[rZrrrrrs$ @@@@@r"_prepare_transformation_reciper!s!t,,Hh H % %D H % %D  m!2m[bbcjkklll mT<m[bbcjkklllK  . s$2U sqrr r--d.>@PQQ z??Q  biijtuuvv v  h  ^^D$4d6FGG z??Q  U\\]ghhii iNN P P$* P P P ,d , ,    ! !A % %HOOPabbcc c & k ! !Xi%8%8 !^^D$4d6FGG z??Q  Y``ajlvwwxx x CJJ9Vabbccc %,4+,,q0 ,  iiiW[iiijj j|+ EEm0D0DEEE". 8 8N**$44D$++TF33334!''7777". / /N**$44D$++TF33334*++Dy(( X.... T**** ''.... )))  ***   /   # #H - - -   # #I . . . 3t'(( ( (ps4;K7L7Lpp^bpppqq q++DO==*II' I II)]33 I4=O&y114H&y11  I%00 2 2 2)]33 I4=O&y114H&y1  $ $Y / / /aayI_?`?`aaa&HH/@@ K8/JJ J "8 8 8@GGXXYY Y2G//!&'788  >ssssNsssuuuunuuu w<?@@Y_.>?@@WWWW%6WWWL ` ` ` `2C ` ` `co o\\\\B[\\\%&788J 677#l:K:KK  $%;%B%B%D%D E E"Y"Y"Y"Yj"Y"Y"Y(@)-2   r$cd\}}t|tjg}jrfdt dD}fd|DS)z Internal function, used in layers. Layer makes all recipe creation when it is initialized, thus to keep recipes simple we pre-compute for all dims rcDg|]}tjdz |zS)r)r>r)r5 ellipsis_dimsrs r"rmz1_prepare_recipes_for_all_dims..s.XXXmD$%%)M9XXXr$c 8i|]}|t|S))r)r)r5rrrrs r"rqz1_prepare_recipes_for_all_dims..s/ m m m`dD0)ZVZ[[[ m m mr$)rrr>rrr=)rrrrrdimsrs``` @r"_prepare_recipes_for_all_dimsrs!t,,Hh H % %D  ! ! "D YXXXXuUVxxXXX m m m m m mhl m m mmr$ reductionc * t|trMt|dkrtdt |d}||}nt |}t |}||}t||t |t|}t||tt|||S#t$r}d||} t|ts| d|z } n| dz } | d|z } t| d |zd }~wwxYw) a einops.reduce combines rearrangement and reduction using reader-friendly notation. Some examples: ```python >>> x = np.random.randn(100, 32, 64) # perform max-reduction on the first axis # Axis t does not appear on RHS - thus we reduced over t >>> y = reduce(x, 't b c -> b c', 'max') # same as previous, but using verbose names for axes >>> y = reduce(x, 'time batch channel -> batch channel', 'max') # let's pretend now that x is a batch of images # with 4 dims: batch=10, height=20, width=30, channel=40 >>> x = np.random.randn(10, 20, 30, 40) # 2d max-pooling with kernel size = 2 * 2 for image processing >>> y1 = reduce(x, 'b c (h1 h2) (w1 w2) -> b c h1 w1', 'max', h2=2, w2=2) # same as previous, using anonymous axes, # note: only reduced axes can be anonymous >>> y1 = reduce(x, 'b c (h1 2) (w1 2) -> b c h1 w1', 'max') # adaptive 2d max-pooling to 3 * 4 grid, # each element is max of 10x10 tile in the original tensor. >>> reduce(x, 'b c (h1 h2) (w1 w2) -> b c h1 w1', 'max', h1=3, w1=4).shape (10, 20, 3, 4) # Global average pooling >>> reduce(x, 'b c h w -> b c', 'mean').shape (10, 20) # subtracting mean over batch for each channel; # similar to x - np.mean(x, axis=(0, 2, 3), keepdims=True) >>> y = x - reduce(x, 'b c h w -> 1 c 1 1', 'mean') # Subtracting per-image mean for each channel >>> y = x - reduce(x, 'b c h w -> b c 1 1', 'mean') # same as previous, but using empty compositions >>> y = x - reduce(x, 'b c h w -> b c () ()', 'mean') ``` Parameters: tensor: tensor: tensor of any supported library (e.g. numpy.ndarray, tensorflow, pytorch). list of tensors is also accepted, those should be of the same type and shape pattern: string, reduction pattern reduction: one of available reductions ('min', 'max', 'sum', 'mean', 'prod', 'any', 'all'). Alternatively, a callable f(tensor, reduced_axes) -> tensor can be provided. This allows using various reductions like: np.max, np.nanmean, tf.reduce_logsumexp, torch.var, etc. axes_lengths: any additional specifications for dimensions Returns: tensor of the same type as input rz9Rearrange/Reduce/Repeat can't be applied to an empty list)rr)r%rlz2 Error while processing {}-reduction pattern "{}".z Input tensor shape: {}. z Input is list. zAdditional info: {}.z {}N)rsr@r>rrstack_on_zeroth_dimensionr)rtrgrrr rrr) r.rrrlr/hashable_axes_lengthsrgremessages r"r-r-sx7 fd # # *6{{a [\\\!&),,G66v>>FF!&))G %l&8&8&:&: ; ; f%%/uUaObObilmrisisttt VT&&11)Zo     777FMMiY`aa&$'' , 4;;EBB BGG + +G)00>>>'GNN1$5$556667sC:C== FBF  Fc "t||fddi|S)a einops.rearrange is a reader-friendly smart element reordering for multidimensional tensors. This operation includes functionality of transpose (axes permutation), reshape (view), squeeze, unsqueeze, stack, concatenate and other operations. Examples: ```python # suppose we have a set of 32 images in "h w c" format (height-width-channel) >>> images = [np.random.randn(30, 40, 3) for _ in range(32)] # stack along first (batch) axis, output is a single array >>> rearrange(images, 'b h w c -> b h w c').shape (32, 30, 40, 3) # stacked and reordered axes to "b c h w" format >>> rearrange(images, 'b h w c -> b c h w').shape (32, 3, 30, 40) # concatenate images along height (vertical axis), 960 = 32 * 30 >>> rearrange(images, 'b h w c -> (b h) w c').shape (960, 40, 3) # concatenated images along horizontal axis, 1280 = 32 * 40 >>> rearrange(images, 'b h w c -> h (b w) c').shape (30, 1280, 3) # flattened each image into a vector, 3600 = 30 * 40 * 3 >>> rearrange(images, 'b h w c -> b (c h w)').shape (32, 3600) # split each image into 4 smaller (top-left, top-right, bottom-left, bottom-right), 128 = 32 * 2 * 2 >>> rearrange(images, 'b (h1 h) (w1 w) c -> (b h1 w1) h w c', h1=2, w1=2).shape (128, 15, 20, 3) # space-to-depth operation >>> rearrange(images, 'b (h h1) (w w1) c -> b h w (c h1 w1)', h1=2, w1=2).shape (32, 15, 20, 12) ``` When composing axes, C-order enumeration used (consecutive elements have different last axis). Find more examples in einops tutorial. Parameters: tensor: tensor of any supported library (e.g. numpy.ndarray, tensorflow, pytorch). list of tensors is also accepted, those should be of the same type and shape pattern: string, rearrangement pattern axes_lengths: any additional specifications for dimensions Returns: tensor of the same type as input. If possible, a view to the original tensor is returned. rrr-r.rrls r"rr!s"n &' I I[ IL I IIr$c "t||fddi|S)a einops.repeat allows reordering elements and repeating them in arbitrary combinations. This operation includes functionality of repeat, tile, and broadcast functions. Examples for repeat operation: ```python # a grayscale image (of shape height x width) >>> image = np.random.randn(30, 40) # change it to RGB format by repeating in each channel >>> repeat(image, 'h w -> h w c', c=3).shape (30, 40, 3) # repeat image 2 times along height (vertical axis) >>> repeat(image, 'h w -> (repeat h) w', repeat=2).shape (60, 40) # repeat image 2 time along height and 3 times along width >>> repeat(image, 'h w -> (h2 h) (w3 w)', h2=2, w3=3).shape (60, 120) # convert each pixel to a small square 2x2. Upsample image by 2x >>> repeat(image, 'h w -> (h h2) (w w2)', h2=2, w2=2).shape (60, 80) # pixelate image first by downsampling by 2x, then upsampling >>> downsampled = reduce(image, '(h h2) (w w2) -> h w', 'mean', h2=2, w2=2) >>> repeat(downsampled, 'h w -> (h h2) (w w2)', h2=2, w2=2).shape (30, 40) ``` When composing axes, C-order enumeration used (consecutive elements have different last axis). Find more examples in einops tutorial. Parameters: tensor: tensor of any supported library (e.g. numpy.ndarray, tensorflow, pytorch). list of tensors is also accepted, those should be of the same type and shape pattern: string, rearrangement pattern axes_lengths: any additional specifications for dimensions Returns: Tensor of the same type as input. If possible, a view to the original tensor is returned. rrrrs r"rr[s"^ &' F FX F F FFr$r<ct|d}t||}|rt d|d|t |t |jkrZ|jr>t |t |jdz krt d|d|nt d|d||jrn|jt}|jd|d gt |t |jz dzzz|j|dzdz}n|j}i}t||D]y\}}t |d kr|dkrt d |d|4|\} t| tr | d kr||| <Y| j |krt d |d|z|S) a Parse a tensor shape to dictionary mapping axes names to their lengths. ```python # Use underscore to skip the dimension in parsing. >>> x = np.zeros([2, 3, 5, 7]) >>> parse_shape(x, 'batch _ h w') {'batch': 2, 'h': 5, 'w': 7} # `parse_shape` output can be used to specify axes_lengths for other operations: >>> y = np.zeros([700]) >>> rearrange(y, '(b c h w) -> b c h w', **parse_shape(x, 'b _ h w')).shape (2, 10, 5, 7) ``` For symbolic frameworks may return symbols, not integers. Parameters: x: tensor of any supported framework pattern: str, space separated names for axes, underscore means skip axis Returns: dict, maps axes names to their lengths Tallow_underscorez'Can't parse shape with composite axes:  rz2Can't parse shape with this number of dimensions: z7Can't parse shape with different number of dimensions: N_rzLength of axis is not 1: z)Length of anonymous axis does not match: )rrrghas_composed_axes RuntimeErrorr>rrrArziprsrfr) r<rexprg ellipsis_idxrr axesrr6s r" parse_shapers>4 7T : : :C NN  # #E XVWVVuVVWWW 5zzS))))   l5zzC001444"#iX_#i#ibg#i#ijjj5jY`jjchjjkk k &,,Y77 OM\M *es5zzC$8$881<= >olQ.001 2  o F e44 f fk t99>>a"#Pw#P#P#P#PQQQ FT$$$ f3;;#.F4L:,,&'dSZ'd'd]b'd'deee- Mr$c &t|}||}g}t|D]Z\}}dgt|z}|||<|||d||[|S)aa For an n-dimensional tensor, returns tensors to enumerate each axis. ```python x = np.zeros([2, 3, 4]) # or any other tensor i, j, k = _enumerate_directions(x) result = i + 2*j + 3*k ``` `result[i, j, k] = i + 2j + 3k`, and also has the same shape as result Works very similarly to numpy.ogrid (open indexing grid) rr)rrgrrr>rKrarange)r<r/rgr axis_idrs r"_enumerate_directionsrs!nnG MM!  E F )% 0 0NNc%jj $g goognnQ &D&DeLLMMMM Mr$cFt||S)z Convert a tensor of an imperative framework (i.e. numpy/cupy/torch/jax/etc.) to `numpy.ndarray` Parameters: tensor: tensor of any known imperative framework Returns: `numpy.ndarray`, converted to numpy )rto_numpy)r.s r"asnumpyrs  v   ' ' / //r$crt|dkrtdt|dkrtd|d}t|trtdt|dkrt dt|t st ddS)Nrz2Singleton () axes are not yet supported in einsum.rz3Shape rearrangement is not yet supported in einsum.z/Anonymous axes are not yet supported in einsum.z&Encountered empty axis name in einsum.z%Axis name in einsum must be a string.)r>r,rsrrrf)rs r"_validate_einsum_axis_namer s 9~~!"VWWW 9~~!"WXXX! I)]++U!"STTT 9~~CDDD i % %DBCCCDDr$cd|vrtd|d\}}d|dD}t|d}tj}d}i}g}|D]} d} | jD]k} | t kr| d z } t| | d} | |vr2|t|krtd |||| <|d z }| || z } l| | d |dz} |jD]O} | t kr| d z } t| | d} | |vrtd | d |d| || z } P| S)Nrz!Einsum pattern must contain '->'.c2g|]}t|ddS)T)rallow_duplicates)r)r5rs r"rmz2_compactify_pattern_for_einsum.. s) s s sVZ dTD Q Q Q s s sr$,Trrz...zToo many axes in einsum.rz Unknown axis z on right side of einsum .) ValueErrorrrstring ascii_lettersrrr r>rrKjoinr)r lefts_str right_strleftsrightoutput_axis_namesrMaxis_name_mapping left_patternsr left_pattern raw_axis_namercompact_patterns r"_compactify_pattern_for_einsumrs 7<==="==..Iy s s^g^m^mnq^r^r s s sE Y > > >E, AM++ !- 9 9M ))%  &} 5 5 5%a(I 111-....&'ABBB/@/C!),Q -i8 8LL\****hh}--4O* 8 8 I % % u $O "=111!!$ - - -\i\\RY\\\]] ],Y77 r$cdSr;r)r.rs r"einsumr!9s7:sr$tensor1tensor2cdSr;r)r"r#rs r"r!r!=sILr$tensor3cdSr;r)r"r#r%rs r"r!r!AsZ]Z]r$tensor4cdSr;r)r"r#r%r'rs r"r!r!Esknknr$tensors_and_patternct|dkrtd|d}t|tstd|dd}t |}t |dj|g|RS)a einops.einsum calls einsum operations with einops-style named axes indexing, computing tensor products with an arbitrary number of tensors. Unlike typical einsum syntax, here you must pass tensors first, and then the pattern. Also, note that rearrange operations such as `"(batch chan) out"`, or singleton axes `()`, are not currently supported. Examples: For a given pattern such as: ```python >>> x, y, z = np.random.randn(3, 20, 20, 20) >>> output = einsum(x, y, z, "a b c, c b d, a g k -> a b k") ``` the following formula is computed: ```tex output[a, b, k] = \sum_{c, d, g} x[a, b, c] * y[c, b, d] * z[a, g, k] ``` where the summation over `c`, `d`, and `g` is performed because those axes names do not appear on the right-hand side. Let's see some additional examples: ```python # Filter a set of images: >>> batched_images = np.random.randn(128, 16, 16) >>> filters = np.random.randn(16, 16, 30) >>> result = einsum(batched_images, filters, ... "batch h w, h w channel -> batch channel") >>> result.shape (128, 30) # Matrix multiplication, with an unknown input shape: >>> batch_shape = (50, 30) >>> data = np.random.randn(*batch_shape, 20) >>> weights = np.random.randn(10, 20) >>> result = einsum(weights, data, ... "out_dim in_dim, ... in_dim -> ... out_dim") >>> result.shape (50, 30, 10) # Matrix trace on a single tensor: >>> matrix = np.random.randn(10, 10) >>> result = einsum(matrix, "i i ->") >>> result.shape () ``` Parameters: tensors_and_pattern: tensors: tensors of any supported library (numpy, tensorflow, pytorch, jax). pattern: string, einsum pattern, with commas separating specifications for each tensor. pattern should be provided after all tensors. Returns: Tensor of the same type as input, after processing with einsum. rzd`einops.einsum` takes at minimum two arguments: the tensors (at least one), followed by the pattern.r2z^The last argument passed to `einops.einsum` must be a string, representing the einsum pattern.Nr)r>rrsrfrrr!)r)rtensorss r"r!r!Is@ 1$$ r   ""%G gs # #  l   "#2#&G,W55G );wqz " " )' functoolsrrtyping collectionsrrrrrrr r r r r TYPE_CHECKINGnumpynprr _backendsrparsingrrrrreReductionCallablerf ReductionSizer*rrr#r0rS CookedRecipeHashableAxesLengthsFakeHashableAxesLengthsrUr lru_cacherrrrrr-rrdictrr np_ndarrayrr roverloadr!rr$r"r>su ######XXXXXXXXXXXXXXXXXXXXXXXX """"""??????????   feCHo6>? #(( )  zA tCyS K K$s) K K K K4D4D4DnXd3i((49*=tCy$sTWx.ZbcghkclZmorrs E#s(OS01uS#X/&L&L&L&L&L&L&L&LREk Ek"&s)Ek8OEkEkEkEkEkP4-)-d334TUU$.4FO_r 2)/AJZm DSX XXc3hX  X  XXXXv n  n& n49#s(O n #  n n n nR75f-.R7R7R7dhR7msR7R7R7R7j7JeFDL017JC7JQU7JZ`7J7J7J7Jt/G5f-./G/Gd/GW]/G/G/G/Gd;6;C;D;;;;~.  0F 0z 0 0 0 0 D D D S2C2C2222j:6:C:v::::LFLVLcLLLLL]F]V]f]s]RX]]]]nFnVnfnvnX[ncinnnnK=vs{!3K=K=K=K=K=K=K=r$