NumPy 運算

[原始碼]

absolute 函數

keras.ops.absolute(x)

逐元素計算絕對值。

keras.ops.abs 是此函數的簡寫。

引數

• x：輸入張量。

返回

一個陣列，包含 x 中每個元素的絕對值。

範例

>>> x = keras.ops.convert_to_tensor([-1.2, 1.2])
>>> keras.ops.absolute(x)
array([1.2, 1.2], dtype=float32)

[原始碼]

add 函數

keras.ops.add(x1, x2)

逐元素相加引數。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

包含 x1 和 x2 逐元素總和的張量。

範例

>>> 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)

keras.ops.add 也會廣播形狀

>>> 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)

[原始碼]

all 函數

keras.ops.all(x, axis=None, keepdims=False)

測試是否沿著給定軸的所有陣列元素都評估為 True。

引數

• x：輸入張量。
• axis：一個整數或整數元組，表示執行邏輯 AND 縮減的軸。預設值 (axis=None) 是對輸入陣列的所有維度執行邏輯 AND。axis 可以為負數，在這種情況下，它從最後一個軸算到第一個軸。
• keepdims：如果為 True，則縮減的軸會保留在結果中，作為大小為一的維度。使用此選項，結果將針對輸入陣列正確廣播。預設為 False。

返回

包含沿著 axis 的邏輯 AND 縮減的張量。

範例

>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.all(x)
array(False, shape=(), dtype=bool)

>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, axis=0)
array([ True False], shape=(2,), dtype=bool)

keepdims=True 輸出一個維度縮減為一的張量。

>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, keepdims=True)
array([[False]], shape=(1, 1), dtype=bool)

[原始碼]

amax 函數

keras.ops.amax(x, axis=None, keepdims=False)

返回陣列的最大值或沿軸的最大值。

引數

• x：輸入張量。
• axis：計算最大值的軸。預設值 (axis=None) 是在輸入陣列的所有維度中尋找最大值。
• keepdims：如果為 True，則縮減的軸會保留在結果中，作為廣播到原始輸入張量大小的維度。預設為 False。

返回

一個包含最大值的陣列。如果 axis=None，則結果是表示整個陣列中最大元素的純量值。如果給定 axis，則結果是一個陣列，其中包含沿指定軸的最大值。

範例

>>> x = keras.ops.convert_to_tensor([[1, 3, 5], [2, 3, 6]])
>>> keras.ops.amax(x)
array(6, dtype=int32)

>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]])
>>> keras.ops.amax(x, axis=0)
array([1, 6, 8], dtype=int32)

>>> 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)

[原始碼]

amin 函數

keras.ops.amin(x, axis=None, keepdims=False)

返回陣列的最小值或沿軸的最小值。

引數

• x：輸入張量。
• axis：計算最小值的軸。預設值 (axis=None) 是在輸入陣列的所有維度中尋找最小值。
• keepdims：如果為 True，則縮減的軸會保留在結果中，作為廣播到原始輸入張量大小的維度。預設為 False。

返回

一個包含最小值的陣列。如果 axis=None，則結果是表示整個陣列中最小元素的純量值。如果給定 axis，則結果是一個陣列，其中包含沿指定軸的最小值。

範例

>>> x = keras.ops.convert_to_tensor([1, 3, 5, 2, 3, 6])
>>> keras.ops.amin(x)
array(1, dtype=int32)

>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]])
>>> keras.ops.amin(x, axis=0)
array([1,5,3], dtype=int32)

>>> 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)

[原始碼]

any 函數

keras.ops.any(x, axis=None, keepdims=False)

測試是否沿著給定軸的任何陣列元素都評估為 True。

引數

• x：輸入張量。
• axis：一個整數或整數元組，表示執行邏輯 OR 縮減的軸。預設值 (axis=None) 是對輸入陣列的所有維度執行邏輯 OR。axis 可以為負數，在這種情況下，它從最後一個軸算到第一個軸。
• keepdims：如果為 True，則縮減的軸會保留在結果中，作為大小為一的維度。使用此選項，結果將針對輸入陣列正確廣播。預設為 False。

返回

包含沿著 axis 的邏輯 OR 縮減的張量。

範例

>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.any(x)
array(True, shape=(), dtype=bool)

>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.any(x, axis=0)
array([ True  True], shape=(2,), dtype=bool)

keepdims=True 輸出一個維度縮減為一的張量。

>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, keepdims=True)
array([[False]], shape=(1, 1), dtype=bool)

[原始碼]

append 函數

keras.ops.append(x1, x2, axis=None)

將張量 x2 附加到張量 x1 的末尾。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。
• axis：張量 x2 附加到張量 x1 的軸。如果為 None，則在使用前將兩個張量展平。

返回

一個張量，其中包含附加到 x1 的 x2 值。

範例

>>> 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)

當指定 axis 時，x1 和 x2 必須具有相容的形狀。

>>> 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,).

[原始碼]

arange 函數

keras.ops.arange(start, stop=None, step=1, dtype=None)

在給定區間內返回均勻間隔的值。

arange 可以使用不同數量的位置引數來呼叫：* arange(stop)：值在半開區間 [0, stop) 內產生（換句話說，區間包含開始但不包含停止）。* arange(start, stop)：值在半開區間 [start, stop) 內產生。* arange(start, stop, step)：值在半開區間 [start, stop) 內產生，值之間的間距由 step 給定。

引數

• start：整數或實數，表示區間的開始。區間包含此值。
• stop：整數或實數，表示區間的結束。區間不包含此值，除非在某些情況下 step 不是整數且浮點捨入誤差會影響 out 的長度。預設值為 None。
• step：整數或實數，表示值之間的間距。對於任何輸出 out，這是兩個相鄰值之間的距離，out[i+1] - out[i]。預設步長為 1。如果將 step 指定為位置引數，則也必須給定 start。
• dtype：輸出陣列的類型。如果未給定 dtype，則從其他輸入引數推斷資料類型。

返回

均勻間隔值的張量。對於浮點引數，結果的長度為 ceil((stop - start)/step)。由於浮點溢位，此規則可能會導致 out 的最後一個元素大於 stop。

範例

>>> keras.ops.arange(3)
array([0, 1, 2], dtype=int32)

>>> keras.ops.arange(3.0)
array([0., 1., 2.], dtype=float32)

>>> keras.ops.arange(3, 7)
array([3, 4, 5, 6], dtype=int32)

>>> keras.ops.arange(3, 7, 2)
array([3, 5], dtype=int32)

[原始碼]

arccos 函數

keras.ops.arccos(x)

三角反餘弦，逐元素。

cos 的反函數，因此，如果 y = cos(x)，則 x = arccos(y)。

引數

• x：輸入張量。

返回

射線角度的張量，該射線在給定的 x 坐標處與單位圓相交，單位為弧度 [0, pi]。

範例

>>> x = keras.ops.convert_to_tensor([1, -1])
>>> keras.ops.arccos(x)
array([0.0, 3.1415927], dtype=float32)

[原始碼]

arccosh 函數

keras.ops.arccosh(x)

反雙曲餘弦，逐元素。

引數

• x：輸入張量。

返回

與 x 形狀相同的輸出張量。

範例

>>> x = keras.ops.convert_to_tensor([10, 100])
>>> keras.ops.arccosh(x)
array([2.993223, 5.298292], dtype=float32)

[原始碼]

arcsin 函數

keras.ops.arcsin(x)

反sine，逐元素。

引數

• x：輸入張量。

返回

x 中每個元素的反sine 張量，單位為弧度，在閉區間 [-pi/2, pi/2] 中。

範例

>>> x = keras.ops.convert_to_tensor([1, -1, 0])
>>> keras.ops.arcsin(x)
array([ 1.5707964, -1.5707964,  0.], dtype=float32)

[原始碼]

arcsinh 函數

keras.ops.arcsinh(x)

反雙曲sine，逐元素。

引數

• x：輸入張量。

返回

與 x 形狀相同的輸出張量。

範例

>>> x = keras.ops.convert_to_tensor([1, -1, 0])
>>> keras.ops.arcsinh(x)
array([0.88137364, -0.88137364, 0.0], dtype=float32)

[原始碼]

arctan 函數

keras.ops.arctan(x)

三角反正切，逐元素。

引數

• x：輸入張量。

返回

x 中每個元素的反切線張量，在區間 [-pi/2, pi/2] 中。

範例

>>> x = keras.ops.convert_to_tensor([0, 1])
>>> keras.ops.arctan(x)
array([0., 0.7853982], dtype=float32)

[原始碼]

arctan2 函數

keras.ops.arctan2(x1, x2)

x1/x2 的逐元素反正切，正確選擇象限。

選擇象限（即分支），以便 arctan2(x1, x2) 是以弧度為單位的有符號角，介於以原點為終點並穿過點 (1, 0) 的射線，以及以原點為終點並穿過點 (x2, x1) 的射線之間。（請注意角色反轉：「y 坐標」是第一個函數參數，「x 坐標」是第二個。）依照 IEEE 慣例，此函數定義適用於 x2 = +/-0 以及 x1 和 x2 的任一或兩者 = +/-inf。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

弧度角張量，範圍為 [-pi, pi]。

範例

考慮不同象限中的四個點

>>> 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)

請注意參數的順序。arctan2 在 x2=0 和其他幾個點也定義了，獲得的值在範圍 [-pi, pi] 內

>>> 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)

[原始碼]

arctanh 函數

keras.ops.arctanh(x)

反雙曲正切，逐元素。

引數

• x：輸入張量。

返回

與 x 形狀相同的輸出張量。

[原始碼]

argmax 函數

keras.ops.argmax(x, axis=None, keepdims=False)

返回沿軸的最大值索引。

引數

• x：輸入張量。
• axis：預設情況下，索引會進入展平的張量，否則沿著指定的軸。
• keepdims：如果設定為 True，則縮減的軸會保留在結果中，作為大小為一的維度。預設為 False。

返回

索引的張量。它的形狀與 x 相同，但沿 axis 的維度已移除。

範例

>>> 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)

[原始碼]

argmin 函數

keras.ops.argmin(x, axis=None, keepdims=False)

返回沿軸的最小值索引。

引數

• x：輸入張量。
• axis：預設情況下，索引會進入展平的張量，否則沿著指定的軸。
• keepdims：如果設定為 True，則縮減的軸會保留在結果中，作為大小為一的維度。預設為 False。

返回

索引的張量。它的形狀與 x 相同，但沿 axis 的維度已移除。

範例

>>> 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)

[原始碼]

argpartition 函數

keras.ops.argpartition(x, kth, axis=-1)

沿給定軸執行間接分割。

它返回一個與 x 形狀相同的索引陣列，該陣列以分割順序索引沿給定軸的資料。

引數

• a：要排序的陣列。
• kth：要分割的元素索引。第 k 個元素將位於其最終排序位置，所有較小的元素將移到它之前，所有較大的元素將移到它之後。分割中所有元素的順序未定義。如果提供 k 個元素的序列，它會將所有元素一次分割到其排序位置。
• axis：沿哪個軸排序。預設值為 -1（最後一個軸）。如果為 None，則使用展平的陣列。

返回

沿指定 axis 分割 x 的索引陣列。

[原始碼]

argsort 函數

keras.ops.argsort(x, axis=-1)

返回將對張量排序的索引。

引數

• x：輸入張量。
• axis：沿哪個軸排序。預設值為 -1（最後一個軸）。如果為 None，則使用展平的張量。

返回

沿指定 axis 排序 x 的索引張量。

範例

一維陣列

>>> x = keras.ops.array([3, 1, 2])
>>> keras.ops.argsort(x)
array([1, 2, 0], dtype=int32)

二維陣列

>>> 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)

[原始碼]

array 函數

keras.ops.array(x, dtype=None)

建立張量。

引數

• x：輸入張量。
• dtype：張量所需的資料類型。

返回

一個張量。

範例

>>> keras.ops.array([1, 2, 3])
array([1, 2, 3], dtype=int32)

>>> keras.ops.array([1, 2, 3], dtype="float32")
array([1., 2., 3.], dtype=float32)

[原始碼]

average 函數

keras.ops.average(x, axis=None, weights=None)

計算沿指定軸的加權平均值。

引數

• x：輸入張量。
• axis：沿哪個整數軸對 x 取平均值。預設值 axis=None 將對輸入張量的所有元素取平均值。如果軸為負數，則從最後一個軸算到第一個軸。
• weights：與 x 中的值相關聯的權重張量。x 中的每個值都會根據其關聯的權重對平均值做出貢獻。權重陣列可以是 1-D（在這種情況下，其長度必須是沿給定軸的 a 的大小）或與 x 的形狀相同。如果 weights=None（預設值），則 x 中的所有資料都假定權重等於 1。
• __ 1-D 計算為__：avg = sum(a * weights) / sum(weights)。對權重的唯一約束是 sum(weights) 不能為 0。

返回

返回沿指定軸的平均值。

範例

>>> 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)

>>> 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.

[原始碼]

bincount 函數

keras.ops.bincount(x, weights=None, minlength=0, sparse=False)

計算整數張量中每個值出現的次數。

引數

• x：輸入張量。它必須為 1 維，並且只能包含非負整數。
• weights：權重張量。它的長度必須與 x 相同。預設值為 None。如果指定，則 x 會由它加權，即如果 n = x[i]，則 out[n] += weight[i] 而不是預設行為 out[n] += 1。
• minlength：一個整數。預設值為 0。如果指定，則輸出張量中至少會有此數量的 bin。如果大於 max(x) + 1，則索引高於 max(x) 的輸出的每個值都設定為 0。
• sparse：是否返回稀疏張量；適用於支援稀疏張量的後端。

返回

1D 張量，其中每個元素都給出其索引值在 x 中出現的次數。其長度是 max(x) + 1 和 minlength 之間的最大值。

範例

>>> 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)

[原始碼]

bitwise_and 函數

keras.ops.bitwise_and(x, y)

逐元素計算兩個陣列的位元 AND。

計算輸入陣列中整數底層二進位表示的位元 AND。此 ufunc 實作 C/Python 運算子 &。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_invert 函數

keras.ops.bitwise_invert(x)

逐元素計算位元反轉或位元 NOT。

計算輸入陣列中整數底層二進位表示的位元 NOT。此 ufunc 實作 C/Python 運算子 ~。

引數

• x：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_left_shift 函數

keras.ops.bitwise_left_shift(x, y)

將整數的位元向左移位。

位元向左移位，方法是在 x 的右側附加 y 個 0。由於數字的內部表示形式為二進位格式，因此此運算相當於將 x 乘以 2**y。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_not 函數

keras.ops.bitwise_not(x)

逐元素計算位元反轉或位元 NOT。

計算輸入陣列中整數底層二進位表示的位元 NOT。此 ufunc 實作 C/Python 運算子 ~。

引數

• x：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_or 函數

keras.ops.bitwise_or(x, y)

逐元素計算兩個陣列的位元 OR。

計算輸入陣列中整數底層二進位表示的位元 OR。此 ufunc 實作 C/Python 運算子 |。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_right_shift 函數

keras.ops.bitwise_right_shift(x, y)

將整數的位元向右移位。

位元向右移位 y。由於數字的內部表示形式為二進位格式，因此此運算相當於將 x 除以 2**y。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

bitwise_xor 函數

keras.ops.bitwise_xor(x, y)

逐元素計算兩個陣列的位元 XOR。

計算輸入陣列中整數底層二進位表示的位元 XOR。此 ufunc 實作 C/Python 運算子 ^。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

broadcast_to 函數

keras.ops.broadcast_to(x, shape)

將張量廣播到新形狀。

引數

• x：要廣播的張量。
• shape：所需張量的形狀。單個整數 i 解釋為 (i,)。

返回

具有所需形狀的張量。

範例

>>> x = keras.ops.array([1, 2, 3])
>>> keras.ops.broadcast_to(x, (3, 3))
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

[原始碼]

ceil 函數

keras.ops.ceil(x)

逐元素返回輸入的天花板值。

純量 x 的天花板值是最小整數 i，使得 i >= x。

引數

• x：輸入張量。

返回

x 中每個元素的天花板值，資料類型為 float。

[原始碼]

clip 函數

keras.ops.clip(x, x_min, x_max)

裁剪（限制）張量中的值。

給定一個區間，區間外的值會被裁剪到區間邊緣。例如，如果指定區間 [0, 1]，則小於 0 的值會變成 0，大於 1 的值會變成 1。

引數

• x：輸入張量。
• x_min：最小值。
• x_max：最大值。

返回

裁剪後的張量。

[原始碼]

concatenate 函數

keras.ops.concatenate(xs, axis=0)

沿現有軸加入張量序列。

引數

• xs：要串聯的張量序列。
• axis：張量將沿其加入的軸。預設值為 0。

返回

串聯後的張量。

[原始碼]

conj 函數

keras.ops.conj(x)

keras.ops.conjugate 的簡寫。

[原始碼]

conjugate 函數

keras.ops.conjugate(x)

逐元素返回複數共軛。

複數的複數共軛是透過變更其虛部的符號來獲得的。

keras.ops.conj 是此函數的簡寫。

引數

• x：輸入張量。

返回

x 中每個元素的複數共軛。

[原始碼]

copy 函數

keras.ops.copy(x)

返回 x 的副本。

引數

• x：輸入張量。

返回

x 的副本。

[原始碼]

correlate 函數

keras.ops.correlate(x1, x2, mode="valid")

計算兩個 1 維張量的互相關。

引數

• x1：第一個長度為 M 的 1 維輸入張量。
• x2：第二個長度為 N 的 1 維輸入張量。
• mode：可以是 valid、same 或 full。預設情況下，模式設定為 valid，它返回長度為 max(M, N) - min(M, N) + 1 的輸出。same 返回長度為 max(M, N) 的輸出。full 模式返回每個重疊點的卷積，輸出長度為 N+M-1

返回

輸出張量，x1 和 x2 的互相關。

[原始碼]

cos 函數

keras.ops.cos(x)

餘弦，逐元素。

引數

• x：輸入張量。

返回

對應的餘弦值。

[原始碼]

cosh 函數

keras.ops.cosh(x)

雙曲餘弦，逐元素。

引數

• x：輸入張量。

返回

與 x 形狀相同的輸出張量。

[原始碼]

count_nonzero 函數

keras.ops.count_nonzero(x, axis=None)

計算沿給定 axis 的 x 中非零值的數量。

如果未指定軸，則會計算張量中的所有非零值。

引數

• x：輸入張量。
• axis：沿哪個軸或軸元組計算非零值的數量。預設值為 None。

返回

整數或整數張量。

範例

>>> 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)

[原始碼]

cross 函數

keras.ops.cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None)

返回兩個（向量陣列）的叉積。

R^3 中 x1 和 x2 的叉積是一個垂直於 x1 和 x2 的向量。如果 x1 和 x2 是向量陣列，則向量預設由 x1 和 x2 的最後一個軸定義，並且這些軸的維度可以為 2 或 3。

如果 x1 或 x2 的維度為 2，則輸入向量的第三個分量假定為零，並據此計算叉積。

如果兩個輸入向量的維度都為 2，則返回叉積的 z 分量。

引數

• x1：第一個向量的分量。
• x2：第二個向量的分量。
• axisa：x1 中定義向量的軸。預設值為 -1。
• axisb：x2 中定義向量的軸。預設值為 -1。
• axisc：結果中包含叉積向量的軸。如果兩個輸入向量的維度都為 2，則會忽略，因為傳回值是純量。預設情況下，最後一個軸。
• axis：如果已定義，則 x1、x2 和結果的軸，用於定義向量和叉積。覆寫 axisa、axisb 和 axisc。

注意：Torch 後端不支援二維向量，也不支援引數 axisa、axisb 和 axisc。請改用 axis。

返回

向量叉積。

[原始碼]

cumprod 函數

keras.ops.cumprod(x, axis=None, dtype=None)

返回沿給定軸的元素累積乘積。

引數

• x：輸入張量。
• axis：計算累積乘積的軸。預設情況下，輸入會展平。
• dtype：傳回張量的 dtype。預設值為 x.dtype。

返回

輸出張量。

[原始碼]

cumsum 函數

keras.ops.cumsum(x, axis=None, dtype=None)

返回沿給定軸的元素累積總和。

引數

• x：輸入張量。
• axis：計算累積總和的軸。預設情況下，輸入會展平。
• dtype：傳回張量的 dtype。預設值為 x.dtype。

返回

輸出張量。

[原始碼]

diag 函數

keras.ops.diag(x, k=0)

提取對角線或建構對角線陣列。

引數

• x：輸入張量。如果 x 是 2 維，則返回 x 的第 k 個對角線。如果 x 是 1 維，則返回一個 2 維張量，其中 x 位於第 k 個對角線上。
• k：要考慮的對角線。預設值為 0。對於主對角線上方的對角線，使用 k > 0，對於主對角線下方的對角線，使用 k < 0。

返回

提取的對角線或建構的對角線張量。

範例

>>> from keras.src import ops
>>> x = ops.arange(9).reshape((3, 3))
>>> x
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

>>> ops.diag(x)
array([0, 4, 8])
>>> ops.diag(x, k=1)
array([1, 5])
>>> ops.diag(x, k=-1)
array([3, 7])

>>> ops.diag(ops.diag(x)))
array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 8]])

[原始碼]

diagonal 函數

keras.ops.diagonal(x, offset=0, axis1=0, axis2=1)

返回指定的對角線。

如果 x 是 2 維，則返回具有給定偏移量的 x 的對角線，即 x[i, i+offset] 形式的元素集合。

如果 x 的維度超過兩個，則軸 axis1 和 axis2 指定用於決定要返回其對角線的 2 維子陣列。

結果陣列的形狀可以透過移除 axis1 和 axis2 並在右側附加一個索引（等於結果對角線的大小）來決定。

引數

• x：輸入張量。
• offset：對角線與主對角線的偏移量。可以是正數或負數。預設值為 0（主對角線）。
• axis1：要用作 2 維子陣列第一個軸的軸。預設值為 0（第一個軸）。
• axis2：要用作 2 維子陣列第二個軸的軸。預設值為 1（第二個軸）。

返回

對角線的張量。

範例

>>> 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])

>>> 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]])

[原始碼]

diff 函數

keras.ops.diff(a, n=1, axis=-1)

計算沿給定軸的第 n 個離散差分。

第一個差分由沿給定軸的 out[i] = a[i+1] - a[i] 給出，較高的差分是透過遞迴使用 diff 來計算的。

引數

• a：輸入張量。
• n：值被差分的次數。預設值為 1。
• axis：沿哪個軸計算離散差分。預設值為 -1（最後一個軸）。

返回

對角線的張量。

範例

>>> 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])

>>> 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]])

[原始碼]

digitize 函數

keras.ops.digitize(x, bins)

返回 x 中每個值所屬的 bin 的索引。

引數

• x：要分箱的輸入陣列。
• bins：bin 陣列。它必須是一維且單調遞增的。

返回

索引的輸出陣列，形狀與 x 相同。

範例

>>> 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])

[原始碼]

divide 函數

keras.ops.divide(x1, x2)

逐元素相除引數。

keras.ops.true_divide 是此函數的別名。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，商數 x1/x2，逐元素。

[原始碼]

divide_no_nan 函數

keras.ops.divide_no_nan(x1, x2)

安全的逐元素除法，在分母為 0 時返回 0。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

商數 x1/x2，逐元素，在 x2 為零時為零。

[原始碼]

dot 函數

keras.ops.dot(x1, x2)

兩個張量的點積。

• 如果 x1 和 x2 都是 1 維張量，則為向量的內積（不含複數共軛）。
• 如果 x1 和 x2 都是 2 維張量，則為矩陣乘法。
• 如果 x1 或 x2 為 0 維（純量），則相當於 x1 * x2。
• 如果 x1 是 N 維張量，而 x2 是 1 維張量，則為 x1 的最後一個軸和 x2 的總和乘積。
• 如果 x1 是 N 維張量，而 x2 是 M 維張量（其中 M>=2），則為 x1 的最後一個軸和 x2 的倒數第二個軸的總和乘積：dot(x1, x2)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

引數

• x1：第一個引數。
• x2：第二個引數。

注意：Torch 後端不接受 0 維張量作為引數。

返回

x1 和 x2 的點積。

[原始碼]

einsum 函數

keras.ops.einsum(subscripts, *operands)

在運算元上評估愛因斯坦求和約定。

引數

• subscripts：指定求和的下標，作為逗號分隔的下標標籤清單。除非顯式指示符 -> 以及精確輸出形式的下標標籤也包含在內，否則會執行隱式（古典愛因斯坦求和）計算。
• operands：要計算愛因斯坦和的運算元。

返回

基於愛因斯坦求和約定的計算。

範例

>>> from keras.src import ops
>>> a = ops.arange(25).reshape(5, 5)
>>> b = ops.arange(5)
>>> c = ops.arange(6).reshape(2, 3)

矩陣的跡

>>> ops.einsum("ii", a)
60
>>> ops.einsum(a, [0, 0])
60
>>> ops.trace(a)
60

提取對角線

>>> 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])

軸求和

>>> 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])

對於更高維度的張量，可以使用省略號來對單個軸求和

>>> ops.einsum("...j -> ...", a)
array([ 10,  35,  60,  85, 110])
>>> np.einsum(a, [..., 1], [...])
array([ 10,  35,  60,  85, 110])

計算矩陣轉置或重新排序任意數量的軸

>>> 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]])

矩陣向量乘法

>>> 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])

[原始碼]

empty 函數

keras.ops.empty(shape, dtype=None)

返回給定形狀和類型的張量，並以未初始化的資料填滿。

引數

• shape：空張量的形狀。
• dtype：空張量所需的資料類型。

返回

空張量。

[原始碼]

equal 函數

keras.ops.equal(x1, x2)

逐元素返回 (x1 == x2)。

引數

• x1：要比較的張量。
• x2：要比較的張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

exp 函數

keras.ops.exp(x)

計算輸入張量中所有元素的指數。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素指數。

[原始碼]

expand_dims 函數

keras.ops.expand_dims(x, axis)

展開張量的形狀。

在展開的張量形狀中的 axis 位置插入新軸（或軸）。

引數

• x：輸入張量。
• axis：新軸（或軸）放置在展開軸中的位置。

返回

維度數量增加的輸出張量。

[原始碼]

expm1 函數

keras.ops.expm1(x)

計算張量中所有元素的 exp(x) - 1。

引數

• x：輸入值。

返回

輸出張量，逐元素指數減一。

[原始碼]

eye 函數

keras.ops.eye(N, M=None, k=0, dtype=None)

返回一個 2 維張量，主對角線上為 1，其他地方為 0。

引數

• N：輸出中的行數。
• M：輸出中的欄數。如果為 None，則預設為 N。
• k：對角線的索引：0（預設值）表示主對角線，正值表示上方對角線，負值表示下方對角線。
• dtype：傳回張量的資料類型。

返回

第 k 個對角線上為 1，其他地方為 0 的張量。

[原始碼]

flip 函數

keras.ops.flip(x, axis=None)

沿給定軸反轉張量中元素的順序。

張量的形狀會保留，但元素會重新排序。

引數

• x：輸入張量。
• axis：沿哪個軸或軸反轉張量。預設值 axis=None 將反轉輸入張量的所有軸。

返回

axis 項目反轉的輸出張量。

[原始碼]

floor 函數

keras.ops.floor(x)

逐元素返回輸入的底值。

純量 x 的底值是最大整數 i，使得 i <= x。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素底值。

[原始碼]

floor_divide 函數

keras.ops.floor_divide(x1, x2)

返回小於或等於輸入除法的最大整數。

引數

• x1：分子。
• x2：分母。

返回

輸出張量，y = floor(x1/x2)

[原始碼]

full 函數

keras.ops.full(shape, fill_value, dtype=None)

返回給定形狀和類型的新張量，並以 fill_value 填滿。

引數

• shape：新張量的形狀。
• fill_value：填滿值。
• dtype：張量所需的資料類型。

返回

輸出張量。

[原始碼]

full_like 函數

keras.ops.full_like(x, fill_value, dtype=None)

返回與給定張量具有相同形狀和類型的完整張量。

引數

• x：輸入張量。
• fill_value：填滿值。
• dtype：覆寫結果的資料類型。

返回

與 x 具有相同形狀和類型的 fill_value 張量。

[原始碼]

get_item 函數

keras.ops.get_item(x, key)

返回 x[key]。

[原始碼]

greater 函數

keras.ops.greater(x1, x2)

逐元素返回 x1 > x2 的真值。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

greater_equal 函數

keras.ops.greater_equal(x1, x2)

逐元素返回 x1 >= x2 的真值。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

histogram 函數

keras.ops.histogram(x, bins=10, range=None)

計算資料張量 x 的直方圖。

引數

• x：輸入張量。
• bins：表示直方圖 bin 數量的整數。預設值為 10。
• range：表示 bin 的下限和上限範圍的元組。如果未指定，則會使用 x 的最小值和最大值。

返回

• 包含以下內容的元組:
• 表示每個 bin 中元素計數的張量。
• 表示 bin 邊緣的張量。

範例

```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]))

----

<span style="float:right;">[[source]](https://github.com/keras-team/keras/tree/v3.9.0/keras/src/ops/numpy.py#L3174)</span>

### `hstack` function


```python
keras.ops.hstack(xs)

水平（欄式）堆疊序列中的張量。

對於 1 維張量，這相當於沿第一個軸串聯，對於所有其他張量，則相當於沿第二個軸串聯。

引數

• xs：張量序列。

返回

透過堆疊給定張量形成的張量。

[原始碼]

identity 函數

keras.ops.identity(n, dtype=None)

返回單位張量。

單位張量是一個方陣張量，主對角線上為 1，其他地方為 0。

引數

• n：n x n 輸出張量中的列數（和行數）。
• dtype：輸出張量的資料類型。

返回

單位張量。

[原始碼]

imag 函數

keras.ops.imag(x)

返回複數引數的虛部。

引數

• x：輸入張量。

返回

複數引數的虛數分量。

[原始碼]

isclose 函數

keras.ops.isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False)

返回兩個張量是否逐元素幾乎相等。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。
• rtol：相對容差。
• atol：絕對容差。
• equal_nan：如果為 True，則逐元素的 NaN 會被視為相等。

返回

輸出布林張量。

[原始碼]

isfinite 函數

keras.ops.isfinite(x)

逐元素返回張量是否為有限值。

當實數值不是 NaN、不是正無限大且不是負無限大時，它們是有限值。當複數值的實部和虛部都是有限值時，它們是有限值。

引數

• x：輸入張量。

返回

輸出布林張量。

[原始碼]

isinf 函數

keras.ops.isinf(x)

逐元素測試正無限大或負無限大。

引數

• x：輸入張量。

返回

輸出布林張量。

[原始碼]

isnan 函數

keras.ops.isnan(x)

逐元素測試 NaN 並將結果作為布林張量返回。

引數

• x：輸入張量。

返回

輸出布林張量。

[原始碼]

left_shift 函數

keras.ops.left_shift(x, y)

將整數的位元向左移位。

位元向左移位，方法是在 x 的右側附加 y 個 0。由於數字的內部表示形式為二進位格式，因此此運算相當於將 x 乘以 2**y。

引數

• x：輸入整數張量。
• y：輸入整數張量。

返回

結果張量。

[原始碼]

less 函數

keras.ops.less(x1, x2)

逐元素返回 x1 < x2 的真值。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

less_equal 函數

keras.ops.less_equal(x1, x2)

傳回 x1 <= x2 逐元素比較的真值。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

linspace 函數

keras.ops.linspace(
    start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0
)

在指定的區間內傳回均勻間隔的數字。

傳回 num 個均勻間隔的樣本，計算範圍為 [start, stop] 區間。

區間的終點可以選擇性地排除在外。

引數

• start：序列的起始值。
• stop：序列的終止值，除非將 endpoint 設為 False。在這種情況下，序列由 num + 1 個均勻間隔的樣本中，除了最後一個樣本以外的所有樣本組成，因此 stop 會被排除在外。請注意，當 endpoint 為 False 時，步長大小會改變。
• num：要生成的樣本數。預設值為 50。必須為非負數。
• endpoint：若為 True，則 stop 為最後一個樣本。否則，不包含在內。預設值為 True。
• retstep：若為 True，則傳回 (samples, step)，其中 step 是樣本之間的間距。
• dtype：輸出張量的類型。
• axis：結果中儲存樣本的軸。僅在 start 或 stop 為類陣列 (array-like) 時相關。預設值為 0。

注意：Torch 後端不支援 axis 引數。

返回

均勻間隔數字的張量。若 retstep 為 True，則傳回 (samples, step)

[原始碼]

log 函數

keras.ops.log(x)

自然對數，逐元素計算。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素自然對數。

[原始碼]

log10 函數

keras.ops.log10(x)

傳回輸入張量以 10 為底的對數，逐元素計算。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素以 10 為底的對數。

[原始碼]

log1p 函數

keras.ops.log1p(x)

傳回 1 加上 x 的自然對數，逐元素計算。

計算 log(1 + x)。

引數

• x：輸入張量。

返回

輸出張量，1 + x 的逐元素自然對數。

[原始碼]

log2 函數

keras.ops.log2(x)

x 以 2 為底的對數，逐元素計算。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素以 2 為底的對數。

[原始碼]

logaddexp 函數

keras.ops.logaddexp(x1, x2)

輸入值的指數運算總和的對數。

計算 log(exp(x1) + exp(x2))。

引數

• x1：輸入張量。
• x2：輸入張量。

返回

輸出張量，輸入值的指數運算總和的逐元素對數。

[原始碼]

logical_and 函數

keras.ops.logical_and(x1, x2)

計算給定輸入張量的逐元素邏輯 AND 運算。

零被視為 False，非零值被視為 True。

引數

• x1：輸入張量。
• x2：輸入張量。

返回

輸出張量，輸入值的逐元素邏輯 AND 運算結果。

[原始碼]

logical_not 函數

keras.ops.logical_not(x)

計算給定輸入張量的逐元素邏輯 NOT 運算。

零被視為 False，非零值被視為 True。

引數

• x：輸入張量。

返回

輸出張量，輸入值的逐元素邏輯 NOT 運算結果。

[原始碼]

logical_or 函數

keras.ops.logical_or(x1, x2)

計算給定輸入張量的逐元素邏輯 OR 運算。

零被視為 False，非零值被視為 True。

引數

• x1：輸入張量。
• x2：輸入張量。

返回

輸出張量，輸入值的逐元素邏輯 OR 運算結果。

[原始碼]

logical_xor 函數

keras.ops.logical_xor(x1, x2)

計算 x1 XOR x2 的真值，逐元素計算。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出布林張量。

[原始碼]

logspace 函數

keras.ops.logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0)

傳回在對數刻度上均勻間隔的數字。

在線性空間中，序列從 base ** start 開始，到 base ** stop 結束（請參閱下方的 endpoint）。

引數

• start：序列的起始值。
• stop：序列的最終值，除非 endpoint 為 False。在這種情況下，num + 1 個值會在對數空間的區間內均勻間隔，其中除了最後一個值（長度為 num 的序列）以外的所有值都會傳回。
• num：要生成的樣本數。預設值為 50。
• endpoint：若為 True，則 stop 為最後一個樣本。否則，不包含在內。預設值為 True。
• base：對數空間的底數。預設值為 10。
• dtype：輸出張量的類型。
• axis：結果中儲存樣本的軸。僅在 start 或 stop 為類陣列 (array-like) 時相關。

注意：Torch 後端不支援 axis 引數。

返回

對數刻度上均勻間隔樣本的張量。

[原始碼]

matmul 函數

keras.ops.matmul(x1, x2)

兩個張量的矩陣乘積。

• 若兩個張量都是 1 維，則傳回點積（純量）。
• 若任一張量是 N 維，N > 2，則會將其視為駐留在最後兩個索引中的矩陣堆疊，並據此進行廣播。
• 若第一個張量是 1 維，則會透過在其維度前面加上 1 來提升為矩陣。在矩陣乘法後，會移除前置的 1。
• 若第二個張量是 1 維，則會透過在其維度後面加上 1 來提升為矩陣。在矩陣乘法後，會移除後置的 1。

引數

• x1：第一個張量。
• x2：第二個張量。

返回

輸出張量，輸入值的矩陣乘積。

[原始碼]

max 函數

keras.ops.max(x, axis=None, keepdims=False, initial=None)

傳回張量的最大值，或沿軸的最大值。

引數

• x：輸入張量。
• axis：要沿其運算的軸或軸。預設情況下，會使用展平的輸入。
• keepdims：如果設定為 True，則縮減的軸會保留在結果中，作為大小為一的維度。預設為 False。
• initial：輸出元素的最小值。預設值為 None。

返回

x 的最大值。

[原始碼]

maximum 函數

keras.ops.maximum(x1, x2)

x1 和 x2 的逐元素最大值。

引數

• x1：第一個張量。
• x2：第二個張量。

返回

輸出張量，x1 和 x2 的逐元素最大值。

[原始碼]

mean 函數

keras.ops.mean(x, axis=None, keepdims=False)

計算沿指定軸的算術平均值。

引數

• x：輸入張量。
• axis：要沿其計算平均值的軸或軸。預設值是計算展平張量的平均值。
• keepdims：若設為 True，則縮減的軸會保留在結果中，作為大小為 1 的維度。

返回

包含平均值的輸出張量。

[原始碼]

median 函數

keras.ops.median(x, axis=None, keepdims=False)

計算沿指定軸的中位數。

引數

• x：輸入張量。
• axis：要沿其計算中位數的軸或軸。預設值為 axis=None，表示沿陣列的展平版本計算中位數。
• keepdims：若設為 True，則縮減的軸會保留在結果中，作為大小為 1 的維度。

返回

輸出張量。

[原始碼]

meshgrid 函數

keras.ops.meshgrid(*x, indexing="xy")

從座標向量建立座標網格。

給定 N 個 1 維張量 T0、T1、...、TN-1 作為輸入，其對應長度為 S0、S1、...、SN-1，這會建立 N 個 N 維張量 G0、G1、...、GN-1，每個張量的形狀皆為 (S0, ..., SN-1)，其中輸出 Gi 是透過將 Ti 擴展到結果形狀來建構的。

引數

• x：代表網格座標的 1 維張量。
• indexing："xy" 或 "ij"。"xy" 是笛卡爾座標；"ij" 是輸出的矩陣索引。預設值為 "xy"。

返回

N 個張量的序列。

範例

>>> from keras.src import ops
>>> x = ops.array([1, 2, 3])
>>> y = ops.array([4, 5, 6])

>>> 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]])

[原始碼]

min 函數

keras.ops.min(x, axis=None, keepdims=False, initial=None)

傳回張量的最小值，或沿軸的最小值。

引數

• x：輸入張量。
• axis：要沿其運算的軸或軸。預設情況下，會使用展平的輸入。
• keepdims：如果設定為 True，則縮減的軸會保留在結果中，作為大小為一的維度。預設為 False。
• initial：輸出元素的最大值。預設值為 None。

返回

x 的最小值。

[原始碼]

minimum 函數

keras.ops.minimum(x1, x2)

x1 和 x2 的逐元素最小值。

引數

• x1：第一個張量。
• x2：第二個張量。

返回

輸出張量，x1 和 x2 的逐元素最小值。

[原始碼]

mod 函數

keras.ops.mod(x1, x2)

傳回除法的逐元素餘數。

引數

• x1：第一個張量。
• x2：第二個張量。

返回

輸出張量，除法的逐元素餘數。

[原始碼]

moveaxis 函數

keras.ops.moveaxis(x, source, destination)

將張量的軸移動到新的位置。

其他軸保持其原始順序。

引數

• x：應重新排序軸的張量。
• source：要移動的軸的原始位置。這些位置必須是唯一的。
• destination：每個原始軸的目的地位置。這些位置也必須是唯一的。

返回

軸已移動的張量。

[原始碼]

multiply 函數

keras.ops.multiply(x1, x2)

將引數逐元素相乘。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素乘積。

[原始碼]

nan_to_num 函數

keras.ops.nan_to_num(x, nan=0.0, posinf=None, neginf=None)

將 NaN 替換為零，將無窮大替換為大的有限數字。

引數

• x：輸入資料。
• nan：選用浮點數或整數。用來替換 NaN 條目的值。
• posinf：選用浮點數或整數。用來替換正無窮大的值。
• neginf：選用浮點數或整數。用來替換負無窮大的值。

返回

x，已替換為非有限值。

[原始碼]

ndim 函數

keras.ops.ndim(x)

傳回張量的維度數。

引數

• x：輸入張量。

返回

x 中的維度數。

[原始碼]

negative 函數

keras.ops.negative(x)

數值負數，逐元素計算。

引數

• x：輸入張量。

返回

輸出張量，y = -x。

[原始碼]

nonzero 函數

keras.ops.nonzero(x)

傳回非零元素的索引。

引數

• x：輸入張量。

返回

非零元素的索引。

[原始碼]

norm 函數

keras.ops.norm(x, ord=None, axis=None, keepdims=False)

矩陣或向量範數。

此函數能夠傳回八種不同的矩陣範數之一，或無限數量的向量範數之一（如下所述），具體取決於 ord 參數的值。

引數

• x：輸入張量。
• ord：範數的階數（請參閱「注意事項」下的表格）。預設值為 None。
• axis：若 axis 是整數，則指定 x 的軸，沿此軸計算向量範數。若 axis 是 2 元組，則指定保存 2 維矩陣的軸，並計算這些矩陣的矩陣範數。
• keepdims：若設為 True，則縮減的軸會保留在結果中，作為大小為 1 的維度。

注意：對於 ord < 1 的值，嚴格來說，結果並非數學上的「範數」，但對於各種數值目的而言，可能仍然有用。可以計算以下範數： - 對於矩陣： - ord=None：Frobenius 範數 - ord="fro"：Frobenius 範數 - ord="nuc"：核範數 - ord=np.inf：max(sum(abs(x), axis=1)) - ord=-np.inf：min(sum(abs(x), axis=1)) - ord=0：不支援 - ord=1：max(sum(abs(x), axis=0)) - ord=-1：min(sum(abs(x), axis=0)) - ord=2：2-範數（最大奇異值） - ord=-2：最小奇異值 - 其他：不支援 - 對於向量： - ord=None：2-範數 - ord="fro"：不支援 - ord="nuc"：不支援 - ord=np.inf：max(abs(x)) - ord=-np.inf：min(abs(x)) - ord=0：sum(x != 0) - ord=1：如下 - ord=-1：如下 - ord=2：如下 - ord=-2：如下 - 其他：sum(abs(x)**ord)**(1./ord)

返回

矩陣或向量的範數。

範例

>>> x = keras.ops.reshape(keras.ops.arange(9, dtype="float32") - 4, (3, 3))
>>> keras.ops.linalg.norm(x)
7.7459664

[原始碼]

not_equal 函數

keras.ops.not_equal(x1, x2)

傳回 (x1 != x2) 逐元素比較結果。

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

輸出張量，x1 和 x2 的逐元素比較。

[原始碼]

ones 函數

keras.ops.ones(shape, dtype=None)

傳回具有給定形狀和類型的新張量，並填滿 1。

引數

• shape：新張量的形狀。
• dtype：張量所需的資料類型。

返回

具有給定形狀和 dtype 的 ones 張量。

[原始碼]

ones_like 函數

keras.ops.ones_like(x, dtype=None)

傳回與 x 具有相同形狀和類型的 ones 張量。

引數

• x：輸入張量。
• dtype：覆寫結果的資料類型。

返回

與 x 具有相同形狀和類型的 ones 張量。

[原始碼]

outer 函數

keras.ops.outer(x1, x2)

計算兩個向量的外積。

給定兩個向量 x1 和 x2，外積為

out[i, j] = x1[i] * x2[j]

引數

• x1：第一個輸入張量。
• x2：第二個輸入張量。

返回

x1 和 x2 的外積。

[原始碼]

pad 函數

keras.ops.pad(x, pad_width, mode="constant", constant_values=None)

填充張量。

引數

• x：要填充的張量。
• pad_width：填充到每個軸邊緣的值數量。((before_1, after_1), ...(before_N, after_N))，每個軸的唯一填充寬度。((before, after),)，為每個軸產生相同的 before 和 after 填充。(pad,) 或 int 是 before = after = pad 寬度的所有軸的快捷方式。
• mode："constant"、"edge"、"linear_ramp"、"maximum"、"mean"、"median"、"minimum"、"reflect"、"symmetric"、"wrap"、"empty"、"circular" 之一。預設值為 "constant"。
• constant_values：若 mode == "constant"，則用來填充的值。預設值為 0。若非 None 且 mode != "constant"，則會引發 ValueError。

注意：Torch 後端僅支援 "constant"、"reflect"、"symmetric" 和 "circular" 模式。只有 Torch 後端支援 "circular" 模式。

注意：Tensorflow 後端僅支援 "constant"、"reflect" 和 "symmetric" 模式。

返回

已填充的張量。

[原始碼]

power 函數

keras.ops.power(x1, x2)

第一個張量元素的值為第二個張量元素的次方，逐元素計算。

引數

• x1：底數。
• x2：指數。

返回

輸出張量，x1 中的底數為 x2 中指數的次方。

[原始碼]

prod 函數

keras.ops.prod(x, axis=None, keepdims=False, dtype=None)

傳回張量元素在給定軸上的乘積。

引數

• x：輸入張量。
• axis：要沿其執行乘積的軸或軸。預設值 axis=None 將計算輸入張量中所有元素的乘積。
• keepdims：若設為 True，則縮減的軸會保留在結果中，作為大小為 1 的維度。
• dtype：傳回張量的資料類型。

返回

x 的元素在給定軸或軸上的乘積。

[原始碼]

quantile 函數

keras.ops.quantile(x, q, axis=None, method="linear", keepdims=False)

計算沿指定軸的資料的 q 分位數。

引數

• x：輸入張量。
• q：要計算的分位數的機率或機率序列。值必須介於 0 和 1 之間（包含 0 和 1）。
• axis：要沿其計算分位數的軸或軸。預設值為 axis=None，表示沿陣列的展平版本計算分位數。
• method：字串，指定用於估計分位數的方法。可用方法為 "linear"、"lower"、"higher"、"midpoint" 和 "nearest"。預設值為 "linear"。若所需分位數介於兩個資料點 i < j 之間
  • "linear"：i + (j - i) * fraction，其中 fraction 是以 i 和 j 為界的索引的小數部分。
  • "lower"：i。
  • "higher"：j。
  • "midpoint"：(i + j) / 2
  • "nearest"：i 或 j，以最接近者為準。
• keepdims：若設為 True，則縮減的軸會保留在結果中，作為大小為 1 的維度。

返回

分位數。若 q 是單一機率且 axis=None，則結果為純量。若給定多個機率水準，則結果的第一個軸對應於分位數。其他軸是在縮減 x 後剩餘的軸。

[原始碼]

ravel 函數

keras.ops.ravel(x)

傳回連續展平的張量。

傳回 1 維張量，其中包含輸入的元素。

引數

• x：輸入張量。

返回

輸出張量。

[原始碼]

real 函數

keras.ops.real(x)

傳回複數引數的實部。

引數

• x：輸入張量。

返回

複數引數的實數分量。

[原始碼]

reciprocal 函數

keras.ops.reciprocal(x)

傳回引數的倒數，逐元素計算。

計算 1/x。

引數

• x：輸入張量。

返回

輸出張量，x 的逐元素倒數。

[原始碼]

repeat 函數

keras.ops.repeat(x, repeats, axis=None)

在張量的每個元素之後重複元素本身。

引數

• x：輸入張量。
• repeats：每個元素的重複次數。
• axis：要沿其重複值的軸。預設情況下，使用展平的輸入陣列，並傳回展平的輸出陣列。

返回

輸出張量。

[原始碼]

reshape 函數

keras.ops.reshape(x, newshape)

為張量賦予新的形狀，而不會變更其資料。

引數

• x：輸入張量。
• newshape：新形狀應與原始形狀相容。一個形狀維度可以是 -1，在這種情況下，該值會從陣列的長度和剩餘維度推斷出來。

返回

重塑形狀後的張量。

[原始碼]

right_shift 函數

keras.ops.right_shift(x, y)