Le modèle personnalisé (modifié) dans Pytorch charge la partie requise des paramètres du modèle de pré-formation et se fige

Une partie de cet article fait référence à https://zhuanlan.zhihu.com/p/34147880

1. Cette méthode est plus polyvalente, elle charge les paramètres du modèle de pré-apprentissage en fonction des paramètres de son propre modèle, et lui attribue le même nom. Si vous ajoutez des calques au modèle d'origine, il ne sera pas chargé

dict_trained=torch.load(self.args.load_path, map_location=torch.device('cpu'))
dict_new=model.state_dict()
# 1. filter out unnecessary keys
dict_trained = {
    
    k: v for k, v in dict_trained.items() if k in dict_new}
# 2. overwrite entries in the existing state dict
model_dict.update(dict_trained)
model.load_state_dict(dict_new)

2. C'est beaucoup plus compliqué, et vous pouvez le modifier selon vos propres besoins. Par exemple, dans le mien, ce modèle ajoute quatre couches de 'dense', 'unary_affine', 'binary_affine', 'classifier', pass j+ = 8, sautez Leur poids et leur biais, cela peut faire référence à une perte de poids. Dans le même temps, la partie 'crf' des paramètres du modèle d'origine ne sera pas chargée.

dict_trained = torch.load(self.args.load_path, map_location=torch.device('cpu'))
dict_new = self.model.state_dict().copy()
trained_list = list(dict_trained.keys())
new_list = list(dict_new.keys())
j = 0
no_loda = {'dense', 'unary_affine', 'binary_affine', 'classifier'}
for i in range(len(trained_list)):
     flag = False
     if 'crf' in trained_list[i]:
         continue
     for nd in no_loda:
         if nd in new_list[j] and 'bert' not in new_list[j]:
             flag = True
     if flag:
         j += 8  # no_loda的dense和bias掠过
     else:
         dict_new[new_list[j]] = dict_trained[trained_list[i]]
         if new_list[j] != trained_list[i]:
             print("i:{},new_state_dict: {}  trained state_dict: {}不一致".format(i, new_list[j], trained_list[i]))
     j += 1 #keys不对齐
model.load_state_dict(dict_new)

Plus tard, j'ai appris qu'il existe un moyen plus simple :

Autrement dit, après avoir configuré votre propre modèle, si vous souhaitez uniquement utiliser les paramètres de la même structure du modèle pré-formé, c'est-à-dire, définissez le paramètre strict sur False lors du chargement . La valeur de ce paramètre est True par défaut, ce qui signifie que la couche du modèle pré-entraîné est strictement égale à la couche de la structure de réseau définie par elle-même (telle que le nom et la dimension de la couche), sinon elle ne peut pas être chargée. la mise en œuvre est la suivante :

model.load_state_dict(torch.load(self.args.load_path, strict=False))

PS : Si vous rencontrez une erreur, vous pouvez imprimer les clés des paramètres du modèle que vous avez modifiés et les clés de chargement des paramètres du modèle pour y jeter un œil, et prescrire le bon médicament

3. Gelez ces couches de paramètres

Tout simplement

for k in model.paramers:
	k.requires_grad=False

Il existe de nombreuses méthodes, ici on utilise la méthode de congélation correspondant à la méthode ci-dessus

Il est recommandé de consulter
https://discuss.pytorch.org/t/how-the-pytorch-freeze-network-in-some-layers-only-the-rest-of-the-training/7088
ou
https://discuss .pytorch.org/t/correct-way-to-freeze-layers/26714
ou
de manière correspondante, pendant la formation, seul le paramètre qui requirements_grad = True peut être mis à jour dans l'optimiseur, donc

optimizer = torch.optim.Adam( filter(lambda p: p.requires_grad, net.parameters(),lr) )