企业官网建设流程全解析

【Bug已解决】UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR 解决方案

问题描述

在 PyTorch 中使用 GPU 进行深度学习训练时，尤其是在使用较新版本的 PyTorch（如 1.10+）搭配 NVIDIA cuDNN 库时，开发者经常会遇到如下警告信息：

UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR: cudnnStatus = CUDNN_STATUS_NOT_SUPPORTED

这个警告通常出现在执行卷积操作（nn.Conv2d）或某些依赖 cuDNN 优化的操作时。虽然它只是一个UserWarning，不会直接导致程序崩溃，但它意味着 cuDNN 无法为当前的卷积配置找到最优的执行计划（execution plan），从而可能回退到性能较低的默认实现，严重影响训练速度。在某些极端情况下，它还可能伴随着显存泄漏或训练过程中的随机崩溃。

该问题在以下场景中尤为常见：

• 使用 Ampere 架构 GPU（如 RTX 3090、A100）搭配较旧的 cuDNN 版本
• 使用混合精度训练（AMP /torch.cuda.amp）
• 使用特殊的卷积参数组合（如groups > 1、膨胀卷积、大尺寸卷积核）
• PyTorch 与 CUDA / cuDNN 版本不匹配

错误复现

环境信息

• GPU: NVIDIA RTX 3090 (Ampere, SM_86)
• CUDA: 11.3
• cuDNN: 8.2.0
• PyTorch: 1.11.0

复现代码

import torch import torch.nn as nn import warnings # 启用所有警告输出 warnings.filterwarnings("always") # 定义一个使用分组卷积和膨胀卷积的网络 class WeirdConvNet(nn.Module): def __init__(self): super().__init__() # groups=4 且 dilation=3 的卷积组合容易触发 cuDNN 执行计划失败 self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=6, dilation=3, groups=4, bias=False) self.bn1 = nn.BatchNorm2d(64) self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=2, dilation=2, groups=8, bias=False) self.bn2 = nn.BatchNorm2d(128) self.relu = nn.ReLU(inplace=True) self.pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(128, 10) def forward(self, x): x = self.relu(self.bn1(self.conv1(x))) x = self.relu(self.bn2(self.conv2(x))) x = self.pool(x) x = torch.flatten(x, 1) x = self.fc(x) return x device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = WeirdConvNet().to(device) # 使用混合精度训练 scaler = torch.cuda.amp.GradScaler() optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) criterion = nn.CrossEntropyLoss() # 模拟训练循环 for epoch in range(3): for i in range(10): # 生成随机输入和标签 inputs = torch.randn(32, 3, 224, 224, device=device) labels = torch.randint(0, 10, (32,), device=device) optimizer.zero_grad() # 混合精度前向传播 with torch.cuda.amp.autocast(): outputs = model(inputs) loss = criterion(outputs, labels) # 反向传播 scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() if i == 0: print(f"Epoch {epoch}, Step {i}, Loss: {loss.item():.4f}") print("训练完成")

运行上述代码后，控制台会输出大量类似如下的警告：

UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR: cudnnStatus = CUDNN_STATUS_NOT_SUPPORTED (cudnnStatus = CUDNN_STATUS_NOT_SUPPORTED)

根因分析

1. cuDNN 执行计划机制

cuDNN 是 NVIDIA 提供的深度神经网络加速库，它为卷积等操作提供了多种算法实现（如 Winograd、FFT、隐式 GEMM 等）。当 PyTorch 调用 cuDNN 执行卷积时，cuDNN 会尝试为当前的卷积配置（输入尺寸、卷积核大小、stride、padding、dilation、groups、数据类型等）寻找一个最优的执行计划。

这个寻找过程称为 "execution plan discovery"。cuDNN 会枚举多种可能的算法，并为每种算法构建一个CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR。如果所有候选算法都无法满足当前配置（例如某些算法不支持groups > 1或不支持半精度浮点），cuDNN 就会返回CUDNN_STATUS_NOT_SUPPORTED，PyTorch 捕获后以UserWarning的形式输出。

2. 版本不匹配

最常见的原因是 PyTorch 编译时链接的 cuDNN 版本与系统实际安装的 cuDNN 版本不匹配。例如：

• PyTorch 1.11 期望 cuDNN 8.3.2+，但系统安装的是 cuDNN 8.2.0
• cuDNN 8.2 对 Ampere 架构（SM_86）的某些卷积配置支持不完善

3. 混合精度训练的触发

使用torch.cuda.amp.autocast()时，卷积操作的输入会被自动转换为float16（半精度）。某些 cuDNN 版本对半精度下的分组卷积或膨胀卷积支持有限，更容易触发执行计划失败。

4. benchmark 模式的副作用

当torch.backends.cudnn.benchmark = True时，PyTorch 会在第一次遇到新的卷积配置时尝试所有 cuDNN 算法并选择最快的。如果所有算法都失败，就会产生大量警告。

5. 确定性模式冲突

当torch.backends.cudnn.deterministic = True时，cuDNN 只能使用确定性算法，这大大缩小了可用算法的范围，更容易导致CUDNN_STATUS_NOT_SUPPORTED。

解决方案

方案一：升级 cuDNN 和 PyTorch 到匹配版本

这是最根本的解决方案。确保 PyTorch、CUDA 和 cuDNN 三者版本兼容。

# 首先检查当前版本 import torch print(f"PyTorch version: {torch.__version__}") print(f"CUDA version: {torch.version.cuda}") print(f"cuDNN version: {torch.backends.cudnn.version()}") print(f"cuDNN enabled: {torch.backends.cudnn.enabled}") print(f"cuDNN benchmark: {torch.backends.cudnn.benchmark}") print(f"cuDNN deterministic: {torch.backends.cudnn.deterministic}")

推荐的版本组合（截至 2024 年）：

安装命令示例：

# 使用 conda 安装（推荐，自动处理 cuDNN 依赖） conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia # 使用 pip 安装 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

方案二：调整 cuDNN 配置标志

如果暂时无法升级版本，可以通过调整 cuDNN 的配置标志来规避问题。

import torch import torch.nn as nn # 方案 2a: 关闭 benchmark 模式 # benchmark=True 会在遇到新配置时尝试所有算法，失败的算法会产生警告 # 关闭后 cuDNN 使用默认算法，虽然可能不是最优，但避免了警告 torch.backends.cudnn.benchmark = False # 方案 2b: 关闭 cuDNN 完全（不推荐，仅用于调试） # 这会让 PyTorch 使用原生 CUDA 实现，性能会下降 # torch.backends.cudnn.enabled = False # 方案 2c: 关闭确定性模式 # 如果之前设置了 deterministic=True，关闭它可以恢复更多可用算法 torch.backends.cudnn.deterministic = False torch.use_deterministic_algorithms(False)

方案三：过滤警告输出

如果确认该警告不影响实际训练（cuDNN 会自动回退到可用算法），可以过滤掉这个特定的警告，避免日志被污染。

import warnings import torch # 方法 1: 使用 warnings 模块过滤特定警告 warnings.filterwarnings( "ignore", message="Plan failed with a cudnnException", category=UserWarning, module="torch" ) # 方法 2: 使用 logging 级别控制（PyTorch 1.12+） # 将 cuDNN 相关的日志级别提高到 ERROR import logging logging.getLogger("torch").setLevel(logging.ERROR) # 方法 3: 上下文管理器临时过滤（推荐，不影响全局） class SuppressCudnnWarning: """临时抑制 cuDNN 执行计划警告的上下文管理器""" def __enter__(self): self._filters = warnings.filters warnings.filterwarnings( "ignore", message="Plan failed with a cudnnException", category=UserWarning ) return self def __exit__(self, *args): warnings.filters = self._filters # 使用示例 with SuppressCudnnWarning(): outputs = model(inputs) # 此处的 cuDNN 警告被抑制

方案四：修改网络结构避免触发

某些特定的卷积参数组合更容易触发该问题。可以通过等价变换来规避。

import torch import torch.nn as nn class OptimizedConvNet(nn.Module): """优化后的网络，避免触发 cuDNN 执行计划失败""" def __init__(self): super().__init__() # 原始: groups=4, dilation=3, kernel_size=7 # 优化: 将分组卷积拆分为标准卷积 + 通道重排 # 或者使用更常见的参数组合 # 方案 A: 减小 groups 或移除 dilation self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) # 移除 groups 和 dilation self.bn1 = nn.BatchNorm2d(64) # 方案 B: 用两个连续的卷积替代大 dilation 卷积 # dilation=2, kernel=3 等效感受野可以用两个 dilation=1, kernel=3 替代 self.conv2a = nn.Conv2d(64, 64, kernel_size=3, padding=1, groups=8, bias=False) self.conv2b = nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(128) self.relu = nn.ReLU(inplace=True) self.pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(128, 10) def forward(self, x): x = self.relu(self.bn1(self.conv1(x))) x = self.relu(self.bn2(self.conv2b(self.conv2a(x)))) x = self.pool(x) x = torch.flatten(x, 1) x = self.fc(x) return x

方案五：使用torch.backends.cudnn.allow_tf32

在 Ampere GPU 上，启用 TF32 可以提高性能，同时也可能改变 cuDNN 的算法选择路径。

import torch # 启用 TF32（仅 Ampere 及以上架构有效） torch.backends.cudnn.allow_tf32 = True torch.backends.cuda.matmul.allow_tf32 = True # TF32 使用 19 位尾数（介于 FP32 和 FP16 之间） # 在保持 FP32 数据类型的同时获得接近 FP16 的性能 # 这可以避免某些半精度下的 cuDNN 兼容性问题

完整修复代码

下面是一个完整的、生产可用的修复方案，集成了版本检查、配置优化和警告过滤：

""" 完整的 cuDNN 执行计划警告修复方案 适用于 PyTorch 1.10+ 和 CUDA 11.x 环境 """ import warnings import logging import torch import torch.nn as nn from typing import Optional class CudnnConfigManager: """ cuDNN 配置管理器 统一管理 cuDNN 相关的配置，避免执行计划失败警告 """ # 已知的兼容版本组合 COMPATIBLE_VERSIONS = { "1.10": {"cuda": "11.3", "cudnn_min": 8200}, # cuDNN 8.2.0 "1.11": {"cuda": "11.3", "cudnn_min": 8200}, "1.12": {"cuda": "11.6", "cudnn_min": 8300}, # cuDNN 8.3 "1.13": {"cuda": "11.7", "cudnn_min": 8400}, # cuDNN 8.4 "2.0": {"cuda": "11.8", "cudnn_min": 8600}, # cuDNN 8.6 "2.1": {"cuda": "11.8", "cudnn_min": 8700}, "2.2": {"cuda": "12.1", "cudnn_min": 8800}, } def __init__(self): self._original_benchmark = None self._original_deterministic = None self._original_filters = None def check_version_compatibility(self) -> dict: """ 检查当前 PyTorch / CUDA / cuDNN 版本兼容性 返回包含详细信息的字典 """ pt_version = torch.__version__.split('+')[0] # 去掉 +cu118 后缀 cuda_version = torch.version.cuda or "unknown" cudnn_version = torch.backends.cudnn.version() info = { "pytorch": pt_version, "cuda": cuda_version, "cudnn": cudnn_version, "gpu": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "N/A", "compute_capability": torch.cuda.get_device_capability(0) if torch.cuda.is_available() else None, "compatible": True, "warnings": [] } # 检查 cuDNN 最低版本 major_version = pt_version.rsplit('.', 1)[0] # 如 "2.0" if major_version in self.COMPATIBLE_VERSIONS: expected = self.COMPATIBLE_VERSIONS[major_version] if cudnn_version < expected["cudnn_min"]: info["compatible"] = False info["warnings"].append( f"cuDNN version {cudnn_version} is lower than " f"recommended {expected['cudnn_min']} for PyTorch {pt_version}" ) # 检查 Ampere GPU + 旧 cuDNN if info["compute_capability"] and info["compute_capability"][0] >= 8: if cudnn_version < 8400: info["warnings"].append( "Ampere or newer GPU detected with cuDNN < 8.4, " "execution plan failures are likely" ) return info def apply_optimal_config( self, benchmark: bool = True, deterministic: bool = False, allow_tf32: bool = True, suppress_warning: bool = True ): """ 应用最优的 cuDNN 配置 参数: benchmark: 是否启用 cuDNN benchmark 模式 deterministic: 是否启用确定性模式 allow_tf32: 是否允许 TF32 计算 suppress_warning: 是否抑制执行计划失败警告 """ # 保存原始配置 self._original_benchmark = torch.backends.cudnn.benchmark self._original_deterministic = torch.backends.cudnn.deterministic # 应用新配置 torch.backends.cudnn.benchmark = benchmark torch.backends.cudnn.deterministic = deterministic torch.backends.cudnn.enabled = True # TF32 配置（Ampere+ GPU） if allow_tf32: torch.backends.cudnn.allow_tf32 = True torch.backends.cuda.matmul.allow_tf32 = True # 抑制 cuDNN 执行计划警告 if suppress_warning: self._original_filters = warnings.filters[:] warnings.filterwarnings( "ignore", message="Plan failed with a cudnnException", category=UserWarning ) # 同时降低 torch 内部日志级别 logging.getLogger("torch").setLevel(logging.ERROR) print(f"[CudnnConfigManager] Configuration applied:") print(f" benchmark={benchmark}, deterministic={deterministic}") print(f" allow_tf32={allow_tf32}, suppress_warning={suppress_warning}") def restore_config(self): """恢复原始 cuDNN 配置""" if self._original_benchmark is not None: torch.backends.cudnn.benchmark = self._original_benchmark if self._original_deterministic is not None: torch.backends.cudnn.deterministic = self._original_deterministic if self._original_filters is not None: warnings.filters = self._original_filters print("[CudnnConfigManager] Original configuration restored.") # ============ 使用示例 ============ def main(): """完整的训练示例，集成了 cuDNN 配置管理""" # Step 1: 初始化配置管理器 config_mgr = CudnnConfigManager() # Step 2: 检查版本兼容性 info = config_mgr.check_version_compatibility() print("=" * 60) print("Environment Information:") for key, value in info.items(): if key != "warnings": print(f" {key}: {value}") if info["warnings"]: print("\nWarnings:") for w in info["warnings"]: print(f" - {w}") print("=" * 60) # Step 3: 应用最优配置 config_mgr.apply_optimal_config( benchmark=True, # 启用 benchmark 以获得最佳性能 deterministic=False, # 关闭确定性模式以获得更多可用算法 allow_tf32=True, # 启用 TF32 suppress_warning=True # 抑制执行计划失败警告 ) # Step 4: 定义模型 class ResidualBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, 3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.downsample = None if stride != 1 or in_channels != out_channels: self.downsample = nn.Sequential( nn.Conv2d(in_channels, out_channels, 1, stride=stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): identity = x out = self.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) if self.downsample: identity = self.downsample(x) out += identity out = self.relu(out) return out class SimpleResNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.stem = nn.Sequential( nn.Conv2d(3, 32, 3, stride=1, padding=1, bias=False), nn.BatchNorm2d(32), nn.ReLU(inplace=True) ) self.layer1 = nn.Sequential( ResidualBlock(32, 64, stride=2), ResidualBlock(64, 64, stride=1) ) self.layer2 = nn.Sequential( ResidualBlock(64, 128, stride=2), ResidualBlock(128, 128, stride=1) ) self.pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(128, num_classes) def forward(self, x): x = self.stem(x) x = self.layer1(x) x = self.layer2(x) x = self.pool(x) x = torch.flatten(x, 1) x = self.fc(x) return x # Step 5: 准备训练 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SimpleResNet(num_classes=10).to(device) # 混合精度训练 scaler = torch.cuda.amp.GradScaler() optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50) criterion = nn.CrossEntropyLoss() # Step 6: 训练循环 num_epochs = 5 for epoch in range(num_epochs): model.train() total_loss = 0.0 correct = 0 total = 0 # 模拟数据加载 for batch_idx in range(50): inputs = torch.randn(64, 3, 32, 32, device=device) labels = torch.randint(0, 10, (64,), device=device) optimizer.zero_grad() with torch.cuda.amp.autocast(): outputs = model(inputs) loss = criterion(outputs, labels) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() total_loss += loss.item() _, predicted = outputs.max(1) correct += predicted.eq(labels).sum().item() total += labels.size(0) scheduler.step() avg_loss = total_loss / 50 acc = 100.0 * correct / total print(f"Epoch [{epoch+1}/{num_epochs}] Loss: {avg_loss:.4f}, " f"Acc: {acc:.2f}%, LR: {scheduler.get_last_lr()[0]:.6f}") # Step 7: 恢复配置 config_mgr.restore_config() print("\n训练完成，无 cuDNN 执行计划警告！") if __name__ == "__main__": main()

常见陷阱与注意事项

1. 不要盲目关闭 cuDNN

有些开发者遇到此问题后直接设置torch.backends.cudnn.enabled = False，这会让所有卷积操作回退到 PyTorch 的原生 CUDA 实现，性能可能下降 3-10 倍。正确的做法是保持 cuDNN 启用，仅调整 benchmark 和 deterministic 标志。

2. benchmark 模式的首次开销

当cudnn.benchmark = True时，第一次遇到新的卷积配置会花费额外时间测试所有算法。如果输入尺寸在训练过程中频繁变化（如可变长度序列），这会导致显著的性能下降。在这种情况下，建议关闭 benchmark。

# 如果输入尺寸固定，启用 benchmark torch.backends.cudnn.benchmark = True # 如果输入尺寸变化，关闭 benchmark torch.backends.cudnn.benchmark = False

3. 确定性模式与可复现性的权衡

设置deterministic = True可以保证结果可复现，但会限制 cuDNN 可用的算法集合，更容易触发执行计划失败。如果不需要严格可复现性，建议关闭。

# 可复现但可能触发警告 torch.backends.cudnn.deterministic = True torch.use_deterministic_algorithms(True) # 不可复现但性能更好，不易触发警告 torch.backends.cudnn.deterministic = False

4. 混合精度训练的特殊考虑

使用 AMP 时，某些旧版 cuDNN 对float16下的分组卷积支持不完善。可以考虑以下策略：

# 策略 1: 对特定层禁用 autocast with torch.cuda.amp.autocast(enabled=False): # 强制使用 float32 执行此层 x = self.conv(x.float()).half() # 策略 2: 使用 BFloat16 代替 Float16 # BFloat16 对 cuDNN 的兼容性更好 with torch.cuda.amp.autocast(dtype=torch.bfloat16): outputs = model(inputs)

5. 多 GPU 训练的额外问题

在DataParallel或DistributedDataParallel场景下，不同 GPU 可能选择不同的 cuDNN 算法，导致结果不一致。建议在多 GPU 训练中统一关闭 benchmark 或统一开启 deterministic。

6. cuDNN 版本号解读

cuDNN 版本号是一个整数，格式为MAJOR * 1000 + MINOR * 100 + PATCHLEVEL：

• 8200 = cuDNN 8.2.0
• 8401 = cuDNN 8.4.1
• 8600 = cuDNN 8.6.0

cudnn_ver = torch.backends.cudnn.version() major = cudnn_ver // 1000 minor = (cudnn_ver // 100) % 10 patch = cudnn_ver % 100 print(f"cuDNN {major}.{minor}.{patch}")

7. 容器环境中的 cuDNN 问题

在 Docker 容器中，cuDNN 版本由基础镜像决定。如果使用nvidia/cuda:11.3.0-cudnn8-runtime-ubuntu20.04，cuDNN 版本固定为 8.2。建议使用 PyTorch 官方镜像pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime，它们已经过充分测试。

8. 从源码编译 PyTorch 时的注意事项

如果从源码编译 PyTorch，确保 cuDNN 的头文件和库文件路径正确：

export CUDNN_LIB_DIR=/usr/local/cuda/lib64 export CUDNN_INCLUDE_DIR=/usr/local/cuda/include export USE_CUDNN=1 python setup.py install

总结

UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR是一个与 cuDNN 版本兼容性和卷积配置相关的警告。核心原因是 cuDNN 无法为当前的卷积配置找到合适的执行计划。

解决此问题的关键步骤如下：

1. 检查版本兼容性：确保 PyTorch、CUDA 和 cuDNN 三者版本匹配，特别是 Ampere 架构 GPU 需要 cuDNN 8.4+。
2. 调整 cuDNN 配置：合理设置benchmark和deterministic标志，根据输入尺寸是否固定来决定是否启用 benchmark。
3. 启用 TF32：在 Ampere+ GPU 上启用 TF32 可以获得更好的性能和兼容性。
4. 过滤无害警告：如果确认警告不影响训练结果，可以使用warnings.filterwarnings过滤。
5. 优化网络结构：避免使用容易触发问题的卷积参数组合（如大 dilation + groups + 半精度）。
6. 考虑混合精度策略：在 AMP 场景下，可以尝试 BFloat16 或对特定层禁用 autocast。

通过以上方案的综合应用，可以彻底消除该警告并确保训练过程的高效和稳定。在实际项目中，建议优先采用方案一（升级版本），这是最根本的解决方式；在无法升级的情况下，方案二和方案三的组合使用也能有效解决问题。