微调的概念#

当我们在进行特定任务时，时常会出现训练数据不够的情况，若从头开始训练一个模型，往往效果较差。为了解决这个问题，我们可以找一个别人已经训练好的现成模型，换成自己的数据，调整一下参数，再训练一遍，这个操作就是微调（fine-tune）

为什么要微调#

对于数据集很小的情况，从头开始训练具有千万参数的大型神经网络是是不现实的。越大的模型对数据量的要求越大，且容易产生过拟合。这是如果我们仍然想使用大型神经网络来训练数据，就需要微调已经训练好的模型。
微调可以降低训练成本。如果使用导出特征向量的方法进行迁移学习，后期训练的成本很低，用CPU也可以快速训练。
前人已经训练好的模型一般会比自己搭建的模型好用，没必要重新搭建模型。

如何微调#

不同的领域微调的方法不一样，下面会介绍几个说法。

对于图片来说，我们CNN的前几层学习到的都是低级的特征，比如，点、线、面，这些低级的特征对于任何图片来说都是可以抽象出来的，所以我们将他作为通用数据，只微调这些低级特征组合起来的高级特征即可，例如，这些点、线、面，组成的是圆还是椭圆，还是正方形，这些代表的含义是我们需要后面训练出来的。

对于语音来说，每个单词表达的意思都是一样的，只不过发音或者是单词的拼写不一样，比如苹果，apple，apfel（德语），都表示的是同一个东西，只不过发音和单词不一样，但是他具体代表的含义是一样的，就是高级特征是相同的，所以我们只要微调低级的特征就可以了。

注意事项#

若新数据集和原始数据集类似，那么可以直接微调最有一个FC层或重新制定一个新的分类器。
若新数据集与原始数据集相差较大，可以从模型中部开始训练，微调最后几层。
若新数据集与原始数据集相差较大，且上面方法不可行，则可以将预训练模型作为新模型的初始化数据，重新训练模型。
新数据集需要与元数据集维度相同，比如CNN中输入的图片大小要相同，才不会导致报错。
对于不同的层可以设置不同的学习率，一般情况下学习率要设置得比使用原数据训练时的学习率小（一般小10倍），这样可以保证原模型不会扭曲过快。也可以使用原来的学习率，这样收敛较快。

微调实例#

使用官方训练好的resnet50来参加kaggle上面的 dog breed 狗的种类识别来做一个简单微调实例。

步骤如下：

获取狗的分类并根据分类进行编号
自定义DataSet，方便获取数据
设定一些超参
定义训练数据和验证数据的图像变换规则
生成数据集
使用官方的dataloader载入数据
开始配置网络
准备训练和测试函数
开始训练

1
import pandas as pd
2
import os
3
import time
4

5
import torch
6
from torch import nn
7
from torchvision import datasets, models, transforms
8
from PIL import Image
9
from torch.utils.data import Dataset, DataLoader
10
from sklearn.model_selection import StratifiedShuffleSplit
11

12
### 1、获取狗的分类并根据分类进行编号
13
DATA_ROOT = "data/dog_breed"
14
all_labels_df = pd.read_csv(os.path.join(DATA_ROOT, 'labels.csv'))
15
breeds = all_labels_df.breed.unique()
16

17
# 这里定义了两个字典，分别以种类名和id作为对应
18
breed2idx = dict((breed, idx) for idx, breed in enumerate(breeds))
19
idx2breed = dict((idx, breed) for idx, breed in enumerate(breeds))
20

21
# 将种类编号添加到列表中
22
all_labels_df['label_idx'] = [breed2idx[b] for b in all_labels_df.breed]
23

24
### 2、自定义DataSet，方便获取数据
25
class DogDataSet(Dataset):
26
    def __init__(self, labels_df, img_path, transform=None):
27
        self.labels_df = labels_df
28
        self.img_path = img_path
29
        self.transform = transform
30

31
    def __len__(self):
32
        return self.labels_df.shape[0]
33

34
    def __getitem__(self, idx):
35
        image_name = os.path.join(self.img_path, self.labels_df.id[idx]) + '.jpg'
36
        img = Image.open(image_name)
37
        label = self.labels_df.label_idx[idx]
38

39
        if self.transform:
40
            img = self.transform(img)
41

42
        return img, label
43

44
### 3、设定一些超参
45
hyps = {
46
    "IMG_SIZE": 224,  # resnet50的输入是224，所以需要将图片统一大小
47
    "BATCH_SIZE": 256,  # 这个批次大小需要占用4.6-5g的显存，如果不够的化可以改下批次，如果内存超过10G可以改为512
48
    "IMG_MEAN": [0.485, 0.456, 0.406],
49
    "IMG_STD": [0.229, 0.224, 0.225],
50
    "CUDA": torch.cuda.is_available(),
51
    "DEVICE": torch.device("cuda" if torch.cuda.is_available() else "cpu")
52
}
53

54
### 4、定义训练数据和验证数据的图像变换规则
55
train_transforms = transforms.Compose([
56
    transforms.Resize(hyps["IMG_SIZE"]),
57
    transforms.RandomResizedCrop(hyps["IMG_SIZE"]),
58
    transforms.RandomHorizontalFlip(),
59
    transforms.RandomRotation(30),
60
    transforms.ToTensor(),
61
    transforms.Normalize(hyps["IMG_MEAN"], hyps["IMG_STD"])
62
])
63

64
val_transforms = transforms.Compose([
65
    transforms.Resize(hyps["IMG_SIZE"]),
66
    transforms.CenterCrop(hyps["IMG_SIZE"]),
67
    transforms.ToTensor(),
68
    transforms.Normalize(hyps["IMG_MEAN"], hyps["IMG_STD"])
69
])
70

71
### 5、生成数据集
72
datasets_names = ["train", "valid"]
73
stratified_split = StratifiedShuffleSplit(n_splits=1, test_size=0.1, random_state=0)
74
train_split_idx, val_split_idx = next(iter(stratified_split.split(all_labels_df.id, all_labels_df.breed)))
75
train_df = all_labels_df.iloc[train_split_idx].reset_index()
76
val_df = all_labels_df.iloc[val_split_idx].reset_index()
77

78
# 为了更快看到结果，只使用100个数据
79
train_df = train_df[:90]
80
val_df = val_df[:10]
81

82
print("训练集数量：", len(train_df))
83
print("验证集数量：", len(val_df))
84

85
### 6、使用官方的dataloader载入数据
86
image_transforms = {
87
    "train": train_transforms,
88
    "valid": val_transforms
89
}
90

91
train_dataset = DogDataSet(
92
    train_df,
93
    os.path.join(DATA_ROOT, "train"),
94
    transform=image_transforms["train"]
95
)
96

97
val_dataset = DogDataSet(
98
    val_df,
99
    os.path.join(DATA_ROOT, "train"),
100
    transform=image_transforms["valid"]
101
)
102

103
image_dataset = {
104
    "train": train_dataset,
105
    "valid": val_dataset
106
}
107

108
image_loader = {
109
    x: DataLoader(
110
        image_dataset[x],
111
        batch_size=hyps["BATCH_SIZE"],
112
        shuffle=True,
113
        num_workers=0
114
    ) for x in datasets_names
115
}
116

117
dataset_sizes = {
118
    x: len(image_dataset[x]) for x in datasets_names
119
}
120

121
### 7、开始配置网络，由于ImageNet是识别1000个物体，我们的狗的分类是120个
122
### 因此需要对模型的最后一层进行微调，将输出从1000改成120
123

124
'''
125
下载官方的预训练模型，
126
并且将所有参数层进行冻结
127
'''
128
model_ft = models.resnet50(pretrained=True)
129
for param in model_ft.parameters():
130
    param.requires_grad = False
131

132
# 打印全连接层信息
133
print(model_ft.fc)
134
# 获取到fc层的输入
135
num_fc_ftr = model_ft.fc.in_features
136
# 定义一个新fc层
137
model_ft.fc = nn.Linear(num_fc_ftr, len(breeds))
138
# 放到设备中
139
model_ft = model_ft.to(hyps["DEVICE"])
140
# 打印新的模型的fc层
141
print(model_ft.fc)
142

143
### 8、准备训练和测试函数
144
# 设置训练参数
145
criterion = nn.CrossEntropyLoss()
146
optimizer = torch.optim.Adam([
147
    {"params": model_ft.fc.parameters()}
148
], lr=0.01)  # 给新的fc层指定学习率
149

150
# 定义训练函数
151
def train(model, device, train_loader, epoch):
152
    model.train()
153
    for batch_idx, data in enumerate(train_loader):
154
        x, y = data
155
        x = x.to(device)
156
        y = y.to(device)
157
        optimizer.zero_grad()
158
        y_hat = model(x)
159
        loss = criterion(y_hat, y)
160
        loss.backward()
161
        optimizer.step()
162
    print("Train Epoch:{}\t Loss:{:.6f}".format(epoch, loss.item()))
163

164
# 定义测试函数
165
def test(model, device, test_loader):
166
    model.eval()
167
    test_loss = 0
168
    correct = 0
169
    with torch.no_grad():
170
        for i, data in enumerate(test_loader):
171
            x, y = data
172
            x = x.to(device)
173
            y = y.to(device)
174
            y_hat = model(x)
175
            test_loss += criterion(y_hat, y).item()
176
            y_pred = y_hat.max(1, keepdim=True)[1]
177
            correct += y_pred.eq(y.view_as(y_pred)).sum().item()
178
    test_loss /= len(test_loader.dataset)
179
    print("Test set: Average loss: {:.4f}".format(test_loss))
180
    print("Accuracy: {}/{}({:.0f}%)".format(
181
        correct,
182
        len(test_loader.dataset),
183
        100 * correct / len(test_loader.dataset))
184
    )
185

186
### 9、开始训练
187
start_time = time.time()
188
for epoch in range(1, 10):
189
    train(model=model_ft, device=hyps["DEVICE"], train_loader=image_loader["train"], epoch=epoch)
190
    test(model=model_ft, device=hyps["DEVICE"], test_loader=image_loader["train"])
191
end_time = time.time()
192
print("训练和测试运行总时间：", end_time - start_time)

1
训练集数量： 90
2
验证集数量： 10
3
Linear(in_features=2048, out_features=1000, bias=True)
4
Linear(in_features=2048, out_features=120, bias=True)
5
Train Epoch:1   Loss:4.852541
6
Test set: Average loss: 0.0587
7
Accuracy: 8/90(9%)
8
Train Epoch:2   Loss:5.330395
9
Test set: Average loss: 0.0590
10
Accuracy: 14/90(16%)
11
Train Epoch:3   Loss:5.285418
12
Test set: Average loss: 0.0612
13
Accuracy: 24/90(27%)
14
Train Epoch:4   Loss:5.473721
15
Test set: Average loss: 0.0646
16
Accuracy: 25/90(28%)
17
Train Epoch:5   Loss:5.354596
18
Test set: Average loss: 0.0554
19
Accuracy: 31/90(34%)
20
Train Epoch:6   Loss:5.442605
21
Test set: Average loss: 0.0551
22
Accuracy: 30/90(33%)
23
Train Epoch:7   Loss:4.990680
24
Test set: Average loss: 0.0427
25
Accuracy: 50/90(56%)
26
Train Epoch:8   Loss:4.028876
27
Test set: Average loss: 0.0406
28
Accuracy: 52/90(58%)
29
Train Epoch:9   Loss:3.824669
30
Test set: Average loss: 0.0419
31
Accuracy: 48/90(53%)
32
训练和测试运行总时间： 157.51129245758057
33

34
进程已结束，退出代码为 0

注意：

为了能快速看到效果，我在这里只使用了90个数据，且使用了原数据进行测试。若想要使用全部数据，且用验证集测试模型，只需删除和修改相应代码即可。

固定层向量导出#

上面的方法有一个缺陷，除了最后修改的一层，前面每一层在同一样本的输出都是一样的，因此浪费了很多计算资源。因此我们可以将不进行反向传播或者不更新网络权重参数的计算结果保存下来，这样我们以后使用的时候就可以直接将结果输出到新的网络层，省去了大量的计算时间。且有时仅需要CPU就能快速完成训练。

下面是一个样例，使用了pytorch中的hook方法，将最后FC层的输入记录了下来，并直接用于前向传播和训练。

1
import pandas as pd
2
import os
3
import time
4

5
import torch
6
from torch import nn
7
from torchvision import datasets, models, transforms
8
from PIL import Image
9
from torch.utils.data import Dataset, DataLoader
10
from sklearn.model_selection import StratifiedShuffleSplit
11

12
### 1、获取狗的分类并根据分类进行编号
13
DATA_ROOT = "data/dog_breed"
14
all_labels_df = pd.read_csv(os.path.join(DATA_ROOT, 'labels.csv'))
15
breeds = all_labels_df.breed.unique()
16

17
# 这里定义了两个字典，分别以种类名和id作为对应
18
breed2idx = dict((breed, idx) for idx, breed in enumerate(breeds))
19
idx2breed = dict((idx, breed) for idx, breed in enumerate(breeds))
20

21
# 将种类编号添加到列表中
22
all_labels_df['label_idx'] = [breed2idx[b] for b in all_labels_df.breed]
23

24
### 2、自定义DataSet，方便获取数据
25
class DogDataSet(Dataset):
26
    def __init__(self, labels_df, img_path, transform=None):
27
        self.labels_df = labels_df
28
        self.img_path = img_path
29
        self.transform = transform
30

31
    def __len__(self):
32
        return self.labels_df.shape[0]
33

34
    def __getitem__(self, idx):
35
        image_name = os.path.join(self.img_path, self.labels_df.id[idx]) + '.jpg'
36
        img = Image.open(image_name)
37
        label = self.labels_df.label_idx[idx]
38

39
        if self.transform:
40
            img = self.transform(img)
41

42
        return img, label
43

44
### 3、设定一些超参
45
hyps = {
46
    "IMG_SIZE": 224,  # resnet50的输入是224，所以需要将图片统一大小
47
    "BATCH_SIZE": 256,  # 这个批次大小需要占用4.6-5g的显存，如果不够的化可以改下批次，如果内存超过10G可以改为512
48
    "IMG_MEAN": [0.485, 0.456, 0.406],
49
    "IMG_STD": [0.229, 0.224, 0.225],
50
    "CUDA": torch.cuda.is_available(),
51
    "DEVICE": torch.device("cuda" if torch.cuda.is_available() else "cpu")
52
}
53

54
### 4、定义训练数据和验证数据的图像变换规则
55
train_transforms = transforms.Compose([
56
    transforms.Resize(hyps["IMG_SIZE"]),
57
    transforms.RandomResizedCrop(hyps["IMG_SIZE"]),
58
    transforms.RandomHorizontalFlip(),
59
    transforms.RandomRotation(30),
60
    transforms.ToTensor(),
61
    transforms.Normalize(hyps["IMG_MEAN"], hyps["IMG_STD"])
62
])
63

64
val_transforms = transforms.Compose([
65
    transforms.Resize(hyps["IMG_SIZE"]),
66
    transforms.CenterCrop(hyps["IMG_SIZE"]),
67
    transforms.ToTensor(),
68
    transforms.Normalize(hyps["IMG_MEAN"], hyps["IMG_STD"])
69
])
70

71
### 4、生成数据集
72
datasets_names = ["train", "valid"]
73
stratified_split = StratifiedShuffleSplit(n_splits=1, test_size=0.1, random_state=0)
74
train_split_idx, val_split_idx = next(iter(stratified_split.split(all_labels_df.id, all_labels_df.breed)))
75
train_df = all_labels_df.iloc[train_split_idx].reset_index()
76
val_df = all_labels_df.iloc[val_split_idx].reset_index()
77

78
# 为了更快看到结果，只使用100个数据
79
train_df = train_df[:90]
80
val_df = val_df[:10]
81

82
print("训练集数量：", len(train_df))
83
print("验证集数量：", len(val_df))
84

85
### 5、使用官方的dataloader载入数据
86
image_transforms = {
87
    "train": train_transforms,
88
    "valid": val_transforms
89
}
90

91
train_dataset = DogDataSet(
92
    train_df,
93
    os.path.join(DATA_ROOT, "train"),
94
    transform=image_transforms["train"]
95
)
96

97
val_dataset = DogDataSet(
98
    val_df,
99
    os.path.join(DATA_ROOT, "train"),
100
    transform=image_transforms["valid"]
101
)
102

103
image_dataset = {
104
    "train": train_dataset,
105
    "valid": val_dataset
106
}
107

108
image_loader = {
109
    x: DataLoader(
110
        image_dataset[x],
111
        batch_size=hyps["BATCH_SIZE"],
112
        shuffle=True,
113
        num_workers=0
114
    ) for x in datasets_names
115
}
116

117
dataset_sizes = {
118
    x: len(image_dataset[x]) for x in datasets_names
119
}
120

121
### 6、开始配置网络，由于ImageNet是识别1000个物体，我们的狗的分类是120个
122
### 因此需要对模型的最后一层进行微调，将输出从1000改成120
123

124
'''
125
下载官方的预训练模型，
126
并且将所有参数层进行冻结
127
'''
128
model_ft = models.resnet50(pretrained=True)
129
for param in model_ft.parameters():
130
    param.requires_grad = False
131

132
# 打印全连接层信息
133
print(model_ft.fc)
134
# 获取到fc层的输入
135
num_fc_ftr = model_ft.fc.in_features
136
# 定义一个新fc层
137
model_ft.fc = nn.Linear(num_fc_ftr, len(breeds))
138
# 放到设备中
139
model_ft = model_ft.to(hyps["DEVICE"])
140
# 打印新的模型的fc层
141
print(model_ft.fc)
142

143
### 7、训练
144
# 设置训练参数
145
criterion = nn.CrossEntropyLoss()
146
optimizer = torch.optim.Adam([
147
    {"params": model_ft.fc.parameters()}
148
], lr=0.01)  # 给新的fc层指定学习率
149

150
# 定义训练函数
151
def train(y_hat, y, epoch):
152
    optimizer.zero_grad()
153
    loss = criterion(y_hat, y)
154
    loss.backward()
155
    optimizer.step()
156
    print("Train Epoch:{}\t Loss:{:.6f}".format(epoch, loss.item()))
157

158
# 定义测试函数
159
def test(y_hat, y, ):
160
    test_loss = 0
161
    correct = 0
162
    test_loss += criterion(y_hat, y).item()
163
    y_pred = y_hat.max(1, keepdim=True)[1]
164
    correct += y_pred.eq(y.view_as(y_pred)).sum().item()
165
    test_loss /= y.shape[0]
166
    print("Test set: Average loss: {:.4f}".format(test_loss))
167
    print("Accuracy: {}/{}({:.0f}%)".format(
168
        correct,
169
        y.shape[0],
170
        100 * correct / y.shape[0])
171
    )
172

173
# 存放所有的输出
174
in_list = []
175

176
def hook(module, input, output):
177
    # input 是一个tuple，代表每一个输入项
178
    # 这里我们只有一项，所以直接获取
179

180
    # 需要全部参数信息可以使用这个打印
181
    # for val in input:
182
    #     print("input val:", val)
183

184
    for i in range(input[0].size(0)):
185
        in_list.append(input[0][i].cpu().numpy())
186

187
# 在相应的层注册hook函数，保证函数能正常工作
188
model_ft.fc.register_forward_hook(hook)
189

190
# 保存fc层输入数据
191
in_list = []
192
with torch.no_grad():
193
    for batch_idx, data in enumerate(image_loader["train"]):
194
        x, y = data
195
        x = x.to(hyps["DEVICE"])
196
        y = y.to(hyps["DEVICE"])
197
        y_hat = model_ft(x)
198
avgpool_output = torch.tensor(in_list)
199

200
# 开始训练
201
start_time = time.time()
202
for epoch in range(1, 10):
203
    y_hat = model_ft.fc(avgpool_output)
204
    train(y_hat, y, epoch)
205
    test(y_hat, y)
206
end_time = time.time()
207
print("训练和测试运行总时间：", end_time - start_time)

1
训练集数量： 90
2
验证集数量： 10
3
Linear(in_features=2048, out_features=1000, bias=True)
4
Linear(in_features=2048, out_features=120, bias=True)
5
Train Epoch:1   Loss:4.901811
6
Test set: Average loss: 0.0545
7
Accuracy: 0/90(0%)
8
Train Epoch:2   Loss:3.896190
9
Test set: Average loss: 0.0433
10
Accuracy: 8/90(9%)
11
Train Epoch:3   Loss:3.244060
12
Test set: Average loss: 0.0360
13
Accuracy: 40/90(44%)
14
Train Epoch:4   Loss:2.896842
15
Test set: Average loss: 0.0322
16
Accuracy: 47/90(52%)
17
Train Epoch:5   Loss:2.154058
18
Test set: Average loss: 0.0239
19
Accuracy: 52/90(58%)
20
Train Epoch:6   Loss:1.155868
21
Test set: Average loss: 0.0128
22
Accuracy: 67/90(74%)
23
Train Epoch:7   Loss:0.720364
24
Test set: Average loss: 0.0080
25
Accuracy: 80/90(89%)
26
Train Epoch:8   Loss:0.768238
27
Test set: Average loss: 0.0085
28
Accuracy: 76/90(84%)
29
Train Epoch:9   Loss:0.770737
30
Test set: Average loss: 0.0086
31
Accuracy: 72/90(80%)
32
训练和测试运行总时间： 0.01994800567626953
33

34
进程已结束，退出代码为 0

结论#

微调是一个对算力低的个人或组织相当友好的技术，可以使用前人已经训练好的模型进行改进，无需重新训练整个模型。本篇文章的代码都是在同一台电脑上、使用CPU进行的，可以看出使用了固定层向量导出方法后，训练速度大幅度提升，可以用仅CPU快速完成训练。

原文链接：CSDN