Skip to main content
 首页 » 编程设计

python之PyTorch 中 fc.bias 和 fc.weight 的大小不匹配

2024年12月31日10java哥

我使用迁移学习方法训练模型并保存检测到的最佳权重。在另一个脚本中,我尝试使用保存的权重进行预测。但是我收到如下错误。我使用 ResNet 微调网络并有 4 个类。

RuntimeError: Error(s) in loading state_dict for ResNet: 
size mismatch for fc.bias: copying a param of torch.Size([1000]) from  
checkpoint, where the shape is torch.Size([4]) in current model. 
size mismatch for fc.weight: copying a param of torch.Size([1000,  
512]) from checkpoint, where the shape is torch.Size([4, 512]) in  
current model. 

我使用以下代码预测输出:

checkpoint = torch.load("./models/custom_model13.model") 
model = resnet18(pretrained=True) 
 
model.load_state_dict(checkpoint) 
model.eval() 
 
def predict_image(image_path): 
    transformation = transforms.Compose([ 
        transforms.RandomResizedCrop(224), 
        transforms.RandomHorizontalFlip(), 
        transforms.ToTensor(), 
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) 
        ]) 
    image_tensor = transformation(image).float() 
    image_tensor = image_tensor.unsqueeze_(0) 
 
    if torch.cuda.is_available(): 
        image_tensor.cuda() 
 
    input = Variable(image_tensor) 
    output = model(input) 
 
    index = output.data.numpy().argmax() 
    return index 
 
if __name__ == "main": 
    imagefile = "image.png" 
    imagepath = os.path.join(os.getcwd(),imagefile) 
    prediction = predict_image(imagepath) 
    print("Predicted Class: ",prediction) 

以及以下用于训练和保存模型的代码:

Data_dir = 'Dataset' 
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), 
                                          data_transforms[x]) 
                  for x in ['train', 'val']} 
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, 
                                             shuffle=True, num_workers=4) 
              for x in ['train', 'val']} 
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} 
class_names = image_datasets['train'].classes 
 
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") 
print (device) 
 
def save_models(epochs, model): 
    torch.save(model.state_dict(), "custom_model{}.model".format(epochs)) 
    print("Checkpoint Saved") 
 
def train_model(model, criterion, optimizer, scheduler, num_epochs=25): 
    since = time.time() 
 
    best_model_wts = copy.deepcopy(model.state_dict()) 
    best_acc = 0.0 
 
    for epoch in range(num_epochs): 
        print('Epoch {}/{}'.format(epoch, num_epochs - 1)) 
        print('-' * 10) 
 
        # Each epoch has a training and validation phase 
        for phase in ['train', 'val']: 
            if phase == 'train': 
                scheduler.step() 
                model.train()  # Set model to training mode 
            else: 
                model.eval()   # Set model to evaluate mode 
 
            running_loss = 0.0 
            running_corrects = 0 
 
            # Iterate over data. 
            for inputs, labels in dataloaders[phase]: 
                inputs = inputs.to(device) 
                labels = labels.to(device) 
 
                # zero the parameter gradients 
                optimizer.zero_grad() 
 
                # forward 
                # track history if only in train 
                with torch.set_grad_enabled(phase == 'train'): 
                    outputs = model(inputs) 
                    _, preds = torch.max(outputs, 1) 
                    loss = criterion(outputs, labels) 
 
                    # backward + optimize only if in training phase 
                    if phase == 'train': 
                        loss.backward() 
                        optimizer.step() 
 
                # statistics 
                running_loss += loss.item() * inputs.size(0) 
                running_corrects += torch.sum(preds == labels.data) 
 
            epoch_loss = running_loss / dataset_sizes[phase] 
            epoch_acc = running_corrects.double() / dataset_sizes[phase] 
 
            print('{} Loss: {:.4f} Acc: {:.4f}'.format( 
                phase, epoch_loss, epoch_acc)) 
 
            # deep copy the model 
            if phase == 'train' and epoch_acc > best_acc: 
                save_models(epoch,model) 
                best_acc = epoch_acc 
                best_model_wts = copy.deepcopy(model.state_dict()) 
 
        print() 
 
    time_elapsed = time.time() - since 
    print('Training complete in {:.0f}m {:.0f}s'.format( 
        time_elapsed // 60, time_elapsed % 60)) 
    print('Best val Acc: {:4f}'.format(best_acc)) 
 
    # load best model weights 
    model.load_state_dict(best_model_wts) 
    return model 
 
def visualize_model(model, num_images=6): 
    was_training = model.training 
    model.eval() 
    images_so_far = 0 
    fig = plt.figure() 
 
    with torch.no_grad(): 
        for i, (inputs, labels) in enumerate(dataloaders['val']): 
            inputs = inputs.to(device) 
            labels = labels.to(device) 
 
            outputs = model(inputs) 
            _, preds = torch.max(outputs, 1) 
 
            for j in range(inputs.size()[0]): 
                images_so_far += 1 
                ax = plt.subplot(num_images//2, 2, images_so_far) 
                ax.axis('off') 
                ax.set_title('predicted: {}'.format(class_names[preds[j]])) 
                imshow(inputs.cpu().data[j]) 
 
                if images_so_far == num_images: 
                    model.train(mode=was_training) 
                    return 
        model.train(mode=was_training) 
 
model_ft = models.resnet18(pretrained=True) 
num_ftrs = model_ft.fc.in_features 
model_ft.fc = nn.Linear(num_ftrs, 4) 
 
model_ft = model_ft.to(device) 
 
criterion = nn.CrossEntropyLoss() 
 
 
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) 
 
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) 
 
model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler, 
                       num_epochs=25) 

请您参考如下方法:

原因:

您以这种方式训练了从 resnet18 派生的模型:

model_ft = models.resnet18(pretrained=True) 
num_ftrs = model_ft.fc.in_features 
model_ft.fc = nn.Linear(num_ftrs, 4) 

也就是说,您更改最后一个 nn.Linear 层以输出 4 个暗淡预测而不是默认的 1000 个。
当您尝试加载模型进行预测时,您的代码是:

model = resnet18(pretrained=True)     
model.load_state_dict(checkpoint) 

您没有将最后一个nn.Linear 层的相同更改应用于模型,因此检查点您正在尝试加载不适合。

修复:

(1) 在加载检查点之前应用相同的更改:

model = resnet18(pretrained=True)     
num_ftrs = model_ft.fc.in_features 
model_ft.fc = nn.Linear(num_ftrs, 4)  # make the change 
model.load_state_dict(checkpoint)  # load 

(2) 更好的是,使用 num_classes 参数来构造 resnet,并以所需的输出数量开始:

model = resnet18(pretrained=True, num_classes=4)   
model.load_state_dict(checkpoint)  # load