NumPy 操作

[source]

absolute function

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)

[source]

add function

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)

[source]

all function

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)

[source]

amax function

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)

[source]

amin function

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)

[source]

any function

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)

[source]

append function

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: 无法连接具有不同维数数组的数组: 得到 (2, 3), (3,).

[source]

arange function

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)

[source]

arccos function

keras.ops.arccos(x)

三角函数的反余弦,逐元素计算.

如果 y = cos(x),那么 x = arccos(y).

参数: x: 输入张量.

返回: 在单位圆上与给定 x 坐标相交的光线的角度张量,以弧度表示 [0, pi].

示例:

>>> x = keras.ops.convert_to_tensor([1, -1])
>>> keras.ops.arccos(x)
array([0.0, 3.1415927], dtype=float32)

[source]

arccosh function

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)

[source]

arcsin function

keras.ops.arcsin(x)

反正弦,逐元素计算.

参数: x: 输入张量.

返回: 一个张量,包含x中每个元素的反正弦值,以弧度表示,并在闭区间[-pi/2, pi/2]内.

示例:

>>> x = keras.ops.convert_to_tensor([1, -1, 0])
>>> keras.ops.arcsin(x)
array([ 1.5707964, -1.5707964,  0.], dtype=float32)

[source]

arcsinh function

keras.ops.arcsinh(x)

元素逐个的反双曲正弦.

参数: x: 输入张量.

返回: 与x形状相同的输出张量.

示例:

>>> x = keras.ops.convert_to_tensor([1, -1, 0])
>>> keras.ops.arcsinh(x)
array([0.88137364, -0.88137364, 0.0], dtype=float32)

[source]

arctan function

keras.ops.arctan(x)

三角函数的反切函数,逐元素计算.

参数: x: 输入张量.

返回: 每个元素在x中的反切函数值的张量,区间为[-pi/2, pi/2].

示例:

>>> x = keras.ops.convert_to_tensor([0, 1])
>>> keras.ops.arctan(x)
array([0., 0.7853982], dtype=float32)

[source]

arctan2 function

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)

[source]

arctanh function

keras.ops.arctanh(x)

反双曲正切,逐元素操作.

参数: x: 输入张量.

返回: 与x形状相同的输出张量.

[source]

argmax function

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)

[source]

argmin function

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

返回沿轴的最小值的索引.

参数: x: 输入张量. axis: 默认情况下,索引是进入展平张量的,否则沿指定的轴. keepdims: 如果设置为 True,减少的轴将保留在结果中,作为大小为一的维度.默认为 False.

返回: 索引张量.它与 x 具有相同的形状,但沿 axis 的维度被移除.

示例:

>>> x = keras.ops.arange(6).reshape(2, 3) + 10
>>> x
array([[10, 11, 12],
       [13, 14, 15]], dtype=int32)
>>> keras.ops.argmin(x)
array(0, dtype=int32)
>>> keras.ops.argmin(x, axis=0)
array([0, 0, 0], dtype=int32)
>>> keras.ops.argmin(x, axis=1)
array([0, 0], dtype=int32)

[source]

argsort function

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)

[source]

array function

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)

[source]

average function

keras.ops.average(x, axis=None, weights=None)

计算沿指定轴的加权平均值.

参数: x: 输入张量. axis: 整数,沿其进行平均的轴.默认值 axis=None 将对输入张量的所有元素进行平均.如果轴为负数,则从最后一个轴计数到第一个轴. weights: 与 x 中的值相关联的权重张量.x 中的每个值根据其关联的权重对平均值做出贡献.权重数组可以是1-D（在这种情况下,其长度必须与沿给定轴的 a 的大小相同）或与 x 具有相同的形状.如果 weights=None（默认值）,则假定 x 中的所有数据具有等于1的权重.

    1-D计算为:`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.

[source]

bincount function

keras.ops.bincount(x, weights=None, minlength=0, sparse=False)

统计整数张量中每个值的出现次数.

参数: x: 输入张量. 它必须是1维的,并且只能包含非负整数. weights: 权重张量. 它的长度必须与x相同.默认值为None. 如果指定,x将按其加权,即如果n = x[i], out[n] += weight[i]而不是默认行为out[n] += 1. minlength: 一个整数. 默认值为0.如果指定,输出张量中至少会有 这个数量的箱子.如果大于max(x) + 1,则输出中索引高于 max(x)的每个值都设置为0. sparse: 是否返回稀疏张量;适用于支持稀疏张量的后端.

返回: 1维张量,其中每个元素给出其索引值在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)

[source]

broadcast_to function

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

[source]

ceil function

keras.ops.ceil(x)

返回输入的上限,逐元素进行.

标量 x 的上限是最小的整数 i,使得 i >= x.

参数: x: 输入张量.

返回: 每个元素在 x 中的上限,具有浮点数据类型.

[source]

clip function

keras.ops.clip(x, x_min, x_max)

裁剪（限制）张量中的值.

给定一个区间,区间外的值会被裁剪到区间边缘.例如,如果指定了一个 [0, 1] 的区间, 小于 0 的值变为 0,大于 1 的值变为 1.

参数: x: 输入张量. x_min: 最小值. x_max: 最大值. 返回: 裁剪后的张量.

[source]

concatenate function

keras.ops.concatenate(xs, axis=0)

连接一系列张量沿现有轴.

参数: xs: 要连接的张量序列. axis: 张量将沿其连接的轴.默认为 0.

返回: 连接后的张量.

[source]

conj function

keras.ops.conj(x)

keras.ops.conjugate 的简写.

[source]

conjugate function

keras.ops.conjugate(x)

返回逐元素的复共轭.

复数的复共轭是通过改变其虚部的符号得到的.

keras.ops.conj 是此函数的简写.

参数: x: 输入张量.

返回: 每个元素在 x 中的复共轭.

[source]

copy function

keras.ops.copy(x)

返回 x 的一个副本.

参数: x: 输入张量.

返回: x 的一个副本.

[source]

cos function

keras.ops.cos(x)

Cosine, element-wise.

参数: x: 输入张量.

返回: 相应的余弦值.

[source]

cosh function

keras.ops.cosh(x)

双曲余弦,逐元素计算.

参数: x:输入张量.

返回: 与x形状相同的输出张量.

[source]

count_nonzero function

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

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

如果没有指定轴,则计算张量中所有非零值的数量.

参数: x: 输入张量. axis: 沿其计算非零值数量的轴或轴的元组.默认为None.

返回: int 或 int 的张量.

示例:

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

[source]

cross function

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: 第一个向量（组）的分量. x2: 第二个向量（组）的分量. axisa: 定义向量（组）的 x1 轴.默认为 -1. axisb: 定义向量（组）的 x2 轴.默认为 -1. axisc: 包含叉积向量（组）的结果轴.如果两个输入向量都具有维度 2,则忽略,因为返回值是标量.默认为最后一个轴. axis: 如果定义,定义向量（组）和叉积（组）的 x1、x2 和结果轴.覆盖 axisa、axisb 和 axisc.

注意: Torch 后端不支持二维向量,也不支持 axisa、axisb 和 axisc 参数.请使用 axis 代替.

返回: 向量叉积（组）.

[source]

cumprod function

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

返回沿给定轴元素的累积乘积.

参数: x: 输入张量. axis: 计算累积乘积的轴. 默认情况下,输入被展平. dtype: 返回张量的数据类型.默认为x.dtype.

返回: 输出张量.

[source]

cumsum function

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

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

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

返回: 输出张量.

[source]

diag function

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

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

参数: x: 输入张量.如果 x 是二维的,返回 x 的第 k 个对角线. 如果 x 是一维的,返回一个二维张量,其中 x 位于第 k 个对角线上. k: 要考虑的对角线.默认为 0.使用 k > 0 表示主对角线以上的对角线, 使用 k < 0 表示主对角线以下的对角线.

返回: 提取的对角线或构造的对角线张量.

示例:

>>> from keras.src import ops
>>> x = ops.arange(9).reshape((3, 3))
>>> x
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

>>> ops.diag(x)
array([0, 4, 8])
>>> ops.diag(x, k=1)
array([1, 5])
>>> ops.diag(x, k=-1)
array([3, 7])

>>> ops.diag(ops.diag(x)))
array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 8]])

[source]

diagonal function

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

[source]

diff function

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

[source]

digitize function

keras.ops.digitize(x, bins)

返回x中每个值所属的bin的索引.

参数: x: 输入数组,将被分bin. 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])

[source]

divide function

keras.ops.divide(x1, x2)

分割参数逐元素.

keras.ops.true_divide 是此函数的别名.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,逐元素的商 x1/x2.

[source]

divide_no_nan function

keras.ops.divide_no_nan(x1, x2)

安全元素级除法,在分母为0时返回0.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 元素级商 x1/x2,在 x2 为零处返回零.

[source]

dot function

keras.ops.dot(x1, x2)

两个张量的点积.

• 如果 x1 和 x2 都是 1-D 张量,它是向量的内积（不带复共轭）.
• 如果 x1 和 x2 都是 2-D 张量,它是矩阵乘法.
• 如果 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]).

参数: x1: 第一个参数. x2: 第二个参数.

注意: Torch 后端不接受 0-D 张量作为参数.

返回: x1 和 x2 的点积.

[source]

einsum function

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

[source]

empty function

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

返回一个给定形状和类型,填充未初始化数据的张量.

参数: shape: 空张量的形状. dtype: 空张量的期望数据类型.

返回: 空张量.

[source]

equal function

keras.ops.equal(x1, x2)

返回 (x1 == x2) 逐元素比较的结果.

参数: x1: 要比较的张量. x2: 要比较的张量.

返回: 输出张量,x1 和 x2 逐元素比较的结果.

[source]

exp function

keras.ops.exp(x)

计算输入张量中所有元素的指数.

参数: x: 输入张量.

返回: 输出张量,x中元素的逐元素指数.

[source]

expand_dims function

keras.ops.expand_dims(x, axis)

扩展张量的形状.

在扩展张量形状的 axis 位置插入一个新的轴.

参数: x: 输入张量. axis: 在扩展轴的位置插入新的轴.

返回: 输出张量,维度数量增加.

[source]

expm1 function

keras.ops.expm1(x)

计算张量中所有元素的 exp(x) - 1.

参数: x: 输入值.

返回: 输出张量,逐元素的指数减一.

[source]

eye function

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

返回一个对角线上为1,其他地方为0的二维张量.

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

返回: 对角线上为1,其他地方为0的张量.

[source]

flip function

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

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

张量的形状保持不变,但元素的顺序被重新排序.

参数: x: 输入张量. axis: 要翻转张量的轴.默认情况下,axis=None,将翻转输入张量的所有轴.

返回: 输出张量,其axis的条目被反转.

[source]

floor function

keras.ops.floor(x)

返回输入的向下取整结果,逐元素进行.

标量 x 的向下取整结果是最大的整数 i,使得 i <= x.

参数: x: 输入张量.

返回: 输出张量,x 的逐元素向下取整结果.

[source]

floor_divide function

keras.ops.floor_divide(x1, x2)

返回小于或等于输入除法结果的最大整数.

参数: x1: 分子. x2: 分母.

返回: 输出张量, y = floor(x1/x2)

[source]

full function

keras.ops.full(shape, fill_value, dtype=None)

返回一个具有给定形状和类型的新张量,并用fill_value填充.

参数: shape: 新张量的形状. fill_value: 填充值. dtype: 张量所需的数据类型.

返回: 输出张量.

[source]

full_like function

keras.ops.full_like(x, fill_value, dtype=None)

返回一个与给定张量具有相同形状和类型的完整张量.

参数: x: 输入张量. fill_value: 填充值. dtype: 覆盖结果的数据类型.

返回: 与x具有相同形状和类型的fill_value张量.

[source]

get_item function

keras.ops.get_item(x, key)

返回 x[key].

[source]

greater function

keras.ops.greater(x1, x2)

返回 x1 > x2 的元素级真值.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的元素级比较结果.

[source]

greater_equal function

keras.ops.greater_equal(x1, x2)

返回 x1 >= x2 的元素级真值.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的元素级比较结果.

[source]

hstack function

keras.ops.hstack(xs)

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

这相当于对1维张量沿第一个轴进行连接, 以及对所有其他张量沿第二个轴进行连接.

参数: xs: 张量序列.

返回: 由给定张量堆叠形成的张量.

[source]

identity function

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

返回单位张量.

单位张量是一个在主对角线上为1,其他位置为0的方形张量.

参数: n: 输出张量中行（和列）的数量,即n x n. dtype: 输出张量的数据类型.

返回: 单位张量.

[source]

imag function

keras.ops.imag(x)

返回复数参数的虚部.

参数: x: 输入张量.

返回: 复数参数的虚部.

[source]

isclose function

keras.ops.isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False)

返回两个张量是否逐元素几乎相等.

参数: x1: 第一个输入张量. x2: 第二个输入张量. rtol: 相对容差. atol: 绝对容差. equal_nan: 如果为 True,逐元素的 NaN 被视为相等.

返回: 输出布尔张量.

[source]

isfinite function

keras.ops.isfinite(x)

返回一个张量是否在元素上是有限的.

实数值在它们不是NaN、不是正无穷大且不是负无穷大时是有限的.复数值在它们的实部和虚部都是有限时是有限的.

参数: x: 输入张量.

返回: 输出布尔张量.

[source]

isinf function

keras.ops.isinf(x)

测试逐元素地判断是否为正无穷或负无穷.

参数: x: 输入张量.

返回: 输出布尔张量.

[source]

isnan function

keras.ops.isnan(x)

测试逐元素地检查NaN并返回结果为布尔型张量.

参数: x: 输入张量.

返回: 输出布尔型张量.

[source]

less function

keras.ops.less(x1, x2)

返回 x1 < x2 的元素级真值.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的元素级比较结果.

[source]

less_equal function

keras.ops.less_equal(x1, x2)

返回 x1 <= x2 的元素级真值.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的元素级比较结果.

[source]

linspace function

keras.ops.linspace(
    start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0
)

返回指定区间内均匀间隔的数字.

返回 num 个均匀间隔的样本,计算在区间 [start, stop] 上.

区间的端点可以选择性地排除.

参数: start: 序列的起始值. stop: 序列的结束值,除非 endpoint 设置为 False.在这种情况下,序列由 num + 1 个均匀间隔的样本中除最后一个外的所有样本组成,因此 stop 被排除.注意,当 endpoint 为 False 时,步长会改变. num: 要生成的样本数量.默认为 50.必须为非负数. endpoint: 如果为 True,stop 是最后一个样本.否则,它不包括在内.默认为 True. retstep: 如果为 True,返回 (samples, step),其中 step 是样本之间的间隔. dtype: 输出张量的类型. axis: 结果中存储样本的轴.仅在 start 或 stop 为类数组时相关.默认为 0.

注意: Torch 后端不支持 axis 参数.

返回: 一个均匀间隔数字的张量. 如果 retstep 为 True,返回 (samples, step)

[source]

log function

keras.ops.log(x)

自然对数,逐元素计算.

参数: x: 输入张量.

返回: 输出张量,x的逐元素自然对数.

[source]

log10 function

keras.ops.log10(x)

返回输入张量按元素的以10为底的对数.

参数: x: 输入张量.

返回: 输出张量,x按元素的以10为底的对数.

[source]

log1p function

keras.ops.log1p(x)

返回x加一的自然对数,逐元素计算.

计算log(1 + x).

参数: x: 输入张量.

返回: 输出张量,逐元素计算1 + x的自然对数.

[source]

log2 function

keras.ops.log2(x)

x 的以 2 为底的对数,逐元素计算.

参数: x: 输入张量.

返回: 输出张量,逐元素计算 x 的以 2 为底的对数.

[source]

logaddexp function

keras.ops.logaddexp(x1, x2)

对输入的指数和的对数.

计算 log(exp(x1) + exp(x2)).

参数: x1: 输入张量. x2: 输入张量.

返回: 输出张量,输入的指数和的对数的逐元素结果.

[source]

logical_and function

keras.ops.logical_and(x1, x2)

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

零被视为False,非零被视为True.

参数: x1: 输入张量. x2: 输入张量.

返回: 输出张量,输入的元素逐位逻辑与.

[source]

logical_not function

keras.ops.logical_not(x)

计算给定输入张量的元素级非运算.

零被视为 False,非零被视为 True.

参数: x: 输入张量.

返回: 输出张量,输入张量的元素级逻辑非运算结果.

[source]

logical_or function

keras.ops.logical_or(x1, x2)

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

零被视为False,非零被视为True.

参数: x1: 输入张量. x2: 输入张量.

返回: 输出张量,输入的元素逻辑或.

[source]

logical_xor function

keras.ops.logical_xor(x1, x2)

计算 x1 XOR x2 的真值,逐元素进行.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出布尔张量.

[source]

logspace function

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 参数.

返回: 一个在对数尺度上均匀分布的样本张量.

[source]

matmul function

keras.ops.matmul(x1, x2)

两个张量的矩阵乘积.

• 如果两个张量都是一维的,则返回点积（标量）.
• 如果任一张量是 N 维的,N > 2,则将其视为堆叠在最后两个索引中的矩阵,并相应地进行广播.
• 如果第一个张量是一维的,则通过在其维度前添加一个 1 将其提升为矩阵.矩阵乘法后,添加的 1 被移除.
• 如果第二个张量是一维的,则通过在其维度后添加一个 1 将其提升为矩阵.矩阵乘法后,添加的 1 被移除.

参数: x1: 第一个张量. x2: 第二个张量.

返回: 输出张量,输入张量的矩阵乘积.

[source]

max function

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

返回一个张量或沿某个轴的最大值.

参数: x: 输入张量. axis: 要操作的轴或轴.默认情况下,使用展平的输入. keepdims: 如果设置为 True,减少的轴将保留在结果中,尺寸为1.默认为 False. initial: 输出元素的最小值.默认为 None.

返回: x 的最大值.

[source]

maximum function

keras.ops.maximum(x1, x2)

逐元素计算x1和x2的最大值.

参数: x1: 第一个张量. x2: 第二个张量.

返回: 输出张量,逐元素计算x1和x2的最大值.

[source]

mean function

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

计算指定轴上的算术平均值.

参数: x: 输入张量. axis: 计算平均值的轴.默认情况下,计算展平张量的平均值. keepdims: 如果设置为 True,减少的轴将保留在结果中,尺寸为1.

返回: 包含平均值的输出张量.

[source]

median function

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

计算指定轴的中位数.

参数: x: 输入张量. axis: 计算中位数的轴或轴.默认为axis=None,即计算展平数组后的中位数. keepdims: 如果设置为True,则被减少的轴将保留在结果中,尺寸为1.

返回: 输出张量.

[source]

meshgrid function

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

[source]

min function

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

返回一个张量或沿某个轴的最小值.

参数: x: 输入张量. axis: 要操作的轴.默认情况下,使用展平的输入. keepdims: 如果设置为 True,减少的轴将保留在结果中,尺寸为1.默认为 False. initial: 输出元素的最大值.默认为 None.

返回: x 的最小值.

[source]

minimum function

keras.ops.minimum(x1, x2)

逐元素取x1和x2的最小值.

参数: x1: 第一个张量. x2: 第二个张量.

返回: 输出张量,逐元素取x1和x2的最小值.

[source]

mod function

keras.ops.mod(x1, x2)

返回元素级别的除法余数.

参数: x1: 第一个张量. x2: 第二个张量.

返回: 输出张量,元素级别的除法余数.

[source]

moveaxis function

keras.ops.moveaxis(x, source, destination)

移动张量的轴到新位置.

其他轴保持其原始顺序.

参数: x: 需要重新排序轴的张量. source: 要移动的轴的原始位置.这些必须是唯一的. destination: 每个原始轴的目标位置.这些也必须是唯一的.

返回: 轴已移动的张量.

[source]

multiply function

keras.ops.multiply(x1, x2)

逐元素相乘参数.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的逐元素乘积.

[source]

nan_to_num function

keras.ops.nan_to_num(x, nan=0.0, posinf=None, neginf=None)

将NaN替换为零,将无穷大替换为大的有限数.

参数: x: 输入数据. nan: 可选的浮点数或整数.用于替换NaN条目的值. posinf: 可选的浮点数或整数. 用于替换正无穷大的值. neginf: 可选的浮点数或整数. 用于替换负无穷大的值.

返回: x,其中非有限值已被替换.

[source]

ndim function

keras.ops.ndim(x)

返回一个张量的维度数.

参数: x: 输入张量.

返回: x 中的维度数.

[source]

negative function

keras.ops.negative(x)

数值负号,逐元素操作.

参数: x: 输入张量.

返回: 输出张量, y = -x.

[source]

nonzero function

keras.ops.nonzero(x)

返回非零元素的索引.

参数: x: 输入张量.

返回: 非零元素的索引.

[source]

norm function

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

矩阵或向量范数.

此函数能够返回八种不同的矩阵范数之一,或无数种向量范数之一（如下所述）,具体取决于 ord 参数的值.

参数: x: 输入张量. ord: 范数的阶数（参见下面的注释表）.默认值为 None. axis: 如果 axis 是整数,它指定计算向量范数的 x 的轴.如果 axis 是 2 元组,它指定保存 2-D 矩阵的轴,并计算这些矩阵的矩阵范数. keepdims: 如果设置为 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

[source]

not_equal function

keras.ops.not_equal(x1, x2)

返回 (x1 != x2) 的逐元素结果.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的逐元素比较结果.

[source]

ones function

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

返回一个给定形状和类型的新张量,填充为1.

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

返回: 具有给定形状和数据类型的1的张量.

[source]

ones_like function

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

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

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

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

[source]

outer function

keras.ops.outer(x1, x2)

计算两个向量的外积.

给定两个向量 x1 和 x2,外积为:

out[i, j] = x1[i] * x2[j]

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: x1 和 x2 的外积.

[source]

pad function

keras.ops.pad(x, pad_width, mode="constant", constant_values=None)

填充一个张量.

参数: x: 需要填充的张量. pad_width: 每个轴边缘填充的数值数量. ((before_1, after_1), ...(before_N, after_N)) 为每个轴指定不同的填充宽度. ((before, after),) 产生相同的每个轴前后填充. (pad,) 或 int 是所有轴的 before = after = pad 填充宽度的快捷方式. mode: 以下之一 "constant", "edge", "linear_ramp", "maximum", "mean", "median", "minimum", "reflect", "symmetric", "wrap", "empty", "circular".默认为 "constant". constant_values: 如果 mode == "constant" 时填充的值. 默认为 0.如果 mode != "constant" 且不为 None,则抛出 ValueError.

注意: Torch 后端仅支持模式 "constant", "reflect", "symmetric" 和 "circular". 只有 Torch 后端支持 "circular" 模式.

注意: Tensorflow 后端仅支持模式 "constant", "reflect" 和 "symmetric".

返回: 填充后的张量.

[source]

power function

keras.ops.power(x1, x2)

第一个张量的元素按第二个张量的元素幂次提升,逐元素操作.

参数: x1: 底数. x2: 指数.

返回: 输出张量,x1中的底数按x2中的指数提升.

[source]

prod function

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

返回给定轴上张量元素的乘积.

参数: x: 输入张量. axis: 执行乘积的轴或轴.默认情况下,axis=None,将计算输入张量中所有元素的乘积. keepdims: 如果设置为True,则会在结果中保留被减少的轴,尺寸为1. dtype: 返回张量的数据类型.

返回: 给定轴或轴上x元素的乘积.

[source]

quantile function

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的轴.

[source]

ravel function

keras.ops.ravel(x)

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

返回一个包含输入元素的一维张量.

参数: x: 输入张量.

返回: 输出张量.

[source]

real function

keras.ops.real(x)

返回复数参数的实部.

参数: x: 输入张量.

返回: 复数参数的实部.

[source]

reciprocal function

keras.ops.reciprocal(x)

返回参数的倒数,逐元素计算.

计算 1/x.

参数: x: 输入张量.

返回: 输出张量,x 的逐元素倒数.

[source]

repeat function

keras.ops.repeat(x, repeats, axis=None)

重复张量中的每个元素.

参数: x: 输入张量. repeats: 每个元素的重复次数. axis: 沿其重复值的轴.默认情况下,使用展平的输入数组,并返回一个展平的输出数组.

返回: 输出张量.

[source]

reshape function

keras.ops.reshape(x, newshape)

Gives a new shape to a tensor without changing its data.

Arguments

• x: 输入张量.
• newshape: 新形状应与原始形状兼容. 一个形状维度可以是-1,在这种情况下,值是从数组的长度和剩余维度推断出来的.

Returns

重塑后的张量.

[source]

roll function

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

沿给定轴滚动张量元素.

超出最后一个位置的元素将在第一个位置重新引入.

参数: x: 输入张量. shift: 元素移动的位置数. axis: 元素移动的轴.默认情况下,数组在移动前会被展平,移动后会恢复原始形状.

返回: 输出张量.

[source]

round function

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

Evenly round to the given number of decimals.

Arguments

• x: 输入张量.
• decimals: 要舍入的小数位数.默认为 0.

Returns

输出张量.

[source]

sign function

keras.ops.sign(x)

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

参数: x: 输入张量.

返回: 与x形状相同的输出张量.

[source]

sin function

keras.ops.sin(x)

三角函数正弦,逐元素计算.

参数: x: 输入张量.

返回: 与x形状相同的输出张量.

[source]

sinh function

keras.ops.sinh(x)

双曲正弦,逐元素计算.

参数: x:输入张量.

返回: 与x形状相同的输出张量.

[source]

size function

keras.ops.size(x)

返回张量中的元素数量.

参数: x: 输入张量.

返回: x 中的元素数量.

[source]

sort function

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

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

参数: x: 输入张量. axis: 要排序的轴.如果为None,则在排序前将张量展平.默认为-1;即最后一个轴.

返回: 排序后的张量.

[source]

split function

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

分割一个张量为多个块.

参数: x: 输入张量. indices_or_sections: 如果是一个整数,N,张量将沿着axis被分割成N个等分部分.如果是一个1维的排序整数数组, 数组的元素表示沿着axis分割的索引. axis: 沿着分割的轴.默认为0.

注意: 使用Torch后端时,分割不一定导致等分.

返回: 一个张量列表.

[source]

sqrt function

keras.ops.sqrt(x)

返回一个张量逐元素的非负平方根.

参数: x: 输入张量.

返回: 输出张量,x的非负平方根.

[source]

square function

keras.ops.square(x)

返回输入的逐元素平方.

参数: x: 输入张量.

返回: 输出张量,x 的平方.

[source]

squeeze function

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

移除x中长度为1的轴.

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

返回: 移除所有或部分长度为1的维度的输入张量.

[source]

stack function

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

连接一系列张量沿一个新的轴.

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

参数: x: 一个张量序列. axis: 沿此轴堆叠.默认为0.

返回: 堆叠后的张量.

[source]

std function

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

计算指定轴上的标准差.

参数: x: 输入张量. axis: 计算标准差的轴. 默认是计算展平张量的标准差. keepdims: 如果设置为 True,减少的轴将保留在结果中,尺寸为1.

返回: 包含标准差值的输出张量.

[source]

subtract function

keras.ops.subtract(x1, x2)

逐元素减去参数.

参数: x1: 第一个输入张量. x2: 第二个输入张量.

返回: 输出张量,x1 和 x2 的逐元素差.

[source]

sum function

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

张量在给定轴上的和.

参数: x: 输入张量. axis: 计算和的轴.默认是计算展平张量的和. keepdims: 如果设置为 True,被减少的轴在结果中保留为大小为1的维度.

返回: 包含和的输出张量.

[source]

swapaxes function

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

交换张量的两个轴.

参数: x: 输入张量. axis1: 第一个轴. axis2: 第二个轴.

返回: 交换轴后的张量.

[source]

take function

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

沿轴从张量中提取元素.

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

返回: 相应的值张量.

[source]

take_along_axis function

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

从x中沿着给定的轴选择1-D indices处的值.

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

返回: 相应的值张量.

[source]

tan function

keras.ops.tan(x)

计算逐元素的正切值.

参数: x: 输入张量.

返回: 与x形状相同的输出张量.

[source]

tanh function

keras.ops.tanh(x)

双曲正切,逐元素计算.

参数: x:输入张量.

返回: 与x形状相同的输出张量.

[source]

tensordot function

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

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

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

返回: 输入张量的点积.

[source]

tile function

keras.ops.tile(x, repeats)

重复 x 由 repeats 给定的次数.

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

如果 x.ndim < d,x 将被提升为 d 维,通过在前面添加 新轴.

如果 x.ndim > d,repeats 将被提升为 x.ndim,通过在前面添加 1.

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

返回: 平铺后的输出张量.

[source]

trace function

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

返回张量对角线上的和.

如果 x 是二维的,则返回其给定偏移对角线上的和,即所有元素 x[i, i+offset] 的和.

如果 x 有多于两个维度,则由 axis1 和 axis2 指定的轴用于确定其迹的二维子数组.

结果张量的形状与 x 的形状相同,但去掉了 axis1 和 axis2.

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

返回: 如果 x 是二维的,则返回对角线的和.如果 x 有更多维度,则返回沿对角线的和的张量.

[source]

transpose function

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

返回一个转置了axes的张量.

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

返回: x的轴被置换后的结果.

[source]

tri function

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

返回一个在和对角线以下位置为1,其他位置为0的张量.

参数: N: 张量中的行数. M: 张量中的列数. k: 数组填充的次对角线. k = 0 是主对角线,而 k < 0 在其下方,k > 0 在其上方.默认值为0. dtype: 返回张量的数据类型.默认值为 "float32".

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

[source]

tril function

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

返回张量的下三角部分.

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

参数: x: 输入张量. k: 要清零元素的对角线.默认为0,即主对角线.k < 0在主对角线之下,k > 0在主对角线之上.

返回: x的下三角部分,形状和数据类型与x相同.

[source]

triu function

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

返回张量的上三角部分.

对于ndim超过2的张量,triu将应用于最后两个轴.

参数: x: 输入张量. k: 要清零元素的对角线下方.默认为0,即主对角线.k < 0在主对角线下方,k > 0在主对角线上方.

返回: x的上三角部分,形状和数据类型与x相同.

[source]

true_divide function

keras.ops.true_divide(x1, x2)

Alias for keras.ops.divide.

[source]

var function

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

计算指定轴上的方差.

参数: x: 输入张量. axis: 计算方差的轴.默认情况下,计算展平张量的方差. keepdims: 如果设置为 True,减少的轴将保留在结果中,尺寸为1.

返回: 包含方差的输出张量.

[source]

vdot function

keras.ops.vdot(x1, x2)

返回两个向量的点积.

如果第一个参数是复数,则使用第一个参数的复共轭进行点积计算.

多维张量在计算点积之前会被展平.

参数: x1: 第一个输入张量.如果为复数,则在计算点积之前取其复共轭. x2: 第二个输入张量.

返回: 输出张量.

[source]

vstack function

keras.ops.vstack(xs)

将张量按顺序垂直（行方向）堆叠.

参数: xs: 张量序列.

返回: 由给定张量堆叠形成的张量.

[source]

where function

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.

[source]

zeros function

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

返回一个给定形状和类型的新张量,填充为零.

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

返回: 具有给定形状和数据类型的零张量.

[source]

zeros_like function

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

返回一个与x具有相同形状和类型的零张量.

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

返回: 一个与x具有相同形状和类型的零张量.