⚡

cublas-cudnnSkill cublas-cudnn

cublas-cudnn 是一个专注于 NVIDIA GPU 加速数学库集成的专业技能。它提供专家级能力，用于高效配置和调用 cuBLAS（基础线性代数子程序库）和 cuDNN（深度神经网络库）。核心功能包括：配置 cuBLAS 张量核心操作以最大化计算性能，生成优化的 GEMM（通用矩阵乘法）调用，集成 cuDNN 的卷积、池化、归一化等深度学习层，智能处理算法选择和基准测试，管理 GPU 工作空间内存，并全面支持 FP16、TF32、INT8 等混合精度操作以提升训练和推理速度。该技能是构建高性能 AI 推理、科学计算和自定义 CUDA 算子的关键工具。 关键词：NVIDIA GPU加速，cuBLAS，cuDNN，张量核心，矩阵乘法GEMM，深度学习卷积，混合精度，CUDA编程，高性能计算，AI推理优化

深度学习 3 次安装 38 次浏览 更新于 2/25/2026

name: cublas-cudnn description: 与NVIDIA GPU加速数学库的专家级集成。配置cuBLAS张量核心操作，生成cuBLAS GEMM调用，集成cuDNN层，处理算法选择，并支持混合精度操作。 allowed-tools: Bash(*) 读取 写入 编辑 全局搜索 Grep 网络获取 metadata: author: babysitter-sdk version: “1.0.0” category: gpu-libraries backlog-id: SK-006

cublas-cudnn

你是 cublas-cudnn - 一个用于NVIDIA GPU加速数学库集成的专业技能。此技能提供使用cuBLAS、cuDNN及相关库的专家级能力。

概述

此技能支持AI驱动的GPU库操作，包括：

  • 配置cuBLAS张量核心操作
  • 使用最优参数生成cuBLAS GEMM调用
  • 集成cuDNN卷积和归一化层
  • 处理cuBLAS/cuDNN算法选择
  • 配置工作空间内存需求
  • 基准测试库操作与自定义内核
  • 支持混合精度操作（FP16， TF32， INT8）
  • 集成cuSPARSE进行稀疏操作

先决条件

  • CUDA Toolkit 11.0+
  • cuBLAS库
  • cuDNN 8.0+
  • cuSPARSE（可选）

能力

1. cuBLAS GEMM操作

使用cuBLAS进行矩阵乘法：

#include <cublas_v2.h>

// 初始化cuBLAS
cublasHandle_t handle;
cublasCreate(&handle);

// 标准SGEMM： C = alpha * A * B + beta * C
float alpha = 1.0f, beta = 0.0f;
cublasSgemm(handle,
    CUBLAS_OP_N, CUBLAS_OP_N,  // 不转置
    M, N, K,                    // 维度
    &alpha,
    d_A, M,                     // A矩阵和前导维度
    d_B, K,                     // B矩阵和前导维度
    &beta,
    d_C, M);                    // C矩阵和前导维度

// 批量GEMM用于多个矩阵
cublasSgemmBatched(handle,
    CUBLAS_OP_N, CUBLAS_OP_N,
    M, N, K,
    &alpha,
    d_Aarray, M,
    d_Barray, K,
    &beta,
    d_Carray, M,
    batchCount);

// 跨步批量GEMM（连续内存）
cublasSgemmStridedBatched(handle,
    CUBLAS_OP_N, CUBLAS_OP_N,
    M, N, K,
    &alpha,
    d_A, M, strideA,
    d_B, K, strideB,
    &beta,
    d_C, M, strideC,
    batchCount);

2. 张量核心操作

启用张量核心以获得最大性能：

// 启用张量核心（需要Volta+）
cublasSetMathMode(handle, CUBLAS_TENSOR_OP_MATH);

// 对于Ampere+，使用TF32
cublasSetMathMode(handle, CUBLAS_TF32_TENSOR_OP_MATH);

// 使用张量核心的半精度GEMM
cublasGemmEx(handle,
    CUBLAS_OP_N, CUBLAS_OP_N,
    M, N, K,
    &alpha,
    d_A, CUDA_R_16F, M,      // FP16输入
    d_B, CUDA_R_16F, K,      // FP16输入
    &beta,
    d_C, CUDA_R_16F, M,      // FP16输出
    CUDA_R_16F,              // 计算类型
    CUBLAS_GEMM_DEFAULT_TENSOR_OP);

// 混合精度：FP16输入，FP32累加
cublasGemmEx(handle,
    CUBLAS_OP_N, CUBLAS_OP_N,
    M, N, K,
    &alpha,
    d_A, CUDA_R_16F, M,
    d_B, CUDA_R_16F, K,
    &beta,
    d_C, CUDA_R_32F, M,      // FP32输出
    CUDA_R_32F,              // FP32计算
    CUBLAS_GEMM_DEFAULT_TENSOR_OP);

3. cuDNN卷积

深度学习卷积：

#include <cudnn.h>

cudnnHandle_t cudnn;
cudnnCreate(&cudnn);

// 创建张量描述符
cudnnTensorDescriptor_t inputDesc, outputDesc;
cudnnCreateTensorDescriptor(&inputDesc);
cudnnCreateTensorDescriptor(&outputDesc);

cudnnSetTensor4dDescriptor(inputDesc, CUDNN_TENSOR_NCHW,
    CUDNN_DATA_FLOAT, N, C, H, W);

// 创建滤波器描述符
cudnnFilterDescriptor_t filterDesc;
cudnnCreateFilterDescriptor(&filterDesc);
cudnnSetFilter4dDescriptor(filterDesc, CUDNN_DATA_FLOAT,
    CUDNN_TENSOR_NCHW, K, C, R, S);

// 创建卷积描述符
cudnnConvolutionDescriptor_t convDesc;
cudnnCreateConvolutionDescriptor(&convDesc);
cudnnSetConvolution2dDescriptor(convDesc,
    pad_h, pad_w,      // 填充
    stride_h, stride_w, // 步幅
    1, 1,               // 扩张
    CUDNN_CROSS_CORRELATION,
    CUDNN_DATA_FLOAT);

// 启用张量核心
cudnnSetConvolutionMathType(convDesc, CUDNN_TENSOR_OP_MATH);

// 寻找最佳算法
cudnnConvolutionFwdAlgoPerf_t perfResults[8];
int returnedAlgoCount;
cudnnFindConvolutionForwardAlgorithm(cudnn,
    inputDesc, filterDesc, convDesc, outputDesc,
    8, &returnedAlgoCount, perfResults);

cudnnConvolutionFwdAlgo_t algo = perfResults[0].algo;

// 获取工作空间大小
size_t workspaceSize;
cudnnGetConvolutionForwardWorkspaceSize(cudnn,
    inputDesc, filterDesc, convDesc, outputDesc,
    algo, &workspaceSize);

void* workspace;
cudaMalloc(&workspace, workspaceSize);

// 执行卷积
float alpha = 1.0f, beta = 0.0f;
cudnnConvolutionForward(cudnn,
    &alpha,
    inputDesc, d_input,
    filterDesc, d_filter,
    convDesc, algo, workspace, workspaceSize,
    &beta,
    outputDesc, d_output);

4. cuDNN批量归一化

cudnnTensorDescriptor_t bnScaleBiasMeanVarDesc;
cudnnCreateTensorDescriptor(&bnScaleBiasMeanVarDesc);
cudnnDeriveBNTensorDescriptor(bnScaleBiasMeanVarDesc, inputDesc,
    CUDNN_BATCHNORM_SPATIAL);

// 前向训练
cudnnBatchNormalizationForwardTraining(cudnn,
    CUDNN_BATCHNORM_SPATIAL,
    &alpha, &beta,
    inputDesc, d_input,
    outputDesc, d_output,
    bnScaleBiasMeanVarDesc,
    d_scale, d_bias,
    0.1,  // 指数平均因子
    d_runningMean, d_runningVariance,
    1e-5, // Epsilon
    d_savedMean, d_savedInvVariance);

// 前向推理
cudnnBatchNormalizationForwardInference(cudnn,
    CUDNN_BATCHNORM_SPATIAL,
    &alpha, &beta,
    inputDesc, d_input,
    outputDesc, d_output,
    bnScaleBiasMeanVarDesc,
    d_scale, d_bias,
    d_runningMean, d_runningVariance,
    1e-5);

5. 算法选择与基准测试

// 基准测试所有算法
cudnnConvolutionFwdAlgoPerf_t perfResults[CUDNN_CONVOLUTION_FWD_ALGO_COUNT];
int returnedCount;

cudnnFindConvolutionForwardAlgorithmEx(cudnn,
    inputDesc, d_input,
    filterDesc, d_filter,
    convDesc,
    outputDesc, d_output,
    CUDNN_CONVOLUTION_FWD_ALGO_COUNT,
    &returnedCount,
    perfResults,
    workspace, workspaceSize);

// 打印基准测试结果
for (int i = 0; i < returnedCount; i++) {
    printf("算法 %d: %.3f 毫秒, 工作空间: %zu 字节
",
        perfResults[i].algo,
        perfResults[i].time,
        perfResults[i].memory);
}

// 通过启发式选择算法
cudnnConvolutionFwdAlgo_t algo;
cudnnGetConvolutionForwardAlgorithm_v7(cudnn,
    inputDesc, filterDesc, convDesc, outputDesc,
    8, &returnedCount, perfResults);

6. 工作空间内存管理

// 查询所有操作的工作空间
size_t convWorkspace, bnWorkspace, poolWorkspace;

cudnnGetConvolutionForwardWorkspaceSize(cudnn, ...);
cudnnGetBatchNormalizationForwardTrainingExWorkspaceSize(cudnn, ...);

// 分配最大所需空间
size_t maxWorkspace = max(convWorkspace, max(bnWorkspace, poolWorkspace));
void* workspace;
cudaMalloc(&workspace, maxWorkspace);

// 跨操作重用工作空间

7. 混合精度支持

// FP16卷积
cudnnSetTensor4dDescriptor(inputDesc, CUDNN_TENSOR_NHWC,
    CUDNN_DATA_HALF, N, C, H, W);
cudnnSetFilter4dDescriptor(filterDesc, CUDNN_DATA_HALF,
    CUDNN_TENSOR_NHWC, K, C, R, S);

// 用于推理的INT8卷积
cudnnSetTensor4dDescriptor(inputDesc, CUDNN_TENSOR_NHWC,
    CUDNN_DATA_INT8, N, C, H, W);
cudnnSetConvolution2dDescriptor(convDesc,
    pad_h, pad_w, stride_h, stride_w, 1, 1,
    CUDNN_CROSS_CORRELATION,
    CUDNN_DATA_INT32);  // INT32累加

8. cuSPARSE集成

#include <cusparse.h>

cusparseHandle_t sparse;
cusparseCreate(&sparse);

// 以CSR格式创建稀疏矩阵
cusparseSpMatDescr_t matA;
cusparseCreateCsr(&matA, M, N, nnz,
    d_rowPtr, d_colIdx, d_values,
    CUSPARSE_INDEX_32I, CUSPARSE_INDEX_32I,
    CUSPARSE_INDEX_BASE_ZERO, CUDA_R_32F);

// 创建稠密向量
cusparseDnVecDescr_t vecX, vecY;
cusparseCreateDnVec(&vecX, N, d_x, CUDA_R_32F);
cusparseCreateDnVec(&vecY, M, d_y, CUDA_R_32F);

// SpMV： y = alpha * A * x + beta * y
size_t bufferSize;
cusparseSpMV_bufferSize(sparse, CUSPARSE_OPERATION_NON_TRANSPOSE,
    &alpha, matA, vecX, &beta, vecY, CUDA_R_32F,
    CUSPARSE_SPMV_ALG_DEFAULT, &bufferSize);

void* buffer;
cudaMalloc(&buffer, bufferSize);

cusparseSpMV(sparse, CUSPARSE_OPERATION_NON_TRANSPOSE,
    &alpha, matA, vecX, &beta, vecY, CUDA_R_32F,
    CUSPARSE_SPMV_ALG_DEFAULT, buffer);

流程集成

此技能与以下流程集成：

  • tensor-core-programming.js - 张量核心工作流
  • ml-inference-optimization.js - ML推理优化
  • custom-cuda-operator-development.js - 自定义算子开发

输出格式

{
  "operation": "gemm-benchmark",
  "library": "cuBLAS",
  "configuration": {
    "M": 4096, "N": 4096, "K": 4096,
    "datatype": "FP16",
    "math_mode": "TENSOR_OP_MATH"
  },
  "performance": {
    "time_ms": 0.85,
    "tflops": 16.2,
    "efficiency_pct": 81.0
  },
  "recommendations": [
    "使用 CUBLAS_GEMM_DEFAULT_TENSOR_OP 以获得张量核心路径",
    "确保维度是8的倍数以获得最佳张量核心使用"
  ]
}

依赖项

  • CUDA Toolkit 11.0+
  • cuBLAS
  • cuDNN 8.0+
  • cuSPARSE（可选）

约束

  • 张量核心需要特定的数据类型和对齐方式
  • 算法选择应按配置进行缓存
  • 工作空间内存必须在执行前分配
  • 混合精度可能需要损失缩放