i ddlZddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZmZej"rddlZddlmZddlmZddlmZmZmZe dZeee ed fgefZeeefZ ej Z!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,ejZde,Z.de+dede de)def dZ/de+dede de)def dZ0ejZd 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;ejZd d!edefd6ZZ=d?eeefdefd@Z=y)AN) OrderedDict) AnyCallableDictListOptionalSetTupleTypeVarUnioncastoverload) EinopsError) get_backend) AnonymousAxisParsedExpression _ellipsisTensor.)minmaxsummeanprodanyalliiaysequencereturnc"d}|D]}||z} |S)zSminimalistic product that works both with numbers and symbols. Supports empty listsr)rresultelements b/Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/einops/einops.py_productr$s F' Mreduction_type reduced_axesct|r||t|S|tvsJ|dk(r|j|s t d|j ||t|S)Nrz5reduce_mean is not available for non-floating tensors)callabletuple _reductions is_float_typeNotImplementedErrorreduce)tensorr&r'backends r# _reduce_axesr1%sffeL&9::,,, V #((0)*abb~~fneL6IJJr%cb ttztk(sJttttdz dddD]`}|dz|dzk(s|dz }d  dzdz dz xx|zcc<d|dztd|dzdDzbfd}|}ttdz dddD]}|| ||dz||dz||dzk(s$|dz }t fdt D} t fdDd  dzdz dz xx|zcc<} g| D]3} | | k(r | | krj |  j | dz 5|}|fS)Nrc3&K|] }|dz  ywrNr ).0axiss r# z+_optimize_transformation..?s8dNcdNcsci}ttD]I}|vrd||< td|jD}t j |||<K|S)Nc3$K|]}|du ywNr )r6xs r#r8zB_optimize_transformation..build_mapping..Hs%T=Satm=Ss)rangelenrvalueslistindex) init_to_finalr7after_reductionaxes_reordering init_shapesr's r# build_mappingz/_optimize_transformation..build_mappingBsi #k*+D|#&* d#"%%T]=Q=Q=S%T"T&*?&;&A&A/&R d# , r%c3&K|]}|v ywr<r )r6r=r's r#r8z+_optimize_transformation..Vs.bNaq /DNasc36K|]}|kr|n|dz ywr5r )r6r7 removed_axiss r#r8z+_optimize_transformation..Xs$ dWct )<$(!JWcs)r?r*sortedr>rappend) rFr'rE final_shapesiremoved_lengthrGinit_axis_to_final_axis init_axisremoved_axis_after_reductionold_reorderingr7rJs ``` @r#_optimize_transformationrT2s0  #l"3 3s;7G GG G -.L 3|$q( )$B$ / ?Q ,q1u"5 5'A.L(6N%m|4{L*.eDItCy4H.I)JLs)L L"cN#L( $DI)Lr%rVr`shape axes_dimscd}t|j}|D]\}}|||j|<t|jD]\}\}} ||} t |dk(rt | dk(r | || d<3d} |D] }| ||z} t | dk(r6t | trnt | tr^| | k7rYtd| d| t | tr)t | tr| | zdk7rtd| d| | d} | | z} | || <t |t | zdk7sd}|r|d t |jnd }d}g}|jD]?}|Dcgc]}|| }}|jt|t |dk7s>d}A|jjDcic] \}}||| }}}tt|j t |j}t |t |jz}|j}|jttt |jk(rd }|r|nd }||||||fScc}wcc}}w) 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 TN)rArWrX enumeraterYr? isinstancerfrrZr]rLr$r\itemsr>r[)r`rhrineed_init_reshape axes_lengthsr7dim input_axis known_axes unknown_axeslength known_product unknown_axisinferred_lengthrFneed_final_reshaperMgroupingelementary_axislengthspospos_in_elementaryr\r'n_axes_after_adding_axesrE _final_shapess r# _reconstruct_from_shape_uncachedrs#4#?#?@L c=@ T33D9:3ireciper/roc t||j||\}}}}} } ||j ||}||j ||}t |dkDrt||||}t |dkDr|j|| |}| |j || }|S#t$r(t||j||} | \}}}}} } YwxYw)Nr)r&r'r0)n_axespos2len) _reconstruct_from_shaperh TypeErrorrreshape transposer?r1add_axes) r0rr/r&rorFrEr'r\rMn_axes_w_added_results r# _apply_recipersi_v GMM&)<` \ _lJ n5"""6?; <1f^R^hop :!!&!T6 M i267==;PR^_ah^o|Z~is#B"".CCcZt||j|\}}}}} } ||j||}||j||}t |dkDrEt |r||t |}n'|tvsJt|||t |}t |dkDro|jD]\} } |j|| }t|j} |jD] \} }|| | < |j|| }| |j|| }|S)Nr)r7) rrhr permute_dimsr?r)r*r+getattrrm expand_dimsrA broadcast_to)xprr/r&rorFrEr'r\rMr axis_position _axis_length final_shape axis_lengths r#_apply_recipe_array_apirs<\s l\XK, L.FK0"9 <1 N ##FE,,?@F"[0 000WR0eL>QRF :+5+;+;+= 'M<^^F^?F,>6<<( *4*:*:*< &M;)4K &+=5FL1 Mr%pattern operation axes_namesndimc |jd\}}t|}t|}|js|jrtd||jr|jrtd||dk(rj|j s |j r tdt j|j|j}t|dkDr4td||dk(rt j|j|j}t|dkDrtd |t j|jD chc]} t| tr| c} h|j|} t| dkDrtd | |tvs t|rIt j|j|j}t|dkDr'td |d |td |dtd|jrt|jdz } || krtd| d|d|| z } t!| D cgc]} t"t%| z}} g}|jD]6}|t"k(r|D]}|j'|g&|j'|8g}|jD]k}|t"k(r|D]}|j'|g&g}|D].}|t"k(r|j)||j'|0|j'|m|jj+||jj-t"|jr|jj+||jj-t"nU|t|jk7r%tdt|jd|d|j}|j}t/}|D]2}|D]+}t|tr|j0||<#t2||<-4g}|jD]A}||vst|tr|j0||<n t2||<|j'|Ct5|Dcic]\}}|| }}}|D]?}tj6|s td|||vrtd|dt8||<Ag}|D]}|Dchc]}||t2k7s|}}|Dchc]}||t2k(s|}}t|dkDrtd|t|t|zt|k(sJ|j'|Dcgc]}|| c}|Dcgc]}|| c}fi}t;j<|D]}||jvst|||<!t5|D cgc]\} }|Dcgc]}|| c}}}} }t?t;j<|} t?t;j<|}!| Dcgc]}||jvs|}"}|!Dcgc]}||jvs|c}|"z}#|#Dcgc]}| jA|}$}t5|!D cic]\} }||jvr| ||}%} }t|#t|"z }&tCt?|jE|Dcic]}||| c}||$|&|%|Scc} wcc} wcc}}wcc}wcc}wcc}wcc}wcc}wcc}}} wcc}wcc}wcc}wcc}} wcc}w)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: 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.zWrong shape: expected zInvalid name for an axiszAxis z is not used in transformzCould not infer sizes for r_)#splitr has_ellipsisrhas_ellipsis_parenthesizedhas_non_unitary_anonymous_axessetsymmetric_difference identifiersr? differencerlrr+r) compositionr>rrgrLextendupdateremovervalue_unknown_axis_lengthrkcheck_axis_name_expected_axis_length itertoolschainrArBrVr@)'rrrrleft_strrght_strleftrghtraxaxes_without_size n_other_dims ellipsis_ndimrNell_axesleft_compositioncomposite_axisr7rght_compositiongroupaxis_name2known_length axis_namerepeat_axes_namespositionnameaxis_name2positionrzinput_axes_known_unknownknownunknownaxis_position_after_reductionresult_axes_groupingordered_axis_leftordered_axis_rghtr'order_after_transpositionrZr\r[s' r#_prepare_transformation_reciper!s!t,Hh H %D H %D   !2!2YZaYbcdd T<<YZaYbcddK  . .$2U2Uqr r--d.>.>@P@PQ z?Q  `ak`lmn n h ^^D$4$4d6F6FG z?Q  ST^S_`a aNN** P*B*R2OR* P ,d , ,   !A % FGXFYZ[ [ k !Xi%8^^D$4$4d6F6FG z?Q  ST]S^^`ak`lmn n.yk9I+VWXYY 4++,q0 ,  8FVW[V\\hij j|+ 05m0DE0D1IA&0DE"..N*$D$++TF3%!''7 /"..N*$D$++TF3%*Dy( X. T* + !''./ )  *       # #H -    # #I . 3t''( ( 6s4;K;K7L6MM]^b]ccopq q++++DO=*'I)]34=OO&y14H&y1 (+%% 2 2)]34=OO&y14H&y1  $ $Y / &@II_?`a?`^Xt$.?`a&//@8/J J "8 8o%66OPQ Q2G/ & "*,:sND>TUY>Z^r>r4Ns.<und@VW[@\`t@tTnu w?@Y__.>?@%6W%6T$dFVFV:VD%6LW2C `2C$ttO_O_G_2C `co oB[\B[$)//5B[\&&788LAy D,, , i ((8 67#l:KK  $%;%B%B%D ENX"Yjd4);D)A#Aj"Y(@)-2 g Q"Flbtu :;i >- X `\#Zs~\5$\5\:/ \?] ]*] <]  ] $ ] ? ] ]]]%.]%8]* ]*]/]4 ]: ]c 6|jd\}}t|}t|jg}|jr1t dDcgc]}t|jdz |z}}|Dcic]}|t ||||c}Scc}wcc}w)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 rr)r)rrr?rrr>r) rrrrrrdims ellipsis_dimsrs r#_prepare_recipes_for_all_dimsrs!t,Hh H %D   ! "D OTUVxXxmD$$%)M9xXhl mhl`dD0)ZVZ[ [hl mmY ms "B7B reductionc yr<r r/rrros r#r.r.sfir%c yr<r rs r#r.r.s`cr%c & t|tr9t|dk(r tdt |d}|j |}n t |}t |j}|j|}t||t |t|}t||tt|||S#t$rH}d|d|d} t|ts | dd 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&roz Error while processing z-reduction pattern "z".z Input tensor shape: z. z Input is list. zAdditional info: rz N)rlrAr?rrstack_on_zeroth_dimensionr*rmrhrrr rr) r/rrror0hashable_axes_lengthsrhremessages r#r.r.s.x9 fd #6{a [\\!&),G66v>F!&)G %l&8&8&: ; f%/uUaObilmrist VT&&1)Zo   9,YK7KG9TVW&$' 0r: :G + +G&|nA66'c!I-.D89sB>> 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#rr1sn &' I[ IL IIr%c yr<r rs r#rrksPSr%c yr<r rs r#rrosJMr%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^ &' FX F FFr%r=cxt|d}t|j|}|jrt d|d|t |t |j k7rR|jr5t |t |j dz kr"t d|d|t d|d||jrk|j jt}|j d|d gt |t |j z dzzz|j |dzdz}n |j }i}t||D]j\}}t |d k(r|dk7st d |d||\} t| tr | d k7sE||| <K| j|k7s[t d |d||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?rrrBrziprlrgr) r=rexprh ellipsis_idxrr!axesrr7s r# parse_shapers4 7T :C N  #E DWIQugVWW 5zS))   5zC0144"%WX_W``abgah#ijj!XY`Xaabchbijk k ,,Y7 OOM\ *es5zC$881<= >oolQ.01 2  oo F e4k t9>a"%>wiq#PQQFT$$3;#.F4L::,&)RSZR[[\]b\c'dee5 Mr%c t|}|j|}g}t|D]J\}}dgt|z}|||<|j |j |j d||L|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)rrhrkr?rLrarange)r=r0rhr!axis_idrs r#_enumerate_directionsrsv!nG MM! E F )% 0c%j $g goognnQ &DeLM!1 Mr%c6t|j|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%ct|dk(r tdt|dkDr td|d}t|tr tdt|dk(r t dt|t s t dy)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-rlrrrg)rs r#_validate_einsum_axis_namer s 9~!"VWW 9~!"WXX! I)]+!"STT 9~CDD i %BCC &r%cd|vr td|jd\}}|jdDcgc]}t|dd}}t|d}tj}d}i}g} |D]w}d} |j D]S} | t k(r| d z } t| | d} | |vr&|t|k\r td |||| <|d z }| || z } U| j| ydj| dz} |j D]?} | t k(r| d z } t| | d} | |vrtd | d |d| || z } A| Scc}w)Nrz!Einsum pattern must contain '->'.,T)rallow_duplicatesrrz...zToo many axes in einsum.rz Unknown axis z on right side of einsum r) ValueErrorrrstring ascii_lettersrrrr?rrLjoinr)r lefts_str right_strrleftsrightoutput_axis_namesrNaxis_name_mapping left_patterns left_pattern raw_axis_namercompact_patterns r#_compactify_pattern_for_einsumr s 7<=="==.Iy^g^m^mnq^r s^rVZ dTD Q^rE s Y >E,, AM !--M )%  &} 5%a(I 11-..&'ABB/@/C!),Q -i8 8L. \*!$hh}-4O** I % u $O "=1!!$ - - i[8QRYQZZ[\] ],Y77+ W tsEcyr<r )r/rs r#einsumrQs7:r%tensor1tensor2cyr<r )rrrs r#rrUsILr%tensor3cyr<r )rrrrs r#rrYsZ]r%tensor4cyr<r )rrrrrs r#rr]sknr%tensors_and_patternct|dkr td|d}t|ts td|dd}t |}t |dj |g|S)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?rrlrgr rr)rrtensorss r#rras~ 1$ r  ""%G gs # l  "#2&G,W5G );wqz " ) )' functoolsrrtyping collectionsrrrrrrr r r r r r TYPE_CHECKINGnumpynprr _backendsrparsingrrrrrfReductionCallablerg ReductionSizer+rrr$r1rT CookedRecipeHashableAxesLengthsFakeHashableAxesLengthsrVr lru_cacherrrrrr.rrdictrr np_ndarrayrrr rr r%r#r+sd #bbbb "??  feCHo6>? #(( )  zzA tCyS K K$s) K4DnXd3i((49*=tCy$sTWx.ZbcghkclZmorrs E#s(OS01uS#X/&L&LREk Ek"&s)Ek8OEkEkP4-)--d34TU$.4FO_r 2)/AJZm DSX XXc3hX  X  XXv n  n& n49#s(O n #  n i4<i#i)iUYi^di i c6cCcIctcX^c cR95f-.R9R9R9dhR9msR9j Vd6lVSV$V6V V PfPsPDPVP P7JeFDL017JC7JQU7JZ`7Jt S4<S#StSS S M6MCMM&M M/G5f-./G/Gd/GW]/Gd;6;C;D;~.  0F 0z 0 D S2C2C22j:6:C:v::LFLVLcLLL]F]V]f]s]RX]]nFnVnfnvnX[ncinnJ=vs{!3J=J=r%