► Keras 3 API 文档 / 操作API / 核心操作

核心操作

`cast` function

keras.ops.cast(x, dtype)

将一个张量转换为所需的dtype.

参数: x: 一个张量或变量. dtype: 目标类型.

返回: 指定dtype的张量.

示例:

>>> x = keras.ops.arange(4)
>>> x = keras.ops.cast(x, dtype="float16")

[source]

`cond` function

keras.ops.cond(pred, true_fn, false_fn)

有条件地应用 true_fn 或 false_fn.

参数: pred: 布尔标量类型 true_fn: 可调用对象,返回 pred == True 情况下的输出. false_fn: 可调用对象,返回 pred == False 情况下的输出.

返回: 根据 pred 返回 true_fn 或 false_fn 的输出.

[source]

`convert_to_numpy` function

keras.ops.convert_to_numpy(x)

将张量转换为NumPy数组.

参数: x: 一个张量.

返回: 一个NumPy数组.

[source]

`convert_to_tensor` function

keras.ops.convert_to_tensor(x, dtype=None, sparse=None)

将一个NumPy数组转换为张量.

参数: x: 一个NumPy数组. dtype: 目标类型. sparse: 是否保持稀疏张量.False将导致稀疏张量被稠密化.默认值None表示仅在后台支持时才保持稀疏张量.

返回: 指定dtype的张量.

示例:

>>> x = np.array([1, 2, 3])
>>> y = keras.ops.convert_to_tensor(x)

[source]

`erf` function

keras.ops.erf(x)

计算 x 的误差函数,逐元素进行.

参数: x: 输入张量.

返回: 一个与 x 具有相同数据类型的张量.

示例:

>>> x = np.array([-3.0, -2.0, -1.0, 0.0, 1.0])
>>> keras.ops.erf(x)
array([-0.99998 , -0.99532, -0.842701,  0.,  0.842701], dtype=float32)

[source]

`erfinv` function

keras.ops.erfinv(x)

计算 x 的逆误差函数,逐元素进行.

参数: x: 输入张量.

返回: 一个与 x 具有相同数据类型的张量.

示例:

>>> x = np.array([-0.5, -0.2, -0.1, 0.0, 0.3])
>>> keras.ops.erfinv(x)
array([-0.47694, -0.17914, -0.08886,  0. ,  0.27246], dtype=float32)

[source]

`extract_sequences` function

keras.ops.extract_sequences(x, sequence_length, sequence_stride)

扩展最后一个轴的维度为长度为 sequence_length 的序列.

在输入的最后一个轴上滑动大小为 sequence_length 的窗口,步长为 sequence_stride, 将最后一个轴替换为 [num_sequences, sequence_length] 的序列.

如果最后一个轴的维度为 N,则序列的数量可以通过以下公式计算:

num_sequences = 1 + (N - sequence_length) // sequence_stride

参数: x: 输入张量. sequence_length: 一个整数,表示序列的长度. sequence_stride: 一个整数,表示序列的步长.

返回: 一个形状为 [..., num_sequences, sequence_length] 的序列张量.

示例:

>>> x = keras.ops.convert_to_tensor([1, 2, 3, 4, 5, 6])
>>> extract_sequences(x, 3, 2)
array([[1, 2, 3],
   [3, 4, 5]])

[source]

`fori_loop` function

keras.ops.fori_loop(lower, upper, body_fun, init_val)

循环实现.

参数: lower: 循环变量的初始值. upper: 循环变量的上限. body_fun: 表示循环体的可调用对象.必须接受两个参数:循环变量和循环状态.循环状态应由该函数更新并返回. init_val: 循环状态的初始值.

返回: 循环结束后的最终状态.

示例:

>>> lower = 0
>>> upper = 10
>>> body_fun = lambda i, s: (i + 1, s + i)
>>> init_val = 0
>>> keras.ops.fori_loop(lower, upper, body_fun, init_val)
45

[source]

`in_top_k` function

keras.ops.in_top_k(targets, predictions, k)

检查目标是否在top-k预测中.

参数: targets: 一个真实标签的张量. predictions: 一个预测标签的张量. k: 一个整数,表示要考虑的预测数量.

返回: 一个与targets形状相同的布尔张量,其中每个元素指示相应目标是否在top-k预测中.

示例:

>>> targets = keras.ops.convert_to_tensor([2, 5, 3])
>>> predictions = keras.ops.convert_to_tensor(
... [[0.1, 0.4, 0.6, 0.9, 0.5],
...  [0.1, 0.7, 0.9, 0.8, 0.3],
...  [0.1, 0.6, 0.9, 0.9, 0.5]])
>>> in_top_k(targets, predictions, k=3)
array([ True False  True], shape=(3,), dtype=bool)

[source]

`is_tensor` function

keras.ops.is_tensor(x)

检查给定对象是否为张量.

注意:此检查特定于后端的张量,因此如果您的后端是PyTorch或JAX,传递一个TensorFlow张量将返回False.

参数: x: 一个变量.

返回: True如果x是张量,否则False.

[source]

`logsumexp` function

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

计算张量中元素的指数和的对数.

参数: x: 输入张量. axis: 一个整数或整数的元组,指定计算和的轴.如果为None,则对所有元素进行求和.默认为None. keepdims: 一个布尔值,指示在计算和时是否保持输入张量的维度.默认为False.

返回: 包含x中元素的指数和的对数的张量.

示例:

>>> x = keras.ops.convert_to_tensor([1., 2., 3.])
>>> logsumexp(x)
3.407606

[source]

`rsqrt` function

keras.ops.rsqrt(x)

计算 x 元素逐个的平方根倒数.

参数: x: 输入张量

返回: 一个与 x 具有相同数据类型的张量.

示例:

>>> x = keras.ops.convert_to_tensor([1.0, 10.0, 100.0])
>>> keras.ops.rsqrt(x)
array([1.0, 0.31622776, 0.1], dtype=float32)

[source]

`scatter` function

keras.ops.scatter(indices, values, shape)

返回一个形状为 shape 的张量,其中 indices 被设置为 values.

从高层次来看,这个操作执行 zeros[indices] = updates 并返回输出.它等价于:

zeros = keras.ops.zeros(shape)
output = keras.ops.scatter_update(zeros, indices, values)

参数: indices: 一个张量或 list/tuple,指定 values 中的值的索引. values: 一个张量,要在 indices 处设置的值. shape: 输出张量的形状.

示例:

>>> indices = [[0, 1], [1, 1]]
>>> values = np.array([1., 1.])
>>> keras.ops.scatter(indices, values, shape=(2, 2))
array([[0., 1.],
       [0., 1.]])

[source]

`scatter_update` function

keras.ops.scatter_update(inputs, indices, updates)

更新输入通过分散（稀疏）索引处的更新.

在较高层次上,此操作执行 inputs[indices] = updates. 假设 inputs 是一个形状为 (D0, D1, ..., Dn) 的张量,scatter_update 主要有两种用法.

indices 是一个形状为 (num_updates, n) 的二维张量,其中 num_updates 是要执行的更新次数,updates 是一个形状为 (num_updates,) 的一维张量.例如,如果 inputs 是 zeros((4, 4, 4)), 并且我们想将 inputs[1, 2, 3] 和 inputs[0, 1, 3] 更新为 1,那么我们可以使用:

inputs = np.zeros((4, 4, 4))
indices = [[1, 2, 3], [0, 1, 3]]
updates = np.array([1., 1.])
inputs = keras.ops.scatter_update(inputs, indices, updates)

indices 是一个形状为 (num_updates, k) 的二维张量,其中 num_updates 是要执行的更新次数,k（k < n）是 indices 中每个索引的大小.updates 是一个形状为 (num_updates, inputs.shape[k:]) 的 n - k 维张量.例如,如果 inputs = np.zeros((4, 4, 4)),并且我们想将 inputs[1, 2, :] 和 inputs[2, 3, :] 更新为 [1, 1, 1, 1],那么 indices 将具有形状 (num_updates, 2)（k = 2）,updates 将具有形状 (num_updates, 4)（inputs.shape[2:] = 4）.请参见以下代码:

inputs = np.zeros((4, 4, 4))
indices = [[1, 2], [2, 3]]
updates = np.array([[1., 1., 1, 1,], [1., 1., 1, 1,])
inputs = keras.ops.scatter_update(inputs, indices, updates)

参数: inputs: 一个张量,要更新的张量. indices: 一个张量或形状为 (N, inputs.ndim) 的列表/元组,指定要更新的索引.N 是要更新的索引数量,必须等于 updates 的第一个维度. updates: 一个张量,要在 indices 处放入 inputs 的新值.

返回: 一个张量,具有与 inputs 相同的形状和数据类型.

[source]

`segment_max` function

keras.ops.segment_max(data, segment_ids, num_segments=None, sorted=False)

计算张量中各段的最大值.

参数: data: 输入张量. segment_ids: 一个N维张量,包含每个元素在data中的段索引. data.shape[:len(segment_ids.shape)] 应与 segment_ids.shape 匹配. num_segments: 一个整数,表示段的总数.如果未指定,则从 segment_ids中的最大值推断. sorted: 一个布尔值,指示segment_ids是否已排序. 默认为False.

返回: 一个张量,包含各段的最大值,其中每个元素表示data中相应段的最大值.

示例:

>>> data = keras.ops.convert_to_tensor([1, 2, 10, 20, 100, 200])
>>> segment_ids = keras.ops.convert_to_tensor([0, 0, 1, 1, 2, 2])
>>> num_segments = 3
>>> keras.ops.segment_max(data, segment_ids, num_segments)
array([2, 20, 200], dtype=int32)

[source]

`segment_sum` function

keras.ops.segment_sum(data, segment_ids, num_segments=None, sorted=False)

计算张量中各段的和.

参数: data: 输入张量. segment_ids: 一个N维张量,包含每个元素在data中的段索引. segment_ids的维度数应严格小于或等于data的维度数. num_segments: 一个整数,表示段的总数.如果未指定,则从 segment_ids中的最大值推断. sorted: 一个布尔值,指示segment_ids是否已排序. 默认为False.

返回: 一个张量,包含各段的和,其中每个元素表示data中相应段的和.

示例:

>>> data = keras.ops.convert_to_tensor([1, 2, 10, 20, 100, 200])
>>> segment_ids = keras.ops.convert_to_tensor([0, 0, 1, 1, 2, 2])
>>> num_segments = 3
>>> keras.ops.segment_sum(data, segment_ids,num_segments)
array([3, 30, 300], dtype=int32)

[source]

`shape` function

keras.ops.shape(x)

获取张量输入的形状.

注意:在TensorFlow后端,当x是一个具有动态形状的tf.Tensor时,在编译函数的上下文中动态的维度将具有一个tf.Tensor值,而不是一个静态的整数值.

参数: x: 一个张量.此函数将尝试访问输入张量的shape属性.

返回: 一个由整数或None值组成的元组,表示输入张量的形状.

示例:

>>> x = keras.ops.zeros((8, 12))
>>> keras.ops.shape(x)
(8, 12)

[source]

`slice` function

keras.ops.slice(inputs, start_indices, shape)

返回输入张量的一部分.

从高层次来看,这个操作是数组切片的显式替代例如 inputs[start_indices: start_indices + shape]. 与通过方括号进行切片不同,此操作将接受所有后端上的张量起始索引,这在通过其他张量操作动态计算索引时非常有用.

inputs = np.zeros((5, 5))
start_indices = np.array([3, 3])
shape = np.array([2, 2])
inputs = keras.ops.slice(inputs, start_indices, shape)

参数: inputs: 一个张量,要更新的张量. start_indices: 一个形状为 (inputs.ndim,) 的列表/元组,指定更新的起始索引. shape: 返回切片的全形状.

返回: 一个张量,具有与 inputs 相同的形状和数据类型.

[source]

`slice_update` function

keras.ops.slice_update(inputs, start_indices, updates)

更新输入张量,通过在指定位置切片插入更新值.

从高层次来看,这个操作执行的是 inputs[start_indices: start_indices + updates.shape] = updates. 假设 inputs 是一个形状为 (D0, D1, ..., Dn) 的张量, start_indices 必须是一个包含 n 个整数的列表/元组,指定起始索引.updates 必须与 inputs 具有相同的秩,并且每个维度的尺寸不得超过 Di - start_indices[i].例如,如果我们有 2D 输入 inputs = np.zeros((5, 5)),并且我们希望将最后 2 行和最后 2 列的交集更新为 1,即 inputs[3:, 3:] = np.ones((2, 2)),那么我们可以使用以下代码:

inputs = np.zeros((5, 5))
start_indices = [3, 3]
updates = np.ones((2, 2))
inputs = keras.ops.slice_update(inputs, start_indices, updates)

参数: inputs: 一个张量,需要更新的张量. start_indices: 一个形状为 (inputs.ndim,) 的列表/元组,指定更新的起始索引. updates: 一个张量,在 indices 处插入 inputs 的新值.updates 必须与 inputs 具有相同的秩.

返回: 一个张量,具有与 inputs 相同的形状和数据类型.

[source]

`stop_gradient` function

keras.ops.stop_gradient(variable)

停止梯度计算.

参数: variable: 一个张量变量,其梯度计算将被禁用.

返回: 禁用梯度计算的变量.

示例:

>>> var = keras.backend.convert_to_tensor(
...     [1., 2., 3.],
...     dtype="float32"
... )
>>> var = keras.ops.stop_gradient(var)

[source]

`top_k` function

keras.ops.top_k(x, k, sorted=True)

找到张量中的前k个值及其索引.

参数: x: 输入张量. k: 一个整数,表示要检索的前元素的数量. sorted: 一个布尔值,表示是否按降序排列输出.默认为True.

返回: 一个包含两个张量的元组.第一个张量包含前k个值,第二个张量包含输入张量中前k个值的索引.

示例:

>>> x = keras.ops.convert_to_tensor([5, 2, 7, 1, 9, 3])
>>> values, indices = top_k(x, k=3)
>>> print(values)
array([9 7 5], shape=(3,), dtype=int32)
>>> print(indices)
array([4 2 0], shape=(3,), dtype=int32)

[source]

`unstack` function

keras.ops.unstack(x, num=None, axis=0)

解包给定秩为R的张量的指定维度,生成秩为(R-1)的张量.

参数: x: 输入张量. num: 维度轴的长度.如果为None,则自动推断. axis: 要解包的轴.

返回: 沿着给定轴解包的张量列表.

示例:

>>> x = keras.ops.array([[1, 2], [3, 4]])
>>> keras.ops.unstack(x, axis=0)
[array([1, 2]), array([3, 4])]

[source]

`vectorized_map` function

keras.ops.vectorized_map(function, elements)

在张量elements的轴0上对function进行并行映射.

示意性地,vectorized_map在单个张量输入elements的情况下实现了以下内容:

def vectorized_map(function, elements)
    outputs = []
    for e in elements:
        outputs.append(function(e))
    return stack(outputs)

在张量可迭代对象elements的情况下,它实现了以下内容:

def vectorized_map(function, elements)
    batch_size = elements[0].shape[0]
    outputs = []
    for index in range(batch_size):
        outputs.append(function([e[index] for e in elements]))
    return np.stack(outputs)

在这种情况下,function应接受单个张量参数列表作为输入.

[source]

`while_loop` function

keras.ops.while_loop(cond, body, loop_vars, maximum_iterations=None)

While循环实现.

参数: cond: 一个表示循环终止条件的可调用对象. 必须接受一个类似loop_vars的结构作为参数.如果 loop_vars是一个元组或列表,loop_vars的每个元素将按位置传递给可调用对象. body: 一个表示循环体的可调用对象.必须接受一个类似loop_vars的结构作为参数,并返回具有相同结构的更新值. 如果loop_vars是一个元组或列表,loop_vars的每个元素将按位置传递给可调用对象. loop_vars: 一个任意嵌套结构的张量状态,用于在循环迭代中保持. maximum_iterations: 可选的最大循环迭代次数.如果提供,cond的输出将与一个确保执行的迭代次数不超过maximum_iterations的额外条件进行AND运算.

返回: 一个张量列表/元组,具有与inputs相同的形状和数据类型.

示例:

>>> i = 0
>>> cond = lambda i: i < 10
>>> body = lambda i: i + 1
>>> keras.ops.while_loop(cond, body, i)
10

>>> x, y = 0, 1
>>> cond = lambda x, y: x < 10
>>> body = lambda x, y: (x + 1, y + 1)
>>> keras.ops.while_loop(cond, body, (x, y))
10, 11

核心操作

cast function

cond function

convert_to_numpy function

convert_to_tensor function

erf function

erfinv function

extract_sequences function

fori_loop function

in_top_k function

is_tensor function

logsumexp function

rsqrt function

scatter function

scatter_update function

segment_max function

segment_sum function

shape function

slice function

slice_update function

stop_gradient function

top_k function

unstack function

vectorized_map function

while_loop function

核心操作

cast function

cond function

convert_to_numpy function

convert_to_tensor function

erf function

erfinv function

extract_sequences function

fori_loop function

in_top_k function

is_tensor function

logsumexp function

rsqrt function

scatter function

scatter_update function

segment_max function

segment_sum function

shape function

slice function

slice_update function

stop_gradient function

top_k function

unstack function

vectorized_map function

while_loop function

`cast` function

`cond` function

`convert_to_numpy` function

`convert_to_tensor` function

`erf` function

`erfinv` function

`extract_sequences` function

`fori_loop` function

`in_top_k` function

`is_tensor` function

`logsumexp` function

`rsqrt` function

`scatter` function

`scatter_update` function

`segment_max` function

`segment_sum` function

`shape` function

`slice` function

`slice_update` function

`stop_gradient` function

`top_k` function

`unstack` function

`vectorized_map` function

`while_loop` function