=VhC9dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#eddddddZ$ejJejLeddQde#e!e$fde#e!ejNfde(de(de#e!e$ff dZ)edejTe)Z+e)jXjZZ.de#e!e$fde#e!ejNfde(de(de#e!e$ff dZ/ej`d d!d"gZ1ed#dd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Z2ed2dd(Z3ejJejLed3dQd4e#e!e2fd5e#e!e2fd6e#e!e3ffd7Z4ed8ejTe4Z5e4jXjZZ6d4e#e!e2fd5e#e!e2fd6e#e!e3ffd9Z7ejJejLed:gggd;gdfde9fd?Z:ed@ejTe:Z;e:jXjZZe9fdAZ=edBdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Z>edCdd(Z?ejJejLedDdQd4e#e!e>fd5e#e!e>fdEe#e!e?fdFe#e!e?fdGe#e!e?fdHe#e!e?fdIe#e!e?fdJe(dKe(de#e!e>ffdLZ@edMejTe@ZAe@jXjZZBd4e#e!e>fd5e#e!e>fdEe#e!e?fdFe#e!e?fdGe#e!e?fdHe#e!e?fdIe#e!e?fdJe(dKe(de#e!e>ffdNZCedOdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZDedPdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZEedQdd(ZFedRdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZGejJejLedSdRd4e#e!eDfd5e#e!eEfdEe#e!eFfdFe#e!eFfdGe#e!eFfdHe#e!eFfdIe#e!eFfdJe(dKe(dTeGdUe8de#e!eGffdVZHedWejTeHZIeHjXjZZJd4e#e!eDfd5e#e!eEfdEe#e!eFfdFe#e!eFfdGe#e!eFfdHe#e!eFfdIe#e!eFfdJe(dKe(dTeGdUe8de#e!eGffdXZKedYZLejJejLedZdQd[e(d\e(d]eLde#e!eLffd^ZMed_ejTeMZNeMjXjZZOd[e(d\e(d]eLde#e!eLffd`ZPejJejLedadQdbe(d\e(dce9fddZQedeejTeQZReQjXjZZSdbe(d\e(dce9fdfZTejJejLedgdQde#e!ejfdheVdieVde(dje9de#e!ejff dkZXedlejTeXZYeXjXjZZZde#e!ejfdheVdieVde(dje9de#e!ejff dmZ[edndd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Z\ejJejLedodQd4e#e!e\fd5e#e!e\fdJe(dKe(de#e!e\ff dpZ]edqejTe]Z^e]jXjZZ_d4e#e!e\fd5e#e!e\fdJe(dKe(de#e!e\ff drZ`edsdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zaedtdd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zbedudd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZcejJejLedvdQd4e#e!eafd5e#e!ebfdJe(dKe(dTecde#e!ecff dwZdedxejTedZeedjXjZZfd4e#e!eafd5e#e!ebfdJe(dKe(dTecde#e!ecff dyZgedzZhed{dd(ZiejJejLed|dQde#e!ehfd}e#e!eifd~e#e!eifde#e!ehffdZjedejTejZkejjXjZZlde#e!ehfd}e#e!eifd~e#e!eifde#e!ehffdZmedZneddd(ZoejJejLeddQde#e!enfde#e!enfde#e!eofde#e!enffdZpedejTepZqepjXjZZrde#e!enfde#e!enfde#e!eofde#e!enffdZseddd%dZtejJejLeddQde#e!etfde#e!etfde(de#e!etffdZuedejTeuZveujXjZZwde#e!etfde#e!etfde(de#e!etffdZxedddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zyeddd(ZzejJejLeddQde#e!eyfd}e#e!ezfde#e!ezfdJe(de9de#e!eyff dZ{edejTe{Z|e{jXjZZ}de#e!eyfd}e#e!ezfde#e!ezfdJe(de9de#e!eyff dZ~edZejJejLeddQde#e!effdZedejTeZejXjZZde#e!effdZej`dddgZedddd&dd'dd(d)d/dd0d1 ZedZejJejLeddQde#e!efde#e!effdZedejTeZejXjZZde#e!efde#e!effdZejJejLeddQdZedejTeZejXjZZdZedZeddd(ZejJejLeddQde#e!efde#e!efde#e!efde#e!efde#e!efde#e!eff dZedejTeZejXjZZde#e!efde#e!efde#e!efde#e!efde#e!efde#e!eff dZedZejJejLeddQd]ede(de#e!effdZedejTeZejXjZZd]ede(de#e!effdZedddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZejJejLed«dQde#e!efde#e!efde#e!effdĄZedūejTeZejXjZZde#e!efde#e!efde#e!effdƄZedddd&dZejJejLedȫdQde#e!efde8de8de#e!effd˄Zed̫ejTeZejXjZZde#e!efde8de8de#e!effd̈́ZeddddddZejJejLedϫdQde#e!efde#e!ejNfde#e!ejNfde(de#e!eff dфZedҫejTeZejXjZZde#e!efde#e!ejNfde#e!ejNfde(de#e!eff dӄZedddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zeddd(ZejJejLed֫dQde#e!efde#e!efde#e!efdEe#e!efde#e!efde#e!efdFe#e!efde#e!effdڄZed۫ejTeZejXjZZde#e!efde#e!efde#e!efdEe#e!efde#e!efde#e!efdFe#e!efde#e!effd܄ZedݎZejJejLedޫdQde#e!efde#e!ejNfde#e!effdZedejTeZejXjZZde#e!efde#e!ejNfde#e!effdZejJejLeddQde#e!ejNffdZedejTeZejXjZZde#e!ejNffdZej`dddgZeddd(d)dd0d1Zeddd(ZejJejLede jvdfde#e!ejNfde#e!ejxfde#e!efd]efdZedejTeZejXjZZde#e!ejNfde#e!ejxfde#e!efd]efdZedddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zeddd(ZejJejLeddQde#e!efde#e!efde#e!efdJe(de9de#e!eff dZedejTeëZejXjZZde#e!efde#e!efde#e!efdJe(de9de#e!eff dZeddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1Zeddd(ZejJejLeddQde#e!efde#e!efdEe#e!efdFe#e!efde#e!efde#e!efde#e!effdZedejTeɫZejXjZZde#e!efde#e!efdEe#e!efdFe#e!efde#e!efde#e!efde#e!effdZej`dddgZeddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZejJejLeddQde#e!efde9de8d eVfd Zed ejTeϫZejXjZZde#e!efde9de8d eVfd Zed ZejJejLeddQde#e!efde(fdZedejTeԫZejXjZZ֐de#e!efde(fdZejJejLeddQde#e!ejNfde#e!ejNfde#e!ejNffdZedejTeثZejXjZZde#e!ejNfde#e!ejNfde#e!ejNffdZedZejJejLeddQde#e!efde#e!ejNfde#e!ejNfde#e!effdZedejTeݫZejXjZZde#e!efde#e!ejNfde#e!ejNfde#e!effdZedZejJejLedd gdfde#e!efd!e(de#e!effd"Zed#ejTeZejXjZZde#e!efd!e(de#e!effd$Zed%ZejJejLed&dQde#e!efde#e!effd'Zed(ejTeZejXjZZde#e!efde#e!effd)Zed*ZejJejLed+d,gdfde#e!efd-e(d.e8de#e!effd/Zed0ejTeZejXjZZde#e!efd-e(d.e8de#e!effd1Zed2ZejJejLed3d,gdfde#e!efd-e(d.e8de#e!effd4Zed5ejTeZejXjZZde#e!efd-e(d.e8de#e!effd6Zej`d7gd8Zed9dd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZejJejLed:dQde#e!efde8d eVdKe(fd;Zed<ejTeZejXjZZde#e!efde8d eVdKe(fd=Zed>ddd$d%dd&dd'dd(d)d*d+d,d-d.d/dd0d1ZejJejLed?dQde#e e!efde#e e!effd@ZedAejTeZejXjZZde#e e!efde#e e!effdBZejJejLedCdQdDZedEejTeZejXjZZdFZejJejLedGdQdHe#e!ejNfdIe9fdJZedKejTeZejXjZZdHe#e!ejNfdIe9fdLZejJejLedMdQdNZedOejTeZ ejXjZZ dPZ y(SzUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListAny) AnnotatedTV_XlaAllReduce_T_atypes.BFloat16_atypes.Float32 _atypes.Half _atypes.Int32_atypes.UInt32xla_all_reduceinputgroup_assignment reduce_opmodereturnc  tjxstj}|j}|jr t j |d|||d|d| }|St|||||fd}|tur|St/j0|d}t/j0|d} t3j4d|||||\} } } } | dd}t/j6rYd| j9dd| j;dd| j;df} | j<} t/j>d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rYRtt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw) aWraps the XLA AllReduce operator documented at https://www.tensorflow.org/xla/operation_semantics#allreduce. Args: input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `int32`, `uint32`. Array or a non-empty tuple of arrays to reduce across replicas. group_assignment: A `Tensor` of type `int32`. Groups between which the reductions are performed. reduce_op: A `string` from: `"Min", "Max", "Mul", "Add", "Mean"`. Reduction computation. mode: A `string` from: `"CrossReplica", "CrossReplicaAndPartition"`. group mode. CrossReplica: group_assignment contains replica_id. Each group contains the replicas for the current partition. CrossReplicaAndPartition: group_assignment contains replica_id. Each group contains the replicas for all partitions. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaAllReducerrN)rrnamectx)rrrrr!T) _contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException_dispatcher_for_xla_all_reduceNotImplementedxla_all_reduce_eager_fallback_SymbolicException TypeError ValueError _dispatchr rdict OpDispatcher NOT_SUPPORTED_executemake_str_op_def_library_apply_op_helpermust_record_gradient_get_attr_typeget_attrinputsrecord_gradient)rrrrr!_ctxtld_resulte__op_outputs_attrs _inputs_flats Z/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/compiler/tf2xla/ops/gen_xla_ops.pyrrs4    0h..0$ #\\ 11 ndE+;[64!gn4-  )T494AGn$ n ;7)   4 ($  )::e6F"+$TCAq#x QK' ""$3%%c*Kll;'f1EGF::L  fg7 (' .k  & &- ##At,,  # #    . "ItT ;TCg  & * !YT  # #  z "  "" B56F/8t*.!0 g  ..<< <   , Z    "d4D-6TN G i,,::: n  PD?' H(?FE--FF F6%F66H% AH%#H%(AJJzraw_ops.XlaAllReducec $tj|d}tj|d}tj|g|tjtj tj tjtjg\}\}tj|tj}||g}d|d|d|f}tjdd||||} tjrtjd||| | \} | S)Nrrr$s XlaAllReducer?attrsr"r!r r8r9args_to_matching_eager_dtypeshalfbfloat16float32int32uint32r+convert_to_tensorrr<r@) rrrrr!r"_attr_TrIrHrCs rJr0r0xs  ;7)   4 ($55ugsW\\SZScSceletetv}wDwDFMFTFTEWX'8E++,d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t||||fd}|tur|St|||||S#tj $rY#t"t$f$rJt'j(t*dt-||||}|t&j.j0ur|cYSwxYw#t"t$f$rJt'j(t*dt-||||}|t&j.j0ur|cYSwxYw)aHelper operator for performing XLA-style broadcasts Broadcasts `lhs` and `rhs` to the same rank, by adding size 1 dimensions to whichever of `lhs` and `rhs` has the lower rank, using XLA's broadcasting rules for binary operators. Args: lhs: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the LHS input tensor rhs: A `Tensor`. Must have the same type as `lhs`. the RHS input tensor broadcast_dims: A `Tensor`. Must be one of the following types: `int32`, `int64`. an XLA-style broadcast dimension specification name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (lhs_output, rhs_output). lhs_output: A `Tensor`. Has the same type as `lhs`. the broadcasted LHS tensor rhs_output: A `Tensor`. Has the same type as `lhs`. the broadcasted RHS tensor r[Nr!r"r#)rorprqr!r$Tindices) r%rr&r'rr(_XlaBroadcastHelperOutput_maker)r*r+r,r-$_dispatcher_for_xla_broadcast_helperr/#xla_broadcast_helper_eager_fallbackr1r2r3r4r rnr5r6r7r:r;r8r<r=r?r@) rorprqr!rArBrCrDrErFrGrHrIs rJrnrnsm0    0h..0$ #\\ 11 "D#sNDg)//8g n03 c>4)41Gn$ n  )::#3~#')Aq#x QK' ""$3%%c*J  ,.F::L lFG= % + +G 4' .c  & &- ##At,,  # #    4 ^T +T3g  & 0 sN499  # #  z " "" "ds:H04'6 g  ..<< <  & Z    DSc8F.2%4 G i,,::: n  sP0D# H #E*6EE*)E*.FFH.AHH AI" I"zraw_ops.XlaBroadcastHelperctj||g|tjtjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*g\}}|\}}tj|g|tj tjg\}\}|||g}d|d|f} tj,dd|| ||} tj.rtj0d|| | t2j5| } | S)Nr$rtsXlaBroadcastHelperrNr[)r8rQrRrUfloat64rVuint8int16int8 complex64int64qint8quint8qint32rTqint16quint16uint16 complex128rSrWuint64rr<r@rurv) rorprqr!r"rY _inputs_T_attr_TindicesrIrHrCs rJrxrxs;66Sz3ZaZiZikrkxkx{B{H{HJQJWJWY`YeYegngxgxzAzGzGIPIVIVX_XfXfhohvhvxxHxHJQJXJXZaZiZikrkyky{B{M{MOVO[O[]d]k]kmtm{m{I~'9*3&.&E&E~FVX[^e^k^kmtmzmz]}&~#.#>sN+, *n 5&   2Al#)s ?' ""$ lFG= % + +G 4' .rZxla_call_moduleFversionmodulehas_token_input_outputc  tjxstj} | j} | jr- t j | d| |d|d|d|d|d|d|d|d |d | } | St|||||||||| | f d } | tur| St/j0|d}t/j2|d}t5|t6t8fstd|z|Dcgc]}t/j:|d}}t5|t6t8fstd|z|Dcgc]}t/j<|d}}|g}t5|t6t8fstd|z|Dcgc]}t/j2|d}}|g}t5|t6t8fstd|z|Dcgc]}t/j2|d}}|g}t5|t6t8fstd|z|d}t/j>|d }| g} t5| t6t8fstd| z| Dcgc]}t/j2|d } } tAjBd|||||||||| |  \}}}}|d d } | s|St/jDrd|jGdd|jIdd|jIdd|jIdd|jIdd|jIdd|jIdd|jIdd |jKd d |jId f}|jL}t/jNd||| | S#t j$r }tj|| Yd }~nd }~wt j$rYnwxYw t|||||||||| | f d } | tur| St|||||||||| | | S#t j$rYtt f$rQt#j$t&d t)|||||||||| |  } | t"j*j,ur| cYSwxYwcc}wcc}wcc}wcc}wcc}w#tt f$rQt#j$t&d t)|||||||||| |  } | t"j*j,ur| cYSwxYw)aInvokes a StableHLO module. This op is used with JAX native serialization in a TensorFlow context with stability guarantees. Args: args: A list of `Tensor` objects. A list of `Tensor` with possibly different types to be passed as arguments to the `module`. These are the actual arguments and do not include the platform argument (see `platforms`) nor the dimension arguments (see `dim_args_spec`). version: An `int`. Tracks changes the semantics of the op, to support backwards compatibility. Minimum supported version is 2. From version 2, the op carries a StableHLO text or bytecode `module`. From version 3, the op also supports the `platforms` attribute. From version 4, the op carries a StableHLO module with compatibility guarantees. From version 5, XLACallModule can include `stablehlo.custom_call` op to execute tf functions. From version 6 the op supports the `disabled_checks` attribute. See more versioning details at https://github.com/search?q=repo%3Atensorflow%2Ftensorflow+path%3Axla_call_module+%22int+kVersionMaximumSupported%22&type=code. module: A `string`. A serialized computation, a text or bytecode representation of an mlir.Module. The return type must be a tuple if and only if the `Sout` is a list with 0 or more than 1 elements. The length of `Tout` and `Sout` must match. This op always returns a tuple of results, even if the module returns a single result. Sout: A list of shapes (each a `tf.TensorShape` or list of `ints`). List of output tensor shapes. Tout: A list of `tf.DTypes`. List of output tensor data types. dim_args_spec: An optional list of `strings`. Defaults to `[]`. this attribute is not supported anymore. platforms: An optional list of `strings`. Defaults to `[]`. the list of platforms supported by `module`. The list can contain the strings "CPU", "CUDA", "ROCM", or "TPU". It is an error to compile this op for a platform that does not appear in the list. This check can be disabled using `disabled_checks`. If the list contains more than one platform, then the `module` takes one additional 0-dimensional integer-tensor parameter in the first position, encoding the index in `platforms` of the current compilation platform. This parameter has value 0 if the plaform is not among `platforms` and the check has been disabled. The list can be empty in old versions (earlier than 6) to denote that no platform checking must be performed at loading time. function_list: An optional list of functions decorated with @Defun. Defaults to `[]`. This list contains the TensorFlow FunctionDefs that are used by the XLACallModule. If the XLACallModule contains `stablehlo.custom_call` operations, they can call TensorFlow graph functions outside of the XLACallModule. This `function_list` attribute registers the dependency of the XLACallModule on those functions. This attribute was added in version 5. has_token_input_output: An optional `bool`. Defaults to `False`. If true, the embedded StableHLO module's main function must take a `!stablehlo.token` as its first argument and returns a token as its first result. This can be used in conjunction with the TF2XLA's side effect mechanism in order to model side effects. This is used only in versions prior to version 9. After that, the number and position of tokens among the arguments and results are obtained from the main function type. This allows us to support more than one token and not necessarily at the start. disabled_checks: An optional list of `strings`. Defaults to `[]`. A list of strings describing the safety checks that were disabled at serialization time. This attribute was added in version 6. For more details see https://github.com/search?q=repo%3Agoogle%2Fjax+path%3Ajax_export+%22class+DisabledSafetyCheck%22&type=code. This list, supplemented with a comma-separate list of directives specified using the flag --tf_xla_call_module_disabled_checks, is used at module loading time to skip the corresponding checks. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `Tout`. XlaCallModulerrSoutTout dim_args_spec platforms function_listrdisabled_checksN) rrrrrrrrrr!r"r#) argsrrrrrrrrrr!BExpected list for 'Sout' argument to 'xla_call_module' Op, not %r.BExpected list for 'Tout' argument to 'xla_call_module' Op, not %r.KExpected list for 'dim_args_spec' argument to 'xla_call_module' Op, not %r.GExpected list for 'platforms' argument to 'xla_call_module' Op, not %r.KExpected list for 'function_list' argument to 'xla_call_module' Op, not %r.FMExpected list for 'disabled_checks' argument to 'xla_call_module' Op, not %r.Tin)(r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_call_moduler/xla_call_module_eager_fallbackr1r2r3r4r rr5r6r7r8make_intr9 isinstancelisttuple make_shape make_type make_boolr:r;r< _get_attr_intr>_get_attr_boolr?r@)rrrrrrrrrrr!rArBrCrD_s_trErFrGrHrIs rJrrsR    0h..0$ #\\  11 otT9gxfdO]Y "8:K g nD. wdM9- GHLNGn$ n   gy 1'   VX .& D4- (  (*. / 0059 9b(  b& ) 9$ 9 D4- (  (*. / 0048 8R(  R ( 8$ 8M MD%= 1  (*7 8 99ERRb8$$R9R-RI Ie} -  (*3 4 55=FFbx  [1F)FM MD%= 1  (*7 8 99#"#--.DF^_O OdE] 3  (*9 : ;;IXX"X&&r+<=X/X )::dGF"-#,M0F)8t EAq#x( QK'  J ""$**95xll8$fcll6.BFll6"E3<<+>s||OR  R+&RON..OO P,PQ8AQ86Q8AS42S4zraw_ops.XlaCallModulec tj|d}tj|d}t|tt fst d|z|D cgc]} tj| d}} t|tt fst d|z|D cgc]} tj| d}} |g}t|tt fst d|z|D cgc]} tj| d}} |g}t|tt fst d |z|D cgc]} tj| d }} |g}t|tt fst d |z|d }tj|d }| g} t| tt fst d| z| D cgc]} tj| d} } tj|| \}}t |}d|d|d|d|d|d|d |d|d |d| f}tjdt|||| | }tjrtjd||||Scc} wcc} wcc} wcc} wcc} w)NrrrrrrrrrrrFrrrrrs XlaCallModulerNr)r8rr9rrrr2rrrconvert_to_mixed_eager_tensorsrlenr<r@)rrrrrrrrrrr!r"rr _attr_TinrIrHrCs rJrrs   gy 1'   VX .& D4- (  (*. / 0059 9b(  b& ) 9$ 9 D4- (  (*. / 0048 8R(  R ( 8$ 8M MD%= 1  (*7 8 99ERRb8$$R9R-RI Ie} -  (*3 4 55=FFbx  [1F)FM MD%= 1  (*7 8 99#"#--.DF^_O OdE] 3  (*9 : ;;IXX"X&&r+<=X/X;;D#F/)Td, w&&$O]K=":+_ >&   -s4y#)s ?' ""$ vw8 ._ : 9SG YsI*I/'I42I9?I> TV_XlaConv_TTV_XlaConv_Tindicesxla_convwindow_stridespadding lhs_dilation rhs_dilationfeature_group_countdimension_numbersprecision_configc rtjxstj} | j} | jr% t j | d| |||||||d|d|} | St|||||||||| f d} | tur| St/j0|d}t/j0|d} t3j4d||||||||||  \}}}}|dd} t/j6rjd|j9dd |j9d d|j;dd|j;df}|j<}t/j>d||| | \} | S#t j$r } tj| | Yd} ~ nd} ~ wt j$rYnwxYw t|||||||||| f d} | tur| St|||||||||| |  S#t j$rYrtt f$rPt#j$t&dt)||||||||||  } | t"j*j,ur| cYSwxYw#tt f$rPt#j$t&dt)||||||||||  } | t"j*j,ur| cYSwxYw) aWraps the XLA ConvGeneralDilated operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#conv_convolution . Args: lhs: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the input tensor rhs: A `Tensor`. Must have the same type as `lhs`. the kernel tensor window_strides: A `Tensor`. Must be one of the following types: `int32`, `int64`. the inter-window strides padding: A `Tensor`. Must have the same type as `window_strides`. the padding to apply at the start and end of each input dimensions lhs_dilation: A `Tensor`. Must have the same type as `window_strides`. dilation to apply between input elements rhs_dilation: A `Tensor`. Must have the same type as `window_strides`. dilation to apply between kernel elements feature_group_count: A `Tensor`. Must have the same type as `window_strides`. number of feature groups for grouped convolution. dimension_numbers: A `string`. a serialized xla::ConvolutionDimensionNumbers proto. precision_config: A `string`. a serialized xla::PrecisionConfig proto. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `lhs`. XlaConvrrNrrr!r"r#) rorprrrrrrrr!r$rt) r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_convr/xla_conv_eager_fallbackr1r2r3r4r rr5r6r7r8r9r:r;r<r=r>r?r@)rorprrrrrrrr!rArBrCrDrErFrGrHrIs rJrrs(>    0h..0$ #\\  11 isCl$79L-/?Agn@' c>7L,.0@$ IJNPGn$ n''(9;NO&&'79KL )::sN" ,':%6$44 AAq#x& QK' ""$3%%c*J  ,.All./1Cll-.0F::L <2 (' .K  & &- ##At,,  # #    ( ^WlL 02BD K g  & $ sNG\< 1B+$DBB  # #  z "  "" b$3C.T K Gi,,::: n   sP#E1%IF&2F  F&%F&*G G I6AIIAJ64J6zraw_ops.XlaConvc  tj|d}tj|d}tj||g| tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\} } | \}}tj|||||g| tj tjg\} }|\}}}}}|||||||g}d| d| d|d|f}tj.dd||| | }tj0rtj2d||||\}|S) Nrrr$rtsXlaConvrMrNrr8r9rQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrrr<r@)rorprrrrrrrr!r"rYrr_inputs_TindicesrIrHrCs rJrrss''(9;NO&&'79KL66Sz3ZaZiZikrkxkx{B{H{HJQJWJWY`YeYegngxgxzAzGzGIPIVIVX_XfXfhohvhvxxHxHJQJXJXZaZiZikrkyky{B{M{MOVO[O[]d]k]kmtm{m{I~'9*3%-%D%DnV]_kmy|OFPRUX_XeXegngtgtWw&x"."O_L>7L,8KsNG\rr?r@)rorprrrrrrrrrr!rArBrCrDrErFrGrHrIs rJrrsH    0h..0$ #\\  11 k4c>7l$79L-/? "8:M g nJ* c>7L,.0@ 14 :;?AGn$ n''(9;NO&&'79KL#--.DF^_''(9;NO )::#n$<".)<'8&6,B'8tEAq#x2 QK' ""$c((0&  (*  ,.All./1Cll-.0H  !9:!3#4#45H#I KF::L \674 (' .q  & &- ##At,,  # #    + ^WlL 02B "3T <=ACg  & ' sNG\< 1B+!7-Dd DD  # #  z " "" Tcs1?*1 /;6I4E3C9O4E'+ -  g  ..<< <  P Z    r4CS/=(/l-94G2C1A7M2C%) +  Gi,,::: n  sP'G ''K HG88HH!I7IK%AKKAL)'L)zraw_ops.XlaConvV2c tj|d}tj|d}tj| d} | d} tj| d} tj|g| t j t jt jt jt jt jt jt jt jt jt j t j"t j$t j&t j(t j*t j,t j.t j0g\} \}tj|g| t j t jt jt jt jt jt jt jt jt jt j t j"t j$t j&t j(t j*t j,t j.t j0g\}\}tj|||||g| t jt jg\}}|\}}}}}|||||||g}d| d|d|d|d|d| d| f}tj2d d||| | }tj4rtj6d ||||\}|S) NrrrrMrrrrts XlaConvV2rNr)r8r9rrrQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrrr<r@)rorprrrrrrrrrr!r" _attr_LhsT _attr_RhsTrrrIrHrCs rJrrs}''(9;NO&&'79KL#--.DF^_''(9;NO66ucGOOU\UdUdfmfsfsu|vCvCELERERT[T`T`bibsbsu|uBuBDKDQDQSZSaSacjcqcqszsCsCELESESU\UdUdfmftftv}vHvHJQJVJVX_XfXfhohvhvDyz*fs66ucGOOU\UdUdfmfsfsu|vCvCELERERT[T`T`bibsbsu|uBuBDKDQDQSZSaSacjcqcqszsCsCELESESU\UdUdfmftftv}vHvHJQJVJVX_XfXfhohvhvDyz*fs%-%D%DnV]_kmy|OFPRUX_XeXegngtgtWw&x"."O_L>7L,8KsNG\r=r?r@)rrrrrr!rArBrCrDrErFrGrHrIs rJrr3s.    0h..0$ #\\ 11 otT=+.'5'5Jgn2. {NE5$@$HGn$ n!!+}=+$$^5EF.   UG ,%   eW -%  )::d (6e$41Aq#x QK' ""$S\\-8:Jll+,c3<<3Dg  )7CLL4IKF::L vw8 (' .q  & &- ##At,,  # #    / neUD BDJg  & + KU499  # #  z " "" R4[5C,1T"K g  ..<< <  0 Z    2t;3A*/u4 I G i,,::: n  sP!F!I>G%GGGH 9H I;!AI;9I;>AKKzraw_ops.XlaCustomCallc tj|d}tj|d}tj|d}tj|d}tj||\}}t |}d|d|d|d|d|f } tj dd|| ||} tjrtjd || | | \} | S) Nrrrrr$s XlaCustomCallrMrNr) r8r9rrrrrr<r@) rrrrrr!r"rYrIrHrCs rJrrs!!+}=+$$^5EF.   UG ,%   eW -%99$D-'4d, ;(8.# 7E7E +&   -q#)s ?' ""$ vw8 (' .rZxla_custom_call_v2call_target_namehas_side_effectctjxstj}|j}|jr% t j |d||d|d|d|d|d|} | St|||||||fd} | tur| St/j0|d}t/j0|d}t/j2|d}t5|t6t8fstd |z|D cgc]} t/j:| d}} t5|t6t8fstd |z|D cgc]} t/j<| d}} t?j@d||||||| \} } }}|dd} t/jBrd|jEdd|jEdd|jGdd |jEd d|jEdd|jEdf }|jH}t/jJd||| | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||fd} | tur| St||||||||S#t j$rY+tt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYwcc} wcc} w#tt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYw)aEmits an HLO `CustomCall` operation with multiple outputs. As opposed to `XlaCustomCall`, this operation supports multiple outputs. See `CustomCall` specification at https://tensorflow.org/xla/operation_semantics#customcall, and `mhlo.custom_call` specification at https://tensorflow.org/mlir/hlo_ops#mhlocustom_call_mlirmhlocustomcallop. Args: operands: A list of `Tensor` objects. A sequence of tensors with possibly different types. call_target_name: A `string`. Name of the user function. The function signature must conform to version 3 of the API, see `API_VERSION_STATUS_RETURNING_UNIFIED`. All operands and results assumed to be in the default layout. backend_config: A `string`. A string that encodes a metadata for the backend. has_side_effect: A `bool`. Indicates whether the custom call has side effects. result_dtypes: A list of `tf.DTypes`. Types of all results. result_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`). Shapes of all results. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `result_dtypes`. XlaCustomCallV2rrr result_dtypes result_shapesN)rrrrrr!r"r#)operandsrrrrrr!NExpected list for 'result_dtypes' argument to 'xla_custom_call_v2' Op, not %r.NExpected list for 'result_shapes' argument to 'xla_custom_call_v2' Op, not %r.operand_dtypes)&r%rr&r'rr(r)r*r+r,r-"_dispatcher_for_xla_custom_call_v2r/!xla_custom_call_v2_eager_fallbackr1r2r3r4r rr5r6r7r8r9rrrrrrr:r;r<r>rr?r@)rrrrrrr!rArBrCrDrrrErFrGrHrIs rJrrs@    0h..0$ #\\  11 x1C*N!3!34E!F -= >s||Orr?r@)rrrrrr!rArBrCrDrErFrGrHrIs rJrr@s8    0h..0$ #\\  11 otUKY.@gn4-  9d, FNg  & * 9 +$DBB  # #  z "  "" B5I/8t6F*.!0 g  ..<< <   2 Z    "d)-6T4D(,. G i,,::: n   sP!F!I-GF//GG G:(G::I*AI*(I*-AKKzraw_ops.XlaDequantizectj|d}tj|d}tj|d}tj|d}t j |t j}|g}d|d|d|d|f}tjdd||||} tjrtjd||| | \} | S) Nrrrrs XlaDequantizerMrNr) r8rr9rr+rXrRrWrr<r@) rrrrrr!r"rIrHrCs rJrrs!!)[9)!!)[9)   4 ($''(8:LM   7%, KFD& (&   -q#)s ?' ""$ vw8 (' .rZ TV_XlaDot_Txla_dotc  tjxstj}|j}|jr t j |d|||d|d| }|St|||||fd}|tur|St/j0|d}t/j0|d} t3j4d|||||\} } } } | dd}t/j6rYd| j9dd| j;dd| j;df} | j<} t/j>d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rYRtt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw) aWraps the XLA DotGeneral operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#dotgeneral . Args: lhs: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the LHS tensor rhs: A `Tensor`. Must have the same type as `lhs`. the RHS tensor dimension_numbers: A `string`. a serialized xla::DotDimensionNumbers proto. precision_config: A `string`. a serialized xla::PrecisionConfig proto. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `lhs`. XlaDotrrNrr#)rorprrr!r$) r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_dotr/xla_dot_eager_fallbackr1r2r3r4r rr5r6r7r8r9r:r;r<r=r>r?r@)rorprrr!rArBrCrDrErFrGrHrIs rJrrs*    0h..0$ #\\ 11 hc3(;-/?Agn2& c$&6>FGn$ n''(9;NO&&'79KL  )::cs6G#3$@Aq#x QK' ""$3%%c*,?ll./1Cll-.0F::L ,1 (' .k  & &- ##At,,  # #    ' &(8$ @$Hg  & # s&7+$DBB  # #  z " "" R#30A/?dL g  ..<< <  * Z    2t.?-=DJ G i,,::: n  rKzraw_ops.XlaDotctj|d}tj|d}tj||g|tjtj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,g\}}|\}}||g}d|d|d|f} tj.dd|| ||} tj0rtj2d|| | | \} | S)Nrrr$sXlaDotrMrNrr) rorprrr!r"rYrrIrHrCs rJrrs/''(9;NO&&'79KL66Sz3ZaZiZikrkxkx{B{H{HJQJWJWY`YeYegngxgxzAzGzGIPIVIVX_XfXfhohvhvxxHxHJQJXJXZaZiZikrkyky{B{M{MOVO[O[]d]k]kmtm{m{I~'9*3s, -/@& (&   Y,f!$4 1' ""$ ,1 (' .rZTV_XlaDotV2_LhsTTV_XlaDotV2_RhsT"TV_XlaDotV2_preferred_element_type xla_dot_v2c tjxstj}|j}|jr" t j |d|||d|d|d| }|St||||||fd}|tur|St/j0|d}t/j0|d}t/j2|d} t5j6d||||||\} } } } | dd}t/j8r{d | j;d d | j;d d| j=dd| j=dd| j;df } | j>}t/j@d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||fd}|tur|St|||||||S#t j$rYtt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw#tt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw) aWraps the XLA DotGeneral operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#dotgeneral . Args: lhs: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the LHS tensor rhs: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the RHS tensor dimension_numbers: A `string`. a serialized xla::DotDimensionNumbers proto. precision_config: A `string`. a serialized xla::PrecisionConfig proto. preferred_element_type: A `tf.DType` from: `tf.float32, tf.float64, tf.int32, tf.uint8, tf.int16, tf.int8, tf.complex64, tf.int64, tf.qint8, tf.quint8, tf.qint32, tf.bfloat16, tf.qint16, tf.quint16, tf.uint16, tf.complex128, tf.half, tf.uint32, tf.uint64`. The type of the tensor. name: A name for the operation (optional). Returns: A `Tensor` of type `preferred_element_type`. XlaDotV2rrrN)rrrr!r"r#)rorprrrr!rr)!r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_dot_v2r/xla_dot_v2_eager_fallbackr1r2r3r4r r r5r6r7r8r9rr:r;r<r=r>r?r@)rorprrrr!rArBrCrDrErFrGrHrIs rJr r &s 0    0h..0$ #\\  11 j$S*=-/? "8:gn:) c$&6 '(,.Gn$ n''(9;NO&&'79KL#--.DF^_ )::8I%5+ANAq#x QK' ""$c((0&  (*=ll./1Cll-.0H  !9: T+K g  ..<< <  $ Z    "B55<4)I Gi,,::: n  rzraw_ops.XlaDynamicUpdateSlicecjtj||g|g\}}|\}}tj|g|tjtjg\}\}|||g}d|d|f} tj dd|| ||} tj rtjd|| | | \} | S)Nr$rtsXlaDynamicUpdateSlicerMrNr$r) rr!r"r!r"rYrrrIrHrCs rJr&r&gs66vRP'9/5&'>>y#PWP]P]_f_l_lOop.*7), *n 5&   5q#)s ?' ""$ vw@ (' .rZTV_XlaEinsum_T xla_einsumabequationc tjxstj}|j}|jr t j |d|||d|}|St||||fd}|tur|St/j0|d} t3j4d||||\}}} } | dd}t/j6rHd| j9dd| j;df} | j<} t/j>d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY(tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw)aAn op which supports basic einsum op with 2 inputs and 1 output. This op has better TPU performance since it doesn't have explicitly reshape and transpose operations as tf.einsum does. Args: a: A `Tensor`. Must be one of the following types: `complex64`, `bfloat16`, `float32`. b: A `Tensor`. Must have the same type as `a`. equation: A `string`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `a`. XlaEinsumr,N)r,r!r"r#)r*r+r,r!r$) r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_einsumr/xla_einsum_eager_fallbackr1r2r3r4r r)r5r6r7r8r9r:r;r<r>r=r?r@) r*r+r,r!rArBrCrDrErFrGrHrIs rJr)r)xs[$    0h..0$ #\\ 11 k4Az8=g n,) Ax'Gn$ n   x 4(  )::qAt=Aq#x QK' ""$#,,z2C  %'F::L \674 (' .[  & &- ##At,,  # #    * a4 !4)g  & & Q$88  # #  z " "" D1H4H g  ..<< <  " Z    b$a(F Gi,,::: n  sPDG:E'EEEF 9F G7AG75G7:AIIzraw_ops.XlaEinsumcxtj|d}tj||g|tjtj tj g\}}|\}}||g}d|d|f}tjdd||||} tjrtjd||| | \} | S)Nr,r$s XlaEinsumrMrNr.) r8r9rQrRrrTrUrr<r@) r*r+r,r!r"rYrrIrHrCs rJr0r0s   x 4(661vsWEVEVX_XhXhjqjyjyD|}'9 &1aQ, #w /&   \1\#)s ?' ""$ \674 (' .rZTV_XlaGather_TrTV_XlaGather_Tindices xla_gatheroperand slice_sizesindices_are_sortedc :tjxstj}|j}|jr! t j |d||||d|d| }|St||||||fd}|tur|St/j0|d}t/j2|d} t5j6d||||||\} } } } | dd}t/j8rjd| j;dd| j=dd| j?dd | j?d f} | j@}t/jBd|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||fd}|tur|St|||||||S#t j$rYftt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw#tt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw) aWraps the XLA Gather operator documented at https://www.tensorflow.org/xla/operation_semantics#gather Args: operand: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`. The array we're gathering from. start_indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. Array containing the starting indices of the slices we gather. slice_sizes: A `Tensor`. Must have the same type as `start_indices`. slice_sizes[i] is the bounds for the slice on dimension i. dimension_numbers: A `string`. A serialized xla::GatherDimensionNumbers proto. indices_are_sorted: A `bool`. Boolean indicating if the indices are sorted. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `operand`. XlaGatherrr7N)rr7r!r"r#)r5rr6rr7r!r$rt)"r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_gatherr/xla_gather_eager_fallbackr1r2r3r4r r4r5r6r7r8r9rr:r;r<r>rr=r?r@)r5rr6rr7r!rArBrCrDrErFrGrHrIs rJr4r4s0    0h..0$ #\\  11 k4-.0Dgn:) -.?D #$(*Gn$ n''(9;NO))*<>RS )::WM!,'8(: GAq#x QK' ""$!3<<0C#D"C$6$67K$L3%%c*J  ,.F::L \674 (' .  & &- ##At,,  # #    * M;0A d %&*,g  & & =+-/dFF  # #  z "  "" D -83D4F&* , g  ..<< <   4 Z    b$wm+61B2D$( * Gi,,::: n   sPE)!H?F&FFFG :G H<"AH<:H<?AJJzraw_ops.XlaGatherc"tj|d}tj|d}tj|g|tj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0g\}\}tj||g|tjtjg\}} | \}}|||g} d|d|d|d|f} tj2dd| | ||} tj4rtj6d| | | | \} | S) Nrr7r$rts XlaGatherrMrNr9r8r9rrQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrboolrr<r@) r5rr6rr7r!r"rYrrrIrHrCs rJr;r;<s''(9;NO))*<>RS 77 3ZaZiZikrkxkx{B{H{HJQJWJWY`YeYegngxgxzAzGzGIPIVIVX_XfXfhohvhvxxHxHJQJXJXZaZiZikrkyky{B{M{MOVO[O[]d]k]kmtm{m{}D}I}IILM':G%-%D%DmU`EacfipivivxyFyFiI&J"."!1=+=+6, !24Hc7J @&   \1\#)s ?' ""$ \674 (' .rZ) TV_XlaIf_Tcondrrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlrxla_ifcondc tjxstj}|j}|jr" t j |d|||d|d|d| }|St||||||fd}|tur|St/|t0t2fstd |z|D cgc]} t5j6| d}} t9j:d||||||\} } } } | dd}|s| St5j<r{d | j?d d| jAdd| jAdd | jAd d| jAdf }| jB}t5jDd||||S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||fd}|tur|St|||||||S#t j$rYtt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYwcc} w#tt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw) a3output = cond ? then_branch(inputs) : else_branch(inputs). Args: cond: A `Tensor`. A boolean scalar. inputs: A list of `Tensor` objects. A list of input tensors. then_branch: A function decorated with @Defun. A function takes 'inputs' and returns a list of tensors, whose types are the same as what else_branch returns. else_branch: A function decorated with @Defun. A function takes 'inputs' and returns a list of tensors. whose types are the same as what then_branch returns. Tout: A list of `tf.DTypes`. name: A name for the operation (optional). Returns: A list of `Tensor` objects of type `Tout`. A list of tensors returned by either then_branch(inputs) or else_branch(inputs). The input shapes of the then_branch and else_branch must match. XlaIf then_branch else_branchrN)rDrErr!r"r#)rAr?rDrErr!9Expected list for 'Tout' argument to 'xla_if' Op, not %r.Tcondr)#r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_ifr/xla_if_eager_fallbackr1r2r3r4r r@r5r6r7rrrr8rr:r;r<r=r>r?r@)rAr?rDrErr!rArBrCrDrrErFrGrHrIs rJr@r@Ps0    0h..0$ #\\ 11 gtT6=+{FD2gn2% v{Kt=tEGn$ n D4- (  !% & ''48 8R(  R ( 8$ 8  )::d6{(t$@Aq#x QK'  J ""$s))'2Mll=)=ll=)5#,,u2Evll6"$F::L vw0 .s  & &- ##At,,  # #    & k4 ?Gg  & " K[$D**  # #  z " "" B$v)4+"&T3 g  ..<< <  & 9 Z    "dV'2DJ Gi,,::: n  sV F%I,!I1GF..GG G9'G99I)AI)'I)1AK  K z raw_ops.XlaIfc t|ttfstd|z|Dcgc]}t j |d}}t j |g|g\}\}t j||\} }|gt|z} d|d|d|d| d|f } t jdt|| | ||} t jrt jd | | | | Scc}w) NrFrrGrDrErsXlaIfrNrC) rrrr2r8rrQrrrr<r@) rAr?rDrErr!r"r _attr_TcondrrIrHrCs rJrIrIs D4- (  !% & ''48 8R(  R ( 8$ 8!88$bI+w==fcJ)V$v,&, [-m ui /&   Xs4y#)s ?' ""$ vw0 . 9sC+XlaKeyValueSort sorted_keys sorted_valuesTV_XlaKeyValueSort_K) TV_XlaKeyValueSort_Vrrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlrxla_key_value_sortkeysvaluesc tjxstj}|j}|jr1 t j |d|||}t j|}|St|||fd}|tur|S t3j4d|||\}}}} | dd}t7j8rHd|j;dd|j;df} |j<} t7j>d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||fd}|tur|St||||S#tj $rY t"t$f$rIt'j(t*dt-|||}|t&j.j0ur|cYSwxYw#t"t$f$rIt'j(t*dt-|||}|t&j.j0ur|cYSwxYw)aWraps the XLA Sort operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#sort . Sorts a tensor. Currently only sorts in ascending order are supported. Args: keys: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. A `Tensor` of type K. values: A `Tensor`. A `Tensor` of type V. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (sorted_keys, sorted_values). sorted_keys: A `Tensor`. Has the same type as `keys`. A `Tensor` of type K. sorted_values: A `Tensor`. Has the same type as `values`. A `Tensor` of type V. rLNrsr#)rRrSr!KV) r%rr&r'rr(_XlaKeyValueSortOutputrvr)r*r+r,r-"_dispatcher_for_xla_key_value_sortr/!xla_key_value_sort_eager_fallbackr1r2r3r4r rQr5r6r7r:r;r8r<r=r?r@) rRrSr!rArBrCrDrErFrGrHrIs rJrQrQsS.    0h..0$ #\\ 11 tV5g&,,W5g n,1 vtt%Gn$ n  )::V$@Aq#x QK' ""$3%%c*C1C1CC1H IF::L <: " ( ( 1' .W  & &- ##At,,  # #    2  'g  & . Tt--  # #  z " "" Dd6$M g  ..<< <  Z    b$Dd"K Gi,,::: n  sP/D H E'3EE'&E'+FFH)AH>HAIIzraw_ops.XlaKeyValueSortctj|g|tjtjtj tj tjtjtjtjtjtjtjtjg \}\}tj|g|g\}\}||g}d|d|f}tjdd||||}tj rtj"d|||t$j'|}|S)NrUrVsXlaKeyValueSortrzrNrL)r8rQrRrUr{rVr|r}r~rrTrrSrWrrr<r@rWrv) rRrSr!r"_attr_K_attr_VrIrHrCs rJrYrYs44dVS7??T[TcTcelerert{uBuBDKDQDQSZS_S_ahananpwp@p@BIBPBPRYR^R^`g`n`npwp~p~CAB'7D66xbI'9F, #w '&   /<#)s ?' ""$ <: " ( ( 1' .rZxla_optimization_barrierc 6tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aOWraps the XLA OptimizationBarrier operator. Documented at https://www.tensorflow.org/xla/operation_semantics#optimizationbarrier. Args: input: A list of `Tensor` objects. A Tuple of Arrays of any type. name: A name for the operation (optional). Returns: A list of `Tensor` objects. Has the same type as `input`. XlaOptimizationBarrierNrsr#rr!r$)r%rr&r'rr(r)r*r+r,r-(_dispatcher_for_xla_optimization_barrierr/'xla_optimization_barrier_eager_fallbackr1r2r3r4r r]r5r6r7r:r;r8r<r>r?r@ rr!rArBrCrDrErFrGrHrIs rJr]r]'s    0h..0$ #\\ 11 &e5g n,7 Gn$ n  ):: D:Aq#x QK' ""$3<<$ %F::L  ,A .U  & &- ##At,,  # #    8 $.$ g  & 4 d&&  # #  z " "" $b$U*F g  ..<< <  Z    "B5t(D Gi,,::: n  sPC"3G"D)5DD)(D)-E EF>(AF><F>AHHzraw_ops.XlaOptimizationBarrierctj||\}}t|}d|f}tjdt |||||}tj rtj d||||S)Nr$sXlaOptimizationBarrierrNr_r8rrrrr<r@rr!r"rYrIrHrCs rJrbrbmsx::5#F.'5e, >&   6E $0C"& ('""$  ,A .rZ) TV_XlaPad_Trrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlrTV_XlaPad_Tindicesxla_pad padding_value padding_low padding_highpadding_interiorc tjxstj}|j}|jr t j |d||||||}|St||||||fd}|tur|S t/j0d||||||\} } } } | dd}t3j4rHd| j7dd| j7df} | j8}t3j:d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||fd}|tur|St|||||||S#t j$rYtt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw#tt f$rLt#j$t&dt)||||||}|t"j*j,ur|cYSwxYw)aRWraps the XLA Pad operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#pad . Args: input: A `Tensor`. A `Tensor` of type T. padding_value: A `Tensor`. Must have the same type as `input`. A scalar `Tensor` of type T. padding_low: A `Tensor`. Must be one of the following types: `int32`, `int64`. the padding to apply at the start of each input dimensions. Must be a compile-time constant 1D tensor of length equal to rank of input. padding_high: A `Tensor`. Must have the same type as `padding_low`. the padding to apply at the end of each input dimension. Must be a compile-time constant 1D tensor of length equal to rank of input. padding_interior: A `Tensor`. Must have the same type as `padding_low`. the padding to apply between each input element. Must be a compile-time constant 1D tensor of length equal to rank of input, containing only non-negative values. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. A `Tensor` of type T. XlaPadNrsr#)rrjrkrlrmr!r$rt)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_padr/xla_pad_eager_fallbackr1r2r3r4r rir5r6r7r:r;r8r<r=r?r@)rrjrkrlrmr!rArBrCrDrErFrGrHrIs rJriri}s8    0h..0$ #\\ 11 he]Kgn6&  {L:J  Gn$ n )::]) #3$@Aq#x QK' ""$3%%c*J  ,.F::L ,1 (' .o  & &- ##At,,  # #    ' -lr?r@) rrurr!rArBrCrDrErFrGrHrIs rJrtrts$    0h..0$ #\\ 11 iw}kgn0'  UD*D2Gn$ n   UG ,%!!+}=+   eW -%  )::KuAq#x QK' ""$s))'2Mll=)7CLL4IKF::L <2 (' .g  & &- ##At,,  # #    ( +ud ,d4g  & $;e$  # #  z " "" b$U %*7 g  ..<< <  * Z    B5k#(t5 Gi,,::: n  sPE<H9F&FFFG8GH6AH64H69AJJzraw_ops.XlaRecvc4tj|d}tj|d}tj|d}g}d|d|d|f}tjdd||||}tj rtj d||||\}|S)NrrursXlaRecvrMrNrw)r8rr9rrr<r@)rrurr!r"rIrHrCs rJryryC s   UG ,%!!+}=+   eW -%, UM; G&   Zr?r@)rr}rrr!rArBrCrD_irErFrGrHrIs rJr|r|T s*    0h..0$ #\\ 11 k4 4Ji2gn2)  0'4A4IGn$ n (4- 8  #%9 : ;;SggB(++B0FGgg  )::5Z*>$41Aq#x QK' ""$3%%c*,Bll12Ill9%'F::L \674 (' .s  & &- ##At,,  # #    * *2GT CTKg  & & 2F$00  # #  z " "" Du6J)0t= g  ..<< <  &h Z    b$Uz4H'.T; G i,,::: n  sVE"I IF!-FF! F!%GGI'AI>IAJ" J"zraw_ops.XlaReducect|ttfstd|z|Dcgc]}t j |d}}t j ||g|tjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0tj2tj4tj6g\}}|\}}||g} d|d|d|f} t j8dd| | ||} t j:rt j<d| | | | \} | Scc}w) Nrrr$rs XlaReducerMrNr)rrrr2r8rrQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrr>rr<r@) rr}rrr!r"rrYrrIrHrCs rJrr s| (4- 8  #%9 : ;;SggB(++B0FGgg66z7JCRYRaRacjcrcrt{uBuBDKDQDQSZS`S`bibnbnpwpApACJCPCPRYR_R_ahaoaoqxqqAHAQAQSZSaSacjcrcrt{tBtBDKDVDVX_XdXdfmftftv}vDvDFMFRFRRUV'9!5*$, 02F W &   \1\#)s ?' ""$ \674 (' .hsG.TV_XlaReducePrecision_Txla_reduce_precision exponent_bits mantissa_bitsc tjxstj}|j}|jr t j |d||d|d|}|St||||fd}|tur|St/j0|d}t/j0|d} t3j4d||||\}}} } | dd}t/j6rYd| j9dd| j;dd| j;df} | j<} t/j>d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rYOtt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aWraps the XLA ReducePrecision operator documented at https://www.tensorflow.org/xla/operation_semantics#reduceprecision. Args: operand: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. array of floating-point type. exponent_bits: An `int`. number of exponent bits in lower-precision format mantissa_bits: An `int`. number of mantissa bits in lower-precision format name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `operand`. XlaReducePrecisionrrN)rrr!r"r#)r5rrr!r$) r%rr&r'rr(r)r*r+r,r-$_dispatcher_for_xla_reduce_precisionr/#xla_reduce_precision_eager_fallbackr1r2r3r4r rr5r6r7r8rr:r;r<r=rr?r@) r5rrr!rArBrCrDrErFrGrHrIs rJrr s$    0h..0$ #\\ 11 "D'? 7gn43 -6>Gn$ n##M?C-##M?C-  )::g],9FAq#x QK' ""$3%%c*O0/02F::L lFG= (' .o  & &- ##At,,  # #    4 M=$ 8$@g  & 0 m  # #  z "  "" "d79F9F04'6 g  ..<< <   , Z    D7D7D.2%4 G i,,::: n   sPD<%H"<FE**FFF1!F11HAHH"AI;9I;zraw_ops.XlaReducePrecisionctj|d}tj|d}tj|g|tjtj tj tjg\}\}|g}d|d|d|f}tjdd||||}tjrtjd||||\}|S)Nrrr$sXlaReducePrecisionrMrNr) r8rrQrRrTrSrUr{rr<r@) r5rrr!r"rYrIrHrCs rJrr s##M?C-##M?C- 77 3IYIY[b[g[gipixix{B{J{JIMN':G, /=/ &   2Al#)s ?' ""$ lFG= (' .rZTV_XlaReduceScatter_Txla_reduce_scatterscatter_dimensionc tjxstj}|j}|jr t j |d||||d|}|St|||||fd}|tur|St/j0|d} t3j4d|||||\} } } } | dd}t/j6rHd| j9dd| j;df} | j<} t/j>d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rY+tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw)aWraps the XLA ReduceScatter operator documented at https://www.tensorflow.org/xla/operation_semantics#reducescatter. Args: input: A `Tensor`. Must be one of the following types: `half`, `bfloat16`, `float32`, `int32`, `uint32`. Array or a non-empty tuple of arrays to reduce across replicas. group_assignment: A `Tensor` of type `int32`. Groups between which the reductions are performed. scatter_dimension: A `Tensor` of type `int32`. Dimension to scatter. reduce_op: A `string` from: `"Min", "Max", "Mul", "Add", "Mean"`. Reduction computation. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaReduceScatterrN)rr!r"r#)rrrrr!r$) r%rr&r'rr(r)r*r+r,r-"_dispatcher_for_xla_reduce_scatterr/!xla_reduce_scatter_eager_fallbackr1r2r3r4r rr5r6r7r8r9r:r;r<r=r>r?r@)rrrrr!rArBrCrDrErFrGrHrIs rJrr/ s*    0h..0$ #\\ 11  $/?; 3gn41  "3YFNGn$ n ;7) )::%:J.?&/d<Aq#x QK' ""$3%%c*Kll;')F::L L&'; (' .m  & &- ##At,,  # #    2 "$5y$ H$Pg  & . !#4   # #  z "  "" Du:J;L3<4%I g  ..<< <   , Z    b$U8H9J1:#G G i,,::: n   sPD HE*EEE"F=FG=$AG=;G=AIIzraw_ops.XlaReduceScatterc >tj|d}tj|g|tjtj tj tjtjg\}\}tj|tj}tj|tj}|||g}d|d|f}tjdd||||} tjrtjd||| | \} | S)Nrr$sXlaReduceScatterrMrNrrP) rrrrr!r"rYrIrHrCs rJrr s ;7)55ugsW\\SZScSceletetv}wDwDFMFTFTEWX'8E++, N)+<=, +y 1&   0!L#)s ?' ""$ L&'; (' .rZTV_XlaReduceWindow_TTV_XlaReduceWindow_Tindicesxla_reduce_windowwindow_dimensionsbase_dilationswindow_dilationsc tjxstj} | j} | jr# t j | d||||||||d| } | St|||||||||f d} | tur| S t/j0d||||||||| \} } }}|dd} t3j4rYd|j7dd|j7dd|j9df}|j:}t3j<d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||||f d} | tur| St||||||||||  S#t j$rY2tt f$rOt#j$t&dt)||||||||| } | t"j*j,ur| cYSwxYw#tt f$rOt#j$t&dt)||||||||| } | t"j*j,ur| cYSwxYw) aWraps the XLA ReduceWindow operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#reducewindow . Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`. the input tensor init_value: A `Tensor`. Must have the same type as `input`. a scalar representing the initial value for the reduction window_dimensions: A `Tensor`. Must be one of the following types: `int32`, `int64`. the shape of the window window_strides: A `Tensor`. Must have the same type as `window_dimensions`. the inter-window strides base_dilations: A `Tensor`. Must have the same type as `window_dimensions`. window_dilations: A `Tensor`. Must have the same type as `window_dimensions`. padding: A `Tensor`. Must have the same type as `window_dimensions`. the padding to apply at the start and end of each input dimensions computation: A function decorated with @Defun. a reducer function to apply name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaReduceWindow computationN)rr!r"r#) rr}rrrrrrr!r$rt)r%rr&r'rr(r)r*r+r,r-!_dispatcher_for_xla_reduce_windowr/ xla_reduce_window_eager_fallbackr1r2r3r4r rr5r6r7r:r;r8r<r=r>r?r@)rr}rrrrrrr!rArBrCrDrErFrGrHrIs rJrr s6    0h..0$ #\\  11 uj:K(8'{$gn>0  -~~'; 78<>Gn$ n ):::->*8*8,rr<r@)rr}rrrrrrr!r"rYrrrrIrHrCs rJrr s66z7JCRYRaRacjcrcrt{uBuBDKDQDQSZS`S`bibnbnpwpApACJCPCPRYR_R_ahaoaoqxqqAHAQAQSZSaSacjcrcrt{tBtBDKDVDVX_XdXdfmftftv}vDvDFMFRFRRUV'9!5*%-%D%DFWYgiwzJLSFTVY\c\i\ikrkxkx[{&|"."ScPnn6F%6Xhjqr, *nm  &   /<#)s ?' ""$ <: (' .rZ) "TV_XlaRemoveDynamicDimensionSize_Trrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlr!xla_remove_dynamic_dimension_size dim_indexc Ltjxstj}|j}|jr t j |d|||}|St|||fd}|tur|S t/j0d|||\}}}} | dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)asInverse of XlaSetDynamicDimensionSize. Make an xla bounded dynamic dimension into a static dimension. The bound of the size of dimension `dim_index` becomes the static dimension size. Args: input: A `Tensor`. dim_index: A `Tensor` of type `int32`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaRemoveDynamicDimensionSizeNrsr#)rrr!r$)r%rr&r'rr(r)r*r+r,r-1_dispatcher_for_xla_remove_dynamic_dimension_sizer/0xla_remove_dynamic_dimension_size_eager_fallbackr1r2r3r4r rr5r6r7r:r;r8r<r=r?r@) rrr!rArBrCrDrErFrGrHrIs rJrr s8"    0h..0$ #\\ 11 -tUIGg n0@  4!4)Gn$ n  )::'u .24Aq#x QK' ""$3%%c* +F::L 'vwH (' .a  & &- ##At,,  # #    A )T #T+g  & = 411  # #  z " "" -r4eBK=A4C g  ..<< <  & Z    +RE@I;?2A G i,,::: n  sPC)5G )D0<DD0/D04E EG1AGG AH#!H#z%raw_ops.XlaRemoveDynamicDimensionSizec.tj|g|g\}\}tj|tj }||g}d|f}tj dd||||}tjrtjd||||\}|S)Nr$sXlaRemoveDynamicDimensionSizerMrNr r8rQr+rXrRrVrr<r@)rrr!r"rYrIrHrCs rJrrh s55ugsBG'8E$$Y >)#, >&   =q$0C"& ('""$ 'vwH (' .rZxla_replica_idctjxstj}|j}|jr t j |d|}|St|fd}|tur|S t/j0d|\}}}}|dd}t3j4r&d}|j6} t3j8d| |||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|fd}|tur|St||S#t j$rYtt f$rGt#j$t&dt)|}|t"j*j,ur|cYSwxYw#tt f$rGt#j$t&dt)|}|t"j*j,ur|cYSwxYw)zrReplica ID. Args: name: A name for the operation (optional). Returns: A `Tensor` of type `int32`. XlaReplicaIdNrsr#)r!)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_replica_idr/xla_replica_id_eager_fallbackr1r2r3r4r rr5r6r7r:r;r8r<r?r@) r!rArBrCrDrErFrGrHrIs rJrrw s    0h..0$ #\\ 11 nd$g n,- Gn$ n  )::T#Aq#x QK' ""$ F::L  fg7 (' .W  & &- ##At,,  # #    . '4g  & *  # #  z " "" B$ g  ..<< <  Z    "do Gi,,::: n  sPC1F.D%DDDE4 EF+AF+)F+.AHHzraw_ops.XlaReplicaIdcg}d}tjdd||||}tjrtjd||||\}|S)Ns XlaReplicaIdrMrNr)r8rr<r@)r!r"rIrHrCs rJrr sX, &   _a #)s ?' ""$  fg7 (' .rZXlaRngBitGenerator output_keyoutputTV_XlaRngBitGenerator_dtypeTV_XlaRngBitGenerator_Tshapexla_rng_bit_generator algorithm initial_staterc *tjxstj}|j}|jr4 t j |d||||d|}t j|}|St|||||fd}|tur|S|t2j4}t7j8|d} t;j<d|||||\} } } } | dd}t7j>rHd| jAdd| jAdf} | jB} t7jDd| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||fd}|tur|St||||||S#tj $rYNt"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw#t"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw)aStateless PRNG bit generator. Wraps the XLA RngBitGenerator operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#rngbitgenerator. Args: algorithm: A `Tensor` of type `int32`. The PRNG algorithm to use, one of tf.random.Algorithm.{PHILOX, THREEFRY, AUTO_SELECT}. initial_state: A `Tensor` of type `uint64`. Initial state for the PRNG algorithm. For THREEFRY, it should be a u64[2] and for PHILOX a u64[3]. shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The output shape of the generated data. dtype: An optional `tf.DType` from: `tf.uint8, tf.int8, tf.int32, tf.int64, tf.uint32, tf.uint64`. Defaults to `tf.uint64`. The type of the tensor. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (output_key, output). output_key: A `Tensor` of type `uint64`. output: A `Tensor` of type `dtype`. rrN)rr!r"r#)rrrrr!Tshape)#r%rr&r'rr(_XlaRngBitGeneratorOutputrvr)r*r+r,r-%_dispatcher_for_xla_rng_bit_generatorr/$xla_rng_bit_generator_eager_fallbackr1r2r3r4r rr5r6r7rRrr8rr:r;r<r=r?r@)rrrrr!rArBrCrDrErFrGrHrIs rJrr s6    0h..0$ #\\  11 "D)]Eg*//8g n24 M5%7?Gn$ n ] NNE   UG ,%  ):: ,9$)6Aq#x QK' ""$s))'2H  *,F::L lFG= % + +G 4' .m  & &- ##At,,  # #    5 mUE4 94Ag  & 1 ]ETtMM  # #  z "  "" !2ti:G27u15(7 g  ..<< <   0 Z    TI8E05U&O G i,,::: n  sP2E7 H8F"E==FFG5GH5AH53H58AJJzraw_ops.XlaRngBitGeneratorcH|tj}tj|d}tj|g|tj tj gtj \}\}tj|tj }tj|tj}|||g}d|d|f}tjdd||||} tjrtjd||| tj| } | S)NrrsXlaRngBitGeneratorrzrNr)rRrr8rrQrVrr+rXrr<r@rrv) rrrrr!r" _attr_TshaperIrHrCs rJrr. s ] NNE   UG ,%#::E7C'--Y`YfYfIikrkxkxy,$$Y >)((G-]E2, UHl 3&   2Al#)s ?' ""$ lFG= % + +G 4' .rZTV_XlaScatter_TTV_XlaScatter_Tindices xla_scatterscatter_indicesupdatescltjxstj}|j}|jr# t j |d||||d|d|d| } | St|||||||fd} | tur| St/j0|d}t/j2|d} t5j6d|||||||\} } } } | dd} t/j8r{d| j;dd| j;dd| j=dd | j?d d | j?d f }| j@}t/jBd||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||fd} | tur| St||||||||S#t j$rYztt f$rMt#j$t&dt)|||||||} | t"j*j,ur| cYSwxYw#tt f$rMt#j$t&dt)|||||||} | t"j*j,ur| cYSwxYw) aWraps the XLA Scatter operator documented at https://www.tensorflow.org/xla/operation_semantics#scatter. Args: operand: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`. Array to be scattered into. scatter_indices: A `Tensor`. Must be one of the following types: `int32`, `int64`. Array containing the starting indices of the slices that must be scattered to. updates: A `Tensor`. Must have the same type as `operand`. Array containing the values that must be used for scattering. update_computation: A function decorated with @Defun. Computation to be used for combining the existing values in the input array and the updates during scatter. dimension_numbers: A `string`. A serialized xla::ScatterDimensionNumbers proto. indices_are_sorted: A `bool`. Boolean indicating if the indices are sorted. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `operand`. XlaScatterupdate_computationrr7N)rrr7r!r"r#)r5rrrrr7r!r$rt)"r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_scatterr/xla_scatter_eager_fallbackr1r2r3r4r rr5r6r7r8r9rr:r;r<r>rr=r?r@)r5rrrrr7r!rArBrCrDrErFrGrHrIs rJrrC s 8    0h..0$ #\\  11 lD'?G02E/1CEgn@* /7,>-t 67;=Gn$ n''(9;NO))*<>RS )::g%:L(9);$ HAq#x$ QK' ""$"CLL1E$F!3<<0C#D"C$6$67K$L3%%c*J  , .F ::L lFG5 (' .K  & &- ##At,,  # #    + OW.@ / 89=?g  & ' ?G/-/d FF  # #  z "  "" T'2A*15G4E5G'+ - g  ..<< <   8 Z    r40?(/3E2C3E%) + Gi,,::: n   sP!E(,"I(F/;FF/.F/3G#G##I9AIIAJ31J3zraw_ops.XlaScatterc&tj|d}tj|d}tj||g|tj tj tjtjtjtjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0g\}} | \}}tj|g|tjtjg\} \}|||g} d|d|d|d|d| f } tj2dd| | ||} tj4rtj6d | | | | \} | S) Nrr7rr$rts XlaScatterrMrNrr=)r5rrrrr7r!r"rYrrrIrHrCs rJrr s''(9;NO))*<>RS667I3QXQ`Q`bibqbqsztAtACJCPCPRYR_R_ahamamovo@o@BIBOBOQXQ^Q^`g`n`npwp~p~@G@P@PRYR`R`bibqbqszsAsACJCUCUW^WcWcelesesu|uCuCELEQEQQTU'9 7G'/'F'FGXZ]`g`m`movo|o|_(A$.$??G4, "46I)+=sG n &   ]Al#)s ?' ""$ lFG5 (' .rZTV_XlaSelectAndScatter_TTV_XlaSelectAndScatter_Tindicesxla_select_and_scattersourcec  tjxstj} | j} | jr$ t j | d|||||||d|d| } | St|||||||||f d} | tur| S t/j0d||||||||| \} } }}|dd} t3j4rjd|j7dd |j7d d|j9dd|j9df}|j:}t3j<d||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||||f d} | tur| St||||||||||  S#t j$rYCtt f$rOt#j$t&dt)||||||||| } | t"j*j,ur| cYSwxYw#tt f$rOt#j$t&dt)||||||||| } | t"j*j,ur| cYSwxYw) aWraps the XLA SelectAndScatter operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#selectandscatter . Args: operand: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the input tensor window_dimensions: A `Tensor`. Must be one of the following types: `int32`, `int64`. the shape of the window window_strides: A `Tensor`. Must have the same type as `window_dimensions`. the inter-window strides padding: A `Tensor`. Must have the same type as `window_dimensions`. the padding to apply at the start and end of each input dimensions source: A `Tensor`. Must have the same type as `operand`. a tensor of values to scatter init_value: A `Tensor`. Must have the same type as `operand`. a scalar representing the initial value for the output tensor select: A function decorated with @Defun. a selection function to apply scatter: A function decorated with @Defun. a scatter function to apply name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `operand`. XlaSelectAndScatterselectscatterN)rrr!r"r#) r5rrrrr}rrr!r$rt)r%rr&r'rr(r)r*r+r,r-&_dispatcher_for_xla_select_and_scatterr/%xla_select_and_scatter_eager_fallbackr1r2r3r4r rr5r6r7r:r;r8r<r=r>r?r@)r5rrrrr}rrr!rArBrCrDrErFrGrHrIs rJrr s:    0h..0$ #\\  11 #T74EXv7gn<5 #^WfFGT ,-13Gn$ n )::w1B. (' .A  & &- ##At,,  # #    6 %~w fgt ./35g  & 2 $ngv VW4TKK  # #  z "  "" "BW?P (' .rZXlaSelfAdjointEigwvTV_XlaSelfAdjointEig_Txla_self_adjoint_eiglowermax_iterepsilonc tjxstj}|j}|jr6 t j |d||d|d|d| }t j|}|St|||||fd}|tur|St3j4|d}t3j6|d}t3j8|d} t;j<d|||||\} } } } | dd}t3j>rjd| jAdd| jCdd| jEdd | jGd f} | jH} t3jJd| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||fd}|tur|St||||||S#tj $rYt"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw#t"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw) aComputes the eigen decomposition of a batch of self-adjoint matrices (Note: Only real inputs are supported). Computes the eigenvalues and eigenvectors of the innermost N-by-N matrices in tensor such that tensor[...,:,:] * v[..., :,i] = e[..., i] * v[...,:,i], for i=0...N-1. Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the input tensor. lower: A `bool`. a boolean specifies whether the calculation is done with the lower triangular part or the upper triangular part. max_iter: An `int`. maximum number of sweep update, i.e., the whole lower triangular part or upper triangular part based on parameter lower. Heuristically, it has been argued that approximately logN sweeps are needed in practice (Ref: Golub & van Loan "Matrix Computation"). epsilon: A `float`. the tolerance ratio. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (w, v). w: A `Tensor`. Has the same type as `a`. The eigenvalues in ascending order, each repeated according to its multiplicity. v: A `Tensor`. Has the same type as `a`. The column v[..., :, i] is the normalized eigenvector corresponding to the eigenvalue w[..., i]. rrrrN)rrrr!r"r#)r*rrrr!r$)&r%rr&r'rr(_XlaSelfAdjointEigOutputrvr)r*r+r,r-$_dispatcher_for_xla_self_adjoint_eigr/#xla_self_adjoint_eig_eager_fallbackr1r2r3r4r rr5r6r7r8rrrr:r;r<rrr>r=r?r@)r*rrrr!rArBrCrDrErFrGrHrIs rJrrL sD    0h..0$ #\\  11 !4GUJ)W&g)..w7g n23 E8Wd,d4Gn$ n   UG ,%   x 4(    3'  )::q%,49Aq#x QK' ""$s))'2J +Yll9%sC,>,>s,CEF::L \67< $ * *7 3' .k  & &- ##At,,  # #    4 eXw .6g  & 0 58W4  # #  z " "" "dQe4 )T4 )41g  & : Dt77  # #  z " "" *B5?H:>T1K g  ..<< <  & Z    ("d=F8<4/I G i,,::: n  sPC,7G,D3?DD32D37E!E!!G7AG GAH+)H+z"raw_ops.XlaSetDynamicDimensionSizecxtj|g|g\}\}tj|tj }tj|tj }|||g}d|f}tj dd||||}tjrtjd||||\}|S)Nr$sXlaSetDynamicDimensionSizerMrNrr) rrrr!r"rYrIrHrCs rJrrs55ugsBG'8E$$Y >)  gmm 4$D), >&   :A$0C"& ('""$ $lFGE (' .rZ) TV_XlaSharding_Trrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlr xla_shardingshardingc xtjxstj}|j}|jr t j |d||d|d|}|St||||fd}|tur|S|d}t/j0|d}|g}t3|t4t6fstd |z|Dcgc]}t/j8|d}} t;j<d||||\} } } } | dd}t/j>rYd | jAd d| jCdd| jCdf} | jD} t/jFd| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rYtt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYwcc}w#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aAn op which shards the input based on the given sharding attribute. It can selectively annotate a subset of tensor dimensions by skipping unspecified_dims, and the sharding annotation should be replicated in those dims. Args: input: A `Tensor`. sharding: An optional `string`. Defaults to `""`. unspecified_dims: An optional list of `ints`. Defaults to `[]`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaShardingrunspecified_dimsN)rrr!r"r#)rrrr!rKExpected list for 'unspecified_dims' argument to 'xla_sharding' Op, not %r.r$)$r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_shardingr/xla_sharding_eager_fallbackr1r2r3r4r rr5r6r7r8r9rrrrr:r;r<r=r>r?r@)rrrr!rArBrCrDrrErFrGrHrIs rJrrs$    0h..0$ #\\ 11 mT5*h,.gn2+ *D2D:Gn$ n H   x 4( $tUm 4  %'7 8 99K[[Bh'',>?[[  )::UX(8tEAq#x QK' ""$3%%c*Jll:&(:ll-.0F::L |VW6 (' .y  & &- ##At,,  # #    , (,d 4dII 5F<F##F<;F<G*G**IAII AJ97J9zraw_ops.XlaShardingc|d}tj|d}|g}t|ttfst d|z|Dcgc]}tj |d}}tj|g|g\}\}|g}d|d|d|f}tjdd||||} tjrtjd ||| | \} | Scc}w) Nrrrrr$s XlaShardingrMrNr) r8r9rrrr2rrQrr<r@) rrrr!r"rrYrIrHrCs rJrr)s H   x 4( $tUm 4  %'7 8 99K[[Bh'',>?[[55ugsBG'8E, *h0B &   ^Q|#)s ?' ""$ |VW6 (' .\sC) TV_XlaSort_Trrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlrxla_sortc >tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r7d|j7df} |j8} t3j:d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)axWraps the XLA Sort operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#sort . Sorts a tensor. Currently only sorts in ascending order are supported. Args: input: A `Tensor`. A `Tensor` of type T. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. A `Tensor` of type T. XlaSortNrsr#r`r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_sortr/xla_sort_eager_fallbackr1r2r3r4r r r5r6r7r:r;r8r<r=r?r@rcs rJr r Cs$    0h..0$ #\\ 11 iu&g n,' Gn$ n  )::T+Aq#x QK' ""$3%%c* +F::L <2 (' .W  & &- ##At,,  # #    ( $.$ g  & $ d&&  # #  z " "" b$U6 g  ..<< <  Z    B5t4 Gi,,::: n  sPC&3G&D-9DD-,D-1E EG,AGGAHHzraw_ops.XlaSortctj|g|g\}\}|g}d|f}tjdd||||}tjrtjd||||\}|S)Nr$sXlaSortrMrNr )r8rQrr<r@rfs rJrrs{55ugsBG'8E, >&   Zrjd | jAd d| jCdd| jEdd| jCdf} | jF}t/jHd|| ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rYtt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYwcc} w#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw) a(An op used by XLA SPMD partitioner to switch from automatic partitioning to manual partitioning. It annotates the input (full-shape, to be automatically partitioned) with the same sharding used by manual partitioning, and outputs a shard-shaped tensor to be consumed by later manually-partitioned ops. If the shape is not evenly partitionable, the padding region will be masked with 0s. The conversion can happen partially in subgroups, by specifying the dim attribute, where only that dim will be converted. Args: input: A `Tensor`. manual_sharding: A `string`. dim: An optional `int`. Defaults to `-1`. unspecified_dims: An optional list of `ints`. Defaults to `[]`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaSpmdFullToShardShaperrrN)rrrr!r"r#)rrrrr!r[Expected list for 'unspecified_dims' argument to 'xla_spmd_full_to_shard_shape' Op, not %r.r$)%r%rr&r'rr(r)r*r+r,r-,_dispatcher_for_xla_spmd_full_to_shard_shaper/+xla_spmd_full_to_shard_shape_eager_fallbackr1r2r3r4r rr5r6r7r8r9rrrrr:r;r<r=r>rr?r@)rrrrr!rArBrCrDrrErFrGrHrIs rJrrs3.    0h..0$ #\\ 11 'u6G%79IKgn6; &6>FGn$ n%%o7HI/[ C#u%# $tUm 4  57G H IIK[[Bh'',>?[[ )::!3B4D(, .Aq#x QK' ""$3%%c*,=ll,-u&(:ll-.0F::L !<B (' .K  & &- ##At,,  # #    < /3(8$ @$Hg  & 8 c+$DBB  # #  z "  "" ("dCR7:DT8< /> g  ..<< <   6\ Z    &DuAP58BR6: -< Gi,,::: n   sVF J 7 J G'3GG'&G'+HHJ-AJJAK(&K(zraw_ops.XlaSpmdFullToShardShapectj|d}|d}tj|d}|g}t|tt fst d|z|Dcgc]}tj|d}}tj|g|g\}\}|g}d|d|d|d|f} tjdd|| || } tjrtjd || | | \} | Scc}w) Nrrrrrr$sXlaSpmdFullToShardShaperMrNr) r8r9rrrrr2rQrr<r@) rrrrr!r"rrYrIrHrCs rJrrs%%%o7HI/[ C#u%# $tUm 4  57G H IIK[[Bh'',>?[[55ugsBG'8E, +_eS& (&   7$0C"& ('""$ !<B (' .\sC3) TV_XlaSpmdShardToFullShape_Trrr_r`rrrarrrrrrrbrrrcrdrerfrgrhrirrrjrrrkrlrxla_spmd_shard_to_full_shapec4tjxstj}|j}|jr# t j |d||d|d|d|d| }|St||||||fd}|tur|St/j0|d}t/j2|d}|d }t/j4|d}|g}t7|t8t:fstd |z|D cgc]} t/j4| d}} t=j>d|||||| \} } } } | dd}t/j@r{d | jCd d| jEdd| jEdd| jGdd| jEdf }| jH}t/jJd||||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t||||||fd}|tur|St|||||||S#t j$rYtt f$rLt#j$t&dt)|||||| }|t"j*j,ur|cYSwxYwcc} w#tt f$rLt#j$t&dt)|||||| }|t"j*j,ur|cYSwxYw) aAn op used by XLA SPMD partitioner to switch from manual partitioning to automatic partitioning. It converts the shard-shaped, manually partitioned input into full-shaped tensor to be partitioned automatically with the same sharding used by manual partitioning. The conversion can happen partially in subgroups, by specifying the dim attribute, where only that dim will be converted. Args: input: A `Tensor`. manual_sharding: A `string`. full_shape: A `tf.TensorShape` or list of `ints`. dim: An optional `int`. Defaults to `-1`. unspecified_dims: An optional list of `ints`. Defaults to `[]`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `input`. XlaSpmdShardToFullShaper full_shaperrN)rr rrr!r"r#)rrr rrr!r[Expected list for 'unspecified_dims' argument to 'xla_spmd_shard_to_full_shape' Op, not %r.r$)&r%rr&r'rr(r)r*r+r,r-,_dispatcher_for_xla_spmd_shard_to_full_shaper/+xla_spmd_shard_to_full_shape_eager_fallbackr1r2r3r4r rr5r6r7r8r9rrrrrr:r;r<r=r>rr?r@)rrr rrr!rArBrCrDrrErFrGrHrIs rJrr"si,    0h..0$ #\\  11 'u6Gz5#,.gn:; S2BDJ Gn$ n%%o7HI/"":|<*[ C#u%# $tUm 4  57G H IIK[[Bh'',>?[[ )::!3B.8c4D(, .Aq#x$ QK' ""$3%%c*,=ll,-|ll<(%1B1B51I #,,/A"BDF::L !<B (' .W  & &- ##At,,  # #    < /:s4Dd L g  & 8 Z$44TKK  # #  z "  "" ("dCR>H7:DT8< /> g  ..<< <   <\ Z    &DuAP?[[55ugsBG'8E, +_l eS,.> @&   7$0C"& ('""$ !<B (' .\s3D XlaSvd)sur TV_XlaSvd_Txla_svdc tjxstj}|j}|jr6 t j |d||d|d|d| }t j|}|St|||||fd}|tur|St3j4|d}t3j6|d}t3j8|d} t;j<d|||||\} } } } | dd}t3j>rjd| jAdd| jCdd| jCdd | jEd f} | jF} t3jHd| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||fd}|tur|St||||||S#tj $rYt"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw#t"t$f$rKt'j(t*dt-|||||}|t&j.j0ur|cYSwxYw) aComputes the eigen decomposition of a batch of self-adjoint matrices (Note: Only real inputs are supported). Computes the eigenvalues and eigenvectors of the innermost M-by-N matrices in tensor such that tensor[...,:,:] = u[..., :, :] * Diag(s[..., :]) * Transpose(v[...,:,:]). Args: a: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. the input tensor. max_iter: An `int`. maximum number of sweep update, i.e., the whole lower triangular part or upper triangular part based on parameter lower. Heuristically, it has been argued that approximately log(min (M, N)) sweeps are needed in practice (Ref: Golub & van Loan "Matrix Computation"). epsilon: A `float`. the tolerance ratio. precision_config: A `string`. a serialized xla::PrecisionConfig proto. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (s, u, v). s: A `Tensor`. Has the same type as `a`. Singular values. The values are sorted in reverse order of magnitude, so s[..., 0] is the largest value, s[..., 1] is the second largest, etc. u: A `Tensor`. Has the same type as `a`. Left singular vectors. v: A `Tensor`. Has the same type as `a`. Right singular vectors. r%rrrN)rrrr!r"r#)r*rrrr!r$)%r%rr&r'rr( _XlaSvdOutputrvr)r*r+r,r-_dispatcher_for_xla_svdr/xla_svd_eager_fallbackr1r2r3r4r r)r5r6r7r8rrr9r:r;r<rr>r=r?r@)r*rrrr!rArBrCrDrErFrGrHrIs rJr)r)s>    0h..0$ #\\  11 haXy',.g##G,g n0& Hg/7?Gn$ n   x 4(    3'&&'79KL  )::A'#3$@Aq#x QK' ""$#++J7ll9%'9ll-.S5G5G5LNF::L ,1    (' .i  & &- ##At,,  # #    ' h!14 94Ag  & # h+$DBB  # #  z " "" RHg/?dL g  ..<< <  * Z    2ta(G-=DJ Gi,,::: n  rzraw_ops.XlaSvdctj|d}tj|d}tj|d}tj|g|t j t jt jt jt jt jt jt jt jt jt j t j"t j$t j&t j(t j*t j,t j.t j0g\}\}|g}d|d|d|d|f}tj2dd||||} tj4rtj6d||| t8j;| } | S) Nrrrr$sXlaSvdrNr%)r8rrr9rQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrrr<r@r+rv) r*rrrr!r"rYrIrHrCs rJr-r-s-   x 4(    3'&&'79KL111#sW__goo_f_l_lnun{n{~E~K~KMTMYMY[b[l[lnun{n{}D}J}JLSLZLZ\c\j\jlsl|l|~E~L~LNUN]N]_f_m_movoAoACJCOCOQXQ_Q_ahaoao=rs-'4A, )W6HC "&   Y,f!$4 1' ""$ ,1    (' .rZTV_XlaVariadicReduce_Txla_variadic_reducec Xtjxstj}|j}|jr t j |d|||d|d| }|St|||||fd}|tur|St/|t0t2fstd|zt5|} t/|t0t2fstd |zt5|| k7rt!d t5|| fzt/|t0t2fstd |z|D cgc]} t7j8| d}} t;j<d|||||\} } } } | dd}t7j>rjd | jAd d | jCd d| jEdd| jEdf}| jF}t7jHd||||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rYtt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYwcc} w#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw)a*Wraps the variadic XLA Reduce operator. Semantics are documented at https://www.tensorflow.org/performance/xla/operation_semantics#variadic_reduce. This version is limited to operands of the same dtype. XlaVariadicReduceV2 is a version that supports heterogeneous operands. Args: input: A list of at least 1 `Tensor` objects with the same type in: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `qint16`, `quint16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`, `bool`. the input tensor(s) init_value: A list with the same length as `input` of `Tensor` objects with the same type as `input`. scalar initial value(s) for the reduction dimensions_to_reduce: A list of `ints`. dimension numbers over which to reduce reducer: A function decorated with @Defun. a reducer function to apply name: A name for the operation (optional). Returns: A list with the same length as `input` of `Tensor` objects with the same type as `input`. XlaVariadicReducerrNrr#rGExpected list for 'input' argument to 'xla_variadic_reduce' Op, not %r.LExpected list for 'init_value' argument to 'xla_variadic_reduce' Op, not %r.oList argument 'init_value' to 'xla_variadic_reduce' Op with length %d must match length %d of argument 'input'.VExpected list for 'dimensions_to_reduce' argument to 'xla_variadic_reduce' Op, not %r.Nr$)%r%rr&r'rr(r)r*r+r,r-#_dispatcher_for_xla_variadic_reducer/"xla_variadic_reduce_eager_fallbackr1r2r3r4r r1r5r6r7rrrrr8rr:r;r<rr=r>r?r@)rr}rrr!rArBrCrD_attr_NrrErFrGrHrIs rJr1r1(ss2    0h..0$ #\\ 11 !4  4iJgn22  0'4A4IGn$ n ED%= )  ,.3 4 55 J' Ju .  ,.8 9 :: _  4 Z'" # $$ (4- 8  ,.B C DDSggB(++B0FGgg  )::5Z2F%,49Aq#x QK' ""$3$$S)30B0B30G$cll3I&Ji02F::L \67< .M  & &- ##At,,  # #    3 *2GT CTKg  & / 2F$00  # #  z " "" T*?S29&F g  ..<< <  Bh Z    r4e =Q07d$D G i,,::: n  sVG!K < K!H(4HH('H(,IIK.AKKAL)'L)zraw_ops.XlaVariadicReducecRt|ttfstd|zt |}t|ttfstd|zt ||k7rt dt ||fzt|ttfstd|z|Dcgc]}t j|d}}t jt|t|z|tjtjtjtjtjtjtj tj"tj$tj&tj(tj*tj,tj.tj0tj2tj4tj6tj8tj:g\}} | d|g| |dz} | dd| ddgz} | \}}t|t|z} d|d|d|d |f} t j<d || | || } t j>rt j@d | | | | Scc}w) Nr4r5r6r7rrMr8r$rsXlaVariadicReducerNr3)!rrrr2rr3r8rrQrRrUr{rVr|r}r~rrrrrrTrrrrrSrWrr>rr<r@) rr}rrr!r"r;rrYrrIrHrCs rJr:r:sW ED%= )  ,.3 4 55 J' Ju .  ,.8 9 :: _  4 Z'" # $$ (4- 8  ,.B C DDSggB(++B0FGgg66tE{T*EU7UWZ]d]l]lnun}n}@G@M@MOVO\O\^e^k^kmtmymy{B{L{LNUN[N[]d]j]jlslzlz|C|J|JLSL\L\^e^l^lnun}n}FMMOVOaOacjcocoqxqqAHAOAOQXQ]Q]]`a'9'"#i&99)my}o-)!5*etJ//, #w(> 7 ,&   17$0C"& ('""$ \67< .hs#J$xla_variadic_reduce_v2c Btjxstj}|j}|jr t j |d|||d|d| }|St|||||fd}|tur|St/|t0t2fstd|z|D cgc]} t5j6| d}} t9j:d|||||\} } } } | dd}t5j<rYd | j?d d| j?dd| j?df} | j@}t5jBd|| ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rYitt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYwcc} w#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw) aWraps the variadic XLA Reduce operator. Semantics are documented at https://www.tensorflow.org/performance/xla/operation_semantics#variadic_reduce. This is an expanded version of XlaVariadicReduce, with support for operands of different dtypes, and improved shape inference. Args: inputs: A list of `Tensor` objects. the input tensor(s) init_values: A list of `Tensor` objects. Must have the same type as `inputs`. scalar initial value(s) for the reduction dimensions_to_reduce: A list of `ints`. dimension numbers over which to reduce reducer: A function decorated with @Defun. a reducer function to apply name: A name for the operation (optional). Returns: A list of `Tensor` objects. Has the same type as `inputs`. XlaVariadicReduceV2rrNrr#)r? init_valuesrrr!YExpected list for 'dimensions_to_reduce' argument to 'xla_variadic_reduce_v2' Op, not %r.r$)"r%rr&r'rr(r)r*r+r,r-&_dispatcher_for_xla_variadic_reduce_v2r/%xla_variadic_reduce_v2_eager_fallbackr1r2r3r4r r=r5r6r7rrrr8rr:r;r<r>r?r@)r?r@rrr!rArBrCrDrrErFrGrHrIs rJr=r=s0    0h..0$ #\\ 11 #T6; 4iJgn45 2GTCTKGn$ n (4- 8  /1E F GGSggB(++B0FGgg )::f+4H'.T;Aq#x QK' ""$3<<$&<ll12Ill9%'F::L |VW> .u  & &- ##At,,  # #    6 ; 4gt EtMg  & 2 +4H$00  # #  z "  "" "BF9DBV5<4)I g  ..<< <   (h Z    "d&7B@T3:'G G i,,::: n   sVE"H? IF)FFF!G <G H<#AH<:H<AJJzraw_ops.XlaVariadicReduceV2ct|ttfstd|z|Dcgc]}t j |d}}t j ||f|\}\}}t|t|z}d|d|d|f} t jdt||| ||} t jrt jd|| | | Scc}w)NrArr$rsXlaVariadicReduceV2rNr?) rrrr2r8rargs_to_mixed_eager_tensorsrrr<r@) r?r@rrr!r"rrYrIrHrCs rJrCrCs (4- 8  /1E F GGSggB(++B0FGgg#+#G#GQ\H]_b#c ' FKf[ 11, 02F W &   3S[$0C"& ('""$ |VW> .hsCxla_variadic_sort dimension is_stablec tjxstj}|j}|jr t j |d|||d|d| }|St|||||fd}|tur|St/j0|d} t3j4d|||||\} } } } | dd}t/j6rYd| j9dd| j9dd| j;df} | j<} t/j>d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||||fd}|tur|St||||||S#t j$rY8tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw#tt f$rKt#j$t&dt)|||||}|t"j*j,ur|cYSwxYw) aWraps the XLA Sort operator, documented at https://www.tensorflow.org/performance/xla/operation_semantics#sort . Sorts one or more tensors, with support for custom comparator, dimension, and is_stable attributes. Args: inputs: A list of `Tensor` objects. A list of `Tensor` of identical shape but possibly different types. dimension: A `Tensor` of type `int32`. The dimension along which to sort. Must be a compile-time constant. comparator: A function decorated with @Defun. A comparator function to apply to 2*N scalars and returning a boolean. N is the number of sort inputs. If you want to sort in ascending order then the comparator should perform a less-than comparison. is_stable: A `bool`. Whether to use stable sort. name: A name for the operation (optional). Returns: A list of `Tensor` objects. Has the same type as `inputs`. A list of `Tensor` of same shape and types as the `input`. XlaVariadicSort comparatorrHN)rKrHr!r"r#)r?rGrKrHr!r$) r%rr&r'rr(r)r*r+r,r-!_dispatcher_for_xla_variadic_sortr/ xla_variadic_sort_eager_fallbackr1r2r3r4r rFr5r6r7r8rr:r;r<r>rr?r@)r?rGrKrHr!rArBrCrDrErFrGrHrIs rJrFrF,s8    0h..0$ #\\ 11 vy,K,gn20 J 494AGn$ n  K8)  )::&I&0I $&Aq#x QK' ""$3<<$lll<(+  -/F::L <: .i  & &- ##At,,  # #    1 9j)T ;TCg  & - ) i  # #  z " "" r4v3=2;$$H g  ..<< <  * Z    RVy1;09"F G i,,::: n  sPD% H%E,8EE,+E,0F FH 2AH  H AI(&I(zraw_ops.XlaVariadicSortcztj|d}tj||\}}tj|t j }t||gz}d|d|d|f}tjdt|||||} tjrtjd||| | S)NrHr$rKsXlaVariadicSortrNrJ) r8rrr+rXrRrVrrrr<r@) r?rGrKrHr!r"rYrIrHrCs rJrMrMs  K8);;FCH/'6$$Y >)f +, , K K&   /V$0C"& ('""$ <: .rZ xla_whilec tjxstj}|j}|jr t j |d||d|d|}|St||||fd}|tur|S t/j0d||||\}}} } | dd}|s| St3j4rYd| j7dd| j7dd| j7df} | j8} t3j:d| | ||S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rY#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aoutput = input; While (Cond(output)) { output = Body(output) } Args: input: A list of `Tensor` objects. A list of input tensors whose types are T. cond: A function decorated with @Defun. A function takes 'input' and returns a tensor. If the tensor is a scalar of non-boolean, the scalar is converted to a boolean according to the following rule: if the scalar is a numerical value, non-zero means True and zero means False; if the scalar is a string, non-empty means True and empty means False. If the tensor is not a scalar, non-emptiness means True and False otherwise. body: A function decorated with @Defun. A function that takes a list of tensors and returns another list of tensors. Both lists have the same types as specified by T. name: A name for the operation (optional). Returns: A list of `Tensor` objects. Has the same type as `input`. A list of output tensors whose types are T. XlaWhilerAbodyN)rArRr!r"r#)rrArRr!r$)r%rr&r'rr(r)r*r+r,r-_dispatcher_for_xla_whiler/xla_while_eager_fallbackr1r2r3r4r rOr5r6r7r:r;r8r<r>r?r@) rrArRr!rArBrCrDrErFrGrHrIs rJrOrOsY4    0h..0$ #\\ 11 j$vtVTCg n,( dD"D*Gn$ n  )::%dDBAq#x QK'  J ""$3<<$fcll6.BFll6"$F::L L&'3 .[  & &- ##At,,  # #    ) $d $d,g  & % dDd<<  # #  z " "" r4e$TM g  ..<< <  Z    RE4dK Gi,,::: n  sPD9G6E#D>>EEF5FG3AG31G36AI Izraw_ops.XlaWhilectj||\}}t|}d|d|d|f}tjdt |||||}tj rtj d||||S)Nr$rArRsXlaWhilerNrQre) rrArRr!r"rYrIrHrCs rJrTrTs|::5#F.'5e, &$ 5&   [#e*\#)s ?' ""$ L&'3 .rZ)N)rMN( __doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr%rr)rr8tensorflow.python.frameworkrrRtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr r+r r:"tensorflow.python.util.deprecationr tensorflow.python.utilr r4 tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrradd_fallback_dispatch_listadd_type_based_api_dispatcherInt32strr to_raw_opr _tf_type_based_dispatcherDispatchr.r0 namedtuplerur^rmrnr[rwrxintr>rrrrrrrrrrrrrrrrrrrrrrrrrrrUInt32floatBFloat16rrrrrrrrrr r r r rrrrrrrrrrrr r$r%r&r(r)r.r/r0r2r3r4r9r:r;r?r@rCrHrIrWrOrPrQrLrXrYr]r_rarbrgrhrirorprqrsrtrwrxryr{r|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrUInt64rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r rrrrrrrrrrr"r#r+r(r)r%r,r-r0r1r3r9r:r=r?rBrCrFrJrLrMrOrQrSrTr#rZrJrpsj= 67179FK3IC86%%'/1CEVXfhwzJK %% (( T)C):$:;TyY\^e^k^kYkOlTy|TEHTXabegxbxXyT)&Tl1y/01OP !/!I!I!R!R 38I3I)J ^ghkmtmzmzhz^{ IL TW gpqtvGqGgH 3K22< " "";=OQegz}NPacqsBDSUdftvFHXZik|~NP`brtDFUV!()I?\k!l %% (( !"Ni-D(DENIVY[rVrLsNFOPSUsPsFtN#)&N`=Y;<^T^^L`=ab';'U'U'^'^$ Ys4>>/3RS "1"K"K"T"T6#6s6RV6r~'9;OQdfwzKM[]ln}NP^`prBDSUfhxzJL\^np@ 3_oV %% (( :j)C-.jYsL?P5QjclmpsFnFdGjR[\_at\tRujENORTgOgEhjxABEGZBZx[jr{|AT|TrUjjmjADjT]^aco^oTpj)&jX ')% &~t~~h'? @#==FF3 +4>>++F G )CCLLIc3D.D$EIVY[lVlLm@IJMOdJd@epyz}TzTpUenortIoIeJZcdgi~d~ZV_`cez`zV{PSgjDg|OXY\^A YA OB 2!P  %% (( TsTCTH^Tu~@CE[@[v\T)&Tl3 12>4>>/3RS "1"K"K"T"Tc3WmENORTjOjEk$ %% ((  x3xx^bx!)&xt7)56~t~~FX7YZ%7%Q%Q%Z%Z"#WZmq: %% (( \)C$78\U\W\\dg\{\PYZ]_f_o_oZoPp\)&\|3 12>4>>.3QR !/!I!I!R!R33F)GTYfksvKO_hilnun~n~i~_$m%79MObduxIKY[jl{}LN\^np@BQSdfvxHJZ\ln}~  %% (( 9O3 +,O9S+=M3NOcfOz}ONWX[]hXhNiO)&Ob %# $^T^^G%< =!;;DD #{*: ;)CQ\L\B]ruJM]fgjlwgw]x"-/ACWYlnBSUcetvEGVXfhxzJL[]np@BRTdfvxGH-/ACWYlnBSUcetvEGVXfhxzJL[]np@BRTdfvxGH%,-QSeg{~QSdfwyGIXZikz|JL\^npARTdfvxHJZ\k&l" %% (( <^Ic#334^9SJZEZ;[^ps^HK^eG^W`adfHaHWI^)&^@ )9' ( )C D'AAJJ9S2B-B#C)TWYiTiJj@CWZtVfopsuWpWfX&L %&C_Vef %% (( QYs,@'@AQR[\_a|\|R}QNWX[]xXxNyQIRSVXlSlImQ )&Qf7)56~t~~FW7XY$5$O$O$X$X! Ic;O6O,P ajknqLlLbM ]fgjlGgG]H Xabeg{b{X| %X $+,OQ`bq$r! %% (( %&OIc3M.M$NOXabehBcBYCONWX[]~X~NOOXY\^xYxOyO')&ObC "AB>4>>RjCkl+C+]+]+f+f( 9SB\=\3] gpqtwQrQhR ]fgjlMgM]N ^ghkmGhG^H )+=?RTef %% (( <C)C/0CYsN?R5SC_bCr{|BP}PsQC)&CJ +I) *>4>>*+E F 'AAJJ 3+>!? IcSaNaDb nq BKLOQ_L_B` )+=~Ocex{LN_aoq@BQSbdrtDFVXgiz|LN^`prBDST 7/Z %% (( <] #~"56]yQTVkQkGl]|EFIK`F`|a]vy]OS]clmpr@m@cA])&]~ +I) *>4>>*+E F 'AAJJyn1D'EV_`cez`zV{KTUXZoUoKpEH^br{|AO|OrP$@  %% (( 8V3./V)&Vp # /">4>> :99BB #~*= >$0//O$& 57IK\^oqBQSbdsuCEUWgiy{JKL  %% ((  GYs,@'@AG9UXZnUnKoG!)&GR7)56~t~~FX7YZ%7%Q%Q%Z%Z" Ic;O6O,P Zcdgi}d}Z~  %% (( %&=')&=~E#CD^T^^TlEmn+C+]+]+f+f( z 1?OT %% (( 9X9S+-.XykIY?ZXirsvyKtKjLX\efik}f}\~XR[\_as\sRtXDMNQS^N^D_X)&Xt %# $^T^^G%< =!;;DD )C,<"= iX[]hXhNi yBCFHZCZy[ ktuxzLuLkM ajknpBkBaC S\]`bm]mSn  D  %% (( :J$J3JYWZ\lWlMmJ)&JX ')% &~t~~h'? @#==FF #3 # \efik{f{\| )+=~Ocex{LN_aoq@BQSbdrtDFVXgiz|LN^`prBDST %% (( <Si^ 34S)CQ_L_B`SPYZ]_mZmPnS)&Sj +I) *>4>>*+E F 'AAJJYsN/B%CQZ[^`n[nQo_hiln|i|_}("";=OQbduxFG %% (( !"N)C1H,H"INZ]NnqNBKLOQhLhBiN#)&N`=Y;<^T^^L`=ab';'U'U'^'^$ 3@W;W1X il ~A QZ[^`w[wQx   79KM^`npBRS %% ((  Pi-B(BCPW`adfmfsfsasWtPJSTWY`YfYfTfJgPtwPGPQTVkQkGlP!)&Pd9978HZ9[\%7%Q%Q%Z%Z" Ys[orEGXZkm{}LN]_np~@PRbdsuFHXZjl|~NP_`%&C_Vef %% (( cYs,@'@AcyY\^rYrOscIRSVXsSsItcFOPSUpPpFqcCLMPRmMmCncBKLOQlLlBmcxABEGbBbxcc@IJMOcJc@dc )&cJ7)56~t~~FW7XY$5$O$O$X$X!Ic;O6O,P^ghknBiB_CXabegBbBXCU^_bd_U@R[\_a|\|R}QZ[^`{[{Q|GPQTVqQqGrOXY\^rYrOs"&-&h " %% (( ./EYs<^7^-_Eluvy|C|I|IwImJEZcdgiKdKZLE0)&EN!S *Q RSaSWSaSacDTE!F4U4o4o4x4x1 IcKmFm;)&;z1y/01OP !/!I!I!R!R  #w}}:L0M 3K228 &&C_VeguxHJZ\kl&'EXgh %% (( "#KRKYKY`dWYsGMM/A%BWS\]`bibpbp]pSqW{DEHJfEf{gWoJW$)&Wr=Y;<^T^^La=bc(=(W(W(`(`%Ic7==>P4QbkloqxqqlcAJSTWYuTuJvZ$+-?Qegz}NPacqsBDSUdftvFHXZik|~NP`brtDFUV !9?O\ %% (( =g3#78g9UXZpUpKqg}FGJL[G[}\gEHg^bgr{|AP|PrQg)&gR-Y+ ,^T^^K-H I )CCLL #2F(GZcdgid[ALUVY[jVjLkTWmqAJKNP_K_A`&##=?QSgi|PRcesuDFUWfhvxHJZ\km~@PRbdtvFHWX")*K_^m"n %% (( #$cIc3K.K$LcajknqPlPbQcclmprQmQcRc]fgjlKgK]LcV_`ce}`}V~cLUVY[sVsLtcU^_bd|_|U}c%)&cJ?i =>~t~~Nd?ef)?)Y)Y)b)b&9SBZ=Z3[pyz}@_{_q`r{|A`|`raluvy{ZvZl[enortLoLeM[dehjBeB[CdmnqsKnKdL 2;11#J !!9;MOcex{LN_aoq@BQSbdrtDFVXgiz|LN^`prBDST %% (( !"]Ic+A&AB]4][^]in]#)&]~;I9:>4>>J^;_`';'U'U'^'^$9S:P5P+QZ^jmx}"|  %% (( :< YsL01< < )&< z ')% &~t~~h'? @#==FFIc<.?$@s %% (( ??3 #56?ygmmI[?\?luvy|C|I|IwImJ?)&?B/i-.~t~~m/LM - G G P P  #w}}2D(E iX[]d]j]jXjNk |EFIKRKXKXFX|Y #*#b  %% (( +,F)C9X4X*YFfopsu|vCvCqCgDFLUVY[b[h[hVhLiFyBCFHgCgyhF-)&FPMY'KL^T^^\zM{|1O1i1i1r1r. 3HgCg9h u~@CELERER@RvS [dehjqjwjwew[x HQRUWvRvHw  D  %% (( >GI\^eiS #'7"78S3Snwx{~NyNoOS)&Sj/i-.~t~~l/KL +EENNy6F1F'GSVyBCFHXCXyY0|  %% (( :AIc</0A #|J[@\A)&AF ')% &~t~~h'? @#==FF 9S,->#? yY\^jYjOk  ' \  %% (( )*tvJLSWa #7S2S(Tagjapsa\efikGfG\Ha+)&aFG)$EF~t~~VrGst/K/e/e/n/n,yFbAb7cvyADfopsuQpQfR4 ' \  %% (( )*ACVX_cg #7S2S(Tggjg|ghqruwSrShTg+)&gRG)$EF~t~~VrGst/K/e/e/n/n,yFbAb7cvyMPr{|A]|]r^4' &&  m%79MObduxIKY[jl{}LN\^np@BQSdfvxHJZ\ln}~  %% (( 9Yyk)*YcYEY]`Y)&Yv %# $^T^^G%< =!;;DDi[(89SSXlo"!!9;M~_svIK\^oqAPRacrtBDTVfhwyJL\^np@BRTcd %% (( !dyc4J)JKdYbcghkcloEdEZFd")&dL;I9:>4>>J];^_&9&S&S&\&\#!iS CY8Y.Z!hqrvwzr{~TsTiU!H %% (( #$W%)&Wr?i =>~t~~Nd?ef)?)Y)Y)b)b&& %% (( U3 3E)FU_cU )&Un7)56~t~~FW7XY$5$O$O$X$X!  #w}}BT8U nr  %% (( ;K)&KZ )9' ( )B C%??HH rZ