Pytorch模型迁移和迁移学习,导入部分模型参数

- 日理万妓 2021-12-22 13:04 437阅读 0赞

# Pytorch模型迁移和迁移学习 #

**目录**

Pytorch模型迁移和迁移学习

1. 利用resnet18做迁移学习

2. 修改网络名称并迁移学习

3.去除原模型的某些模块

--------------------

### 1. 利用resnet18做迁移学习 ###

import torch
    from torchvision import models
    
    if __name__ == "__main__":
        # device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        device = 'cpu'
        print("-----device:{}".format(device))
        print("-----Pytorch version:{}".format(torch.__version__))
    
        input_tensor = torch.zeros(1, 3, 100, 100)
        print('input_tensor:', input_tensor.shape)
        pretrained_file = "model/resnet18-5c106cde.pth"
        model = models.resnet18()
        model.load_state_dict(torch.load(pretrained_file))
        model.eval()
        out = model(input_tensor)
        print("out:", out.shape, out[0, 0:10])

结果输出:

> input\_tensor: torch.Size(\[1, 3, 100, 100\])  
> out: torch.Size(\[1, 1000\]) tensor(\[ 0.4010,  0.8436,  0.3072,  0.0627,  0.4446,  0.8470,  0.1882,  0.7012,0.2988, -0.7574\], grad\_fn=<SliceBackward>)

如果,我们修改了resnet18的网络结构,如何将原来预训练模型参数(resnet18-5c106cde.pth)迁移到新的resnet18网络中呢?

比如,这里将官方的resnet18的self.layer4 = self.\_make\_layer(block, 512, layers\[3\], stride=2)改为:self.layer44 = self.\_make\_layer(block, 512, layers\[3\], stride=2)

class ResNet(nn.Module):
    
        def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
            super(ResNet, self).__init__()
            self.inplanes = 64
            self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                                   bias=False)
            self.bn1 = nn.BatchNorm2d(64)
            self.relu = nn.ReLU(inplace=True)
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
            self.layer1 = self._make_layer(block, 64, layers[0])
            self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
            self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
            self.layer44 = self._make_layer(block, 512, layers[3], stride=2)
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            self.fc = nn.Linear(512 * block.expansion, num_classes)
    
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                elif isinstance(m, nn.BatchNorm2d):
                    nn.init.constant_(m.weight, 1)
                    nn.init.constant_(m.bias, 0)
    
            # Zero-initialize the last BN in each residual branch,
            # so that the residual branch starts with zeros, and each residual block behaves like an identity.
            # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
            if zero_init_residual:
                for m in self.modules():
                    if isinstance(m, Bottleneck):
                        nn.init.constant_(m.bn3.weight, 0)
                    elif isinstance(m, BasicBlock):
                        nn.init.constant_(m.bn2.weight, 0)
    
        def _make_layer(self, block, planes, blocks, stride=1):
            downsample = None
            if stride != 1 or self.inplanes != planes * block.expansion:
                downsample = nn.Sequential(
                    conv1x1(self.inplanes, planes * block.expansion, stride),
                    nn.BatchNorm2d(planes * block.expansion),
                )
    
            layers = []
            layers.append(block(self.inplanes, planes, stride, downsample))
            self.inplanes = planes * block.expansion
            for _ in range(1, blocks):
                layers.append(block(self.inplanes, planes))
    
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.bn1(x)
            x = self.relu(x)
            x = self.maxpool(x)
    
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            x = self.layer44(x)
    
            x = self.avgpool(x)
            x = x.view(x.size(0), -1)
            x = self.fc(x)
    
            return x

这时,直接加载模型:

>     model = models.resnet18()  
>     model.load\_state\_dict(torch.load(pretrained\_file))

这时,肯定会报错,类似:Missing key(s) in state\_dict或者Unexpected key(s) in state\_dict的错误:

> RuntimeError: Error(s) in loading state\_dict for ResNet:  
>     Missing key(s) in state\_dict: "layer44.0.conv1.weight", "layer44.0.bn1.weight", "layer44.0.bn1.bias", "layer44.0.bn1.running\_mean", "layer44.0.bn1.running\_var", "layer44.0.conv2.weight", "layer44.0.bn2.weight", "layer44.0.bn2.bias", "layer44.0.bn2.running\_mean", "layer44.0.bn2.running\_var", "layer44.0.downsample.0.weight", "layer44.0.downsample.1.weight", "layer44.0.downsample.1.bias", "layer44.0.downsample.1.running\_mean", "layer44.0.downsample.1.running\_var", "layer44.1.conv1.weight", "layer44.1.bn1.weight", "layer44.1.bn1.bias", "layer44.1.bn1.running\_mean", "layer44.1.bn1.running\_var", "layer44.1.conv2.weight", "layer44.1.bn2.weight", "layer44.1.bn2.bias", "layer44.1.bn2.running\_mean", "layer44.1.bn2.running\_var".   
>     Unexpected key(s) in state\_dict: "layer4.0.conv1.weight", "layer4.0.bn1.running\_mean", "layer4.0.bn1.running\_var", "layer4.0.bn1.weight", "layer4.0.bn1.bias", "layer4.0.conv2.weight", "layer4.0.bn2.running\_mean", "layer4.0.bn2.running\_var", "layer4.0.bn2.weight", "layer4.0.bn2.bias", "layer4.0.downsample.0.weight", "layer4.0.downsample.1.running\_mean", "layer4.0.downsample.1.running\_var", "layer4.0.downsample.1.weight", "layer4.0.downsample.1.bias", "layer4.1.conv1.weight", "layer4.1.bn1.running\_mean", "layer4.1.bn1.running\_var", "layer4.1.bn1.weight", "layer4.1.bn1.bias", "layer4.1.conv2.weight", "layer4.1.bn2.running\_mean", "layer4.1.bn2.running\_var", "layer4.1.bn2.weight", "layer4.1.bn2.bias". 
> 
> Process finished with

> RuntimeError: Error(s) in loading state\_dict for ResNet:  
>     Unexpected key(s) in state\_dict: "layer4.0.conv1.weight", "layer4.0.bn1.running\_mean", "layer4.0.bn1.running\_var", "layer4.0.bn1.weight", "layer4.0.bn1.bias", "layer4.0.conv2.weight", "layer4.0.bn2.running\_mean", "layer4.0.bn2.running\_var", "layer4.0.bn2.weight", "layer4.0.bn2.bias", "layer4.0.downsample.0.weight", "layer4.0.downsample.1.running\_mean", "layer4.0.downsample.1.running\_var", "layer4.0.downsample.1.weight", "layer4.0.downsample.1.bias", "layer4.1.conv1.weight", "layer4.1.bn1.running\_mean", "layer4.1.bn1.running\_var", "layer4.1.bn1.weight", "layer4.1.bn1.bias", "layer4.1.conv2.weight", "layer4.1.bn2.running\_mean", "layer4.1.bn2.running\_var", "layer4.1.bn2.weight", "layer4.1.bn2.bias".

我们希望将原来预训练模型参数(resnet18-5c106cde.pth)迁移到新的resnet18网络,当然只能迁移二者相同的模型参数,不同的参数还是随机初始化的.

def transfer_model(pretrained_file, model):
        '''
        只导入pretrained_file部分模型参数
        tensor([-0.7119,  0.0688, -1.7247, -1.7182, -1.2161, -0.7323, -2.1065, -0.5433,-1.5893, -0.5562]
        update:
            D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
            If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
            If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
            In either case, this is followed by: for k in F:  D[k] = F[k]
        :param pretrained_file:
        :param model:
        :return:
        '''
        pretrained_dict = torch.load(pretrained_file)  # get pretrained dict
        model_dict = model.state_dict()  # get model dict
        # 在合并前(update),需要去除pretrained_dict一些不需要的参数
        pretrained_dict = transfer_state_dict(pretrained_dict, model_dict)
        model_dict.update(pretrained_dict)  # 更新(合并)模型的参数
        model.load_state_dict(model_dict)
        return model
    
    
    def transfer_state_dict(pretrained_dict, model_dict):
        '''
        根据model_dict,去除pretrained_dict一些不需要的参数,以便迁移到新的网络
        url: https://blog.csdn.net/qq_34914551/article/details/87871134
        :param pretrained_dict:
        :param model_dict:
        :return:
        '''
        # state_dict2 = {k: v for k, v in save_model.items() if k in model_dict.keys()}
        state_dict = {}
        for k, v in pretrained_dict.items():
            if k in model_dict.keys():
                # state_dict.setdefault(k, v)
                state_dict[k] = v
            else:
                print("Missing key(s) in state_dict :{}".format(k))
        return state_dict
    
    
    if __name__ == "__main__":
    
        input_tensor = torch.zeros(1, 3, 100, 100)
        print('input_tensor:', input_tensor.shape)
        pretrained_file = "model/resnet18-5c106cde.pth"
        # model = resnet18()
        # model.load_state_dict(torch.load(pretrained_file))
        # model.eval()
        # out = model(input_tensor)
        # print("out:", out.shape, out[0, 0:10])
    
        model1 = resnet18()
        model1 = transfer_model(pretrained_file, model1)
        out1 = model1(input_tensor)
        print("out1:", out1.shape, out1[0, 0:10])

### 2. 修改网络名称并迁移学习 ###

上面的例子,只是将官方的resnet18的self.layer4 = self.\_make\_layer(block, 512, layers\[3\], stride=2)改为了:self.layer44 = self.\_make\_layer(block, 512, layers\[3\], stride=2),我们仅仅是修改了一个网络名称而已,就导致 model.load\_state\_dict(torch.load(pretrained\_file))出错,

那么,我们如何将预训练模型"model/resnet18-5c106cde.pth"转换成符合新的网络的模型参数呢?

方法很简单,**只需要将resnet18-5c106cde.pth的模型参数中所有前缀为layer4的名称,改为layer44即可**

**本人已经定义好了方法:**

> **modify\_state\_dict(pretrained\_dict, model\_dict, old\_prefix, new\_prefix)**

def string_rename(old_string, new_string, start, end):
        new_string = old_string[:start] + new_string + old_string[end:]
        return new_string
    
    
    def modify_model(pretrained_file, model, old_prefix, new_prefix):
        '''
        :param pretrained_file:
        :param model:
        :param old_prefix:
        :param new_prefix:
        :return:
        '''
        pretrained_dict = torch.load(pretrained_file)
        model_dict = model.state_dict()
        state_dict = modify_state_dict(pretrained_dict, model_dict, old_prefix, new_prefix)
        model.load_state_dict(state_dict)
        return model
    
    
    def modify_state_dict(pretrained_dict, model_dict, old_prefix, new_prefix):
        '''
        修改model dict
        :param pretrained_dict:
        :param model_dict:
        :param old_prefix:
        :param new_prefix:
        :return:
        '''
        state_dict = {}
        for k, v in pretrained_dict.items():
            if k in model_dict.keys():
                # state_dict.setdefault(k, v)
                state_dict[k] = v
            else:
                for o, n in zip(old_prefix, new_prefix):
                    prefix = k[:len(o)]
                    if prefix == o:
                        kk = string_rename(old_string=k, new_string=n, start=0, end=len(o))
                        print("rename layer modules:{}-->{}".format(k, kk))
                        state_dict[kk] = v
        return state_dict

if __name__ == "__main__":
        input_tensor = torch.zeros(1, 3, 100, 100)
        print('input_tensor:', input_tensor.shape)
        pretrained_file = "model/resnet18-5c106cde.pth"
        # model = models.resnet18()
        # model.load_state_dict(torch.load(pretrained_file))
        # model.eval()
        # out = model(input_tensor)
        # print("out:", out.shape, out[0, 0:10])
        #
        # model1 = resnet18()
        # model1 = transfer_model(pretrained_file, model1)
        # out1 = model1(input_tensor)
        # print("out1:", out1.shape, out1[0, 0:10])
        #
        new_file = "new_model.pth"
        model = resnet18()
        new_model = modify_model(pretrained_file, model, old_prefix=["layer4"], new_prefix=["layer44"])
        torch.save(new_model.state_dict(), new_file)
    
        model2 = resnet18()
        model2.load_state_dict(torch.load(new_file))
        model2.eval()
        out2 = model2(input_tensor)
        print("out2:", out2.shape, out2[0, 0:10])

这时,输出,跟之前一模一样了

> out: torch.Size(\[1, 1000\]) tensor(\[ 0.4010,  0.8436,  0.3072,  0.0627,  0.4446,  0.8470,  0.1882,  0.7012,0.2988, -0.7574\], grad\_fn=<SliceBackward>)

### 3.去除原模型的某些模块 ###

下面是在不修改原模型代码的情况下,通过"resnet18.named\_children()"和"resnet18.children()"的方法去除子模块"fc"和"avgpool"

import torch
    import torchvision.models as models
    from collections import OrderedDict
    
    if __name__=="__main__":
        resnet18 = models.resnet18(False)
        print("resnet18",resnet18)
    
        # use named_children()
        resnet18_v1 = OrderedDict(resnet18.named_children())
        # remove avgpool,fc
        resnet18_v1.pop("avgpool")
        resnet18_v1.pop("fc")
        resnet18_v1 = torch.nn.Sequential(resnet18_v1)
        print("resnet18_v1",resnet18_v1)
        # use children
        resnet18_v2 = torch.nn.Sequential(*list(resnet18.children())[:-2])
        print(resnet18_v2,resnet18_v2)

## ##

发表评论取消回复

表情：

评论列表（有 0 条评论，437人围观）

还没有评论，来说两句吧...

相关阅读

相关 Pytorch中实现只导入部分模型参数的方式

![e0d34bcb3f6a87a90eaa31d14d350423.jpeg][] 今天小编就为大家分享一篇Pytorch中实现只导入部分模型参数的方式，具有很好的参考价值

浅浅的花香味﹌/ 2024年03月22日 20:42/ 0 赞/ 89 阅读

相关 Pytorch迁移学习使用Resnet50进行模型训练预测猫狗二分类

目录 1.ResNet残差网络 1.1 ResNet定义 1.2 ResNet 几种网络配置 1.3 ResNet50网络结构 1.3.1 前几层卷积和池化 1

痛定思痛。/ 2023年10月13日 22:14/ 0 赞/ 169 阅读

相关手势识别：使用EfficientNet模型迁移、VGG16模型迁移

![20191009191333910.png][] [日萌社][Link 1] [人工智能AI：Keras PyTorch MXNet TensorFlow

分手后的思念是犯贱/ 2023年07月17日 15:37/ 0 赞/ 21 阅读

相关 PyTorch 更新模型参数以及并固定该部分参数(二)

简介在进行这部分时，会存在一些疑惑，针对以下疑惑进行解答。问题一：实际上在固定参数的时候，大家会有疑惑，既然使用这种方式固定冻结网络参数是否存在固定的高层网络，但是

喜欢ヅ旅行/ 2023年02月12日 06:27/ 0 赞/ 14 阅读

相关 0018-pytorch-迁移学习范本-01

-- coding: utf-8 -- @Time : 2021/1/19 10:39 @Author : Johnson

一时失言乱红尘/ 2023年01月08日 05:25/ 0 赞/ 210 阅读

相关 PyTorch：模型训练-模型参数parameters

[\-柚子皮-][-_-] 获取模型参数的不同方法 1、model.named\_parameters()，迭代打印model.named\_parameters()将

╰半橙微兮°/ 2022年12月16日 15:24/ 0 赞/ 237 阅读

相关 Facebook万字长文：AI模型全部迁移至PyTorch框架

PyTorch自2017年推出以来，就迅速占领GitHub热度榜榜首，一度有赶超Tensorflow的趋势。 ![Facebook万字长文：AI模型全部迁移至PyTorch框

清疚/ 2022年10月06日 05:59/ 0 赞/ 197 阅读

相关【pytorch】pytorch读模型打印参数

下面的代码包含用途有： 1.训练时多GPU，推理时所有层多出一个module时替换； 2.训练模型出现层的定义不一致时替换； 3.打印训练过程中学习的参数，可视化对应参数

女爷i/ 2022年09月16日 04:59/ 0 赞/ 350 阅读

相关 Pytorch模型迁移和迁移学习,导入部分模型参数

Pytorch模型迁移和迁移学习目录 Pytorch模型迁移和迁移学习 1. 利用resnet18做迁移学习 2. 修改网络名称并迁移学习 3.去除原模型的某些

- 日理万妓/ 2021年12月22日 13:04/ 0 赞/ 438 阅读

相关 Pytorch迁移学习

环境： Pytorch1.1，Python3.6，win10/ubuntu18，GPU 正文 1. Pytorch构建ResNet18模型并训练，进行真实图片分

矫情吗；*/ 2021年11月02日 02:28/ 0 赞/ 606 阅读