【Bug已解决】How to check if a tensor is on cuda or send it to cuda in Pytorch? 解决方案问题描述在 PyTorch 中进行 GPU 加速时开发者经常需要检查一个 tensor 是否已经在 GPUCUDA上以及如何将 tensor 从 CPU 移动到 GPU。这看似简单的操作实际上涉及许多细节处理不当会导致RuntimeError: Expected all tensors to be on the same device等常见错误。典型的问题场景包括模型在 GPU 上但输入数据在 CPU 上导致前向传播报错多个 tensor 在不同设备上进行运算触发设备不一致错误使用.cuda()和.to(device)混用导致代码可移植性差在多 GPU 环境下指定错误的 GPU 设备检查 tensor 设备的方法不正确导致条件判断失效在没有 GPU 的机器上运行 GPU 代码导致崩溃这些问题的核心在于理解 PyTorch 的设备管理机制以及 tensor 在不同设备间的数据传输方式。错误复现场景一设备不一致错误import torch import torch.nn as nn # 模型在 GPU 上 model nn.Linear(10, 2).cuda() # 输入数据在 CPU 上 input_data torch.randn(5, 10) # 默认在 CPU 上 # 前向传播报错 output model(input_data) # RuntimeError: Expected all tensors to be on the same device, # but found at least two devices, cuda:0 and cpu!场景二运算中设备混合# tensor A 在 GPU 上 a torch.randn(3, 3).cuda() # tensor B 在 CPU 上 b torch.randn(3, 3) # 运算报错 c a b # RuntimeError: Expected all tensors to be on the same device场景三检查设备方法错误tensor torch.randn(3, 3).cuda() # 错误的检查方式 if tensor.is_cuda: # 这实际上是正确的但很多人不知道 print(on GPU) # 更常见的错误用 比较设备 if tensor.device cuda: # 错误device 是对象不是字符串 print(on GPU) # TypeError: str object cannot be interpreted as an integer # 或者比较结果不正确场景四无 GPU 环境崩溃# 在没有 GPU 的机器上运行 model nn.Linear(10, 2).cuda() # RuntimeError: CUDA is not available # 或者AssertionError: Torch not compiled with CUDA enabled场景五多 GPU 设备指定错误# 机器有 4 张 GPUcuda:0, cuda:1, cuda:2, cuda:3 # 想在第二张 GPU 上运行 tensor torch.randn(3, 3).cuda(1) # 正确 # 但模型在 cuda:0 上 model nn.Linear(10, 2).cuda() # 默认 cuda:0 # 运算报错 output model(tensor) # RuntimeError: Expected all tensors to be on the same device, # but found at least two devices, cuda:1 and cuda:0根因分析1. PyTorch 的设备模型PyTorch 中的每个 tensor 都有一个device属性标识它存储在哪个设备上。设备可以是cpuCPU 内存cuda:0第一个 GPUcuda:1第二个 GPUcuda:N第 N1 个 GPU不同设备上的 tensor 不能直接运算必须先移动到同一设备。2..cuda()vs.to(device)的区别.cuda()硬编码使用 GPU在没有 GPU 的环境会报错.to(device)可以接受任意设备配合条件判断实现可移植代码3. 设备比较的正确方式tensor.device返回一个torch.device对象不是字符串。正确的比较方式# 正确方式 tensor.device.type cuda # 检查是否在 GPU 上 tensor.device torch.device(cuda:0) # 比较具体设备 tensor.is_cuda # 布尔值检查4. 数据传输的开销CPU 和 GPU 之间的数据传输是通过 PCIe 总线进行的速度较慢。频繁的设备间传输会成为性能瓶颈。解决方案方案一使用to(device)实现可移植代码推荐import torch import torch.nn as nn # 统一的设备选择 device torch.device(cuda if torch.cuda.is_available() else cpu) # 模型和数据都移到同一设备 model nn.Linear(10, 2).to(device) input_data torch.randn(5, 10).to(device) # 前向传播正常 output model(input_data)方案二检查 tensor 设备的多种方法import torch tensor torch.randn(3, 3).cuda() # 方法1使用 is_cuda 属性最简洁 if tensor.is_cuda: print(Tensor is on GPU) # 方法2检查 device.type if tensor.device.type cuda: print(fTensor is on GPU: {tensor.device}) # 方法3比较 device 对象 if tensor.device torch.device(cuda:0): print(Tensor is on cuda:0) # 方法4检查具体 GPU 编号 if tensor.device.type cuda: gpu_id tensor.device.index print(fTensor is on GPU {gpu_id}) # 方法5使用 try-except try: tensor_gpu tensor.cuda() print(Successfully moved to GPU) except RuntimeError: print(CUDA not available)方案三封装设备管理工具import torch import torch.nn as nn from typing import Union, List, Dict, Any class DeviceManager: 设备管理工具类 def __init__(self, deviceNone): if device is None: self.device torch.device(cuda if torch.cuda.is_available() else cpu) elif isinstance(device, str): self.device torch.device(device) else: self.device device if self.device.type cuda: print(f使用 GPU: {torch.cuda.get_device_name(self.device)}) else: print(使用 CPU) def to_device(self, data: Any) - Any: 将各种类型的数据移到目标设备 if isinstance(data, torch.Tensor): return data.to(self.device) elif isinstance(data, nn.Module): return data.to(self.device) elif isinstance(data, (list, tuple)): return type(data)(self.to_device(item) for item in data) elif isinstance(data, dict): return {k: self.to_device(v) for k, v in data.items()} else: return data def check_device(self, *tensors) - bool: 检查多个 tensor 是否在同一设备 if len(tensors) 1: return True first_device tensors[0].device return all(t.device first_device for t in tensors) def ensure_same_device(self, *tensors): 确保所有 tensor 在同一设备移到目标设备 return tuple(t.to(self.device) for t in tensors) def get_device_info(self) - Dict: 获取设备信息 info { device: str(self.device), type: self.device.type, } if self.device.type cuda: info.update({ gpu_name: torch.cuda.get_device_name(self.device), gpu_count: torch.cuda.device_count(), gpu_index: self.device.index if self.device.index is not None else 0, memory_allocated: torch.cuda.memory_allocated(self.device) / 1024**3, memory_cached: torch.cuda.memory_reserved(self.device) / 1024**3, }) return info def empty_cache(self): 清空 GPU 缓存 if self.device.type cuda: torch.cuda.empty_cache() print(GPU 缓存已清空) def move_to_device(data, device): 便捷函数将数据移到指定设备 if isinstance(data, torch.Tensor): return data.to(device) elif isinstance(data, nn.Module): return data.to(device) elif isinstance(data, dict): return {k: move_to_device(v, device) for k, v in data.items()} elif isinstance(data, (list, tuple)): return type(data)(move_to_device(item, device) for item in data) else: return data方案四多 GPU 管理import torch import torch.nn as nn # 指定特定 GPU device torch.device(cuda:1) # 使用第二张 GPU model nn.Linear(10, 2).to(device) # 使用 DataParallel 进行多 GPU 训练 model nn.Linear(10, 2) if torch.cuda.device_count() 1: print(f使用 {torch.cuda.device_count()} 张 GPU) model nn.DataParallel(model) model model.to(device) # 使用 DistributedDataParallel更高效的多 GPU # 需要配合 torch.distributed 使用完整修复代码 完整的 PyTorch CUDA 设备管理方案 涵盖设备检查、数据迁移、多GPU、内存管理、训练集成 import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset import os import time from typing import Optional, Union, List, Dict, Any, Tuple # # 设备管理器 # class DeviceManager: 全面的设备管理工具 def __init__(self, device: Optional[Union[str, torch.device]] None): 初始化设备管理器 if device is None: self.device torch.device(cuda if torch.cuda.is_available() else cpu) elif isinstance(device, str): self.device torch.device(device) else: self.device device self._print_device_info() def _print_device_info(self): 打印设备信息 print(f当前设备: {self.device}) if self.device.type cuda: gpu_id self.device.index if self.device.index is not None else 0 print(f GPU 名称: {torch.cuda.get_device_name(gpu_id)}) print(f GPU 数量: {torch.cuda.device_count()}) props torch.cuda.get_device_properties(gpu_id) print(f 总显存: {props.total_memory / 1024**3:.2f} GB) print(f CUDA 版本: {torch.version.cuda}) print(f cuDNN 版本: {torch.backends.cudnn.version()}) def to_device(self, data: Any) - Any: 递归地将数据移到当前设备 if isinstance(data, torch.Tensor): return data.to(self.device, non_blockingTrue) elif isinstance(data, nn.Module): return data.to(self.device) elif isinstance(data, dict): return {k: self.to_device(v) for k, v in data.items()} elif isinstance(data, (list, tuple)): return type(data)(self.to_device(item) for item in data) else: return data def is_on_device(self, tensor: torch.Tensor, device_type: Optional[str] None) - bool: 检查 tensor 是否在指定设备上 if device_type is None: return tensor.device self.device return tensor.device.type device_type def is_on_cuda(self, tensor: torch.Tensor) - bool: 检查 tensor 是否在 CUDA 上 return tensor.is_cuda def is_on_cpu(self, tensor: torch.Tensor) - bool:  检查 tensor 是否在 CPU 上 return tensor.device.type cpu def get_tensor_device(self, tensor: torch.Tensor) - str: 获取 tensor 的设备描述 return str(tensor.device) def ensure_same_device(self, *tensors: torch.Tensor) - Tuple[torch.Tensor, ...]: 确保所有 tensor 在同一设备上 # 检查是否已在同一设备 devices set(t.device for t in tensors) if len(devices) 1: return tensors # 移到当前设备 return tuple(t.to(self.device) for t in tensors) def check_all_same_device(self, *tensors: torch.Tensor) - bool: 检查所有 tensor 是否在同一设备 if len(tensors) 1: return True first_device tensors[0].device return all(t.device first_device for t in tensors) def get_gpu_memory_info(self) - Dict[str, float]: 获取 GPU 显存信息单位GB if self.device.type ! cuda: return {available: 0, total: 0, used: 0} gpu_id self.device.index if self.device.index is not None else 0 total torch.cuda.get_device_properties(gpu_id).total_memory / 1024**3 allocated torch.cuda.memory_allocated(gpu_id) / 1024**3 reserved torch.cuda.memory_reserved(gpu_id) / 1024**3 available total - allocated return { total: total, allocated: allocated, reserved: reserved, available: available, } def print_memory_stats(self): 打印显存使用情况 if self.device.type ! cuda: print(当前使用 CPU无显存信息) return mem self.get_gpu_memory_info() print(f显存使用情况:) print(f 总显存: {mem[total]:.2f} GB) print(f 已分配: {mem[allocated]:.2f} GB) print(f 已缓存: {mem[reserved]:.2f} GB) print(f 可用: {mem[available]:.2f} GB) def empty_cache(self): 清空 GPU 缓存 if self.device.type cuda: torch.cuda.empty_cache() print(GPU 缓存已清空) def synchronize(self): 同步 GPU 操作 if self.device.type cuda: torch.cuda.synchronize(self.device) # # GPU 训练器 # class GPUTrainer: 支持 GPU 的训练器 def __init__(self, model, optimizer, criterion, device_managerNone): self.dm device_manager or DeviceManager() self.model model.to(self.dm.device) self.optimizer optimizer self.criterion criterion # 使用 DataParallel如果有多 GPU if self.dm.device.type cuda and torch.cuda.device_count() 1: self.model nn.DataParallel(self.model) print(f使用 DataParallelGPU 数量: {torch.cuda.device_count()}) self.train_losses [] self.val_losses [] def train_epoch(self, dataloader): 训练一个 epoch self.model.train() total_loss 0 num_batches 0 for batch_idx, (data, target) in enumerate(dataloader): # 确保数据在正确设备上 data, target self.dm.ensure_same_device( data, target ) # 确保与模型在同一设备 data data.to(self.dm.device) target target.to(self.dm.device) self.optimizer.zero_grad() output self.model(data) loss self.criterion(output, target) loss.backward() self.optimizer.step() total_loss loss.item() num_batches 1 return total_loss / num_batches def validate(self, dataloader): 验证 self.model.eval() total_loss 0 num_batches 0 with torch.no_grad(): for data, target in dataloader: data data.to(self.dm.device) target target.to(self.dm.device) output self.model(data) loss self.criterion(output, target) total_loss loss.item() num_batches 1 return total_loss / num_batches def fit(self, train_loader, val_loader, num_epochs): 训练 print(f\n{Epoch:6} | {Train Loss:12} | {Val Loss:12} | {Time:8}) print(- * 50) for epoch in range(num_epochs): start_time time.time() train_loss self.train_epoch(train_loader) val_loss self.validate(val_loader) elapsed time.time() - start_time self.train_losses.append(train_loss) self.val_losses.append(val_loss) print(f{epoch:6d} | {train_loss:12.6f} | {val_loss:12.6f} | {elapsed:7.2f}s) # 每 5 个 epoch 打印显存 if (epoch 1) % 5 0 and self.dm.device.type cuda: self.dm.print_memory_stats() print(- * 50) def predict(self, data): 推理 self.model.eval() data self.dm.to_device(data) with torch.no_grad(): output self.model(data) return output # # 工具函数 # def check_tensor_device(tensor: torch.Tensor) - str: 检查 tensor 的设备并返回描述字符串 if tensor.is_cuda: gpu_id tensor.device.index if tensor.device.index is not None else 0 return fCUDA (GPU {gpu_id}) else: return CPU def move_model_and_data(model, data, deviceNone): 将模型和数据移到同一设备 if device is None: device torch.device(cuda if torch.cuda.is_available() else cpu) model model.to(device) if isinstance(data, torch.Tensor): data data.to(device) elif isinstance(data, dict): data {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in data.items()} elif isinstance(data, (list, tuple)): data type(data)(v.to(device) if isinstance(v, torch.Tensor) else v for v in data) return model, data def benchmark_device_transfer(size10000, deviceNone): 基准测试 CPU-GPU 数据传输速度 if device is None: device torch.device(cuda if torch.cuda.is_available() else cpu) if device.type ! cuda: print(CUDA 不可用跳过基准测试) return # 创建大 tensor tensor_cpu torch.randn(size, size) # CPU - GPU 传输 torch.cuda.synchronize() start time.time() tensor_gpu tensor_cpu.to(device) torch.cuda.synchronize() cpu_to_gpu_time time.time() - start # GPU - CPU 传输 start time.time() tensor_back tensor_gpu.to(cpu) torch.cuda.synchronize() gpu_to_cpu_time time.time() - start tensor_size_mb tensor_cpu.nelement() * tensor_cpu.element_size() / 1024**2 print(f数据大小: {tensor_size_mb:.2f} MB) print(fCPU - GPU: {cpu_to_gpu_time * 1000:.2f} ms ({tensor_size_mb / cpu_to_gpu_time:.2f} MB/s)) print(fGPU - CPU: {gpu_to_cpu_time * 1000:.2f} ms ({tensor_size_mb / gpu_to_cpu_time:.2f} MB/s)) # # 使用示例 # def demo_device_check(): 设备检查示例 print( * 60) print(示例 1: 检查 tensor 设备) print( * 60) dm DeviceManager() # CPU tensor cpu_tensor torch.randn(3, 3) print(f\nCPU Tensor:) print(f 设备: {check_tensor_device(cpu_tensor)}) print(f is_cuda: {cpu_tensor.is_cuda}) print(f device.type: {cpu_tensor.device.type}) # GPU tensor if torch.cuda.is_available(): gpu_tensor torch.randn(3, 3).cuda() print(f\nGPU Tensor:) print(f 设备: {check_tensor_device(gpu_tensor)}) print(f is_cuda: {gpu_tensor.is_cuda}) print(f device: {gpu_tensor.device}) # 移到 CPU moved_tensor gpu_tensor.to(cpu) print(f\n移到 CPU 后:) print(f 设备: {check_tensor_device(moved_tensor)}) print() def demo_device_transfer(): 设备迁移示例 print( * 60) print(示例 2: 设备迁移) print( * 60) dm DeviceManager() # 创建各种数据 tensor torch.randn(5, 10) model nn.Linear(10, 2) data_dict { input: torch.randn(3, 5), target: torch.tensor([0, 1, 2]), } data_list [torch.randn(3), torch.randn(3)] print(f\n迁移前:) print(f tensor 设备: {tensor.device}) print(f model 参数设备: {next(model.parameters()).device}) print(f dict[input] 设备: {data_dict[input].device}) # 迁移到设备 tensor dm.to_device(tensor) model dm.to_device(model) data_dict dm.to_device(data_dict) data_list dm.to_device(data_list) print(f\n迁移后:) print(f tensor 设备: {tensor.device}) print(f model 参数设备: {next(model.parameters()).device}) print(f dict[input] 设备: {data_dict[input].device}) print(f list[0] 设备: {data_list[0].device}) print() def demo_error_handling(): 错误处理示例 print( * 60) print(示例 3: 设备不一致错误处理) print( * 60) dm DeviceManager() # 模拟设备不一致 if torch.cuda.is_available(): a torch.randn(3, 3).cuda() b torch.randn(3, 3) # CPU print(f\nTensor a 设备: {a.device}) print(fTensor b 设备: {b.device}) print(f同一设备: {dm.check_all_same_device(a, b)}) # 修复确保同一设备 a, b dm.ensure_same_device(a, b) print(f\n修复后:) print(f a 设备: {a.device}) print(f b 设备: {b.device}) print(f 同一设备: {dm.check_all_same_device(a, b)}) print(f a b 成功: {(a b).shape}) print() def demo_full_training(): 完整训练示例 print( * 60) print(示例 4: GPU 训练) print( * 60) # 准备数据 torch.manual_seed(42) X torch.randn(1000, 10) y (X torch.randn(10, 3)).argmax(dim1) dataset TensorDataset(X, y) train_size 800 val_size 200 train_ds, val_ds torch.utils.data.random_split(dataset, [train_size, val_size]) train_loader DataLoader(train_ds, batch_size32, shuffleTrue) val_loader DataLoader(val_ds, batch_size32) # 创建模型 model nn.Sequential( nn.Linear(10, 64), nn.ReLU(), nn.Dropout(0.2), nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 3), ) optimizer optim.Adam(model.parameters(), lr0.001) criterion nn.CrossEntropyLoss() # 创建训练器 trainer GPUTrainer(model, optimizer, criterion) # 训练 trainer.fit(train_loader, val_loader, num_epochs10) # 推理 test_data torch.randn(5, 10) predictions trainer.predict(test_data) print(f\n推理结果形状: {predictions.shape}) print(f预测类别: {predictions.argmax(dim1)}) print() def demo_memory_management(): 显存管理示例 print( * 60) print(示例 5: 显存管理) print( * 60) dm DeviceManager() if dm.device.type cuda: print(\n初始状态:) dm.print_memory_stats() # 分配大 tensor big_tensor torch.randn(1000, 1000, devicedm.device) print(\n分配大 tensor 后:) dm.print_memory_stats() # 删除 tensor del big_tensor print(\n删除 tensor 后未清缓存:) dm.print_memory_stats() # 清空缓存 dm.empty_cache() print(\n清空缓存后:) dm.print_memory_stats() else: print(CUDA 不可用跳过显存管理示例) print() def demo_transfer_benchmark(): 传输基准测试 print( * 60) print(示例 6: CPU-GPU 传输基准测试) print( * 60) benchmark_device_transfer(size5000) print() if __name__ __main__: demo_device_check() demo_device_transfer() demo_error_handling() demo_full_training() demo_memory_management() demo_transfer_benchmark() print( * 60) print(所有示例执行完毕) print( * 60)常见陷阱与注意事项1..cuda()vs.to(device)# 不推荐硬编码 GPU无 GPU 时报错 model model.cuda() data data.cuda() # 推荐可移植代码 device torch.device(cuda if torch.cuda.is_available() else cpu) model model.to(device) data data.to(device)2. 忘记将模型移到 GPU# 错误只移了数据没移模型 model nn.Linear(10, 2) # 仍在 CPU data torch.randn(5, 10).cuda() # 在 GPU output model(data) # 报错 # 正确都移到 GPU model model.to(device) data data.to(device)3.non_blockingTrue的使用# 使用 non_blocking 可以重叠数据传输和计算 # 但需要配合 pin_memory 使用 dataloader DataLoader(dataset, batch_size32, pin_memoryTrue) for data, target in dataloader: data data.to(device, non_blockingTrue) target target.to(device, non_blockingTrue) # ...4. GPU 显存泄漏# 错误累积计算图导致显存泄漏 losses [] for batch in dataloader: loss model(batch) losses.append(loss) # 保存了计算图 loss.backward() # 正确只保存标量值 losses [] for batch in dataloader: loss model(batch) losses.append(loss.item()) # 只保存数值 loss.backward()5. 多 GPU 下的设备检查# DataParallel 会将数据分散到多个 GPU model nn.DataParallel(model) # 模型的实际设备是 cuda:0 # 但中间结果可能在不同 GPU 上 # 检查 DataParallel 模型的设备 print(next(model.parameters()).device) # cuda:06. CPU 和 GPU 运算结果可能有微小差异# 由于浮点精度不同CPU 和 GPU 的结果可能有微小差异 a_cpu torch.randn(1000, 1000) a_gpu a_cpu.cuda() result_cpu a_cpu a_cpu.T result_gpu a_gpu a_gpu.T # 结果可能不完全相同 print(torch.allclose(result_cpu, result_gpu.cpu(), atol1e-5))总结在 PyTorch 中检查 tensor 设备和迁移数据到 CUDA关键要点如下使用to(device)而非.cuda()实现 CPU/GPU 可移植代码避免无 GPU 环境报错。检查设备的正确方法使用tensor.is_cuda或tensor.device.type cuda不要直接与字符串比较。确保所有 tensor 在同一设备运算前检查设备一致性使用ensure_same_device工具函数。模型和数据都要移到 GPU只移一个会导致设备不一致错误。使用pin_memory和non_blocking加速 CPU 到 GPU 的数据传输。注意显存管理及时删除不需要的 tensor定期调用torch.cuda.empty_cache()。避免显存泄漏不要保存计算图使用.item()获取标量值。多 GPU 使用 DataParallel 或 DistributedDataParallel注意数据分散和收集的开销。通过遵循这些最佳实践可以有效地管理 PyTorch 中的设备避免常见的设备不一致错误并充分利用 GPU 加速训练。