CINXE.COM

<!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta name="description" content="Keras documentation"> <meta name="author" content="Keras Team"> <link rel="shortcut icon" href="https://keras.io/img/favicon.ico"> <link rel="canonical" href="https://keras.io/api/ops/numpy/" />  <meta property="og:title" content="Keras documentation: NumPy ops"> <meta property="og:image" content="https://keras.io/img/logo-k-keras-wb.png"> <meta name="twitter:title" content="Keras documentation: NumPy ops"> <meta name="twitter:image" content="https://keras.io/img/k-keras-social.png"> <meta name="twitter:card" content="summary"> <title>NumPy ops</title>  <link href="/css/bootstrap.min.css" rel="stylesheet">  <link href="https://fonts.googleapis.com/css2?family=Open+Sans:wght@400;600;700;800&display=swap" rel="stylesheet">  <link href="/css/docs.css" rel="stylesheet"> <link href="/css/monokai.css" rel="stylesheet">  <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start': new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0], j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src= 'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f); })(window,document,'script','dataLayer','GTM-5DNGF4N'); </script> <script> (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o), m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) })(window,document,'script','https://www.google-analytics.com/analytics.js','ga'); ga('create', 'UA-175165319-128', 'auto'); ga('send', 'pageview'); </script>  <script async defer src="https://buttons.github.io/buttons.js"></script> </head> <body>  <noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-5DNGF4N" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>  <div class='k-page'> <div class="k-nav" id="nav-menu"> <a href='/'><img src='/img/logo-small.png' class='logo-small' /></a> <div class="nav flex-column nav-pills" role="tablist" aria-orientation="vertical"> <a class="nav-link" href="/about/" role="tab" aria-selected="">About Keras</a> <a class="nav-link" href="/getting_started/" role="tab" aria-selected="">Getting started</a> <a class="nav-link" href="/guides/" role="tab" aria-selected="">Developer guides</a> <a class="nav-link active" href="/api/" role="tab" aria-selected="">Keras 3 API documentation</a> <a class="nav-sublink" href="/api/models/">Models API</a> <a class="nav-sublink" href="/api/layers/">Layers API</a> <a class="nav-sublink" href="/api/callbacks/">Callbacks API</a> <a class="nav-sublink active" href="/api/ops/">Ops API</a> <a class="nav-sublink2 active" href="/api/ops/numpy/">NumPy ops</a> <a class="nav-sublink2" href="/api/ops/nn/">NN ops</a> <a class="nav-sublink2" href="/api/ops/linalg/">Linear algebra ops</a> <a class="nav-sublink2" href="/api/ops/core/">Core ops</a> <a class="nav-sublink2" href="/api/ops/image/">Image ops</a> <a class="nav-sublink2" href="/api/ops/fft/">FFT ops</a> <a class="nav-sublink" href="/api/optimizers/">Optimizers</a> <a class="nav-sublink" href="/api/metrics/">Metrics</a> <a class="nav-sublink" href="/api/losses/">Losses</a> <a class="nav-sublink" href="/api/data_loading/">Data loading</a> <a class="nav-sublink" href="/api/datasets/">Built-in small datasets</a> <a class="nav-sublink" href="/api/applications/">Keras Applications</a> <a class="nav-sublink" href="/api/mixed_precision/">Mixed precision</a> <a class="nav-sublink" href="/api/distribution/">Multi-device distribution</a> <a class="nav-sublink" href="/api/random/">RNG API</a> <a class="nav-sublink" href="/api/utils/">Utilities</a> <a class="nav-sublink" href="/api/keras_tuner/">KerasTuner</a> <a class="nav-sublink" href="/api/keras_cv/">KerasCV</a> <a class="nav-sublink" href="/api/keras_nlp/">KerasNLP</a> <a class="nav-sublink" href="/api/keras_hub/">KerasHub</a> <a class="nav-link" href="/2.18/api/" role="tab" aria-selected="">Keras 2 API documentation</a> <a class="nav-link" href="/examples/" role="tab" aria-selected="">Code examples</a> <a class="nav-link" href="/keras_tuner/" role="tab" aria-selected="">KerasTuner: Hyperparameter Tuning</a> <a class="nav-link" href="/keras_hub/" role="tab" aria-selected="">KerasHub: Pretrained Models</a> <a class="nav-link" href="/keras_cv/" role="tab" aria-selected="">KerasCV: Computer Vision Workflows</a> <a class="nav-link" href="/keras_nlp/" role="tab" aria-selected="">KerasNLP: Natural Language Workflows</a> </div> </div> <div class='k-main'> <div class='k-main-top'> <script> function displayDropdownMenu() { e = document.getElementById("nav-menu"); if (e.style.display == "block") { e.style.display = "none"; } else { e.style.display = "block"; document.getElementById("dropdown-nav").style.display = "block"; } } function resetMobileUI() { if (window.innerWidth <= 840) { document.getElementById("nav-menu").style.display = "none"; document.getElementById("dropdown-nav").style.display = "block"; } else { document.getElementById("nav-menu").style.display = "block"; document.getElementById("dropdown-nav").style.display = "none"; } var navmenu = document.getElementById("nav-menu"); var menuheight = navmenu.clientHeight; var kmain = document.getElementById("k-main-id"); kmain.style.minHeight = (menuheight + 100) + 'px'; } window.onresize = resetMobileUI; window.addEventListener("load", (event) => { resetMobileUI() }); </script> <div id='dropdown-nav' onclick="displayDropdownMenu();"> <svg viewBox="-20 -20 120 120" width="60" height="60"> <rect width="100" height="20"></rect> <rect y="30" width="100" height="20"></rect> <rect y="60" width="100" height="20"></rect> </svg> </div> <form class="bd-search d-flex align-items-center k-search-form" id="search-form"> <input type="search" class="k-search-input" id="search-input" placeholder="Search Keras documentation..." aria-label="Search Keras documentation..." autocomplete="off"> <button class="k-search-btn"> <svg width="13" height="13" viewBox="0 0 13 13"><title>search</title><path d="m4.8495 7.8226c0.82666 0 1.5262-0.29146 2.0985-0.87438 0.57232-0.58292 0.86378-1.2877 0.87438-2.1144 0.010599-0.82666-0.28086-1.5262-0.87438-2.0985-0.59352-0.57232-1.293-0.86378-2.0985-0.87438-0.8055-0.010599-1.5103 0.28086-2.1144 0.87438-0.60414 0.59352-0.8956 1.293-0.87438 2.0985 0.021197 0.8055 0.31266 1.5103 0.87438 2.1144 0.56172 0.60414 1.2665 0.8956 2.1144 0.87438zm4.4695 0.2115 3.681 3.6819-1.259 1.284-3.6817-3.7 0.0019784-0.69479-0.090043-0.098846c-0.87973 0.76087-1.92 1.1413-3.1207 1.1413-1.3553 0-2.5025-0.46363-3.4417-1.3909s-1.4088-2.0686-1.4088-3.4239c0-1.3553 0.4696-2.4966 1.4088-3.4239 0.9392-0.92727 2.0864-1.3969 3.4417-1.4088 1.3553-0.011889 2.4906 0.45771 3.406 1.4088 0.9154 0.95107 1.379 2.0924 1.3909 3.4239 0 1.2126-0.38043 2.2588-1.1413 3.1385l0.098834 0.090049z"></path></svg> </button> </form> <script> var form = document.getElementById('search-form'); form.onsubmit = function(e) { e.preventDefault(); var query = document.getElementById('search-input').value; window.location.href = '/search.html?query=' + query; return False } </script> </div> <div class='k-main-inner' id='k-main-id'> <div class='k-location-slug'> ► <a href='/api/'>Keras 3 API documentation</a> / <a href='/api/ops/'>Ops API</a> / NumPy ops </div> <div class='k-content'> <h1 id="numpy-ops">NumPy ops</h1> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L86">[source]</a> <h3 id="absolute-function"><code>absolute</code> function</h3> <div class="codehilite"><pre><code>keras.ops.absolute(x) </code></pre></div> Compute the absolute value element-wise. <code>keras.ops.abs</code> is a shorthand for this function. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns An array containing the absolute value of each element in <code>x</code>. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([-1.2, 1.2]) >>> keras.ops.absolute(x) array([1.2, 1.2], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L139">[source]</a> <h3 id="add-function"><code>add</code> function</h3> <div class="codehilite"><pre><code>keras.ops.add(x1, x2) </code></pre></div> Add arguments element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns The tensor containing the element-wise sum of <code>x1</code> and <code>x2</code>. Examples <div class="codehilite"><pre><code>>>> x1 = keras.ops.convert_to_tensor([1, 4]) >>> x2 = keras.ops.convert_to_tensor([5, 6]) >>> keras.ops.add(x1, x2) array([6, 10], dtype=int32) </code></pre></div> <a href="/api/ops/numpy#add-function"><code>keras.ops.add</code></a> also broadcasts shapes: <div class="codehilite"><pre><code>>>> x1 = keras.ops.convert_to_tensor( ... [[5, 4], ... [5, 6]] ... ) >>> x2 = keras.ops.convert_to_tensor([5, 6]) >>> keras.ops.add(x1, x2) array([[10 10] [10 12]], shape=(2, 2), dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L198">[source]</a> <h3 id="all-function"><code>all</code> function</h3> <div class="codehilite"><pre><code>keras.ops.all(x, axis=None, keepdims=False) </code></pre></div> Test whether all array elements along a given axis evaluate to <code>True</code>. Arguments <ul> <li>x: Input tensor.</li> <li>axis: An integer or tuple of integers that represent the axis along which a logical AND reduction is performed. The default (<code>axis=None</code>) is to perform a logical AND over all the dimensions of the input array. <code>axis</code> may be negative, in which case it counts for the last to the first axis.</li> <li>keepdims: If <code>True</code>, axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. Defaults to <code>False</code>.</li> </ul> Returns The tensor containing the logical AND reduction over the <code>axis</code>. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([True, False]) >>> keras.ops.all(x) array(False, shape=(), dtype=bool) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, axis=0) array([ True False], shape=(2,), dtype=bool) </code></pre></div> <code>keepdims=True</code> outputs a tensor with dimensions reduced to one. <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, keepdims=True) array([[False]], shape=(1, 1), dtype=bool) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L321">[source]</a> <h3 id="amax-function"><code>amax</code> function</h3> <div class="codehilite"><pre><code>keras.ops.amax(x, axis=None, keepdims=False) </code></pre></div> Returns the maximum of an array or maximum value along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which to compute the maximum. By default (<code>axis=None</code>), find the maximum value in all the dimensions of the input array.</li> <li>keepdims: If <code>True</code>, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults to <code>False</code>.</li> </ul> Returns An array with the maximum value. If <code>axis=None</code>, the result is a scalar value representing the maximum element in the entire array. If <code>axis</code> is given, the result is an array with the maximum values along the specified axis. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[1, 3, 5], [2, 3, 6]]) >>> keras.ops.amax(x) array(6, dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]]) >>> keras.ops.amax(x, axis=0) array([1, 6, 8], dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]]) >>> keras.ops.amax(x, axis=1, keepdims=True) array([[8], [5]], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L376">[source]</a> <h3 id="amin-function"><code>amin</code> function</h3> <div class="codehilite"><pre><code>keras.ops.amin(x, axis=None, keepdims=False) </code></pre></div> Returns the minimum of an array or minimum value along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which to compute the minimum. By default (<code>axis=None</code>), find the minimum value in all the dimensions of the input array.</li> <li>keepdims: If <code>True</code>, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults to <code>False</code>.</li> </ul> Returns An array with the minimum value. If <code>axis=None</code>, the result is a scalar value representing the minimum element in the entire array. If <code>axis</code> is given, the result is an array with the minimum values along the specified axis. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([1, 3, 5, 2, 3, 6]) >>> keras.ops.amin(x) array(1, dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]]) >>> keras.ops.amin(x, axis=0) array([1,5,3], dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]]) >>> keras.ops.amin(x, axis=1, keepdims=True) array([[1],[3]], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L262">[source]</a> <h3 id="any-function"><code>any</code> function</h3> <div class="codehilite"><pre><code>keras.ops.any(x, axis=None, keepdims=False) </code></pre></div> Test whether any array element along a given axis evaluates to <code>True</code>. Arguments <ul> <li>x: Input tensor.</li> <li>axis: An integer or tuple of integers that represent the axis along which a logical OR reduction is performed. The default (<code>axis=None</code>) is to perform a logical OR over all the dimensions of the input array. <code>axis</code> may be negative, in which case it counts for the last to the first axis.</li> <li>keepdims: If <code>True</code>, axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. Defaults to <code>False</code>.</li> </ul> Returns The tensor containing the logical OR reduction over the <code>axis</code>. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([True, False]) >>> keras.ops.any(x) array(True, shape=(), dtype=bool) </code></pre></div> <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.any(x, axis=0) array([ True True], shape=(2,), dtype=bool) </code></pre></div> <code>keepdims=True</code> outputs a tensor with dimensions reduced to one. <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, keepdims=True) array([[False]], shape=(1, 1), dtype=bool) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L447">[source]</a> <h3 id="append-function"><code>append</code> function</h3> <div class="codehilite"><pre><code>keras.ops.append(x1, x2, axis=None) </code></pre></div> Append tensor <code>x2</code> to the end of tensor <code>x1</code>. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> <li>axis: Axis along which tensor <code>x2</code> is appended to tensor <code>x1</code>. If <code>None</code>, both tensors are flattened before use.</li> </ul> Returns A tensor with the values of <code>x2</code> appended to <code>x1</code>. Examples <div class="codehilite"><pre><code>>>> x1 = keras.ops.convert_to_tensor([1, 2, 3]) >>> x2 = keras.ops.convert_to_tensor([[4, 5, 6], [7, 8, 9]]) >>> keras.ops.append(x1, x2) array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32) </code></pre></div> When <code>axis</code> is specified, <code>x1</code> and <code>x2</code> must have compatible shapes. <div class="codehilite"><pre><code>>>> x1 = keras.ops.convert_to_tensor([[1, 2, 3], [4, 5, 6]]) >>> x2 = keras.ops.convert_to_tensor([[7, 8, 9]]) >>> keras.ops.append(x1, x2, axis=0) array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=int32) >>> x3 = keras.ops.convert_to_tensor([7, 8, 9]) >>> keras.ops.append(x1, x3, axis=0) Traceback (most recent call last): ... TypeError: Cannot concatenate arrays with different numbers of dimensions: got (2, 3), (3,). </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L508">[source]</a> <h3 id="arange-function"><code>arange</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arange(start, stop=None, step=1, dtype=None) </code></pre></div> Return evenly spaced values within a given interval. <code>arange</code> can be called with a varying number of positional arguments: * <code>arange(stop)</code>: Values are generated within the half-open interval <code>[0, stop)</code> (in other words, the interval including start but excluding stop). * <code>arange(start, stop)</code>: Values are generated within the half-open interval <code>[start, stop)</code>. * <code>arange(start, stop, step)</code>: Values are generated within the half-open interval <code>[start, stop)</code>, with spacing between values given by step. Arguments <ul> <li>start: Integer or real, representing the start of the interval. The interval includes this value.</li> <li>stop: Integer or real, representing the end of the interval. The interval does not include this value, except in some cases where <code>step</code> is not an integer and floating point round-off affects the length of <code>out</code>. Defaults to <code>None</code>.</li> <li>step: Integer or real, represent the spacing between values. For any output <code>out</code>, this is the distance between two adjacent values, <code>out[i+1] - out[i]</code>. The default step size is 1. If <code>step</code> is specified as a position argument, <code>start</code> must also be given.</li> <li>dtype: The type of the output array. If <code>dtype</code> is not given, infer the data type from the other input arguments.</li> </ul> Returns Tensor of evenly spaced values. For floating point arguments, the length of the result is <code>ceil((stop - start)/step)</code>. Because of floating point overflow, this rule may result in the last element of out being greater than stop. Examples <div class="codehilite"><pre><code>>>> keras.ops.arange(3) array([0, 1, 2], dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> keras.ops.arange(3.0) array([0., 1., 2.], dtype=float32) </code></pre></div> <div class="codehilite"><pre><code>>>> keras.ops.arange(3, 7) array([3, 4, 5, 6], dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> keras.ops.arange(3, 7, 2) array([3, 5], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L570">[source]</a> <h3 id="arccos-function"><code>arccos</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arccos(x) </code></pre></div> Trigonometric inverse cosine, element-wise. The inverse of <code>cos</code> so that, if <code>y = cos(x)</code>, then <code>x = arccos(y)</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Tensor of the angle of the ray intersecting the unit circle at the given x-coordinate in radians <code>[0, pi]</code>. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([1, -1]) >>> keras.ops.arccos(x) array([0.0, 3.1415927], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L606">[source]</a> <h3 id="arccosh-function"><code>arccosh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arccosh(x) </code></pre></div> Inverse hyperbolic cosine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as x. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([10, 100]) >>> keras.ops.arccosh(x) array([2.993223, 5.298292], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L640">[source]</a> <h3 id="arcsin-function"><code>arcsin</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arcsin(x) </code></pre></div> Inverse sine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Tensor of the inverse sine of each element in <code>x</code>, in radians and in the closed interval <code>[-pi/2, pi/2]</code>. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([1, -1, 0]) >>> keras.ops.arcsin(x) array([ 1.5707964, -1.5707964, 0.], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L675">[source]</a> <h3 id="arcsinh-function"><code>arcsinh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arcsinh(x) </code></pre></div> Inverse hyperbolic sine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([1, -1, 0]) >>> keras.ops.arcsinh(x) array([0.88137364, -0.88137364, 0.0], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L709">[source]</a> <h3 id="arctan-function"><code>arctan</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arctan(x) </code></pre></div> Trigonometric inverse tangent, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Tensor of the inverse tangent of each element in <code>x</code>, in the interval <code>[-pi/2, pi/2]</code>. Example <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([0, 1]) >>> keras.ops.arctan(x) array([0., 0.7853982], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L748">[source]</a> <h3 id="arctan2-function"><code>arctan2</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arctan2(x1, x2) </code></pre></div> Element-wise arc tangent of <code>x1/x2</code> choosing the quadrant correctly. The quadrant (i.e., branch) is chosen so that <code>arctan2(x1, x2)</code> is the signed angle in radians between the ray ending at the origin and passing through the point <code>(1, 0)</code>, and the ray ending at the origin and passing through the point <code>(x2, x1)</code>. (Note the role reversal: the "y-coordinate" is the first function parameter, the "x-coordinate" is the second.) By IEEE convention, this function is defined for <code>x2 = +/-0</code> and for either or both of <code>x1</code> and <code>x2</code> <code>= +/-inf</code>. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Tensor of angles in radians, in the range <code>[-pi, pi]</code>. Examples Consider four points in different quadrants: <div class="codehilite"><pre><code>>>> x = keras.ops.convert_to_tensor([-1, +1, +1, -1]) >>> y = keras.ops.convert_to_tensor([-1, -1, +1, +1]) >>> keras.ops.arctan2(y, x) * 180 / numpy.pi array([-135., -45., 45., 135.], dtype=float32) </code></pre></div> Note the order of the parameters. <code>arctan2</code> is defined also when x2=0 and at several other points, obtaining values in the range <code>[-pi, pi]</code>: <div class="codehilite"><pre><code>>>> keras.ops.arctan2( ... keras.ops.array([1., -1.]), ... keras.ops.array([0., 0.]), ... ) array([ 1.5707964, -1.5707964], dtype=float32) >>> keras.ops.arctan2( ... keras.ops.array([0., 0., numpy.inf]), ... keras.ops.array([+0., -0., numpy.inf]), ... ) array([0., 3.1415925, 0.7853982], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L806">[source]</a> <h3 id="arctanh-function"><code>arctanh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.arctanh(x) </code></pre></div> Inverse hyperbolic tangent, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L840">[source]</a> <h3 id="argmax-function"><code>argmax</code> function</h3> <div class="codehilite"><pre><code>keras.ops.argmax(x, axis=None, keepdims=False) </code></pre></div> Returns the indices of the maximum values along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: By default, the index is into the flattened tensor, otherwise along the specified axis.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one. Defaults to <code>False</code>.</li> </ul> Returns Tensor of indices. It has the same shape as <code>x</code>, with the dimension along <code>axis</code> removed. Example <div class="codehilite"><pre><code>>>> x = keras.ops.arange(6).reshape(2, 3) + 10 >>> x array([[10, 11, 12], [13, 14, 15]], dtype=int32) >>> keras.ops.argmax(x) array(5, dtype=int32) >>> keras.ops.argmax(x, axis=0) array([1, 1, 1], dtype=int32) >>> keras.ops.argmax(x, axis=1) array([2, 2], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L891">[source]</a> <h3 id="argmin-function"><code>argmin</code> function</h3> <div class="codehilite"><pre><code>keras.ops.argmin(x, axis=None, keepdims=False) </code></pre></div> Returns the indices of the minium values along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: By default, the index is into the flattened tensor, otherwise along the specified axis.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one. Defaults to <code>False</code>.</li> </ul> Returns Tensor of indices. It has the same shape as <code>x</code>, with the dimension along <code>axis</code> removed. Example <div class="codehilite"><pre><code>>>> x = keras.ops.arange(6).reshape(2, 3) + 10 >>> x array([[10, 11, 12], [13, 14, 15]], dtype=int32) >>> keras.ops.argmin(x) array(0, dtype=int32) >>> keras.ops.argmin(x, axis=0) array([0, 0, 0], dtype=int32) >>> keras.ops.argmin(x, axis=1) array([0, 0], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6589">[source]</a> <h3 id="argpartition-function"><code>argpartition</code> function</h3> <div class="codehilite"><pre><code>keras.ops.argpartition(x, kth, axis=-1) </code></pre></div> Performs an indirect partition along the given axis. It returns an array of indices of the same shape as <code>x</code> that index data along the given axis in partitioned order. Arguments <ul> <li>a: Array to sort.</li> <li>kth: Element index to partition by. The k-th element will be in its final sorted position and all smaller elements will be moved before it and all larger elements behind it. The order of all elements in the partitions is undefined. If provided with a sequence of k-th it will partition all of them into their sorted position at once.</li> <li>axis: Axis along which to sort. The default is -1 (the last axis). If <code>None</code>, the flattened array is used.</li> </ul> Returns Array of indices that partition <code>x</code> along the specified <code>axis</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L937">[source]</a> <h3 id="argsort-function"><code>argsort</code> function</h3> <div class="codehilite"><pre><code>keras.ops.argsort(x, axis=-1) </code></pre></div> Returns the indices that would sort a tensor. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which to sort. Defaults to <code>-1</code> (the last axis). If <code>None</code>, the flattened tensor is used.</li> </ul> Returns Tensor of indices that sort <code>x</code> along the specified <code>axis</code>. Examples One dimensional array: <div class="codehilite"><pre><code>>>> x = keras.ops.array([3, 1, 2]) >>> keras.ops.argsort(x) array([1, 2, 0], dtype=int32) </code></pre></div> Two-dimensional array: <div class="codehilite"><pre><code>>>> x = keras.ops.array([[0, 3], [3, 2], [4, 5]]) >>> x array([[0, 3], [3, 2], [4, 5]], dtype=int32) >>> keras.ops.argsort(x, axis=0) array([[0, 1], [1, 0], [2, 2]], dtype=int32) >>> keras.ops.argsort(x, axis=1) array([[0, 1], [1, 0], [0, 1]], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L983">[source]</a> <h3 id="array-function"><code>array</code> function</h3> <div class="codehilite"><pre><code>keras.ops.array(x, dtype=None) </code></pre></div> Create a tensor. Arguments <ul> <li>x: Input tensor.</li> <li>dtype: The desired data-type for the tensor.</li> </ul> Returns A tensor. Examples <div class="codehilite"><pre><code>>>> keras.ops.array([1, 2, 3]) array([1, 2, 3], dtype=int32) </code></pre></div> <div class="codehilite"><pre><code>>>> keras.ops.array([1, 2, 3], dtype="float32") array([1., 2., 3.], dtype=float32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1051">[source]</a> <h3 id="average-function"><code>average</code> function</h3> <div class="codehilite"><pre><code>keras.ops.average(x, axis=None, weights=None) </code></pre></div> Compute the weighted average along the specified axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Integer along which to average <code>x</code>. The default, <code>axis=None</code>, will average over all of the elements of the input tensor. If axis is negative it counts from the last to the first axis.</li> <li>weights: Tensor of wieghts associated with the values in <code>x</code>. Each value in <code>x</code> contributes to the average according to its associated weight. The weights array can either be 1-D (in which case its length must be the size of a along the given axis) or of the same shape as <code>x</code>. If <code>weights=None</code> (default), then all data in <code>x</code> are assumed to have a weight equal to one.</li> <li>__ The 1-D calculation is__: <code>avg = sum(a * weights) / sum(weights)</code>. The only constraint on weights is that <code>sum(weights)</code> must not be 0.</li> </ul> Returns Return the average along the specified axis. Examples <div class="codehilite"><pre><code>>>> data = keras.ops.arange(1, 5) >>> data array([1, 2, 3, 4], dtype=int32) >>> keras.ops.average(data) array(2.5, dtype=float32) >>> keras.ops.average( ... keras.ops.arange(1, 11), ... weights=keras.ops.arange(10, 0, -1) ... ) array(4., dtype=float32) </code></pre></div> <div class="codehilite"><pre><code>>>> data = keras.ops.arange(6).reshape((3, 2)) >>> data array([[0, 1], [2, 3], [4, 5]], dtype=int32) >>> keras.ops.average( ... data, ... axis=1, ... weights=keras.ops.array([1./4, 3./4]) ... ) array([0.75, 2.75, 4.75], dtype=float32) >>> keras.ops.average( ... data, ... weights=keras.ops.array([1./4, 3./4]) ... ) Traceback (most recent call last): ... ValueError: Axis must be specified when shapes of a and weights differ. </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1140">[source]</a> <h3 id="bincount-function"><code>bincount</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bincount(x, weights=None, minlength=0, sparse=False) </code></pre></div> Count the number of occurrences of each value in a tensor of integers. Arguments <ul> <li>x: Input tensor. It must be of dimension 1, and it must only contain non-negative integer(s).</li> <li>weights: Weight tensor. It must have the same length as <code>x</code>. The default value is <code>None</code>. If specified, <code>x</code> is weighted by it, i.e. if <code>n = x[i]</code>, <code>out[n] += weight[i]</code> instead of the default behavior <code>out[n] += 1</code>.</li> <li>minlength: An integer. The default value is 0. If specified, there will be at least this number of bins in the output tensor. If greater than <code>max(x) + 1</code>, each value of the output at an index higher than <code>max(x)</code> is set to 0.</li> <li>sparse: Whether to return a sparse tensor; for backends that support sparse tensors.</li> </ul> Returns 1D tensor where each element gives the number of occurrence(s) of its index value in x. Its length is the maximum between <code>max(x) + 1</code> and minlength. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.array([1, 2, 2, 3], dtype="uint8") >>> keras.ops.bincount(x) array([0, 1, 2, 1], dtype=int32) >>> weights = x / 2 >>> weights array([0.5, 1., 1., 1.5], dtype=float64) >>> keras.ops.bincount(x, weights=weights) array([0., 0.5, 2., 1.5], dtype=float64) >>> minlength = (keras.ops.max(x).numpy() + 1) + 2 # 6 >>> keras.ops.bincount(x, minlength=minlength) array([0, 1, 2, 1, 0, 0], dtype=int32) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1199">[source]</a> <h3 id="bitwiseand-function"><code>bitwise_and</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_and(x, y) </code></pre></div> Compute the bit-wise AND of two arrays element-wise. Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>&</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1230">[source]</a> <h3 id="bitwiseinvert-function"><code>bitwise_invert</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_invert(x) </code></pre></div> Compute bit-wise inversion, or bit-wise NOT, element-wise. Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>. Arguments <ul> <li>x: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1355">[source]</a> <h3 id="bitwiseleftshift-function"><code>bitwise_left_shift</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_left_shift(x, y) </code></pre></div> Shift the bits of an integer to the left. Bits are shifted to the left by appending <code>y</code> 0s at the right of <code>x</code>. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying <code>x</code> by <code>2**y</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1260">[source]</a> <h3 id="bitwisenot-function"><code>bitwise_not</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_not(x) </code></pre></div> Compute bit-wise inversion, or bit-wise NOT, element-wise. Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>. Arguments <ul> <li>x: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1291">[source]</a> <h3 id="bitwiseor-function"><code>bitwise_or</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_or(x, y) </code></pre></div> Compute the bit-wise OR of two arrays element-wise. Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>|</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1421">[source]</a> <h3 id="bitwiserightshift-function"><code>bitwise_right_shift</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_right_shift(x, y) </code></pre></div> Shift the bits of an integer to the right. Bits are shifted to the right <code>y</code>. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing <code>x</code> by <code>2**y</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1323">[source]</a> <h3 id="bitwisexor-function"><code>bitwise_xor</code> function</h3> <div class="codehilite"><pre><code>keras.ops.bitwise_xor(x, y) </code></pre></div> Compute the bit-wise XOR of two arrays element-wise. Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>^</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1489">[source]</a> <h3 id="broadcastto-function"><code>broadcast_to</code> function</h3> <div class="codehilite"><pre><code>keras.ops.broadcast_to(x, shape) </code></pre></div> Broadcast a tensor to a new shape. Arguments <ul> <li>x: The tensor to broadcast.</li> <li>shape: The shape of the desired tensor. A single integer <code>i</code> is interpreted as <code>(i,)</code>.</li> </ul> Returns A tensor with the desired shape. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.array([1, 2, 3]) >>> keras.ops.broadcast_to(x, (3, 3)) array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1531">[source]</a> <h3 id="ceil-function"><code>ceil</code> function</h3> <div class="codehilite"><pre><code>keras.ops.ceil(x) </code></pre></div> Return the ceiling of the input, element-wise. The ceil of the scalar <code>x</code> is the smallest integer <code>i</code>, such that <code>i >= x</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The ceiling of each element in <code>x</code>, with float dtype. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1565">[source]</a> <h3 id="clip-function"><code>clip</code> function</h3> <div class="codehilite"><pre><code>keras.ops.clip(x, x_min, x_max) </code></pre></div> Clip (limit) the values in a tensor. Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of <code>[0, 1]</code> is specified, values smaller than 0 become 0, and values larger than 1 become 1. Arguments <ul> <li>x: Input tensor.</li> <li>x_min: Minimum value.</li> <li>x_max: Maximum value.</li> </ul> Returns The clipped tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1622">[source]</a> <h3 id="concatenate-function"><code>concatenate</code> function</h3> <div class="codehilite"><pre><code>keras.ops.concatenate(xs, axis=0) </code></pre></div> Join a sequence of tensors along an existing axis. Arguments <ul> <li>xs: The sequence of tensors to concatenate.</li> <li>axis: The axis along which the tensors will be joined. Defaults to <code>0</code>.</li> </ul> Returns The concatenated tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1676">[source]</a> <h3 id="conj-function"><code>conj</code> function</h3> <div class="codehilite"><pre><code>keras.ops.conj(x) </code></pre></div> Shorthand for <a href="/api/ops/numpy#conjugate-function"><code>keras.ops.conjugate</code></a>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1652">[source]</a> <h3 id="conjugate-function"><code>conjugate</code> function</h3> <div class="codehilite"><pre><code>keras.ops.conjugate(x) </code></pre></div> Returns the complex conjugate, element-wise. The complex conjugate of a complex number is obtained by changing the sign of its imaginary part. <a href="/api/ops/numpy#conj-function"><code>keras.ops.conj</code></a> is a shorthand for this function. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The complex conjugate of each element in <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1691">[source]</a> <h3 id="copy-function"><code>copy</code> function</h3> <div class="codehilite"><pre><code>keras.ops.copy(x) </code></pre></div> Returns a copy of <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns A copy of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6453">[source]</a> <h3 id="correlate-function"><code>correlate</code> function</h3> <div class="codehilite"><pre><code>keras.ops.correlate(x1, x2, mode="valid") </code></pre></div> Compute the cross-correlation of two 1-dimensional tensors. Arguments <ul> <li>x1: First 1-dimensional input tensor of length M.</li> <li>x2: Second 1-dimensional input tensor of length N.</li> <li>mode: Either <code>valid</code>, <code>same</code> or <code>full</code>. By default the mode is set to <code>valid</code>, which returns an output of length max(M, N) - min(M, N) + 1. <code>same</code> returns an output of length max(M, N). <code>full</code> mode returns the convolution at each point of overlap, with an output length of N+M-1</li> </ul> Returns Output tensor, cross-correlation of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1719">[source]</a> <h3 id="cos-function"><code>cos</code> function</h3> <div class="codehilite"><pre><code>keras.ops.cos(x) </code></pre></div> Cosine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The corresponding cosine values. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1747">[source]</a> <h3 id="cosh-function"><code>cosh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.cosh(x) </code></pre></div> Hyperbolic cosine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1780">[source]</a> <h3 id="countnonzero-function"><code>count_nonzero</code> function</h3> <div class="codehilite"><pre><code>keras.ops.count_nonzero(x, axis=None) </code></pre></div> Counts the number of non-zero values in <code>x</code> along the given <code>axis</code>. If no axis is specified then all non-zeros in the tensor are counted. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or tuple of axes along which to count the number of non-zeros. Defaults to <code>None</code>.</li> </ul> Returns int or tensor of ints. Examples <div class="codehilite"><pre><code>>>> x = keras.ops.array([[0, 1, 7, 0], [3, 0, 2, 19]]) >>> keras.ops.count_nonzero(x) 5 >>> keras.ops.count_nonzero(x, axis=0) array([1, 1, 2, 1], dtype=int64) >>> keras.ops.count_nonzero(x, axis=1) array([2, 3], dtype=int64) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1862">[source]</a> <h3 id="cross-function"><code>cross</code> function</h3> <div class="codehilite"><pre><code>keras.ops.cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None) </code></pre></div> Returns the cross product of two (arrays of) vectors. The cross product of <code>x1</code> and <code>x2</code> in R^3 is a vector perpendicular to both <code>x1</code> and <code>x2</code>. If <code>x1</code> and <code>x2</code> are arrays of vectors, the vectors are defined by the last axis of <code>x1</code> and <code>x2</code> by default, and these axes can have dimensions 2 or 3. Where the dimension of either <code>x1</code> or <code>x2</code> is 2, the third component of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned. Arguments <ul> <li>x1: Components of the first vector(s).</li> <li>x2: Components of the second vector(s).</li> <li>axisa: Axis of <code>x1</code> that defines the vector(s). Defaults to <code>-1</code>.</li> <li>axisb: Axis of <code>x2</code> that defines the vector(s). Defaults to <code>-1</code>.</li> <li>axisc: Axis of the result containing the cross product vector(s). Ignored if both input vectors have dimension 2, as the return is scalar. By default, the last axis.</li> <li>axis: If defined, the axis of <code>x1</code>, <code>x2</code> and the result that defines the vector(s) and cross product(s). Overrides <code>axisa</code>, <code>axisb</code> and <code>axisc</code>.</li> </ul> Note: Torch backend does not support two dimensional vectors, or the arguments <code>axisa</code>, <code>axisb</code> and <code>axisc</code>. Use <code>axis</code> instead. Returns Vector cross product(s). <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1934">[source]</a> <h3 id="cumprod-function"><code>cumprod</code> function</h3> <div class="codehilite"><pre><code>keras.ops.cumprod(x, axis=None, dtype=None) </code></pre></div> Return the cumulative product of elements along a given axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which the cumulative product is computed. By default the input is flattened.</li> <li>dtype: dtype of returned tensor. Defaults to x.dtype.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1973">[source]</a> <h3 id="cumsum-function"><code>cumsum</code> function</h3> <div class="codehilite"><pre><code>keras.ops.cumsum(x, axis=None, dtype=None) </code></pre></div> Returns the cumulative sum of elements along a given axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which the cumulative sum is computed. By default the input is flattened.</li> <li>dtype: dtype of returned tensor. Defaults to x.dtype.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2026">[source]</a> <h3 id="diag-function"><code>diag</code> function</h3> <div class="codehilite"><pre><code>keras.ops.diag(x, k=0) </code></pre></div> Extract a diagonal or construct a diagonal array. Arguments <ul> <li>x: Input tensor. If <code>x</code> is 2-D, returns the k-th diagonal of <code>x</code>. If <code>x</code> is 1-D, return a 2-D tensor with <code>x</code> on the k-th diagonal.</li> <li>k: The diagonal to consider. Defaults to <code>0</code>. Use <code>k > 0</code> for diagonals above the main diagonal, and <code>k < 0</code> for diagonals below the main diagonal.</li> </ul> Returns The extracted diagonal or constructed diagonal tensor. Examples <div class="codehilite"><pre><code>>>> from keras.src import ops >>> x = ops.arange(9).reshape((3, 3)) >>> x array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) </code></pre></div> <div class="codehilite"><pre><code>>>> ops.diag(x) array([0, 4, 8]) >>> ops.diag(x, k=1) array([1, 5]) >>> ops.diag(x, k=-1) array([3, 7]) </code></pre></div> <div class="codehilite"><pre><code>>>> ops.diag(ops.diag(x))) array([[0, 0, 0], [0, 4, 0], [0, 0, 8]]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2107">[source]</a> <h3 id="diagonal-function"><code>diagonal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.diagonal(x, offset=0, axis1=0, axis2=1) </code></pre></div> Return specified diagonals. If <code>x</code> is 2-D, returns the diagonal of <code>x</code> with the given offset, i.e., the collection of elements of the form <code>x[i, i+offset]</code>. If <code>x</code> has more than two dimensions, the axes specified by <code>axis1</code> and <code>axis2</code> are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing <code>axis1</code> and <code>axis2</code> and appending an index to the right equal to the size of the resulting diagonals. Arguments <ul> <li>x: Input tensor.</li> <li>offset: Offset of the diagonal from the main diagonal. Can be positive or negative. Defaults to <code>0</code>.(main diagonal).</li> <li>axis1: Axis to be used as the first axis of the 2-D sub-arrays. Defaults to <code>0</code>.(first axis).</li> <li>axis2: Axis to be used as the second axis of the 2-D sub-arrays. Defaults to <code>1</code> (second axis).</li> </ul> Returns Tensor of diagonals. Examples <div class="codehilite"><pre><code>>>> from keras.src import ops >>> x = ops.arange(4).reshape((2, 2)) >>> x array([[0, 1], [2, 3]]) >>> x.diagonal() array([0, 3]) >>> x.diagonal(1) array([1]) </code></pre></div> <div class="codehilite"><pre><code>>>> x = ops.arange(8).reshape((2, 2, 2)) >>> x array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) >>> x.diagonal(0, 0, 1) array([[0, 6], [1, 7]]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2186">[source]</a> <h3 id="diff-function"><code>diff</code> function</h3> <div class="codehilite"><pre><code>keras.ops.diff(a, n=1, axis=-1) </code></pre></div> Calculate the n-th discrete difference along the given axis. The first difference is given by <code>out[i] = a[i+1] - a[i]</code> along the given axis, higher differences are calculated by using <code>diff</code> recursively. Arguments <ul> <li>a: Input tensor.</li> <li>n: The number of times values are differenced. Defaults to <code>1</code>.</li> <li>axis: Axis to compute discrete difference(s) along. Defaults to <code>-1</code>.(last axis).</li> </ul> Returns Tensor of diagonals. Examples <div class="codehilite"><pre><code>>>> from keras.src import ops >>> x = ops.convert_to_tensor([1, 2, 4, 7, 0]) >>> ops.diff(x) array([ 1, 2, 3, -7]) >>> ops.diff(x, n=2) array([ 1, 1, -10]) </code></pre></div> <div class="codehilite"><pre><code>>>> x = ops.convert_to_tensor([[1, 3, 6, 10], [0, 5, 6, 8]]) >>> ops.diff(x) array([[2, 3, 4], [5, 1, 2]]) >>> ops.diff(x, axis=0) array([[-1, 2, 0, -2]]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2236">[source]</a> <h3 id="digitize-function"><code>digitize</code> function</h3> <div class="codehilite"><pre><code>keras.ops.digitize(x, bins) </code></pre></div> Returns the indices of the bins to which each value in <code>x</code> belongs. Arguments <ul> <li>x: Input array to be binned.</li> <li>bins: Array of bins. It has to be one-dimensional and monotonically increasing.</li> </ul> Returns Output array of indices, of same shape as <code>x</code>. Example <div class="codehilite"><pre><code>>>> x = np.array([0.0, 1.0, 3.0, 1.6]) >>> bins = np.array([0.0, 3.0, 4.5, 7.0]) >>> keras.ops.digitize(x, bins) array([1, 1, 2, 1]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5861">[source]</a> <h3 id="divide-function"><code>divide</code> function</h3> <div class="codehilite"><pre><code>keras.ops.divide(x1, x2) </code></pre></div> Divide arguments element-wise. <a href="/api/ops/numpy#truedivide-function"><code>keras.ops.true_divide</code></a> is an alias for this function. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, the quotient <code>x1/x2</code>, element-wise. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5900">[source]</a> <h3 id="dividenonan-function"><code>divide_no_nan</code> function</h3> <div class="codehilite"><pre><code>keras.ops.divide_no_nan(x1, x2) </code></pre></div> Safe element-wise division which returns 0 where the denominator is 0. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns The quotient <code>x1/x2</code>, element-wise, with zero where x2 is zero. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2299">[source]</a> <h3 id="dot-function"><code>dot</code> function</h3> <div class="codehilite"><pre><code>keras.ops.dot(x1, x2) </code></pre></div> Dot product of two tensors. <ul> <li>If both <code>x1</code> and <code>x2</code> are 1-D tensors, it is inner product of vectors (without complex conjugation).</li> <li>If both <code>x1</code> and <code>x2</code> are 2-D tensors, it is matrix multiplication.</li> <li>If either <code>x1</code> or <code>x2</code> is 0-D (scalar), it is equivalent to <code>x1 * x2</code>.</li> <li>If <code>x1</code> is an N-D tensor and <code>x2</code> is a 1-D tensor, it is a sum product over the last axis of <code>x1</code> and <code>x2</code>.</li> <li>If <code>x1</code> is an N-D tensor and <code>x2</code> is an M-D tensor (where <code>M>=2</code>), it is a sum product over the last axis of <code>x1</code> and the second-to-last axis of <code>x2</code>: <code>dot(x1, x2)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])</code>.</li> </ul> Arguments <ul> <li>x1: First argument.</li> <li>x2: Second argument.</li> </ul> Note: Torch backend does not accept 0-D tensors as arguments. Returns Dot product of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2507">[source]</a> <h3 id="einsum-function"><code>einsum</code> function</h3> <div class="codehilite"><pre><code>keras.ops.einsum(subscripts, *operands) </code></pre></div> Evaluates the Einstein summation convention on the operands. Arguments <ul> <li>subscripts: Specifies the subscripts for summation as comma separated list of subscript labels. An implicit (classical Einstein summation) calculation is performed unless the explicit indicator <code>-></code> is included as well as subscript labels of the precise output form.</li> <li>operands: The operands to compute the Einstein sum of.</li> </ul> Returns The calculation based on the Einstein summation convention. Example <div class="codehilite"><pre><code>>>> from keras.src import ops >>> a = ops.arange(25).reshape(5, 5) >>> b = ops.arange(5) >>> c = ops.arange(6).reshape(2, 3) </code></pre></div> Trace of a matrix: <div class="codehilite"><pre><code>>>> ops.einsum("ii", a) 60 >>> ops.einsum(a, [0, 0]) 60 >>> ops.trace(a) 60 </code></pre></div> Extract the diagonal: <div class="codehilite"><pre><code>>>> ops.einsum("ii -> i", a) array([ 0, 6, 12, 18, 24]) >>> ops.einsum(a, [0, 0], [0]) array([ 0, 6, 12, 18, 24]) >>> ops.diag(a) array([ 0, 6, 12, 18, 24]) </code></pre></div> Sum over an axis: <div class="codehilite"><pre><code>>>> ops.einsum("ij -> i", a) array([ 10, 35, 60, 85, 110]) >>> ops.einsum(a, [0, 1], [0]) array([ 10, 35, 60, 85, 110]) >>> ops.sum(a, axis=1) array([ 10, 35, 60, 85, 110]) </code></pre></div> For higher dimensional tensors summing a single axis can be done with ellipsis: <div class="codehilite"><pre><code>>>> ops.einsum("...j -> ...", a) array([ 10, 35, 60, 85, 110]) >>> np.einsum(a, [..., 1], [...]) array([ 10, 35, 60, 85, 110]) </code></pre></div> Compute a matrix transpose or reorder any number of axes: <div class="codehilite"><pre><code>>>> ops.einsum("ji", c) array([[0, 3], [1, 4], [2, 5]]) >>> ops.einsum("ij -> ji", c) array([[0, 3], [1, 4], [2, 5]]) >>> ops.einsum(c, [1, 0]) array([[0, 3], [1, 4], [2, 5]]) >>> ops.transpose(c) array([[0, 3], [1, 4], [2, 5]]) </code></pre></div> Matrix vector multiplication: <div class="codehilite"><pre><code>>>> ops.einsum("ij, j", a, b) array([ 30, 80, 130, 180, 230]) >>> ops.einsum(a, [0, 1], b, [1]) array([ 30, 80, 130, 180, 230]) >>> ops.einsum("...j, j", a, b) array([ 30, 80, 130, 180, 230]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2605">[source]</a> <h3 id="empty-function"><code>empty</code> function</h3> <div class="codehilite"><pre><code>keras.ops.empty(shape, dtype=None) </code></pre></div> Return a tensor of given shape and type filled with uninitialized data. Arguments <ul> <li>shape: Shape of the empty tensor.</li> <li>dtype: Desired data type of the empty tensor.</li> </ul> Returns The empty tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2630">[source]</a> <h3 id="equal-function"><code>equal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.equal(x1, x2) </code></pre></div> Returns <code>(x1 == x2)</code> element-wise. Arguments <ul> <li>x1: Tensor to compare.</li> <li>x2: Tensor to compare.</li> </ul> Returns Output tensor, element-wise comparison of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2657">[source]</a> <h3 id="exp-function"><code>exp</code> function</h3> <div class="codehilite"><pre><code>keras.ops.exp(x) </code></pre></div> Calculate the exponential of all elements in the input tensor. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise exponential of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2693">[source]</a> <h3 id="expanddims-function"><code>expand_dims</code> function</h3> <div class="codehilite"><pre><code>keras.ops.expand_dims(x, axis) </code></pre></div> Expand the shape of a tensor. Insert a new axis at the <code>axis</code> position in the expanded tensor shape. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Position in the expanded axes where the new axis (or axes) is placed.</li> </ul> Returns Output tensor with the number of dimensions increased. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2729">[source]</a> <h3 id="expm1-function"><code>expm1</code> function</h3> <div class="codehilite"><pre><code>keras.ops.expm1(x) </code></pre></div> Calculate <code>exp(x) - 1</code> for all elements in the tensor. Arguments <ul> <li>x: Input values.</li> </ul> Returns Output tensor, element-wise exponential minus one. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6332">[source]</a> <h3 id="eye-function"><code>eye</code> function</h3> <div class="codehilite"><pre><code>keras.ops.eye(N, M=None, k=0, dtype=None) </code></pre></div> Return a 2-D tensor with ones on the diagonal and zeros elsewhere. Arguments <ul> <li>N: Number of rows in the output.</li> <li>M: Number of columns in the output. If <code>None</code>, defaults to <code>N</code>.</li> <li>k: Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal.</li> <li>dtype: Data type of the returned tensor.</li> </ul> Returns Tensor with ones on the k-th diagonal and zeros elsewhere. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2756">[source]</a> <h3 id="flip-function"><code>flip</code> function</h3> <div class="codehilite"><pre><code>keras.ops.flip(x, axis=None) </code></pre></div> Reverse the order of elements in the tensor along the given axis. The shape of the tensor is preserved, but the elements are reordered. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which to flip the tensor. The default, <code>axis=None</code>, will flip over all of the axes of the input tensor.</li> </ul> Returns Output tensor with entries of <code>axis</code> reversed. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2789">[source]</a> <h3 id="floor-function"><code>floor</code> function</h3> <div class="codehilite"><pre><code>keras.ops.floor(x) </code></pre></div> Return the floor of the input, element-wise. The floor of the scalar <code>x</code> is the largest integer <code>i</code>, such that <code>i <= x</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise floor of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6365">[source]</a> <h3 id="floordivide-function"><code>floor_divide</code> function</h3> <div class="codehilite"><pre><code>keras.ops.floor_divide(x1, x2) </code></pre></div> Returns the largest integer smaller or equal to the division of inputs. Arguments <ul> <li>x1: Numerator.</li> <li>x2: Denominator.</li> </ul> Returns Output tensor, <code>y = floor(x1/x2)</code> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2815">[source]</a> <h3 id="full-function"><code>full</code> function</h3> <div class="codehilite"><pre><code>keras.ops.full(shape, fill_value, dtype=None) </code></pre></div> Return a new tensor of given shape and type, filled with <code>fill_value</code>. Arguments <ul> <li>shape: Shape of the new tensor.</li> <li>fill_value: Fill value.</li> <li>dtype: Desired data type of the tensor.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2839">[source]</a> <h3 id="fulllike-function"><code>full_like</code> function</h3> <div class="codehilite"><pre><code>keras.ops.full_like(x, fill_value, dtype=None) </code></pre></div> Return a full tensor with the same shape and type as the given tensor. Arguments <ul> <li>x: Input tensor.</li> <li>fill_value: Fill value.</li> <li>dtype: Overrides data type of the result.</li> </ul> Returns Tensor of <code>fill_value</code> with the same shape and type as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2929">[source]</a> <h3 id="getitem-function"><code>get_item</code> function</h3> <div class="codehilite"><pre><code>keras.ops.get_item(x, key) </code></pre></div> Return <code>x[key]</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2948">[source]</a> <h3 id="greater-function"><code>greater</code> function</h3> <div class="codehilite"><pre><code>keras.ops.greater(x1, x2) </code></pre></div> Return the truth value of <code>x1 > x2</code> element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise comparison of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L2975">[source]</a> <h3 id="greaterequal-function"><code>greater_equal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.greater_equal(x1, x2) </code></pre></div> Return the truth value of <code>x1 >= x2</code> element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise comparison of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6650">[source]</a> <h3 id="histogram-function"><code>histogram</code> function</h3> <div class="codehilite"><pre><code>keras.ops.histogram(x, bins=10, range=None) </code></pre></div> Computes a histogram of the data tensor <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> <li>bins: An integer representing the number of histogram bins. Defaults to 10.</li> <li>range: A tuple representing the lower and upper range of the bins. If not specified, it will use the min and max of <code>x</code>.</li> </ul> Returns <ul> <li>A tuple containing:</li> <li>A tensor representing the counts of elements in each bin.</li> <li>A tensor representing the bin edges.</li> </ul> Example <div class="codehilite"><pre><code>```python >>> input_tensor = np.random.rand(8) >>> keras.ops.histogram(input_tensor) (array([1, 1, 1, 0, 0, 1, 2, 1, 0, 1], dtype=int32), array([0.0189519 , 0.10294958, 0.18694726, 0.27094494, 0.35494262, 0.43894029, 0.52293797, 0.60693565, 0.69093333, 0.77493101, 0.85892869])) </code></pre></div> <div class="codehilite"><pre><code>---- [[source]](https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3023) ### `hstack` function ```python keras.ops.hstack(xs) </code></pre></div> Stack tensors in sequence horizontally (column wise). This is equivalent to concatenation along the first axis for 1-D tensors, and along the second axis for all other tensors. Arguments <ul> <li>xs: Sequence of tensors.</li> </ul> Returns The tensor formed by stacking the given tensors. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3050">[source]</a> <h3 id="identity-function"><code>identity</code> function</h3> <div class="codehilite"><pre><code>keras.ops.identity(n, dtype=None) </code></pre></div> Return the identity tensor. The identity tensor is a square tensor with ones on the main diagonal and zeros elsewhere. Arguments <ul> <li>n: Number of rows (and columns) in the <code>n x n</code> output tensor.</li> <li>dtype: Data type of the output tensor.</li> </ul> Returns The identity tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3076">[source]</a> <h3 id="imag-function"><code>imag</code> function</h3> <div class="codehilite"><pre><code>keras.ops.imag(x) </code></pre></div> Return the imaginary part of the complex argument. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The imaginary component of the complex argument. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3104">[source]</a> <h3 id="isclose-function"><code>isclose</code> function</h3> <div class="codehilite"><pre><code>keras.ops.isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False) </code></pre></div> Return whether two tensors are element-wise almost equal. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> <li>rtol: Relative tolerance.</li> <li>atol: Absolute tolerance.</li> <li>equal_nan: If <code>True</code>, element-wise NaNs are considered equal.</li> </ul> Returns Output boolean tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3131">[source]</a> <h3 id="isfinite-function"><code>isfinite</code> function</h3> <div class="codehilite"><pre><code>keras.ops.isfinite(x) </code></pre></div> Return whether a tensor is finite, element-wise. Real values are finite when they are not NaN, not positive infinity, and not negative infinity. Complex values are finite when both their real and imaginary parts are finite. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output boolean tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3158">[source]</a> <h3 id="isinf-function"><code>isinf</code> function</h3> <div class="codehilite"><pre><code>keras.ops.isinf(x) </code></pre></div> Test element-wise for positive or negative infinity. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output boolean tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3181">[source]</a> <h3 id="isnan-function"><code>isnan</code> function</h3> <div class="codehilite"><pre><code>keras.ops.isnan(x) </code></pre></div> Test element-wise for NaN and return result as a boolean tensor. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output boolean tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1389">[source]</a> <h3 id="leftshift-function"><code>left_shift</code> function</h3> <div class="codehilite"><pre><code>keras.ops.left_shift(x, y) </code></pre></div> Shift the bits of an integer to the left. Bits are shifted to the left by appending <code>y</code> 0s at the right of <code>x</code>. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying <code>x</code> by <code>2**y</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3207">[source]</a> <h3 id="less-function"><code>less</code> function</h3> <div class="codehilite"><pre><code>keras.ops.less(x1, x2) </code></pre></div> Return the truth value of <code>x1 < x2</code> element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise comparison of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3234">[source]</a> <h3 id="lessequal-function"><code>less_equal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.less_equal(x1, x2) </code></pre></div> Return the truth value of <code>x1 <= x2</code> element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise comparison of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3307">[source]</a> <h3 id="linspace-function"><code>linspace</code> function</h3> <div class="codehilite"><pre><code>keras.ops.linspace( start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0 ) </code></pre></div> Return evenly spaced numbers over a specified interval. Returns <code>num</code> evenly spaced samples, calculated over the interval <code>[start, stop]</code>. The endpoint of the interval can optionally be excluded. Arguments <ul> <li>start: The starting value of the sequence.</li> <li>stop: The end value of the sequence, unless <code>endpoint</code> is set to <code>False</code>. In that case, the sequence consists of all but the last of <code>num + 1</code> evenly spaced samples, so that <code>stop</code> is excluded. Note that the step size changes when <code>endpoint</code> is <code>False</code>.</li> <li>num: Number of samples to generate. Defaults to <code>50</code>. Must be non-negative.</li> <li>endpoint: If <code>True</code>, <code>stop</code> is the last sample. Otherwise, it is not included. Defaults to <code>True</code>.</li> <li>retstep: If <code>True</code>, return <code>(samples, step)</code>, where <code>step</code> is the spacing between samples.</li> <li>dtype: The type of the output tensor.</li> <li>axis: The axis in the result to store the samples. Relevant only if start or stop are array-like. Defaults to <code>0</code>.</li> </ul> Note: Torch backend does not support <code>axis</code> argument. Returns A tensor of evenly spaced numbers. If <code>retstep</code> is <code>True</code>, returns <code>(samples, step)</code> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3367">[source]</a> <h3 id="log-function"><code>log</code> function</h3> <div class="codehilite"><pre><code>keras.ops.log(x) </code></pre></div> Natural logarithm, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise natural logarithm of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3395">[source]</a> <h3 id="log10-function"><code>log10</code> function</h3> <div class="codehilite"><pre><code>keras.ops.log10(x) </code></pre></div> Return the base 10 logarithm of the input tensor, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise base 10 logarithm of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3424">[source]</a> <h3 id="log1p-function"><code>log1p</code> function</h3> <div class="codehilite"><pre><code>keras.ops.log1p(x) </code></pre></div> Returns the natural logarithm of one plus the <code>x</code>, element-wise. Calculates <code>log(1 + x)</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise natural logarithm of <code>1 + x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3454">[source]</a> <h3 id="log2-function"><code>log2</code> function</h3> <div class="codehilite"><pre><code>keras.ops.log2(x) </code></pre></div> Base-2 logarithm of <code>x</code>, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise base-2 logarithm of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3485">[source]</a> <h3 id="logaddexp-function"><code>logaddexp</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logaddexp(x1, x2) </code></pre></div> Logarithm of the sum of exponentiations of the inputs. Calculates <code>log(exp(x1) + exp(x2))</code>. Arguments <ul> <li>x1: Input tensor.</li> <li>x2: Input tensor.</li> </ul> Returns Output tensor, element-wise logarithm of the sum of exponentiations of the inputs. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3515">[source]</a> <h3 id="logicaland-function"><code>logical_and</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logical_and(x1, x2) </code></pre></div> Computes the element-wise logical AND of the given input tensors. Zeros are treated as <code>False</code> and non-zeros are treated as <code>True</code>. Arguments <ul> <li>x1: Input tensor.</li> <li>x2: Input tensor.</li> </ul> Returns Output tensor, element-wise logical AND of the inputs. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3546">[source]</a> <h3 id="logicalnot-function"><code>logical_not</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logical_not(x) </code></pre></div> Computes the element-wise NOT of the given input tensor. Zeros are treated as <code>False</code> and non-zeros are treated as <code>True</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise logical NOT of the input. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3579">[source]</a> <h3 id="logicalor-function"><code>logical_or</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logical_or(x1, x2) </code></pre></div> Computes the element-wise logical OR of the given input tensors. Zeros are treated as <code>False</code> and non-zeros are treated as <code>True</code>. Arguments <ul> <li>x1: Input tensor.</li> <li>x2: Input tensor.</li> </ul> Returns Output tensor, element-wise logical OR of the inputs. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6392">[source]</a> <h3 id="logicalxor-function"><code>logical_xor</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logical_xor(x1, x2) </code></pre></div> Compute the truth value of <code>x1 XOR x2</code>, element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output boolean tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3649">[source]</a> <h3 id="logspace-function"><code>logspace</code> function</h3> <div class="codehilite"><pre><code>keras.ops.logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0) </code></pre></div> Returns numbers spaced evenly on a log scale. In linear space, the sequence starts at <code>base ** start</code> and ends with <code>base ** stop</code> (see <code>endpoint</code> below). Arguments <ul> <li>start: The starting value of the sequence.</li> <li>stop: The final value of the sequence, unless <code>endpoint</code> is <code>False</code>. In that case, <code>num + 1</code> values are spaced over the interval in log-space, of which all but the last (a sequence of length <code>num</code>) are returned.</li> <li>num: Number of samples to generate. Defaults to <code>50</code>.</li> <li>endpoint: If <code>True</code>, <code>stop</code> is the last sample. Otherwise, it is not included. Defaults to <code>True</code>.</li> <li>base: The base of the log space. Defaults to <code>10</code>.</li> <li>dtype: The type of the output tensor.</li> <li>axis: The axis in the result to store the samples. Relevant only if start or stop are array-like.</li> </ul> Note: Torch backend does not support <code>axis</code> argument. Returns A tensor of evenly spaced samples on a log scale. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3711">[source]</a> <h3 id="matmul-function"><code>matmul</code> function</h3> <div class="codehilite"><pre><code>keras.ops.matmul(x1, x2) </code></pre></div> Matrix product of two tensors. <ul> <li>If both tensors are 1-dimensional, the dot product (scalar) is returned.</li> <li>If either tensor is N-D, N > 2, it is treated as a stack of matrices residing in the last two indexes and broadcast accordingly.</li> <li>If the first tensor is 1-D, it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication the prepended 1 is removed.</li> <li>If the second tensor is 1-D, it is promoted to a matrix by appending a 1 to its dimensions. After matrix multiplication the appended 1 is removed.</li> </ul> Arguments <ul> <li>x1: First tensor.</li> <li>x2: Second tensor.</li> </ul> Returns Output tensor, matrix product of the inputs. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3758">[source]</a> <h3 id="max-function"><code>max</code> function</h3> <div class="codehilite"><pre><code>keras.ops.max(x, axis=None, keepdims=False, initial=None) </code></pre></div> Return the maximum of a tensor or maximum along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which to operate. By default, flattened input is used.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one. Defaults to <code>False</code>.</li> <li>initial: The minimum value of an output element. Defaults to <code>None</code>.</li> </ul> Returns Maximum of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3800">[source]</a> <h3 id="maximum-function"><code>maximum</code> function</h3> <div class="codehilite"><pre><code>keras.ops.maximum(x1, x2) </code></pre></div> Element-wise maximum of <code>x1</code> and <code>x2</code>. Arguments <ul> <li>x1: First tensor.</li> <li>x2: Second tensor.</li> </ul> Returns Output tensor, element-wise maximum of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6166">[source]</a> <h3 id="mean-function"><code>mean</code> function</h3> <div class="codehilite"><pre><code>keras.ops.mean(x, axis=None, keepdims=False) </code></pre></div> Compute the arithmetic mean along the specified axes. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which the means are computed. The default is to compute the mean of the flattened tensor.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one.</li> </ul> Returns Output tensor containing the mean values. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3838">[source]</a> <h3 id="median-function"><code>median</code> function</h3> <div class="codehilite"><pre><code>keras.ops.median(x, axis=None, keepdims=False) </code></pre></div> Compute the median along the specified axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which the medians are computed. Defaults to <code>axis=None</code> which is to compute the median(s) along a flattened version of the array.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduce are left in the result as dimensions with size one.</li> </ul> Returns The output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3892">[source]</a> <h3 id="meshgrid-function"><code>meshgrid</code> function</h3> <div class="codehilite"><pre><code>keras.ops.meshgrid(*x, indexing="xy") </code></pre></div> Creates grids of coordinates from coordinate vectors. Given <code>N</code> 1-D tensors <code>T0, T1, ..., TN-1</code> as inputs with corresponding lengths <code>S0, S1, ..., SN-1</code>, this creates an <code>N</code> N-dimensional tensors <code>G0, G1, ..., GN-1</code> each with shape <code>(S0, ..., SN-1)</code> where the output <code>Gi</code> is constructed by expanding <code>Ti</code> to the result shape. Arguments <ul> <li>x: 1-D tensors representing the coordinates of a grid.</li> <li>indexing: <code>"xy"</code> or <code>"ij"</code>. "xy" is cartesian; <code>"ij"</code> is matrix indexing of output. Defaults to <code>"xy"</code>.</li> </ul> Returns Sequence of N tensors. Example <div class="codehilite"><pre><code>>>> from keras.src import ops >>> x = ops.array([1, 2, 3]) >>> y = ops.array([4, 5, 6]) </code></pre></div> <div class="codehilite"><pre><code>>>> grid_x, grid_y = ops.meshgrid(x, y, indexing="ij") >>> grid_x array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> grid_y array([[4, 5, 6], [4, 5, 6], [4, 5, 6]]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3951">[source]</a> <h3 id="min-function"><code>min</code> function</h3> <div class="codehilite"><pre><code>keras.ops.min(x, axis=None, keepdims=False, initial=None) </code></pre></div> Return the minimum of a tensor or minimum along an axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which to operate. By default, flattened input is used.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one. Defaults to <code>False</code>.</li> <li>initial: The maximum value of an output element. Defaults to <code>None</code>.</li> </ul> Returns Minimum of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L3993">[source]</a> <h3 id="minimum-function"><code>minimum</code> function</h3> <div class="codehilite"><pre><code>keras.ops.minimum(x1, x2) </code></pre></div> Element-wise minimum of <code>x1</code> and <code>x2</code>. Arguments <ul> <li>x1: First tensor.</li> <li>x2: Second tensor.</li> </ul> Returns Output tensor, element-wise minimum of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4026">[source]</a> <h3 id="mod-function"><code>mod</code> function</h3> <div class="codehilite"><pre><code>keras.ops.mod(x1, x2) </code></pre></div> Returns the element-wise remainder of division. Arguments <ul> <li>x1: First tensor.</li> <li>x2: Second tensor.</li> </ul> Returns Output tensor, element-wise remainder of division. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4086">[source]</a> <h3 id="moveaxis-function"><code>moveaxis</code> function</h3> <div class="codehilite"><pre><code>keras.ops.moveaxis(x, source, destination) </code></pre></div> Move axes of a tensor to new positions. Other axes remain in their original order. Arguments <ul> <li>x: Tensor whose axes should be reordered.</li> <li>source: Original positions of the axes to move. These must be unique.</li> <li>destination: Destinations positions for each of the original axes. These must also be unique.</li> </ul> Returns Tensor with moved axes. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5824">[source]</a> <h3 id="multiply-function"><code>multiply</code> function</h3> <div class="codehilite"><pre><code>keras.ops.multiply(x1, x2) </code></pre></div> Multiply arguments element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise product of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4122">[source]</a> <h3 id="nantonum-function"><code>nan_to_num</code> function</h3> <div class="codehilite"><pre><code>keras.ops.nan_to_num(x, nan=0.0, posinf=None, neginf=None) </code></pre></div> Replace NaN with zero and infinity with large finite numbers. Arguments <ul> <li>x: Input data.</li> <li>nan: Optional float or int. Value to replace <code>NaN</code> entries with.</li> <li>posinf: Optional float or int. Value to replace positive infinity with.</li> <li>neginf: Optional float or int. Value to replace negative infinity with.</li> </ul> Returns <code>x</code>, with non-finite values replaced. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4157">[source]</a> <h3 id="ndim-function"><code>ndim</code> function</h3> <div class="codehilite"><pre><code>keras.ops.ndim(x) </code></pre></div> Return the number of dimensions of a tensor. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The number of dimensions in <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5989">[source]</a> <h3 id="negative-function"><code>negative</code> function</h3> <div class="codehilite"><pre><code>keras.ops.negative(x) </code></pre></div> Numerical negative, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, <code>y = -x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4182">[source]</a> <h3 id="nonzero-function"><code>nonzero</code> function</h3> <div class="codehilite"><pre><code>keras.ops.nonzero(x) </code></pre></div> Return the indices of the elements that are non-zero. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Indices of elements that are non-zero. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/linalg.py#L312">[source]</a> <h3 id="norm-function"><code>norm</code> function</h3> <div class="codehilite"><pre><code>keras.ops.norm(x, ord=None, axis=None, keepdims=False) </code></pre></div> Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the <code>ord</code> parameter. Arguments <ul> <li>x: Input tensor.</li> <li>ord: Order of the norm (see table under Notes). The default is <code>None</code>.</li> <li>axis: If <code>axis</code> is an integer, it specifies the axis of <code>x</code> along which to compute the vector norms. If <code>axis</code> is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one.</li> </ul> Note: For values of <code>ord < 1</code>, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: - For matrices: - <code>ord=None</code>: Frobenius norm - <code>ord="fro"</code>: Frobenius norm - <code>ord="nuc"</code>: nuclear norm - <code>ord=np.inf</code>: <code>max(sum(abs(x), axis=1))</code> - <code>ord=-np.inf</code>: <code>min(sum(abs(x), axis=1))</code> - <code>ord=0</code>: not supported - <code>ord=1</code>: <code>max(sum(abs(x), axis=0))</code> - <code>ord=-1</code>: <code>min(sum(abs(x), axis=0))</code> - <code>ord=2</code>: 2-norm (largest sing. value) - <code>ord=-2</code>: smallest singular value - other: not supported - For vectors: - <code>ord=None</code>: 2-norm - <code>ord="fro"</code>: not supported - <code>ord="nuc"</code>: not supported - <code>ord=np.inf</code>: <code>max(abs(x))</code> - <code>ord=-np.inf</code>: <code>min(abs(x))</code> - <code>ord=0</code>: <code>sum(x != 0)</code> - <code>ord=1</code>: as below - <code>ord=-1</code>: as below - <code>ord=2</code>: as below - <code>ord=-2</code>: as below - other: <code>sum(abs(x)**ord)**(1./ord)</code> Returns Norm of the matrix or vector(s). Example <div class="codehilite"><pre><code>>>> x = keras.ops.reshape(keras.ops.arange(9, dtype="float32") - 4, (3, 3)) >>> keras.ops.linalg.norm(x) 7.7459664 </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4208">[source]</a> <h3 id="notequal-function"><code>not_equal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.not_equal(x1, x2) </code></pre></div> Return <code>(x1 != x2)</code> element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise comparsion of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6303">[source]</a> <h3 id="ones-function"><code>ones</code> function</h3> <div class="codehilite"><pre><code>keras.ops.ones(shape, dtype=None) </code></pre></div> Return a new tensor of given shape and type, filled with ones. Arguments <ul> <li>shape: Shape of the new tensor.</li> <li>dtype: Desired data type of the tensor.</li> </ul> Returns Tensor of ones with the given shape and dtype. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4234">[source]</a> <h3 id="oneslike-function"><code>ones_like</code> function</h3> <div class="codehilite"><pre><code>keras.ops.ones_like(x, dtype=None) </code></pre></div> Return a tensor of ones with the same shape and type of <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> <li>dtype: Overrides the data type of the result.</li> </ul> Returns A tensor of ones with the same shape and type as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4304">[source]</a> <h3 id="outer-function"><code>outer</code> function</h3> <div class="codehilite"><pre><code>keras.ops.outer(x1, x2) </code></pre></div> Compute the outer product of two vectors. Given two vectors <code>x1</code> and <code>x2</code>, the outer product is: <div class="codehilite"><pre><code>out[i, j] = x1[i] * x2[j] </code></pre></div> Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Outer product of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4380">[source]</a> <h3 id="pad-function"><code>pad</code> function</h3> <div class="codehilite"><pre><code>keras.ops.pad(x, pad_width, mode="constant", constant_values=None) </code></pre></div> Pad a tensor. Arguments <ul> <li>x: Tensor to pad.</li> <li>pad_width: Number of values padded to the edges of each axis. <code>((before_1, after_1), ...(before_N, after_N))</code> unique pad widths for each axis. <code>((before, after),)</code> yields same before and after pad for each axis. <code>(pad,)</code> or <code>int</code> is a shortcut for <code>before = after = pad</code> width for all axes.</li> <li>mode: One of <code>"constant"</code>, <code>"edge"</code>, <code>"linear_ramp"</code>, <code>"maximum"</code>, <code>"mean"</code>, <code>"median"</code>, <code>"minimum"</code>, <code>"reflect"</code>, <code>"symmetric"</code>, <code>"wrap"</code>, <code>"empty"</code>, <code>"circular"</code>. Defaults to <code>"constant"</code>.</li> <li>constant_values: value to pad with if <code>mode == "constant"</code>. Defaults to <code>0</code>. A <code>ValueError</code> is raised if not None and <code>mode != "constant"</code>.</li> </ul> Note: Torch backend only supports modes <code>"constant"</code>, <code>"reflect"</code>, <code>"symmetric"</code> and <code>"circular"</code>. Only Torch backend supports <code>"circular"</code> mode. Note: Tensorflow backend only supports modes <code>"constant"</code>, <code>"reflect"</code> and <code>"symmetric"</code>. Returns Padded tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5964">[source]</a> <h3 id="power-function"><code>power</code> function</h3> <div class="codehilite"><pre><code>keras.ops.power(x1, x2) </code></pre></div> First tensor elements raised to powers from second tensor, element-wise. Arguments <ul> <li>x1: The bases.</li> <li>x2: The exponents.</li> </ul> Returns Output tensor, the bases in <code>x1</code> raised to the exponents in <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4454">[source]</a> <h3 id="prod-function"><code>prod</code> function</h3> <div class="codehilite"><pre><code>keras.ops.prod(x, axis=None, keepdims=False, dtype=None) </code></pre></div> Return the product of tensor elements over a given axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which a product is performed. The default, <code>axis=None</code>, will compute the product of all elements in the input tensor.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduce are left in the result as dimensions with size one.</li> <li>dtype: Data type of the returned tensor.</li> </ul> Returns Product of elements of <code>x</code> over the given axis or axes. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4503">[source]</a> <h3 id="quantile-function"><code>quantile</code> function</h3> <div class="codehilite"><pre><code>keras.ops.quantile(x, q, axis=None, method="linear", keepdims=False) </code></pre></div> Compute the q-th quantile(s) of the data along the specified axis. Arguments <ul> <li>x: Input tensor.</li> <li>q: Probability or sequence of probabilities for the quantiles to compute. Values must be between 0 and 1 inclusive.</li> <li>axis: Axis or axes along which the quantiles are computed. Defaults to <code>axis=None</code> which is to compute the quantile(s) along a flattened version of the array.</li> <li>method: A string specifies the method to use for estimating the quantile. Available methods are <code>"linear"</code>, <code>"lower"</code>, <code>"higher"</code>, <code>"midpoint"</code>, and <code>"nearest"</code>. Defaults to <code>"linear"</code>. If the desired quantile lies between two data points <code>i < j</code>:<ul> <li><code>"linear"</code>: <code>i + (j - i) * fraction</code>, where fraction is the fractional part of the index surrounded by <code>i</code> and <code>j</code>.</li> <li><code>"lower"</code>: <code>i</code>.</li> <li><code>"higher"</code>: <code>j</code>.</li> <li><code>"midpoint"</code>: <code>(i + j) / 2</code></li> <li><code>"nearest"</code>: <code>i</code> or <code>j</code>, whichever is nearest.</li> </ul> </li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduce are left in the result as dimensions with size one.</li> </ul> Returns The quantile(s). If <code>q</code> is a single probability and <code>axis=None</code>, then the result is a scalar. If multiple probabilies levels are given, first axis of the result corresponds to the quantiles. The other axes are the axes that remain after the reduction of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4556">[source]</a> <h3 id="ravel-function"><code>ravel</code> function</h3> <div class="codehilite"><pre><code>keras.ops.ravel(x) </code></pre></div> Return a contiguous flattened tensor. A 1-D tensor, containing the elements of the input, is returned. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4582">[source]</a> <h3 id="real-function"><code>real</code> function</h3> <div class="codehilite"><pre><code>keras.ops.real(x) </code></pre></div> Return the real part of the complex argument. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The real component of the complex argument. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4605">[source]</a> <h3 id="reciprocal-function"><code>reciprocal</code> function</h3> <div class="codehilite"><pre><code>keras.ops.reciprocal(x) </code></pre></div> Return the reciprocal of the argument, element-wise. Calculates <code>1/x</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, element-wise reciprocal of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4679">[source]</a> <h3 id="repeat-function"><code>repeat</code> function</h3> <div class="codehilite"><pre><code>keras.ops.repeat(x, repeats, axis=None) </code></pre></div> Repeat each element of a tensor after themselves. Arguments <ul> <li>x: Input tensor.</li> <li>repeats: The number of repetitions for each element.</li> <li>axis: The axis along which to repeat values. By default, use the flattened input array, and return a flat output array.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4713">[source]</a> <h3 id="reshape-function"><code>reshape</code> function</h3> <div class="codehilite"><pre><code>keras.ops.reshape(x, newshape) </code></pre></div> Gives a new shape to a tensor without changing its data. Arguments <ul> <li>x: Input tensor.</li> <li>newshape: The new shape should be compatible with the original shape. One shape dimension can be -1 in which case the value is inferred from the length of the array and remaining dimensions.</li> </ul> Returns The reshaped tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L1455">[source]</a> <h3 id="rightshift-function"><code>right_shift</code> function</h3> <div class="codehilite"><pre><code>keras.ops.right_shift(x, y) </code></pre></div> Shift the bits of an integer to the right. Bits are shifted to the right <code>y</code>. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing <code>x</code> by <code>2**y</code>. Arguments <ul> <li>x: Input integer tensor.</li> <li>y: Input integer tensor.</li> </ul> Returns Result tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4744">[source]</a> <h3 id="roll-function"><code>roll</code> function</h3> <div class="codehilite"><pre><code>keras.ops.roll(x, shift, axis=None) </code></pre></div> Roll tensor elements along a given axis. Elements that roll beyond the last position are re-introduced at the first. Arguments <ul> <li>x: Input tensor.</li> <li>shift: The number of places by which elements are shifted.</li> <li>axis: The axis along which elements are shifted. By default, the array is flattened before shifting, after which the original shape is restored.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4778">[source]</a> <h3 id="round-function"><code>round</code> function</h3> <div class="codehilite"><pre><code>keras.ops.round(x, decimals=0) </code></pre></div> Evenly round to the given number of decimals. Arguments <ul> <li>x: Input tensor.</li> <li>decimals: Number of decimal places to round to. Defaults to <code>0</code>.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4814">[source]</a> <h3 id="searchsorted-function"><code>searchsorted</code> function</h3> <div class="codehilite"><pre><code>keras.ops.searchsorted(sorted_sequence, values, side="left") </code></pre></div> Perform a binary search, returning indices for insertion of <code>values</code> into <code>sorted_sequence</code> that maintain the sorting order. Arguments <ul> <li>sorted_sequence: 1-D input tensor, sorted along the innermost dimension.</li> <li>values: N-D tensor of query insertion values.</li> <li>side: 'left' or 'right', specifying the direction in which to insert for the equality case (tie-breaker).</li> </ul> Returns Tensor of insertion indices of same shape as <code>values</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6487">[source]</a> <h3 id="select-function"><code>select</code> function</h3> <div class="codehilite"><pre><code>keras.ops.select(condlist, choicelist, default=0) </code></pre></div> Return elements from <code>choicelist</code>, based on conditions in <code>condlist</code>. Arguments <ul> <li>condlist: List of boolean tensors. The list of conditions which determine from which array in choicelist the output elements are taken. When multiple conditions are satisfied, the first one encountered in condlist is used.</li> <li>choicelist: List of tensors. The list of tensors from which the output elements are taken. This list has to be of the same length as <code>condlist</code>.</li> <li>defaults: Optional scalar value. The element inserted in the output when all conditions evaluate to <code>False</code>.</li> </ul> Returns Tensor where the output at position <code>m</code> is the <code>m</code>-th element of the tensor in <code>choicelist</code> where the <code>m</code>-th element of the corresponding tensor in <code>condlist</code> is <code>True</code>. Example <div class="codehilite"><pre><code>from keras import ops x = ops.arange(6) condlist = [x<3, x>3] choicelist = [x, x**2] ops.select(condlist, choicelist, 42) # # Returns tensor([0, 1, 2, 42, 16, 25]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4846">[source]</a> <h3 id="sign-function"><code>sign</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sign(x) </code></pre></div> Returns a tensor with the signs of the elements of <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4875">[source]</a> <h3 id="sin-function"><code>sin</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sin(x) </code></pre></div> Trigonometric sine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4904">[source]</a> <h3 id="sinh-function"><code>sinh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sinh(x) </code></pre></div> Hyperbolic sine, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4927">[source]</a> <h3 id="size-function"><code>size</code> function</h3> <div class="codehilite"><pre><code>keras.ops.size(x) </code></pre></div> Return the number of elements in a tensor. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Number of elements in <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6555">[source]</a> <h3 id="slogdet-function"><code>slogdet</code> function</h3> <div class="codehilite"><pre><code>keras.ops.slogdet(x) </code></pre></div> Compute the sign and natural logarithm of the determinant of a matrix. Arguments <ul> <li>x: Input matrix. It must 2D and square.</li> </ul> Returns A tuple <code>(sign, logabsdet)</code>. <code>sign</code> is a number representing the sign of the determinant. For a real matrix, this is 1, 0, or -1. For a complex matrix, this is a complex number with absolute value 1 (i.e., it is on the unit circle), or else 0. <code>logabsdet</code> is the natural log of the absolute value of the determinant. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4954">[source]</a> <h3 id="sort-function"><code>sort</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sort(x, axis=-1) </code></pre></div> Sorts the elements of <code>x</code> along a given axis in ascending order. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which to sort. If <code>None</code>, the tensor is flattened before sorting. Defaults to <code>-1</code>; the last axis.</li> </ul> Returns Sorted tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5016">[source]</a> <h3 id="split-function"><code>split</code> function</h3> <div class="codehilite"><pre><code>keras.ops.split(x, indices_or_sections, axis=0) </code></pre></div> Split a tensor into chunks. Arguments <ul> <li>x: Input tensor.</li> <li>indices_or_sections: If an integer, N, the tensor will be split into N equal sections along <code>axis</code>. If a 1-D array of sorted integers, the entries indicate indices at which the tensor will be split along <code>axis</code>.</li> <li>axis: Axis along which to split. Defaults to <code>0</code>.</li> </ul> Note: A split does not have to result in equal division when using Torch backend. Returns A list of tensors. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6046">[source]</a> <h3 id="sqrt-function"><code>sqrt</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sqrt(x) </code></pre></div> Return the non-negative square root of a tensor, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, the non-negative square root of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6016">[source]</a> <h3 id="square-function"><code>square</code> function</h3> <div class="codehilite"><pre><code>keras.ops.square(x) </code></pre></div> Return the element-wise square of the input. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor, the square of <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6090">[source]</a> <h3 id="squeeze-function"><code>squeeze</code> function</h3> <div class="codehilite"><pre><code>keras.ops.squeeze(x, axis=None) </code></pre></div> Remove axes of length one from <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Select a subset of the entries of length one in the shape.</li> </ul> Returns The input tensor with all or a subset of the dimensions of length 1 removed. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5072">[source]</a> <h3 id="stack-function"><code>stack</code> function</h3> <div class="codehilite"><pre><code>keras.ops.stack(x, axis=0) </code></pre></div> Join a sequence of tensors along a new axis. The <code>axis</code> parameter specifies the index of the new axis in the dimensions of the result. Arguments <ul> <li>x: A sequence of tensors.</li> <li>axis: Axis along which to stack. Defaults to <code>0</code>.</li> </ul> Returns The stacked tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5113">[source]</a> <h3 id="std-function"><code>std</code> function</h3> <div class="codehilite"><pre><code>keras.ops.std(x, axis=None, keepdims=False) </code></pre></div> Compute the standard deviation along the specified axis. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis along which to compute standard deviation. Default is to compute the standard deviation of the flattened tensor.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one.</li> </ul> Returns Output tensor containing the standard deviation values. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5790">[source]</a> <h3 id="subtract-function"><code>subtract</code> function</h3> <div class="codehilite"><pre><code>keras.ops.subtract(x1, x2) </code></pre></div> Subtract arguments element-wise. Arguments <ul> <li>x1: First input tensor.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor, element-wise difference of <code>x1</code> and <code>x2</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6252">[source]</a> <h3 id="sum-function"><code>sum</code> function</h3> <div class="codehilite"><pre><code>keras.ops.sum(x, axis=None, keepdims=False) </code></pre></div> Sum of a tensor over the given axes. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which the sum is computed. The default is to compute the sum of the flattened tensor.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one.</li> </ul> Returns Output tensor containing the sum. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5151">[source]</a> <h3 id="swapaxes-function"><code>swapaxes</code> function</h3> <div class="codehilite"><pre><code>keras.ops.swapaxes(x, axis1, axis2) </code></pre></div> Interchange two axes of a tensor. Arguments <ul> <li>x: Input tensor.</li> <li>axis1: First axis.</li> <li>axis2: Second axis.</li> </ul> Returns A tensor with the axes swapped. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5191">[source]</a> <h3 id="take-function"><code>take</code> function</h3> <div class="codehilite"><pre><code>keras.ops.take(x, indices, axis=None) </code></pre></div> Take elements from a tensor along an axis. Arguments <ul> <li>x: Source tensor.</li> <li>indices: The indices of the values to extract.</li> <li>axis: The axis over which to select values. By default, the flattened input tensor is used.</li> </ul> Returns The corresponding tensor of values. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5224">[source]</a> <h3 id="takealongaxis-function"><code>take_along_axis</code> function</h3> <div class="codehilite"><pre><code>keras.ops.take_along_axis(x, indices, axis=None) </code></pre></div> Select values from <code>x</code> at the 1-D <code>indices</code> along the given axis. Arguments <ul> <li>x: Source tensor.</li> <li>indices: The indices of the values to extract.</li> <li>axis: The axis over which to select values. By default, the flattened input tensor is used.</li> </ul> Returns The corresponding tensor of values. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5261">[source]</a> <h3 id="tan-function"><code>tan</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tan(x) </code></pre></div> Compute tangent, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5290">[source]</a> <h3 id="tanh-function"><code>tanh</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tanh(x) </code></pre></div> Hyperbolic tangent, element-wise. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns Output tensor of same shape as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5350">[source]</a> <h3 id="tensordot-function"><code>tensordot</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tensordot(x1, x2, axes=2) </code></pre></div> Compute the tensor dot product along specified axes. Arguments <ul> <li>x1: First tensor.</li> <li>x2: Second tensor.</li> <li>axes: - If an integer, N, sum over the last N axes of <code>x1</code> and the first N axes of <code>x2</code> in order. The sizes of the corresponding axes must match. - Or, a list of axes to be summed over, first sequence applying to <code>x1</code>, second to <code>x2</code>. Both sequences must be of the same length.</li> </ul> Returns The tensor dot product of the inputs. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5399">[source]</a> <h3 id="tile-function"><code>tile</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tile(x, repeats) </code></pre></div> Repeat <code>x</code> the number of times given by <code>repeats</code>. If <code>repeats</code> has length <code>d</code>, the result will have dimension of <code>max(d, x.ndim)</code>. If <code>x.ndim < d</code>, <code>x</code> is promoted to be d-dimensional by prepending new axes. If <code>x.ndim > d</code>, <code>repeats</code> is promoted to <code>x.ndim</code> by prepending 1's to it. Arguments <ul> <li>x: Input tensor.</li> <li>repeats: The number of repetitions of <code>x</code> along each axis.</li> </ul> Returns The tiled output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5448">[source]</a> <h3 id="trace-function"><code>trace</code> function</h3> <div class="codehilite"><pre><code>keras.ops.trace(x, offset=0, axis1=0, axis2=1) </code></pre></div> Return the sum along diagonals of the tensor. If <code>x</code> is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements <code>x[i, i+offset]</code> for all <code>i</code>. If a has more than two dimensions, then the axes specified by <code>axis1</code> and <code>axis2</code> are used to determine the 2-D sub-arrays whose traces are returned. The shape of the resulting tensor is the same as that of <code>x</code> with <code>axis1</code> and <code>axis2</code> removed. Arguments <ul> <li>x: Input tensor.</li> <li>offset: Offset of the diagonal from the main diagonal. Can be both positive and negative. Defaults to <code>0</code>.</li> <li>axis1: Axis to be used as the first axis of the 2-D sub-arrays. Defaults to <code>0</code>.(first axis).</li> <li>axis2: Axis to be used as the second axis of the 2-D sub-arrays. Defaults to <code>1</code> (second axis).</li> </ul> Returns If <code>x</code> is 2-D, the sum of the diagonal is returned. If <code>x</code> has larger dimensions, then a tensor of sums along diagonals is returned. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6123">[source]</a> <h3 id="transpose-function"><code>transpose</code> function</h3> <div class="codehilite"><pre><code>keras.ops.transpose(x, axes=None) </code></pre></div> Returns a tensor with <code>axes</code> transposed. Arguments <ul> <li>x: Input tensor.</li> <li>axes: Sequence of integers. Permutation of the dimensions of <code>x</code>. By default, the order of the axes are reversed.</li> </ul> Returns <code>x</code> with its axes permuted. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5496">[source]</a> <h3 id="tri-function"><code>tri</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tri(N, M=None, k=0, dtype=None) </code></pre></div> Return a tensor with ones at and below a diagonal and zeros elsewhere. Arguments <ul> <li>N: Number of rows in the tensor.</li> <li>M: Number of columns in the tensor.</li> <li>k: The sub-diagonal at and below which the array is filled. <code>k = 0</code> is the main diagonal, while <code>k < 0</code> is below it, and <code>k > 0</code> is above. The default is 0.</li> <li>dtype: Data type of the returned tensor. The default is "float32".</li> </ul> Returns Tensor with its lower triangle filled with ones and zeros elsewhere. <code>T[i, j] == 1</code> for <code>j <= i + k</code>, 0 otherwise. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5527">[source]</a> <h3 id="tril-function"><code>tril</code> function</h3> <div class="codehilite"><pre><code>keras.ops.tril(x, k=0) </code></pre></div> Return lower triangle of a tensor. For tensors with <code>ndim</code> exceeding 2, <code>tril</code> will apply to the final two axes. Arguments <ul> <li>x: Input tensor.</li> <li>k: Diagonal above which to zero elements. Defaults to <code>0</code>. the main diagonal. <code>k < 0</code> is below it, and <code>k > 0</code> is above it.</li> </ul> Returns Lower triangle of <code>x</code>, of same shape and data type as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5559">[source]</a> <h3 id="triu-function"><code>triu</code> function</h3> <div class="codehilite"><pre><code>keras.ops.triu(x, k=0) </code></pre></div> Return upper triangle of a tensor. For tensors with <code>ndim</code> exceeding 2, <code>triu</code> will apply to the final two axes. Arguments <ul> <li>x: Input tensor.</li> <li>k: Diagonal below which to zero elements. Defaults to <code>0</code>. the main diagonal. <code>k < 0</code> is below it, and <code>k > 0</code> is above it.</li> </ul> Returns Upper triangle of <code>x</code>, of same shape and data type as <code>x</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5937">[source]</a> <h3 id="truedivide-function"><code>true_divide</code> function</h3> <div class="codehilite"><pre><code>keras.ops.true_divide(x1, x2) </code></pre></div> Alias for <a href="/api/ops/numpy#divide-function"><code>keras.ops.divide</code></a>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5590">[source]</a> <h3 id="trunc-function"><code>trunc</code> function</h3> <div class="codehilite"><pre><code>keras.ops.trunc(x) </code></pre></div> Return the truncated value of the input, element-wise. The truncated value of the scalar <code>x</code> is the nearest integer <code>i</code> which is closer to zero than <code>x</code> is. In short, the fractional part of the signed number <code>x</code> is discarded. Arguments <ul> <li>x: Input tensor.</li> </ul> Returns The truncated value of each element in <code>x</code>. Example <div class="codehilite"><pre><code>>>> x = ops.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) >>> ops.trunc(x) array([-1.0, -1.0, -0.0, 0.0, 1.0, 1.0, 2.0]) </code></pre></div> <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6204">[source]</a> <h3 id="var-function"><code>var</code> function</h3> <div class="codehilite"><pre><code>keras.ops.var(x, axis=None, keepdims=False) </code></pre></div> Compute the variance along the specified axes. Arguments <ul> <li>x: Input tensor.</li> <li>axis: Axis or axes along which the variance is computed. The default is to compute the variance of the flattened tensor.</li> <li>keepdims: If this is set to <code>True</code>, the axes which are reduced are left in the result as dimensions with size one.</li> </ul> Returns Output tensor containing the variance. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5626">[source]</a> <h3 id="vdot-function"><code>vdot</code> function</h3> <div class="codehilite"><pre><code>keras.ops.vdot(x1, x2) </code></pre></div> Return the dot product of two vectors. If the first argument is complex, the complex conjugate of the first argument is used for the calculation of the dot product. Multidimensional tensors are flattened before the dot product is taken. Arguments <ul> <li>x1: First input tensor. If complex, its complex conjugate is taken before calculation of the dot product.</li> <li>x2: Second input tensor.</li> </ul> Returns Output tensor. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5648">[source]</a> <h3 id="vectorize-function"><code>vectorize</code> function</h3> <div class="codehilite"><pre><code>keras.ops.vectorize(pyfunc, excluded=None, signature=None) </code></pre></div> Turn a function into a vectorized function. Example <div class="codehilite"><pre><code>def myfunc(a, b): return a + b vfunc = keras.ops.vectorize(myfunc) y = vfunc([1, 2, 3, 4], 2) # Returns Tensor([3, 4, 5, 6]) </code></pre></div> Arguments <ul> <li>pyfunc: Callable of a single tensor argument.</li> <li>excluded: Optional set of integers representing positional arguments for which the function will not be vectorized. These will be passed directly to <code>pyfunc</code> unmodified.</li> <li>signature: Optional generalized universal function signature, e.g., <code>"(m,n),(n)->(m)"</code> for vectorized matrix-vector multiplication. If provided, <code>pyfunc</code> will be called with (and expected to return) arrays with shapes given by the size of corresponding core dimensions. By default, <code>pyfunc</code> is assumed to take scalars tensors as input and output.</li> </ul> Returns A new function that applies <code>pyfunc</code> to every element of its input along axis 0 (the batch axis). <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5717">[source]</a> <h3 id="vstack-function"><code>vstack</code> function</h3> <div class="codehilite"><pre><code>keras.ops.vstack(xs) </code></pre></div> Stack tensors in sequence vertically (row wise). Arguments <ul> <li>xs: Sequence of tensors.</li> </ul> Returns Tensor formed by stacking the given tensors. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L5749">[source]</a> <h3 id="where-function"><code>where</code> function</h3> <div class="codehilite"><pre><code>keras.ops.where(condition, x1=None, x2=None) </code></pre></div> Return elements chosen from <code>x1</code> or <code>x2</code> depending on <code>condition</code>. Arguments <ul> <li>condition: Where <code>True</code>, yield <code>x1</code>, otherwise yield <code>x2</code>.</li> <li>x1: Values from which to choose when <code>condition</code> is <code>True</code>.</li> <li>x2: Values from which to choose when <code>condition</code> is <code>False</code>.</li> </ul> Returns A tensor with elements from <code>x1</code> where <code>condition</code> is <code>True</code>, and elements from <code>x2</code> where <code>condition</code> is <code>False</code>. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L6280">[source]</a> <h3 id="zeros-function"><code>zeros</code> function</h3> <div class="codehilite"><pre><code>keras.ops.zeros(shape, dtype=None) </code></pre></div> Return a new tensor of given shape and type, filled with zeros. Arguments <ul> <li>shape: Shape of the new tensor.</li> <li>dtype: Desired data type of the tensor.</li> </ul> Returns Tensor of zeros with the given shape and dtype. <hr /> <a href="https://github.com/keras-team/keras/tree/v3.6.0/keras/src/ops/numpy.py#L4260">[source]</a> <h3 id="zeroslike-function"><code>zeros_like</code> function</h3> <div class="codehilite"><pre><code>keras.ops.zeros_like(x, dtype=None) </code></pre></div> Return a tensor of zeros with the same shape and type as <code>x</code>. Arguments <ul> <li>x: Input tensor.</li> <li>dtype: Overrides the data type of the result.</li> </ul> Returns A tensor of zeros with the same shape and type as <code>x</code>. <hr /> </div> <div class='k-outline'> <div class='k-outline-depth-1'> <a href='#numpy-ops'>NumPy ops</a> </div> <div class='k-outline-depth-3'> <a href='#absolute-function'><code>absolute</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#add-function'><code>add</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#all-function'><code>all</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#amax-function'><code>amax</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#amin-function'><code>amin</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#any-function'><code>any</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#append-function'><code>append</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arange-function'><code>arange</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arccos-function'><code>arccos</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arccosh-function'><code>arccosh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arcsin-function'><code>arcsin</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arcsinh-function'><code>arcsinh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arctan-function'><code>arctan</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arctan2-function'><code>arctan2</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#arctanh-function'><code>arctanh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#argmax-function'><code>argmax</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#argmin-function'><code>argmin</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#argpartition-function'><code>argpartition</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#argsort-function'><code>argsort</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#array-function'><code>array</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#average-function'><code>average</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bincount-function'><code>bincount</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwiseand-function'><code>bitwise_and</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwiseinvert-function'><code>bitwise_invert</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwiseleftshift-function'><code>bitwise_left_shift</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwisenot-function'><code>bitwise_not</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwiseor-function'><code>bitwise_or</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwiserightshift-function'><code>bitwise_right_shift</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#bitwisexor-function'><code>bitwise_xor</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#broadcastto-function'><code>broadcast_to</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#ceil-function'><code>ceil</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#clip-function'><code>clip</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#concatenate-function'><code>concatenate</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#conj-function'><code>conj</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#conjugate-function'><code>conjugate</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#copy-function'><code>copy</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#correlate-function'><code>correlate</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#cos-function'><code>cos</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#cosh-function'><code>cosh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#countnonzero-function'><code>count_nonzero</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#cross-function'><code>cross</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#cumprod-function'><code>cumprod</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#cumsum-function'><code>cumsum</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#diag-function'><code>diag</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#diagonal-function'><code>diagonal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#diff-function'><code>diff</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#digitize-function'><code>digitize</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#divide-function'><code>divide</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#dividenonan-function'><code>divide_no_nan</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#dot-function'><code>dot</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#einsum-function'><code>einsum</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#empty-function'><code>empty</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#equal-function'><code>equal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#exp-function'><code>exp</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#expanddims-function'><code>expand_dims</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#expm1-function'><code>expm1</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#eye-function'><code>eye</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#flip-function'><code>flip</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#floor-function'><code>floor</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#floordivide-function'><code>floor_divide</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#full-function'><code>full</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#fulllike-function'><code>full_like</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#getitem-function'><code>get_item</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#greater-function'><code>greater</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#greaterequal-function'><code>greater_equal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#histogram-function'><code>histogram</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#hstack-function'><code>hstack</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#identity-function'><code>identity</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#imag-function'><code>imag</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#isclose-function'><code>isclose</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#isfinite-function'><code>isfinite</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#isinf-function'><code>isinf</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#isnan-function'><code>isnan</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#leftshift-function'><code>left_shift</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#less-function'><code>less</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#lessequal-function'><code>less_equal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#linspace-function'><code>linspace</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#log-function'><code>log</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#log10-function'><code>log10</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#log1p-function'><code>log1p</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#log2-function'><code>log2</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logaddexp-function'><code>logaddexp</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logicaland-function'><code>logical_and</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logicalnot-function'><code>logical_not</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logicalor-function'><code>logical_or</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logicalxor-function'><code>logical_xor</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#logspace-function'><code>logspace</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#matmul-function'><code>matmul</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#max-function'><code>max</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#maximum-function'><code>maximum</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#mean-function'><code>mean</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#median-function'><code>median</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#meshgrid-function'><code>meshgrid</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#min-function'><code>min</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#minimum-function'><code>minimum</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#mod-function'><code>mod</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#moveaxis-function'><code>moveaxis</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#multiply-function'><code>multiply</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#nantonum-function'><code>nan_to_num</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#ndim-function'><code>ndim</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#negative-function'><code>negative</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#nonzero-function'><code>nonzero</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#norm-function'><code>norm</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#notequal-function'><code>not_equal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#ones-function'><code>ones</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#oneslike-function'><code>ones_like</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#outer-function'><code>outer</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#pad-function'><code>pad</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#power-function'><code>power</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#prod-function'><code>prod</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#quantile-function'><code>quantile</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#ravel-function'><code>ravel</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#real-function'><code>real</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#reciprocal-function'><code>reciprocal</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#repeat-function'><code>repeat</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#reshape-function'><code>reshape</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#rightshift-function'><code>right_shift</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#roll-function'><code>roll</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#round-function'><code>round</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#searchsorted-function'><code>searchsorted</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#select-function'><code>select</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sign-function'><code>sign</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sin-function'><code>sin</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sinh-function'><code>sinh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#size-function'><code>size</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#slogdet-function'><code>slogdet</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sort-function'><code>sort</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#split-function'><code>split</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sqrt-function'><code>sqrt</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#square-function'><code>square</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#squeeze-function'><code>squeeze</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#stack-function'><code>stack</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#std-function'><code>std</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#subtract-function'><code>subtract</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#sum-function'><code>sum</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#swapaxes-function'><code>swapaxes</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#take-function'><code>take</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#takealongaxis-function'><code>take_along_axis</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tan-function'><code>tan</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tanh-function'><code>tanh</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tensordot-function'><code>tensordot</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tile-function'><code>tile</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#trace-function'><code>trace</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#transpose-function'><code>transpose</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tri-function'><code>tri</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#tril-function'><code>tril</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#triu-function'><code>triu</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#truedivide-function'><code>true_divide</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#trunc-function'><code>trunc</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#var-function'><code>var</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#vdot-function'><code>vdot</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#vectorize-function'><code>vectorize</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#vstack-function'><code>vstack</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#where-function'><code>where</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#zeros-function'><code>zeros</code> function</a> </div> <div class='k-outline-depth-3'> <a href='#zeroslike-function'><code>zeros_like</code> function</a> </div> </div> </div> </div> </div> </body> <footer style="float: left; width: 100%; padding: 1em; border-top: solid 1px #bbb;"> <a href="https://policies.google.com/terms">Terms</a> | <a href="https://policies.google.com/privacy">Privacy</a> </footer> </html>