Pi> ddlZddlmZddlmZddlZddlmZm Z ddl mZ ej dd8dZ ejd d d Zejjej d dd d dedejdede ejedfdede jdejfdZee_ejjdd d dedejde ejedfdede jdejf dZdZejjdd d dedejde ejedfdede jdejf dZdZejjdd d dedejde ejedfdede jdejf dZdZejjdd d dedejde ejedfdede jdejf dZdZejjdd d dedejde ejedfdede jdejf dZ dZ!ejjdd d dedejde ejedfdede jdejf d Z"d!Z#ejjdd d dedejde ejedfdede jdejf d"Z$d#Z%ejjdd d dedejde ejedfdede jdejf d$Z&d%Z'ejjdd d dedejde ejedfdede jdejf d&Z(d'Z)ejjdd d dedejde ejedfdede jdejf d(Z*d)Z+ejjdd d dedejde ejedfdede jdejf d*Z,d+Z-ejjdd d dedejde ejedfdede jdejf d,Z.d-Z/ejjdd d dedejde ejedfdede jdejf d.Z0d/Z1ejjdd d dedejde ejedfdede jdejf d0Z2d1Z3ejjdd d dedejde ejedfdede jdejf d2Z4d3Z5ejjdd d dedejde ejedfdede jdejf d4Z6d5Z7ejjdd d dedejde ejedfdede jdejf d6Z8d7Z9dS)9N)util)partial)CallableUnioncdfd S)Nc8|fd|D||S)Nc&g|] }|Sr .0xts g/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/einx/op/elementwise.py z..... s!,,,A11Q44,,,r )exprs_in tensors_inexpr_outopbackendcrs rz.. s5PQPQ,,,,,,,hQQrNr rrs``rrr s$r)tracecn t||gzD]L}|D]5}t|tjjjrtd6Mtd|DrJtd|DrJd  fdt||D} |}tj |||g\}}t|dkrt|dksJ|d|dfS) NzConcatenation not allowedc3K|]?}|D](}tjj|V)@dSr)alleinxexprstage3 is_marked)r rootr!s r z%elementwise_stage3..sO``UYU]U]U_U_``T49#--d33```````rc3^K|](}tjj|V)dSr)r r!r"r#r r!s rr%z%elementwise_stage3..s5OO49#--d33OOOOOOrc&|dkrdS|dkrdS|S)Naddbiasmultiplyscaler )ss rget_namez$elementwise_stage3..get_names# ::6 *__7Hrc g|][\}}tj||jt jt j\S))nameinit)r tracer call_factoryshaper _op_to_str)r tensorr!rr.rs rrz&elementwise_stage3.. su    FD    J $/"--..$$ !     rrrr) listr isinstancer r!r" Concatenation ValueErroranyzip all_to_tensorvmap_with_axis_stage3len) rrrrrr$r! tensors_out exprs_outr.s `` @relementwise_stage3rC s X(+>>HHJJ > >D$ 0 >?? > !<=== > >````````` `OO OOOOOOO O       H55   J&&z22J!7*xj"gK {  q S^^q%8%8%8 8 q>9Q< ''rT)csec tjj||\}}tjj|}t|ddkrt|dkrtjjtjj tjj |ddtjj |ddggt|ddz}t|dkr'|d}d|D}t}t|D]R\}} t|D]"\} } || kr| | sn#|||St|dkrt#d|dt%t'|} tjj|dtjj | gg}t|dt|kr5t#dt|ddt|t|ddkr%t#d t|dtjd t-|d|Dtj|ddgzd |Dz|d dt|ddz} | dd| d} }|| fS)NrrcJg|] }d|D!S)cdh|]-}t|tjjj&|j.Sr )r9r r!stage1 NamedAxisr0r's r z#parse...Ms1 ^ ^ ^4D$)BRB\1]1] ^TY ^ ^ ^r)r)r r$s rrzparse..Ls?    _ ^488:: ^ ^ ^   rz9Could not implicitly determine output expression for op ''z Expected z input tensors, but got z&Expected 1 output expression, but got cTg|]%\}}tj||&Sr )r r!Equation)r expr_in tensor_shapes rrzparse..es>   % I  w 5 5   rcg|]L\}}tj|tj|dtjfddMS).N)depth1depth2)r r!rNnpasarraynewaxis)r kvs rrzparse..nsY   1 I  q"*Q--RZ"@VZ  [ [   rF)rD cse_concat)r rr!_clean_description_and_parametersr!rIparse_opr@OpArgsdemark get_markedr8set enumerateissubsetr)r;nextiter __deepcopy__solver=rNitems) descriptionrD tensor_shapes parametersr input_args in_axis_names valid_parentsiparentjchildrexprsrs rparsert3s"glLLZK   " "; / /B 2a5zzQ3}--22 Y    %%I$++BqE!H55I$//1a99'  2abb6ll     2ww!||U   "    "=11 1 1IAv%m44 1 1566%.."8"86E!!*Q-000 }   " "^Y[^^^__ _]++,,99;; Y  "Q%)9)>)>z)J)J!K L L 2a5zzS'''']SAZZ]]]I[I[]]^^^ 2a5zzQN#be**NNOOO IOO  ),RUM)B)B   I  1a      "((**         BqE Q! E"ssU2YhH X rcddfd S)Nr7c4|gfd|DRi|S)Nc&g|] }|Sr r r s rrz.....}s!---qqtt---rr )rirtensorskwargsrrs rrz..|sJQQN----W---NNN17NNrr rs``rrr|s+Tr)rrDrirxrrrDrkreturncrt|gd|DRd|i|\}}t|||||\}}|S)a~ Applies an element-by-element operation over the given tensors. It supports the following shorthand notation: * The output is determined implicitly if one of the input expressions contains the named axes of all other inputs and if this choice is unique. | Example: ``a b, a`` expands to ``a b, a -> a b``. | Example: ``b a, b, a`` expands to ``b a, b, a -> b a``. | Example: ``a b, b a`` raises an exception. | Example: ``a b, a b`` expands to ``a b, a b -> a b``. * Bracket notation can be used when passing two input tensors to indicate that the second input is a subexpression of the first. Example: ``a [b]`` expands to ``a b, b``. Args: description: Description string for the operation in einx notation. tensors: Input tensors or tensor factories matching the description string. op: Backend elemebt-by-element operation. Must accept the same number of tensors as specified in the description string and comply with numpy broadcasting rules. If ``op`` is a string, retrieves the attribute of ``backend`` with the same name. backend: Backend to use for all operations. If None, determines the backend from the input tensors. Defaults to None. cse: Whether to apply common subexpression elimination to the expressions. Defaults to True. graph: Whether to return the graph representation of the operation instead of computing the result. Defaults to False. **parameters: Additional parameters that specify values for single axes, e.g. ``a=4``. Returns: The result of the elementwise operation if ``graph=False``, otherwise the graph representation of the operation. Examples: Compute a sum of two vectors: >>> a, b = np.random.uniform(size=(10,)), np.random.uniform(size=(10,)) >>> einx.elementwise("a, a -> a", a, b, op=np.add).shape (10,) Add a vector on all columns of a matrix: >>> a, b = np.random.uniform(size=(10, 10)), np.random.uniform(size=(10,)) >>> einx.add("a b, a -> a b", a, b).shape (10, 10,) Subtract a vector from all rows of a matrix: >>> a, b = np.random.uniform(size=(10, 10)), np.random.uniform(size=(10,)) >>> einx.subtract("a b, b -> a b", a, b).shape (10, 10,) Select from one of two choices according to a boolean mask: >>> x, mask = ( ... np.random.uniform(size=(10, 10)), ... np.random.uniform(size=(10,)), ... ) >>> einx.where("a, a b, -> a b", mask, x, 0).shape (10, 10,) Add a bias onto all channels of a tensor: >>> x, w = ( ... np.random.uniform(size=(4, 16, 16, 64)), ... np.random.uniform(size=(64,)), ... ) >>> einx.add("b... [c]", x, w).shape (4, 16, 16, 64) cLg|]!}tj|"Sr )r r2 get_shape)r r6s rrzelementwise..s(KKKt{,,V44KKKrrD)rr)rtrC) rirrrDrxrkrrr6s r elementwiser~zsqlKK7KKKQTXbHh*(GX"V]^^^FH Mrc*t|g|Rd||d|S)zrrct|ddi|S)Nrrrrs rlogical_and_stage3rLrrc*t|g|Rd||d|S)zCSpecialization of :func:`einx.elementwise` with ``op="logical_or"`` logical_orrrrs rrrP?    ".S  LV  rct|ddi|S)Nrrrrs rlogical_or_stage3r^ t ? ? ? ??rc*t|g|Rd||d|S)z>Specialization of :func:`einx.elementwise` with ``op="where"``whererrrs rrrb, { aW a a's a aV` a aarct|ddi|S)Nrrrrs r where_stage3rn t : :6 : ::rc*t|g|Rd||d|S)z=Specialization of :func:`einx.elementwise` with ``op="less"``lessrrrs rrrrs, { `W ` `c ` `U_ ` ``rct|ddi|S)Nrrrrs r less_stage3r~s t 9 9& 9 99rc*t|g|Rd||d|S)zCSpecialization of :func:`einx.elementwise` with ``op="less_equal"`` less_equalrrrs rrrrrct|ddi|S)Nrrrrs rless_equal_stage3rrrc*t|g|Rd||d|S)z@Specialization of :func:`einx.elementwise` with ``op="greater"``greaterrrrs rrr- { cW c cGQT c cXb c ccrct|ddi|S)Nrrrrs rgreater_stage3r t < Specialization of :func:`einx.elementwise` with ``op="equal"``equalrrrs rrrrrct|ddi|S)Nrrrrs r equal_stage3rrrc*t|g|Rd||d|S)zBSpecialization of :func:`einx.elementwise` with ``op="not_equal"`` not_equalrrrs rrrs?    "-wC  KU  rct|ddi|S)Nrrrrs rnot_equal_stage3rs t > >v > >>rc*t|g|Rd||d|S)z@Specialization of :func:`einx.elementwise` with ``op="maximum"``maximumrrrs rrrrrct|ddi|S)Nrrrrs rmaximum_stage3rrrc*t|g|Rd||d|S)z@Specialization of :func:`einx.elementwise` with ``op="minimum"``minimumrrrs rrrrrct|ddi|S)Nrrrrs rminimum_stage3rrrr):r r functoolsrnumpyrTtypingrr numpy.typingnptjitrC lru_cacherttraceback_utilfilterstrTensorBackendbool ArrayLiker~r)rrrr+rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrs  """"""""    "("("(  "(J+/CCCCCL   /3 TTTTkT T4<d* + T  T - T [TTT  Tn /3 ````k`4<d* +`  ` - `  [ ````999/3 eeeeke4<d* +e  e - e  [ eeee>>>/3 eeeeke4<d* +e  e - e  [ eeee>>>/3    k 4<d* +    -   [    AAA/3    k 4<d* +    -   [    BBB/3 cccckc4<d* +c  c - c  [ cccc<<</3    k 4<d* +    -   [    AAA/3    k 4<d* +    -   [    @@@/3 bbbbkb4<d* +b  b - b  [ bbbb;;;/3 aaaaka4<d* +a  a - a  [ aaaa:::/3    k 4<d* +    -   [    @@@/3 ddddkd4<d* +d  d - d  [ dddd===/3    k 4<d* +    -   [    CCC/3 bbbbkb4<d* +b  b - b  [ bbbb;;;/3    k 4<d* +    -   [    ???/3 ddddkd4<d* +d  d - d  [ dddd===/3 ddddkd4<d* +d  d - d  [ dddd=====r