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"，则 inputs 的形状为 (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)

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

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

参数

target: 表示真实二元标签的目标张量。其形状应与 output 张量的形状匹配。
output: 表示预测概率或 logits 的输出张量。其形状应与 target 张量的形状匹配。
from_logits: （可选）output 是否为 logits 或概率的张量。如果 output 表示 logits，则将其设置为 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)

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

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

参数

target: 表示真实分类标签的目标张量。其形状应与 output 张量的形状匹配，除了最后一个维度。
output: 表示预测概率或 logits 的输出张量。其形状应与 target 张量的形状匹配，除了最后一个维度。
from_logits: （可选）output 是否为 logits 或概率的张量。如果 output 表示 logits，则将其设置为 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"，则 inputs 的形状为 (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 操作的结果。

[源代码]

`conv_transpose` 函数

keras.ops.conv_transpose(
    inputs,
    kernel,
    strides,
    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"，则 inputs 的形状为 (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 的张量，即 conv 操作的结果。

[源代码]

`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) 的张量，包含 logits（模型的输出）。它们不应通过 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) 的张量，表示每个序列的概率 logits 总和的负数。如果 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) 的张量，包含 logits（模型的输出）。
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 维深度卷积。

此操作支持一维和二维深度卷积。

参数

inputs: 秩为 N+2 的张量。如果 data_format="channels_last"，则 inputs 的形状为 (batch_size,) + inputs_spatial_shape + (num_channels,)；如果 data_format="channels_first"，则 inputs 的形状为 (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,
)

缩放点积注意力函数。

计算 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：可选的偏差数组，将添加到 logits 中。形状必须可广播到 (B, N, T, S)。
mask：可选的掩码数组，用于过滤 logits。它是一个布尔掩码，其中 True 表示元素应参与注意力。对于加性掩码，用户应将其传递给偏差。形状必须可广播到 (B, N, T, S)。
scale：logits 的可选缩放因子。如果为 None，则缩放因子将设置为 1.0 / sqrt(H)。
is_causal：是否应用因果掩码。
flash_attention：是否使用闪存注意力。如果为 None，则在满足必要条件时将尝试使用闪存注意力。通常，输入必须为 float16 和 bfloat16 数据类型，输入布局要求可能因后端而异。

返回值

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

指数线性单元激活函数。

定义如下

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

参数

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 激活函数。

定义如下

0 当 x < -2.5 时，1 当 x > 2.5 时，(0.2 * x) + 0.5 当 -2.5 <= x <= 2.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)

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

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

f(x) = alpha * x 当 x < 0 时 或 f(x) = x 当 x >= 0 时。

参数

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)

对数 softmax 激活函数。

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

参数

x: 输入张量。
axis：整数，应用对数 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"，则 inputs 的形状为 (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 的均值和方差。

均值和方差是通过跨 axes 聚合 x 的内容来计算的。如果 x 为一维且 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：是否返回稀疏张量；对于支持稀疏张量的后端。

返回值

Tensor：多热编码的张量。

示例

>>> 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：是否返回稀疏张量；对于支持稀疏张量的后端。

返回值

Integer tensor：独热编码的张量，与 x 形状相同，除了指定的 axis 维度，该维度的长度为 num_classes。输出张量的数据类型由 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) 激活函数。

定义如下

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

参数

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 维可分离卷积。

此操作支持一维和二维可分离卷积。separable_conv 是深度卷积后跟逐点卷积。

参数

inputs: 秩为 N+2 的张量。如果 data_format="channels_last"，则 inputs 的形状为 (batch_size,) + inputs_spatial_shape + (num_channels,)；如果 data_format="channels_first"，则 inputs 的形状为 (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)

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

定义如下

0 当 if x < -3 时
x 当 x > 3 时
x * (x + 3) / 6 当 -3 <= x <= 3 时

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

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

稀疏分类交叉熵损失类似于分类交叉熵，但它用于目标张量包含整数类标签而不是独热编码向量的情况。它衡量目标和输出概率或 logits 之间的差异。

参数

target：表示真实类标签（整数）的目标张量。其形状应与 output 张量的形状匹配，除了最后一维。
output: 表示预测概率或 logits 的输出张量。其形状应与 target 张量的形状匹配，除了最后一个维度。
from_logits: （可选）output 是否为 logits 或概率的张量。如果 output 表示 logits，则将其设置为 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)

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

定义如下

0 当 if x < -3 时
x 当 x > 3 时
x * (x + 3) / 6 当 -3 <= x <= 3 时

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

NN 操作

average_pool 函数

batch_normalization 函数

binary_crossentropy 函数

categorical_crossentropy 函数

conv 函数

conv_transpose 函数

ctc_decode 函数

ctc_loss 函数

depthwise_conv 函数

dot_product_attention 函数

elu 函数

gelu 函数

hard_sigmoid 函数

leaky_relu 函数

log_sigmoid 函数

log_softmax 函数

max_pool 函数

moments 函数

multi_hot 函数

normalize 函数

one_hot 函数

psnr 函数

relu 函数

relu6 函数

selu 函数

separable_conv 函数

sigmoid 函数

silu 函数

hard_silu 函数

softmax 函数

softplus 函数

softsign 函数

sparse_categorical_crossentropy 函数

silu 函数

hard_silu 函数

NN 操作

average_pool 函数

batch_normalization 函数

binary_crossentropy 函数

categorical_crossentropy 函数

conv 函数

conv_transpose 函数

ctc_decode 函数

ctc_loss 函数

depthwise_conv 函数

dot_product_attention 函数

elu 函数

gelu 函数

hard_sigmoid 函数

leaky_relu 函数

log_sigmoid 函数

log_softmax 函数

max_pool 函数

moments 函数

multi_hot 函数

normalize 函数

one_hot 函数

psnr 函数

relu 函数

relu6 函数

selu 函数

separable_conv 函数

sigmoid 函数

silu 函数

hard_silu 函数

softmax 函数

softplus 函数

softsign 函数

sparse_categorical_crossentropy 函数

silu 函数

hard_silu 函数

`average_pool` 函数

`batch_normalization` 函数

`binary_crossentropy` 函数

`categorical_crossentropy` 函数

`conv` 函数

`conv_transpose` 函数

`ctc_decode` 函数

`ctc_loss` 函数

`depthwise_conv` 函数

`dot_product_attention` 函数

`elu` 函数

`gelu` 函数

`hard_sigmoid` 函数

`leaky_relu` 函数

`log_sigmoid` 函数

`log_softmax` 函数

`max_pool` 函数

`moments` 函数

`multi_hot` 函数

`normalize` 函数

`one_hot` 函数

`psnr` 函数

`relu` 函数

`relu6` 函数

`selu` 函数

`separable_conv` 函数

`sigmoid` 函数

`silu` 函数

`hard_silu` 函数

`softmax` 函数

`softplus` 函数

`softsign` 函数

`sparse_categorical_crossentropy` 函数

`silu` 函数

`hard_silu` 函数