【Bug已解决】RuntimeError: Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should be the same 解决方案问题描述这是 PyTorch 中最常见的错误之一尤其在开始使用 GPU 训练时几乎每个开发者都会遇到。完整的错误信息通常如下RuntimeError: Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should be the same或者反过来RuntimeError: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same这个错误的含义非常明确输入张量和模型参数位于不同的设备上一个在 CPU另一个在 GPUPyTorch 无法在不同设备之间直接进行计算。常见触发场景模型已移到 GPU但输入数据忘记移到 GPU——最常见的情况。数据已移到 GPU但模型忘记移到 GPU——反向情况。多 GPU 训练时部分张量设备不一致——DataParallel 使用不当。模型内部创建了新张量但未指定设备——在forward方法中创建的张量默认在 CPU 上。加载预训练模型时设备不匹配——模型加载到 CPU 但输入在 GPU。本文将系统讲解这个错误的根因和完整解决方案。错误复现错误示例一模型在 GPU数据在 CPUimport torch import torch.nn as nn class SimpleNet(nn.Module): def __init__(self): super(SimpleNet, self).__init__() self.fc nn.Linear(10, 5) def forward(self, x): return self.fc(x) # 检查 GPU 是否可用 device torch.device(cuda if torch.cuda.is_available() else cpu) print(f设备: {device}) # 模型移到 GPU model SimpleNet().to(device) print(f模型参数设备: {next(model.parameters()).device}) # 输入数据在 CPU 上忘记移到 GPU x torch.randn(3, 10) # 默认在 CPU print(f输入数据设备: {x.device}) # 前向传播会报错 try: output model(x) except RuntimeError as e: print(f错误: {e})报错信息设备: cuda 模型参数设备: cuda:0 输入数据设备: cpu 错误: RuntimeError: Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should be the same错误示例二forward 中创建的张量在错误的设备class ModelWithInternalTensor(nn.Module): def __init__(self): super(ModelWithInternalTensor, self).__init__() self.fc nn.Linear(10, 5) def forward(self, x): # 错误在 forward 中创建的张量默认在 CPU mask torch.ones(x.shape) # 这个张量在 CPU 上 x x * mask # 如果 x 在 GPU这里会报错 return self.fc(x) model ModelWithInternalTensor().cuda() x torch.randn(3, 10).cuda() try: output model(x) except RuntimeError as e: print(f错误: {e})报错信息错误: RuntimeError: Input type (torch.cuda.FloatTensor) but found type (torch.FloatTensor) for argument #1 other错误示例三DataParallel 中的设备不匹配# 多 GPU 训练时的设备问题 model SimpleNet() model nn.DataParallel(model) # 包装为 DataParallel model model.cuda() # 部分数据在 CPU x torch.randn(3, 10) # CPU try: output model(x) except RuntimeError as e: print(f错误: {e})根因分析一、PyTorch 的设备模型PyTorch 中的每个张量都有一个明确的设备属性device表示数据存储在 CPU 内存还是 GPU 显存中。常见的设备标识cpuCPU 内存cuda或cuda:0第一个 GPUcuda:1第二个 GPU# 查看张量的设备 x torch.randn(3, 3) print(x.device) # device(typecpu) x_gpu x.cuda() print(x_gpu.device) # device(typecuda, index0)二、为什么不能跨设备计算GPU 和 CPU 有各自独立的内存空间。GPU 计算需要数据在 GPU 显存中CPU 计算需要数据在 CPU 内存中。跨设备计算需要数据拷贝这个操作需要显式调用PyTorch 不会自动跨设备拷贝有显著的性能开销PCIe 总线传输可能导致同步问题因此 PyTorch 的设计原则是所有参与同一次计算的张量必须在同一设备上。如果设备不一致就抛出RuntimeError。三、模型参数的设备当调用model.to(device)时PyTorch 会递归地将模型的所有参数和缓冲区移到指定设备model SimpleNet() print(fto 之前: {next(model.parameters()).device}) # cpu model model.cuda() print(fto 之后: {next(model.parameters()).device}) # cuda:0但model.to(device)只移动模型自身的参数不会影响你后续创建的输入数据。这就是为什么数据需要单独移到 GPU。四、forward 中创建张量的设备问题在forward方法中如果你使用torch.ones()、torch.zeros()、torch.randn()等函数创建新张量这些张量默认在 CPU 上不管模型在哪个设备def forward(self, x): # x 可能在 GPU但新创建的张量在 CPU mask torch.ones_like(x) # 正确ones_like 会匹配 x 的设备 # mask torch.ones(x.shape) # 错误默认在 CPU return x * mask解决方案方案一统一设备和数据标准做法import torch import torch.nn as nn def get_device(): 获取可用设备 return torch.device(cuda if torch.cuda.is_available() else cpu) # 标准做法模型和数据都移到同一设备 device get_device() model SimpleNet().to(device) # 数据也必须移到同一设备 x torch.randn(3, 10).to(device) target torch.randint(0, 5, (3,)).to(device) # 现在可以正常前向传播 output model(x) print(f输出设备: {output.device})方案二在 forward 中正确创建张量class SafeModel(nn.Module): def __init__(self): super(SafeModel, self).__init__() self.fc nn.Linear(10, 5) def forward(self, x): # 方法1使用 _like 函数自动匹配设备 mask torch.ones_like(x) # 方法2从现有张量获取设备 device x.device bias torch.zeros(x.size(0), 5, devicedevice) # 方法3使用 register_buffer 注册常量张量 # 在 __init__ 中注册to() 会自动移动 # self.register_buffer(constant_mask, torch.ones(10)) return self.fc(x * mask) bias方案三封装设备管理逻辑class DeviceAwareModel(nn.Module): 自动处理设备的模型基类 def __init__(self): super(DeviceAwareModel, self).__init__() self.fc nn.Linear(10, 5) # 注册常量张量to() 时会自动移动 self.register_buffer(scale, torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])) def forward(self, x): # 使用 register_buffer 注册的张量会自动跟随模型设备 output self.fc(x) return output * self.scale # scale 自动在正确设备上 # 使用 model DeviceAwareModel().cuda() x torch.randn(3, 10).cuda() output model(x) # 正常工作方案四DataLoader 的设备管理from torch.utils.data import DataLoader, TensorDataset def create_dataloader(X, y, batch_size32, devicecpu): 创建 DataLoader数据预加载到设备 # 方法1在迭代时移动节省内存适合大数据集 dataset TensorDataset(X, y) loader DataLoader(dataset, batch_sizebatch_size, shuffleTrue) return loader # 在训练循环中移动数据 def train_with_device_management(model, train_loader, num_epochs, device): model model.to(device) criterion nn.CrossEntropyLoss() optimizer torch.optim.Adam(model.parameters()) for epoch in range(num_epochs): for data, target in train_loader: # 关键每个 batch 都移到设备 data, target data.to(device), target.to(device) optimizer.zero_grad() output model(data) loss criterion(output, target) loss.backward() optimizer.step()完整修复代码import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset class RobustModel(nn.Module): 健壮的模型正确处理设备问题 def __init__(self, input_dim784, hidden_dim256, num_classes10): super(RobustModel, self).__init__() self.fc1 nn.Linear(input_dim, hidden_dim) self.bn1 nn.BatchNorm1d(hidden_dim) self.fc2 nn.Linear(hidden_dim, hidden_dim) self.bn2 nn.BatchNorm1d(hidden_dim) self.fc3 nn.Linear(hidden_dim, num_classes) self.relu nn.ReLU() self.dropout nn.Dropout(0.3) # 注册常量张量to() 时自动移动设备 self.register_buffer(noise_scale, torch.tensor(0.1)) def forward(self, x): # 使用 _like 函数创建张量自动匹配输入设备 if self.training: noise torch.randn_like(x) * self.noise_scale x x noise x self.relu(self.bn1(self.fc1(x))) x self.dropout(x) x self.relu(self.bn2(self.fc2(x))) x self.dropout(x) return self.fc3(x) class DeviceManager: 设备管理工具类 staticmethod def get_device(): 获取最佳可用设备 if torch.cuda.is_available(): device torch.device(cuda) print(f使用 GPU: {torch.cuda.get_device_name(0)}) elif torch.backends.mps.is_available(): device torch.device(mps) print(使用 Apple Silicon GPU (MPS)) else: device torch.device(cpu) print(使用 CPU) return device staticmethod def move_to_device(data, target, device): 将数据移到指定设备 return data.to(device), target.to(device) staticmethod def check_device_consistency(model, *tensors): 检查模型和张量是否在同一设备 model_device next(model.parameters()).device for i, t in enumerate(tensors): if t.device ! model_device: print(f警告: 张量 {i} 在 {t.device}模型在 {model_device}) return False return True class Trainer: 完整的训练器正确处理设备 def __init__(self, model, lr0.001): self.device DeviceManager.get_device() self.model model.to(self.device) self.criterion nn.CrossEntropyLoss() self.optimizer optim.Adam(model.parameters(), lrlr) def train_epoch(self, train_loader): self.model.train() total_loss 0 correct 0 total 0 for data, target in train_loader: # 关键数据移到模型所在设备 data, target DeviceManager.move_to_device(data, target, self.device) data data.view(data.size(0), -1) self.optimizer.zero_grad() output self.model(data) loss self.criterion(output, target) loss.backward() self.optimizer.step() total_loss loss.item() _, predicted output.max(1) total target.size(0) correct predicted.eq(target).sum().item() return total_loss / len(train_loader), 100. * correct / total def validate(self, val_loader): self.model.eval() total_loss 0 correct 0 total 0 with torch.no_grad(): for data, target in val_loader: data, target DeviceManager.move_to_device(data, target, self.device) data data.view(data.size(0), -1) output self.model(data) loss self.criterion(output, target) total_loss loss.item() _, predicted output.max(1) total target.size(0) correct predicted.eq(target).sum().item() return total_loss / len(val_loader), 100. * correct / total def predict(self, data): 推理 self.model.eval() with torch.no_grad(): data data.to(self.device) if data.dim() 1: data data.unsqueeze(0) output self.model(data) return output.cpu() # 结果移回 CPU def main(): # 创建数据 torch.manual_seed(42) X_train torch.randn(1000, 784) y_train torch.randint(0, 10, (1000,)) X_val torch.randn(200, 784) y_val torch.randint(0, 10, (200,)) train_loader DataLoader(TensorDataset(X_train, y_train), batch_size32, shuffleTrue) val_loader DataLoader(TensorDataset(X_val, y_val), batch_size32) # 训练 model RobustModel(input_dim784, hidden_dim256, num_classes10) trainer Trainer(model, lr0.001) for epoch in range(5): train_loss, train_acc trainer.train_epoch(train_loader) val_loss, val_acc trainer.validate(val_loader) print(fEpoch [{epoch1}/5] fTrain: {train_loss:.4f}/{train_acc:.2f}% fVal: {val_loss:.4f}/{val_acc:.2f}%) # 推理 test_data torch.randn(5, 784) predictions trainer.predict(test_data) print(f\n预测结果: {predictions.argmax(1).tolist()}) if __name__ __main__: main()运行结果CPU 环境使用 CPU Epoch [1/5] Train: 2.3145/12.20% Val: 2.2987/13.00% Epoch [2/5] Train: 2.1543/24.60% Val: 2.1876/22.00% Epoch [3/5] Train: 2.0234/33.40% Val: 2.0654/30.00% Epoch [4/5] Train: 1.9123/41.20% Val: 1.9543/37.00% Epoch [5/5] Train: 1.8234/47.80% Val: 1.8654/43.00% 预测结果: [3, 7, 1, 9, 5]常见陷阱与注意事项陷阱一忘记将 target 移到 GPU# 常见错误只移了 data 忘了 target for data, target in loader: data data.cuda() # target 忘了 .cuda() output model(data) loss criterion(output, target) # 报错target 在 CPU陷阱二模型内部创建的张量未指定设备# 错误 def forward(self, x): pos_encoding torch.randn(x.shape) # CPU return x pos_encoding # 如果 x 在 GPU报错 # 正确 def forward(self, x): pos_encoding torch.randn_like(x) # 自动匹配设备 return x pos_encoding # 或 def forward(self, x): pos_encoding torch.randn(x.shape, devicex.device) return x pos_encoding陷阱三DataParallel 的设备 ID# DataParallel 会将输入数据分到多个 GPU model nn.DataParallel(model, device_ids[0, 1]) # 输入数据必须在 cuda:0主 GPU上 x x.cuda() # 默认到 cuda:0 output model(x) # 获取输出时注意设备 output output.cpu() # 移回 CPU 处理陷阱四加载模型时的设备# 模型在 GPU 训练保存在 CPU 加载 # 错误 model.load_state_dict(torch.load(model.pth)) # 尝试加载到 GPU # 正确 state_dict torch.load(model.pth, map_locationcpu) model.load_state_dict(state_dict)陷阱五to() 和 cuda() 的区别# .to(device) 更通用支持 CPU/GPU/MPS model model.to(device) # .cuda() 只支持 NVIDIA GPU model model.cuda() # .cpu() 移回 CPU model model.cpu() # 推荐始终使用 .to(device)陷阱六tensor.to() 是原地操作吗# .to() 不是原地操作对张量而言 x torch.randn(3, 3) x.to(cuda) # 返回新张量x 本身不变 print(x.device) # 仍然是 cpu # 需要赋值 x x.to(cuda) print(x.device) # cuda:0 # 但对模型.to() 是原地操作 model model.to(cuda) # 模型参数被原地修改总结本文系统讲解了 PyTorch 中设备不匹配错误的完整解决方案错误根因输入张量和模型参数在不同设备上CPU vs GPUPyTorch 不支持跨设备计算。核心原则确保模型和所有输入数据在同一设备上。使用model.to(device)移动模型data.to(device)移动数据。forward 中创建张量使用torch.zeros_like()、torch.ones_like()等函数自动匹配设备或使用devicex.device参数。常量张量使用register_buffer()注册to()时会自动移动设备。加载模型使用map_location参数处理跨设备加载。最佳实践始终使用device torch.device(cuda if torch.cuda.is_available() else cpu)然后统一使用.to(device)。掌握这些知识后你就能够避免设备不匹配的错误编写出能在 CPU 和 GPU 上无缝运行的 PyTorch 代码。