pip install torchvision

from torchvision import models
from torch import nn
from torch import optim
 
resnet_model = models.resnet18(pretrained=True) 
# pretrained 設置為 True，會自動下載模型 所對應權重，并加載到模型中
# 也可以自己下載 權重，然后 load 到 模型中，源碼中有 權重的地址。
 
# 假設 我們的 分類任務只需要 分 100 類，那么我們應該做的是
# 1. 查看 resnet 的源碼
# 2. 看最后一層的 名字是啥 （在 resnet 里是 self.fc = nn.Linear(512 * block.expansion, num_classes)）
# 3. 在外面替換掉這個層
resnet_model.fc= nn.Linear(in_features=..., out_features=100)
 
# 這樣就 哦了，修改后的模型除了輸出層的參數(shù)是 隨機初始化的，其他層都是用預訓練的參數(shù)初始化的。
 
# 如果只想訓練 最后一層的話，應該做的是：
# 1. 將其它層的參數(shù) requires_grad 設置為 False
# 2. 構建一個 optimizer， optimizer 管理的參數(shù)只有最后一層的參數(shù)
# 3. 然后 backward， step 就可以了
 
# 這一步可以節(jié)省大量的時間，因為多數(shù)的參數(shù)不需要計算梯度
for para in list(resnet_model.parameters())[:-2]:
    para.requires_grad=False 
 
optimizer = optim.SGD(params=[resnet_model.fc.weight, resnet_model.fc.bias], lr=1e-3)
 
...

def __setattr__(self, name, value):
    def remove_from(*dicts):
        for d in dicts:
            if name in d:
                del d[name]

def weight_init(m):
# 使用isinstance來判斷m屬于什么類型
    if isinstance(m, nn.Conv2d):
        n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
        m.weight.data.normal_(0, math.sqrt(2. / n))
    elif isinstance(m, nn.BatchNorm2d):
# m中的weight，bias其實都是Variable，為了能學習參數(shù)以及后向傳播
        m.weight.data.fill_(1)
        m.bias.data.zero_()

model = torchvision.models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False
# 替換最后的全連接層， 改為訓練100類
# 新構造的模塊的參數(shù)默認requires_grad為True
model.fc = nn.Linear(512, 100)
 
# 只優(yōu)化最后的分類層
optimizer = optim.SGD(model.fc.parameters(), lr=1e-2, momentum=0.9)

ignored_params = list(map(id, model.fc.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params,
                     model.parameters())
 
optimizer = torch.optim.SGD([
            {'params': base_params},
            {'params': model.fc.parameters(), 'lr': 1e-3}
            ], lr=1e-2, momentum=0.9)

torch.save(the_model.state_dict(), PATH)

the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load(PATH))

torch.save(the_model, PATH)

the_model = torch.load(PATH)

model_dict = the_model.state_dict(),
for k,v in model_dict.items():
    print(k)

model_dict[k] = new_value

the_model.load_state_dict(model_dict)

model_dict = model.state_dict() 
pretrained_dict = torch.load(model_path)
 # 1. filter out unnecessary keys
diff = {k: v for k, v in model_dict.items() if \
            k in pretrained_dict and pretrained_dict[k].size() == v.size()}
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict and model_dict[k].size() == v.size()}
pretrained_dict.update(diff)
# 2. overwrite entries in the existing state dict
model_dict.update(pretrained_dict)
# 3. load the new state dict
model.load_state_dict(model_dict)

model_dict = model.state_dict() 
pretrained_dict = torch.load(model_path)
keys = []
for k,v in pretrained_dict.items():
    keys.append(k)
i = 0
for k,v in model_dict.items():
    if v.size() == pretrained_dict[keys[i]].size():
        print(k, ',', keys[i])
         model_dict[k]=pretrained_dict[keys[i]]
    i = i + 1
model.load_state_dict(model_dict)