abs 函数keras.ops.abs(x)
keras.ops.absolute 的简写。
absolute 函数keras.ops.absolute(x)
按元素计算绝对值。
keras.ops.abs 是此函数的简写。
参数
返回
一个包含 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 = 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。
参数
axis=None) 是在输入数组的所有维度上执行逻辑与。axis 可以为负数，在这种情况下，它从最后一个轴到第一个轴计数。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)
返回数组的最大值或沿某个轴的最大值。
参数
axis=None)，在输入数组的所有维度中查找最大值。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)
返回数组的最小值或沿某个轴的最小值。
参数
axis=None)，在输入数组的所有维度中查找最小值。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)
angle 函数keras.ops.angle(x)
复数张量的逐元素角度。
参数
返回
与 x 形状相同的输出张量，包含每个元素的角度（以弧度为单位）。
示例
>>> x = keras.ops.convert_to_tensor([[1 + 3j, 2 - 5j], [4 - 3j, 3 + 2j]])
>>> keras.ops.angle(x)
array([[ 1.2490457, -1.19029 ],
[-0.6435011, 0.5880026]], dtype=float32)
any 函数keras.ops.any(x, axis=None, keepdims=False)
测试沿给定轴的任何数组元素是否计算为 True。
参数
axis=None) 是对输入数组的所有维度执行逻辑或。axis 可以为负数，在这种情况下，它从最后一个轴到第一个轴计数。True，则被归约的轴将作为大小为 1 的维度保留在结果中。使用此选项，结果将正确地广播到输入数组。默认为 False。返回
包含沿 axis 的逻辑或 (OR) 归约结果的张量。
示例
>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.any(x)
array(True, shape=(), dtype=bool)
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.any(x, axis=0)
array([ True True], shape=(2,), dtype=bool)
keepdims=True 输出一个维度被归约为 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 的末尾。
参数
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) 内生成值（换句话说，该区间包括 start 但不包括 stop）。* arange(start, stop)：在半开区间 [start, stop) 内生成值。* arange(start, stop, step)：在半开区间 [start, stop) 内生成值，值之间的间距由 step 给出。
参数
step 不是整数且浮点舍入会影响 out 的长度。默认为 None。out，这是两个相邻值之间的距离，即 out[i+1] - out[i]。默认步长为 1。如果将 step 指定为位置参数，则还必须给定 start。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 = 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 = keras.ops.convert_to_tensor([10, 100])
>>> keras.ops.arccosh(x)
array([2.993223, 5.298292], dtype=float32)
arcsin 函数keras.ops.arcsin(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 = 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 中每个元素的反正切张量，在区间 [-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 的情况都已定义。
参数
返回
角度张量，以弧度为单位，范围在 [-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)
请注意参数的顺序。当 x2=0 以及在其他几个点上时，arctan2 也被定义，得到的值在 [-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 形状相同的输出张量。
argmax 函数keras.ops.argmax(x, axis=None, keepdims=False)
返回沿某一轴的最大值的索引。
参数
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)
返回沿某个轴的最小值的索引。
参数
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 形状相同的索引数组，该数组按分区顺序沿给定轴索引数据。
参数
None，则使用展平的数组。返回
一个索引数组，它沿着指定的 axis 对 x 进行分区。
argsort 函数keras.ops.argsort(x, axis=-1)
返回对张量进行排序的索引。
参数
-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)
创建一个张量。
参数
返回
一个张量。
示例
>>> 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=None 将对输入张量的所有元素求平均值。如果 axis 为负数，则从最后一个轴到第一个轴计数。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.
bartlett 函数keras.ops.bartlett(x)
巴特利特窗函数。巴特利特窗是一个三角窗，先线性上升，然后线性下降。
参数
返回
一个包含巴特利特窗值的一维张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.bartlett(x)
array([0. , 0.5, 1. , 0.5, 0. ], dtype=float32)
bincount 函数keras.ops.bincount(x, weights=None, minlength=0, sparse=False)
计算整数张量中每个值出现的次数。
参数
x 相同。默认值为 None。如果指定，x 将按其加权，即如果 n = x[i]，则 out[n] += weight[i]，而不是默认行为 out[n] += 1。max(x) + 1，则输出中索引高于 max(x) 的每个值都设置为 0。返回
一维张量，其中每个元素给出其索引值在 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 运算符 &。
参数
返回
结果张量。
bitwise_invert 函数keras.ops.bitwise_invert(x)
按元素计算按位反转或按位非。
计算输入数组中整数的底层二进制表示的按位非 (NOT)。此 ufunc 实现了 C/Python 运算符 ~。
参数
返回
结果张量。
bitwise_left_shift 函数keras.ops.bitwise_left_shift(x, y)
将整数的位向左移动。
通过在 x 的右侧附加 y 个 0 来将位向左移动。由于数字的内部表示是二进制格式，因此此操作等效于将 x 乘以 2**y。
参数
返回
结果张量。
bitwise_not 函数keras.ops.bitwise_not(x)
按元素计算按位反转或按位非。
计算输入数组中整数的底层二进制表示的按位非 (NOT)。此 ufunc 实现了 C/Python 运算符 ~。
参数
返回
结果张量。
bitwise_or 函数keras.ops.bitwise_or(x, y)
按元素计算两个数组的按位或。
计算输入数组中整数的底层二进制表示的按位或。此 ufunc 实现了 C/Python 运算符 |。
参数
返回
结果张量。
bitwise_right_shift 函数keras.ops.bitwise_right_shift(x, y)
将整数的位向右移动。
位向右移动 y。由于数字的内部表示是二进制格式，此操作等效于将 x 除以 2**y。
参数
返回
结果张量。
bitwise_xor 函数keras.ops.bitwise_xor(x, y)
按元素计算两个数组的按位异或。
计算输入数组中整数的底层二进制表示的按位异或 (XOR)。此 ufunc 实现了 C/Python 运算符 ^。
参数
返回
结果张量。
blackman 函数keras.ops.blackman(x)
布莱克曼窗函数。布莱克曼窗是使用加权余弦形成的锥形窗。
参数
返回
一个包含布莱克曼窗值的一维张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.blackman(x)
array([-1.3877788e-17, 3.4000000e-01, 1.0000000e+00, 3.4000000e-01,
-1.3877788e-17], dtype=float32)
broadcast_to 函数keras.ops.broadcast_to(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]])
cbrt 函数keras.ops.cbrt(x)
逐元素计算输入张量的立方根。
此操作返回 x 的实值立方根，在实数域中正确处理负数。
参数
返回
一个包含 x 中每个元素立方根的张量。
ceil 函数keras.ops.ceil(x)
逐元素返回输入的上取整。
标量 x 的上取整是最小的整数 i，使得 i >= x。
参数
返回
x 中每个元素的上取整，数据类型为浮点数。
clip 函数keras.ops.clip(x, x_min, x_max)
裁剪（限制）张量中的值。
给定一个区间，区间外的值被裁剪到区间的边缘。例如，如果指定了 [0, 1] 的区间，小于 0 的值将变为 0，大于 1 的值将变为 1。
参数
返回
裁剪后的张量。
concatenate 函数keras.ops.concatenate(xs, axis=0)
沿现有轴连接一系列张量。
参数
0。返回
连接后的张量。
conj 函数keras.ops.conj(x)
keras.ops.conjugate 的简写。
conjugate 函数keras.ops.conjugate(x)
逐元素返回复共轭。
复数的复共轭是通过改变其虚部的符号得到的。
keras.ops.conj 是此函数的简写。
参数
返回
x 中每个元素的复共轭。
copy 函数keras.ops.copy(x)
返回 x 的一个副本。
参数
返回
x 的一个副本。
correlate 函数keras.ops.correlate(x1, x2, mode="valid")
计算两个一维张量的互相关。
参数
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)
逐元素计算余弦。
参数
返回
相应的余弦值。
cosh 函数keras.ops.cosh(x)
逐元素计算双曲余弦。
参数
返回
与 x 形状相同的输出张量。
count_nonzero 函数keras.ops.count_nonzero(x, axis=None)
沿给定 axis 计算 x 中非零值的数量。
如果未指定轴，则计算张量中所有非零值的数量。
参数
None。返回
整数或整数张量。
示例
>>> x = keras.ops.array([[0, 1, 7, 0], [3, 0, 2, 19]])
>>> keras.ops.count_nonzero(x)
5
>>> keras.ops.count_nonzero(x, axis=0)
array([1, 1, 2, 1], dtype=int64)
>>> keras.ops.count_nonzero(x, axis=1)
array([2, 3], dtype=int64)
cross 函数keras.ops.cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None)
返回两个（向量数组的）向量的叉积。
R^3 中 x1 和 x2 的叉积是一个同时垂直于 x1 和 x2 的向量。如果 x1 和 x2 是向量数组，则向量默认由 x1 和 x2 的最后一个轴定义，并且这些轴的维度可以是 2 或 3。
当 x1 或 x2 的维度为 2 时，输入向量的第三个分量假定为零，并相应地计算叉积。
在两个输入向量维度均为 2 的情况下，返回叉积的 z 分量。
参数
x1 的轴。默认为 -1。x2 的轴。默认为 -1。x1、x2 和结果的轴。覆盖 axisa、axisb 和 axisc。注意：Torch 后端不支持二维向量，也不支持参数 axisa、axisb 和 axisc。请改用 axis。
返回
向量叉积。
cumprod 函数keras.ops.cumprod(x, axis=None, dtype=None)
返回沿给定轴的元素的累积乘积。
参数
返回
输出张量。
cumsum 函数keras.ops.cumsum(x, axis=None, dtype=None)
返回沿给定轴的元素的累积和。
参数
返回
输出张量。
deg2rad 函数keras.ops.deg2rad(x)
将角度从度转换为弧度。
转换定义为：rad = deg * (π / 180)
参数
返回
一个包含转换为弧度的角度的张量。
示例
>>> from keras import ops
>>> ops.deg2rad(180.0)
3.141592653589793
>>> ops.deg2rad([0.0, 90.0, 180.0])
array([0., 1.57079633, 3.14159265])
diag 函数keras.ops.diag(x, k=0)
提取对角线或构建对角线数组。
参数
x 是二维的，则返回 x 的第 k 条对角线。如果 x 是一维的，则返回一个二维张量，其中 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]])
diagflat 函数keras.ops.diagflat(x, k=0)
创建一个二维数组，将展平的输入放在第 k 条对角线上。
参数
0。对于主对角线上方的对角线，使用 k > 0；对于主对角线下方的对角线，使用 k < 0。返回
一个二维张量，其指定对角线上为展平的输入。
diagonal 函数keras.ops.diagonal(x, offset=0, axis1=0, axis2=1)
返回指定的对角线。
如果 x 是二维的，则返回具有给定偏移量的 x 的对角线，即形式为 x[i, i+offset] 的元素集合。
如果 x 有两个以上的维度，则使用由 axis1 和 axis2 指定的轴来确定返回其对角线的二维子数组。
可以通过移除 axis1 和 axis2 并在右侧附加一个等于结果对角线大小的索引来确定结果数组的形状。
参数
0（主对角线）。0（第一个轴）。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 计算。
参数
1。-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 形状相同。
示例
>>> 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 的商，逐元素计算。
divide_no_nan 函数keras.ops.divide_no_nan(x1, x2)
安全的逐元素除法，在分母为 0 时返回 0。
参数
返回
商 x1/x2，逐元素计算，当 x2 为零时为零。
dot 函数keras.ops.dot(x1, x2)
两个张量的点积。
x1 和 x2 都是一维张量，则为向量的内积（无复共轭）。x1 和 x2 都是二维张量，则是矩阵乘法。x1 或 x2 是 0-D（标量），则它等效于 x1 * x2。x1 是 N-D 张量，而 x2 是 1-D 张量，则它是对 x1 和 x2 的最后一个轴的求和积。x1 是一个 N-D 张量，x2 是一个 M-D 张量（其中 M>=2），则它是对 x1 的最后一个轴和 x2 的倒数第二个轴的求和积：dot(x1, x2)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。参数
注意：Torch 后端不接受 0-D 张量作为参数。
返回
x1 和 x2 的点积。
einsum 函数keras.ops.einsum(subscripts, *operands, **kwargs)
对操作数计算爱因斯坦求和约定。
参数
-> 以及精确输出形式的下标标签，否则将执行隐式（经典爱因斯坦求和）计算。返回
基于爱因斯坦求和约定的计算。
示例
>>> 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)
返回一个给定形状和类型的张量，其中填充了未初始化的数据。
参数
返回
空张量。
equal 函数keras.ops.equal(x1, x2)
逐元素返回 (x1 == x2)。
参数
返回
输出张量，x1 和 x2 的逐元素比较。
exp 函数keras.ops.exp(x)
计算输入张量中所有元素的指数。
参数
返回
输出张量，x 的逐元素指数。
exp2 函数keras.ops.exp2(x)
计算输入张量中所有元素的以 2 为底的指数。
参数
返回
输出张量，x 的逐元素以 2 为底的指数。
expand_dims 函数keras.ops.expand_dims(x, axis)
扩展张量的形状。
在扩展张量形状的 axis 位置插入一个新轴。
参数
返回
维度增加后的输出张量。
expm1 函数keras.ops.expm1(x)
为张量中的所有元素计算 exp(x) - 1。
参数
返回
输出张量，逐元素指数减一。
eye 函数keras.ops.eye(N, M=None, k=0, dtype=None)
返回一个对角线上为 1，其他地方为 0 的二维张量。
参数
None，则默认为 N。返回
一个在第 k 条对角线上为 1，其他地方为 0 的张量。
flip 函数keras.ops.flip(x, axis=None)
沿给定轴反转张量中元素的顺序。
张量的形状保持不变，但元素重新排序。
参数
axis=None 将翻转输入张量的所有轴。返回
axis 的条目被反转的输出张量。
floor 函数keras.ops.floor(x)
逐元素返回输入的下取整。
标量 x 的下取整是最大的整数 i，使得 i <= x。
参数
返回
输出张量，x 的逐元素下取整。
floor_divide 函数keras.ops.floor_divide(x1, x2)
返回小于或等于输入除法结果的最大整数。
参数
返回
输出张量，y = floor(x1/x2)
full 函数keras.ops.full(shape, fill_value, dtype=None)
返回一个给定形状和类型的新张量，用 fill_value 填充。
参数
返回
输出张量。
full_like 函数keras.ops.full_like(x, fill_value, dtype=None)
返回一个与给定张量具有相同形状和类型的完整张量。
参数
返回
与 x 具有相同形状和类型的 fill_value 张量。
get_item 函数keras.ops.get_item(x, key)
返回 x[key]。
greater 函数keras.ops.greater(x1, x2)
逐元素返回 x1 > x2 的真值。
参数
返回
输出张量，x1 和 x2 的逐元素比较。
greater_equal 函数keras.ops.greater_equal(x1, x2)
逐元素返回 x1 >= x2 的真值。
参数
返回
输出张量，x1 和 x2 的逐元素比较。
hamming 函数keras.ops.hamming(x)
汉明窗函数。
汉明窗定义为：w[n] = 0.54 - 0.46 * cos(2 * pi * n / (N - 1))，其中 0 <= n <= N - 1。
参数
返回
一个包含汉明窗值的一维张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.hamming(x)
array([0.08, 0.54, 1. , 0.54, 0.08], dtype=float32)
hanning 函数keras.ops.hanning(x)
汉宁窗函数。
汉宁窗定义为：w[n] = 0.5 - 0.5 * cos(2 * pi * n / (N - 1))，其中 0 <= n <= N - 1。
参数
返回
一个包含汉宁窗值的一维张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.hanning(x)
array([0. , 0.5, 1. , 0.5, 0. ], dtype=float32)
histogram 函数keras.ops.histogram(x, bins=10, range=None)
计算数据张量 x 的直方图。
参数
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.11.0/keras/src/ops/numpy.py#L3499)</span>
### `hstack` function
```python
keras.ops.hstack(xs)
按水平（列方式）顺序堆叠张量。
这相当于沿第一个轴对一维张量进行连接，以及沿第二个轴对所有其他张量进行连接。
参数
返回
通过堆叠给定张量形成的张量。
identity 函数keras.ops.identity(n, dtype=None)
返回单位张量。
单位张量是一个方阵，主对角线上为 1，其他位置为 0。
参数
n x n 输出张量中的行数（和列数）。返回
单位张量。
imag 函数keras.ops.imag(x)
返回复数参数的虚部。
参数
返回
复数参数的虚部。
inner 函数keras.ops.inner(x1, x2)
返回两个张量的内积。
一维张量的普通向量内积（无复共轭），在更高维度上是最后一个轴上的求和积。
多维数组通过展平除最后一个轴外的所有轴被视为向量。得到的点积是在它们的最后一个轴上执行的。
参数
x1 和 x2 的最后一个维度必须匹配。返回
输出张量。输出的形状由移除 x1 和 x2 的最后一个轴后广播它们的形状确定。
isclose 函数keras.ops.isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False)
返回两个张量是否逐元素几乎相等。
参数
True，则逐元素的 NaN 被视为相等。返回
输出布尔张量。
isfinite 函数keras.ops.isfinite(x)
逐元素返回一个张量是否是有限的。
当实数值不是 NaN、不是正无穷大、也不是负无穷大时，它们是有限的。当复数值的实部和虚部都是有限的时，它们是有限的。
参数
返回
输出布尔张量。
isinf 函数keras.ops.isinf(x)
逐元素测试正无穷大或负无穷大。
参数
返回
输出布尔张量。
isnan 函数keras.ops.isnan(x)
逐元素测试 NaN 并以布尔张量形式返回结果。
参数
返回
输出布尔张量。
kaiser 函数keras.ops.kaiser(x, beta)
凯泽窗函数。
凯泽窗定义为：w[n] = I0(beta * sqrt(1 - (2n / (N - 1) - 1)^2)) / I0(beta)，其中 I0 是第一类修正的零阶贝塞尔函数。
参数
返回
一个包含凯泽窗值的一维张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.kaiser(x, beta=14.0)
array([7.7268669e-06, 1.6493219e-01, 1.0000000e+00, 1.6493219e-01,
7.7268669e-06], dtype=float32)
left_shift 函数keras.ops.left_shift(x, y)
将整数的位向左移动。
通过在 x 的右侧附加 y 个 0 来将位向左移动。由于数字的内部表示是二进制格式，因此此操作等效于将 x 乘以 2**y。
参数
返回
结果张量。
less 函数keras.ops.less(x1, x2)
逐元素返回 x1 < x2 的真值。
参数
返回
输出张量，x1 和 x2 的逐元素比较。
less_equal 函数keras.ops.less_equal(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] 上计算。
区间的端点可以选择性地排除。
参数
endpoint 设置为 False。在这种情况下，序列由 num + 1 个均匀间隔的样本中的除最后一个之外的所有样本组成，因此 stop 被排除。请注意，当 endpoint 为 False 时，步长会改变。50。必须为非负数。True，则 stop 是最后一个样本。否则，不包括它。默认为 True。True，则返回 (samples, step)，其中 step 是样本之间的间距。0。注意：Torch 后端不支持 axis 参数。
返回
一个均匀间隔数字的张量。如果 retstep 为 True，则返回 (samples, step)
log 函数keras.ops.log(x)
逐元素计算自然对数。
参数
返回
输出张量，x 的逐元素自然对数。
log10 函数keras.ops.log10(x)
逐元素返回输入张量的以 10 为底的对数。
参数
返回
输出张量，x 的逐元素以 10 为底的对数。
log1p 函数keras.ops.log1p(x)
逐元素返回一加 x 的自然对数。
计算 log(1 + x)。
参数
返回
输出张量，1 + x 的逐元素自然对数。
log2 函数keras.ops.log2(x)
x 的以 2 为底的对数，逐元素计算。
参数
返回
输出张量，x 的逐元素以 2 为底的对数。
logaddexp 函数keras.ops.logaddexp(x1, x2)
输入的指数和的对数。
计算 log(exp(x1) + exp(x2))。
参数
返回
输出张量，输入的指数和的逐元素对数。
logical_and 函数keras.ops.logical_and(x1, x2)
计算给定输入张量的逐元素逻辑与。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的逐元素逻辑与。
logical_not 函数keras.ops.logical_not(x)
计算给定输入张量的逐元素非。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的逐元素逻辑非。
logical_or 函数keras.ops.logical_or(x1, x2)
计算给定输入张量的逐元素逻辑或。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的逐元素逻辑或。
logical_xor 函数keras.ops.logical_xor(x1, x2)
逐元素计算 x1 XOR x2 的真值。
参数
返回
输出布尔张量。
logspace 函数keras.ops.logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0)
返回在对数刻度上均匀间隔的数字。
在线性空间中，序列从 base ** start 开始，到 base ** stop 结束（参见下面的 endpoint）。
参数
endpoint 为 False。在这种情况下，num + 1 个值在对数空间中的区间上间隔开，其中返回除最后一个值之外的所有值（一个长度为 num 的序列）。50。True，则 stop 是最后一个样本。否则，不包括它。默认为 True。10。注意：Torch 后端不支持 axis 参数。
返回
一个在对数刻度上均匀间隔的样本张量。
matmul 函数keras.ops.matmul(x1, x2)
两个张量的矩阵乘积。
参数
返回
输出张量，输入的矩阵乘积。
max 函数keras.ops.max(x, axis=None, keepdims=False, initial=None)
返回张量的最大值或沿某个轴的最大值。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。默认为 False。None。返回
x 的最大值。
maximum 函数keras.ops.maximum(x1, x2)
x1 和 x2 的逐元素最大值。
参数
返回
输出张量，x1 和 x2 的逐元素最大值。
mean 函数keras.ops.mean(x, axis=None, keepdims=False)
沿指定轴计算算术平均值。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
包含均值的输出张量。
median 函数keras.ops.median(x, axis=None, keepdims=False)
沿指定轴计算中位数。
参数
axis=None，即沿数组的展平版本计算中位数。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 扩展到结果形状来构造的。
参数
"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)
返回张量的最小值或沿某个轴的最小值。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。默认为 False。None。返回
x 的最小值。
minimum 函数keras.ops.minimum(x1, x2)
x1 和 x2 的逐元素最小值。
参数
返回
输出张量，x1 和 x2 的逐元素最小值。
mod 函数keras.ops.mod(x1, x2)
返回除法的逐元素余数。
参数
返回
输出张量，除法的逐元素余数。
moveaxis 函数keras.ops.moveaxis(x, source, destination)
将张量的轴移动到新位置。
其他轴保持其原始顺序。
参数
返回
轴已移动的张量。
multiply 函数keras.ops.multiply(x1, x2)
按元素将参数相乘。
参数
返回
输出张量，x1 和 x2 的逐元素乘积。
nan_to_num 函数keras.ops.nan_to_num(x, nan=0.0, posinf=None, neginf=None)
将 NaN 替换为零，将无穷大替换为大的有限数。
参数
NaN 条目的值。返回
x，其中非有限值已被替换。
ndim 函数keras.ops.ndim(x)
返回张量的维度数。
参数
返回
x 中的维度数。
negative 函数keras.ops.negative(x)
逐元素取数值负数。
参数
返回
输出张量，y = -x。
nonzero 函数keras.ops.nonzero(x)
返回非零元素的索引。
参数
返回
非零元素的索引。
norm 函数keras.ops.norm(x, ord=None, axis=None, keepdims=False)
矩阵或向量范数。
此函数能够返回八种不同的矩阵范数之一，或无限多种向量范数之一（如下所述），具体取决于 ord 参数的值。
参数
None。axis 是一个整数，它指定了计算向量范数的 x 的轴。如果 axis 是一个二元组，它指定了包含二维矩阵的轴，并计算这些矩阵的矩阵范数。True，则被归约的轴将作为大小为 1 的维度保留在结果中。注意：对于 ord < 1 的值，结果严格来说不是数学上的“范数”，但它可能对各种数值目的仍然有用。可以计算以下范数： - 对于矩阵： - ord=None：弗罗贝尼乌斯范数 - ord="fro"：弗罗贝尼乌斯范数 - 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 的逐元素比较。
ones 函数keras.ops.ones(shape, dtype=None)
返回一个给定形状和类型的新张量，用 1 填充。
参数
返回
具有给定形状和 dtype 的全 1 张量。
ones_like 函数keras.ops.ones_like(x, dtype=None)
返回一个与 x 具有相同形状和类型的全 1 张量。
参数
返回
与 x 具有相同形状和类型的全 1 张量。
outer 函数keras.ops.outer(x1, x2)
计算两个向量的外积。
给定两个向量 x1 和 x2，外积是
out[i, j] = x1[i] * x2[j]
参数
返回
x1 和 x2 的外积。
pad 函数keras.ops.pad(x, pad_width, mode="constant", constant_values=None)
填充一个张量。
参数
((before_1, after_1), ...(before_N, after_N)) 为每个轴指定唯一的填充宽度。((before, after),) 为每个轴产生相同的 before 和 after 填充。(pad,) 或 int 是所有轴的 before = after = pad 宽度的简写。"constant"、"edge"、"linear_ramp"、"maximum"、"mean"、"median"、"minimum"、"reflect"、"symmetric"、"wrap"、"empty"、"circular" 之一。默认为 "constant"。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 中的指数的幂。
prod 函数keras.ops.prod(x, axis=None, keepdims=False, dtype=None)
返回张量元素在给定轴上的乘积。
参数
axis=None 将计算输入张量中所有元素的乘积。True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
x 的元素在给定轴或多个轴上的乘积。
quantile 函数keras.ops.quantile(x, q, axis=None, method="linear", keepdims=False)
沿指定轴计算数据的第 q 个分位数。
参数
axis=None，即沿数组的展平版本计算分位数。"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，以较近者为准。True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
分位数。如果 q 是单个概率且 axis=None，则结果是一个标量。如果给定了多个概率水平，则结果的第一个轴对应于分位数。其他轴是 x 归约后剩余的轴。
ravel 函数keras.ops.ravel(x)
返回一个连续的展平张量。
返回一个包含输入元素的一维张量。
参数
返回
输出张量。
real 函数keras.ops.real(x)
返回复数参数的实部。
参数
返回
复数参数的实部。
reciprocal 函数keras.ops.reciprocal(x)
逐元素返回参数的倒数。
计算 1/x。
参数
返回
输出张量，x 的逐元素倒数。
repeat 函数keras.ops.repeat(x, repeats, axis=None)
在一个张量中，将每个元素在其后重复。
参数
返回
输出张量。
reshape 函数keras.ops.reshape(x, newshape)
在不改变其数据的情况下，为张量赋予新的形状。
参数
返回
重塑后的张量。
right_shift 函数keras.ops.right_shift(x, y)
将整数的位向右移动。
位向右移动 y。由于数字的内部表示是二进制格式，此操作等效于将 x 除以 2**y。
参数
返回
结果张量。
roll 函数keras.ops.roll(x, shift, axis=None)
沿给定轴滚动张量元素。
滚出最后一个位置的元素会重新从第一个位置引入。
参数
返回
输出张量。
rot90 函数keras.ops.rot90(array, k=1, axes=(0, 1))
在由轴指定的平面中将数组旋转 90 度。
此函数在由 axes 指定的平面中将数组逆时针旋转 90 度 k 次。支持二维或更多维的数组。
参数
(0, 1)）。返回
旋转后的数组。
示例
>>> import numpy as np
>>> from keras import ops
>>> m = np.array([[1, 2], [3, 4]])
>>> rotated = ops.rot90(m)
>>> rotated
array([[2, 4],
[1, 3]])
>>> m = np.arange(8).reshape((2, 2, 2))
>>> rotated = ops.rot90(m, k=1, axes=(1, 2))
>>> rotated
array([[[1, 3],
[0, 2]],
[[5, 7],
[4, 6]]])
round 函数keras.ops.round(x, decimals=0)
四舍五入到给定的小数位数。
参数
0。返回
输出张量。
searchsorted 函数keras.ops.searchsorted(sorted_sequence, values, side="left")
执行二分搜索，返回将 values 插入 sorted_sequence 以保持排序顺序的索引。
参数
返回
与 values 形状相同的插入索引张量。
select 函数keras.ops.select(condlist, choicelist, default=0)
根据 condlist 中的条件，从 choicelist 中返回元素。
参数
condlist 相同。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 形状相同的输出张量。
signbit 函数keras.ops.signbit(x)
返回 x 元素的符号位。
输出布尔张量在 x 的符号为负时包含 True，否则包含 False。
参数
返回
与 x 形状相同的输出布尔张量。
sin 函数keras.ops.sin(x)
逐元素计算三角正弦。
参数
返回
与 x 形状相同的输出张量。
sinh 函数keras.ops.sinh(x)
逐元素计算双曲正弦。
参数
返回
与 x 形状相同的输出张量。
size 函数keras.ops.size(x)
返回张量中的元素数量。
参数
返回
x 中的元素数量。
slogdet 函数keras.ops.slogdet(x)
计算矩阵行列式的符号和自然对数。
参数
返回
一个元组 (sign, logabsdet)。sign 是一个表示行列式符号的数字。对于实数矩阵，它是 1、0 或 -1。对于复数矩阵，它是一个绝对值为 1 的复数（即它在单位圆上），否则为 0。logabsdet 是行列式绝对值的自然对数。
sort 函数keras.ops.sort(x, axis=-1)
沿给定轴按升序对 x 的元素进行排序。
参数
None，则在排序前将张量展平。默认为 -1；最后一个轴。返回
排序后的张量。
split 函数keras.ops.split(x, indices_or_sections, axis=0)
将一个张量分割成块。
参数
axis 分割成 N 个相等的部分。如果是一个已排序整数的一维数组，则条目表示张量将沿 axis 分割的索引。0。注意：使用 Torch 后端时，分割不一定会导致等分。
返回
一个张量列表。
sqrt 函数keras.ops.sqrt(x)
逐元素返回张量的非负平方根。
参数
返回
输出张量，x 的非负平方根。
square 函数keras.ops.square(x)
返回输入的逐元素平方。
参数
返回
输出张量，x 的平方。
squeeze 函数keras.ops.squeeze(x, axis=None)
从 x 中移除长度为 1 的轴。
参数
返回
输入张量，其中所有或部分长度为 1 的维度已被移除。
stack 函数keras.ops.stack(x, axis=0)
沿新轴连接一系列张量。
axis 参数指定新轴在结果维度中的索引。
参数
0。返回
堆叠后的张量。
std 函数keras.ops.std(x, axis=None, keepdims=False)
沿指定轴计算标准差。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
包含标准差值的输出张量。
subtract 函数keras.ops.subtract(x1, x2)
按元素减去参数。
参数
返回
输出张量，x1 和 x2 的逐元素差。
sum 函数keras.ops.sum(x, axis=None, keepdims=False)
张量在给定轴上的和。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
包含和的输出张量。
swapaxes 函数keras.ops.swapaxes(x, axis1, axis2)
交换张量的两个轴。
参数
返回
一个轴被交换的张量。
take 函数keras.ops.take(x, indices, axis=None)
沿一个轴从张量中取元素。
参数
返回
相应的值张量。
take_along_axis 函数keras.ops.take_along_axis(x, indices, axis=None)
沿给定轴从 x 中选择一维 indices 处的值。
参数
返回
相应的值张量。
tan 函数keras.ops.tan(x)
逐元素计算正切。
参数
返回
与 x 形状相同的输出张量。
tanh 函数keras.ops.tanh(x)
逐元素计算双曲正切。
参数
返回
与 x 形状相同的输出张量。
tensordot 函数keras.ops.tensordot(x1, x2, axes=2)
沿指定轴计算张量点积。
参数
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 沿每个轴的重复次数。返回
平铺的输出张量。
trace 函数keras.ops.trace(x, offset=0, axis1=0, axis2=1)
返回张量对角线上的和。
如果 x 是二维的，则返回其具有给定偏移量的对角线上的和，即所有 i 的元素 x[i, i+offset] 的和。
如果 a 有两个以上的维度，则使用由 axis1 和 axis2 指定的轴来确定返回其迹的二维子数组。
结果张量的形状与移除了 axis1 和 axis2 的 x 相同。
参数
0。0（第一个轴）。1（第二个轴）。返回
如果 x 是二维的，则返回对角线的和。如果 x 有更大的维度，则返回一个沿对角线求和的张量。
transpose 函数keras.ops.transpose(x, axes=None)
返回一个 axes 被转置的张量。
参数
x 维度的排列。默认情况下，轴的顺序是反转的。返回
x，其轴已置换。
tri 函数keras.ops.tri(N, M=None, k=0, dtype=None)
返回一个在对角线及以下为 1，其他地方为 0 的张量。
参数
k = 0 是主对角线，k < 0 在其下方，k > 0 在其上方。默认值为 0。返回
下三角填充为 1，其他地方为 0 的张量。T[i, j] == 1 对于 j <= i + k，否则为 0。
tril 函数keras.ops.tril(x, k=0)
返回张量的下三角部分。
对于 ndim 超过 2 的张量，tril 将应用于最后两个轴。
参数
0，即主对角线。k < 0 在其下方，k > 0 在其上方。返回
x 的下三角部分，与 x 具有相同的形状和数据类型。
triu 函数keras.ops.triu(x, k=0)
返回张量的上三角部分。
对于 ndim 超过 2 的张量，triu 将应用于最后两个轴。
参数
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 = 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])
unravel_index 函数keras.ops.unravel_index(indices, shape)
在给定的数组形状中，将展平的索引转换为坐标数组。
参数
返回
包含每个维度解开索引的数组元组。
示例
indices = 5 shape = (3, 3) unravel_index(indices, shape) (1, 2) # 在一个 3x3 数组中，5 位于第 1 行，第 2 列
var 函数keras.ops.var(x, axis=None, keepdims=False)
沿指定轴计算方差。
参数
True，则被归约的轴将作为大小为 1 的维度保留在结果中。返回
包含方差的输出张量。
vdot 函数keras.ops.vdot(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。"(m,n),(n)->(m)" 用于向量化的矩阵-向量乘法。如果提供，pyfunc 将被调用（并期望返回）具有由相应核心维度大小给出的形状的数组。默认情况下，假定 pyfunc 接受标量张量作为输入和输出。返回
一个新函数，它将 pyfunc 应用于其输入的每个元素，沿轴 0（批处理轴）。
vstack 函数keras.ops.vstack(xs)
按垂直（行方式）顺序堆叠张量。
参数
返回
通过堆叠给定张量形成的张量。
where 函数keras.ops.where(condition, x1=None, x2=None)
根据 condition 从 x1 或 x2 中选择元素返回。
参数
True 时，产生 x1，否则产生 x2。condition 为 True 时从中选择的值。condition 为 False 时从中选择的值。返回
一个张量，其元素在 condition 为 True 时来自 x1，在 condition 为 False 时来自 x2。
zeros 函数keras.ops.zeros(shape, dtype=None)
返回一个给定形状和类型的新张量，用零填充。
参数
返回
具有给定形状和 dtype 的全零张量。
zeros_like 函数keras.ops.zeros_like(x, dtype=None)
返回一个与 x 具有相同形状和类型的全零张量。
参数
返回
一个与 x 具有相同形状和类型的全零张量。