Wh\dZddlmZddlmZmZddlZddlZddlZddl m Z ddl Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddlmZddlmZddlmZddlmZddlmZddlmZ ddl!m"Z"ddl#m$Z$ddl%Z&ej'e(Z)ej*de j+dZ,de,_-ej./e,ej0ecZZ1ej2e3cZ3Z4ej5dGddZ6dEd#Z7e,8ej9ej:e,e,j;dEd$Ze,<d&Z?e?ej@e,<dFd,ZAej9eAe,ejBe,<dGd-ZCdHd.ZDejEe,eDd/ZFde$dd0dId4ZGe j+d5ZHdeH_-ej./eHGd6d7ejIZJGd8d9ejIZKeJZLeKZMejNOeJejNOeKejPOeJejPOeKejQOeKejROeKdJd<ZSeH8ej9ej:eHeHjTdJd=ZUd>ZVeVej>eH<d?ZWeWej@eH<d@ZXeXejBeH<dAZYejEeHeYddBdCdKdDZZdS)LzModule for JAX callbacks.) annotations)CallableSequenceN)Any)core) deprecations)dispatch)dtypes)effects)sharding_impls) tree_util)util)ad)batching)mlir)lax)map) xla_client)SingleDeviceSharding) DeprecatedArgjax-callback-vectorized pure_callbackT)frozenc0eZdZUdZded<ded<d d Zd S) _FlatCallbacka/A Python function callable with flat arguments and results. An instance of this class is used as a parameter for the callback primitives. We prefer it to an anonymous flattened function because it produces equal objects when we call the same Python function with the same argument structure. Callable[..., Any] callback_funcztree_util.PyTreeDefin_tree flat_args jax.ArrayreturnSequence[jax.Array]cztj|j|\}}tj|j|i|SN)r tree_unflattenr tree_leavesr)selfrargskwargss W/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/jax/_src/callback.py__call__z_FlatCallback.__call__Es>+DL)DDLD&  !3!3T!DV!D!D E EEN)rr r!r")__name__ __module__ __qualname____doc____annotations__r+r,r*rr9sT$###FFFFFFr,rcallbackshardingSingleDeviceSharding | None vectorizedbool | DeprecatedArg vmap_method str | Nonec~~~~ tjd^}}n"#t$r}td|d}~wwxYwtj||}tj|5 t jtj||cdddS#t$rt dwxYw#1swxYwYdS)Ncpubackendzjax.pure_callback failed to find a local CPU device to place the inputs on. Make sure "cpu" is listed in --jax_platforms or the JAX_PLATFORMS environment variable.zjax.pure_callback failed jax local_devices RuntimeError device_putdefault_devicer tree_mapnpasarray BaseExceptionlogger exception) result_avalsr3r4r6r8r( cpu_device_es r*pure_callback_implrNJs@ K &u555NJ     /     j ) )$ *%%     HHdO < <             1222            s4 =8=)C+!B&B??CC Cc~~~~~|Sr$r2)r3rJr4r6r8avalss r*pure_callback_abstract_evalrQhs Xx[ r,c$~~td)NzgPure callbacks do not support JVP. Please use `jax.custom_jvp` to use callbacks while taking gradients. ValueErrorr(r)s r*pure_callback_jvp_rulerVu" FM N NNr,c$~~td)NzmPure callbacks do not support transpose. Please use `jax.custom_vjp` to use callbacks while taking gradients.rSrUs r*pure_callback_transpose_rulerYrWr,bool | None | DeprecatedArgrJSequence[core.ShapedArray]r)rc P ttr$"tjddjddddt ||D\ dt ||D}t fd D}dkr7d "t d d Dd <d krWd 0t dt d |Dd <j||d} nىdksdkrodkr ndfdt ||D} d "t dd Dd <j| |d} n^dkr@d|Dtj |\} fd} t| | } ntdjdt | dt| zfS)NrzThe default behavior of z under vmap will soon change. Currently, the default behavior is to generate a sequential vmap (i.e. a loop), but in the future the default will be to raise an error. To keep the current default, set vmap_method='sequential'. stacklevel sequentialcJh|] \}}|tju|j|!Sr2)r not_mappedshape).0ads r* z)callback_batching_rule..s9111tq!H/// ///r,c`g|]+\}}|tjur|ntj||d,Srrrbmoveaxisrdargdims r* z*callback_batching_rule..SNNN19cH///ccS!,,NNNr,c3ZK|]%}tjtjd|V&dS)rN)r unmapped_aval no_axis_name)rdaval axis_sizes r* z)callback_batching_rule..sK   D$5q$??      r,output_layoutsc3VK|]$}|dntd|DdzV%dS)Nc3 K|] }|dzV dSNr2rdns r*rvz3callback_batching_rule...s&)@)@A!a%)@)@)@)@)@)@r,rituplerdlayouts r*rvz)callback_batching_rule..sZ%0%0 E)@)@)@)@)@$@$@4$G%0%0%0%0%0%0r,legacy_vectorized input_layoutsc3|K|]7\}}|tjur|n|dntd|DdzV8dS)Nc3 K|] }|dzV dSrzr2r|s r*rvz3callback_batching_rule...s&,C,CqQU,C,C,C,C,C,Cr,ri)rrbr)rdrrfs r*rvz)callback_batching_rule..sr&?&?fa,,,&&>44u,C,CF,C,C,C'C'Cd'J&?&?&?&?&?&?r,)r6r8rJ expand_dims broadcast_allr{cbg|]+\}}|tjurtj|fn|,Sr2)rrbr broadcast)rdxrfsizes r*roz*callback_batching_rule..sM))) Aq&'(*=%=%= a$!!!1)))r,c3VK|]$}|dntd|DdzV%dS)Nc3 K|] }|dzV dSrzr2r|s r*rvz3callback_batching_rule...s&+B+BaAE+B+B+B+B+B+Br,rir~rs r*rvz)callback_batching_rule..sZ&1&1.$$e+B+B6+B+B+B&B&BT&I&1&1&1&1&1&1r,c*g|]}|tjuSr2rrbrdrfs r*roz*callback_batching_rule..s ===1!8..===r,cRtj|}j|dS)N)rJr6r8)r merge_listsbind) batched_args merged_args is_batchedr)primrJunbatched_argsr6r8s r* _batch_funz*callback_batching_rule.._batch_funsH$ZNNk TY #!   r,zvmap is only supported for the zk primitive when vmap_method is one of 'sequential', 'expand_dims', 'broadcast_all', or 'legacy_vectorized'.ri) isinstancerrwarnnameziprgetrrpartition_listlax_mapNotImplementedErrorlen)rr(dimsr6r8rJr)new_argsbatched_result_avalsoutvals bcast_argsrrrurrrs` ```` @@@@r*callback_batching_rulers| M**{/B! O49 O O O K11s4111*)NN=@t__NNN(          L  VZZ0@%A%A%M$%0%0-.%0%0%0 0 0F '''zz/"". %&?&?vo6==&?&?&?!?!?f_di )   GGm##{o'E'E#6699AD))))$'')))Jzz/"". %&1&1/&1&1&1!1!1f_di'   GGl""=====J#'#6z8#L#L NLj,//GG  $)       wG , ,,r,c4t|tjrr|jt |jjkrtd|tdtj }tj j j |_ |St|tj r|t|tstdt|tt!|j}|j}|t'd ||}n+#t*$r}t-d|d|d|d}~wwxYwd}tj }tj j j|_ d g|_|g|_|SdS) Nz~callbacks are only supported in spmd computations when all mesh axes are partitioned manually (no partial automatic sharding).zEcallbacks do not support specifying sharding inside spmd computationsz:pure_callback only supports SingleDeviceSharding, but got z9Please file a bug at https://github.com/jax-ml/jax/issuesz6Sharding provided to pure_callback specifies a device z' that is not in the device assignment ()rr{)rr SPMDAxisContext manual_axes frozensetmesh axis_namesrxc OpShardingTypeMANUALtypeShardingContextrnextiter device_setdevice_assignmentAssertionErrorindex IndexErrorrTMAXIMALtile_assignment_dimensionstile_assignment_devices) axis_contextr4 op_shardingdevicer device_indexrMs r*_callback_op_shardingrs n<==9\->-I#J#JJJ  L      -//K})0K  n<== "6 7 7 ! !X ! !   D,--..f&8  " GII I.(..v66 ... & & &" & & &''-. .. l -//K})1K./SK*+7.K'  sD-- E7EEc fd}t|jj|}tj||dt ||j|jd|\}}}|S)Nc<tt|ddS)N)r3r4)rrN)rr3paramss r* _callbackz)pure_callback_lowering.._callbacks:         r,Fhas_side_effectr4)rmodule_contextrremit_python_callbacklistavals_in avals_out) ctxr3r4r(rrrresultrLs ` ` r*pure_callback_loweringrs&c&8&ExPP+*   4jj l m   ,&!Q -r,ctj|j}tj||krt ddS)NzQresult_shape_dtypes cannot specify 64-bit types when `jax_enable_x64` is disabled)rEdtyper canonicalize_dtyperT) shape_dtypedts r*_check_shape_dtyper6sJ x !""" r""b(( [ ] ]])(r,)r4r6r8rresult_shape_dtypesr(c t|ts0|.tjddd|t d|rdnd}gd }||vrt d |d |t j||f\}} t jt|t jd |} t j| \} } tj |t|| t| |||d } t j | | S)aCalls a pure Python callback. Works under :func:`jit`/:func:`~vmap`/etc. For more explanation, see `External Callbacks`_. ``pure_callback`` enables calling a Python function in JIT-ed JAX functions. The input ``callback`` will be passed JAX arrays placed on a local CPU, and it should also return JAX arrays on CPU. The callback is treated as functionally pure, meaning it has no side-effects and its output value depends only on its argument values. As a consequence, it is safe to be called multiple times (e.g. when transformed by :func:`~vmap` or :func:`~pmap`), or not to be called at all when e.g. the output of a `jit`-decorated function has no data dependence on its value. Pure callbacks may also be reordered if data-dependence allows. When `vmap`-ed the behavior will depend on the value of the ``vmap_method``. * Calling :func:`~jax.vmap` on a callback without an explicit ``vmap_method`` is deprecated and it will eventually raise ``NotImplementedError``. * ``vmap_method="sequential"`` uses :func:`~jax.lax.map` to loop over the batched arguments, calling ``callback`` once for each batch element. * ``vmap_method="expand_dims"`` calls ``callback`` with new axes of size ``1`` added as the leading dimension unbatched inputs. * ``vmap_method="broadcast_all"`` behaves like ``expand_dims``, but the inputs are tiled to the expected batched shape. If necessary, the legacy behavior provided by the deprecated ``vectorized=True`` argument can be recovered using ``vmap_method="legacy_vectorized"``. The current default behavior is to use ``vmap_method="sequential"`` when not specified, but this behavior is deprecated, and in the future, the default will be to raise a ``NotImplementedError`` unless ``vmap_method`` is explicitly specified. Args: callback: function to execute on the host. The callback is assumed to be a pure function (i.e. one without side-effects): if an impure function is passed, it may behave in unexpected ways, particularly under transformation. The callable will be passed PyTrees of arrays as arguments, and should return a PyTree of arrays that matches ``result_shape_dtypes``. result_shape_dtypes: pytree whose leaves have ``shape`` and ``dtype`` attributes, whose structure matches the expected output of the callback function at runtime. :class:`jax.ShapeDtypeStruct` is often used to define leaf values. *args: arguments to be passed to the callback function sharding: optional sharding that specifies the device from which the callback should be invoked. vmap_method: string specifying how the callback transforms under :func:`~jax.vmap` as described above. **kwargs: keyword arguments to be passed to the callback function Returns: result: a pytree of :class:`jax.Array` objects whose structure matches that of ``result_shape_dtypes``. See Also: - :func:`jax.experimental.io_callback`: callback designed for impure functions. - :func:`jax.debug.callback`: callback designed for general-purpose debugging. - :func:`jax.debug.print`: callback designed for printing. Examples: The behavior of ``pure_callback`` under :func:`~jax.vmap` is controlled by the ``vmap_method`` argument as described above. It is useful to consider some explicit examples that demonstrate the semantics. For example, consider the following function: >>> def callback(x, y): ... print(jnp.shape(x), jnp.shape(y)) ... return x + y >>> def fun(x, y, *, vmap_method): ... shape = jnp.broadcast_shapes(jnp.shape(x), jnp.shape(y)) ... dtype = jnp.result_type(x, y) ... out_type = jax.ShapeDtypeStruct(shape, dtype) ... return jax.pure_callback(callback, out_type, x, y, ... vmap_method=vmap_method) Calling this with ``vmap_method="expand_dims"`` adds a new axis of size ``1`` to ``y``: >>> from functools import partial >>> x = jnp.arange(4) >>> y = 1.0 >>> jax.vmap(partial(fun, vmap_method="expand_dims"), in_axes=(0, None))(x, y) (4,) (1,) Array([1., 2., 3., 4.], dtype=float32) Whereas, ``vmap_method="broadcast_all"`` adds an axis of size ``4`` to ``y``: >>> jax.vmap(partial(fun, vmap_method="broadcast_all"), ... in_axes=(0, None))(x, y) (4,) (4,) Array([1., 2., 3., 4.], dtype=float32) .. _External Callbacks: https://jax.readthedocs.io/en/latest/notebooks/external_callbacks.html NrzThe vectorized argument of jax.pure_callback is deprecated and setting it will soon raise an error. To avoid an error in the future, and to suppress this warning, please use the vmap_method argument instead.r^z{the vectorized and vmap_method arguments of jax.pure_callback cannot be used together. Please use the vmap_method argument.rr`)r`rrrNz.vmap_method must be on of the allowed methods z , but got: c@tj|j|jSr$r ShapedArrayrcrrs r*zpure_callback..s !'22r,)r3rJr4r6r8)rrrrrTr tree_flattenrDrpure_callback_prrrr%)r3rr4r6r8r(r)allowed_vmap_methodsrrrJflat_result_avalsout_treeout_flats r*rr=s}T J . . Fz7I! N    C D DD*4E%%K555,,,  "9M " " " " # ##!-tVn==)W ')<===#224GII, ) 6| D DX  !Xw//*++ (  !(H 5 55r, io_callbackceZdZdZdS)IOEffectcdS)NIOr2rLs r*rzIOEffect.sdr,Nr-r.r/__str__r2r,r*rrs N'''r,rceZdZdZdS)OrderedIOEffectcdS)N OrderedIOr2rs r*rzOrderedIOEffect.skr,Nrr2r,r*rrs ! !'''r,rorderedboolc~~~ tjd^}}n"#t$r}td|d}~wwxYwtj||}tj|5 t jtj||cdddS#t$rt dwxYw#1swxYwYdS)Nr;r<zjax.io_callback failed to find a local CPU device to place the inputs on. Make sure "cpu" is listed in --jax_platforms or the JAX_PLATFORMS environment variable.zjax.io_callback failedr>)rJr3r4rr(rKrLrMs r*io_callback_implrs>Hg &u555NJ     /     j ) )$ *%%     HHdO < <             /000            s4 <7<(C*!B&B>>CCCc2~~~|rtnt}||hfSr$)_OrderedIOEffect _IOEffect)r3rJr4rrPeffects r*io_callback_abstract_evalrs( Xx& 5  I& x r,c$~~td)Nz IO callbacks do not support JVP.rSrUs r*io_callback_jvp_ruler s F5666r,c$~~td)Nz&IO callbacks do not support transpose.rSrUs r*io_callback_transpose_rulers F;<<.s ;;;,,;;;r,c`g|]+\}}|tjur|ntj||d,Srirjrls r*roz-io_callback_batching_rule..rpr,cXtj|}tj|ddS)NF)r3r4rJr)rr io_callback_pr)rmergedr3rrJr4rs r*rz-io_callback_batching_rule.._batch_funs@  j., G GF  v8+7 H H HHr,ri)rTrrrrr) r(rr3rJr4rrrrout_valsrrs ``` @@r*io_callback_batching_rulers ; 9 : ::;;d;;;*NN=@t__NNN(!%!4Z!J!J.,HHHHHHHHHZ . .( 4#h--' ''r,c fd}t|jj|}r|jt }t j|||t||j |j d|\} }} | t j t |in7t j||dt||j |j d|\} }} | S)Nc >tt|ddS)N)r3r4r)rr)rr3rrs r*rz'io_callback_lowering.._callback)s=          r,Tr) rrr tokens_inrrrrrrrset_tokens_outTokenSet) rr3r4rr(rrrtokenrrLs ` ` ` r*io_callback_loweringr(s        &c&8&ExPP+  M  . / /E0   T      FE1t}&6%>??@@@@0   T      FE1 -r,F)r4rc@tj||f\}}tjt|tj|\}} t d|} t j|t||t| ||d} tj | | S)a(Calls an impure Python callback. For more explanation, see `External Callbacks`_. Args: callback: function to execute on the host. It is assumed to be an impure function. If ``callback`` is pure, using :func:`jax.pure_callback` instead may lead to more efficient execution. result_shape_dtypes: pytree whose leaves have ``shape`` and ``dtype`` attributes, whose structure matches the expected output of the callback function at runtime. :class:`jax.ShapeDtypeStruct` is often used to define leaf values. *args: arguments to be passed to the callback function sharding: optional sharding that specifies the device from which the callback should be invoked. ordered: boolean specifying whether sequential calls to callback must be ordered. **kwargs: keyword arguments to be passed to the callback function Returns: result: a pytree of :class:`jax.Array` objects whose structure matches that of ``result_shape_dtypes``. See Also: - :func:`jax.pure_callback`: callback designed for pure functions. - :func:`jax.debug.callback`: callback designed for general-purpose debugging. - :func:`jax.debug.print`: callback designed for printing. .. _External Callbacks: https://jax.readthedocs.io/en/latest/notebooks/external_callbacks.html c@tj|j|jSr$rrs r*rzio_callback..zsD$4QWag$F$Fr,)r3rJr4r) r rrDrrrrrrr%) r3rr4rr(r)rrflat_shape_dtypesrrrs r*rrSsH!-tVn==)W ')<=== ) 67J K KXFF+--  Xw//*++ (  !(H 5 55r,)r3rr4r5r6r7r8r9)r6rZr8r9rJr[r)r)r4r5)r3rr4r5)r3rrrr(rr4r5r6rZr8r9r)r)r3rr4r5rr) r3rrrr(rr4r5rrr)r)[r0 __future__rcollections.abcrr dataclasses functoolsloggingtypingrr?jax._srcrrr r r r r rjax._src.interpretersrrr jax._src.laxrjax._src.lax.control_flow.loopsrr jax._src.librrjax._src.sharding_implsrjax._src.typingrnumpyrE getLoggerr-rHregister Primitivermultiple_results%prim_requires_devices_during_loweringaddsafe_map unsafe_mapsafe_zipr unsafe_zip dataclassrrNdef_implpartialapply_primitivedef_abstract_evalrQrVprimitive_jvpsrYprimitive_transposesrprimitive_batchersrrregister_loweringrrrEffectrrrrlowerable_effectsadd_typecontrol_flow_allowed_effectsordered_effectsshardable_ordered_effectsrdef_effectful_abstract_evalrrrrrrr2r,r*r:s$ """"""........ !!!!!!######$$$$$$******&&&&&&::::::))))))888888))))))  8 $ $ /000!$.11#' .22?CCC-Z-Zd### F F F F F F F$# F     4**8+C+:<<==="   #" NNN&</"NNN ,H(T-T-T-T-n0Ay/@O00O, 2222j6(>???]]]-1.;moo" J6J6J6J6J6J6^}-- !% .22=AAAw~"""""gn""" HJJ "?$$""8,,,""?333$--h777$--o>>> 111!**?;;;    2(y()A)688999*    +*  777$8- ===*D &(((.GM*%%%P}&:;;;-1 0606060606060606r,