o bi@sddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z ddl mZdd lmZdd lmZGd d d eZed ddZGdddeZeddsddZGdddeZeddtddZGdddeZeddd ZGd!d"d"eZed#d$d%ZGd&d'd'eZed(d)d*ZGd+d,d,eZed-d.d/Z Gd0d1d1eZ!ed2d3d4Z"Gd5d6d6eZ#ed7 dud8d9Z$Gd:d;d;eZ%ed<d=d>Z&Gd?d@d@eZ'edAdBdCZ(GdDdEdEeZ)edFdvdGdHZ*edIdJdKZ+edLdMdNZ,GdOdPdPeZ-edQdRdSZ.GdTdUdUeZ/edVdWdXZ0dudYdZZ1Gd[d\d\eZ2ed]dwd^d_Z3ed`dadbZ4GdcddddeZ5ededfdgZ6GdhdidieZ7edjdkdlZ8edmdndoZ9edpdqdrZ:dS)xN)backend)tree) keras_export) KerasTensor)any_symbolic_tensors)slice_along_axis) Operation)serialization_lib)traceback_utilsc@eZdZddZddZdS)MapcCstj||SN)rcoremap)selffxsrF/home/ubuntu/.local/lib/python3.10/site-packages/keras/src/ops/core.pycallszMap.callcsLtdd|}t|djdt||}fdd}t||}|S)NcS|dSNrrtrrrz)Map.compute_output_spec..rctf|j|j|j|jdSNshapedtypesparseraggedrrr r!r"rnrrappend_batch_axis  z2Map.compute_output_spec..append_batch_axis)r map_structureflattenrrcompute_output_spec)rrrxyr&rr$rr*s    zMap.compute_output_specN__name__ __module__ __qualname__rr*rrrrr  r z keras.ops.mapcCs&t|fr t||Stj||S)uMap 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)rrrrrr$s (rcs8eZdZd ddfdd Zd ddZd d d ZZS) ScanNFnamec$tj|d||_||_||_dSNr5)super__init__lengthreverseunroll)rr;r<r=r6 __class__rrr:R z Scan.__init__cCstjj||||j|j|jdS)Nr;r<r=)rrscanr;r<r=)rrinitrrrrrXsz Scan.callcCs||dur t|j}d}n|jdurt|jn t|djd}|d}t|||\}}t|f|j|j|j d}||fSNr)rr r!) intr;rr)rrr*rr r!)rrrCrr%r+carryr,rrrr*bs   zScan.compute_output_spec)NFr4r r.r/r0r:rr* __classcell__rrr>rr3Qs  r3zkeras.ops.scanFr4cCs<t||frt|||d|||Stjj||||||dS)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] rA)r<r=)rr3r2rrrB)rrCrr;r<r=rrrrBss F  rBcs4eZdZd ddfdd ZddZd d ZZS) AssociativeScanFrNr5ctj|d||_||_dSr8)r9r:r<axis)rr<rKr6r>rrr: zAssociativeScan.__init__cCstjj|||j|jdS)Nr<rK)rrassociative_scanr<rK)rrelemsrrrrs zAssociativeScan.callcst|fddD}tt|dkr"tdddDt|fddD}t|||}fdd}t ||}|S) Ncsg|]}|jjqSr)rrK.0elemrrr sz7AssociativeScan.compute_output_spec..r4zNArray inputs to associative_scan must have the same first dimension. (saw: {})cSsg|]}|jqSrrrPrrrrTscsg|] }t|ddjdqS)rr4)rK)rrK)rQr+rSrrrTscstdj|j|jdSrD)rrr r!r+) elems_flatrr_restore_shapesz;AssociativeScan.compute_output_spec.._restore_shape) rr)lenset ValueErrorformatpack_sequence_asrr*r()rrrOlensr+y_specrXr)rWrrr*s"    z#AssociativeScan.compute_output_specFrrGrrr>rrIsrIzkeras.ops.associative_scancCs2t|frt||d||Stjj||||dS)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]] rM)rrIr2rrrN)rrOr<rKrrrrNs 6 rNc2eZdZddfdd ZddZddZZS) ScatterNr5ctj|d||_dSr8r9r:rrrr6r>rrr:% zScatter.__init__cCtj|||jSr )rrscatterrrindicesvaluesrrrr)z Scatter.callcCst|j|jdSNr rrr rirrrr*,zScatter.compute_output_specrGrrr>rrb$rbzkeras.ops.scattercC.t||frt|d||Stj|||S)aReturns 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.]]) rU)rrbr2rrrh)rjrkrrrrrh0 rhc@r ) ScatterUpdatecCtj|||Sr )rrscatter_updaterinputsrjupdatesrrrrPrpzScatterUpdate.callcCt|j|jdSrmrorwrrrr*Srpz!ScatterUpdate.compute_output_specNr-rrrrrtOr1rtzkeras.ops.scatter_updatecC.t|||frt|||Stj|||S)aUpdate inputs via updates at scattered (sparse) indices. At a high level, this operation does `inputs[indices] = updates`. Assume `inputs` is a tensor of shape `(D0, D1, ..., Dn)`, there are 2 main usages of `scatter_update`. 1. `indices` is a 2D tensor of shape `(num_updates, n)`, where `num_updates` is the number of updates to perform, and `updates` is a 1D tensor of shape `(num_updates,)`. For example, if `inputs` is `zeros((4, 4, 4))`, and we want to update `inputs[1, 2, 3]` and `inputs[0, 1, 3]` as 1, then we can use: ```python inputs = np.zeros((4, 4, 4)) indices = [[1, 2, 3], [0, 1, 3]] updates = np.array([1., 1.]) inputs = keras.ops.scatter_update(inputs, indices, updates) ``` 2 `indices` is a 2D tensor of shape `(num_updates, k)`, where `num_updates` is the number of updates to perform, and `k` (`k < n`) is the size of each index in `indices`. `updates` is a `n - k`-D tensor of shape `(num_updates, inputs.shape[k:])`. For example, if `inputs = np.zeros((4, 4, 4))`, and we want to update `inputs[1, 2, :]` and `inputs[2, 3, :]` as `[1, 1, 1, 1]`, then `indices` would have shape `(num_updates, 2)` (`k = 2`), and `updates` would have shape `(num_updates, 4)` (`inputs.shape[2:] = 4`). See the code below: ```python inputs = np.zeros((4, 4, 4)) indices = [[1, 2], [2, 3]] updates = np.array([[1., 1., 1, 1,], [1., 1., 1, 1,]) inputs = keras.ops.scatter_update(inputs, indices, updates) ``` Args: inputs: A tensor, the tensor to be updated. indices: A tensor or list/tuple of shape `(N, inputs.ndim)`, specifying indices to update. `N` is the number of indices to update, must be equal to the first dimension of `updates`. updates: A tensor, the new values to be put to `inputs` at `indices`. Returns: A tensor, has the same shape and dtype as `inputs`. )rrtr2rrrv)rxrjryrrrrvWs/rvcra) SliceNr5crcr8rdrer>rrr:rfzSlice.__init__cCrgr )rrslicer)rrx start_indicesrrrrrlz Slice.callcsRtdd|jDrttrtdtfddt|jD}t|jdS)Ncss|]}|dkVqdSNr)rQsrrr sz,Slice.compute_output_spec..zGWhen using -1 in `shape`, `start_indices` should not be a KerasTensor. c3s2|]\}}|dkrj||n|VqdSrrU)rQirrxr~rrrs  rn)anyr isinstancerr[tuple enumerater )rrxr~ final_shaperrrr*szSlice.compute_output_specrGrrr>rr|rqr|zkeras.ops.slicecCrr)aTReturn a slice of an input tensor. At a high level, this operation is an explicit replacement for array slicing e.g. `inputs[start_indices: start_indices + shape]`. Unlike slicing via brackets, this operation will accept tensor start indices on all backends, which is useful when indices dynamically computed via other tensor operations. ```python inputs = np.zeros((5, 5)) start_indices = np.array([3, 3]) shape = np.array([2, 2]) inputs = keras.ops.slice(inputs, start_indices, shape) ``` Args: inputs: A tensor, the tensor to be updated. start_indices: A list/tuple of shape `(inputs.ndim,)`, specifying the starting indices for updating. shape: The full shape of the returned slice. Returns: A tensor, has the same shape and dtype as `inputs`. rU)rr|r2rrr})rxr~rrrrr}rsr}c@r ) SliceUpdatecCrur )rr slice_updaterrxr~ryrrrrrpzSliceUpdate.callcCrzrmrorrrrr*rpzSliceUpdate.compute_output_specNr-rrrrrr1rzkeras.ops.slice_updatecCr{)aUpdate an input by slicing in a tensor of updated values. At a high level, this operation does `inputs[start_indices: start_indices + updates.shape] = updates`. Assume inputs is a tensor of shape `(D0, D1, ..., Dn)`, `start_indices` must be a list/tuple of n integers, specifying the starting indices. `updates` must have the same rank as `inputs`, and the size of each dim must not exceed `Di - start_indices[i]`. For example, if we have 2D inputs `inputs = np.zeros((5, 5))`, and we want to update the intersection of last 2 rows and last 2 columns as 1, i.e., `inputs[3:, 3:] = np.ones((2, 2))`, then we can use the code below: ```python inputs = np.zeros((5, 5)) start_indices = [3, 3] updates = np.ones((2, 2)) inputs = keras.ops.slice_update(inputs, start_indices, updates) ``` Args: inputs: A tensor, the tensor to be updated. start_indices: A list/tuple of shape `(inputs.ndim,)`, specifying the starting indices for updating. updates: A tensor, the new values to be put to `inputs` at `indices`. `updates` must have the same rank as `inputs`. Returns: A tensor, has the same shape and dtype as `inputs`. )rrr2rrr)rxr~ryrrrrsrc@r )SwitchcGstjj||g|RSr )rrswitch)rindexbranchesoperandsrrrrsz Switch.callcGstj|dg|R}|Sr)rr*)rrrrspecrrrr*szSwitch.compute_output_specNr-rrrrrr1rzkeras.ops.switchcGs4t|rtj||g|RStjj||g|RS)aApply 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 )rrr2rrr)rrrrrrrs$rc4eZdZd ddfdd ZddZddZZS) WhileLoopNr5cr7r8)r9r:condbodymaximum_iterations)rrrrr6r>rrr:#r@zWhileLoop.__init__cCstjj|j|j||jdS)Nr)rr while_looprrrr loop_varsrrrr)s zWhileLoop.callcCstdd|S)NcSst|j|jdSrmro)vrrrr3sz/WhileLoop.compute_output_spec..)rr(rrrrr*1szWhileLoop.compute_output_specr rGrrr>rr"srzkeras.ops.while_loopcCs2t|frt|||d|Stjj||||dS)aWhile 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)rrr2rrr)rrrrrrrr7s *rc@r ) StopGradientcCs tj|Sr )rr stop_gradientrvariablerrrrn zStopGradient.callcCrzrmrorrrrr*qrpz StopGradient.compute_output_specNr-rrrrrmr1rzkeras.ops.stop_gradientcCs"t|fr t|Stj|S)aStops 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) )rrr2rrr)rrrrrus   rcra) ForiLoopNr5cr7r8)r9r:lowerupperbody_fun)rrrrr6r>rrr:r@zForiLoop.__init__cCstj|j|j|j|Sr )rr fori_looprrrrinit_valrrrrs z ForiLoop.callcCrzrmrorrrrr*rpzForiLoop.compute_output_specrGrrr>rrsrzkeras.ops.fori_loopcCs2t|||frt||||Stj||||S)aFor 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 )rrr2rrr)rrrrrrrrsrcs4eZdZd ddfdd ZddZdd ZZS) UnstackNrr5crJr8)r9r:numrK)rrrKr6r>rrr:rLzUnstack.__init__cCstj||j|jSr )rrunstackrrKrr+rrrrsz Unstack.callcs|j}|dkrtj|}jd|j|dd|j}|dur*j|}|dur7tdjdfddt|D}|S)Nrr4z'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.csg|] }tjdqS)rr )rr )rQ_ output_shapesr+rrrTsz/Unstack.compute_output_spec..)rKrYrrr[range)rr+rKroutputrrrr*s"   zUnstack.compute_output_specrrGrrr>rrsrzkeras.ops.unstackcCs,t|fr t|||Stjj|||dS)aUnpacks 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])] )rrK)rrr2rrr)r+rrKrrrrs rzkeras.ops.shapecCst|fr|jStj|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) )rrrrrVrrrrs  rzkeras.ops.dtypecCs t|jS)aReturn 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' )rstandardize_dtyper rVrrrr s r cra) CastNr5ctj|dt||_dSr8r9r:rrr rr r6r>rrr:'z Cast.__init__cCstj||jSr )rrcastr rrrrr+rpz Cast.callcCtj|j|jdSNrrrrr rrrrr*.rlzCast.compute_output_specrGrrr>rr&rqrzkeras.ops.castcCs&t|fr t|d|Stj||S)a Cast 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") rn)rrrrrr+r rrrr2s rcra) SaturateCastNr5crr8rrr>rrr:HrzSaturateCast.__init__cCs t||jSr )_saturate_castr rrrrrLrzSaturateCast.callcCrrrrrrrr*Orlz SaturateCast.compute_output_specrGrrr>rrGrqrzkeras.ops.saturate_castcCs"t|fr t|d|St||S)aPerforms 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]] rn)rrrrrrr saturate_castSs / rc Cs|pt}dd}t|}t|j}||\}}||\}}t|||} | |kr4tj| d|d} t|||} | |krItj| d|d} |j || | }| ||S)NcSs`d|kr d}d}||fSd|vr t|j}t|j}||fSt|j}t|j}||fS)Nboolrr4rE) ml_dtypesiinfominmaxfinfo)r dtype_min dtype_maxrrrget_dtype_min_maxs   z)_saturate_cast..get_dtype_min_maxrrn) rrr npmaximumastype nextafterminimumnumpyclipr) r+r backend_modulerin_dtypein_minin_maxout_minout_max min_limit max_limitrrrrs     rcr) ConvertToTensorNr5cs6tj|d|dur dnt||_||_||_dSr8)r9r:rrr r!r")rr r!r"r6r>rrr:s zConvertToTensor.__init__cCstjj||j|j|jdS)Nr r!r")rrconvert_to_tensorr r!r"rrrrrszConvertToTensor.callcCsd|jdur t|jn|j}|jdur|jsdn|j}|jdur%|js%dn|j}tj|j|||dS)NFr)r rrr!r"rr)rr+r r!r"rrrr*s   z#ConvertToTensor.compute_output_specNNNrGrrr>rrsrzkeras.ops.convert_to_tensorcCs0t|frt|||d|Stjj||||dS)aConvert 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)rrrrr)r+r r!r"rrrrs rzkeras.ops.convert_to_numpycCst|fr t|St|S)zlConvert a tensor to a NumPy array. Args: x: A tensor. Returns: A NumPy array. )rrarrayrconvert_to_numpyrVrrrrs  rc@s2eZdZejddZddZddZddZd S) CondcsHfdd}trtj|jjdd}||i|S||i|S)Ncs*t||r j|i|Sj|i|Sr )rr2r)argskwargsrSrrcall_fns zCond.__call__..call_fnz.call()) object_name)r is_traceback_filtering_enabled!inject_argument_info_in_tracebackr?r.)rrrrrrSr__call__s  z Cond.__call__cCrur )rrr)rpredtrue_fnfalse_fnrrrrrpz Cond.callcCs:t|}t|}|||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_specr[)rrrr true_fn_spec false_fn_specrrrr*s   zCond.compute_output_speccCsBzt||WnYdSdd}t|||}tt|S)NFcSs8|dus|dur|duo|duS|j|jko|j|jkSr r)t_specf_specrrr check_leaf%sz+Cond._check_output_spec..check_leaf)rassert_same_structurer(allr))rrrrsamerrrrszCond._check_output_specN) r.r/r0r filter_tracebackrrr*rrrrrrs   rzkeras.ops.condcCst|||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)rrrrrrr.s rcsJeZdZddfdd ZddZddZfd d Zed d ZZ S) VectorizedMapNr5crcr8)r9r:function)rrr6r>rrr:>rfzVectorizedMap.__init__cCstj|j|Sr )rrvectorized_mapr)relementsrrrrBrpzVectorizedMap.callcsNtdd|}t|djdt|j|}fdd}t||}|S)NcSrrrrrrrrFrz3VectorizedMap.compute_output_spec..rcrrr#rr$rrr&Jr'z.append_batch_axis)rr(r)rrr*r)rrr+r,r&rr$rr*Es   z!VectorizedMap.compute_output_speccst}|d|ji|S)Nr)r9 get_configupdater)rconfigr>rrrUs zVectorizedMap.get_configcCs(|}t|d|d<|di|S)Nrr)copyr deserialize_keras_object)clsrrrr from_configZs zVectorizedMap.from_config) r.r/r0r:rr*r classmethodrrHrrr>rr=s rzkeras.ops.vectorized_mapcCs$t|fr t||Stj||S)a:Parallel 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 np.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. )rrrrr)rrrrrrcs  rzkeras.ops.is_tensorcC tj|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_tensorrVrrrrs rzkeras.ops.custom_gradientcCr)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 ``` )rrcustom_gradient)rrrrrs Qr)NNFr4r`r rr);rrr keras.srcrrkeras.src.api_exportrkeras.src.backendrr&keras.src.backend.common.backend_utilsrkeras.src.ops.operationrkeras.src.savingr keras.src.utilsr r rr3rBrIrNrbrhrtrvr|r}rrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrs          ," N% <  3  # ( 5        3(  1 & "