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）是对输入数组的所有维度执行逻辑 AND。axis 可以是负数，在这种情况下，它从最后一个轴计数到第一个轴。True，则被约简的轴将在结果中保留为大小为一的维度。使用此选项，结果将与输入数组正确广播。默认为 False。返回
包含 axis 上逻辑 AND 约简的张量。
示例
>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.all(x)
array(False, shape=(), dtype=bool)
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, axis=0)
array([ True False], shape=(2,), dtype=bool)
keepdims=True 输出的张量维度被约简为一。
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, keepdims=True)
array([[False]], shape=(1, 1), dtype=bool)
amax 函数keras.ops.amax(x, axis=None, keepdims=False)
返回数组的最大值或沿轴的最大值。
参数
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）是对输入数组的所有维度执行逻辑 OR。axis 可以是负数，在这种情况下，它从最后一个轴计数到第一个轴。True，则被约简的轴将在结果中保留为大小为一的维度。使用此选项，结果将与输入数组正确广播。默认为 False。返回
包含 axis 上逻辑 OR 约简的张量。
示例
>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.any(x)
array(True, shape=(), dtype=bool)
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.any(x, axis=0)
array([ True True], shape=(2,), dtype=bool)
keepdims=True 输出的张量维度被约简为一。
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, keepdims=True)
array([[False]], shape=(1, 1), dtype=bool)
append 函数keras.ops.append(x1, x2, axis=None)
将张量 x2 追加到张量 x1 的末尾。
参数
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=None, dtype=None)
在给定区间内返回等距值。
arange 可以用不同数量的位置参数调用： * arange(stop): 值在半开区间 [0, stop) 中生成（换句话说，包含起始值但不包含停止值）。 * arange(start, stop): 值在半开区间 [start, stop) 中生成。 * arange(start, stop, step): 值在半开区间 [start, stop) 中生成，值之间的间距由 step 给出。
参数
step 不是整数且浮点数舍入会影响 out 的长度的情况下。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)
注意参数的顺序。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 相同的输出张量。
argmax 函数keras.ops.argmax(x, axis=None, keepdims=False)
返回沿轴的最大值的索引。
参数
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)
返回沿轴的最小值的索引。
参数
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 形状相同的索引数组，该数组沿给定轴以分区顺序索引数据。
参数
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 中的所有数据权重都为一。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)
Bartlett 窗口函数。Bartlett 窗口是一个上升然后线性下降的三角形窗口。
参数
返回
包含 Bartlett 窗口值的 1D 张量。
示例
>>> 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。返回
1D 张量，其中每个元素给出其索引值在 x 中出现次数的计数。其长度是 max(x) + 1 和 minlength 之间的最大值。
示例
>>> x = keras.ops.array([1, 2, 2, 3], dtype="uint8")
>>> keras.ops.bincount(x)
array([0, 1, 2, 1], dtype=int32)
>>> weights = x / 2
>>> weights
array([0.5, 1., 1., 1.5], dtype=float64)
>>> keras.ops.bincount(x, weights=weights)
array([0., 0.5, 2., 1.5], dtype=float64)
>>> minlength = (keras.ops.max(x).numpy() + 1) + 2 # 6
>>> keras.ops.bincount(x, minlength=minlength)
array([0, 1, 2, 1, 0, 0], dtype=int32)
bitwise_and 函数keras.ops.bitwise_and(x, y)
按元素计算两个数组的按位 AND。
计算输入数组中整数的底层二进制表示的按位 AND。此 ufunc 实现 C/Python 运算符 &。
参数
返回
结果张量。
bitwise_invert 函数keras.ops.bitwise_invert(x)
按元素计算按位反转，或按位 NOT。
计算输入数组中整数的底层二进制表示的按位 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。
计算输入数组中整数的底层二进制表示的按位 NOT。此 ufunc 实现 C/Python 运算符 ~。
参数
返回
结果张量。
bitwise_or 函数keras.ops.bitwise_or(x, y)
按元素计算两个数组的按位 OR。
计算输入数组中整数的底层二进制表示的按位 OR。此 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。
计算输入数组中整数的底层二进制表示的按位 XOR。此 ufunc 实现 C/Python 运算符 ^。
参数
返回
结果张量。
blackman 函数keras.ops.blackman(x)
Blackman 窗口函数。Blackman 窗口是通过使用加权余弦形成的锥形。
参数
返回
包含 Blackman 窗口值的 1D 张量。
示例
>>> 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 中每个元素的上界，具有浮点数 dtype。
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 的副本。
corrcoef 函数keras.ops.corrcoef(x)
计算皮尔逊相关系数矩阵。
参数
(N, D) 的二维张量，其中 N 是变量数量，D 是观测数量。返回
形状为 (N, N) 的张量，表示相关矩阵。
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)
计算 x 在给定 axis 上非零值的数量。
如果没有指定轴，则计算张量中所有非零值的数量。
参数
None。返回
整数或整数张量。
示例
>>> x = keras.ops.array([[0, 1, 7, 0], [3, 0, 2, 19]])
>>> keras.ops.count_nonzero(x)
5
>>> keras.ops.count_nonzero(x, axis=0)
array([1, 1, 2, 1], dtype=int64)
>>> keras.ops.count_nonzero(x, axis=1)
array([2, 3], dtype=int64)
cross 函数keras.ops.cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None)
返回向量（或向量数组）的叉积。
R^3 中 x1 和 x2 的叉积是垂直于 x1 和 x2 的向量。如果 x1 和 x2 是向量数组，则向量由 x1 和 x2 的最后一个轴定义，并且这些轴可以具有维度 2 或 3。
当 x1 或 x2 的维度为 2 时，输入向量的第三个分量假定为零，并据此计算叉积。
在两个输入向量维度均为 2 的情况下，返回叉积的 z 分量。
参数
x1 的轴。默认为 -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-th 对角线。如果 x 是一维的，则返回一个二维张量，将 x 放在 k-th 对角线上。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-th 对角线上。
参数
0。对于主对角线以上的对角线使用 k > 0，对于主对角线以下的对角线使用 k < 0。返回
在指定对角线上具有展平输入的二维张量。
diagonal 函数keras.ops.diagonal(x, offset=0, axis1=0, axis2=1)
返回指定的对角线。
如果 x 是二维的，则返回具有给定偏移量的 x 对角线，即元素 x[i, i+offset] 的集合。
如果 x 的维度大于 2，则使用由 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 中每个值所属的 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 的商，按元素计算。
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 维张量而 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])。参数
注意：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。返回
对角线上为 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 相同形状和类型的填充值张量。
gcd 函数keras.ops.gcd(x1, x2)
x1 和 x2 的最大公约数，按元素计算。
参数
返回
输出张量，x1 和 x2 的按元素最大公约数。
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)
Hamming 窗口函数。
Hamming 窗口定义为：w[n] = 0.54 - 0.46 * cos(2 * pi * n / (N - 1))，其中 0 <= n <= N - 1。
参数
返回
包含 Hamming 窗口值的 1D 张量。
示例
>>> 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)
Hanning 窗口函数。
Hanning 窗口定义为：w[n] = 0.5 - 0.5 * cos(2 * pi * n / (N - 1))，其中 0 <= n <= N - 1。
参数
返回
包含 Hanning 窗口值的 1D 张量。
示例
>>> x = keras.ops.convert_to_tensor(5)
>>> keras.ops.hanning(x)
array([0. , 0.5, 1. , 0.5, 0. ], dtype=float32)
heaviside 函数keras.ops.heaviside(x1, x2)
Heaviside 阶跃函数。
Heaviside 阶跃函数定义为：heaviside(x1, x2) = 0 if x1 < 0, 1 if x1 > 0, x2 if x1 == 0
参数
x1 == 0 时返回的值。返回
形状由 x1 和 x2 的广播确定的张量。
示例
>>> x1 = keras.ops.convert_to_tensor([-2.0, 0.0, 3.0])
>>> x2 = 0.5
>>> keras.ops.heaviside(x1, x2)
array([0. , 0.5, 1. ], dtype=float32)
histogram 函数keras.ops.histogram(x, bins=10, range=None)
计算数据张量 x 的直方图。
参数
x 的最小值和最大值。返回
示例
>>> 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]))
hstack 函数keras.ops.hstack(xs)
水平（按列）堆叠序列中的张量。
对于一维张量，这等同于沿第一个轴的连接，对于所有其他张量，则等同于沿第二个轴的连接。
参数
返回
通过堆叠给定张量形成的张量。
hypot 函数keras.ops.hypot(x1, x2)
直角三角形（腿为 x1 和 x2）的按元素斜边长。
这等效于按元素计算 sqrt(x1**2 + x2**2)，其形状由广播确定。
参数
返回
形状由 x1 和 x2 的广播确定的张量。
示例
>>> x1 = keras.ops.convert_to_tensor([3.0, 4.0, 5.0])
>>> x2 = keras.ops.convert_to_tensor([4.0, 3.0, 12.0])
>>> keras.ops.hypot(x1, x2)
array([5., 5., 13.], dtype=float32)
>>> x1 = keras.ops.convert_to_tensor([[1, 2], [3, 4]])
>>> x2 = keras.ops.convert_to_tensor([1, 1])
>>> keras.ops.hypot(x1, x2)
array([[1.41421356 2.23606798],
[3.16227766 4.12310563]], dtype=float32)
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 并将结果作为布尔张量返回。
参数
返回
输出布尔张量。
isneginf 函数keras.ops.isneginf(x)
按元素测试负无穷。
参数
返回
输出布尔张量。
isposinf 函数keras.ops.isposinf(x)
按元素测试正无穷。
参数
返回
输出布尔张量。
isreal 函数keras.ops.isreal(x)
按元素测试实数。
参数
返回
输出布尔张量。
示例
from keras import ops x = ops.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype="complex64") ops.isreal(x) array([False, True, True, True, True, False])
kaiser 函数keras.ops.kaiser(x, beta)
Kaiser 窗口函数。
Kaiser 窗口定义为：w[n] = I0(beta * sqrt(1 - (2n / (N - 1) - 1)^2)) / I0(beta)，其中 I0 是第一类修正贝塞尔函数零阶。
参数
返回
包含 Kaiser 窗口值的 1D 张量。
示例
>>> 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)
kron 函数keras.ops.kron(x1, x2)
x1 和 x2 的克罗内克积。
计算两个输入张量的克罗内克积。如果 x1 的形状为 (a0, a1, ..., an)，x2 的形状为 (b0, b1, ..., bn)，则输出的形状将为 (a0*b0, a1*b1, ..., an*bn)。
参数
返回
表示 x1 和 x2 的克罗内克积的张量。
lcm 函数keras.ops.lcm(x1, x2)
x1 和 x2 的最小公倍数，按元素计算。
参数
返回
输出张量，x1 和 x2 的按元素最小公倍数。
示例
>>> x1 = keras.ops.convert_to_tensor([2, 3, 4])
>>> x2 = keras.ops.convert_to_tensor([5, 6, 7])
>>> keras.ops.lcm(x1, x2)
array([10, 6, 28], dtype=int32)
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)
返回 1 加上 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)
计算给定输入张量的按元素逻辑 AND。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的按元素逻辑 AND。
logical_not 函数keras.ops.logical_not(x)
计算给定输入张量的按元素 NOT。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的按元素逻辑 NOT。
logical_or 函数keras.ops.logical_or(x1, x2)
计算给定输入张量的按元素逻辑 OR。
零被视为 False，非零被视为 True。
参数
返回
输出张量，输入的按元素逻辑 OR。
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，则被约简的轴将在结果中保留为大小为一的维度。默认为 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，则被约简的轴将在结果中保留为大小为一的维度。返回
输出张量。
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，则被约简的轴将在结果中保留为大小为一的维度。默认为 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：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 的按元素比较。
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。如果 constant_values 不为 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，则被约简的轴将在结果中保留为大小为一的维度。返回
沿给定轴或轴的 x 元素的乘积。
quantile 函数keras.ops.quantile(x, q, axis=None, method="linear", keepdims=False)
计算数据沿指定轴的 q-th 分位数（们）。
参数
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，则被约简的轴将在结果中保留为大小为一的维度。返回
分位数（们）。如果 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 中选择元素。
参数
choicelist 中哪个数组获取输出元素的条件列表。当多个条件满足时，使用 condlist 中遇到的第一个条件。condlist 相同。False 时插入到输出中的元素。返回
张量，其中位置 m 的输出是 choicelist 中对应 condlist 中对应张量中 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 的所有或部分维度已被移除。
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)
沿给定轴在一维 indices 处从 x 中选择值。
参数
返回
对应的取值张量。
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)
根据 repeats 给出的次数重复 x。
如果 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 的维度大于 2，则使用由 axis1 和 axis2 指定的轴来确定返回其迹的二维子数组。
结果张量的形状与 x 的形状相同，但移除了 axis1 和 axis2。
参数
0。0。（第一轴）。1（第二轴）。返回
如果 x 是二维的，则返回对角线的总和。如果 x 的维度更大，则返回对角线总和的张量。
trapezoid 函数keras.ops.trapezoid(y, x=None, dx=1.0, axis=-1)
使用复合梯形法则沿给定轴进行积分。
参数
y 对应的采样点。如果为 None，则假定间距为 dx。x 为 None 时采样点之间的间距。返回
沿给定轴的 y 的近似积分。
示例
>>> y = keras.ops.convert_to_tensor([[1, 2, 3], [4, 5, 6]])
>>> keras.ops.trapezoid(y, axis=1)
array([ 4., 10.], dtype=float32)
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的截断值是距离零最近的整数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])
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接受标量张量作为输入和输出。返回
一个新函数，它沿着轴0（批处理轴）将pyfunc应用于其输入的每个元素。
view函数keras.ops.view(x, dtype=None)
使用指定的dtype创建一个相同数据的位视图。
参数
返回
具有dtype数据类型的张量视图。
示例
>>> x = keras.ops.array([1, 2, 3])
>>> x
array([1, 2, 3], dtype=int32)
>>> keras.ops.view(x, dtype="float32")
array([1.0e-45, 3.0e-45, 4.0e-45], dtype=float32)
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具有相同形状和类型的零张量。