uki; UddlmZddlmZmZddlZddlmZmZm Z m Z ddl m Z m Z mZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZmZmZmZddlm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl+m-Z-ddl+m.Z.ddl+m/Z0ddl+m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGmHZHejeJeEZKeDZL djdZMdkdZNdZOdZPe e7dZQej dldZSed ZTejGd!d"e eTZVe ejd#$d%ZWGd&d'ejZYdmd(ZZeYd)Z[d*Z\e\eje[< dnd+Z^e.je[e^d,Z`e`e,je[<eH dod-Zb dpd.Zcece0je[< dqd/Zeeeeje[<ejGd0d1e eTZgej drd2Zi drd3Zjd4ZkejGd5d6Zmd7Znd8Zoe ejd#$ dsd9Zpd:Zqej dtd;Zrd<Zsdud=ZtGd>d?ejZudvd@ZvejdAZweudBZxe.jexe^dCDdEZyeyejex< dpdFZzeze0jex< dqdGZ{e{ejex<e,je-je,j<e.je,je,jdCDdHZe:GdIdJZdwdKZdxdLZeC dydMZdNZ dzdOZdPZdQZdRZdSZejdTZd#e_ejeejeee,je<ee,je<e1j ee.jee.j"ed#UejdVZdWedX<d#e_dYZejee.jeeejdZdedVd[d\Ze eed]^Zd_Zejd`Z d{ d|daZejdbZ d}dcZd~ddZ d}deZ d}dfZ d}dgZddhZejdiZd#e_ejeejGee1j ee.jee.j"ed#Uee-jHe<ee,je<ee,je<ee0je<y)) annotations)CallableSequenceN)update_wrapperreducepartialwraps)AnyGenericTypeVar)config)core)custom_api_util)custom_transpose)dtypes)effects) linear_util)traceback_util)stop_gradient_p SymbolicZeroZerozeros_like_aval)argnums_partialflatten_fun_nokwargsresolve_kwargsprepend_static_args debug_info fun_signatureinfer_argnums_and_argnames)UnexpectedTracerError) AbstractRef)ad)batching)mlir) partial_eval)pxla) not_mapped) tree_flattentree_unflattentree_maptreedef_is_leaf treedef_tupleregister_pytree_node_class tree_leavestree_flatten_with_pathtree_leaves_with_pathkeystrtreedef_childrentree_structure PyTreeDef)cachesafe_zipsafe_map split_listunzip2weakref_lru_cachec>tj||\}}}||fSNpetrace_to_jaxpr_dynamic)funin_avalsjaxpr_constss V/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/custom_derivatives.py_initial_style_jaxprrF<s'..sH=%F cRtjtj|Sr<)r> close_jaxprconvert_constvars_jaxpr)rBs rE _close_jaxprrKBs 2259 ::rGc8ttj||Sr<)rr" add_tangents)rCxxss rE _sum_tangentsrPEs Q ''rGc6ttj|Sr<)r*rfrom_primal_valuerNs rE_zeros_like_pytreerTHs $((! ,,rGcdt|tjrtj|S|Sr<) isinstancerTracerrbindrSs rErYMs"At{{)Co""1%rGct||}||}t|\}}|Dcgc]}tj|} }|j || df|Scc}wN)r)r(rget_avalstore) fr^in_tree args_flatpy_argsansans_flatans_treerN ans_avalss rE_flatten_fun_nokwargsrgRsa 7I .' 7 ##C((H)12At}}Q2)2++xB'( /3sA ReturnValueceZdZUdZded<ded<ded<dZd ed <d Zd ed < d ddZejZ d ddZ ddZ e ejdddZy) custom_jvpaSet up a JAX-transformable function for a custom JVP rule definition. This class is meant to be used as a function decorator. Instances are callables that behave similarly to the underlying function to which the decorator was applied, except when a differentiation transformation (like :py:func:`jax.jvp` or :py:func:`jax.grad`) is applied, in which case a custom user-supplied JVP rule function is used instead of tracing into and performing automatic differentiation of the underlying function's implementation. There are two instance methods available for defining the custom JVP rule: :py:func:`~jax.custom_jvp.defjvp` for defining a *single* custom JVP rule for all the function's inputs, and for convenience :py:func:`~jax.custom_jvp.defjvps`, which wraps :py:func:`~jax.custom_jvp.defjvp`, and allows you to provide separate definitions for the partial derivatives of the function w.r.t. each of its arguments. For example:: @jax.custom_jvp def f(x, y): return jnp.sin(x) * y @f.defjvp def f_jvp(primals, tangents): x, y = primals x_dot, y_dot = tangents primal_out = f(x, y) tangent_out = jnp.cos(x) * x_dot * y + jnp.sin(x) * y_dot return primal_out, tangent_out For a more detailed introduction, see the tutorial_. .. _tutorial: https://docs.jax.dev/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html Callable[..., ReturnValue]r@ Sequence[int]nondiff_argnums Sequence[str]nondiff_argnamesNz5Callable[..., tuple[ReturnValue, ReturnValue]] | NonejvpFboolsymbolic_zerosct||||_t}|r:t|j}|Jt |d|\}}|j ||r|j |t t||_yr<) rr@setrrupdatetuplesortedrmselfr@rmronondiff_argnums_siginferred_nondiff_argnumsrCs rE__init__zcustom_jvp.__init__s 4DH!$ $(( #c __$> t%%!67o. (8!9:DrGc"||_||_|S)aDefine a custom JVP rule for the function represented by this instance. Args: jvp: a Python callable representing the custom JVP rule. When there are no ``nondiff_argnums``, the ``jvp`` function should accept two arguments, where the first is a tuple of primal inputs and the second is a tuple of tangent inputs. The lengths of both tuples are equal to the number of parameters of the :class:`~jax.custom_jvp` function. The ``jvp`` function should produce as output a pair where the first element is the primal output and the second element is the tangent output. Elements of the input and output tuples may be arrays or any nested tuples/lists/dicts thereof. symbolic_zeros: boolean, indicating whether the rule should be passed objects representing static symbolic zeros in its tangent argument in correspondence with unperturbed values; otherwise, only standard JAX types (e.g. array-likes) are passed. Setting this option to ``True`` allows a JVP rule to detect whether certain inputs are not involved in differentiation, but at the cost of needing special handling for these objects (which e.g. can't be passed into jax.numpy functions). Default ``False``. Returns: Returns ``jvp`` so that ``defjvp`` can be used as a decorator. Examples: >>> @jax.custom_jvp ... def f(x, y): ... return jnp.sin(x) * y ... >>> @f.defjvp ... def f_jvp(primals, tangents): ... x, y = primals ... x_dot, y_dot = tangents ... primal_out = f(x, y) ... tangent_out = jnp.cos(x) * x_dot * y + jnp.sin(x) * y_dot ... return primal_out, tangent_out >>> x = jnp.float32(1.0) >>> y = jnp.float32(2.0) >>> with jnp.printoptions(precision=2): ... print(jax.value_and_grad(f)(x, y)) (Array(1.68, dtype=float32), Array(1.08, dtype=float32)) )rprr)ryrprrs rEdefjvpzcustom_jvp.defjvps`DH(D JrGcdjr tdfd}j|y)aConvenience wrapper for defining JVPs for each argument separately. This convenience wrapper cannot be used together with ``nondiff_argnums``. Args: *jvps: a sequence of functions, one for each positional argument of the :class:`~jax.custom_jvp` function. Each function takes as arguments the tangent value for the corresponding primal input, the primal output, and the primal inputs. See the example below. Returns: None. Examples: >>> @jax.custom_jvp ... def f(x, y): ... return jnp.sin(x) * y ... >>> f.defjvps(lambda x_dot, primal_out, x, y: jnp.cos(x) * x_dot * y, ... lambda y_dot, primal_out, x, y: jnp.sin(x) * y_dot) >>> x = jnp.float32(1.0) >>> y = jnp.float32(2.0) >>> with jnp.printoptions(precision=2): ... print(jax.value_and_grad(f)(x, y)) (Array(1.68, dtype=float32), Array(1.08, dtype=float32)) z/Can't use ``defjvps`` with ``nondiff_argnums``.c |}t|}t|Dcgc]\}}|r |||g|n|}}}tt|g|}||fScc}}wr<)rTzipr*rP) primalstangents primal_outzerostrpall_tangents_out tangent_outjvpsrys rErpzcustom_jvp.defjvps..jvpst>j ,e(+Hd(;=$a;>#a6g65H==]JJ9IJk  $$=sAN)rm TypeErrorr)ryrrps`` rEdefjvpszcustom_jvp.defjvpss-:  G HH% KKrGzjax.custom_jvp.__call__repro_api_namec xtdj||j}|j}jsd|d}t | t j||}jr1tfdt|D}tt|Dcgc]}|jvs|}}ttjj|||d \} } jDcgc]}|| } }t|D cgc]\}} |jvs||} }} td jg| | | ittt| }ttjj|| }n^tjj||} } td j||fi}tjj|}t!| \}}t#| |\}}t%|||j||\}}t'j(||g|d j*i}tj,||\}\}}}t/||S#t$r}td|d||d}~wwxYwcc}wcc}wcc} }w) Nzcustom_jvp funstatic_argnumsz'No JVP defined for custom_jvp function z using defjvp.z9The input arguments to the custom_jvp-decorated function T could not be resolved to positional-only arguments. Binding failed with the error: c3ZK|]"\}}|jvr t|n|$ywr<)rm_stop_gradient).0irNrys rE z&custom_jvp.__call__..s40q!)*T-A-A(A>!$qH0s(+rFrequire_static_args_hashablezcustom_jvp jvprr)rr@rm func_namerpAttributeErrorrrrv enumeraterangelenrlu wrap_initrr(rg _flatten_jvpcustom_jvp_call_prXrrmerge_linear_auxr))ryargskwargsdebug primal_namemsger diff_argnumsf_dyn_args static_argsa diff_args debug_jvprprar`flat_fun out_type1flat_jvp out_type2out_flatrCout_trees` rE__call__zcustom_jvp.__call__s '4&*&:&: R>R5RaSlS$R\\$((u%M%14BGIlb('+&:&:;T!W;k;'0Xtq!!4CWCW:W47XiX-txxA{AIAyA,1%K8H2I,JLi  TXX8A!CDO Qc\\$((u=t(b-txx"D\!i LLi 8c%h/Iw/G<Hi&sK9L9L'. ;Hi %%hJ9J595H5HJH--iCA!Q (H --G   E M--.C 1  T<Xs6J 'J,;J, J1J63J6 J)J$$J)r\r\r@rkrmrlrorn)F)rp.Callable[..., tuple[ReturnValue, ReturnValue]]rrrqreturnr)rz!Callable[..., ReturnValue] | NonerNonerr rr rrh)__name__ __module__ __qualname____doc____annotations__rprrr}r forward_attr __getattr__rrrr api_boundaryrr\rGrErjrjas#H"!  !!?C#<C.$1313;.; -;"/;, ,,+%*2@2!2A2h(T > & &35-.5-.rGrjT) use_eq_storect|t|dzg\}}t||} t||} || | } t| tt frt| dk7rd|d|d| d} t | | \} }t| \}}t|\}}|Dcgc]}tj|}}||k7rd|d|d|d|d } t | |}|#|\}}\t||Dcgc]}|jc}}t||Dcgc]}|jc}}||k7rRd|d|d |d t|jd d d |dt|jd d d }t |tt!tj"||sQd|d|d |dt|jd d d |dt|jd d  }t ||Dcgc]%}tj|j%'}}|Dcgc]3}tj|j%j'5}}|Dcgc]P}t)|t*ur#tj|j%n|j,j%R}}tt!tj"||st|dk(rU|||c\} \}!\}"d} t | j/|!j| j|"jd} dt1|||D}#t | j/dj3|#|j5||df||zScc}w#tj$rd}YwxYwcc}wcc}wcc}wcc}wcc}w)NzCustom JVP rule  for function zd must produce a pair (list or tuple of length two) representing primal and tangent outputs, but got .z[ must produce primal and tangent outputs with equal container (pytree) structures, but got  and z respectively.z must produce a pair (list or tuple of length two) where the first element represents the primal output (equal in value to the output of the custom_jvp-decorated function z, and in particular of the same container/pytree structure), but instead the JVP rule output's first element had container/pytree structure: 'z) while the custom_jvp-decorated function , had output container/pytree structure: z, and in particular with leaves of the same shape/dtype), but instead the JVP rule output's first element had shapes/dtypes of: " had output shapes/dtypes of: zCustom JVP rule must produce primal and tangent outputs with corresponding shapes and dtypes. Expected {} (tangent type of {}) but got {}.ziCustom JVP rule must produce primal and tangent outputs with corresponding shapes and dtypes, but got: {}c3|K|]4\}}}||k7r)d|jd|jd|6yw)z primal z with tangent z, expecting tangent N) str_short)rav_pav_etav_ts rErz_flatten_jvp..zsKdE4 d] dnn&'~dnn6F5GG[\a[b cs:< r\)r8rr)rVlistrvrr(rr]rStoreExceptionrstrreplaceallmap typematchstrip_weak_typeto_tangent_avaltyperavalformatrjoinr^)$r_r^rjvp_namer`maybe_out_typer primals_in tangents_in py_primals py_tangentspair_outrpy_primals_outpy_tangents_out primals_outr tangents_out out_tree2rN primal_avals out_type_ out_tree_ primal_avals_rty_treety_tree_mprimal_avals_outexpected_tangent_avals_outrtangent_avals_outrrr disagreementss$ rErr4s &tc$i1n-=>*kgz2*w 4+ z; '( HtUm ,H 0B hZ~k]C22:1 >C C.$,!./&~6+x(9, ,78q$--"8,8  hZ~k]C""*5 > KC C.!#y#, I}bh)NA!++-)NOGi)OA!++-)OPHH hZ~k]CQ]M))#r23466A]CM))#r231 8a aL s4>><? @ hZ~k]CQ]M))#r23466A]CM))#r23 7a aLBMNQdmmA&668NN   MM!$$&668   !-.q'5}}Q'779;<66;Q;Q;ST.. S!;=N O P %&!+#35OQb gtx$]c cjj!2DNN4DdnnFVW XX=c#&'79SUf#gm cjj=!9: ;;++xr*+ | ##}9  ,I,*O)O8O .s7N0N56O O *O<8O :AO%5O Oc(eZdZdZdZdZdZdZy)CustomJVPCallPrimitiveTc&|j|i|Sr< _true_bindryrparamss rErXzCustomJVPCallPrimitive.bind 4??D +F ++rGcL|d|d|dd}}}|j||||fi|S)Nrrr)process_custom_jvp_call)rytracerrr@rptracerss rEbind_with_tracez&CustomJVPCallPrimitive.bind_with_traces;Qa$qr(gC (5 ( (sC KF KKrGctr<NotImplementedError)ryr@rCrs rEimplzCustomJVPCallPrimitive.impl rGct|}|jd}|jd}|jd}tjt j ||j j}t||}||g|fS)N call_jaxpr num_consts jvp_jaxpr_funr) dictpoprrr jaxpr_as_funrBrlift_jvp)ryr new_paramsrrrr@rps rEget_bind_paramsz&CustomJVPCallPrimitive.get_bind_paramsszfJ#->>,#?J nn\2JNN?3M ,,t((4","2"2"="= ?C :} -C :z !!rGNrrrmultiple_resultsrXrr rr\rGrErrs,L"rGrcTfd}tj|jS)Nc ftt|d\}}|rJ||||zd}}|Dcgc]}t|tu}}j|\}}} |Dcgc]}t|tus|} }t j ||g|| } t| t| g\} } t| }t| | Dcgc]>\}}|r,tt j|jn t|@}}}t|dJg| |Scc}wcc}wcc}}w)Nr) divmodrrr call_wrappedr eval_jaxprr8iterrr]rnext)rOnraggedrrrr jvp_jaxpr jvp_consts out_zerosnonzero_tangentsout out_primalsnz_out_tangentsnz_out_tangents_pz out_tangentsrrs rErpzlift_jvp..jvpsSs2w"IAv::a("Qz\]*;XG.6 7T!W $ 7E 7'A}'A'A5'I$Iz9#+KatAwl/JKK //)Z M' M&> ??rGcustom_jvp_callc~~~tjj|j}|rtd||j|jfS)Nz'Effects not supported in `custom_jvp`: r"custom_derivatives_allowed_effects filter_not_inr  out_avals)rCrrrrrrAdisallowed_effectss rE_custom_jvp_call_typecheckr6s^ zAAOOPZPbPbc  12D1EF HH   z11 11rGctj|j|jjDcgc]}|j c}}tj |j|j|j|j|g||j|jd\}}|j||Scc}w)N)dim_var_valuesconst_lowering) r$ ir_constsrDrB constvarsr jaxpr_subcompmodule_context name_stack tokens_inr8r9set_tokens_out)ctxrrrCvrDr'tokenss rE_custom_jvp_vjp_call_loweringrDs >>**:*:*D*DEQ!&&E G&""3#5#5z7G7G#&>>3==&F$(F9<9K9K252D2DF+#vV * FsB= c^~tj|jd|j||SNF)r"backward_pass3rBrD)rrBrctrCs rE _custom_jvp_call_transpose_fancyrIs&  5;;u||T2 FFrGc|j|j}}tj|j |j j |d\}}tj|||fS)NrT) rBrDr> dce_jaxprrrwith_unknown_namesr ClosedJaxpr)jaxpr_ used_outputsrBrD new_jaxpr used_inputss rE#_cached_closed_call_dce_instantiaterRsd,, %<< mmu//BBDmED)[   )V ,k 99rGc  ts0tjsdgtjzdfSj d}j d t |t\}}t|sJtj fd}tjDcgc] \}}|s | }}}tj |tj| j} tj j|j"| |j$j&j(} || fScc}}w)NFrrc4j|\}}} jd}|r"t|Dcgc] \}}|r | c}}n}tj|g|d\}} t|D cgc] \} } | s |  } } } ||| fScc}}wcc} } w)NrrT)rrrr>rK)in_zerosr#rDr%szur, nz_used_outs dce_jvp_jaxprrCusedrB dce_out_zeroseqnr used_outss rEdce_jvp_jaxpr_thunkz1_custom_jvp_call_dce..dce_jvp_jaxpr_thunks#==#=#=x#H Ivy $ %BIK#i";E$!Q1AEQZL||I/J/J\/JDQM1&))Y&?H744QHMH &- //FHs BB7 BBr)rr)anyr> has_effectsrinvarsrrRrvr_memoizeroutvarsrrrr new_jaxpr_eqn primitiver source_inforA) r]r\rdce_call_jaxprused_insr^rZrBrcrnew_eqnrs `` @rE_custom_jvp_call_dcerjs) Ys 3 7S_ $d **zz,'***_--A% "$.( X;;00")S[[9 B74TQ B' B jjLL!4,9,D,DF*    jj'3==*n6L6L oosww ' 7  Cs 5 EEcdt|j}|ds|jd|jdjj|d<t |}|dj jj|d<tj|j|||dg|zS)Nrrrprnamer rrrrrrwrBr_pp_eqnrr\contextsettingsrnamess rE_custom_jvp_call_pp_rulerts  &   JJ|**_-88BB&- .%,'--88BB&. ckkk0'8$X- //rGceZdZdZ d d dZej Z d d dZe e jdd dZ y) custom_vjpaSet up a JAX-transformable function for a custom VJP rule definition. This class is meant to be used as a function decorator. Instances are callables that behave similarly to the underlying function to which the decorator was applied, except when a reverse-mode differentiation transformation (like :py:func:`jax.grad`) is applied, in which case a custom user-supplied VJP rule function is used instead of tracing into and performing automatic differentiation of the underlying function's implementation. There is a single instance method, :py:func:`~jax.custom_vjp.defvjp`, which may be used to define the custom VJP rule. This decorator precludes the use of forward-mode automatic differentiation. For example:: @jax.custom_vjp def f(x, y): return jnp.sin(x) * y def f_fwd(x, y): return f(x, y), (jnp.cos(x), jnp.sin(x), y) def f_bwd(res, g): cos_x, sin_x, y = res return (cos_x * g * y, sin_x * g) f.defvjp(f_fwd, f_bwd) For a more detailed introduction, see the tutorial_. .. _tutorial: https://docs.jax.dev/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html cFt||||_t}|r:t|j}|Jt |d|\}}|j ||r|j |t t||_d|_ d|_ d|_ d|_ yrF) rr@rtrrrurvrwrmfwdbwdrroptimize_rematrxs rEr}zcustom_vjp.__init__,s4DH!$ $(( #c __$> t%%!67o. (8!9:D>BDH6:DHDDrGc||_||_||_||_|jr|jr t dyy)aDefine a custom VJP rule for the function represented by this instance. Args: fwd: a Python callable representing the forward pass of the custom VJP rule. When there are no ``nondiff_argnums``, the ``fwd`` function has the same input signature as the underlying primal function. It should return as output a pair, where the first element represents the primal output and the second element represents any "residual" values to store from the forward pass for use on the backward pass by the function ``bwd``. Input arguments and elements of the output pair may be arrays or nested tuples/lists/dicts thereof. bwd: a Python callable representing the backward pass of the custom VJP rule. When there are no ``nondiff_argnums``, the ``bwd`` function takes two arguments, where the first is the "residual" values produced on the forward pass by ``fwd``, and the second is the output cotangent with the same structure as the primal function output. The output of ``bwd`` must be a tuple of length equal to the number of arguments of the primal function, and the tuple elements may be arrays or nested tuples/lists/dicts thereof so as to match the structure of the primal input arguments. symbolic_zeros: boolean, determining whether to indicate symbolic zeros to the ``fwd`` and ``bwd`` rules. Enabling this option allows custom derivative rules to detect when certain inputs, and when certain output cotangents, are not involved in differentiation. If ``True``: * ``fwd`` must accept, in place of each leaf value ``x`` in the pytree comprising an argument to the original function, an object (of type ``jax.custom_derivatives.CustomVJPPrimal``) with two attributes instead: ``value`` and ``perturbed``. The ``value`` field is the original primal argument, and ``perturbed`` is a boolean. The ``perturbed`` bit indicates whether the argument is involved in differentiation (i.e., if it is ``False``, then the corresponding Jacobian "column" is zero). * ``bwd`` will be passed objects representing static symbolic zeros in its cotangent argument in correspondence with unperturbed values; otherwise, only standard JAX types (e.g. array-likes) are passed. Setting this option to ``True`` allows these rules to detect whether certain inputs and outputs are not involved in differentiation, but at the cost of special handling. For instance: * The signature of ``fwd`` changes, and the objects it is passed cannot be output from the rule directly. * The ``bwd`` rule is passed objects that are not entirely array-like, and that cannot be passed to most ``jax.numpy`` functions. * Any custom pytree nodes involved in the primal function's arguments must accept, in their unflattening functions, the two-field record objects that are given as input leaves to the ``fwd`` rule. Default ``False``. optimize_remat: boolean, an experimental flag to enable an automatic optimization when this function is used under :func:`jax.remat`. This will be most useful when the ``fwd`` rule is an opaque call such as a Pallas kernel or a custom call. Default ``False``. Returns: None. Examples: >>> @jax.custom_vjp ... def f(x, y): ... return jnp.sin(x) * y ... >>> def f_fwd(x, y): ... return f(x, y), (jnp.cos(x), jnp.sin(x), y) ... >>> def f_bwd(res, g): ... cos_x, sin_x, y = res ... return (cos_x * g * y, sin_x * g) ... >>> f.defvjp(f_fwd, f_bwd) >>> x = jnp.float32(1.0) >>> y = jnp.float32(2.0) >>> with jnp.printoptions(precision=2): ... print(jax.value_and_grad(f)(x, y)) (Array(1.68, dtype=float32), Array(1.08, dtype=float32)) Aremat optimization for custom_vjp does not support symbolic zerosN)rxryrrrzr )ryrxryrrrzs rEdefvjpzcustom_vjp.defvjpGsNtDHDH(D(D t22  M OO 3rGzjax.custom_vjp.__call__rc td|j|||j}|jr |jsd|j d}t | t|j||}td|j|||j}td|j|i}|jr:t|j||j||j|j }n |j}tjjrE|jr td t!|j|j|j|S|jr|jD]} t#|| t%t'|D cgc]} | |jvs| } } t)t+j,|j| | |d \} } |jD cgc]} ||  } } t)t+j,|| | |d \}}t/t+j,|j| | }n[t+j,|j| |} } t+j,|| }t+j,|j| }t1| \}}|Dcgc]}t3j4|}}tj6jr!t9| |j| j} t;| |\}}t=||j|j||||\}}t?||||}tAjB|||g|||jd}t+jD||\}\}}}tG||S#t$r!}td|j d||d}~wwxYwcc} wcc} wcc}w)Nzcustom_vjp funrz'No VJP defined for custom_vjp function z using defvjp.z9The input arguments to the custom_vjp-decorated function rzcustom_vjp fwdzcustom_vjp bwd)rmrrz2nondiff_argnums not implemented for new custom_vjprFr) out_treesrr)$rr@rmrxryrrrrrz optimize_remat_of_custom_vjp_fwdrrr %enable_custom_vjp_by_custom_transposevaluer custom_vjp_by_custom_transpose_check_for_tracersrrrrrrr(rr]mutable_array_checks_check_primal_refsrg _flatten_fwd _flatten_bwdcustom_vjp_call_prXrr))ryrr debug_funrr debug_fwd debug_bwdrxr dyn_argnumsrrrfwd_rCryrar`rNrArout_typeflat_fwdrflat_bwdrrs rErzcustom_vjp.__call__s+TXXtV*.*>*>@I 884885i6I6I5J. Yc 3  DHHdF 3d+TXXtV*.*>*>@I+TXXtR@I  , ((Itxx..,, .c HHc 3399  ! @B B I +DHHdhh I4 PP  %%BA'9$q''BB"'D "2TQat?S?S6SqT T& LLi 8+ u6 H)-(<(<=1tAw= =!",,sy"I"-t?DFa"",,txxI"N"-/||DHHCTH||CI6ll488 :'1i,56q$--"6h6  $ $ * * D$8$8"-- H0W=h( $$d&9&99 Wh(h c7Hi@h"''(HL)2L>G7;7J7JLh//)Da (Aq Hh //k   E  !"889s <  4U>7s0N2O2O7 O$O)2 O;OONrr)FF) rx&Callable[..., tuple[ReturnValue, Any]]ryzCallable[..., tuple[Any, ...]]rrrqrzrqrrr) rrrrr}rrrr}rrrrr\rGrErvrv sF1313 . - "/ 2 ,,+ %*$) `O8`O0`O"`O" `O  `OD > & &35>05>0rGrvcJt||||||}t||dgd|S)Nprimalr)_check_for_aliased_refs_check_for_returned_refs)r_rmrrr's rErrs0!_eT: 4#1c8R3 *rGc t|}t|Dcgc]%\}}|gt|jzD]}|'}}}}t |} i} tt || D]\}\} }| |vrt |tr |jn|}t tj|x} tsR| jttj||x} |k7s|jt!| }t#d|d| j%d|| d||d ycc}}}w)Nzjonly one reference to a mutable array may be passed as an argument to a function, but custom_vjp function z. got the same mutable array reference of type z at rr)rtrr3 num_leavesr.rrVCustomVJPPrimalrrr]r! setdefaultid get_referentsafe_arg_namesr ValueErrorr)r_rmrrrzrargrNargnumsleavesrefsargnumrdup_idx arg_namess rErrsL)&t_ < <61ccN3/::: < 2c Y;tfJqc:445KKM?3%HRRS S D ;tfJqc:445KKM?3%H556 6 6 JJs%D(D# D#c&eZdZUdZded<ded<y)rzHPrimal to a ``custom_vjp``'s forward rule when ``symbolic_zeros`` is setr rrq perturbedN)rrrrrr\rGrErrsP * /rGrc d}t||S)a Strips away perturbation information from forward rule arguments. This is a helper function for user with the ``symbolic_zeros`` option to the ``defvjp`` method of a ``custom_vjp``-decorated function. In ``symbolic_zeros`` mode, the custom forward rule receives arguments whose pytree leaves are records with a ``value`` attribute that carries the primal argument. This is a way to convert such argument trees back to their original form, replacing each such record with its carried value at each leaf. cjt|turtdt||jS)Nzunexpected leaf type )rrrr)rs rErz,custom_vjp_primal_tree_values..value(s/ Dz( -d4j\: ;; ::rG)r*)treers rEcustom_vjp_primal_tree_valuesrs % rGcrt|D])}t|tjsd}t |y)NaFound a JAX Tracer object passed as an argument to a custom_vjp function in a position indicated by nondiff_argnums as non-differentiable. Tracers cannot be passed as non-differentiable arguments to custom_vjp functions; instead, nondiff_argnums should only be used for arguments that can't be or contain JAX tracers, e.g. function-valued arguments. In particular, array-valued arguments should typically not be indicated as nondiff_argnums.)r.rVrrWr )rNrrs rErr.s8!n 'd$ $Nc "# && 'rGc|r |jn t|} |r |jnd} |r)tdt|ddd|dddD}n|ddd}t ||} t j jrt|||| || } t| ttfrt| dk7rd| d| d| d| d | d } t| | \}}t|\}}t|\}}t j jrt|| d ||j|Dcgc]}t!j"|}}|}|#|\}}\t ||Dcgc]}|j)c}}t ||Dcgc]}|j)c}}||k7rRd| d| d | d t|j+ddd| dt|j+ddd }t|t-t/t j0||sQd| d| d | dt|j+ddd| dt|j+dd }t|t3||\}}|j5|||fg||Scc}w#t$j&$rd}YmwxYwcc}wcc}w)Nz c3:K|]\}}t||ywr<)r)rrNr,s rErz_flatten_fwd..DsN41aA&NsrrzCustom VJP fwd rule rz must produce a pair (list or tuple of length two) where the first element represents the primal output (equal to those of the custom_vjp-decorated function z) and the second element represents residuals (i.e. values stored from the forward pass for use on the backward pass), but instead of a pair the fwd rule z produced rrxz must produce a pair (list or tuple of length two) where the first element represents the primal output (equal to the output of the custom_vjp-decorated function z) and the second element represents residuals (i.e. values stored from the forward pass for use on the backward pass), but instead the fwd rule output's first element had container/pytree structure: rrz) while the custom_vjp-decorated function rz) and the second element represents residuals (i.e. values stored from the forward pass for use on the backward pass), but instead the fwd rule output's first element had shapes/dtypes of: r)rrrvrr)r rrrrVrrrr(rrrr]rrrrrrr_filter_forwarded_inputsr^)r_r^rmrr debug_primalrr`rrrfwd_namerbrrrresrrres_treerNrrrrrrrr pruned_resinput_forwardss rErr:s+7 &&CF+$-Y ;( N3tCaCy$qt!t*3MN ND !9D 7D )'   &&A gF [( HtUm ,H 0B !(>+G,-8=9-.6Jj !  MC C. .#&~6+xs#-#x   &&Q%x7J7JK,78q$--"8,8!#y#, I}bh)NA!++-)NOGi)OA!++-)OPHH !(>+GH] M))#r23466A]CM))#r231 8a aL s4>><? @ !(>+GH]M))#r23466A]CM))#r23 7a aL7TB*n++x>23 $: $ $$O9  ,I,*O)Os$/J$ J)(K K )KKc t|Dcic]\}}t||}}}|Dcgc]}t||vs|c}|Dcgc]}|jt|c}fScc}}wcc}wcc}wr<)rrget)outsinsrrNidxsos rErrsh/8~>tq!"Q%(>$> /RU$.! /41Pa$((2a5/1P PP? /1PsA.A4A4 !A9c ~|\}}}t||j|jzk(sJt||jg\}} t||} t|| } || | } t | t r+t| tt |k(r t| } tt|tg|jz} tt| d\}}gfd} t | tstt|| | dg}t!||D]\}}}|us+t#|j%dt&j(k(r)|j+t-|j%`t/|t0urt3j4|j7|j8x}s|x}stA|j7|sktC|j7|sQd t;|d |j=d |j=t3jD||}t||j+||S#t$r-t| \}}d}t|j||dwxYw)Nrctt|d}||jg|z|S|j|g|z|S)Nr)rr(extend)rNdr cts_in_flatzeros rEappendz_flatten_bwd..appends\\!_Q'(JyQ]$*,- H !z)* HrGc |duSr<r\rSs rErYz_flatten_bwd..s drG)is_leafa(Custom VJP bwd rule must produce an output with the same container (pytree) structure as the args tuple of the primal function, and in particular must produce a tuple of length equal to the number of arguments to the primal function, but got bwd output structure {} for primal input structure {}.dtypezCustom VJP bwd rule produced a SymbolicZero with a shape/dtype that does not match the corresponding input tangent shape/dtype: at outputz" the SymbolicZero had shape/dtype z/ while the corresponding input had shape/dtype zG. Consider just returning a None here instead of a SymbolicZero object.zuCustom VJP bwd rule must produce an output with the same type as the args tuple of the primal function, but at outputz) the bwd rule produced an output of type z# corresponding to an input of type )#rrr8r)rVrr2rvobjectr9r/rr*r(rrrgetattrrrfloat0rrrrr typecompatto_cotangent_avalrr1rr]_ref_typecompat_temporary_dtype_exceptionaval_mismatch_extra)r_r`rArrrrrCrcts_outpy_res py_cts_out py_cts_indummykeypathsrin_tree2rresultskprrHa_rrs @@rErrs $+(Ha Th))H,?,?? ?? ?D8#6#6"78,#w (C (&h0* #) 4 S^s;KG;T7U%Ui I $ 68*w/A/A"A B%-e4Q78+(A+  = i '  VY/BC 'x;7ib!R TzWQ..0':fmmK nnT!++-./ b\ ! __Q002"''MB B!":,&H,,.!"667kkm_E o nnT"'']#ooa1134==;L5LRM!!"5"5"7<,Q-@-@-BBGr |$||~&'&&'kkm_**1b12 4 o nnR34 .G =y)KAx 9C CJJx1 2<=s :&L6L<ct|txr.tj|j j |Sr<)rVr!rrr inner_avalrrs rErrs5 Q $ @ //!--/::B ?ArGct|tjrt|tjr|j|jk(xrtj||dxrht j |jt jxs8t j |jt jjSy)NT)only_shape_shd_checkF) rVr ShapedArrayshaperr issubdtyperextendednpinexactrs rErrs4##$B8H8H)I GGrxx  < NN1bt < <   rxx 9;   qww (9(9 := rGc(eZdZdZdZdZdZdZy)CustomVJPCallPrimitiveTc&|j|i|Sr<rrs rErXzCustomVJPCallPrimitive.bindrrGc^|d|d|d|ddf\}}}}|j|||||fi|S)Nrrr)process_custom_vjp_call)ryrrrr@rxryrs rErz&CustomVJPCallPrimitive.bind_with_tracesK!!Wd1gtAwQR@Cc7 (5 ( (sCg P PPrGctr<r )ryr@rxryrs rEr zCustomVJPCallPrimitive.implr rGct|}|jd}|jd}|jd}tjt j ||j j}t||}t|j|g\}} t|jd|} ||| g|fS)Nrrfwd_jaxpr_thunkrry) rrrrrrrBrlift_fwdr8rA_handle_consts_in_bwd) ryrrrrrr@rx const_avalsrCrys rErz&CustomVJPCallPrimitive.get_bind_paramssfJ#->>,#?J nn\2J nn%67O ,,t((4","2"2"="= ?C : /C 3 3j\BNK  u 5{ CC c?J &&rGNrr\rGrErrs,Q 'rGrcTfd}tj|jS)Nc&|ddd|ddd}}t|t|k(sJt| g\}}t| g\}}t|rtj j |\}}t j||g|S)Nrr)rr8r_r"CustomVJPExceptionrrr) rvalsnonzerosrCrconst_nonzeros in_nonzeros fwd_jaxpr fwd_constsrrs rErxzlift_fwd..fwds#A#YQTT (D t9H %% %D:,/JAw",X |"DNK >""7"7"998O88+FIz ??9j ;7 ;;rGrr.)rrrxs`` rErrs!< co&@&@ AArGc\|Dcgc] }t|c}t||zScc}wr<)rr)r_rrrs rErrs'& 'a$q' '$q$x. 88 's)custom_vjp_callF) cacheablec~~tjj|j}|rtd||j|jfS)Nz'Effects not supported in `custom_vjp`: r1)rCrrArr5s rE_custom_vjp_call_typecheckrs\AAOO  12D1EF HH   z11 11rGc  ts0tj|sdgt|jzdfS|j d |j d|j d |j d|j dt t\}}t|sJttjjtjfd} fd }tj| j}t|jDcgc] \}}|s | } }}t!|j ||| } tj"|j| |j$| |j&|j(|j*} t-|| fScc}}w) NFrrryrrrrctjj|}\}}}|jt d|Dz }t |d|zt z\}}|j|jfS)Nc3$K|]}|du ywr<r\rr_s rErzD_custom_vjp_call_dce..dce_fwd_jaxpr_thunk..&+HaATM+H)T) rrMrrsumrRrvrBrD) rrrCrfwds num_res_out dce_fwd_jaxprrrr]s rEdce_fwd_jaxpr_thunkz1_custom_vjp_call_dce..dce_fwd_jaxpr_thunk!s  ">/">">"FGI! Ax%%+H4+H(HHK:7[(5+;;=M1    4 4 44rGc \}}}t||jg\}}t|}g}t jD]i\}}|r|j t |#|j} r|j t| P|j t| kt |dJ jg||Sr<) r8rrrr4rr rrrr)rrCrrctscts_all_ctsrZrct_avalryrrrrr]s rEdce_bwdz%_custom_vjp_call_dce..dce_bwd+s[NAx$!4!4 56HC 9DG)Z%9%9:3 d tDz"&&(  ..g. / ..1 23 d  ## # 3   +S +7 ++rG)rrry)r_r>r`rrarrRrvrrrrrrbrrcrrdrerrfrAr)r]r\rgrhrrdce_bwd_wrappedrZrBrcrriryrrrrrs` @@@@@rE_custom_vjp_call_dcers Ys 3 7S_ $d **!$L!9*JJ01/zz%(#KN::VaKb)$45.A% "$.( X 2<$>?;;5@5,,"LL,/NN b``, then the Python callable ``fun`` should have the signature ``a -> (b, CT b --o CT a)`` where we use ``CT x`` to denote a cotangent type for ``x`` and the ``--o`` arrow to denote a linear function. See the example below. That is, ``fun`` should return a pair where the first element represents the value of the mathematical function to be differentiated and the second element is a function to be called on the backward pass of reverse-mode automatic differentiation (i.e. the "custom gradient" function). The function returned as the second element of the output of ``fun`` can close over intermediate values computed when evaluating the function to be differentiated. That is, use lexical closure to share work between the forward pass and the backward pass of reverse-mode automatic differentiation. However, it cannot perform Python control flow which depends on the values of the closed-over intermediate values or its cotangent arguments; if the function includes such control flow, an error is raised. Args: fun: a Python callable specifying both the mathematical function to be differentiated and its reverse-mode differentiation rule. It should return a pair consisting of an output value and a Python callable that represents the custom gradient function. Returns: A Python callable that accepts the same arguments as ``fun`` and returns the output value specified by the first element of ``fun``'s output pair. For example: >>> @jax.custom_gradient ... def f(x): ... return x ** 2, lambda g: (g * x,) ... >>> print(f(3.)) 9.0 >>> print(jax.grad(f)(3.)) 3.0 An example with a function on two arguments, so that the VJP function must return a tuple of length two: >>> @jax.custom_gradient ... def f(x, y): ... return x * y, lambda g: (g * y, g * x) ... >>> print(f(3., 4.)) 12.0 >>> print(jax.grad(f, argnums=(0, 1))(3., 4.)) (Array(4., dtype=float32, weak_type=True), Array(3., dtype=float32, weak_type=True)) c|i|\}}|Sr<r\)rrrcrCr@s rE wrapped_funz$custom_gradient..wrapped_funs $ !& !FC JrGcf |i|\}}t|f\}}td||fi}ttj|||\}}|Dcgc]%}t j |j'} }tj|| \} } } |t| ||| fScc}w)Nzcustom_gradient fwdr) r(rrrrrr]rr>r? Residuals)rrrcrulerdrrr`rNrfrBrCrDr@s rErxzcustom_gradient..fwdsT$V$IC%sf-Hh0$CI(dAJ*LMUWMD'=EFq!113FIF00yAE1f  %Hf= ==Gs*B.c|\}}}}t|f\}}||k7rt|d|tj||g|}t ||}t |r|f}|S)Nz != )r(rrrr)r+) rrrBr`rrDcts_flatrrs rEryzcustom_gradient..bwdss'*$E7Hf&v.Hi9I & .L$MMooeV7h7GWg.Gw g NrG)rvr})r@rrxrys` rEcustom_gradientr!bs:z>S# rGc.eZdZdZdZdZedZy)rc<||_||_||_||_yr<)rBr`rrD)ryrBr`rrDs rEr}zResiduals.__init__sDJDLDMDKrGcpt|j|j|j|jfSr<)rrBr`rrDrys rE__iter__zResiduals.__iter__s& T\\4==$++F GGrGc`|j|j|j|jffSr<)rDrBr`rr%s rEr(zResiduals.tree_flattens$ ;;T\\4==A AArGc$|\}}}|||||Sr<r\)clsauxrDrBr`rs rEr)zResiduals.tree_unflattens"E7H ugx 00rGN)rrrr}r&r( classmethodr)r\rGrErrs% HB11rGrct|\}}tttj|}t d||i}t jjrtj||||St||||S)a Closure conversion utility, for use with higher-order custom derivatives. To define custom derivatives such as with ``jax.custom_vjp(f)``, the target function ``f`` must take, as formal arguments, all values involved in differentiation. If ``f`` is a higher-order function, in that it accepts as an argument a Python function ``g``, then values stored away in ``g``'s closure will not be visible to the custom derivative rules, and attempts at AD involving these values will fail. One way around this is to convert the closure by extracting these values, and to pass them as explicit formal arguments across the custom derivative boundary. This utility carries out that conversion. More precisely, it closure-converts the function ``fun`` specialized to the types of the arguments given in ``example_args``. When we refer here to "values in the closure" of ``fun``, we do not mean the values that are captured by Python directly when ``fun`` is defined (e.g. the Python objects in ``fun.__closure__``, if the attribute exists). Rather, we mean values encountered during the execution of ``fun`` on ``example_args`` that determine its output. This may include, for instance, arrays captured transitively in Python closures, i.e. in the Python closure of functions called by ``fun``, the closures of the functions that they call, and so forth. The function ``fun`` must be a pure function. Example usage:: def minimize(objective_fn, x0): converted_fn, aux_args = closure_convert(objective_fn, x0) return _minimize(converted_fn, x0, *aux_args) @partial(custom_vjp, nondiff_argnums=(0,)) def _minimize(objective_fn, x0, *args): z = objective_fn(x0, *args) # ... find minimizer x_opt ... return x_opt def fwd(objective_fn, x0, *args): y = _minimize(objective_fn, x0, *args) return y, (y, args) def rev(objective_fn, res, g): y, args = res y_bar = g # ... custom reverse-mode AD ... return x0_bar, *args_bars _minimize.defvjp(fwd, rev) Args: fun: Python callable to be converted. Must be a pure function. example_args: Arrays, scalars, or (nested) standard Python containers (tuples, lists, dicts, namedtuples, i.e., pytrees) thereof, used to determine the types of the formal arguments to ``fun``. This type-specialized form of ``fun`` is the function that will be closure converted. Returns: A pair comprising (i) a Python callable, accepting the same arguments as ``fun`` followed by arguments corresponding to the values hoisted from its closure, and (ii) a list of values hoisted from the closure. closure_convert) r(rvrrr]rr check_tracer_leaksr_closure_convert_for_avals __wrapped__)r@ example_args flat_argsr`rArs rEr-r-sq|$L1)W 3t}}i0 1( &\2 >% $$ % 1 1#w% PP %c7He DDrGc"t|tjsyt|tjr9t|j tj rt|jSt|tjrM|jj}|tjuxst|ddtj k( St|tjs t#d|j%DSy)NFrc38K|]\}}t|ywr<)_maybe_perturbed)rrlattrs rErz#_maybe_perturbed..#sF*$%FsT)rVrrWr" JVPTracertangentrr5rr>DynamicJaxprTracerrrabstract_tokenrrrr_ _contents)rNvspaces rEr5r5s At{{ # !R\\"z!))RWW'E AHH %%!R**+VV # # %F$---@.&--? AA a & F F FF rGc ttj||\} tj||\ }} t t |\\ } t|  fd}||fS)Nrct| z }t||g\}} |}tt|\}} |k7rd d|}t |t j |g|}t|S)NzThe inputs to the closure produced by closure_convert must have the same Pytree structure as the example arguments passed when closure_convert was called. Expected z , but got )rr8r(rvrrrr)) args_hconstsnum_argsr const_argsrDall_argsrrrclosure_constsr`rBmergerrs rE converted_funz1_closure_convert_for_avals..converted_fun2s< :-H!, ;D* >: .F%eDk2Hh(55r?partition_listr5r)r@r`rArr out_pvalsrDrArErCrBrDrrs ` @@@@@rEr/r/'s{/ll3:.9+x66{HM%F Z((67G(P%>::* . .  ""rGcggf}|Dcgc]&}|||j|xs||(c}fd}||fScc}w)Nctt|t|}}Dcgc]}t|r|n|c}Scc}wr<)rr )l1l2i1i2sndwhichs rErDzpartition_list..mergeEs1 "XtBxB/4 5Ds # 55 5s5)r)choicelstr'eltrDrOs @rErFrFBsS B#BE F33vc{  " "3 ' 66#; 6 F%6 e Gs+Ac t|\}}t|\}t|f}ttj|t d|||fi|\}} t tj|t tj|} t|g| \} } t| } | jt|| f}ttj|t d|||fi|\tjfd}tjg| ||| |t!| t!|d}t#| |S)a Call a linear function, with a custom implementation for its transpose. The `Haskell-like type signatures`_ of ``fun`` and ``fun_transpose`` are: .. code-block:: haskell fun :: r -> a -o b fun_transpose :: r -> b -o a where the ``-o`` arrow indicates a linear function, ``r`` is the residual input type and ``a`` is the linear input type. The functions ``fun`` and ``fun_transpose`` are coupled as transposes of one another. Specifically, the transpose of a ``linear_call`` primitive is another ``linear_call`` to ``fun_transpose``, with ``fun`` as its custom transposition. For example: >>> def f(r, x): ... return x / r >>> def t(r, t): ... return t / r >>> def div_add(x, denom): ... return x + linear_call(f, t, denom, x) >>> def transpose(f, x_example): ... def transposed(y): ... x, = jax.linear_transpose(f, x_example)(y) ... return x ... return transposed >>> div_add(9., 3.) Array(12., dtype=float32, weak_type=True) >>> transpose(partial(div_add, denom=3.), 1.)(18.) # custom Array(24., dtype=float32, weak_type=True) >>> transpose(lambda x: x + x / 3., 1.)(18.) # reference Array(24., dtype=float32, weak_type=True) The above definition of ``f`` illustrates the purpose of a residual argument: division is linear in one of its inputs (the dividend ``x``) but not the other (the divisor ``r``). As another example: >>> def custom_id(x): ... def f(_, x): return x ... def t(_, t): return 7. ... return linear_call(f, t, (), x) >>> custom_id(1.) 1.0 >>> transpose(custom_id, 1.)(1.) TypedFloat(7.0, dtype=float32) >>> transpose(transpose(custom_id, 1.), 1.)(1.) 1.0 >>> transpose(transpose(transpose(custom_id, 1.), 1.), 1.)(1.) TypedFloat(7.0, dtype=float32) Args: fun: a Python callable specifying a linear function. It should take two arguments: one of "residual" inputs (type ``r``), i.e. inputs in which the function is not necessarily linear, and one of "linear" inputs (type ``a``). It should return output whose components are linear in the linear input (type ``b``). fun_transpose: a Python callable specifying a structurally linear function that is the transpose of ``fun`` with respect to its linear inputs. Its first argument is the same residual inputs (``r``) as ``fun``. Its second argument is of type ``b``. Finally, its output is of type ``a`` and each of its component are linear in its second argument (the ``b`` inputs). residual_args: Argument in which ``fun`` and ``fun_transpose`` are not necessarily linear. Not involved in transposition. linear_args: Argument in which ``fun`` and ``fun_transpose`` are linear and with respect to which the two are transposes. Returns: The call result, i.e. ``fun(residual_args, linear_args)``. .. _Haskell-like type signatures: https://wiki.haskell.org/Type_signature zlinear_call funrzlinear_call fun_transposectjg\}}k7rtdddt||fS)NzYtranspose output pytree structure must match that of linear inputs, got output structure z and input structure r)rFrLrrK)t_jaxprt_constslin_treer4 res_avalsr t_out_trees rEtranspose_thunkz$linear_call..transpose_thunksq,Q-A-A-C-Ey-E9-EGGX|x  "",,0!!) ! - ..  ( **rGcalleerZnum_callee_constsnum_res)r(r,rrrrrrr]rFrKr4r>rb linear_call_prXrr))r@ fun_transpose residual_args linear_args operands_resr operands_lin f_in_treer_r lin_avalsf_jaxprf_constsf_jaxpr_closed t_in_treerZr'rWr4rXrrYs @@@@@rE linear_callrkMswn( 6,' 4,Xx01)$ll  13!. K|]}t|tuywr<)rr)rrs rErz(_linear_call_jvp_rule..s 5T!W_ 5sr[)r8rr_rX) rrr\rZr]r^consts_and_resconst_tangentsrrs rE_linear_call_jvp_rulerrs&w1BW1L0MN.''3Dw3N2OP.( 5n 5 55 5""<<<(.)7<+##<< <)/)7<, l ""rGc |\}}t|||g\}} t|jt||g\} } } td| DsJtd|DsJfd} t || D cgc]#\} }t | t ur t|n| %}} }tjg||||| t|t|d}dg||zz|zScc}} w)Nc3FK|]}tj|ywr<r"is_undefined_primalrrNs rErz._linear_call_transpose_rule..s AqR # #A & As!c3HK|]}tj| ywr<rurws rErz._linear_call_transpose_rule..s Aq''* * As "c fSr<r\)r\rhsrEnew_transpose_thunkz8_linear_call_transpose_rule..new_transpose_thunks 8 rGr[) r8rArrrrrrr_rX)rr\rZr]r^r transposerVrcrdrC cts_avalsrzrHrrrhs ` @rE_linear_call_transpose_ruler}s'))X)3  (**&(L,3x='24/!Q  AL A AA A AL A AA A#y) + R $Bx4/ R 7 +# +    : :< :# :&//B14X'*<'8  :' $w. /' 99 +s(C)c |djS)Nr\r4)rrs rE_linear_call_abstract_evalrs   # ##rGrk)r unreachablezcore.Primitive unreachable_pc~||r<r\)r4exc_typemessagerCs rEunreachable_implr srGc|Sr<r\)r4rC__s rErYrYsIrGr4rrc|ttj|}t|\}}t|\}}t j ||||d}t ||S)aFail when evaluated concretely (but allow for staging). This function allows one to assert an impossibility of evaluation. It can be used to guarantee that evaluation does not "reach" a certain point in the sense that it does not execute, but it can nonetheless be staged out by JAX without error. Args: *args: The arbitrary pytree of arguments to the function. out_avals: Optional specification of the output types of this function invocation from the point of view of staging. If ``None``, these are chosen as equal to types of input arguments. exc_type: Optional constructor for the Python exception raised if evaluated. message: Optional string message for the Python exception raised if evaluated. r)r*rr]r(rrXr)) r4rrrrar`out_avals_flatrr's rErrs^(-I#D))W))4.(I$,g ?# # &&rGzAcan't apply forward-mode autodiff (jvp) to a custom_vjp function.)rrcJt|}|jfd}|S)Nc|\}}td|}ttt|}|j |||||fS)NcHtj|jSr<)rr]r)rs rErYz=custom_vjp_by_custom_transpose..jvp..Gst}}Q'7'G'G'IrGr)r*rr disallow_jvp def_transpose)rrr residuals tan_out_typestan_fnryrxs rErpz+custom_vjp_by_custom_transpose..jvpDsP7mOD)I4PM glmL MF   y(; ;;rG)rjr)r@rxryrps `` rErrAs)3#::<< *rGcustom_jvp_call_jaxprcZ|r tdtdfd }|S)Nr|c <t ||}"r"D]}t||t"}tt |Dcgc] }||vs| }}t t j ||d\}}t t j!||d\}}n0t j |}}t j!}t|\} } t|| \} t|"d| | \} } t| } | Dcgc]}tj|c}tj| j!\}}}tj"tj$|}| \}}}|j&t)d|Dz }t*j,j/|j*}|rt1d|tj2fd}t5j6g|| t ||||d}t9||g\}}t;|}|Dcgc]}| t=|n| |}}t=|dJt?||f}tA|g||Scc}wcc}wcc}w)NrFrc3$K|]}|du ywr<r\rs rErzHoptimize_remat_of_custom_vjp_fwd..wrapped_fwd..rr z^remat optimization for custom_vjp does not support forward functions with these side effects: c@tj\}}}||fSr<r=)rBrCrDrrAs rEfun_jaxpr_thunkzNoptimize_remat_of_custom_vjp_fwd..wrapped_fwd..fun_jaxpr_thunks&228XFeQ F]rGrr^rr)!rrrtrrrrrr(rgr _fix_fwd_argsrr]r>r?rLrIrJrr rr2r3r rb remat_opt_prXr8rr r,r))#rrrrzrrrrrCrar`rrrrNrrD prim_treerr r r5rrrres_r_rrrArrr@rxrms# @@rE wrapped_fwdz5optimize_remat_of_custom_vjp_fwd..wrapped_fwdis #tV ,D;! 247 ;;_- %c$i 0N1A=M4MQNkN$R\\#)%L%0%)Olb(  SY G +T=BDgdA\\#)B C4: ! 4 CC C d  ## #i23H ($5h$5$5 66UO 5. Ds JJJJ)rztuple[ReturnValue, Any])r r )r@rrxrrmrrrs````` rErr\s@ K MM :373737j rGct|Dcgc]}|df}}|Dcgc] }|D]}| }}}||Scc}wcc}}wNTr\)r_rrNpairs rErrsI! "1d) "$ " +d +! +! +$ + D/ # +s /4c8~~~tj||Sr<)rr)rr^rrrs rE_remat_opt_implrs#'? %  9 %t ,,rGc4~|j|jfSr<)r4r)rrrCs rE_remat_opt_abstract_evalrs   i// //rGc dt||Dcgc]+\}}|tur|dk7rtj||dn|-}}}|Dcgc] }|tu } }tj|| d\} } | j } t jt j| j} | D cgc] } | rdnt}} t| |g\}t jfd}tjg| ||t| z|| |d}||fScc}}wcc}wcc} w)NrFctj}tj|d\}}|j|j fSrF)rrMr# batch_jaxprrBrD) fun_jaxprbatched_fun_jaxpr out_batched axis_datar prim_batcheds rEbatched_fun_jaxpr_thunkz0_remat_opt_vmap..batched_fun_jaxpr_thunksM  /"34I%-%9%99lE&3"{  " "$5$<$< <rIrJrBr8rbrrXr)rrin_dimsrr^rrrNr in_batchedbatched_fwd_jaxprr extra_constsbout_dimsrCr batched_outsrs` ` @rE_remat_opt_vmaprsR!w/ 1Q)*(;Q(  Aq! $  1$ 1-45#5*5#+#7#7J$/ [")),nn  !2!8!89;.9 :1a*$ :( :zJ<8/!\;;== !!K<K$K-7#l:K-K*1,=2I K, x 3 15 ;s0D" D(8D-cVt|g\}t||g\}}ttj|}|Dcgc]}t |t  } }t | |D cgc] \} } | s |  }} } | dgt|zz} tj|| d\} }t||z }tj| |tgt|t|g||g||g} tjtj| j}fd}t| j|zt|z}tj g| j||||d|z||d}t||||g\}}}}g||g||fScc}wcc} } w)NTctj}dgtz}tj||d\}}|j |j fSr)rrMrr"r#rBrD)rin_nz fun_jvp_jaxprrCrrs rEfun_jvp_jaxpr_thunkz+_remat_opt_jvp..fun_jvp_jaxpr_thunksT  /"34I FS\ !E||Iud;M1    4 4 44rGrr)r8rr"instantiate_zerosrVrrrr#rearrange_bindersr>rIrJrBrDrrX)rrrr^rrrD consts_dotr consts_nznzcrfwd_jaxpr_jvp_out_nznum_out fwd_jaxpr_jvprnew_num_constsrrres_dotouts_dots` ` rE_remat_opt_jvprsw 5/&'#Hzl;*h %%x 0(0:;1:a&&;);"9j9@eb!R@*@ tfs8}, ,%<< 5$?.& K' !'''z3w<0 :H &'(:Wg00 ?6 ?J ?" ?%- ?:H"#g+*= ?$",D7GW2M!N#wh 3-'-H- --/<@sF * F%5F%ctd)NzBremat optimization for custom_vjp does not support higher-order ADr )rrr^rrrs rE_remat_opt_transposers J LLrGc ,t|s0tj|sdgt|jzdfSt ||j dg\}}t||jDcgc] \}}|s | }}}t|rSdg|j dz}|dgt|j|j dz zz }tj|j dj||\}} |jrJtj|} t| |jDcgc] \}}|s | } }}t|j } tt | |j dgd} | | d<| | d<t|| d<tj| |t | | j"|j$|j&}| |fS|j d\}}tj(||\}}} t||Dcgc] \}}|s | }}}t+j,||} t |j|j dg\}} t| | Dcgc] \}}|s | } }}tj| |t*j.t| | j"|j$|j&}dg|j dz| z} | |fScc}}wcc}}wcc}}wcc}}w) NFr^rTr) instantiaterr)r)r_r>r`rrar8rrrcrKrBr;rIrr rdrrrfrAdce_jaxpr_constsrrM closed_call_p)r]r\used_res used_primsrZrBrcrrPrh closed_jaxprrarrrirrD used_constsrrCs rE_remat_opt_dcer s Ys 3 7S_ $d **#I 90E/FG(J!)S[[9 B74TQ B' B]'CJJ|44KD6S_szz,/GGHHK,,szz+'>'D'Di3>@Ix""" ">>),L"8SZZ8 AGD!Da AF Acjj!JHszz,/G.HI!LMN-J|*J{MJyj,2F2F "G W  6 #457Iv')':':9j'Q$I{H";7 @GD!4a @F @##Iv6L3:: <(@'ABIAv"8V4 =GD!a =F =++T\-Jcoosww8GwL11Hs02 K>=K>= LL# L .L  L L remat_opt)r@ lu.WrappedFunrASequence[core.AbstractValue]rz tuple[core.Jaxpr, Sequence[Any]])rBz core.Jaxprrcore.ClosedJaxpr)r_rr^zlu.Storer`r4)rintrrrr)rAzmlir.LoweringRuleContextrr)rNrrOztuple[bool, ...]rz#tuple[core.ClosedJaxpr, list[bool]])r]zSequence[bool]r\ core.JaxprEqnrz'tuple[list[bool], core.JaxprEqn | None])r\rrqzcore.JaxprPpContextrrzcore.JaxprPpSettingsrz core.pp.Doc)r_rrmrlrcore.DebugInfo)r_rr^z lu.EqualStorermrlrrrqrrrrr`r4)r_rr`r4rArrz;Callable[[], tuple[PyTreeDef, PyTreeDef, list[int | None]]])rrq)rrrrrr)r@rrztuple[Callable, list[Any]])rNr rrq)rr)r@rr`r)r\F)r@rkrrrxrrrrmrlrrrqrr)rrr^rrrrzCallable[[], core.ClosedJaxpr])rr)r]z list[bool]r\r) __future__rcollections.abcrr dataclasses functoolsrrrr typingr r r jax._srcr rrjax._src.custom_transposerrrrrrjax._src.ad_utilrrrrjax._src.api_utilrrrrrrrjax._src.errorsr jax._src.state.typesr!jax._src.interpretersr"r#r$r%r>r&jax._src.interpreters.batchingr'jax._src.tree_utilr(r)r*r+r,r-r.r/r0r1r2r3r4 jax._src.utilr5r6r7r8r9r:register_exclusion__file__rrrFrKrPrTrtransformation_with_aux2rgrhregister_custom_decorator_typerjr Primitiverrrr6custom_typechecksrDregister_loweringrIfancy_transposesrRrj dce_rulesrt pp_eqn_rulesrvtransformation2rrr dataclassrrrrrrrrrrrrrrrraise_custom_vjp_error_on_jvpprimitive_batchers custom_lin_pr!rr-r5r/rFrkrmrrr}rr_rdef_impldef_abstract_evalprimitive_jvpsprimitive_transposes register_initial_style_primitive lower_funrrrrrrrcustom_jvp_call_jaxpr_prrrrrrrrrdef_effectful_abstract_evalfancy_primitive_batchersr\rGrErs%#.<<(($6&#::2,$*&4&5PPPP.."!!(+ #?> ;(- J!)4=m$ //P.%P.0P.d  $ $48K$9K$Z"T^^".@$++<=2-G()  .>  (*GHG*J%&:6F:-P::!!$1!,!D#7  /&9 /'; /@K /(@#$//_0%_00_0B  "/ 8F  "/8F&6   $ '  $ $48E%"/E%!%E% .E%+ E% $ E%9E%NQC#C7CXCCJA 'T^^'2 B99++<=(*G!&(2-G()7!7!$17!,7!p#7  /&9 /'; /@K /(@#$/1/O/OBOO,r(H(H!&(Wr 1 1 1 DEL*#+9# #4B)'B)H2 #:0$}- !%  ()  :;#8- )D &%%%m4}ndnn'./ !/} = ~=!%  '( }&67 EF!% %'<  OQ  )$..)@A"&( C #CC 0C C # C  C,CJ --- - 4 -0! !  !  ! 4 ! F$. $.  $.  $.4$.L L L L L 4 L(Tdnn[) #  _% ''(@A%%%k2{NDNNd%,-2A!!+.!/+'; $* [rG