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: 表示执行逻辑与运算的轴的整数或整数元组。默认值（axis=None）是在输入数组的所有维度上执行逻辑与运算。axis 可以为负数，在这种情况下，它从最后一个轴到第一个轴进行计数。
• keepdims: 如果为 True，则将减少的轴保留在结果中，作为大小为一的维度。使用此选项，结果将针对输入数组正确广播。默认为 False。

返回值

包含 axis 上逻辑与运算结果的张量。

示例

>>> 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: 表示执行逻辑或运算的轴的整数或整数元组。默认值（axis=None）是在输入数组的所有维度上执行逻辑或运算。axis 可以为负数，在这种情况下，它从最后一个轴到第一个轴进行计数。
• keepdims: 如果为 True，则将减少的轴保留在结果中，作为大小为一的维度。使用此选项，结果将针对输入数组正确广播。默认为 False。

返回值

包含 axis 上逻辑或运算结果的张量。

示例

>>> 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，则在使用前将两个张量展平。

返回值

包含 x2 附加到 x1 后值的张量。

示例

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

逐元素计算反正弦。

参数

• x: 输入张量。

返回值

x 中每个元素的反正弦的张量，以弧度表示，范围为闭区间 [-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)

逐元素计算反双曲正弦。

参数

• 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 个元素将处于其最终排序位置，所有较小的元素将移动到其前面，所有较大的元素将移动到其后面。分区中所有元素的顺序未定义。如果提供了一个 kth 序列，它将立即将所有这些元素分区到其排序位置。
• 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 将对输入张量的所有元素求平均值。如果 axis 为负数，则从最后一个轴到第一个轴进行计数。
• weights: 与 x 中的值相关的权重张量。x 中的每个值根据其关联权重对平均值做出贡献。权重数组可以是一维的（在这种情况下，其长度必须是沿给定轴的 a 的大小）或与 x 形状相同。如果 weights=None（默认值），则假设 x 中的所有数据权重都等于 1。
• __ 一维计算为 __：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: 输入张量。它必须是一维的，并且只能包含非负整数。
• weights: 权重张量。它必须与 x 具有相同的长度。默认值为 None。如果指定，则 x 将以此为权重，即如果 n = x[i]，则 out[n] += weight[i] 而不是默认行为 out[n] += 1。
• minlength: 整数。默认值为 0。如果指定，则输出张量中至少有这么多箱。如果大于 max(x) + 1，则输出中索引高于 max(x) 的每个值都设置为 0。
• sparse: 是否返回稀疏张量；对于支持稀疏张量的后端。

返回值

一维张量，每个元素表示其索引值在 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)

逐元素计算两个数组的按位与运算。

计算输入数组中整数的底层二进制表示的按位与运算。此 ufunc 实现 C/Python 运算符 &。

参数

• x：输入整数张量。
• y：输入整数张量。

返回值

结果张量。

[源代码]

bitwise_invert 函数

keras.ops.bitwise_invert(x)

逐元素计算按位取反或按位非运算。

计算输入数组中整数的底层二进制表示的按位非运算。此 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)

逐元素计算按位取反或按位非运算。

计算输入数组中整数的底层二进制表示的按位非运算。此 ufunc 实现 C/Python 运算符 ~。

参数

• x：输入整数张量。

返回值

结果张量。

[源代码]

bitwise_or 函数

keras.ops.bitwise_or(x, y)

逐元素计算两个数组的按位或运算。

计算输入数组中整数的底层二进制表示的按位或运算。此 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)

逐元素计算两个数组的按位异或运算。

计算输入数组中整数的底层二进制表示的按位异或运算。此 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 中每个元素的上限，数据类型为浮点型。

[源代码]

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

计算两个一维张量的互相关。

参数

• x1：长度为 M 的第一个一维输入张量。
• x2：长度为 N 的第二个一维输入张量。
• 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)

返回两个（向量数组）的叉积。

x1 和 x2 在 R^3 中的叉积是一个垂直于 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：返回张量的数据类型。默认为 x.dtype。

返回值

输出张量。

[源代码]

cumsum 函数

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

沿给定轴返回元素的累积和。

参数

• x: 输入张量。
• axis：计算累积和的轴。默认情况下，输入会被展平。
• dtype：返回张量的数据类型。默认为 x.dtype。

返回值

输出张量。

[源代码]

diag 函数

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

提取对角线或构造对角线数组。

参数

• x：输入张量。如果 x 是二维的，则返回 x 的第 k 条对角线。如果 x 是一维的，则返回一个二维张量，其中 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 是二维的，则返回 x 具有给定偏移量的对角线，即形式为 x[i, i+offset] 的元素的集合。

如果 x 具有两个以上的维度，则由 axis1 和 axis2 指定的轴用于确定返回其对角线的二维子数组。

结果数组的形状可以通过移除 axis1 和 axis2 并将等于结果对角线大小的索引附加到右侧来确定。

参数

• x: 输入张量。
• offset：对角线相对于主对角线的偏移量。可以是正数或负数。默认为 0（主对角线）。
• axis1：用作二维子数组的第一轴的轴。默认为 0（第一轴）。
• axis2：用作二维子数组的第二轴的轴。默认为 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 中每个值所属的箱的索引。

参数

• x：要进行分箱的输入数组。
• bins：箱数组。它必须是一维的并且单调递增。

返回值

输出索引数组，与 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 都是一维张量，则它是向量的内积（不进行复共轭）。
• 如果 x1 和 x2 都是二维张量，则它是矩阵乘法。
• 如果 x1 或 x2 是零维（标量），则等效于 x1 * x2。
• 如果 x1 是 N 维张量，x2 是一维张量，则它是 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 后端不接受零维张量作为参数。

返回值

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)

返回一个二维张量，对角线上的元素为 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：表示直方图箱数的整数。默认为 10。
• range：表示箱子上下范围的元组。如果未指定，它将使用 x 的最小值和最大值。

返回值

• 包含以下内容的元组：:
• 一个表示每个箱子中元素计数的张量。
• 一个表示箱子边界的张量。

示例

```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.7.0/keras/src/ops/numpy.py#L3049)</span>

### `hstack` function


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

水平（列方向）依次堆叠张量。

对于一维张量，这等效于沿第一个轴连接，对于所有其他张量，则沿第二个轴连接。

参数

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

在指定区间内返回等间距的数字。

返回在区间 [start, stop] 上计算的 num 个等间距样本。

可以可选地排除区间的端点。

参数

• start：序列的起始值。
• stop：序列的结束值，除非 endpoint 设置为 False。在这种情况下，序列由 num + 1 个等间距样本中的所有样本（最后一个样本除外）组成，因此 stop 被排除在外。请注意，当 endpoint 为 False 时，步长会发生变化。
• num：要生成的样本数。默认为 50。必须是非负数。
• endpoint：如果为 True，则 stop 是最后一个样本。否则，它不包括在内。默认为 True。
• retstep：如果为 True，则返回 (samples, step)，其中 step 是样本之间的间距。
• dtype：输出张量的类型。
• axis：结果中存储样本的轴。仅当 start 或 stop 为数组时才相关。默认为 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)

计算给定输入张量的逐元素逻辑与。

零被视为 False，非零被视为 True。

参数

• x1：输入张量。
• x2：输入张量。

返回值

输出张量，输入的逐元素逻辑与。

[源代码]

logical_not 函数

keras.ops.logical_not(x)

计算给定输入张量的逐元素逻辑非。

零被视为 False，非零被视为 True。

参数

• x: 输入张量。

返回值

输出张量，输入的逐元素逻辑非。

[源代码]

logical_or 函数

keras.ops.logical_or(x1, x2)

计算给定输入张量的逐元素逻辑或。

零被视为 False，非零被视为 True。

参数

• x1：输入张量。
• x2：输入张量。

返回值

输出张量，输入的逐元素逻辑或。

[源代码]

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 为数组时才相关。

注意：Torch 后端不支持 axis 参数。

返回值

一个对数刻度上等间距样本的张量。

[源代码]

matmul 函数

keras.ops.matmul(x1, x2)

两个张量的矩阵乘积。

• 如果两个张量都是一维的，则返回点积（标量）。
• 如果任一张量是 N 维的，N > 2，则将其视为位于最后两个索引中的矩阵堆栈并相应地广播。
• 如果第一个张量是一维的，则通过在其维度前添加 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 元组，则指定保存二维矩阵的轴，并计算这些矩阵的矩阵范数。
• 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)

返回值

矩阵或向量(s)的范数。

示例

>>> 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：张量所需的数据类型。

返回值

具有给定形状和数据类型的全 1 张量。

[源代码]

ones_like 函数

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

返回一个与 x 具有相同形状和类型的全 1 张量。

参数

• x: 输入张量。
• dtype: 覆盖结果的数据类型。

返回值

一个与 x 具有相同形状和类型的全 1 张量。

[源代码]

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),) 为每个轴产生相同的填充宽度。(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。如果 mode != "constant" 且不为 None，则会引发 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 个分位数(s)。

参数

• x: 输入张量。
• q: 要计算的分位数的概率或概率序列。值必须在 0 到 1（包括 0 和 1）之间。
• axis: 计算分位数的轴或轴。默认为 axis=None，即沿数组的扁平化版本计算分位数(s)。
• 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 的维度保留在结果中。

返回值

分位数(s)。如果 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)