Ë 2ÆVh<œãóP—ddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlmZddl mZdd lmZGd „de«Zed«d „«ZGd„de«Zed«dWd„«ZGd„de«Zed«dXd„«ZGd„de«Zed«d„«ZGd„de«Zed«d„«ZGd„de«Zed «d!„«ZGd"„d#e«Zed$«d%„«ZGd&„d'e«Zed(«d)„«Z Gd*„d+e«Z!ed,« dYd-„«Z"Gd.„d/e«Z#ed0«d1„«Z$Gd2„d3e«Z%ed4«d5„«Z&Gd6„d7e«Z'ed8«dZd9„«Z(ed:«d;„«Z)ed<«d=„«Z*Gd>„d?e«Z+ed@«dA„«Z,GdB„dCe«Z-edD«dE„«Z.dYdF„Z/GdG„dHe«Z0edI«d[dJ„«Z1edK«dL„«Z2GdM„dNe«Z3edO«dP„«Z4edQ«dR„«Z5edS«dT„«Z6edU«dV„«Z7y)\éN)Úbackend)Útree)Úkeras_export)ÚKerasTensor)Úany_symbolic_tensors)Úslice_along_axis)Ú Operation)Útraceback_utilscó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚMapcó"•—t‰|«y©N©ÚsuperÚ__init__©ÚselfÚ __class__s €úB/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/ops/core.pyrzMap.__init__óø€Ü ‰ÑÕócóB—tjj||«Sr)rÚcoreÚmap)rÚfÚxss rÚcallzMap.calls€Ü|‰|×Ñ 2Ó&Ð&rcó’‡—|d}|jdŠtj||«}ˆfd„}tj||«}|S)Nrcód•—t‰f|jz|j|j¬«S)N©ÚshapeÚdtypeÚsparse©rr!r"r#)ÚxÚns €rÚappend_batch_axisz2Map.compute_output_spec..append_batch_axiss)ø€ÜØd˜QŸW™W‘n¨A¯G©G¸A¿H¹Hôð r)r!rÚcompute_output_specrÚ map_structure)rrrr%Úyr'r&s @rr(zMap.compute_output_specsJø€Øˆq‰EˆØH‰HQ‰KˆÜ×'Ñ'¨¨1Ó-ˆô ô ×ÑÐ0°!Ó4ˆØˆr©Ú__name__Ú __module__Ú__qualname__rrr(Ú __classcell__©rs@rrrsø„ôò'örrz keras.ops.mapcóŽ—t|f«rt«j||«Stjj||«S)u…Map a function over leading array axes. Like Pythonâ€™s builtin map, except inputs and outputs are in the form of stacked arrays. Consider using the `vectorized_map()` transform instead, unless you need to apply a function element by element for reduced memory usage or heterogeneous computation with other control flow primitives. When `xs` is an array type, the semantics of `map()` are given by this Python implementation: ```python def map(f, xs): return np.stack([f(x) for x in xs]) ``` Args: f: Callable defines the function to apply element-wise over the first axis or axes of `xs`. xs: Values over which to map along the leading axis. Returns: Mapped values. Examples: >>> f = lambda x: x**2 >>> xs = keras.ops.arange(10) >>> ys = keras.ops.map(f, xs) >>> ys [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> f = lambda x: {"y1": x**2, "y2": x * 10} # Can have nested outputs >>> ys = keras.ops.map(f, xs) >>> ys["y1"] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> ys["y2"] [0, 10, 20, 30, 40, 50, 60, 70, 80, 90] )rrÚ symbolic_callrrr)rrs rrr#s;€ôP˜R˜EÔ"Ü‹u×"Ñ" 1 bÓ)Ð)Ü<‰<×Ñ˜A˜rÓ"Ð"rcó,‡—eZdZdˆfd„ Zd„Zd„ZˆxZS)ÚScancó>•—t‰|«||_||_yr)rrÚreverseÚunroll)rr6r7rs €rrz Scan.__init__Qsø€Ü ‰ÑÔØˆŒØˆrcót—tjj|||||j|j¬«S)N©r6r7)rrÚscanr6r7)rrÚinitrÚlengths rrz Scan.callVs3€Ü|‰|× Ñ Ø ˆtR˜¨¯©¸d¿k¹kð!ó ð rcó,—|€t|«}d}n7|t|«n$tj|«djd}|d}t j |||«\}}t |f|jz|j|j¬«}||fS©Nrr ) ÚintrÚflattenr!rr(rr"r#) rrr;rr<r&r%Úcarryr*s rr(zScan.compute_output_spec[s“€Ø ˆ:ÜF“ˆAØ‰AðÐ%ôF”ä—\‘\ "Ó% aÑ(×.Ñ.¨qÑ1ð ð 1‘ˆAä×.Ñ.¨q°$¸Ó:‰ˆˆqÜ˜q˜d Q§W¡W™n°A·G±GÀAÇHÁHÔMˆØaˆxˆr)Fér+r0s@rr4r4Psø„õò ö rr4zkeras.ops.scancó¤—t||f«rt||¬«j||||«Stjj||||||¬«S)aÈScan a function over leading array axes while carrying along state. When the type of `xs` is an array type or `None`, and the type of `ys` is an array type, the semantics of `scan()` are given roughly by this Python implementation: ```python def scan(f, init, xs, length=None): if xs is None: xs = [None] * length carry = init ys = [] for x in xs: carry, y = f(carry, x) ys.append(y) return carry, np.stack(ys) ``` The loop-carried value `carry` (`init`) must hold a fixed shape and dtype across all iterations. In TensorFlow, `y` must match `carry` in shape and dtype. This is not required in other backends. Args: f: Callable defines the logic for each loop iteration. This accepts two arguments where the first is a value of the loop carry and the second is a slice of `xs` along its leading axis. This callable returns a pair where the first represents a new value for the loop carry and the second represents a slice of the output. init: The initial loop carry value. This can be a scalar, tensor, or any nested structure. It must match the structure of the first element returned by `f`. xs: Optional value to scan along its leading axis. This can be a tensor or any nested structure. If `xs` is not provided, you must specify `length` to define the number of loop iterations. Defaults to `None`. length: Optional integer specifying the number of loop iterations. If `length` is not provided, it defaults to the sizes of leading axis of the arrays in `xs`. Defaults to `None`. reverse: Optional boolean specifying whether to run the scan iteration forward or in reverse, equivalent to reversing the leading axes of the arrays in both `xs` and in `ys`. unroll: Optional positive integer or boolean specifying how many scan iterations to unroll within a single iteration of a loop. If an integer is provided, it determines how many unrolled loop iterations to run within a single rolled iteration of the loop. If a boolean is provided, it will determine if the loop is completely unrolled (`unroll=True`) or left completely unrolled (`unroll=False`). Note that unrolling is only supported by JAX and TensorFlow backends. Returns: A pair where the first element represents the final loop carry value and the second element represents the stacked outputs of `f` when scanned over the leading axis of the inputs. Examples: >>> sum_fn = lambda c, x: (c + x, c + x) >>> init = keras.ops.array(0) >>> xs = keras.ops.array([1, 2, 3, 4, 5]) >>> carry, result = keras.ops.scan(sum_fn, init, xs) >>> carry 15 >>> result [1, 3, 6, 10, 15] r9)rr4r2rrr:)rr;rr<r6r7s rr:r:ls_€ôL˜T 2˜JÔ'Ü˜G¨FÔ3×AÑAØ ˆtR˜ó ð ô<‰<×ÑØ ˆ4V W°Vðóðrcó.‡—eZdZdˆfd„ Zdd„Zd„ZˆxZS)ÚAssociativeScancó0•—t‰|«||_yr)rrr6)rr6rs €rrzAssociativeScan.__init__¼sø€Ü ‰ÑÔØˆrcó\—tjj|||j|¬«S)N©r6Úaxis)rrÚassociative_scanr6)rrÚelemsrIs rrzAssociativeScan.callÀs+€Ü|‰|×,Ñ,Ø ˆu˜dŸl™l°ð-ó ð rcóà‡ —tj|«Š ‰ Dcgc]}|j|‘Œ}}tt |««dk7r2tdj ‰ Dcgc]}|j‘Œc}««‚tj|‰ Dcgc]}t|dd|¬«‘Œc}«}tj|||«}ˆ fd„}tj||«}|Scc}wcc}wcc}w)NrBzNArray inputs to associative_scan must have the same first dimension. (saw: {})r)rIcób•—t‰dj|j|j¬«Sr>r$)r%Ú elems_flats €rÚ_restore_shapez;AssociativeScan.compute_output_spec.._restore_shapeÕs)ø€ÜØ ‘m×)Ñ)°·±ÀÇÁôð r)rr@r!ÚlenÚsetÚ ValueErrorÚformatÚpack_sequence_asrrr(r)) rrrKrIÚelemÚlensr%Úy_specrOrNs @rr(z#AssociativeScan.compute_output_specÅsÝø€Ü—\‘\ %Ó(ˆ Ø-7Ö8 T— ‘ ˜4Ó Ð8ˆÐ8ÜŒs4‹y‹>˜QÒÜð-ß-3©VØ,6Ö7 DT—Z“ZÒ7ó.óð ô ×!Ñ!ØÀ*ÖM¸QÔ$ Q¨¨1°4Ö8ÒMó ˆô×,Ñ,¨Q°°1Ó5ˆô ô ×#Ñ# N°FÓ;ˆØˆ ùò)9ùò 8ùò Ns›C!ÁC&ÂC+ )F)rr+r0s@rrErE»sø„õó ö rrEzkeras.ops.associative_scancóš—t|f«rt|¬«j|||«Stjj||||¬«S)aL Performs a scan with an associative binary operation, in parallel. This operation his similar to `scan`, with the key difference that `associative_scan` is a parallel implementation with potentially significant performance benefits, especially when jit compiled. The catch is that it can only be used when `f` is a binary associative operation (i.e. it must verify `f(a, f(b, c)) == f(f(a, b), c)`). For an introduction to associative scans, refer to this paper: Blelloch, Guy E. 1990. [Prefix Sums and Their Applications]( https://www.cs.cmu.edu/~guyb/papers/Ble93.pdf). Args: f: A Python callable implementing an associative binary operation with signature `r = f(a, b)`. Function `f` must be associative, i.e., it must satisfy the equation `f(a, f(b, c)) == f(f(a, b), c)`. The inputs and result are (possibly nested Python tree structures of) array(s) matching `elems`. Each array has a dimension in place of the `axis` dimension. `f` should be applied elementwise over the `axis` dimension. The result `r` has the same shape (and structure) as the two inputs `a` and `b`. elems: A (possibly nested Python tree structure of) array(s), each with an `axis` dimension of size `num_elems`. reverse: A boolean stating if the scan should be reversed with respect to the `axis` dimension. axis: an integer identifying the axis over which the scan should occur. Returns: A (possibly nested Python tree structure of) array(s) of the same shape and structure as `elems`, in which the `k`'th element of `axis` is the result of recursively applying `f` to combine the first `k` elements of `elems` along `axis`. For example, given `elems = [a, b, c, ...]`, the result would be `[a, f(a, b), f(f(a, b), c), ...]`. Examples: >>> sum_fn = lambda x, y: x + y >>> xs = keras.ops.arange(5) >>> ys = keras.ops.associative_scan(sum_fn, xs, axis=0) >>> ys [0, 1, 3, 6, 10] >>> sum_fn = lambda x, y: [x[0] + y[0], x[1] + y[1], x[2] + y[2]] >>> xs = [keras.ops.array([[1, 2]]) for _ in range(3)] >>> ys = keras.ops.associative_scan(sum_fn, xs, axis=0) >>> ys [[1, 3], [1, 3], [1, 3]] )r6rH)rrEr2rrrJ)rrKr6rIs rrJrJÞsG€ôl˜U˜HÔ%Ü wÔ/×=Ñ=¸aÀÈÓMÐMÜ<‰<×(Ñ(¨¨E¸7ÈÐ(ÓNÐNrcó—eZdZd„Zd„Zy)ÚScattercóD—tjj|||«Sr)rrÚscatter©rÚindicesÚvaluesr!s rrzScatter.calls€Ü|‰|×#Ñ# G¨V°UÓ;Ð;rcó0—t||j¬«S©N©r"©rr"r]s rr(zScatter.compute_output_specó€Ü˜5¨¯©Ô5Ð5rN©r,r-r.rr(©rrrZrZs„ò<ó6rrZzkeras.ops.scattercó–—t|||f«rt«j|||«Stjj|||«S)aÉReturns a tensor of shape `shape` where `indices` are set to `values`. At a high level, this operation does `zeros[indices] = updates` and returns the output. It is equivalent to: ```python zeros = keras.ops.zeros(shape) output = keras.ops.scatter_update(zeros, indices, values) ``` Args: indices: A tensor or list/tuple specifying indices for the values in `values`. values: A tensor, the values to be set at `indices`. shape: Shape of the output tensor. Example: >>> indices = [[0, 1], [1, 1]] >>> values = np.array([1., 1.]) >>> keras.ops.scatter(indices, values, shape=(2, 2)) array([[0., 1.], [0., 1.]]) )rrZr2rrr\)r^r_r!s rr\r\!sC€ô4˜W f¨eÐ4Ô5Ü‹y×&Ñ& w°¸Ó>Ð>Ü<‰<×Ñ ¨°Ó7Ð7rcó—eZdZd„Zd„Zy)Ú ScatterUpdatecóD—tjj|||«Sr)rrÚscatter_update©rÚinputsr^Úupdatess rrzScatterUpdate.callAs€Ü|‰|×*Ñ*¨6°7¸GÓDÐDrcóD—t|j|j¬«Sra©rr!r"rls rr(z!ScatterUpdate.compute_output_specDó€Ü˜6Ÿ<™<¨v¯|©|Ô<Ð˜V ]°GÐ<Ô=Ü‹}×*Ñ*¨6°=À'ÓJÐJÜ<‰<×$Ñ$ V¨]¸GÓDÐDrcó—eZdZd„Zd„Zy)ÚSwitchcóD—tjj||g|¢ŽSr)rrÚswitch)rÚindexÚbranchesÚoperandss rrzSwitch.callÐs€Ü|‰|×"Ñ" 5¨(Ð>°XÒ>Ð>rcó8—tj|dg|¢Ž}|S©Nr)rr()rr†r‡rˆÚspecs rr(zSwitch.compute_output_specÓs €ä×*Ñ*¨8°A©;ÐB¸ÒBˆØˆrNrerfrrrƒrƒÏs„ò?órrƒzkeras.ops.switchcó’—t|«rt«j||g|¢ŽStjj ||g|¢ŽS)aëApply exactly one of the `branches` given by `index`. If `index` is out of bounds, it is clamped to within bounds. The semantics of `switch` are given roughly by this Python implementation: ```python def switch(index, branches, *operands): index = clamp(0, index, len(branches) - 1) return branches[index](*operands) ``` Args: index: An integer scalar indicating which branch function to apply. branches: A sequence of functions to be applied based on `index`. operands: Inputs to whichever branch is applied. Returns: The outputs of `branch(*operands)` for the branch that was selected based on `index`. Examples: >>> add_fn = lambda x, y: x + y >>> subtract_fn = lambda x, y: x - y >>> x = keras.ops.array(2.0) >>> y = keras.ops.array(0.5) >>> branches = [add_fn, subtract_fn] >>> keras.ops.switch(0, branches, x, y) 2.5 >>> keras.ops.switch(1, branches, x, y) 1.5 )rrƒr2rrr…)r†r‡rˆs rr…r…ÙsE€ôH˜HÔ%Ø%Œv‹x×%Ñ% e¨XÐA¸ÒAÐAÜ<‰<×Ñ˜u hÐ:°Ò:Ð:rcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)Ú WhileLoopcóL•—t‰|«||_||_||_yr)rrÚcondÚbodyÚmaximum_iterations)rrr‘r’rs €rrzWhileLoop.__init__s$ø€Ü ‰ÑÔØˆŒ ØˆŒ Ø"4ˆÕrcó„—tjj|j|j||j ¬«S)N©r’)rrÚ while_looprr‘r’)rÚ loop_varss rrzWhileLoop.call s8€Ü|‰|×&Ñ&ØI‰IØI‰IØØ#×6Ñ6ð 'ó ð rcój—|Dcgc]#}t|j|j¬«‘Œ%c}Scc}wrarp)rr–Úvs rr(zWhileLoop.compute_output_specs%€Ø=FÖG¸”˜AŸG™G¨1¯7©7Ö3ÒGÐGùÒGs…(0r+r0s@rrŽrŽsø„ô5ò öHrrŽzkeras.ops.while_loopcóH—tjj||||¬«S)a‡While loop implementation. Args: cond: A callable that represents the termination condition of the loop. Must accept a `loop_vars` like structure as an argument. If `loop_vars` is a tuple or list, each element of `loop_vars` will be passed positionally to the callable. body: A callable that represents the loop body. Must accept a `loop_vars` like structure as an argument, and return update value with the same structure. If `loop_vars` is a tuple or list, each element of `loop_vars` will be passed positionally to the callable. loop_vars: An arbitrary nested structure of tensor state to persist across loop iterations. maximum_iterations: Optional maximum number of iterations of the while loop to run. If provided, the `cond` output is AND-ed with an additional condition ensuring the number of iterations executed is no greater than `maximum_iterations`. Returns: A list/tuple of tensors, has the same shape and dtype as `inputs`. Examples: >>> i = 0 >>> cond = lambda i: i < 10 >>> body = lambda i: i + 1 >>> keras.ops.while_loop(cond, body, i) 10 >>> x, y = 0, 1 >>> cond = lambda x, y: x < 10 >>> body = lambda x, y: (x + 1, y + 1) >>> keras.ops.while_loop(cond, body, (x, y)) 10, 11 r”)rrr•)rr‘r–r’s rr•r•s-€ôT<‰<×"Ñ"ØØØØ-ð #óðrcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚStopGradientcó"•—t‰|«yrrrs €rrzStopGradient.__init__Hrrcó@—tjj|«Sr)rrÚ stop_gradient©rÚvariables rrzStopGradient.callKs€Ü|‰|×)Ñ)¨(Ó3Ð3rcóD—t|j|j¬«SrarprŸs rr(z StopGradient.compute_output_specNó€Ü˜8Ÿ>™>°·±Ô@Ð@rr+r0s@rr›r›Gsø„ôò4öArr›zkeras.ops.stop_gradientcóŠ—t|f«rt«j|«Stjj|«S)a‚Stops gradient computation. Args: variable: A tensor variable for which the gradient computation is to be disabled. Returns: The variable with gradient computation disabled. Examples: >>> var = keras.backend.convert_to_tensor( ... [1., 2., 3.], ... dtype="float32" ... ) >>> var = keras.ops.stop_gradient(var) )rr›r2rrrž)r s rržržRs6€ô&˜X˜KÔ(Ü‹~×+Ñ+¨HÓ5Ð5Ü<‰<×%Ñ% hÓ/Ð/rcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚForiLoopcóL•—t‰|«||_||_||_yr)rrÚlowerÚupperÚbody_fun)rr§r¨r©rs €rrzForiLoop.__init__ks#ø€Ü ‰ÑÔØˆŒ ØˆŒ Ø ˆ rcó‚—tjj|j|j|j |«Sr)rrÚ fori_loopr§r¨r©©rÚinit_vals rrz ForiLoop.callqs1€Ü|‰|×%Ñ%ØJ‰JØJ‰JØM‰MØó ð rcóD—t|j|j¬«Srarpr¬s rr(zForiLoop.compute_output_specyr¢rr+r0s@rr¥r¥jsø„ô!ò öArr¥zkeras.ops.fori_loopcóš—t|||f«rt|||«j|«Stjj||||«S)a‘For loop implementation. Args: lower: The initial value of the loop variable. upper: The upper bound of the loop variable. body_fun: A callable that represents the loop body. Must take two arguments: the loop variable and the loop state. The loop state should be updated and returned by this function. init_val: The initial value of the loop state. Returns: The final state after the loop. Example: >>> lower = 0 >>> upper = 10 >>> body_fun = lambda i, s: (i + 1, s + i) >>> init_val = 0 >>> keras.ops.fori_loop(lower, upper, body_fun, init_val) 45 )rr¥r2rrr«)r§r¨r©rs rr«r«}sH€ô0˜U E¨8Ð4Ô5Ü˜˜u hÓ/×=Ñ=¸hÓGÐGÜ<‰<×!Ñ! %¨°¸(ÓCÐCrcó,‡—eZdZdˆfd„ Zd„Zd„ZˆxZS)ÚUnstackcó>•—t‰|«||_||_yr)rrÚnumrI)rr³rIrs €rrzUnstack.__init__›sø€Ü ‰ÑÔØˆŒØˆ rcól—tjj||j|j«Sr)rrÚunstackr³rI©rr%s rrzUnstack.call s#€Ü|‰|×#Ñ# A t§x¡x°·±Ó;Ð;rcóp—|j}|dkrt|j«|z}|jd||j|dzdz}|j}|€|j|}|€t d|j›d«‚t|«Dcgc]}t ||j¬«‘Œ}}|Scc}w)NrrBz'Cannot infer argument `num` from shape zn. Either provide a tensor with a concrete shape in the `axis` dimension or explicitly pass the `num` argument.©r!r")rIrPr!r³rRÚrangerr")rr%rIÚ output_shapesr³Ú_Úoutputs rr(zUnstack.compute_output_spec£sÃ€Øy‰yˆØ!Š8Üq—w‘w“< $Ñ&ˆDØŸ™ ˜¨¯©°¸±°Ð)<Ñ<ˆ Øh‰hˆØˆ;Ø—'‘'˜$‘-ˆCØˆ;ÜØ9Ø—7‘7)ð6ð6óð ôFKÈ3ÃZö Ø@AŒK˜m°1·7±7Ö;ð ˆð ðˆ ùò sÂB3rŠr+r0s@rr±r±šsø„õò <örr±zkeras.ops.unstackcó”—t|f«rt||«j|«Stjj|||¬«S)aËUnpacks the given dimension of a rank-R tensor into rank-(R-1) tensors. Args: x: The input tensor. num: The length of the dimension axis. Automatically inferred if `None`. axis: The axis along which to unpack. Returns: A list of tensors unpacked along the given axis. Example: >>> x = keras.ops.array([[1, 2], [3, 4]]) >>> keras.ops.unstack(x, axis=0) [array([1, 2]), array([3, 4])] )r³rI)rr±r2rrrµ)r%r³rIs rrµrµ¸sB€ô&˜Q˜DÔ!Üs˜DÓ!×/Ñ/°Ó2Ð2Ü<‰<×Ñ s°ÐÓ6Ð6rzkeras.ops.shapecóp—t|f«r|jStjj|«S)aKGets the shape of the tensor input. Note: On the TensorFlow backend, when `x` is a `tf.Tensor` with dynamic shape, dimensions which are dynamic in the context of a compiled function will have a `tf.Tensor` value instead of a static integer value. Args: x: A tensor. This function will try to access the `shape` attribute of the input tensor. Returns: A tuple of integers or None values, indicating the shape of the input tensor. Example: >>> x = keras.ops.zeros((8, 12)) >>> keras.ops.shape(x) (8, 12) )rr!rr©r%s rr!r!Ðs,€ô,˜Q˜DÔ!Øw‰wˆÜ<‰<×Ñ˜aÓ Ð rzkeras.ops.dtypecó@—tj|j«S)aòReturn the dtype of the tensor input as a standardized string. Note that due to the standardization, the dtype will not compare equal to the backend-specific version of the dtype. Args: x: A tensor. This function will try to access the `dtype` attribute of the input tensor. Returns: A string indicating the dtype of the input tensor, e.g. `"float32"`. Example: >>> x = keras.ops.zeros((8, 12)) >>> keras.ops.dtype(x) 'float32' )rÚstandardize_dtyper"r¿s rr"r"ës€ô*×$Ñ$ Q§W¡WÓ-Ð-rcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚCastcóV•—t‰|«tj|«|_yr©rrrrÁr"©rr"rs €rrz Cast.__init__ó ø€Ü ‰ÑÔÜ×.Ñ.¨uÓ5ˆ rcóV—tjj||j«Sr)rrÚcastr"r¶s rrz Cast.calls€Ü|‰|× Ñ D§J¡JÓ/Ð/rcóX—tj|j|j¬«S©Nr¸©rrr!r"r¶s rr(zCast.compute_output_specó€Ü×"Ñ"¨¯©¸¿ ¹ ÔCÐCrr+r0s@rrÃrÃsø„ô6ò0öDrrÃzkeras.ops.castcó¨—tj|«}t|f«rt|¬«|«Stjj||«S)aCast a tensor to the desired dtype. Args: x: A tensor or variable. dtype: The target type. Returns: A tensor of the specified `dtype`. Example: >>> x = keras.ops.arange(4) >>> x = keras.ops.cast(x, dtype="float16") rb)rrÁrrÃrrÉ©r%r"s rrÉrÉsG€ô ×%Ñ% eÓ,€Eä˜Q˜DÔ!Ø Œt˜%Ô Ó#Ð#Ü<‰<×Ñ˜Q Ó&Ð&rcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚSaturateCastcóV•—t‰|«tj|«|_yrrÅrÆs €rrzSaturateCast.__init__'rÇrcó.—t||j«Sr)Ú_saturate_castr"r¶s rrzSaturateCast.call+s€Ü˜a §¡Ó,Ð,rcóX—tj|j|j¬«SrËrÌr¶s rr(z SaturateCast.compute_output_spec.rÍrr+r0s@rrÑrÑ&sø„ô6ò-öDrrÑzkeras.ops.saturate_castcó€—tj|«}t|f«rt|¬«|«St ||«S)a‚Performs a safe saturating cast to the desired dtype. Saturating cast prevents data type overflow when casting to `dtype` with smaller values range. E.g. `ops.cast(ops.cast([-1, 256], "float32"), "uint8")` returns `[255, 0]`, but `ops.saturate_cast(ops.cast([-1, 256], "float32"), "uint8")` returns `[0, 255]`. Args: x: A tensor or variable. dtype: The target type. Returns: A safely casted tensor of the specified `dtype`. Example: Image resizing with bicubic interpolation may produce values outside original range. >>> image2x2 = np.array([0, 1, 254, 255], dtype="uint8").reshape(1, 2, 2, 1) >>> image4x4 = tf.image.resize(image2x2, (4, 4), method="bicubic") >>> print(image4x4.numpy().squeeze()) >>> # [[-22.500004 -22.204624 -21.618908 -21.32353 ] >>> # [ 52.526054 52.82143 53.407146 53.70253 ] >>> # [201.29752 201.59288 202.17859 202.47395 ] >>> # [276.32355 276.61893 277.20465 277.50006 ]] Casting this resized image back to `uint8` will cause overflow. >>> image4x4_casted = ops.cast(image4x4, "uint8") >>> print(image4x4_casted.numpy().squeeze()) >>> # [[234 234 235 235] >>> # [ 52 52 53 53] >>> # [201 201 202 202] >>> # [ 20 20 21 21]] Saturate casting to `uint8` will clip values to `uint8` range before casting and will not cause overflow. >>> image4x4_saturate_casted = ops.saturate_cast(image4x4, "uint8") >>> print(image4x4_saturate_casted.numpy().squeeze()) >>> # [[ 0 0 0 0] >>> # [ 52 52 53 53] >>> # [201 201 202 202] >>> # [255 255 255 255]] rb)rrÁrrÑrÔrÏs rÚ saturate_castr×2s>€ô^ ×%Ñ% eÓ,€Eä˜Q˜DÔ!Ø(Œ| %Ô(¨Ó+Ð+Ü˜!˜UÓ#Ð#rcó—|xst}d„}tj|«}tj|j«}||«\}}||«\}}tj||«j|«} | |krtj| d|¬«} tj||«j|«} | |kDrtj| d|¬«} |jj|| | «}|j||«S)Ncó,—d|k(rd}d}||fSd|vrBtj|«j}tj|«j}||fStj|«j}tj|«j}||fS)NÚboolrrBr?)Ú ml_dtypesÚiinfoÚminÚmaxÚfinfo)r"Ú dtype_minÚ dtype_maxs rÚget_dtype_min_maxz)_saturate_cast..get_dtype_min_maxks“€ØUŠ?ØˆIØˆIð˜)Ð#Ð#ð e‰^Ü!Ÿ™¨Ó.×2Ñ2ˆIÜ!Ÿ™¨Ó.×2Ñ2ˆIð˜)Ð#Ð#ô"Ÿ™¨Ó.×2Ñ2ˆIÜ!Ÿ™¨Ó.×2Ñ2ˆIØ˜)Ð#Ð#rrrb)rrÁr"ÚnpÚmaximumÚastypeÚ nextafterÚminimumÚnumpyÚcliprÉ)r%r"Úbackend_modulerâÚin_dtypeÚin_minÚin_maxÚout_minÚout_maxÚ min_limitÚ max_limits rrÔrÔhsï€Ø#Ò.¤w€Nò $ô ×%Ñ% eÓ,€EÜ×(Ñ(¨¯©Ó1€HÙ& xÓ0N€FˆFÙ(¨Ó/Ñ€GˆWô— ‘ ˜6 7Ó+×2Ñ2°8Ó<€IØ7ÒÜ—L‘L ¨A°XÔ>ˆ Ü— ‘ ˜6 7Ó+×2Ñ2°8Ó<€IØ7ÒÜ—L‘L ¨A°XÔ>ˆ ð ×Ñ×!Ñ! ! Y° Ó:€Aà×Ñ˜q %Ó(Ð(rcó*‡—eZdZˆfd„Zd„Zd„ZˆxZS)ÚConvertToTensorcód•—t‰|«tj|«|_||_yr)rrrrÁr"r#)rr"r#rs €rrzConvertToTensor.__init__‘s'ø€Ü ‰ÑÔÜ×.Ñ.¨uÓ5ˆŒ Øˆrcón—tjj||j|j¬«S)N©r"r#)rrÚconvert_to_tensorr"r#r¶s rrzConvertToTensor.call–s-€Ü|‰|×-Ñ-Ø T—Z‘Z¨¯©ð.ó ð rcóÚ—|j€|jn|j}|j|jsdn|j}tj|j||¬«S)NFr )r"r#rrr!)rr%r"r#s rr(z#ConvertToTensor.compute_output_spec›sR€ØŸ:™:Ð-—’°4·:±:ˆà—[‘[Ð,°T·[²[‰EÀaÇhÁhð ô×"Ñ"¨¯©¸ÀfÔMÐMrr+r0s@rrórósø„ôò ö Nrrózkeras.ops.convert_to_tensorcó†—t|f«rt||¬«|«Stjj ||||¬«S)a´Convert a NumPy array or Python array to a tensor. Native tensors for the current backend or left unchanged unless the `dtype`, `sparse` or `ragged` arguments are set. Args: x: A NumPy array, Python array (can be nested) or a backend tensor. dtype: The target type. If `None`, the type of `x` is used. sparse: Whether to keep sparse tensors. `False` will cause sparse tensors to be densified. The default value of `None` means that sparse tensors are kept only if the backend supports them. ragged: Whether to keep ragged tensors. `False` will cause ragged tensors to be densified. The default value of `None` means that ragged tensors are kept only if the backend supports them. Returns: A backend tensor of the specified `dtype` and sparseness. Example: >>> x = np.array([1, 2, 3]) >>> y = keras.ops.convert_to_tensor(x) rö)r"r#Úragged)rrórrr÷)r%r"r#rús rr÷r÷£sG€ô2˜Q˜DÔ!Ø:Œ U°6Ô:¸1Ó=Ð=Ü<‰<×)Ñ)Ø ˜v¨fð*óðrzkeras.ops.convert_to_numpycón—t|f«rtj|«Stj|«S)zlConvert a tensor to a NumPy array. Args: x: A tensor. Returns: A NumPy array. )rrãÚarrayrÚconvert_to_numpyr¿s rrýrýÃs/€ô˜Q˜DÔ!ôx‰x˜‹{ÐÜ×#Ñ# AÓ&Ð&rcóB—eZdZejd„«Zd„Zd„Zd„Zy)ÚCondcó²‡—ˆfd„}tj«r6tj|‰jj›d¬«}||i|¤ŽS||i|¤ŽS)Ncód•—t||«r‰j|i|¤ŽS‰j|i|¤ŽSr)rr2r)ÚargsÚkwargsrs €rÚcall_fnzCond.__call__..call_fn×s;ø€Ü# D¨&Ô1Ø)t×)Ñ)¨4Ð:°6Ñ:Ð:à t—y‘y $Ð1¨&Ñ1Ð1rz.call())Úobject_name)r Úis_traceback_filtering_enabledÚ!inject_argument_info_in_tracebackrr,)rrrrs` rÚ__call__z Cond.__call__Õsbø€ô 2ô×9Ñ9Ô;ä%×GÑGØØ $§¡× 7Ñ 7Ð8¸Ð@ôˆGñ˜DÐ+ FÑ+Ð+ñ˜Ð' Ñ'Ð'rcóD—tjj|||«Sr)rrr)rÚpredÚtrue_fnÚfalse_fns rrz Cond.callès€Ü|‰|× Ñ w°Ó9Ð9rcó¢—tj|«}tj|«}|j||«std|›d|›d«‚|S)Nz_`true_fn` and `false_fn` should return outputs of the same kind (struct, dtype and shape). Got z and z instead.)rr(Ú_check_output_specrR)rr rrÚtrue_fn_specÚ false_fn_specs rr(zCond.compute_output_specës_€Ü×2Ñ2°7Ó;ˆÜ×3Ñ3°HÓ=ˆ Ø×&Ñ& |°]ÔCÜðà#n E¨-¨¸ ðCóð ð Ðrcó®— tj||«d„}tj|||«}ttj|««S#YyxYw)NFcó†—||€ |duxr|duS|j|jk(xr|j|jk(Srr¸)Út_specÚf_specs rÚ check_leafz+Cond._check_output_spec..check_leafüsC€Øˆ~ Ø ~Ò8¨&°D¨.Ð8Ø—<‘< 6§<¡<Ñ/ÒP°F·L±LÀFÇLÁLÑ4PÐPr)rÚassert_same_structurer)Úallr@)rrrrÚsames rrzCond._check_output_specösQ€ð Ü×&Ñ& |°]ÔCò Qô ×!Ñ! *¨l¸MÓJˆÜ”4—<‘< Ó%Ó&Ð&øð Ùús‚AÁAN) r,r-r.r Úfilter_tracebackrrr(rrfrrrÿrÿÔs)„Ø×%Ñ%ñ(ó&ð(ò$:ò ó'rrÿzkeras.ops.condcó&—t«|||«S)aPConditionally applies `true_fn` or `false_fn`. Args: pred: Boolean scalar type true_fn: Callable returning the output for the `pred == True` case. false_fn: Callable returning the output for the `pred == False` case. Returns: The output of either `true_fn` or `false_fn` depending on pred. )rÿ)r rrs rrrs€ðŒ4‹6$˜ Ó*Ð*rzkeras.ops.vectorized_mapcóB—tjj||«S)a5Parallel map of `function` on axis 0 of tensor(s) `elements`. Schematically, `vectorized_map` implements the following, in the case of a single tensor input `elements`: ```python def vectorized_map(function, elements) outputs = [] for e in elements: outputs.append(function(e)) return stack(outputs) ``` In the case of an iterable of tensors `elements`, it implements the following: ```python def vectorized_map(function, elements) batch_size = elements[0].shape[0] outputs = [] for index in range(batch_size): outputs.append(function([e[index] for e in elements])) return np.stack(outputs) ``` In this case, `function` is expected to take as input a single list of tensor arguments. )rrÚvectorized_map)ÚfunctionÚelementss rrrs€ô<<‰<×&Ñ& x°Ó:Ð:rzkeras.ops.is_tensorcó@—tjj|«S)a%Check whether the given object is a tensor. Note: This checks for backend specific tensors so passing a TensorFlow tensor would return `False` if your backend is PyTorch or JAX. Args: x: A variable. Returns: `True` if `x` is a tensor, otherwise `False`. )rrÚ is_tensorr¿s rr r 6s€ô<‰<×!Ñ! !Ó$Ð$rzkeras.ops.custom_gradientcó@—tjj|«S)aü Decorator to define a function with a custom gradient. This decorator allows fine grained control over the gradients of a sequence for operations. This may be useful for multiple reasons, including providing a more efficient or numerically stable gradient for a sequence of operations. Args: f: Function `f(*args)` that returns a tuple `(output, grad_fn)`, where: - `args` is a sequence of (nested structures of) tensor inputs to the function. - `output` is a (nested structure of) tensor outputs of applying operations in `forward_fn` to `args`. - `grad_fn` is a function with the signature `grad_fn(*args, upstream)` which returns a tuple of tensors the same size as (flattened) `args`: the derivatives of tensors in `output` with respect to the tensors in `args`. `upstream` is a tensor or sequence of tensors holding the initial value gradients for each tensor in `output`. Returns: A function `h(*args)` which returns the same value as `f(*args)[0]` and whose gradient is determined by `f(*args)[1]`. Examples: 1. Backend-agnostic example. ```python @ops.custom_gradient def log1pexp(x): e = ops.exp(x) def grad(*args, upstream=None): if upstream is None: (upstream,) = args return ops.multiply(upstream, 1.0 - 1.0 / ops.add(1, e)) return ops.log(1 + e), grad ``` Note that the grad function that returns gradient computation requires `args` as well as an `upstream` keyword argument, depending on the backend being set. With the JAX and TensorFlow backends, it requires only one argument, whereas it might use the `upstream` argument in the case of the PyTorch backend. When working with TensorFlow/JAX backend, `grad(upstream)` is sufficient. With PyTorch, the `grad` function requires `*args` as well as `upstream`, e.g. `def grad(*args, upstream)`. Follow the previous example to use `@ops.custom_gradient` in a way that is compatible with all backends. 2. Here's JAX & TensorFlow-specific example: ```python @ops.custom_gradient def log1pexp(x): e = ops.exp(x) def grad(upstream): return ops.multiply(upstream, 1.0 - 1.0 / ops.add(1, e)) return ops.log(1 + e), grad ``` 3. Lastly, here's a PyTorch-specific example, using `*args` & `upstream`: ```python @ops.custom_gradient def log1pexp(x): e = ops.exp(x) def grad(*args, upstream): return ops.multiply(upstream, 1.0 - 1.0 / ops.add(1, e)) return ops.log(1 + e), grad ``` )rrÚcustom_gradient)rs rr"r"Fs€ôb<‰<×'Ñ'¨Ó*Ð*r)NNFrB)FrrrŠ)NNN)8rÛrèrãÚ keras.srcrrÚkeras.src.api_exportrÚkeras.src.backendrrÚ&keras.src.backend.common.backend_utilsrÚkeras.src.ops.operationr Úkeras.src.utilsr rrr4r:rErJrZr\rirkrtrvr|r~rƒr…rŽr•r›ržr¥r«r±rµr!r"rÃrÉrÑr×rÔrór÷rýrÿrrr r"rfrrúr)sLðÛÛåÝÝ-Ý)Ý2ÝCÝ-Ý+ôˆ)ôñ*ˆoÓñ)#óð)#ôXˆ9ôñ8ÐÓòKó ðKô\ iô ñFÐ*Ó+ò7Oó,ð7Oôt6ˆiô6ñÐ!Ó"ñ8ó#ð8ô<=Iô=ñÐ(Ó)ñ0Aó*ð0Aôf6ˆIô6ñÐÓ ñ<ó!ð<ô<=)ô=ñÐ&Ó'ñ Eó(ð EôFˆYôñÐ Ó!ñ%;ó"ð%;ôPH ôHñ&Ð$Ó%ð ò .ó&ð.ôbA9ôAñÐ'Ó(ñ0ó)ð0ô.AˆyôAñ&Ð#Ó$ñDó%ðDô8ˆiôñ<Ð!Ó"ò7ó#ð7ñ.ÐÓ ñ!ó!ð!ñ4ÐÓ ñ.ó!ð.ô. Dˆ9ô DñÐÓñ'ó ð'ô, D9ô DñÐ'Ó(ñ2$ó)ð2$ój%)ôPNiôNñ&Ð+Ó,òó-ðñ>Ð*Ó+ñ 'ó,ð 'ô .'ˆ9ô.'ñbÐÓñ+ó ð+ñÐ(Ó)ñ;ó*ð;ñ@Ð#Ó$ñ%ó%ð%ñÐ)Ó*ñP+ó+ñP+r