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，则被归约的轴将在结果中保留为大小为 1 的维度。使用此选项，结果将正确地广播到输入数组。默认为 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 输出一个维度缩减为 1 的张量。

>>> 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，则被归约的轴将在结果中保留为大小为 1 的维度。使用此选项，结果将正确地广播到输入数组。默认为 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 输出一个维度缩减为 1 的张量。

>>> 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: 输入张量。

在弧度 [0, pi] 中，射线与单位圆在给定 x 坐标处相交的角度张量。

示例

>>> 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 中每个元素的反 tangent 张量，在区间 [-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)

反双曲 tangent，逐元素。

参数

x: 输入张量。

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

[源代码]

`argmax` 函数

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

返回沿轴的最大值的索引。

参数

x: 输入张量。
axis: 默认情况下，索引指向展平的张量，否则沿指定的轴。
keepdims: 如果设置为 True，则被归约的轴将在结果中保留为大小为 1 的维度。默认为 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，则被归约的轴将在结果中保留为大小为 1 的维度。默认为 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 将平均输入张量的所有元素。如果轴为负数，则从最后一个轴到第一个轴计数。
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。如果指定，则输出张量中将至少有此数量的 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，使得 i >= x。

参数

x: 输入张量。

x 中每个元素的上限，具有浮点 dtype。

[源代码]

`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: 返回张量的 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 是二维的，则返回 x 的第 k 条对角线。如果 x 是一维的，则返回一个二维张量，其第 k 条对角线上为 x。
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: 要分箱的输入数组。
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)

返回一个二维张量，其对角线上为 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: 覆盖结果的数据类型。

具有 fill_value 的张量，其形状和类型与 x 相同。

[源代码]

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

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

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

参数

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，则被归约的轴将在结果中保留为大小为 1 的维度。默认为 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 个一维张量 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，则被归约的轴将在结果中保留为大小为 1 的维度。默认为 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)

矩阵或向量的范数。

示例

>>> 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 的全 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。如果不是 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)

返回连续的扁平化张量。

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

参数

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 时，插入到输出中的元素。

张量，其中位置 m 的输出是 choicelist 中张量的第 m 个元素，其中 condlist 中相应张量的第 m 个元素为 True。

示例

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 中删除长度为 1 的轴。

参数

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

输入张量，其中删除了全部或部分长度为 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，则缩减的轴将保留在结果中，作为大小为 1 的维度。

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

[源代码]

`subtract` 函数

keras.ops.subtract(x1, x2)

逐元素相减参数。

参数

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

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

[源代码]

`sum` 函数

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

张量在给定轴上的和。

参数

x: 输入张量。
axis：计算和的轴或轴。默认值是计算扁平化张量的和。
keepdims：如果设置为 True，则缩减的轴将保留在结果中，作为大小为 1 的维度。

包含和的输出张量。

[源代码]

`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，则通过向 repeats 前置 1 将其提升为 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)

返回轴已转置的张量。

参数

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

轴已排列的 x。

[源代码]

`tri` 函数

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

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

参数

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

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

[源代码]

`tril` 函数

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

返回张量的下三角。

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

参数

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

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

[源代码]

`triu` 函数

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

返回张量的上三角。

对于 ndim 超过 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 的截断值是最近的整数 i，它比 x 更接近零。简而言之，有符号数 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，则缩减的轴将保留在结果中，作为大小为 1 的维度。

包含方差的输出张量。

[源代码]

`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 假定将标量张量作为输入和输出。

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

[源代码]

`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` 函数