cudnn_ops 库#

数据类型参考#

这些是 cudnn_ops 库中的数据类型参考。

指向不透明结构类型的指针#

这些是 cudnn_ops 库中指向不透明结构类型的指针。

cudnnActivationDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnActivationDescriptor_t 是一个指向不透明结构的指针，该结构保存激活操作的描述。 cudnnCreateActivationDescriptor() 用于创建一个实例，并且必须使用 cudnnSetActivationDescriptor() 来初始化此实例。

cudnnCTCLossDescriptor_t#

cudnnCTCLossDescriptor_t 是一个指向不透明结构的指针，该结构保存 CTC 损失操作的描述。 cudnnCreateCTCLossDescriptor() 用于创建一个实例，cudnnSetCTCLossDescriptor() 用于初始化此实例，并且 cudnnDestroyCTCLossDescriptor() 用于销毁此实例。

cudnnDropoutDescriptor_t#

cudnnDropoutDescriptor_t 是一个指向不透明结构的指针，该结构保存 dropout 操作的描述。 cudnnCreateDropoutDescriptor() 用于创建一个实例，cudnnSetDropoutDescriptor() 用于初始化此实例，cudnnDestroyDropoutDescriptor() 用于销毁此实例，cudnnGetDropoutDescriptor() 用于查询先前初始化的实例的字段，cudnnRestoreDropoutDescriptor() 用于将实例恢复到先前保存的状态。

cudnnFilterDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnFilterDescriptor_t 是一个指向不透明结构的指针，该结构保存过滤器数据集的描述。 cudnnCreateFilterDescriptor() 用于创建一个实例，并且必须使用 cudnnSetFilter4dDescriptor() 或 cudnnSetFilterNdDescriptor() 来初始化此实例。

cudnnLRNDescriptor_t#

cudnnLRNDescriptor_t 是一个指向不透明结构的指针，该结构保存局部响应归一化的参数。 cudnnCreateLRNDescriptor() 用于创建一个实例，并且必须使用例程 cudnnSetLRNDescriptor() 来初始化此实例。

cudnnOpTensorDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnOpTensorDescriptor_t 是一个指向不透明结构的指针，该结构保存 Tensor Core 操作的描述，用作 cudnnOpTensor() 的参数。 cudnnCreateOpTensorDescriptor() 用于创建一个实例，并且必须使用 cudnnSetOpTensorDescriptor() 来初始化此实例。

cudnnPoolingDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnPoolingDescriptor_t 是一个指向不透明结构的指针，该结构保存池化操作的描述。 cudnnCreatePoolingDescriptor() 用于创建一个实例，并且必须使用 cudnnSetPoolingNdDescriptor() 或 cudnnSetPooling2dDescriptor() 来初始化此实例。

cudnnReduceTensorDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnReduceTensorDescriptor_t 是一个指向不透明结构的指针，该结构保存张量归约操作的描述，用作 cudnnReduceTensor() 的参数。 cudnnCreateReduceTensorDescriptor() 用于创建一个实例，并且必须使用 cudnnSetReduceTensorDescriptor() 来初始化此实例。

cudnnSpatialTransformerDescriptor_t#

cudnnSpatialTransformerDescriptor_t 是一个指向不透明结构的指针，该结构保存空间变换操作的描述。 cudnnCreateSpatialTransformerDescriptor() 用于创建一个实例，cudnnSetSpatialTransformerNdDescriptor() 用于初始化此实例，并且 cudnnDestroySpatialTransformerDescriptor() 用于销毁此实例。

cudnnTensorDescriptor_t#

cudnnTensorDescriptor_t 是一个指向不透明结构的指针，该结构保存通用 n 维数据集的描述。 cudnnCreateTensorDescriptor() 用于创建一个实例，并且必须使用例程 cudnnSetTensorNdDescriptor()、cudnnSetTensor4dDescriptor() 或 cudnnSetTensor4dDescriptorEx() 之一来初始化此实例。

cudnnTensorTransformDescriptor_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnTensorTransformDescriptor_t 是一个不透明结构，包含张量变换的描述。使用 cudnnCreateTensorTransformDescriptor() 函数创建此描述符的实例，并使用 cudnnDestroyTensorTransformDescriptor() 函数销毁先前创建的实例。

枚举类型#

这些是 cudnn_ops 库中的枚举类型。

cudnnBatchNormMode_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnBatchNormMode_t 是一种枚举类型，用于指定 cudnnBatchNormalizationForwardInference()、cudnnBatchNormalizationForwardTraining()、cudnnBatchNormalizationBackward() 和 cudnnDeriveBNTensorDescriptor() 例程中的操作模式。

值

CUDNN_BATCHNORM_PER_ACTIVATION

归一化操作按 activation 执行。此模式旨在用于非卷积网络层之后。在此模式下，bnBias 和 bnScale 的张量维度以及 cudnnBatchNormalization* 函数中使用的参数为 1xCxHxW。

CUDNN_BATCHNORM_SPATIAL

归一化操作在 N+空间维度上执行。此模式旨在用于卷积层之后（在卷积层中需要空间不变性）。在此模式下，bnBias 和 bnScale 张量维度为 1xCx1x1。

CUDNN_BATCHNORM_SPATIAL_PERSISTENT

此模式类似于 CUDNN_BATCHNORM_SPATIAL，但在某些任务中可能更快。

对于以下两个批归一化 API 调用，CUDNN_DATA_FLOAT 和 CUDNN_DATA_HALF 类型，计算能力 6.0 或更高版本，可以选择优化的路径：cudnnBatchNormalizationForwardTraining() 和 cudnnBatchNormalizationBackward()。在 cudnnBatchNormalizationBackward() 的情况下，savedMean 和 savedInvVariance 参数不应为 NULL。

NCHW 模式限定 此模式可能使用确定性的缩放原子整数归约，但这会对输入数据范围施加更多限制。当发生数值溢出时，算法可能会在输出缓冲区中产生 NaN 或 Inf（无穷大）。

当输入数据中存在 Inf/NaN 时，此模式下的输出与纯浮点实现相同。

对于有限但非常大的输入值，由于动态范围较小，算法可能会更频繁地遇到溢出并发出 Inf/NaN，而 CUDNN_BATCHNORM_SPATIAL 将产生有限的结果。用户可以调用 cudnnQueryRuntimeError() 来检查此模式下是否发生了数值溢出。

cudnnBatchNormOps_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnBatchNormOps_t 是一种枚举类型，用于指定 cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize()、cudnnBatchNormalizationForwardTrainingEx()、cudnnGetBatchNormalizationBackwardExWorkspaceSize()、cudnnBatchNormalizationBackwardEx() 和 cudnnGetBatchNormalizationTrainingExReserveSpaceSize() 函数中的操作模式。

值

CUDNN_BATCHNORM_OPS_BN

仅执行批归一化，按 activation 执行。

CUDNN_BATCHNORM_OPS_BN_ACTIVATION

首先执行批归一化，然后执行 activation。

CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION

执行批归一化，然后执行逐元素加法，然后执行 activation 操作。

cudnnConvolutionBwdDataAlgo_t#

cudnnConvolutionBwdDataAlgo_t 是一种枚举类型，它公开了可用于执行反向数据卷积操作的不同算法。

值

CUDNN_CONVOLUTION_BWD_DATA_ALGO_0

此算法将卷积表示为矩阵乘积之和，而无需实际显式形成保存输入张量数据的矩阵。总和使用原子加法运算完成，因此结果是非确定性的。

CUDNN_CONVOLUTION_BWD_DATA_ALGO_1

此算法将卷积表示为矩阵乘积，而无需实际显式形成保存输入张量数据的矩阵。结果是确定性的。

CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT

此算法使用快速傅里叶变换方法来计算卷积。需要大量的内存工作空间来存储中间结果。结果是确定性的。

CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT_TILING

此算法使用快速傅里叶变换方法，但将输入拆分为平铺块。需要大量的内存工作空间来存储中间结果，但对于大型图像，比 CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT 少。结果是确定性的。

CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD

此算法使用 Winograd 变换方法来计算卷积。需要合理大小的工作空间来存储中间结果。结果是确定性的。

CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED

此算法使用 Winograd 变换方法来计算卷积。可能需要大量的工作空间来存储中间结果。结果是确定性的。

cudnnConvolutionBwdFilterAlgo_t#

cudnnConvolutionBwdFilterAlgo_t 是一种枚举类型，它公开了可用于执行反向滤波器卷积操作的不同算法。

值

CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0

此算法将卷积表示为矩阵乘积之和，而无需实际显式形成保存输入张量数据的矩阵。总和使用原子加法运算完成，因此结果是非确定性的。

CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1

此算法将卷积表示为矩阵乘积，而无需实际显式形成保存输入张量数据的矩阵。结果是确定性的。

CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT

此算法使用快速傅里叶变换方法来计算卷积。需要大量的工作空间来存储中间结果。结果是确定性的。

CUDNN_CONVOLUTION_BWD_FILTER_ALGO_3

此算法类似于 CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0，但使用一些小型工作空间来预先计算一些索引。结果也是非确定性的。

CUDNN_CONVOLUTION_BWD_FILTER_WINOGRAD_NONFUSED

此算法使用 Winograd 变换方法来计算卷积。可能需要大量的工作空间来存储中间结果。结果是确定性的。

CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT_TILING

此算法使用快速傅里叶变换方法来计算卷积，但将输入张量拆分为平铺块。可能需要大量的工作空间来存储中间结果。结果是确定性的。

cudnnConvolutionFwdAlgo_t#

cudnnConvolutionFwdAlgo_t 是一种枚举类型，它公开了可用于执行前向卷积操作的不同算法。

值

CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM

此算法将卷积表示为矩阵乘积，而无需实际显式形成保存输入张量数据的矩阵。

CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PPRECOMP_GEMM

此算法将卷积表示为矩阵乘积，而无需实际显式形成保存输入张量数据的矩阵，但仍需要一些内存工作空间来预先计算一些索引，以便于隐式构造保存输入张量数据的矩阵。

CUDNN_CONVOLUTION_FWD_ALGO_GEMM

此算法将卷积表示为显式矩阵乘积。需要大量的内存工作空间来存储保存输入张量数据的矩阵。

CUDNN_CONVOLUTION_FWD_ALGO_DIRECT

此算法将卷积表示为直接卷积（例如，不隐式或显式地进行矩阵乘法）。

CUDNN_CONVOLUTION_FWD_ALGO_FFT

此算法使用快速傅里叶变换方法来计算卷积。需要大量的内存工作空间来存储中间结果。

CUDNN_CONVOLUTION_FWD_ALGO_FFT_TILING

此算法使用快速傅里叶变换方法，但将输入拆分为平铺块。需要大量的内存工作空间来存储中间结果，但对于大型图像，比 CUDNN_CONVOLUTION_FWD_ALGO_FFT 少。

CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD

此算法使用 Winograd 变换方法来计算卷积。需要合理大小的工作空间来存储中间结果。

CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED

此算法使用 Winograd 变换方法来计算卷积。可能需要大量的工作空间来存储中间结果。

cudnnCTCLossAlgo_t#

cudnnCTCLossAlgo_t 是一种枚举类型，它公开了可用于执行 CTC 损失操作的不同算法。

值

CUDNN_CTC_LOSS_ALGO_DETERMINISTIC

保证结果可重现。

CUDNN_CTC_LOSS_ALGO_NON_DETERMINISTIC

不保证结果可重现。

cudnnDeterminism_t#

cudnnDeterminism_t 是一种枚举类型，用于指示计算结果是否是确定性的（可重现的）。有关更多信息，请参阅 再现性（确定性）。

值

CUDNN_NON_DETERMINISTIC

不保证结果可重现。

CUDNN_DETERMINISTIC

保证结果可重现。

cudnnDivNormMode_t#

cudnnDivNormMode_t 是一种枚举类型，用于指定 cudnnDivisiveNormalizationForward() 和 cudnnDivisiveNormalizationBackward() 中的操作模式。

值

CUDNN_DIVNORM_PRECOMPUTED_MEANS

预期均值张量数据指针包含用户预先计算的均值或其他内核卷积值。均值指针也可以为 NULL，在这种情况下，它被认为填充了零。这等效于空间 LRN。

在反向传播中，均值被视为独立的输入，并且独立计算均值的梯度。在此模式下，为了产生整个 LCN 计算图上的净梯度，应将 destDiffMeans 结果通过用户的均值层（可以使用平均池化来实现）反向传播，并添加到 cudnnDivisiveNormalizationBackward() 生成的 destDiffData 张量中。

cudnnFoldingDirection_t#

cudnnFoldingDirection_t 是一种枚举类型，用于选择折叠方向。有关更多信息，请参阅 cudnnTensorTransformDescriptor_t。

数据成员

CUDNN_TRANSFORM_FOLD = 0U

选择折叠。

CUDNN_TRANSFORM_UNFOLD = 1U

选择展开。

cudnnIndicesType_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnIndicesType_t 是一种枚举类型，用于指示 cudnnReduceTensor() 例程要计算的索引的数据类型。此枚举类型用作 cudnnReduceTensorDescriptor_t 描述符的字段。

值

CUDNN_32BIT_INDICES

计算无符号 int 索引。

CUDNN_64BIT_INDICES

计算无符号 long 索引。

CUDNN_16BIT_INDICES

计算无符号 short 索引。

CUDNN_8BIT_INDICES

计算无符号 char 索引。

cudnnLRNMode_t#

cudnnLRNMode_t 是一种枚举类型，用于指定 cudnnLRNCrossChannelForward() 和 cudnnLRNCrossChannelBackward() 中的操作模式。

值

CUDNN_LRN_CROSS_CHANNEL_DIM1

LRN 计算跨张量的维度 dimA[1] 执行。

cudnnNormAlgo_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnNormAlgo_t 是一种枚举类型，用于指定执行归一化操作的算法。

值

CUDNN_NORM_ALGO_STANDARD

执行标准归一化。

CUDNN_NORM_ALGO_PERSIST

此模式类似于 CUDNN_NORM_ALGO_STANDARD，但它仅支持 CUDNN_NORM_PER_CHANNEL，并且在某些任务中可能更快。

对于以下两个归一化 API 调用，CUDNN_DATA_FLOAT 和 CUDNN_DATA_HALF 类型，计算能力 6.0 或更高版本，可以选择优化的路径：cudnnNormalizationForwardTraining() 和 cudnnNormalizationBackward()。在 cudnnNormalizationBackward() 的情况下，savedMean 和 savedInvVariance 参数不应为 NULL。

NCHW 模式限定 此模式可能使用确定性的缩放原子整数归约，但这会对输入数据范围施加更多限制。当发生数值溢出时，算法可能会在输出缓冲区中产生 NaN 或 Inf（无穷大）。

当输入数据中存在 Inf/NaN 时，此模式下的输出与纯浮点实现相同。

对于有限但非常大的输入值，由于动态范围较小，算法可能会更频繁地遇到溢出并发出 Inf/NaN，而 CUDNN_NORM_ALGO_STANDARD 将产生有限的结果。用户可以调用 cudnnQueryRuntimeError() 来检查此模式下是否发生了数值溢出。

cudnnNormMode_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnNormMode_t 是一种枚举类型，用于指定 cudnnNormalizationForwardInference()、cudnnNormalizationForwardTraining()、cudnnBatchNormalizationBackward()、cudnnGetNormalizationForwardTrainingWorkspaceSize()、cudnnGetNormalizationBackwardWorkspaceSize() 和 cudnnGetNormalizationTrainingReserveSpaceSize() 例程中的操作模式。

值

CUDNN_NORM_PER_ACTIVATION

归一化操作按 activation 执行。此模式旨在用于非卷积网络层之后。在此模式下，normBias 和 normScale 的张量维度以及 cudnnNormalization* 函数中使用的参数为 1xCxHxW。

CUDNN_NORM_PER_CHANNEL

归一化操作在 N+空间维度上按通道执行。此模式旨在用于卷积层之后（在卷积层中需要空间不变性）。在此模式下，normBias 和 normScale 张量维度为 1xCx1x1。

cudnnNormOps_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnNormOps_t 是一种枚举类型，用于指定 cudnnGetNormalizationForwardTrainingWorkspaceSize()、cudnnNormalizationForwardTraining()、cudnnGetNormalizationBackwardWorkspaceSize()、cudnnNormalizationBackward() 和 cudnnGetNormalizationTrainingReserveSpaceSize() 函数中的操作模式。

值

CUDNN_NORM_OPS_NORM

仅执行归一化。

CUDNN_NORM_OPS_NORM_ACTIVATION

首先执行归一化，然后执行 activation。

CUDNN_NORM_OPS_NORM_ADD_ACTIVATION

执行归一化，然后执行逐元素加法，然后执行 activation 操作。

cudnnOpTensorOp_t#

cudnnOpTensorOp_t 是一种枚举类型，用于指示 cudnnOpTensor() 例程要使用的 Tensor Core 操作。此枚举类型用作 cudnnOpTensorDescriptor_t 描述符的字段。

值

CUDNN_OP_TENSOR_ADD

要执行的操作是加法。

CUDNN_OP_TENSOR_MUL

要执行的操作是乘法。

CUDNN_OP_TENSOR_MIN

要执行的操作是最小值比较。

CUDNN_OP_TENSOR_MAX

要执行的操作是最大值比较。

CUDNN_OP_TENSOR_SQRT

要执行的操作是平方根，仅对 A 张量执行。

CUDNN_OP_TENSOR_NOT

要执行的操作是取反，仅对 A 张量执行。

cudnnPoolingMode_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnPoolingMode_t 是一个枚举类型，传递给 cudnnSetPooling2dDescriptor() 以选择 cudnnPoolingForward() 和 cudnnPoolingBackward() 要使用的池化方法。

值

CUDNN_POOLING_MAX

使用池化窗口内的最大值。

CUDNN_POOLING_AVERAGE_COUNT_INCLUDE_PADDING

池化窗口内的值被平均。用于计算平均值的元素数量包括填充区域内的空间位置。

CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING

池化窗口内的值被平均。用于计算平均值的元素数量不包括填充区域内的空间位置。

CUDNN_POOLING_MAX_DETERMINISTIC

使用池化窗口内的最大值。使用的算法是确定性的。

cudnnReduceTensorIndices_t#

此枚举类型已弃用，目前仅供已弃用的 API 使用。考虑使用替代已弃用 API 的方法，这些 API 使用此枚举类型。

cudnnReduceTensorIndices_t 是一个枚举类型，用于指示是否要由 cudnnReduceTensor() 例程计算索引。此枚举类型用作 cudnnReduceTensorDescriptor_t 描述符的字段。

值

CUDNN_REDUCE_TENSOR_NO_INDICES

不计算索引。

CUDNN_REDUCE_TENSOR_FLATTENED_INDICES

计算索引。结果索引是相对的且扁平化的。

cudnnSamplerType_t#

cudnnSamplerType_t 是一个枚举类型，传递给 cudnnSetSpatialTransformerNdDescriptor() 以选择 cudnnSpatialTfSamplerForward() 和 cudnnSpatialTfSamplerBackward() 要使用的采样器类型。

值

CUDNN_SAMPLER_BILINEAR

选择双线性采样器。

cudnnSoftmaxAlgorithm_t#

cudnnSoftmaxAlgorithm_t 用于选择 cudnnSoftmaxForward() 和 cudnnSoftmaxBackward() 中使用的 softmax 函数的实现。

值

CUDNN_SOFTMAX_FAST

此实现应用直接的 softmax 操作。

CUDNN_SOFTMAX_ACCURATE

此实现通过其最大值缩放 softmax 输入域的每个点，以避免 softmax 评估中潜在的浮点溢出。

CUDNN_SOFTMAX_LOG

此条目执行 log softmax 操作，通过缩放输入域中的每个点来避免溢出，如 CUDNN_SOFTMAX_ACCURATE 中所示。

cudnnSoftmaxMode_t#

cudnnSoftmaxMode_t 用于选择 cudnnSoftmaxForward() 和 cudnnSoftmaxBackward() 计算结果所依据的数据。

值

CUDNN_SOFTMAX_MODE_INSTANCE softmax 操作是针对每个图像 (N) 在维度 C,H,W 上计算的。

CUDNN_SOFTMAX_MODE_CHANNEL softmax 操作是针对每个空间位置 (H,W) 每个图像 (N) 在维度 C 上计算的。

API 函数#

这些是 cudnn_ops 库中的 API 函数。

cudnnActivationBackward()#

此函数在 cuDNN 9.0 中已弃用。

此例程计算神经元激活函数的梯度。

cudnnStatus_t cudnnActivationBackward(
    cudnnHandle_t                    handle,
    cudnnActivationDescriptor_t      activationDesc,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    yDesc,
    const void                      *y,
    const cudnnTensorDescriptor_t    dyDesc,
    const void                      *dy,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *beta,
    const cudnnTensorDescriptor_t    dxDesc,
    void                            *dx)

此例程允许就地操作；意味着 dy 和 dx 指针可能相等。但是，这要求相应的张量描述符是相同的（特别是，对于允许就地操作，输入和输出的步幅必须匹配）。

所有张量格式都支持 4 维和 5 维，但是，当 yDesc 和 xDesc 的步幅相等且 HW packed 时，可获得最佳性能。对于超过 5 维的张量，其空间维度必须是 packed 的。

参数

handle

输入。指向先前创建的 cuDNN 上下文的句柄。有关更多信息，请参阅 cudnnHandle_t。

activationDesc

输入。激活描述符。有关更多信息，请参阅 cudnnActivationDescriptor_t。

alpha, beta

输入。指向用于将计算结果与输出层中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

yDesc

输入。指向先前初始化的输入张量描述符的句柄。有关更多信息，请参阅 cudnnTensorDescriptor_t。

y

输入。指向与张量描述符 yDesc 关联的 GPU 内存的数据指针。

dyDesc

输入。指向先前初始化的输入微分张量描述符的句柄。

dy

输入。指向与张量描述符 dyDesc 关联的 GPU 内存的数据指针。

xDesc

输入。指向先前初始化的输出张量描述符的句柄。

x

输入。指向与输出张量描述符 xDesc 关联的 GPU 内存的数据指针。

dxDesc

输入。指向先前初始化的输出微分张量描述符的句柄。

dx

输出。指向与输出张量描述符 dxDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 输入微分张量和输出微分张量的步幅 nStride、cStride、hStride、wStride 不同，并且使用了就地操作。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。有关一些不支持的配置示例，请参阅以下内容

  • 输入张量和输出张量的维度 n、c、h 和 w 不同。

  • 输入张量和输出张量的 datatype 不同。

  • 输入张量和输入微分张量的步幅 nStride、cStride、hStride 和 wStride 不同。

  • 输出张量和输出微分张量的步幅 nStride、cStride、hStride 和 wStride 不同。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnActivationForward()#

此函数在 cuDNN 9.0 中已弃用。

此例程对每个输入值逐元素应用指定的神经元激活函数。

cudnnStatus_t cudnnActivationForward(
    cudnnHandle_t handle,
    cudnnActivationDescriptor_t     activationDesc,
    const void                     *alpha,
    const cudnnTensorDescriptor_t   xDesc,
    const void                     *x,
    const void                     *beta,
    const cudnnTensorDescriptor_t   yDesc,
    void                           *y)

此例程允许就地操作；意味着 xData 和 yData 指针可能相等。但是，这要求 xDesc 和 yDesc 描述符是相同的（特别是，对于允许就地操作，输入和输出的步幅必须匹配）。

所有张量格式都支持 4 维和 5 维，但是，当 xDesc 和 yDesc 的步幅相等且 HW packed 时，可获得最佳性能。对于超过 5 维的张量，其空间维度必须是 packed 的。

参数

handle

输入。指向先前创建的 cuDNN 上下文的句柄。有关更多信息，请参阅 cudnnHandle_t。

activationDesc

输入。激活描述符。有关更多信息，请参阅 cudnnActivationDescriptor_t。

alpha, beta

输入。指向用于将计算结果与输出层中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。指向先前初始化的输入张量描述符的句柄。有关更多信息，请参阅 cudnnTensorDescriptor_t。

x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针。

yDesc

输入。指向先前初始化的输入张量描述符的句柄。

y

输入。指向与张量描述符 yDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 参数 mode 具有无效的枚举值。

  • 输入张量和输出张量的维度 n、c、h、w 不同。

  • 输入张量和输出张量的 datatype 不同。

  • 输入张量和输出张量的步幅 nStride、cStride、hStride、wStride 不同，并且使用了就地操作（意味着 x 和 y 指针相等）。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnAddTensor()#

此函数在 cuDNN 9.0 中已弃用。

此函数将缩放后的偏置张量值添加到另一个张量。偏置张量 A 的每个维度必须与目标张量 C 的相应维度匹配，或者必须等于 1。在后一种情况下，来自偏置张量的这些维度的相同值将用于混合到 C 张量中。

cudnnStatus_t cudnnAddTensor(
    cudnnHandle_t                     handle,
    const void                       *alpha,
    const cudnnTensorDescriptor_t     aDesc,
    const void                       *A,
    const void                       *beta,
    const cudnnTensorDescriptor_t     cDesc,
    void                             *C)

仅支持 4D 和 5D 张量。超出这些维度，不支持此例程。

参数

handle

输入。指向先前创建的 cuDNN 上下文的句柄。有关更多信息，请参阅 cudnnHandle_t。

alpha, beta

输入。指向用于将源值与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*srcValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

aDesc

输入。指向先前初始化的张量描述符的句柄。有关更多信息，请参阅 cudnnTensorDescriptor_t。

A

输入。指向由 aDesc 描述符描述的张量数据的指针。

cDesc

输入。指向先前初始化的张量描述符的句柄。

C

输入/输出。指向由 cDesc 描述符描述的张量数据的指针。

返回值

CUDNN_STATUS_SUCCESS

函数执行成功。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

偏置张量的维度指的是与输出张量维度不兼容的数据量，或者两个张量描述符的 dataType 不同。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnBatchNormalizationBackward()#

此函数在 cuDNN 9.0 中已弃用。

此函数执行反向批归一化层计算。该层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t cudnnBatchNormalizationBackward(
    cudnnHandle_t                    handle,
    cudnnBatchNormMode_t             mode,
    const void                      *alphaDataDiff,
    const void                      *betaDataDiff,
    const void                      *alphaParamDiff,
    const void                      *betaParamDiff,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const cudnnTensorDescriptor_t    dyDesc,
    const void                      *dy,
    const cudnnTensorDescriptor_t    dxDesc,
    void                            *dx,
    const cudnnTensorDescriptor_t    bnScaleBiasDiffDesc,
    const void                      *bnScale,
    void                            *resultBnScaleDiff,
    void                            *resultBnBiasDiff,
    double                           epsilon,
    const void                      *savedMean,
    const void                      *savedInvVariance)

仅支持 4D 和 5D 张量。

epsilon 值在训练、反向传播和推理期间必须相同。

当 x、dy 和 dx 都使用 HW-packed 张量时，可以获得更高的性能。

有关更多信息，请参阅 cudnnDeriveBNTensorDescriptor()，了解此函数中使用的参数的辅助张量描述符生成。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

*alphaDataDiff, *betaDataDiff

输入。指向用于将梯度输出 dx 与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alphaDataDiff[0]*resultValue + betaDataDiff[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

*alphaParamDiff, *betaParamDiff

输入。指向用于将梯度输出 resultBnScaleDiff 和 resultBnBiasDiff 与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alphaParamDiff[0]*resultValue + betaParamDiff[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, dxDesc, dyDesc

输入。指向先前初始化的张量描述符的句柄。

*x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针，用于该层的 x 数据。

*dy

输入。指向与张量描述符 dyDesc 关联的 GPU 内存的数据指针，用于反向传播的微分 dy 输入。

*dx

输入/输出。指向与张量描述符 dxDesc 关联的 GPU 内存的数据指针，用于相对于 x 的结果微分输出。

bnScaleBiasDiffDesc

输入。以下五个张量的共享张量描述符：bnScale、resultBnScaleDiff、resultBnBiasDiff、savedMean 和 savedInvVariance。此张量描述符的维度取决于归一化模式。有关更多信息，请参阅 cudnnDeriveBNTensorDescriptor()。

注意

对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

*bnScale

输入。指向设备内存中批归一化 scale 参数的指针（在原始论文中，量 scale 被称为 gamma）。

注意

bnBias 参数不是此层计算所必需的。

resultBnScaleDiff, resultBnBiasDiff

输出。指向设备内存中由此例程计算的结果 scale 和 bias 微分量的指针。请注意，这些 scale 和 bias 梯度是特定于此批归一化操作的权重梯度，并且根据定义，它们不会被反向传播。

epsilon

输入。批归一化公式中使用的 Epsilon 值。其值应等于或大于 cudnn.h 中定义的 CUDNN_BN_MIN_EPSILON 值。前向和后向函数应使用相同的 epsilon 值。

*savedMean, *savedInvVariance

输入。可选的缓存参数，包含在前向传递期间计算的已保存的中间结果。为了使其正常工作，该层的 x 和 bnScale 数据必须保持不变，直到调用此后向函数。

注意

这两个参数都可以为 NULL，但只能同时为 NULL。建议使用此缓存，因为内存开销相对较小。

支持的配置

此函数支持各种描述符的数据类型的以下组合。

cudnnBatchNormalizationBackward() 的支持配置#

支持的数据类型配置

xDesc 数据类型

bnScaleBiasMeanVarDesc 数据类型

alpha, beta 数据类型

yDesc 数据类型

PSEUDO_HALF_CONFIG

CUDNN_DATA_HALF

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_HALF

FLOAT_CONFIG

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

DOUBLE_CONFIG

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

PSEUDO_BFLOAT16_CONFIG

CUDNN_DATA_BFLOAT16

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_BFLOAT16

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 任何指针 alpha、beta、x、dy、dx、bnScale、resultBnScaleDiff 和 resultBnBiasDiff 为 NULL。

  • xDesc、yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • 对于空间模式，bnScaleBiasDiffDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于按激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • 指针 savedMean 和 savedInvVariance 中恰好有一个为 NULL。

  • epsilon 值小于 CUDNN_BN_MIN_EPSILON。

  • 任何一对 xDesc、dyDesc 或 dxDesc 的维度或数据类型不匹配。

cudnnBatchNormalizationBackwardEx()#

此函数在 cuDNN 9.0 中已弃用。

此函数是 cudnnBatchNormalizationBackward() 的扩展，用于使用快速 NHWC 半持久内核执行反向批归一化层计算。

cudnnStatus_t cudnnBatchNormalizationBackwardEx (
    cudnnHandle_t                       handle,
    cudnnBatchNormMode_t                mode,
    cudnnBatchNormOps_t                 bnOps,
    const void                          *alphaDataDiff,
    const void                          *betaDataDiff,
    const void                          *alphaParamDiff,
    const void                          *betaParamDiff,
    const cudnnTensorDescriptor_t       xDesc,
    const void                          *xData,
    const cudnnTensorDescriptor_t       yDesc,
    const void                          *yData,
    const cudnnTensorDescriptor_t       dyDesc,
    const void                          *dyData,
    const cudnnTensorDescriptor_t       dzDesc,
    void                                *dzData,
    const cudnnTensorDescriptor_t       dxDesc,
    void                                *dxData,
    const cudnnTensorDescriptor_t       dBnScaleBiasDesc,
    const void                          *bnScaleData,
    const void                          *bnBiasData,
    void                                *dBnScaleData,
    void                                *dBnBiasData,
    double                              epsilon,
    const void                          *savedMean,
    const void                          *savedInvVariance,
    const cudnnActivationDescriptor_t   activationDesc,
    void                                *workspace,
    size_t                              workSpaceSizeInBytes
    void                                *reserveSpace
    size_t                              reserveSpaceSizeInBytes);

当满足以下条件时，此 API 将触发新的半持久 NHWC 内核

如果 workspace 为 NULL 并且传入的 workSpaceSizeInBytes 为零，则此 API 的功能将与非扩展函数 cudnnBatchNormalizationBackward() 完全相同。

此 workspace 不需要是干净的。此外，workspace 不需要在前向和后向传递之间保持不变，因为它不用于传递任何信息。

此扩展函数可以接受指向 GPU 工作区的 *workspace 指针，以及来自用户的工作区大小 workSpaceSizeInBytes。

bnOps 输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

仅支持 4D 和 5D 张量。epsilon 值在训练、反向传播和推理期间必须相同。

当张量布局为 NCHW 时，当 x、dy 和 dx 使用 HW-packed 张量时，可以获得更高的性能。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

bnOps

输入。操作模式。目前，仅在 NHWC 布局中支持 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 和 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION。有关更多信息，请参阅 cudnnBatchNormOps_t。此输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

*alphaDataDiff, *betaDataDiff

输入。指向用于将梯度输出 dx 与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

*alphaParamDiff, *betaParamDiff

输入。指向用于将梯度输出 dBnScaleData 和 dBnBiasData 与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, *x, yDesc, *yData, dyDesc, *dyData

输入。设备内存中该层的 x 数据、反向传播的梯度输入 dy、原始前向输出 y 数据的张量描述符和指针。yDesc 和 yData 在 bnOps 设置为 CUDNN_BATCHNORM_OPS_BN 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dzDesc, dxDesc

输入。设备内存中计算的梯度输出 dz 和 dx 的张量描述符和指针。dzDesc 在 bnOps 为 CUDNN_BATCHNORM_OPS_BN 或 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*dzData, *dxData

输出。设备内存中计算的梯度输出 dz 和 dx 的张量描述符和指针。*dzData 在 bnOps 为 CUDNN_BATCHNORM_OPS_BN 或 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dBnScaleBiasDesc

输入。以下六个张量的共享张量描述符：bnScaleData、bnBiasData、dBnScaleData、dBnBiasData、savedMean 和 savedInvVariance。有关更多信息，请参阅 cudnnDeriveBNTensorDescriptor()。

此张量描述符的维度取决于归一化模式。

注意

对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*bnScaleData

输入。指向设备内存中批归一化 scale 参数的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，量 scale 被称为 gamma）。

*bnBiasData

输入。 设备内存中批归一化偏差参数的指针（在Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta）。 此参数仅在应执行激活时使用。

*dBnScaleData, *dBnBiasData

输出。 bnScaleData 和 bnBiasData 梯度的设备内存中的指针，分别对应尺度和偏差。

epsilon

输入。 批归一化公式中使用的 Epsilon 值。其值应等于或大于 cudnn.h 中为 CUDNN_BN_MIN_EPSILON 定义的值。前向和后向函数中应使用相同的 epsilon 值。

*savedMean, *savedInvVariance

输入。 可选的缓存参数，包含在前向传播期间计算的已保存中间结果。为了使此功能正常工作，层的 x 和 bnScaleData、bnBiasData 数据必须保持不变，直到调用此后向函数。请注意，这两个参数都可以为 NULL，但只能同时为 NULL。建议使用此缓存，因为内存开销相对较小。

activationDesc

输入。 激活操作的描述符。当 bnOps 输入设置为 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 或 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

工作区

输入。 指向 GPU 工作区的指针。如果 workspace 为 NULL 且传入的 workSpaceSizeInBytes 为零，则此 API 的功能将与非扩展函数 cudnnBatchNormalizationBackward() 完全相同。

workSpaceSizeInBytes

输入。 工作区的大小。它必须足够大，才能由此函数触发快速 NHWC 半持久内核。

*reserveSpace

输入。 指向 reserveSpace 的 GPU 工作区的指针。

reserveSpaceSizeInBytes

输入。 reserveSpace 的大小。它必须等于或大于 cudnnGetBatchNormalizationTrainingExReserveSpaceSize() 所需的大小。

支持的配置

此函数支持各种描述符的数据类型的以下组合。

cudnnBatchNormalizationBackwardEx() 的支持配置#

支持的数据类型配置

xDesc 数据类型

bnScaleBiasMeanVarDesc 数据类型

alpha, beta 数据类型

yDesc 数据类型

PSEUDO_HALF_CONFIG

CUDNN_DATA_HALF

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_HALF

FLOAT_CONFIG

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

DOUBLE_CONFIG

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

PSEUDO_BFLOAT16_CONFIG

CUDNN_DATA_BFLOAT16

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_BFLOAT16

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alphaDataDiff、betaDataDiff、alphaParamDiff、betaParamDiff、x、dy、dx、bnScale、resultBnScaleDiff 和 resultBnBiasDiff 中的任何一个为 NULL。

  • xDesc、yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • 对于空间模式，dBnScaleBiasDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • 指针 savedMean 和 savedInvVariance 中恰好有一个为 NULL。

  • epsilon 值小于 CUDNN_BN_MIN_EPSILON。

  • 对于 xDesc、dyDesc 和 dxDesc 的任何一对，维度或数据类型不匹配。

cudnnBatchNormalizationForwardInference()#

此函数在 cuDNN 9.0 中已弃用。

此函数为推理阶段执行前向批归一化层计算。此层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t cudnnBatchNormalizationForwardInference(
    cudnnHandle_t                    handle,
    cudnnBatchNormMode_t             mode,
    const void                      *alpha,
    const void                      *beta,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y,
    const cudnnTensorDescriptor_t    bnScaleBiasMeanVarDesc,
    const void                      *bnScale,
    const void                      *bnBias,
    const void                      *estimatedMean,
    const void                      *estimatedVariance,
    double                           epsilon)

仅支持 4D 和 5D 张量。

此函数执行的输入变换定义为

y = beta*y + alpha *[bnBias + (bnScale * (x-estimatedMean)/sqrt(epsilon + estimatedVariance)]

epsilon 值在训练、反向传播和推理期间必须相同。

对于训练阶段，请参阅 cudnnBatchNormalizationForwardTraining()。

当 HW 打包张量用于 x 和 dx 的所有张量时，可以获得更高的性能。

有关更多信息，请参阅 cudnnDeriveBNTensorDescriptor()，了解此函数中使用的参数的辅助张量描述符生成。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。 指向先前初始化的张量描述符的句柄。

*x

输入。 指向与张量描述符 xDesc 关联的 GPU 内存的数据指针，用于层的 x 输入数据。

*y

输入/输出。 指向与张量描述符 yDesc 关联的 GPU 内存的数据指针，用于批归一化层的 y 输出。

bnScaleBiasMeanVarDesc, bnScale, bnBias

输入。 张量描述符和设备内存中批归一化尺度和偏差参数的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta，尺度被称为 gamma）。

estimatedMean, estimatedVariance

输入。 均值和方差张量（这些张量与偏差和尺度具有相同的描述符）。在 cudnnBatchNormalizationForwardTraining() 调用期间累积的 resultRunningMean 和 resultRunningVariance 应作为输入在此处传递。

epsilon

输入。 批归一化公式中使用的 Epsilon 值。其值应等于或大于 cudnn.h 中为 CUDNN_BN_MIN_EPSILON 定义的值。前向和后向函数中应使用相同的 epsilon 值。

支持的配置

此函数支持各种描述符的数据类型的以下组合。

cudnnBatchNormalizationForwardInference() 的支持配置#

支持的数据类型配置

xDesc 数据类型

bnScaleBiasMeanVarDesc 数据类型

alpha, beta 数据类型

yDesc 数据类型

INT8_CONFIG

CUDNN_DATA_INT8

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_INT8

PSEUDO_HALF_CONFIG

CUDNN_DATA_HALF

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_HALF

FLOAT_CONFIG

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

DOUBLE_CONFIG

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

BFLOAT16_CONFIG

CUDNN_DATA_BFLOAT16

CUDNN_DATA_BFLOAT16

CUDNN_DATA_FLOAT

CUDNN_DATA_BFLOAT16

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alpha、beta、x、y、bnScale、bnBias、estimatedMean 和 estimatedInvVariance 中的一个为 NULL。

  • xDesc 或 yDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量。）

  • 对于空间模式，bnScaleBiasMeanVarDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • epsilon 值小于 CUDNN_BN_MIN_EPSILON。

  • 对于 xDesc、yDesc，维度或数据类型不匹配。

cudnnBatchNormalizationForwardTraining()#

此函数在 cuDNN 9.0 中已弃用。

此函数为训练阶段执行前向批归一化层计算。此层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t cudnnBatchNormalizationForwardTraining(
    cudnnHandle_t                    handle,
    cudnnBatchNormMode_t             mode,
    const void                      *alpha,
    const void                      *beta,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y,
    const cudnnTensorDescriptor_t    bnScaleBiasMeanVarDesc,
    const void                      *bnScale,
    const void                      *bnBias,
    double                           exponentialAverageFactor,
    void                            *resultRunningMean,
    void                            *resultRunningVariance,
    double                           epsilon,
    void                            *resultSaveMean,
    void                            *resultSaveInvVariance)

仅支持 4D 和 5D 张量。

epsilon 值在训练、反向传播和推理期间必须相同。

对于推理阶段，请使用 cudnnBatchNormalizationForwardInference()。

当 HW 打包张量用于 x 和 y 时，可以获得更高的性能。

有关此函数中使用的参数的辅助张量描述符生成，请参阅 cudnnDeriveBNTensorDescriptor()。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。 层 x 和 y 数据的张量描述符和设备内存中的指针。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*x

输入。 指向与张量描述符 xDesc 关联的 GPU 内存的数据指针，用于层的 x 输入数据。

*y

输入。 指向与张量描述符 yDesc 关联的 GPU 内存的数据指针，用于批归一化层的 y 输出。

bnScaleBiasMeanVarDesc

输入。 共享张量描述符 desc，用于通过 cudnnDeriveBNTensorDescriptor() 导出的辅助张量。此张量描述符的维度取决于归一化模式。

bnScale, bnBias

输入。 设备内存中批归一化尺度和偏差参数的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta，尺度被称为 gamma）。请注意，bnBias 参数可以替换上一层的偏差参数，以提高效率。

exponentialAverageFactor

输入。 在移动平均计算中使用的因子，如下所示

runningMean = runningMean*(1-factor) + newMean*factor

在第 N 次调用函数时使用 factor=1/(1+n) 以获得累积移动平均 (CMA) 行为，例如

CMA[n] = (x[1]+...+x[n])/n

例如

CMA[n+1] = (n*CMA[n]+x[n+1])/(n+1)
= ((n+1)*CMA[n]-CMA[n])/(n+1) + x[n+1]/(n+1)
= CMA[n]*(1-1/(n+1))+x[n+1]*1/(n+1)
= CMA[n]*(1-factor) + x(n+1)*factor
resultRunningMean, resultRunningVariance

输入/输出。 运行均值和方差张量（这些张量与偏差和尺度具有相同的描述符）。这两个指针都可以为 NULL，但只能同时为 NULL。resultRunningVariance 中存储的值（或在推理模式下作为输入传递的值）是样本方差，并且是 variance[x] 的移动平均值，其中方差是根据模式在批次或空间+批次维度上计算的。如果这些指针不为 NULL，则应将张量初始化为某些合理的值或 0。

epsilon

输入。 批归一化公式中使用的 Epsilon 值。其值应等于或大于 cudnn.h 中为 CUDNN_BN_MIN_EPSILON 定义的值。前向和后向函数中应使用相同的 epsilon 值。

resultSaveMean, resultSaveInvVariance

输出。 可选的缓存，用于保存前向传播期间计算的中间结果。当提供给 cudnnBatchNormalizationBackward() 函数时，这些缓冲区可用于加速后向传播。用户不应直接使用 resultSaveMean 和 resultSaveInvVariance 缓冲区中存储的中间结果。根据批归一化模式，resultSaveInvVariance 中存储的结果可能会有所不同。为了使缓存正常工作，输入层数据必须保持不变，直到调用后向函数。请注意，这两个参数都可以为 NULL，但只能同时为 NULL。在这种情况下，将不会保存中间统计信息，并且 cudnnBatchNormalizationBackward() 将必须重新计算它们。建议使用此缓存，因为内存开销相对较小，因为这些张量的维度乘积远低于数据张量。

支持的配置

此函数支持各种描述符的数据类型的以下组合。

cudnnBatchNormalizationForwardTraining() 的支持配置#

支持的数据类型配置

xDesc 数据类型

bnScaleBiasMeanVarDesc 数据类型

alpha, beta 数据类型

yDesc 数据类型

PSEUDO_HALF_CONFIG

CUDNN_DATA_HALF

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_HALF

FLOAT_CONFIG

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

DOUBLE_CONFIG

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

PSEUDO_BFLOAT16_CONFIG

CUDNN_DATA_BFLOAT16

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_BFLOAT16

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alpha、beta、x、y、bnScale 和 bnBias 中的一个为 NULL。

  • xDesc 或 yDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量。）

  • 对于空间模式，bnScaleBiasMeanVarDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • resultSaveMean、resultSaveInvVariance 指针中恰好有一个为 NULL。

  • resultRunningMean、resultRunningInvVariance 指针中恰好有一个为 NULL。

  • epsilon 值小于 CUDNN_BN_MIN_EPSILON。

  • 对于 xDesc、yDesc，维度或数据类型不匹配。

cudnnBatchNormalizationForwardTrainingEx()#

此函数在 cuDNN 9.0 中已弃用。

此函数是 cudnnBatchNormalizationForwardTraining() 的扩展，用于执行前向批归一化层计算。

cudnnStatus_t cudnnBatchNormalizationForwardTrainingEx(
    cudnnHandle_t                       handle,
    cudnnBatchNormMode_t                mode,
    cudnnBatchNormOps_t                 bnOps,
    const void                          *alpha,
    const void                          *beta,
    const cudnnTensorDescriptor_t       xDesc,
    const void                          *xData,
    const cudnnTensorDescriptor_t       zDesc,
    const void                          *zData,
    const cudnnTensorDescriptor_t       yDesc,
    void                                *yData,
    const cudnnTensorDescriptor_t       bnScaleBiasMeanVarDesc,
    const void                          *bnScaleData,
    const void                          *bnBiasData,
    double                              exponentialAverageFactor,
    void                                *resultRunningMeanData,
    void                                *resultRunningVarianceData,
    double                              epsilon,
    void                                *saveMean,
    void                                *saveInvVariance,
    const cudnnActivationDescriptor_t   activationDesc,
    void                                *workspace,
    size_t                              workSpaceSizeInBytes
    void                                *reserveSpace
    size_t                              reserveSpaceSizeInBytes);

当满足以下条件时，此 API 将触发新的半持久 NHWC 内核

如果 workspace 为 NULL 且传入的 workSpaceSizeInBytes 为零，则此 API 的功能将与非扩展函数 cudnnBatchNormalizationForwardTraining() 完全相同。

此工作区不需要是干净的。此外，工作区在正向和反向传播之间不必保持不变，因为它不用于传递任何信息。

此扩展函数可以接受指向 GPU 工作区的 *workspace 指针，以及来自用户的工作区大小 workSpaceSizeInBytes。

bnOps 输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

仅支持 4D 和 5D 张量。epsilon 值在训练、反向传播和推理期间必须相同。

当张量布局为 NCHW 时，当 x、dy 和 dx 使用 HW-packed 张量时，可以获得更高的性能。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

bnOps

输入。 快速 NHWC 内核的操作模式。有关更多信息，请参阅 cudnnBatchNormOps_t。此输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

*alpha, *beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, *xData, zDesc, *zData, yDesc, *yData

输入。 层输入 x 和输出 y 的张量描述符和设备内存中的指针，以及可选的 z 张量输入，用于在激活之前将残差加到批归一化操作的结果中。可选的 zDesc 和 *zData 描述符仅在 bnOps 为 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时使用，否则用户可以传递 NULL。使用时，z 应与 x 和最终输出 y 具有完全相同的维度。有关更多信息，请参阅 cudnnTensorDescriptor_t。

bnScaleBiasMeanVarDesc

输入。 共享张量描述符 desc，用于通过 cudnnDeriveBNTensorDescriptor() 导出的辅助张量。此张量描述符的维度取决于归一化模式。

*bnScaleData, *bnBiasData

输入。 设备内存中批归一化尺度和偏差数据的指针。在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta，尺度被称为 gamma。请注意，bnBiasData 参数可以替换先前操作的偏差参数，以提高效率。

exponentialAverageFactor

输入。 在移动平均计算中使用的因子，如下所示

runningMean = runningMean*(1-factor) + newMean*factor

在第 N 次调用函数时使用 factor=1/(1+n) 以获得累积移动平均 (CMA) 行为，例如

CMA[n] = (x[1]+...+x[n])/n

例如

CMA[n+1] = (n*CMA[n]+x[n+1])/(n+1)
= ((n+1)*CMA[n]-CMA[n])/(n+1) + x[n+1]/(n+1)
= CMA[n]*(1-1/(n+1))+x[n+1]*1/(n+1)
= CMA[n]*(1-factor) + x(n+1)*factor
*resultRunningMeanData, *resultRunningVarianceData

输入/输出。 指向运行均值和运行方差数据的指针。这两个指针都可以为 NULL，但只能同时为 NULL。resultRunningVarianceData 中存储的值（或在推理模式下作为输入传递的值）是样本方差，并且是 variance[x] 的移动平均值，其中方差是根据模式在批次或空间+批次维度上计算的。如果这些指针不为 NULL，则应将张量初始化为某些合理的值或 0。

epsilon

输入。 批归一化公式中使用的 Epsilon 值。其值应等于或大于 cudnn.h 中为 CUDNN_BN_MIN_EPSILON 定义的值。前向和后向函数中应使用相同的 epsilon 值。

*saveMean, *saveInvVariance

输出。 可选的缓存参数，包含在前向传播期间计算的已保存中间结果。为了使此功能正常工作，层的 x 和 bnScaleData、bnBiasData 数据必须保持不变，直到调用此后向函数。请注意，这两个参数都可以为 NULL，但只能同时为 NULL。建议使用此缓存，因为内存开销相对较小。

activationDesc

输入。 激活操作的张量描述符。当 bnOps 输入设置为 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 或 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

*workspace, workSpaceSizeInBytes

输入。 *workspace 是指向 GPU 工作区的指针，workSpaceSizeInBytes 是工作区的大小。当 *workspace 不为 NULL 且 *workSpaceSizeInBytes 足够大，并且张量布局为 NHWC 且数据类型配置受支持时，此函数将触发一个新的半持久 NHWC 内核以进行批归一化。工作区不需要是干净的。此外，工作区在正向和反向传播之间不需要保持不变。

*reserveSpace

输入。 指向 reserveSpace 的 GPU 工作区的指针。

reserveSpaceSizeInBytes

输入。 reserveSpace 的大小。必须等于或大于 cudnnGetBatchNormalizationTrainingExReserveSpaceSize() 所需的大小。

支持的配置

此函数支持各种描述符的数据类型的以下组合。

cudnnBatchNormalizationForwardTrainingEx() 的支持配置#

支持的数据类型配置

xDesc 数据类型

bnScaleBiasMeanVarDesc 数据类型

alpha, beta 数据类型

yDesc 数据类型

PSEUDO_HALF_CONFIG

CUDNN_DATA_HALF

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_HALF

FLOAT_CONFIG

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

DOUBLE_CONFIG

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

CUDNN_DATA_DOUBLE

PSEUDO_BFLOAT16_CONFIG

CUDNN_DATA_BFLOAT16

CUDNN_DATA_FLOAT

CUDNN_DATA_FLOAT

CUDNN_DATA_BFLOAT16

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alpha、beta、x、y、bnScaleData 和 bnBiasData 中的一个为 NULL。

  • xDesc 或 yDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量。）

  • 对于空间模式，bnScaleBiasMeanVarDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • saveMean、saveInvVariance 指针中恰好有一个为 NULL。

  • resultRunningMeanData、resultRunningInvVarianceData 指针中恰好有一个为 NULL。

  • epsilon 值小于 CUDNN_BN_MIN_EPSILON。

  • 对于 xDesc 和 yDesc，维度或数据类型不匹配。

cudnnCreateActivationDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建激活描述符对象。有关更多信息，请参阅 cudnnActivationDescriptor_t。

cudnnStatus_t cudnnCreateActivationDescriptor(
        cudnnActivationDescriptor_t   *activationDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateDropoutDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建通用 dropout 描述符对象。有关更多信息，请参阅 cudnnDropoutDescriptor_t。

cudnnStatus_t cudnnCreateDropoutDescriptor(
    cudnnDropoutDescriptor_t    *dropoutDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateFilterDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数通过分配保存其不透明结构所需的内存来创建过滤器描述符对象。有关更多信息，请参阅 cudnnFilterDescriptor_t。

cudnnStatus_t cudnnCreateFilterDescriptor(
    cudnnFilterDescriptor_t *filterDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateLRNDescriptor()#

此函数分配保存 LRN 和 DivisiveNormalization 层操作所需的数据所需的内存，并返回一个描述符，该描述符用于后续的层正向和反向调用。

cudnnStatus_t cudnnCreateLRNDescriptor(
            cudnnLRNDescriptor_t    *poolingDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateOpTensorDescriptor()#

此函数创建张量逐点数学描述符。有关更多信息，请参阅 cudnnOpTensorDescriptor_t。

cudnnStatus_t cudnnCreateOpTensorDescriptor(
    cudnnOpTensorDescriptor_t*  opTensorDesc)

参数

opTensorDesc

输出。 指向结构的指针，该结构保存张量逐点数学运算（例如加法、乘法等）的描述。

返回值

CUDNN_STATUS_SUCCESS

函数成功返回。

CUDNN_STATUS_BAD_PARAM

传递给函数的张量逐点数学描述符无效。

CUDNN_STATUS_ALLOC_FAILED

此张量逐点数学描述符的内存分配失败。

cudnnCreatePoolingDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建池化描述符对象。

cudnnStatus_t cudnnCreatePoolingDescriptor(
    cudnnPoolingDescriptor_t    *poolingDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateReduceTensorDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建缩减张量描述符对象。

cudnnStatus_t cudnnCreateReduceTensorDescriptor(
    cudnnReduceTensorDescriptor_t*      reduceTensorDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_BAD_PARAM

reduceTensorDesc 是一个 NULL 指针。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateSpatialTransformerDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建通用空间变换器描述符对象。

cudnnStatus_t cudnnCreateSpatialTransformerDescriptor(
    cudnnSpatialTransformerDescriptor_t *stDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功创建。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

cudnnCreateTensorDescriptor()#

此函数通过分配保存其不透明结构所需的内存来创建通用张量描述符对象。数据初始化为全零。

cudnnStatus_t cudnnCreateTensorDescriptor(
    cudnnTensorDescriptor_t *tensorDesc)

参数

tensorDesc

输入。 指向指针的指针，该指针应存储已分配的张量描述符对象的地址。

返回值

CUDNN_STATUS_BAD_PARAM

无效的输入参数。

CUDNN_STATUS_ALLOC_FAILED

无法分配资源。

CUDNN_STATUS_SUCCESS

对象已成功创建。

cudnnCreateTensorTransformDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数通过分配保存其不透明结构所需的内存来创建张量变换描述符对象。张量数据初始化为全零。使用 cudnnSetTensorTransformDescriptor() 函数来初始化由此函数创建的描述符。

cudnnStatus_t cudnnCreateTensorTransformDescriptor(
    cudnnTensorTransformDescriptor_t *transformDesc);

参数

transformDesc

输出。 指向未初始化的张量变换描述符的指针。

返回值

CUDNN_STATUS_SUCCESS

描述符对象已成功创建。

CUDNN_STATUS_BAD_PARAM

transformDesc 为 NULL。

CUDNN_STATUS_ALLOC_FAILED

内存分配失败。

cudnnDeriveBNTensorDescriptor()#

此函数从层的 x 数据描述符导出批归一化 scale、invVariance、bnBias 和 bnScale 子张量的辅助张量描述符。

cudnnStatus_t cudnnDeriveBNTensorDescriptor(
    cudnnTensorDescriptor_t         derivedBnDesc,
    const cudnnTensorDescriptor_t   xDesc,
    cudnnBatchNormMode_t            mode)

将由此函数生成的张量描述符用作 cudnnBatchNormalizationForwardInference() 和 cudnnBatchNormalizationForwardTraining() 函数的 bnScaleBiasMeanVarDesc 参数，以及 cudnnBatchNormalizationBackward() 函数中的 bnScaleBiasDiffDesc 参数。

结果维度将是

  • 对于 BATCHNORM_MODE_SPATIAL，4D 为 1xCx1x1，5D 为 1xCx1x1x1

  • 对于 BATCHNORM_MODE_PER_ACTIVATION 模式，4D 为 1xCxHxW，5D 为 1xCxDxHxW

对于 HALF 输入数据类型，结果张量描述符将具有 FLOAT 类型。对于其他数据类型，它将具有与输入数据相同的类型。

注意

  • 仅支持 4D 和 5D 张量。

  • 应首先使用 cudnnCreateTensorDescriptor() 创建 derivedBnDesc。

  • xDesc 是层 x 数据的描述符，并且必须在调用此函数之前设置正确的维度。

参数

derivedBnDesc

输出。 指向先前创建的张量描述符的句柄。

xDesc

输入。 指向先前创建并初始化的层 x 数据描述符的句柄。

mode

输入。 批归一化层操作模式。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

无效的批归一化模式。

cudnnDeriveNormTensorDescriptor()#

此函数从层的 x 数据描述符和归一化模式导出归一化 mean、invariance、normBias 和 normScale 子张量的张量描述符。归一化 mean 和 invariance 共享相同的描述符，而 bias 和 scale 共享相同的描述符。

cudnnStatus_t CUDNNWINAPI
cudnnDeriveNormTensorDescriptor(cudnnTensorDescriptor_t derivedNormScaleBiasDesc,
                                cudnnTensorDescriptor_t derivedNormMeanVarDesc,
                                const cudnnTensorDescriptor_t xDesc,
                            cudnnNormMode_t mode,
                                int groupCnt)

将由此函数生成的张量描述符用作 cudnnNormalizationForwardInference() 和 cudnnNormalizationForwardTraining() 函数的 normScaleBiasDesc 或 normMeanVarDesc 参数，以及 cudnnNormalizationBackward() 函数中的 dNormScaleBiasDesc 和 normMeanVarDesc 参数。

结果维度将是

  • 对于 CUDNN_NORM_PER_ACTIVATION，4D 为 1xCx1x1，5D 为 1xCx1x1x1

  • 对于 CUDNN_NORM_PER_CHANNEL 模式，4D 为 1xCxHxW，5D 为 1xCxDxHxW

对于 HALF 输入数据类型，结果张量描述符将具有 FLOAT 类型。对于其他数据类型，它将具有与输入数据相同的类型。

注意

  • 仅支持 4D 和 5D 张量。

  • 应首先使用 cudnnCreateTensorDescriptor() 创建 derivedNormScaleBiasDesc 和 derivedNormMeanVarDesc。

  • xDesc 是层 x 数据的描述符，并且必须在调用此函数之前设置正确的维度。

参数

derivedNormScaleBiasDesc

输出。 指向先前创建的张量描述符的句柄。

derivedNormMeanVarDesc

输出。 指向先前创建的张量描述符的句柄。

xDesc

输入。 指向先前创建并初始化的层 x 数据描述符的句柄。

mode

输入。 批归一化层操作模式。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

无效的批归一化模式。

cudnnDestroyActivationDescriptor()#

此函数销毁先前创建的激活描述符对象。

cudnnStatus_t cudnnDestroyActivationDescriptor(
        cudnnActivationDescriptor_t activationDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyDropoutDescriptor()#

此函数销毁先前创建的 dropout 描述符对象。

cudnnStatus_t cudnnDestroyDropoutDescriptor(
    cudnnDropoutDescriptor_t dropoutDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyFilterDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数销毁一个滤波器对象。

cudnnStatus_t cudnnDestroyFilterDescriptor(
    cudnnFilterDescriptor_t filterDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyLRNDescriptor()#

此函数销毁先前创建的 LRN 描述符对象。

cudnnStatus_t cudnnDestroyLRNDescriptor(
    cudnnLRNDescriptor_t lrnDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyOpTensorDescriptor()#

此函数删除张量逐点数学描述符对象。

cudnnStatus_t cudnnDestroyOpTensorDescriptor(
    cudnnOpTensorDescriptor_t   opTensorDesc)

参数

opTensorDesc

输入。 指向包含要删除的张量逐点数学描述的结构的指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功返回。

cudnnDestroyPoolingDescriptor()#

此函数销毁先前创建的池化描述符对象。

cudnnStatus_t cudnnDestroyPoolingDescriptor(
    cudnnPoolingDescriptor_t poolingDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyReduceTensorDescriptor()#

此函数销毁先前创建的 reduce 张量描述符对象。当输入指针为 NULL 时，此函数不执行销毁操作。

cudnnStatus_t cudnnDestroyReduceTensorDescriptor(
    cudnnReduceTensorDescriptor_t   tensorDesc)

参数

tensorDesc

输入。 指向要销毁的 reduce 张量描述符对象的指针。

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroySpatialTransformerDescriptor()#

此函数销毁先前创建的空间变换器描述符对象。

cudnnStatus_t cudnnDestroySpatialTransformerDescriptor(
    cudnnSpatialTransformerDescriptor_t stDesc)

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyTensorDescriptor()#

此函数销毁先前创建的张量描述符对象。当输入指针为 NULL 时，此函数不执行销毁操作。

cudnnStatus_t cudnnDestroyTensorDescriptor(cudnnTensorDescriptor_t tensorDesc)

参数

tensorDesc

输入。 指向要销毁的张量描述符对象的指针。

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDestroyTensorTransformDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

销毁先前创建的张量变换描述符。

cudnnStatus_t cudnnDestroyTensorTransformDescriptor(
    cudnnTensorTransformDescriptor_t transformDesc);

参数

transformDesc

输入。 要销毁的张量变换描述符。

返回值

CUDNN_STATUS_SUCCESS

对象已成功销毁。

cudnnDivisiveNormalizationBackward()#

此函数执行后向 DivisiveNormalization 层计算。

cudnnStatus_t cudnnDivisiveNormalizationBackward(
    cudnnHandle_t                    handle,
    cudnnLRNDescriptor_t             normDesc,
    cudnnDivNormMode_t               mode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *means,
    const void                      *dy,
    void                            *temp,
    void                            *temp2,
    const void                      *beta,
    const cudnnTensorDescriptor_t    dxDesc,
    void                            *dx,
    void                            *dMeans)

支持的张量格式为 4D 的 NCHW 和 5D 的 NCDHW，具有任何非重叠的非负步幅。仅支持 4D 和 5D 张量。

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

normDesc

输入。 指向先前初始化的 LRN 参数描述符的句柄（此描述符用于 LRN 和 DivisiveNormalization 层）。

mode

输入。 DivisiveNormalization 层的运算模式。目前仅实现了 CUDNN_DIVNORM_PRECOMPUTED_MEANS。归一化使用用户预先计算的均值输入张量执行。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue.

有关更多信息，请参阅 缩放参数。

xDesc、 x、 means

输入。 设备内存中层 x 和均值数据的张量描述符和指针。请注意，means 张量预计由用户预先计算。它也可以包含任何有效值（不一定需要是实际的 means，例如，可以是与高斯核卷积的结果）。

dy

输入。 设备内存中层 dy 累积损失微分数据（误差反向传播）的张量指针。

temp、 temp2

工作区。 设备内存中的临时张量。这些用于在后向传递期间计算中间值。这些张量不必从前向传递保存到后向传递。两者都使用 xDesc 作为描述符。

dxDesc

输入。 dx 和 dMeans 的张量描述符。

dx、 dMeans

输出。 层产生的累积梯度 dx 和 dMeans （dLoss/dx 和 dLoss/dMeans）的张量指针（在设备内存中）。两者共享相同的描述符。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 张量指针 x、 dx、 temp、 tmep2 和 dy 之一为 NULL。

  • 任何输入或输出张量维度的数量不在 [4,5] 范围内。

  • alpha 或 beta 指针为 NULL。

  • xDesc 和 dxDesc 之间的维度不匹配。

  • LRN 描述符参数超出其有效范围。

  • 任何张量步幅为负。

CUDNN_STATUS_UNSUPPORTED

该函数不支持提供的配置，例如，任何输入和输出张量步幅不匹配（对于相同维度）都是不支持的配置。

cudnnDivisiveNormalizationForward()#

此函数执行前向空间 DivisiveNormalization 层计算。它将层中的每个值除以其空间邻域的标准差。请注意，DivisiveNormalization 仅实现计算的 x/max(c, sigma_x) 部分，其中 sigma_x 是 x 的空间邻域上的方差。

cudnnStatus_t cudnnDivisiveNormalizationForward(
    cudnnHandle_t                    handle,
    cudnnLRNDescriptor_t             normDesc,
    cudnnDivNormMode_t               mode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *means,
    void                            *temp,
    void                            *temp2,
    const void                      *beta,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y)

完整的 LCN（局部对比度归一化）计算可以作为两步过程实现

x_m = x-mean(x);
y = x_m/max(c, sigma(x_m));

x-mean(x) 通常被称为“减法归一化”的计算部分可以使用 cuDNN 平均池化层，然后调用 addTensor 来实现。

支持的张量格式为 4D 的 NCHW 和 5D 的 NCDHW，具有任何非重叠的非负步幅。仅支持 4D 和 5D 张量。

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

normDesc

输入。 指向先前初始化的 LRN 参数描述符的句柄。此描述符用于 LRN 和 DivisiveNormalization 层。

divNormMode

输入。 DivisiveNormalization 层的运算模式。目前仅实现了 CUDNN_DIVNORM_PRECOMPUTED_MEANS。归一化使用用户预先计算的均值输入张量执行。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。 输入和输出张量的张量描述符对象。请注意，xDesc 在 x、 means、 temp 和 temp2 张量之间共享。

x

输入。 设备内存中的输入张量数据指针。

means

输入。 设备内存中的输入均值张量数据指针。请注意，此张量可以是 NULL （在这种情况下，在计算期间假定其值为零）。此张量也不必包含 means，这些可以是任何值，常用的变体是用归一化正核（例如高斯核）进行卷积的结果。

temp、 temp2

工作区。 设备内存中的临时张量。这些用于在前向传递期间计算中间值。这些张量不必作为从前向传递到后向传递的输入保存。两者都使用 xDesc 作为其描述符。

y

输出。 指向设备内存中张量的指针，该张量用于前向 DivisiveNormalization 计算的结果。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 张量指针 x、 y、 temp 和 temp2 之一为 NULL。

  • 输入张量或输出张量维度的数量超出 [4,5] 范围。

  • 任何两个输入或输出张量之间的维度不匹配。

  • 对于指针 x == y 的原位计算，输入数据和输出数据张量之间的步幅不匹配。

  • alpha 或 beta 指针为 NULL。

  • LRN 描述符参数超出其有效范围。

  • 任何张量步幅为负。

CUDNN_STATUS_UNSUPPORTED

该函数不支持提供的配置，例如，任何输入和输出张量步幅不匹配（对于相同维度）都是不支持的配置。

cudnnDropoutBackward()#

此函数对 dy 执行后向 dropout 操作，并在 dx 中返回结果。如果在前向 dropout 操作期间，来自 x 的值传播到 y，则在后向操作期间，来自 dy 的值将传播到 dx，否则，dx 值将设置为 0。

cudnnStatus_t cudnnDropoutBackward(
    cudnnHandle_t                   handle,
    const cudnnDropoutDescriptor_t  dropoutDesc,
    const cudnnTensorDescriptor_t   dydesc,
    const void                     *dy,
    const cudnnTensorDescriptor_t   dxdesc,
    void                           *dx,
    void                           *reserveSpace,
    size_t                          reserveSpaceSizeInBytes)

对于完全打包的张量，可以获得更好的性能。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

dropoutDesc

输入。 先前创建的 dropout 描述符对象。

dyDesc

输入。指向先前初始化的张量描述符的句柄。

dy

输入。 指向由 dyDesc 描述符描述的张量数据的指针。

dxDesc

输入。指向先前初始化的张量描述符的句柄。

dx

输出。 指向由 dxDesc 描述符描述的张量数据的指针。

reserveSpace

输入。 指向用户分配的 GPU 内存的指针，此函数使用该内存。预计 reserveSpace 在调用 cudnnDropoutForward 期间填充，并且未更改。

reserveSpaceSizeInBytes

输入。 指定为保留空间提供的内存大小（以字节为单位）

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 输入张量和输出张量的元素数量不同。

  • 输入张量和输出张量的 datatype 不同。

  • 输入张量和输出张量的步幅不同，并且使用原位操作（意味着 x 和 y 指针相等）。

  • 提供的 reserveSpaceSizeInBytes 小于 cudnnDropoutGetReserveSpaceSize() 返回的值。

  • 未在 dropoutDesc 上使用非 NULL 状态参数调用 cudnnSetDropoutDescriptor()。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnDropoutForward()#

此函数对 x 执行前向 dropout 操作，并在 y 中返回结果。如果 dropout 用作 cudnnSetDropoutDescriptor() 的参数，则近似 dropout 分数的 x 值将被替换为 0，其余值将按 1/(1-dropout) 缩放。此函数不应与另一个使用相同状态的 cudnnDropoutForward() 函数同时运行。

cudnnStatus_t cudnnDropoutForward(
    cudnnHandle_t                       handle,
    const cudnnDropoutDescriptor_t      dropoutDesc,
    const cudnnTensorDescriptor_t       xdesc,
    const void                         *x,
    const cudnnTensorDescriptor_t       ydesc,
    void                               *y,
    void                               *reserveSpace,
    size_t                              reserveSpaceSizeInBytes)

注意

  • 对于完全打包的张量，可以获得更好的性能。

  • 在推理期间不应调用此函数。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

dropoutDesc

输入。 先前创建的 dropout 描述符对象。

xDesc

输入。指向先前初始化的张量描述符的句柄。

x

输入。 指向由 xDesc 描述符描述的张量数据的指针。

yDesc

输入。指向先前初始化的张量描述符的句柄。

y

输出。 指向由 yDesc 描述符描述的张量数据的指针。

reserveSpace

输出。 指向用户分配的 GPU 内存的指针，此函数使用该内存。预计 reserveSpace 的内容在 cudnnDropoutForward() 和 cudnnDropoutBackward() 调用之间不会更改。

reserveSpaceSizeInBytes

输入。 指定为保留空间提供的内存大小（以字节为单位）。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 输入张量和输出张量的元素数量不同。

  • 输入张量和输出张量的 datatype 不同。

  • 输入张量和输出张量的步幅不同，并且使用原位操作（意味着 x 和 y 指针相等）。

  • 提供的 reserveSpaceSizeInBytes 小于 cudnnDropoutGetReserveSpaceSize() 返回的值。

  • 未在 dropoutDesc 上使用非 NULL 状态参数调用 cudnnSetDropoutDescriptor()。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnDropoutGetReserveSpaceSize()#

此函数用于查询运行 dropout 所需的保留空间量，输入维度由 xDesc 给出。相同的保留空间应传递给 cudnnDropoutForward() 和 cudnnDropoutBackward()，并且其内容预计在 cudnnDropoutForward() 和 cudnnDropoutBackward() 调用之间保持不变。

cudnnStatus_t cudnnDropoutGetReserveSpaceSize(
    cudnnTensorDescriptor_t     xDesc,
    size_t                     *sizeInBytes)

参数

xDesc

输入。 指向先前初始化的张量描述符的句柄，该描述符描述 dropout 操作的输入。

sizeInBytes

输出。 运行 dropout 所需的 GPU 内存量作为保留空间，其输入张量描述符由 xDesc 指定。

返回值

CUDNN_STATUS_SUCCESS

查询成功。

cudnnDropoutGetStatesSize()#

此函数用于查询存储 cudnnDropoutForward() 函数使用的随机数生成器状态所需的空间量。

cudnnStatus_t cudnnDropoutGetStatesSize(
    cudnnHandle_t       handle,
    size_t             *sizeInBytes)

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

sizeInBytes

输出。 存储随机生成器状态所需的 GPU 内存量。

返回值

CUDNN_STATUS_SUCCESS

查询成功。

cudnnGetActivationDescriptor()#

此函数查询先前初始化的通用激活描述符对象。

cudnnStatus_t cudnnGetActivationDescriptor(
        const cudnnActivationDescriptor_t   activationDesc,
        cudnnActivationMode_t              *mode,
        cudnnNanPropagation_t              *reluNanOpt,
        double                             *coef)

参数

activationDesc

输入。 指向先前创建的激活描述符的句柄。

mode

输出。 用于指定激活模式的枚举。

reluNanOpt

输出。 用于指定 Nan 传播模式的枚举。

coef

输出。 浮点数，用于在激活模式设置为 CUDNN_ACTIVATION_CLIPPED_RELU 时指定剪切阈值，或者在激活模式设置为 CUDNN_ACTIVATION_ELU 时指定 alpha 系数。

返回值

CUDNN_STATUS_SUCCESS

对象已成功查询。

cudnnGetActivationDescriptorSwishBeta()#

此函数查询为 SWISH 激活设置的当前 beta 参数。

cudnnStatus_t
cudnnGetActivationDescriptorSwishBeta(cudnnActivationDescriptor_t
activationDesc, double* swish_beta)

参数

activationDesc

输入。 指向先前创建的激活描述符的句柄。

swish_beta

输出。 指向双精度值的指针，该指针将接收当前配置的 SWISH beta 参数。

返回值

CUDNN_STATUS_SUCCESS

beta 参数已成功查询。

CUDNN_STATUS_BAD_PARAM

activationDesc 或 swish_beta 至少有一个为 NULL。

cudnnGetBatchNormalizationBackwardExWorkspaceSize()#

此函数返回用户应分配的 GPU 内存工作区量，以便能够为指定的 bnOps 输入设置调用 cudnnGetBatchNormalizationBackwardExWorkspaceSize() 函数。分配的工作区随后将传递给函数 cudnnGetBatchNormalizationBackwardExWorkspaceSize()。

cudnnStatus_t cudnnGetBatchNormalizationBackwardExWorkspaceSize(
    cudnnHandle_t                       handle,
    cudnnBatchNormMode_t                mode,
    cudnnBatchNormOps_t                 bnOps,
    const cudnnTensorDescriptor_t       xDesc,
    const cudnnTensorDescriptor_t       yDesc,
    const cudnnTensorDescriptor_t       dyDesc,
    const cudnnTensorDescriptor_t       dzDesc,
    const cudnnTensorDescriptor_t       dxDesc,
    const cudnnTensorDescriptor_t       dBnScaleBiasDesc,
    const cudnnActivationDescriptor_t   activationDesc,
    size_t                              *sizeInBytes);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

bnOps

输入。 快速 NHWC 内核的操作模式。有关更多信息，请参阅 cudnnBatchNormOps_t。此输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

xDesc、 yDesc、 dyDesc、 dzDesc、 dxDesc

输入。 设备内存中层 x 数据、反向传播微分 dy （输入）、可选的 y 输入数据、可选的 dz 输出以及 dx 输出（即关于 x 的结果微分）的张量描述符和指针。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dBnScaleBiasDesc

输入。 以下六个张量的共享张量描述符：bnScaleData、 bnBiasData、 dBnScaleData、 dBnBiasData、 savedMean 和 savedInvVariance。这是辅助张量的共享张量描述符 desc，该张量由 cudnnDeriveBNTensorDescriptor() 派生而来。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

activationDesc

输入。 激活操作的描述符。当 bnOps 输入设置为 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 或 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

*sizeInBytes

输出。 此函数确定的工作区所需的 GPU 内存量，以便能够使用指定的 bnOps 输入设置执行 cudnnGetBatchNormalizationBackwardExWorkspaceSize() 函数。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc、 yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • 对于空间模式，dBnScaleBiasDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • 任何一对 xDesc、dyDesc 或 dxDesc 的维度或数据类型不匹配。

cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize()#

此函数在 cuDNN 9.0 中已弃用。

此函数返回用户应分配的 GPU 内存工作区量，以便能够为指定的 bnOps 输入设置调用 cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize() 函数。分配的工作区应由用户传递给函数 cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize()。

cudnnStatus_t cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize(
    cudnnHandle_t                           handle,
    cudnnBatchNormMode_t                    mode,
    cudnnBatchNormOps_t                     bnOps,
    const cudnnTensorDescriptor_t           xDesc,
    const cudnnTensorDescriptor_t           zDesc,
    const cudnnTensorDescriptor_t           yDesc,
    const cudnnTensorDescriptor_t           bnScaleBiasMeanVarDesc,
    const cudnnActivationDescriptor_t       activationDesc,
    size_t                                  *sizeInBytes);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

bnOps

输入。 快速 NHWC 内核的操作模式。有关更多信息，请参阅 cudnnBatchNormOps_t。此输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

xDesc、 zDesc、 yDesc

输入。 设备内存中层 x 数据、可选的 z 输入数据和 y 输出的张量描述符和指针。zDesc 仅在 bnOps 为 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时才需要，否则用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

bnScaleBiasMeanVarDesc

输入。 以下六个张量的共享张量描述符：bnScaleData、 bnBiasData、 dBnScaleData、 dBnBiasData、 savedMean 和 savedInvVariance。这是辅助张量的共享张量描述符 desc，该张量由 cudnnDeriveBNTensorDescriptor() 派生而来。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

activationDesc

输入。 激活操作的描述符。当 bnOps 输入设置为 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 或 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

*sizeInBytes

输出。 此函数确定的工作区所需的 GPU 内存量，以便能够使用指定的 bnOps 输入设置执行 cudnnGetBatchNormalizationBackwardExWorkspaceSize() 函数。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc、 yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • 对于空间模式，dBnScaleBiasDesc 维度对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于逐激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • xDesc 或 dyDesc 的任何一对的维度或数据类型不匹配。

cudnnGetBatchNormalizationTrainingExReserveSpaceSize()#

此函数在 cuDNN 9.0 中已弃用。

此函数返回用户应为批量归一化运算分配的保留 GPU 内存工作区量，用于指定的 bnOps 输入设置。与 workspace 相比，保留空间应在前向和后向调用之间保留，并且数据不应更改。

cudnnStatus_t cudnnGetBatchNormalizationTrainingExReserveSpaceSize(
    cudnnHandle_t                       handle,
    cudnnBatchNormMode_t                mode,
    cudnnBatchNormOps_t                 bnOps,
    const cudnnActivationDescriptor_t   activationDesc,
    const cudnnTensorDescriptor_t       xDesc,
    size_t                              *sizeInBytes);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。操作模式（空间或按激活）。有关更多信息，请参阅 cudnnBatchNormMode_t。

bnOps

输入。 快速 NHWC 内核的操作模式。有关更多信息，请参阅 cudnnBatchNormOps_t。此输入可用于将此函数设置为仅执行批归一化，或批归一化后跟激活，或批归一化后跟逐元素加法，然后再激活。

xDesc

输入。 设备内存中层 x 数据的张量描述符和指针。有关更多信息，请参阅 cudnnTensorDescriptor_t。

activationDesc

输入。 激活操作的描述符。当 bnOps 输入设置为 CUDNN_BATCHNORM_OPS_BN_ACTIVATION 或 CUDNN_BATCHNORM_OPS_BN_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

*sizeInBytes

输出。 保留的 GPU 内存量。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc 张量描述符维度不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

cudnnGetDropoutDescriptor()#

此函数查询先前初始化的 dropout 描述符的字段。

cudnnStatus_t cudnnGetDropoutDescriptor(
    cudnnDropoutDescriptor_t    dropoutDesc,
    cudnnHandle_t               handle,
    float                      *dropout,
    void                       **states,
    unsigned long long         *seed)

参数

dropoutDesc

输入。 先前初始化的 dropout 描述符。

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

dropout

输出。 在 dropout 层期间，输入值设置为 0 的概率。

states

输出。 指向用户分配的 GPU 内存的指针，该内存保存随机数生成器状态。

seed

输出。 用于初始化随机数生成器状态的种子。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

一个或多个参数是指针无效。

cudnnGetFilter4dDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数查询先前初始化的 Filter4d 描述符对象的参数。

cudnnStatus_t cudnnGetFilter4dDescriptor(
    const cudnnFilterDescriptor_t     filterDesc,
    cudnnDataType_t            *dataType,
    cudnnTensorFormat_t        *format,
    int                        *k,
    int                        *c,
    int                        *h,
    int                        *w)

参数

filterDesc

输入。 指向先前创建的滤波器描述符的句柄。

datatype

输出。 数据类型。

format

输出。 格式类型。

k

输出。 输出特征图的数量。

c

输出。 输入特征图的数量。

h

输出。 每个滤波器的高度。

w

输出。 每个滤波器的宽度。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

cudnnGetFilterNdDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数查询先前初始化的 FilterNd 描述符对象。

cudnnStatus_t cudnnGetFilterNdDescriptor(
    const cudnnFilterDescriptor_t   wDesc,
    int                             nbDimsRequested,
    cudnnDataType_t                *dataType,
    cudnnTensorFormat_t            *format,
    int                            *nbDims,
    int                             filterDimA[])

参数

wDesc

输入。 指向先前初始化的滤波器描述符的句柄。

nbDimsRequested

输入。 预期滤波器描述符的维度。它也是数组 filterDimA 的最小大小，以便能够容纳结果

datatype

输出。 数据类型。

format

输出。 格式类型。

nbDims

输出。 滤波器的实际维度。

filterDimA

输出。 维度至少为 nbDimsRequested 的数组，该数组将填充来自提供的滤波器描述符的滤波器参数。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

参数 nbDimsRequested 为负数。

cudnnGetFilterSizeInBytes()#

此函数在 cuDNN 9.0 中已弃用。

此函数返回滤波器张量在内存中的大小（相对于给定的描述符）。它可用于了解要分配多少 GPU 内存来保存该滤波器张量。

cudnnStatus_t
cudnnGetFilterSizeInBytes(const cudnnFilterDescriptor_t filterDesc, size_t *size);

参数

filterDesc

输入。 指向先前初始化的滤波器描述符的句柄。

size

输出。 保存 GPU 内存中的张量所需的大小（以字节为单位）。

返回值

CUDNN_STATUS_SUCCESS

filterDesc 有效。

CUDNN_STATUS_BAD_PARAM

filerDesc 无效。

cudnnGetLRNDescriptor()#

此函数检索存储在先前初始化的 LRN 描述符对象中的值。

cudnnStatus_t cudnnGetLRNDescriptor(
    cudnnLRNDescriptor_t    normDesc,
    unsigned               *lrnN,
    double                 *lrnAlpha,
    double                 *lrnBeta,
    double                 *lrnK)

参数

normDesc

输出。 指向先前创建的 LRN 描述符的句柄。

lrnN、 lrnAlpha、 lrnBeta、 lrnK 输出。 指向接收存储在描述符对象中的参数值的指针。有关更多信息，请参阅 cudnnSetLRNDescriptor()。这些指针中的任何一个都可以为 NULL （对于相应的参数，不返回值）。

返回值

CUDNN_STATUS_SUCCESS

函数已成功完成。

cudnnGetNormalizationBackwardWorkspaceSize()#

此函数返回用户应分配的 GPU 内存工作区量，以便能够为指定的 normOps 和 algo 输入设置调用 cudnnNormalizationBackward() 函数。分配的工作区随后将传递给函数 cudnnNormalizationBackward()。

cudnnStatus_t
cudnnGetNormalizationBackwardWorkspaceSize(cudnnHandle_t handle,
                                        cudnnNormMode_t mode,
                                        cudnnNormOps_t normOps,
                                        cudnnNormAlgo_t algo,
                                        const cudnnTensorDescriptor_t xDesc,
                                        const cudnnTensorDescriptor_t yDesc,
                                        const cudnnTensorDescriptor_t dyDesc,
                                            const cudnnTensorDescriptor_t dzDesc,
                                        const cudnnTensorDescriptor_t dxDesc,
                                        const cudnnTensorDescriptor_t dNormScaleBiasDesc,
                                    const cudnnActivationDescriptor_t activationDesc,
                                        const cudnnTensorDescriptor_t normMeanVarDesc,
                                        size_t *sizeInBytes,
                                        int groupCnt);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

xDesc、 yDesc、 dyDesc、 dzDesc、 dxDesc

输入。 设备内存中层 x 数据、反向传播微分 dy （输入）、可选的 y 输入数据、可选的 dz 输出以及 dx 输出（即关于 x 的结果微分）的张量描述符和指针。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dNormScaleBiasDesc

输入。 以下四个张量的共享张量描述符：normScaleData、 normBiasData、 dNormScaleData、 dNormBiasData。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

activationDesc

输入。 激活操作的描述符。当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

normMeanVarDesc

输入。 以下张量的共享张量描述符：savedMean 和 savedInvVariance。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

*sizeInBytes

输出。 此函数确定的工作区所需的 GPU 内存量，以便能够使用指定的 normOps 输入设置执行 cudnnGetNormalizationForwardTrainingWorkspaceSize() 函数。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc、 yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • dNormScaleBiasDesc 维度对于按通道归一化的 4D 张量不是 1xCx1x1，对于 5D 张量不是 1xCx1x1x1；对于按激活归一化模式的 4D 张量不是 1xCxHxW，对于 5D 张量不是 1xCxDxHxW。

  • 任何一对 xDesc、dyDesc 或 dxDesc 的维度或数据类型不匹配。

cudnnGetNormalizationForwardTrainingWorkspaceSize()#

此函数返回用户应分配的 GPU 内存工作区大小，以便能够为指定的 normOps 和 algo 输入设置调用 cudnnNormalizationForwardTraining() 函数。分配的工作区应随后由用户传递给函数 cudnnNormalizationForwardTraining()。

cudnnStatus_t
cudnnGetNormalizationForwardTrainingWorkspaceSize(cudnnHandle_t handle,
                                                cudnnNormMode_t mode,
                                                cudnnNormOps_t normOps,
                                                cudnnNormAlgo_t algo,
                                                const cudnnTensorDescriptor_t xDesc,
                                                const cudnnTensorDescriptor_t zDesc,
                                                const cudnnTensorDescriptor_t yDesc,
                                                    const cudnnTensorDescriptor_t normScaleBiasDesc,
                                                const cudnnActivationDescriptor_t activationDesc,
                                                const cudnnTensorDescriptor_t normMeanVarDesc,
                                                size_t *sizeInBytes,
                                                int groupCnt);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

xDesc、 zDesc、 yDesc

输入。 设备内存中层 x 数据、反向传播微分 dy （输入）、可选的 y 输入数据、可选的 dz 输出以及 dx 输出（即关于 x 的结果微分）的张量描述符和指针。有关更多信息，请参阅 cudnnTensorDescriptor_t。

normScaleBiasDesc

输入。 以下四个张量的共享张量描述符：normScaleData 和 normBiasData。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，数据类型必须为 double。

activationDesc

输入。 激活操作的描述符。当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

normMeanVarDesc

输入。 以下张量的共享张量描述符：savedMean 和 savedInvVariance。此张量描述符的维度取决于归一化模式。请注意，对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。

*sizeInBytes

输出。 此函数确定的工作区所需的 GPU 内存量，以便能够使用指定的 normOps 输入设置执行 cudnnGetNormalizationForwardTrainingWorkspaceSize() 函数。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc、yDesc 或 zDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • normScaleBiasDesc 维度对于按通道归一化的 4D 张量不是 1xCx1x1，对于 5D 张量不是 1xCx1x1x1；对于按激活归一化模式的 4D 张量不是 1xCxHxW，对于 5D 张量不是 1xCxDxHxW。

  • xDesc 或 yDesc 的任何一对的维度或数据类型不匹配。

cudnnGetNormalizationTrainingReserveSpaceSize()#

此函数返回用户应为归一化操作分配的保留 GPU 内存工作区大小，用于指定的 normOps 输入设置。与工作区相比，保留空间应在前向和后向调用之间保留，并且数据不应更改。

cudnnStatus_t
cudnnGetNormalizationTrainingReserveSpaceSize(cudnnHandle_t handle,
                                            cudnnNormMode_t mode,
                                            cudnnNormOps_t normOps,
                                            cudnnNormAlgo_t algo,
                                            const cudnnActivationDescriptor_t activationDesc,
                                            const cudnnTensorDescriptor_t xDesc,
                                            size_t *sizeInBytes,
                                            int groupCnt);

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

xDesc

输入。 层 x 数据的张量描述符。有关更多信息，请参阅 cudnnTensorDescriptor_t。

activationDesc

输入。 激活操作的描述符。当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

*sizeInBytes

输出。 保留的 GPU 内存量。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • xDesc 张量描述符维度不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

cudnnGetOpTensorDescriptor()#

此函数返回传递的张量逐点数学描述符的配置。

cudnnStatus_t cudnnGetOpTensorDescriptor(
    const cudnnOpTensorDescriptor_t opTensorDesc,
    cudnnOpTensorOp_t               *opTensorOp,
    cudnnDataType_t                 *opTensorCompType,
    cudnnNanPropagation_t           *opTensorNanOpt)

参数

opTensorDesc

输入。 传递以从中获取配置的张量逐点数学描述符。

opTensorOp

输出。 指向与此张量逐点数学描述符关联的张量逐点数学运算类型的指针。

opTensorCompType

输出。 指向与此张量逐点数学描述符关联的 cuDNN 数据类型的指针。

opTensorNanOpt

输出。 指向与此张量逐点数学描述符关联的 NAN 传播选项的指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功返回。

CUDNN_STATUS_BAD_PARAM

传递的输入张量逐点数学描述符无效。

cudnnGetPooling2dDescriptor()#

此函数查询先前创建的 Pooling2d 描述符对象。

cudnnStatus_t cudnnGetPooling2dDescriptor(
    const cudnnPoolingDescriptor_t      poolingDesc,
    cudnnPoolingMode_t                 *mode,
    cudnnNanPropagation_t              *maxpoolingNanOpt,
    int                                *windowHeight,
    int                                *windowWidth,
    int                                *verticalPadding,
    int                                *horizontalPadding,
    int                                *verticalStride,
    int                                *horizontalStride)

参数

poolingDesc

输入。 指向先前创建的池化描述符的句柄。

mode

输出。 枚举数，用于指定池化模式。

maxpoolingNanOpt

输出。 用于指定 Nan 传播模式的枚举。

windowHeight

输出。 池化窗口的高度。

windowWidth

输出。 池化窗口的宽度。

verticalPadding

输出。 垂直填充的大小。

horizontalPadding

输出。 水平填充的大小。

verticalStride

输出。 池化垂直步幅。

horizontalStride

输出。 池化水平步幅。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

cudnnGetPooling2dForwardOutputDim()#

此函数提供应用 Pooling2d 后张量的输出维度。

cudnnStatus_t cudnnGetPooling2dForwardOutputDim(
    const cudnnPoolingDescriptor_t      poolingDesc,
    const cudnnTensorDescriptor_t       inputDesc,
    int                                *outN,
    int                                *outC,
    int                                *outH,
    int                                *outW)

输出图像的每个维度 h 和 w 的计算方式如下

outputDim = 1 + (inputDim + 2*padding - windowDim)/poolingStride;

参数

poolingDesc

输入。 指向先前初始化的池化描述符的句柄。

inputDesc

输入。指向先前初始化的输入张量描述符的句柄。

N

输出。 输出中的图像数量。

C

输出。 输出中的通道数量。

H

输出。 输出中图像的高度。

W

输出。 输出中图像的宽度。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • poolingDesc 尚未初始化。

  • poolingDesc 或 inputDesc 的维度数量无效（分别需要 2 和 4）。

cudnnGetPoolingNdDescriptor()#

此函数查询先前初始化的通用 PoolingNd 描述符对象。

cudnnStatus_t cudnnGetPoolingNdDescriptor(
const cudnnPoolingDescriptor_t      poolingDesc,
int                                 nbDimsRequested,
cudnnPoolingMode_t                 *mode,
cudnnNanPropagation_t              *maxpoolingNanOpt,
int                                *nbDims,
int                                 windowDimA[],
int                                 paddingA[],
int                                 strideA[])

参数

poolingDesc

输入。 指向先前创建的池化描述符的句柄。

nbDimsRequested

输入。 预期池化描述符的维度。它也是数组 windowDimA、paddingA 和 strideA 的最小大小，以便能够容纳结果。

mode

输出。 枚举数，用于指定池化模式。

maxpoolingNanOpt

输入。 枚举数，用于指定 Nan 传播模式。

nbDims

输出。 池化描述符的实际维度。

windowDimA

输出。 维度至少为 nbDimsRequested 的数组，将使用提供的池化描述符中的窗口参数填充。

paddingA

输出。 维度至少为 nbDimsRequested 的数组，将使用提供的池化描述符中的填充参数填充。

strideA

输出。 维度至少为 nbDimsRequested 的数组，将使用提供的池化描述符中的步幅参数填充。

返回值

CUDNN_STATUS_SUCCESS

对象已成功查询。

CUDNN_STATUS_NOT_SUPPORTED

参数 nbDimsRequested 大于 CUDNN_DIM_MAX。

cudnnGetPoolingNdForwardOutputDim()#

此函数提供应用 PoolingNd 后张量的输出维度。

cudnnStatus_t cudnnGetPoolingNdForwardOutputDim(
    const cudnnPoolingDescriptor_t  poolingDesc,
    const cudnnTensorDescriptor_t   inputDesc,
    int                             nbDims,
    int                             outDimA[])

输出张量的 (nbDims-2)-D 图像的每个维度的计算方式如下

outputDim = 1 + (inputDim + 2*padding - windowDim)/poolingStride;

参数

poolingDesc

输入。 指向先前初始化的池化描述符的句柄。

inputDesc

输入。指向先前初始化的输入张量描述符的句柄。

nbDims

输入。 要应用池化的维度数。

outDimA

输出。 nbDims 输出维度的数组。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • poolingDesc 尚未初始化。

  • nbDims 的值与 poolingDesc 和 inputDesc 的维度不一致。

cudnnGetReduceTensorDescriptor()#

此函数查询先前初始化的 reduce 张量描述符对象。

cudnnStatus_t cudnnGetReduceTensorDescriptor(
    const cudnnReduceTensorDescriptor_t reduceTensorDesc,
    cudnnReduceTensorOp_t               *reduceTensorOp,
    cudnnDataType_t                     *reduceTensorCompType,
    cudnnNanPropagation_t               *reduceTensorNanOpt,
    cudnnReduceTensorIndices_t          *reduceTensorIndices,
    cudnnIndicesType_t                  *reduceTensorIndicesType)

参数

reduceTensorDesc

输入。 指向先前初始化的 reduce 张量描述符对象的指针。

reduceTensorOp

输出。 枚举数，用于指定 reduce 张量运算。

reduceTensorCompType

输出。 枚举数，用于指定 reduction 的计算数据类型。

reduceTensorNanOpt

输入。 枚举数，用于指定 Nan 传播模式。

reduceTensorIndices

输出。 枚举数，用于指定 reduce 张量索引。

reduceTensorIndicesType

输出。 枚举数，用于指定 reduce 张量索引类型。

返回值

CUDNN_STATUS_SUCCESS

对象已成功查询。

CUDNN_STATUS_BAD_PARAM

reduceTensorDesc 为 NULL。

cudnnGetReductionIndicesSize()#

这是一个辅助函数，用于返回传递给 reduction 的索引空间的最小大小，给定输入和输出张量。

cudnnStatus_t cudnnGetReductionIndicesSize(
    cudnnHandle_t                       handle,
    const cudnnReduceTensorDescriptor_t reduceDesc,
    const cudnnTensorDescriptor_t       aDesc,
    const cudnnTensorDescriptor_t       cDesc,
    size_t                              *sizeInBytes)

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

reduceDesc

输入。 指向先前初始化的 reduce 张量描述符对象的指针。

aDesc

输入。 指向输入张量描述符的指针。

cDesc

输入。 指向输出张量描述符的指针。

sizeInBytes

输出。 传递给 reduction 的索引空间的最小大小。

返回值

CUDNN_STATUS_SUCCESS

索引空间大小已成功返回。

cudnnGetReductionWorkspaceSize()#

这是一个辅助函数，用于返回传递给 reduction 的工作区的最小大小，给定输入和输出张量。

cudnnStatus_t cudnnGetReductionWorkspaceSize(
    cudnnHandle_t                       handle,
    const cudnnReduceTensorDescriptor_t reduceDesc,
    const cudnnTensorDescriptor_t       aDesc,
    const cudnnTensorDescriptor_t       cDesc,
    size_t                              *sizeInBytes)

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

reduceDesc

输入。 指向先前初始化的 reduce 张量描述符对象的指针。

aDesc

输入。 指向输入张量描述符的指针。

cDesc

输入。 指向输出张量描述符的指针。

sizeInBytes

输出。 传递给 reduction 的索引空间的最小大小。

返回值

CUDNN_STATUS_SUCCESS

工作区大小已成功返回。

cudnnGetTensor4dDescriptor()#

此函数查询先前初始化的 Tensor4d 描述符对象的参数。

cudnnStatus_t cudnnGetTensor4dDescriptor(
    const cudnnTensorDescriptor_t  tensorDesc,
    cudnnDataType_t         *dataType,
    int                     *n,
    int                     *c,
    int                     *h,
    int                     *w,
    int                     *nStride,
    int                     *cStride,
    int                     *hStride,
    int                     *wStride)

参数

tensorDesc

输入。指向先前初始化的张量描述符的句柄。

datatype

输出。 数据类型。

n

输出。 图像数量。

c

输出。 每个图像的特征图数量。

h

输出。 每个特征图的高度。

w

输出。 每个特征图的宽度。

nStride

输出。 两个连续图像之间的步幅。

cStride

输出。 两个连续特征图之间的步幅。

hStride

输出。 两个连续行之间的步幅。

wStride

输出。 两个连续列之间的步幅。

返回值

CUDNN_STATUS_SUCCESS

操作成功。

cudnnGetTensorNdDescriptor()#

此函数检索存储在先前初始化的 TensorNd 描述符对象中的值。

cudnnStatus_t cudnnGetTensorNdDescriptor(
    const cudnnTensorDescriptor_t   tensorDesc,
    int                             nbDimsRequested,
    cudnnDataType_t                *dataType,
    int                            *nbDims,
    int                             dimA[],
    int                             strideA[])

参数

tensorDesc

输入。指向先前初始化的张量描述符的句柄。

nbDimsRequested

输入。 要从给定张量描述符中提取的维度数。它也是数组 dimA 和 strideA 的最小大小。如果此数字大于结果 nbDims[0]，则仅返回 nbDims[0] 维度。

datatype

输出。 数据类型。

nbDims

输出。 张量的实际维度将返回在 nbDims[0] 中。

dimA

输出。 维度至少为 nbDimsRequested 的数组，将使用提供的张量描述符中的维度填充。

strideA

输出。 维度至少为 nbDimsRequested 的数组，将使用提供的张量描述符中的步幅填充。

返回值

CUDNN_STATUS_SUCCESS

结果已成功返回。

CUDNN_STATUS_BAD_PARAM

tensorDesc 或 nbDims 指针为 NULL。

cudnnGetTensorSizeInBytes()#

此函数返回张量在内存中的大小，相对于给定的描述符。此函数可用于了解要分配多少 GPU 内存来保存该张量。

cudnnStatus_t cudnnGetTensorSizeInBytes(
    const cudnnTensorDescriptor_t   tensorDesc,
    size_t                         *size)

参数

tensorDesc

输入。指向先前初始化的张量描述符的句柄。

size

输出。 保存 GPU 内存中张量所需的字节大小。

返回值

CUDNN_STATUS_SUCCESS

结果已成功返回。

cudnnGetTensorTransformDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数返回存储在先前初始化的张量变换描述符中的值。

cudnnStatus_t cudnnGetTensorTransformDescriptor(
    cudnnTensorTransformDescriptor_t transformDesc,
    uint32_t nbDimsRequested,
    cudnnTensorFormat_t *destFormat,
    int32_t padBeforeA[],
    int32_t padAfterA[],
    uint32_t foldA[],
    cudnnFoldingDirection_t *direction);

参数

transformDesc

输入。 先前初始化的张量变换描述符。

nbDimsRequested

输入。 要考虑的维度数。有关更多信息，请参阅 张量描述符。

destFormat

输出。 将返回的变换格式。

padBeforeA[]

输出。 用添加到每个维度之前的填充量填充的数组。此 padBeforeA[] 参数的维度等于 nbDimsRequested。

padAfterA[]

输出。 用添加到每个维度之后的填充量填充的数组。此 padBeforeA[] 参数的维度等于 nbDimsRequested。

foldA[]

输出。 用每个空间维度的折叠参数填充的数组。此 foldA[] 数组的维度为 nbDimsRequested-2。

direction

输出。 选择折叠或展开的设置。有关更多信息，请参阅 cudnnFoldingDirection_t。

返回值

CUDNN_STATUS_SUCCESS

结果已成功获得。

CUDNN_STATUS_BAD_PARAM

如果 transformDesc 为 NULL，或者如果 nbDimsRequested 小于 3 或大于 CUDNN_DIM_MAX。

cudnnInitTransformDest()#

此函数在 cuDNN 9.0 中已弃用。

此函数初始化并返回用于张量变换操作的目标张量描述符 destDesc。初始化是使用变换描述符 cudnnTensorDescriptor_t 中描述的所需参数完成的。

cudnnStatus_t cudnnInitTransformDest(
    const cudnnTensorTransformDescriptor_t transformDesc,
    const cudnnTensorDescriptor_t srcDesc,
    cudnnTensorDescriptor_t destDesc,
    size_t *destSizeInBytes);

返回的张量描述符将被打包。

参数

transformDesc

输入。 指向先前初始化的张量变换描述符的句柄。

srcDesc

输入。指向先前初始化的张量描述符的句柄。

destDesc

输出。 将被初始化和返回的张量描述符的句柄。

destSizeInBytes

输出。 指向新张量大小（以字节为单位）的指针。

返回值

CUDNN_STATUS_SUCCESS

张量描述符已成功初始化。

CUDNN_STATUS_BAD_PARAM

如果 srcDesc 或 destDesc 为 NULL，或者如果张量描述符 nbDims 不正确。有关更多信息，请参阅 张量描述符。

CUDNN_STATUS_NOT_SUPPORTED

如果提供的配置不是 4D。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnLRNCrossChannelBackward()#

此函数执行后向 LRN 层计算。

cudnnStatus_t cudnnLRNCrossChannelBackward(
    cudnnHandle_t                    handle,
    cudnnLRNDescriptor_t             normDesc,
    cudnnLRNMode_t                   lrnMode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    yDesc,
    const void                      *y,
    const cudnnTensorDescriptor_t    dyDesc,
    const void                      *dy,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *beta,
    const cudnnTensorDescriptor_t    dxDesc,
    void                            *dx)

支持的格式为：positive-strided、NCHW 和 NHWC 用于 4D x 和 y，仅 NCDHW DHW-packed 用于 5D（对于 x 和 y）。仅支持非重叠的 4D 和 5D 张量。NCHW 布局是性能首选。

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

normDesc

输入。 指向先前初始化的 LRN 参数描述符的句柄。

lrnMode

输入。 LRN 层操作模式。当前仅实现 CUDNN_LRN_CROSS_CHANNEL_DIM1。归一化沿张量的 dimA[1] 执行。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

yDesc、y

输入。 层 y 数据的张量描述符和设备内存中的指针。

dyDesc、dy

输入。 层输入累积损失微分数据 dy （包括误差反向传播）的张量描述符和设备内存中的指针。

xDesc、x

输入。 层 x 数据的张量描述符和设备内存中的指针。请注意，这些值在反向传播期间不会被修改。

dxDesc、dx

输出。 层最终累积损失微分数据 dx （包括误差反向传播）的张量描述符和设备内存中的指针。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 张量指针 x、y 之一为 NULL。

  • 输入张量维度数小于等于 2。

  • LRN 描述符参数超出其有效范围。

  • 张量参数之一是 5D 但不是 NCDHW DHW-packed 格式。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 任何输入张量数据类型与任何输出张量数据类型都不同。

  • x、y、dx 或 dy 的任何成对张量维度不匹配。

  • 任何张量参数步幅为负。

cudnnLRNCrossChannelForward()#

此函数执行前向 LRN 层计算。

cudnnStatus_t cudnnLRNCrossChannelForward(
    cudnnHandle_t                    handle,
    cudnnLRNDescriptor_t             normDesc,
    cudnnLRNMode_t                   lrnMode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *beta,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y)

支持的格式为：positive-strided、NCHW 和 NHWC 用于 4D x 和 y，仅 NCDHW DHW-packed 用于 5D（对于 x 和 y）。仅支持非重叠的 4D 和 5D 张量。NCHW 布局是性能首选。

参数

handle

输入。 指向先前创建的 cuDNN 库描述符的句柄。

normDesc

输入。 指向先前初始化的 LRN 参数描述符的句柄。

lrnMode

输入。 LRN 层操作模式。当前仅实现 CUDNN_LRN_CROSS_CHANNEL_DIM1。归一化沿张量的 dimA[1] 执行。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。 输入和输出张量的张量描述符对象。

x

输入。 设备内存中的输入张量数据指针。

y

输出。 设备内存中的输出张量数据指针。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 张量指针 x、y 之一为 NULL。

  • 输入张量维度数小于等于 2。

  • LRN 描述符参数超出其有效范围。

  • 张量参数之一是 5D 但不是 NCDHW DHW-packed 格式。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 任何输入张量数据类型与任何输出张量数据类型都不同。

  • x 和 y 张量维度不匹配。

  • 任何张量参数步幅为负。

cudnnNormalizationBackward()#

此函数在 cuDNN 9.0 中已弃用。

此函数执行由模式指定的后向归一化层计算。按通道归一化层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t
cudnnNormalizationBackward(cudnnHandle_t handle,
                        cudnnNormMode_t mode,
                        cudnnNormOps_t normOps,
                        cudnnNormAlgo_t algo,
                        const void *alphaDataDiff,
                            const void *betaDataDiff,
                        const void *alphaParamDiff,
                        const void *betaParamDiff,
                        const cudnnTensorDescriptor_t xDesc,
                        const void *xData,
                        const cudnnTensorDescriptor_t yDesc,
                        const void *yData,
                        const cudnnTensorDescriptor_t dyDesc,
                        const void *dyData,
                        const cudnnTensorDescriptor_t dzDesc,
                        void *dzData,
                        const cudnnTensorDescriptor_t dxDesc,
                        void *dxData,
                        const cudnnTensorDescriptor_t dNormScaleBiasDesc,
                        const void *normScaleData,
                        const void *normBiasData,
                        void *dNormScaleData,
                        void *dNormBiasData,
                        double epsilon,
                        const cudnnTensorDescriptor_t normMeanVarDesc,
                        const void *savedMean,
                        const void *savedInvVariance,
                        cudnnActivationDescriptor_t activationDesc,
                        void *workSpace,
                        size_t workSpaceSizeInBytes,
                        void *reserveSpace,
                        size_t reserveSpaceSizeInBytes,
                        int groupCnt)

仅支持 4D 和 5D 张量。

epsilon 值在训练、反向传播和推理期间必须相同。此工作区不需要是干净的。此外，工作区不必在前向和后向传递之间保持不变，因为它不用于传递任何信息。

此函数可以接受指向 GPU 工作区的 *workspace 指针，以及工作区大小 workSpaceSizeInBytes，来自用户。

normOps 输入可用于将此函数设置为仅执行归一化，或归一化后跟激活，或归一化后跟逐元素加法，然后激活。

当张量布局为 NCHW 时，当 HW-packed 张量用于 x、dy、dx 时，可以获得更高的性能。

当以下条件为真时，对于 CUDNN_NORM_PER_CHANNEL 模式可以获得更高的性能

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

*alphaDataDiff, *betaDataDiff

输入。指向用于将梯度输出 dx 与目标张量中的先前值混合的缩放因子（在主机内存中）的指针，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

*alphaParamDiff, *betaParamDiff

输入。 指向缩放因子（在主机内存中）的指针，用于将梯度输出 dNormScaleData 和 dNormBiasData 与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc、*xData、yDesc、*yData、dyDesc、*dyData

输入。 层 x 数据、反向传播梯度输入 dy、原始前向输出 y 数据的张量描述符和设备内存中的指针。yDesc 和 yData 在 normOps 设置为 CUDNN_NORM_OPS_NORM 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dzDesc, dxDesc

输入。 计算出的梯度输出 dz 和 dx 的张量描述符和设备内存中的指针。dzDesc 在 normOps 为 CUDNN_NORM_OPS_NORM 或 CUDNN_NORM_OPS_NORM_ACTIVATION 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*dzData, *dxData

输出。 计算出的梯度输出 dz 和 dx 的张量描述符和设备内存中的指针。*dzData 在 normOps 为 CUDNN_NORM_OPS_NORM 或 CUDNN_NORM_OPS_NORM_ACTIVATION 时不需要，用户可以传递 NULL。有关更多信息，请参阅 cudnnTensorDescriptor_t。

dNormScaleBiasDesc

输入。 以下六个张量的共享张量描述符：normScaleData、normBiasData、dNormScaleData 和 dNormBiasData。此张量描述符的维度取决于归一化模式。

对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*normScaleData

输入。 设备内存中归一化比例参数的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，比例量称为 gamma）。

*normBiasData

输入。 设备内存中归一化偏差参数的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差称为 beta）。仅当应执行激活时才使用此参数。

*dNormScaleData、*dNormBiasData

输出。 设备内存中 normScaleData 和 normBiasData 梯度的指针，分别。

epsilon

输入。 归一化公式中使用的 Epsilon 值。其值应等于或大于零。相同 epsilon 值应在前向和后向函数中使用。

normMeanVarDesc

输入。 以下张量的共享张量描述符：savedMean 和 savedInvVariance。此张量描述符的维度取决于归一化模式。

对于 FP16 和 FP32 输入张量，此张量描述符的数据类型必须为 float，对于 FP64 输入张量，则必须为 double。有关更多信息，请参阅 cudnnTensorDescriptor_t。

*savedMean, *savedInvVariance

输入。 可选的缓存参数，包含在前向传递期间计算的已保存中间结果。为了使其正确工作，层的 x 和 normScaleData、normBiasData 数据必须保持不变，直到调用此后向函数。请注意，这两个参数可以同时为 NULL。建议使用此缓存，因为内存开销相对较小。

activationDesc

输入。 激活操作的描述符。当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，则使用此激活，否则用户可以传递 NULL。

工作区

输入。 指向 GPU 工作区的指针。

workSpaceSizeInBytes

输入。 工作区的大小。它必须足够大，才能由此函数触发快速 NHWC 半持久内核。

*reserveSpace

输入。 指向 reserveSpace 的 GPU 工作区的指针。

reserveSpaceSizeInBytes

输入。 reserveSpace 的大小。它必须等于或大于 cudnnGetNormalizationTrainingReserveSpaceSize() 所需的量。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 任何指针 alphaDataDiff、betaDataDiff、alphaParamDiff、betaParamDiff、xData、dyData、dxData、normScaleData、dNormScaleData 和 dNormBiasData 为 NULL。

  • xDesc、yDesc 或 dxDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • dNormScaleBiasDesc 维度对于按通道归一化的 4D 张量不是 1xCx1x1，对于 5D 张量不是 1xCx1x1x1；对于按激活归一化模式的 4D 张量不是 1xCxHxW，对于 5D 张量不是 1xCxDxHxW。

  • 指针 savedMean 和 savedInvVariance 中恰好有一个为 NULL。

  • epsilon 值小于零。

  • xDesc、dyDesc、dxDesc、dNormScaleBiasDesc 或 normMeanVarDesc 的任何一对的维度或数据类型不匹配。

cudnnNormalizationForwardInference()#

此函数在 cuDNN 9.0 中已弃用。

此函数执行推理阶段的前向归一化层计算。按通道归一化层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t
cudnnNormalizationForwardInference(cudnnHandle_t handle,
                                cudnnNormMode_t mode,
                                cudnnNormOps_t normOps,
                                cudnnNormAlgo_t algo,
                                const void *alpha,
                                const void *beta,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t normScaleBiasDesc,
                                const void *normScale,
                                const void *normBias,
                                const cudnnTensorDescriptor_t normMeanVarDesc,
                                const void *estimatedMean,
                                const void *estimatedVariance,
                                const cudnnTensorDescriptor_t zDesc,
                                const void *z,
                                cudnnActivationDescriptor_t activationDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
                                double epsilon,
                                int groupCnt);

仅支持 4D 和 5D 张量。

此函数执行的输入变换定义为

y = beta*y + alpha *[normBias + (normScale * (x-estimatedMean)/sqrt(epsilon + estimatedVariance)]

epsilon 值在训练、反向传播和推理期间必须相同。

对于训练阶段，请参阅 cudnnNormalizationForwardTraining()。

当 HW-packed 张量用于所有 x 和 y 时，可以获得更高的性能。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

*alpha, *beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。指向先前初始化的张量描述符的句柄。

*x

输入。 指向与张量描述符 xDesc 关联的 GPU 内存的数据指针，用于层的 x 输入数据。

*y

输出。 指向与张量描述符 yDesc 关联的 GPU 内存的数据指针，用于归一化层的 y 输出。

zDesc、*z

输入。 用于残差添加到归一化操作结果（在激活之前）的张量描述符和设备内存中的指针。zDesc 和 *z 是可选的，仅当 normOps 为 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时使用，否则用户可以传递 NULL。使用时，z 应具有与 x 和最终输出 y 完全相同的维度。有关更多信息，请参阅 cudnnTensorDescriptor_t。

由于 normOps 仅支持 CUDNN_NORM_OPS_NORM，目前我们可以将这些设置为 NULL。

normScaleBiasDesc, normScale, normBias

输入。 归一化比例和偏差参数的张量描述符和设备内存中的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta，比例被称为 gamma）。

normMeanVarDesc, estimatedMean, estimatedVariance

输入。 均值和方差张量及其张量描述符。 在训练阶段从 cudnnNormalizationForwardTraining() 调用中累积的 estimatedMean 和 estimatedVariance 输入应在此处作为输入传递。

activationDesc

输入。 激活操作的描述符。 当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，将使用此激活，否则用户可以传递 NULL。 由于 normOps 仅支持 CUDNN_NORM_OPS_NORM，目前我们可以将这些设置为 NULL。

epsilon

输入。 归一化公式中使用的 epsilon 值。 其值应等于或大于零。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

选择了不支持的计算或数据类型，或者选择了未知的算法类型。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alpha、beta、x、y、normScale、normBias、estimatedMean 和 estimatedInvVariance 之一为 NULL。

  • xDesc 或 yDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • normScaleBiasDesc 和 normMeanVarDesc 维度对于每通道模式，对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于每激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • epsilon 值小于零。

  • 对于 xDesc 和 yDesc，维度或数据类型不匹配。

cudnnNormalizationForwardTraining()#

此函数在 cuDNN 9.0 中已弃用。

此函数执行训练阶段的前向归一化层计算。 根据模式，将执行不同的归一化操作。 每通道层基于 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文。

cudnnStatus_t
cudnnNormalizationForwardTraining(cudnnHandle_t handle,
                                cudnnNormMode_t mode,
                                cudnnNormOps_t normOps,
                                cudnnNormAlgo_t algo,
                                const void *alpha,
                                const void *beta,
                                const cudnnTensorDescriptor_t xDesc,
                                    const void *xData,
                                const cudnnTensorDescriptor_t normScaleBiasDesc,
                                const void *normScale,
                                const void *normBias,
                                double exponentialAverageFactor,
                                const cudnnTensorDescriptor_t normMeanVarDesc,
                                void *resultRunningMean,
                                void *resultRunningVariance,
                                double epsilon,
                                void *resultSaveMean,
                                void *resultSaveInvVariance,
                                cudnnActivationDescriptor_t activationDesc,
                            const cudnnTensorDescriptor_t zDesc,
                                const void *zData,
                                const cudnnTensorDescriptor_t yDesc,
                                void *yData,
                                void *workspace,
                                size_t workSpaceSizeInBytes,
                                void *reserveSpace,
                                size_t reserveSpaceSizeInBytes,
                                int groupCnt);

仅支持 4D 和 5D 张量。

epsilon 值在训练、反向传播和推理期间必须相同。

对于推理阶段，请参阅 cudnnNormalizationForwardInference()。

当 HW 打包张量用于 x 和 y 时，可以获得更高的性能。

当满足以下条件时，此 API 将触发新的半持久 NHWC 内核

此 workspace 不需要是干净的。 此外，workspace 在前向和后向传递之间不必保持不变，因为它不用于传递任何信息。 此扩展函数可以接受指向 GPU 工作区的 *workspace 指针，以及来自用户的工作区大小 workSpaceSizeInBytes。

normOps 输入可用于将此函数设置为仅执行归一化，或归一化后跟激活，或归一化后跟逐元素加法，然后激活。

仅支持 4D 和 5D 张量。epsilon 值在训练、反向传播和推理期间必须相同。

当张量布局为 NCHW 时，当 xData、yData 使用 HW-packed 张量时，可以获得更高的性能。

参数

handle

输入。指向先前创建的 cuDNN 库描述符的句柄。有关更多信息，请参阅 cudnnHandle_t。

mode

输入。 运算模式（按通道或按激活）。有关更多信息，请参阅 cudnnNormMode_t。

normOps

输入。 后处理运算模式。目前，仅在 NHWC 布局中支持 CUDNN_NORM_OPS_NORM_ACTIVATION 和 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION。有关更多信息，请参阅 cudnnNormOps_t。此输入可用于设置此函数以执行仅归一化、或归一化后激活、或归一化后逐元素加法，然后再激活。

algo

输入。 要执行的算法。有关更多信息，请参阅 cudnnNormAlgo_t。

*alpha, *beta

输入。 指向缩放因子（在主机内存中）的指针，用于将层输出值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc, yDesc

输入。指向先前初始化的张量描述符的句柄。

*xData

输入。 指向与张量描述符 xDesc 关联的 GPU 内存的数据指针，用于层的 x 输入数据。

*yData

输出。 指向与张量描述符 yDesc 关联的 GPU 内存的数据指针，用于归一化层的 y 输出。

zDesc, *zData

输入。 用于残差加法的张量描述符和设备内存中的指针，加法操作在归一化操作的结果之后，激活操作之前。 zDesc 和 *zData 是可选的，仅当 normOps 为 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时使用，否则用户可以传递 NULL。 使用时，z 应具有与 xData 和最终输出 yData 完全相同的维度。 有关更多信息，请参阅 cudnnTensorDescriptor_t。

normScaleBiasDesc, normScale, normBias

输入。 归一化比例和偏差参数的张量描述符和设备内存中的指针（在 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 论文中，偏差被称为 beta，比例被称为 gamma）。 张量描述符的维度取决于归一化模式。

exponentialAverageFactor

输入。 在移动平均计算中使用的因子，如下所示

runningMean = runningMean*(1-factor) + newMean*factor

在第 N 次函数调用时使用 factor=1/(1+n) 以获得累积移动平均 (CMA) 行为，使得

CMA[n] = (x[1]+...+x[n])/n

下面证明了这一点

Writing
CMA[n+1] = (n*CMA[n]+x[n+1])/(n+1)
= ((n+1)*CMA[n]-CMA[n])/(n+1) + x[n+1]/(n+1)
= CMA[n]*(1-1/(n+1))+x[n+1]*1/(n+1)
= CMA[n]*(1-factor) + x(n+1)*factor
normMeanVarDesc

输入。 用于以下张量的张量描述符：resultRunningMean, resultRunningVariance, resultSaveMean, resultSaveInvVariance。

*resultRunningMean, *resultRunningVariance

输入/输出。 指向运行均值和运行方差数据的指针。 这两个指针都可以为 NULL，但只能同时为 NULL。 存储在 resultRunningVariance 中的值（或在推理模式下作为输入传递的值）是样本方差，并且是 variance[x] 的移动平均值，其中方差是根据模式在批次或空间+批次维度上计算的。 如果这些指针不为 NULL，则应将张量初始化为一些合理的值或 0。

epsilon

输入。 归一化公式中使用的 epsilon 值。 其值应等于或大于零。

*resultSaveMean, *resultSaveInvVariance

输出。 可选的缓存参数，包含前向传递期间计算的已保存中间结果。 为了使其正确工作，层的 x 和 normScale、normBias 数据必须保持不变，直到调用此后向函数。 请注意，这两个参数都可以为 NULL，但只能同时为 NULL。 建议使用此缓存，因为内存开销相对较小。

activationDesc

输入。 激活操作的张量描述符。 当 normOps 输入设置为 CUDNN_NORM_OPS_NORM_ACTIVATION 或 CUDNN_NORM_OPS_NORM_ADD_ACTIVATION 时，将使用此激活，否则用户可以传递 NULL。

*workspace, workSpaceSizeInBytes

输入。 *workspace 是指向 GPU 工作区的指针，workSpaceSizeInBytes 是工作区的大小。 当 *workspace 不为 NULL 且 *workSpaceSizeInBytes 足够大，并且张量布局为 NHWC 且数据类型配置受支持时，此函数将触发用于归一化的半持久 NHWC 内核。 工作区不需要是干净的。 此外，工作区在前向和后向传递之间不需要保持不变。

*reserveSpace

输入。 指向 reserveSpace 的 GPU 工作区的指针。

reserveSpaceSizeInBytes

输入。 reserveSpace 的大小。 必须等于或大于 cudnnGetNormalizationTrainingReserveSpaceSize() 所需的量。

groutCnt

输入。 目前仅支持 1。

返回值

CUDNN_STATUS_SUCCESS

计算已成功执行。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 指针 alpha、beta、xData、yData、normScale 和 normBias 之一为 NULL。

  • xDesc 或 yDesc 张量描述符维度的数量不在 [4,5] 范围内（仅支持 4D 和 5D 张量）。

  • normScaleBiasDesc 维度对于每通道模式，对于 4D 不是 1xCx1x1，对于 5D 不是 1xCx1x1x1；对于每激活模式，对于 4D 不是 1xCxHxW，对于 5D 不是 1xCxDxHxW。

  • resultSaveMean、resultSaveInvVariance 指针中恰好有一个为 NULL。

  • resultRunningMean、resultRunningInvVariance 指针中恰好有一个为 NULL。

  • epsilon 值小于零。

  • xDesc 或 yDesc 的维度或数据类型不匹配。

cudnnOpTensor()#

此函数在 cuDNN 9.0 中已弃用。

此函数实现方程 C = op(alpha1[0] * A, alpha2[0] * B) + beta[0] * C，给定张量 A、B 和 C 以及缩放因子 alpha1、alpha2 和 beta。 要使用的 op 由描述符 cudnnOpTensorDescriptor_t 指示，即 opTensorDesc 的类型。 当前支持的 ops 由 cudnnOpTensorOp_t 枚举列出。

cudnnStatus_t cudnnOpTensor(
    cudnnHandle_t                     handle,
    const cudnnOpTensorDescriptor_t   opTensorDesc,
    const void                       *alpha1,
    const cudnnTensorDescriptor_t     aDesc,
    const void                       *A,
    const void                       *alpha2,
    const cudnnTensorDescriptor_t     bDesc,
    const void                       *B,
    const void                       *beta,
    const cudnnTensorDescriptor_t     cDesc,
    void                             *C)

以下是对输入和目标张量的限制

  • 输入张量 A 的每个维度必须与目标张量 C 的相应维度匹配，并且输入张量 B 的每个维度必须与目标张量 C 的相应维度匹配或必须等于 1。 在后一种情况下，来自输入张量 B 的那些维度的相同值将用于混合到 C 张量中。

输入张量 A 和 B 以及目标张量 C 的数据类型，满足要求#

opTensorCompType 在 opTensorDesc 中

张量 A

张量 B

目标张量 C

FLOAT

FLOAT

FLOAT

FLOAT

FLOAT

INT8

INT8

FLOAT

FLOAT

HALF

HALF

FLOAT

FLOAT

BFLOAT16

BFLOAT16

FLOAT

DOUBLE

DOUBLE

DOUBLE

DOUBLE

FLOAT

FLOAT

FLOAT

HALF

FLOAT

HALF

HALF

HALF

FLOAT

INT8

INT8

INT8

FLOAT

FLOAT

FLOAT

INT8

FLOAT

FLOAT

FLOAT

BFLOAT16

FLOAT

BFLOAT16

BFLOAT16

BFLOAT16

CUDNN_TENSOR_NCHW_VECT_C 不支持作为输入张量格式。 支持维度高达五 (5) 的所有张量。 此例程不支持超出这些维度的张量格式。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

opTensorDesc

输入。 指向先前初始化的 op 张量描述符的句柄。

alpha1, alpha2, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将源值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

aDesc, bDesc, cDesc

输入。 指向先前初始化的张量描述符的句柄。

A, B

输入。 指向由 aDesc 和 bDesc 描述符分别描述的张量数据的指针。

C

输入/输出。指向由 cDesc 描述符描述的张量数据的指针。

返回值

CUDNN_STATUS_SUCCESS

函数执行成功。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 偏差张量和输出张量维度的维度超过 5。

  • opTensorCompType 未按上述设置。

CUDNN_STATUS_BAD_PARAM

目标张量 C 的数据类型无法识别，或者未满足上述对输入和目标张量的限制。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnOpsVersionCheck()#

跨库版本检查器。 每个子库都有一个版本检查器，用于检查其自身的版本是否与其依赖项的版本匹配。

cudnnStatus_t cudnnOpsVersionCheck(void)

返回值

CUDNN_STATUS_SUCCESS

版本检查通过。

CUDNN_STATUS_SUBLIBRARY_VERSION_MISMATCH

版本不一致。

cudnnPoolingBackward()#

此函数在 cuDNN 9.0 中已弃用。

此函数计算池化操作的梯度。

cudnnStatus_t cudnnPoolingBackward(
    cudnnHandle_t                       handle,
    const cudnnPoolingDescriptor_t      poolingDesc,
    const void                         *alpha,
    const cudnnTensorDescriptor_t       yDesc,
    const void                         *y,
    const cudnnTensorDescriptor_t       dyDesc,
    const void                         *dy,
    const cudnnTensorDescriptor_t       xDesc,
    const void                         *xData,
    const void                         *beta,
    const cudnnTensorDescriptor_t       dxDesc,
    void                               *dx)

从 cuDNN 版本 6.0 开始，为最大值后向池化实现了确定性算法。 可以通过 poolingDesc 的池化模式枚举来选择此算法。 经测量，确定性算法比传统的最大值后向池化算法慢 50%，或快 20%，具体取决于用例。

此函数中任何张量描述符参数都不支持张量向量化。 当使用 HW-packed 张量时，预计性能最佳。 仅支持 2 个和 3 个空间维度。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

poolingDesc

输入。 指向先前初始化的池化描述符的句柄。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将计算结果与输出层中的先前值混合，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

yDesc

输入。 指向先前初始化的输入张量描述符的句柄。 对于平均池化，可以为 NULL。

y

输入。 指向与张量描述符 yDesc 关联的 GPU 内存的数据指针。 对于平均池化，可以为 NULL。

dyDesc

输入。 指向先前初始化的输入微分张量描述符的句柄。 必须是 FLOAT、DOUBLE、HALF 或 BFLOAT16 类型。 有关更多信息，请参阅 cudnnDataType_t。

dy

输入。 指向与张量描述符 dyData 关联的 GPU 内存的数据指针。

xDesc

输入。 指向先前初始化的输出张量描述符的句柄。 对于平均池化，可以为 NULL。

x

输入。 指向与输出张量描述符 xDesc 关联的 GPU 内存的数据指针。 对于平均池化，可以为 NULL。

dxDesc

输入。 指向先前初始化的输出微分张量描述符的句柄。 必须是 FLOAT、DOUBLE、HALF 或 BFLOAT16 类型。 有关更多信息，请参阅 cudnnDataType_t。

dx

输出。指向与输出张量描述符 dxDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • yDesc 和 dyDesc 张量的维度 n、c、h、w 不同。

  • yDesc 和 dyDesc 张量的步幅 nStride、cStride、hStride、wStride 不同。

  • dxDesc 和 dxDesc 张量的维度 n、c、h、w 不同。

  • xDesc 和 dxDesc 张量的步幅 nStride、cStride、hStride、wStride 不同。

  • 四个张量的数据类型不同。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。 一些示例包括

  • 输入张量或输出张量的 wStride 不是 1。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnPoolingForward()#

此函数在 cuDNN 9.0 中已弃用。

此函数计算输入值的池化（即，几个相邻值的最大值或平均值），以生成高度和/或宽度较小的输出。

cudnnStatus_t cudnnPoolingForward(
    cudnnHandle_t                    handle,
    const cudnnPoolingDescriptor_t   poolingDesc,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *beta,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y)

支持所有张量格式，当使用 HW-packed 张量时，预计性能最佳。 仅允许 2 个和 3 个空间维度。 向量化张量仅在具有 2 个空间维度时受支持。

输出张量 yDesc 的维度可以小于或大于例程 cudnnGetPooling2dForwardOutputDim() 或 cudnnGetPoolingNdForwardOutputDim() 建议的维度。

对于平均池化，即使对于整数输入和输出数据类型，计算类型也是 float。 输出舍入为最近偶数，如果超出范围，则 clamp 到类型的最负值或最正值。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

poolingDesc

输入。 指向先前初始化的池化描述符的句柄。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将计算结果与输出层中的先前值混合，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。 指向先前初始化的输入张量描述符的句柄。 必须是 FLOAT、DOUBLE、HALF、INT8、INT8x4、INT8x32 或 BFLOAT16 类型。 有关更多信息，请参阅 cudnnDataType_t。

x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针。

yDesc

输入。 指向先前初始化的输出张量描述符的句柄。 必须是 FLOAT、DOUBLE、HALF、INT8、INT8x4、INT8x32 或 BFLOAT16 类型。 有关更多信息，请参阅 cudnnDataType_t。

y

输出。 指向与输出张量描述符 yDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 输入张量和输出张量的维度 n、c 不同。

  • 输入张量和输出张量的数据类型不同。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnReduceTensor()#

此函数在 cuDNN 9.0 中已弃用。

此函数通过实现方程 C = alpha * reduce op ( A ) + beta * C 来减少张量 A，给定张量 A 和 C 以及缩放因子 alpha 和 beta。 要使用的 reduce op 由描述符 reduceTensorDesc 指示。 当前支持的 ops 由 cudnnReduceTensorOp_t 枚举列出。

cudnnStatus_t cudnnReduceTensor(
    cudnnHandle_t                           handle,
    const cudnnReduceTensorDescriptor_t     reduceTensorDesc,
    void                                   *indices,
    size_t                                  indicesSizeInBytes,
    void                                   *workspace,
    size_t                                  workspaceSizeInBytes,
    const void                             *alpha,
    const cudnnTensorDescriptor_t           aDesc,
    const void                             *A,
    const void                             *beta,
    const cudnnTensorDescriptor_t           cDesc,
    void                                   *C)

输出张量 C 的每个维度必须与输入张量 A 的相应维度匹配，或者必须等于 1。 等于 1 的维度表示要减少的 A 的维度。

实现将仅为 min 和 max ops 生成索引，如 reduceTensorDesc 的 cudnnReduceTensorIndices_t 枚举所示。 请求其他 reduce ops 的索引会导致错误。 索引的数据类型由 cudnnIndicesType_t 枚举指示；目前仅支持 32 位（无符号整数）类型。

实现返回的索引不是绝对索引，而是相对于要减少的维度的索引。 索引也是扁平化的，即不是坐标元组。

如果类型为 double，则张量 A 和 C 的数据类型必须匹配。 在这种情况下，alpha 和 beta 以及 reduceTensorDesc 的计算枚举都假定为 double 类型。

HALF 和 INT8 数据类型可以与 FLOAT 数据类型混合。 在这些情况下，reduceTensorDesc 的计算枚举必须是 FLOAT 类型。

支持维度高达 8 的所有张量格式。 此例程不支持超出这些维度的格式。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

reduceTensorDesc

输入。 指向先前初始化的 reduce 张量描述符的句柄。

indices

输出。 指向先前分配的空间的句柄，用于写入索引。

indicesSizeInBytes

输入。 上述先前分配的空间的大小。

工作区

输入。 指向先前分配的空间的句柄，用于 reduce 实现。

workspaceSizeInBytes

输入。 上述先前分配的空间的大小。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将源值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*resultValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

aDesc, cDesc

输入。 指向先前初始化的张量描述符的句柄。

A

输入。指向由 aDesc 描述符描述的张量数据的指针。

C

输入/输出。指向由 cDesc 描述符描述的张量数据的指针。

返回值

CUDNN_STATUS_SUCCESS

函数执行成功。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 输入张量和输出张量的维度超过 8。

  • reduceTensorCompType 未按上述设置。

CUDNN_STATUS_BAD_PARAM

输入张量和输出张量的相应维度全部匹配，或者未满足上述段落中的条件。

CUDNN_INVALID_VALUE

索引或工作区的分配不足。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnRestoreDropoutDescriptor()#

此函数将 dropout 描述符恢复到先前保存的状态。

cudnnStatus_t cudnnRestoreDropoutDescriptor(
    cudnnDropoutDescriptor_t dropoutDesc,
    cudnnHandle_t            handle,
    float                    dropout,
    void                    *states,
    size_t                   stateSizeInBytes,
    unsigned long long       seed)

参数

dropoutDesc

输入/输出。 先前创建的 dropout 描述符。

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

dropout

输入。 在执行 dropout 时，输入张量中的值设置为 0 的概率。

states

输入。 指向 GPU 内存的指针，该内存保存由先前调用 cudnnSetDropoutDescriptor() 初始化的随机数生成器状态。

stateSizeInBytes

输入。 保存随机数生成器 states 的缓冲区的大小（以字节为单位）。

seed

输入。 在先前调用 cudnnSetDropoutDescriptor() 中使用的种子，用于初始化 states 缓冲区。 使用与此不同的种子无效。 可以通过调用 cudnnSetDropoutDescriptor() 来实现种子的更改以及随后对随机数生成器状态的更新。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_INVALID_VALUE

states 缓冲区大小（如 stateSizeInBytes 中所示）太小。

cudnnScaleTensor()#

此函数在 cuDNN 9.0 中已弃用。

此函数将张量的所有元素按给定的因子缩放。

cudnnStatus_t cudnnScaleTensor(
    cudnnHandle_t                   handle,
    const cudnnTensorDescriptor_t   yDesc,
    void                           *y,
    const void                     *alpha)

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

yDesc

输入。指向先前初始化的张量描述符的句柄。

y

输入/输出。 指向由 yDesc 描述符描述的张量数据的指针。

alpha

输入。 指向 Host 内存中单个值的指针，该值将用于缩放张量的所有元素。 有关更多信息，请参阅 缩放参数。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

提供的指针之一为 NIL。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSetActivationDescriptor()#

此函数初始化先前创建的通用激活描述符对象。

cudnnStatus_t cudnnSetActivationDescriptor(
    cudnnActivationDescriptor_t         activationDesc,
    cudnnActivationMode_t               mode,
    cudnnNanPropagation_t               reluNanOpt,
    double                              coef)

参数

activationDesc

输入/输出。 指向先前创建的激活描述符的句柄。

mode

输入。 枚举器，用于指定激活模式。

reluNanOpt

输入。 枚举器，用于指定 Nan 传播模式。

coef

输入。 浮点数。 当激活模式（请参阅 cudnnActivationMode_t）设置为 CUDNN_ACTIVATION_CLIPPED_RELU 时，此输入指定裁剪阈值；当激活模式设置为 CUDNN_ACTIVATION_RELU 时，此输入指定上限。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

mode 或 reluNanOpt 具有无效的枚举值。

cudnnSetActivationDescriptorSwishBeta()#

此函数将 SWISH 激活函数的 beta 参数设置为 swish_beta。

cudnnStatus_t cudnnSetActivationDescriptorSwishBeta(cudnnActivationDescriptor_t activationDesc, double swish_beta)

参数

activationDesc

输入/输出。 指向先前创建的激活描述符的句柄。

swish_beta

输入。 用于设置 SWISH 激活的 beta 参数的值。

返回值

CUDNN_STATUS_SUCCESS

值已成功设置。

CUDNN_STATUS_BAD_PARAM

激活描述符是 NULL 指针。

cudnnSetDropoutDescriptor()#

此函数初始化先前创建的 dropout 描述符对象。 如果 states 参数等于 NULL，则不会初始化随机数生成器状态，并且只会设置 dropout 值。 用户不应更改 states 指向的内存，直到计算完成。

cudnnStatus_t cudnnSetDropoutDescriptor(
    cudnnDropoutDescriptor_t    dropoutDesc,
    cudnnHandle_t               handle,
    float                       dropout,
    void                       *states,
    size_t                      stateSizeInBytes,
    unsigned long long          seed)

当 states 参数不为 NULL 时，cudnnSetDropoutDescriptor() 会调用 cuRAND 初始化内核。 此内核需要大量的 GPU 内存用于堆栈。 内核完成时，内存将被释放。 当没有足够的可用内存用于 GPU 堆栈时，将返回 CUDNN_STATUS_ALLOC_FAILED 状态。

参数

dropoutDesc

输入/输出。 先前创建的 dropout 描述符对象。

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

dropout

输入。 在 dropout 层期间，输入值设置为零的概率。

states

输出。 指向用户分配的 GPU 内存的指针，该内存将保存随机数生成器状态。

stateSizeInBytes

输入。 指定为状态提供的内存大小（以字节为单位）。

seed

输入。 用于初始化随机数生成器状态的种子。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_INVALID_VALUE

sizeInBytes 参数小于 cudnnDropoutGetStatesSize() 返回的值。

CUDNN_STATUS_ALLOC_FAILED

该函数无法临时扩展 GPU 堆栈。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

CUDNN_STATUS_INTERNAL_ERROR

内部使用的 CUDA 函数返回错误状态。

cudnnSetFilter4dDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数将先前创建的过滤器描述符对象初始化为 4D 过滤器。 过滤器的布局在内存中必须是连续的。

cudnnStatus_t cudnnSetFilter4dDescriptor(
    cudnnFilterDescriptor_t    filterDesc,
    cudnnDataType_t            dataType,
    cudnnTensorFormat_t        format,
    int                        k,
    int                        c,
    int                        h,
    int                        w)

Tensor format CUDNN_TENSOR_NHWC 在 cudnnConvolutionForward()、cudnnConvolutionBackwardData() 和 cudnnConvolutionBackwardFilter() 中的支持有限。

参数

filterDesc

输入/输出。 指向先前创建的过滤器描述符的句柄。

datatype

输入。 数据类型。

format

输入。 过滤器布局格式的类型。 如果此输入设置为 CUDNN_TENSOR_NCHW，这是 cudnnTensorFormat_t 描述符允许的枚举值之一，则过滤器的布局形式为 KCRS，其中

  • K 表示输出特征图的数量

  • C 是输入特征图的数量

  • R 是每个过滤器的行数

  • S 是每个过滤器的列数

如果此输入设置为 CUDNN_TENSOR_NHWC，则过滤器的布局形式为 KRSC。

k

输入。 输出特征图的数量。

c

输入。 输入特征图的数量。

h

输入。 每个过滤器的高度。

w

输入。 每个过滤器的宽度。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

参数 k、c、h、w 中至少有一个为负数，或者 dataType 或 format 具有无效的枚举值。

cudnnSetFilterNdDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数初始化先前创建的过滤器描述符对象。 过滤器的布局在内存中必须是连续的。

cudnnStatus_t cudnnSetFilterNdDescriptor(
    cudnnFilterDescriptor_t filterDesc,
    cudnnDataType_t         dataType,
    cudnnTensorFormat_t     format,
    int                     nbDims,
    const int               filterDimA[])

张量格式 CUDNN_TENSOR_NHWC 在 cudnnConvolutionForward()、cudnnConvolutionBackwardData() 和 cudnnConvolutionBackwardFilter() 中的支持有限。

参数

filterDesc

输入/输出。 指向先前创建的过滤器描述符的句柄。

datatype

输入。 数据类型。

format

输入。过滤器布局格式的类型。 如果此输入设置为 CUDNN_TENSOR_NCHW，这是 cudnnTensorFormat_t 描述符允许的枚举值之一，则过滤器的布局如下

  • 对于 N=4，4D 过滤器描述符，过滤器布局的形式为 KCRS

    • K 表示输出特征图的数量

    • C 是输入特征图的数量

    • R 是每个过滤器的行数

    • S 是每个过滤器的列数

  • 对于 N=3，3D 过滤器描述符，数字 S（每个过滤器的列数）被省略。

  • 对于 N=5 和更大，更高维度的布局紧随 RS 之后。

另一方面，如果此输入设置为 CUDNN_TENSOR_NHWC，则过滤器的布局如下

  • 对于 N=4，4D 过滤器描述符，过滤器布局的形式为 KRSC。

  • 对于 N=3，3D 过滤器描述符，数字 S（每个过滤器的列数）被省略，并且 C 的布局紧随 R 之后。

  • 对于 N=5 和更大，更高维度的布局插入在 S 和 C 之间。

nbDims

输入。 过滤器的维度。

filterDimA

输入。 维度为 nbDims 的数组，其中包含每个维度的过滤器大小。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

数组 filterDimA 的元素中至少有一个为负数，或者 dataType 或 format 具有无效的枚举值。

CUDNN_STATUS_NOT_SUPPORTED

参数 nbDims 超过 CUDNN_DIM_MAX。

cudnnSetLRNDescriptor()#

此函数初始化先前创建的 LRN 描述符对象。

cudnnStatus_t cudnnSetLRNDescriptor(
    cudnnLRNDescriptor_t   normDesc,
    unsigned               lrnN,
    double                 lrnAlpha,
    double                 lrnBeta,
    double                 lrnK)

注意

  • 在 cudnn.h 中定义的宏 CUDNN_LRN_MIN_N、CUDNN_LRN_MAX_N、CUDNN_LRN_MIN_K、CUDNN_LRN_MIN_BETA 指定了参数的有效范围。

  • 双精度参数的值将在计算期间向下转换为张量 datatype。

参数

normDesc

输出。 指向先前创建的 LRN 描述符的句柄。

lrnN

输入。 归一化窗口宽度（以元素为单位）。 LRN 层使用窗口 [center-lookBehind, center+lookAhead]，其中 lookBehind = floor( (lrnN-1)/2 )，lookAhead = lrnN-lookBehind-1。 因此，对于 n=10，窗口为 [k-4...k...k+5]，总共有 10 个样本。 对于 DivisiveNormalization 层，窗口在所有空间维度（dimA[2]、dimA[3]、dimA[4]）上具有与上述相同的范围。 默认情况下，在 cudnnCreateLRNDescriptor() 中，lrnN 设置为 5。

lrnAlpha

输入。 归一化公式中 alpha 方差缩放参数的值。 在库代码内部，对于 LRN，此值除以窗口宽度；对于 DivisiveNormalization，此值除以 (窗口宽度)^#空间维度。 默认情况下，在 cudnnCreateLRNDescriptor() 中，此值设置为 1e-4。

lrnBeta

输入。 归一化公式中 beta 幂参数的值。 默认情况下，在 cudnnCreateLRNDescriptor() 中，此值设置为 0.75。

lrnK

输入。 归一化公式中 k 参数的值。 默认情况下，此值设置为 2.0。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

其中一个输入参数超出上述有效范围。

cudnnSetOpTensorDescriptor()#

此函数初始化张量逐元素数学运算描述符。

cudnnStatus_t cudnnSetOpTensorDescriptor(
    cudnnOpTensorDescriptor_t   opTensorDesc,
    cudnnOpTensorOp_t           opTensorOp,
    cudnnDataType_t             opTensorCompType,
    cudnnNanPropagation_t       opTensorNanOpt)

参数

opTensorDesc

输出。 指向保存张量逐元素数学运算描述符描述的结构的指针。

opTensorOp

输入。 此张量逐元素数学运算描述符的张量逐元素数学运算。

opTensorCompType

输入。 此张量逐元素数学运算描述符的计算数据类型。

opTensorNanOpt

输入。 NAN 传播策略。

返回值

CUDNN_STATUS_SUCCESS

函数成功返回。

CUDNN_STATUS_BAD_PARAM

至少传递的一个输入参数无效。

cudnnSetPooling2dDescriptor()#

此函数将先前创建的通用池化描述符对象初始化为 2D 描述。

cudnnStatus_t cudnnSetPooling2dDescriptor(
    cudnnPoolingDescriptor_t    poolingDesc,
    cudnnPoolingMode_t          mode,
    cudnnNanPropagation_t       maxpoolingNanOpt,
    int                         windowHeight,
    int                         windowWidth,
    int                         verticalPadding,
    int                         horizontalPadding,
    int                         verticalStride,
    int                         horizontalStride)

参数

poolingDesc

输入/输出。 指向先前创建的池化描述符的句柄。

mode

输入。 用于指定池化模式的枚举值。

maxpoolingNanOpt

输入。 枚举数，用于指定 Nan 传播模式。

windowHeight

输入。 池化窗口的高度。

windowWidth

输入。 池化窗口的宽度。

verticalPadding

输入。 垂直填充的大小。

horizontalPadding

输入。 水平填充的大小

verticalStride

输入。 池化垂直步幅。

horizontalStride

输入。 池化水平步幅。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

参数 windowHeight、windowWidth、verticalStride、horizontalStride 中至少有一个为负数，或者模式或 maxpoolingNanOpt 具有无效的枚举值。

cudnnSetPoolingNdDescriptor()#

此函数初始化先前创建的通用池化描述符对象。

cudnnStatus_t cudnnSetPoolingNdDescriptor(
    cudnnPoolingDescriptor_t     poolingDesc,
    const cudnnPoolingMode_t     mode,
    const cudnnNanPropagation_t  maxpoolingNanOpt,
    int                          nbDims,
    const int                    windowDimA[],
    const int                    paddingA[],
    const int                    strideA[])

参数

poolingDesc

输入/输出。 指向先前创建的池化描述符的句柄。

mode

输入。 用于指定池化模式的枚举值。

maxpoolingNanOpt

输入。 枚举数，用于指定 Nan 传播模式。

nbDims

输入。 池化操作的维度。 必须大于零。

windowDimA

输入。 维度为 nbDims 的数组，其中包含每个维度的窗口大小。 数组元素的值必须大于零。

paddingA

输入。 维度为 nbDims 的数组，其中包含每个维度的填充大小。 允许负填充。

strideA

输入。 维度为 nbDims 的数组，其中包含每个维度的步幅大小。 数组元素的值必须大于零（即，不允许负步幅大小）。

返回值

CUDNN_STATUS_SUCCESS

对象已成功初始化。

CUDNN_STATUS_NOT_SUPPORTED

如果 (nbDims > CUDNN_DIM_MAX-2)。

CUDNN_STATUS_BAD_PARAM

nbDims，或者数组 windowDimA 或 strideA 的元素中至少有一个为负数，或者模式或 maxpoolingNanOpt 具有无效的枚举值。

cudnnSetReduceTensorDescriptor()#

此函数初始化先前创建的归约张量描述符对象。

cudnnStatus_t cudnnSetReduceTensorDescriptor(
    cudnnReduceTensorDescriptor_t   reduceTensorDesc,
    cudnnReduceTensorOp_t           reduceTensorOp,
    cudnnDataType_t                 reduceTensorCompType,
    cudnnNanPropagation_t           reduceTensorNanOpt,
    cudnnReduceTensorIndices_t      reduceTensorIndices,
    cudnnIndicesType_t              reduceTensorIndicesType)

参数

reduceTensorDesc

输入/输出。 指向先前创建的归约张量描述符的句柄。

reduceTensorOp

输入。 用于指定归约张量操作的枚举值。

reduceTensorCompType

输入。 用于指定归约的计算数据类型的枚举值。

reduceTensorNanOpt

输入。 枚举数，用于指定 Nan 传播模式。

reduceTensorIndices

输入。 用于指定归约张量索引的枚举值。

reduceTensorIndicesType

输入。 用于指定归约张量索引类型的枚举值。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

reduceTensorDesc 为 NULL（reduceTensorOp、reduceTensorCompType、reduceTensorNanOpt、reduceTensorIndices 或 reduceTensorIndicesType 具有无效的枚举值）。

cudnnSetSpatialTransformerNdDescriptor()#

此函数初始化先前创建的通用空间变换器描述符对象。

cudnnStatus_t cudnnSetSpatialTransformerNdDescriptor(
    cudnnSpatialTransformerDescriptor_t     stDesc,
    cudnnSamplerType_t                      samplerType,
    cudnnDataType_t                         dataType,
    const int                               nbDims,
    const int                               dimA[])

参数

stDesc

输入/输出。 先前创建的空间变换器描述符对象。

samplerType

输入。 用于指定采样器类型的枚举值。

dataType

输入。 数据类型。

nbDims

输入。 变换后的张量的维度。

dimA

输入。 维度为 nbDims 的数组，其中包含每个维度的变换后张量的大小。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • stDesc 或 dimA 为 NULL。

  • dataType 或 samplerType 具有无效的枚举值。

cudnnSetTensor()#

此函数将张量的所有元素设置为给定值。

cudnnStatus_t cudnnSetTensor(
    cudnnHandle_t                   handle,
    const cudnnTensorDescriptor_t   yDesc,
    void                           *y,
    const void                     *valuePtr)

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

yDesc

输入。指向先前初始化的张量描述符的句柄。

y

输入/输出。 指向由 yDesc 描述符描述的张量数据的指针。

valuePtr

输入。 指向主机内存中单个值的指针。 张量 y 的所有元素都将设置为 value[0]。 value[0] 中元素的数据类型必须与张量 y 的数据类型匹配。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

提供的指针之一为 NIL。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSetTensor4dDescriptor()#

此函数将先前创建的通用张量描述符对象初始化为 4D 张量。 四个维度的步幅从 format 参数推断出来，并以数据在内存中连续且维度之间没有填充的方式设置。

cudnnStatus_t cudnnSetTensor4dDescriptor(
    cudnnTensorDescriptor_t tensorDesc,
    cudnnTensorFormat_t     format,
    cudnnDataType_t         dataType,
    int                     n,
    int                     c,
    int                     h,
    int                     w)

张量的总大小（包括维度之间可能的填充）限制为 2 Giga 元素，类型为 datatype。

参数

tensorDesc

输入/输出。 指向先前创建的张量描述符的句柄。

format

输入。 格式类型。

datatype

输入。 数据类型。

n

输入。 图像数量。

c

输入。 每个图像的特征图数量。

h

输入。 每个特征图的高度。

w

输入。 每个特征图的宽度。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

参数 n、c、h、w 中至少有一个为负数，或者 format 具有无效的枚举值，或者 dataType 具有无效的枚举值。

CUDNN_STATUS_NOT_SUPPORTED

张量描述符的总大小超过 2 Giga 元素的最大限制。

cudnnSetTensor4dDescriptorEx()#

此函数将先前创建的通用张量描述符对象初始化为 4D 张量，类似于 cudnnSetTensor4dDescriptor()，但步幅显式作为参数传递。 这可用于以任何顺序布局 4D 张量，或者仅用于定义维度之间的间隙。

cudnnStatus_t cudnnSetTensor4dDescriptorEx(
    cudnnTensorDescriptor_t     tensorDesc,
    cudnnDataType_t             dataType,
    int                         n,
    int                         c,
    int                         h,
    int                         w,
    int                         nStride,
    int                         cStride,
    int                         hStride,
    int                         wStride)

目前，某些 cuDNN 例程对步幅的支持有限。 如果使用具有不受支持的步幅的 4D 张量对象，这些例程将返回 CUDNN_STATUS_NOT_SUPPORTED。 cudnnTransformTensor() 可用于将数据转换为受支持的布局。

张量的总大小（包括维度之间可能的填充）限制为 2 Giga 元素，类型为 datatype。

参数

tensorDesc

输入/输出。 指向先前创建的张量描述符的句柄。

datatype

输入。 数据类型。

n

输入。 图像数量。

c

输入。 每个图像的特征图数量。

h

输入。 每个特征图的高度。

w

输入。 每个特征图的宽度。

nStride

输入。 两个连续图像之间的步幅。

cStride

输入。 两个连续特征图之间的步幅。

hStride

输入。 两个连续行之间的步幅。

wStride

输入。 两个连续列之间的步幅。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

参数 n、c、h、w 或 nStride、cStride、hStride、wStride 中至少有一个为负数，或者 dataType 具有无效的枚举值。

CUDNN_STATUS_NOT_SUPPORTED

张量描述符的总大小超过 2 Giga 元素的最大限制。

cudnnSetTensorNdDescriptor()#

此函数初始化先前创建的通用张量描述符对象。

cudnnStatus_t cudnnSetTensorNdDescriptor(
    cudnnTensorDescriptor_t tensorDesc,
    cudnnDataType_t         dataType,
    int                     nbDims,
    const int               dimA[],
    const int               strideA[])

张量的总大小（包括维度之间可能的填充）限制为 2 Giga 元素，类型为 datatype。 张量被限制为至少具有 4 个维度，最多具有 CUDNN_DIM_MAX 个维度（在 cudnn.h 中定义）。 当处理较低维度的数据时，建议用户创建 4D 张量，并将未使用的维度的大小设置为 1。

参数

tensorDesc

输入/输出。 指向先前创建的张量描述符的句柄。

datatype

输入。 数据类型。

nbDims

输入。 张量的维度。

请勿使用 2 个维度。 由于历史原因，过滤器描述符中的最小维度数为 3。

dimA

输入。 维度为 nbDims 的数组，其中包含每个维度的张量大小。 未使用维度的大小应设置为 1。 按照惯例，数组中维度的顺序遵循格式 - [N, C, D, H, W]，其中 W 在数组中占据最小的索引。

strideA

输入。 维度为 nbDims 的数组，其中包含每个维度的张量步幅。 按照惯例，数组中步幅的顺序遵循格式 - [Nstride, Cstride, Dstride, Hstride, Wstride]，其中 Wstride 在数组中占据最小的索引。

返回值

CUDNN_STATUS_SUCCESS

对象已成功设置。

CUDNN_STATUS_BAD_PARAM

数组 dimA 的元素中至少有一个为负数或零，或者 dataType 具有无效的枚举值。

CUDNN_STATUS_NOT_SUPPORTED

参数 nbDims 超出范围 [4, CUDNN_DIM_MAX]，或者张量描述符的总大小超过 2 Giga 元素的最大限制。

cudnnSetTensorNdDescriptorEx()#

此函数初始化 Nd 张量描述符。

cudnnStatus_t cudnnSetTensorNdDescriptorEx(
    cudnnTensorDescriptor_t tensorDesc,
    cudnnTensorFormat_t     format,
    cudnnDataType_t         dataType,
    int                     nbDims,
    const int               dimA[])

参数

tensorDesc

输出。 指向要初始化的张量描述符结构的指针。

format

输入。 张量格式。

dataType

输入。 张量数据类型。

nbDims

输入。 张量的维度。

请勿使用 2 个维度。 由于历史原因，过滤器描述符中的最小维度数为 3。

dimA

输入。 包含每个维度大小的数组。

返回值

CUDNN_STATUS_SUCCESS

函数已成功执行。

CUDNN_STATUS_BAD_PARAM

张量描述符未正确分配；或者输入参数设置不正确。

CUDNN_STATUS_NOT_SUPPORTED

请求的维度大小大于支持的最大维度大小。

cudnnSetTensorTransformDescriptor()#

此函数在 cuDNN 9.0 中已弃用。

此函数初始化张量变换描述符，该描述符是先前使用 cudnnCreateTensorTransformDescriptor() 函数创建的。

cudnnStatus_t cudnnSetTensorTransformDescriptor(
    cudnnTensorTransformDescriptor_t transformDesc,
    const uint32_t nbDims,
    const cudnnTensorFormat_t destFormat,
    const int32_t padBeforeA[],
    const int32_t padAfterA[],
    const uint32_t foldA[],
    const cudnnFoldingDirection_t direction);

参数

transformDesc

输出。 要初始化的张量变换描述符。

nbDims

输入。 变换操作数的维度。 必须大于 2。 有关更多信息，请参阅 张量描述符。

destFormat

输入。 所需的目标格式。

padBeforeA[]

输入。 一个数组，其中包含应在每个维度之前添加的填充量。 设置为 NULL 表示不填充。

padAfterA[]

输入。 一个数组，其中包含应在每个维度之后添加的填充量。 设置为 NULL 表示不填充。

foldA[]

输入。 一个数组，其中包含每个空间维度（维度 2 及更高维度）的折叠参数。 设置为 NULL 表示不折叠。

direction

输入。 选择折叠或展开。 当所有折叠参数都 <= 1 时，此输入无效。 有关更多信息，请参阅 cudnnFoldingDirection_t。

返回值

CUDNN_STATUS_SUCCESS

函数已成功启动。

CUDNN_STATUS_BAD_PARAM

参数 transformDesc 为 NULL，或者如果 direction 无效，或者 nbDims <= 2。

CUDNN_STATUS_NOT_SUPPORTED

如果请求的维度大小大于支持的最大维度大小（即，nbDims 之一大于 CUDNN_DIM_MAX），或者如果 destFromat 不是 NCHW 或 NHWC。

cudnnSoftmaxBackward()#

此例程计算 Softmax 函数的梯度。

cudnnStatus_t cudnnSoftmaxBackward(
    cudnnHandle_t                    handle,
    cudnnSoftmaxAlgorithm_t          algorithm,
    cudnnSoftmaxMode_t               mode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    yDesc,
    const void                      *yData,
    const cudnnTensorDescriptor_t    dyDesc,
    const void                      *dy,
    const void                      *beta,
    const cudnnTensorDescriptor_t    dxDesc,
    void                            *dx)

此例程允许就地操作；即，dy 和 dx 指针可能相等。 但是，这要求 dyDesc 和 dxDesc 描述符相同（特别是，输入和输出的步幅必须匹配才允许就地操作）。

所有张量格式都支持所有模式和算法，适用于 4D 和 5D 张量。 NCHW 完全 packed 张量的性能预计最高。 对于超过 5 个维度的张量，必须在其空间维度中进行 packed。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

algorithm

输入。 用于指定 Softmax 算法的枚举值。

mode

输入。 用于指定 Softmax 模式的枚举值。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将计算结果与输出层中的先前值混合，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

yDesc

输入。指向先前初始化的输入张量描述符的句柄。

y

输入。指向与张量描述符 yDesc 关联的 GPU 内存的数据指针。

dyDesc

输入。指向先前初始化的输入微分张量描述符的句柄。

dy

输入。 指向与张量描述符 dyData 关联的 GPU 内存的数据指针。

dxDesc

输入。指向先前初始化的输出微分张量描述符的句柄。

dx

输出。指向与输出张量描述符 dxDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • yDesc、dyDesc 和 dxDesc 张量的维度 n、c、h、w 不同。

  • yDesc 和 dyDesc 张量的步幅 nStride、cStride、hStride、wStride 不同。

  • 三个张量的 datatype 不同。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSoftmaxForward()#

此例程计算 Softmax 函数。

cudnnStatus_t cudnnSoftmaxForward(
    cudnnHandle_t                    handle,
    cudnnSoftmaxAlgorithm_t          algorithm,
    cudnnSoftmaxMode_t               mode,
    const void                      *alpha,
    const cudnnTensorDescriptor_t    xDesc,
    const void                      *x,
    const void                      *beta,
    const cudnnTensorDescriptor_t    yDesc,
    void                            *y)

此例程允许就地操作；即，x 和 y 指针可能相等。 但是，这要求 xDesc 和 yDesc 描述符相同（特别是，输入和输出的步幅必须匹配才允许就地操作）。

所有张量格式都支持所有模式和算法，适用于 4D 和 5D 张量。 NCHW 完全 packed 张量的性能预计最高。 对于超过 5 个维度的张量，必须在其空间维度中进行 packed。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

algorithm

输入。 用于指定 Softmax 算法的枚举值。

mode

输入。 用于指定 Softmax 模式的枚举值。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将计算结果与输出层中的先前值混合，如下所示

dstValue = alpha[0]*result + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。指向先前初始化的输入张量描述符的句柄。

x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针。

yDesc

输入。指向先前初始化的输出张量描述符的句柄。

y

输出。 指向与输出张量描述符 yDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • 输入张量和输出张量的维度 n、c、h、w 不同。

  • 输入张量和输出张量的 datatype 不同。

  • 参数 algorithm 或 mode 具有无效的枚举值。

CUDNN_STATUS_EXECUTION_FAILED 函数无法在 GPU 上启动。

cudnnSpatialTfGridGeneratorBackward()#

此函数计算网格生成操作的梯度。

cudnnStatus_t cudnnSpatialTfGridGeneratorBackward(
    cudnnHandle_t                               handle,
    const cudnnSpatialTransformerDescriptor_t   stDesc,
    const void                                 *dgrid,
    void                                       *dtheta)

仅支持 2D 变换。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

stDesc

输入。 先前创建的空间变换器描述符对象。

dgrid

输入。 指向 GPU 内存的数据指针，其中包含输入微分数据。

dtheta

输出。 指向 GPU 内存的数据指针，其中包含输出微分数据。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • handle 为 NULL。

  • 参数 dgrid 或 dtheta 之一为 NULL。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。 一些示例包括

  • 在 stDesc 中指定的变换后张量的维度 > 4。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSpatialTfGridGeneratorForward()#

此函数在输入张量中生成与输出张量中每个像素对应的坐标网格。

cudnnStatus_t cudnnSpatialTfGridGeneratorForward(
    cudnnHandle_t                               handle,
    const cudnnSpatialTransformerDescriptor_t   stDesc,
    const void                                 *theta,
    void                                       *grid)

仅支持 2D 变换。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

stDesc

输入。 先前创建的空间变换器描述符对象。

theta

输入。 仿射变换矩阵。 对于 2D 变换，它的大小应为 n*2*3，其中 n 是在 stDesc 中指定的图像数量。

grid

输出。 坐标网格。 对于 2D 变换，它的大小为 n*h*w*2，其中 n、h、w 在 stDesc 中指定。 在第 4 维度中，第一个坐标是 x，第二个坐标是 y。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • handle 为 NULL。

  • 参数 grid 或 theta 之一为 NULL。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 在 stDesc 中指定的变换后张量的维度 > 4。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSpatialTfSamplerBackward()#

此函数计算采样操作的梯度。

cudnnStatus_t cudnnSpatialTfSamplerBackward(
    cudnnHandle_t                              handle,
    const cudnnSpatialTransformerDescriptor_t  stDesc,
    const void                                *alpha,
    const cudnnTensorDescriptor_t              xDesc,
    const void                                *x,
    const void                                *beta,
    const cudnnTensorDescriptor_t              dxDesc,
    void                                      *dx,
    const void                                *alphaDgrid,
    const cudnnTensorDescriptor_t              dyDesc,
    const void                                *dy,
    const void                                *grid,
    const void                                *betaDgrid,
    void                                      *dgrid)

仅支持 2D 变换。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

stDesc

输入。 先前创建的空间变换器描述符对象。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将源值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*srcValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。指向先前初始化的输入张量描述符的句柄。

x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针。

dxDesc

输入。指向先前初始化的输出微分张量描述符的句柄。

dx

输出。指向与输出张量描述符 dxDesc 关联的 GPU 内存的数据指针。

alphaDgrid、betaDgrid

输入。 指向缩放因子（在主机内存中）的指针，用于将梯度输出 dgrid 与目标指针中的先前值混合，如下所示

dstValue = alpha[0]*srcValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

dyDesc

输入。指向先前初始化的输入微分张量描述符的句柄。

dy

输入。指向与张量描述符 dyDesc 关联的 GPU 内存的数据指针。

grid

输入。 由 cudnnSpatialTfGridGeneratorForward() 生成的坐标网格。

dgrid

输出。 指向 GPU 内存的数据指针，其中包含输出微分数据。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • handle 为 NULL。

  • 参数 x、dx、y、dy、grid 和 dgrid 之一为 NULL。

  • dy 的维度与 stDesc 中指定的维度不同。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 变换后张量的维度 > 4。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnSpatialTfSamplerForward()#

此函数执行采样器操作，并使用网格生成器给出的网格生成输出张量。

cudnnStatus_t cudnnSpatialTfSamplerForward(
    cudnnHandle_t                              handle,
    const cudnnSpatialTransformerDescriptor_t  stDesc,
    const void                                *alpha,
    const cudnnTensorDescriptor_t              xDesc,
    const void                                *x,
    const void                                *grid,
    const void                                *beta,
    cudnnTensorDescriptor_t                    yDesc,
    void                                      *y)

仅支持 2D 变换。

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

stDesc

输入。 先前创建的空间变换器描述符对象。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将源值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*srcValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。指向先前初始化的输入张量描述符的句柄。

x

输入。指向与张量描述符 xDesc 关联的 GPU 内存的数据指针。

grid

输入。 由 cudnnSpatialTfGridGeneratorForward() 生成的坐标网格。

yDesc

输入。指向先前初始化的输出张量描述符的句柄。

y

输出。 指向与输出张量描述符 yDesc 关联的 GPU 内存的数据指针。

返回值

CUDNN_STATUS_SUCCESS

调用成功。

CUDNN_STATUS_BAD_PARAM

满足以下至少一个条件

  • handle 为 NULL。

  • 参数 x、y 或 grid 之一为 NULL。

  • dy 的维度与 stDesc 中指定的维度不同。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。一些示例包括

  • 变换后张量的维度 > 4。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnTransformFilter()#

此函数在 cuDNN 9.0 中已弃用。

此函数根据描述的变换在不同格式、数据类型或维度之间转换过滤器。 它可用于将具有不受支持的布局格式的过滤器转换为具有受支持的布局格式的过滤器。

cudnnStatus_t cudnnTransformFilter(
    cudnnHandle_t handle,
    const cudnnTensorTransformDescriptor_t transDesc,
    const void *alpha,
    const cudnnFilterDescriptor_t srcDesc,
    const void *srcData,
    const void *beta,
    const cudnnFilterDescriptor_t destDesc,
    void *destData);

此函数将缩放后的数据从输入过滤器 srcDesc 复制到具有不同布局的输出张量 destDesc。 如果 srcDesc 和 destDesc 的过滤器描述符具有不同的维度，则它们必须与 transDesc 中指定的折叠和填充量以及顺序一致。

srcDesc 和 destDesc 张量不得以任何方式重叠（即，张量不能就地变换）。

当执行折叠变换或零填充变换时，缩放因子（alpha、beta）应设置为 (1, 0)。 但是，展开变换支持任何 (alpha、beta) 值。 此函数是线程安全的。

参数

handle

输入。指向先前创建的 cuDNN 上下文的句柄。有关更多信息，请参阅 cudnnHandle_t。

transDesc

输入。 包含请求的过滤器变换详细信息的描述符。 有关更多信息，请参阅 cudnnTensorTransformDescriptor_t。

alpha, beta

输入。 指向主机内存中缩放因子的指针，这些缩放因子用于缩放输入张量 srcDesc 中的数据。 beta 用于缩放目标张量，而 alpha 用于缩放源张量。 有关更多信息，请参阅 缩放参数。

在折叠和零填充情况下，beta 缩放值不适用。 展开支持任何 (alpha、beta)。

srcDesc, destDesc

输入。 指向先前初始化的过滤器描述符的句柄。 srcDesc 和 destDesc 不得重叠。 有关更多信息，请参阅 cudnnTensorDescriptor_t。

srcData, destData

输入。 指向主机内存中分别由 srcDesc 和 destDesc 描述的张量数据的指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_BAD_PARAM

参数未初始化或初始化不正确，或者 srcDesc 和 destDesc 之间的维度数不同。

CUDNN_STATUS_NOT_SUPPORTED

此函数不支持所提供的配置。此外，在折叠和填充路径中，任何非 A=1 和 B=0 的值都将导致 CUDNN_STATUS_NOT_SUPPORTED。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnTransformTensor()#

此函数在 cuDNN 9.0 中已弃用。

此函数将缩放后的数据从一个张量复制到另一个布局不同的张量。这些描述符需要具有相同的维度，但不一定需要具有相同的步幅。输入和输出张量不得以任何方式重叠（意味着张量不能就地转换）。此函数可用于将具有不支持格式的张量转换为受支持的格式。

cudnnStatus_t cudnnTransformTensor(
    cudnnHandle_t                  handle,
    const void                    *alpha,
    const cudnnTensorDescriptor_t  xDesc,
    const void                    *x,
    const void                    *beta,
    const cudnnTensorDescriptor_t  yDesc,
    void                          *y)

参数

handle

输入。 指向先前创建的 cuDNN 上下文的句柄。

alpha, beta

输入。 指向缩放因子（在主机内存中）的指针，用于将源值与目标张量中的先前值混合，如下所示

dstValue = alpha[0]*srcValue + beta[0]*priorDstValue

有关更多信息，请参阅 缩放参数。

xDesc

输入。指向先前初始化的张量描述符的句柄。有关更多信息，请参阅 cudnnTensorDescriptor_t。

x

输入。 指向由 xDesc 描述符描述的张量数据的指针。

yDesc

输入。指向先前初始化的张量描述符的句柄。有关更多信息，请参阅 cudnnTensorDescriptor_t。

y

输出。 指向由 yDesc 描述符描述的张量数据的指针。

返回值

CUDNN_STATUS_SUCCESS

函数成功启动。

CUDNN_STATUS_NOT_SUPPORTED

该函数不支持提供的配置。

CUDNN_STATUS_BAD_PARAM

两个张量描述符的维度 n、c、h、w 或 dataType 不同。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

cudnnTransformTensorEx()#

此函数在 cuDNN 9.0 中已弃用。

此函数在不同格式之间转换张量布局。它可用于将具有不支持布局格式的张量转换为具有支持布局格式的张量。

cudnnStatus_t cudnnTransformTensorEx(
    cudnnHandle_t handle,
    const cudnnTensorTransformDescriptor_t transDesc,
    const void *alpha,
    const cudnnTensorDescriptor_t srcDesc,
    const void *srcData,
    const void *beta,
    const cudnnTensorDescriptor_t destDesc,
    void *destData);

此函数将缩放后的数据从输入张量 srcDesc 复制到具有不同布局的输出张量 destDesc。srcDesc 和 destDesc 的张量描述符应具有相同的维度，但不一定需要具有相同的步幅。

srcDesc 和 destDesc 张量不得以任何方式重叠（即，张量不能就地变换）。

当执行折叠变换或零填充变换时，缩放因子（alpha、beta）应设置为 (1, 0)。 但是，展开变换支持任何 (alpha、beta) 值。 此函数是线程安全的。

参数

handle

输入。指向先前创建的 cuDNN 上下文的句柄。有关更多信息，请参阅 cudnnHandle_t。

transDesc

输入。 包含请求的张量转换详细信息的描述符。 有关更多信息，请参阅 cudnnTensorTransformDescriptor_t。

alpha, beta

输入。 指向主机内存中缩放因子的指针，这些缩放因子用于缩放输入张量 srcDesc 中的数据。 beta 用于缩放目标张量，而 alpha 用于缩放源张量。 有关更多信息，请参阅 缩放参数。

在折叠和零填充情况下，beta 缩放值不适用。 展开支持任何 (alpha、beta)。

srcDesc, destDesc

输入。 指向先前初始化的张量描述符的句柄。srcDesc 和 destDesc 不得重叠。 有关更多信息，请参阅 cudnnTensorDescriptor_t。

srcData, destData

输入。 指向主机内存中由 srcDesc 和 destDesc 描述的张量数据的指针（分别）。

返回值

CUDNN_STATUS_SUCCESS

函数已成功启动。

CUDNN_STATUS_BAD_PARAM

参数未初始化或初始化不正确，或者 srcDesc 和 destDesc 之间的维度数不同。

CUDNN_STATUS_NOT_SUPPORTED

函数不支持所提供的配置。此外，在折叠和填充路径中，任何非 A=1 和 B=0 的值都将导致 CUDNN_STATUS_NOT_SUPPORTED。

CUDNN_STATUS_EXECUTION_FAILED

函数无法在 GPU 上启动。

在本页