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 个元素将位于其最终排序位置，所有较小的元素将被移到它之前，所有较大的元素将被移到它之后。划分中所有元素的顺序未定义。如果提供一个 k-th 序列，它将一次将所有这些元素划分到其排序位置。
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 中的所有数据假定权重等于一。
一维计算公式为：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。如果指定，输出张量中将至少包含此数量的 bin。如果大于 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 >= x 的最小整数 i。

参数

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

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

参数

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)

计算 x 中沿给定 axis 的非零值的数量。

如果未指定 axis，则计算张量中的所有非零值。

参数

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 中每个值所属 bin 的索引。

参数

x: 要进行 binning 的输入张量。
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 都是一维张量，则为向量的内积（不进行复共轭）。
如果 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)

返回一个二维张量，对角线上为一，其他位置为零。

参数

N: 输出的行数。
M: 输出的列数。如果为 None，则默认为 N。
k: 对角线的索引：0（默认值）指主对角线，正值指上对角线，负值指下对角线。
dtype: 返回张量的数据类型。

返回值

在第 k 条对角线上为一，其他位置为零的张量。

[源代码]

`flip` 函数

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

沿给定轴反转张量中元素的顺序。

张量的形状得以保留，但元素的顺序会被重新排列。

参数

x: 输入张量。
axis: 沿哪个轴或哪些轴翻转张量。默认值 axis=None 将沿输入张量的所有轴进行翻转。

返回值

沿 axis 的条目被反转的输出张量。

[源代码]

`floor` 函数

keras.ops.floor(x)

返回输入的下限值，逐元素计算。

标量 x 的下限是满足 i <= x 的最大整数 i。

参数

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)

返回一个与给定张量具有相同形状和类型、填充有 fill_value 的张量。

参数

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.10.0/keras/src/ops/numpy.py#L3311)</span>

### `hstack` function


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

按顺序水平（按列）堆叠张量。

对于一维张量，这相当于沿第一个轴进行连接；对于所有其他张量，则相当于沿第二个轴进行连接。

参数

xs: 张量序列。

返回值

通过堆叠给定张量形成的张量。

[源代码]

`identity` 函数

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

返回单位张量。

单位张量是一个方张量，主对角线上为一，其他位置为零。

参数

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 是类数组时才相关。默认为 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)

逐元素返回一加 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，被归约的轴在结果中将保留为大小为一的维度。

返回值

包含平均值的输出张量。

[源代码]

`median` 函数

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

计算沿指定轴的中位数。

参数

x: 输入张量。
axis: 计算中位数的轴或轴的元组。默认为 axis=None，即计算张量的展平版本的中位数。
keepdims: 如果设置为 True，被归约的轴在结果中将保留为大小为一的维度。

返回值

输出张量。

[源代码]

`meshgrid` 函数

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

从坐标向量创建坐标网格。

给定 N 个一维张量 T0, T1, ..., TN-1 作为输入，其对应长度为 S0, S1, ..., SN-1，这将创建 N 个 N 维张量 G0, G1, ..., GN-1，每个张量的形状为 (S0, ..., SN-1)，其中输出 Gi 是通过将 Ti 扩展到结果形状构建的。

参数

x: 表示网格坐标的一维张量。
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: 可选的 float 或 int。用于替换 NaN 条目的值。
posinf: 可选的 float 或 int。用于替换正无穷大的值。
neginf: 可选的 float 或 int。用于替换负无穷大的值。

返回值

已替换非有限值的 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，被归约的轴在结果中将保留为大小为一的维度。

注意：对于 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)

返回一个具有给定形状和类型、填充有一的新张量。

参数

shape: 新张量的形状。
dtype: 所需的张量数据类型。

返回值

具有给定形状和 dtype 的一张量。

[源代码]

`ones_like` 函数

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

返回一个与 x 具有相同形状和类型、填充有一的张量。

参数

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

返回值

与 x 具有相同形状和类型、填充有一的张量。

[源代码]

`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 是所有轴前后填充宽度都等于 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，被归约的轴在结果中将保留为大小为一的维度。
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，被归约的轴在结果中将保留为大小为一的维度。

返回值

分位数。如果 q 是单个概率且 axis=None，则结果是一个标量。如果给定了多个概率级别，结果的第一个轴对应于分位数。其他轴是 x 归约后剩余的轴。

[源代码]

`ravel` 函数

keras.ops.ravel(x)

返回一个连续的展平张量。

返回一个一维张量，包含输入元素的副本。

参数

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)

将整数的位向右移动。

将位向右移动 y 位。由于数字的内部表示采用二进制格式，此操作相当于将 x 除以 2**y。

参数

x: 输入整数张量。
y: 输入整数张量。

返回值

结果张量。

[源代码]

`roll` 函数

keras.ops.roll(x, shift, axis=None)

沿给定轴滚动张量元素。

滚动超出最后一个位置的元素将重新出现在第一个位置。

参数

x: 输入张量。
shift: 元素移动的位数。
axis: 元素移动的轴。默认情况下，在移动之前将张量展平，之后恢复原始形状。

返回值

输出张量。

[源代码]

`round` 函数

keras.ops.round(x, decimals=0)

按给定的小数位数进行四舍五入。

参数

x: 输入张量。
decimals: 四舍五入的小数位数。默认为 0。

返回值

输出张量。

[源代码]

`searchsorted` 函数

keras.ops.searchsorted(sorted_sequence, values, side="left")

执行二分查找，返回将 values 插入 sorted_sequence 中以保持排序顺序的索引。

参数

sorted_sequence: 一维输入张量，沿最内层维度排序。
values: 用于查询插入值的 N 维张量。
side: 'left' 或 'right'，指定在相等情况（打破平局）下的插入方向。

返回值

与 values 形状相同的插入索引张量。

[源代码]

`select` 函数

keras.ops.select(condlist, choicelist, default=0)

根据 condlist 中的条件，从 choicelist 中返回元素。

参数

condlist: 布尔张量列表。决定从 choicelist 中的哪个张量中获取输出元素的条件列表。当满足多个条件时，使用在 condlist 中首先遇到的条件。
choicelist: 张量列表。从中获取输出元素的张量列表。此列表必须与 condlist 具有相同的长度。
defaults: 可选标量值。当所有条件都评估为 False 时插入到输出中的元素。

返回值

张量，其中在 condlist 中的条件评估为 True 的第一个位置，取自 choicelist 中对应位置的张量元素。

示例

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

[源代码]

`sign` 函数

keras.ops.sign(x)

返回一个包含 x 中元素符号的张量。

参数

x: 输入张量。

返回值

与 x 具有相同形状的输出张量。

[源代码]

`sin` 函数

keras.ops.sin(x)

三角正弦，逐元素计算。

参数

x: 输入张量。

返回值

与 x 具有相同形状的输出张量。

[源代码]

`sinh` 函数

keras.ops.sinh(x)

双曲正弦，逐元素计算。

参数

x: 输入张量。

返回值

与 x 具有相同形状的输出张量。

[源代码]

`size` 函数

keras.ops.size(x)

返回张量中的元素数量。

参数

x: 输入张量。

返回值

x 中的元素数量。

[源代码]

`slogdet` 函数

keras.ops.slogdet(x)

计算矩阵行列式的符号和自然对数。

参数

x: 输入矩阵。它必须是二维的且是方阵。

返回值

一个元组 (sign, logabsdet)。sign 是一个表示行列式符号的数字。对于实矩阵，它是 1、0 或 -1。对于复矩阵，它是一个绝对值为 1 的复数（即位于单位圆上），或者为 0。logabsdet 是行列式绝对值的自然对数。

[源代码]

`sort` 函数

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

沿给定轴按升序对 x 的元素进行排序。

参数

x: 输入张量。
axis: 沿哪个轴排序。如果为 None，则在排序前将张量展平。默认为 -1，即最后一个轴。

返回值

排序后的张量。

[源代码]

`split` 函数

keras.ops.split(x, indices_or_sections, axis=0)

将张量分割成块。

参数

x: 输入张量。
indices_or_sections: 如果是整数 N，则张量将沿 axis 被分割成 N 个相等的部分。如果是一个包含已排序整数的一维张量，则其中的条目表示沿 axis 分割张量的索引。
axis: 沿哪个轴分割。默认为 0。

注意：使用 Torch 后端时，分割不一定导致相等的部分。

返回值

张量列表。

[源代码]

`sqrt` 函数

keras.ops.sqrt(x)

逐元素返回张量的非负平方根。

参数

x: 输入张量。

返回值

输出张量，x 的非负平方根。

[源代码]

`square` 函数

keras.ops.square(x)

返回输入的逐元素平方。

参数

x: 输入张量。

返回值

输出张量，x 的平方。

[源代码]

`squeeze` 函数

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

从 x 中移除长度为一的轴。

参数

x: 输入张量。
axis: 选择形状中长度为一的条目的子集。

返回值

移除了所有或一部分长度为 1 的维度的输入张量。

[源代码]

`stack` 函数

keras.ops.stack(x, axis=0)

沿新轴连接一系列张量。

axis 参数指定结果维度中新轴的索引。

参数

x: 张量序列。
axis: 沿哪个轴堆叠。默认为 0。

返回值

堆叠后的张量。

[源代码]

`std` 函数

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

计算沿指定轴的标准差。

参数

x: 输入张量。
axis: 计算标准差的轴。默认是计算展平张量的标准差。
keepdims: 如果设置为 True，被归约的轴在结果中将保留为大小为一的维度。

返回值

包含标准差值的输出张量。

[源代码]

`subtract` 函数

keras.ops.subtract(x1, x2)

对参数进行逐元素相减。

参数

x1: 第一个输入张量。
x2: 第二个输入张量。

返回值

输出张量，x1 和 x2 的逐元素差。

[源代码]

`sum` 函数

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

张量沿给定轴的求和。

参数

x: 输入张量。
axis: 计算求和的轴或轴的元组。默认是计算展平张量的求和。
keepdims: 如果设置为 True，被归约的轴在结果中将保留为大小为一的维度。

返回值

包含求和结果的输出张量。

[源代码]

`swapaxes` 函数

keras.ops.swapaxes(x, axis1, axis2)

交换张量的两个轴。

参数

x: 输入张量。
axis1: 第一个轴。
axis2: 第二个轴。

返回值

轴已交换的张量。

[源代码]

`take` 函数

keras.ops.take(x, indices, axis=None)

沿轴从张量中取出元素。

参数

x: 源张量。
indices: 要提取值的索引。
axis: 选择值的轴。默认情况下，使用展平的输入张量。

返回值

相应的值张量。

[源代码]

`take_along_axis` 函数

keras.ops.take_along_axis(x, indices, axis=None)

沿给定轴从 x 中选择一维 indices 处的元素。

参数

x: 源张量。
indices: 要提取值的索引。
axis: 选择值的轴。默认情况下，使用展平的输入张量。

返回值

相应的值张量。

[源代码]

`tan` 函数

keras.ops.tan(x)

计算正切，逐元素计算。

参数

x: 输入张量。

返回值

与 x 具有相同形状的输出张量。

[源代码]

`tanh` 函数

keras.ops.tanh(x)

双曲正切，逐元素计算。

参数

x: 输入张量。

返回值

与 x 具有相同形状的输出张量。

[源代码]

`tensordot` 函数

keras.ops.tensordot(x1, x2, axes=2)

计算沿指定轴的张量点积。

参数

x1: 第一个张量。
x2: 第二个张量。
axes: - 如果是整数 N，则依次对 x1 的最后 N 个轴和 x2 的前 N 个轴求和。对应轴的大小必须匹配。- 或者，要进行求和的轴列表，第一个序列应用于 x1，第二个应用于 x2。两个序列必须具有相同的长度。

返回值

输入张量的点积。

[源代码]

`tile` 函数

keras.ops.tile(x, repeats)

将 x 重复 repeats 次。

如果 repeats 的长度为 d，结果的维度将为 max(d, x.ndim)。

如果 x.ndim < d，则通过在其前面添加新轴将 x 提升为 d 维。

如果 x.ndim > d，则通过在其前面添加 1 将 repeats 提升到 x.ndim。

参数

x: 输入张量。
repeats: 沿每个轴重复 x 的次数。

返回值

平铺后的输出张量。

[源代码]

`trace` 函数

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

返回张量沿对角线的求和。

如果 x 是二维的，则返回沿具有给定偏移量的其对角线的求和，即所有 i 的元素 x[i, i+offset] 的总和。

如果 a 的维度超过二维，则使用由 axis1 和 axis2 指定的轴来确定返回其迹的二维子张量。

结果张量的形状与移除了 axis1 和 axis2 的 x 相同。

参数

x: 输入张量。
offset: 对角线与主对角线的偏移量。可以是正数或负数。默认为 0。
axis1: 用作二维子张量的第一个轴的轴。默认为 0（第一个轴）。
axis2: 用作二维子张量的第二个轴的轴。默认为 1（第二个轴）。

返回值

如果 x 是二维的，则返回对角线的总和。如果 x 的维度更大，则返回沿对角线的求和张量。

[源代码]

`transpose` 函数

keras.ops.transpose(x, axes=None)

返回一个 axes 转置后的张量。

参数

x: 输入张量。
axes: 整数序列。x 维度的排列。默认情况下，轴的顺序会被反转。

返回值

轴已置换的 x 张量。

[源代码]

`tri` 函数

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

返回一个张量，在对角线及其下方为一，其他位置为零。

参数

N: 张量的行数。
M: 张量的列数。
k: 填充一的子对角线位置及其下方。k = 0 是主对角线，而 k < 0 在其下方，k > 0 在其上方。默认为 0。
dtype: 返回张量的数据类型。默认为 "float32"。

返回值

左下三角填充为一，其他位置为零的张量。对于 j <= i + k，T[i, j] == 1，否则为 0。

[源代码]

`tril` 函数

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

返回张量的左下三角。

对于维度超过 2 的张量，tril 将应用于最后两个轴。

参数

x: 输入张量。
k: 将元素归零的对角线位置及其上方。默认为 0（主对角线）。k < 0 在其下方，k > 0 在其上方。

返回值

x 的左下三角，形状和数据类型与 x 相同。

[源代码]

`triu` 函数

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

返回张量的右上三角。

对于维度超过 2 的张量，triu 将应用于最后两个轴。

参数

x: 输入张量。
k: 将元素归零的对角线位置及其下方。默认为 0（主对角线）。k < 0 在其下方，k > 0 在其上方。

返回值

x 的右上三角，形状和数据类型与 x 相同。

[源代码]

`true_divide` 函数

keras.ops.true_divide(x1, x2)

keras.ops.divide 的别名。

[源代码]

`trunc` 函数

keras.ops.trunc(x)

逐元素返回输入的截断值。

标量 x 的截断值是离零比 x 更近的最近整数 i。简而言之，有符号数 x 的小数部分被丢弃。

参数

x: 输入张量。

返回值

x 中每个元素的截断值。

示例

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

[源代码]

`var` 函数

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

计算沿指定轴的方差。

参数

x: 输入张量。
axis: 计算方差的轴或轴的元组。默认是计算展平张量的方差。
keepdims: 如果设置为 True，被归约的轴在结果中将保留为大小为一的维度。

返回值

包含方差的输出张量。

[源代码]

`vdot` 函数

keras.ops.vdot(x1, x2)

返回两个向量的点积。

如果第一个参数是复数，则使用第一个参数的复共轭来计算点积。

在计算点积之前，会将多维张量展平。

参数

x1: 第一个输入张量。如果是复数，在计算点积之前会取其复共轭。
x2: 第二个输入张量。

返回值

输出张量。

[源代码]

`vectorize` 函数

keras.ops.vectorize(pyfunc, excluded=None, signature=None)

将函数转换为向量化函数。

示例

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

参数

pyfunc: 接受单个张量参数的可调用对象。
excluded: 可选的整数集合，表示函数不会向量化的位置参数。这些参数将直接传递给 pyfunc 而不进行修改。
signature: 可选的通用函数签名，例如，用于向量化矩阵-向量乘法的 "(m,n),(n)->(m)"。如果提供，pyfunc 将使用核心维度大小给出的形状张量进行调用（并期望返回）。默认情况下，假定 pyfunc 接受标量张量作为输入和输出。

返回值

一个新函数，它沿轴 0（批处理轴）将 pyfunc 应用于其输入的每个元素。

[源代码]

`vstack` 函数

keras.ops.vstack(xs)

按顺序垂直（按行）堆叠张量。

参数

xs: 张量序列。

返回值

通过堆叠给定张量形成的张量。

[源代码]

`where` 函数

keras.ops.where(condition, x1=None, x2=None)

根据 condition 从 x1 或 x2 中选择元素并返回。

参数

condition: 如果为 True，则取 x1；否则，取 x2。
x1: 当 condition 为 True 时选择的值来源。
x2: 当 condition 为 False 时选择的值来源。

返回值

一个张量，其中 condition 为 True 的位置取自 x1，condition 为 False 的位置取自 x2。

[源代码]

`zeros` 函数

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

返回一个具有给定形状和类型、填充有零的新张量。

参数

shape: 新张量的形状。
dtype: 所需的张量数据类型。

返回值

具有给定形状和 dtype 的零张量。

[源代码]

`zeros_like` 函数

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

返回一个与 x 具有相同形状和类型、填充有零的张量。

参数

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

返回值

与 x 具有相同形状和类型、填充有零的张量。

NumPy 运算

absolute 函数

add 函数

all 函数

amax 函数

amin 函数

any 函数

append 函数

arange 函数

arccos 函数

arccosh 函数

arcsin 函数

arcsinh 函数

arctan 函数

arctan2 函数

arctanh 函数

argmax 函数

argmin 函数

argpartition 函数

argsort 函数

array 函数

average 函数

bincount 函数

bitwise_and 函数

bitwise_invert 函数

bitwise_left_shift 函数

bitwise_not 函数

bitwise_or 函数

bitwise_right_shift 函数

bitwise_xor 函数

broadcast_to 函数

ceil 函数

clip 函数

concatenate 函数

conj 函数

conjugate 函数

copy 函数

correlate 函数

cos 函数

cosh 函数

count_nonzero 函数

cross 函数

cumprod 函数

cumsum 函数

diag 函数

diagonal 函数

diff 函数

digitize 函数

divide 函数

divide_no_nan 函数

dot 函数

einsum 函数

empty 函数

equal 函数

exp 函数

expand_dims 函数

expm1 函数

eye 函数

flip 函数

floor 函数

floor_divide 函数

full 函数

full_like 函数

get_item 函数

greater 函数

greater_equal 函数

histogram 函数

hstack 函数

identity 函数

imag 函数

isclose 函数

isfinite 函数

isinf 函数

isnan 函数

left_shift 函数

less 函数

less_equal 函数

linspace 函数

log 函数

log10 函数

log1p 函数

log2 函数

logaddexp 函数

logical_and 函数

logical_not 函数

logical_or 函数

logical_xor 函数

logspace 函数

matmul 函数

max 函数

maximum 函数

mean 函数

median 函数

meshgrid 函数

min 函数

minimum 函数

mod 函数

moveaxis 函数

multiply 函数

nan_to_num 函数

ndim 函数

negative 函数

nonzero 函数

norm 函数

not_equal 函数

ones 函数

ones_like 函数

outer 函数

pad 函数

power 函数

prod 函数

quantile 函数

ravel 函数

real 函数

reciprocal 函数

repeat 函数

reshape 函数

right_shift 函数

roll 函数

round 函数

searchsorted 函数

select 函数

sign 函数

sin 函数

sinh 函数

size 函数

slogdet 函数

sort 函数

split 函数

sqrt 函数

square 函数

squeeze 函数

stack 函数

std 函数

subtract 函数

sum 函数

swapaxes 函数

take 函数

take_along_axis 函数

tan 函数

tanh 函数

tensordot 函数

tile 函数

trace 函数

transpose 函数

tri 函数

tril 函数

triu 函数

true_divide 函数

trunc 函数

var 函数

vdot 函数

vectorize 函数

vstack 函数

where 函数

zeros 函数

zeros_like 函数

NumPy 运算

absolute 函数

add 函数

all 函数

amax 函数

amin 函数

any 函数

append 函数

arange 函数

arccos 函数

arccosh 函数

arcsin 函数

arcsinh 函数

arctan 函数

arctan2 函数

arctanh 函数

argmax 函数

argmin 函数

argpartition 函数

argsort 函数

array 函数

average 函数

bincount 函数

bitwise_and 函数

bitwise_invert 函数

bitwise_left_shift 函数

bitwise_not 函数

bitwise_or 函数

bitwise_right_shift 函数

bitwise_xor 函数

broadcast_to 函数

ceil 函数

clip 函数

concatenate 函数

conj 函数

conjugate 函数

copy 函数

correlate 函数

cos 函数

cosh 函数

count_nonzero 函数

cross 函数

cumprod 函数

cumsum 函数

diag 函数

diagonal 函数

diff 函数

digitize 函数

divide 函数

divide_no_nan 函数

dot 函数

einsum 函数

empty 函数

equal 函数

exp 函数

expand_dims 函数

expm1 函数

eye 函数

flip 函数

floor 函数

floor_divide 函数

full 函数

full_like 函数

get_item 函数

greater 函数

greater_equal 函数

histogram 函数

identity 函数

imag 函数

isclose 函数

isfinite 函数

isinf 函数

isnan 函数

left_shift 函数

less 函数

less_equal 函数

linspace 函数

log 函数

log10 函数

log1p 函数

`absolute` 函数

`add` 函数

`all` 函数

`amax` 函数

`amin` 函数

`any` 函数

`append` 函数

`arange` 函数

`arccos` 函数

`arccosh` 函数

`arcsin` 函数

`arcsinh` 函数

`arctan` 函数

`arctan2` 函数

`arctanh` 函数

`argmax` 函数

`argmin` 函数

`argpartition` 函数

`argsort` 函数

`array` 函数

`average` 函数

`bincount` 函数

`bitwise_and` 函数

`bitwise_invert` 函数

`bitwise_left_shift` 函数

`bitwise_not` 函数

`bitwise_or` 函数

`bitwise_right_shift` 函数

`bitwise_xor` 函数

`broadcast_to` 函数

`ceil` 函数

`clip` 函数

`concatenate` 函数

`conj` 函数

`conjugate` 函数

`copy` 函数

`correlate` 函数

`cos` 函数

`cosh` 函数

`count_nonzero` 函数

`cross` 函数

`cumprod` 函数

`cumsum` 函数

`diag` 函数

`diagonal` 函数

`diff` 函数

`digitize` 函数

`divide` 函数

`divide_no_nan` 函数

`dot` 函数

`einsum` 函数

`empty` 函数

`equal` 函数

`exp` 函数

`expand_dims` 函数

`expm1` 函数

`eye` 函数

`flip` 函数

`floor` 函数

`floor_divide` 函数

`full` 函数

`full_like` 函数

`get_item` 函数

`greater` 函数

`greater_equal` 函数

`histogram` 函数

`identity` 函数

`imag` 函数

`isclose` 函数

`isfinite` 函数

`isinf` 函数

`isnan` 函数

`left_shift` 函数

`less` 函数

`less_equal` 函数

`linspace` 函数

`log` 函数

`log10` 函数

`log1p` 函数

`log2` 函数