ijddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z ddl m Z dd lmZdd lmZdd lmZGd d eZeddZGddeZedd[dZGddeZedd\dZGddeZeddZGddeZedd]dZGd d!eZed"d#ZGd$d%eZ ed&d'Z!Gd(d)eZ"ed*d+Z#Gd,d-eZ$ed. d]d/Z%Gd0d1eZ&ed2d3Z'Gd4d5eZ(ed6d7Z)Gd8d9eZ*ed:d^d;Z+ed<d=Z,ed>d?Z-Gd@dAeZ.edBdCZ/GdDdEeZ0edFdGZ1d]dHZ2GdIdJeZ3edKd_dLZ4edMdNZ5GdOdPeZ6edQdRZ7GdSdTeZ8edUdVZ9edWdXZ:edYdZZ;y)`N)backend)tree) keras_export) KerasTensor)any_symbolic_tensors)canonicalize_axis)slice_along_axis) Operation)serialization_lib)traceback_utilsceZdZdZdZy)MapcBtjj||SN)rcoremap)selffxss g/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/keras/src/ops/core.pycallzMap.calls||2&&ctjd|}tj|djdt j ||}fd}tj||}|S)Nc |dSNrts rz)Map.compute_output_spec.. 1rrcztf|jz|j|j|jSNshapedtypesparseraggedrr$r%r&r'rns rappend_batch_axisz2Map.compute_output_spec..append_batch_axis2dQWWnggxxxx  r)r map_structureflattenr$rcompute_output_spec)rrrxyr+r*s @rr/zMap.compute_output_specsd   ~r 2 LL Q  % %a (  ' '1 -    0! 4rN__name__ __module__ __qualname__rr/rrrrrs 'rrz keras.ops.mapct|frtj||Stjj ||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)rrs rrr%s;PRE"u""1b)) <<  Ar ""rc6eZdZdddfd ZddZddZxZS)ScanNnamecPt||||_||_||_yNr:)super__init__lengthreverseunroll)rr@rArBr; __class__s rr?z Scan.__init__Ss( d#   rctjj||||j|j|j S)Nr@rArB)rrscanr@rArB)rrinitrs rrz Scan.callYs<||   ;;LL;; !  rch|t|j}d}nK|jt|jn$tj|djd}|d}t j |||\}}t|f|jz|j|j}||fSNr)r$r%r&) intr@rr.r$rr/rr%r&)rrrGrr*r0carryr1s rr/zScan.compute_output_speccs :DKK AA;;*DKK \\"%a(..q1  1A..q$:q qdQWWnAGGAHH Maxr)NFrr3r4r5r?rr/ __classcell__rCs@rr9r9RsT  rr9zkeras.ops.scanct||frt|||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] rE)rArB)rr9r7rrrF)rrGrr@rArBs rrFrFts^LT2J'76 -4 $ % <<   4VWV  rc2eZdZdddfd ZdZdZxZS)AssociativeScanNr:cBt||||_||_yr=)r>r?rAaxis)rrArTr;rCs rr?zAssociativeScan.__init__s! d#  rcptjj|||j|jS)NrArT)rrassociative_scanrArT)rrelemss rrzAssociativeScan.calls/||,, udll-  rc tj|Dcgc]}|j|j}}t t |dk7r2t djDcgc]}|jc}tj|Dcgc]}t|dd|jc}}tj|||}fd}tj||}|Scc}wcc}wcc}w)NrLzNArray inputs to associative_scan must have the same first dimension. (saw: {})r)rTcbtdj|j|jSrI)rr$r%r&)r0 elems_flats r_restore_shapez;AssociativeScan.compute_output_spec.._restore_shapes) m)) r) rr.r$rTlenset ValueErrorformatpack_sequence_asr rr/r-) rrrXelemlensr0y_specr\r[s @rr/z#AssociativeScan.compute_output_specs\\%( 2<=$ 499%== s4y>Q --3V,67DTZZ7.   ! ! @J K1 aADII 6 K ,,Q15  ##NF; +> 8 Ls C5(C:  C? FrrMrOs@rrRrRsd  rrRzkeras.ops.associative_scanct|frt||j||Stjj ||||S)aJ 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]] rV)rrRr7rrrW)rrXrArTs rrWrWsNlUH%wT:HH u   << ( (E7 ( NNrc0eZdZddfd ZdZdZxZS)ScatterNr:c4t||||_yr=r>r?r$rr$r;rCs rr?zScatter.__init__& d# rcXtjj|||jSr)rrscatterr$rindicesvaluess rrz Scatter.call*s||##GVTZZ@@rcDt|j|jSNr%rr$r%ros rr/zScatter.compute_output_spec-s4::V\\::rrMrOs@rrhrh%s&*A;rrhzkeras.ops.scatterct||frt|j||Stjj |||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.]]) r$)rrhr7rrrn)rprqr$s rrnrn1sB4Wf-.U#11'6BB <<   77rc2eZdZdddfd ZdZdZxZS) ScatterUpdateNr:c4t||||_yr=)r>r? reduction)rr{r;rCs rr?zScatterUpdate.__init__Qs d#"rc\tjj||||jS)Nr{)rrscatter_updater{rinputsrpupdatess rrzScatterUpdate.callUs+||** GW+  rcDt|j|jSrsrurs rr/z!ScatterUpdate.compute_output_specZ6<>> inputs = np.zeros((4,)) >>> indices = [[0], [0], [1]] >>> updates = np.array([1., 1., 1.]) >>> keras.ops.scatter_update(inputs, indices, updates, reduction="add") array([2., 1., 0., 0.]) )addmaxminmulzInvalid reduction: z9. Supported values are: None, 'add', 'max', 'min', 'mul'.r})lowerr_rryr7rrr~)rrprr{s rr~r~^s@OO% 8 8%i[1JJ VWg67y1?? GW   << & &I ' rc0eZdZddfd ZdZdZxZS)SliceNr:c4t||||_yr=rjrks rr?zSlice.__init__rlrcXtjj|||jSr)rrslicer$)rr start_indicess rrz Slice.calls||!!&-DDrcpt|jt|jk7r%td|jd|jt|drV]G<=}**6='JJ << $ $V]G DDrceZdZdZdZy)SwitchcDtjj||g|Sr)rrswitch)rindexbranchesoperandss rrz Switch.calls||""5(>X>>rc8tj|dg|}|Sr)rr/)rrrrspecs rr/zSwitch.compute_output_spec"s **8A;BB rNr2rrrrrs ?rrzkeras.ops.switchct|rtj||g|Stjj ||g|S)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 )rrr7rrr)rrrs rrr(sEHH%%vx%%eXAAA <<  uh : ::rc2eZdZdddfd ZdZdZxZS) WhileLoopNr:cPt||||_||_||_yr=)r>r?condbodymaximum_iterations)rrrrr;rCs rr?zWhileLoop.__init__Rs) d#  "4rctjj|j|j||j S)Nr)rr while_looprrrr loop_varss rrzWhileLoop.callXs8||&& II II #66 '  rc0tjd|S)NcDt|j|jSrsru)vs rrz/WhileLoop.compute_output_spec..bsk!''9r)rr-rs rr/zWhileLoop.compute_output_spec`s!! 99  rrrMrOs@rrrQs5D5   rrzkeras.ops.while_loopct|frt|||j|Stjj ||||S)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)rrr7rrr)rrrrs rrrfsXTYL) $+= - " # << " "  - # rceZdZdZdZy) StopGradientc@tjj|Sr)rr stop_gradientrvariables rrzStopGradient.calls||))(33rcDt|j|jSrsrurs rr/z StopGradient.compute_output_spec8>>@@rNr2rrrrrs 4Arrzkeras.ops.stop_gradientct|frtj|Stjj |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) )rrr7rrr)rs rrrs6&XK(~++H55 << % %h //rc0eZdZddfd ZdZdZxZS)ForiLoopNr:cPt||||_||_||_yr=)r>r?rupperbody_fun)rrrrr;rCs rr?zForiLoop.__init__s( d#    rctjj|j|j|j |Sr)rr fori_looprrrrinit_vals rrz ForiLoop.calls1||%% JJ JJ MM    rcDt|j|jSrsrurs rr/zForiLoop.compute_output_specrrrMrOs@rrrs7;!  Arrzkeras.ops.fori_loopct|||frt|||j|Stjj ||||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 )rrr7rrr)rrrrs rrrsH0UE845uh/==hGG << ! !%( CCrc2eZdZdddfd ZdZdZxZS)UnstackNr:cBt||||_||_yr=)r>r?numrT)rrrTr;rCs rr?zUnstack.__init__s! d# rcltjj||j|jSr)rrunstackrrTrr0s rrz Unstack.calls#||##Atxx;;rcpt|jt|j}|jd||j|dzdz}|j}||j|}|t d|jdt |Dcgc]}t||j}}|Scc}w)NrLz'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%) rrTr]r$rr_rangerr%)rr0rT output_shapesr_outputs rr/zUnstack.compute_output_specs CL9)<< hh ;''$-C ;977)66 FK3Z @AKm177 ;    sB3rrMrOs@rrrs <rrzkeras.ops.unstackct|frt||j|Stjj |||S)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])] )rrT)rrr7rrr)r0rrTs rrrsB&QD!sD!//22 <<  s  66rzkeras.ops.shapecpt|fr |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$rrr0s rr$r$ s,,QD!ww <<  a  rzkeras.ops.dtypec@tj|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%rs rr%r%;s*  $ $QWW --rc0eZdZddfd ZdZdZxZS)CastNr:c4t||||_yr=r>r?r%rr%r;rCs rr?z Cast.__init__TrlrcVtjj||jSr)rrcastr%rs rrz Cast.callXs||  DJJ//rcXtj|j|jSNrrrr$r%rs rr/zCast.compute_output_spec["" CCrrMrOs@rrrSs&*0Drrzkeras.ops.castctj|}t|frt||Stjj ||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") rt)rrrrrrr0r%s rrr_sG  % %e ,EQD! t% ## <<  Q &&rc0eZdZddfd ZdZdZxZS) SaturateCastNr:c4t||||_yr=rrs rr?zSaturateCast.__init__vrlrc.t||jSr)_saturate_castr%rs rrzSaturateCast.callzsa,,rcXtj|j|jSrrrs rr/z SaturateCast.compute_output_spec}rrrMrOs@rrrus&*-Drrzkeras.ops.saturate_castctj|}t|frt||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]] rt)rrrrrrs r saturate_castrs>^  % %e ,EQD!(|%(++ !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)NboolrrLrJ) ml_dtypesiinforrfinfo)r% dtype_min dtype_maxs rget_dtype_min_maxz)_saturate_cast..get_dtype_min_maxs U?II)## e^!.22I!.22I)##".22I!.22I)##rrrt) rrr%npmaximumastype nextafterminimumnumpyclipr) r0r%backend_modulerin_dtypein_minin_maxout_minout_max min_limit max_limits rrrs#.wN $  % %e ,E((1H&x0NFF(/GW 67+228  67+228  !!!Y :A   q% ((rc2eZdZdddfd ZdZdZxZS)ConvertToTensorNr:cPt||||_||_||_yr=)r>r?r%r&r')rr%r&r'r;rCs rr?zConvertToTensor.__init__s( d#   rctjj||j|j|j S)Nr%r&r')rrconvert_to_tensorr%r&r'rs rrzConvertToTensor.calls3||-- TZZ DKK.  rcN|jtj|jn |j}|j|jsdn |j}|j|jsdn |j}tj |j |||S)NFr#)r%rrr&r'rr$)rr0r%r&r's rr/z#ConvertToTensor.compute_output_specszz!  % %agg .  [[,T[[Eahh [[,T[[Eahh ""''vf  rNNNrMrOs@rrrsT   rrzkeras.ops.convert_to_tensorc|dntj|}t|frt||||Stjj ||||S)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) Nr)rrrrrr)r0r%r&r's rrrs_2MDw'@'@'GEQD!IU6&I!LL << ) ) vf * rzkeras.ops.convert_to_numpycnt|frtj|Stj|S)zlConvert a tensor to a NumPy array. Args: x: A tensor. Returns: A NumPy array. )rrarrayrconvert_to_numpyrs rrrs/QD!xx{  # #A &&rcBeZdZejdZdZdZdZy)Condcfd}tjr6tj|jjd}||i|S||i|S)Ncdt||rj|i|Sj|i|Sr)rr7r)argskwargsrs rcall_fnzCond.__call__..call_fn0s;#D&1)t))4:6:: tyy$1&11rz.call()) object_name)r is_traceback_filtering_enabled!inject_argument_info_in_tracebackrCr3)rr r!r"s` r__call__z Cond.__call__.sb 2  9 9 ;%GG $ 7 78@GD+F+ +'''rcDtjj|||Sr)rrr)rpredtrue_fnfalse_fns rrz Cond.callAs||  w99rctj|}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_specr_)rr(r)r* true_fn_spec false_fn_specs rr/zCond.compute_output_specDs_227; 33H= &&|]C#nE- C  rc tj||d}tj|||}ttj|S#YyxYw)NFc|| |duxr|duS|j|jk(xr|j|jk(Srr)t_specf_specs r check_leafz+Cond._check_output_spec..check_leafUsC~~8&D.8<<6<</PFLLFLL4P Pr)rassert_same_structurer-allr.)rr-r.r3sames rr,zCond._check_output_specOsQ   & &|] C Q !!*lMJ4<<%&& s AAN) r3r4r5r filter_tracebackr&rr/r,rrrrr-s)%%(&($:  'rrzkeras.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(r)r*s rrr^s 46$ **rcJeZdZddfd ZdZdZfdZedZxZ S) VectorizedMapNr:c4t||||_yr=)r>r?function)rr<r;rCs rr?zVectorizedMap.__init__ns d#  rcVtjj|j|Sr)rrvectorized_mapr<)relementss rrzVectorizedMap.callrs||**4==(CCrctjd|}tj|djdt j |j |}fd}tj||}|S)Nc |dSrrrs rrz3VectorizedMap.compute_output_spec..vr rrcztf|jz|j|j|jSr"r(r)s rr+z.append_batch_axiszr,r)rr-r.r$rr/r<)rr?r0r1r+r*s @rr/z!VectorizedMap.compute_output_specush   ~x 8 LL "1 % + +A .  ' ' q 9    0! 4rc^t|}|jd|ji|S)Nr<)r> get_configupdater<)rconfigrCs rrDzVectorizedMap.get_configs*#% z4==12 rch|j}tj|d|d<|di|S)Nr<r)copyr deserialize_keras_object)clsrFs r from_configzVectorizedMap.from_configs8.GG :  z}V}r) r3r4r5r?rr/rD classmethodrKrNrOs@rr:r:ms/)-!D  rr:zkeras.ops.vectorized_mapc|t|frt||Stjj ||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. )rr:rrr>)r<r?s rr>r>s7<XK(&}X&x00 << & &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_tensorrs rrOrOs << ! !! $$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 ``` )rrcustom_gradient)rs rrQrQsb << ' ' **r)NNFrLrerrr)rOrQrrrrYs^-)2DC-.+)*o)#)#X9DK K\"i"J*+9O,9Ox ;i ;!"8#8< =I =()L*L^"