NN 操作

[源代码]

average_pool 函数

keras.ops.average_pool(
    inputs, pool_size, strides=None, padding="valid", data_format=None
)

平均池化操作。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。池化仅在空间维度上进行。
• pool_size：整数或大小为 `len(inputs_spatial_shape)` 的整数元组/列表，指定输入张量每个空间维度的池化窗口大小。如果 `pool_size` 是整数，则每个空间维度共享相同的 `pool_size`。
• strides：整数或大小为 `len(inputs_spatial_shape)` 的整数元组/列表。输入张量每个空间维度的滑动窗口步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。

返回

一个秩为 N+2 的张量，即平均池化操作的结果。

[源代码]

batch_normalization 函数

keras.ops.batch_normalization(
    x, mean, variance, axis, offset=None, scale=None, epsilon=0.001
)

通过 `mean` 和 `variance` 对 `x` 进行归一化。

此操作通常用于神经网络中的批归一化步骤。它沿着给定轴对输入张量进行归一化。

参数

• x：输入张量。
• mean：一个均值向量，其长度与输入张量的 `axis` 维度相同。
• variance：一个方差向量，其长度与输入张量的 `axis` 维度相同。
• axis：整数，应被归一化的轴。
• offset：一个偏移向量，其长度与输入张量的 `axis` 维度相同。如果非 `None`，则将 `offset` 添加到归一化后的张量中。默认为 `None`。
• scale：一个缩放向量，其长度与输入张量的 `axis` 维度相同。如果非 `None`，则归一化后的张量将乘以 `scale`。默认为 `None`。
• epsilon：添加到方差中的小浮点数，以避免除以零。默认为 1e-3。

返回

归一化后的张量。

示例

>>> x = keras.ops.convert_to_tensor(
...     [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]]
... )
>>> keras.ops.batch_normalization(
...     x,
...     mean=[0.4, 0.5, 0.6],
...     variance=[0.67, 0.67, 0.67],
...     axis=-1
... )
array([[-3.6624e-01, -3.6624e-01, -3.6624e-01],
       [-4.6445e-09,  0.0000e+00, -1.8578e-08],
       [ 3.6624e-01,  3.6624e-01,  3.6624e-01]])

[源代码]

binary_crossentropy 函数

keras.ops.binary_crossentropy(target, output, from_logits=False)

计算目标张量和输出张量之间的二元交叉熵损失。

二元交叉熵损失通常用于二元分类任务，其中每个输入样本属于两个类别之一。它衡量目标概率或 logit 与输出概率或 logit 之间的差异性。

参数

• target：表示真实二元标签的目标张量。其形状应与 `output` 张量的形状匹配。
• output：表示预测概率或 logit 的输出张量。其形状应与 `target` 张量的形状匹配。
• from_logits：（可选）`output` 是一个 logit 张量还是概率张量。如果 `output` 表示 logit，则设置为 `True`；否则，如果 `output` 表示概率，则设置为 `False`。默认为 `False`。

返回

• 整数张量：`target` 和 `output` 之间计算出的二元交叉熵损失。

示例

>>> target = keras.ops.convert_to_tensor([0, 1, 1, 0])
>>> output = keras.ops.convert_to_tensor([0.1, 0.9, 0.8, 0.2])
>>> binary_crossentropy(target, output)
array([0.10536054 0.10536054 0.22314355 0.22314355],
      shape=(4,), dtype=float32)

[源代码]

categorical_crossentropy 函数

keras.ops.categorical_crossentropy(target, output, from_logits=False, axis=-1)

计算目标张量和输出张量之间的分类交叉熵损失。

分类交叉熵损失通常用于多类别分类任务，其中每个输入样本可以属于多个类别中的一个。它衡量目标概率或 logit 与输出概率或 logit 之间的差异性。

参数

• target：表示真实分类标签的目标张量。除了最后一个维度外，其形状应与 `output` 张量的形状匹配。
• output：表示预测概率或 logit 的输出张量。除了最后一个维度外，其形状应与 `target` 张量的形状匹配。
• from_logits：（可选）`output` 是一个 logit 张量还是概率张量。如果 `output` 表示 logit，则设置为 `True`；否则，如果 `output` 表示概率，则设置为 `False`。默认为 `False`。
• axis：（可选）计算分类交叉熵的轴。默认为 `-1`，对应于张量的最后一个维度。

返回

• 整数张量：`target` 和 `output` 之间计算出的分类交叉熵损失。

示例

>>> target = keras.ops.convert_to_tensor(
... [[1, 0, 0],
...  [0, 1, 0],
...  [0, 0, 1]])
>>> output = keras.ops.convert_to_tensor(
... [[0.9, 0.05, 0.05],
...  [0.1, 0.8, 0.1],
...  [0.2, 0.3, 0.5]])
>>> categorical_crossentropy(target, output)
array([0.10536054 0.22314355 0.6931472 ], shape=(3,), dtype=float32)

[源代码]

conv 函数

keras.ops.conv(
    inputs, kernel, strides=1, padding="valid", data_format=None, dilation_rate=1
)

通用 N 维卷积。

此操作支持 1D、2D 和 3D 卷积。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。
• kernel：秩为 N+2 的张量。`kernel` 的形状为 `(kernel_spatial_shape, num_input_channels, num_output_channels)`。`num_input_channels` 应与 `inputs` 中的通道数匹配。
• strides：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定卷积沿每个空间维度的步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。
• dilation_rate：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定用于扩张卷积的扩张率。如果 `dilation_rate` 是整数，则每个空间维度共享相同的 `dilation_rate`。

返回

一个秩为 N+2 的张量，即卷积操作的结果。

[源代码]

conv_transpose 函数

keras.ops.conv_transpose(
    inputs,
    kernel,
    strides=1,
    padding="valid",
    output_padding=None,
    data_format=None,
    dilation_rate=1,
)

通用 N 维转置卷积。

也称为反卷积。此操作支持 1D、2D 和 3D 卷积。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。
• kernel：秩为 N+2 的张量。`kernel` 的形状为 [kernel_spatial_shape, num_output_channels, num_input_channels]，`num_input_channels` 应与 `inputs` 中的通道数匹配。
• strides：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定卷积沿每个空间维度的步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• output_padding：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定沿输出张量高度和宽度的填充量。可以是一个单独的整数，为所有空间维度指定相同的值。沿给定维度的输出填充量必须小于沿该维度的步长。如果设置为 `None`（默认值），则会推断输出形状。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。
• dilation_rate：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定用于扩张卷积的扩张率。如果 `dilation_rate` 是整数，则每个空间维度共享相同的 `dilation_rate`。

返回

一个秩为 N+2 的张量，即卷积操作的结果。

[源代码]

ctc_decode 函数

keras.ops.ctc_decode(
    inputs,
    sequence_lengths,
    strategy="greedy",
    beam_width=100,
    top_paths=1,
    merge_repeated=True,
    mask_index=0,
)

解码 CTC 模型的输出。

参数

• inputs：形状为 `(batch_size, max_length, num_classes)` 的张量，包含 logit（模型的输出）。它们*不*应该通过 softmax进行归一化。
• sequence_lengths：形状为 `(batch_size,)` 的张量，包含批次的序列长度。
• strategy：解码策略的字符串。支持的值为 `"greedy"` 和 `"beam_search"`。
• beam_width：用于束搜索的整数标量束宽。默认为 100。
• top_paths：一个整数标量，表示要返回的顶部路径数。默认为 1。
• merge_repeated：一个布尔标量，指示是否在输出中合并重复的标签。默认为 `True`。
• mask_index：一个整数标量，词汇表中掩码字符的索引。默认为 `0`。

返回

• 一个包含以下内容的元组：:
• 表示已解码序列列表的张量。如果 `strategy="greedy"`，形状为 `(1, batch_size, max_length)`。如果 `strategy="beam_search"`，形状为 `(top_paths, batch_size, max_length)`。请注意：`-1` 表示空白标签。
• 如果 `strategy="greedy"`，则为形状 `(batch_size, 1)` 的张量，表示每个序列的概率 logit 之和的负数。如果 `strategy="beam_seatch"`，则为形状 `(batch_size, top_paths)` 的张量，表示每个序列的对数概率。

[源代码]

ctc_loss 函数

keras.ops.ctc_loss(target, output, target_length, output_length, mask_index=0)

CTC（连接时序分类）损失。

参数

• target：形状为 `(batch_size, max_length)` 的张量，包含整数格式的真实标签。
• output：形状为 `(batch_size, max_length, num_classes)` 的张量，包含 logit（模型的输出）。
• target_length：形状为 `(batch_size,)` 的张量，包含真实的标签长度。
• output_length：形状为 `(batch_size,)` 的张量，包含输出长度。
• mask_index：词汇表中掩码字符的索引。默认为 `0`。

[源代码]

depthwise_conv 函数

keras.ops.depthwise_conv(
    inputs, kernel, strides=1, padding="valid", data_format=None, dilation_rate=1
)

通用 N 维深度卷积。

此操作支持 1D 和 2D 深度卷积。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。
• kernel：秩为 N+2 的张量。`kernel` 的形状为 [kernel_spatial_shape, num_input_channels, num_channels_multiplier]，`num_input_channels` 应与 `inputs` 中的通道数匹配。
• strides：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定卷积沿每个空间维度的步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。
• dilation_rate：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定用于扩张卷积的扩张率。如果 `dilation_rate` 是整数，则每个空间维度共享相同的 `dilation_rate`。

返回

一个秩为 N+2 的张量，即深度卷积操作的结果。

[源代码]

dot_product_attention 函数

keras.ops.dot_product_attention(
    query,
    key,
    value,
    bias=None,
    mask=None,
    scale=None,
    is_causal=False,
    flash_attention=None,
    attn_logits_soft_cap=None,
)

缩放点积注意力函数。

在 Q (`query`)、K (`key`) 和 V (`value`) 上计算注意力函数：`attention(Q, K, V) = softmax(Q * K / sqrt(d)) * V`。如果我们将 `logits` 定义为 `Q * K` 的输出，将 `probs` 定义为 `softmax` 的输出。

在整个函数中，我们使用以下符号表示数组的形状： - B：批次大小 - S：键/值的长度 - T：查询的长度 - N：注意力头的数量 - H：每个注意力头的维度 - K：键/值头的数量 - G：组数，等于 `N // K`

参数

• query：形状为 `(B, T, N, H)` 的查询数组。
• key：形状为 `(B, S, K, H)` 的键数组。当 `K` 等于 `N` 时，执行多头注意力（MHA）。否则，如果 `N` 是 `K` 的倍数，则执行分组查询注意力（GQA）；如果 `K==1`（GQA 的一种特殊情况），则执行多查询注意力（MQA）。
• value：与 `key` 形状相同的值数组。
• bias：可选的偏置数组，将被添加到 logit 中。其形状必须可广播到 `(B, N, T, S)`。
• mask：可选的掩码数组，用于过滤 logit。它是一个布尔掩码，其中 `True` 表示该元素应参与注意力计算。对于加性掩码，用户应将其传递给偏置。其形状必须可广播到 `(B, N, T, S)`。
• scale：logit 的可选缩放因子。如果为 `None`，缩放因子将设置为 `1.0 / sqrt(H)`。
• is_causal：是否应用因果掩码。
• flash_attention：是否使用闪存注意力。如果为 `None`，在满足所需条件的情况下，将尝试使用闪存注意力。通常，输入必须是 float16 和 bfloat16 数据类型，并且输入布局要求可能因后端而异。
• attn_logits_soft_cap：在应用 softmax 函数之前，注意力 logit 最大值的限制值。这仅在 JAX TPU 后端支持。默认为 None。

返回

一个与 `query` 形状相同的注意力输出数组。

示例

>>> query = keras.random.normal((2, 4, 8, 16))
>>> key = keras.random.normal((2, 6, 8, 16))
>>> value = keras.random.normal((2, 6, 8, 16))
>>> keras.ops.nn.dot_product_attention(query, key, value).shape
(2, 4, 8, 16)

[源代码]

elu 函数

keras.ops.elu(x, alpha=1.0)

指数线性单元激活函数。

其定义为：

当 `x < 0` 时，`f(x) = alpha * (exp(x) - 1.)`；当 `x >= 0` 时，`f(x) = x`。

参数

• x：输入张量。
• alpha：一个标量，正区间的斜率。默认为 `1.0`。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_elu = keras.ops.elu(x)
>>> print(x_elu)
array([-0.63212055, 0., 1.], shape=(3,), dtype=float64)

[源代码]

gelu 函数

keras.ops.gelu(x, approximate=True)

高斯误差线性单元 (GELU) 激活函数。

如果 `approximate` 为 `True`，则定义为：`f(x) = 0.5 * x * (1 + tanh(sqrt(2 / pi) * (x + 0.044715 * x^3)))`

或者如果 `approximate` 为 `False`，则定义为：`f(x) = x * P(X <= x) = 0.5 * x * (1 + erf(x / sqrt(2)))`，其中 `P(X) ~ N(0, 1)`。

参数

• x：输入张量。
• approximate：GELU 激活的近似版本。默认为 `True`。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_gelu = keras.ops.gelu(x)
>>> print(x_gelu)
array([-0.15865525, 0., 0.84134475], shape=(3,), dtype=float64)

[源代码]

hard_sigmoid 函数

keras.ops.hard_sigmoid(x)

硬 Sigmoid 激活函数。

其定义为：

如果 `x < -2.5`，则为 `0`；如果 `x > 2.5`，则为 `1`；如果 `-2.5 <= x <= 2.5`，则为 `(0.2 * x) + 0.5`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_hard_sigmoid = keras.ops.hard_sigmoid(x)
>>> print(x_hard_sigmoid)
array([0.3, 0.5, 0.7], shape=(3,), dtype=float64)

[源代码]

leaky_relu 函数

keras.ops.leaky_relu(x, negative_slope=0.2)

修正线性单元激活函数的 Leaky 版本。

当单元未激活时，它允许一个小的梯度，其定义为

当 `x < 0` 时，`f(x) = alpha * x`；当 `x >= 0` 时，`f(x) = x`。

参数

• x：输入张量。
• negative_slope：当 x < 0 时激活函数的斜率。默认为 `0.2`。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_leaky_relu = keras.ops.leaky_relu(x)
>>> print(x_leaky_relu)
array([-0.2,  0. ,  1. ], shape=(3,), dtype=float64)

[源代码]

log_sigmoid 函数

keras.ops.log_sigmoid(x)

Sigmoid 激活函数的对数。

其定义为 `f(x) = log(1 / (1 + exp(-x)))`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-0.541391, 0.0, 0.50, 5.0])
>>> keras.ops.log_sigmoid(x)
array([-1.0000418, -0.6931472, -0.474077, -0.00671535], dtype=float32)

[源代码]

log_softmax 函数

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

Log-softmax 激活函数。

其定义为：`f(x) = x - max(x) - log(sum(exp(x - max(x))))`

参数

• x：输入张量。
• axis：整数，应用 log-softmax 的轴。默认为 `-1`。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_log_softmax = keras.ops.log_softmax(x)
>>> print(x_log_softmax)
array([-2.40760596, -1.40760596, -0.40760596], shape=(3,), dtype=float64)

[源代码]

max_pool 函数

keras.ops.max_pool(
    inputs, pool_size, strides=None, padding="valid", data_format=None
)

最大池化操作。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。池化仅在空间维度上进行。
• pool_size：整数或大小为 `len(inputs_spatial_shape)` 的整数元组/列表，指定输入张量每个空间维度的池化窗口大小。如果 `pool_size` 是整数，则每个空间维度共享相同的 `pool_size`。
• strides：整数或大小为 `len(inputs_spatial_shape)` 的整数元组/列表。输入张量每个空间维度的滑动窗口步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。

返回

一个秩为 N+2 的张量，即最大池化操作的结果。

[源代码]

moments 函数

keras.ops.moments(x, axes, keepdims=False, synchronized=False)

计算 `x` 的均值和方差。

均值和方差是通过聚合 `x` 在 `axes` 上的内容来计算的。如果 `x` 是 1-D 且 `axes = [0]`，这只是一个向量的均值和方差。

参数

• x：输入张量。
• axes：用于计算均值和方差的轴列表。
• keepdims：如果设置为 `True`，被缩减的轴将作为大小为 1 的维度保留在结果中。
• synchronized：仅适用于 TensorFlow 后端。如果为 `True`，则在分布式训练策略的每个训练步骤中，在所有设备上同步全局批次统计信息（均值和方差）。如果为 `False`，每个副本使用其自己的本地批次统计信息。

返回

一个包含两个张量的元组——均值和方差。

示例

>>> x = keras.ops.convert_to_tensor([0, 1, 2, 3, 100], dtype="float32")
>>> keras.ops.moments(x, axes=[0])
(array(21.2, dtype=float32), array(1553.3601, dtype=float32))

[源代码]

multi_hot 函数

keras.ops.multi_hot(
    inputs, num_classes=None, axis=-1, dtype=None, sparse=False, **kwargs
)

将整数标签编码为多热点向量。

此函数将整数标签编码为多热点向量，其中每个标签在结果向量中映射为一个二元值。

参数

• inputs：要转换为多热点向量的整数标签张量。
• num_classes：整数，唯一类的总数。
• axis：（可选）应添加多热点编码的轴。默认为 `-1`，对应于最后一个维度。
• dtype：（可选）结果张量的数据类型。默认为后端的浮点类型。
• sparse：是否返回稀疏张量；适用于支持稀疏张量的后端。

返回

• 张量：多热点编码的张量。

示例

>>> data = keras.ops.convert_to_tensor([0, 4])
>>> keras.ops.multi_hot(data, num_classes=5)
array([1.0, 0.0, 0.0, 0.0, 1.0], dtype=float32)

[源代码]

normalize 函数

keras.ops.normalize(x, axis=-1, order=2, epsilon=None)

沿指定轴对 `x` 进行归一化。

其定义为：`normalize(x) = x / max(norm(x), epsilon)`。

参数

• x：输入张量。
• axis：执行归一化的轴。默认为 -1。
• order：范数公式中的指数值。默认为 2。
• epsilon：范数的下限值。默认为 `backend.epsilon()`。

返回

归一化后的数组。

示例

>>> x = keras.ops.convert_to_tensor([[1, 2, 3], [4, 5, 6]])
>>> x_norm = keras.ops.math.normalize(x)
>>> print(x_norm)
array([[0.26726124 0.5345225  0.8017837 ]
       [0.45584232 0.5698029  0.68376344]], shape=(2, 3), dtype=float32)

[源代码]

one_hot 函数

keras.ops.one_hot(x, num_classes, axis=-1, dtype=None, sparse=False)

将整数张量 `x` 转换为独热张量。

独热编码是一种表示方法，其中每个整数值都转换为一个长度等于 `num_classes` 的二元向量，与整数值对应的索引标记为 1，而所有其他索引标记为 0。

参数

• x：要编码的整数张量。形状可以是任意的，但 dtype 应该是整数。
• num_classes：独热编码的类别数。
• axis：执行编码的轴。`-1` 表示最后一个轴。默认为 `-1`。
• dtype：（可选）输出张量的数据类型。如果未提供，则默认为后端的默认数据类型。
• sparse：是否返回稀疏张量；适用于支持稀疏张量的后端。

返回

• 整数张量：独热编码的张量，其形状与 `x` 相同，除了指定的 `axis` 维度，该维度的长度为 `num_classes`。输出张量的 dtype 由 `dtype` 或后端的默认数据类型决定。

示例

>>> x = keras.ops.convert_to_tensor([1, 3, 2, 0])
>>> one_hot(x, num_classes=4)
array([[0. 1. 0. 0.]
       [0. 0. 0. 1.]
       [0. 0. 1. 0.]
       [1. 0. 0. 0.]], shape=(4, 4), dtype=float32)

[源代码]

psnr 函数

keras.ops.psnr(x1, x2, max_val)

峰值信噪比（PSNR）函数。

该函数计算两个信号 `x1` 和 `x2` 之间的峰值信噪比。PSNR 是衡量重建信号质量的指标。PSNR 越高，重建信号越接近原始信号。请注意，当信号功率小于噪声功率时，它可能为负值。

参数

• x1：第一个输入信号。
• x2：第二个输入信号。必须与 `x1` 具有相同的形状。
• max_val：信号中可能的最大值。

返回

• float：`x1` 和 `x2` 之间的 PSNR 值。

示例

>>> x1 = keras.random.normal((2, 4, 4, 3))
>>> x2 = keras.random.normal((2, 4, 4, 3))
>>> max_val = 1.0
>>> keras.ops.nn.psnr(x1, x2, max_val)
-3.1697404

[源代码]

relu 函数

keras.ops.relu(x)

修正线性单元激活函数。

其定义为 `f(x) = max(0, x)`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x1 = keras.ops.convert_to_tensor([-1.0, 0.0, 1.0, 0.2])
>>> keras.ops.relu(x1)
array([0.0, 0.0, 1.0, 0.2], dtype=float32)

[源代码]

relu6 函数

keras.ops.relu6(x)

上限为 6 的修正线性单元激活函数。

其定义为 `f(x) = np.clip(x, 0, 6)`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-3.0, -2.0, 0.1, 0.2, 6.0, 8.0])
>>> keras.ops.relu6(x)
array([0.0, 0.0, 0.1, 0.2, 6.0, 6.0], dtype=float32)

[源代码]

selu 函数

keras.ops.selu(x)

缩放指数线性单元（SELU）激活函数。

其定义为：

当 `x < 0` 时，`f(x) = scale * alpha * (exp(x) - 1.)`；当 `x >= 0` 时，`f(x) = scale * x`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_selu = keras.ops.selu(x)
>>> print(x_selu)
array([-1.11133055, 0., 1.05070098], shape=(3,), dtype=float64)

[源代码]

separable_conv 函数

keras.ops.separable_conv(
    inputs,
    depthwise_kernel,
    pointwise_kernel,
    strides=1,
    padding="valid",
    data_format=None,
    dilation_rate=1,
)

通用 N 维可分离卷积。

此操作支持 1D 和 2D 可分离卷积。`separable_conv` 是一个深度卷积后跟一个逐点卷积。

参数

• inputs：秩为 N+2 的张量。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size,) + inputs_spatial_shape + (num_channels,)`；如果 `data_format="channels_first"`，则为 `(batch_size, num_channels) + inputs_spatial_shape`。
• depthwise_kernel：秩为 N+2 的张量。`depthwise_kernel` 的形状为 [kernel_spatial_shape, num_input_channels, num_channels_multiplier]，`num_input_channels` 应与 `inputs` 中的通道数匹配。
• pointwise_kernel：秩为 N+2 的张量。`pointwise_kernel` 的形状为 `(*ones_like(kernel_spatial_shape), num_input_channels * num_channels_multiplier, num_output_channels)`。
• strides：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定卷积沿每个空间维度的步长。如果 `strides` 是整数，则每个空间维度共享相同的 `strides`。
• padding：字符串，`"valid"` 或 `"same"`。`"valid"` 表示不应用填充，而 `"same"` 会在输入的左/右或上/下均匀填充，使得当 `strides=1` 时，输出具有与输入相同的高度/宽度维度。
• data_format：一个字符串，可以是 `"channels_last"` 或 `"channels_first"`。`data_format` 决定了输入中维度的顺序。如果 `data_format="channels_last"`，`inputs` 的形状为 `(batch_size, ..., channels)`；如果 `data_format="channels_first"`，`inputs` 的形状为 `(batch_size, channels, ...)`。
• dilation_rate：整数或长度为 `len(inputs_spatial_shape)` 的整数元组/列表，指定用于扩张卷积的扩张率。如果 `dilation_rate` 是整数，则每个空间维度共享相同的 `dilation_rate`。

返回

一个秩为 N+2 的张量，即深度卷积操作的结果。

[源代码]

sigmoid 函数

keras.ops.sigmoid(x)

Sigmoid 激活函数。

其定义为 `f(x) = 1 / (1 + exp(-x))`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-6.0, 1.0, 0.0, 1.0, 6.0])
>>> keras.ops.sigmoid(x)
array([0.00247262, 0.7310586, 0.5, 0.7310586, 0.9975274], dtype=float32)

[源代码]

silu 函数

keras.ops.silu(x)

Sigmoid 线性单元 (SiLU) 激活函数，也称为 Swish。

SiLU 激活函数由 sigmoid 函数乘以其输入计算得出。其定义为 `f(x) = x * sigmoid(x)`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-6.0, 1.0, 0.0, 1.0, 6.0])
>>> keras.ops.sigmoid(x)
array([0.00247262, 0.7310586, 0.5, 0.7310586, 0.9975274], dtype=float32)
>>> keras.ops.silu(x)
array([-0.0148357, 0.7310586, 0.0, 0.7310586, 5.9851646], dtype=float32)

[源代码]

hard_silu 函数

keras.ops.hard_silu(x)

Hard SiLU 激活函数，也称为 Hard Swish。

其定义为：

• 如果 `x < -3`，则为 `0`
• 如果 `x > 3`，则为 `x`
• 如果 `-3 <= x <= 3`，则为 `x * (x + 3) / 6`

它是 silu 激活的一种更快、分段线性的近似。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-3.0, -1.0, 0.0, 1.0, 3.0])
>>> keras.ops.hard_silu(x)
array([-0.0, -0.3333333, 0.0, 0.6666667, 3.0], shape=(5,), dtype=float32)

[源代码]

softmax 函数

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

Softmax 激活函数。

输出向量的元素位于 `(0, 1)` 范围内，它们的总和恰好为 1（不包括浮点舍入误差）。

每个向量都是独立处理的。`axis` 参数指定了在输入中应用该函数的轴。

其定义为：`f(x) = exp(x) / sum(exp(x))`

参数

• x：输入张量。
• axis：整数，应用 softmax 的轴。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_softmax = keras.ops.softmax(x)
>>> print(x_softmax)
array([0.09003057, 0.24472847, 0.66524096], shape=(3,), dtype=float64)

[源代码]

softplus 函数

keras.ops.softplus(x)

Softplus 激活函数。

其定义为 `f(x) = log(exp(x) + 1)`，其中 `log` 是自然对数，`exp` 是指数函数。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-0.555, 0.0, 0.555])
>>> keras.ops.softplus(x)
array([0.45366603, 0.6931472, 1.008666], dtype=float32)

[源代码]

softsign 函数

keras.ops.softsign(x)

Softsign 激活函数。

其定义为 `f(x) = x / (abs(x) + 1)`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-0.100, -10.0, 1.0, 0.0, 100.0])
>>> keras.ops.softsign(x)
Array([-0.09090909, -0.90909094, 0.5, 0.0, 0.990099], dtype=float32)

[源代码]

sparse_categorical_crossentropy 函数

keras.ops.sparse_categorical_crossentropy(target, output, from_logits=False, axis=-1)

计算稀疏分类交叉熵损失。

稀疏分类交叉熵损失与分类交叉熵类似，但当目标张量包含整数类标签而不是独热编码向量时使用。它衡量目标概率或 logit 与输出概率或 logit 之间的差异性。

参数

• target：表示真实类标签（作为整数）的目标张量。除了最后一个维度外，其形状应与 `output` 张量的形状匹配。
• output：表示预测概率或 logit 的输出张量。除了最后一个维度外，其形状应与 `target` 张量的形状匹配。
• from_logits：（可选）`output` 是一个 logit 张量还是概率张量。如果 `output` 表示 logit，则设置为 `True`；否则，如果 `output` 表示概率，则设置为 `False`。默认为 `False`。
• axis：（可选）计算稀疏分类交叉熵的轴。默认为 `-1`，对应于张量的最后一个维度。

返回

• 整数张量：`target` 和 `output` 之间计算出的稀疏分类交叉熵损失。

示例

>>> target = keras.ops.convert_to_tensor([0, 1, 2], dtype=int32)
>>> output = keras.ops.convert_to_tensor(
... [[0.9, 0.05, 0.05],
...  [0.1, 0.8, 0.1],
...  [0.2, 0.3, 0.5]])
>>> sparse_categorical_crossentropy(target, output)
array([0.10536056 0.22314355 0.6931472 ], shape=(3,), dtype=float32)

[源代码]

silu 函数

keras.ops.swish(x)

Sigmoid 线性单元 (SiLU) 激活函数，也称为 Swish。

SiLU 激活函数由 sigmoid 函数乘以其输入计算得出。其定义为 `f(x) = x * sigmoid(x)`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-6.0, 1.0, 0.0, 1.0, 6.0])
>>> keras.ops.sigmoid(x)
array([0.00247262, 0.7310586, 0.5, 0.7310586, 0.9975274], dtype=float32)
>>> keras.ops.silu(x)
array([-0.0148357, 0.7310586, 0.0, 0.7310586, 5.9851646], dtype=float32)

[源代码]

hard_silu 函数

keras.ops.hard_swish(x)

Hard SiLU 激活函数，也称为 Hard Swish。

其定义为：

• 如果 `x < -3`，则为 `0`
• 如果 `x > 3`，则为 `x`
• 如果 `-3 <= x <= 3`，则为 `x * (x + 3) / 6`

它是 silu 激活的一种更快、分段线性的近似。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = keras.ops.convert_to_tensor([-3.0, -1.0, 0.0, 1.0, 3.0])
>>> keras.ops.hard_silu(x)
array([-0.0, -0.3333333, 0.0, 0.6666667, 3.0], shape=(5,), dtype=float32)

[源代码]

celu 函数

keras.ops.celu(x, alpha=1.0)

连续可微指数线性单元。

其定义为：

当 `x < 0` 时，`f(x) = alpha * (exp(x / alpha) - 1)`；当 `x >= 0` 时，`f(x) = x`。

参数

• x：输入张量。
• alpha：CELU 公式中的 α 值。默认为 `1.0`。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_celu = keras.ops.celu(x)
>>> print(x_celu)
array([-0.63212056, 0. , 1. ], shape=(3,), dtype=float64)

[源代码]

sparsemax 函数

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

Sparsemax 激活函数。

对于每个批次 `i` 和类别 `j`，sparsemax 激活函数定义为

sparsemax(x)[i, j] = max(x[i, j] - τ(x[i, :]), 0)。

参数

• x：输入张量。
• axis：`int`，应用 sparsemax 操作的轴。

返回

一个张量，sparsemax 变换的输出。与 `x` 具有相同的类型和形状。

示例

>>> x = np.array([-1., 0., 1.])
>>> x_sparsemax = keras.ops.sparsemax(x)
>>> print(x_sparsemax)
array([0., 0., 1.], shape=(3,), dtype=float64)

[源代码]

squareplus 函数

keras.ops.squareplus(x, b=4)

Squareplus 激活函数。

Squareplus 激活函数定义为

f(x) = (x + sqrt(x^2 + b)) / 2

参数

• x：输入张量。
• b：平滑度参数。默认为 4。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1.0, 0.0, 1.0])
>>> x_squareplus = keras.ops.squareplus(x)
>>> print(x_squareplus)
array([0.6180, 1.0000, 1.6180], dtype=float32)

[源代码]

sparse_plus 函数

keras.ops.sparse_plus(x)

SparsePlus 激活函数。

其定义为：

当 `x <= -1` 时，`f(x) = 0`。当 `-1 < x < 1` 时，`f(x) = (1/4) * (x + 1)^2`。当 `x >= 1` 时，`f(x) = x`。

参数

• x：输入张量。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1.0, 0.0, 1.0])
>>> x_sparse_plus = keras.ops.sparse_plus(x)
>>> print(x_sparse_plus)
Array([0.   0.25 1.  ], shape=(3,), dtype=float32)

[源代码]

soft_shrink 函数

keras.ops.soft_shrink(x, threshold=0.5)

Soft Shrink 激活函数。

其定义为：

如果 `x > threshold`，则 `f(x) = x - threshold`；如果 `x < -threshold`，则 `f(x) = x + threshold`；否则 `f(x) = 0`。

参数

• x：输入张量。
• threshold：阈值。默认为 0.5。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1.0, 0.0, 1.0])
>>> x_soft_shrink = keras.ops.soft_shrink(x)
>>> print(x_soft_shrink)
array([-0.5  0.   0.5], shape=(3,), dtype=float64)

[源代码]

threshold 函数

keras.ops.threshold(x, threshold, default_value)

阈值激活函数。

该函数对输入 `x` 进行如下阈值处理：如果 `x > threshold`，则 `f(x) = x`；否则 `f(x) = default_value`。

参数

• x：输入张量。
• threshold：决定何时保留或替换 x 的值。
• default_value：当 `x <= threshold` 时要分配的值。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-1.0, 0.0, 1.0, 2.0])
>>> x_threshold = keras.ops.threshold(x, 1, 0)
>>> print(x_threshold)
array([0., 0., 0., 2.], shape=(4,), dtype=float64)

[源代码]

glu 函数

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

门控线性单元 (GLU) 激活函数。

其定义为：

f(x) = a * sigmoid(b)，其中 `x` 沿给定轴被分割为 `a` 和 `b`。

参数

• x：输入张量。
• axis：分割输入张量的轴。默认为 `-1`。

返回

一个形状为输入一半的张量。

示例

>>> x = np.array([-1., 0., 1. , 1.])
>>> x_glu = keras.ops.glu(x)
>>> print(x_glu)
array([-0.73105858, 0. ], shape=(2,), dtype=float64)

[源代码]

tanh_shrink 函数

keras.ops.tanh_shrink(x)

逐元素应用 tanh收缩函数。

其定义为：

f(x) = x - tanh(x).

参数

• x：输入张量。

返回

与 `x` 形状相同的输出张量，其中每个元素都根据 tanh 收缩操作进行转换。

示例

>>> x = np.array([ -1., 0., 1.])
>>> x_tanh_shrink = keras.ops.tanh_shrink(x)
>>> print(x_tanh_shrink)
array([-0.23840584  0.  0.23840584], shape=(3,), dtype=float64)

[源代码]

hard_tanh 函数

keras.ops.hard_tanh(x)

逐元素应用 HardTanh 函数。

其定义为：

当 `x < -1` 时，`f(x) = -1`；当 `-1 <= x <= 1` 时，`f(x) = x`；当 `x > 1` 时，`f(x) = 1`。

参数

• x：输入张量。

返回

与 `x` 形状相同的输出张量，其中值被限制在 -1 和 1 之间。

示例

>>> x = np.array([-2., -1., 0., 1., 2.])
>>> x_hard_tanh = keras.ops.hard_tanh(x)
>>> print(x_hard_tanh)
array([-1. -1.  0.  1.  1.], shape=(5,), dtype=float64)

[源代码]

hard_shrink 函数

keras.ops.hard_shrink(x, threshold=0.5)

Hard Shrink 激活函数。

Hard Shrink 函数是一个阈值操作，定义为

如果 `|x| > threshold`，则 `f(x) = x`；否则 `f(x) = 0`。

参数

• x：输入张量。
• threshold：阈值。默认为 0.5。

返回

一个与 `x` 形状相同的张量。

示例

>>> x = np.array([-0.5, 0., 1.])
>>> x_hard_shrink = keras.ops.hard_shrink(x)
>>> print(x_hard_shrink)
array([0. 0. 1.], shape=(3,), dtype=float64)