j jddlZddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZmZejrddlZddlmZddlmZddlmZmZmZe dZeee ed fgefZeeefZ ejZ!d Z"d Z#d Z$d e edefdZ%de de efdZ&dZ'e e e ee e ee eeeefe e eefZ(e e eefd fZ)e e eefZ*GddZ+de+de ede*de(fdZ,ej-de,Z.de+dede de)def dZ/de+dede de)def dZ0ej-d d!ed"e d#e ed fd$ede+f d%Z1d!ed"e d#e ed fdeee+ffd&Z2ede ed!ed'e de!def d(Z3eded!ed'e de!def d)Z3deee efd!ed'e de!def d*Z3ede ed!ede!defd+Z4eded!ede!defd,Z4deee efd!ede!defd-Z4ede ed!ede!defd.Z5eded!ede!defd/Z5deee efd!ede!defd0Z5d1ed!ede6fd2Z7d3Z8eZ9dede9fd4Z:d5Z;ej-d d!edefd6ZZ=d?eeefdefd@Z=dS)AN) OrderedDict) AnyCallableDictListOptionalSetTupleTypeVarUnioncastoverload) EinopsError) get_backend) AnonymousAxisParsedExpression _ellipsisTensor.)minmaxsummeanprodanyalliiaysequencereturncd}|D]}||z}|S)zSminimalistic product that works both with numbers and symbols. Supports empty listsr)rresultelements >C:\Projects\Historical\venv\Lib\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_axesr1%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 )r6xs r#r8zB_optimize_transformation..build_mapping..Hs&%T%Tatm%T%T%T%T%T%Tr%)rangelenrvalueslistindex) init_to_finalr7after_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 )r6r=r's r#r8z+_optimize_transformation..Vs(.b.bq /D.b.b.b.b.b.br%c32K|]}|kr|n|dz VdSr5r )r6r7 removed_axiss r#r8z+_optimize_transformation..Xs5 d dt )<)<$( d d d d d dr%)r?r*sortedr>rappend) rFr'rE final_shapesiremoved_lengthrGinit_axis_to_final_axis init_axisremoved_axis_after_reductionold_reorderingr7rJs ``` @r#_optimize_transformationrT2s   #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%rVr`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|] }| Sr r )r6elementary_axis axes_lengthss r# z4_reconstruct_from_shape_uncached..sQQQ_<0QQQr%c(i|]\}}||Sr r )r6pospos_in_elementaryrms r# z4_reconstruct_from_shape_uncached..s3"""1G6G\+ ,"""r%)rArWrX enumeraterYr? isinstancerfrrZr]rLr$r\itemsr>r[)r`rhrineed_init_reshaper7dim input_axis known_axes unknown_axeslength known_product unknown_axisinferred_lengthrFneed_final_reshaperMgroupinglengthsr\r'n_axes_after_adding_axesrE _final_shapesrms @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/rmc  t||||\}}}}} } n=#t$r0t||||} | \}}}}} } YnwxYw||||}||||}t |dkrt||||}t |dkr||| |}| ||| }|S)Nr)r&r'r0)n_axespos2len) _reconstruct_from_shaperh TypeErrorrreshape transposer?r1add_axes) r0rr/r&rmrFrEr'r\rMn_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)r7) rrhr permute_dimsr?r)r*r+getattrru expand_dimsrA broadcast_to)xprr/r&rmrFrEr'r\rMr axis_position _axis_length final_shape axis_lengths r#_apply_recipe_array_apirs\s l\\XK, L.FK00"99 <1 N # # S#^FE,,?,?@@FF"[00000WR00eL>Q>QRRRF :+5+;+;+=+= @ @ 'M<^^F^??FF6<(( *4*:*:*<*< 5 5 &M;)4K & &55FL11 Mr%pattern operation axes_namesndimc   !"|d\}}t| t|" js"jrtd| jr jrtd||dkri js"jrtdt  j"j}t|dkrtd|n*|dkrt j"j}t|dkrtd |t d "jDh j|}t|dkrtd |n|tvst|rNt "j j}t|dkrtd |d |ntd|dtd jrt j dz }||krtd|d|d||z } dt| D} g} j D]>} | tkr| D]} | | g)| | ?g}"j D]{} | tkr| D]} || g)g}| D]8} | tkr|| #|| 9||| j|  jt"jr9"j| "jtnN|t j kr(tdt j d|d j } "j }t)| D]1} | D],}t+|t,r |j|<"t0|<-2g}"jD]E}|vr?t+|t,r |j|<n t0|<||Fdt3D|D]G}tj|std||vrtd|dt6|<Hg}| D]} fd| D}fd| D}t|dkrtd|t|t|zt| ksJ|fd|Dfd|Dfi}t9j| D]}|"jvrt|||<fd t3|D}t=t9j| !t=t9j|}"fd!!D} fd"|D|z}!fd#|D} fd$t3|D}t|t|z }t?t= 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)rz@Identifiers only on one side of expression (should be on both): repeatz3Unexpected identifiers on the left side of repeat: c<h|]}t|t|Sr )rtr)r6axs r# z1_prepare_transformation_recipe..?s' P P PB*R2O2O PR P P Pr%z&Specify sizes for new axes in repeat: z3Unexpected identifiers on the right side of reduce z: zUnknown reduction z. Expect one of .rzWrong shape: expected >=z dims. Received z -dim tensor.c<g|]}tt|zSr )rrg)r6rNs r#rnz2_prepare_transformation_recipe..Ps#EEE1IA&EEEr%zWrong shape: expected ci|]\}}|| Sr r )r6positionnames r#rrz2_prepare_transformation_recipe..saaa^Xt$aaar%zInvalid name for an axiszAxis z is not used in transformc6h|]}|tk|Sr _unknown_axis_lengthr6r7axis_name2known_lengths r#rz1_prepare_transformation_recipe..s+sssD>TUY>Z^r>r>r4>r>r>rr%c6h|]}|tk|Sr rrs r#rz1_prepare_transformation_recipe..s+uuud@VW[@\`t@t@tT@t@t@tr%zCould not infer sizes for c g|] }| Sr r r6r7axis_name2positions r#rnz2_prepare_transformation_recipe..s 9 9 94 & 9 9 9r%c g|] }| Sr r rs r#rnz2_prepare_transformation_recipe..s ;i;i;iY]..s===d D !===r%r )r6rNcomposite_axisrs r#rnz2_prepare_transformation_recipe..s?---BS!^====n===---r%c&g|] }|jv |Sr  identifiers)r6r7rghts r#rnz2_prepare_transformation_recipe..s&WWWT$dFV:V:VD:V:V:Vr%c&g|] }|jv |Sr r)r6r7lefts r#rnz2_prepare_transformation_recipe..s& ` ` `$ttO_G_G_G_G_G_r%c:g|]}|Sr )rB)r6r7ordered_axis_lefts r#rnz2_prepare_transformation_recipe..s(\\\$)//55\\\r%c:i|]\}}|jv||Sr r)r6rN axis_namerrs r#rrz2_prepare_transformation_recipe..s= Ay D, , , i ( , , ,r%c"i|] }|| Sr r rs r#rrz2_prepare_transformation_recipe..s!"Y"Y"Yd4);D)A"Y"Y"Yr%r_)!splitr has_ellipsisrhas_ellipsis_parenthesizedhas_non_unitary_anonymous_axessetsymmetric_differencerr? differencer+r) compositionr>rrLextendupdateremoverrtrvaluerrscheck_axis_name_expected_axis_length itertoolschainrArVr@)#rrrrleft_strrght_strraxes_without_size n_other_dims ellipsis_ndimell_axesleft_compositionrr7rght_compositiongrouprrepeat_axes_namesrlinput_axes_known_unknownknownunknownaxis_position_after_reductionresult_axes_groupingordered_axis_rghtr'order_after_transpositionrZr\r[rrrrrs# @@@@@r#_prepare_transformation_reciper!s!t,,Hh H % %D H % %D  e!2ecZaccddd eT<ecZaccdddK  . s$2U sqrr r--d.>@PQQ z??Q  makmmnn n  h  ^^D$4d6FGG z??Q  `T^``aa aNN P P$* P P P ,d , ,    ! !A % %ZGXZZ[[ [ & k ! !Xi%8%8 !^^D$4d6FGG z??Q  mT]mmakmmnn n XyXX+XXXYYY %,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 8PoPPPQQ Q2G//!*  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)r6 ellipsis_dimsrs r#rnz1_prepare_recipes_for_all_dims..s.XXXmD$%%)M9XXXr%c 8i|]}|t|S))r)r)r6rrrrs r#rrz1_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 dSr<r r/rrrms r#r.r.sfifir%c dSr<r rs r#r.r.s`c`cr%c  t|trMt|dkrtdt |d}||}nt |}t |}||}t||t |t|}t||tt|||S#t$rQ}d|d|d} t|ts | d|d z } n| d z } | d |d z } t| d |zdd}~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&rmz Error while processing z-reduction pattern "z".z Input tensor shape: z. z Input is list. zAdditional info: rz N)rtrAr?rrstack_on_zeroth_dimensionr*rurhrrr rr) r/rrrmr0hashable_axes_lengthsrhremessages r#r.r.sx9 fd # # *6{{a [\\\!&),,G66v>>FF!&))G %l&8&8&:&: ; ; f%%/uUaObObilmrisisttt VT&&11)Zo     999WYWWGWWW&$'' , :::: :GG + +G6|6666'I!II-..D89sC:C== EA EEc dSr<r r/rrms r#rr)sSVSVr%c dSr<r rs r#rr-sMPSr%c "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.rs r#rr1s"n &' I I[ IL I IIr%c dSr<r rs r#rrksPSPSr%c dSr<r rs r#rrosJM#r%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, i.e. upsample an image by 2x >>> repeat(image, 'h w -> (h h2) (w w2)', h2=2, w2=2).shape (60, 80) # 'pixelate' an 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#rrss"^ &' 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: )rrrhhas_composed_axes RuntimeErrorr?rrrBrziprtrgr) r=rexprh ellipsis_idxrr!axesrr7s r# parse_shaper s>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)rrhrsr?rLrarange)r=r0rhr!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-rtrrrg)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)r6rs r#rnz2_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 r) ValueErrorrrstring ascii_lettersrrrr?rrLjoinr)r lefts_str right_strleftsrightoutput_axis_namesrNaxis_name_mapping left_patternsr left_pattern raw_axis_namercompact_patterns r#_compactify_pattern_for_einsumr's 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)Qs7:sr%tensor1tensor2cdSr<r )r*r+rs r#r)r)UsILr%tensor3cdSr<r )r*r+r-rs r#r)r)YsZ]Z]r%tensor4cdSr<r )r*r+r-r/rs r#r)r)]sknknr%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.r3z^The last argument passed to `einops.einsum` must be a string, representing the einsum pattern.Nr)r?rrtrgr'rr))r1rtensorss r#r)r)as~ 1$$ r   ""%G gs # #  l   "#2#&G,W55G );wqz " " )' functoolsrrtyping collectionsrrrrrrr r r r r r TYPE_CHECKINGnumpynprr _backendsrparsingrrrrrfReductionCallablerg ReductionSizer+rrr$r1rT CookedRecipeHashableAxesLengthsFakeHashableAxesLengthsrVr lru_cacherrrrrr.rrdictr r np_ndarrayrrr'r)r r%r#rEs ######bbbbbbbbbbbbbbbbbbbbbbbbbb """"""??????????   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 n i4<i#i)iUYi^diii i c6cCcIctcX^ccc cR95f-.R9R9R9dhR9msR9R9R9R9j Vd6lVSV$V6VVV V PfPsPDPVPPP P7JeFDL017JC7JQU7JZ`7J7J7J7Jt S4<S#StSSSS S M6MCMM&MMM M/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[ncinnnnJ=vs{!3J=J=J=J=J=J=J=r%